\n<thead>\n<tr>\n<th>Symbols</th>\n<th>Composition Form</th>\n<th>Examples</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>",", and</td>\n<td><em>and</em> composition</td>\n<td>A and B and C</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>A, B, C</td>\n</tr>\n<tr>\n<td>"]", or</td>\n<td><em>or</em> composition</td>\n<td>A or B or C</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>A</td>\n</tr>\n<tr>\n<td>list of, "*", collection of</td>\n<td><em>repetitive</em> composition</td>\n<td>A*</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>list of A</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>collection of A</td>\n</tr>\n</tbody>\n</table>\n\nTable 3: Summary of Component Expression Symbols.\nobject Database is\n components: (Name and Addr and Age)*;\nend DB;\n\nA better alternative is:\n\nobject Database is\n components: Record*;\nend DB;\n\nobject Record is\n components: Name and Addr and Age;\nend Record;\n\nThe latter alternative is clearer, and promotes reuse of the object named Record.\n\nEach of the four composition primitives defines a particular structure. Used in combination, the composition primitives can define a wide variety of structures commonly used in specifications. The following subsections provide further details and examples on the use of the RSL composition forms.\n\n3.3.1. And Composition\n\nThe and composition operator defines a heterogeneous collection of objects. In mathematical terms, an and-structure is a tuple. In relation to a programming language, an and-structure is analogous to a record type. That is, the and operator defines an object with a fixed number of components, where the components may be any other type of object. For example, the following definition specifies an object with exactly three components:\n\nobject A is\n components: X and Y and Z;\nend A;\n\nThe components of an and-structure are never optional. That is, each component is always present.\n\n3.3.2. Or Composition\n\nThe or composition operator also defines a heterogeneous collection of objects. In mathematical terms, an or-structure is a tuple of boolean-tagged elements, where exactly one of the elements is tagged true, and all other pairs are tagged false. The true tag indicates which of the or-structure elements is present. In relation to a programming language, an or-structure is analogous to a union type or variant record.\n\nThe following definition specifies an object with one of three possible components:\n\nobject O is\n components: X or Y or Z;\nend O;\n\nIn contrast to an and-structure, only one of the components of an or-structure is present at one time.\n\n3.3.3. Repetitive Composition\n\nThe repetitive composition operator defines a homogeneous collection of zero or more objects. In mathematical terms, a repetitive structure is a ordered bag (a bag is a set with duplicate entries allowed). In relation to a programming language, a repetitive structure is analogous to a list or array. However, a repetitive structure differs significantly from an array in that a\nrepetitive structure is not of a fixed size.\n\nThe following definition specifies an object with zero or more components:\n\n```plaintext\nobject L is\n components: X*;\nend L;\n```\n\n3.3.4. Recursive Composition\n\nUnlike the preceding three composition forms, recursive composition has no explicit composition operator. A recursive definition results when an object is defined such that it contains itself as a component, or subcomponent. In mathematical terms, a recursive structure corresponds to a recursive mathematical definition. In relation to a programming language, a recursive structure corresponds to a recursive type definition, which is typically defined using a pointer. However, a recursive structure in RSL is not a pointer-based definition. RSL contains no pointers.\n\nThe following are examples of recursive definitions:\n\n```plaintext\nobject R is\n components: X and Y and R;\nend R;\n\nobject R1\n components: R2 and R3 and R4;\nend R1;\n\nobject R2 is\n components: R5 and R6;\nend R2;\n\nobject R5 is\n components: R7 and R1;\nend R5;\n```\n\nIn object R, the recursion is direct, since R is defined immediately as a component of itself. The object R1 is indirectly recursive -- R1 has a component R2, which in turn has a component R5, which in turn has a component R1.\n\n3.3.5. Common Uses of RSL Composition Forms\n\nThe PersonDatabase object in Section 3.1 is a good example of and-composition. An example of or-composition is\n\n```plaintext\nobject MaritalStatus is\n components: Married or Unmarried or Widowed or Divorced;\nend MaritalStatus;\n```\n\nIt is common in specifications to define an object that contains any of a number of subobjects, intermixed in any order. Consider the following example:\n\n```plaintext\nobject UnformattedDocument\n components: (RawText or FormattingCommand)*;\n description: (*\n An UnformattedDocument contains RawText strings and formatting commands intermixed in any order.\n *);\n```\nThe general composition form that specifies intermixed components is:\n\n\\[\n\\text{components: } (A \\text{ or } B \\text{ or } \\ldots )^*;\n\\]\n\nThis expression specifies a component structure that has an A or B or ..., any number of times, in any order. It should be noted that the following form does not specify intermixing:\n\n\\[\n\\text{components: } (A^* \\text{ and } B^* \\text{ and } \\ldots )\n\\]\n\nThis form specifies a component structure that has zero or more A's, followed by zero or more B's, followed by ... . That is, all of the A's, if any, come first, followed by all of the B's, etc. Keep in mind that and-composition specifies a tuple, where each component of the tuple must be present.\n\nThe following example illustrates a practical use of recursive composition:\n\n```plaintext\nobject DatabaseQuery is\n components: SimpleQuery | SimpleQuery, OrQueryOperator, DatabaseQuery\n description: (*\n A DatabaseQuery is an object that specifies how a database search can be conducted. For example, if a user wanted to find all the records in a database with a name of Smith and age of 25, or a name of Jones and age 35, the DatabaseQuery object would be\n Name=Smith and Age=25 or Name=Jones and Age=35\n *);\nend DatabaseQuery;\n\nobject SimpleQuery is\n components: FieldValueSpecifier | FieldValueSpecifier, AndQueryOperator, SimpleQuery\n description: (*\n A SimpleQuery is the component of a query that and's together two or more FieldValueSpecifiers, or is just a single FieldValueSpecifier.\n *)\nend SimpleQuery;\n\nobject FieldValueSpecifier is\n components: FieldKey, EqualsSign, FieldValue;\nend FieldValueSpecifier;\n\nobject FieldKey is\n components: NameKey | AgeKey | AddressKey;\nend FieldKey;\n\nobject NameKey = \"name\";\nobject AgeKey = \"age\";\nobject AddressKey = \"address\";\nobject EqualsSign = \";\nobject OrQueryOperator = \"or\";\nobject AndQueryOperator = \"and\";\n```\n\n### 3.3.6. Composition Expressions in Operations\n\nIn the current version of RSL, fully general composition expressions are only meaningful in object definitions. In operation definitions, only and-composition is meaningful. The use of or-composition in an operation definition is equivalent to and-composition and the use of list-\ncomposition is ignored. For example, in RSL Version 2, the following two operation definitions are equivalent:\n\n```plaintext\noperation 01 is\n components 02 or 03 or 04*;\nend 01\n\noperation 01 is\n components 02 and 03 and 04;\nend 01\n```\n\nIn a future version of RSL, general composition of operation components will be supported.\n\n### 3.4. Operation Typing and Functionality\n\nAs in a programming language, operation input/output lists define the formal parameter types that are accepted and produced by an operation. In contexts where operations are used with actual parameters, the same sort of type checking applies in RSL as in a programming language. Namely, the type of each actual parameter must agree with the type of the corresponding formal parameter.\n\nAs noted in the introduction, all the operations defined in a specification are side effect free. This means that an operation cannot use any object unless that object is an explicit input. Further, an operation may effect change only through an explicit output. In the nomenclature of programming languages, RSL is a fully functional language.\n\nThe notion that operations effect change rather than modify objects is also an important aspect of functional definition. An operation does not modify objects to produce output objects. Rather, a fully functional operation can only create new objects.\n\nConsider the AddRecord example defined above. When this operation executes, it accepts a database and record as inputs. What it outputs is a new copy of the input database, with a new copy of the input record added into the database. In programming language terms, functional specifications have no global variables, no global files, and no call-by-var parameters. In this sense, RSL functional definitions are similar to definitions in functional programming languages such as pure LISP and ML.\n\nThe fully functional specification of operations is sometimes counter-intuitive, particularly in the case of large objects in a transaction-oriented system. For example, one might consider the explicit input and output of a large database to be unnecessary and/or inefficient. It is necessary since in order to construct a result that contains a new record, the original database must be input. It cannot be assumed that the operation will read from some stored database file or other external storage structure.\n\nWith regards to implementation efficiency, this matter is strictly not of concern in an RSL specification. It is almost certainly not the case that a DBMS implementation would copy entire databases from input to output. However, such implementation concerns are beyond the scope of an RSL specification. The specification states in functional terms what an operation does, including all inputs and outputs that it uses. A subsequent implementation can use whatever efficient techniques are available, as long as the implementation meets the abstract specification.\n\n### 3.5. Names and Types\n\nIn the examples thus far, the components of an entity have been shown as simple names. Consider the PersonRecord example from above:\nobject PersonRecord is\n components: Name and Age and Address;\n description: (*\n A PersonRecord contains the information items for an\n individual in the PersonDatabase.\n */);\nend PersonRecord;\n\nHere Name, Age, and Address are the names of other defined objects. Consider the following alternate definition of PersonRecord:\n\nobject PersonRecord is\n components: n:Name and a:Age and ad:Address;\n description: (*\n A PersonRecord contains the information items for an\n individual in the PersonDatabase.\n */);\nend PersonRecord;\n\nHere the components are defined using name/type pairs. The component structure of PersonRecord is precisely the same in both of the above two definitions. The name component of the name/type pair is a local subobject name by which the component can be referenced. The names are n, a, and ad in this example. The type half of a name/type pair is the name of a defined object. The object types in this example are Name, Age, and Address.\n\nA components definition can be legally specified with or without name/type pairs. Name/type pairs are used when it is necessary to refer to a component in an RSL expression. Name/type pairs can also be used in class definitions, and other RSL contexts. Upcoming sections of the report discuss the uses of name/type pairs in further detail.\n\nIt is instructive to contrast the use of name/type pairs in RSL versus a programming language. Consider, for example, the equivalent of the last PersonRecord definition in a Pascal-like language:\n\ntype Name = string;\ntype Age = integer;\ntype Address = string;\ntype PersonRecord =\n record\n n: Name;\n a: Age;\n ad: Address;\n end;\n\nEach RSL object is defined as a type in the programming language. Except for notational differences, the RSL and programming language definition have the same meaning.\n\nA difference between RSL and a Pascal-like language is that component names are not required in RSL. Consider the following fictitious Pascal-like record definition, which is equivalent to the original RSL definition of PersonRecord, and which uses the equivalent of RSL opaque atomic types (defined in Section 3.6 below):\n\n type Name;\n type Age;\n type Address;\n type PersonRecord =\n record\n Name;\n Age;\n end;\nAddress;\nend;\n\nIn this example, the field names are omitted in the record definition. This is generally not allowed in a programming language, since it precludes runtime access to the record fields. However, such nameless fields are perfectly reasonable in RSL, since there is no \"runtime\" to worry about. That is, the structure of an RSL object need only declare what the components are, without necessarily providing a means to access the components. In this sense, an RSL definition can be more abstract than a corresponding programming language definition.\n\nThere are cases in which object component access is necessary in RSL, in which cases component names are necessary. These cases will be discussed in detail in upcoming examples.\n\n3.6. Composite versus Atomic Objects\n\nAny object defined with a non-empty components field is composite. An atomic object is one of the following:\n\n- an object defined as a built-in type,\n- an object with no components field, or\n- an object defined with \"components: empty\".\n\nThe built-in atomic types are number, integer, real, string, and boolean. The number atomic type is a synonym for real -- they both represent mathematical real numbers. The integer type is the normal subset of real. The string type represents symbolic values. The boolean type denotes a true/false value.\n\nThe general format for a composite object definition is the following:\n\n```plaintext\nobject name is\n components: ...;\n...\nend name\n```\n\nIn contrast, the general format for an atomic object definition is:\n\n```plaintext\nobject name is name\n ...\nend name\n```\n\nwhere the definition body (denoted by the ellipses) has no components. The name following the is must be a built-in atomic object name or the name of another atomic object. Note that the body in an atomic object definition is optional. Hence, an atomic definition may take a simple form, such as:\n\n```plaintext\nobject DataMaximum is number;\n```\n\nor a longer form, such as:\n\n```plaintext\nobject DataMaximum is number\n operations: . . . ;\n description: . . . ;\nend DataMaximum;\n```\n\nThe reader should note the distinction between the following two definitions, the first of which is composite and the second atomic:\n\n```plaintext\nobject C is\n components: integer;\n```\nC is a composite object containing a single integer component. In contrast, object A is an atomic integer object. While the definitional form of object C is not particularly useful, it is syntactically valid and must therefore be understood.\n\nA special form of atomic definition is an opaque object. The general form of opaque definition is either of the following:\n\n```\nobject name;\n\nobject name is\n components: ;\n\n... end name\n```\n\nAs in the preceding form of atomic definition, the body in an opaque definition is optional, so that any one of the following forms is legal:\n\n```\nobject ExternalItem;\nobject ExternalItem is\ndescription: ... ;\nend ExternalItem;\nobject ExternalItem is\n components: ;\ndescription: ... ;\nend ExternalItem;\n```\n\nIf the components keyword is given in an opaque definition, it must be followed by an empty components expression, or by one of the single keywords empty or none. empty and none are synonyms, both denoting an empty composition expression. The use of opaque definitions is discussed further in Section 3.8.\n\n### 3.7. Abstract versus Concrete Objects\n\nObject definitions that use the keyword is define a formal object type. Object definitions that use the symbol \"=\" in place of is define a concrete object value. A type represents an abstract set of many possible values, typically an infinite set. A value represents a single concrete object. For example, the standard type integer represents the infinite set of all possible integers. The value 10 represents the single integer value 10.\n\nAs a user-defined example, the following object definition represents the set of all possible values that have a number component and a string component:\n\n```\nobject NumberAndString is\n components: number and string;\nend NumberAndString;\n```\n\nIn contrast, the following definition defines a single value of this type:\n\n```\nobject TenAndXyz:NumberAndString = [10, \"xyz\"];\n```\n\nThere are two general formats for concrete value definition:\n\n```\nobject value-object-name = value-expression\n[...\nend name]\n```\nand\n\n\\[\n\\textbf{object} \\ \\text{value-object-name:} \\text{type-object-name} = \\text{value-expression} \\\\\n\\begin{array}{c}\n[... \\\\\n\\end{array} \\\\\n\\text{end name}\n\\]\n\nThe first of these two forms is used to define an object as a value of an atomic type, i.e., numeric, string, or boolean. The second form is used to define concrete values of composite types. In both forms, additional object attributes are optional.\n\nThe \\textit{value expression} to the right of the \"=\" denotes the concrete value. A numeric value is denoted by a real or integer numeric literal. A string is denoted by a double-quoted string literal. A boolean value is denoted by one of the standard identifiers \\texttt{true} or \\texttt{false}. A concrete composite value is constructed using square bracket operators \"[\" and \"]\". For example, the object value \\([1, 2, 3]\\) is a composite value consisting of the numbers 1, 2 and 3. Composite values can be nested to any depth.\n\nA composite value can represent either an \\textit{and'}d or \\textit{list-of} object as necessary. For example, the value \\([1, 2, 3]\\) is a concrete value for either of the following types of object:\n\n\\begin{verbatim}\nobject NumberList is \n components: number*; \nend NumberList;\n\nobject NumberTriple is \n components: number and number and number; \nend NumberTriple;\n\\end{verbatim}\n\n3.8. The Representational Base of Object Hierarchies\n\nIn order for an RSL definition to be complete, all referenced entities must be defined. In particular, there must be a definition for any object referenced by name in the components part of another definition or in the input/output lists of an operation. At some point, the hierarchy of object definitions must \"bottom out\" at atomic objects. Given the forms of atomic object discussed above, there are three levels of abstraction for defining the atomic basis of an object hierarchy:\n\n1. \\textit{opaque} objects\n2. atomic objects defined as one of the built-in atomic types\n3. atomic objects defined as a specific concrete value\n\nOf the three alternative levels, opaque definitions are the most abstract. An opaque definition signifies that the value set of an object is to be considered implementation-dependent, and that the abstract specification will not specify it concretely. Defining an object as a built-in type is intermediate in abstraction. This form of definition is more concrete than an opaque definition, but less concrete than specifying an object as a specific concrete value. Defining as concrete values is the most concrete basis for a requirements specification.\n\nAs an example, recall the DatabaseQuery definition from above. In that example, the atomic objects NameKey, AgeKey, etc. were defined as concrete atomic values. They could alternatively have been defined as opaque objects using the following definitions, in place of the definitions given originally in the example:\n\n\\begin{verbatim}\nobject NameKey;\nobject AgeKey;\nobject AddressKey;\n\\end{verbatim}\nobject EqualsSign;\nobject OrQueryOperator;\nobject AndQueryOperator;\n\nThe third alternative for these atomic objects is the following set of definitions:\n\nobject NameKey is string;\nobject AgeKey is string;\nobject AddressKey is string;\nobject EqualsSign is string;\nobject OrQueryOperator is string;\nobject AndQueryOperator is string;\n\nAny of the three levels of atomic specification is legal in RSL. Which is chosen depends on the degree of abstraction desired.\n\n3.9. Default Operation Parameters\n\nWhen concrete objects are defined in a specification, it can be useful to specify operations that accept these objects as inputs and/or produce them as outputs. Consider the following addition to the PersonDatabase example presented earlier:\n\nobject DefaultName = \"Name Unknown\";\nobject DefaultAge = -1;\nobject DefaultAddress = \"Address Unknown\";\nobject DefaultPersonRecord = [DefaultName, DefaultAge, DefaultAddress];\n\noperation AddRecord is\n inputs: PersonDatabase, PersonRecord:=DefaultPersonRecord;\n outputs: PersonDatabase;\n description: (*\n Add a new record into a person database.\n *)\nend AddRecord;\n\nHere, concrete objects have been defined as defaults for the components of a default PersonRecord. The AddRecord operation has then been modified to specify a default value for the PersonRecord input.\n\nThe general format for defining default operation parameters is the following:\n\noperation name is\n inputs: type-name:=value-name, ...;\n outputs: type-name:=value-name, ...;\nend name;\n\nwhere type-name denotes an abstract object and value-name denotes a concrete object.\n\nA default value in a parameter list specifies what the standard parameter value should be, if no other value is given when an operation is invoked. Using parameter defaults, a specifier can define specific concrete values that constitute the standard required data for a system. When the system is implemented, these standard data will be those installed for initial system operation. In the absence of other user input that changes these values, the defaults will remain in use.\n\n4. Classes\n\nAn object or operation definition may be specified as a class. A class definition is a general template for an object or operation, of which more specific instances can be declared. The following example shows a redefinition of the PersonRecord object defined earlier, this time as a\nclass:\n\n object class PersonRecord\n components: Name and Age and Address;\n description: (*\n The PersonRecord class contains components that are common\nto all personnel in the database.\n *);\n end PersonRecord;\n\nThis example specifies that all records in the database will contain the common components of Name, Age, and Address. The PersonRecord class can then be specialized as follows:\n\n object StaffEmployee instance of PersonRecord\n components: HourlyWage and EmploymentStatus;\n operations: ;\n description: (*\n A StaffEmployee is distinguished by HourlyWage and\n EmploymentStatus components.\n *);\n end StaffEmployee;\n\n object Programmer is\n components: Salary and Step;\n operations: ;\n description: (*\n A Programmer is distinguished by Salary and Step\n components.\n *);\n end Programmer;\n\n object Manager instance of PersonRecord\n components: Salary and Step and Supervisees;\n description: (*\n A Manager is distinguished by Salary, Step, and Supervisees\n components.\n *);\n end Manager;\n\n object Supervisees is\n components: (StaffEmployee or Programmer)*;\n description: (*\n This is the list of people that a manager supervises.\n *);\n end Supervisees;\n\nEach instance of PersonRecord is said to inherit the generic class components. That is, StaffEmployee, Programmer, and Manager all inherit the Name, Age, and Address components from the PersonRecord class. In addition, each of the instances further specializes itself by adding further fields. For example, a StaffEmployee is specialized by HourlyWage and EmploymentStatus components.\n\nThe purpose of a class is to define components that are common to a number of entities. The class contains the common components, and each instance automatically inherits these components, in addition to adding zero or more specializing components.\n\nClasses may be defined in any number of levels. Consider the following refinement of the preceding example:\nobject class PersonRecord is\n components: Name and Age and Address;\n description: (*\n The PersonRecord class contains components that are common\nto all personnel in the database.\n *); end PersonRecord;\n\nobject StaffEmployee instance of PersonRecord is\n components: HourlyWage and EmploymentStatus;\n operations: ;\n description: (*\n A StaffEmployee is distinguished by HourlyWage and\n EmploymentStatus components.\n *); end StaffEmployee;\n\nobject class SalariedEmployee instance of PersonRecord is\n components: Salary and Step;\nend SalariedEmployee;\n\nobject Programmer instance of SalariedEmployee is\n description: (*\n A Programmer is now just an instance of SalariedEmployee,\n from which it inherits components Salary and Step components.\n *); end Programmer;\n\nobject Manager instance of SalariedEmployee is\n components: Supervisees;\n description: (*\n A Manager inherits Salary and Step components. It\n specializes with Supervisees.\n *); end Manager;\n\nobject Supervisees is\n components: (StaffEmployee or SalariedEmployee)*;\n description: (*\n This is the list of people that a manager supervises.\n *); end Supervisees;\n\nHere there are three levels of class definition. A class object that is itself an instance is called a subclass. In this case, SalariedEmployee is a subclass. It inherits components from PersonRecord and in turn defines components that will be shared by its instances. Note that inheritance is fully transitive. That is, instances inherit all components from all levels of parent class above them. In this example, the instance object Programmer inherits all components from the two levels of parent class above it. Namely, it inherits Name, Age, Address, Salary, and Step. Note further that an instance need not provide any specializing components if it inherits all that it needs from its parent class(es). The Programmer object is such a case.\n\nUsing name/type pairs in a class definition can enhance the expressibility of the class hierarchy. Suppose it is the case that all employees have an office, but the specific type of office is defined differently for individual instances. The following example expresses this idea:\nobject class PersonRecord is\n components: Name and Age and Address and Office: ;\n description: (*\n The PersonRecord class contains components that are common\n to all personnel in the database.\n *);\nend PersonRecord;\n\nobject StaffEmployee instance of PersonRecord is\n components: HourlyWage and EmploymentStatus and Office:none;\n operations: ;\n description: (*\n A StaffEmployee is distinguished by HourlyWage and\n EmploymentStatus components.\n *);\nend StaffEmployee;\n\nobject class SalariedEmployee instance of PersonRecord is\n components: Salary and Step;\nend SalariedEmployee;\n\nobject Programmer instance of SalariedEmployee is\n components: Office: SharedOffice;\n description: (*\n A Programmer is now just an instance of SalariedEmployee,\n from which in inherits Salary and Step components.\n *);\nend Programmer;\n\nobject Manager instance of SalariedEmployee is\n components: Supervisees;\n description: (*\n A Manager inherits Supervisees\n components.\n *);\nend Manager;\n\nobject SharedOffice is\n components: OfficeNumber and Desk*;\nend SharedOffice;\n\nobject PrivateOffice is\n components: OfficeNumber and Desk and Window;\nend PrivateOffice;\n\nHere the \"Office: \" component of PersonRecord is only the name half of a name/type pair. Syntax-tactically, it is a name followed by a colon, with no object name following the colon. This means that an instance must specify the type half of this pair to complete the definition. This form of component in a class definition is called a specialization-required component.\n\nIn the above example, the StaffEmployee object is specialized with \"Office: none\". Note that since specialization is required for the Office, a complete definition must define the type for Office:; even if that type is \"none\". That is, simply leaving the Office: component out of the StaffEmployee definition would result in an incomplete specification.\n\nThe definition of SalariedEmployee does not specify a type for \"Office: \", but this is acceptable since it is a class, and its instances can provide the required specialization. Hence, the\nProgrammer components specify \"Office: SharedOffice\" and the Manager components specify \"Office: PrivateOffice\".\n\n4.1. Multiple Inheritance\n\nIt is sometimes useful to have a single instance that inherits attributes from more than one parent. For example,\n\n```\nobject MemberOfTechnicalStaff instance of Manager and Programmer is\n components: TechnicalSpeciality;\n description: (*\n A member of the technical staff is both a manager and a programmer.\n *);\nend MemberOfTechnicalStaff;\n```\n\nThe rule for multiple inheritance is that the instance inherits the union of the parent attributes. In particular, if the parents have one or more common attributes, then the instance has only a single version of the common attributes.\n\n4.2. Restrictions on Inheritance and Specialization\n\nInstances inherit components from a parent class, and can add new components to those that are inherited. Instances cannot however uninherit or override a component that is specified in the parent. Uninhibit would mean that an instance could eliminate one or more parent components. Override would mean that if a parent component were specified with both a name and an type, that the type could be changed in the instance. Not all class-based languages have this additivity restriction, but RSL does.\n\n4.3. Class Objects as Types\n\nIt was noted earlier that an abstract object formally definition defines a type, in the same sense as in strongly-typed programming languages. Using the class/subclass hierarchy allows the definition of subtypes. Specifically, an instance of an object class is considered a subtype of its parent class.\n\nThe major effect of subtyping in RSL relates to the use of class and instance objects in operation parameters. The typing rule for operation parameters is the following:\n\n_A formal parameter of a class type may accept an actual parameter of that type, as well as any instance type(s) of which the formal type is an parent._\n\nConsider the following example:\n\n```\nobject class Parent is ... ;\nobject class Child instance of Parent is ... ;\nobject class GrandChild instance of Child is ... ;\n\noperation O is\n inputs: p:Parent, g:GrandChild;\n outputs: c:Child\n```\n\nHere Child is a subtype of Parent; GrandChild is a subtype of Child and in turn a subtype of Parent. Hence, by the typing rule above, the formal input parameter _p_ can match an actual parameter of any type in the class hierarchy. I.e., an actual parameter of type Parent, Child, or GrandChild can be supplied to the input _p_. In contrast, only an actual parameter of type GrandChild can be supplied to the formal input _g_. The output parameter _c_ produces a value of\ntype Child or GrandChild, but not Parent.\n\nNotice that subtyping of formal parameters is one-directional. That is, a formal parameter of a class type may accept actuals of itself or any instance type. However, a formal parameter of an instance type may not accept parameters of a parent type. This is the same general rule as in typed object-oriented programming languages, such as C++ [Stroustrup 91].\n\n5. Modules\n\nEntity definitions are packaged within modules. The syntax and semantics of RSL modules are similar to that of the Modula-2 programming language [Wirth 85]. The basic format of an RSL module is the following:\n\n```\nmodule name ;\n [imports]\n [exports]\n [attributeDefinitions ... ;]\n [entityDefinition; | formalDefinition; ] ...\nend name\n```\n\nModule imports and exports optionally define inter-module name visibility. Attribute-definitions specify user-defined attributes, as described in Section 6 below. If any attribute definitions are present, they must appear before entity definitions. Entity-definitions are objects and operations, as described in the preceding section. Formal-definitions are discussed in Sections 7 and 8 below.\n\nIn terms of packaging, a module defines a name scope within which all defined entities are visible. Any definition within a given module may reference any other entity defined within the same module. Unlike many programming languages, an entity definition does not need to lexically precede its reference(s) within a module.\n\nNormally, entities defined in two different modules are mutually invisible. For example if object A is defined in module M1 and operation B is defined in module M2, the definition of B cannot reference A as an input or output. The use of import and export declarations extends the visibility of names between modules. The general format of an import declaration is the following:\n\n```\nfrom module-name import [qualified] entity-name,...\n```\n\nand the format of export is:\n\n```\nexport entity-name,...\n```\n\nConsider the following example:\n\n```\nmodule A;\n export O1;\n object O1 is ... ;\n object O2 is ... ;\nend A;\n\nmodule B;\nfrom A import O1;\noperation Op1 is\n inputs: O1, ... ;\nend Op1\noperation Op2 is\n```\n\n(* Legal reference to O1 *)\nThe import declaration in B makes object O1 visible within B. Hence, the reference to O1 in Op1 is fine. Since object O2 is not explicitly imported into B, the reference to O2 in Op2 is illegal.\n\nIt should be noted that imports must be matched by corresponding exports. That is, a name cannot be import into one module without having been export from another. Conversely, if a module exports one or more entities, each of these entities must be referenced by at least one import.\n\nThe use of import/export can lead to name conflicts if a module both imports and defines an entity of the same name. For example:\n\n```plaintext\nmodule A;\n export O1;\n object O1 is ... ;\nend A;\n\nmodule B from A import O1;\n object O1 is ... ; (* Name conflict *)\n operation Op is\n inputs: O1; (* Ambiguous reference *)\nend B;\n```\n\nHere module B both imports and defines O1. To overcome such name conflicts, names can be import in **qualified** form, and referenced by prefixing with the name of the defining module. The following is a version of the immediately preceding example with the name conflict removed:\n\n```plaintext\nmodule A;\n export O1;\n object O1 is ... ;\nend A;\n\nmodule B from A import qualified O1;\n object O1 is ... ; (* No conflict *)\n operation Op is\n inputs: O1; (* Legal reference to B’s O1 *)\n outputs: A.O1; (* Legal reference to A’s O1 *)\nend B;\n```\n\nNote the use of the keyword **qualified** in the import clause. Here, reference to the imported version of O1 is denoted by the qualified reference \"A.O1\" within B. The unqualified reference to O1 refers to the O1 defined within B. Hence, there is no name conflict in this case, since both versions of O1 can be referenced unambiguously.\n\n6. **User-Defined Attributes**\n\nIn the most general sense, the format of an entity definition is the following:\n\n```\n[object | operation] name is\n attribute-name : attribute-value\n...\nend name\n```\n\nIn the examples thus far, built-in attributes have been discussed. For an object, the built-in attributes are: components, operations, equations, and description. For an operation, built-in attributes are components, inputs, outputs, preconditions, postconditions, and description.\nA user-defined attribute specifies additional relational or descriptive information about an object or operation. Consider the following example:\n\n```plaintext\nmodule M;\n define object attribute scheduled_by, coordinated_by, special_note;\n object Meeting is\n components: StartTime, EndTime, Attendees, ... ;\n scheduled_by: StaffPerson;\n coordinated_by: Manager;\n description: (* A meeting represents ... *);\n special_note: (* Ask our system analyst if this is correct *);\n end Meeting;\n object StaffPerson is ... ;\n object Manager is ... ;\nend M\n```\n\nThis example illustrates how attributes are defined and used. Before use, an attribute must be defined in a `define` clause of the following general form:\n\n```plaintext\ndefine [object | operation] attribute attr-name, ...\n```\n\nSuch a definition allows the listed `attr-names` to appear within entity definitions. In the example above, scheduled_by, coordinated_by, and special_note are defined object attributes. Note that object and operation attributes are separately declared, so if the same attribute is desired for both objects and operations, two separate `define` declarations must be given.\n\nOnce defined, an attribute can be put to two uses: (1) to define formal relations between entities -- a relational attribute; (2) to augment an entity definition with special-purpose comments -- a commentary attribute. These two uses are specified by the following two syntactic forms, respectively:\n\n```plaintext\nattr-name : entity-name, ...\nattr-name : RSL comment\n```\n\nIn the Meeting example above, scheduled_by and coordinated_by are relational attributes; special_note is commentary.\n\nA relation between entities specifies a non-hierarchical connection. To understand such connections, it is instructive to compare relational attributes to the built-in RSL component relation. Consider the following alternative to the Meeting specification above, where no relational attributes are used:\n\n```plaintext\nmodule M\n object Meeting is\n components: StartTime, EndTime, Attendees,\n scheduled_by: StaffPerson, coordinated_by: Manager;\n end Meeting;\n object StaffPerson is ... ;\n object Manager is ... ;\nend M\n```\n\nHere, what were formerly specified as relations are now `components` of the meeting. The relational versus hierarchical specifications define different conceptual views. In the relational specification, the scheduled_by and coordinated_by objects are not part of the Meeting as in the hierarchical definition. While the difference is subtle, it can be important in terms of\nconstructing an accurate view a system being specified.\n\nThe distinction between relational versus hierarchical specifications can be further clarified by considering bi-directional relations. Here is a further refinement of the Meeting example:\n\n```plaintext\nmodule M;\n define object attribute scheduled_by, coordinated_by, special_note;\n define object attribute scheduler_of, coordinator_of;\n\n object Meeting is\n components: StartTime, EndTime, Attendees, ... ;\n scheduled_by: StaffPerson;\n coordinated_by: Manager;\n description: (* A meeting represents ... *);\n special_note: (* Ask our system analyst if this is correct *);\n end Meeting;\n\n object StaffPerson is ...\n scheduler_of: Meeting\n end StaffPerson;\n\n object Manager is ...\n coordinator_of: Meeting\n end Manager;\nend M\n```\n\nHere a bi-directional scheduling relation has been established between Meeting and StaffPerson. A similar bi-directional coordinating relation has been specified between Meeting and Manager. Such relations would be more awkward to specify using hierarchical components, and the hierarchy would be inappropriate in the sense that none of the objects participating in the relations is conceptually part of the others.\n\nCommentary attributes are particularly useful to describe meta-properties of a requirements specification. The intention of the special_note attribute above is to supply a temporary annotation for use during the development of the specification. While it is possible to use the built-in description field for such commentary, it is clearly more awkward to do so, as the following version of Meeting illustrates:\n\n```plaintext\nmodule M;\n define object attribute scheduled_by, coordinated_by;\n\n object Meeting is\n components: StartTime, EndTime, Attendees, ... ;\n scheduled_by: StaffPerson;\n coordinated_by: Manager;\n description: (* A meeting represents ...\n SPECIAL_NOTE: Ask our system analyst if this is correct *);\n end Meeting;\n\n object StaffPerson is ...\n object Manager is ...\nend M\n```\n\nIt should be noted that there is a fully functional notation that can be substituted for the use of relational attributes. In this sense, relational attributes can be viewed as \"syntactic sugar\" for an equivalent functional definition. Details of the equivalence are discussed in Appendix C. Relational attributes are provided in RSL for specifiers who find relational notation conceptually\nconvenient. Those users who would prefer to use a fully functional notation, while retaining the expression power of relations, should consult Appendix C.\n\n7. Formal Specifications\n\nRSL object and operation definitions can be augmented with formal mathematical specifications. These formal specifications are in three forms: equational, predicative, and axiomatic. Equational specifications are defined by associating a set of equations with an object. Predicative specifications are defined by associating preconditions and postconditions with an operation. Axiomatic specifications are defined by associating a set of global conditions with all of the objects and operations within a module.\n\nThe predominant form of logical expression used in a formal specification is the predicate. Semantically, a predicate is a mathematical formula with a boolean (i.e., true/false) value. A predicate is fundamentally the same form of boolean expression as found in programming languages. However, predicates in RSL can contain quantifiers and set operator that are typically unavailable in programming languages. In addition to boolean-valued expressions, RSL provides numeric, string, and set-valued expressions.\n\nThis section of the report is a terse syntactic description of the elements of a formal specification. Section 8 to follow contains a tutorial discussion of formal specification, with examples.\n\n7.1. Variable names\n\nThe base elements in an expression are variable names. Variables are declared in name/type pairs that appear in component expressions, input/output lists, and other contexts. Syntactically, a variable name is an identifier.\n\nThe reader should note the distinction between a variable name, used in an expression, versus an object name. An object name is defined using a complete object definition. That is, object names are those and only those names defined in definitions starting \"object object-name ... ;\". In contrast, a variable name is defined only in the context of a name/type pair. Variable names are those and only those names defined as variable-name:object-name. Such name/type pairs appear in one of four syntactic contexts:\n\n1. composition expressions appearing in the components part of an object definition\n2. input/output lists in an operation definition\n3. equation variable definitions\n4. forall and exists clauses\n\nThe first two of these contexts were described in a preceding section of the report. The last two contexts are described shortly.\n\n7.2. Functional, Arithmetic, and Boolean Expressions\n\nA functional expression is the invocation of an operation or auxiliary function (auxiliary functions are defined below). The general form of a functional expression is:\n\n\\[ \\text{name(args,...)} \\]\n\nwhere name is the name of a defined operation or auxiliary function and args are input arguments. Any defined operation or auxiliary function can be used in a functional expression. The argument types of functional expressions are type checked in the same manner that function\ncalls are type checked in a programming language. That is, the number and type of arguments must agree with the input/output declarations in the named operation.\n\nThe standard boolean operators **and**, **or**, and **not** are used in predicates. Note that **and** and **or** have overloaded meanings in RSL. In the context of a composition expression, **and** and **or** denote composition primitives. In the context of a predicate, **and** and **or** denote boolean operators.\n\nPredicates can contain the relational operators **=**, **\"=\" (not equal)**, **<**, **>**, **<=**, and **>=**. These are defined between expressions of the same type.\n\nPredicate terms can include standard arithmetic operations on real numbers (including integers). The operators are **+**, **-**, ***, **/**, **div**, and **mod**. Note that since a predicate must have a boolean value, arithmetic expressions can only be used in predicates in the context of other logical operations, such as comparisons. For example, \"a+b\" is a legal expression but not a legal predicate. \"(a+b) > 10\" is a legal predicate.\n\n7.3. Set Operations\n\nSet operations available for use in predicates are: **+** (union), **/** (intersect), **-** (difference), **#** (cardinality), and **in** (element of). Set operations can be used on variables denoting a list-composed object.\n\n7.4. Composite Object Selector Operations\n\nWhen an object is declared with multiple **anded** subcomponents, there is a built-in **and** selector operation for each such component, as the following general definition illustrates:\n\n```plaintext\nobject Foo is\n components: Fool and Foo2 and ... and Foon;\n\n (*Built-in operations:*)\n SelectFool: (Foo) -> (Fool);\n SelectFoo2: (Foo) -> (Foo2);\n ...\n SelectFoon: (Foo) -> (Foon);\nend Foo;\n```\n\nAn alternate, \"syntactically sugared\" notation for **and-selector** operations is the infix \".\" operator. Using infix \".\", the following two terms are the same:\n\n```plaintext\nSelectFool(foo) is equivalent to foo.Fool\n```\n\nNote that the \".\" operation is analogous to the use of \".\" in a programming language. Namely, \".\" selects an and-component in the same manner that \".\" selects a record field in a programming language.\n\nWhen an object is declared with multiple **or'd** subcomponents, there exist two **or-selector** operations for each such component, as the following general definition illustrates:\n\n```plaintext\nobject Foo\n components: Pool or Foo2 or ... or Foon\n\n (* assumable operations: *)\n IsPool: (Foo) -> (bool);\n IsFoo2: (Foo) -> (bool);\n ...\n IsFoon: (Foo) -> (bool);\n SelectPool: (Foo) -> (Pool);\n```\n```cpp\nSelectFoo2: (Foo) -> (Foo2);\n\nSelectFoon: (Foo) -> (Foon);\nend Foo;\n```\n\nThe operations prefixed with \"Is\" are used to determine which alternative a subobject is. The operations prefixed with \"Select\" are used in the same fashion as the selectors for an and-composed object.\n\nAn alternate, \"syntactically sugared\" notation for or-selector operations is the infix \"?\" operator. Using infix \"?\", the following two terms are the same:\n\n```\nIsFool(Foo) is equivalent to Foo?Fool\n```\n\nA common use for the or-selector is in objects with an error alternative. Consider the following example:\n\n```cpp\nobject ValueOrError is\n components: Value or Error;\nend ValueOrError;\n```\n\nfor which ValueOrError?Value is true if the subcomponent of foo is Value, or ValueOrError?Error is true if the subcomponent is an Error subobject. The \"?\" operator allows or’d components to be \"safely\" accessed. That is, before accessing an or component via \".\", it should be checked with \"?\".\n\nWhen an object is declared with a list of subcomponents, there is a built-in list selector operation for an individual subcomponent and a sublist operation that selects a range of subcomponents. The following general definition illustrates these list selectors:\n\n```cpp\nobject foo is\n components: Fool*;\n(*Built-in operations:*)\n SelectNthFool: (Foo, number) -> (Fool);\n SelectMthruNthFoo: (Foo, number, number) -> (Foo);\n```\n\nAn alternate, \"syntactically sugared\" notation for list-selector uses \"[\" and \"]\" brackets. Using brackets, the following two terms are the same:\n\n```\nSelectNthFool(foo, n) is equivalent to foo[n] as are the following two:\nSelectMthruNthFoo(foo, m, n) is equivalent to foo[m:n]\n```\n\nNote that the \"[...]\" operation is analogous to the use of \"[...]\" in a programming language. Namely, \"O[n]\" selects the nth component of a list-composed object in the same way that \"A[n]\" selects the nth component of an array in a programming language.\n\nIn relation to other predicate operators, \".\", \"?\", and \"[...]\" have the highest precedence.\n\n7.5. Logical Implication and Quantifiers\n\nLogical implication operations are if-then-else, \";=>\" (implies), and \"<=\" (iff). Note that this if-then-else is a boolean operator, not a control construct as in a programming language. In the expression\n\n```\nif T then P1 else P2\n```\n\nT is a predicate, P1 and P2 are each expressions, and the value of the expression is P1 if T is true, or P2 if T is false.\nUniversal and existential quantifiers can appear in predicates. In normal mathematical notation, universal quantification is represented by an upside down \"A\" and existential quantification by a backwards \"E\". In RSL, the quantifier operators are \\texttt{forall} and \\texttt{exists}. The general form of universal quantification is\n\n\\begin{verbatim}\nforall (x:t) predicate\n\\end{verbatim}\n\nread as \"for all values \\textit{x} of type \\textit{t}, \\textit{predicate} is true\" where \\textit{x} must appear somewhere in \\textit{predicate}. The general form of existential quantification in RSL is\n\n\\begin{verbatim}\nexists (x:t) predicate\n\\end{verbatim}\n\nread as \"there exists an \\textit{x} of type \\textit{t} such that \\textit{predicate} is true\", where \\textit{x} must appear somewhere in \\textit{predicate}.\n\nIn standard mathematical logic, universal quantification typically takes one of the following two syntactic forms:\n\n1. \\texttt{forall (x such that p1(x)): p2(x)}\n2. \\texttt{forall (x \\in S): p(x)}\n\nThe reading of form (1) is \"for all values \\textit{x} such that predicate \\textit{p1(x)} is true, \\textit{p2(x)} is also true\". The reading of form (2) is \"for all elements \\textit{x} in set \\textit{S}, predicate \\textit{p(x)} is true\".\n\nIn RSL, the \\texttt{forall} operator quantifies over all values of a particular object type. In comparison to forms (1) and (2) above, the general form of universal quantification in RSL is\n\n\\begin{verbatim}\nforall (x: O) p(x)\n\\end{verbatim}\n\nThe reading of this RSL form of quantification is \"for all values \\textit{x} of object type \\textit{O}, predicate \\textit{p(x)} is true\". The reason that RSL quantifies over object types is that RSL is based on \\textit{typed logic}. This means that all variables that appear in RSL predicates must be of some object type. In many mathematical treatments of quantification, the issue of strong value typing may not arise, and hence the notion of quantifying over types does not arise.\n\nThe fact that RSL is based on typed logic does not restrict how universal quantification can be used, it just means that the use of universal quantification in RSL must take typing into account. Therefore, the specific format of quantification is slightly different than in untyped logics.\n\nBoth quantification form (1) and form (2) above can be easily represented in RSL. The RSL for form (1) is:\n\n\\begin{verbatim}\nforall (x:SomeObject) if p1(x) then p2(x)\n\\end{verbatim}\n\nwhere the predicates operations \\texttt{p1} and \\texttt{p2} take \\texttt{SomeObject} as input and output boolean. The RSL notation for quantification form (2) is:\n\n\\begin{verbatim}\nforall (x:Elem) if x in S then p(x)\n\\end{verbatim}\n\nwhere object \\texttt{S} must be composed of \\texttt{Elem*}.\n\nSection 8 below contains examples on the use of universal and existential quantification in RSL.\n\n\\section*{7.6. Pre/Postconditions, Equations, and Axioms}\n\nPreconditions and postconditions are associated with an operation by including precondition and/or postcondition declarations within the operation definition. The syntactic forms are:\n\n\\begin{verbatim}\nprecondition: predicate ;\npostcondition: predicate ;\n\\end{verbatim}\nwhere *predicate* is a legal RSL predicate expression. Typically, conditions are made up of a number of predicates, composed with boolean \"and's\" and \"or's\". Section 8 has a number of examples that illustrate the use of pre/postconditions in RSL.\n\nEquations are associated with an object by including an equation declaration within the object definition. The general form of equation definition is the following:\n\n```\nequations:\n var var_name:object_name, ...;\n functional_expr == quantifier_free_expression;\n ...;\n```\n\nwhere a *functional_expr* is as defined above, and a *quantifier_free_expression* is an expression that contains no quantifiers or set operations. Note that the *quantifier_free_expression* is not limited to a boolean value, that is, it need not be only a predicate. The variable declaration(s) that precede the equations define auxiliary variables that are used in the equations. The next section of the report contains example equation definitions in RSL.\n\nThe \"==\" operator and the \"=\" operator should not be confused. The \"==\" separates the two sides of an equation; it has the lowest precedence of any infix operator. The \"=\" is the logical equality operator, which returns a boolean value. It has the same precedence as the other comparison operators.\n\nAxioms are associated with all of the objects and operations defined within a module. Syntactically, an axiom is a predicate:\n\n```\naxiom: predicate ;\n```\n\n### 7.7. Auxiliary Functions\n\nAs noted in Section 1.3, the objects and operations in an RSL specification should be those that are visible to end-users of the specified system. When a specification is fully formalized, it is sometimes necessary or convenient to define auxiliary functions that are referenced in pre/postconditions or equations. An auxiliary function differs from an operation in that it is not intended to be visible to the end user of the specified system.\n\nConsider the following example:\n\n```\nobject NumericPair is\n components : nl:Number, n2:Number;\nend NumericPair;\n\noperation DoSomethingWithPairs is\n inputs: pl: NumericPair, p2: NumericPair, s: SomeOtherObject;\n output : s':SomeOtherObject;\n precondition: if PairwiseLess(pl,p2) then ... ;\nend DoSomethingWithPairs;\n\nfunction PairwiseLess(pl:NumericPair, p2:NumericPair) : (boolean) =\n (pl.nl < p2.nl) and (pl.n2 < p2.n2);\n```\n\nHere the auxiliary function PairwiseLess is defined. This function takes inputs p1 and p2, both of type NumericPair. It produces a boolean output. The following is the general format of an auxiliary function:\n\n```\nfunction name (list of inputs) : (list of outputs) =\n body\n ...\n```\nThe function body is an expression of the output type(s). If the function produces a single output, then the body is an expression of that type. If the function produces more than one value, then the body is a list of expressions enclosed in square brackets, where each expression corresponds by type to the appropriate formal parameter.\n\nWhile PairwiseLess is not strictly necessary in the preceding example, it can make the specification clearer and more concise, particularly if PairwiseLess is used in several different preconditions and postconditions. The next section contains further examples on the use of auxiliary functions and a discussion of when their use is appropriate.\n\n8. Formal Specification Examples\n\nThe four object composition primitives in RSL are just that -- primitive. In particular, using just these four primitives, there is no way to specify any of a number of important properties about objects and operations. For example, in the PersonDatabase object suppose it is necessary to specify that the database cannot have duplicate entries. Or, suppose it is necessary that the database behave as a queue-like structure, such that new records are added on a first-come-first-served (FIFO) basis. Neither of these or similar properties can be defined with the use of composition primitives alone. The use of formal specification is necessary in such cases.\n\nOne method to describe properties such as these is to use English. It is in fact useful to describe all properties of an entity in its English description. However, it is not sufficient to rely solely on natural language to specify critical properties. To do so soon leads to well-known problems of ambiguity and imprecision. Therefore, it is necessary to use the more formal language of mathematics to obtain a truly precise and unambiguous specification.\n\nAnother method to describe properties is to use a computer programming language. This has the advantage of being fully precise and unambiguous. However, using a programming language for specification is fundamentally contrary to the purpose of specification. Namely, a specification should be as free as possible of implementation detail. The purpose of a programming language is precisely for the expression of implementation detail.\n\nTo overcome the disadvantages of English and programming languages, researchers have developed a number of formal techniques expressly for use in specification. The two formal techniques supported primarily in RSL are algebraic and predicative specification. With the algebraic technique, formal properties are specified as a set of equations associated with an object. Hence, algebraic specifications can be considered object-oriented. In the predicative technique, formal properties are specified as preconditions and postconditions on operations. Hence, predicative specification can be considered operation-oriented.\n\nIt is important to note that the two techniques provide different approaches to formal specification. A system can be fully specified using only the algebraic approach, it can be fully specified using only the predicative approach, or it can be specified using a combination of the two approaches.\n\nA potential problem with either of these forms of specification is the introduction of implementation biases into a specification. As examples below illustrate, these formal specification techniques tread a fine line between specification and implementation. In fact, what many software engineers call a specification language others may call a very high-level programming language.\n\nThe gist of the problem is that the more precise we try to become with a specification, the more we tend to constrain what the implementation can look like. However, this violates the\ngeneral principle that a specification is as free from implementation details as possible.\n\nAnother problem is that in some cases we find that in order to state a specification sufficiently precisely, we need to interject auxiliary functions, thereby violating the general rule that a specification should contain only entities directly visible to the end user.\n\nIn summary, specification is a continual battle between risking imprecision by saying too little versus risking the addition of implementation details by saying too much. The experienced specifier learns how to wage this battle successfully.\n\n8.1. Equational Specification\n\nAn equational specification formally defines an object in terms of equations between the operations of the object. Equational specifications are desirable because they require no underlying data model. Rather, the definition of an object is stated entirely in terms of its abstract operations. This model-free property of equational specification is generally not satisfied by other forms of formal specification. For example, the predicative style of specification defined in the next section of the report is not model-free. Rather, predicative specification relies on a set-based data model to provide a basis for defining formal preconditions and postconditions. Without reliance on some underlying model, the predicative style of specification would not be complete.\n\nThe process of defining an equational specification is divided into three major steps:\n\n1. Define the operation signatures for the object's operations\n2. Categorize the operations into constructors, destructors, selectors, and initializers\n3. Define the equations\n\nTo illustrate these steps, consider the definition of a database object that has a set-like structure. That is, it has the property that duplicate entries are not allowed. Here is an equational definition for such a database:\n\n```plaintext\nobject SetDB is\n components: Elem*; (* Note the minimal representation *)\n\n operations:\n Insert: (SetDB, Elem) -> (SetDB), (* Constructor operation *)\n Delete: (SetDB, Elem) -> (SetDB), (* Destructor operation *)\n Find: (SetDB, Elem) -> (boolean), (* Selector operation *)\n EmptyDB: () -> (SetDB); (* Initializer operation *)\n\n equations:\n var s: SetDB; e, e': Elem;\n Find(EmptyDB()) == false;\n Find(Insert(s, e), e') ==\n if e=e' then true else Find(s, e');\n Delete(EmptyDB(), e) == EmptyDB();\n Delete(Insert(s, e), e') ==\n if e=e'\n then Delete(s, e')\n else Insert(Delete(s, e'), e);\n\nend SetDB;\n```\nThe first two lines of this definition use the standard RSL notation for defining any object. When defining an object equationally, its component structure should always be an expression of the form \"C\\*\", where C is a single object name. In the case of the SetDB, the components are Elem\\*, where Elem is some type of element defined elsewhere.\n\nThe operations section of the SetDB definition contains the full signatures for its operations. The term signature refers to the inputs and outputs of an operation. The general form of an operation signature in RSL is\n\n\\[ \\text{operation name} : \\text{(list of inputs)} \\rightarrow \\text{(list of outputs)} \\]\n\nwhere the input and output lists contain zero or more object names.\n\nBefore defining the equations, an object’s operations are organized into the following categories:\n\n1. **Constructor** and initializer operations that build an object out of smaller parts. These two categories can be grouped under the common heading of constructors.\n2. **Selector** and destructor operations that access or remove some component of an object. These two categories can be grouped under the common heading of selectors.\n3. **Derived** operations that can be defined formally in terms of one or more constructors or selectors.\n\nThe comments in the SetDB definition indicate the categories of each of the operations.\n\nThe important characteristic of constructor operations is that they are additive. That is, the resulting output of a constructor is a combination of the inputs. In contrast, selector operations are subtractive. That is, the resulting output is some smaller piece of the input. In general, an equationally defined object should have at least one each of the constructor, initializer, destructor, and selector operations.\n\nOnce operations have been fully defined and categorized, the equations themselves are defined. The general format of an equation is the following:\n\n\\[ \\text{functional_expr} = \\text{quantifier_free_expression}; \\]\n\nwhere a functional_expr is defined above, and a quantifier_free_expression is an expression that contains no quantifiers or set operations. The \"==\" operator separates an equation into a left-hand side (LHS) and a right-hand side (RHS).\n\nThe following guidelines are useful for constructing a correct equational specification:\n\na. The equations define what the selector operations do to the constructor operations, and not vice versa. That is, the outermost operation name in the LHS of an equation should always be a selector, not a constructor.\n\nb. There should be one equation that defines what each selector does to each constructor. Hence, if there are \\( c \\) constructors and \\( s \\) selectors, then there are \\( c \\times s \\) equations.\n\nc. Equations are defined in an inductive style. Specifically, equations are defined in groups, where the first of the group specifies what a selector does with an initializer. The remaining equations in the inductive group specify what a selector does with the other constructors.\n\nConsider how these guidelines were used to construct the SetDB equations:\na. The SetDB selectors are Find and Delete. Hence, each of the SetDB equations has one of these as the outermost operation in the LHS of the equation.\n\nb. Since there are 2 selectors and 2 constructors, there are a total of 4 equations.\n\nc. The inductive style of definition indicates that two groups of equations are appropriate. The first group of two equations specifies what Find does to EmptyDB and Insert. The second group of equations specifies what Delete does to EmptyDB and Insert.\n\nThe most difficult part of an equational definition is constructing the second part of the inductive definition. That is, defining the equations for what the selectors do with the non-initializing constructors. To examine this part of process, let us review what an inductive style definition is.\n\nTo begin, it is assumed that the reader is familiar with the concept of proof by mathematical induction. Readers entirely unfamiliar with this topic should consult an appropriate reference. Recall that an inductive proof is a two step process, in which a proposition p(x) is proved for all values of x. The steps are:\n\n1. Proof of the base case: set x=0 and prove p(x).\n\n2. Proof of the inductive step: assume p(x) is true for x=n and then prove that p(x) is true for x=n+1.\n\nAn inductive equational definition involves a similar two-step process. That is, we define one equation for a base case and one for an inductive step. In the base-case equation, there is an analog to setting the induction variable to 0 -- we define the equation for an object that has 0 components. That is, the base case equation defines what a selector does to an initializer, since an initializer constructs an object with zero components. In the SetDB example, the base case equations are:\n\n\\[\n\\text{Find}(\\text{EmptyDB}()) == \\text{false};\n\\]\n\nand\n\n\\[\n\\text{Delete}(\\text{EmptyDB}(), e) == \\text{EmptyDB}();\n\\]\n\nThese equations define what the selectors do with a SetDB of size 0, that is a SetDB constructed with the EmptyDB initializer. Both these equations are quite intuitive -- if we try to find something in a SetDB of size 0, we receive a false result back. If we try to delete something from a SetDB of size 0, we get back the same 0-sized SetDB we started with. As in a mathematical induction proof, the base case is generally easy to establish.\n\nThe two inductive step equations in the SetDB example are:\n\n\\[\n\\text{Find}(\\text{Insert}(s, e), e') == \\\\\n\\quad \\text{if } e=e' \\text{ then true else Find}(s, e');\n\\]\n\nand\n\n\\[\n\\text{Delete}(\\text{Insert}(s, e), e') == \\\\\n\\quad \\text{if } e=e' \\\\\n\\quad \\text{then Delete}(s, e') \\\\\n\\quad \\text{else Insert}(\\text{Delete}(s, e'), e);\n\\]\n\nThese equations specify what the selectors do with a SetDB of size n+1. The derivation of n+1 comes from an assumption about the set s that is the first argument to Insert, Find, and Delete. The assumption is that s contains n elements. Hence, the constructed object Insert(s, e) contains n+1 elements -- the n elements assumed to be in s plus the one new element e that is inserted.\nBoth of the inductive-step equations use a recursive style of definition. This is very common in inductive-step equations. The recursion always involves some form of conditional, typically an if-then-else. The test of the condition checks the $n+1$ case, then the recursion handles the other $n$ cases. Consider again the case for Find:\n\n$$\\text{Find}(\\text{Insert}(s, e), e') =\n\\begin{cases} \n\\text{true} & \\text{if } e = e' \\\\\n\\text{Find}(s, e') & \\text{if } e \\neq e'\n\\end{cases}$$\n\nTo paraphrase this equation in English, the LHS says \"consider what the Find selector does with a SetDB of size $n+1\". The RHS then says, \"if the last item that was inserted is the item we’re trying to find, then we’ve found it so return true; otherwise, the item we’re looking for, if present, must be one of the $n$ items in the SetDB $s$, so we recursively apply Find to look for it.\"\n\nBy far the most difficult equation in the SetDB example is the last one that defines the inductive step for Delete. The equation is not necessarily intuitive in terms of exactly how it defines set-like behavior. An important technique to determine if a set of equations does what we want is to formally test the equations. To gain an understanding of how the last equation works, we will apply this testing technique shortly. Before doing so, we examine some additional equational definitions.\n\n8.2. Some Additional Equational Definitions\n\nThe SetDB example defined equations for the database property that duplicate entries are not allowed. Given below are additional equational definitions that specify other database structural properties. These are all properties that are considered appropriate to be known by an end user.\n\n8.2.1. A Bag-Like Object\n\nSuppose the desired definition of database is one that does allow duplicate entries, that is, it behaves like a mathematical bag instead of a set. To obtain the definition of a bag from that of a set, only one change is necessary -- the then clause of the last SetDB equation is changed from\n\n```plaintext\nthen Delete(s, e') (* for a set *)\n```\n\nto\n\n```plaintext\nthen s (* for a bag *)\n```\n\nThe upcoming section on testing equations will discuss why this change does what is claimed.\n\n8.2.2. A LIFO-Structured Database\n\nSuppose we choose to define a LIFO DB, that is, a DB that behaves like a stack. A stack is much simpler than a set since no recursive searching is necessary for the selector operation. For a stack, the selector is the Top operation. Here is the equational definition:\n\n```plaintext\nobject StackDB is\ncomponents: Elem*;\n\noperations:\nPush: (StackDB, Elem) -> (StackDB), (* constructor operation *)\nPop: (StackDB) -> (StackDB), (* destructor operation *)\nTop: (StackDB) -> (Elem), (* selector operation *)\nEmptyStackDB: () -> (StackDB); (* initializer operation *)\n\nequations:\nvar s: StackDB; e: Elem;\n```\nTop(EmptyStackDB()) == EmptyElem();\nTop(Push(s, e)) == e;\nPop(EmptyStackDB) == EmptyStackDB();\nPop(Push(s, e)) == s;\n\nend StackDB;\n\n8.2.3. A FIFO-Structured Database\n\nNext we consider the definition of a DB with a FIFO property that is, the definition of a queue-like DB. This definition is intermediate in terms of complexity between a SetDB and StackDB.\n\nobject QueueDB\n components: Elem*;\n\n operations:\n Enq: (QueueDB, Elem) -> (QueueDB), (* constructor operation *)\n Deq: (QueueDB) -> (QueueDB), (* destructor operation *)\n Front: (QueueDB) -> (Elem), (* selector operation *)\n EmptyQueueDB: () -> (QueueDB); (* initializer operation *)\n\n equations:\n var q: QueueDB; e:Elem;\n Front(EmptyQueueDB()) == EmptyElem();\n Front(Enq(q, e)) ==\n if q = EmptyQueueDB()\n then EmptyQueueDB()\n else Front(q);\n Deq(EmptyQueueDB) == EmptyQueueDB();\n Deq(Enq(q, e)) ==\n if q = EmptyQueueDB\n then EmptyQueueDB\n else Enq(Deq(q), e);\n\nend QueueDB;\n\n8.2.4. A Keyed Database\n\nFinally, we consider the definition of a keyed database, in which duplicates are not allowed. The difference between this and SetDB is a more realistic version of the Find operation. No real database would have Find return a boolean. Rather, Find should return a whole element, which would be located by some Key. The following specification defines this form of database. The equations have the same fundamental structure as SetDB, but with the addition of a Key argument where appropriate.\n\nobject DB is\n components: Elem*;\n\n operations:\n Insert: (DB, Key, Elem) -> DB; (* constructor operation *)\n Delete: (DB, Key) -> (DB); (* destructor operation *)\n Find: (DB, Key) -> (Elem); (* selector operation *)\n EmptyDB: () -> (DB); (* initializer operation *)\nequations:\n var d: DB; e: Elem; k, k': Key;\n Find(EmptyDB, k) == EmptyElem();\n Find(Insert(d, e, k), k') ==\n if k = k' then e else find(d, k');\n Delete(EmptyDB, k) == EmptyDB;\n Delete(Insert(d, e, k), k') ==\n if k = k'\n then Delete(d, k')\n else Insert(Delete(d, k'), k, e);\nend DB;\n\n8.3. Testing Equational Specifications\n\nThe first step in testing an equational specification is to understand precisely how equationally defined objects are represented. Since an equationally-defined object has no concrete representation, we have no real way to \"get our hands on it.\" We cannot draw a picture of an object that has no concrete representation. The only means to represent such an object is by using its constructor operations.\n\nConsider the representation of SetDB objects. To build a SetDB, the component type Elem must be defined. Assume for simplicity object Elem is defined as a number. Given this, a SetDB object will contain numeric values. As a concrete example, the SetDB containing elements 1, 2, and 3 is represented as a functional expression containing three applications of the Insert constructor:\n\n\\[ \\text{Insert(Insert(Insert(EmptyDB(), 1), 2), 3)} \\]\n\nIn general, any equationally-defined object can be represented as a sequence of constructor operations, applied at the base to an initializer operation.\n\nTo apply a selector operation to a constructed object, the constructed object simply appears as an argument in the appropriate selector argument position. For example, to delete the element 2 for the above set, the Delete operation is applied as follows:\n\n\\[ \\text{Delete(Insert(Insert(Insert(EmptyDB(), 1), 2), 3), 2)} \\]\n\nFunctional expressions such as this are commonly called \"terms\". A term is any number of equationally-defined operations, applied properly according to their signature definitions.\n\nThe general method to test a set of equations is to consider the equations as reduction rules and apply these rules to a constructed object. In general, a reduction rule is of the form\n\n\\[ \\text{LHS} \\rightarrow \\text{RHS} \\]\n\nwhere the \"\\(\\rightarrow\\)\" symbol is read \"reduces to\". To treat an equation as a rewrite rule, the \"\\(==\\)\" is simply replaced by a \"\\(\\rightarrow\\)\". We do not actually change the \"\\(==\\)\" but rather we view the equation as a rewrite rule, as if the \"\\(==\\)\" were \"\\(\\rightarrow\\)\".\n\nA reduction rule is said to be applied to some subject. In the case of an equational rewrite rule, the subject is a term. Rewrite rule application involves matching the LHS of the rule to some part of the term, and then replacing the matched term with the RHS of the rule. This replacement of the matched LHS with a RHS is the actual rewriting process.\n\nThe goal of equational term reduction is to remove all selector operations from a term, leaving only constructors. This goal makes sense when we consider the form of the equations. Recall that equations are written in terms of what a selector does to a constructor, not the other way around. The reason that we do not define equations for what constructors do is that they need not be reduced. In other words, a term containing only constructors is considered fully\nreduced. In this way, an actual object is represented fundamentally by a series of constructor operations. Whenever a selector is applied to a constructed object, the selector is \"reduced out\" to produce a term that again only contains constructors.\n\nConsider the reduction of the Delete term just above:\n\n```plaintext\nDelete(Insert(Insert(Insert(EmptyDB(), 1), 2), 3), 2)\n```\n\nThe goal of the reduction is the following object\n\n```plaintext\n(Insert(Insert(EmptyDB(), 1), 3)\n```\n\nwhich represents a SetDB containing a 1 and 3 -- the 2 has been deleted as expected. This goal was reached by a series of rule applications which matched an equation LHS to some part of the term, and then replaced the matched LHS with the RHS of the equation. Let us trace through the reduction steps for the above term. We first start with the subject term:\n\n```plaintext\nDelete(Insert(Insert(Insert(EmptyDB(), 1), 2), 3), 2)\n```\n\nTo find a match, we consult the SetDB equations, looking for a LHS match. The process we apply is pattern matching. That is, we consider the LHS of each equation to be a pattern that we attempt to match to some part of the term. The matching technique attempts to match each operation name in a LHS with a the same name in the term. The variables in the LHS are matched to components in the term of the appropriate type.\n\nConsider how the match is attempted on the above term with each of the four SetDB equations. The LHSs of the first two equations contain a Find operation. These two equations can be eliminated from consideration immediately, since there is no occurrence of Find anywhere in the subject term (i.e., there are only Delete, Insert, and EmptyDB). The LHS of the last two SetDB equations are possible candidates for a match, since they start with Delete. The third equation cannot match however, since there is no pattern in the subject term that will match.\n\n```plaintext\nDelete(EmptyDB(), ...)\n```\n\nThis is because the only occurrence of Delete in the subject term is applied to Insert, not EmptyDB, and the operation names \"Insert\" and \"EmptyDB\" do not match.\n\nWe are left with the fourth SetDB equation. This equation does in fact match, as follows:\n\n<table>\n<thead>\n<tr>\n<th>LHS Subterm</th>\n<th>Matched Subject Subterm</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Delete</td>\n<td>Delete</td>\n</tr>\n<tr>\n<td>Insert</td>\n<td>outermost application of Insert</td>\n</tr>\n<tr>\n<td>s</td>\n<td>Insert(Insert(EmptyDB(), 1), 2)</td>\n</tr>\n<tr>\n<td>e</td>\n<td>3</td>\n</tr>\n<tr>\n<td>e'</td>\n<td>2</td>\n</tr>\n</tbody>\n</table>\n\nwhere a subterm is some part of a term. Given this matching, the rule can now be applied, i.e., reduced. The reduction involves systematic substitution of the matched LHS with the appropriate subterms of the RHS of equation 4. The RHS of equation 4 is the following:\n\n```plaintext\nif e=e'\n then Delete(s, e')\n else Insert(Delete(s, e'), e);\n```\n\nWhen the RHS of an equation contains an if-then-else, the replacement will be selected from either the then clause or the else clause. This requires the the evaluation of the if predicate. In this case, the if predicate is\n\n```plaintext\ne = e'\n```\n\nBased on the above subterm matches, this predicate evaluates to\nwhich is false. Hence, the RHS replacement is the term given in the else clause of the if-then-else, which is\n\n\\[ \\text{Insert(Delete(s, e'), e);} \\]\n\nThat is, we must substitute this term for the matched LHS. Doing this, the first step of the overall reduction process yields the following results:\n\n\\[\n\\text{Delete(Insert(Insert(Insert(EmptyDB, 1), 2), 3), 2)} \\Rightarrow \\\\\n\\text{Insert(Delete(Insert(EmptyDB, 1), 2), 2), 3)}\n\\]\n\nNotice what has happened here: the Delete has been moved inward in the term passed the Insert. Also, the 2 has been moved inward passed the 3. This sort of manipulation is the gist of what term writing accomplishes. Namely, the term is rewritten by (re)moving pieces according to the equations.\n\nSince the term above still contains a selector operation, it is not yet fully reduced. We therefore apply the same matching process as was used for the first reduction step. As in that case, the first two equations are eliminated immediately as possible matches. The LHS of the third equation also fails to match as before. We again match the fourth equation, this time as follows:\n\n<table>\n<thead>\n<tr>\n<th>LHS Subterm</th>\n<th>Matched Subject Subterm</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Delete</td>\n<td>Delete</td>\n</tr>\n<tr>\n<td>Insert</td>\n<td>2nd to the outermost application of Insert</td>\n</tr>\n<tr>\n<td>s</td>\n<td>Insert(Insert(EmptyDB(), 1), 2)</td>\n</tr>\n<tr>\n<td>e</td>\n<td>2</td>\n</tr>\n<tr>\n<td>e'</td>\n<td>2</td>\n</tr>\n</tbody>\n</table>\n\nThe difference in this case is that the evaluation of the if predicate in the RHS of equation 4 is now\n\n\\[ 2 = 2 \\]\n\nwhich evaluates to true this time. Hence, now instead of the else clause, we substitute the then clause, which is:\n\n\\[ \\text{then Delete(s, e')} \\]\n\nDoing this, the second step of the reduction process yields the following results:\n\n\\[\n\\text{Insert(Delete(Insert(Insert(EmptyDB, 1), 2), 1), 2)} \\Rightarrow \\\\\n\\text{Insert(Delete(EmptyDB(), 1), 2), 3)}\n\\]\n\nThe resulting term is not yet fully reduced, since it still contains the Delete selector. Two additional reduction steps will occur to arrive at complete reduction. The next step will match equation 4 again, as in the preceding two steps. On this match, the if predicate, \\( e = e' \\), will test\n\n\\[ 1 = 2 \\]\n\nwhich is false, thereby causing substitution of the else clause. Doing this, the third step of the reduction yields:\n\n\\[\n\\text{Insert(Delete(Insert(EmptyDB(), 1), 2), 3)} \\Rightarrow \\\\\n\\text{Insert(Insert(Delete(EmptyDB(), 1), 2), 3)}\n\\]\n\nThe final step of the reduction uses SetDB equation 3. This is because the pattern matching finds \"... Delete(EmptyDB() ...\" in the term, which matches the LHS of equation 3. Given this, the final step of the reduction is\n\n\\[\n\\text{Insert(Insert(Delete(EmptyDB(), 1), 2), 3)} \\Rightarrow \\\\\n\\text{Insert(EmptyDB(), 1), 2), 3)}\n\\]\nInsert(Insert(EmptyDB(), i), 3)\n\nIn addition to testing that SetDB equations are correct, the above reduction sequence reveals precisely how the SetDB equations work. It should now be clear why equation 4 of SetDB is written as it is. Namely, it is up to the Delete equation to make sure that the set property is maintained. Any number of Insert operations can be applied to a SetDB term, including Insert's of the same element. While this temporarily violates the set property, the Delete equation makes sure that set behavior is maintained by deleting all of the same elements that may have been inserted. While this may seem to be an inefficient manner in which to maintain the set property, we do not care about efficiency at all, only that the desired property is properly maintained.\n\n8.4. Predicative Specification\n\nPredicative specification is a complementary form of specification to equational. In the predicative approach, preconditions and postconditions are associated with an operation. The precondition specifies a predicate that must be true before the operation begins. The postcondition specifies a predicate that must be true after the operation completes.\n\nConsider an alternate definition of a set-like database:\n\n```plaintext\nobject SetDB is\n components: Elem*;\n operations: Insert, Delete, Find, EmptyDB;\n\n (* Note that we do not need full operation signatures, nor\n * equations, since we are now specifying with pre and post-\n * conditions in place of the equations we used above. *)\nend SetDB;\n\noperation Insert is\n inputs: d:SetDB, e:Elem;\n outputs: d’:SetDB;\n precondition: Find(d, e) = false;\n (* An equivalent precondition is: not (s in e);\n * see discussion below. *)\n postcondition: Find(d’, e) = true;\n (* An equivalent precondition is: s in e;\n * see discussion below. *)\nend Insert;\n\noperation Find is\n inputs: d:SetDB, e:Elem;\n outputs: b:boolean;\n precondition: (* An empty precond means true *) ;\n postcondition: b = e in d;\nend Find;\n\noperation Delete is\n inputs: d:SetDB, e:Elem;\n outputs: d’:SetDB;\n precondition: e in d;\n (* See discussion below about removing this precond. *)\n postcondition: not Find(d, e);\nend Delete;\n```\noperation EmptyDB is\n inputs: ;\n outputs: d:SetDB;\n precondition: ;\n postcondition: forall (e:Elem) not Find(d,e);\n (* See discussion below about removing this precond. *)\nend EmptyDB;\n\nIt is instructive to compare and contrast this predicative definition of SetDB with the equational\ndefinition given in the preceding section. Both definitions specify the same meaning in different\nforms. The following are are some important points about specification with pre and post condi-\ntions in particular.\n\nBy definition, violation of a precondition is an error: Abstractly this means simply that the\noperation fails and no postcondition happens. Concretely (i.e., in the user's manual), this means\nthat the end-user should see some form of appropriate error message.\n\nA specification can be weakened or strengthened by the selective removal or addition of pre\nand/or post conditions. E.g.,\n\n```\nop Delete is\n in: d:DB, e:Elem;\n out: d':DB;\n precond: Find(d, e) = true;\n postcond: Find(d', e) = false;\nend Delete;\n```\n\nis relatively weaker than\n\n```\nop Delete is\n in: d:DB, e:Elem;\n out: d':DB;\n postcond: Find(d', e) = false;\nend Delete;\n```\nin that the latter specification says that it is an error to try to delete an element that is not already\nin the database, whereas the former is non-committal.\n\n8.4.1. Quantification\n\nIn equational specification, recursion is used to specify a single equation that can be applied\nin an indefinite (potentially infinite) number of cases. That is, a recursive equation can be appli-\ncable to objects from size 1 to an infinite size. The predicative style of specification uses quantification\nto define predicates that apply to objects of an indefinite size.\n\nConsider the following basic example of universal quantification:\n\n```\noperation FindAllYoungFolks is\n inputs: pdb: PersonDatabase;\n outputs: nl: NameList;\n postcondition:\n forall (p: PersonRecord)\n if (p in pdb) and (p.a < 40)\n then p.n in nl;\n description: (*\n FindAllYoungFolks produces a list of the names of all\n persons in the PersonDatabase whose age is less than 40\n *);\nend FindAllYoungFolks;\n```\nobject PersonDatabase is\n components: PersonRecord*;\n description: (* Same as earlier definitions. *)\nend PersonDatabase;\n\nobject PersonRecord is\n components: n:Name and a:Age and ad:Address;\n description: (* Same as earlier definitions. *)\nend PersonRecord;\n\nobject NameList is\n components: Name*;\nend NameList;\n\nThe postcondition of the FindAllYoungFolks operation uses forall to quantify over the input PersonDatabase. An English paraphrase of the postcondition is as follows: \"For each PersonRecord, p, in the input, if the age of person p is less than 40, then the name of person p is in the output name list\". This form of quantification is very typical of postconditions on operations that produce list-structured objects as outputs.\n\nThe following objects and operations further exemplify the use of universal and existential quantification in RSL. Consider an operation that merges set-like databases, of the type specified earlier:\n\noperation MergeDBs\n inputs: d1:SetDB, d2:SetDB;\n outputs: d3:SetDB;\n postcondition:\n forall (e: Elem)\n if (e in d1) or (e in d2)\n then e in d3;\n description: (*\n The MergeDBs operation merges two databases of the same type of element. The postcondition states that the result of the merge is that any element that is in either input d1 or d2 must be in the output d3.\n *)\nend MergeDBs;\n\nThere is no needed precondition. The postcondition states that if an element is in either of the input DBs, then it is in the output DB. An interesting question is the strength of this postcondition. In particular, does it guarantee that there are no duplicates in the output d3? Since the \"in\" operator is not constructive, based on this postcondition alone there is no way to state for certain whether d3 has duplicates or not. That is, this postcondition is too weak to guarantee no duplicates. Thus, we must look elsewhere.\n\nThe \"elsewhere\" we look is in the specification of the other DB operations. Specifically, the specifications for SetDB Find and Delete are:\n\noperation Find is\n inputs: d:SetDB, e:Elem;\n outputs: b:boolean;\n precondition: (* An empty precond means true *) ;\n postcondition: b = e in d;\nend Find;\n\noperation Delete is\n inputs: d:SetDB, e:Elem;\nWhat Find ensures is that if at least one copy of an element is in a SetDB, then it can be found. What Delete ensures, is if there are one or more copies of an element in a SetDB, then after the Delete none can be found. Therefore, whether duplicates are ever physically present in a SetDB is immaterial. The specifications of Find and Delete uphold the critical set property that if an element has been added at least once, then it can be found, and if it is deleted, it cannot be found. Hence, even if MergeDBs does add duplicates, Find and Delete will maintain the set property when subsequently invoked.\n\nConsider another form of database merge:\n\n```\nobject PairedDB is\n components: ElemPair*;\nend PairedDB;\n\nobject ElemPair is\n components: el:Elem and e2:Elem;\n description: (* An ElemPair is just a pair of elements. *)\nend ElemPair;\n\noperation PairwiseMergeDBs\n inputs: d1:DB, d2:DB;\n outputs: dp: PairedDB\n precond: #d\n postcondition:\n forall (el,e2: Elem)\n if (el in d1) and (e2 in d2)\n then\n exists (ep: ElemPair) (ep in dp) and\n (ep.el = el) and (ep.e2 = e2)\n description: (*\n PairwiseMergeDBs merges two databases of the same type of\n element into a paired database. The precondition states\n that the two input DBs must have the same number of\n elements. The postcondition states that the resulting\n output, dp, must consist of pairs of all the elements that\n are the two input databases.\n *)\nend PairwiseMergeDBs\n```\n\nIt is important to note that universal quantification does not deliver elements in any specific order. Given this, the postcondition for the PairwiseMergeDBs example may be weaker than it appears. Namely, it specifies that dp contains all possible pairs from d1 and d2, in any order. Suppose that only ordered pairs were desired, such that each pair contains the \\(i\\)th element from each of the inputs. This could be specified in a number of ways, including as follows:\n\n```\noperation PairwiseMergeDBs\n ...\n postcondition:\n forall (el,e2: Elem)\n if (el in d1) and (e2 in d2)\n then\n```\nexists (ep: ElemPair) ((ep in dp) and\n PositionOf(ep.el1, dl) = PositionOf(ep.el2, d2))\n\nwhere PositionOf is the following auxiliary function that outputs the ordinal position of an Elem within a DB:\n\nfunction PositionOf(e:Elem, d:DB):n:number) =\n if d = nil\n then 0\n else if e = d[1]\n then 1\n else PositionOf(e, d[2:#d]) + 1;\n\n8.4.2. Combining Predicative and Equational Specification\n\nThe following example shows how a sorted, keyed database can be defined using a combination of equational and predicative specification:\n\nobject Elem is\n components: k: Key, ElemValue;\n description: /*\n A DB element with an internal key.\n */\nend Elem;\n\nobject Key is string;\n\nobject SKDB is\n components: Elem*\n operations:\n Insert: (SKDB, Elem) -> (SKDB),\n Delete: (SKDB, Key) -> (SKDB),\n Find: (SKDB, Key) -> (Elem),\n EmptySKDB: () -> (SKDB),\n FindNth: (SKDB, number) -> (Elem),\n SortDB: (SKDB, Key) -> (SKDB);\n equations:\n var d: SKDB; e:Elem; i:number;\n Find(EmptyDB, k) == EmptyElem();\n Find(Insert(d, e), k') ==\n if e.k=k' then e else find(d, k');\n Delete(EmptyDB, k) == EmptyDB;\n Delete(Insert(d, k), k') ==\n if k=k'\n then Delete(d, k')\n else Insert(Delete(d, k'), k, e);\n FindNth(Insert(d,e), i) ==\n if i = 1 then e\n else FindNth(d,i-1);\nend SKDB;\n\noperation SortDB is\n inputs: d:SKDB, k:Key;\n outputs: d':SKDB;\n precond: ;\n postcond: forall (i,j:number)\n if i<j then FindNth(d',i).k < FindNth(d',j).k;\n46\nOf particular note in this example is the universal quantifier in the SortDB postcondition. An English paraphrase of this postcondition is as follows: \"For all pairs of numbers i and j, if i is less than j then the key at position i is less than the key at position j, where the key at position n is delivered by the FindNth operation.\"\n\n8.4.3. More on Auxiliary Functions\n\nA negative critique of keyed database specification is that FindNth might best be left invisible to end-users. That is, there may be no reason that users need to find the nth element in a DB. Rather, users simply need the DB sorted, and to be able to find elements by key. Even if this is the case, we still need FindNth in order to fully specify the definition of SortDB.\n\nIt was noted earlier that specification is a battle between saying too little and saying too much. In the case of FindNth, the battle has been lost if FindNth is not a necessary user-level operation, since FindNth is still a necessary specification-level function. In the example above, FindNth was specified equationally as a visible operation. The alternate definition as an auxiliary function is the following:\n\n\\[\n\\text{function FindNth}(d:\\text{SKDB}, n:\\text{number}) : (e:\\text{Elem}) = d[n];\n\\]\n\nIn some cases, it may turn out that what at first appears to be an auxiliary function is in fact a legitimate user-level operation. When this happens, the process of formalizing a specification has helped uncover an incompleteness originally present before the formal definition was considered. In other cases, auxiliary functions should best be left invisible to the user, in which case they remain genuinely auxiliary. In all cases, specifiers must consider carefully when auxiliary functions are necessary.\n\nAn noteworthy property of auxiliary functions is that their definitions are constructive. That is, the body of the function constructs an actual value that the function outputs. Such constructive definitions are in contrast to operations that are defined solely in terms of pre- and post-conditions. A postcondition does not construct a value, but rather states a property that an assumed constructed value must meet.\n\nThe astute reader will notice that with the introduction of constructive functions, RSL has the expressive power of a functional programming language, such as LISP or ML. Hence, using constructive functions, it is possible for specifications to become very much like programs. This is clearly not the intent. Specifiers should always be mindful that the fundamental goal of specification is to define what a system does, not how it works. Auxiliary functions should be used judiciously, so that RSL specifications remain free of unnecessary program-level detail.\nReferences\n\n\nAppendix A: Summary of Entity Definition Forms\n\nThe examples in the body of the manual show how objects and operations can be defined in a number of forms. This Appendix summarizes each of the definitional forms.\n\nA.1 Object Definition Forms\n\nThe most complete form of object definition is the following:\n\n object name is\n [components: ...;]\n [operations: ...;]\n [equations: ...;]\n [description: ...;]\n [<user-defined attributes>; ... ;]\n end <name>\n\nwhere the square brackets denote optional terms. This long-form specifies a composite type if the components attribute is non-empty, or an opaque type if the components attribute is missing or defined as empty.\n\nThe following is a shorter definition form used to specify atomic types:\n\n object name is name [ \n [operations: ...;]\n [equations: ...;]\n [description: ...;]\n [<user-defined attributes>; ... ;]\n end <name>\n\nNotice in this shorter form that the components attribute is missing. The other attributes remain optional in the short form.\n\nReplacing the keyword is with '=' defines a concrete value rather than an abstract type. The general format for a concrete object definition is as follows:\n\n object name = expression [ \n [description: ...;]\n [<user-defined attributes>; ... ;]\n end <name>\n\nNotice that components, operations, and equations attributes are all missing in a concrete value definition. Formally, it is inappropriate to include these attributes for a concrete value, so their inclusion is disallowed syntactically.\n\nThe simplest form of object specification is a fully opaque type, defined as:\n\n object name:\n\nA.2 Operation and Function Definition Forms\n\nThe general forms for operation definition are analogous to the object forms. The long-form operation definition is the following:\n\n operation name is\n [components: ...;]\n [inputs: ...;]\nThis form defines a user-visible operation with optional attributes. A non-user-visible auxiliary function can be defined in two forms, the first of which is:\n\n```\nfunction name is\n [inputs: ...;]\n [outputs: ...;]\n [preconditions: ...;]\n [postconditions: ...;]\n [description: ...;]\n [user-defined attributes]; ...\nend <name>\n```\n\nThis form defines a non-constructive auxiliary function. The formal specification of such functions is given with pre/postconditions or equationally.\n\nThe final function definition form is:\n\n```\nfunction name = (inputs):(outputs) = epxr\n [preconditions: ...;]\n [postconditions: ...;]\n [description: ...;]\n [user-defined attributes]; ...\nend <name>\n```\n\nThis form defines a constructive auxiliary function, where the given expression defines the concrete value computed by the function. Notice that a constructive function may optionally include pre/postconditions so that a both constructive and predicative definition can be supplied if desired. The two definitions can provide complementary but equivalent specifications.\nAppendix B: Keyword Synonyms\n\nTo provide flexibility in the textual style of an RSL specification, most keywords have abbreviated forms that are synonymous with the longer forms of the keyword. The following table summarizes all keyword synonyms:\n\n<table>\n<thead>\n<tr>\n<th>Full Keyword</th>\n<th>Synonymous Abbreviations</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>and</td>\n<td>','</td>\n</tr>\n<tr>\n<td>axiom</td>\n<td>ax</td>\n</tr>\n<tr>\n<td>collection</td>\n<td>list, list of, '*' (as a postfix operator)</td>\n</tr>\n<tr>\n<td>components</td>\n<td>parts</td>\n</tr>\n<tr>\n<td>exists</td>\n<td>exist, there exist, there exists</td>\n</tr>\n<tr>\n<td>function</td>\n<td>func</td>\n</tr>\n<tr>\n<td>iff</td>\n<td>'<=>'</td>\n</tr>\n<tr>\n<td>implies</td>\n<td>'=>'</td>\n</tr>\n<tr>\n<td>inputs</td>\n<td>in</td>\n</tr>\n<tr>\n<td>object</td>\n<td>obj</td>\n</tr>\n<tr>\n<td>operation</td>\n<td>op</td>\n</tr>\n<tr>\n<td>operations</td>\n<td>ops</td>\n</tr>\n<tr>\n<td>outputs</td>\n<td>out</td>\n</tr>\n<tr>\n<td>postconditions</td>\n<td>postcond, post</td>\n</tr>\n<tr>\n<td>preconditions</td>\n<td>precon, pre</td>\n</tr>\n<tr>\n<td>variable</td>\n<td>var</td>\n</tr>\n</tbody>\n</table>\nAppendix C: Functional Definition of Relational Attributes\n\nFormally, relational attributes can be viewed as \"syntactic sugaring\" for a functional definition of formal relations. RSL users who prefer to limit the number of constructs used in a specification may prefer not to use relational attributes.\n\nIn general, the relation between two objects is represented as a function (or operation) with an appropriate signature. Consider the following bi-directional relation:\n\n```\ndefine object attribute R;\nobject O1 is\n R: O2;\nend O1;\nobject O2 is\n R: O1\nend O2\n```\n\nThe functional representation is as follows:\n\n```\nobject O1 is\n ...\nend O1;\nobject O2 is\n ...\nend O2;\nfunction O1_R_O2(O1): (O2);\nfunction O2_R_O1(O2): (O1);\n```\n\nMulti-valued relations, such as\n\n```\nobject O3 is\n ...\n R: O1,O2;\nend O3;\n```\n\nare represented as multi-valued functions or multiple, suitably-named single-valued functions. The functional representation is clearly bulkier than the attribute-based representation, since in the former, one function needs to be defined for each separate reference to a single relation.\n\nAn additional consideration regarding relational definitions concerns the future enhancement of the RSL development environment. A near-term goal is to provide a formal verification environment for RSL, so that properties of a specification can be mechanically verified. The most effective means to provide such verification is to translate RSL into an existing formal language for which mechanized verification support already exists. Candidates for the target of translation include EHDM [Rushby 91] and HOL [Gordon 87]). These and similar systems do not provide direct verification support for relational definitions. Therefore, translation of relations into functional form will be necessary if mechanized verification support is to be provided for RSL in the foreseeable future.\nAppendix D: Complete RSL Syntax\n\ntop_level_def:\n spec_unit\n | entity_spec\n | attr_def\n\nspec_unit:\n module_heading entity_spec_list ';' 'end' spec_name_ender ';' |\n module_heading attr_defs ';' entity_spec_list ';' 'end' spec_name_ender\n |\n module_heading 'end' spec_name_ender ';' |\n module_heading attr_defs ';' 'end' spec_name_ender ';' |\n entity_spec ';'|\n\nmodule_heading:\n 'module' spec_name ';' |\n 'module' spec_name ';' imports |\n 'module' spec_name ';' exports |\n 'module' spec_name ';' imports exports\n\nimports:\n import |\n import imports\n\nimport:\n 'from' name 'import' ident_list ';' |\n 'import' ident_list ';\n\nexports:\n export |\n export exports\n\nexport:\n 'export' 'qualified' ident_list ';' |\n 'export' ident_list ';\n\nentity_spec_list:\n entity_spec |\n entity_spec_list ';' entity_spec\n\nentity_spec:\n object_spec |\n operation_spec |\n formal_decl\nobject_spec:\n obj_heading 'is' obj_body 'end' obj_name_ender |\n obj_heading instance 'is' obj_body 'end' obj_name_ender |\n obj_symbol name_type_pair '=' obj_expr |\n obj_symbol name_type_pair '=' obj_expr obj_attributes 'end' obj_name_ender |\n obj_heading 'is' obj_name |\n obj_symbol obj_name\n\nobj_heading:\n obj_symbol obj_name |\n obj_symbol class obj_name\n\noperation_spec:\n op_heading 'is' op_body 'end' op_name_ender |\n op_heading instance 'is' op_body 'end' op_name_ender |\n op_symbol op_name '(' name_type_list ')' ':' '(' name_type_list ')' '=\"' expr |\n op_symbol op_name '(' name_type_list ')' ':' '(' name_type_list ')' '=\"' expr precond postcond op_attributes 'end' op_name_ender\n\nop_heading:\n op_symbol op_name |\n op_symbol class op_name\n\nclass:\n 'class'\n\ninstance:\n 'instance' 'of' class_name_list\n\nobj_body:\n parts ops eqns obj_attributes |\n name ops eqns obj_attributes |\n parts ops eqns |\n name ops eqns\n\nop_body:\n parts inputs outputs precond postcond op_attributes\n\nparts:\n /* empty */ |\n parts_spec or_op parts_spec |\n prefix_list_op parts_spec |\n parts_spec postfix_list_op |\n name_type_pair |\n name ':\"' '(' parts_spec ')' |\n '(' parts_spec ')'\nand_op:\n 'and' |\n op_name ':' op_parms\n\nop_parms:\n '(' sig_args_list ')' '-' '(' sig_args_list ')\n\nname_type_list:\n /* empty */ |\n prefix_list_op ins_parts_spec |\n ins_parts_spec postfix_list_op |\n init_name_type_pair\n\nobj_attributes:\n obj_attribute |\n obj_attributes ';' obj_attribute\n\nobj_attribute:\n attr_name ':' 'text'\n\nattr_name:\n name\n\nop_attributes:\n /* empty */ |\n obj_attributes\n\nname_type_pair:\n name |\n name ':' obj_name\n\nname_obj_pair:\n name |\n name ':' obj_name\n\ninit_name_type_pair:\n name_type_pair |\n name_type_pair ':=' obj_expr\n\nspec_name:\n name\n\nspec_name_ender:\n /* empty */ |\n name\n\nclass_name_list:\nclass_name |\n class_name_list ',' class_name\n\nclass_name:\n name\n\nobj_name:\n name\n\nobj_name_ender:\n /* empty */ | name\n\nop_name:\n name\n\nop_name_ender:\n /* empty */ | name\n\nformal_decl:\n var_symbol var_decls '; ' |\n function_decl '; ' |\n ax_symbol ax_decls ' ; ' |\n\nvar_decls:\n var_decl |\n var_decls ' ; ' var_decl\n\nvar_decl:\n var_name_list ':' obj_name\n\nfunction_decl:\n function_heading '(' name_type_list ')' ':' '(' name_type_list ')' |\n '=' expr |\n function_heading '(' name_type_list ')' ':' '(' name_type_list ')' |\n '=' expr precond postcond op_attributes 'end' op_name_ender |\n function_heading '(' name_type_list ')' ':' '(' name_type_list ')' |\n 'is' precond postcond op_attributes 'end' op_name_ender |\n\nfunction_heading:\n 'function' op_name |\n 'func' op_name\n\nprecond:\n /* empty */ |\npre_symbol ': ';' |\n pre_symbol ': expr ';' |\n pre_symbol error ';\n\npostcond:\n /* empty */ |\n post_symbol ': ';' |\n post_symbol ': expr ';' |\n post_symbol error ';\n\nexpr:\n expr 'and' expr |\n expr 'or' expr |\n expr 'implies' expr |\n expr 'iff' expr |\n 'not' expr |\n 'if' expr 'then' expr |\n 'if' expr 'then' expr 'else' expr |\n 'forall' '(' name_obj_list ')' expr |\n exists_symbol '(' name_obj_list ')' expr |\n rel_expr\n\nrel_expr:\n expr rel_bin_op expr %prec '=' |\n arith_expr\n\narith_expr:\n arith_expr arith_add_op arith_expr |\n arith_expr arith_mult_op arith_expr |\n arith_expr arith_exp_op arith_expr |\n arith_pre_op arith_expr |\n selector_expr |\n index_expr |\n functional_expr |\n obj_expr |\n '(' expr ')\n\nselector_expr:\n arith_expr select_op arith_expr %prec ','\n\nindex_expr:\n arith_expr '[' expr '] ' %prec '[' |\n arith_expr '[' expr ': expr ']'|\n\nfunctional_expr:\n op_name '(' op_args ')'\n\n57\nop_args:\n /* empty */ | op_arg | op_arg ',', op_args\n\nsig_args_list:\n /* empty */ | sig_args\n\nsig_args:\n sig_arg | sig_arg ',', sig_args\n\nop_arg:\n expr\n\nsig_arg:\n name_type_pair\n\nrel_bin_op:\n '=' | '<' | '>' | '<>' | '<=' | '>= | 'in'\n\narith_add_op:\n '+' | '-'\n\narith_mult_op:\n '*' | '/' | 'div' | 'mod'\n\narith_exp_op:\n\narith_pre_op:\n '+' | '-' | '#'\n\nselect_op:\neqns: /* empty */ | \n eqns_symbol ':' eqn_decls ';' | \n eqns_symbol ':' {EnterEqns();} \n var_symbol var_decls ';' eqn_decls ';' | \n eqns_symbol error ';' \n\neqn_decls: \n eqn_decl | \n eqn_decls ';' eqn_decl \n\neqn_decl: \n lhs '==' rhs ; \n\nlhs: \n functional_expr \n ; \n\nrhs: \n expr \n ; \n\nax_decls: \n ax_decl | \n ax_decls ';' ax_decl \n\nax_decl: \n expr \n\nvar_name_list: \n var_name | \n var_name_list ',' var_name \n\nvar_name: \n name \n\nobj_expr: \n obj_atom \n | \n '[' '[' ]' | \n '[' obj_expr_list ']' \n\nobj_expr_list: \n obj_expr |\nobj_expr_list ',', obj_expr\n\nobj_atom:\n \"double-quoted string of printable ASCII characters\" | \"zero or more digits\" | \"zero or more digits with optional fraction and exponent\" | 'nil' | name\n\nname:\n \"letter followed by zero or more letters or digits\"\n\nattr_defs\n 'define' op_symbol 'attribute' ident_list | 'define' 'attribute' ident_list ;\n\nident_list:\n var_name_list\n\nobj_symbol:\n 'object' | 'obj'\n\nop_symbol:\n 'operation' | 'op'\n\nparts_symbol:\n 'components' | 'parts'\n\nops_symbol:\n 'operations' | 'ops'\n\nin_symbol:\n 'inputs' | 'in'\n\nout_symbol:\n 'outputs' | 'out'\n\nvar_symbol:\n 'variable' | 'var'\nAppendix E: RSL Tools\n\nThere are two major RSL tool interfaces:\n\n1. The RSL Language Browser\n2. The Dataflow Editor/Browser\n\nThese interfaces provide two different views of an RSL requirements specification. The browser view is the base; it contains a complete document with all details of the objects and operations. The dataflow view is a specialized, operation-centered depiction of a specification that shows how specified operations relate in terms of inputs and outputs. The dataflow display is convenient for viewing the \"big picture\" of a specification, with more formal lower-level details abstracted out.\n\nSections 2 and 3 of this manual describe the user-level interface to the two tools.\n\nE.1. RSL Browser\n\nFigure 1 shows the interface display to the browser. As shown in the Figure, the browser has two display windows: the Top-Level Browser and Browser Manager. Browser Manager is used to manipulate a collection of specification modules. Specification modules are displayed using graphics windows and Top-Level Browser windows.\n\nE.1.1. The Browser Manager\n\nThe Browser Manager manages a collection of specification views, both text and graphical. The display consists of a collection of menus and two scrollable windows that describe the modules currently available within the Browser Manager. Both windows list the modules that have been loaded. The first window shows the operations available within each module as an indented list following the module name; the second window displays the objects available within each module similarly. These are the Browser Manager's navigation windows.\n\nThe Browser Manager has seven top-level menus: File, Edit, Objects, Operations, Module, Browse, and Options. These menus provide functions to load, unload, display, and navigate between modules.\n\nE.1.1.1. File Menu\n\nThe File Menu is used to load modules into the system.\n\nE.1.1.2. Object and Operation Menus\n\nThe Object and Operation Menus are used to permit the user to display objects and operation specifications that are defined within modules. As each module is loaded by the Browser Manager, the names of its component objects and operations are inserted into the Object and Operation menus. By selecting one of these names, the user can display the corresponding specification that defines the item.\n\nE.1.1.3. Module Menu\n\nThe Module Menu lists all of the modules that have been loaded into the browser manager. A checkbox is displayed to the left of each module name. This checkbox is used to control the visibility of the objects and operations of the module within the Browser Manager’s Object, Operation, and navigation windows. If this checkbox is checked, then the objects and\noperations are visible within both the menus and the windows. If the checkbox is empty, only the module name is listed within the navigation windows.\n\nE.1.1.4. Options Menu\n\nThe Options Menu lists a number of variables that permit the user to modify the navigation and display appearance of the modules managed by the *Browser Manager*.\n\nE.1.2. The Top-Level Browser\n\nWhen the *Browser Manager* opens a text browser for a given file the specification is parsed\n\n---\n\n1 Files may contain more than one module\nand displayed in a browser window. Browser windows are made up of a scrollable text window and a menu bar. The text window contains all of the objects and operations described in the specification. Initially, hyperlinks are created for these objects and operations, so that each is connected to the object or operation immediately preceding and following it, as well as to the first and last object or operation within the file. The user may also create customized links between semantically linked objects and operations either within the same module, or across module boundaries.\n\nThe following subsections describe the functions provided by the browser window. These functions are found in the following browser menus: File, Objects, Operations, Track, and Hyperlink.\n\nE.1.2.1. File Commands\n\nThe File menu lists the following commands: Open, Save, SaveAs, Quit. The first three commands permit the user to save and restore customized links between objects and operations.\n\nTo load a previously saved collection of custom hyperlinks, the user selects Open from the File menu. A dialog box will then appear, listing all of the files within the current directory and providing an editable string giving the pathname of the current directory. The user may then either click on a file name given in the window, or edit the string to name the desired file. If the user then clicks on the button labeled OK, the browser will load the links described within the selected file.\n\nThe Save and SaveAs functions are used to store custom hyperlinks for later use. The Save function stores the hyperlink description in a file named file.hlinks, where file is the name of the file containing the specification within the browser window. The SaveAs function permits the user to select a different name for the hyperlink file.\n\nThe Quit function deletes the browser window.\n\nE.1.2.2. Object, Operation, and Track\n\nIn order to make locating objects and operations more convenient, the menus Object, Operation, and Track have been provided. The Object menu contains an alphabetical list of each object contained within the browser window. If the user selects one of these objects, the text display will be scrolled to display the definition of the object, and the object name is highlighted. Similarly, the Operation menu may be used to quickly locate operations within the browser window.\n\nThe Track menu contains two functions, Track Operation and Track Object. When objects and operations are defined within a module, their definitions contain a list of component objects and the operations they provide. If the user selects one of these constituent object or operation names from within the larger definition, the browser module's text window will be scrolled until the definition corresponding to the selected name appears.\n\nE.1.2.3. Hyperlinks\n\nThe Hyperlinks menu is used to permit the user to move easily between related items within the browser window. This menu provides the following functions: Create, Show, Goto, \n\n---\n\n\\(^2\\) Selection of a name is performed by placing the cursor marker within the name, or by selecting all or part of the name in the usual fashion\n\n64\nNext, Prev, First, Last.\n\nThe user is permitted to create customized hyperlinks between objects and operations. This is done by selecting the Create function. When Create is selected, the Top-Level Browser displays a dialog box containing four labeled slots: Module, Name, Source, Destination. The Module slot indicates the module containing the Destination portion of the custom link. By default, this module is the same as that of the module displayed within the browser window, but the user may optionally use this slot to indicate a module stored within a different browser window. The Name slot names the custom hyperlink that is being created. By default, the name is CustomXX, where XX is a unique number; however, the user is free to modify this name to a more mnemonic name indicating the nature of the relation between source and destination. Source and Destination slots refer to the objects or operations to be connected.\n\nThe Show Menu is provided in order to permit the user to see all of the different hyperlinks having a selected object or operation as their source. (Recall that all objects and operations minimally have links to preceding, following, first, and last items within the browser window). When Show is selected, the Top-Level Browser displays these links, listing the name, type (i.e., standard or custom), and destination of each. The four mandatory links are shown first.\n\nThe Goto Menu permits the user to traverse a named link. When Goto is selected from the Hyperlink Menu, a dialog box is displayed. The user follows a link by typing the link’s name within the slot provided.\n\nThe last four functions provided by the Hyperlink Menu permit the user to follow the four mandatory links easily. Next moves the user to the definition of the currently selected object or operation’s succeeding node, Prev moves the user to the definition of previous node, First moves the user to the first node defined within the browser, and Last moves the user to the last node defined within the browser.\n\nE.2. Dataflow Editor\n\nFigure 2 shows the interface display to the dataflow tool. The data flow tool allows a wide variety of data flow diagrams to be developed and edited quickly. A wide variety of diagrams can be created because the developer is allowed to specify the shape of the nodes in a diagram, can connect nodes with splines instead of straight lines, and can annotate the diagram with graphics and text using a full-feature graphics editor provided. Furthermore, diagrams can be organized into levels because multiple display canvases can be opened, and \"next level\" links can be made in various ways between \"parent\" nodes and canvases containing nodes at the next level of detail.\n\nDiagrams can be developed and edited quickly due to special drawing features specifically suited to graph drawing. When connections are made between nodes, the system automatically beautifies the connections by moving the endpoint(s) to the edge of the node(s) to which they are connected. When a node is moved, the splines connected to the node are automatically modified so that they remain connected to the node. Also, the connector labels are moved so that they retain their relationship to the connections that they label.\n\nAs shown in the preceding Figure, the data flow editing is integrated with a graphics editor, that allows a developer to annotate data flow diagrams with graphics and text. The graphics editor contains a graphics palette and a menu bar, which provide standard graphical editing capabilities.\n\nThe data flow palette contains three functions that are initiated by clicking the mouse on the display canvas, and five operations that are part of a pull-down menu at the bottom of the palette.\nFigure 2: Dataflow Tool Interface.\nE.2.1. Data Flow Functions\n\nThere is a current function associated with the data flow palette. The current function is always highlighted, and can be changed by clicking the mouse on an unhighlighted palette item. Following is a brief description of each of the functions.\n\nE.2.1.1. NewNode\n\nTo create a new node, the developer makes sure that \"New Node\" is highlighted in the data flow palette, and then clicks anywhere on a display canvas. A node appears containing a text cursor that prompts the developer to enter a name for the node. If the developer does not enter a name (i.e., he performs some other operation) a default name is given to the node. The developer can later edit the name using the \"Text Edit\" function found in the drawing palette. He can also relocate the name within the node, but the system will not allow the name to be moved outside of the boundaries of the node.\n\nE.2.1.2. Connect Nodes\n\nTo connect two nodes, the developer makes sure that \"Connect Node\" is highlighted in the data flow palette, and clicks the left mouse button within the boundaries of a node. He then drags the mouse, with the left button down, and releases the left button at the location of each point desired in the connecting spline. When the final point of the spline is defined, the developer clicks the middle mouse button. This final point must be within the boundaries of a node, or the spline disappears. If a valid connector has been drawn, a cursor appears prompting the developer to enter a name for the connector. As with the \"New Node\" function, if no name is entered, a default name is generated for the connector.\n\nE.2.1.3. In/Out Connector\n\nTo define an input or output connector for a node, the developer makes sure that \"In/Out\" is highlighted in the data flow palette, and clicks the left mouse button on the display canvas. He then draws a spline in the same manner as with the \"Connect Nodes\" function. However, the \"In/Out\" function requires that exactly one of the endpoints of the spline be within the boundaries of a node, not two, and if this requirement is not met the spline will disappear. If a valid connector has been drawn, a cursor appears prompting the developer to enter a name for the connector. As with the \"New Node\" and \"Connect\" functions, if no name is entered, a default name is generated for the connector.\n\nE.2.2. Data Flow Operations\n\nAt the bottom of the user interface palette is a pull-down menu containing data flow operations that do not require mouse gesturing on the display canvas. Some of these operations are dependent on what object is selected on the display canvas. An object can be selected by choosing the \"Select\" function from the graphics palette, and clicking on an object. Black \"handles\" surround a selected object, as in a standard drawing editor.\n\nE.2.2.1. New Level\n\nThe \"New Level\" operation opens a new display canvas and allows the developer to locate the canvas on the screen. If a node is selected in the original display canvas, a virtual \"next level\" connection is made between that node and the new canvas. Next level connections allow users to traverse through a multiple-canvas diagram in a hierarchical manner.\nE.2.2.2. Levelize\n\nWhen a developer feels a display canvas is becoming too crowded, he can use the \"Levelize\" command to move a group of nodes and connectors to another canvas at the next level of detail. When \"Levelize\" is chosen, a new canvas is opened, and all selected nodes and connectors on the original canvas are moved to the new canvas. The transplanted nodes are replaced by a single \"parent\" node, and the developer is prompted to enter a name for the parent. All nodes still on the original canvas that were connected to transplanted objects are connected to the parent node. A next level connection is automatically made between the parent node and the new canvas.\n\nE.2.2.3. Goto Next Level\n\nA developer can traverse a next level connection by selecting the \"Goto Next Level\" operation. When this operation is performed, the system checks the next level connection of the node selected on the display canvas. If this next level connection exists, the canvas containing the next level of data flow is mapped on the screen (if necessary), deiconified (if necessary), and raised to the forefront of the screen.\n\nE.2.2.4. Set Next Level\n\nThe \"Set Next Level\" command allows the developer to explicitly set the next level connection of the object selected on the display. When this operation is chosen, a dialog box pops up prompting the developer to enter the name of the canvas that should be connected to the selected object.\n\nE.2.2.5. Set Default Node\n\nA developer can change the shape of the node that is created with future \"New Node\" commands by drawing a graphic using the drawing tools in the graphics palette, selecting the object using the \"Select\" function of the graphics palette, and then choosing the \"Set Default Node\" command. When this operation is chosen, the system copies the internal representation of the object selected on the display and uses it as the shape of all new nodes created. This default object can be a rectangle, an ellipse, or a polygon, and can have any size and color.\n\nE.2.3. Saving and Loading Diagrams\n\nThe \"file\" menu found in the menu bar provides commands that allow a developer to save and load data flow diagrams. Diagrams can be saved in two formats: a textual format that can be reloaded into the data flow tool, or in postscript format for printing purposes. The \"Save Interface\" command saves files for reloading, the \"Load Interface\" command loads such files back into the system, and the \"Save to Postscript\" command creates a postscript file. Postscript files can also be loaded into the system, but the document loaded will be raw graphics, with no special relationship between nodes and connectors."}}},{"rowIdx":252,"cells":{"id":{"kind":"string","value":"65692714b711302c529267b5a2f96ce1544a0df9"},"text":{"kind":"string","value":"Design of the Certifying Programming Language\n— Vero\n\nXinyu Feng\nEmail:xinyu.feng@yale.edu\n\nJune 3, 2004\nContents\n\n1 Introduction ............................................. 5\n 1.1 The Certifying Programming Language ................. 5\n 1.2 Related Work ....................................... 7\n 1.3 Design of Vero — Overview ........................... 8\n 1.4 Contributions of My Work ............................. 8\n\n2 The Internal Language ................................. 11\n 2.1 The Proof Language — PL ............................. 11\n 2.1.1 The PL Abstract Syntax ......................... 11\n 2.1.2 Formalization .................................. 12\n 2.1.3 Some Built-in PL Terms ......................... 13\n 2.2 The Computation Language — CL ...................... 14\n 2.2.1 The Abstract Syntax ............................ 14\n 2.2.2 Static Semantics ................................ 15\n 2.2.3 Dynamic Semantics .............................. 24\n 2.3 Expressive Power of CL ............................. 25\n 2.3.1 Higher-Kinded Recursive Types ................. 25\n 2.3.2 Guarded Recursive Type Constructors .......... 28\n\n3 The Vero Surface Language ............................ 37\n 3.1 Lexical Conventions .................................. 37\n 3.1.1 Notation Conventions ............................ 37\n 3.1.2 White Space .................................... 37\n 3.1.3 Comments ....................................... 37\n 3.1.4 Identifiers and Operators ...................... 37\n 3.1.5 Literals ........................................ 38\n 3.2 Syntax .............................................. 40\n 3.3 Sample Vero Programs ................................ 43\n 3.3.1 Proof Terms .................................... 43\n 3.3.2 CL Programs .................................... 47\n\n4 Implementation ....................................... 49\n 4.1 Implementing a PTS-like type system .................. 49\n 4.2 Suspension-based lambda encoding ..................... 51\n4.3 Hash-consing and memoization \t52\n4.4 Other issues to worked on \t52\n\n5 Conclusion and Future Work \t55\n\nA Type Safety of CL \t61\nChapter 1\n\nIntroduction\n\n1.1 The Certifying Programming Language\n\nThe idea of Proof-carrying code (PCC) [NL96, App01] allows a code producer to provide a machine-language program to a host, along with a formal proof of its safety. The proof can be mechanically checked by the host; the producer need not be trusted because a valid proof is incontrovertible evidence of safety. Here we propose a more general concept of certified program, which is a piece of code together with a proof that the code satisfies a given specification. It is more general than PCC because the code can be at any level, rather than low-level machine-language code; and the specification can be complex invariants and more advanced properties than safety property.\n\nTo implement the idea of certified program, we need tools to help us generate proofs about properties of programs, which include transforming unsafe programs to safe ones with proofs of the safety, compiling a certified high-level program down to certified binary programs, optimizing a certified program to get more efficient, but still certified software. Certifying Programming Language (CPL) is intended to be such a tool, which serves as a meta-language to write transformation tools for certified programs. Such a language should be able to represent the formal systems used to verify programs written in specific term languages, to reasoning about the encoding of the formal systems, and to analyse and manipulate the program and the proof terms.\n\nThere are a large number of formal verification frameworks are used these days, which range from type systems, Floyd-Hoare logic [Flo67, Hoa69], separation logic [Rey02], to TLA- or assumption-guarantee-based reasoning (of concurrent programs) [Lam94, Jon83]; each has been applied to different languages and has been very successful in its own domain. It is clear that there is no single framework that would fit all purposes. To support them all, we need incorporate in CPL a very expressive meta-logical framework (MLF). Each term language, whether it is a typed assembly language or a high-level language with Hoare-logic assertions, is implemented in CPL by first encoding the underlying\ndomain logic in MLF. The meta theory of each formal system used to verify these term languages can be verified in MLF.\n\nOn the other hand, to support the development of program transformation tools of the term language, such as certifying compilers, optimizers, etc., the CPL should support general-purpose programming idioms, e.g., side-effects, non-termination, exception handler, IO. Therefore the term languages can be represented in CPL by datatype definition, and the transforming tools is written as regular CPL programs. CPL type definitions can be indexed by MLF objects to ensure that the implementation of the term language accurately follows the underlying formal logic. Type checking for a term program can be done by simply checking its encoding in CPL (using the MLF and CPL checker).\n\nProgramming with certified binaries. To make the design of CPL more concrete, we give a quick overview on the key ideas. CPL provides first-class support to both general purpose data values and MLF objects; together they form another first-class structure called certified binaries [SSTP02]. A certified binary $S$ is a triple $(a, A, v)$ that consists of (1) an MLF term $a$ of type $d$ (where $d$ is an MLF representation type) (2) an MLF proof $A$ of $P(a)$ (where $P$ is a predicate on elements of type $d$), and (3) a CPL value $v$ of type $D$ (where $D$ is a CPL data type). The connection between $a$ and $v$ can be established by defining $D$ as a type indexed over terms of type $d$ [XP99, XCC03].\n\nFor example, we use $\\text{Nat}$ to denote the natural number represented in MLF, and $\\text{Prime}$ for the predicate that asserts an element of $\\text{Nat}$ as a prime number. We introduce a singleton type constructor $s_{\\text{Nat}}$: given an MLF term $n$ of type $\\text{Nat}$, if a computation value $v$ has type $s_{\\text{Nat}}[n]$, then $v$ denotes the natural number represented by $n$. A certified binary for a prime number contains three parts: an MLF term $n$ of type $\\text{Nat}$, a proof for the proposition $\\text{Prime}(n)$, and a CPL computation value of type $s_{\\text{Nat}}[n]$. We can pack it up into an existential package and make it a first-class value with type:\n\n$$\\exists n : \\text{Nat}. \\exists t : \\text{Prime}(n). s_{\\text{Nat}}[n].$$\n\nNotice that MLF objects are never directly dependent on CPL computation terms; in fact, because of this strong separation, a certified prime number package can still be implemented as a single integer at runtime.\n\nWe can also build certified binaries for programs that involve effects. Suppose $F$ is a CPL computation function that takes an integer as an argument and returns another as the result, and assume that $F$ may contain side-effects and may not always terminate. We can still reason about $F$ by first building a model $f$ inside MLF and then insist that $F$ has type:\n\n$$\\forall n : \\text{Nat}. \\ s_{\\text{Nat}}[n] \\to s_{\\text{Nat}}[f(n)]$$\n\nHere $f$ is an MLF function (which is always total) of type $\\text{Nat} \\to \\text{Nat}$. The fact that $F$ has the above type does not mean that $F$ cannot have effects, rather, it only requires that the return value of $F$ (if it does terminate) is always equal to what is specified by the model $f$. \n1.2. RELATED WORK\n\nWe can show that \\( F \\) is a “certifying” implementation that always maps a prime number into another prime number by building an MLF proof object (for its model \\( f \\)) of type \\( \\forall t : \\text{Nat}. \\text{Prime}(t) \\Rightarrow \\text{Prime}(f(t)) \\) where \\( \\Rightarrow \\) denotes logical implication.\n\nOf course, finding a model is often difficult, but in many cases we do not need to prove the partial correctness of \\( F \\). For example, assume \\text{int} denotes the standard integer type. A function \\( F \\) of type:\n\n\\[\n\\text{int} \\rightarrow \\exists n : \\text{Nat}. \\exists t : \\text{Prime}(n) . s_{\\text{Nat}}[n].\n\\]\n\nwould already guarantee that the return value (if it returns) is always a prime number.\n\nThe above definitions can be easily generalized to more complex representation types. For example, if \\( d \\) is an MLF term representing a target programming language (TPL) and \\( D \\) is a CPL type definition (indexed over terms of type \\( d \\)), and suppose \\( P \\) is a security predicate showing that a term of \\( d \\) satisfies a particular safety policy, a certified TPL binary would simply consist of an MLF term \\( a \\) of type \\( d \\), an MLF proof of type \\( P(a) \\) showing that \\( a \\) is secure, and a CPL term (representing the actual TPL program) of type \\( D(a) \\). A “certifying” security rewriting function (implemented in CPL) is one that must have return type \\( \\exists a : d. \\exists t : P(a) . D(d) \\), that is, its implementation must also construct the proof certificate \\( P(a) \\) while inserting all the security checks.\n\n1.2 Related Work\n\nAlthough quite similar to the idea of PCC, the concept of certified program is more general, as explained in Section 1.1. There are other differences between the PCC framework and the Certifying Programming Language. First, PCC relies on a rather ad hoc process that uses external tools (e.g., meta-logical frameworks, verification condition generators) to construct proof certificates; a certifying programming language treats certified code as first-class citizens and provides direct support for creating and manipulating proof certificates. Second, existing PCC systems use a certifying compiler [CLN’00] to generate the object code and the safety certificate; the certificate can be checked by an external PCC checker, but there is no guarantee that the certifying compiler always generate a valid certificate. CPL fills this missing link by having both the code and the certificate be programmed in the same language—the validity of the certificate can be guaranteed by the CPL type system.\n\nThe research on CPL is based on the recent work on certified binaries (CB) by Shao, Saha, Trifonov and Papaspyrou [SSTP02], and the LTT system by Cray and Vanderwaart [CV02]. CB and LTT are mainly designed for compiler intermediate languages but the key ideas can be applied to the design of certifying programming languages. Both CB and LTT use singleton (or indexed) types [XP99] to support dependent types while maintaining a phase distinction between compile-time type checking and runtime evaluation. CB incorporates\nthe calculus of inductive constructions (used by Coq) [Pan98] while LTT uses the LF logical framework [HHP93].\n\n1.3 Design of Vero — Overview\n\nThe language Vero is our first attempt to the design of a CPL. The name “vero” is a Latin word, which means “in truth, indeed, to be sure”. It reflects the objective of designing such a language.\n\nThe design of Vero is based on previous work of CB and LTT. Vero integrates the Calculus of Inductive Constructions (CIC) as the proof language (PL), with a general-purpose computation language (CL). Unlike CB, we have a separate type system for the computation language, while in CB it is inductively as part of the proof language. Such a design is quite similar to that of LTT. However, we use CIC instead of LF as the proof language, which is different with LTT.\n\nBoth the PL and the CL of Vero are explicitly typed language, that is because at present we put more emphasis on the expressiveness of our language, rather than user friendliness. Since we do not have to worry about decidable type inference, we have a very powerful type system for the computation language CL, which is much more general than that of SML. In addition to the core formulation presented in CB and LTT, we add the general recursive type constructor and the sum type to the type system of CL. Using the technique proposed by Collins and Shao [CS92], we have a natural way to define higher kinded recursive types. Also, with the introduction of the general recursive constructor and the sum type, we can easily simulate the guarded recursive datatype constructors proposed by Xi, Chen and Chen [XCC03].\n\nAnother difference between Vero and the previous work of CB and LTT is that Vero, as a CPL, is a surface language to be used directly by programmers, while CB and LTT are compiler intermediate languages. Therefore, in addition to the design of the internal language, we need to design the concrete syntax of the surface language of Vero.\n\nThe current version of Vero is just a prototype implementation. To focus on the implementation of such a powerful type system, we omitted a lot of orthogonal (but very important) issues, e.g. side-effects, exception handling, the module system, general pattern matching, and IO. All these issues will be researched in our future work.\n\n1.4 Contributions of My Work\n\nThis report presents the design and implementation of the language Vero, the work of my 690 project. The project was carried out from January 2004 to April 2004 (in the fall of 2003 I was working on a different project, i.e. type checking BIOS code). The main contributions of my work are as follows:\n\n1. I designed a richly typed internal language of Vero and formulated its static and dynamic semantics. The work is presented in Section 2.1 and\n2.2 of Chapter 2. The type safety proof for CL is given in Appendix A.\n\n2. I showed that by inductively define the Leibniz equality in our PL, we can simulate the guarded recursive datatype constructors proposed in [XCC03]. Such an ability allows us to have a uniform way to define the singleton datatypes indexed over the proof terms. I showed that the built-in singleton type $s_{\\text{Bool}}$ in CB can be defined, and the complicated form of the if expression can be simulated using the more general case expression (see Section 2.3). Also I discussed some possible approaches to automatically generate the indexed type definition, given an inductive PL type.\n\n3. I designed the concrete syntax of the Vero core language and presented some sample Vero programs, which is given in Chapter 3.\n\n4. I implemented a type checker for Vero. Although the implementation is based on previous work of FLINT group [SLM98, Sah02], the fact that Vero is a surface language instead of a compiler intermediate language added extra complexity to the implementation; one example is we need provide helpful error messages for programmers to position the error. I also tried to improve the efficiency by memoizing more information than the previous implementation [SLM98, Sah02], although we have not test it over any benchmarks. The implementation is explained in detail in Chapter 4.\nChapter 2\n\nThe Internal Language\n\nIn this chapter we present the design of the internal language of Vero, which consists of a Proof Language (PL) used as a meta-logical framework, and a general purpose Computation Language (CL). In Section 2.3 we also show two important features of CL, i.e. the support of higher-kindred recursive types and guarded recursive type constructors.\n\n2.1 The Proof Language — PL\n\nWe use the same type language proposed in [SSTP02], which is a minor revision of the Calculus of Inductive Constructions used in Coq [Tea03].\n\n2.1.1 The PL Abstract Syntax\n\nThe proof language is in the form of PTS plus inductive definitions. Figure 2.1 shows the syntax of PL.\n\n\\[\n\\text{sort } s ::= \\text{Prop} | \\text{Type} | \\text{Ext} \\\\\n\\text{ptm } A, B ::= s | X | X \\cdot B | A \\cdot B | \\Pi X : A.B | \\text{Ind}(X : B)\\{\\vec{A}\\} | \\text{Ctor}(i, A) \\\\\n| \\text{Elim}[A', B'](A)\\{\\vec{B}\\}\n\\]\n\nFigure 2.1: Syntax of the Proof Language\n\nIn addition to the standard features of PTS, PL also provides a general mechanism of inductive definitions [Pau93]. The term \\text{Ind}(X : B)\\{\\vec{A}\\} introduces an inductive type \\(X\\) with constructors whose types are listed in \\(\\vec{A}\\). Here \\(X\\) must only occur “positively” inside each \\(A_i\\) (see [Pau93] for the formal definition of positivity). The term \\text{Ctor}(i, A) refers to the \\(i\\)-th constructor in an inductive\nCHAPTER 2. THE INTERNAL LANGUAGE\n\ntype $A$. For presentation, we will use a more friendly syntax in the rest of this paper. An inductive type $I = \\text{Ind}(X : B)\\{\\bar{A}\\}$ will be written as:\n\n\\[\n\\text{Inductive } I : B := c_1 : [I/X]A_1 \\\\\n| c_2 : [I/X]A_2 \\\\\n| .. \\\\\n| c_n : [I/X]A_n\n\\]\n\nWe give an explicit name $c_i$ to each constructor, so $c_i$ is just an abbreviation of $\\text{Ctor}(i, I)$.\n\nPL provides iterators to support primitive recursion on inductive types. The eliminator $\\text{Elim}[A', B'](A)(\\bar{B})$ takes a term $A$ of inductive type $A'$, performs the iterative operation specified by $\\bar{B}$ (which contains a branch for each constructor of $A'$), and returns a term of type $B'[A]$ (dependent elimination) or $B'$ (non dependent elimination) as the result.\n\nFigure 2.2 gives a few examples of inductive definitions including the inductive types $\\text{Bool}$ and $\\text{Nat}$. The elimination for $\\text{Nat}$ takes the following form $\\text{Elim}[\\text{Nat}, k](n)\\{f_1 : f_2\\}$. Here, $k$ is a dependent type with kind $\\text{Nat} \\rightarrow \\text{Prop}$; $n$ is the argument which has type $\\text{Nat}$. The term in the zero branch, $f_1$, has type $k$. The term in the succ branch, $f_2$, has type $\\text{Nat} \\rightarrow k n \\rightarrow k n$. PL uses the $\\iota$-reduction to perform the iterator operation. For example, the two $\\iota$-reduction rules for $\\text{Nat}$ work as follows:\n\n\\[\n\\text{Elim}[\\text{Nat}, k](\\text{zero})\\{f_1 : f_2\\} \\rightarrow, f_1\n\\]\n\\[\n\\text{Elim}[\\text{Nat}, k](\\text{succ } n')\\{f_1 : f_2\\} \\rightarrow, f_2 n' (\\text{Elim}[\\text{Nat}, k](n')\\{f_1 : f_2\\})\n\\]\n\nHere we omitted the general $\\iota$-reduction rule, which is formally defined in [SSTP02].\n\n2.1.2 Formalization\n\nWe define the proof context $\\Gamma$ as a list of bindings from variables to pseudo terms, which has the following syntax.\n\n\\[\n\\text{ctxt } \\Gamma ::= \\cdot | \\Gamma, X : A\n\\]\n\nPL has the following PTS specification which we will use to derive its typing rules:\n\n\\[\n\\begin{align*}\n\\mathcal{S} &= \\{\\text{Prop}, \\text{Type}, \\text{Ext}\\} \\\\\n\\mathcal{A} &= \\{\\text{Prop} : \\text{Type}, \\text{Type} : \\text{Ext}\\} \\\\\n\\mathcal{R} &= \\{(\\text{Prop}, \\text{Prop}), (\\text{Type}, \\text{Prop}), (\\text{Ext}, \\text{Prop}), (\\text{Prop}, \\text{Type}), (\\text{Type}, \\text{Type})\\}\n\\end{align*}\n\\]\n\nThe typing judgement for PL takes the form of $\\Gamma \\vdash A : B$. Since our PL is borrowed untouched from the TL of CB [SSTP02], we omit the typing rules for PL, which can be found in the Appendix of [SSTP02].\n\nProposition 2.1 and 2.2 are used in the type safety proof of CL in Section 2.2. They can be proved by simple induction on the PL typing rules.\n2.1. **THE PROOF LANGUAGE — PL**\n\n**Proposition 2.1** If $\\Gamma_1, X : B, \\Gamma_2 \\vdash \\text{Prop} : \\text{Type}$ and $\\Gamma_1 \\vdash A : B$, then $\\Gamma_1, [A/X] \\Gamma_2 \\vdash \\text{Prop} : \\text{Type}$.\n\n**Proposition 2.2 (Proof Substitution)** If $\\Gamma_1, X : B', \\Gamma_2 \\vdash A' : B'$, then $\\Gamma_1, [A'/X] \\Gamma_2 \\vdash [A'/X] A : [A'/X] B$\n\n### 2.1.3 Some Built-in PL Terms\n\nIn Figure 2.2, we present some PL terms, which are used in the type checking of the computation language in the following sections.\n\n- **Inductive Bool** : Prop := true : Bool\n | false : Bool\n\n- **Inductive Nat** : Prop := zero : Nat\n | succ : Nat → Nat\n\n- **plus** : Nat → Nat → Nat\n\n - plus(zero) = $\\lambda t : \\text{Nat}. t$\n - plus(succ $t$) = $\\lambda t' : \\text{Nat}. \\text{succ} ((\\text{plus} \\ t) \\ t')$\n\n- **ifez** : Nat → (Π $k : \\text{Prop}$. k → (Nat → k) → k)\n\n - ifez(zero) = $\\lambda k : \\text{Prop}. \\lambda t_1 : k. \\lambda t_2 : \\text{Nat} \\rightarrow k. t_1$\n - ifez(succ $t$) = $\\lambda k : \\text{Prop}. \\lambda t_1 : k. \\lambda t_2 : \\text{Nat} \\rightarrow k. t_2 \\ t$\n\n- **le** : Nat → Nat → Bool\n\n - le(zero) = $\\lambda t : \\text{Nat}. \\text{true}$\n - le(succ $t$) = $\\lambda t' : \\text{Nat}. \\text{ifez} \\ t' \\ \\text{Bool} \\ (\\text{le} \\ t)$\n\n- **lt** : Nat → Nat → Bool\n\n - $lt = \\lambda t : \\text{Nat}. \\text{le} \\ (\\text{succ} \\ t)$\n\n- **Cond** : Bool → Prop → Prop → Prop\n\n - Cond(true) = $\\lambda k_1 : \\text{Prop}. \\lambda k_2 : \\text{Prop}. k_1$\n - Cond(false) = $\\lambda k_1 : \\text{Prop}. \\lambda k_2 : \\text{Prop}. k_2$\n\n*Figure 2.2: Some PL terms*\n\nIn our examples, we take the liberty of using the pattern-matching syntax (as in ML) to express the iterator operations, but they can be easily converted back to the Elim form. In addition to the inductive type Nat and Bool, plus is a function which calculates the sum of two natural numbers. The function ifez behaves like a switch statement: if its argument is zero, it returns a function that selects the first branch; otherwise, the result takes the second branch and applies it to the predecessor of the argument. The function le evaluates to\ntrue if its first argument is less than or equal to the second. The function \\( \\text{lt} \\) performs the less-than comparison. The definition of function \\( \\text{Cond} \\) implements a conditional with result at the type level.\n\nIn the following sections, we use the meta-function \\( \\Downarrow \\) to map natural numbers \\( n \\in \\mathbb{N} \\) to their representations as proof terms. It is defined inductively by \\( \\overline{0} = \\text{zero} \\) and \\( n+1 = \\text{succ} \\overline{n} \\), so \\( \\Gamma \\vdash \\overline{n} : \\text{Nat} \\) holds for all valid \\( \\Gamma \\) and \\( n \\in \\mathbb{N} \\).\n\n### 2.2 The Computation Language — CL\n\nThe computation language is an explicitly typed, general purpose programming language. In this report we just define the core language and we do not have a module system. Other language idioms like side-effects, exception handler and IO are orthogonal to our focus on an expressive type system. They are omitted to simplify the formulation.\n\n#### 2.2.1 The Abstract Syntax\n\nFigure 2.3 gives the syntax of the internal language of \\( \\text{vero} \\).\n\n\\[\n\\begin{align*}\n\\text{kind} \\quad \\kappa & ::= \\Omega \\mid \\kappa_1 \\rightarrow \\kappa_2 \\mid \\Pi X : A. \\kappa \\mid \\kappa_1 \\oplus \\kappa_2 \\\\\n\\text{typ} \\quad \\tau & ::= \\tau \\mid \\text{unit} \\mid \\text{unit}_\\mathbb{N} \\mid \\text{unit}_\\mathbb{B} \\mid \\tau_1 \\rightarrow \\tau_2 \\mid \\forall \\tau : \\kappa. \\tau \\mid \\forall X : A. \\tau \\\\\n& \\quad \\mid \\{ l_1 : \\tau_1, \\ldots, l_n : \\tau_n \\} \\mid \\tau_1 + \\tau_2 \\mid \\mu(\\tau_1, \\tau_2) \\mid \\exists \\tau : \\kappa. \\tau \\mid \\exists X : A. \\tau \\\\\n& \\quad \\mid \\lambda \\tau : X. \\tau \\mid \\tau_1[\\tau_2] \\mid \\Lambda X : A. \\tau \\mid \\tau[A] \\mid \\langle \\tau_1, \\tau_2 \\rangle \\mid \\pi_1 \\tau \\mid \\pi_2 \\tau \\\\\n\\text{fun} \\quad f & ::= \\lambda x : \\tau. e \\mid \\Lambda t : \\kappa. e \\mid \\Lambda X : A. e \\\\\n\\text{exp} \\quad \\pi & ::= x \\mid () \\mid \\prod \\mid e_1 \\text{ aop } e_2 \\mid \\text{ tt } \\mid \\text{ ff } \\mid e_1 \\text{ cop } e_2 \\\\\n& \\quad \\mid \\text{ if } [B, A](e_0, X_1, e_1, X_2, e_2) \\mid \\text{ f } \\mid \\text{ fix } x : \\tau. f \\mid e_1 e_2 \\mid e[\\tau] \\mid e[A] \\\\\n& \\quad \\mid \\{ l_1 = e_1, \\ldots, l_n = e_n \\} \\mid e[d] \\mid \\text{ inj}^0_\\tau e \\mid \\text{ inj}^1_\\tau e \\mid \\text{ case}(e_0, e_1, e_2) \\\\\n& \\quad \\mid \\text{ fold} \\tau e \\mid \\text{ unfold } e \\mid \\langle t = \\tau, e : \\tau' \\rangle \\mid \\langle X = A, e : \\tau \\rangle \\mid \\text{ let } x = e_1 \\text{ in } e_2 \\\\\n& \\quad \\mid \\text{ let } t = \\tau \\text{ in } e \\mid \\text{ let } X = A \\text{ in } e \\mid \\text{ let } \\langle t, x \\rangle = e_1 \\text{ in } e_2 \\\\\n& \\quad \\mid \\text{ let } (X, x) = e_1 \\text{ in } e_2 \\\\\n\\text{arith} \\quad \\text{ aop } ::= + \\mid \\ldots \\\\\n\\text{cmp} \\quad \\text{ cop } ::= < \\mid \\ldots \\\\\n\\text{val} \\quad v ::= () \\mid \\prod \\mid \\text{ tt } \\mid \\text{ ff } \\mid \\lambda x : \\tau. e \\mid \\Lambda t : \\kappa. e \\mid \\Lambda X : A. e \\mid \\{ l_1 = v_1, \\ldots, l_n = v_n \\} \\\\\n& \\quad \\mid \\text{ inj}^0_\\tau v \\mid \\text{ inj}^1_\\tau v \\mid \\text{ fold} \\tau v \\mid \\langle t = \\tau, v : \\tau' \\rangle \\mid \\langle X = A, v : \\tau \\rangle \\\\\n\\end{align*}\n\\]\n\nFigure 2.3: Syntax of the Computation Language\n2.2. THE COMPUTATION LANGUAGE — CL\n\n2.2.2 Static Semantics\n\nThe type context $\\Delta$ is defined as a list of bindings from type variables to kinds, and the term context $\\Sigma$ is a list of bindings from expression variables to types. They have the following syntax:\n\n\\[\n\\begin{align*}\ntyctx & \\quad \\Delta ::= \\cdot \\mid \\Delta, t : \\kappa \\\\\ntmctx & \\quad \\Sigma ::= \\cdot \\mid \\Sigma, x : \\tau\n\\end{align*}\n\\]\n\nIn Figure 2.4, we give a summary of the static semantics of the computation language.\n\n\\[\n\\begin{align*}\ntyctx & \\quad \\text{formation} \\quad \\Gamma \\vdash \\Delta \\ ok \\\\\ntmctx & \\quad \\text{formation} \\quad \\Gamma; \\Delta \\vdash \\Sigma \\ ok \\\\\nkind & \\quad \\text{formation} \\quad \\Gamma \\vdash \\kappa \\ kind \\\\\ntype & \\quad \\text{formation} \\quad \\Gamma; \\Delta \\vdash \\tau : \\kappa \\\\\nexpr & \\quad \\text{formation} \\quad \\Gamma; \\Delta; \\Sigma \\vdash e : \\tau\n\\end{align*}\n\\]\n\nFigure 2.4: Judgements\n\nContexts and Kind Formation\n\nFirst we give the kind formation rules and type context formation rules.\n\n\\[\n\\begin{array}{ll}\n\\Gamma \\vdash \\kappa \\ kind & \\\\\n\\hline\n\\Gamma \\vdash \\text{Prop} : \\text{Type} & \\quad \\Gamma \\vdash \\Omega \\ kind \\\\\n\\hline\n\\Gamma \\vdash \\kappa_1 \\ kind \\quad \\Gamma \\vdash \\kappa_2 \\ kind & \\quad \\Gamma \\vdash \\kappa_1 \\rightarrow \\kappa_2 \\ kind \\\\\n\\hline\n\\Gamma \\vdash \\kappa_1 \\ kind \\quad \\Gamma \\vdash \\kappa_2 \\ kind & \\quad \\Gamma, X : A \\vdash \\kappa \\ kind \\\\\n\\hline\n\\Gamma \\vdash \\Pi X : A.\\kappa \\ kind & \\quad \\Gamma \\vdash \\Delta \\ ok \\\\\n\\hline\n\\Gamma \\vdash \\kappa \\ kind & \\quad \\Gamma \\vdash \\kappa \\ kind \\\\\n\\hline\n\\Gamma \\vdash \\Delta \\ ok & \\quad \\Gamma \\vdash \\Delta, t : \\kappa \\ ok \\quad (t \\notin \\text{dom}(\\Delta)) \\\\\n\\hline\n\\Gamma \\vdash \\cdot \\ ok & \\quad \\Gamma \\vdash \\Delta, t : \\kappa \\ ok \\quad (\\text{DEF-T})\n\\end{array}\n\\]\n\nAll types of CL expressions have kind $\\Omega$. The kind $\\kappa_1 \\rightarrow \\kappa_2$ is the kind of higher-order type constructors. Two mutually recursive defined type constructors has the kind $\\kappa_1 \\otimes \\kappa_2$, which will be explained in detail in section 2.3. The kind $\\Pi X : A.\\kappa$ allows us define CL type constructors indexed over PL terms.\nProposition 2.3 and 2.4 are substitution propositions for the kind language.\n\n**Proposition 2.3** If $\\Gamma_1, X : B, \\Gamma_2 \\vdash \\kappa$ kind and $\\Gamma_1 \\vdash A : B$, then $\\Gamma_1, [A/X] \\Gamma_2 \\vdash [A/X]|\\kappa$ kind.\n\n**Proof.** By induction of the derivation of $\\Gamma_1, X : B, \\Gamma_2 \\vdash \\kappa$ kind (Proposition 2.1 is used). □\n\n**Proposition 2.4**\n\n1. If $\\Gamma \\vdash \\Delta, t : \\kappa$ ok, then $\\Gamma \\vdash \\Delta$ ok.\n2. If $\\Gamma_1, X : B, \\Gamma_2 \\vdash \\Delta$ ok and $\\Gamma_1 \\vdash A : B$, then $\\Gamma_1, [A/X] \\Gamma_2 \\vdash [A/X] \\Delta$ ok.\n\n**Proof.** By induction on the derivations of $\\Gamma \\vdash \\Delta_1, t : \\kappa, \\Delta_2$ ok and $\\Gamma_1, X : B, \\Gamma_2 \\vdash \\Delta$ ok respectively (Propositions 2.1 and 2.3 are used to prove 2). □\n\n**Type Formation**\n\nFigure 2.5 show the formations rules of types. Most of the types have standard semantics, except that $s_{\\text{Nat}}$ and $s_{\\text{Bool}}$ are singleton type constructors indexed by PL terms which have type $\\text{Nat}$ and $\\text{Bool}$, respectively. Rule T-ALL1 and T-ALL2 show that we have polymorphism with regard to both CL types and PL terms. The structure type shown in rule T-STR is basically record type: all the fields must have types in kind $\\Omega$, and we do not have dependent.\n\nThe $\\mu$ constructor, together with type tuples $(r_1, r_2)$ and projections, shown in rule T-REC, T-TUP, T-PRJL, and T-PRJR, are used to formulate recursive types, which are explained in detail in Section 2.3.\n\nExistential types shown in rule T-EX1 and T-EX2 give us the power to introduce first-class modules in the system, which will be our future research. However, the existential type $\\exists X : A. \\tau$ also plays an important role to pack the proof terms together with computation terms, which is an essential feature in CL. In Section 2.3 we will show the usage of the existential types.\n\nType functions shown in rule T-FN1 and T-FN2 and corresponding application rules allow us define higher-order type constructors and constructors indexed over PL terms.\nFigure 2.5: Type formation rules\nType Reduction and Equivalence\n\nFirst we give the reducible types by the following rules.\n\n\\[(\\lambda x : k. \\tau)[\\tau'] \\sim_\\iota [\\tau'/x]_\\tau\\] \\hspace{2cm} (TR-\\beta 1)\n\n\\[(\\lambda x : B. \\tau)[A] \\sim_\\iota [A/X]_\\tau\\] \\hspace{2cm} (TR-\\beta 2)\n\n\\[\\lambda x : k. \\tau[x] \\sim_\\iota \\tau \\quad x \\text{ is not free in } \\tau\\] \\hspace{2cm} (TR-\\eta 1)\n\n\\[\\lambda X : A. \\tau[X] \\sim_\\iota \\tau \\quad X \\text{ is not free in } \\tau\\] \\hspace{2cm} (TR-\\eta 2)\n\n\\[\\pi_1(\\tau_1, \\tau_2) \\sim_\\iota \\tau_1\\] \\hspace{2cm} (TR-\\proj 1)\n\n\\[\\pi_2(\\tau_1, \\tau_2) \\sim_\\iota \\tau_2\\] \\hspace{2cm} (TR-\\proj 2)\n\nIn Figure 2.6 we define the type reduction relation \\(\\triangleright_\\iota\\). The \\(\\sim\\) relation shown in rules PRRED-1 to PRRED-4 is the reduction relation between proof terms, which is the union of the \\(\\beta\\)-reduction, \\(\\eta\\)-reduction and \\(\\iota\\)-reduction (denoted by \\(\\sim_\\beta\\), \\(\\sim_\\eta\\), and \\(\\sim_\\iota\\), respectively).\n\nDefinition 2.5 The multi-step reduction relation \\(\\triangleright^*_\\iota\\) and the number of reduction steps is inductively defined in the following way:\n\n- \\(\\tau \\triangleright^*_\\iota \\tau\\) in 0 steps;\n- if \\(\\tau_1 \\triangleright^*_\\iota \\tau_2\\) in \\(k\\) steps, and \\(\\tau_2 \\triangleright_\\iota \\tau_3\\), then \\(\\tau_1 \\triangleright^*_\\iota \\tau_3\\) in \\(k + 1\\) steps.\n\nThe type equivalence relation \\(\\equiv_\\iota\\) is defined by the rules shown in Figure 2.7.\n\nThe following propositions show properties of the type system of CL. Confluence (Proposition 2.7) and strong normalization (Proposition 2.11) are two critical properties for a sound type system. However, there are no short proofs for such properties. Intuitively, our type system has such properties because most of the constructs in the type system are standard and there are literatures that have proved these properties for similar systems. Although we have the \\(\\mu\\) constructor to define recursive types, the folded form and unfolded form are not equivalent types. Also CL types only have dependency on PL terms, which is proved to be confluent and strong normalizing in [Sah02]. The proofs of Proposition 2.7 and 2.11 are omitted here.\n\nProposition 2.6\n\n1. If \\(\\tau_1 =_\\iota \\tau_2\\), for any \\(\\tau\\) and \\(t\\) we have \\([\\tau/t]_\\tau =_i [\\tau/t]_\\tau_1\\).\n\n2. If \\(\\tau_1 =_\\iota \\tau_2\\), for any \\(A\\) and \\(X\\) we have \\([A/X]_\\tau_1 =_i [A/X]_\\tau_2\\).\n\nProof. Obvious... \\(\\Box\\)\n\nProposition 2.7 (Confluence) If \\(\\tau \\triangleright_\\iota \\tau_1\\) and \\(\\tau \\triangleright_\\iota \\tau_2\\), there exists a \\(\\tau'\\) such that \\(\\tau_1 \\triangleright^*_\\iota \\tau'\\) and \\(\\tau_2 \\triangleright^*_\\iota \\tau'\\).\nFigure 2.6: Type reduction relation $\\triangleright_{\\downarrow}$\nProposition 2.8 (Substitution-1) If $\\Gamma; \\Delta,t : \\kappa' \\vdash \\tau : \\kappa$, and $\\Gamma; \\Delta \\vdash \\tau' : \\kappa'$, then $\\Gamma; \\Delta \\vdash [\\tau'/t] \\tau : \\kappa$.\n\nProof sketch. By induction on the derivation of $\\Gamma; \\Delta,t : \\kappa' \\vdash \\tau : \\kappa$ (Proposition 2.4 is used). ∎\n\nProposition 2.9 (Substitution-2) If $\\Gamma_1,X : B,\\Gamma_2;\\Delta \\vdash \\tau : \\kappa$ and $\\Gamma_1 \\vdash A : B$ then $\\Gamma_1,[A/X]\\Gamma_2;[A/X]\\Delta \\vdash [A/X]\\tau : [A/X]\\kappa$.\n\nProof sketch. By induction on the derivation of $\\Gamma_1,X : B,\\Gamma_2;\\Delta \\vdash \\tau : \\kappa$ (Proposition 2.4 is used). ∎\n\nProposition 2.10 (Subject Reduction) If $\\Gamma; \\Delta \\vdash \\tau : \\kappa$ and $\\tau \\triangleright t \\tau'$, we must have $\\Gamma; \\Delta \\vdash \\tau' : \\kappa$.\n\nProof sketch. Here we give the sketch of the proof. First we need to prove the inversion of type formation rules. Then by induction on the $\\leadsto_\\tau$ rules, we prove that if $\\Gamma; \\Delta \\vdash \\tau : \\kappa$ and $\\tau \\leadsto_\\tau \\tau'$, we must have $\\Gamma; \\Delta \\vdash \\tau' : \\kappa$.\n\nFinally by induction on the $\\triangleright_\\tau$ rules we prove the proposition. ∎\n\nProposition 2.11 (Strong Normalization) For any type $\\tau$, if $:\\vdash \\tau : \\kappa$ for some $\\kappa$, then there exists $n \\geq 1$ such that there is no $\\tau'$ such that $\\tau \\triangleright_\\tau \\tau'$ in $n$ steps.\n2.2. THE COMPUTATION LANGUAGE — CL\n\nExpression formation\n\nFirst we give the formation rules of term context.\n\n\\[\n\\frac{}{\\Gamma; \\Delta \\vdash \\Sigma} \\text{ ok}\n\\]\n\n\\[\n\\frac{\\Gamma \\vdash \\Delta \\quad \\Gamma; \\Delta \\vdash \\Sigma}{\\Gamma; \\Delta \\vdash \\Sigma \\text{ ok}}\n\\]\n\n\\[\n\\frac{\\Gamma; \\Delta, x : \\tau \\vdash \\Sigma \\text{ ok}}{\\Gamma; \\Delta \\vdash \\Sigma, x : \\tau \\text{ ok}}\n\\] (INT-TMC)\n\n\\[\n\\frac{\\Gamma; \\Delta \\vdash \\Sigma \\text{ ok} \\quad \\Gamma; \\Delta \\vdash \\tau : \\Omega}{\\Gamma; \\Delta \\vdash \\Sigma, x : \\tau \\text{ ok}}\n\\] (DEF-E) \\( x \\notin \\text{dom(\\Sigma)} \\)\n\n**Proposition 2.12**\n\n1. If \\( \\Gamma; \\Delta \\vdash \\Sigma, x : \\tau \\text{ ok} \\), then \\( \\Gamma; \\Delta \\vdash \\Sigma \\text{ ok} \\).\n\n2. If \\( \\Gamma; \\Delta, t : \\kappa \\vdash \\Sigma \\text{ ok} \\) and \\( \\Gamma; \\Delta \\vdash \\tau : \\kappa \\), then \\( \\Gamma; \\Delta \\vdash [\\tau/t] \\Sigma \\text{ ok} \\).\n\n3. If \\( \\Gamma, X : B ; \\Delta \\vdash \\Sigma \\text{ ok} \\) and \\( \\Gamma \\vdash A : B \\), then \\( \\Gamma ; [A/X] \\Delta \\vdash [A/X] \\Sigma \\text{ ok} \\).\n\n**Proof.** By induction on the derivation of \\( \\Gamma; \\Delta \\vdash \\Sigma, x : \\tau \\text{ ok} \\), \\( \\Gamma; \\Delta, t : \\kappa \\vdash \\Sigma \\text{ ok} \\), and \\( \\Gamma, X : B ; \\Delta \\vdash \\Sigma \\text{ ok} \\), respectively (Propositions 2.8 and 2.9 are used to prove 2 and 3, respectively). \\( \\square \\)\n\nFigure 2.8 and 2.9 show the formations rules of expressions.\n\nRules E-NAT, E-TRUE, and E-FALSE assign singleton types to numeric and boolean constants. For instance the constant `True` has type `sNat([succ zero])` in any valid environment.\n\nSingleton types play a central role in reflecting properties of values in the type language, where we can reason about them constructively. For instance rules E-ADD and E-IT use respectively the type terms `plus` and `lt` (defined in Section 2.1.3) to reflect the semantics of the term operations into the type level via singleton types.\n\nThe branching construct `if[B,A](e,X_1,e_1,X_2,e_2)` allows information obtained dynamically (e.g., through comparisons) to be made available for static reasoning in the form of proof parameters to its branches. The type term `A` represents a proof of the proposition encoded by either `B true` or `B false`, depending on the value of `e`. This proof is bound to the type variable `(X_1 \\text{ or } X_2)` of the appropriate branch, which can use it in the construction of other proofs. The correspondence between the value of `e` and the type of `A` is again established through a singleton boolean type. Thus for instance if the run-time value of `e` asserts the truthfulness of some proposition `P`, since the type parameter `A''` of the singleton type of `e` reflects the value of `e` at the type level, we can define `B` so that `B A''` represents `P` or `¬P`, depending on whether `A'' = B \\text{ true}` or `A'' = B \\text{ false}`, and reason in each of the two branches under the assumption that `P` or `¬P`, respectively. Of course, for this reasoning to be sound, we need a proof that `A''` indeed reflects the truthfulness of `P`, that is, we need a proof term `A` of kind `B A''`.\n\nIn fact if is more flexible than that, because `B false` does not have to be the negation of `B true`, one can have imprecise information flow into the branches.\nCHAPTER 2. THE INTERNAL LANGUAGE\n\nΓ; Δ; Σ ⊢ e : τ\n\nΓ; Δ ⊢ Σ ok\n\nΓ; Δ; Σ ⊢ x : τ\n\n(E-VAR)\n\nΓ; Δ; Σ ⊢ x : τ\n\n(E-UNIT)\n\nΓ; Δ; Σ ⊢ () : unit\n\n(E-TRUE)\n\nΓ; Δ ⊢ Σ ok\n\nΓ; Δ; Σ ⊢ ⊤ : τ\n\n(E-NAT)\n\nΓ; Δ; Σ ⊢ sNat[A1]\n\nΓ; Δ, Σ ⊢ e1, e2 : sNat[A2]\n\n(E-ADD)\n\nΓ; Δ; Σ ⊢ sNat[A1]\n\nΓ; Δ, Σ ⊢ e1, e2 : sNat[A2]\n\n(E-UNIT)\n\nΓ; Δ; Σ ⊢ () : unit\n\nΓ; Δ ⊢ Σ ok\n\nΓ; Δ, Σ ⊢ tt : sBool[true]\n\n(E-TRUE)\n\nΓ; Δ ⊢ Σ ok\n\nΓ; Δ; Σ ⊢ ff : sBool[false]\n\n(E-FALSE)\n\nΓ ⊢ B : Bool → Prop\n\nΓ; Δ; Σ ⊢ e0 : sBool[A']\n\nΓ ⊢ A : B A'\n\nΓ, X1 : B true; Δ; Σ ⊢ e1 : τ\n\nΓ ⊢ τ : Ω\n\nΓ, X2 : B false; Δ; Σ ⊢ e2 : τ\n\n(E-FP)\n\nΓ; Δ, Σ ⊢ if[B, A](e0, X1, e1, X2, e2) : τ\n\nΓ; Δ; Σ; x : τ1 ⊢ e : τ2\n\n(E-FN)\n\nΓ; Δ; Σ ⊢ λx : τ1.e : τ1 → τ2\n\n(E-TFN1)\n\nΓ ⊢ A : s\n\nΓ; Δ; Σ ⊢ e1, e2 : τ1\n\nΓ ⊢ τ : Ext\n\nΓ; Δ, Σ ⊢ X : s\n\n(E-TFN2)\n\nΓ; Δ; Σ ⊢ ∀X : A.e : τ\n\nΓ; Δ; Σ ⊢ λX : A.e : ∀X : A.τ\n\n(E-FIX)\n\nΓ; Δ; Σ ⊢ x : τ.f : τ\n\nΓ; Δ; Σ ⊢ fix x : τ.f : τ\n\n(E-APP)\n\nΓ; Δ ⊢ e1 : τ1 → τ2\n\nΓ; Δ; Σ ⊢ e2 : τ1\n\nΓ; Δ; Σ ⊢ e1.e2 : τ2\n\n(E-TAPP1)\n\nΓ ⊢ A : B\n\nΓ ⊢ B : s\n\nΓ; Δ, Σ ⊢ e : ∀X : B.τ\n\nΓ; Δ; Σ ⊢ e[A] : [A/X]τ\n\n(E-TAPP2)\n\nΓ; Δ; Σ ⊢ e1 : τi\n\nΓ; Δ; Σ ⊢ e1 : τi\n\n(E-STR)\n\nΓ; Δ, Σ ⊢ i = 1, \\ldots, n\n\nΓ; Δ; Σ ⊢ e : \\{l_1 : τ_1, \\ldots, l_n : τ_n\\}\n\nΓ; Δ, Σ ⊢ e.i : τ_i\n\n(E-PROJ)\n\nFigure 2.8: Expression formation rules\n\\[ \\Gamma; \\Delta; \\Sigma \\vdash e : \\tau \\]\n\n\\[ \\frac{\\Gamma; \\Delta \\vdash t_1 + t_2 : \\Omega \\quad \\Gamma; \\Delta; \\Sigma \\vdash e : t_1}{\\Gamma; \\Delta; \\Sigma \\vdash \\text{inj}^{t_1 + t_2}_1 e : t_1 + t_2} \\quad (E\\text{-inj}) \\]\n\n\\[ \\frac{\\Gamma; \\Delta \\vdash t_1 + t_2 : \\Omega \\quad \\Gamma; \\Delta; \\Sigma \\vdash e : t_2}{\\Gamma; \\Delta; \\Sigma \\vdash \\text{inj}^{t_1 + t_2}_2 e : t_1 + t_2} \\quad (E\\text{-inj}) \\]\n\n\\[ \\Gamma; \\Delta; \\Sigma \\vdash e_0 : t_1 + t_2 \\quad \\Gamma; \\Delta; \\Sigma \\vdash e_1 : t_1 \\rightarrow \\tau \\quad \\Gamma; \\Delta; \\Sigma \\vdash e_2 : t_2 \\rightarrow \\tau \\]\n\n\\[ \\Gamma; \\Delta; \\Sigma \\vdash \\text{case}(e_0, e_1, e_2) : \\tau \\quad (E\\text{-case}) \\]\n\n\\[ \\frac{\\Gamma; \\Delta \\vdash \\mu_\\kappa(t_1, t_2) : \\Omega \\quad \\Gamma; \\Delta; \\Sigma \\vdash e : K(\\kappa, t_1, t_2)}{\\Gamma; \\Delta; \\Sigma \\vdash \\text{fold}_{\\kappa}(t_1, t_2) e : \\mu_\\kappa(t_1, t_2)} \\quad (E\\text{-fold}) \\]\n\n\\[ \\frac{\\Gamma; \\Delta; \\Sigma \\vdash e : \\mu_\\kappa(t_1, t_2)}{\\Gamma; \\Delta; \\Sigma \\vdash \\text{unfold} e : K(\\kappa, t_1, t_2)} \\quad (E\\text{-unfld}) \\]\n\n\\[ \\frac{\\Gamma; \\Delta \\vdash \\tau : \\kappa \\quad \\Gamma; \\Delta; e : \\kappa \\vdash \\tau' : \\Omega \\quad \\Gamma; \\Delta; \\Sigma \\vdash e : [\\tau/\\tau']}{\\Gamma; \\Delta; \\Sigma \\vdash \\langle e = e' : \\tau' \\rangle : \\exists \\kappa. \\tau'} \\quad (E\\text{-pack1}) \\]\n\n\\[ \\frac{\\Gamma \\vdash A : B \\quad \\Gamma \\vdash X : B; \\Delta \\vdash \\tau : \\Omega}{\\Gamma \\vdash B : s \\quad \\Gamma \\vdash \\Delta; \\Sigma \\vdash e : [A/X]_{\\tau}} \\quad (s \\neq \\text{Ext}) \\quad (E\\text{-pack2}) \\]\n\n\\[ \\frac{\\Gamma; \\Delta; \\Sigma \\vdash e_0 : \\tau_0 \\quad \\Gamma; \\Delta, \\Sigma, x : \\tau_0 \\vdash e : \\tau}{\\Gamma; \\Delta; \\Sigma \\vdash \\text{let} x = e_0 \\text{ in } e : \\tau} \\quad (E\\text{-let}) \\]\n\n\\[ \\frac{\\Gamma; \\Delta; \\Sigma \\vdash \\tau_0 : \\kappa \\quad \\Gamma; \\Delta; \\Sigma \\vdash [\\tau_0/t]e : \\tau}{\\Gamma; \\Delta; \\Sigma \\vdash \\text{let } t = \\tau_0 \\text{ in } e : \\tau} \\quad (E\\text{-tlet1}) \\]\n\n\\[ \\frac{\\Gamma \\vdash A : B \\quad \\Gamma \\vdash \\Delta; \\Sigma \\vdash [A/X]e : \\tau}{\\Gamma \\vdash \\Delta; \\Sigma \\vdash \\text{let } X = A \\text{ in } e : \\tau} \\quad (E\\text{-tlet2}) \\]\n\n\\[ \\frac{\\Gamma; \\Delta \\vdash \\tau : \\Omega \\quad \\Gamma; \\Delta; \\Sigma \\vdash e_0 : \\exists \\kappa. \\tau_0 \\quad \\Gamma; \\Delta, \\Sigma, \\tau : \\tau_0 \\vdash e : \\tau}{\\Gamma; \\Delta; \\Sigma \\vdash \\text{let}(t, x) = e_0 \\text{ in } e : \\tau} \\quad (E\\text{-open1}) \\]\n\n\\[ \\frac{\\Gamma; \\Delta \\vdash \\tau : \\Omega \\quad \\Gamma; \\Delta; \\Sigma \\vdash e_0 : \\exists X. A \\tau_0 \\quad \\Gamma; X : A; \\Delta, \\Sigma, x : \\tau_0 \\vdash e : \\tau}{\\Gamma; \\Delta; \\Sigma \\vdash \\text{let}(X, x) = e_0 \\text{ in } e : \\tau} \\quad (E\\text{-open2}) \\]\n\n\\[ \\frac{\\Gamma; \\Delta; \\Sigma \\vdash \\tau : \\tau = \\tau'}{\\Gamma; \\Delta; \\Sigma \\vdash e : \\tau : \\tau'} \\quad (E\\text{-conv}) \\]\n\nFigure 2.9: Expression formation rules (Figure 2.8 continued)\nIn particular the encoding of the usual oblivious (in proof-passing sense) if is possible using \\(B = \\lambda t: \\text{Bool}. \\text{True}\\).\n\nSince we allow the definition of higher-kindred recursive types using the \\(\\mu\\) constructor, we need to analyze the structure of \\(\\kappa\\) in the rules E-fold and E-unfold to determine how to unroll the \\(\\mu\\)-type. This analysis is performed by the meta-level macro \\(K\\) (interpreted by the compiler). The definition of \\(K\\) is described in detail in Section 2.3.1. Note that the way we define \\(K\\) will not affect the type safety proof.\n\nThe rest expressions have standard meaning.\n\n### 2.2.3 Dynamic Semantics\n\nWe present a small step call-by-value operational semantics for CL in the style of Wright and Felleisen [WF94]. The reduction relation \\(\\Rightarrow\\) is defined by the following rules:\n\n\\[\n\\begin{align*}\n\\text{R-ADD} & & \\overline{n_1 + n_2} &\\Rightarrow \\overline{n_1 + n_2} \\\\\n\\text{R-IT-T} & & \\overline{n_1} \\lessgtr \\overline{n_2} &\\Rightarrow \\overline{n_1} \\lessgtr \\overline{n_2} \\\\\n\\text{R-IT-F} & & \\overline{n_1} \\geq \\overline{n_2} &\\Rightarrow \\overline{n_1} \\geq \\overline{n_2} \\\\\n\\text{R-FP-T} & & \\text{if}[B, A](\\text{tt}, X_1, e_1, X_2, e_2) \\Rightarrow [A/X_1]e_1 \\\\\n\\text{R-FP-F} & & \\text{if}[B, A](\\text{ff}, X_1, e_1, X_2, e_2) \\Rightarrow [A/X_2]e_2 \\\\\n\\text{R-\\(\\beta\\)} & & (\\lambda x: \\tau.e) v \\Rightarrow [v/x]e \\\\\n\\text{R-TAPP1} & & (\\Lambda t: \\kappa.e) \\tau \\Rightarrow [\\tau/t]e \\\\\n\\text{R-TAPP2} & & (\\Lambda X: B.e)[A] \\Rightarrow [A/X]e \\\\\n\\text{R-FIX} & & \\text{fix } x: \\tau.f \\Rightarrow [\\text{fix } x: \\tau.f/x]f \\\\\n\\text{R-SUB} & & \\{l_1 = v_1, \\ldots, l_n = v_n\\}. l_i \\Rightarrow v_i \\quad (i \\leq n) \\\\\n\\text{R-CASE1} & & \\text{case}(\\text{inj}_1^\\tau v, e_1, e_2) \\Rightarrow e_1 v \\\\\n\\text{R-CASE2} & & \\text{case}(\\text{inj}_2^\\tau v, e_1, e_2) \\Rightarrow e_2 v \\\\\n\\text{R-UNFD} & & \\text{unfold } (\\text{fold}^\\tau v) \\Rightarrow v \\\\\n\\text{R-LET} & & \\text{let } x = v \\text{ in } e \\Leftarrow [v/x]e \\\\\n\\text{R-TLET1} & & \\text{let } t = \\tau \\text{ in } e \\Leftarrow [\\tau/t]e \\\\\n\\text{R-TLET2} & & \\text{let } X = A \\text{ in } e \\Leftarrow [A/X]e \\\\\n\\text{R-OPEN1} & & \\text{let } (t, x) = (\\tau = \\tau', v; \\tau') \\text{ in } e \\Leftarrow [v/x][\\tau/t]e \\\\\n\\text{R-OPEN2} & & \\text{let } (X, x) = (X' = A; v; \\tau') \\text{ in } e \\Leftarrow [v/x][A/X]e\n\\end{align*}\n\\]\n\nAn evaluation context \\(E\\) encodes the call-by-value discipline:\n\n\\[\nE ::= \\bullet \\mid E + e \\mid v + E \\mid E < e \\mid v < E \\mid E e \\mid v E \\mid E[\\tau] \\mid E[A] \\\\\n\\mid \\{l_1 = v_1, \\ldots, l_{i-1} = v_{i-1}, l_i = E, l_{i+1} = e_{i+1}, \\ldots, l_n = e_n\\} \\\\\n\\mid E. t \\mid \\text{inj}_1^\\tau E \\mid \\text{inj}_2^\\tau E \\mid \\text{case}(E, e_1, e_2) \\mid \\text{fold}^\\tau E \\mid \\text{unfold} E \\\\\n\\mid (t = \\tau, E; \\tau') \\mid (X = A, E; \\tau) \\mid \\text{let } x = E \\text{ in } e \\mid \\text{let}(t, x) = E \\text{ in } e \\\\\n\\mid \\text{let}(X, x) = E \\text{ in } e \\mid \\text{if}[B, A](E, X_1.e_1, X_2.e_2)\n\\]\n2.3. EXPRESSIVE POWER OF CL\n\nThe notation \\( E(e) \\) stands for the term obtained by replacing the hole \\( \\bullet \\) in \\( E \\) by \\( e \\). The single step computation \\( \\rightarrow \\) relates \\( E(e) \\) to \\( E(e') \\) when \\( e \\leftrightarrow e' \\), and \\( \\rightarrow^* \\) is its reflexive-transitive closure.\n\nWe can see that types are irrelevant for the evaluation, hence a type-erasure semantics, in which all type-related operations and parameters are erased, would be entirely standard.\n\n2.3 Expressive Power of CL\n\nBased on a powerful type system, our computation language is very expressive. In this section, we will show that by adopting the technique proposed by Collins and Shao [CS02], our CL has a uniform way to support higher-kind recursive types. In addition, the combination of the general recursive type and expressive proof language allows us to support the guarded recursive data types proposed by Xi, Chen and Chen [XCC03].\n\n2.3.1 Higher-Kinded Recursive Types\n\nThe standard approach to recursive types in the context of modern programming languages such as SML (as presented by Harper and Stone [HS96]) is to present a higher-kind type constructor \\( \\mu : (\\kappa \\rightarrow \\kappa) \\rightarrow \\kappa \\). The unrolling of a recursive type \\( \\mu(\\lambda t : \\kappa.\\tau) \\) is then \\( \\tau[t/\\mu(\\lambda t : \\kappa.\\tau)] \\). Unfortunately (unless \\( \\kappa = \\Omega \\)), the result of applying this type constructor \\( \\mu \\) does not belong to the “ground kind” \\( \\Omega \\), which we define as the kind of all type constructors of terms. In other words, in general we cannot type an expression in the term language with a recursive type. Instead, we would employ Harper/Stone’s solution, which is to use a “projection” operator to take the result back to \\( \\Omega \\). Consider the following simple example (in SML syntax):\n\n```plaintext\ndatatype tree = Leaf of unit\n | Node of forest * int\nand forest = Trees of tree * tree\n```\n\nIn a standard presentation, since the types mutually recurse, we would package them together using a `fixpoint` function:\n\n\\[\n\\lambda(tree, forest) : \\Omega @ \\Omega . (unit + forest * int, tree * tree)\n\\]\n\nApplying the recursive type constructor \\( \\mu \\) (and cleaning up the syntax), the type of this definition then becomes:\n\n\\[\n\\tau := \\mu(\\lambda t : \\Omega @ \\Omega . (unit + \\pi_2 t * int, \\pi_1 t * \\pi_1 t))\n\\]\n\nWe could then project this result back to obtain the type of `tree` as \\( \\pi_1 \\tau \\) and the type of `forest` as \\( \\pi_2 \\tau \\).\nThis approach is not especially general; in particular, in [HS96], projections of $\\kappa_1 \\rightarrow \\kappa_2$ back to $\\Omega$ are handled differently in the static semantics from projections of $\\kappa_1 \\otimes \\kappa_2$, and it is not clear how their mechanism may be applied to higher kinds.\n\n\\[\n\\frac{\\Delta, t : \\kappa \\vdash \\tau : \\kappa}{\\Delta \\vdash \\mu t : \\kappa. \\tau : \\kappa} \\quad \\text{(rec-form)}\n\\]\n\n\\[\n\\frac{p = \\pi_i \\mid \\cdot}{s = \\tau'' \\mid \\cdot}\n\\]\n\n\\[\n\\Delta \\vdash \\tau \\equiv (p(\\mu t : \\kappa. \\tau'))(s) : \\Omega\n\\]\n\n\\[\n\\frac{\\Delta : \\Sigma \\vdash e : \\tau}{\\Delta ; \\Sigma \\vdash \\text{unfold}(e) : (p(\\mu t : \\kappa. \\tau' / t)[\\tau'])(s)} \\quad \\text{(Unfold)}\n\\]\n\n\\[\n\\frac{p = \\pi_i \\mid \\cdot}{s = \\tau'' \\mid \\cdot}\n\\]\n\n\\[\n\\Delta \\vdash \\tau \\equiv (p(\\mu t : \\kappa. \\tau'))(s) : \\Omega\n\\]\n\n\\[\n\\frac{\\Delta ; \\Sigma \\vdash e : (p(\\mu t : \\kappa. \\tau' / t)[\\tau'])(s)}{\\Delta ; \\Sigma \\vdash \\text{fold}_e(e) : \\tau} \\quad \\text{(Fold)}\n\\]\n\nFigure 2.10: Typing rules for fold and unfold in Harper and Stone [HS96]\n\nThe typing rules given in Figure 2.3.1 are taken from [HS96]. In these rules, $p$ and $s$ are “optional”, and are required to coerce the $\\mu$-type back to $\\Omega$. The fact that they are necessary indicates this formulation of recursive types is quite unnatural; we have to resort to “tricks” such as this to type check fold and unfold. A worse problem is that these rules only work for a limited set of kinds; i.e. kinds of the form of $(\\kappa_1 \\otimes \\ldots \\otimes \\kappa_n)$, and for each $\\kappa_i$, it must be in the form of $\\kappa_i'' \\rightarrow \\Omega$; it is completely unclear how to extend this mechanism to be more general.\n\nIn our design of CL, we use the technique proposed by Collins and Shao [CS02], which explicitly combine the fixpoint function and the projection operation into one type, writing a recursive type over $\\kappa$ as $\\mu_\\kappa(f, g)$. For instance, if we let $f = \\lambda t : \\Omega \\otimes \\Omega.(\\text{unit} + \\pi_2 t * \\text{int}, \\pi_1 t * \\pi_1 t)$ as above, then we can write \\text{tree} as\n\n$$\\mu_{\\Theta \\Omega}(f, \\lambda t : \\Omega \\otimes \\Omega. \\pi_1 t),$$\n\nand \\text{forest} as\n\n$$\\mu_{\\Theta \\Omega}(f, \\lambda t : \\Omega \\otimes \\Omega. \\pi_2 t).$$\n\nOur typing rules for fold and unfold are given in Figure 2.9 as rules E-fold and E-unfold. The meta-level macro $\\mathcal{K}$, interpreted by the compiler, is used to analyse the structure of $\\kappa$ in these two rules. Here we extended Collins and Shao’s definition of $\\mathcal{K}$ to support kinds $\\kappa$ like $\\Pi X : A. \\kappa'$.\\[\\]\nWe define $\\mathcal{K}$ as follows (assuming that we have the ability to perform a meta-level typecase operation):\n\n$$\\mathcal{K}(\\kappa, \\tau_1 : \\kappa \\rightarrow \\kappa, \\tau_2 : \\kappa \\rightarrow \\Omega) := \\tau_2[\\mathcal{H}(\\kappa, \\kappa, \\lambda t. t, \\tau_1)],$$\n\nwhere $\\mathcal{H}$ is defined as follows:\n\n$$\\mathcal{H}(\\kappa', \\kappa, \\tau' : \\kappa \\rightarrow \\kappa', \\tau_1 : \\kappa \\rightarrow \\kappa) :=\n\\begin{cases}\n\\mu_\\kappa(\\tau_1, \\tau') & \\text{when } \\kappa' = \\Omega \\\\\n(\\mathcal{H}(\\kappa_1, \\kappa, \\lambda t. \\kappa. \\pi_1(\\tau'[t]), \\tau_1), & \\text{when } \\kappa' = \\kappa_1 \\circ \\kappa_2 \\\\\n\\mathcal{H}(\\kappa_2, \\kappa, \\lambda t. \\kappa. \\pi_2(\\tau'[t]), \\tau_1)) & \\text{when } \\kappa' = \\kappa_1 \\rightarrow \\kappa_2 \\\\\n\\lambda X : A. \\mathcal{H}(\\kappa'', \\kappa, \\lambda t. (\\tau'[t])[X], \\tau_1) & \\text{when } \\kappa' = \\Pi X : A. \\kappa''\n\\end{cases}$$\n\nThe $\\mathcal{K}$ macro takes three arguments: the kind $\\kappa$ which we are working over, the fixpoint type function $\\tau_1 : \\kappa \\rightarrow \\kappa$, and the coercion type function $\\tau_2 : \\kappa \\rightarrow \\Omega$. The macro returns the unrolling of $\\mu_\\kappa(\\tau_1, \\tau_2)$. To do this it passes the arguments to the $\\mathcal{H}$ macro. The purpose of this macro is to expand the recursive type from something belonging to $\\Omega$ to something belong to $\\kappa$ so that $\\tau_1$ may be applied to it. It takes four parameters: the kind $\\kappa'$ which is the kind of the result, the kind $\\kappa$ which is the kind of the whole expression (necessary for when we create types $\\mu_\\kappa(\\tau_1, \\ldots)$), the type function $\\tau_1$ which is copied verbatim to any $\\mu$-types we generated, and a type function $\\tau'$. The type function $\\tau'$ works to take a value from $\\kappa$ to $\\kappa'$ — we keep this around to build up the new coercion functions when we create $\\mu$-types in the recursive calls.\n\nIt is easy to check that the definitions of the $\\mathcal{K}$ and $\\mathcal{H}$ macro are always well-kinded. Also since in each unfolding of the macro $\\mathcal{H}$, the first argument $\\tau'$ becomes strictly smaller in structure. Therefore the unfolding of the $\\mathcal{H}$ macro (and trivially the $\\mathcal{K}$ macro) will always terminate. Therefore we say the $\\mathcal{K}$ macro is well defined.\n\nRevisiting the example shown at the beginning of this section, we specified the type of $\\text{tree}$ to be\n\n$$\\mu_{\\Omega\\Box}(f, \\lambda t. \\Omega \\circ \\Omega. \\pi_1 t),$$\n\nwhere\n\n$$f = \\lambda t. \\Omega \\circ \\Omega. (\\text{unit} + \\pi_2 t \\ast \\text{int}, \\pi_1 t \\ast \\pi_1 t).$$\n\nIf we were to unfold this type, we would first apply\n\n$$\\mathcal{H}(\\Omega \\circ \\Omega, \\Omega \\circ \\Omega, \\lambda x : \\Omega \\circ \\Omega. x, f).$$\n\nSubstituting once, this leaves:\n\n$$(\\mathcal{H}(\\Omega, \\Omega \\circ \\Omega, \\lambda h : \\Omega \\circ \\Omega. \\pi_1(h), f), \\mathcal{H}(\\Omega, \\Omega \\circ \\Omega, \\lambda h : \\Omega \\circ \\Omega. \\pi_2(h), f))$$\n\nApplying $\\mathcal{H}(\\Omega, \\Omega \\circ \\Omega, \\lambda h : \\Omega \\circ \\Omega. \\pi_1(h), f)$ gives us $\\mu_{\\Omega\\Box}(f, \\lambda h : \\Omega \\circ \\Omega. \\pi_1 h)$, which (not coincidentally) is the type of $\\text{tree}$ itself. The full unfolding of $\\text{tree}$, then, is\n\n$$\\pi_1(f(\\mu_{\\Omega\\Box}(f, \\lambda h : \\Omega \\circ \\Omega. \\pi_1 h), \\mu_{\\Omega\\Box}(f, \\lambda h : \\Omega \\circ \\Omega. \\pi_2 h))))$$\nwhich evaluates to\n\\[\n\\text{unit} + (\\mu_{\\Omega\\Omega}(f, \\lambda x:\\Omega@\\Omega. \\pi_2 x) \\times \\text{int}),\n\\]\nwhich is precisely what one would expect.\n\nIn [CS02], the authors gave another example to show the formulation of recursive types. Consider the following datatypes (from Olasinski [Oka99]):\n\n\\[\n\\begin{align*}\n\\text{datatype} & \\quad \\alpha \\text{ Quad} = \\quad \\Omega \\quad \\text{of } \\alpha \\times \\alpha \\times \\alpha \\\\\n\\text{and} & \\quad \\alpha \\text{ Square} = \\quad \\text{Zero of } \\alpha \\\\\n& \\quad \\mid \\quad \\text{Succ of } (\\alpha \\text{ Quad}) \\text{Square}\n\\end{align*}\n\\]\n\nLet \\( \\kappa = (\\Omega \\rightarrow \\Omega) \\oplus (\\Omega \\rightarrow \\Omega) \\). We will type \\( \\alpha \\text{ Quad} \\) as\n\n\\[\n\\text{Quad} = \\lambda t:\\Omega. \\mu_\\kappa(f, \\lambda x: \\kappa. (\\pi_1(x) t)),\n\\]\n\nand we’ll type \\( \\alpha \\text{ Square} \\) as\n\n\\[\n\\text{Square} = \\lambda t:\\Omega. \\mu_\\kappa(f, \\lambda x: \\kappa. (\\pi_2(x) t)),\n\\]\n\nwhere\n\n\\[\nf = \\lambda x: \\kappa. (\\lambda t: \\Omega. t * t * t, t: \\Omega. t + \\pi_2(x) (\\pi_1(x) t))\n\\]\n\nIn order to create a value of type \\( \\text{int \\quad Quad} \\), we would write the following:\n\n\\[\n\\text{fold}^{\\text{Quad(int)}}(1, 2, 3, 4).\n\\]\n\nSimilarly, to create the value \\( \\text{Succ(Zero}(\\Omega(1, 2, 3, 4)) \\)) of type \\( \\text{int \\quad Square} \\), abbreviating \\( T = \\text{Quad(int)} \\):\n\n\\[\n\\text{fold}^{\\text{Square(int)}}(\\text{inj}_2) \\circ \\text{Succ}(T)\n\\]\n\n\\[\n(\\text{fold}^{\\text{Square}(T)}(\\text{inj}_1) \\circ \\text{Succ}(\\text{Quad}(T)) \\circ \\text{fold}(T(1, 2, 3, 4))))\n\\]\n\n### 2.3.2 Guarded Recursive Type Constructors\n\nIn Coq or our proof language PL, we can easily define the following inductive data type constructor \\( \\text{Exp} \\):\n\n\\[\n\\begin{align*}\n\\text{Inductive} \\quad & \\text{Exp} : \\text{Prop} \\rightarrow \\text{Prop} := \\\\\n& \\quad \\text{Var} : \\Pi \\alpha : \\text{Prop}. \\alpha \\rightarrow \\text{Exp} \\alpha \\\\\n& \\quad | \\text{Lam} : \\Pi \\alpha : \\text{Prop}. \\Pi \\beta : \\text{Prop}. (\\alpha \\rightarrow \\text{Exp} \\beta) \\rightarrow \\text{Exp}(\\alpha \\rightarrow \\beta) \\\\\n& \\quad | \\text{App} : \\Pi \\alpha : \\text{Prop}. \\Pi \\beta : \\text{Prop}. \\text{Exp}(\\alpha \\rightarrow \\beta) \\rightarrow \\text{Exp} \\alpha \\rightarrow \\text{Exp} \\beta\n\\end{align*}\n\\]\n\nHowever, it is not so clear how to formulate above data type constructor using the general recursive type constructor \\( \\mu \\) and union types.\n\nXi, Chen and Chen [XCC09] proposed the notion of guarded recursive datatype constructors, which generalized the notion of recursive datatypes and allowed us formulate above inductively defined type constructor using \\( \\mu \\) and union types.\n\nA guarded type is in the form of \\( \\exists \\Delta. \\tau \\), where \\( \\Delta \\) is a type variable context that may contain some type equalities. The name \\textit{guarded} is used for such type\nequalities. For instance, $\\exists \\Delta_1.\\tau$ is a guarded type, where $\\Delta_1 = \\{\\alpha_1, \\alpha_2, \\alpha_1 \\ast \\alpha_2 \\equiv \\text{int} \\ast \\text{bool}\\}$ and $\\tau = \\alpha_1 \\ast \\alpha_1$; this type is equivalent to $\\text{int} \\ast \\text{int}$ since we must map $\\alpha_1$ to $\\text{int}$ in order to satisfy the type equality $\\alpha_1 \\ast \\alpha_2 \\equiv \\text{int} \\ast \\text{bool}$. The type $\\exists \\Delta_2.\\tau$ is also a guarded type, where $\\Delta_2 = \\{\\alpha_1, \\alpha_2, \\alpha_1 \\ast \\alpha_2 \\equiv \\text{int}\\}$; this type is equivalent to the type void, i.e., the type in which there is no element, since the type equality $\\alpha_1 \\ast \\alpha_2 \\equiv \\text{int}$ cannot be satisfied.\n\nFor a recursive datatype constructor in the following general form (in a SML-like syntax):\n\n$$\\text{datatype } \\vec{\\alpha} \\ T = \\begin{cases} c_1 \\text{ of } \\forall \\alpha_1' : \\kappa_1'. \\tau_1 \\rightarrow \\tau_1' \\ T \\\\ c_2 \\text{ of } \\forall \\alpha_2' : \\kappa_2'. \\tau_2 \\rightarrow \\tau_2' \\ T \\\\ \\vdots \\\\ c_k \\text{ of } \\forall \\alpha_k' : \\kappa_k'. \\tau_k \\rightarrow \\tau_k' \\ T \\end{cases}$$\n\nit can be formally defined as $\\mu \\text{.}\\sigma$, where $\\sigma$ is a union of guarded types:\n\n$$\\mu \\text{.}\\lambda \\vec{\\alpha}. (\\exists \\alpha_1, \\tau_1 \\equiv \\vec{\\alpha}).[t/T]\\tau_1 + \\ldots + \\exists \\alpha_k, \\tau_k \\equiv \\vec{\\alpha}).[t/T]\\tau_k)$$\n\nThat is why $T$ is called a guarded recursive datatype constructor (it is assumed that for $i = 1, \\ldots, k$, $\\vec{\\alpha} = \\alpha_1, \\ldots, \\alpha_n$ and $\\vec{\\alpha}_i$ share no common type variables).\n\nIn [XCC03] the authors gave rules to infer and solve the type constraints automatically so that programmer do not have to explicitly write these type equations. Although in our type system, we do not have similar mechanics that allow user explicitly specify the type constraints, nor do we have such constraint-solving rules, we can support such guarded recursive type constructors if the type variables $\\vec{\\alpha}$ have kinds $\\vec{A}$, i.e. they are type variables in the proof language.\n\nThe basic idea is that we can inductively define the equality of types in our PL:\n\n$$\\text{Inductive Eq}[k : \\text{Prop}, t : k] : k \\rightarrow \\text{Prop} := \\text{refl}\\_\\text{equal} : \\text{Eq} k t t;$$\n\nand its elimination allows us to define a type term showing this is actually Leibniz equality:\n\n$$\\text{Leibniz : } \\Pi k : \\text{Prop}. \\Pi t : k. \\Pi t' : k.(\\text{Eq} k t t') \\rightarrow \\Pi : (k \\rightarrow \\text{Prop}). P \\ t \\rightarrow P \\ t'$$\n\nNow let’s consider the classical example that use dependent types to eliminate index bound checking [X98] (in DML syntax):\n\n$$\\text{datatype } \\vec{\\alpha}\\ 1\\text{\\ list with nat } = \\begin{cases} \\text{nil}(0) \\\\\n\\{n : \\text{nat}\\} \\text{ cons}(n + 1) \\text{ of } \\vec{\\alpha} * \\vec{\\alpha}\\ 1\\text{\\ list}(n) \\end{cases}$$\n\nThe syntax introduces a type constructor $\\text{list}$ that takes a type and a index of sort $\\text{nat}$ to form a list type.\n\nAbove type constructor can be easily defined in Vero:\n\n$$\\text{list } = \\Lambda t : \\Omega. \\Lambda X : \\text{Nat}. \\mu \\Omega. \\text{Nat} \\rightarrow \\Omega (f, g),$$\n\nwhere $f$ is defined as:\n\n$$f = \\Lambda S : \\Omega \\rightarrow \\text{Nat} \\rightarrow \\Omega. \\Lambda t : \\Omega. \\Lambda X : \\text{Nat}.\\ (\\exists p_1 : (\\text{Eq Nat} \\ X \\ \\text{zero}). \\text{unit} + \\exists X' : \\text{Nat}. \\exists p_2 : (\\text{Eq Nat} \\ X \\ (\\text{succ} \\ X')). (t \\ast S[t][X']););$$\nand \\( g \\) is:\n\n\\[\ng = \\Lambda f : \\Omega \\rightarrow \\text{Nat} \\rightarrow \\Omega. f[t][X].\n\\]\n\nAs we can see, \\( p_1 \\) and \\( p_2 \\) in \\( f \\) are actually proofs of formulae \\((\\text{Eq Nat } X \\text{ zero})\\) and \\((\\text{Eq Nat } X (\\text{succ } X'))\\), respectively. This kind of guarded recursive type constructors are of special interests to us because it allows us package the proof terms and computation terms together. Later on we can extract the proof terms by unpacking such a package. For instance, in the following program, we can unpack \\( x_1 \\) in \\( e_1 \\) and \\( x_2 \\) in \\( e_2 \\) to get the proof term \\( p_1 \\) and \\( p_2 \\) respectively.\n\n\\[\n\\begin{align*}\n\\text{let} & \\\\\n& \\quad t : \\Omega \\quad = \\ldots \\\\\n& \\quad X : \\text{Nat} \\quad = \\ldots \\\\\n& \\quad l : \\text{list}[t][X] = \\ldots \\\\\n\\text{in} & \\\\\n\\text{case(unfold } l, \\\\\n& \\quad \\lambda x_1 : (\\exists p_1 : (\\text{Eq Nat } X \\text{ zero}).\\text{unit}).e_1, \\\\\n& \\quad \\lambda x_2 : (\\exists X' : \\text{Nat}. \\exists p_2 : (\\text{Eq Nat } X (\\text{succ } X')).(t * \\text{list}[t][X'])).e_2)\n\\end{align*}\n\\]\n\nAnother important usage of the notion of guarded recursive type constructor is to construct singleton type constructors, like \\( s_{\\text{Nat}} \\) and \\( s_{\\text{Bool}} \\). In fact, the primitive singleton type constructor \\( s_{\\text{Bool}} \\) can be defined in the following way:\n\n\\[\ns_{\\text{Bool}} = \\Lambda X : \\text{Bool}.(\\exists p_1 : (\\text{Eq Bool } X \\text{ true}).\\text{unit}) + (\\exists p_2 : (\\text{Eq Bool } X \\text{ false}).\\text{unit})\n\\]\n\nThe if expression can now be simulated by the more general case expression:\n\n\\[\n\\begin{align*}\n\\text{let} & \\\\\n& \\quad b : s_{\\text{Bool}}[M] = \\ldots \\\\\n& \\quad X : \\Pi X' : \\text{Bool}.B X' = AX'.B \\ldots \\\\\n& \\quad X' : B M = X M \\\\\n\\text{in} & \\\\\n\\text{case}(b, \\\\\n& \\quad \\lambda x_1 : (\\exists p_1 : (\\text{Eq Bool } M \\text{ true}).\\text{unit}). \\\\\n& \\quad \\text{let} \\\\\n& \\quad \\quad (p_1, _) = x_1 \\\\\n& \\quad \\quad X_1 = \\text{Leibniz Bool } M \\text{ true } p_1 \\ B \\ X' \\\\\n& \\quad \\quad \\text{in } e_1, \\\\\n& \\quad \\lambda x_2 : (\\exists p_2 : (\\text{Eq Bool } M \\text{ false}).\\text{unit}). \\\\\n& \\quad \\text{let} \\\\\n& \\quad \\quad (p_2, _) = x_2 \\\\\n& \\quad \\quad X_2 = \\text{Leibniz Bool } M \\text{ false } p_2 \\ B \\ X' \\\\\n& \\quad \\quad \\text{in } e_2)\n\\end{align*}\n\\]\n\nwhere the \\( B, X', b, e_1 \\) and \\( e_2 \\) above are corresponding to the \\( B, A, e_0, e_1 \\) and \\( e_2 \\) in the if expression, respectively.\nNote that in general, it is undecidable to automatically infer such proof terms as $p_1$ and $p_2$. That is why in DML [Xi98] only a very constraint domain is used in the position of $p_1$ and $p_2$. However, since Vero is an explicitly typed language, we require the programmer to provide such proof terms to construct a value of such a list type. Therefore our language is much more expressive than Hongwei Xi’s guarded recursive datatype constructors [XCC03] or DML [Xi98].\n\nWe define another singleton type constructor, i.e. singleton list type constructor. First we define the List constructor in our PL:\n\n\\[\n\\text{Inductive List : Prop := Nil : List} \\\\\n\\text{\\quad | Cons : Nat \\to List \\to List.}\n\\]\n\nThe singleton list constructor in the computation language is defined as:\n\n\\[\ns_{\\text{List}} : \\Pi X : \\text{List}. \\Omega : \\text{List}. \\mu \\Pi X \\text{List.} \\Omega(f, g),\n\\]\n\nwhere $f$ and $g$ are defined as following:\n\n\\[\nf = \\Lambda t : (\\Pi X : \\text{List.} \\Omega). \\Lambda X : \\text{List.} \\\\\n\\quad \\exists p_1 : (\\text{Eq List X Nil}). \\text{unit +} \\\\\n\\quad \\exists n : \\text{Nat.} \\exists l : \\text{List.} \\exists p_2 : (\\text{Eq List X (Cons a l))}. (s_{\\text{Nat}}[n] \\ast t[l])\n\\]\n\n\\[\ng = \\Lambda t : (\\Pi X : \\text{List.} \\Omega). (t[X])\n\\]\n\nNow we can define an empty list:\n\n\\[\n\\text{nil} : s_{\\text{List}}[\\text{Nil}] = \\text{fold}^{\\text{unit}}_{\\text{Nil}} \\langle \\text{inj}_1 \\rangle \\langle p_1 = \\text{Pr} (\\text{Eq List Nil Nil}), () : \\text{unit} \\rangle\n\\]\n\nwhere $\\text{Pr}(\\text{Eq List Nil Nil})$ stands for a proof of the formula $\\langle \\text{Eq List Nil Nil} \\rangle$, which is trivial and omitted here. For brevity we also omit the superscript of $\\text{inj}_1$.\n\nWe can give another non-empty instance of the singleton list defined above, e.g.,\n\n\\[\nl : s_{\\text{List}}[\\text{Cons zero Nil}] = \\text{fold}^{\\text{unit}}_{\\text{Cons zero Nil}} \\langle \\text{inj}_2 \\rangle \\\\\n\\quad \\langle a = \\text{zero}, l = \\text{Nil}, \\\\\n\\quad \\langle p_2 = \\text{Pr} (\\text{Eq List (Cons zero Nil) (Cons a l))} \\rangle \\langle 0, \\text{nil} : s_{\\text{Nat}}[n] \\ast (s_{\\text{List}} l) \\rangle \\\\\n\\quad : \\exists p_2 : (\\text{Eq List (Cons zero Nil) (Cons a l))}. (s_{\\text{Nat}}[a] \\ast (s_{\\text{List}} l)) \\\\\n\\quad : \\exists l : \\text{List.} \\exists p_2 : (\\text{Eq List (Cons zero Nil) (Cons a l))}. (s_{\\text{Nat}}[a] \\ast (s_{\\text{List}} l))).\n\\]\n\nAgain the proof of the formula $\\langle \\text{Eq List (Cons zero Nil) (Cons a l)} \\rangle$ is omitted here, which is denoted as $\\text{Pr}(\\text{Eq List (Cons zero Nil) (Cons a l)})$. The superscript of $\\text{inj}_2$ is also omitted.\n\n**Automatically generating the indexed type constructor.** From above examples we can see that if the programmer wants to define both an inductive type in PL and its counterpart (i.e. the type constructor indexed over such an inductive PL type) in CL, he/she need do a lot of repeated work, because the similarity of these two in structures.\nWe also noticed that there are some patterns in the definitions of singleton type constructors like \\(s_{\\text{bool}}\\) and \\(s_{\\text{list}}\\). It is likely that there is a general way that, given an inductive PL type, can automatically generate its counterpart in CL. Here we present our attempt to develop such a general method.\n\nBefore presenting such a method, we first have a review of the syntactic constraints of types of constructors in inductive definition [Pau93].\n\n**Definition 2.13** The terms \\(P\\) which are strictly positive with regard to \\(X\\) are generated by the syntax:\n\n\\[\n\\text{Pos} ::= X | \\text{Pos} \\; m | \\Pi x: M. \\text{Pos}\n\\]\n\nwith the restriction that \\(X\\) does not occur free in \\(M\\) and \\(m\\).\n\n**Definition 2.14** The terms \\(C\\) which are a type of the constructor with regard to \\(X\\) are generated by the syntax:\n\n\\[\n\\text{Co} ::= X | \\text{Co} \\; m | P \\rightarrow \\text{Co} | \\Pi x: M. \\text{Co}\n\\]\n\nwith the restriction that \\(P\\) is strictly positive with regard to \\(X\\), and \\(X\\) does not occur free in \\(M\\) and \\(m\\). Also we require that \\(C\\) is a well kinded type.\n\nA well-formed constructor type can be written as \\(C \\equiv \\Pi X_i : A_i . X.B_i\\). A strictly positive type is a particular case of constructor types, which we call a non-recursive type of constructor. A type of constructor which is not a strictly positive type is called recursive. Note that in above definition the dependent type \\(\\Pi x : M. \\text{Co}\\) and non dependent type \\(P \\rightarrow \\text{Co}\\). \\(X\\) can occur in the type of the argument only in the non dependent case.\n\nIn the following discussion, we will relax the formulation in Section 2.1. We say a general inductive definition is in the form of \\(\\text{Ind}(X_i : A_i | X : \\Pi Y_i : B_i.s) | C_i\\). This general form allow inductive definitions to take arguments \\(X_i\\), as in Coq [Tea09]. The kind of the inductive type \\(X\\) is a general arity \\(\\Pi Y_i : B_i.s\\), where \\(s\\) is Prop or Type. A restricted inductive definition is in the form of \\(\\text{Ind}(X : \\text{Prop}) | C_i\\), which takes no arguments and requires the kind of \\(X\\) must be Prop. It has the further restriction that in each \\(C_i\\), which is in the form of \\(\\Pi X_i : A_i . X\\), each \\(A_i\\) must also be an inductive type defined using the restricted form.\n\nFirst we work on the restricted form of inductive definition. Our goal is to define a meta-level macro \\(S\\), which takes a restricted inductive definition and generates the corresponding indexed type constructor in CL. If the inductive PL type \\(I\\) has recursive constructors, \\(S\\) will generate the CL type constructor \\(\\Lambda X : I.(\\mu \\Pi X : I. \\Omega(f, g))\\), where\n\n\\[\nf : (\\Pi X : I. \\Omega) \\rightarrow \\Pi X : I. \\Omega = \\Lambda t : (\\Pi X : I. \\Omega). \\Lambda X : I. (\\tau_1 + \\ldots + \\tau_k)\n\\]\n\nand\n\n\\[\ng : (\\Pi X : I. \\Omega) \\rightarrow \\Omega = \\Lambda t : (\\Pi X : I. \\Omega). (t[X]).\n\\]\nEach $\\tau_i$ is generated according to the constructor type $C_i$ in $I$. If all the constructors of $I$ are non-recursive, $S$ will simply generate a type constructor\n\n$$t : \\Pi X : I. \\Omega = \\Lambda X : I. (\\tau_1 + \\ldots + \\tau_k),$$\n\nwhere $\\tau_i$ has the same meaning with above definition of $f$.\n\nThe central task of $S$ is to generate $\\tau_i$ for each constructor type\n\n$$C_i = \\Pi X : A_i. I.$$\n\nRecall that in the restricted form we require each $A_i$ must be an inductive type which also has the restricted form. $S$ generates $\\tau_i$ in the following way:\n\n$$\\tau_i = \\exists X_i : A_i. \\exists p : (\\text{Eq } I X (c_i X_i)). ((S' A_1)[X_1] * \\ldots * (S' A_n)[X_n]),$$\n\nwhere\n\n$$S' A_i = \\begin{cases} S A_i & A_i \\not= I \\\\ t & A_i = I \\end{cases}$$\n\nThe implementation of $S$ is given in pseudo SML code in Figure 2.11.\n\n```sml\nfun S (I as Ind(X : Prop)[C : G]) = \n if I is recursive, then\n \\mu I.X.\\Omega(\\Lambda t : (\\Pi X : I.\\Omega A X : I. (S C (t, I, c_1, C_1) + \\ldots + S C (t, I, c_n, C_n)), g))\n else A X : I.(S C (I, I, c_1, C_1) + \\ldots + S C (I, I, c_n, C_n))\n and S C (t, I, c_i, C_i) =\n let fun F I [] [] = \\exists p : (\\text{Eq } I X c_i).unit\n F I [(X_1 : A_1), \\ldots, (X_k : A_k)] [t_1, \\ldots, t_k] =\n \\exists X_i : A_i. \\exists p : (\\text{Eq } I X (c_i X_i)).(t_1 * \\ldots * t_k)\n F (\\Pi X : A. C) L_1 L_2 = F C (L_1 \\circ ([X : A])) (L_2 \\circ ([S A][X]))\n F (I \\rightarrow C) L_1 L_2 = F C (L_1 \\circ ([X : I])) (L_2 \\circ [t[X]])\n F (A \\rightarrow C) L_1 L_2 = F C (L_1 \\circ ([X : A])) (L_2 \\circ ([S A][X]))\n in\n F C [ ] [ ]\n end\n```\n\nFigure 2.11: Implementation of $S$.\n\nHowever, above definition of $S$ cannot be applied to the general form of inductive definition for two reasons: first, $S$ is at meta-level and it could not be defined using the type language, therefore we have no way to deal with $S X$ where $X$ is a variable in PL; second, in general we have no idea about how to\nhandle a PL term which is not an inductive type, e.g., the arrow term \\( A \\to B \\), in other words, if the \\( A_i \\) shown in the definition of \\( S' \\) \\( A_i \\) is a general PL form, we do not know how to do the conversion.\n\nOne way to relax such restrictions is not to convert any \\( A_i \\) which is different with \\( I \\). This approach will, of course, generate a different kind of indexed type constructors.\n\nRecall that a *general* inductive type \\( I \\) has the form \\( \\text{Ind}[X_i : A_i](X : \\Pi Y_i : B_i, s)[\\xi_i : \\xi_i] \\). We define a new macro \\( S_I \\) to handle the general form.\n\nFor the recursive case, we generate the following CL type constructor (abbreviating \\( T = \\Pi X_i : A_i, \\Pi Y_i : B_i, \\Pi X : (I X_i, Y_i), \\Omega \\)):\n\n\\[\n\\Lambda X_i : A_i, \\Lambda Y_i : B_i, \\Lambda X : (I X_i, Y_i), \\mu_T(f, g),\n\\]\n\nwhere\n\n\\[\nf : T \\to T = \\Lambda t : T. \\Lambda X_i : A_i, \\Lambda Y_i : B_i, \\Lambda X : (I X_i, Y_i), (\\tau_1 + \\ldots + \\tau_k),\n\\]\n\nand\n\n\\[\ng : T \\to \\Omega = \\Lambda t : T. (t[X_i][Y_i][X]).\n\\]\n\nAgain each \\( \\tau_i \\) is generated according to the constructor type \\( C_i \\) in \\( I \\). If all the constructors of \\( I \\) are non-recursive, \\( S_I \\) will simply generate a type constructor\n\n\\[\nt : T = \\Lambda X_i : A_i, \\Lambda Y_i : B_i, \\Lambda X : (I X_i, Y_i), (\\tau_1 + \\ldots + \\tau_k).\n\\]\n\nFor a general constructor type (note the \\( \\tilde{A}_i \\) and \\( \\tilde{B}_i \\) is different with the \\( A_i \\) and \\( B_i \\) in \\( I \\)):\n\n\\[\nC_i = \\Pi X_i : A_i, I \\tilde{B}_i,\n\\]\n\nthe form of \\( \\tau_i \\) is also different with that for the restricted form. For non-recursive case, we simply generate:\n\n\\[\n\\tau_i = \\exists X_i : A_i \\exists p : (\\text{Eq} (I X_i, Y_i) X (c_i X_i X_i^p)). \\text{unit};\n\\]\n\nwhile for recursive case,\n\n\\[\n\\tau_i = \\exists X_i : A_i \\exists p : (\\text{Eq} (I X_i, Y_i) X (c_i X_i X_i^p))((S'_i A'_i) \\times \\cdots \\times (S'_i A'_n) \\times X_i^p),\n\\]\n\nwhere\n\n\\[\n(S'_i A'_i) [X_i] = \\begin{cases} \\text{unit} & A'_i \\neq I \\tilde{Y}_i^p \\text{ for any } \\tilde{Y}_i^p \\\\ t[X_i] & \\exists Y_i^p \\text{ such that } A'_i = I Y_i^p \\end{cases}\n\\]\n\nNote the arguments \\( X_i \\) are the same for all appearance of \\( I \\), therefore they are omitted. This agrees with Coq syntax.\n\nThen we do some clean-up: drop unit in the tuple type and only keep these \\( t[X_i] \\) for any \\( i \\), resulting in some \\( \\tau_i \\) like:\n\n\\[\n\\tau_i = \\exists X_i : A_i \\exists p : (\\text{Eq} (I X_i, Y_i) X (c_i X_i X_i^p))((t[X_i^p] \\ast \\ldots \\ast t[X_i^n]),\n\\]\n\n\\]}\n2.3. EXPRESSIVE POWER OF CL\n\nApplying above approach to the following polymorphic list:\n\n\\[ \\text{Inductive List}[X:\\text{Prop}] : \\text{Prop} := \\text{Nil} : \\text{List} \\]\n\\[ \\mid \\text{Cons} : X \\rightarrow \\text{List} \\rightarrow \\text{List}, \\]\n\nwe get the following indexed type constructor in CL (abbreviating \\( T = \\exists X' : \\text{Prop}.\\exists X : (\\text{List} X'').\\Omega)\\):\n\n\\[ \\Lambda X' : \\text{Prop}.\\Lambda X : (\\text{List} X').\\mu_T(f, g), \\]\n\nwhere \\( f \\) and \\( g \\) are defined as following:\n\n\\[ f = \\lambda t : T.\\Lambda X' : \\text{Prop}.\\Lambda X : \\text{List} X'. \\]\n\\[ \\exists p_1 : \\text{(Eq (List X') X (Nil X')).unit} + \\]\n\\[ \\exists x : X'. \\exists : (\\text{List} X').\\exists p_2 : (\\text{Eq (List X')} X (\\text{Cons} X' x l)).t[l] \\]\n\n\\[ g = \\lambda t : T.t[X'][X] \\]\n\nHowever, such an indexed type constructor might not be so interesting from the viewpoint of computation: after type ensure, only an empty list is left. We have no idea how useful it is in practice.\n\nMaybe in the future we can come up with some practical approach, which is a compromise between the restricted \\( S \\) and the general but not so interesting \\( S_t \\). Let’s call it \\( S_G \\). \\( S_G \\) works in the same way with \\( S_t \\) except it handles the general constructor type\n\n\\[ C_i = \\exists X_i : \\tilde{A}_i. I \\tilde{B}_i' \\]\n\nin a different way, i.e. it will generate a different \\( \\tau_i \\):\n\n\\[ \\tau_i = \\exists \\tilde{X}_i : \\tilde{A}_i. \\exists p : \\text{(Eq (I \\tilde{X}_i \\tilde{Y}_i) X (c_i \\tilde{X}_i \\tilde{X}_i'))}.((S'_G A'_i)[X'_i] * \\cdots * (S'_G A'_n)[X'_n]), \\]\n\nwhere\n\n\\[ (S'_G A'_i)[X'_i] = \\begin{cases} \n(S_{A'_i} A'_i)[X'_i] & \\text{A'}_i \\neq I \\tilde{Y}_i, \\text{but programmer provides such} \\ S_{A'_i} \\text{for} \\ A'_i \\\\\n\\text{unit} & \\text{A'}_i \\neq I \\tilde{Y}_i \\text{and no} \\ S_{A'_i} \\\\\nt[X_i] & \\text{exists} \\ Y_i \\text{such that} \\ A'_i \\equiv I \\tilde{Y}_i \n\\end{cases} \\]\n\nThen we do the same clean-up as \\( S_t \\) to remove (or merge) useless unit type.\n\nOf course to make such an approach really work, we must provide some way to allow the programmer to point out which \\( A'_i \\) he/she wants to convert, and to provide corresponding \\( S_{A'_i} \\). This will be part of our future work.\nCHAPTER 2. THE INTERNAL LANGUAGE\nChapter 3\n\nThe Vero Surface Language\n\n3.1 Lexical Conventions\n\nIn this section we define the Vero lexical convention, which is very close to that of SML.\n\n3.1.1 Notation Conventions\n\nIn the following definition of lexical objects, we adopt the following notation conventions:\n\n\\[ \\langle obj \\rangle \\quad \\text{the lexical object } obj \\text{ appears zero or one time} \\]\n\n\\[ \\{ obj \\}^* \\quad \\text{the lexical object } obj \\text{ appears zero or more times} \\]\n\n\\[ \\{ obj \\}^+ \\quad \\text{the lexical object } obj \\text{ appears one or more times} \\]\n\nNote that \\( \\langle \\) and \\( \\rangle \\) are different with \\( < \\) and \\( > \\) respectively. The latter belong to the alphabet of Vero, while the former only appear in production rules.\n\n3.1.2 White Space\n\nSpace, newline and horizontal tabulation are considered as white spaces. White spaces are ignored but they separate tokens.\n\n3.1.3 Comments\n\nComments in Vero are enclosed between \\( \\ast \\) and \\( \\ast \\), and can be nested. Comments are treated as white spaces.\n\n3.1.4 Identifiers and Operators\n\nAt present we only define the core language without the module system, therefore we do not define qualified identifiers here.\nAn identifier is a sequence of *letters, digits, primes* (*) and underbars (*_*), starting with a letter or prime. An operator is a *symbolic* sequence, i.e. any non-empty sequence of *symbols*.\n\n\\[\n\\begin{align*}\n\\text{non zero} &::= 1..9 \\\\\n\\text{digit} &::= 0 \\mid \\text{nonzero} \\\\\n\\text{letter} &::= A..Z \\mid a..z \\\\\n\\text{symbol} &::= ! \\mid \\% \\mid \\& \\mid \\$ \\mid \\# \\mid + \\mid - \\mid / \\mid : \\mid < \\\\\n&\\quad \\mid = \\mid > \\mid ? \\mid @ \\mid ^ \\mid _ \\mid \\` \\mid | \\mid \\^ \\mid \\_* \\\\\n\\text{id} &::= \\text{letter} \\{ \\text{digit} \\mid \\text{letter} \\mid _ \\mid ? \\}_* \\\\\n\\text{id} &::= \\{ \\text{symbol} \\}_+ \n\\end{align*}\n\\]\n\nIn either case, however, reserved words are excluded. This means that for example # and | are not operators, but ## and |=| are.\n\nIdentifiers are case-sensitive.\n\nAll operators by default are infix. In section 3.2 we will see how to convert the infix operator to a prefix function identifier.\n\n### 3.1.5 Literals\n\n#### Numeral Literals\n\nVero supports both decimal and hexadecimal numerals.\n\n\\[\n\\begin{align*}\n\\text{hexdigit} &::= \\text{digit} \\mid A..F \\mid a..f \\\\\n\\text{decInt} &::= (\\^) \\{ \\text{digit} \\}_+ \\\\\n\\text{hexInt} &::= (\\^) 0x \\{ \\text{hexdigit} \\}_+ \\\\\n\\text{int} &::= \\text{decInt} \\mid \\text{hexInt} \\\\\n\\text{word} &::= 0w \\{ \\text{digit} \\}_+ \\mid 0wx \\{ \\text{hexdigit} \\}_+ \n\\end{align*}\n\\]\n\nAt present we do not support *real* numbers.\n\n#### String Literals\n\nThe *Vero alphabet* includes the set of printable ASCII characters (i.e., numbered 33-126), space or escape sequences (see the following sub-section). Unicode is not supported.\n\nA string literal is a sequence, between quotes (*\"*), of zero or more characters in the alphabet.\n\n\\[\n\\text{string} ::= \" \\{ \\text{alphabet} \\} \" \n\\]\n3.1. LEXICAL CONVENTIONS\n\nCharacter Literals\nA character literal is a sequence of the form \\#s, where s is a string constant denoting a string of size one character.\n\n\\textit{char} ::= \\#\"alphabet\"\n\nEscape Sequence for Character and String Literals\nThe character and string \\textit{escape sequences} allow for the representation of some non-graphic characters as well as the single quote, double quote, and backslash characters in character literals and string literals.\n\nEach escape sequence starts with the escape character \\\\ (backslash). The escape sequences are:\n\n- \\a A single character interpreted by the system as alert (ASCII 7)\n- \\b Backspace (ASCII 8)\n- \\t Horizontal tab (ASCII 9)\n- \\n Linefeed, also known as newline (ASCII 10)\n- \\v Vertical tab (ASCII 11)\n- \\f Form feed (ASCII 12)\n- \\r Carriage return (ASCII 13)\n- \\\\c The control character c, where c may be any character with number 64-95. The number of \\\\c is 64 higher than c.\n- \\ddd The single character with number ddd (3 decimal digits denoting an integer in the ordinal range of the alphabet).\n- \\uxxxx The single character with number xxxx (4 hexadecimal digits denoting an integer in the ordinal range of the alphabet).\n- \\\\\\\\ \" This sequence is ignored, where f..f stands for a sequence of one or more formatting characters.\n\nThe \\textit{formatting characters} are a subset of the non-printable characters including at least space, tab, newline, form feed. The last form allows long strings to be written on more than one line, by writing \\\\ at the end of one line and at the start of the next.\n\nReserved words\nThe following words are reserved keywords in Vero (incomplete):\n\n\\textit{resvWords} ::= [1 | 1 | 1 | # | ; | . | ... | : | :: | := | = | # | -> |\n| -> | * | < | > | and | Cases | case | cond | else | end\n| End | Fix | fn | if | in | Inductive | let | of | Pack\n| rec | then | type | val | with | andalso | orelse\n3.2 Syntax\n\nIn this section, we give the grammar of the Vero surface language. We show some sample Vero programs in Section 3.3.\n\nIn Vero identifiers and operators have distinguished lexical form, as described in Section 3.1.4. Programmers can introduce new operators, which must be infix and have lower priority than built-in operators. We do not provide directives for fixity and priority declaration. In the definition of a new operator opr, opr must be in parentheses and defined as a prefix function identifier (i.e. in the form of (opr), see Figure 3.1). After definition, opr can be used as a infix operator, or a prefix function identifier if it is bracketed in parentheses.\n\n\\[\npre_id ::= id \\mid (opr)\n\\]\n\\[\nop ::= opr \\mid andalso \\mid orelse \\mid + \\mid - \\mid * \\mid / \\mid \\text{div}\n\\mid \\text{mod} \\mid < \\mid <= \\mid > \\mid >=\n\\]\n\nFigure 3.1: Identifiers\n\nFigure 3.2 shows the grammar of the type language of Vero. Figures 3.4 and 3.5 define the grammar of Vero declarations and expressions. A Vero program is either a declaration or an expression, as defined in Figure 3.6.\n\n\\[\nty ::= app_ty \\mid \\{tlabels\\} \\mid ty \\cdot ty \\mid ty \\rightarrow ty \\mid ty \\ opr \\ ty \\mid ty \\ opr \\ ty \\mid ty \\\\\n\\mid \\{cids\\} \\ ty \\mid \\{cids\\} \\ ty\n\\]\n\\[\napp_ty ::= aty \\mid aty \\ app_ty\n\\]\n\\[\naty ::= pre_id \\mid \\{tlabels\\} \\mid \\{union\\_brches\\} \\mid \\{t\\}\n\\mid \\{t\\} :: Cases \\ ty \\ of \\ prrules \\ End\n\\]\n\\[\ntlabels ::= \\epsilon \\mid tlabels'\n\\]\n\\[\ntlabels' ::= selector : ty \\ , \\ tlabels' \\mid selector : ty\n\\]\n\\[\nunion\\_brches ::= union\\_brch \\mid union\\_brch \\mid union\\_brches\n\\]\n\\[\nunion\\_brch ::= id \\mid pre\\_id \\ of \\ ty\n\\]\n\\[\nprrules ::= prmatch \\mid prmatch \\mid prrules\n\\]\n\\[\nprmatch ::= simp\\_pat => ty\n\\]\n\nFigure 3.2: The Type Language\nsimp\\_pat ::= sgl\\_pat \\mid pre\\_id \\textsc{spats}\n\nsgl\\_pat ::= pre\\_id \\mid \\_ \n\n\\textsc{spats} ::= sgl\\_pat \\mid sgl\\_pat \\textsc{spats}\n\nFigure 3.3: Simple Pattern\n\ndec ::= \\texttt{val \\_} \\texttt{vb} \\mid \\texttt{val \\_} \\texttt{rec \\_} \\texttt{rvbs} \\mid \\texttt{type \\_} \\texttt{tb} \\mid \\texttt{type \\_} \\texttt{rec \\_} \\texttt{rtbs} \\mid \\texttt{open \\_} \\texttt{opn}\n| \\texttt{Inductive \\_} \\texttt{tyfarg \\_} \\texttt{indlist} \\mid \\texttt{Fix \\_} \\texttt{tyfbs}\ndecs ::= \\varepsilon \\mid \\textsc{dec \\_} \\textsc{decs} \\mid ; \\textsc{decs}\nvb ::= \\texttt{pre\\_id} = \\texttt{exp} \\mid \\texttt{pre\\_id} : \\texttt{ty} = \\texttt{exp}\n\\texttt{rvb} ::= \\texttt{pre\\_id} : \\texttt{ty} = \\texttt{exp}\n\\texttt{rvbs} ::= \\texttt{rvb} \\mid \\texttt{rvb} \\texttt{and} \\texttt{rvbs}\ntb ::= \\texttt{pre\\_id} = \\texttt{ty} \\mid \\texttt{pre\\_id} : \\texttt{ty} = \\texttt{ty}\n\\texttt{rtb} ::= \\texttt{pre\\_id} : \\texttt{ty} = \\texttt{ty}\n\\texttt{rtbs} ::= \\texttt{rtb} \\mid \\texttt{rtb} \\texttt{and} \\texttt{rtbs}\n\\texttt{opn} ::= <\\texttt{id},\\texttt{id}> = \\texttt{exp}\n\\texttt{tyfarg} ::= \\varepsilon \\mid \\texttt{tyfarg}'\n\\texttt{tyfarg}' ::= [ \\texttt{cids} ]\ncids ::= \\texttt{cid} \\mid \\texttt{cid} , \\texttt{cids}\ncid ::= \\texttt{id} : \\texttt{ty}\n\\texttt{indlist} ::= \\texttt{inditem} \\mid \\texttt{inditem \\_} \\texttt{with \\_} \\texttt{indlist}\n\\texttt{inditem} ::= \\texttt{pre\\_id} : \\texttt{ty} = \\texttt{constructors}\n\\texttt{constructors} ::= \\varepsilon \\mid \\texttt{constructors}'\n\\texttt{constructors}' ::= \\texttt{constructor} \\mid \\texttt{constructor} \\mid \\texttt{constructors}'\n\\texttt{constructor} ::= \\texttt{pre\\_id} : \\texttt{ty}\n\\texttt{tyfbs} ::= \\texttt{tyfb} \\mid \\texttt{tyfb} \\texttt{with} \\texttt{tyfbs}\n\\texttt{tyfb} ::= \\texttt{pre\\_id} \\texttt{tyfarg} : \\texttt{ty} = \\texttt{ty}\n\nFigure 3.4: Declaration\nexp ::= app_exp | tyfarg' exp | # selector aexp | exp op exp\n | if exp then exp else exp | case exp of match\n | fn earg_pat => exp\napp_exp ::= aexp | aexp app_exp\naexp ::= pre_id | int | word | string | char | ( seqexp ) | ()\n | ( exp_2c ) | ( elabels ) | [[ exp_list ]] | #[exp_list]\n | let decs in seqexp end | aexp tyarg | id [ ty ]\n | cond [ ty , ty ] ( condbody ) | Pack id = ty with exp : ty End\nseqexp ::= exp | exp ; seqexp\nexp_2c ::= exp, exp_2c | exp, exp\nelabel ::= selector = exp\nelabels' ::= elabel , elabels' | elabel\nelabels ::= ε | elabels'\nexp_list' ::= exp | exp , exp_list'\nexp_list ::= ε | exp_list'\ntyarg ::= [ ty ]\ncondbody ::= exp , [ id ] exp , [ id ] exp\nselector ::= id | int\nmatch ::= rule | rule | match\nrule ::= simp_pat => exp\nearg_pat ::= cid | ( cids )\n\nFigure 3.5: Expressions\n\nprogram ::= dec | exp\n\nFigure 3.6: Program\n3.3 Sample Vero Programs\n\nTo show the meaning of Vero grammars, we present some sample programs.\n\n3.3.1 Proof Terms\n\nIn Figure 3.7 we give the representation of the PL terms defined in Figure 2.2 (Note that in Figure 3.7 we changed the name of the function Cond in Figure 2.2 to \\textit{Test}).\n\nAs we can see the syntax of PL terms is quite similar with Coq [Tea03]. One difference is that we have no type inference in Vero, therefore the result type of \\textit{Cases} expression must always be explicitly provided, even if it is non dependent.\n\nFigures 3.8 and 3.9 shows more PL terms, which includes \\textit{List}, \\textit{Eq}, \\textit{Leibniz} and other terms defined in Section 2.3.2 and in the paper on TSCB [SSTP02].\n\nIn our surface language, we support mutually inductive types and mutually recursive fixpoints, as in Coq. The following program is one example of mutually recursive fixpoints.\n\n\\begin{verbatim}\nFix even[n: Nat] : Bool =\n <: Bool :> Cases n of 0 => True\n | S n' => odd n'\nEnd\n\nwith odd[n: Nat] : Bool =\n <: Bool :> Cases n of 0 => False\n | S n' => even n'\nEnd\n\\end{verbatim}\n(**************************\n(* some built-in PL terms *)\n**************************)\n\n(* Syntax of Inductive definition and Cases expression is *)\n(* almost the same with Coq (v.7.4) *)\nInductive Nat : Prop = 0 : Nat | S : Nat -> Nat;\n\nInductive Bool : Prop = True : Bool | False : Bool;\n\n(* Fix here corresponds to the Fixpoint command in Coq *)\nFix plus [n1: Nat]: Nat -> Nat =\n [n2: Nat] <:: Nat -> Cases n1 of 0 => n2\n | S n' => S (plus n' n2)\nEnd;\n\n(* type is like the Definition command in Coq Vernacular *)\n(* the constraint after the identifier ifez is optional *)\ntype ifez : Nat -> (k:Prop)k -> (Nat -> k) -> k =\n [n: Nat][k: Prop, p1:k, p2:Nat->k]\n <:: k -> Cases n of 0 => p1\n | S n' => p2 n'\nEnd;\n\nFix le [n1: Nat] : Nat -> Bool =\n [n2: Nat]\n <:: Bool -> Cases n1 of 0 => True\n | S n' => ifez n2 Bool False (le n')\nEnd;\n\ntype lt : Nat -> Nat -> Bool = [n1: Nat, n2 : Nat] le (S n1) n2;\n\ntype Test : Bool -> Prop -> Prop -> Prop =\n [b:Bool, p1:Prop, p2:Prop]\n <:: Prop -> Cases b of True => p1\n | False => p2\nEnd;\n\nFigure 3.7: Representation of some built-in PL terms\n3.3. SAMPLE VERO PROGRAMS\n\nInductive [a:Prop] List : Prop =\n Nil : List\n | Cons : a -> List -> List;\n\nInductive [k:Prop, x:k] Eq : k -> Prop = refl_equal : Eq x;\n\ntype LeibKnd =\n (k : Prop, x: k)\n (P: k -> Prop) (P x) -> (y:k) (Eq k x y) -> (P y);\n\ntype Leibniz : LeibKnd =\n [k:Prop, x:k, P: k->Prop, p1: P x, y:k, p2: Eq k x y]\n <: P : Cases p2 of refl_equal => p1 End;\n\nInductive LT : Nat -> Nat -> Prop =\n ltzs : (n:Nat) LT 0 (S n)\n | ltss : (n1:Nat, n2:Nat) LT n1 n2 -> LT (S n1) (S n2);\n\ntype TT : Prop = (P : Prop) P -> P;\n\ntype id : TT = [P:Prop, p:P] p;\n\ntype LTUrTrue : Nat -> Nat -> Bool -> Prop =\n [n1:Nat, n2:Nat, b:Bool] Test b (LT n1 n2) TT;\n\ntype LTCond = [n1: Nat, n2: Nat] LTUrTrue n1 n2 (it n1 n2);\n\ntype LTsucc =\n [n1: Nat, n2: Nat, b:Bool]\n LTUrTrue n1 n2 b -> LTUrTrue (S n1) (S n2) b;\n\nFix ltPrf [n1:Nat] : (n2:Nat) LTCond n1 n2 = [n2: Nat]\n<: [n:Nat] LTCond n n2 :\n Cases n1 of\n 0 => <: LTCond 0 :\n Cases n2 of\n 0 => id\n | S n2' => (ltzs n2')\nEnd\n| S n1' => <: LTCond (S n1') :\n Cases n2 of\n 0 => id\n | S n2' =>\n ( <: LTsucc n1' n2' :\n Cases (lt n1' n2') of\n True => ltss n1' n2'\n | False => id TT\n End) (ltPrf n1' n2')\n End\nEnd\n\nFigure 3.8: More PL terms\ntype leftUnit : (n:Nat) Eq Nat n (plus 0 n) =\n [n:Nat] refl_equal Nat n;\n\ntype eqf : (k1: Prop, k2:Prop, f: k1 -> k2)\n (t1: k1, t2:k1, p: Eq k1 t1 t2) Eq k2 (f t1) (f t2) =\n [k1: Prop, k2:Prop, f: k1 -> k2] [t1: k1, t2:k1, p: Eq k1 t1 t2]\n Leibniz k1 t1 ([x:k1] Eq k2 (f x) (f x))\n (refl_equal k2 (f t1)) t2 p;\n\ntype eqfNatS : (n1: Nat, n2:Nat) Eq Nat n1 n2 -> Eq Nat (S n1) (S n2) =\n [n1:Nat, n2:Nat]p: Eq Nat n1 n2]\n eqf Nat Nat S n1 n2 p;\n\nFix rightUnit [n:Nat] : Eq Nat n (plus n 0) =\n <: [n:Nat] Eq Nat n (plus n 0) :\n Cases n of\n 0 => refl_equal Nat 0\n | S n' => eqfNatS n' (plus n' 0) (rightUnit n')\n End;\n\ntype eqTrans =\n [k: Prop][t1:k, t2: k, t3: k][p1: Eq k t1 t2][p2: Eq k t2 t3]\n Leibniz k t2 ([t:k] Eq k t1 t) p1 t3 p2;\n\nFix succPlus [n1:Nat]: (n2:Nat) Eq Nat (S (plus n1 n2)) (plus n1 (S n2)) =\n [n2:Nat]\n <: [n:Nat] Eq Nat (S (plus n n2)) (plus n (S n2)) :\n Cases n1 of\n 0 => refl_equal Nat (S n2)\n | S n1' => eqfNatS (plus (S n1') n2)\n (plus n1' (S n2)) (succPlus n1' n2)\n End;\n\nFix plusSym [n1:Nat] : (n2:Nat) Eq Nat (plus n1 n2) (plus n2 n1) =\n [n2: Nat]\n <: [n:Nat] Eq Nat (plus n n2) (plus n2 n) :\n Cases n1 of\n 0 => rightUnit n2\n | S n1' =>\n eqTrans Nat (plus (S n1') n2)\n (S (plus n2 n1')) (plus n2 (S n1'))\n eqfNatS (plus n1' n2) (plus n2 n1') (plusSym n1' n2)\n (succPlus n2 n1')\n End\n\nFigure 3.9: More PL terms (Figure 3.8 continued)\n3.3. SAMPLE VERO PROGRAMS\n\n3.3.2 CL Programs\n\nThe following program defines a polymorphic list:\n\n```verbatim\ntype rec list : Kind -> Kind =\n [a : Kind] nil | cons of a*(list a);\n```\n\nThe sort Kind corresponds to the \\( \\Omega \\) in the internal language. To simplify the syntax, we collapse the PL and the type language of CL, which can be distinguished by the sorts. The reserved word rec shows that the type list is a recursive type constructor.\n\nWe define the packaged nat type and the add function in the following program, as proposed in the TSCB paper [SSTP02].\n\n```verbatim\ntype nat : Kind = <n : Nat> snat n;\nval add : nat * nat -> nat =\n fn ns : nat * nat =>\n let val n1 = #1 ns\n val n2 = #2 ns\n open < n1', sn1 > = n1\n open < n2', sn2 > = n2\n in\n pack n = plus n1' n2'\n with sn1 + sn2 : snat n\n end\nend;\n```\n\nThe type expression \\(<n : Nat> snat n\\) represents the existential type \\( \\exists n : Nat. s\\text{Nat}[n] \\); expression open \\(< n1', sn1 > = n1\\) corresponds to the term let \\((n'_1, sn_1) = n_1\\) in ...; and the pack expression in the form of pack \\(t = t1 with e : t2\\) end corresponds to the term \\((t = t_1, e : t_2)\\).\n\nNow we implement the function that computes the length of a function:\n\n```verbatim\nval a_zero : nat =\n pack n = 0\n with 0 : snat n\nEnd;\nval a_one : nat =\n pack n = S 0\n with 1 : snat n\nEnd;\nval rec length : (a:Kind)list a -> nat =\n [a:Kind]fn l : list a =>\n case l of nil => a_zero\n | cons x =>\n let\n val lth = length[a] (#2 x)\n in\n add (a_one, lth)\n End;\n```\nAt present we do not support general pattern matching, which will be our future work.\n\nWhat follows is the list type constructor indexed by its length, as shown in Section 2.3.2:\n\n```ml\ntype rec llist : Kind -> Nat -> Kind =\n[t:Kind, n:Nat]\n { lnil of <p1: Eq Nat 0 n > unit\n | lcons of < n' : Nat >\n < p2: Eq Nat (S n') n > t * (llist t n')\n};\n```\n\nThe curly brackets enclose the labeled sum type, which has similar syntax with the SML datatype declaration.\n\nThe problem of above list type constructor is that llist Nat (plus n1 n2) is treated as different type with llist Nat (plus n2 n1), because the PL terms plus n1 n2 and plus n2 n1 are two different normal forms and not βη-equivalent.\n\nHere we implement the solution proposed in [SSTP02]. First we present a new version of llist:\n\n```ml\ntype listP : Kind -> Nat -> Kind =\n[t:Kind, n:Nat] < n' : Nat, p: Eq Nat n n' > llist t n';\n```\n\nThe function listCvt converts a list of type llist a n to a list of type listP a n, and function cvt2 converts a list of type listP a (plus n1 n2) to a list of type listP a (plus n2 n1):\n\n```ml\nval listCvt : (t:Kind, n:Nat) llist t n -> listP t n =\n[t:Kind, n:Nat]\n fn l : llist t n =>\n pack n' = n\n with (pack p = refl_equal Nat n\n with l : llist t n\n end) : < p: Eq Nat n n'> llist t n'\n end;\n```\n\n```ml\nval cvt2 : (t:Kind, n1:Nat, n2:Nat) listP t (plus n1 n2) -> listP t (plus n2 n1) =\n[t:Kind, n1:Nat, n2:Nat]\n fn l : listP t (plus n1 n2) =>\n let open < n1', pk > = l\n open < p, l' > = pk\n type pl1 = eqTrans Nat (plus n1 n1) (plus n1 n2)\n n1' (plusSym n2 n1) p\n in\n pack n' = n1'\n with (pack p = pl1\n with l' : llist t n1'\n End) : < p: Eq Nat (plus n2 n1) n'> llist t n'\n end\n```\n\nend\nChapter 4\n\nImplementation\n\nAs part of the project, I implemented a type checker of Vero. For such a richly typed language like Vero, it is not an easy task to implement the type checker efficiently. As presented by Shao, League and Mommier [SLM98], even for such simple types like: \\( T_n = T_{n_1} \\to T_{n_2}, \\ldots, T_1 = \\alpha \\to \\alpha \\), a naive representation of \\( T_n \\) like a tree structure would require \\( O(2^n) \\) space, so a sufficiently small \\( n \\) (e.g., 30) would wreak the efficiency of the compiler.\n\nIn this chapter, I give a detailed introduction of my implementation of the type checker. Most of the implementation is based on the work by Shao, League and Mommier [SLM98], and Saha [Sah02].\n\n4.1 Implementing a PTS-like type system\n\nFrom the syntax of the surface language of Vero, user may have noticed that we collapsed the PL and the type language of CL into one. It is mainly for the ease of syntax design. In our implementation, we stick with such strategy so that we can have a quick and clear implementation.\n\nAfter the collapse, the whole type system is like a PTS with extension of inductive types, case analysis and fixpoints, recursive types, record and union types, and primitive types. The datatype \\texttt{stem} used for representing type terms is shown below (we use the name \\texttt{stem} because we are using suspension-based lambda encoding [Nad94] to represent types):\n\n\\[\n\\begin{array}{l}\n\\texttt{datatype} \\quad \\texttt{sort} \\\\\n\\quad \\texttt{Kind} \\\\\n\\quad | \\quad \\texttt{Top} \\\\\n\\quad | \\quad \\texttt{Prop} \\\\\n\\quad | \\quad \\texttt{Type} \\\\\n\\quad | \\quad \\texttt{Ext}\n\\end{array}\n\\]\n\n49\nCHAPTER 4. IMPLEMENTATION\n\ndatatype stemfl\n - Var of int * stem (* variable & its kind *)\n - Sort of sort (* sorts *)\n - Tcon of tycons * stem (* primitive types and their kinds *)\n - All of stem * stem (* Pi type *)\n - Fn of stem * stem (* abstraction *)\n - App of stem * stem (* application *)\n - Seq of stem list (* auxiliary type, no counterpart in Vero *)\n - Ind of stem * int * stem list (* inductive definition *)\n - Con of stem * int * int * stem list (* constructors of inductive definition *)\n - Fix of int list * stem * int * stem list (* fixpoint *)\n - Case of stem * stem * stem list (* case analysis *)\n - Ex of stem * stem (* existential *)\n - Record of (symbol * stem) list (* record *)\n - Union of (symbol * stem) list (* union *)\n - Rec of stem * int (* μ *)\n - Env of stem * int * int * suspEnv (* suspension term *)\n - ITK of stem * stemfl (* for memoise *)\nand\n - Dummy of int\n - Pair of stem * int\nwith\n - suspEnv — stem list\nand\n - stem — stemfl hash_cell\n\n... \n\nThe datatype is very close to Saha’s implementation of PTS [Sah02], with some extension and revision. Here the sort Kind denotes $\\Omega$ in CL, and Kind : Top. Prop, Type and Ext correspond to Prop, Type and Ext in PL, respectively.\n\nWe use deBruijn indices [De 80] for variables. Thus a term of the form\n\n$$\\lambda X : A.A \\lambda Y : X \\ldots Y \\ldots X \\ldots$$\n\nis represented as\n\n$$\\lambda_\\ldots : A.\\lambda_\\ldots : \\#1 \\ldots \\#1 \\ldots \\#2 \\ldots$$\n\nwhere the variable is denoted by its lexical depth. This is useful because two $\\alpha$-equivalent terms now have the same representation. Our representation of variables memoize more information than Saha’s implementation [Sah02]. Here instead of just memoizing the sort of variables, we memoize their kinds. Therefore when we see variable #2 in above type term, we do not have to go back to the first $\\lambda$ to see it has kind $A$. Also since we use dag to represent type terms, this information redundancy will not consume much space (we need just one more reference).\n\nSimilarly, for primitive types, denoted as $Tcon(c, k)$, we also memoize the kind $k$ of the primitive type $c$.\n\nUsing deBruijn indices, the abstraction $\\lambda X : A.B$ and production $\\Pi X : A.B$ are denoted as $Fn(st_A, st_B)$ and $All(st_A, st_B)$ respectively, where $st_A$ and $st_B$\nare representations of \\(A\\) and \\(B\\).\n\nThe mechanism for inductive definition is more general than that presented in Chapter 2. The implementation allows mutually recursive, parameterized inductive definitions. Also, in our implementation, we use \\texttt{Case} and \\texttt{Fix} to simulate the primitive recursion operator \\texttt{Elim} presented in Chapter 2. The formation rules and the reduction rules for these constructs is entirely standard. This approach was formalized and proved equivalent to the primitive recursive approach in [Gim94]. We use the same formalization in our implementation. The implementation of \\texttt{Ind}, \\texttt{Con}, \\texttt{Fix} and \\texttt{Case} is the same with Saha’s [Sah02].\n\nThe existential type, record type, union type, and recursive type in CL are encoded using constructors \\texttt{Ex}, \\texttt{Record}, \\texttt{Union} and \\texttt{Rec}. The first three are standard treatment. The formalization of recursive type is similar to \\texttt{Ind} and we also support mutual recursively defined types. The only difference between \\texttt{Rec} and \\texttt{Ind} is that we do not record the arguments in \\texttt{Rec}, as we do in \\texttt{Ind}.\n\nThe \\texttt{Env} and \\texttt{ITK} representation will be explained in the next two sections.\n\nHere all the type terms are represented as dags. The datatype \\texttt{sterm} is a reference pointing to a term of type \\texttt{sterm1}, packaged with memoized information. It will be explained in following sections.\n\n## 4.2 Suspension-based lambda encoding\n\nType reduction is done lazily in our implementation. To achieve this, we use the suspension-based lambda encoding, which was proposed in [Nad94] and used in the implementation of FLINT [SLM98] and Saha’s implementation of PTS system [Sah02]. Here we borrow Saha’s formulation, with some extension for CL terms.\n\nThe suspension terms are introduced by the \\texttt{Env} constructor. Intuitively, these suspension terms are a form of closures: they are a pair of a type and an environment containing the values of the free variables. Reductions change the nesting depth of type terms which changes the deBruijn indices of variables. Therefore, the environment formed during a reduction must remember both the required substitutions and the change in DeBruijn indices. Accordingly, the environments are represented as a triple \\((i, j, env)\\) where the first index \\(i\\) indicates the current embedding level of the term, the second index \\(j\\) indicates the embedding level after the reduction, and the \\(env\\) is a mapping between variables (deBruijn indices) to terms.\n\nFigure 4.2 shows how we use these suspension terms. Since the sort of a variable plays no role in the reductions, we represent variables only by their deBruijn index. During a \\(\\beta\\)-reduction, instead of performing the substitution directly, we create a suspension term. The environment represents the following: the term \\(p_2\\) that was originally in the scope of 1 abstraction is now under none; \\(p_3\\) originally under the scope of 0 abstractions is to be substituted for the first free variable in \\(p_2\\). In the other cases we propagate the suspensions through to the subterms. This allows us to do the substitution lazily; we query the environment only when we encounter a variable during type manipulations. In\nthe case of a free variable, we simply adjust its DeBruijn index; in the case of a bound variable, we use the value from the environment.\n\n4.3 Hash-consing and memoization\n\nIn our implementation, we hash-cons all types into one hash table. Under hash-consing, all types are guaranteed to use the most compact dag representation. Because we are using deBruijn notation, type variables are represented as integers and all $\\alpha$-convertible types have identical representations, which allow them to be collapsed via hash-consing.\n\nEach hash cell is defined as a mutable 4-tuple, with the following data type:\n\n```\n type 'a hash_cell = (int * 'a * aux_info * 'a option ref) ref.\n```\n\nRemember the type `stem` is defined as `stem1 hash_cell`. Therefore a hash cell containing a type has the following fields: the first field is an integer hash code; the second is the actual denotation of the type; the third is a set of auxiliary information, which includes a flag that shows whether the type in the second field is in normal form or not, and if so, the set of free variables denoted in deBruijn indices. Compared with the implementation by [SLM98] and [Sah02], here we have one more field, i.e. an optional field of the kind of the type. After type checking a term, we memoize its kind so that we can avoid duplicate checking of $\\alpha$-equivalent term.\n\nWe also memoize the result of every sequence of reduction of each term, as in [SLM98] and [Sah02]. Given a term `ref(h, t, aux, k)`, suppose $t$ can be reduced to $t'$; then, we can do in-place update, changing the second field of $t$ to a term $ITK(inj(t'), t)$, where $inj(t')$ is the hash cell containing the term $t'$.\n\n4.4 Other issues to worked on\n\nAlthough we have not run our type checker over benchmarks, according to the experience of [SLM98] and [Sah02], the combination of the lazy reduction, hash-consing and memoization is very effective: we have fast type equality operation, compact space usage, and linear-time traversal of types.\n\nHowever, there still some issues for future work. One problem is to effectively represent `Nat` in PL. Since each natural number $\\pi$ in CL has type $s_{\\text{Nat}}[\\tilde{n}]$. For a large natural number literal, we would have very inefficient denotation of its type. It is possible to introduce some compact notation of $\\tilde{n}$ rather than the `unary` notation. If we need to destruct $\\tilde{n}$, we can lazily unroll it back to the canonical denotation. Another problem is to efficiently implement the bound integer numbers and other data types in PL. This is essential to make Vero a practical language.\n4.4. OTHER ISSUES TO WORKED ON\n\n\\[\n\\begin{align*}\n\\text{App}(Fn(p_1, p_2), p_3) & \\leadsto Env(p_2, 1, 0, [\\text{Pair}(p_3, 0)]) \\quad (\\beta - \\text{redex}) \\\\\n\\text{Env}(\\text{Var}(n, \\_, i, j, \\text{env})) & \\leadsto \\text{Var}(n - i + j) \\quad n > i \\quad (\\text{free variable}) \\\\\n\\text{Env}(\\text{Var}(n, \\_, i, j, \\text{env})) & \\leadsto \\text{Env}(p_1, 0, j - j', []) \\quad n^{th} \\text{element} \\\\\n& \\quad \\text{of env} = \\text{Pair}(j', p_1) \\quad (\\text{bound variable}) \\\\\n\\text{Env}(T\\text{con} c, i, j, \\text{env}) & \\leadsto T\\text{con} c \\\\\n\\text{Env}(\\text{Sort} s, i, j, \\text{env}) & \\leadsto \\text{Sort} s \\\\\n\\text{Env}(\\text{Fn}(p_1, p_2), i, j, \\text{env}) & \\leadsto \\text{Fn}(pr_{i,j}^\\text{env}(p_1), ext_{i,j}^\\text{env}(p_2)) \\\\\n\\text{Env}(\\text{All}(p_1, p_2), i, j, \\text{env}) & \\leadsto \\text{All}(pr_{i,j}^\\text{env}(p_1), ext_{i,j}^\\text{env}(p_2)) \\\\\n\\text{Env}(\\text{App}(p_1, p_2), i, j, \\text{env}) & \\leadsto \\text{App}(pr_{i,j}^\\text{env}(p_1), pr_{i,j}^\\text{env}(p_2)) \\\\\n\\text{Env}(\\text{Ind}(p_1, i', p'), i, j, \\text{env}) & \\leadsto \\text{Ind}(pr_{i,j}^\\text{env}(p_1), i', pr_{i,j}^\\text{env}(p')) \\\\\n\\text{Env}(\\text{Con}(p_1, i', j', p'), i, j, \\text{env}) & \\leadsto \\text{Con}(pr_{i,j}^\\text{env}(p_1), i', j', pr_{i,j}^\\text{env}(p')) \\\\\n\\text{Env}(\\text{Fix}(\\bar{i}, p_1, i', p'), i, j, \\text{env}) & \\leadsto \\text{Fix}(\\bar{i}, pr_{i,j}^\\text{env}(p_1), i', pr_{i,j}^\\text{env}(p')) \\\\\n\\text{Env}(\\text{Case}(p_1, p_2, p'), i, j, \\text{env}) & \\leadsto \\text{Case}(pr_{i,j}^\\text{env}(p_1), pr_{i,j}^\\text{env}(p_2), pr_{i,j}^\\text{env}(p')) \\\\\n\\text{Env}(\\text{Seq}(p'), i, j, \\text{env}) & \\leadsto \\text{Seq}(pr_{i,j}^\\text{env}(p')) \\\\\n\\text{Env}(\\text{Ex}(p_1, p_2), i, j, \\text{env}) & \\leadsto \\text{Ex}(pr_{i,j}^\\text{env}(p_1), pr_{i,j}^\\text{env}(p_2)) \\\\\n\\text{Env}(\\text{Record}(l_i, p_1), i, j, \\text{env}) & \\leadsto \\text{Record}(l_i, pr_{i,j}^\\text{env}(p_1)) \\\\\n\\text{Env}(\\text{Union}(l_i, p_1), i, j, \\text{env}) & \\leadsto \\text{Union}(l_i, pr_{i,j}^\\text{env}(p_1)) \\\\\n\\text{Env}(\\text{Rec}(p, i'), i, j, \\text{env}) & \\leadsto \\text{Rec}(pr_{i,j}^\\text{env}(p), i')\n\\end{align*}\n\\]\n\nwhere\n\n\\[\n\\begin{align*}\npr_{i,j}^\\text{env}(p) & \\equiv \\text{Env}(p, i, j, \\text{env}) \\\\\next_{i,j}^\\text{env}(p) & \\equiv \\text{Env}(p, i + 1, j + 1, (\\text{Dummy} \\; j :: \\text{env}))\n\\end{align*}\n\\]\n\nFigure 4.1: Using suspension terms for lazy reduction\nChapter 5\n\nConclusion and Future Work\n\nIn this report we presented the design and implementation of the Vero language. Both the internal (core) language and the surface (core) language of Vero are presented in the report. We also formulated the static and dynamic semantics, and proved the type safety of Vero. Some sample programs were presented to show the expressiveness of the language.\n\nThe current version of Vero is still a quite simplified version, in which we just concentrate on the design of the strong type system of the core language, and explore the expressiveness of such a language. A lot of orthogonal but important issues are omitted. To make Vero a practical language, we need to solve the following problems in our future work:\n\n1. At present we use CIC as the meta-logical framework. Although CIC provides a powerful meta-logic, it has a lot of restrictions for representation, such as the requirement of positiveness in inductive definitions. This makes it sometimes clumsy to use. In the future we will explore the possibility to have a MLF with the expressive power of the logical framework (e.g., LF) and the reasoning power of a modern proof assistant (e.g., Coq). Such a MLF will also pose new challenges to our design of the computation language. For instance, if an MLF representation $d$ uses higher-order abstract syntax, how do we use its terms to index a datatype definition $D$ (which usually uses first-order representations)?\n\n2. Vero is the first language that supports explicit handling of proof objects. A Vero program may contain both MLF terms (e.g., inductive definitions, primitive recursive functions) and usual Vero computation terms (e.g., concrete datatype definitions, recursive functions). We want to extend and adapt the ML-style module system to provide scalable support to large-scale CPL programs. Actually, since we have existential types in CL, which can package either types in CL or MLF terms, we have the potential to support first-class module systems in Vero. However, that would destroy the current clean design, which does not have circular dependency. That is, in our current design, the computation term might depend on\ntypes or MLF terms, while a type only depends on MLF terms, and MLF terms have no dependency with computation terms and types. If we add first-class module system, types and MLF terms will in turn depend on modules, which are now first-class computation terms. We need some research to introduce some clean formulation and make sure this will not introduce inconsistency.\n\n3. Indexed data type definitions such as singleton integer types and guarded recursive data types [XCC03] are the key facility to link the computation term with the MLF representation. We want to explore its design space and see how different decisions affect the usability and expressiveness. We’ll also design more powerful pattern matching support to make programming with these data types easier.\n\n4. Both the PL and the CL of the current version of Vero is explicitly typed. To make it more easy to use, we need to provide partial type inference support, as did in Coq [Tea03]. Also the way to define indexed data types requires repeated work (see our definition of singleton list in Section 2.3.2). Given a PL inductive definition, it would be desirable to automatically generate the corresponding indexed datatype definition. Although we have proposed some approaches in this report, they are just experimental approaches and need further research.\n\n5. There are some other implementation issues to be worked on, such as add exception handling and reference to the computation language, build libraries for both PL and CL, or more preferably, develop tools that can transform SML and Coq code to Vero CL and PL code so that we can take advantage of existing SML and Coq libraries.\nBibliography\n\n\nAppendix A\n\nType Safety of CL\n\nLemma A.1 (Canonical Forms) Suppose that \\( v \\) is a well-formed value and we have \\( \\vdash \\vdash \\vdash v : \\tau \\).\n\n1. If \\( \\vdash \\vdash \\vdash v : \\text{unit} \\), then \\( v \\equiv () \\).\n2. If \\( \\vdash \\vdash \\vdash v : s_{\\text{Nat}}[A] \\), then \\( v \\equiv \\pi\\overline{n} \\) and \\( \\overline{n} = _{\\beta n} A \\), for some \\( n \\).\n3. If \\( \\vdash \\vdash \\vdash v : s_{\\text{Bool}}[A] \\), then either \\( v \\equiv \\text{tt} \\) and \\( A = _{\\beta n} \\text{true} \\), or \\( v \\equiv \\text{ff} \\) and \\( A = _{\\beta n} \\text{false} \\).\n4. If \\( \\vdash \\vdash \\vdash v : \\tau_1 \\rightarrow \\tau_2 \\), then \\( v \\equiv \\lambda x : \\tau_1.e \\) for some \\( x \\) and \\( e \\).\n5. If \\( \\vdash \\vdash \\vdash v : \\forall t : \\kappa.\\tau \\), then \\( v \\equiv \\Lambda t : \\kappa.e \\) for some \\( e \\).\n6. If \\( \\vdash \\vdash \\vdash v : \\forall X : A.\\tau \\), then \\( v \\equiv \\Lambda X : A.e \\) for some \\( e \\).\n7. If \\( \\vdash \\vdash \\vdash v : \\{l_1 : \\tau_1, \\ldots, l_n : \\tau_n\\} \\), then \\( v \\equiv \\{l_1 = v_1, \\ldots, l_n = v_n\\} \\) for some \\( v_1, \\ldots, v_n \\).\n8. If \\( \\vdash \\vdash \\vdash v : \\tau_1 + \\tau_2 \\), then either \\( v \\equiv \\text{inj}_{1}^{1+\\tau_2}v_1 \\) for some \\( v_1 \\), or \\( v \\equiv \\text{inj}_{2}^{1+\\tau_2}v_2 \\) for some \\( v_2 \\).\n9. If \\( \\vdash \\vdash \\vdash v : \\mu_\\kappa(\\tau_1, \\tau_2) \\), then \\( v \\equiv \\text{fold}_{1}^{\\mu_\\kappa(\\tau_1, \\tau_2)}v' \\) for some \\( v' \\).\n10. If \\( \\vdash \\vdash \\vdash v : \\exists t : \\tau.\\tau' \\), then \\( v \\equiv \\langle t = \\tau, v' : \\tau' \\rangle \\) for some \\( v' \\).\n11. If \\( \\vdash \\vdash \\vdash v : \\exists X : A.\\tau \\), then \\( v \\equiv \\langle X = A, v' : \\tau \\rangle \\) for some \\( v' \\).\n\nProof. We can draw the conclusion by a simple inspection of the expression formation rules shown in Figure 2.8 and 2.9, using the fact that \\( v \\) is a value. \\( \\square \\)\n\nTheorem A.2 (Progress) If \\( \\vdash \\vdash \\vdash e : \\tau \\), then either \\( e \\) is a value, or there exists \\( e' \\) such that \\( e \\rightarrow e' \\).\n\nProof. We prove it by induction on the type derivation for \\( e \\). We analyze the cases corresponding to the last expression formation rule used in the type derivation.\n(Rule E-VAR) Cannot occur, since we require empty contexts.\n\n(Rules E-UNIT, E-NAT, E-TRUE, E-FALSE, E-FN, E-TFN1 and E-TFN2) In each case $e$ is a value, which completes the proof.\n\n(Rule E-ADD) We require that $e \\equiv e_1 + e_2$ for some $e_1$ and $e_2$, and $\\vdash \\cdots \\vdash e_1 : s_{\\text{Nat}}[A_1]$ and $\\vdash \\cdots \\vdash e_2 : s_{\\text{Nat}}[A_2]$, and $\\tau \\equiv s_{\\text{Nat}}[\\text{plus } A_1 A_2]$. By induction hypothesis, there are three cases.\n\n- $e_1$ and $e_2$ are values. According to Lemma A.1, there exist $n_1$ and $n_2$ such that $e_1 \\equiv \\frac{n_1}{\\tau_1}$ and $e_2 \\equiv \\frac{n_2}{\\tau_2}$. By reduction rule R-ADD, $e_1 + e_2 \\hookrightarrow n_1 + n_2$. Therefore $e \\mapsto \\bullet\\{n_1 + n_2\\}$.\n\n- $e_1 \\mapsto e'_1$ for some $e'_1$. Therefore $e_1 \\equiv E_1\\{e_{11}\\}$ and $e'_1 \\equiv E_1\\{e'_{11}\\}$ for some evaluation context $E_1$ and redex $e_{11}$ such that $e_{11} \\hookrightarrow e'_{11}$. Then $e \\mapsto E\\{e'_{11}\\}$, where $E \\equiv E_1 + e_2$.\n\n- $e_1$ is a value and $e_2 \\mapsto e'_2$ for some $e'_2$. The proof is similar to the above case.\n\n(Rule E-LT) We require that $e \\equiv e_1 \\lt e_2$ for some $e_1$ and $e_2$, and $\\vdash \\cdots \\vdash e_1 : s_{\\text{Nat}}[A_1]$ and $\\vdash \\cdots \\vdash e_2 : s_{\\text{Nat}}[A_2]$, and $\\tau \\equiv s_{\\text{Bool}}[\\text{lt } A_1 A_2]$.\n\nThe following proof is similar to the above case.\n\n(Rule E-IF) We require that $e \\equiv \\text{if } [B, A](e_0, X_1, e_1, X_2, e_2)$, and $\\vdash \\cdots \\vdash e_0 : s_{\\text{Bool}}[A']$. By induction hypothesis, there are two cases.\n\n- $e_0$ is a value. According to Lemma A.1, either $e_0 \\equiv \\text{tt}$ or $e_0 \\equiv \\text{ff}$. If $e_0 \\equiv \\text{tt}$, by reduction rule R-IF-T, if $[B, A](e_0, X_1, e_1, X_2, e_2) \\hookrightarrow [A/X_1]e_1$. Therefore $e \\mapsto \\bullet\\{[A/X_1]e_1\\}$. Otherwise, by reduction rule R-IF-F we know if $[B, A](e_0, X_1, e_1, X_2, e_2) \\hookrightarrow [A/X_2]e_2$. Therefore $e \\mapsto \\bullet\\{[A/X_2]e_2\\}$.\n\n- $e_0 \\mapsto e'_0$ for some $e'_0$. Therefore $e_0 \\equiv E_0\\{e_{01}\\}$ and $e'_0 \\equiv E_0\\{e'_{01}\\}$ for some evaluation context $E_0$ and redex $e_{01}$ such that $e_{01} \\hookrightarrow e'_{01}$. Then $e \\mapsto E\\{e'_{01}\\}$, where $E \\equiv \\text{if } [B, A](E_0, X_1, e_1, X_2, e_2)$.\n\n(Rule E-FIX) We require that $e \\equiv \\text{fix } x : \\tau.f$ for some $x$ and $f$. According to the reduction rule R-FIX, $\\text{fix } x : \\tau.f \\hookrightarrow [\\text{fix } x : \\tau.f/x]f$. Therefore $e \\mapsto \\bullet\\{[\\text{fix } x : \\tau.f/x]f\\}$.\n\n(Rule E-APP) We require that $e \\equiv e_1 e_2$ for some $e_1$ and $e_2$. By induction hypothesis, there are three cases.\n\n- $e_1$ and $e_2$ are values. According to Lemma A.1, there exist $\\tau_1$, $x$ and $e'_1$ such that $e_1 \\equiv \\lambda x : \\tau_1.e'_1$. By reduction rule R-\\(\\beta\\), $e_1 e_2 \\hookrightarrow [e_2/x]e'_1$. Therefore $e \\mapsto \\bullet\\{[e_2/x]e'_1\\}$.\n• $e_1 \\mapsto e'_1$ for some $e'_1$. Therefore $e_1 \\equiv E_1 \\{e_{11}\\}$ and $e'_1 \\equiv E_1 \\{e'_{11}\\}$ for some evaluation context $E_1$ and redex $e_{11}$ such that $e_{11} \\mapsto e'_{11}$. Then $e \\mapsto E \\{e'_{11}\\}$, where $E \\equiv E_1 e_2$.\n\n• $e_1$ is a value and $e_2 \\mapsto e'_2$ for some $e'_2$. The proof is similar to the above case.\n\n(Rule E-tapp1) We require that $e \\equiv e_0[\\tau_0]$ and $\\tau \\equiv [\\tau_0/t]\\tau'$ for some $e_0$, $\\tau_0$, $t$ and $\\tau'$. By induction hypothesis, there are two cases.\n\n• $e_0$ is a value. According to Lemma A.1, there exist $\\kappa$ and $e_1$ such that $e_0 \\equiv \\Lambda : \\kappa \\cdot e_1$. By reduction rule R-tapp1, $e_0[\\tau_0] \\mapsto [\\tau_0/t]e_1$. Therefore $e \\mapsto \\bullet ([\\tau_0/t]e_1)$.\n\n• $e_1 \\mapsto e'_1$ for some $e'_1$. Therefore $e_1 \\equiv E_1 \\{e_{11}\\}$ and $e'_1 \\equiv E_1 \\{e'_{11}\\}$ for some evaluation context $E_1$ and redex $e_{11}$ such that $e_{11} \\mapsto e'_{11}$. Then $e \\mapsto E \\{e'_{11}\\}$, where $E \\equiv E_1[\\tau_0]$.\n\n(Rule E-tapp2) Similar to the proof of the above case.\n\n(Rule E-str) We require that $e \\equiv \\{l_1 = e_1, \\ldots, l_n = e_n\\}$ and $\\tau \\equiv \\{l_1 : \\tau_1, \\ldots, l_n : \\tau_n\\}$ for some $l_i, e_i$ and $\\tau_i$, ($1 \\leq i \\leq n$). By induction hypothesis, there are two cases.\n\n• For $i = 1, \\ldots, n$, all the $e_i$ are values. Then $e$ is itself a value.\n\n• Without loss of generality, we assume that the first expression among all the $e_i$ ($i = 1, \\ldots, n$) that is not a value is $e_j$, ($1 \\leq j \\leq n$). $e_j \\mapsto e'_j$ for some $e'_j$. Therefore $e_j \\equiv E_1 \\{e_{j}, \\ldots, e_{n}\\}$ and $e'_j \\equiv E_1 \\{e'_{j}, \\ldots, e_{n}\\}$ for some evaluation context $E_1$ and redex $e_{j}$ such that $e_{j} \\mapsto e'_{j}$. Then $e \\mapsto E \\{e'_{j}\\}$, where $E \\equiv \\{l_1 = e_1, \\ldots, l_{j-1} = e_{j-1}, l_j = E_1, l_{j+1} = e_{j+1}, \\ldots, l_n = e_n\\}$ (Note that $e_1, \\ldots, e_{j-1}$ are all values).\n\n(Rule E-proj) We require that $e \\equiv e_0.l_j$ for some $e_0$ and $l_j$. By induction hypothesis, there are two cases.\n\n• $e_0$ is a value. According to Lemma A.1, there exist $l_i$ and $v_i$ for $i = 1, \\ldots, n$, such that $e_0 \\equiv \\{l_1 = v_1, \\ldots, l_n = v_n\\}$, and $1 \\leq j \\leq n$. By reduction rule R-proj, $e_0.l_j \\mapsto v_j$. Therefore $e \\mapsto \\bullet (v_j)$.\n\n• $e_0 \\mapsto e'_0$ for some $e'_0$. Therefore $e_0 \\equiv E_1 \\{e_{0j}\\}$ and $e'_0 \\equiv E_1 \\{e'_{0j}\\}$ for some evaluation context $E_1$ and redex $e_{0j}$ such that $e_{0j} \\mapsto e'_{0j}$. Then $e \\mapsto E \\{e'_{0j}\\}$, where $E \\equiv E_1.l_j$. \n\n63\n(Rule E-INJL) We require that $e \\equiv \\text{inj}_{\\tau_1 \\rightarrow \\tau_2}^{\\tau_1} e_1$ for some $\\tau_1$, $\\tau_2$ and $e_1$. By induction hypothesis, there are two cases.\n\n- $e_1$ is a value. Then $e$ is itself a value.\n- $e_1 \\mapsto e'_1$ for some $e'_1$. Therefore $e_1 \\equiv E_1 \\{e_{11}\\}$ and $e'_1 \\equiv E_1 \\{e'_{11}\\}$ for some evaluation context $E_1$ and redex $e_{11}$ such that $e_{11} \\mapsto e'_{11}$. Then $e \\mapsto E \\{e'_{11}\\}$, where $E \\equiv \\text{inj}_{\\tau_1 \\rightarrow \\tau_2}^{\\tau_1} E_1$.\n\n(Rule E-INJR) The proof is similar to the above case.\n\n(Rule E-CASE) We require that $e \\equiv \\text{case} e_0, e_1, e_2$ for some $e_0$, $e_1$ and $e_2$. By induction hypothesis, there are two cases.\n\n- $e_0$ is a value. According to Lemma A.1, either $e_0 \\equiv \\text{inj}_{\\tau_1 \\rightarrow \\tau_2}^{\\tau_1} v_1$ or $e_0 \\equiv \\text{inj}_{\\tau_1 \\rightarrow \\tau_2}^{\\tau_2} v_2$ for some $v_1$, $v_2$, $\\tau_1$ and $\\tau_2$. Accordingly, by reduction rule R-CASE1 and R-CASE2, we have either $e \\mapsto e_1 v_1$ or $e \\mapsto e_2 v_2$. Therefore either $e \\mapsto \\bullet \\{e_1 v_1\\}$ or $e \\mapsto \\bullet \\{e_2 v_2\\}$.\n- $e_0 \\mapsto e'_0$ for some $e'_0$. Therefore $e_0 \\equiv E_1 \\{e_{00}\\}$ and $e'_0 \\equiv E_1 \\{e'_{00}\\}$ for some evaluation context $E_1$ and redex $e_{00}$ such that $e_{00} \\mapsto e'_{00}$. Then $e \\mapsto E \\{e'_{00}\\}$, where $E \\equiv \\text{case} E_1, e_1, e_2$.\n\n(Rule E-FOLD) We require that $e \\equiv \\text{fold}^{\\mu_{\\kappa}(\\tau_1, \\tau_2)} \\kappa \\tau_1 \\tau_2 e_1$ for some $\\kappa$, $\\tau_1$, $\\tau_2$ and $e_1$. By induction hypothesis, there are two cases.\n\n- $e_1$ is a value. Then $e$ is itself a value.\n- $e_1 \\mapsto e'_1$ for some $e'_1$. Therefore $e_1 \\equiv E_1 \\{e_{11}\\}$ and $e'_1 \\equiv E_1 \\{e'_{11}\\}$ for some evaluation context $E_1$ and redex $e_{11}$ such that $e_{11} \\mapsto e'_{11}$. Then $e \\mapsto E \\{e'_{11}\\}$, where $E \\equiv \\text{fold}^{\\mu_{\\kappa}(\\tau_1, \\tau_2)} \\kappa \\tau_1 \\tau_2 E_1$.\n\n(Rule E-UNFLD) We require that $e \\equiv \\text{unfold} e_1$ and $\\tau \\equiv \\mathsf{K}(\\kappa, \\tau_1, \\tau_2)$ for some $\\kappa$, $\\tau_1$, $\\tau_2$ and $e_1$. By induction hypothesis, there are two cases.\n\n- $e_1$ is a value. According to Lemma A.1, $e_1 \\equiv \\text{fold}^{\\mu_{\\kappa}(\\tau_1, \\tau_2)} \\kappa \\tau_1 \\tau_2 v_1$. By reduction rule R-UNFD, $e \\mapsto v_1$. Therefore $e \\mapsto \\bullet \\{v_1\\}$.\n- $e_1 \\mapsto e'_1$ for some $e'_1$. Therefore $e_1 \\equiv E_1 \\{e_{11}\\}$ and $e'_1 \\equiv E_1 \\{e'_{11}\\}$ for some evaluation context $E_1$ and redex $e_{11}$ such that $e_{11} \\mapsto e'_{11}$. Then $e \\mapsto E \\{e'_{11}\\}$, where $E \\equiv \\text{unfold} E_1$.\n\n(Rule E-PACK1) We require that $e \\equiv \\langle t = \\tau, e_1 : \\tau' \\rangle$ and $\\tau \\equiv \\exists t : \\kappa. \\tau'$. By induction hypothesis, there are two cases.\n\n- $e_1$ is a value. Then $e$ is itself a value.\n- $e_1 \\mapsto e'_1$ for some $e'_1$. Therefore $e_1 \\equiv E_1 \\{e_{11}\\}$ and $e'_1 \\equiv E_1 \\{e'_{11}\\}$ for some evaluation context $E_1$ and redex $e_{11}$ such that $e_{11} \\mapsto e'_{11}$. Then $e \\mapsto E \\{e'_{11}\\}$, where $E \\equiv \\langle t = \\tau, E_1 : \\tau' \\rangle$. \n(Rule E-PACK2) The proof is similar to the above case.\n\n(Rule E-LET) We require that \\( e \\equiv \\text{let } x = e_1 \\text{ in } e_2 \\) for some \\( x, e_1 \\) and \\( e_2 \\). By induction hypothesis, there are two cases.\n\n- \\( e_1 \\) is a value. By reduction rule R-LET, \\( e \\mapsto [e_1/x]e_2 \\). Therefore \\( e \\mapsto \\bullet[[e_1/x]e_2] \\).\n- \\( e_1 \\mapsto e'_1 \\) for some \\( e'_1 \\). Therefore \\( e_1 \\equiv E_1\\{e_{11}\\} \\) and \\( e'_1 \\equiv E_1\\{e'_{11}\\} \\) for some evaluation context \\( E_1 \\) and redex \\( e_{11} \\) such that \\( e_{11} \\mapsto e'_{11} \\). Then \\( e \\mapsto E\\{e'_{11}\\} \\), where \\( E \\equiv \\text{let } x = E_1 \\text{ in } e_2 \\). \n\n(Rule E-TLET1) We require that \\( e \\equiv t = \\tau' \\) in \\( e_1 \\) for some \\( t, \\tau' \\) and \\( e_1 \\). By reduction rule R-TLET1, \\( e \\mapsto [\\tau'/t]e_1 \\). Therefore \\( e \\mapsto \\bullet[[\\tau'/t]e_1] \\).\n\n(Rule E-TLET2) The proof is similar to the above case.\n\n(Rule E-OPEN1) We require that \\( e \\equiv \\text{let}(t, x) = e_1 \\) in \\( e_2 \\) for some \\( t, x, e_1 \\) and \\( e_2 \\). By induction hypothesis, there are two cases.\n\n- \\( e_1 \\) is a value. According to Lemma A.1, \\( e_1 \\equiv t' = \\tau_1, v : \\tau_2 \\). By reduction rule R-OPEN1, \\( e \\mapsto [v/x][\\tau_1/t]e_2 \\). Therefore \\( e \\mapsto \\bullet[[v/x][\\tau_1/t]e_2] \\).\n- \\( e_1 \\mapsto e'_1 \\) for some \\( e'_1 \\). Therefore \\( e_1 \\equiv E_1\\{e_{11}\\} \\) and \\( e'_1 \\equiv E_1\\{e'_{11}\\} \\) for some evaluation context \\( E_1 \\) and redex \\( e_{11} \\) such that \\( e_{11} \\mapsto e'_{11} \\). Then \\( e \\mapsto E\\{e'_{11}\\} \\), where \\( E \\equiv \\text{let}(t, x) = E_1 \\text{ in } e_2 \\).\n\n(Rule E-OPEN2) The proof is similar to the above case.\n\n(Rule E-CONV) By induction hypothesis. \n\n\\[ \\square \\]\n\nLemma A.3 (Type Inversion)\n\n1. If \\( \\Gamma; \\Delta; \\Sigma \\vdash x : \\tau \\), then \\( \\tau = \\tau, \\Sigma(x) \\) and \\( \\Gamma; \\Delta \\vdash \\Sigma \\text{ ok} \\).\n2. If \\( \\Gamma; \\Delta; \\Sigma \\vdash () : \\tau \\), then \\( \\tau = \\text{unit} \\) and \\( \\Gamma; \\Delta \\vdash \\Sigma \\text{ ok} \\).\n3. If \\( \\Gamma; \\Delta; \\Sigma \\vdash \\pi : \\tau \\), then \\( \\tau = \\pi, \\text{Nat}[\\widehat{\\pi}] \\) and \\( \\Gamma; \\Delta \\vdash \\Sigma \\text{ ok} \\).\n4. If \\( \\Gamma; \\Delta; \\Sigma \\vdash \\text{tt} : \\tau \\), then \\( \\tau = \\text{true}, \\text{Bool}[\\text{true}] \\) and \\( \\Gamma; \\Delta \\vdash \\Sigma \\text{ ok} \\).\n5. If \\( \\Gamma; \\Delta; \\Sigma \\vdash \\text{ff} : \\tau \\), then \\( \\tau = \\text{false}, \\text{Bool}[\\text{false}] \\) and \\( \\Gamma; \\Delta \\vdash \\Sigma \\text{ ok} \\).\n6. If \\( \\Gamma; \\Delta; \\Sigma \\vdash e_1 \\cdot e_2 : \\tau \\), then \\( \\tau = \\text{Nat}([\\text{plus} A_1 A_2], \\Gamma; \\Delta; \\Sigma \\vdash e_1 : \\text{Nat}[A_1], \\) and \\( \\Gamma; \\Delta; \\Sigma \\vdash e_2 : \\text{Nat}[A_2], \\) for some \\( A_1 \\) and \\( A_2 \\).\n7. If \\( \\Gamma; \\Delta; \\Sigma \\vdash e_1 \\cdot e_2 : \\tau \\), then \\( \\tau = \\text{Nat}([\\text{lt} A_1 A_2], \\Gamma; \\Delta; \\Sigma \\vdash e_1 : \\text{Nat}[A_1], \\) and \\( \\Gamma; \\Delta; \\Sigma \\vdash e_2 : \\text{Nat}[A_2], \\) for some \\( A_1 \\) and \\( A_2 \\).\n8. If $\\Gamma; \\Delta; \\Sigma \\vdash \\text{if}[B, A](e_0, X_1.e_1, X_2.e_2) : \\tau$, then $\\Gamma \\vdash B : \\text{bool} \\to \\text{Prop}$,\n$\\Gamma; \\Delta; \\Sigma \\vdash e_0 : \\text{bool}(A')$, $\\Gamma \\vdash A : B \\ A'$, $\\Gamma, X_1 : B \\ \\text{true}; \\Delta; \\Sigma \\vdash e_1 : \\tau'$, $\\Gamma, X_2 : B \\ \\text{false}; \\Delta; \\Sigma \\vdash e_2 : \\tau'$, $\\Gamma, \\Delta \\vdash \\tau' : \\Omega$, and $\\tau = t \\tau'$ for some $A'$ and $\\tau'$.\n\n9. If $\\Gamma; \\Delta; \\Sigma \\vdash \\lambda x.\\tau_1.e : \\tau$, then $\\tau = t \\tau_1 \\tau_2$, and $\\Gamma; \\Delta; \\Sigma, x : \\tau_1 \\vdash e : \\tau_2$.\n\n10. If $\\Gamma; \\Delta; \\Sigma \\vdash \\text{let}\\; \\kappa.e : \\tau$, then there exists $\\tau'$ such that $\\Gamma; \\Delta, t : \\kappa; \\Sigma \\vdash e : \\tau'$, $\\Gamma; \\Delta \\vdash \\Sigma \\text{ ok and } \\tau = t \\forall \\kappa.\\tau'$.\n\n11. If $\\Gamma; \\Delta; \\Sigma \\vdash \\text{let}\\; \\kappa.X.e : \\tau$, then there exists $\\tau'$ such that $\\Gamma \\vdash A : s$ $(s \\neq \\text{Ext})$, $\\Gamma; \\Delta \\vdash \\Sigma \\text{ ok, } \\Gamma, X : A ; \\Delta; \\Sigma \\vdash e : \\tau'$, and $\\tau = t \\forall X.X.\\tau'$.\n\n12. If $\\Gamma; \\Delta; \\Sigma \\vdash \\text{fix}\\; x.\\tau'.f : \\tau$, then $\\tau = t \\tau'$, $\\Gamma; \\Delta \\vdash \\tau : \\Omega$, and $\\Gamma; \\Delta; \\Sigma, x : \\tau' \\vdash f : \\tau'$.\n\n13. If $\\Gamma; \\Delta; \\Sigma \\vdash e_1.e_2 : \\tau$, then there exist $\\tau_1$ and $\\tau_2$ such that $\\Gamma; \\Delta; \\Sigma \\vdash e_1 : \\tau_1 \\to \\tau_2$, $\\Gamma; \\Delta; \\Sigma \\vdash e_2 : \\tau_1$, and $\\tau = t \\tau_2$.\n\n14. If $\\Gamma; \\Delta; \\Sigma \\vdash e[\\tau_1] : \\tau$, then there exist $\\tau_2$ and $\\kappa$ such that $\\Gamma; \\Delta; \\Sigma \\vdash e : \\forall t.\\kappa.\\tau_2$, and $\\tau = t \\tau_2$.\n\n15. If $\\Gamma; \\Delta; \\Sigma \\vdash e[A] : \\tau$, then there exist $B, s$ $(s \\neq \\text{Ext})$ and $\\tau'$ such that $\\Gamma \\vdash A : B$, $\\Gamma \\vdash B : s$, $\\Gamma; \\Delta; \\Sigma \\vdash e : \\forall X.B.\\tau'$ and $\\tau = t [A/X] \\tau'$.\n\n16. If $\\Gamma; \\Delta; \\Sigma \\vdash \\{l_1 = e_1, \\ldots, l_n = e_n\\} : \\tau$, then there exist $\\tau_1, \\ldots, \\tau_n$ such that $\\tau = t \\{l_1 : \\tau_1, \\ldots, l_n : \\tau_n\\}$ and for $i = 1, \\ldots, n$ $\\Gamma; \\Delta; \\Sigma \\vdash e_i : \\tau_i$.\n\n17. If $\\Gamma; \\Delta; \\Sigma \\vdash e.l_i : \\tau$, then there exist $\\tau_1, \\ldots, \\tau_n$ $(1 \\leq i \\leq n)$ such that $\\Gamma; \\Delta; \\Sigma \\vdash e : \\{l_1 : \\tau_1, \\ldots, l_n : \\tau_n\\}$ and $\\tau = t \\tau_i$.\n\n18. If $\\Gamma; \\Delta; \\Sigma \\vdash \\text{inj}_1^{\\tau_1 + \\tau_2}e : \\tau$, then $\\tau = t \\tau_1 + \\tau_2$, $\\Gamma; \\Delta \\vdash \\tau_1 + \\tau_2 : \\Omega$, and $\\Gamma; \\Delta; \\Sigma \\vdash e : \\tau_1$.\n\n19. If $\\Gamma; \\Delta; \\Sigma \\vdash \\text{inj}_2^{\\tau_1 + \\tau_2}e : \\tau$, then $\\tau = t \\tau_1 + \\tau_2$, $\\Gamma; \\Delta \\vdash \\tau_1 + \\tau_2 : \\Omega$, and $\\Gamma; \\Delta; \\Sigma \\vdash e : \\tau_2$.\n\n20. If $\\Gamma; \\Delta; \\Sigma \\vdash \\text{case}(e_0, e_1, e_2) : \\tau$, then there exist $\\tau'$, $\\tau_1$ and $\\tau_2$ such that $\\Gamma; \\Delta; \\Sigma \\vdash e_0 : \\tau_1 + \\tau_2$, $\\Gamma; \\Delta; \\Sigma \\vdash e_1 : \\tau_1 \\to \\tau'$, $\\Gamma; \\Delta; \\Sigma \\vdash e_2 : \\tau_2 \\to \\tau'$, and $\\tau = t \\tau'$.\n\n21. If $\\Gamma; \\Delta; \\Sigma \\vdash \\text{fold}^{\\mu_\\kappa}(\\tau_1, \\tau_2)e : \\tau$, then $\\Gamma; \\Delta \\vdash \\mu_\\kappa(\\tau_1, \\tau_2) : \\Omega$, $\\Gamma; \\Delta; \\Sigma \\vdash e : \\mathcal{K}(\\kappa, \\tau_1, \\tau_2)$, and $\\tau = t \\mu_\\kappa(\\tau_1, \\tau_2)$.\n\n22. If $\\Gamma; \\Delta; \\Sigma \\vdash \\text{unfold}e : \\tau$, then there exist $\\kappa, \\tau_1$, and $\\tau_2$ such that $\\Gamma; \\Delta; \\Sigma \\vdash e : \\mu_\\kappa(\\tau_1, \\tau_2)$, and $\\tau = t \\mathcal{K}(\\kappa, \\tau_1, \\tau_2)$.\n\n23. If $\\Gamma; \\Delta; \\Sigma \\vdash (t = \\tau_1, e : \\tau_2) : \\tau$, then there exist $\\kappa$ such that $\\Gamma; \\Delta \\vdash \\tau_1 : \\kappa$, $\\Gamma; \\Delta; \\Sigma \\vdash e : [\\tau_1/t] \\tau_2$, $\\Gamma; \\Delta; t : \\kappa \\vdash \\tau_2 : \\Omega$, and $\\tau = t \\exists \\kappa.\\tau_2$. \n24. If $\\Gamma; \\Delta; \\Sigma \\vdash \\langle X = A, e : \\tau' \\rangle : \\tau$, then there exist $B$ and $s$ ($s \\neq \\text{Ext}$) such that $\\Gamma \\vdash A : B$, $\\Gamma \\vdash B : s$, $\\Gamma, X : B; \\Delta \\vdash \\tau' : \\Omega$, $\\Gamma; \\Delta; \\Sigma \\vdash e : [A/X]\\tau'$, and $\\tau =_{t} \\exists x : B. \\tau'$.\n\n25. If $\\Gamma; \\Delta; \\Sigma \\vdash x = e_0$ in $e : \\tau$, then there exist $\\tau_0$ and $\\tau'$ such that $\\Gamma; \\Delta; \\Sigma \\vdash e_0 : \\tau_0$, $\\Gamma; \\Delta; \\Sigma, x : \\tau_0 \\vdash e : \\tau'$, and $\\tau =_{t} \\tau'$.\n\n26. If $\\Gamma; \\Delta; \\Sigma \\vdash t = \\tau_0$ in $e : \\tau$, then there exist $\\kappa$ and $\\tau'$ such that $\\Gamma; \\Delta \\vdash \\tau_0 : \\kappa$, $\\Gamma; \\Delta; \\Sigma \\vdash [\\tau_0/t]e : \\tau'$, and $\\tau =_{t} \\tau'$.\n\n27. If $\\Gamma; \\Delta; \\Sigma \\vdash X = A$ in $e : \\tau$, then there exist $B$ and $\\tau'$ such that $\\Gamma \\vdash A : B$, $\\Gamma; \\Delta; \\Sigma \\vdash [A/X]e : \\tau'$, and $\\tau =_{t} \\tau'$.\n\n28. If $\\Gamma; \\Delta; \\Sigma \\vdash (let(t, x) = e_0$ in $e : \\tau$, then there exist $\\kappa$, $\\tau_0$ and $\\tau'$ such that $\\Gamma; \\Delta \\vdash \\tau' : \\Omega$, $\\Gamma; \\Delta; \\Sigma \\vdash e_0 : \\exists t : \\kappa. \\tau_0$, $\\Gamma; \\Delta, t : \\kappa; \\Sigma, x : \\tau_0 \\vdash e : \\tau'$, and $\\tau =_{t} \\tau'$.\n\n29. If $\\Gamma; \\Delta; \\Sigma \\vdash \\text{let}(X, x) = e_0$ in $e : \\tau$, then there exist $A$, $\\tau_0$ and $\\tau'$ such that $\\Gamma; \\Delta \\vdash \\tau' : \\Omega$, $\\Gamma; \\Delta; \\Sigma \\vdash e_0 : \\exists X : A. \\tau_0$, $\\Gamma, X : A; \\Delta, \\Sigma, x : \\tau_0 \\vdash e : \\tau'$, and $\\tau =_{t} \\tau'$.\n\nProof. By inspection of the expression formation rules, shown in Figure 2.8 and 2.9, we can see that every typing judgement $\\Gamma; \\Delta; \\Sigma \\vdash e : \\tau$ is the result of applying a unique typing rule, apart from the type-equality rule $\\text{E-conv}$. Due to the reflexivity and transitivity of $=_{t}$, any derivation of $\\Gamma; \\Delta; \\Sigma \\vdash e : \\tau$ can be converted to a standard form in which there is an application of the rule $\\text{E-conv}$ at its root, the derivation of whose first premise ends with an instance of a rule other than $\\text{E-conv}$. This rule is uniquely determined by the typing judgement. \\hfill\\Box\n\nLemma A.4 (Term Substitution) If $\\Gamma; \\Delta; \\Sigma, x : \\tau' \\vdash e : \\tau$, and $\\Gamma; \\Delta; \\Sigma \\vdash e' : \\tau'$, we must have $\\Gamma; \\Delta; \\Sigma \\vdash [e'/x]e : \\tau$.\n\nProof. By induction on the type derivation of $\\Gamma; \\Delta; \\Sigma, x : \\tau', \\Sigma_2 \\vdash e : \\tau$ (the Proposition 2.12 is used). \\hfill\\Box\n\nLemma A.5 (Type Substitution I) If $\\Gamma; \\Delta, t : \\kappa; \\Sigma \\vdash e : \\tau$, and $\\Gamma; \\Delta \\vdash \\tau' : \\kappa$, we must have $\\Gamma; \\Delta; [\\tau'/t] \\Sigma \\vdash [\\tau'/t]e : [\\tau'/t] \\tau$.\n\nProof. By induction on the derivation of $\\Gamma; \\Delta, t : \\kappa, \\Delta_2; \\Sigma \\vdash e : \\tau$ (Propositions 2.12, 2.8, and 2.6 are used). \\hfill\\Box\n\nLemma A.6 (Type Substitution II) If $\\Gamma_1, X : B, \\Gamma_2; \\Delta; \\Sigma \\vdash e : \\tau$, and $\\Gamma_1 \\vdash A : B$, we must have $\\Gamma_1, [A/X] \\Gamma_2; [A/X] \\Delta; [A/X] \\Sigma \\vdash [A/X] e : [A/X] \\tau$. \n\nProof. By induction on the derivation of \\( \\Gamma_1, X : B, \\Gamma_2; \\Delta; \\Sigma \\vdash e : \\tau \\) (Propositions 2.2.2, 2.12, 2.9 and 2.6 are used).\n\nBefore we prove the subject reduction lemma, we need firstly prove the adequacy of the representation of arithmetic using our proof language.\n\n**Lemma A.7 (Adequacy of the PL representation of arithmetic)**\n\n1. For all \\( n_1, n_2 \\in \\mathbb{N} \\), plus \\( \\hat{n_1} \\hat{n_2} = \\beta_{\\mu} n_1 + n_2 \\)\n2. For all \\( n_1, n_2 \\in \\mathbb{N} \\), lt \\( \\hat{n_1} \\hat{n_2} = \\beta_{\\mu} \\text{true} \\) if and only if \\( n_1 < n_2 \\).\n3. For all \\( n_1, n_2 \\in \\mathbb{N} \\), le \\( \\hat{n_1} \\hat{n_2} = \\beta_{\\mu} \\text{false} \\) if and only if \\( n_1 \\geq n_2 \\).\n\nProof sketch.\n\n1. By induction on \\( n_1 \\) and inspection of the definition of plus.\n2. By induction on \\( n_1 \\) and inspection of the definition of lt and le. We need first prove that For all \\( n_1, n_2 \\in \\mathbb{N} \\), le \\( \\hat{n_1} \\hat{n_2} = \\beta_{\\mu} \\text{true} \\) if and only if \\( n_1 \\leq n_2 \\).\n3. By 2 and the definition of lt.\n\n**Lemma A.8 (Subject Reduction)** If \\( \\vdash \\vdash e : \\tau \\) and \\( e \\rightarrow e' \\), then \\( \\vdash \\vdash e' : \\tau \\).\n\nProof. By induction on the rules defining reduction relation \\( \\rightarrow \\).\n\n(Rule R-ADD) We require \\( e \\equiv \\overline{n_1 + n_2} \\) for some \\( n_1 \\) and \\( n_2 \\). By Lemma A.3, we have \\( \\tau =_{\\iota} \\text{snat}[\\text{plus } A_1 A_2] \\), \\( \\vdash \\vdash \\overline{n_1} : \\text{snat}[A_1] \\), and \\( \\vdash \\vdash \\overline{n_2} : \\text{snat}[A_2] \\), for some \\( A_1 \\) and \\( A_2 \\). Again by Lemma A.3, \\( \\text{snat}[A_1] =_{\\iota} \\text{snat}[\\overline{n_1}] \\) and \\( \\text{snat}[A_2] =_{\\iota} \\text{snat}[\\overline{n_2}] \\). By inspection of the type equivalence rules in Figure 2.7 we know \\( A_1 =_{\\beta_{\\mu}} \\overline{n_1} \\) and \\( A_2 =_{\\beta_{\\mu}} \\overline{n_2} \\). Therefore \\( \\text{plus } A_1 A_2 =_{\\beta_{\\mu}} \\text{plus } \\overline{n_1} \\overline{n_2} \\). By Lemma A.7, \\( \\text{plus } A_1 A_2 =_{\\beta_{\\mu}} \\overline{n_1 + n_2} \\). Therefore \\( \\text{snat}[\\text{plus } A_1 A_2] =_{\\iota} \\text{snat}[\\overline{n_1 + n_2}] \\).\n\nTherefore \\( \\tau =_{\\iota} \\text{snat}[\\overline{n_1 + n_2}] \\).\n\nBy the following derivation we have \\( \\vdash \\vdash \\overline{n_1 + n_2} : \\tau \\):\n\n\\[\n\\begin{align*}\n\\vdash \\vdash & \\text{Prop : Type} \\\\\n\\therefore & \\vdash \\vdash \\overline{n_1} : \\text{snat}[A_1] \\\\\n\\therefore & \\vdash \\vdash \\overline{n_2} : \\text{snat}[A_2] \\\\\n\\therefore & \\vdash \\vdash \\overline{n_1 + n_2} : \\text{snat}[\\overline{n_1 + n_2}] \\\\\n\\therefore & \\vdash \\vdash \\overline{n_1 + n_2} : \\tau\n\\end{align*}\n\\]\n(Rule R-LT-T) We require $e \\equiv \\pi \\cdot \\pi$ for some $n_1$ and $n_2$, and $n_1 < n_2$. By Lemma A.3, we have $\\tau = s_{\\text{Boo}}[\\text{lt } A_1 A_2]$, $\\vdash \\pi_1 : s_{\\text{Nat}}[A_1]$, and $\\vdash \\pi_2 : s_{\\text{Nat}}[A_2]$, for some $A_1$ and $A_2$. Similar to the proof in the above case, we know that $\\text{lt } A_1 A_2 = \\beta_0$, $\\pi_1 \\pi_2$. Since $n_1 < n_2$, by Lemma A.7, $\\pi_1 \\pi_2 = \\beta_0$ true. Therefore $\\tau = s_{\\text{Boo}}[\\text{true}].$\n\nBy the rule E-TRUE, we know $\\vdash e : s_{\\text{Boo}}[\\text{true}]$. Therefore, we get $\\vdash e : \\tau$ by rule E-CONV.\n\n(Rule R-LT-F) The proof is similar to the above case.\n\n(Rule R-if-T) We require $e \\equiv \\text{if}[B,A](\\tau_1,e_1,\\tau_2,e_2)$. By Lemma A.3, we have $\\vdash \\pi : s_{\\text{Boo}}[A']$, $\\vdash A : B A'$, $\\vdash e_1 : \\tau'$, $\\vdash e_1 : \\tau' : \\Omega$, and $\\tau = \\tau'$, for some $A'$ and $\\tau'$.\n\nAgain by Lemma A.3 we know $s_{\\text{Boo}}[A'] = s_{\\text{Boo}}[\\text{true}]$, therefore $A' = \\beta_0$ true. Therefore $\\vdash A : B \\text{ true}$. By Lemma A.6 we know $\\vdash e_1 : A/X_1[e_1] : \\tau'$ (we know $X_1$ is not free in $\\tau'$ by $\\vdash e_1 : \\tau' : \\Omega$). Since $\\tau = \\tau'$, by the rule E-CONV we know $\\vdash e_1 : \\tau_1 : \\tau$.\n\n(Rule R-if-F) The proof is similar to the above case.\n\n(Rule R-β) We require $e \\equiv (\\lambda x : \\tau_1.e')v$ for some $x$, $\\tau_1$ and $e'$. By Lemma A.3, we have $\\vdash \\lambda x : \\tau_1.e' : \\tau_1 \\rightarrow \\tau_2$, $\\vdash v : \\tau_1$ and $\\tau = \\tau_2$ for some $\\tau_2$.\n\nAgain by Lemma A.3, we have $\\vdash \\tau_1 : \\Omega$, $\\vdash x : \\tau_1 \\vdash e' : \\tau_2'$, and $\\tau_1 \\rightarrow \\tau_2 = \\tau_1 \\rightarrow \\tau_2'$.\n\nIt is easy to prove that $\\tau_2 = \\tau_2'$ from $\\tau_1 \\rightarrow \\tau_2 = \\tau_1 \\rightarrow \\tau_2'$. Since $\\tau = \\tau_2$, we have $\\tau = \\tau_2'$. By Lemma A.4 we have $\\vdash e_1 : e' : \\tau_2'$. Then $\\vdash e_1 : e' : \\tau$ follows the rule E-CONV.\n\n(Rule R-tapp1) The proof is similar to the above case. In this case we use Lemma A.5 instead of Lemma A.4.\n\n(Rule R-tapp2) The proof is similar to the case for rule R-β. In this case we use Lemma A.6 instead of Lemma A.4.\n\n(Rule R-fix) The proof is similar to the case for rule R-β.\n\n(Rule R-sel) We require $e \\equiv \\{l_1 = v_1, \\ldots, l_n = v_n\\}.l_i$ for some $\\tau_1, \\ldots, \\tau_n$, and $1 \\leq i \\leq n$. By Lemma A.3 we know $\\vdash \\pi : \\{l_1 = v_1, \\ldots, l_n = v_n\\} : \\{l_1 : \\tau_1, \\ldots, l_n : \\tau_n\\}$ and $\\tau = \\tau_i$.\n\nAgain by Lemma A.3 we know there exist $\\tau_1', \\ldots, \\tau_n'$ such that $\\{l_1 : \\tau_1', \\ldots, l_n : \\tau_n'\\} = \\{l_1 : l_1', \\ldots, l_n : l_n'\\}$ and for $i = 1, \\ldots, n$ we have $\\vdash \\pi : \\tau_i'$.\n\nIt is easy to prove that for each $i$ ($1 \\leq i \\leq n$) we have $\\tau_i = \\tau_i'$, since $\\{l_1 : l_1', \\ldots, l_n : l_n'\\} = \\{l_1 : l_1', \\ldots, l_n : l_n'\\}$. Since $\\tau = \\tau_i$, we know $\\tau = \\tau_i'$\n\nTherefore we have $\\vdash \\pi : \\tau$ by rule E-CONV.\n(Rule R-case1) We require \\( e \\equiv \\text{case}(\\text{inj}_1^\\prime v, e_1, e_2) \\) for some \\( \\tau', v, e_1 \\) and \\( e_2 \\).\nBy Lemma A.3 we know \\( \\vdash_1 \\vdash \\text{inj}_1^\\prime v : \\tau_1 + \\tau_2 \\). \\( \\vdash_1 \\vdash e_1 : \\tau_1 \\rightarrow \\tau_0 \\), \\( \\vdash_1 \\vdash e_2 : \\tau_2 \\rightarrow \\tau_0 \\), and \\( \\tau =_t \\tau_0 \\), for some \\( \\tau_0, \\tau_1 \\) and \\( \\tau_2 \\).\nAgain by Lemma A.3 we know there exist \\( \\tau'_1 \\) and \\( \\tau'_2 \\) such that \\( \\tau' \\equiv \\tau'_1 + \\tau'_2 \\).\n\\( \\tau'_1 + \\tau'_2 =_t \\tau_1 + \\tau_2 \\), and \\( \\vdash_1 \\vdash v : \\tau'_1 \\).\nIt is easy to prove that \\( \\tau_1 =_t \\tau'_1 \\), since \\( \\tau'_1 + \\tau'_2 =_t \\tau_1 + \\tau_2 \\).\nTherefore we have the following derivation of \\( \\vdash_1 \\vdash e_1 v : \\tau \\).\n\\[\n\\begin{array}{c}\n\\vdash_1 \\vdash e_1 : \\tau_1 \\rightarrow \\tau_0 \\\\\n\\vdash_1 \\vdash v : \\tau_1 \\\\\n\\vdash_1 \\vdash e_1 v : \\tau_0 \\\\\n\\vdash_1 \\vdash e_1 v : \\tau\n\\end{array}\n\\]\n\n(Rule R-case2) Similar to the proof of the above case.\n\n(Rule R-unfd) We require \\( e \\equiv \\text{unfold}(\\text{fold}^\\prime v) \\) for some \\( \\tau' \\) and \\( v \\). By Lemma A.3 we know there exist \\( \\kappa, \\tau_1 \\) and \\( \\tau_2 \\) such that \\( \\vdash_1 \\vdash \\text{fold}^\\prime v : \\mu_\\kappa(\\tau_1, \\tau_2) \\), and \\( \\tau =_t \\mathcal{K}(\\kappa, \\tau_1, \\tau_2) \\).\nAgain by Lemma A.3 we know there exist \\( \\kappa', \\tau'_1 \\) and \\( \\tau'_2 \\) such that \\( \\tau' \\equiv \\mu_\\kappa(\\tau'_1, \\tau'_2) \\), \\( \\vdash_1 \\vdash \\mu_\\kappa(\\tau'_1, \\tau'_2) : \\Omega \\), \\( \\mu_\\kappa(\\tau_1, \\tau_2) =_t \\mu_\\kappa(\\tau'_1, \\tau'_2) \\), and \\( \\vdash_1 \\vdash v : \\mathcal{K}(\\kappa', \\tau'_1, \\tau'_2) \\).\nFrom the fact that \\( \\mu_\\kappa(\\tau_1, \\tau_2) =_t \\mu_\\kappa(\\tau'_1, \\tau'_2) \\), it easy to prove that \\( \\kappa =_t \\kappa' \\), \\( \\tau_1 =_t \\tau'_1 \\) and \\( \\tau_2 =_t \\tau'_2 \\). Therefore we can prove that \\( \\mathcal{K}(\\kappa, \\tau_1, \\tau_2) =_t \\mathcal{K}(\\kappa', \\tau'_1, \\tau'_2) \\).\nSince \\( \\tau =_t \\mathcal{K}(\\kappa, \\tau_1, \\tau_2) \\), we know \\( \\vdash_1 \\vdash v : \\tau \\).\n\n(Rule R-let) Similar to the proof of the case for the rule R-beta.\n\n(Rule R-tlet1) We require \\( e \\equiv \\text{let } t = \\tau_0 \\text{ in } e' \\). By Lemma A.3 we know there exist \\( \\kappa \\) and \\( \\tau' \\) such that \\( \\vdash_1 \\vdash \\tau_0 : \\kappa \\), \\( \\vdash_1 \\vdash [\\tau_0/t]e' : \\tau' \\), and \\( \\tau =_t \\tau' \\).\nTherefore we have \\( \\vdash_1 \\vdash [\\tau_0/t]e' : \\tau \\).\n\n(Rule R-tlet2) Similar to the proof of the above case.\n\n(Rule R-open) We require \\( e \\equiv \\text{let } (t, x) = \\langle t' = \\tau_1, v : \\tau_2 \\rangle \\text{ in } e' \\). By Lemma A.3 we know there exist \\( \\kappa, \\tau_0 \\) and \\( \\tau' \\) such that \\( \\vdash_1 \\vdash \\tau' : \\Omega \\), \\( \\vdash_1 \\vdash \\langle t' = \\tau_1, v : \\tau_2 \\rangle : \\exists t : \\kappa, \\tau_0 \\vdash_1 \\vdash t : \\kappa, x : \\tau_0 \\vdash_1 \\vdash e' : \\tau' \\), and \\( \\tau =_t \\tau' \\).\nAgain by Lemma A.3 we know there exists \\( \\kappa' \\) such that \\( \\vdash_1 \\vdash \\tau_1 : \\kappa' \\), \\( \\vdash_1 \\vdash v : [\\tau_1/t] \\tau_2 \\), and \\( \\exists t : \\kappa, \\tau_0 =_t \\exists t' : \\kappa', \\tau_2 \\).\nIt is easy to prove that \\( \\kappa' \\equiv \\kappa \\) and \\( \\tau_2 =_t [t'/t] \\tau_0 \\). By Proposition 2.6 we know \\( [\\tau_1/t'] \\tau_2 =_t [\\tau_1/t'] [t'/t] \\tau_0 \\), i.e. \\( [\\tau_1/t'] \\tau_2 =_t [\\tau_1/t] \\tau_0 \\). By the typing rule E-conv we know \\( \\vdash_1 \\vdash v : [\\tau_1/t] \\tau_0 \\).\n\nBy Lemma A.5 and A.4 we know \\( \\vdash_1 \\vdash [v/x][\\tau_1/t] e : [\\tau_1/t] \\tau' \\). Since we have \\( \\vdash_1 \\vdash \\tau' : \\Omega \\), \\( t \\) must not be free in \\( \\tau' \\). Therefore \\( \\vdash_1 \\vdash [v/x][\\tau_1/t] e : \\tau' \\). Again by typing rule E-conv we finally get \\( \\vdash_1 \\vdash [v/x][\\tau_1/t] e : \\tau \\).\n(Rule \\textbf{R-open2}) Similar to the proof for the above case. In this case we use Lemma A.6 instead of Lemma A.5.\n\n\\textbf{Theorem A.9 (Type Preservation)} If \\(\\cdot;\\cdot;\\vdash e : \\tau\\) and \\(e \\mapsto^* e'\\), then \\(\\cdot;\\cdot;\\vdash e' : \\tau\\).\n\n\\textbf{Proof.} Since evaluation contexts binds no variables, by Lemma A.8 and A.4, we have if \\(\\cdot;\\cdot;\\vdash e : \\tau\\) and \\(e \\mapsto e'\\), then \\(\\cdot;\\cdot;\\vdash e' : \\tau\\). Then the result follows by induction on the length of the reduction sequence \\(e \\mapsto^* e'\\).\n\n\\textbf{Theorem A.10 (Safety of CL)} If \\(\\cdot;\\cdot;\\vdash e : \\tau\\), then either \\(e \\mapsto^* v\\) and \\(\\cdot;\\cdot;\\vdash v : \\tau\\), for some \\(v\\), or \\(e\\) diverges (i.e., for each \\(e'\\), if \\(e \\mapsto^* e'\\), then there exists \\(e''\\) such that \\(e' \\mapsto e''\\)).\n\n\\textbf{Proof.} Follows Theorems A.2 and A.9."}}},{"rowIdx":253,"cells":{"id":{"kind":"string","value":"64fe2838829698046657fb1cbcbd6ea95c74555c"},"text":{"kind":"string","value":"# Table of Contents\n\nEclipse GlassFish Server ......................................................... 1\nPreface ....................................................................................... 2\n Oracle GlassFish Server Documentation Set .............................. 2\nTypographic Conventions ........................................................ 4\nSymbol Conventions .................................................................. 4\nDefault Paths and File Names .................................................. 5\n1 Overview of GlassFish Server Performance Tuning ................. 7\n Process Overview ................................................................... 7\n Understanding Operational Requirements ............................... 9\n General Tuning Concepts ....................................................... 13\n Further Information .............................................................. 16\n2 Tuning Your Application ....................................................... 17\n Java Programming Guidelines ............................................... 17\n Java Server Page and Servlet Tuning ..................................... 20\n EJB Performance Tuning ....................................................... 23\n3 Tuning the GlassFish Server .................................................. 43\n Using the GlassFish Server Performance Tuner ....................... 43\n Deployment Settings ............................................................ 44\n Logger Settings ...................................................................... 45\n Web Container Settings ......................................................... 46\n EJB Container Settings ........................................................ 47\n Java Message Service Settings ............................................. 53\n Transaction Service Settings ............................................... 53\n HTTP Service Settings ........................................................ 55\n Network Listener Settings .................................................... 60\n Transport Settings ............................................................... 64\n Thread Pool Settings ........................................................... 64\n ORB Settings ....................................................................... 65\n Resource Settings ............................................................... 72\n Load Balancer Settings ......................................................... 77\n4 Tuning the Java Runtime System ............................................. 79\n Java Virtual Machine Settings .............................................. 79\n Start Options ...................................................................... 79\n Tuning High Availability Persistence ..................................... 80\n Managing Memory and Garbage Collection .......................... 80\n Further Information ............................................................ 88\n5 Tuning the Operating System and Platform .................................................. 89\n Server Scaling ......................................................................................... 89\n Solaris 10 Platform-Specific Tuning Information ....................................... 93\n Tuning for the Solaris OS ......................................................................... 93\n Tuning for Solaris on x86 ........................................................................ 97\n Tuning for Linux platforms ...................................................................... 98\n Tuning UltraSPARC CMT-Based Systems ................................................. 104\nThis book describes how to get the best performance with GlassFish Server 5.1.\n\nEclipse GlassFish Server Performance Tuning Guide, Release 5.1\n\nCopyright ?? 2013, 2019 Oracle and/or its affiliates. All rights reserved.\n\nThis program and the accompanying materials are made available under the terms of the Eclipse Public License v. 2.0, which is available at http://www.eclipse.org/legal/epl-2.0.\n\nSPDX-License-Identifier: EPL-2.0\n\nOracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners.\n\nIntel and Intel Xeon are trademarks or registered trademarks of Intel Corporation. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. AMD, Opteron, the AMD logo, and the AMD Opteron logo are trademarks or registered trademarks of Advanced Micro Devices. UNIX is a registered trademark of The Open Group.\nPreface\n\nThis documentation is part of the Java Enterprise Edition contribution to the Eclipse Foundation and is not intended for use in relation to Java Enterprise Edition or Oracle GlassFish. The documentation is in the process of being revised to reflect the new Jakarta EE branding. Additional changes will be made as requirements and procedures evolve for Jakarta EE. Where applicable, references to Java EE or Java Enterprise Edition should be considered references to Jakarta EE.\n\nPlease see the Title page for additional license information.\n\nThe Performance Tuning Guide describes how to get the best performance with GlassFish Server 5.1.\n\nThis preface contains information about and conventions for the entire Eclipse GlassFish Server (GlassFish Server) documentation set.\n\nGlassFish Server 5.1 is developed through the GlassFish project open-source community at http://glassfish.java.net/. The GlassFish project provides a structured process for developing the GlassFish Server platform that makes the new features of the Java EE platform available faster, while maintaining the most important feature of Java EE: compatibility. It enables Java developers to access the GlassFish Server source code and to contribute to the development of the GlassFish Server. The GlassFish project is designed to encourage communication between Oracle engineers and the community.\n\nOracle GlassFish Server Documentation Set\n\n<table>\n<thead>\n<tr>\n<th>Book Title</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Release Notes</td>\n<td>Provides late-breaking information about the software and the documentation and includes a comprehensive, table-based summary of the supported hardware, operating system, Java Development Kit (JDK), and database drivers.</td>\n</tr>\n<tr>\n<td>Quick Start Guide</td>\n<td>Explains how to get started with the GlassFish Server product.</td>\n</tr>\n<tr>\n<td>Installation Guide</td>\n<td>Explains how to install the software and its components.</td>\n</tr>\n<tr>\n<td>Upgrade Guide</td>\n<td>Explains how to upgrade to the latest version of GlassFish Server. This guide also describes differences between adjacent product releases and configuration options that can result in incompatibility with the product specifications.</td>\n</tr>\n<tr>\n<td>Deployment Planning Guide</td>\n<td>Explains how to build a production deployment of GlassFish Server that meets the requirements of your system and enterprise.</td>\n</tr>\n<tr>\n<td>Book Title</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>------------------------------------------</td>\n<td>---------------------------------------------------------------------------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>Administration Guide</td>\n<td>Explains how to configure, monitor, and manage GlassFish Server subsystems and components from the command line by using the asadmin utility. Instructions for performing these tasks from the Administration Console are provided in the Administration Console online help.</td>\n</tr>\n<tr>\n<td>Security Guide</td>\n<td>Provides instructions for configuring and administering GlassFish Server security.</td>\n</tr>\n<tr>\n<td>Application Deployment Guide</td>\n<td>Explains how to assemble and deploy applications to the GlassFish Server and provides information about deployment descriptors.</td>\n</tr>\n<tr>\n<td>Application Development Guide</td>\n<td>Explains how to create and implement Java Platform, Enterprise Edition (Java EE platform) applications that are intended to run on the GlassFish Server. These applications follow the open Java standards model for Java EE components and application programmer interfaces (APIs). This guide provides information about developer tools, security, and debugging.</td>\n</tr>\n<tr>\n<td>Embedded Server Guide</td>\n<td>Explains how to run applications in embedded GlassFish Server and to develop applications in which GlassFish Server is embedded.</td>\n</tr>\n<tr>\n<td>High Availability Administration Guide</td>\n<td>Explains how to configure GlassFish Server to provide higher availability and scalability through failover and load balancing.</td>\n</tr>\n<tr>\n<td>Performance Tuning Guide</td>\n<td>Explains how to optimize the performance of GlassFish Server.</td>\n</tr>\n<tr>\n<td>Troubleshooting Guide</td>\n<td>Describes common problems that you might encounter when using GlassFish Server and explains how to solve them.</td>\n</tr>\n<tr>\n<td>Error Message Reference</td>\n<td>Describes error messages that you might encounter when using GlassFish Server.</td>\n</tr>\n<tr>\n<td>Reference Manual</td>\n<td>Provides reference information in man page format for GlassFish Server administration commands, utility commands, and related concepts.</td>\n</tr>\n<tr>\n<td>Message Queue Release Notes</td>\n<td>Describes new features, compatibility issues, and existing bugs for Open Message Queue.</td>\n</tr>\n<tr>\n<td>Message Queue Technical Overview</td>\n<td>Provides an introduction to the technology, concepts, architecture, capabilities, and features of the Message Queue messaging service.</td>\n</tr>\n<tr>\n<td>Message Queue Administration Guide</td>\n<td>Explains how to set up and manage a Message Queue messaging system.</td>\n</tr>\n<tr>\n<td>Message Queue Developer’s Guide for JMX Clients</td>\n<td>Describes the application programming interface in Message Queue for programmatically configuring and monitoring Message Queue resources in conformance with the Java Management Extensions (JMX).</td>\n</tr>\n<tr>\n<td>Message Queue Developer’s Guide for Java Clients</td>\n<td>Provides information about concepts and procedures for developing Java messaging applications (Java clients) that work with GlassFish Server.</td>\n</tr>\n</tbody>\n</table>\nThe following table describes the typographic changes that are used in this book.\n\n<table>\n<thead>\n<tr>\n<th>Typeface</th>\n<th>Meaning</th>\n<th>Example</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>AaBbCc123</td>\n<td>The names of commands, files, and directories, and onscreen computer output</td>\n<td>Edit your .login file. Use ls a to list all files. machine_name% you have mail.</td>\n</tr>\n<tr>\n<td>AaBbCc123</td>\n<td>What you type, contrasted with onscreen computer output</td>\n<td>machine_name% su Password:</td>\n</tr>\n<tr>\n<td>AaBbCc123</td>\n<td>A placeholder to be replaced with a real name or value</td>\n<td>The command to remove a file is rm filename.</td>\n</tr>\n<tr>\n<td>AaBbCc123</td>\n<td>Book titles, new terms, and terms to be emphasized (note that some emphasized items appear bold online)</td>\n<td>Read Chapter 6 in the User's Guide. A cache is a copy that is stored locally. Do not save the file.</td>\n</tr>\n</tbody>\n</table>\n\nThe following table explains symbols that might be used in this book.\n\n<table>\n<thead>\n<tr>\n<th>Symbol</th>\n<th>Description</th>\n<th>Example</th>\n<th>Meaning</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>[ ]</td>\n<td>Contains optional arguments and command options.</td>\n<td>ls [-l]</td>\n<td>The -l option is not required.</td>\n</tr>\n<tr>\n<td>{</td>\n<td>}</td>\n<td>Contains a set of choices for a required command option.</td>\n<td>-d {y</td>\n</tr>\n<tr>\n<td>Symbol</td>\n<td>Description</td>\n<td>Example</td>\n<td>Meaning</td>\n</tr>\n<tr>\n<td>--------</td>\n<td>-------------</td>\n<td>---------</td>\n<td>---------</td>\n</tr>\n<tr>\n<td><code>{ }</code></td>\n<td>Indicates a variable reference.</td>\n<td><code>${com.sun.javaRoot}</code></td>\n<td>References the value of the <code>com.sun.javaRoot</code> variable.</td>\n</tr>\n<tr>\n<td>-</td>\n<td>Joins simultaneous multiple keystrokes.</td>\n<td>Control-A</td>\n<td>Press the Control key while you press the A key.</td>\n</tr>\n<tr>\n<td>+</td>\n<td>Joins consecutive multiple keystrokes.</td>\n<td>Ctrl+A+N</td>\n<td>Press the Control key, release it, and then press the subsequent keys.</td>\n</tr>\n<tr>\n<td>></td>\n<td>Indicates menu item selection in a graphical user interface.</td>\n<td>File > New > Templates</td>\n<td>From the File menu, choose New. From the New submenu, choose Templates.</td>\n</tr>\n</tbody>\n</table>\n\n### Default Paths and File Names\n\nThe following table describes the default paths and file names that are used in this book.\n\n<table>\n<thead>\n<tr>\n<th>Placeholder</th>\n<th>Description</th>\n<th>Default Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>as-install</td>\n<td>Represents the base installation directory for GlassFish Server. In configuration files, as-install is represented as follows: <code>${com.sun.aas.installRoot}</code></td>\n<td>Installations on the Oracle Solaris operating system, Linux operating system, and Mac OS operating system: user's-home-directory <code>/glassfish3/glassfish</code> Installations on the Windows operating system: SystemDrive <code>:\\glassfish3\\glassfish</code></td>\n</tr>\n<tr>\n<td>as-install-parent</td>\n<td>Represents the parent of the base installation directory for GlassFish Server.</td>\n<td>Installations on the Oracle Solaris operating system, Linux operating system, and Mac operating system: user's-home-directory <code>/glassfish3</code> Installations on the Windows operating system: SystemDrive <code>:\\glassfish3</code></td>\n</tr>\n<tr>\n<td>domain-root-dir</td>\n<td>Represents the directory in which a domain is created by default.</td>\n<td>as-install <code>/domains</code></td>\n</tr>\n<tr>\n<td>Placeholder</td>\n<td>Description</td>\n<td>Default Value</td>\n</tr>\n<tr>\n<td>-------------</td>\n<td>-------------</td>\n<td>---------------</td>\n</tr>\n<tr>\n<td>domain-dir</td>\n<td>Represents the directory in which a domain's configuration is stored. In configuration files, domain-dir is represented as follows: <code>${com.sun.aas.instanceRoot}</code></td>\n<td>domain-root-dir<code>/</code>domain-name</td>\n</tr>\n<tr>\n<td>instance-dir</td>\n<td>Represents the directory for a server instance.</td>\n<td>domain-dir<code>/</code>instance-name</td>\n</tr>\n</tbody>\n</table>\n1 Overview of GlassFish Server Performance Tuning\n\nYou can significantly improve performance of the Oracle GlassFish Server and of applications deployed to it by adjusting a few deployment and server configuration settings. However, it is important to understand the environment and performance goals. An optimal configuration for a production environment might not be optimal for a development environment.\n\nThe following topics are addressed here:\n\n- Process Overview\n- Understanding Operational Requirements\n- General Tuning Concepts\n- Further Information\n\nProcess Overview\n\nThe following table outlines the overall GlassFish Server 4.0 administration process, and shows where performance tuning fits in the sequence.\n\nTable 1-1 Performance Tuning Roadmap\n\n<table>\n<thead>\n<tr>\n<th>Step</th>\n<th>Description of Task</th>\n<th>Location of Instructions</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Design: Decide on the high-availability topology and set up GlassFish Server.</td>\n<td>GlassFish Server Open Source Edition Deployment Planning Guide</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Capacity Planning: Make sure the systems have sufficient resources to perform well.</td>\n<td>GlassFish Server Open Source Edition Deployment Planning Guide</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Installation: Configure your DAS, clusters, and clustered server instances.</td>\n<td>GlassFish Server Open Source Edition Installation Guide</td>\n</tr>\n<tr>\n<td>Step</td>\n<td>Description of Task</td>\n<td>Location of Instructions</td>\n</tr>\n<tr>\n<td>------</td>\n<td>---------------------</td>\n<td>--------------------------</td>\n</tr>\n</tbody>\n</table>\n| 4 | Deployment: Install and run your applications. Familiarize yourself with how to configure and administer the GlassFish Server. | The following books: \n• GlassFish Server Open Source Edition Application Deployment Guide \n• GlassFish Server Open Source Edition Administration Guide |\n| 5 | High Availability Configuration: Configuring your DAS, clusters, and clustered server instances for high availability and failover | GlassFish Server Open Source Edition High Availability Administration Guide |\n| 6 | Performance Tuning: Tune the following items: \n• Applications \n• GlassFish Server \n• Java Runtime System \n• Operating system and platform | The following chapters: \n• Tuning Your Application \n• Tuning the GlassFish Server \n• Tuning the Java Runtime System \n• Tuning the Operating System and Platform |\n\n**Performance Tuning Sequence**\n\nApplication developers should tune applications prior to production use. Tuning applications often produces dramatic performance improvements. System administrators perform the remaining steps in the following list after tuning the application, or when application tuning has to wait and you want to improve performance as much as possible in the meantime.\n\nIdeally, follow this sequence of steps when you are tuning performance:\n\n1. Tune your application, described in Tuning Your Application.\n2. Tune the server, described in Tuning the GlassFish Server.\n3. Tune the Java runtime system, described in Tuning the Java Runtime System.\n4. Tune the operating system, described in Tuning the Operating System and Platform.\nUnderstanding Operational Requirements\n\nBefore you begin to deploy and tune your application on the GlassFish Server, it is important to clearly define the operational environment. The operational environment is determined by high-level constraints and requirements such as:\n\n- Application Architecture\n- Security Requirements\n- High Availability Clustering, Load Balancing, and Failover\n- Hardware Resources\n- Administration\n\nApplication Architecture\n\nThe Java EE Application model, as shown in the following figure, is very flexible; allowing the application architect to split application logic functionally into many tiers. The presentation layer is typically implemented using servlets and JSP technology and executes in the web container.\n\nFigure 1-1 Java EE Application Model\n\nModerately complex enterprise applications can be developed entirely using servlets and JSP technology. More complex business applications often use Enterprise JavaBeans (EJB) components. The GlassFish Server integrates the Web and EJB containers in a single process. Local access to EJB components from servlets is very efficient. However, some application deployments may require EJB\ncomponents to execute in a separate process; and be accessible from standalone client applications as well as servlets. Based on the application architecture, the server administrator can employ the GlassFish Server in multiple tiers, or simply host both the presentation and business logic on a single tier.\n\nIt is important to understand the application architecture before designing a new GlassFish Server deployment, and when deploying a new business application to an existing application server deployment.\n\nSecurity Requirements\n\nMost business applications require security. This section discusses security considerations and decisions.\n\nUser Authentication and Authorization\n\nApplication users must be authenticated. The GlassFish Server provides a number of choices for user authentication, including file-based, administration, LDAP, certificate, JDBC, digest, PAM, Solaris, and custom realms.\n\nThe default file based security realm is suitable for developer environments, where new applications are developed and tested. At deployment time, the server administrator can choose between the Lightweight Directory Access Protocol (LDAP) or Solaris security realms. Many large enterprises use LDAP-based directory servers to maintain employee and customer profiles. Small to medium enterprises that do not already use a directory server may find it advantageous to leverage investment in Solaris security infrastructure.\n\nFor more information on security realms, see \"Administering Authentication Realms\" in GlassFish Server Open Source Edition Security Guide.\n\nThe type of authentication mechanism chosen may require additional hardware for the deployment. Typically a directory server executes on a separate server, and may also require a backup for replication and high availability. Refer to the Oracle Java System Directory Server (http://www.oracle.com/us/products/middleware/identity-management/oracle-directory-services/index.html) documentation for more information on deployment, sizing, and availability guidelines.\n\nAn authenticated user's access to application functions may also need authorization checks. If the application uses the role-based Java EE authorization checks, the application server performs some additional checking, which incurs additional overheads. When you perform capacity planning, you must take this additional overhead into account.\n**Encryption**\n\nFor security reasons, sensitive user inputs and application output must be encrypted. Most business-oriented web applications encrypt all or some of the communication flow between the browser and GlassFish Server. Online shopping applications encrypt traffic when the user is completing a purchase or supplying private data. Portal applications such as news and media typically do not employ encryption. Secure Sockets Layer (SSL) is the most common security framework, and is supported by many browsers and application servers.\n\nThe GlassFish Server supports SSL 2.0 and 3.0 and contains software support for various cipher suites. It also supports integration of hardware encryption cards for even higher performance. Security considerations, particularly when using the integrated software encryption, will impact hardware sizing and capacity planning.\n\nConsider the following when assessing the encryption needs for a deployment:\n\n- What is the nature of the applications with respect to security? Do they encrypt all or only a part of the application inputs and output? What percentage of the information needs to be securely transmitted?\n\n- Are the applications going to be deployed on an application server that is directly connected to the Internet? Will a web server exist in a demilitarized zone (DMZ) separate from the application server tier and backend enterprise systems?\n\n A DMZ-style deployment is recommended for high security. It is also useful when the application has a significant amount of static text and image content and some business logic that executes on the GlassFish Server, behind the most secure firewall. GlassFish Server provides secure reverse proxy plugins to enable integration with popular web servers. The GlassFish Server can also be deployed and used as a web server in DMZ.\n\n- Is encryption required between the web servers in the DMZ and application servers in the next tier? The reverse proxy plugins supplied with GlassFish Server support SSL encryption between the web server and application server tier. If SSL is enabled, hardware capacity planning must be take into account the encryption policy and mechanisms.\n\n- If software encryption is to be employed:\n - What is the expected performance overhead for every tier in the system, given the security requirements?\n - What are the performance and throughput characteristics of various choices?\n\nFor information on how to encrypt the communication between web servers and GlassFish Server, see \"Administering Message Security\" in GlassFish Server Open Source Edition Security Guide.\n\n**High Availability Clustering, Load Balancing, and Failover**\n\nGlassFish Server 4.0 enables multiple GlassFish Server instances to be clustered to provide high\navailability through failure protection, scalability, and load balancing.\n\nHigh availability applications and services provide their functionality continuously, regardless of hardware and software failures. To make such reliability possible, GlassFish Server 4.0 provides mechanisms for maintaining application state data between clustered GlassFish Server instances. Application state data, such as HTTP session data, stateful EJB sessions, and dynamic cache information, is replicated in real time across server instances. If any one server instance goes down, the session state is available to the next failover server, resulting in minimum application downtime and enhanced transactional security.\n\nGlassFish Server provides the following high availability features:\n\n- High Availability Session Persistence\n- High Availability Java Message Service\n- RMI-IIOP Load Balancing and Failover\n\nSee Tuning High Availability Persistence for high availability persistence tuning recommendations.\n\nSee the GlassFish Server Open Source Edition High Availability Administration Guide for complete information about configuring high availability clustering, load balancing, and failover features in GlassFish Server 4.0.\n\n### Hardware Resources\n\nThe type and quantity of hardware resources available greatly influence performance tuning and site planning.\n\nGlassFish Server provides excellent vertical scalability. It can scale to efficiently utilize multiple high-performance CPUs, using just one application server process. A smaller number of application server instances makes maintenance easier and administration less expensive. Also, deploying several related applications on fewer application servers can improve performance, due to better data locality, and reuse of cached data between co-located applications. Such servers must also contain large amounts of memory, disk space, and network capacity to cope with increased load.\n\nGlassFish Server can also be deployed on large \"farms\" of relatively modest hardware units. Business applications can be partitioned across various server instances. Using one or more external load balancers can efficiently spread user access across all the application server instances. A horizontal scaling approach may improve availability, lower hardware costs and is suitable for some types of applications. However, this approach requires administration of more application server instances and hardware nodes.\nAdministration\n\nA single GlassFish Server installation on a server can encompass multiple instances. A group of one or more instances that are administered by a single Administration Server is called a domain. Grouping server instances into domains permits different people to independently administer the groups.\n\nYou can use a single-instance domain to create a \"sandbox\" for a particular developer and environment. In this scenario, each developer administers his or her own application server, without interfering with other application server domains. A small development group may choose to create multiple instances in a shared administrative domain for collaborative development.\n\nIn a deployment environment, an administrator can create domains based on application and business function. For example, internal Human Resources applications may be hosted on one or more servers in one Administrative domain, while external customer applications are hosted on several administrative domains in a server farm.\n\nGlassFish Server supports virtual server capability for web applications. For example, a web application hosting service provider can host different URL domains on a single GlassFish Server process for efficient administration.\n\nFor detailed information on administration, see the GlassFish Server Open Source Edition Administration Guide.\n\nGeneral Tuning Concepts\n\nSome key concepts that affect performance tuning are:\n\n- User load\n- Application scalability\n- Margins of safety\n\nThe following table describes these concepts, and how they are measured in practice. The left most column describes the general concept, the second column gives the practical ramifications of the concept, the third column describes the measurements, and the right most column describes the value sources.\n\nTable 1-2 Factors That Affect Performance\n<table>\n<thead>\n<tr>\n<th><strong>Concept</strong></th>\n<th><strong>In practice</strong></th>\n<th><strong>Measurement</strong></th>\n<th><strong>Value sources</strong></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>User Load</td>\n<td>Concurrent sessions at peak load</td>\n<td>Transactions Per Minute (TPM)</td>\n<td>(Max. number of concurrent users) * (expected response time) / (time between clicks)</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Web Interactions Per Second (WIPS)</td>\n<td></td>\n</tr>\n<tr>\n<td>Application</td>\n<td>Transaction rate measured on one CPU</td>\n<td>TPM or WIPS</td>\n<td>Measured from workload benchmark. Perform at each tier.</td>\n</tr>\n<tr>\n<td>Scalability</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Vertical</td>\n<td>Increase in performance from additional CPUs</td>\n<td>Percentage gain per additional CPU</td>\n<td>Based on curve fitting from benchmark. Perform tests while gradually increasing the number of CPUs. Identify the "knee" of the curve, where additional CPUs are providing uneconomical gains in performance. Requires tuning as described in this guide. Perform at each tier and iterate if necessary. Stop here if this meets performance requirements.</td>\n</tr>\n<tr>\n<td>Scalability</td>\n<td></td>\n<td>Percentage gain per additional server process and/or hardware node.</td>\n<td>Use a well-tuned single application server instance, as in previous step. Measure how much each additional server instance and hardware node improves performance.</td>\n</tr>\n<tr>\n<td>Horizontal</td>\n<td>Increase in performance from additional servers</td>\n<td>Percentage gain per additional server process and/or hardware node.</td>\n<td></td>\n</tr>\n<tr>\n<td>Scalability</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Safety</td>\n<td>High availability requirements</td>\n<td>If the system must cope with failures, size the system to meet performance requirements assuming that one or more application server instances are non functional</td>\n<td>Different equations used if high availability is required.</td>\n</tr>\n<tr>\n<td>Margins</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>+</td>\n<td>Excess capacity for unexpected peaks</td>\n<td>It is desirable to operate a server at less than its benchmarked peak, for some safety margin</td>\n<td>80% system capacity utilization at peak loads may work for most installations. Measure your deployment under real and simulated peak loads.</td>\n</tr>\n</tbody>\n</table>\n\n**Capacity Planning**\n\nThe previous discussion guides you towards defining a deployment architecture. However, you determine the actual size of the deployment by a process called capacity planning. Capacity planning enables you to predict:\n• The performance capacity of a particular hardware configuration.\n• The hardware resources required to sustain specified application load and performance.\n\nYou can estimate these values through careful performance benchmarking, using an application with realistic data sets and workloads.\n\n**To Determine Capacity**\n\n1. **Determine performance on a single CPU.**\n \n First determine the largest load that a single processor can sustain. You can obtain this figure by measuring the performance of the application on a single-processor machine. Either leverage the performance numbers of an existing application with similar processing characteristics or, ideally, use the actual application and workload in a testing environment. Make sure that the application and data resources are tiered exactly as they would be in the final deployment.\n\n2. **Determine vertical scalability.**\n\n Determine how much additional performance you gain when you add processors. That is, you are indirectly measuring the amount of shared resource contention that occurs on the server for a specific workload. Either obtain this information based on additional load testing of the application on a multiprocessor system, or leverage existing information from a similar application that has already been load tested.\n\n Running a series of performance tests on one to eight CPUs, in incremental steps, generally provides a sense of the vertical scalability characteristics of the system. Be sure to properly tune the application, GlassFish Server, backend database resources, and operating system so that they do not skew the results.\n\n3. **Determine horizontal scalability.**\n\n If sufficiently powerful hardware resources are available, a single hardware node may meet the performance requirements. However for better availability, you can cluster two or more systems. Employing external load balancers and workload simulation, determine the performance benefits of replicating one well-tuned application server node, as determined in step 2.\n\n**User Expectations**\n\nApplication end-users generally have some performance expectations. Often you can numerically quantify them. To ensure that customer needs are met, you must understand these expectations clearly, and use them in capacity planning.\n\nConsider the following questions regarding performance expectations:\n\n• What do users expect the average response times to be for various interactions with the application? What are the most frequent interactions? Are there any extremely time-critical interactions? What is the length of each transaction, including think time? In many cases, you may\nneed to perform empirical user studies to get good estimates.\n\n- What are the anticipated steady-state and peak user loads? Are there any particular times of the day, week, or year when you observe or expect to observe load peaks? While there may be several million registered customers for an online business, at any one time only a fraction of them are logged in and performing business transactions. A common mistake during capacity planning is to use the total size of customer population as the basis and not the average and peak numbers for concurrent users. The number of concurrent users also may exhibit patterns over time.\n\n- What is the average and peak amount of data transferred per request? This value is also application-specific. Good estimates for content size, combined with other usage patterns, will help you anticipate network capacity needs.\n\n- What is the expected growth in user load over the next year? Planning ahead for the future will help avoid crisis situations and system downtimes for upgrades.\n\nFurther Information\n\n- For more information on Java performance, see Java Performance Documentation (http://java.sun.com/docs/performance) and Java Performance BluePrints (http://java.sun.com/blueprints/performance/index.html).\n\n- For more information about performance tuning for high availability configurations, see the GlassFish Server Open Source Edition High Availability Administration Guide.\n\n- For complete information about using the Performance Tuning features available through the GlassFish Server Administration Console, refer to the Administration Console online help.\n\n- For details on optimizing EJB components, see Seven Rules for Optimizing Entity Beans (http://java.sun.com/developer/technicalArticles/ebeans/sevenrules/)\n\n- For details on profiling, see \"Profiling Tools\" in GlassFish Server Open Source Edition Application Development Guide.\n\n- To view a demonstration video showing how to use the GlassFish Server Performance Tuner, see the Oracle GlassFish Server 3.1 - Performance Tuner demo (http://www.youtube.com/watch?v=FavsE2pzAjc).\n\n- To find additional Performance Tuning development information, see the Performance Tuner in Oracle GlassFish Server 3.1 (http://blogs.oracle.com/jenblog/entry/performance_tuner_in_oracle_glassfish) blog.\n2 Tuning Your Application\n\nThis chapter provides information on tuning applications for maximum performance. A complete guide to writing high performance Java and Java EE applications is beyond the scope of this document.\n\nThe following topics are addressed here:\n\n- Java Programming Guidelines\n- Java Server Page and Servlet Tuning\n- EJB Performance Tuning\n\nJava Programming Guidelines\n\nThis section covers issues related to Java coding and performance. The guidelines outlined are not specific to GlassFish Server, but are general rules that are useful in many situations. For a complete discussion of Java coding best practices, see the Java Blueprints (http://www.oracle.com/technetwork/java/javaee/blueprints/index.html).\n\nThe following topics are addressed here:\n\n- Avoid Serialization and Deserialization\n- Use StringBuilder to Concatenate Strings\n- Assign null to Variables That Are No Longer Needed\n- Declare Methods as final Only If Necessary\n- Declare Constants as static final\n- Avoid Finalizers\n- Declare Method Arguments final\n- Synchronize Only When Necessary\n- Use DataHandlers for SOAP Attachments\n\nAvoid Serialization and Deserialization\n\nSerialization and deserialization of objects is a CPU-intensive procedure and is likely to slow down your application. Use the transient keyword to reduce the amount of data serialized. Additionally, customized readObject() and writeObject() methods may be beneficial in some cases.\nUse **StringBuilder to Concatenate Strings**\n\nTo improve performance, instead of using string concatenation, use `StringBuilder.append()`.\n\nString objects are immutable - that is, they never change after creation. For example, consider the following code:\n\n```java\nString str = \"testing\";\nstr = str + \"abc\";\nstr = str + \"def\";\n```\n\nThe compiler translates this code as:\n\n```java\nString str = \"testing\";\nStringBuilder tmp = new StringBuilder(str);\ntmp.append(\"abc\");\nstr = tmp.toString();\nStringBuilder tmp = new StringBuilder(str);\ntmp.append(\"def\");\nstr = tmp.toString();\n```\n\nThis copying is inherently expensive and overusing it can reduce performance significantly. You are far better off writing:\n\n```java\nStringBuilder tmp = new StringBuilder(\"testing\");\ntmp.append(\"abc\");\ntmp.append(\"def\");\nString str = tmp.toString();\n```\n\n**Assign null to Variables That Are No Longer Needed**\n\nExplicitly assigning a null value to variables that are no longer needed helps the garbage collector to identify the parts of memory that can be safely reclaimed. Although Java provides memory management, it does not prevent memory leaks or using excessive amounts of memory.\n\nAn application may induce memory leaks by not releasing object references. Doing so prevents the Java garbage collector from reclaiming those objects, and results in increasing amounts of memory being used. Explicitly nullifying references to variables after their use allows the garbage collector to reclaim memory.\n\nOne way to detect memory leaks is to employ profiling tools and take memory snapshots after each transaction. A leak-free application in steady state will show a steady active heap memory after\ngarbage collections.\n\nDeclare Methods as final Only If Necessary\n\nModern optimizing dynamic compilers can perform inlining and other inter-procedural optimizations, even if Java methods are not declared final. Use the keyword `final` as it was originally intended: for program architecture reasons and maintainability.\n\nOnly if you are absolutely certain that a method must not be overridden, use the `final` keyword.\n\nDeclare Constants as static final\n\nThe dynamic compiler can perform some constant folding optimizations easily, when you declare constants as `static final` variables.\n\nAvoid Finalizers\n\nAdding finalizers to code makes the garbage collector more expensive and unpredictable. The virtual machine does not guarantee the time at which finalizers are run. Finalizers may not always be executed, before the program exits. Releasing critical resources in `finalize()` methods may lead to unpredictable application behavior.\n\nDeclare Method Arguments final\n\nDeclare method arguments `final` if they are not modified in the method. In general, declare all variables `final` if they are not modified after being initialized or set to some value.\n\nSynchronize Only When Necessary\n\nDo not synchronize code blocks or methods unless synchronization is required. Keep synchronized blocks or methods as short as possible to avoid scalability bottlenecks. Use the Java Collections Framework for unsynchronized data structures instead of more expensive alternatives such as `java.util.HashTable`.\nUse DataHandlers for SOAP Attachments\n\nUsing a `javax.activation.DataHandler` for a SOAP attachment will improve performance.\n\nJAX-RPC specifies:\n\n- A mapping of certain MIME types to Java types.\n- Any MIME type is mappable to a `javax.activation.DataHandler`.\n\nAs a result, send an attachment (.gif or XML document) as a SOAP attachment to an RPC style web service by utilizing the Java type mappings. When passing in any of the mandated Java type mappings (appropriate for the attachment's MIME type) as an argument for the web service, the JAX-RPC runtime handles these as SOAP attachments.\n\nFor example, to send out an `image/gif` attachment, use `java.awt.Image`, or create a `DataHandler` wrapper over your image. The advantages of using the wrapper are:\n\n- Reduced coding: You can reuse generic attachment code to handle the attachments because the `DataHandler` determines the content type of the contained data automatically. This feature is especially useful when using a document style service. Since the content is known at runtime, there is no need to make calls to `attachment.setContent(stringContent, \"image/gif\")`, for example.\n- Improved Performance: Informal tests have shown that using `DataHandler` wrappers doubles throughput for `image/gif` MIME types, and multiplies throughput by approximately 1.5 for `text/xml` or `java.awt.Image` for `image/*` types.\n\nJava Server Page and Servlet Tuning\n\nMany applications running on the GlassFish Server use servlets or JavaServer Pages (JSP) technology in the presentation tier. This section describes how to improve performance of such applications, both through coding practices and through deployment and configuration settings.\n\nSuggested Coding Practices\n\nThis section provides some tips on coding practices that improve servlet and JSP application performance.\n\nThe following topics are addressed here:\n\n- General Guidelines\n- Avoid Shared Modified Class Variables\n- HTTP Session Handling\nConfiguration and Deployment Tips\n\nGeneral Guidelines\n\nFollow these general guidelines to increase performance of the presentation tier:\n\n- Minimize Java synchronization in servlets.\n- Do not use the single thread model for servlets.\n- Use the servlet's `init()` method to perform expensive one-time initialization.\n- Avoid using `System.out.println()` calls.\n\nAvoid Shared Modified Class Variables\n\nIn the servlet multithread model (the default), a single instance of a servlet is created for each application server instance. All requests for a servlet on that application instance share the same servlet instance. This can lead to thread contention if there are synchronization blocks in the servlet code. Therefore, avoid using shared modified class variables because they create the need for synchronization.\n\nHTTP Session Handling\n\nFollow these guidelines when using HTTP sessions:\n\n- Create sessions sparingly. Session creation is not free. If a session is not required, do not create one.\n- Use `javax.servlet.http.HttpSession.invalidate()` to release sessions when they are no longer needed.\n- Keep session size small, to reduce response times. If possible, keep session size below 7 kilobytes.\n- Use the directive `<%@ page session=\"false\" %>` in JSP files to prevent the GlassFish Server from automatically creating sessions when they are not necessary.\n- Avoid large object graphs in an `HttpSession`. They force serialization and add computational overhead. Generally, do not store large objects as `HttpSession` variables.\n- Do not cache transaction data in an `HttpSession`. Access to data in an `HttpSession` is not transactional. Do not use it as a cache of transactional data, which is better kept in the database and accessed using entity beans. Transactions will rollback upon failures to their original state. However, stale and inaccurate data may remain in `HttpSession` objects. GlassFish Server provides \"read-only\" bean-managed persistence entity beans for cached access to read-only data.\n**Configuration and Deployment Tips**\n\nFollow these configuration tips to improve performance. These tips are intended for production environments, not development environments.\n\n- To improve class loading time, avoid having excessive directories in the server `CLASSPATH`. Put application-related classes into JAR files.\n\n- HTTP response times are dependent on how the keep-alive subsystem and the HTTP server is tuned in general. For more information, see [HTTP Service Settings](#).\n\n- Cache servlet results when possible. For more information, see \"Developing Web Applications\" in GlassFish Server Open Source Edition Application Development Guide.\n\n- If an application does not contain any EJB components, deploy the application as a WAR file, not an EAR file.\n\n**Optimize SSL**\n\nOptimize SSL by using routines in the appropriate operating system library for concurrent access to heap space. The library to use depends on the version of the Solaris Operating System (SolarisOS) that you are using. To ensure that you use the correct library, set the `LD_PRELOAD` environment variable to specify the correct library file. For more information, refer to the following table.\n\n<table>\n<thead>\n<tr>\n<th>Solaris OS Version</th>\n<th>Library</th>\n<th>Setting of <code>LD_PRELOAD</code> Environment Variable</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>10</td>\n<td>libumem3LIB</td>\n<td>/usr/lib/libumem.so</td>\n</tr>\n<tr>\n<td>9</td>\n<td>libmtmalloc3LIB</td>\n<td>/usr/lib/libmtmalloc.so</td>\n</tr>\n</tbody>\n</table>\n\nTo set the `LD_PRELOAD` environment variable, edit the entry for this environment variable in the `startserv` script. The `startserv` script is located in the `bin/startserv` directory of your domain.\n\nThe exact syntax to define an environment variable depends on the shell that you are using.\n\n**Disable Security Manager**\n\nThe security manager is expensive because calls to required resources must call the `doPrivileged()` method and must also check the resource with the `server.policy` file. If you are sure that no malicious code will be run on the server and you do not use authentication within your application, then you can disable the security manager.\n\nSee \"Enabling and Disabling the Security Manager\" in GlassFish Server Open Source Edition Application Development Guide for instructions on enabling or disabling the security manager. If using the GlassFish Server Administration Console, navigate to the Configurations>configuration-\nSecurity node and check or uncheck the Security Manager option as desired. Refer to the Administration Console online help for more information.\n\n## EJB Performance Tuning\n\nThe GlassFish Server's high-performance EJB container has numerous parameters that affect performance. Individual EJB components also have parameters that affect performance. The value of individual EJB component's parameter overrides the value of the same parameter for the EJB container. The default values are designed for a single-processor computer system. Modify these values as appropriate to optimize for other system configurations.\n\nThe following topics are addressed here:\n\n- **Goals**\n- **Monitoring EJB Components**\n- **General Guidelines**\n- **Using Local and Remote Interfaces**\n- **Improving Performance of EJB Transactions**\n- **Using Special Techniques**\n- **Tuning Tips for Specific Types of EJB Components**\n- **JDBC and Database Access**\n- **Tuning Message-Driven Beans**\n\n### Goals\n\nThe goals of EJB performance tuning are:\n\n- **Increased speed**: Cache as many beans in the EJB caches as possible to increase speed (equivalently, decrease response time). Caching eliminates CPU-intensive operations. However, since memory is finite, as the caches become larger, housekeeping for them (including garbage collection) takes longer.\n\n- **Decreased memory consumption**: Beans in the pools or caches consume memory from the Java virtual machine heap. Very large pools and caches degrade performance because they require longer and more frequent garbage collection cycles.\n\n- **Improved functional properties**: Functional properties such as user timeout, commit options, security, and transaction options, are mostly related to the functionality and configuration of the application. Generally, they do not compromise functionality for performance. In some cases, you might be forced to make a \"trade-off\" decision between functionality and performance. This section\noffers suggestions in such cases.\n\n### Monitoring EJB Components\n\nWhen the EJB container has monitoring enabled, you can examine statistics for individual beans based on the bean pool and cache settings.\n\nFor example, the monitoring command below returns the Bean Cache statistics for a stateful session bean.\n\n```bash\nasadmin get --user admin --host e4800-241-a --port 4848\n-m specjcmp.application.SPECjAppServer.ejb-module.\n supplier_jar.stateful-session-bean.BuyerSes.bean-cache.*\n```\n\nThe following is a sample of the monitoring output:\n\n```\nresize-quantity = -1\ncache-misses = 0\nidle-timeout-in-seconds = 0\nnum-passivations = 0\ncache-hits = 59\nnum-passivation-errors = 0\ntotal-beans-in-cache = 59\nnum-expired-sessions-removed = 0\nmax-beans-in-cache = 4096\nnum-passivation-success = 0\n```\n\nThe monitoring command below gives the bean pool statistics for an entity bean:\n\n```bash\nasadmin get --user admin --host e4800-241-a --port 4848\n-m specjcmp.application.SPECjAppServer.ejb-module.\n supplier_jar.stateful-entity-bean.ItemEnt.bean-pool.*\n```\n\n```\nidle-timeout-in-seconds = 0\nsteady-pool-size = 0\ntotal-beans-destroyed = 0\nnum-threads-waiting = 0\nnum-beans-in-pool = 54\nmax-pool-size = 2147483647\npool-resize-quantity = 0\ntotal-beans-created = 255\n```\n\nThe monitoring command below gives the bean pool statistics for a stateless bean.\n\n```bash\nasadmin get --user admin --host e4800-241-a --port 4848\n-m specjcmp.application.SPECjAppServer.ejb-module.\n```\n\n```\n```\nTuning the bean involves charting the behavior of the cache and pool for the bean in question over a period of time.\n\nIf too many passivations are happening and the JVM heap remains fairly small, then the `max-cache-size` or the `cache-idle-timeout-in-seconds` can be increased. If garbage collection is happening too frequently, and the pool size is growing, but the cache hit rate is small, then the `pool-idle-timeout-in-seconds` can be reduced to destroy the instances.\n\nNote:\nSpecifying a `max-pool-size` of zero (0) means that the pool is unbounded. The pooled beans remain in memory unless they are removed by specifying a small interval for `pool-idle-timeout-in-seconds`. For production systems, specifying the pool as unbounded is NOT recommended.\n\n**Monitoring Individual EJB Components**\n\nTo gather method invocation statistics for all methods in a bean, use the following command:\n\n```\nasadmin get -m monitorableObject.*\n```\n\nwhere `monitorableObject` is a fully-qualified identifier from the hierarchy of objects that can be monitored, shown below.\n\n```\nserverInstance.application.applicationName.ejb-module.moduleName\n```\n\nwhere `moduleName` is `x.jar` for module `x.jar`.\n\n - `.stateless-session-bean.beanName .bean-pool .bean-method.methodName`\n - `.stateful-session-bean.beanName .bean-cache .bean-method.methodName`\nFor standalone beans, use this pattern:\n\n```\nserverInstance.application.applicationName.standalone-ejb-module.moduleName\n```\n\nThe possible identifiers are the same as for `ejb-module`.\n\nFor example, to get statistics for a method in an entity bean, use this command:\n\n```\nasadmin get -m serverInstance.application.applicationName.ejb-module.moduleName .entity-bean.beanName.bean-method.methodName.*\n```\n\nFor more information about administering the monitoring service in general, see \"Administering the Monitoring Service\" in GlassFish Server Open Source Edition Administration Guide. For information about viewing comprehensive EJB monitoring statistics, see \"EJB Statistics\" in GlassFish Server Open Source Edition Administration Guide.\n\nTo configure EJB monitoring using the GlassFish Server Administration Console, navigate to the Configurations>configuration-name>Monitoring node. After configuring monitoring, you can view monitoring statistics by navigating to the server (Admin Server) node and then selecting the Monitor tab. Refer to the Administration Console online help for instructions on each of these procedures.\n\nAlternatively, to list EJB statistics, use the `asadmin list` subcommand. For more information, see `list (1)`.\n\nFor statistics on stateful session bean passivations, use this command:\n\n```\nasadmin get -m serverInstance.application.applicationName.ejb-module.moduleName .stateful-session-bean.beanName.bean-cache.*\n```\n\nFrom the attribute values that are returned, use this command:\n\n```\nnum-passivations num-passivation-errors num-passivation-success\n```\n\n**General Guidelines**\n\nThe following guidelines can improve performance of EJB components. Keep in mind that decomposing an application into many EJB components creates overhead and can degrade performance. EJB components are not simply Java objects. They are components with semantics for remote call interfaces, security, and transactions, as well as properties and methods.\nUse High Performance Beans\n\nUse high-performance beans as much as possible to improve the overall performance of your application. For more information, see Tuning Tips for Specific Types of EJB Components.\n\nThe types of EJB components are listed below, from the highest performance to the lowest:\n\n1. Stateless Session Beans and Message Driven Beans\n2. Stateful Session Beans\n3. Container Managed Persistence (CMP) entity beans configured as read-only\n4. Bean Managed Persistence (BMP) entity beans configured as read-only\n5. CMP beans\n6. BMP beans\n\nFor more information about configuring high availability session persistence, see \"Configuring High Availability Session Persistence and Failover\" in GlassFish Server Open Source Edition High Availability Administration Guide. To configure EJB beans using the GlassFish Server Administration Console, navigate to the Configurations>configuration-name>EJB Container node and then refer to the Administration Console online help for detailed instructions.\n\nUse Caching\n\nCaching can greatly improve performance when used wisely. For example:\n\n• Cache EJB references: To avoid a JNDI lookup for every request, cache EJB references in servlets.\n• Cache home interfaces: Since repeated lookups to a home interface can be expensive, cache references to EJBHomes in the init() methods of servlets.\n• Cache EJB resources: Use setSessionContext() or ejbCreate() to cache bean resources. This is again an example of using bean lifecycle methods to perform application actions only once where possible. Remember to release acquired resources in the ejbRemove() method.\n\nUse the Appropriate Stubs\n\nThe stub classes needed by EJB applications are generated dynamically at runtime when an EJB client needs them. This means that it is not necessary to generate the stubs or retrieve the client JAR file when deploying an application with remote EJB components. When deploying an application, it is no longer necessary to specify the --retrieve option, which can speed up deployment.\nIf you have a legacy rich-client application that directly uses the CosNaming service (not a recommended configuration), then you must generate the stubs for your application explicitly using RMIC. For more information, see the GlassFish Server Open Source Edition Troubleshooting Guide for more details.\n\n### Remove Unneeded Stateful Session Beans\n\nRemoving unneeded stateful session beans avoids passivating them, which requires disk operations.\n\n### Cache and Pool Tuning Tips\n\nFollow these tips when using the EJB cache and pools to improve performance:\n\n- Explicitly call `remove()`: Allow stateful session EJB components to be removed from the container cache by explicitly calling the `remove()` method in the client.\n\n- Tune the entity EJB component’s pool size: Entity Beans use both the EJB pool and cache settings. Tune the entity EJB component’s pool size to minimize the creation and destruction of beans. Populating the pool with a non-zero steady size before hand is useful for getting better response for initial requests.\n\n- Cache bean-specific resources: Use the `setEntityContext()` method to cache bean specific resources and release them using the `unSetEntityContext()` method.\n\n- Load related data efficiently for container-managed relationships (CMRs). For more information, see Pre-Fetching Container Managed Relationship (CMR) Beans.\n\n- Identify read-only beans: Configure read-only entity beans for read only operations. For more information, see Read-Only Entity Beans.\n\n### Using Local and Remote Interfaces\n\nThis section describes some considerations when EJB components are used by local and remote clients.\n\n### Prefer Local Interfaces\n\nAn EJB component can have remote and local interfaces. Clients not located in the same application server instance as the bean (remote clients) use the remote interface to access the bean. Calls to the remote interface require marshalling arguments, transportation of the marshalled data over the network, un-marshaling the arguments, and dispatch at the receiving end. Thus, using the remote interface entails significant overhead.\nIf an EJB component has a local interface, then local clients in the same application server instance can use it instead of the remote interface. Using the local interface is more efficient, since it does not require argument marshalling, transportation, and un-marshalling.\n\nIf a bean is to be used only by local clients then it makes sense to provide only the local interface. If, on the other hand, the bean is to be location-independent, then you should provide both the remote and local interfaces so that remote clients use the remote interface and local clients can use the local interface for efficiency.\n\n**Using Pass-By-Reference Semantics**\n\nBy default, the GlassFish Server uses pass-by-value semantics for calling the remote interface of a bean, even if it is co-located. This can be expensive, since clients using pass-by-value semantics must copy arguments before passing them to the EJB component.\n\nHowever, local clients can use pass-by-reference semantics and thus the local and remote interfaces can share the passed objects. But this means that the argument objects must be implemented properly, so that they are shareable. In general, it is more efficient to use pass-by-reference semantics when possible.\n\nUsing the remote and local interfaces appropriately means that clients can access EJB components efficiently. That is, local clients use the local interface with pass-by-reference semantics, while remote clients use the remote interface with pass-by-value semantics.\n\nHowever, in some instances it might not be possible to use the local interface, for example when:\n\n- The application predates the EJB 2.0 specification and was written without any local interfaces.\n- There are bean-to-bean calls and the client beans are written without making any co-location assumptions about the called beans.\n\nFor these cases, the GlassFish Server provides a pass-by-reference option that clients can use to pass arguments by reference to the remote interface of a co-located EJB component.\n\nYou can specify the pass-by-reference option for an entire application or a single EJB component. When specified at the application level, all beans in the application use pass-by-reference semantics when passing arguments to their remote interfaces. When specified at the bean level, all calls to the remote interface of the bean use pass-by-reference semantics. See \"Value Added Features\" in GlassFish Server Open Source Edition Application Development Guide for more details about the pass-by-reference flag.\n\nTo specify that an EJB component will use pass by reference semantics, use the following tag in the `sun-ejb-jar.xml` deployment descriptor:\nThis avoids copying arguments when the EJB component’s methods are invoked and avoids copying results when methods return. However, problems will arise if the data is modified by another source during the invocation.\n\n**Improving Performance of EJB Transactions**\n\nThis section provides some tips to improve performance when using transactions.\n\nThe following topics are addressed here:\n\n- Use Container-Managed Transactions\n- Do Not Encompass User Input Time\n- Identify Non-Transactional Methods\n- Use `TX_REQUIRED` for Long Transaction Chains\n- Use Lowest Cost Database Locking\n- Use XA-Capable Data Sources Only When Needed\n- Configure JDBC Resources as One-Phase Commit Resources\n- Use the Least Expensive Transaction Attribute\n\n**Use Container-Managed Transactions**\n\nContainer-managed transactions are preferred for consistency, and provide better performance.\n\n**Do Not Encompass User Input Time**\n\nTo avoid resources being held unnecessarily for long periods, a transaction should not encompass user input or user think time.\n\n**Identify Non-Transactional Methods**\n\nDeclare non-transactional methods of session EJB components with `NotSupportedException` or `Never` transaction attributes. These attributes can be found in the `ejb-jar.xml` deployment descriptor file. Transactions should span the minimum time possible since they lock database rows.\nUse **TX_REQUIRED** for Long Transaction Chains\n\nFor very large transaction chains, use the transaction attribute **TX_REQUIRED**. To ensure EJB methods in a call chain, use the same transaction.\n\nUse Lowest Cost Database Locking\n\nUse the lowest cost locking available from the database that is consistent with any transaction. Commit the data after the transaction completes rather than after each method call.\n\nUse XA-Capable Data Sources Only When Needed\n\nWhen multiple database resources, connector resources or JMS resources are involved in one transaction, a distributed or global transaction needs to be performed. This requires XA capable resource managers and data sources. Use XA capable data sources, only when two or more data source are going to be involved in a transaction. If a database participates in some distributed transactions, but mostly in local or single database transactions, it is advisable to register two separate JDBC resources and use the appropriate resource in the application.\n\nConfigure JDBC Resources as One-Phase Commit Resources\n\nTo improve performance of transactions involving multiple resources, the GlassFish Server uses last agent optimization (LAO), which allows the configuration of one of the resources in a distributed transaction as a one-phase commit (1PC) resource. Since the overhead of multiple-resource transactions is much higher for a JDBC resource than a message queue, LAO substantially improves performance of distributed transactions involving one JDBC resource and one or more message queues. To take advantage of LAO, configure a JDBC resource as a 1PC resource. Nothing special needs to be done to configure JMS resources.\n\nIn global transactions involving multiple JDBC resources, LAO will still improve performance, however, not as much as for one JDBC resource. In this situation, one of the JDBC resources should be configured as 1PC, and all others should be configured as XA.\n\nUse the Least Expensive Transaction Attribute\n\nSet the following transaction attributes in the EJB deployment descriptor file (**ejb-jar.xml**). Options are listed from best performance to worst. To improve performance, choose the least expensive attribute\nthat will provide the functionality your application needs:\n\n1. NEVER\n2. TX_NOTSUPPORTED\n3. TX_MANDATORY\n4. TX_SUPPORTS\n5. TX_REQUIRED\n6. TX_REQUIRESNEW\n\nUsing Special Techniques\n\nSpecial performance-enhancing techniques are discussed in the following sections:\n\n- Version Consistency\n- Request Partitioning\n\nVersion Consistency\n\nNote:\n\nThe technique in section applies only to the EJB 2.1 architecture. In the EJB 3.0 architecture, use the Java Persistence API (JPA).\n\nUse version consistency to improve performance while protecting the integrity of data in the database. Since the application server can use multiple copies of an EJB component simultaneously, an EJB component’s state can potentially become corrupted through simultaneous access.\n\nThe standard way of preventing corruption is to lock the database row associated with a particular bean. This prevents the bean from being accessed by two simultaneous transactions and thus protects data. However, it also decreases performance, since it effectively serializes all EJB access.\n\nVersion consistency is another approach to protecting EJB data integrity. To use version consistency, you specify a column in the database to use as a version number. The EJB lifecycle then proceeds like this:\n\n- The first time the bean is used, the `ejbLoad()` method loads the bean as normal, including loading the version number from the database.\n- The `ejbStore()` method checks the version number in the database versus its value when the EJB component was loaded.\n - If the version number has been modified, it means that there has been simultaneous access to\nthe EJB component and `ejbStore()` throws a `ConcurrentModificationException`.\n\n- Otherwise, `ejbStore()` stores the data and completes as normal.\n The `ejbStore()` method performs this validation at the end of the transaction regardless of whether any data in the bean was modified.\n\nSubsequent uses of the bean behave similarly, except that the `ejbLoad()` method loads its initial data (including the version number) from an internal cache. This saves a trip to the database. When the `ejbStore()` method is called, the version number is checked to ensure that the correct data was used in the transaction.\n\nVersion consistency is advantageous when you have EJB components that are rarely modified, because it allows two transactions to use the same EJB component at the same time. Because neither transaction modifies the data, the version number is unchanged at the end of both transactions, and both succeed. But now the transactions can run in parallel. If two transactions occasionally modify the same EJB component, one will succeed and one will fail and can be retried using the new values—which can still be faster than serializing all access to the EJB component if the retries are infrequent enough (though now your application logic has to be prepared to perform the retry operation).\n\nTo use version consistency, the database schema for a particular table must include a column where the version can be stored. You then specify that table in the `sun-cmp-mapping.xml` deployment descriptor for a particular bean:\n\n```xml\n<entity-mapping>\n <cmp-field-mapping>\n ...\n </cmp-field-mapping>\n <consistency>\n <check-version-of-accessed-instances>\n <column-name>OrderTable.VC_VERSION_NUMBER</column-name>\n </check-version-of-accessed-instances>\n </consistency>\n</entity-mapping>\n```\n\nIn addition, you must establish a trigger on the database to automatically update the version column when data in the specified table is modified. The GlassFish Server requires such a trigger to use version consistency. Having such a trigger also ensures that external applications that modify the EJB data will not conflict with EJB transactions in progress.\n\nFor example, the following DDL illustrates how to create a trigger for the `Order` table:\nCREATE TRIGGER OrderTrigger\nBEFORE UPDATE ON OrderTable\nFOR EACH ROW\nWHEN (new.VC_VERSION_NUMBER = old.VC_VERSION_NUMBER)\nDECLARE\nBEGIN\n :NEW.VC_VERSION_NUMBER := :OLD.VC_VERSION_NUMBER + 1;\nEND;\n\nRequest Partitioning\n\nRequest partitioning enables you to assign a request priority to an EJB component. This gives you the flexibility to make certain EJB components execute with higher priorities than others.\n\nAn EJB component which has a request priority assigned to it will have its requests (services) executed within an assigned threadpool. By assigning a threadpool to its execution, the EJB component can execute independently of other pending requests. In short, request partitioning enables you to meet service-level agreements that have differing levels of priority assigned to different services.\n\nRequest partitioning applies only to remote EJB components (those that implement a remote interface). Local EJB components are executed in their calling thread (for example, when a servlet calls a local bean, the local bean invocation occurs on the servlet’s thread).\n\nTo Enable Request Partitioning\n\nFollow this procedure.\n\n1. Configure additional threadpools for EJB execution.\n Using the GlassFish Server Administration Console, navigate to the Configurations>configuration-name>Thread Pools node. Refer to the Administration Console online help for more information. Alternatively, you can follow the instructions in \"Administering Thread Pools\" in GlassFish Server Open Source Edition Administration Guide.\n Configure the threadpools as follows:\n\n2. Add the additional threadpool IDs to the GlassFish Server's ORB.\n This can be done on the Configurations>configuration-name>ORB node in the Administration Console.\n For example, enable threadpools named priority-1 and priority-2 to the <orb> element as follows:\n\n```xml\n<orb max-connections=\"1024\" message-fragment-size=\"1024\"\n use-thread-pool-ids=\"thread-pool-1,priority-1,priority-2\">\n```\n1. Include the threadpool ID in the `use-thread-pool-id` element of the EJB component's `sun-ejb-jar.xml` deployment descriptor. For example, the following `sun-ejb-jar.xml` deployment descriptor for an EJB component named “TheGreeter” is assigned to a thread pool named `priority-2`:\n\n```xml\n<sun-ejb-jar>\n <enterprise-beans>\n <unique-id>1</unique-id>\n <ejb>\n <ejb-name>TheGreeter</ejb-name>\n <jndi-name>greeter</jndi-name>\n <use-thread-pool-id>priority-1</use-thread-pool-id>\n </ejb>\n </enterprise-beans>\n</sun-ejb-jar>\n```\n\n1. Restart the GlassFish Server.\n\n**Tuning Tips for Specific Types of EJB Components**\n\nThis section provides tips for tuning various specific types of EJB components:\n\n- **Entity Beans**\n- **Stateful Session Beans**\n- **Stateless Session Beans**\n- **Read-Only Entity Beans**\n- **Pre-Fetching Container Managed Relationship (CMR) Beans**\n\nThese components can all be configured in the GlassFish Server Administration Console from the Configurations>configuration-name>EJB Container node. Alternatively, you can perform these configurations by following the instructions in \"RMI-IIOP Load Balancing and Failover\" in GlassFish Server Open Source Edition High Availability Administration Guide.\n\n**Entity Beans**\n\nDepending on the usage of a particular entity bean, one should tune `max-cache-size` so that the beans that are used less frequently (for example, an order that is created and never used after the transaction is over) are cached less, and beans that are used frequently (for example, an item in the inventory that gets referenced very often), are cached more.\nStateful Session Beans\n\nWhen a stateful bean represents a user, a reasonable `max-cache-size` of beans is the expected number of concurrent users on the application server process. If this value is too low (in relation to the steady load of users), beans would be frequently passivated and activated, causing a negative impact on the response times, due to CPU intensive serialization and deserialization as well as disk I/O.\n\nAnother important variable for tuning is `cache-idle-timeout-in-seconds` where at periodic intervals of `cache-idle-timeout-in-seconds`, all the beans in the cache that have not been accessed for more than `cache-idle-timeout-in-seconds` time, are passivated. Similar to an HTTP session timeout, the bean is removed after it has not been accessed for `removal-timeout-in-seconds`. Passivated beans are stored on disk in serialized form. A large number of passivated beans could not only mean many files on the disk system, but also slower response time as the session state has to be de-serialized before the invocation.\n\nCheckpoint only when needed\n\nIn high availability mode, when using stateful session beans, consider checkpointing only those methods that alter the state of the bean significantly. This reduces the number of times the bean state has to be checkpointed into the persistent store.\n\nStateless Session Beans\n\nStateless session beans are more readily pooled than entity or the stateful session beans. Valid values for `steady-pool-size`, `pool-resize-quantity` and `max-pool-size` are the best tunables for these type of beans. Set the `steady-pool-size` to greater than zero if you want to pre-populate the pool. This way, when the container comes up, it creates a pool with `steady-pool-size` number of beans. By pre-populating the pool it is possible to avoid the object creation time during method invocations.\n\nSetting the `steady-pool size` to a very large value can cause unwanted memory growth and can result in large garbage collection times. `pool-resize-quantity` determines the rate of growth as well as the rate of decay of the pool. Setting it to a small value is better as the decay behaves like an exponential decay. Setting a small `max-pool-size` can cause excessive object destruction (and as a result excessive object creation) as instances are destroyed from the pool if the current pool size exceeds `max-pool-size`.\n\nRead-Only Entity Beans\n\nRead-only entity beans cache data from the database. GlassFish Server supports read-only beans that use both bean-managed persistence (BMP) and container-managed persistence (CMP). Of the two types, CMP read-only beans provide significantly better performance. In the EJB lifecycle, the EJB container\ncalls the `ejbLoad()` method of a read-only bean once. The container makes multiple copies of the EJB component from that data, and since the beans do not update the database, the container never calls the `ejbStore()` method. This greatly reduces database traffic for these beans.\n\nIf there is a bean that never updates the database, use a read-only bean in its place to improve performance. A read-only bean is appropriate if either:\n\n- Database rows represented by the bean do not change.\n- The application can tolerate using out-of-date values for the bean.\n\nFor example, an application might use a read-only bean to represent a list of best-seller books. Although the list might change occasionally in the database (say, from another bean entirely), the change need not be reflected immediately in an application.\n\nThe `ejbLoad()` method of a read-only bean is handled differently for CMP and BMP beans. For CMP beans, the EJB container calls `ejbLoad()` only once to load the data from the database; subsequent uses of the bean just copy that data. For BMP beans, the EJB container calls `ejbLoad()` the first time a bean is used in a transaction. Subsequent uses of that bean within the transaction use the same values. The container calls `ejbLoad()` for a BMP bean that doesn’t run within a transaction every time the bean is used. Therefore, read-only BMP beans still make a number of calls to the database.\n\nTo create a read-only bean, add the following to the EJB deployment descriptor `sun-ejb-jar.xml`:\n\n```\n<is-read-only-bean>true</is-read-only-bean>\n<refresh-period-in-seconds>600</refresh-period-in-seconds>\n```\n\nRefresh Period\n\nAn important parameter for tuning read-only beans is the refresh period, represented by the deployment descriptor entity `refresh-period-in-seconds`. For CMP beans, the first access to a bean loads the bean’s state. The first access after the refresh period reloads the data from the database. All subsequent uses of the bean use the newly refreshed data (until another refresh period elapses). For BMP beans, an `ejbLoad()` method within an existing transaction uses the cached data unless the refresh period has expired (in which case, the container calls `ejbLoad()` again).\n\nThis parameter enables the EJB component to periodically refresh its \"snapshot\" of the database values it represents. If the refresh period is less than or equal to 0, the bean is never refreshed from the database (the default behavior if no refresh period is given).\n\nPre-Fetching Container Managed Relationship (CMR) Beans\n\nIf a container-managed relationship (CMR) exists in your application, loading one bean will load all its\nrelated beans. The canonical example of CMR is an order-orderline relationship where you have one Order EJB component that has related OrderLine EJB components. In previous releases of the application server, to use all those beans would require multiple database queries: one for the Order bean and one for each of the OrderLine beans in the relationship.\n\nIn general, if a bean has n relationships, using all the data of the bean would require n+1 database accesses. Use CMR pre-fetching to retrieve all the data for the bean and all its related beans in one database access.\n\nFor example, you have this relationship defined in the ejb-jar.xml file:\n\n```xml\n<relationships>\n <ejb-relation>\n <description>Order-OrderLine</description>\n <ejb-relation-name>Order-OrderLine</ejb-relation-name>\n <ejb-relationship-role>\n <ejb-relationship-role-name>Order-has-N-OrderLines</ejb-relationship-role-name>\n <multiplicity>One</multiplicity>\n <relationship-role-source>\n <ejb-name>OrderEJB</ejb-name>\n </relationship-role-source>\n <cmr-field>\n <cmr-field-name>orderLines</cmr-field-name>\n <cmr-field-type>java.util.Collection</cmr-field-type>\n </cmr-field>\n </ejb-relationship-role>\n </ejb-relation>\n</relationships>\n```\n\nWhen a particular Order is loaded, you can load its related OrderLines by adding this to the sun-cmp-mapping.xml file for the application:\nNow when an Order is retrieved, the CMP engine issues SQL to retrieve all related OrderLines with a SELECT statement that has the following WHERE clause:\n\n```\nOrderTable.OrderID = OrderLineTable.OrderLine_OrderID\n```\n\nThis clause indicates an outer join. These OrderLines are pre-fetched.\n\nPre-fetching generally improves performance because it reduces the number of database accesses. However, if the business logic often uses Orders without referencing their OrderLines, then this can have a performance penalty, that is, the system has spent the effort to pre-fetch the OrderLines that are not actually needed.\n\nAvoid pre-fetching for specific finder methods; this can often avoid that penalty. For example, consider an order bean has two finder methods: a findByPrimaryKey method that uses the Orderlines, and a findByCustomerId method that returns only order information and therefore does not use the Orderlines. If you have enabled CMR pre-fetching for the Orderlines, both finder methods will pre-fetch the Orderlines. However, you can prevent pre-fetching for the findByCustomerId method by including this information in the sun-ejb-jar.xml descriptor:\nJDBC and Database Access\n\nThe following are some tips to improve the performance of database access:\n\n- **Use JDBC Directly**\n- **Encapsulate Business Logic in Entity EJB Components**\n- **Close Connections**\n- **Minimize the Database Transaction Isolation Level**\n\n**Use JDBC Directly**\n\nWhen dealing with large amounts of data, such as searching a large database, use JDBC directly rather than using Entity EJB components.\n\n**Encapsulate Business Logic in Entity EJB Components**\n\nCombine business logic with the Entity EJB component that holds the data needed for that logic to process.\n\n**Close Connections**\n\nTo ensure that connections are returned to the pool, always close the connections after use.\nMinimize the Database Transaction Isolation Level\n\nUse the default isolation level provided by the JDBC driver rather than calling `setTransactionIsolationLevel()`, unless you are certain that your application behaves correctly and performs better at a different isolation level.\n\nReduce the database transaction isolation level when appropriate. Reduced isolation levels reduce work in the database tier, and could lead to better application performance. However, this must be done after carefully analyzing the database table usage patterns.\n\nTo set the database transaction isolation level using the GlassFish Server Administration Console, navigate to the Resources>JDBC>JDBC Connection Pools>pool-name node. Refer to the Administration Console online help for complete instructions. Alternatively, follow the instructions in \"Administering Database Connectivity\" in GlassFish Server Open Source Edition Administration Guide. For more information on tuning JDBC connection pools, see JDBC Connection Pool Settings.\n\nTuning Message-Driven Beans\n\nThis section provides some tips to improve performance when using JMS with message-driven beans (MDBs).\n\nUse `getConnection()`\n\nJMS connections are served from a connection pool. This means that calling `getConnection()` on a Queue connection factory is fast.\n\nTune the Message-Driven Bean’s Pool Size\n\nThe container for message-driven beans (MDB) is different than the containers for entity and session beans. In the MDB container, sessions and threads are attached to the beans in the MDB pool. This design makes it possible to pool the threads for executing message-driven requests in the container.\n\nTune the Message-Driven bean’s pool size to optimize the concurrent processing of messages. Set the size of the MDB pool to, based on all the parameters of the server (taking other applications into account). For example, a value greater than 500 is generally too large.\n\nTo configure MDB pool settings in the GlassFish Server Administration Console, navigate to the Configurations>configuration-name>EJB Container node and then select the MDB Settings tab. Refer to the Administration Console online help for more information. Alternatively, you can set the MDB pool size by using the following `asadmin set` subcommand:\nCache Bean-Specific Resources\n\nUse the `setMessageDrivenContext()` or `ejbCreate()` method to cache bean specific resources, and release those resources from the `ejbRemove()` method.\n\nLimit Use of JMS Connections\n\nWhen designing an application that uses JMS connections make sure you use a methodology that sparingly uses connections, by either pooling them or using the same connection for multiple sessions.\n\nThe JMS connection uses two threads and the sessions use one thread each. Since these threads are not taken from a pool and the resultant objects aren't pooled, you could run out of memory during periods of heavy usage.\n\nOne workaround is to move `createTopicConnection` into the `init` of the servlet.\n\nMake sure to specifically close the session, or it will stay open, which ties up resources.\n3 Tuning the GlassFish Server\n\nThis chapter describes some ways to tune your GlassFish Server installation for optimum performance.\n\nNote that while this chapter describes numerous interactions with both the GlassFish Server Administration Console and the command-line interface, it is not intended to provide exhaustive descriptions of either. For complete information about using the Administration Console, refer to the Administration Console online help. For complete information about using the GlassFish Server command-line interface, refer to the other titles in the GlassFish Server documentation set at http://docs.oracle.com/docs/cd/E18930_01/index.html.\n\nThe following topics are addressed here:\n\n- Using the GlassFish Server Performance Tuner\n- Deployment Settings\n- Logger Settings\n- Web Container Settings\n- EJB Container Settings\n- Java Message Service Settings\n- Transaction Service Settings\n- HTTP Service Settings\n- Network Listener Settings\n- Transport Settings\n- Thread Pool Settings\n- ORB Settings\n- Resource Settings\n- Load Balancer Settings\n\nUsing the GlassFish Server Performance Tuner\n\nYou can significantly improve the performance of GlassFish Server and the applications deployed on it by adjusting a few deployment and server configuration settings. These changes can be made manually, as described in this chapter, or by using the built-in Performance Tuner in the GlassFish Server Administration Console.\n\nThe Performance Tuner recommends server settings to suit the needs of your GlassFish Server deployment. It helps you reach an optimal configuration, although finer tuning might be needed in case of specific requirements. You can configure performance tuning for the entire domain, or for\nDeployment Settings\n\nDeployment settings can have significant impact on performance. Follow these guidelines when configuring deployment settings for best performance:\n\n- **Disable Auto-Deployment**\n- **Use Pre-compiled JavaServer Pages**\n- **Disable Dynamic Application Reloading**\n\n**Disable Auto-Deployment**\n\nEnabling auto-deployment will adversely affect deployment, though it is a convenience in a development environment. For a production system, disable auto-deploy to optimize performance. If auto-deployment is enabled, then the Reload Poll Interval setting can have a significant performance impact.\n\nTo enable or disable auto-deployment from the GlassFish Server Administration Console, navigate to the Domain node and then click the Applications Configuration tab. Refer to the Administration Console for further instructions. Alternatively, refer to \"To Deploy an Application or Module Automatically\" in GlassFish Server Open Source Edition Application Deployment Guide for instructions on enabling or disabling auto-deployment.\nUse Pre-compiled JavaServer Pages\n\nCompiling JSP files is resource intensive and time consuming. Pre-compiling JSP files before deploying applications on the server will improve application performance. When you do so, only the resulting servlet class files will be deployed.\n\nYou can specify to precompile JSP files when you deploy an application through the Administration Console or `deploy` subcommand. You can also specify to pre-compile JSP files for a deployed application with the Administration Console. Navigate to the Domain node and then click the Applications Configuration tab. Refer to the Administration Console for further instructions.\n\nDisable Dynamic Application Reloading\n\nIf dynamic reloading is enabled, the server periodically checks for changes in deployed applications and automatically reloads the application with the changes. Dynamic reloading is intended for development environments and is also incompatible with session persistence. To improve performance, disable dynamic class reloading.\n\nYou can use the Administration Console to disable dynamic class reloading for an application that is already deployed. Navigate to the Domain node and then click the Applications Configuration tab. Refer to the Administration Console for further instructions.\n\nLogger Settings\n\nThe GlassFish Server produces writes log messages and exception stack trace output to the log file in the logs directory of the instance, `domain-dir`/logs`. The volume of log activity can impact server performance; particularly in benchmarking situations.\n\nGeneral Settings\n\nIn general, writing to the system log slows down performance slightly; and increased disk access (increasing the log level, decreasing the file rotation limit or time limit) also slows down the application.\n\nAlso, make sure that any custom log handler does not log to a slow device like a network file system since this can adversely affect performance.\nLog Levels\n\nSet the log level for the server and its subsystems in the GlassFish Server Administration Console. Navigate to the Configurations>configuration-name>Logger Settings page, and follow the instructions in the online help. Alternatively, you can configure logging by following the instructions in \"Administering the Logging Service\" in GlassFish Server Open Source Edition Administration Guide.\n\nWeb Container Settings\n\nSet Web container settings in the GlassFish Server Administration Console by navigating to the Configurations>configuration-name>Web Container node. Follow the instructions in the online help for more information. Alternatively, you can configure Web container settings by following the instructions in \"Administering Web Applications\" in GlassFish Server Open Source Edition Administration Guide.\n\n- Session Properties: Session Timeout\n- Manager Properties: Reap Interval\n- Disable Dynamic JSP Reloading\n\nSession Properties: Session Timeout\n\nSession timeout determines how long the server maintains a session if a user does not explicitly invalidate the session. The default value is 30 minutes. Tune this value according to your application requirements. Setting a very large value for session timeout can degrade performance by causing the server to maintain too many sessions in the session store. However, setting a very small value can cause the server to reclaim sessions too soon.\n\nManager Properties: Reap Interval\n\nModifying the reap interval can improve performance, but setting it without considering the nature of your sessions and business logic can cause data inconsistency, especially for time-based persistence-frequency.\n\nFor example, if you set the reap interval to 60 seconds, the value of session data will be recorded every 60 seconds. But if a client accesses a servlet to update a value at 20 second increments, then inconsistencies will result.\n\nFor example, consider the following online auction scenario:\n• Bidding starts at $5, in 60 seconds the value recorded will be $8 (three 20 second intervals).\n• During the next 40 seconds, the client starts incrementing the price. The value the client sees is $10.\n• During the client's 20 second rest, the GlassFish Server stops and starts in 10 seconds. As a result, the latest value recorded at the 60 second interval ($8) is be loaded into the session.\n• The client clicks again expecting to see $11; but instead sees is $9, which is incorrect.\n• So, to avoid data inconsistencies, take into the account the expected behavior of the application when adjusting the reap interval.\n\n**Disable Dynamic JSP Reloading**\n\nOn a production system, improve web container performance by disabling dynamic JSP reloading. To do so, edit the default-web.xml file in the config directory for each instance. Change the servlet definition for a JSP file to look like this:\n\n```xml\n<servlet>\n <servlet-name>jsp</servlet-name>\n <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>\n <init-param>\n <param-name>development</param-name>\n <param-value>false</param-value>\n </init-param>\n <init-param>\n <param-name>xpoweredBy</param-name>\n <param-value>true</param-value>\n </init-param>\n <init-param>\n <param-name>genStrAsCharArray</param-name>\n <param-value>true</param-value>\n </init-param>\n <load-on-startup>3</load-on-startup>\n</servlet>\n```\n\n**EJB Container Settings**\n\nThe EJB Container has many settings that affect performance. As with other areas, use monitor the EJB Container to track its execution and performance.\n\nYou can configure most EJB container settings from the GlassFish Server Administration Console by navigating to the Configurations>configuration-name>EJB Container node and then following the instructions in the online help.\nMonitoring the EJB Container\n\nMonitoring the EJB container is disabled by default. You can enable EJB monitoring through the GlassFish Server Administration Console by navigating to the Configuration->configuration-name->Monitoring node and then following the instructions in the online help. Set the monitoring level to LOW for to monitor all deployed EJB components, EJB pools, and EJB caches. Set the monitoring level to HIGH to also monitor EJB business methods.\n\nTuning the EJB Container\n\nThe EJB container caches and pools EJB components for better performance. Tuning the cache and pool properties can provide significant performance benefits to the EJB container.\n\nThe pool settings are valid for stateless session and entity beans while the cache settings are valid for stateful session and entity beans.\n\nThe following topics are addressed here:\n\n- Overview of EJB Pooling and Caching\n- Tuning the EJB Pool\n- Tuning the EJB Cache\n- Pool and Cache Settings for Individual EJB Components\n- Commit Option\n\nOverview of EJB Pooling and Caching\n\nBoth stateless session beans and entity beans can be pooled to improve server performance. In addition, both stateful session beans and entity beans can be cached to improve performance.\n\nTable 3-1 Bean Type Pooling or Caching\n\n<table>\n<thead>\n<tr>\n<th>Bean Type</th>\n<th>Pooled</th>\n<th>Cached</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Stateless Session</td>\n<td>Yes</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Stateful Session</td>\n<td>No</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>Entity</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n</tbody>\n</table>\n\nThe difference between a pooled bean and a cached bean is that pooled beans are all equivalent and...\nindistinguishable from one another. Cached beans, on the contrary, contain conversational state in the case of stateful session beans, and are associated with a primary key in the case of entity beans. Entity beans are removed from the pool and added to the cache on `ejbActivate()` and removed from the cache and added to the pool on `ejbPassivate(). ejbActivate()` is called by the container when a needed entity bean is not in the cache. `ejbPassivate()` is called by the container when the cache grows beyond its configured limits.\n\nNote:\nIf you develop and deploy your EJB components using Oracle Java Studio, then you need to edit the individual bean descriptor settings for bean pool and bean cache. These settings might not be suitable for production-level deployment.\n\nTuning the EJB Pool\n\nA bean in the pool represents the pooled state in the EJB lifecycle. This means that the bean does not have an identity. The advantage of having beans in the pool is that the time to create a bean can be saved for a request. The container has mechanisms that create pool objects in the background, to save the time of bean creation on the request path.\n\nStateless session beans and entity beans use the EJB pool. Keeping in mind how you use stateless session beans and the amount of traffic your server handles, tune the pool size to prevent excessive creation and deletion of beans.\n\nEJB Pool Settings\n\nAn individual EJB component can specify cache settings that override those of the EJB container in the `<bean-pool>` element of the EJB component's `sun-ejb-jar.xml` deployment descriptor.\n\nThe EJB pool settings are:\n\n- **Initial and Minimum Pool Size:** the initial and minimum number of beans maintained in the pool. Valid values are from 0 to `MAX_INTEGER`, and the default value is 8. The corresponding EJB deployment descriptor attribute is `steady-pool-size`. Set this property to a number greater than zero for a moderately loaded system. Having a value greater than zero ensures that there is always a pooled instance to process an incoming request.\n\n- **Maximum Pool Size:** the maximum number of connections that can be created to satisfy client requests. Valid values are from zero to `MAX_INTEGER`, and the default is 32. A value of zero means that the size of the pool is unbounded. The potential implication is that the JVM heap will be filled with objects in the pool. The corresponding EJB deployment descriptor attribute is `max-pool-size`. Set this property to be representative of the anticipated high load of the system. An very large pool\nwastes memory and can slow down the system. A very small pool is also inefficient due to contention.\n\n- **Pool Resize Quantity**: the number of beans to be created or deleted when the cache is being serviced by the server. Valid values are from zero to \\( \\text{MAX_INTEGER} \\) and default is 16. The corresponding EJB deployment descriptor attribute is `resize-quantity`. Be sure to re-calibrate the pool resize quantity when you change the maximum pool size, to maintain an equilibrium. Generally, a larger maximum pool size should have a larger pool resize quantity.\n\n- **Pool Idle Timeout**: the maximum time that a stateless session bean, entity bean, or message-driven bean is allowed to be idle in the pool. After this time, the bean is destroyed if the bean in case is a stateless session bean or a message driver bean. This is a hint to server. The default value is 600 seconds. The corresponding EJB deployment descriptor attribute is `pool-idle-timeout-in-seconds`. If there are more beans in the pool than the maximum pool size, the pool drains back to initial and minimum pool size, in steps of pool resize quantity at an interval specified by the pool idle timeout. If the resize quantity is too small and the idle timeout large, you will not see the pool draining back to steady size quickly enough.\n\n### Tuning the EJB Cache\n\nA bean in the cache represents the ready state in the EJB lifecycle. This means that the bean has an identity (for example, a primary key or session ID) associated with it.\n\nBeans moving out of the cache have to be passivated or destroyed according to the EJB lifecycle. Once passivated, a bean has to be activated to come back into the cache. Entity beans are generally stored in databases and use some form of query language semantics to load and store data. Session beans have to be serialized when storing them upon passivation onto the disk or a database; and similarly have to be deserialized upon activation.\n\nAny incoming request using these \"ready\" beans from the cache avoids the overhead of creation, setting identity, and potentially activation. So, theoretically, it is good to cache as many beans as possible. However, there are drawbacks to caching:\n\n- Memory consumed by all the beans affects the heap available in the Virtual Machine.\n- Increasing objects and memory taken by cache means longer, and possibly more frequent, garbage collection.\n- The application server might run out of memory unless the heap is carefully tuned for peak loads.\n\nKeeping in mind how your application uses stateful session beans and entity beans, and the amount of traffic your server handles, tune the EJB cache size and timeout settings to minimize the number of activations and passivations.\nEJB Cache Settings\n\nAn individual EJB component can specify cache settings that override those of the EJB container in the `<bean-cache>` element of the EJB component’s `sun-ejb-jar.xml` deployment descriptor.\n\nThe EJB cache settings are:\n\n- **Max Cache Size**: Maximum number of beans in the cache. Make this setting greater than one. The default value is 512. A value of zero indicates the cache is unbounded, which means the size of the cache is governed by Cache Idle Timeout and Cache Resize Quantity. The corresponding EJB deployment descriptor attribute is `max-cache-size`.\n\n- **Cache Resize Quantity**: Number of beans to be created or deleted when the cache is serviced by the server. Valid values are from zero to MAX_INTEGER, and the default is 16. The corresponding EJB deployment descriptor attribute is `resize-quantity`.\n\n- **Removal Timeout**: Amount of time that a stateful session bean remains passivated (idle in the backup store). If a bean was not accessed after this interval of time, then it is removed from the backup store and will not be accessible to the client. The default value is 60 minutes. The corresponding EJB deployment descriptor attribute is `removal-timeout-in-seconds`.\n\n- **Removal Selection Policy**: Algorithm used to remove objects from the cache. The corresponding EJB deployment descriptor attribute is `victim-selection-policy`. Choices are:\n - NRU (not recently used). This is the default, and is actually pseudo-random selection policy.\n - FIFO (first in, first out)\n - LRU (least recently used)\n\n- **Cache Idle Timeout**: Maximum time that a stateful session bean or entity bean is allowed to be idle in the cache. After this time, the bean is passivated to the backup store. The default value is 600 seconds. The corresponding EJB deployment descriptor attribute is `cache-idle-timeout-in-seconds`.\n\n- **Refresh period**: Rate at which a read-only-bean is refreshed from the data source. Zero (0) means that the bean is never refreshed. The default is 600 seconds. The corresponding EJB deployment descriptor attribute is `refresh-period-in-seconds`. Note: this setting does not have a custom field in the Admin Console. To set it, use the Add Property button in the Additional Properties section.\n\n### Pool and Cache Settings for Individual EJB Components\n\nIndividual EJB pool and cache settings in the `sun-ejb-jar.xml` deployment descriptor override those of the EJB container. The following table lists the cache and pool settings for each type of EJB component.\n\n<table>\n<thead>\n<tr>\n<th>Cache or Pool Setting</th>\n<th>Stateful Session Bean</th>\n<th>Stateless Session Bean</th>\n<th>Entity Bean</th>\n<th>Entity Read-Only Bean</th>\n<th>Message Driven Bean</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>cache-resize-quantity</td>\n<td>X</td>\n<td>+</td>\n<td>X</td>\n<td>X</td>\n<td>+</td>\n</tr>\n</tbody>\n</table>\nCommit Option\n\nThe commit option controls the action taken by the EJB container when an EJB component completes a transaction. The commit option has a significant impact on performance.\n\nThe following are the possible values for the commit option:\n\n- **Commit option B**: When a transaction completes, the bean is kept in the cache and retains its identity. The next invocation for the same primary key can use the cached instance. The EJB container will call the bean's `ejbLoad()` method before the method invocation to synchronize with the database.\n\n- **Commit option C**: When a transaction completes, the EJB container calls the bean's `ejbPassivate()` method, the bean is disassociated from its primary key and returned to the free pool. The next invocation for the same primary key will have to get a free bean from the pool, set the `PrimaryKey` on this instance, and then call `ejbActivate()` on the instance. Again, the EJB container will call the bean's `ejbLoad()` before the method invocation to synchronize with the database.\n\nOption B avoids `ejbActivate()` and `ejbPassivate()` calls. So, in most cases it performs better than option C since it avoids some overhead in acquiring and releasing objects back to pool.\n\nHowever, there are some cases where option C can provide better performance. If the beans in the cache are rarely reused and if beans are constantly added to the cache, then it makes no sense to cache beans. With option C is used, the container puts beans back into the pool (instead of caching them) after method invocation or on transaction completion. This option reuses instances better and reduces the number of live objects in the JVM, speeding garbage collection.\nDetermining the Best Commit Option\n\nTo determine whether to use commit option B or commit option C, first take a look at the cache-hits value using the monitoring command for the bean. If the cache hits are much higher than cache misses, then option B is an appropriate choice. You might still have to change the max-cache-size and cache-resize-quantity to get the best result.\n\nIf the cache hits are too low and cache misses are very high, then the application is not reusing the bean instances and hence increasing the cache size (using max-cache-size) will not help (assuming that the access pattern remains the same). In this case you might use commit option C. If there is no great difference between cache-hits and cache-misses then tune max-cache-size, and probably cache-idle-timeout-in-seconds.\n\nJava Message Service Settings\n\nThe Type attribute that determines whether the Java Message Service (JMS) is on local or remote system affects performance. Local JMS performance is better than remote JMS performance. However, a remote cluster can provide failover capabilities and can be administrated together, so there may be other advantages of using remote JMS. For more information on using JMS, see \"Administering the Java Message Service (JMS)\" in GlassFish Server Open Source Edition Administration Guide.\n\nTransaction Service Settings\n\nThe transaction manager makes it possible to commit and roll back distributed transactions.\n\nA distributed transactional system writes transactional activity into transaction logs so that they can be recovered later. But writing transactional logs has some performance penalty.\n\nThe following topics are addressed here:\n\n- Monitoring the Transaction Service\n- Tuning the Transaction Service\n\nMonitoring the Transaction Service\n\nTransaction Manager monitoring is disabled by default. Enable monitoring of the transaction service through the GlassFish Server Administration Console by navigating to the Configurations>configuration-name>Monitoring node. Refer to the Administration Console for complete instructions.\nYou can also enable monitoring with these commands:\n\n```\nset serverInstance.transaction-service.monitoringEnabled=true\nreconfig serverInstance\n```\n\n**Viewing Monitoring Information**\n\nTo view monitoring information for the transaction service in the GlassFish Server Administration Console, navigate to the server (Admin Server) node and then select the Monitor tab.\n\nThe following statistics are gathered on the transaction service:\n\n- `total-tx-completed` Completed transactions.\n- `total-tx-rolled-back` Total rolled back transactions.\n- `total-tx-inflight` Total inflight (active) transactions.\n- `isFrozen` Whether transaction system is frozen (true or false)\n- `inflight-tx` List of inflight (active) transactions.\n\n**Tuning the Transaction Service**\n\nThis property can be used to disable the transaction logging, where the performance is of utmost importance more than the recovery. This property, by default, won't exist in the server configuration.\n\nMost Transaction Service tuning tasks can be performed through the GlassFish Server Administration Console by navigating to the Configurations>configuration-name>Transaction Service node and then following the instructions in the online help. Alternatively, you can follow the instructions in \"Administering Transactions\" in GlassFish Server Open Source Edition Administration Guide.\n\n**Disable Distributed Transaction Logging**\n\nYou can disable transaction logging through the Administration Console or by using the following `asadmin set` subcommand:\n\n```\nasadmin set\nserver1.transaction-service.disable-distributed-transaction-logging=true\n```\n\nDisabling transaction logging can improve performance. Setting it to false (the default), makes the\ntransaction service write transactional activity to transaction logs so that transactions can be recovered. If Recover on Restart is checked, this property is ignored.\n\nSet this property to true only if performance is more important than transaction recovery.\n\n**Recover On Restart (Automatic Recovery)**\n\nYou can set the Recover on Restart attribute through the Administration Console or by entering the following `asadmin set` subcommand:\n\n```\nasadmin set server1.transaction-service.automatic-recovery=false\n```\n\nWhen Recover on Restart is true, the server will always perform transaction logging, regardless of the Disable Distributed Transaction Logging attribute.\n\nIf Recover on Restart is false, then:\n\n- If Disable Distributed Transaction Logging is false (the default), then the server will write transaction logs.\n- If Disable Distributed Transaction Logging is true, then the server will not write transaction logs.\n\nNot writing transaction logs will give approximately twenty percent improvement in performance, but at the cost of not being able to recover from any interrupted transactions. The performance benefit applies to transaction-intensive tests. Gains in real applications may be less.\n\n**Keypoint Interval**\n\nThe keypoint interval determines how often entries for completed transactions are removed from the log file. Keypointing prevents a process log from growing indefinitely.\n\nFrequent keypointing is detrimental to performance. The default value of the Keypoint Interval is 2048, which is sufficient in most cases.\n\n**HTTP Service Settings**\n\nTuning the monitoring and access logging settings for the HTTP server instances that handle client requests are important parts of ensuring peak GlassFish Server performance.\n\nThe following topics are addressed here:\n\n- Monitoring the HTTP Service\nMonitoring the HTTP Service\n\nDisabling the collection of monitoring statistics can increase overall GlassFish Server performance. You can enable or disable monitoring statistics collection for the HTTP service using either the Administration Console or `asadmin` subcommands.\n\nRefer to \"Administering the Monitoring Service\" in GlassFish Server Open Source Edition Administration Guide for complete instructions on configuring the monitoring service using `asadmin` subcommands.\n\nIf using the Administration Console, click the Configurations>configuration-name>Monitoring node for the configuration for which you want to enable or disable monitoring for selected components. Refer to the Administration Console online help for complete instructions.\n\nFor instructions on viewing comprehensive monitoring statistics using `asadmin` subcommands, see \"Viewing Comprehensive Monitoring Data\" in GlassFish Server Open Source Edition Administration Guide. If using the Administration Console, you can view monitoring statistics by navigating to the server (Admin Server) node, and then clicking the Monitor tab. Refer to the online help for configuring different views of the available monitoring statistics.\n\nWhen viewing monitoring statistics, some key performance-related information to review includes the following:\n\n- DNS Cache Information (dns)\n- File Cache Information (file-cache)\n- Keep Alive (keep-alive)\n- Connection Queue\n\nDNS Cache Information (dns)\n\nThe DNS cache caches IP addresses and DNS names. The DNS cache is disabled by default. In the DNS Statistics for Process ID All page under Monitor in the web-based Administration interface the following statistics are displayed:\n\n- Enabled\n- CacheEntries (CurrentCacheEntries / MaxCacheEntries)\n- HitRatio\n- Caching DNS Entries\n- Limit DNS Lookups to Asynchronous\n - Enabled\n- NameLookups\n- AddrLookups\n- LookupsInProgress\n\nEnabled\n\nIf the DNS cache is disabled, the rest of this section is not displayed.\n\nBy default, the DNS cache is off. Enable DNS caching in the Administration Console by clicking the Configurations>configuration-name>Network Config>http-listener-name node. Click the HTTP tab and enable the DNS Lookup option.\n\nCacheEntries (CurrentCacheEntries / MaxCacheEntries)\n\nThe number of current cache entries and the maximum number of cache entries. A single cache entry represents a single IP address or DNS name lookup. Make the cache as large as the maximum number of clients that access your web site concurrently. Note that setting the cache size too high is a waste of memory and degrades performance.\n\nSet the maximum size of the DNS cache by entering or changing the value in the in the Administration Console by clicking the Configurations>configuration-name>Network Config>http-listener-name node. Click the File tab and set the desired options.\n\nHitRatio\n\nThe hit ratio is the number of cache hits divided by the number of cache lookups.\n\nThis setting is not tunable.\n\nNote:\n\nIf you turn off DNS lookups on your server, host name restrictions will not work and IP addresses will appear instead of host names in log files.\n\nCaching DNS Entries\nIt is possible to also specify whether to cache the DNS entries. If you enable the DNS cache, the server can store hostname information after receiving it. If the server needs information about the client in the future, the information is cached and available without further querying. Specify the size of the DNS cache and an expiration time for DNS cache entries. The DNS cache can contain 32 to 32768 entries; the default value is 1024. Values for the time it takes for a cache entry to expire can range from 1 second to 1 year specified in seconds; the default value is 1200 seconds (20 minutes).\n\n**Limit DNS Lookups to Asynchronous**\n\nDo not use DNS lookups in server processes because they are resource-intensive. If you must include DNS lookups, make them asynchronous.\n\n**Enabled**\n\nIf asynchronous DNS is disabled, the rest of this section will not be displayed.\n\n**NameLookups**\n\nThe number of name lookups (DNS name to IP address) that have been done since the server was started. This setting is not tunable.\n\n**AddrLookups**\n\nThe number of address loops (IP address to DNS name) that have been done since the server was started. This setting is not tunable.\n\n**LookupsInProgress**\n\nThe current number of lookups in progress.\n\n**File Cache Information (file-cache)**\n\nThe file cache caches static content so that the server handles requests for static content quickly. The file-cache section provides statistics on how your file cache is being used.\n\nFor information about tuning the file cache, see [File Cache Settings](#).\nThe Monitoring page lists the following file cache statistics:\n\n- Number of Hits on Cached File Content\n- Number of Cache Entries\n- Number of Hits on Cached File Info\n- Heap Space Used for Cache\n- Number of Misses on Cached File Content\n- Cache Lookup Misses\n- Number of Misses on Cached File Content\n- Max Age of a Cache Entry\n- Max Number of Cache Entries\n- Max Number of Open Entries\n- Is File Cached Enabled?\n- Maximum Memory Map to be Used for Cache\n- Memory Map Used for cache\n- Cache Lookup Hits\n- Open Cache Entries: The number of current cache entries and the maximum number of cache entries are both displayed. A single cache entry represents a single URI. This is a tunable setting.\n- Maximum Heap Space to be Used for Cache\n\n**Keep Alive (keep-alive)**\n\nThe following are statistics related to the Keep Alive system. The most important settings you can tune here relate to HTTP Timeout. See Timeout for more information.\n\n- Connections Terminated Due to Client Connection Timed Out\n- Max Connection Allowed in Keep-alive\n- Number of Hits\n- Connections in Keep-alive Mode\n- Connections not Handed to Keep-alive Thread Due to too Many Persistent Connections\n- The Time in Seconds Before Idle Connections are Closed\n- Connections Closed Due to Max Keep-alive Being Exceeded\nConnection Queue\n\n- Total Connections Queued: Total connections queued is the total number of times a connection has been queued. This includes newly accepted connections and connections from the keep-alive system.\n\n- Average Queuing Delay: Average queueing delay is the average amount of time a connection spends in the connection queue. This represents the delay between when a request connection is accepted by the server, and a request processing thread (also known as a session) begins servicing the request.\n\nHTTP Service Access Logging\n\nAccessing Logging can be tuned using several asadmin subcommands. Refer to \"Administering the Monitoring Service\" in GlassFish Server Open Source Edition Administration Guide for information about using these subcommands.\n\nIf using the Administration Console, Access Logging is configured from the Configurations>configuration-name>HTTP Service page. Refer to the Administration Console online help for complete instructions about the options on this page.\n\nTo enable or disable access logging, check or uncheck the Access Logging Enabled checkbox. Access Logging is disabled by default.\n\nWhen performing benchmarking, ensure that Access Logging is disabled. If Access Logging is enabled, it is recommended that you also enable Rotation to ensure that the logs do not run out of disk space.\n\nNetwork Listener Settings\n\nYou can tune Network Listener settings from the command line by using the instructions in \"Administering HTTP Network Listeners\" in GlassFish Server Open Source Edition Administration Guide.\n\nIf using the Administration Console, navigate to the Configurations>configuration-name>Network Config>Network Listeners>listener-name node, and then click the tab for the desired configuration page. Refer to the online help for complete instructions about the options on these tabs.\n\nGlassFish Server Network Listener performance can be enhanced by modifying settings on the following Edit Network Listener tabs in the Administration Console:\n\n- General Settings\n- HTTP Settings\nFile Cache Settings\n\nGeneral Settings\n\nFor machines with only one network interface card (NIC), set the network address to the IP address of the machine (for example, 192.18.80.23 instead of default 0.0.0.0). If you specify an IP address other than 0.0.0.0, the server will make one less system call per connection. Specify an IP address other than 0.0.0.0 for best possible performance. If the server has multiple NIC cards then create multiple listeners for each NIC.\n\nHTTP Settings\n\nThe following settings on the HTTP tab can significantly affect performance:\n\n- Max Connections\n- DNS Lookup Enabled\n- Timeout\n- Header Buffer Length\n\nMax Connections\n\nMax Connections controls the number of requests that a particular client can make over a keep-alive connection. The range is any positive integer, and the default is 256.\n\nAdjust this value based on the number of requests a typical client makes in your application. For best performance specify quite a large number, allowing clients to make many requests.\n\nThe number of connections specified by Max Connections is divided equally among the keep alive threads. If Max Connections is not equally divisible by Thread Count, the server can allow slightly more than Max Connections simultaneous keep alive connections.\n\nDNS Lookup Enabled\n\nThis setting specifies whether the server performs DNS (domain name service) lookups on clients that access the server. When DNS lookup is not enabled, when a client connects, the server knows the client's IP address but not its host name (for example, it knows the client as 198.95.251.30, rather than www.xyz.com). When DNS lookup is enabled, the server will resolve the client’s IP address into a host name for operations like access control, common gateway interface (CGI) programs, error reporting,\nand access logging.\n\nIf the server responds to many requests per day, reduce the load on the DNS or NIS (Network Information System) server by disabling DNS lookup. Enabling DNS lookup will increase the latency and load on the system, so modify this setting with caution.\n\n**Timeout**\n\nTimeout determines the maximum time (in seconds) that the server holds open an HTTP keep alive connection. A client can keep a connection to the server open so that multiple requests to one server can be serviced by a single network connection. Since the number of open connections that the server can handle is limited, a high number of open connections will prevent new clients from connecting.\n\nThe default time out value is 30 seconds. Thus, by default, the server will close the connection if idle for more than 30 seconds. The maximum value for this parameter is 300 seconds (5 minutes).\n\nThe proper value for this parameter depends upon how much time is expected to elapse between requests from a given client. For example, if clients are expected to make requests frequently then, set the parameter to a high value; likewise, if clients are expected to make requests rarely, then set it to a low value.\n\nBoth HTTP 1.0 and HTTP 1.1 support the ability to send multiple requests across a single HTTP session. A server can receive hundreds of new HTTP requests per second. If every request was allowed to keep the connection open indefinitely, the server could become overloaded with connections. On Unix/Linux systems, this could easily lead to a file table overflow.\n\nThe GlassFish Server’s Keep Alive system, which is affected by the Timeout setting, addresses this problem. A waiting keep alive connection has completed processing the previous request, and is waiting for a new request to arrive on the same connection. The server maintains a counter for the maximum number of waiting keep-alive connections. If the server has more than the maximum waiting connections open when a new connection waits for a keep-alive request, the server closes the oldest connection. This algorithm limits the number of open waiting keep-alive connections.\n\nIf your system has extra CPU cycles, incrementally increase the keep alive settings and monitor performance after each increase. When performance saturates (stops improving), then stop increasing the settings.\n\n**Header Buffer Length**\n\nThe size (in bytes) of the buffer used by each of the request processing threads for reading the request data from the client.\n\nAdjust the value based on the actual request size and observe the impact on performance. In most\nThe GlassFish Server uses a file cache to serve static information faster. The file cache contains information about static files such as HTML, CSS, image, or text files. Enabling the HTTP file cache will improve performance of applications that contain static files.\n\nThe following settings on the File Cache tab can significantly affect performance:\n\n- **Max File Count**\n- **Max Age**\n\n### Max File Count\n\nMax File Count determines how many files are in the cache. If the value is too big, the server caches little-needed files, which wastes memory. If the value is too small, the benefit of caching is lost. Try different values of this attribute to find the optimal solution for specific applications; generally, the effects will not be great.\n\n### Max Age\n\nThis parameter controls how long cached information is used after a file has been cached. An entry older than the maximum age is replaced by a new entry for the same file.\n\nIf your Web site's content changes infrequently, increase this value for improved performance. Set the maximum age by entering or changing the value in the Maximum Age field of the File Cache Configuration page in the web-based Admin Console for the HTTP server node and selecting the File Caching Tab.\n\nSet the maximum age based on whether the content is updated (existing files are modified) on a regular schedule or not. For example, if content is updated four times a day at regular intervals, you could set the maximum age to 21600 seconds (6 hours). Otherwise, consider setting the maximum age to the longest time you are willing to serve the previous version of a content file after the file has been modified.\n**Transport Settings**\n\nThe Acceptor Threads property for the Transport service specifies how many threads you want in accept mode on a listen socket at any time. It is a good practice to set this to less than or equal to the number of CPUs in your system.\n\nIn the GlassFish Server, acceptor threads on an HTTP Listener accept connections and put them onto a connection queue. Session threads then pick up connections from the queue and service the requests. The server posts more session threads if required at the end of the request.\n\nSee \"Administering HTTP Network Listeners\" in GlassFish Server Open Source Edition Administration Guide for instructions on modifying the Acceptor Threads property. If using the Administration Console, the Acceptor Threads property is available on the Configurations>configuration-name>Network Config>Transports>tcp page.\n\n**Thread Pool Settings**\n\nYou can tune thread pool settings by following the instructions in \"Administering Thread Pools\" in GlassFish Server Open Source Edition Administration Guide. If using the Administration Console, Thread Pool settings are available on the Configurations>configuration-name>Thread Pools>thread-pool-name page.\n\nThe following thread pool settings can have significant effects on GlassFish Server performance:\n\n- **Max Thread Pool Size**\n- **Min Thread Pool Size**\n\n**Max Thread Pool Size**\n\nThe Max Thread Pool Size parameter specifies the maximum number of simultaneous requests the server can handle. The default value is 5. When the server has reached the limit or request threads, it defers processing new requests until the number of active requests drops below the maximum amount. Increasing this value will reduce HTTP response latency times.\n\nIn practice, clients frequently connect to the server and then do not complete their requests. In these cases, the server waits a length of time specified by the Timeout parameter.\n\nAlso, some sites do heavyweight transactions that take minutes to complete. Both of these factors add to the maximum simultaneous requests that are required. If your site is processing many requests that take many seconds, you might need to increase the number of maximum simultaneous requests.\n\nAdjust the thread count value based on your load and the length of time for an average request. In\ngeneral, increase this number if you have idle CPU time and requests that are pending; decrease it if the CPU becomes overloaded. If you have many HTTP 1.0 clients (or HTTP 1.1 clients that disconnect frequently), adjust the timeout value to reduce the time a connection is kept open.\n\nSuitable Request Max Thread Pool Size values range from 100 to 500, depending on the load. If your system has extra CPU cycles, keep incrementally increasing thread count and monitor performance after each incremental increase. When performance saturates (stops improving), then stop increasing thread count.\n\n**Min Thread Pool Size**\n\nThe Min Thread Pool Size property specifies the minimum number of threads the server initiates upon startup. The default value is 2. Min Thread Pool Size represents a hard limit for the maximum number of active threads that can run simultaneously, which can become a bottleneck for performance.\n\nSpecifying the same value for minimum and maximum threads allows GlassFish Server to use a slightly more optimized thread pool. This configuration should be considered unless the load on the server varies quite significantly.\n\n**ORB Settings**\n\nThe GlassFish Server includes a high performance and scalable CORBA Object Request Broker (ORB). The ORB is the foundation of the EJB Container on the server.\n\nFor complete instructions on configuring ORB settings, refer to \"Administering the Object Request Broker (ORB)\" in GlassFish Server Open Source Edition Administration Guide. Also refer to \"RMI-IIOP Load Balancing and Failover\" in GlassFish Server Open Source Edition High Availability Administration Guide. You can also configure most ORB settings through the GlassFish Server Administration Console by navigating to the Configurations>configuration-name> ORB node and then following the instructions in the Administration Console online help.\n\nThe following topics are addressed here:\n\n- Overview\n- How a Client Connects to the ORB\n- Monitoring the ORB\n- Tuning the ORB\nOverview\n\nThe ORB is primarily used by EJB components via:\n\n- RMI/IIOP path from an application client (or rich client) using the application client container.\n- RMI/IIOP path from another GlassFish Server instance ORB.\n- RMI/IIOP path from another vendor's ORB.\n- In-process path from the Web Container or MDB (message driven beans) container.\n\nWhen a server instance makes a connection to another server instance ORB, the first instance acts as a client ORB. SSL over IIOP uses a fast optimized transport with high-performance native implementations of cryptography algorithms.\n\nIt is important to remember that EJB local interfaces do not use the ORB. Using a local interface passes all arguments by reference and does not require copying any objects.\n\nHow a Client Connects to the ORB\n\nA rich client Java program performs a new `initialContext()` call which creates a client side ORB instance. This in turn creates a socket connection to the GlassFish Server IIOP port. The reader thread is started on the server ORB to service IIOP requests from this client. Using the `initialContext`, the client code does a lookup of an EJB deployed on the server. An IOR which is a remote reference to the deployed EJB on the server is returned to the client. Using this object reference, the client code invokes remote methods on the EJB.\n\n`InitialContext` lookup for the bean and the method invocations translate the marshalling application request data in Java into IIOP message(s) that are sent on the socket connection that was created earlier on to the server ORB. The server then creates a response and sends it back on the same connection. This data in the response is then un-marshalled by the client ORB and given back to the client code for processing. The Client ORB shuts down and closes the connection when the rich client application exits.\n\nMonitoring the ORB\n\nORB statistics are disabled by default. To gather ORB statistics, enable monitoring with the following `asadmin` command:\n\n```xml\nset serverInstance.iioop-service.orb.system.monitoringEnabled=true\nreconfig serverInstance\n```\nIf using the Administration Console, you can enable ORB monitoring on the Configurations>configuration-name>Monitoring page. To view ORB monitoring statistics through the Administration Console, navigate to the server (Admin Server) page and click the Monitor tab. Refer to the Administration Console online help for complete instructions.\n\nThe following statistics are of particular interest when tuning the ORB:\n\n- **Connection Statistics**\n- **Thread Pools**\n\n## Connection Statistics\n\nThe following statistics are gathered on ORB connections:\n\n- **total-inbound-connections**: Total inbound connections to ORB.\n- **total-outbound-connections**: Total outbound connections from ORB.\n\nUse the following command to get ORB connection statistics:\n\n```bash\nasadmin get --monitor\nserverInstance.iiop-service.orb.system.orb-connection.*\n```\n\n## Thread Pools\n\nThe following statistics are gathered on ORB thread pools:\n\n- **thread-pool-size**: Number of threads in ORB thread pool.\n- **waiting-thread-count**: Number of thread pool threads waiting for work to arrive.\n\nUse the following command to display ORB thread pool statistics:\n\n```bash\nasadmin get --monitor\nserverInstance.iiop-service.orb.system.orb-thread-pool.*\n```\n\n## Tuning the ORB\n\nTune ORB performance by setting ORB parameters and ORB thread pool parameters. You can often decrease response time by leveraging load-balancing, multiple shared connections, thread pool and\nmessage fragment size. You can improve scalability by load balancing between multiple ORB servers from the client, and tuning the number of connection between the client and the server.\n\nThe following topics are addressed here:\n\n- Tunable ORB Parameters\n- ORB Thread Pool Parameters\n- Client ORB Properties\n- Thread Pool Sizing\n- Examining IIOP Messages\n\n### Tunable ORB Parameters\n\nYou can tune ORB parameters using the instructions in \"Administering the Object Request Broker (ORB)\" in GlassFish Server Open Source Edition Administration Guide. If using the Administration Console, navigate to the Configurations>configuration-name>ORB node and refer to the online help.\n\nThe following table summarizes the tunable ORB parameters.\n\n<table>\n<thead>\n<tr>\n<th>Path</th>\n<th>ORB Modules</th>\n<th>Server Settings</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>RMI/IIOP from application client to application server</td>\n<td>communication infrastructure, thread pool</td>\n<td>steady-thread-pool-size, max-thread-pool-size, idle-thread-timeout-in-seconds</td>\n</tr>\n<tr>\n<td>RMI/IIOP from ORB to GlassFish Server</td>\n<td>communication infrastructure, thread pool</td>\n<td>steady-thread-pool-size, max-thread-pool-size, idle-thread-timeout-in-seconds</td>\n</tr>\n<tr>\n<td>RMI/IIOP from a vendor ORB</td>\n<td>parts of communication infrastructure, thread pool</td>\n<td>steady-thread-pool-size, max-thread-pool-size, idle-thread-timeout-in-seconds</td>\n</tr>\n<tr>\n<td>In-process</td>\n<td>thread pool</td>\n<td>steady-thread-pool-size, max-thread-pool-size, idle-thread-timeout-in-seconds</td>\n</tr>\n</tbody>\n</table>\n\n### ORB Thread Pool Parameters\n\nThe ORB thread pool contains a task queue and a pool of threads. Tasks or jobs are inserted into the task queue and free threads pick tasks from this queue for execution. Do not set a thread pool size such\nthat the task queue is always empty. It is normal for a large application’s Max Pool Size to be ten times the size of the current task queue.\n\nThe GlassFish Server uses the ORB thread pool to:\n\n- Execute every ORB request\n- Trim EJB pools and caches\n- Execute MDB requests\n\nThus, even when one is not using ORB for remote-calls (via RMI/IIOP), set the size of the threadpool to facilitate cleaning up the EJB pools and caches.\n\nYou can set ORB thread pool attributes using the instructions in \"Administering Thread Pools\" in GlassFish Server Open Source Edition Administration Guide. If using the Administration Console, navigate to Configurations>configuration-name> Thread Pools>thread-pool-name, where thread-pool-name is the thread pool ID selected for the ORB. Thread pools have the following attributes that affect performance.\n\n- Minimum Pool Size: The minimum number of threads in the ORB thread pool. Set to the average number of threads needed at a steady (RMI/IIOP) load.\n- Maximum Pool Size: The maximum number of threads in the ORB thread pool.\n- Idle Timeout: Number of seconds to wait before removing an idle thread from pool. Allows shrinking of the thread pool.\n- Number of Work Queues\n\nIn particular, the maximum pool size is important to performance. For more information, see Thread Pool Sizing.\n\n### Client ORB Properties\n\nSpecify the following properties as command-line arguments when launching the client program. You do this by using the following syntax when starting the Java VM:\n\n```\n-Dproperty=value\n```\n\nThe following topics are addressed here:\n\n- Controlling Connections Between Client and Server ORB\n- Limiting the Maximum Number of Client Connections\n- Load Balancing\nControlling Connections Between Client and Server ORB\n\nWhen using the default JDK ORB on the client, a connection is established from the client ORB to the application server ORB every time an initial context is created. To pool or share these connections when they are opened from the same process by adding to the configuration on the client ORB:\n\n-Djava.naming.factory.initial=com.sun.enterprise.naming.SerialInitContextFactory\n\nLimiting the Maximum Number of Client Connections\n\nYou can specify the total maximum number of client connections on all ORB listener ports (TCP, SSL and SSL with mutual authentication). When open client connections exceed the maximum value you specify, the ORB rejects any new incoming client connections.\n\nSet this value to support the expected number of simultaneous client connections, but not to exceed the VM or system file descriptor limits. If the value is set too high, the ORB will continue accepting new client connections, resulting in a \"too many open files\" error if the VM runs out of file descriptors.\n\nTo specify the maximum number of client connections, set the configs.config.config-name.iiop-service.orb.max-connections attribute to the number that you require:\n\nasadmin> set configs.config.config-name.iiop-service.orb.max-connections=max-connections\n\nconfig-name\nThe name of the configuration in which the IIOP service is defined. For example, server-config is the name for the configuration of the domain administration server (DAS).\n\nmax-connections\nAn integer that specifies the maximum number of client connections.\n\nFor updates to this value to take effect, restart GlassFish Server.\n\nThe following example shows how to set the maximum number of client connections for the ORB in the DAS to 512:\n\nasadmin> set configs.config.server-config.iiop-service.orb.max-connections=512\nconfigs.config.server-config.iiop-service.orb.max-connections=512\nCommand set executed successfully.\nLoad Balancing\n\nFor information on how to configure HTTP load balancing, see \"Configuring HTTP Load Balancing\" in GlassFish Server Open Source Edition High Availability Administration Guide.\n\nFor information on how to configure RMI/IIOP for multiple application server instances in a cluster, \"RMI-IIOP Load Balancing and Failover\" in GlassFish Server Open Source Edition High Availability Administration Guide.\n\nWhen tuning the client ORB for load-balancing and connections, consider the number of connections opened on the server ORB. Start from a low number of connections and then increase it to observe any performance benefits. A connection to the server translates to an ORB thread reading actively from the connection (these threads are not pooled, but exist currently for the lifetime of the connection).\n\nThread Pool Sizing\n\nAfter examining the number of inbound and outbound connections as explained above, tune the size of the thread pool appropriately. This can affect performance and response times significantly.\n\nThe size computation takes into account the number of client requests to be processed concurrently, the resource (number of CPUs and amount of memory) available on the machine and the response times required for processing the client requests.\n\nSetting the size to a very small value can affect the ability of the server to process requests concurrently, thus affecting the response times since requests will sit longer in the task queue. On the other hand, having a large number of worker threads to service requests can also be detrimental because they consume system resources, which increases concurrency. This can mean that threads take longer to acquire shared structures in the EJB container, thus affecting response times.\n\nThe worker thread pool is also used for the EJB container's housekeeping activity such as trimming the pools and caches. This activity needs to be accounted for also when determining the size. Having too many ORB worker threads is detrimental for performance since the server has to maintain all these threads. The idle threads are destroyed after the idle thread timeout period.\n\nExamining IIOP Messages\n\nIt is sometimes useful to examine the IIOP messages passed by the GlassFish Server. To make the server save IIOP messages to the server.log file, set the JVM option -Dcom.sun.CORBA.ORBDebug=giop. Use the same option on the client ORB.\n\nThe following is an example of IIOP messages saved to the server log. Note: in the actual output, each line is preceded by the timestamp, such as [29/Aug/2002:22:41:43] INFO (27179): CORE3282: stdout.\n+++++++\nMessage(Thread[ORB Client-side Reader, conn to 192.18.80.118:1050,5,main]):\ncreateFromStream: type is 4 <\nMessageBase(Thread[ORB Client-side Reader, conn to 192.18.80.118:1050,5,main]):\nMessage GIOP version: 1.2\nMessageBase(Thread[ORB Client-side Reader, conn to 192.18.80.118:1050,5,main]):\nORB Max GIOP Version: 1.2\nMessage(Thread[ORB Client-side Reader, conn to 192.18.80.118:1050,5,main]):\ncreateFromStream: message construction complete.\ncom.sun.corba.ee.internal.iiop.MessageMediator\n(Thread[ORB Client-side Reader, conn to 192.18.80.118:1050,5,main]): Received message:\n---- Input Buffer ----\nCurrent index: 0\nTotal length : 340\n47 49 4f 50 01 02 00 04 0 0 00 01 48 00 00 00 05 GIOP.......H....\n\nNote:\nThe flag -Dcom.sun.CORBA.ORBdebug=giop generates many debug messages in the logs. This is used only when you suspect message fragmentation.\n\nIn this sample output above, the createFromStream type is shown as 4. This implies that the message is a fragment of a bigger message. To avoid fragmented messages, increase the fragment size. Larger fragments mean that messages are sent as one unit and not as fragments, saving the overhead of multiple messages and corresponding processing at the receiving end to piece the messages together.\n\nIf most messages being sent in the application are fragmented, increasing the fragment size is likely to improve efficiency. On the other hand, if only a few messages are fragmented, it might be more efficient to have a lower fragment size that requires smaller buffers for writing messages.\n\n**Resource Settings**\n\nTuning JDBC and connector resources can significantly improve GlassFish Server performance.\n\nThe following topics are addressed here:\n\n- JDBC Connection Pool Settings\n- Connector Connection Pool Settings\nJDBC Connection Pool Settings\n\nFor optimum performance of database-intensive applications, tune the JDBC Connection Pools managed by the GlassFish Server. These connection pools maintain numerous live database connections that can be reused to reduce the overhead of opening and closing database connections. This section describes how to tune JDBC Connection Pools to improve performance.\n\nJ2EE applications use JDBC Resources to obtain connections that are maintained by the JDBC Connection Pool. More than one JDBC Resource is allowed to refer to the same JDBC Connection Pool. In such a case, the physical connection pool is shared by all the resources.\n\nRefer to \"Administering Database Connectivity\" in GlassFish Server Open Source Edition Administration Guide for more information about managing JDBC connection pools.\n\nThe following topics are addressed here:\n\n- Monitoring JDBC Connection Pools\n- Tuning JDBC Connection Pools\n\nMonitoring JDBC Connection Pools\n\nStatistics-gathering is disabled by default for JDBC Connection Pools. Refer to for instructions on enabling JDBC monitoring in \"Administering the Monitoring Service\" in GlassFish Server Open Source Edition Administration Guide. If using the Administration Console, JDBC monitoring can be enabled on the Configurations>configuration-name>Monitoring page.\n\nThe following attributes are monitored:\n\n- \\texttt{numConnFailedValidation (count)} Number of connections that failed validation.\n- \\texttt{numConnUsed (range)} Number of connections that have been used.\n- \\texttt{numConnFree (count)} Number of free connections in the pool.\n- \\texttt{numConnTimedOut (bounded range)} Number of connections in the pool that have timed out.\n\nTo get JDBC monitoring statistics, use the following commands:\n\n\\begin{verbatim}\nasadmin get --monitor=true serverInstance.resources.jdbc-connection-pool.*asadmin get --monitor=true serverInstance.resources.jdbc-connection-pool. poolName.* *\n\\end{verbatim}\n\nTo view JDBC monitoring statistics through the Administration Console, navigate to the server (Admin Server) page and click the Monitor tab. Refer to the Administration Console online help for complete instructions.\nTuning JDBC Connection Pools\n\nRefer to \"Administering Database Connectivity\" in GlassFish Server Open Source Edition Administration Guide for instructions on configuring JDBC connection pools. If using the GlassFish Server Administration Console by navigating to the Resources>JDBC>JDBC Connection Pools>jdbc-pool-name page and then clicking the desired tab.\n\nThe following JDBC properties affect GlassFish Server performance:\n\n- Pool Size Settings\n- Timeout Settings\n- Isolation Level Settings\n- Connection Validation Settings\n\nPool Size Settings\n\nPool Size settings can be configured in the Pool Settings section on the General tab in the Edit JDBC Connection Pool page.\n\nThe following settings control the size of the connection pool:\n\n- Initial and Minimum Pool Size: Size of the pool when created, and its minimum allowable size.\n- Maximum Pool Size: Upper limit of size of the pool.\n- Pool Resize Quantity: Number of connections to be removed when the idle timeout expires. Connections that have idled for longer than the timeout are candidates for removal. When the pool size reaches the initial and minimum pool size, removal of connections stops.\n\nThe following table summarizes advantages and disadvantages to consider when sizing connection pools.\n\nTable 3-3 Connection Pool Sizing\n\n<table>\n<thead>\n<tr>\n<th>Connection Pool</th>\n<th>Advantages</th>\n<th>Disadvantages</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Small Connection pool</td>\n<td>Faster access on the connection table.</td>\n<td>May not have enough connections to satisfy requests.</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Requests may spend more time in the queue.</td>\n</tr>\n</tbody>\n</table>\n### Connection Pool\n\n<table>\n<thead>\n<tr>\n<th>Large Connection pool</th>\n<th><strong>Advantages</strong></th>\n<th><strong>Disadvantages</strong></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>More connections to fulfill requests.</td>\n<td>Slower access on the connection table.</td>\n</tr>\n<tr>\n<td></td>\n<td>Requests will spend less (or no) time in the queue</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n### Timeout Settings\n\nThe following JDBC timeout settings can be configured on the Pool Settings section on the General tab in the Edit JDBC Connection Pool page.\n\n- **Max Wait Time**: Amount of time the caller (the code requesting a connection) will wait before getting a connection timeout. The default is 60 seconds. A value of zero forces the caller to wait indefinitely.\n\n To improve performance set Max Wait Time to zero (0). This essentially blocks the caller thread until a connection becomes available. Also, this allows the server to alleviate the task of tracking the elapsed wait time for each request and increases performance.\n\n- **Idle Timeout**: Maximum time in seconds that a connection can remain idle in the pool. After this time, the pool can close this connection. This property does not control connection timeouts on the database server.\n\n Keep this timeout shorter than the database server timeout (if such timeouts are configured on the database), to prevent accumulation of unusable connection in GlassFish Server.\n\n For best performance, set Idle Timeout to zero (0) seconds, so that idle connections will not be removed. This ensures that there is normally no penalty in creating new connections and disables the idle monitor thread. However, there is a risk that the database server will reset a connection that is unused for too long.\n\n### Isolation Level Settings\n\nThe following JDBC Isolation Level settings can be configured in the Transaction section on the General tab in the Edit JDBC Connection Pool page.\n\n- **Transaction Isolation**: Specifies the transaction isolation level of the pooled database connections. If this parameter is unspecified, the pool uses the default isolation level provided by the JDBC Driver.\n\n- **Isolation Level Guaranteed**: Guarantees that every connection obtained from the pool has the isolation specified for the Transaction Isolation level. Applicable only when the Transaction Isolation level is specified. The default value is Guaranteed.\n\n This setting can have some performance impact on some JDBC drivers. Set to false when certain that the application does not change the isolation level before returning the connection.\n\nAvoid specifying the Transaction Isolation level. If that is not possible, consider disabling the Isolation...\nLevel Guaranteed option and then make sure applications do not programmatically alter the connections; isolation level.\n\nIf you must specify a Transaction Isolation level, specify the best-performing level possible. The isolation levels listed from best performance to worst are:\n\n1. READ_UNCOMMITTED\n2. READ_COMMITTED\n3. REPEATABLE_READ\n4. SERIALIZABLE\n\nChoose the isolation level that provides the best performance, yet still meets the concurrency and consistency needs of the application.\n\nConnection Validation Settings\n\nJDBC Connection Validation settings can be configured in the Connection Validation section on the Advanced tab in the Edit JDBC Connection Pool page.\n\n- Connection Validation Required: If enabled, the pool validates connections (checks to find out if they are usable) before providing them to an application. If possible, keep this option disabled. Requiring connection validation forces the server to apply the validation algorithm every time the pool returns a connection, which adds overhead to the latency of getConnection(). If the database connectivity is reliable, you can omit validation.\n\n- Validation Method: Specifies the type of connection validation to perform. Must be one of the following:\n - auto-commit: Attempt to perform an auto-commit on the connection.\n - metadata: Attempt to get metadata from the connection.\n - table: Performing the query on a specified table. If this option is selected, Table Name must also be set. Choosing this option may be necessary if the JDBC driver caches calls to setAutoCommit() and getMetaData().\n - custom-validation: Define a custom validation method.\n\n- Table Name: Name of the table to query when the Validation Method is set to table.\n\n- Close All Connections On Any Failure: Specify whether all connections in the pool should be closed if a single validation check fails. This option is disabled by default. One attempt will be made to re-establish failed connections.\n**Connector Connection Pool Settings**\n\nFrom a performance standpoint, connector connection pools are similar to JDBC connection pools. Follow all the recommendations in the previous section, Tuning JDBC Connection Pools.\n\n**Transaction Support**\n\nYou may be able to improve performance by overriding the default transaction support specified for each connector connection pool.\n\nFor example, consider a case where an Enterprise Information System (EIS) has a connection factory that supports local transactions with better performance than global transactions. If a resource from this EIS needs to be mixed with a resource coming from another resource manager, the default behavior forces the use of XA transactions, leading to lower performance. However, by changing the EIS's connector connection pool to use LocalTransaction transaction support and leveraging the Last Agent Optimization feature previously described, you could leverage the better-performing EIS LocalTransaction implementation. For more information on LAO, see Configure JDBC Resources as One-Phase Commit Resources.\n\nYou can specify transaction support when you create or edit a connector connection pool.\n\nAlso set transaction support using `asadmin`. For example, the following `asadmin` command could be used to create a connector connection pool `TESTPOOL` with `transaction-support` set to `LOCAL`.\n\n```bash\nasadmin> create-connector-connection-pool --runame jdbcra\n--connectiondefinition javax.sql.DataSource\n-transactionsupport LocalTransaction\nTESTPOOL\n```\n\n**Load Balancer Settings**\n\nGlassFish Server Open Source Edition is compatible with the Apache HTTP server `mod_jk` module for load balancing.\n\nGlassFish Server load balancing configurations can vary widely depending on the needs of your enterprise and are beyond the scope of this Performance Tuning Guide. For complete information about configuring load balancing in GlassFish Server, refer to the following documentation:\n\n- \"Configuring HTTP Load Balancing\" in GlassFish Server Open Source Edition High Availability Administration Guide\n- \"RMI-IIOP Load Balancing and Failover\" in GlassFish Server Open Source Edition High Availability Administration Guide\nAdministration Guide\n4 Tuning the Java Runtime System\n\nThe following topics are addressed here:\n\n- Java Virtual Machine Settings\n- Start Options\n- Tuning High Availability Persistence\n- Managing Memory and Garbage Collection\n- Further Information\n\nJava Virtual Machine Settings\n\nJava SE 7 provides two implementations of the HotSpot Java virtual machine (JVM):\n\n- The client VM is tuned for reducing startup time and memory footprint. Invoke it by using the `-client` JVM command-line option.\n- The server VM is designed for maximum program execution speed. Invoke it by using the `-server` JVM command-line option.\n\nBy default, the GlassFish Server uses the JVM setting appropriate to the purpose:\n\n- Developer Profile, targeted at application developers, uses the `-client` JVM flag to optimize startup performance and conserve memory resources.\n- Enterprise Profile, targeted at production deployments, uses the `-server` JVM flag to maximize program execution speed.\n\nYou can override the default JVM options by following the instructions in \"Administering JVM Options\" in GlassFish Server Open Source Edition Administration Guide. If using the Administration Console, navigate to the Configurations>configuration-name>JVM Settings node, and then click the JVM Options tab. Refer to the online help for complete information about the settings on this page.\n\nFor more information on server-class machine detection in Java SE 7, see Server-Class Machine Detection (http://docs.oracle.com/javase/7/docs/technotes/guides/vm/server-class.html).\n\nFor more information on JVMs, see Java Virtual Machines (http://docs.oracle.com/javase/7/docs/).\n\nStart Options\n\nIn some situations, performance can be improved by using large page sizes. For Ultrasparc CMT\nTuning High Availability Persistence\n\nIf session $s_1$ and $s_2$ need to be replicated to an instance (backup server), the replication module batches the replication messages to be sent to that instance instead of sending separate replication messages. This improves performance. In configurations in which a lot of session replication is performed, you may find better performance by tuning the org.shoal.cache.transmitter.max.batch.size system property. This property determines the number of replication messages that constitute one batch.\n\nThe default value for this property is 20. You can try setting it as high as 90, depending on system loads. Like all system properties, this property is set with the -D flag in your Java arguments.\n\nManaging Memory and Garbage Collection\n\nThe efficiency of any application depends on how well memory and garbage collection are managed. The following sections provide information on optimizing memory and allocation functions:\n\n- Tuning the Garbage Collector\n- Tracing Garbage Collection\n- Other Garbage Collector Settings\n- Tuning the Java Heap\n- Rebasing DLLs on Windows\n\nTuning the Garbage Collector\n\nGarbage collection (GC) reclaimed the heap space previously allocated to objects no longer needed. The process of locating and removing the dead objects can stall any application and consume as much as 25 percent throughput.\n\nAlmost all Java Runtime Environments come with a generational object memory system and sophisticated GC algorithms. A generational memory system divides the heap into a few carefully sized partitions called generations. The efficiency of a generational memory system is based on the observation that most of the objects are short lived. As these objects accumulate, a low memory condition occurs forcing GC to take place.\nThe heap space is divided into the old and the new generation. The new generation includes the new object space (eden), and two survivor spaces. The JVM allocates new objects in the eden space, and moves longer lived objects from the new generation to the old generation.\n\nThe young generation uses a fast copying garbage collector which employs two semi-spaces (survivor spaces) in the eden, copying surviving objects from one survivor space to the second. Objects that survive multiple young space collections are tenured, meaning they are copied to the tenured generation. The tenured generation is larger and fills up less quickly; and each collection takes longer than a young space only collection. Collecting the tenured space is also referred to as doing a full generation collection.\n\nThe frequent young space collections are quick (a few milliseconds), while the full generation collection takes a longer (tens of milliseconds to a few seconds, depending upon the heap size).\n\nOther GC algorithms, such as the Concurrent Mark Sweep (CMS) algorithm, are incremental. They divide the full GC into several incremental pieces. This provides a high probability of small pauses. This process comes with an overhead and is not required for enterprise web applications.\n\nWhen the new generation fills up, it triggers a minor collection in which the surviving objects are moved to the old generation. When the old generation fills up, it triggers a major collection which involves the entire object heap.\n\nBoth HotSpot and Solaris JDK use thread local object allocation pools for lock-free, fast, and scalable object allocation. So, custom object pooling is not often required. Consider pooling only if object construction cost is high and significantly affects execution profiles.\n\n**Choosing the Garbage Collection Algorithm**\n\nThe default collector for Java server class machines will optimize for throughput but be tolerant of somewhat long pause times. If you would prefer to have minimal pause times at the expense of some throughput and increased CPU usage, consider using the CMS collector.\n\nTo use the CMS collector\n\nFollow this procedure.\n\n1. Make sure that the system is not using 100 percent of its CPU.\n2. Configure the CMS collector in the server instance.\n To do this, add the following JVM options:\n - `-XX:+UseConcMarkSweepGC`\n - `-XX:SoftRefLRUPolicyMSPerMB=1`\n**Additional Information**\n\nUse the `jvmstat` utility to monitor HotSpot garbage collection. (See Further Information.)\n\nFor detailed information on tuning the garbage collector, see Java SE 6 HotSpot Virtual Machine Garbage Collection Tuning (http://www.oracle.com/technetwork/java/javase/gc-tuning-6-140523.html).\n\n**Tracing Garbage Collection**\n\nThe two primary measures of garbage collection performance are throughput and pauses. Throughput is the percentage of the total time spent on other activities apart from GC. Pauses are times when an application appears unresponsive due to GC.\n\nTwo other considerations are footprint and promptness. Footprint is the working size of the JVM process, measured in pages and cache lines. Promptness is the time between when an object becomes dead, and when the memory becomes available. This is an important consideration for distributed systems.\n\nA particular generation size makes a trade-off between these four metrics. For example, a large young generation likely maximizes throughput, but at the cost of footprint and promptness. Conversely, using a small young generation and incremental GC will minimize pauses, and thus increase promptness, but decrease throughput.\n\nJVM diagnostic output will display information on pauses due to garbage collection. If you start the server in verbose mode (use the command `asadmin start-domain --verbose domain`), then the command line argument `-verbose:gc` prints information for every collection. Here is an example of output of the information generated with this JVM flag:\n\n```\n[GC 50650K->21808K(76868K), 0.0478645 secs]\n[GC 51197K->22305K(76868K), 0.0478645 secs]\n[GC 52293K->23867K(76868K), 0.0478645 secs]\n[Full GC 52970K->1690K(76868K), 0.54789968 secs]\n```\n\nOn each line, the first number is the combined size of live objects before GC, the second number is the size of live objects after GC, the number in parenthesis is the total available space, which is the total heap minus one of the survivor spaces. The final figure is the amount of time that the GC took. This example shows three minor collections and one major collection. In the first GC, 50650 KB of objects existed before collection and 21808 KB of objects after collection. This means that 28842 KB of objects were dead and collected. The total heap size is 76868 KB. The collection process required 0.0478645 seconds.\n\nOther useful monitoring options include:\n\n- `-XX:+PrintGCDetails` for more detailed logging information\n• `-Xloggc:file` to save the information in a log file\n\n### Other Garbage Collector Settings\n\nTo specify the attributes for the Java virtual machine, use the Administration Console and set the property under config-name > JVM settings (JVM options).\n\n### Setting the Maximum Permanent Generation\n\nFor applications that do not dynamically generate and load classes, the size of the permanent generation does not affect GC performance. For applications that dynamically generate and load classes (for example, JSP applications), the size of the permanent generation does affect GC performance, since filling the permanent generation can trigger a Full GC. Tune the maximum permanent generation with the `-XX:MaxPermSize` option.\n\n### Disabling Explicit Garbage Collection\n\nAlthough applications can explicitly invoke GC with the `System.gc()` method, doing so is a bad idea since this forces major collections, and inhibits scalability on large systems. It is best to disable explicit GC by using the flag `-XX:+DisableExplicitGC`.\n\n**Note:**\n\nOn Windows systems, setting the `-XX:+DisableExplicitGC` option might prevent the renaming or removal of open application files. As a result, deployment, redeployment, or other operations that attempt to rename or delete files might fail.\n\nApplication files can remain open because the files have been used by class loaders to find classes or resources, or have been opened explicitly by GlassFish Server or application code but never explicitly closed. On Windows systems, open files cannot be renamed or deleted. To overcome this limitation, GlassFish Server uses the `System.gc()` method to garbage collect the Java object that corresponds to an open file. When the Java object that corresponds to an open file is garbage collected, the object’s `finalize` method closes the open channel to the file. GlassFish Server can then delete or rename the file.\n\n### Setting the Frequency of Full Garbage Collection\n\nGlassFish Server uses RMI in the Administration module for monitoring. Garbage cannot be collected\nin RMI-based distributed applications without occasional local collections, so RMI forces a periodic full collection. Control the frequency of these collections with the property `-sun.rmi.dgc.client.gcInterval`. For example, `- java -Dsun.rmi.dgc.client.gcInterval=3600000` specifies explicit collection once per hour instead of the default rate of once per minute.\n\n**Tuning the Java Heap**\n\nThis section discusses topics related to tuning the Java Heap for performance.\n\n- Guidelines for Java Heap Sizing\n- Heap Tuning Parameters\n\n**Guidelines for Java Heap Sizing**\n\nMaximum heap size depends on maximum address space per process. The following table shows the maximum per-process address values for various platforms:\n\n<table>\n<thead>\n<tr>\n<th>Operating System</th>\n<th>Maximum Address Space Per Process</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Oracle/Redhat/Ubuntu Linux 32-bit</td>\n<td>4 GB</td>\n</tr>\n<tr>\n<td>Oracle/Redhat/Ubuntu Linux 64-bit</td>\n<td>Terabytes</td>\n</tr>\n<tr>\n<td>Windows XP/2008/7</td>\n<td>2 GB</td>\n</tr>\n<tr>\n<td>Solaris x86 (32-bit)</td>\n<td>4 GB</td>\n</tr>\n<tr>\n<td>Solaris 32-bit</td>\n<td>4 GB</td>\n</tr>\n<tr>\n<td>Solaris 64-bit</td>\n<td>Terabytes</td>\n</tr>\n</tbody>\n</table>\n\nMaximum heap space is always smaller than maximum address space per process, because the process also needs space for stack, libraries, and so on. To determine the maximum heap space that can be allocated, use a profiling tool to examine the way memory is used. Gauge the maximum stack space the process uses and the amount of memory taken up libraries and other memory structures. The difference between the maximum address space and the total of those values is the amount of memory that can be allocated to the heap.\n\nYou can improve performance by increasing your heap size or using a different garbage collector. In general, for long-running server applications, use the Java SE throughput collector on machines with multiple processors (`-XX:+AggressiveHeap`) and as large a heap as you can fit in the free memory of your machine.\nHeap Tuning Parameters\n\nYou can control the heap size with the following JVM parameters:\n\n- `-Xms` value\n- `-Xmx` value\n- `-XX:MinHeapFreeRatio=`minimum\n- `-XX:MaxHeapFreeRatio=`maximum\n- `-XX:NewRatio=`ratio\n- `-XX:NewSize=`size\n- `-XX:MaxNewSize=`size\n- `-XX:+AggressiveHeap`\n\nThe `-Xms` and `-Xmx` parameters define the minimum and maximum heap sizes, respectively. Since GC occurs when the generations fill up, throughput is inversely proportional to the amount of the memory available. By default, the JVM grows or shrinks the heap at each GC to try to keep the proportion of free space to the living objects at each collection within a specific range. This range is set as a percentage by the parameters `-XX:MinHeapFreeRatio=`minimum and `-XX:MaxHeapFreeRatio=`maximum; and the total size bounded by `-Xms` and `-Xmx`.\n\nSet the values of `-Xms` and `-Xmx` equal to each other for a fixed heap size. When the heap grows or shrinks, the JVM must recalculate the old and new generation sizes to maintain a predefined `NewRatio`.\n\nThe `NewSize` and `MaxNewSize` parameters control the new generation’s minimum and maximum size. Regulate the new generation size by setting these parameters equal. The bigger the younger generation, the less often minor collections occur. The size of the young generation relative to the old generation is controlled by `NewRatio`. For example, setting `-XX:NewRatio=3` means that the ratio between the old and young generation is 1:3, the combined size of eden and the survivor spaces will be fourth of the heap.\n\nBy default, the GlassFish Server is invoked with the Java HotSpot Server JVM. The default `NewRatio` for the Server JVM is 2: the old generation occupies 2/3 of the heap while the new generation occupies 1/3. The larger new generation can accommodate many more short-lived objects, decreasing the need for slow major collections. The old generation is still sufficiently large enough to hold many long-lived objects.\n\nTo size the Java heap:\n\n- Decide the total amount of memory you can afford for the JVM. Accordingly, graph your own performance metric against young generation sizes to find the best setting.\n- Make plenty of memory available to the young generation. The default is calculated from `NewRatio` and the `-Xmx` setting.\n• Larger eden or younger generation spaces increase the spacing between full GCs. But young space collections could take a proportionally longer time. In general, keep the eden size between one fourth and one third the maximum heap size. The old generation must be larger than the new generation.\n\nFor up-to-date defaults, see Java HotSpot VM Options (http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html).\n\nExample 4-1 Heap Configuration on Solaris\n\nThis is an example heap configuration used by GlassFish Server on Solaris for large applications:\n\n```bash\n-Xms3584m\n-Xmx3584m\n-verbose:gc\n-Dsun.rmi.dgc.client.gcInterval=3600000\n```\n\nSurvivor Ratio Sizing\n\nThe `SurvivorRatio` parameter controls the size of the two survivor spaces. For example, `-XX:SurvivorRatio=6` sets the ratio between each survivor space and eden to be 1:6, each survivor space will be one eighth of the young generation. The default for Solaris is 32. If survivor spaces are too small, copying collection overflows directly into the old generation. If survivor spaces are too large, they will be empty. At each GC, the JVM determines the number of times an object can be copied before it is tenured, called the tenure threshold. This threshold is chosen to keep the survivor space half full.\n\nUse the option `-XX:+PrintTenuringDistribution` to show the threshold and ages of the objects in the new generation. It is useful for observing the lifetime distribution of an application.\n\nRebasing DLLs on Windows\n\nWhen the JVM initializes, it tries to allocate its heap using the `-Xms` setting. The base addresses of GlassFish Server DLLs can restrict the amount of contiguous address space available, causing JVM initialization to fail. The amount of contiguous address space available for Java memory varies depending on the base addresses assigned to the DLLs. You can increase the amount of contiguous address space available by rebasing the GlassFish Server DLLs.\n\nTo prevent load address collisions, set preferred base addresses with the rebase utility that comes with Visual Studio and the Platform SDK. Use the rebase utility to reassign the base addresses of the GlassFish Server DLLs to prevent relocations at load time and increase the available process memory.\nfor the Java heap.\n\nThere are a few GlassFish Server DLLs that have non-default base addresses that can cause collisions. For example:\n\n- The nspr libraries have a preferred address of 0x30000000.\n- The icu libraries have the address of 0x4A000000.\n\nMove these libraries near the system DLLs (msvcrt.dll is at 0x78000000) to increase the available maximum contiguous address space substantially. Since rebasing can be done on any DLL, rebase to the DLLs after installing the GlassFish Server.\n\nTo rebase the GlassFish Server’s DLLs\n\nBefore You Begin\n\nTo perform rebasing, you need:\n\n- Windows 2000\n- Visual Studio and the Microsoft Framework SDK rebase utility\n\n1. Make as-install\\bin the default directory.\n\n ```\n cd as-install\\bin\n ```\n\n1. Enter this command:\n\n ```\n rebase -b 0x6000000 *.dll\n ```\n\n1. Use the dependencywalker utility to make sure the DLLs were rebased correctly.\n For more information, see the Dependency Walker website (http://www.dependencywalker.com).\n\n2. Increase the size for the Java heap, and set the JVM Option accordingly on the JVM Settings page in the Admin Console.\n\n3. Restart the GlassFish Server.\n\nExample 4-2 Heap Configuration on Windows\n\nThis is an example heap configuration used by Oracle GlassFish Server for heavy server-centric applications, on Windows, as set in the domain.xml file.\nFurther Information\n\nFor more information on tuning the JVM, see:\n\n- **Java HotSpot VM Options** ([http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html](http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html))\n- **Frequently Asked Questions About the Java HotSpot Virtual Machine** ([http://www.oracle.com/technetwork/java/hotspotfaq-138619.html](http://www.oracle.com/technetwork/java/hotspotfaq-138619.html))\n5 Tuning the Operating System and Platform\n\nThis chapter discusses tuning the operating system (OS) for optimum performance. It discusses the following topics:\n\n- Server Scaling\n- Solaris 10 Platform-Specific Tuning Information\n- Tuning for the Solaris OS\n- Tuning for Solaris on x86\n- Tuning for Linux platforms\n- Tuning UltraSPARC CMT-Based Systems\n\nServer Scaling\n\nThis section provides recommendations for optimal performance scaling server for the following server subsystems:\n\n- Processors\n- Memory\n- Disk Space\n- Networking\n- UDP Buffer Sizes\n\nProcessors\n\nThe GlassFish Server automatically takes advantage of multiple CPUs. In general, the effectiveness of multiple CPUs varies with the operating system and the workload, but more processors will generally improve dynamic content performance.\n\nStatic content involves mostly input/output (I/O) rather than CPU activity. If the server is tuned properly, increasing primary memory will increase its content caching and thus increase the relative amount of time it spends in I/O versus CPU activity. Studies have shown that doubling the number of CPUs increases servlet performance by 50 to 80 percent.\n**Memory**\n\nSee the section Hardware and Software Requirements in the GlassFish Server Release Notes for specific memory recommendations for each supported operating system.\n\n**Disk Space**\n\nIt is best to have enough disk space for the OS, document tree, and log files. In most cases 2GB total is sufficient.\n\nPut the OS, swap/paging file, GlassFish Server logs, and document tree each on separate hard drives. This way, if the log files fill up the log drive, the OS does not suffer. Also, it's easy to tell if the OS paging file is causing drive activity, for example.\n\nOS vendors generally provide specific recommendations for how much swap or paging space to allocate. Based on Oracle testing, GlassFish Server performs best with swap space equal to RAM, plus enough to map the document tree.\n\n**Networking**\n\nTo determine the bandwidth the application needs, determine the following values:\n\n- The number of peak concurrent users ($N_{\\text{peak}}$) the server needs to handle.\n- The average request size on your site, $r$. The average request can include multiple documents. When in doubt, use the home page and all its associated files and graphics.\n- Decide how long, $t$, the average user will be willing to wait for a document at peak utilization.\n\nThen, the bandwidth required is:\n\n$$N_{\\text{peak}} r / t$$\n\nFor example, to support a peak of 50 users with an average document size of 24 Kbytes, and transferring each document in an average of 5 seconds, requires 240 Kbytes (1920 Kbit/s). So the site needs two T1 lines (each 1544 Kbit/s). This bandwidth also allows some overhead for growth.\n\nThe server's network interface card must support more than the WAN to which it is connected. For example, if you have up to three T1 lines, you can get by with a 10BaseT interface. Up to a T3 line (45 Mbit/s), you can use 100BaseT. But if you have more than 50 Mbit/s of WAN bandwidth, consider configuring multiple 100BaseT interfaces, or look at Gigabit Ethernet technology.\nUDP Buffer Sizes\n\nGlassFish Server uses User Datagram Protocol (UDP) for the transmission of multicast messages to GlassFish Server instances in a cluster. For peak performance from a GlassFish Server cluster that uses UDP multicast, limit the need to retransmit UDP messages. To limit the need to retransmit UDP messages, set the size of the UDP buffer to avoid excessive UDP datagram loss.\n\nTo Determine an Optimal UDP Buffer Size\n\nThe size of UDP buffer that is required to prevent excessive UDP datagram loss depends on many factors, such as:\n\n- The number of instances in the cluster\n- The number of instances on each host\n- The number of processors\n- The amount of memory\n- The speed of the hard disk for virtual memory\n\nIf only one instance is running on each host in your cluster, the default UDP buffer size should suffice. If several instances are running on each host, determine whether the UDP buffer is large enough by testing for the loss of UDP packets.\n\nNote:\n\nOn Linux systems, the default UDP buffer size might be insufficient even if only one instance is running on each host. In this situation, set the UDP buffer size as explained in To Set the UDP Buffer Size on Linux Systems.\n\n1. Ensure that no GlassFish Server clusters are running.\n If necessary, stop any running clusters as explained in \"To Stop a Cluster\" in GlassFish Server Open Source Edition High Availability Administration Guide.\n\n2. Determine the absolute number of lost UDP packets when no clusters are running.\n How you determine the number of lost packets depends on the operating system. For example:\n - On Linux systems, use the `netstat -su` command and look for the `packet receive errors` count in the `Udp` section.\n - On AIX systems, use the `netstat -s` command and look for the `fragments dropped (dup or out of space)` count in the `ip` section.\n\n3. Start all the clusters that are configured for your installation of GlassFish Server.\n Start each cluster as explained in \"To Start a Cluster\" in GlassFish Server Open Source Edition High Availability Administration Guide.\n4. Determine the absolute number of lost UDP packets after the clusters are started.\n5. If the difference in the number of lost packets is significant, increase the size of the UDP buffer.\n\n**To Set the UDP Buffer Size on Linux Systems**\n\nOn Linux systems, a default UDP buffer size is set for the client, but not for the server. Therefore, on Linux systems, the UDP buffer size might have to be increased. Setting the UDP buffer size involves setting the following kernel parameters:\n\n- `net.core.rmem_max`\n- `net.core.wmem_max`\n- `net.core.rmem_default`\n- `net.core.wmem_default`\n\nSet the kernel parameters in the `/etc/sysctl.conf` file or at runtime.\n\nIf you set the parameters in the `/etc/sysctl.conf` file, the settings are preserved when the system is rebooted. If you set the parameters at runtime, the settings are not preserved when the system is rebooted.\n\n- To set the parameters in the `/etc/sysctl.conf` file, add or edit the following lines in the file:\n\n ```\n net.core.rmem_max=rmem-max\n net.core.wmem_max=wmem-max\n net.core.rmem_default=rmem-default\n net.core.wmem_default=wmem-default\n ```\n\n- To set the parameters at runtime, use the `sysctl` command.\n\n ```\n $ /sbin/sysctl -w net.core.rmem_max=rmem-max\n net.core.wmem_max=wmem-max\n net.core.rmem_default=rmem-default\n net.core.wmem_default=wmem-default\n ```\n\nExample 5-1 Setting the UDP Buffer Size in the `/etc/sysctl.conf` File\n\nThis example shows the lines in the `/etc/sysctl.conf` file for setting the kernel parameters for controlling the UDP buffer size to 524288.\nExample 5-2 Setting the UDP Buffer Size at Runtime\n\nThis example sets the kernel parameters for controlling the UDP buffer size to 524288 at runtime.\n\n```bash\n/sbin/sysctl -w net.core.rmem_max=524288 \\\n net.core.wmem_max=52428 \\\n net.core.rmem_default=52428 \\\n net.core.wmem_default=524288\n```\n\nSolaris 10 Platform-Specific Tuning Information\n\nSolaris Dynamic Tracing (DTrace) is a comprehensive dynamic tracing framework for the Solaris Operating System (OS). You can use the DTrace Toolkit to monitor the system. The DTrace Toolkit is available through the OpenSolaris project from the DTraceToolkit page (\n\nTuning for the Solaris OS\n\n- Tuning Parameters\n- File Descriptor Setting\n\nTuning Parameters\n\nTuning Solaris TCP/IP settings benefits programs that open and close many sockets. Since the GlassFish Server operates with a small fixed set of connections, the performance gain might not be significant.\nThe following table shows Solaris tuning parameters that affect performance and scalability benchmarking. These values are examples of how to tune your system for best performance.\n\nTable 5-1 Tuning Parameters for Solaris\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Scope</th>\n<th>Default</th>\n<th>Tuned Value</th>\n<th>Comments</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>rlim_fd_max</td>\n<td>/etc</td>\n<td>65536</td>\n<td>65536</td>\n<td>Limit of process open file descriptors. Set to account for expected load (for associated sockets, files, and pipes if any).</td>\n</tr>\n<tr>\n<td>rlim_fd_cur</td>\n<td>/etc</td>\n<td>1024</td>\n<td>8192</td>\n<td></td>\n</tr>\n<tr>\n<td>sq_max_size</td>\n<td>/etc</td>\n<td>2</td>\n<td>0</td>\n<td>Controls streams driver queue size; setting to 0 makes it infinite so the performance runs won't be hit by lack of buffer space. Set on clients too. Note that setting sq_max_size to 0 might not be optimal for production systems with high network traffic.</td>\n</tr>\n<tr>\n<td>tcp_close_wait_interval</td>\n<td>ndd/dev/tcp</td>\n<td>240000</td>\n<td>60000</td>\n<td>Set on clients too.</td>\n</tr>\n<tr>\n<td>tcp_time_wait_interval</td>\n<td>ndd/dev/tcp</td>\n<td>240000</td>\n<td>60000</td>\n<td>Set on clients too.</td>\n</tr>\n<tr>\n<td>tcp_conn_req_max_q</td>\n<td>ndd/dev/tcp</td>\n<td>128</td>\n<td>1024</td>\n<td>+</td>\n</tr>\n<tr>\n<td>Parameter</td>\n<td>Scope</td>\n<td>Default</td>\n<td>Tuned Value</td>\n<td>Comments</td>\n</tr>\n<tr>\n<td>----------------------------</td>\n<td>----------------</td>\n<td>----------</td>\n<td>-------------</td>\n<td>-----------------------------------------------</td>\n</tr>\n<tr>\n<td><code>tcp_conn_req_max_q0</code></td>\n<td>ndd / dev/tcp</td>\n<td>1024</td>\n<td>4096</td>\n<td>+</td>\n</tr>\n<tr>\n<td><code>tcp_ip_abort_interval</code></td>\n<td>ndd / dev/tcp</td>\n<td>480000</td>\n<td>60000</td>\n<td>+</td>\n</tr>\n<tr>\n<td><code>tcp_keepalive_interval</code></td>\n<td>ndd / dev/tcp</td>\n<td>720000</td>\n<td>900000</td>\n<td>For high traffic web sites, lower this value.</td>\n</tr>\n<tr>\n<td><code>tcp_rexmit_interval_init</code></td>\n<td>ndd / dev/tcp</td>\n<td>3000</td>\n<td>3000</td>\n<td>If retransmission is greater than 30-40%, you should increase this value.</td>\n</tr>\n<tr>\n<td><code>tcp_rexmit_interval_max</code></td>\n<td>ndd / dev/tcp</td>\n<td>240000</td>\n<td>10000</td>\n<td>+</td>\n</tr>\n<tr>\n<td><code>tcp_rexmit_interval_min</code></td>\n<td>ndd / dev/tcp</td>\n<td>200</td>\n<td>3000</td>\n<td>+</td>\n</tr>\n<tr>\n<td><code>tcp_smallest_anon_port</code></td>\n<td>ndd / dev/tcp</td>\n<td>32768</td>\n<td>1024</td>\n<td>Set on clients too.</td>\n</tr>\n<tr>\n<td><code>tcp_slow_start_initial</code></td>\n<td>ndd / dev/tcp</td>\n<td>1</td>\n<td>2</td>\n<td>Slightly faster transmission of small amounts of data.</td>\n</tr>\n<tr>\n<td><code>tcp_xmit_hiwat</code></td>\n<td>ndd / dev/tcp</td>\n<td>8129</td>\n<td>32768</td>\n<td>Size of transmit buffer.</td>\n</tr>\n<tr>\n<td><code>tcp_recv_hiwat</code></td>\n<td>ndd / dev/tcp</td>\n<td>8129</td>\n<td>32768</td>\n<td>Size of receive buffer.</td>\n</tr>\n<tr>\n<td><code>tcp_conn_hash_size</code></td>\n<td>ndd / dev/tcp</td>\n<td>512</td>\n<td>8192</td>\n<td>Size of connection hash table. See Sizing the Connection Hash Table.</td>\n</tr>\n</tbody>\n</table>\n\n### Sizing the Connection Hash Table\n\nThe connection hash table keeps all the information for active TCP connections. Use the following command to get the size of the connection hash table:\nThis value does not limit the number of connections, but it can cause connection hashing to take longer. The default size is 512.\n\nTo make lookups more efficient, set the value to half of the number of concurrent TCP connections that are expected on the server. You can set this value only in `/etc/system`, and it becomes effective at boot time.\n\nUse the following command to get the current number of TCP connections.\n\n```\nnetstat -nP tcp | wc -l\n```\n\n### File Descriptor Setting\n\nOn the Solaris OS, setting the maximum number of open files property using `ulimit` has the biggest impact on efforts to support the maximum number of RMI/IIOP clients.\n\nTo increase the hard limit, add the following command to `/etc/system` and reboot it once:\n\n```\nset rlim_fd_max = 8192\n```\n\nVerify this hard limit by using the following command:\n\n```\nulimit -a -H\n```\n\nOnce the above hard limit is set, increase the value of this property explicitly (up to this limit) using the following command:\n\n```\nulimit -n 8192\n```\n\nVerify this limit by using the following command:\n\n```\nulimit -a\n```\n\nFor example, with the default `ulimit` of 64, a simple test driver can support only 25 concurrent clients, but with `ulimit` set to 8192, the same test driver can support 120 concurrent clients. The test driver spawned multiple threads, each of which performed a JNDI lookup and repeatedly called the same\nbusiness method with a think (delay) time of 500 ms between business method calls, exchanging data of about 100 KB. These settings apply to RMI/IIOP clients on the Solaris OS.\n\n**Tuning for Solaris on x86**\n\nThe following are some options to consider when tuning Solaris on x86 for GlassFish Server:\n\n- **File Descriptors**\n- **IP Stack Settings**\n\nSome of the values depend on the system resources available. After making any changes to `/etc/system`, reboot the machines.\n\n**File Descriptors**\n\nAdd (or edit) the following lines in the `/etc/system` file:\n\n```plaintext\nset rlim_fd_max=65536\nset rlim_fd_cur=65536\nset sq_max_size=0\nset tcp:tcp_conn_hash_size=8192\nset autoup=60\nset pcisch:pci_stream_buf_enable=0\n```\n\nThese settings affect the file descriptors.\n\n**IP Stack Settings**\n\nAdd (or edit) the following lines in the `/etc/system` file:\n\n```plaintext\nset ip:tcp_squeue_wput=1\nset ip:tcp_squeue_close=1\nset ip:ip_squeue_bind=1\nset ip:ip_squeue_worker_wait=10\nset ip:ip_squeue_profile=0\n```\n\nThese settings tune the IP stack.\nTo preserve the changes to the file between system reboots, place the following changes to the default TCP variables in a startup script that gets executed when the system reboots:\n\n```\nndd -set /dev/tcp tcp_time_wait_interval 60000\nndd -set /dev/tcp tcp_conn_req_max_q 16384\nndd -set /dev/tcp tcp_conn_req_max_q0 16384\nndd -set /dev/tcp tcp_ip_abort_interval 60000\nndd -set /dev/tcp tcp_keepalive_interval 720000\nndd -set /dev/tcp tcp_rexmit_interval_initial 4000\nndd -set /dev/tcp tcp_rexmit_interval_min 3000\nndd -set /dev/tcp tcp_rexmit_interval_max 10000\nndd -set /dev/tcp tcp_smallest_anon_port 32768\nndd -set /dev/tcp tcp_slow_start_initial 2\nndd -set /dev/tcp tcp_xmit_hiwat 32768\nndd -set /dev/tcp tcp_recv_hiwat 32768\n```\n\n**Tuning for Linux platforms**\n\nTo tune for maximum performance on Linux, you need to make adjustments to the following:\n\n- **Startup Files**\n- **File Descriptors**\n- **Virtual Memory**\n- **Network Interface**\n- **Disk I/O Settings**\n- **TCP/IP Settings**\n\n**Startup Files**\n\nThe following parameters must be added to the `/etc/rc.d/rc.local` file that gets executed during system startup.\nAdditionally, create an `/etc/sysctl.conf` file and append it with the following values:\n\n```\n--- begin\n#Disables packet forwarding\nnet.ipv4.ip_forward = 0\n#Enables source route verification\nnet.ipv4.conf.default.rp_filter = 1\n#Disables the magic-sysrq key\nkernel.sysrq = 0\nfs.file-max=65536\nvm.bdflush = 100 1200 128 512 15 5000 500 1884 2\nnet.ipv4.ip_local_port_range = 1024 65000\nnet.core.rmem_max= 262143\nnet.core.rmem_default = 262143\nnet.ipv4.tcp_rmem = 4096 131072 262143\nnet.ipv4.tcp_wmem = 4096 131072 262143\nnet.ipv4.tcp_sack = 0\nnet.ipv4.tcp_timestamps = 0\nkernel.shmmax = 67108864\n--- end --\n```\n**File Descriptors**\n\nYou may need to increase the number of file descriptors from the default. Having a higher number of file descriptors ensures that the server can open sockets under high load and not abort requests coming in from clients.\n\nStart by checking system limits for file descriptors with this command:\n\n```plaintext\ncat /proc/sys/fs/file-max\n8192\n```\n\nThe current limit shown is 8192. To increase it to 65535, use the following command (as root):\n\n```plaintext\necho \"65535\"> /proc/sys/fs/file-max\n```\n\nTo make this value to survive a system reboot, add it to `/etc/sysctl.conf` and specify the maximum number of open files permitted:\n\n```plaintext\nfs.file-max = 65535\n```\n\nNote that the parameter is not `proc.sys.fs.file-max`, as one might expect.\n\nTo list the available parameters that can be modified using `sysctl`:\n\n```plaintext\nsysctl -a\n```\n\nTo load new values from the `sysctl.conf` file:\n\n```plaintext\nsysctl -p /etc/sysctl.conf\n```\n\nTo check and modify limits per shell, use the following command:\n\n```plaintext\nlimit\n```\n\nThe output will look something like this:\nThe openfiles and descriptors show a limit of 1024. To increase the limit to 65535 for all users, edit `/etc/security/limits.conf` as root, and modify or add the nofile setting (number of file) entries:\n\n```\n* soft nofile 65535\n* hard nofile 65535\n```\n\nThe character “*” is a wildcard that identifies all users. You could also specify a user ID instead.\n\nThen edit `/etc/pam.d/login` and add the line:\n\n```\nsession required /lib/security/pam_limits.so\n```\n\nOn Red Hat, you also need to edit `/etc/pam.d/sshd` and add the following line:\n\n```\nsession required /lib/security/pam_limits.so\n```\n\nOn many systems, this procedure will be sufficient. Log in as a regular user and try it before doing the remaining steps. The remaining steps might not be required, depending on how pluggable authentication modules (PAM) and secure shell (SSH) are configured.\n\n### Virtual Memory\n\nTo change virtual memory settings, add the following to `/etc/rc.local`:\n\n```\necho 100 1200 128 512 15 5000 500 1884 2> /proc/sys/vm/bdflush\n```\n\nFor more information, view the man pages for `bdflush`. \nNetwork Interface\n\nTo ensure that the network interface is operating in full duplex mode, add the following entry into `/etc/rc.local`:\n\n```\nmii-tool -F 100baseTx-FD eth0\n```\n\nwhere eth0 is the name of the network interface card (NIC).\n\nDisk I/O Settings\n\nTo tune disk I/O performance for non SCSI disks\n\n1. Test the disk speed.\n Use this command:\n\n ```\n /sbin/hdparm -t /dev/hdX\n ```\n\n1. Enable direct memory access (DMA).\n Use this command:\n\n ```\n /sbin/hdparm -d1 /dev/hdX\n ```\n\n1. Check the speed again using the `hdparm` command.\n Given that DMA is not enabled by default, the transfer rate might have improved considerably. In order to do this at every reboot, add the `/sbin/hdparm -d1 /dev/hdX` line to `/etc/conf.d/local.start`, `/etc/init.d/rc.local`, or whatever the startup script is called.\n For information on SCSI disks, see: System Tuning for Linux Servers ??? SCSI (http://people.redhat.com/alikins/system_tuning.html#scsi).\n\nTCP/IP Settings\n\n??\nTo tune the TCP/IP settings\n\n1. Add the following entry to `/etc/rc.local`\n\n ```\n echo 30 > /proc/sys/net/ipv4/tcp_fin_timeout\n echo 60000 > /proc/sys/net/ipv4/tcp_keepalive_time\n echo 15000 > /proc/sys/net/ipv4/tcp_keepalive_intvl\n echo 0 > /proc/sys/net/ipv4/tcp_window_scaling\n ```\n\n1. Add the following to `/etc/sysctl.conf`\n\n ```\n # Disables packet forwarding\n net.ipv4.ip_forward = 0\n # Enables source route verification\n net.ipv4.conf.default.rp_filter = 1\n # Disables the magic-sysrq key\n kernel.sysrq = 0\n net.ipv4.ip_local_port_range = 1204 65000\n net.core.rmem_max = 262140\n net.core.rmem_default = 262140\n net.ipv4.tcp_rmem = 4096 131072 262140\n net.ipv4.tcp_wmem = 4096 131072 262140\n net.ipv4.tcp_sack = 0\n net.ipv4.tcp_timestamps = 0\n net.ipv4.tcp_window_scaling = 0\n net.ipv4.tcp_keepalive_time = 60000\n net.ipv4.tcp_keepalive_intvl = 15000\n net.ipv4.tcp_fin_timeout = 30\n ```\n\n1. Add the following as the last entry in `/etc/rc.local`\n\n ```\n sysctl -p /etc/sysctl.conf\n ```\n\n1. Reboot the system.\n\n2. Use this command to increase the size of the transmit buffer:\n\n ```\n tcp_recv_hiwat ndd /dev/tcp 8129 32768\n ```\nTuning UltraSPARC CMT-Based Systems\n\nUse a combination of tunable parameters and other parameters to tune UltraSPARC CMT-based systems. These values are an example of how you might tune your system to achieve the desired result.\n\n**Tuning Operating System and TCP Settings**\n\nThe following table shows the operating system tuning for Solaris 10 used when benchmarking for performance and scalability on UltraSPARC CMT-based systems (64-bit systems).\n\nTable 5-2 Tuning 64-bit Systems for Performance Benchmarking\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Scope</th>\n<th>Default Value</th>\n<th>Tuned Value</th>\n<th>Comments</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>rlim_fd_max</td>\n<td>/etc/sysstem</td>\n<td>65536</td>\n<td>260000</td>\n<td>Process open file descriptors limit; should account for the expected load (for the associated sockets, files, pipes if any).</td>\n</tr>\n<tr>\n<td>hires_tick</td>\n<td>/etc/sysstem</td>\n<td>+</td>\n<td>1</td>\n<td>+</td>\n</tr>\n<tr>\n<td>Parameter</td>\n<td>Scope</td>\n<td>Default Value</td>\n<td>Tuned Value</td>\n<td>Comments</td>\n</tr>\n<tr>\n<td>---------------------</td>\n<td>---------------</td>\n<td>---------------</td>\n<td>-------------</td>\n<td>---------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>sq_max_size</td>\n<td>/etc/system</td>\n<td>2</td>\n<td>0</td>\n<td>Controls streams driver queue size; setting to 0 makes it infinite so the performance runs won’t be hit by lack of buffer space. Set on clients too. Note that setting sq_max_size to 0 might not be optimal for production systems with high network traffic.</td>\n</tr>\n<tr>\n<td>ip:ip_squeue_bind</td>\n<td>+</td>\n<td>+</td>\n<td>0</td>\n<td>+</td>\n</tr>\n<tr>\n<td>ip:ip_squeue_fanout</td>\n<td>+</td>\n<td>+</td>\n<td>1</td>\n<td>+</td>\n</tr>\n<tr>\n<td>ipge:ipge_taskq_disable</td>\n<td>/etc/system</td>\n<td>+</td>\n<td>0</td>\n<td>+</td>\n</tr>\n<tr>\n<td>ipge:ipge_tx_ring_size</td>\n<td>/etc/system</td>\n<td>+</td>\n<td>2048</td>\n<td>+</td>\n</tr>\n<tr>\n<td>ipge:ipge_srv_fifo_depth</td>\n<td>/etc/system</td>\n<td>+</td>\n<td>2048</td>\n<td>+</td>\n</tr>\n<tr>\n<td>ipge:ipge_copy_thresh</td>\n<td>/etc/system</td>\n<td>+</td>\n<td>384</td>\n<td>+</td>\n</tr>\n<tr>\n<td>ipge:ipge_dma_thresh</td>\n<td>/etc/system</td>\n<td>+</td>\n<td>384</td>\n<td>+</td>\n</tr>\n<tr>\n<td>ipge:ipge_tx_syncq</td>\n<td>/etc/system</td>\n<td>+</td>\n<td>1</td>\n<td>+</td>\n</tr>\n<tr>\n<td>tcp_conn_req_max_q</td>\n<td>ndd/dev/tcp</td>\n<td>128</td>\n<td>3000</td>\n<td>+</td>\n</tr>\n<tr>\n<td>tcp_conn_req_max_q0</td>\n<td>ndd/dev/tcp</td>\n<td>1024</td>\n<td>3000</td>\n<td>+</td>\n</tr>\n<tr>\n<td>Parameter</td>\n<td>Scope</td>\n<td>Default Value</td>\n<td>Tuned Value</td>\n<td>Comments</td>\n</tr>\n<tr>\n<td>-----------------</td>\n<td>-----------</td>\n<td>-----------------</td>\n<td>-------------</td>\n<td>-------------------------------</td>\n</tr>\n<tr>\n<td>tcp_max_buf</td>\n<td>ndd</td>\n<td>/dev/tcp</td>\n<td>+</td>\n<td>4194304</td>\n</tr>\n<tr>\n<td>tcp_cwnd_max</td>\n<td>ndd/</td>\n<td>dev/tcp</td>\n<td>+</td>\n<td>2097152</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>tcp_xmit_hiwat</td>\n<td>ndd/</td>\n<td>dev/tcp</td>\n<td>8129</td>\n<td>400000</td>\n</tr>\n<tr>\n<td>tcp_recv_hiwat</td>\n<td>ndd/</td>\n<td>dev/tcp</td>\n<td>8129</td>\n<td>400000</td>\n</tr>\n</tbody>\n</table>\n\nNote that the IPGE driver version is 1.25.25.\n\n**Disk Configuration**\n\nIf HTTP access is logged, follow these guidelines for the disk:\n\n- Write access logs on faster disks or attached storage.\n- If running multiple instances, move the logs for each instance onto separate disks as much as possible.\n- Enable the disk read/write cache. Note that if you enable write cache on the disk, some writes might be lost if the disk fails.\n- Consider mounting the disks with the following options, which might yield better disk performance: `nologging, directio, noatime`.\n\n**Network Configuration**\n\nIf more than one network interface card is used, make sure the network interrupts are not all going to the same core. Run the following script to disable interrupts:\n```\nallpsr='/usr/sbin/psrinfo | grep -v off-line | awk '{ print $1 }'\nset $allpsr\nnumpsr=$#\nwhile [ $numpsr -gt 0 ];\n do\n shift\n numpsr=`expr $numpsr - 1`\n tmp=1\n while [ $tmp -ne 4 ];\n do\n /usr/sbin/psradm -i $1\n shift\n numpsr=`expr $numpsr - 1`\n tmp=`expr $tmp + 1`\n done\n done\ndone\n```\n\nPut all network interfaces into a single group. For example:\n\n```\n$ifconfig ipge0 group webserver\n$ifconfig ipge1 group webserver\n```"}}},{"rowIdx":254,"cells":{"id":{"kind":"string","value":"3640bab7cf8301bb4e4d1aaad3e9baa05ebadb72"},"text":{"kind":"string","value":"The sustainable development of a software product depends on a number of groups working together to achieve a common goal. However, each of the groups interacts with the product in different ways, and can have conflicting aims and objectives. For example, developers trying to correct issues in the software architecture, which will impact future releases of the product, can be stopped by a project manager who is charged with delivering a release on time and within budget. While the functional requirements of a software product are usually documented, there are a number of other investments in software development that are not always as explicitly agreed upon but are still essential to a product’s long-term success. The major investment types include software product quality -- a main control variable in software development, and intellectual capital (IC) -- being the key input and tool used in software development.\n\nAs management requires measurement, it is necessary to understand the priorities placed on investment options by the various groups involved in the development of a software product. The objective of this thesis is to develop a method capable of both determining the priorities of different groups for software product quality, and IC. The method elicits the required information from a series of case studies to build up a picture of the priorities placed on major investment options and constraints -- features, quality, IC, time and cost. The results highlight strengths, and areas for improvement -- through the identification of differing priorities and ambiguities in management of different aspects studied.\n\nIn conducting this research, systematic biases in the selection of requirements appear to be occurring, adding an objective to understand how bias impacts decision making in a requirements engineering context.\n\nThis thesis provides a method that determines the priorities on the level of investment on different options in the development of software products. It is concluded that people involved in the development of software need to be aligned on issues of software product quality as these priorities set expectations. The same was not found true for issues of IC, where groups can complete tasks without negatively impacting others, as long as the organisation works effectively as a single entity. On the issue of biases in the prioritisation of these aspects, prospect theory is found to apply to requirements selection in an academic experiment -- suggesting people will prefer functionality over software product quality, and to meet the known requirements of customers over predicting general market requirements.\nPerspectives on Software and their Priorities: Balancing Conflicting Stakeholder Views\n\nSebastian Barney\nPerspectives on Software and their Priorities: Balancing Conflicting Stakeholder Views\n\nSebastian Barney\n\nDepartment of Systems and Software Engineering\nSchool of Engineering\nBlekinge Institute of Technology\nSWEDEN\nNowadays people know the price of everything and the value of nothing.\nOscar Wilde (1854 – 1900)\nAbstract\n\nThe sustainable development of a software product depends on a number of groups working together to achieve a common goal. However, each of the groups interacts with the product in different ways, and can have conflicting aims and objectives. For example, developers trying to correct issues in the software architecture, which will impact future releases of the product, can be stopped by a project manager who is charged with delivering a release on time and within budget. While the functional requirements of a software product are usually documented, there are a number of other investments in software development that are not always as explicitly agreed upon but are still essential to a product’s long-term success. The major investment types include software product quality – a main control variable in software development, and intellectual capital (IC) – being the key input and tool used in software development.\n\nAs management requires measurement, it is necessary understand the priorities placed on investment options by the various groups involved in the development of a software product. The objective of this thesis is to develop a method capable of both determining the priorities of different groups, and the level of alignment between these groups in terms of their priorities.\n\nEvolving the method from a study into the values used to select requirements for a release of software, Ericsson supported the development of a methodology to determine and compare the priorities of different groups for software product quality, and IC. The method elicited the required information from a series of case studies to build up a picture of the priorities placed on major investment options and constraints – features, quality, IC, time and cost. The results highlight strengths, and areas for improvement – through the identification of differing priorities and ambiguities in management of different aspects studied. In conducting this research, systematic biases in the selection of requirements appear to be occurring, adding an objective to understand how bias impacts decision making in a requirements engineering context.\nThis thesis provides a method that determines the priorities on the level of investment on different options in the development of software products. It is concluded that people involved in the development of software need to be aligned on issues of software product quality as these priorities set expectations. The same was not found true for issues of IC, where groups can complete tasks without negatively impacting others, as long as the organisation works effectively as a single entity. On the issue of biases in the prioritisation of these aspects, prospect theory is found to apply to requirements selection in an academic experiment – suggesting people will prefer functionality over software product quality, and to meet the known requirements of customers over predicting general market requirements.\nAcknowledgements\n\nFirst I would like to sincerely thank my supervisor, Prof. Claes Wohlin, for his invaluable feedback, expertise and advice. Despite Claes’ all too busy schedule, he has always made time to ensure I get the support I need.\n\nI would like to extend this gratitude to my co-supervisor, Dr. Aybükê Arnum. Aybükê’s direction and support lead me to my doctoral studies in Sweden, she had continued to support me, and is always there to provide a different perspective on our research activities.\n\nRecognition must also be given to my colleagues in the SERL group for creating a positive, supportive and enjoyable research environment. I would like to extend special thanks to my collaborators – Nina Fogelström, Mahvish Khurum and Dr. Anders Hederstierna, and my co-supervisor, Dr. Mikael Svalnberg.\n\nI am grateful to everyone who has participated in this research – filling in questionnaires, providing feedback and analysis, and putting me in contact with the right people. Special thanks must be extended to Ericsson, and in particular my mentors, for their continued support and direction of my research.\n\nFinally I would like to thank my family for their continued support. Especially to Oziel, for his support, and both putting up both with me and without me.\n\nThis work was partly funded by The Knowledge Foundation in Sweden under a research grant for the project Blekinge Engineering Software Qualities (BESQ).\nOverview of Papers\n\nPapers in this Thesis\n\n\nRelated Papers not in this Thesis\n\n\nContents\n\nAbstract vii\nAcknowledgements ix\nOverview of Papers xi\nPapers in this Thesis xi\nRelated Papers not in this Thesis xii\nContents xiii\n\n1 Introduction 1\n 1.1 Overview .................................. 1\n 1.2 Background ................................ 4\n 1.3 Research Questions ........................ 12\n 1.4 Methodology ................................ 13\n 1.5 Research Setting ........................... 17\n 1.6 Overview of Chapters ........................ 19\n 1.7 Contribution of Thesis ....................... 23\n 1.8 Future Work ............................... 25\n 1.9 Summary ................................... 26\n\n2 Understanding Software Product Requirements Selection 29\n 2.1 Introduction ................................ 30\n 2.2 Background ................................ 31\n 2.3 Methodology ................................ 37\n 2.4 Data Analysis and Results .................... 43\n 2.5 Discussion of Results ........................ 59\n# CONTENTS\n\n2.6 Validity Threats .................................. 64 \n2.7 Conclusions and Future Study .................... 66 \n\n3 Balancing Software Product Qualities ................... 69 \n3.1 Introduction ..................................... 69 \n3.2 Background ......................................... 71 \n3.3 Methodology ......................................... 75 \n3.4 Case Study ........................................... 80 \n3.5 Discussion ........................................... 89 \n3.6 Conclusion .......................................... 91 \n\n4 Balancing Software Product Investment Options .......... 93 \n4.1 Introduction ......................................... 93 \n4.2 Background ........................................... 95 \n4.3 Methodology ......................................... 100 \n4.4 Case Study .......................................... 106 \n4.5 Discussion .......................................... 111 \n4.6 Validity Threats ..................................... 112 \n4.7 Conclusion .......................................... 113 \n\n5 Attitudes to Value and Risk in Requirement Selection .... 115 \n5.1 Introduction ......................................... 116 \n5.2 Background .......................................... 118 \n5.3 Experiment Planning and Operation .................... 123 \n5.4 Results and Analysis ................................ 127 \n5.5 Conclusions and Future Work ......................... 130 \n\nBibliography ............................................ 133 \n\nAppendix ................................................ 145 \nSoftware Product Quality Definitions ....................... 145 \nInvestment Type and Constraint Definitions ................ 147\nChapter 1\n\nIntroduction\n\n1.1 Overview\n\nGetting any product to a consumer today involves many different groups of people. Each of these groups is involved with a product in a different way, and values different things from the same product. Many of these desires on the product solution can work together, but it is possible for that the desires of one group conflict with the desires of another group. However, these conflicts must be resolved. If an organisation is able to successfully exploit the diversity of ideas, strengths and options of the different groups involved in a product’s development can also provide value to potentially all of the groups involved.\n\nTake the simple example of a hospital sheet. Patients and healthcare professionals want the solution primarily to be hygienic – making disposable plastic sheets an obvious solution. But the patient also wants it to be comfortable – disposable silk sheets meet both criteria, and additionally silk is hypoallergenic. But those responsible for paying for healthcare require a more affordable solution than single use silk sheets. Laundering the sheets does help reduce the cost dramatically, but silk is still expensive and will not survive as many wash cycles as many alternatives. Fortunately sheets made from cotton blends are cheaper than silk, last longer, can be cleaned sufficiently and are acceptable to most patients. It is also reasonable to expect that a nurse would like fitted sheets as they are much easier to put on a bed, but with the amount of laundering the elastic would wear out quickly, resulting in an unacceptably short life for each sheet. Similarly colours might also help brighten up a sick patients day,\nbut the amount of washing combined with the sufficient cleaning agents having a bleaching effect means dull off-white sheets would quickly become the norm. Thus hospitals use white cotton blend sheets that are regularly laundered.\n\nAs the example shows, there are many people who have a stake in the provision of a hospital sheet. Each of these groups has different aims and concerns in the provision of the solution, but ultimately these need to be reconciled. The final solution to this problem meets the aims of each group involved, but each group has made some compromise – the patient did not get the most comfortable material, the payer did not get the cheapest solution and the nurse did not get elasticised sheets. However, ultimately the solution was acceptable to all groups involved.\n\nThe development of a software product faces many similar challenges to the example given of the hospital sheet, but the situation is much more complex. There are many groups involved in the development of a software product – for example there are end users, product managers, system architects, project managers, developers, testers and trainers. As each of these groups is involved with a software solution in a different way, they see the product differently have potentially conflicting desires and expectations on the final solutions. But as each group brings with it expertise and experience. If these groups are effectively leveraged a greater product can be achieved for all groups involved.\n\nExploiting the strengths and viewpoints of other people in decision-making to achieve a better outcome has become a natural part of our society. Most people reading this thesis will relate to Figure 1.1, as they will have either helped friends and family purchase a computer, or asked someone to help them. A diverse group of people has a better ability to understand problems and find possible solutions.\n\nUltimately the aim is to deliver the maximum amount of value to the groups that will decide the success or failure of a product. Someone visiting a patient in a hospital in the above example will have some response to the sheets, but ultimately the needs of the patient, healthcare professionals and payer for the medical services will overrule these concerns as success of the solution does not depend on the visitor.\n\nTo complicate the situation, software is not like other products. Both software, and the resources used to create it are intangible. A substantial amount of the cost of the hospital sheet will cover growing, harvesting, weaving, bleaching and distribution of the cotton. Very little cost goes into recovering the cost of designing the final solution. The opposite is true of software, most of the cost\n\n---\n\n1This figure is reprinted with permission from xkcd.com.\n1.1 Overview\n\nFigure 1.1: “Shopping Teams” cartoon from \\textit{xkcd.com} [87]\n\ngo towards the design, as the manufacture and distribution of software is very cheap. However, despite the different nature of software, the successful development of software products requires that different stakeholders requirements are balanced, and an outcome that is acceptable to all of the groups upon who success depends is created.\n\nThis thesis aims to understand the priorities of the groups upon whom the success of a software product depends. There are a number of different sets of issues known to impact the development of software products, which can be explored in terms of the issues raised. Specifically this thesis examines factors influencing the selection and prioritisation of requirements for a release of software, priorities on software product quality, and the balancing of different types\nof investment and constraints software companies face – particularly features, quality, intellectual capital (IC), time and cost.\n\nAdditionally this thesis looks at how these groups are aligned in terms of their priorities, and the relative influence of the different groups. In order to achieve these first two research objectives a method is developed that is able to elicit the required information and process the results in a meaningful way.\n\nFinally, given the complex nature of the decisions in this area, this thesis also explores how bias in decision-making may skew the these priorities. This thesis looks at how prospect theory could impact decision makers selecting requirements for a release of software.\n\nAn introduction to the literature in the areas studied in this thesis are provided in Section 1.2. The research questions addressed in this thesis are presented in Section 1.3. Information about the methodologies used are presented in Section 1.4, with the research setting given in in Section 1.5. An overview of the chapters that make up this thesis is given in Section 1.6, with the major contributions of this thesis presented in Section 1.7. Future work is presented in Section 1.8. Finally a summary of the thesis is made in Section 1.9.\n\n1.2 Background\n\nThis section introduces the key concepts and related work used in this thesis. It covers different types of investments that must be made in software products and defines value for software products. This section then covers techniques to prioritise investments and introduces value-based software engineering (VBSE). It concludes with an introduction to biases when making decisions, with a focus on those that will influence the prioritisation of investments.\n\n1.2.1 Software Product Investments\n\nSoftware is different from most other products. When purchasing software, the consumer normally only receives a box containing a CD and a booklet, which of course does not justify the price. Which raises the question, ‘where does the rest of the money go?’ This situation clearly contrasts from that of a car, which comes with a complex set of assembled parts, many of which have been tailor made to the particular make and model of the car, and even to the consumers individual preferences. While physical components do not make up the whole cost of the car, it does create a different perception for consumers.\n1.2 Background\n\nThe forgotten cost in both cases is for the creation of the product – covering design, testing, certification and in the case of software coding. The main difference is that software results in a physically intangible product, where most others additionally result in a physically tangible one as well.\n\nThe key input and tool used in the development of a software product is IC [95]. For an organisation IC comprises of the knowledge, skills and experiences of employees; the structures and processes within the organisation; and the relationships between the organisation and external parties who have some interest in the organisation.\n\nWithin an organisation, software is most commonly developed in projects. Four control variables have been identified for the management of software development projects – features, quality, time and cost [13]. Of these, features and quality are areas in which investments can be made, while time and cost constrain the possible investment that can be made. Features refer to the functionality the software provides – what it is able to do, while quality describes how well it does these tasks.\n\nThese area of IC, features and quality are described in the following sections.\n\nIntellectual Capital\n\nThe standard model of IC used in research today was developed by Bontis [28]. It divides IC into human capital, structural capital and relationship capital.\n\nHuman capital describes the value brought to an organisation by its employees [28]. It covers employees’ knowledge, experience, skills and abilities. Investments a company can make in human capital include strategic hiring of personnel, training, job rotation and collaboration.\n\nStructural capital is most commonly described as the knowledge the organisation has when everyone goes home [86]. It refers to the structures and processes that allow the organisation to meet market requirements – for example copyright, patents, trademarks and data stored on information systems. Investments in structural capital include organisational restructures and taking a strategic approach to intellectual capital protection.\n\nRelationship capital recognises the value of the knowledge held in the relationships between an organisation and external parties. External parties include customers, suppliers, alliances/partners, community, regulatory and competitors [74]. The knowledge built up in a relationship with an external party is valuable, and that is why an existing customer can be more valuable than a new one.\nAll of these areas require investment. Failure to invest in IC will be detrimental to the long-term financial performance of an organisation.\n\nFeatures\n\nShifting the focus from the organisation to the products it produces, features are the functional requirements that a software product fulfils. For example, Google’s main feature is search functionality.\n\nThe purpose of features in a software product is to create business value [44]. However, developing new features comes at a cost for organisations – requirements for features must be elicited from various sources, analysed to ensure they are consistent and clear, conflicts between requirements must be reconciled, specified, designed, coded and tested [79].\n\nWhen selecting requirements to implement in a release of a software product there are many factors that must be balanced to create software product value [109, 110, 6]. There is no silver bullet to select requirements to maximise the value of a software product. This is because value creation strategies are highly contextual [75] and must be analysed as part of a multidimensional array of variables [91].\n\nSoftware Product Quality\n\nAnother product issue requiring investment is software product quality.\n\nQuality is a complex and multifaceted concept. It can be considered from a number of different perspectives [45], but the most common perspectives to consider in the development of a software product are that of the user and manufacturer [58, 71]. From the users’ perspective quality is defined as fit for purpose, while the manufacturing perspective defines quality as conformance to specification.\n\nOnly considering the user and manufacturing perspectives is dangerous. Value-based software engineering recognises that there are many groups upon whom the success of a software product depends. While these groups will be discussed in more detail later in Section 1.2, it is important that some key groups are represented when deciding on how to invest in software product quality [71].\n\nThere is no single correct answer for the level investment different aspects of software product quality should receive. The issues involved in the quality of a software product will depend on a number of factors that define the context of the product [71]. However, it is important to realise that less than perfect software may in fact be ideal [113], but deciding how much less than than perfect\n1.2 Background\n\nis a business decision – insufficient investment in software product quality means the product will fail to satisfy, while too much investment results in costs that will not pay-off.\n\nConstraints\n\nIt is critical to recognise that all of these investment options are bound by time and cost. No organisation has unlimited resources, making it necessary to balance different investment options against each other. Increasing the investment in one area reduces the possible investment in other areas.\n\n1.2.2 Value\n\nIn order to achieve the correct balance on investment options in the development of a software product it is necessary to understand how value is created. The notion of value is a rich one, with the word being used in many disciplines and having a wide diversity of meanings.\n\nIn economics value is used to describe what a customer is willing to pay for a product – use value, and the market value of a product – exchange value [84]. A consumer’s perceived value of a product is defined as their perceived benefits from using the product divided by the perceived price, which can be compared with alternative product offerings [107].\n\nIf the perceived value is greater than the price the customer will view the purchase as providing value. If the price is greater than the cost then the software company will make profit on sales.\n\nAn organisation’s success does not necessarily correlate with the level of investment in IT [105]. In order to create value, a software company must align the business, product, project and relationship perspectives with the business strategies that drive value [5, 4, 101]. The success of software companies depends on their ability to develop products that meet consumer requirements, while offering value for money [27, 82].\n\n1.2.3 Perspectives in Software Development\n\nAlready there have been a number of references to different groups and perspectives involved in the development of a software product. The need to reconcile these groups has been stated. Relationship Capital, one part of IC, recognises that an organisation works with and is influenced by many parties outside the\norganisation. Definitions of software quality consider the consumers and developers of software, while research into the creation of value recognise the need to align software consumers, software development organisations, software products and projects to develop software products.\n\nEach software development organisation will have its own internal structures, but there are many roles that are undertaken in the development of a software product. These include product managers, project managers, designers, programmers and testers. Each of these stakeholder groups will bring a different perspective and priorities to the software development process [68, 23]. For example, a project manager considers whether they can deliver the required functionality on time and budget, a software company considers its profits, while a user considers whether the product meets their needs.\n\nThe different value propositions by the groups involved in the development of a software product are often not compatible, and therefore must be reconciled [23]. To complicate matters, these groups are often not aware of their own value propositions, or are unable to express them concretely, so a concerted effort is required to elicit the desires of each group [2].\n\nFigure 1.2 shows an example of the possible misalignment between three different perspectives involved in the development of a software product. It is based on the methodology presented in Chapter 4. In this example the product manager has promised new features to customers within a given time period. As the product manager is responsible for ensuring the product is profitable they have further placed a high priority on cost. However, the architects and developers in this example do not have the same interaction with customers, but are aware of a number of internal quality issues affecting the code. While it is possible these issues do not currently affect the product, they can impact on the developers and can impact the product further down the line, and may require training and new skills to address. For these reasons we can see differences in the priorities of the three groups, with a greater focus on features time and cost by the product managers, while the architects and developers want to focus relatively more focus on quality and IC.\n\n1.2.4 Prioritisation Techniques\n\nThere are a number of different techniques that can be used to prioritise different factors in the software development process to elicit the requirements of different people and groups. While academic literature has focused on the analytic hierarchy process (AHP), there are a number of techniques that can be used [17]. This section covers AHP, cumulative voting (CV) and hierarchical\n1.2 Background\n\nFigure 1.2: Misalignment between investment priorities of different perspectives\n\ncumulative voting (AHP).\n\nAnalytic Hierarchy Process\n\nAHP is a systematic decision-making technique that has been designed to solve complex problems with multiple aspects [15]. Users of this method make pairwise comparisons of all items being considered, rating their preference for one item over another on a nine-point scale. The technique recognises that people will not always be consistent in their use of the nine-point scale comparisons, and allows for this while calculating the users’ final preferences. The final preferences are presented on a relative scale.\nAHP was found unsuitable for prioritising large numbers of items due to the number of comparisons that must be made [15]. However, researchers have been able to develop techniques to remove redundant comparisons.\n\n**Cumulative Voting**\n\nCV is a simple and straightforward technique, where people are asked to split a specified number of points across a set of items provided [15]. This method is also known as the $100 method, as people are commonly asked to split $100 across a set of items to show their relative value.\n\nFor example, if someone thinks item $A$ is twice as valuable as item $B$ they may assign these items 20 and 10 points respectively, leaving 70 points to award to the remaining items. If they think item $C$ has no value, they can assign it zero points (or $0$).\n\nLike AHP, CV produces results on a relative scale [15].\n\n**Hierarchical Cumulative Voting**\n\nHCV is an extended version of CV. The CV technique asks participants to identify the relative priority of each item in a single list, while HCV asks people to complete a number of CV exercises and has a method for reconciling these separate lists into a single list showing the relative importance of each item.\n\nAsking people to prioritise a single list of attributes can be troublesome as not all the items may be at the same level of extraction and may be difficult to compare as they are not directly related [11]. However, comparisons of this nature must be made – for example, when managers determine the level of investment in features, software product quality and IC.\n\nIn order to create a HCV exercise an author must first create a list of items for which they want to find the relative priority [16]. These items can then be logically grouped, creating a descriptive heading for each group. Each group then becomes its own CV exercise, with an additional CV exercise being generated from the list of descriptive headings. The relative importance of each item in the original list can then be calculated through multiplication of the items with their descriptive headings.\n\n**1.2.5 Value-Based Software Engineering**\n\nBeing able to elicit the priorities of different groups is a key component of value-based software engineering (VBSE), which has become an area of increas-\n1.2 Background\n\nSoftware has traditionally involved a bespoke development for a single customer, but is increasingly moving towards market driven software product development – where a software product is made for the market-at-large. With bespoke development the customer was responsible for deciding what should go in to the software to create a satisfactory level of value. However, now the software companies need to take on this role as the sheer number of customers does not allow that level of involvement, and different customers will have different needs.\n\nVBSE recognises that in order to maximise the value of a software product offering it is essential to reconcile the needs of different stakeholder groups [4, 109, 110]. Central to VBSE and this aim of reconciling the needs of different groups is Theory-W. Theory-W requires [26]:\n\n1. Success-critical stakeholder groups to be identified – the groups upon whom the success of a product depends. This may change from development context to development context.\n\n2. The requirements of these groups to be elicited.\n\n3. Negotiation between the groups to create a win-win situation – this is a decision that all groups find acceptable. It is possible that it may not be an ideal outcome for each group individually, but it is important to consider these issues collectively.\n\n4. A control process to support success-critical stakeholder win-win realisation and adaption to a changing environment.\n\nThe key advantage of Theory-W is that it explicitly brings all of the parties on whom success lies together to understand each other’s needs, compromise and agree. In order to be successful Theory-W must be managed to ensure the plans are achieved and any deviations from the plans are corrected [26]. Management requires an understanding of why the goals are being pursued, what is the required result, who is responsible for the result, how the result will be achieved and at what cost the result can be achieved. The answer to these questions will be specific to the context in which they are posed.\n\n1.2.6 Decision-Making\n\nIt is important to recognise that people have biases, and these can affect the decisions that they make. When choosing between different investment options\nthere are a number of biases that may influence the decision made. These include [90]:\n\nHyperbolic discounting, which suggests people will have a preference for more immediate payoffs. With the aforementioned investment types this will most probably mean giving preference to features over quality and IC.\n\nProspect theory, which states that the relationship between money and value is not linear – a loss is felt more than an equivalent-sized gain, and doubling the size of a gain does not double the value it brings. This suggests decision makers will be conservative with revenue-generating decisions, and risk-taking with cost-generating decisions.\n\nOmission bias, infers a tendency to judge harmful actions as worse than harmful inaction. As investment in quality and IC have immediate costs, but do not have immediate payoffs, it is likely this bias will lead to an under-investment in these areas.\n\nThe planning fallacy or tendency to underestimate task completion times, could also be impact the situation.\n\n1.3 Research Questions\n\nThe development of software products involves a complex set of competing priorities and interests. Balancing these concerns is a difficult task, but is one that must be undertaken by software development companies. However, to manage this process and facilitate effective change, it is essential to be able to quantify the relative weight placed on different aspects that are managed. Thus the first main research question (MRQ) for this thesis is:\n\nMRQ1: How can the priorities of success-critical stakeholders be determined in the software development process?\n\nAs the development of software products involves many different groups of people working together, it is of interest to see if they are working towards one single goal, or identify if they have competing priorities. Thus the second research question is:\n\nMRQ2: Can the level of agreement between success-critical stakeholder groups be determined in terms of priorities on the software development process?\n1.4 Methodology\n\nFurther, as the decision-making process involved in prioritising different factors in the software development process is a human one, it is potentially subject to human biases. This raises the question:\n\n**MRQ3:** How do biases affect the priorities placed on investment options in the development of software products?\n\nThe answer to these questions will allow researchers and practitioners to identify the priorities of different success-critical stakeholder groups, determine their alignment, and understand the biases that influence the balance as it is practised.\n\nThe chapters in which each MRQ is addressed is presented in Table 1.1.\n\nTable 1.1: Relationship between chapters and main research questions\n\n<table>\n<thead>\n<tr>\n<th>Chapter</th>\n<th>1</th>\n<th>2</th>\n<th>3</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Chapter 2</td>\n<td>×</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Chapter 3</td>\n<td>×</td>\n<td>×</td>\n<td></td>\n</tr>\n<tr>\n<td>Chapter 4</td>\n<td>×</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Chapter 5</td>\n<td></td>\n<td>×</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n1.4 Methodology\n\nIn order to answer the research questions posed in this paper it is essential to have a research methodology. A research methodology provides the link between research questions and the data used to answer them [77]. Thus a methodology must be chosen that will provide the necessary data to answer the stated research questions. This section explores types of methodologies that can be used, with a focus on those that can be used to answer the research questions this thesis seeks to address.\n\nResearch methodology can be categorised in many different ways. Empirical research is one of the main categories in which methodologies can be placed. Empirical research can be described as evidenced based research, where findings are verified through observation and experience, and it is contrasted with studies of pure logic. As the research questions in this thesis have applied and practical objectives, this thesis focuses on empirical research methodologies.\n1.4.1 Approaches to Empirical Research\n\nThere are a number of approaches for conducting empirical research in the software engineering discipline. The most common approaches for gathering data are case studies, surveys and experiments [72]. However, there are also other methods that can be used.\n\n**Case Studies**\n\nA case study is used to investigate phenomena in their native context around the time they occur [97]. While the small sample size makes it difficult to impossible to generalise the results of case study research [73], the approach is useful in exploratory research where little is known about an area. Case studies are conducted within the natural setting [77]. The methods for data collection will vary depending on the needs of the case study, but can be direct (eg. observations and interviews) or indirect (eg. document studies).\n\n**Surveys**\n\nWhere case study research is conducted on a small scale, surveys are used to learn about a large population [77]. Much more data is collected with the aim of producing more generalisable results. As such it should be possible to tabulate or otherwise structure and order the results to describe characteristics of the situation studied. In order to generalise the results of a survey, careful attention must be paid to the selection of participants to reduce the risk of a bias in the results. The results are usually collected in questionnaires and interviews, with statistical methods employed to analyse the results.\n\n**Experiments**\n\nExperiments are situations created by researchers to investigate the relationship between different factors by controlling related variables [77]. This means a situation is repeatedly created with a controlled variance of some aspect or aspects to observe the resultant outcome.\n\n1.4.2 Data Collection\n\nWith all of the approaches above there are multiple methodologies that can be employed to collect data. These methodologies are divided into two broad categories – quantitative and qualitative [77]. These are described in more detail\n1.4 Methodology\n\nin the following sections, with a discussion on choosing which one is the most appropriate for a given study.\n\nQuantitative Research\n\nQuantitative research is generally used to answer questions about the relationships between variables for the purpose of explaining, predicting or controlling the phenomena [77]. Statistical methods are commonly used to establish or confirm hypotheses, and produce generalised findings – which is the greatest power of quantitative research.\n\nQuantitative research is usually carefully structured with consideration for the variables that need to be observed or controlled. Objectives are often written in terms of hypotheses to be tested.\n\nQualitative Research\n\nQualitative research seeks to better understand and explain complex situations [77]. The researcher must enter the research with an open mind, as discoveries along the way can shape the research.\n\nQualitative researchers use observations and inductive reasoning to build theory from the ground up, where quantitative researchers use statistical methods to confirm proposed theories. One reason for this difference is an assumption by qualitative researchers that reality cannot be easily divided up into discrete measurable variables.\n\nDeciding Between Quantitative and Qualitative Research\n\nThe choice between quantitative and qualitative methods is not a choice between right and wrong [77]. Both have their strengths and weaknesses, and each is more suited to certain situations. It is even possible to use both together – with qualitative methods being to understand why a situation is occurring, and quantitative methods to find out if these reasons are common.\n\n1.4.3 Data Sources\n\nIn addition to the categorisations of methodologies detailed above, the research also needs to decide the subjects or context to be studied.\n\nIn 1994 Glass discussed the “software-research crisis,” concluding that the main problem with software research is that most is not relevant to industry [46]. Since then there has been a movement toward more applied research in the\nsoftware development industry, helping to ensure research is valuable to the people who develop software.\n\nHowever, it is not always possible to conduct research in an industrial context. For example, it may not be possible to control the required variables to conduct an experiment due to a business’ need to carry-on working. This means that while some research may be valuable in an industrial context, it is necessary to conduct the research in a laboratory setting.\n\nThe number of systematic reviews of software engineering literature [69] has been growing steadily since 2004 [70].\n\n1.4.4 Categorisation of Chapters in this Thesis\n\nThis thesis employs a mixed research methodology. An overview of the methodologies used in each chapter of this thesis is presented in this section, but further details on the methodologies used can be found in each chapter. The methodologies used are summarised in Table 1.2.\n\n<table>\n<thead>\n<tr>\n<th>Methods</th>\n<th>2</th>\n<th>3</th>\n<th>4</th>\n<th>5</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Quantitative</td>\n<td>×</td>\n<td>×</td>\n<td>×</td>\n<td>×</td>\n</tr>\n<tr>\n<td>Qualitative</td>\n<td>×</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Case study</td>\n<td>×</td>\n<td>×</td>\n<td>×</td>\n<td></td>\n</tr>\n<tr>\n<td>Survey</td>\n<td></td>\n<td>×</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Experiment</td>\n<td></td>\n<td></td>\n<td></td>\n<td>×</td>\n</tr>\n<tr>\n<td>Industry</td>\n<td>×</td>\n<td>×</td>\n<td>×</td>\n<td></td>\n</tr>\n<tr>\n<td>Laboratory</td>\n<td></td>\n<td></td>\n<td></td>\n<td>×</td>\n</tr>\n</tbody>\n</table>\n\nChapter 2 used qualitative methods to discover how companies were managing requirements to create value and quantitative methods to determine what values were being applied to the selection and prioritisation of requirements. A number of case studies are presented in the results, providing a small industrial survey.\n\nIn Chapter 3 a case study was conducted in industry using quantitative methods to determine the priorities placed on different aspects of software product\nquality, and ambiguities in the management of these aspects. Qualitative analysis of the results was conducted in a workshop setting following the analysis of the quantitative data.\n\nChapter 4 presents an industrial case study using quantitative methods to determine the priorities on different investment types and constraints in the software development process. Again a workshop was held to analyse the results, employing qualitative methods.\n\nFinally, Chapter 5 presents an experiment conducted in an academic setting to determine if prospect theory applies to the selection of requirements for a release of software. Quantitative methods were used to collect and analyse the data.\n\n1.5 Research Setting\n\nThis thesis presents a number of empirical studies, set in both academic and industrial contexts. The three primary settings used in the collection of data are presented in the following subsections.\n\n1.5.1 Anonymous Companies\n\nChapter 2 uses data collected from a set of companies. These companies are described here and in the corresponding chapter, but for reasons of confidentiality remain anonymous.\n\nIn total three medium-sized companies are involved in this research:\n\n- The first company is based in Australia and operates primarily in the Australian market. The company provides a number of business services, which includes a number of software products. This company has been developing software for over ten years.\n\n- The second company is based in Australia, but has offices in other countries and sells products globally. It is a young company, founded in 2002, and creates a number of software products aimed at the professional software development and business markets.\n\n- The third company is based in Germany, with sales offices in other countries and sells their products primarily in Europe. It offers a number of software products and software intensive solutions in the telecommunications arena.\nCollecting data from a number of industrial sources provides greater power in the ability to identify and draw more general trends and conclusions. However, this is not true for this research as the set of companies used is not representative of the software development industry at large. Although there are a number of advantages from gathering data from a number of different sources – this provides greater confidence for identifying more general trends, allowing future work to focus on areas of key interest without having to find a large number of companies able and willing to participate in a general study.\n\n1.5.2 Ericsson\n\nEricsson is a world leading company in telecommunication, providing a wide range of products and solutions. Products are developed and sold as generic solutions offered to an open market, although customised versions of the products are also developed.\n\nEricsson is the industrial partner for the research presented in Chapters 3 and 4 and Related Paper 3. Ericsson was active in this continued relationship – shaping the research, providing access to collect data, analysing the results, and instigating change based on the results.\n\nOf Ericsson’s diverse product portfolio, one major software-intensive product has been the subject of the research activities presented in this thesis. It is developed within one part of the organisation, so the results are specific to this part of Ericsson and should not be considered representative of Ericsson more generally. The product is not named for reasons of confidentiality.\n\nThe research partnership with Ericsson provides benefits for both academia and industry – creating a win-win scenario with the success-critical stakeholder groups. Ericsson is able to get an external perspective that is grounded in research to examine areas perceived beneficial to the company; providing the researcher with industry relevant topics, data and results.\n\n1.5.3 Blekinge Institute of Technology\n\nUnfortunately it is not always realistic or feasible to collect data from industry. Reasons of time, cost and risk can make it difficult-to-impossible to carry out some studies in this context. However, this does not mean that these studies do not have academic merit or the potential for industrial application. Experiments in an academic setting can help bridge the gap between ideas and industry being prepared to get involved.\nData was collected from students enrolled in a software metrics course as part of a software engineering programme at Blekinge Institute of Technology for the research presented in Chapter 5. The students involved in the research were considered to be well versed in concepts of market-driven software requirements engineering, with almost 95% completing their masters degrees and 69% having work experience in the software development industry. The students also come from a wide range of countries – Bangladesh, China, Germany, India, Iran, Jordan, Nepal, Nigeria, Pakistan and Sweden – giving the group collectively a wide range of academic, industrial and social experiences.\n\n1.6 Overview of Chapters\n\nThis section provides a brief overview and highlights the major contributions of each chapter in this thesis.\n\n1.6.1 Chapter 2: Understanding Requirements Selection\n\nMuch of the value of a software product is in the requirements it fulfils. Given the need for software companies to maximise the creation of value in their products, the process for selecting requirements for a release of software becomes a crucial one. Decisions ultimately have to balance a number of different perspectives and issues that concern the groups behind each perspective.\n\nThis chapter extends previous research by the author [6], and explores how creation of software product value through requirements selection is understood in an industrial settings. It looks at the process for selecting requirements for a release of software, and how this has evolved over time. It determines the priority placed on the values that shape the requirements selection and prioritisation decisions for a release of software; and uses these results to determine the relative influence of key stakeholder perspectives in this process.\n\nA methodology is used involving interviews and a CV task. The interviews seek to understand requirement selection and prioritisation processes and how they have evolved. CV is used to find the relative priority on a number of values that influence the selection and prioritisation of requirements. Each value is associated with one success-critical stakeholder group, allowing the influence of each group to be determined.\n\nThe results of the collective case study of anonymous companies show that two of the companies followed the same process changes to come to their current requirement management practices, despite coming from different countries and\nindustries. While there were differences in the values that shape the selection and prioritisation of requirements for a release, it appears that these values will change depending on a number of contextual factors – like number of customers and the profitability of a product. Finally the results show that while all success-critical stakeholders are important, their influence is not equal - with the business perspective being the more influential in the prioritisation and selection of requirements for a release than the product and project perspectives.\n\nThe result show that there is no silver bullet in the selection and prioritisation of requirements – it is a difficult task to balance that companies continue to improve in a step-wise process. Additionally, the values used to select requirements for a release vary with context in which a software product exists – for example, a new product that is yet to turn a profit is treated differently to an established profitable product; and the size of the customer base influences requirement selection.\n\nBeyond this chapter, this research has been further extended, with another paper by the authors examining the values influencing the selection and prioritisation of companies operating in China [9]. The results show that Chinese companies with a domestic market, Chinese companies with an international market and Western companies operating in China have similar value systems – but Chinese companies with an international market perceive they have a strength in after-sales support.\n\n1.6.2 Chapter 3: Balancing Software Product Qualities\n\nThe development of software products involves a number of groups working towards a set of common goals. However, as each group is involved with the product in a different way, each will be more aware of certain issues and less aware of other issues. In turn, this impacts how the different groups will prioritise the same set of issues. While features of a software product are usually explicitly stated in a requirement document, software product qualities are often not so clearly stated – leaving the interpretation up to the individuals working on the software product. As software product quality is one of the key areas to control in the development of a software product, it is important to ensure the people working on that product are working towards the same goal.\n\nThe aim of Chapter 3 is to test a methodology proposed by the authors for determining the priorities placed on aspects of software product quality by the success-critical stakeholders and the degree to which these groups are aligned. This methodology additionally proposes a way to identify ambiguities in the responsibility and management of each aspect of software product quality.\nA methodology is proposed using cumulative voting (CV) to determine the relative importance of factors drawn from ISO 9126. The pilot of this method found participants had trouble balancing some aspects, and the methodology was updated to use hierarchical cumulative voting (HCV) – which removes the need for direct comparisons between the areas participants felt unable, but still allows the areas to be brought back together for analysis.\n\nThe proposed methodology is applied to a case study within Ericsson. The methodology was able to elicit the values with respect to software product quality, and shows that the internal success-critical stakeholder groups are well aligned in the priorities placed on software product quality. Additionally the results show that in general qualities perceived as more important have fewer and less serious ambiguities in their responsibility and management, while the less important qualities have more ambiguities.\n\nThese results are encouraging on a number of counts. First, the proposed methodology was able to meet its objectives – identifying the values with respect to software product quality from success-critical stakeholders, determine the level of alignment between logical groupings, and determine ambiguities in management. While the results of Ericsson cannot be assumed to be indicative of the wider software development industry, they too are promising, with the success-critical stakeholder groups agreeing on the priorities of software product quality and ensuring that the most important things are the most effectively managed.\n\nGiven the success of the methodology, a follow-up study was conducted examining the priorities and alignment of success-critical stakeholder groups on aspects of IC [8]. Like Chapter 3, this paper also forms an input to Chapter 4.\n\n1.6.3 Chapter 4: Balancing Software Product Investment Options\n\nDeveloping a software product is more complex than just balancing software product qualities, but experience shows that people have trouble making comparisons between different types of investments. Features and software product quality are two obvious investments, but given IC is both the key input and tool in the development of software it is essential to develop this part of an organisation. Given that all investments are in someway constrained by time and cost, investing in any one area reduces the level of investment in another area – making it critical to get the balance right.\n\nChapter 4 aims to determine the relative importance of a number of key investment types – features, software product quality and IC – in the presence of\ntime and cost constraints. To achieve this goal, this study presents a methodology that aims to collect new data, and bring together the results from both the software product quality study presented in Chapter 3 and a study into IC [8].\n\nHCV is used to bring together the priorities identified from previous studies, and allow them to be compared on one single scale.\n\nThe method is applied to the Ericsson case, and is able to bring together priorities identified in the different sets of data collecting to create a single prioritised list of investment types and constraints.\n\nThis work expands on the HCV method, and demonstrates that it is able to bring the results of separate studies together. This technique, for example, would allow specialists within particular areas to prioritise the factors closest to them, while still being able to create a complete prioritised list. The method supports people in making comparison between the relative importance of areas they would normally have trouble.\n\n1.6.4 Chapter 5: Attitudes to Value and Risk in Requirements Selection\n\nFinding a balance between commercial (customer specific, market pull and external quality requirements) and internal quality requirements is a recognised challenge in market driven software product development (MDSPD). Part of the problem is that any decision can be subject to human biases, and these biases can potentially result in decisions being made that do not lead to the optimal outcome. In order to address this challenge, and ensure that good decisions are made, it is important to understand the preferences and biases influencing decision makers selecting requirements for software releases.\n\nProspect theory has been successfully applied to many disciplines. Applying it to an MDSPD setting suggests decision makers will avoid risk when selecting between commercial requirements, take risk with internal quality requirements, and prefer commercial requirements over internal quality requirements to maximise their perceived value. This paper seeks to investigate this claim.\n\nChapter 5 presents an experiment into prospect theory, investigating whether the biases proposed by prospect theory can be seen operating in MDSP requirements engineering (RE). The methodology copies the original experiments in prospect theory, but places the student subjects in a MDSP RE setting.\n\nThe results indicate risk avoidance when dealing with commercial requirements, while greater risk is taken when dealing with internal quality requirements.\nAs this is the first paper to use prospect theory to explain requirements selection decisions, it presents an opportunity to educate people in the biases they bring to the RE process, and facilitate the creation of strategies for balancing the different requirements types.\n\n1.7 Contribution of Thesis\n\nThe general contribution of this thesis is twofold:\n\n- First is a methodology that is able to determine the value propositions of success-critical stakeholder groups and determine their alignment.\n- Second is an insight into how the bias explained by prospect theory applies to the selection of requirements.\n\nThe methodology was developed to address the MRQ1 and MRQ2 – to determine the priorities of success-critical stakeholders in the software development process, and to determine the level of agreement between success-critical stakeholder groups in terms of priorities on the software development process. It is developed in Chapters 2, 3 and 4, and is successfully used to:\n\n1. Elicit the motives behind the selection and prioritisation of requirements – addressing MRQ1 in Chapter 2.\n2. Elicit the priorities on software product quality and determine the level of alignment between internal success-critical stakeholder groups – addressing MRQ1 and MRQ2 in Chapter 3.\n3. Determine the relative priorities on features, aspects of software product quality, time, cost and aspects of IC – bringing together the results of Chapter 3 – addressing MRQ1 in Chapter 4.\n\nThe method has been shown to be robust – being successfully applied to a number of issues, and used to bring different issues together.\n\nBeing able to determine the relative priorities of different issues is a valuable capacity of the method. The research in Chapter 3 shows that people have trouble comparing issues of features, software product quality and project management – however, these are issues that decision makers must balance on a daily basis. Being able to both determine what is going on, and what people\nperceive should be going on allows a deeper level on introspection and discussions between the success-critical stakeholder groups to achieve a better balance and hence better outcome.\n\nThe methodology can also bring a greater level of insight through the use of issue specific experts. Not all groups have the same knowledge and understanding of all parts of the software development process, making some groups more apt to describe an issue or set of issues. Similarly, it is unlikely any one group has a sufficient level of oversight on the entire software development process to provide the level of detail required on all issues. The methodology presented in Chapter 4 allows different groups to respond to different issues, and is able to bring these issues together at a higher level. This allows experts to describe issues at a high level of detail, but still make comparisons between issues that are not directly impacting the same groups.\n\nThis thesis presents the first industrial application of HCV to the best of the author’s knowledge. While this method has been used in academic settings [16, 18], this thesis shows the method can be used by, makes sense to and can elicit the value propositions of industrial practitioners in describing their work setting.\n\nIn conducting this research a systematic biases in the selection of requirements appears to be occurring, adding an additional objective and research question to this research – MRQ3, to understand how bias impacts decision-making in a requirements engineering context. This question was addressed in Chapter 5, with a study to determine if prospect theory can be used to explain decisions made in the selection and prioritisation of requirements for a release of software.\n\nThe results indicate that prospect theory applies to the selection and prioritisation of requirements for a release of software. This will give decision makers a bias for functional requirements over non-functional requirements. This is because functional requirements are more commonly associated with gains, while non-functional requirements are more commonly associated with costs – at least in the short term.\n\nBetween functional requirements there will be a preference for lower risk, even if this means smaller revenues. Decision makers prefer to be responsible for a smaller and safer revenue stream than a larger and riskier one. Generating some revenue will reflect better on the decision maker, than taking a reasonable risk and getting nothing in return.\n\nThe same is not true when it comes to non-functional requirements. Here decision makers will take high risk options, as this reduces costs in the short term. However, this also increases the likelihood of greater costs in the future.\n1.8 Future Work\n\nThese insights provide a reminder that people responsible for the selection and prioritisation of requirements need to ensure that their decisions are aligned with the company strategy, and will help achieve short, medium and long-term goals and objectives.\n\n1.8 Future Work\n\nFuture work was underway at the time of writing this thesis, but there remain a number of other research activities to be completed.\n\nThis thesis presents the first industrial uses of the hierarchical cumulative voting (HCV) method. This method potentially requires the use of weighing factors in bring together the different CV tasks that make up HCV [16], however, further guidelines are needed to support researchers implementing this method determine what weighting factors should be used. While some guidelines are presented by Berander and Jönsson [16], these authors also admit their guidelines are insufficient.\n\nExpanding upon Chapter 3, a study was underway at the time of writing this thesis to determine the alignment of outsourced solution providers into the mix of success-critical stakeholders already presented. This use of outsourced solution providers has increased dramatically, and this has brought about a change in the work environment. Where a new employee is inducted into a support network of experienced developers, a subcontracted team potentially has no prior experience working on a product. While functional requirements are usually explicitly stated and contracted, this is much harder to do with non-functional aspects, making it even more important to ensure that outsourced solution providers are aligned with a company’s strategy.\n\nIn the studies presented in this thesis, participants were asked both what they thought was happening today and what they thought should be happening today in terms of the priorities placed on software development. While a need for change was identified in each study, the reasons the groups studied have been unable to achieve this changes is unknown. In order to both better understand the current situations faced in the development of software, and help these groups achieve their aims and objectives it is essential to understand the barriers faced in prioritising investments in ways perceive most beneficial.\n\nWhile this thesis presents a method for eliciting priorities, moving forward it is important to ensure that these priorities are aligned with the strategies of both the company and product in question. It is not sufficient just to ensure that the priorities realise the company and product strategies, as it is possible these\ndo not recognise the realities of sustainable software product development. It is also important to ensure that technical issues are appropriately balanced within the company and product strategies. To this end, this method can support the success-critical stakeholders determine what they want, to start a dialogue on why these requirements are needed, and how these factors should be balanced going forward.\n\nReplication of these studies would allow any common problems or patterns in industry to be identified. This would allow researchers to focus on the areas causing the greatest conflict to industry.\n\nOn the topic of biases in the decision-making process future work needs to determine if industrial practitioners behave in the same manner as the students used in the experiment in Chapter 5. Further, as each product is different, determine if there are any other factors that influence the degree to which prospect theory biases the decisions made by software product managers.\n\nWork also needs to be undertaken to determine what other biases affect decision makers in how they select and prioritise requirements for a release of software. While some biases that could impact the prioritisation of requirements are presented in Section 1.2.6, this list is not exhaustive and to the best of the author’s knowledge has not been tested in a software engineering context.\n\nFurther it would be beneficial to understand the degree to which biases influence the prioritisation of requirements, and the situations where this leads to improved or sub-optimal outcomes. This information would allow decision support to reduce the negative effects of bias from decision-making processes.\n\n1.9 Summary\n\nThis section provides an overview of this chapter. It reiterates the main concepts, relates each of the research objectives with the appropriate chapters and summarises the findings.\n\nThe sustainable development of a software product relies on both a number of groups working together, and appropriate level of investments in IC, features and quality. Finding an appropriate balance between the different investment options is a difficult task – each of the groups has a different view of the software, resulting in conflicts as to what is important.\n\nHowever, a balance of investment options must be found, and the groups brought together to work towards a common goal. In order to understand this situation in industry, this thesis aims to find a method capable of eliciting the\npriorities placed on aspects of IC, features and quality by groups critical to the\nsuccess of a software product. Further the method should be able to identify\nthe level of alignment between these groups.\n\nIn Chapter 2 the CV method is used to determine the priorities of success-\ncritical stakeholder with respect to the selection of requirements for a release\nof software. Following the success of CV in Chapter 2, the same methodology\nwas used to elicit priorities on software product quality in Chapter 3 – however,\nthe participants found this method difficult to use, which lead to HCV to be\nemployed successfully. The strength of HCV is then used to prioritise features,\naspects of quality, aspects of IC, time and cost against each other in Chapter 4.\n\nIn conducting the studies associated with Chapters 2, 3 and 4 a possible\nsystematic bias appeared to be occurring in the prioritisation of investment\noptions. This is explored in Chapter 5, with an experiment testing the impact\nof prospect theory on requirements selection.\n\nThe results of Chapters 2, 3 and 4 find HCV to be a powerful method in\neliciting the priorities of different groups on aspects of IC, features and qualities in\nthe development of a software product. Not only can HCV be used to\ndetermine the level of alignment between the different groups, but this method\nallows experts to describe different areas of investment with the possibility to\nconsolidate these responses together and produce a single view.\n\nChapter 5 indicates that prospect theory applies to the selection of require-\nments for a release of software. This means that decision makers will favour\nlower risk investments over ones that have a higher risk and greater reward.\nConversely it means that the decision makers will preference high risk options\nin relation to cost, despite the possibility of incurring high costs later due to\nthese decisions.\n\nThis thesis provides a method capable of determining the priorities on the\nlevel of investment on different options in the development of software products.\nWhile it is concluded that groups should be aligned on issues of quality, it is\nreasonable that the priorities on aspects of IC will change between groups due\nto the groups’ different job functions. Further, it appears decision makers will\nbe naturally biased towards certain decisions that can be defined in terms of\nlosses and gains. Such biases need to be understood to ensure that decision\nmakers can carry out their job in a balanced and unbiased manner.\nChapter 2\n\nUnderstanding Software Product Requirements Selection\n\nAbstract\n\nIt is important for a software company to maximize value creation for a given investment. The purpose of requirements engineering activities is to add business value that is accounted for in terms of return-on-investment of a software product. This chapter provides insight into the release planning processes used in the software industry to create software product value, by presenting three case studies. It examines how IT professionals perceive value creation through requirements engineering and how the release planning process is conducted to create software product value. It also presents to what degree the major stakeholders’ perspectives are represented in the decision making process. Our findings show that the client and market base of the software product represents the most influential group in the decision to implement specific requirements. This is reflected both in terms of deciding the processes followed and the decision-making criteria applied when selecting requirements for the product. Furthermore, the management of software product value is dependant on the context in which the product exists. Factors, such as the maturity of the product, the marketplace in which it exists, and the development tools and methods\navailable, influence the criteria that decide whether a requirement is included in a specific project or release.\n\n2.1 Introduction\n\nIncremental software development is becoming an increasingly commonplace practice among software companies as they have discovered the potential of this approach to reduce the amount of effort and time that needs to be invested in a product development prior to its release [64, 32, 96]. Examples of organizations that have adopted time-to-market as their principal product development criterion include Ericsson, Nokia, General Electric and Hewlett Packard. The ability for software developers to develop a product that meets customer requirements while offering high value to both their own business and to their customers provides increased reassurance of market success, provided that the product is released at the appropriate time and offers a superior level of quality relative to competitors.\n\nGlobal competition forces companies to become more competitive and responsive to consumers and market developments. Moreover, rapidly changing market requirements as well as environmental and governmental regulations have stressed the urgency of dramatic changes in software companies for future economic survival. Thus, creating value for software companies is more important than ever before.\n\nValue is created when a company makes a profit. It is critical for a software company to maximize value creation for a given investment. Hence, it is essential to understand the relationships between the technical decisions and the business strategy that drives the value. Boehm [22] stated software engineering (SE) is largely practiced in a value neutral setting with every requirement, use case, test case, defect and object being considered equally important. Traditionally, there is a separation of concerns — software developers are confined to turning requirements into verified code. Yet Bullock [31] found that eighty percent of business value comes from only twenty percent of software components. Furthermore, there is often a mismatch between the decision criteria used by software developers at the organizational level, and the value creation criteria used by software development organizations [27]. In other words, the alignment of product, project and business decisions is a major problem in the software industry.\n\nThe value-based approach in requirements engineering (RE) promotes the alignment of product, project and business decisions [5, 4], and the involve-\n2.2 Background\n\n2.2.1 The Concept of Value\n\nEconomic theory defines value at an abstract level, in terms of use and exchange value. A use value is what the customer is willing to pay for the product, and an exchange value is the market value of the product [84]. ‘Value-adding’ became very popular in the early 20th century where the focus on product development became the product itself and customer value was seen as being inherent in\nthe product. By the end of the 1980s the product development was focused on the relationships between the customer service and customer needs. Value was created in cooperation with the customer who was seen as an active participant in value creation activities [102, 51].\n\nThe concept of the value-based approach in SE was introduced in late 1990s in the context of decision-making about product lines [43], managing investments in reusable software [44] and software economics [27]. Since then, the value-based approach has attracted both software practitioners and academics leading to the integration of value considerations into existing and emerging SE principles and practices [110].\n\n2.2.2 Defining Value\n\nValue constructions in economic theory are based on customer satisfaction, loyalty and re-purchasing behaviour [51]. By borrowing the economic theory, we address three aspects of value, namely product value, a customer’s perceived value and relationship value. Product value is related to the product price and influenced by the quality attributes of the software product. The value of a product increases in direct proportion to its advantage over competitive products or decreases in proportion to its disadvantage [1]. A customer’s perceived value is the benefit derived from the product and is a measure of how much a customer is willing to pay for it, i.e. \\( \\text{perceived value} = \\frac{\\text{perceived benefits}}{\\text{perceived price}} \\), where \\( \\text{perceived benefits} \\) and \\( \\text{price} \\) are both measured relative to competing products [107]. A customer’s perceived value is influenced by his/her needs, expectations, past experiences, and culture. Relationship value is created through the social relationships between the software company and the customer. It exists through the product and customer’s perceived value [52].\n\nA customer views a purchase as a bargain, if perceived value > price. If \\( \\text{price} > \\text{cost} \\) then the software company will make profit for their sale. The critical success factor for software companies is their ability to develop a product that meets customer requirements while offering high value that provides a certain guarantee of market success [27, 82]. Since the ultimate aim for a software company is to maximize value creation for a given investment, it is essential to understand the relationships between product, project and business level decisions and the business strategy that drives the value [5, 4, 101].\n2.2 Background\n\n2.2.3 Value Based Approach in Requirements Process\n\nToday software has a major effect on the cost, value and schedule of projects [22]. However, an organization’s success in terms of profitability or market capitalisation does not necessarily correlate with their level of investment in IT [105]. That is because money spent does not always translate into the realisation of benefits. Most studies into the critical success factors, in successful and failed projects, find that the primary critical success factors lie in the value domain. Most projects fail due to a lack of user input, incomplete requirements, lack of resources, unrealistic expectations, unclear objectives and/or unclear time-frames [22]. This is because projects are tracked by monitoring project cost and schedule [23]. This approach, unfortunately, does not consider stakeholder or business value. A project can be successful in terms of cost (i.e. if it is finalized within its budget), but may fail to provide any business value. This can be due to not effectively tracking a project when the project plan changes rapidly, there are flaws in user acceptability, operationally the system is not cost-effective or timely market entry is required [22].\n\nFavaro [44] argues that the purpose of the requirements process is to add business value. As global competition forces companies to become increasingly competitive and responsive to consumers and market developments, the emerging discussions in SE indicate that a value-based approach makes all the difference in creating successful product and value for software business because it puts the requirements engineer in the position of managing requirements to make the most strategic opportunities.\n\nAlthough companies put a great amount of effort into increasing customers’ perceived value in the product development process, determining how and when value is added is still a challenge even in marketing and management science [47]. This is because value creation strategies are highly contextual [75] and must be analysed as part of a multidimensional array of variables [91]. Unfortunately, there is no prescribed approach to achieving this perception. There are some companies that adopt a single strategy that best suits their circumstances and are quite successful in value creation. Examples of this approach include Sony-Ericsson and Siemens-Nokia marriages for their mobile phone products.\n\nKotler [75] states that strategy and product management should change with market demand. Although this is only one of many factors that could influence the relative importance for criteria in the selection of requirements, we were unable to identify a complete list of factors from the literature.\n\nTechniques to reconcile conflicts include requirement prioritization techniques, business case analysis techniques, and stakeholder identification and\nrequirements and negotiation techniques [23]. It is also important to consider that the value a market attaches to different requirements changes over time [81], but it is not understood how they will change [109, 110]. The critical success factor for software vendors is to respond quickly to changing requirements while maintaining a focus on their value proposition, which may, for example, yield a quicker return on investment.\n\nShaw [99] adds that features in software only need to be good enough to meet the needs of the users. Recognising that bug fixes come at a cost. The paper highlights that people are able to handle a certain level of unintended behaviour, and making valuable software includes finding this optimal level of quality.\n\nValue-based requirements engineering (VBRE) aims to maximize the value of a release of software to success-critical stakeholders through the selection of requirements [109, 110, 4]. VBRE is a very young area of academic study, however, the problem of creating product value through requirements selection and prioritization is real to the development of software products in today’s competitive environment. Companies have been forced to change their practices due to current market forces, but there is little theory providing an approach for development of IT intensive solutions that are valuable to all stakeholders [47]. In this article we examine this topic in industry through three case studies.\n\n2.2.4 Incremental Development and Release Planning\n\nIncremental software development is a top-down approach to development in which a minimal software product is developed and released in the first increment, and a function(s) or a requirement(s) is added in each successive increment until the product is complete. Each increment or product release may contain all previously elicited requirements in addition to some new requirements or functions allowing the product to cumulatively grow. This approach to software development requires the analysis of requirements, assigning them to increments [49] and releasing each increment with an aim of meeting the expectations and values of stakeholders who are involved in product development.\n\nRelease planning is the process of selecting an optimal subset of requirements for realization in a certain release in incremental software development [32]. The aim of release planning is to determine the optimal set of requirements, when they should be released and at what cost this should be achieved [81]. Researchers agree that release planning is a crucial determinant of the success of the software product as it determines which requirements will go the next release [33]. Release planning can only be conducted after a product’s require-\n2.2 Background\n\nments have been elicited, analysed and specified [110]. If release planning is done badly it increases risk [81]. For example, leaving critical features or difficult tasks to last or ignoring dependencies and interdependencies can result in time and budget overruns and a loss of market share.\n\nKarlsson et al. [64] suggested that release planning be approached through the prioritization of requirements. Carlshamre et al. [33] and Dahlstedt and Persson [39] furthered prioritization by recognising and accommodating the dependencies that exist between requirements. Wiegers [108] proposed a method of prioritization that recognised and combined benefits and penalties of proposed functionality between multiple stakeholder perspectives, relative costs and relative risks.\n\n2.2.5 Aligning Release Planning and Stakeholders’ Value Perspectives\n\nValue creation in software development is supported by aligning product, project and business level decisions throughout the development process [5, 109, 110]. Decisions are traditionally made in a client neutral setting as it is easier to assume that all clients have the same or similar expectations in the solution a product will supply [20]. This does not result in the best solution for all stakeholders. Additionally software developers are increasingly trying to expand the target market for software products [109, 4]. Requirements come from a diverse set of stakeholders are not fed into a specific project, but are managed at a product level. Product managers initiate development projects based on a selected set of requirements. We argue that the following value perspectives are important to software developers when creating value:\n\n**Business perspective:** Business value stems from product sales.\n\n**Product perspective:** Product value stems from customer and market requirements.\n\n**Project perspective:** Project value stems from project budget/timing/delivery etc.\n\nThe above value perspectives need to be aligned with product, project and business level decisions made during the software development process. Each stakeholder group’s perception of value is different [68, 23]. For example a project sponsor defines value in terms of the cost of the software and the benefits it provides, while a software company measures value in profit. Stakeholders\nvalues are often incompatible, and must be reconciled [23]. Boehm [23] argues that:\n\n- Users of the software want many features, while the project sponsor wants to limit cost by minimising the development effort\n\n- Developers want stable requirements, but users want to be able to change requirements\n\n- The system maintainers want their job to be made easier, but the developers and project sponsors want control over the solution provided and the ability to make changes whenever they want\n\nIn summary, while product managers are focussing on business perspective and developers are focussing on product perspectives, sales/project managers will be more concerned with project perspective. Interestingly stakeholders are not always aware of their own value propositions, which can often only be elicited through experience in the problem domain [2]. Additionally only a limited number of companies in the software business are able to define or measure value from their customers’ perspectives despite many describing the achievement of this as having “never been more important” [2]. Maurice et al. [81] recognised that while iterative development facilitates early customer feedback, allowing faster delivery and a more interactive process; it also creates difficulties with reconciling conflicting stakeholder perspectives.\n\nStakeholder management, which involves a focus on the relationship between an organisation and its stakeholders over the transactions been an organisation and its stakeholder has found to create and improve the value of the organisation for shareholders [56]. While taking a more liberal definition of stakeholder management, Berman et al. [19] found that two aspects of stakeholder management that are most influential on the financial performance of an organisation – employees, and product safety and quality.\n\nValue-based Requirements Engineering (VBRE) exploits the concept of economic value during the RE process [47]. Boehm [22] states that in order to achieve this, VBRE must include practices and principles for a) identifying a system’s success-critical stakeholders; b) Eliciting their value propositions with respect to the system and c) reconciling these value propositions into a set of mutually agreed objectives for the system.\n2.3 Methodology\n\nThe main purpose of this study is to understand how software product value is created through the RE process, and identify the relative influence of the decision criteria and major stakeholders’ perspectives during requirements selection stage of market driven incremental software development. This chapter extends the exploratory research conducted in Barney et al. [6]. The following research questions, presented in three groups, are investigated with respect to the collective case study conducted:\n\n1. Value-based approach in release planning\n (a) How is release planning conducted in order to create product value?\n\n2. Values influencing requirement selection\n (a) To what degree do different value propositions influence the selection of requirement for a release of software?\n (b) Does the manufacturer see potential to improve product value by applying the criteria differently in the selection of requirements for a release?\n\n3. Perspectives influencing requirement selection\n (a) To what degree do the perspectives of the major stakeholders influence the requirements selection and prioritization process in software industry?\n (b) Does the manufacturer see potential to improve product value by changing the level of influence of the major stakeholders?\n\n2.3.1 Research Model\n\nThe research framework in this study is built on Boehm’s Theory W model [22] that proposes a process for VBRE. According to this model, the process follows identification of success-critical stakeholders, elicitation of their value propositions and requirements, and finally reconciliation of value into a mutually agreed set of requirements.\n\nIn this study we used the stakeholder groups identified by Wohlin and Aurum [109, 110] who participate in requirements selection for the next software\nrelease. Note that this model addresses stakeholders’ perspectives from software company point of view only. These stakeholders group include business, project and product perspectives as illustrated in Figure 2.1. Each stakeholder group’s perception of value is different. For example a project sponsor defines value in terms of the cost of the software and the benefits it provides, while a software company measures value in profit. Based on premises that requirements selection process will be influenced by stakeholders’ perception of value, this study aims to investigate the most prominent decision criterion during requirements selection process.\n\nFigure 2.1: Value-based requirements engineering research model\n2.3 Methodology\n\nThis study used the criteria identified in Wohlin and Aurum [109, 110]. In these studies the researchers aimed to identify a set of orthogonal criteria that influenced the selection of requirements for a release of software. It was determined this was only possible if the criteria were kept at a high level of abstraction. Criteria were identified and confirmed in two main stages: (i) through a in-depth brainstorming session involving three researchers in requirements engineering with industrial contacts, and (ii) the industry-based research participants were asked to confirm the relevance of the criteria identified by the researchers and identify any missing criteria.\n\nAdditionally this chapter combined both the criteria identified by the Wohlin and Aurum [109, 110] and the results provided by the participants. All of the criteria originally identified were adopted, with one additional criterion being selected from those identified by the research participants: function is promised/sold. It was felt there was sufficient overlap between the other criteria identified by the participants and those identified by the researcher.\n\nFurther this study asked participants to confirm that each criterion was relevant and identify any criteria missing from list provided. The participants were all IT professionals working in the software development industry.\n\nThis research is conducted by using three industry-based case studies since case studies are “especially suitable for learning more about a little known or poorly understood situation” [77]. This study employed a mixed research methodology to conduct each case study which is supported by semi-structured interviews, questionnaires and unstructured interviews. Data is collected from two Australian companies (Company A and Company C), and one German company (Company B). Any cultural issues are outside the scope of this study. The researchers of this study do not perceive cultural issues as a factor in this research as both companies are Western companies, with the German company having a multicultural workforce.\n\nSemi-Structured Interviews\n\nIn the first phase semi-structured interviews were conducted to understand the processes used in RE and release planning to create product value – research question 1. The interview questions [6] covered the interviewee’s background; company’s background; product background; RE process; requirements elicitation process; requirements interpretation, verification and validation process; requirements prioritization and selection; and views on value-based software engineering, and was piloted with academics and professionals within the IT industry.\nEach interview went for a period ranging between 25 and 40 minutes. The interviews were held at times suitable for both the researcher and participant. Each participant was given an introduction, providing an overview of the research, and detailing the participant’s rights and responsibilities. Then each participant was asked a series of questions, with the researcher and participant seeking clarification or more information where required. The proceedings of each interview were recorded verbatim electronically. The construction of the interview questions was based on the key activities in the RE, release planning processes and the interviewees’ perception of how to create product value through RE. The interview questions also included company, product and personal (interviewee) background details.\n\nQuestionnaire\n\nIn the second phase, a questionnaire was created to understand the value-system applied to the decision making process in release planning to create product value – research questions two and three. The questionnaire [6] provided the list of criteria presented in this section and asked respondents to identify any criteria missing from the list; mark the criteria relevant to selection of requirements for a release; specify the relative importance of each criteria as they influence the process today; and specify the relative importance of the criteria as the respondent perceived in an optimal situation. The questionnaire was piloted with academics and professionals with in the IT industry.\n\nThe questionnaire was targeted at employees who are in a decision-making capacity for the selection of requirements for the product studied. The participants were asked to respond for the product they were identified as being involved with by their company. The company contact at each company selected participants they regarded as appropriate to participate in the questionnaire. The questionnaire focused on the 14 decision criteria which covered three different perspectives, as shown in Figure 2.1, i.e. business, project and product perspectives.\n\nUnstructured Interviews\n\nIn the third phase the results from the semi-structured interview and questionnaire were then presented to selected participants (including project manager, product manager and development team leader) for their comments in unstructured interviews. The participants were asked to verify and explain the results.\n2.3 Methodology\n\n2.3.2 Case Studies\n\nAs illustrated in Table 2.1, data is collected from three different companies where each company is regarded as one case study. Due to the exploratory nature of this research and limited access to industry, each company was selected using convenience sampling, with a personal with the authors.\n\nCompany A\n\nIn Company A we studied two products (Product A1 and Product A2) in detail. Product A1 is an enterprise grade document and data repository developed and supported by Company A. The product has been undergoing iterative development for over ten years. It was in its third major release, with the fourth release due months after the study was conducted. Product A2 provided a solution for managing the collection, analysis and processing of paper requests and responses such as election polls, surveys, exams, insurance claims, remittances and general inbound mail. It is developed, hosted and supported by Company A. The product has been undergoing iterative development over two years. At the time of the study the company was preparing for the first major release of this product since it was first released. This product was implemented to replace the existing solutions within the organization that no longer met the requirements of the business.\n\nCompany B\n\nData is collected on only one product from Company B, called Product B, which was a real-time service for mobile telecommunications networks, developed, manufactured and supported. Once implemented this product allows mobile subscribers to decide what each caller hears before the subscriber answers his/her phone call, replacing the traditional ring back tone. The product has been undergoing iterative development for over two years. It has been implemented for over ten mobile telecommunications carriers, and continues to be highly popular with new clients of Company B. Product B needs to be set-up for each mobile telecommunications carrier by Company B. While implementations of this product have a common core, it needs to interface with a number of proprietary systems of the mobile telecommunications carrier. These include the mobile telecommunications network and account management system. Interfaces to these systems, and integration of the service into the existing infrastructure need to be developed and customized. The product has a highly customizable front end for user interaction with the system, the core product\nTable 2.1: Descriptions of companies used in the collective case study\n\n<table>\n<thead>\n<tr>\n<th>Company</th>\n<th>Location</th>\n<th>Geographic</th>\n<th>Industry served</th>\n<th>Employees</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A</td>\n<td>Australia</td>\n<td>Australia</td>\n<td>Telecommunications, finance, government, retail</td>\n<td>200 Total</td>\n</tr>\n<tr>\n<td>B</td>\n<td>Germany</td>\n<td>Europe</td>\n<td>Telecommunications</td>\n<td>All 100</td>\n</tr>\n<tr>\n<td>C</td>\n<td>Australia</td>\n<td>Global</td>\n<td>Corporate groupware, software development</td>\n<td>All 55</td>\n</tr>\n</tbody>\n</table>\nsoftware in a middle layer, with a database and specialised telephony switches at the backend. Product B was originally built for a specific client contract, but was designed to allow it to be implemented in other environments.\n\n**Company C**\n\nWe collected data on three products from this company; Products C1, C2 and C3. Product C1 is an enterprise grade issue tracking system developed and maintained by Company C. It is a web-based application with a database backend. The product has been undergoing iterative development for approximately three years. It is used by almost 4,000 organizations in 55 countries. This product can be set-up and integrated by an organization that purchases the software, however, Company C provides support for this product. Product C2 is an enterprise grade wiki developed and maintained by Company C. It is a web-based application with a database backend. This product has been undergoing iterative development for approximately two years. It is used by over 1,800 organizations. This product can be set-up and integrated by an organization that purchases the software, however, Company C provides support for this product. Product C3 is a continuous integration service developed and maintained by Company C. It has just been released for alpha testing. This is used by software developers to build and test code every time it is updated.\n\n### 2.4 Data Analysis and Results\n\nResearchers have proposed numerous methods to create software product value through RE and release planning, such as evolve and trade-off analysis techniques. While it is recognized that there is a disparity between formal methods and the processes used in industry, little research has been conducted into the process companies in the software industry use to create software product value.\n\n#### 2.4.1 Value-Based Approach in Release Planning\n\nThis section focuses on decision criteria and release planning applied at the product level based on data from Company A only. The interviews with management level people provided insights to release planning for these two products. We conducted four interviews with people from Product A1 and two interviews from Product A2.\n\nThe aim of interview was to understand how the software industry conducted release planning in order to create product value. The interview questions also\naddressed stakeholder groups, the role of product and requirements engineer, change management issues, and RE activities. The participants from Product A1 were the product manager, R&D managers, IT consultant and System and Program team manager and were the product and R&D managers from Product A2.\n\nStakeholder groups\n\nThe participants identified the clients as the most important stakeholder group in determining what requirements were implemented for a release of software because they represent the revenue stream. However, it was noted that to understand a clients' needs, Company A needed to understand their business and customers. Sales, implementation, operations, development, product management and marketing were also seen as influential groups, but there was disagreement as to the level of influence these stakeholders played.\n\nProduct Management\n\nIn the past at Company A the sales team dealt directly with the Research and Development (R&D) team to create customer specific versions of Product A1. This created unnecessary rework as similar solutions we redeveloped from scratch, so the role of Product Manager was created to merge these changes into a core product with a strategy to take it into the market place. Additionally both development and sales are biased in their approach to development. The development team is technology focused, the sales team is revenue focused and operations just need to get the job done. One of the participants described how a Product Manager agnostically has a view of all areas and can make a balanced judgment.\n\nThe Role of Requirements Engineer\n\nThe role of a requirements engineer is not clearly defined in Company A. The Product Manager was responsible for business requirements, while the Development Manager (or research and development team) was responsible for technical requirements.\n\nChange Management\n\nIn Company A changes to the product are mainly managed according to their size. One of the participants identified small changes as being rolled out in bug\nfixes, while bigger changes have a more formal project. The availability of the resources was also identified as the biggest constraint to development.\n\n**Requirements Elicitation (for Product Release)**\n\nCompany A held an annual meeting bringing together the sales teams, production team and other vested parties to develop a business strategy for the upcoming year. The objective of this meeting was also to provide feedback on what are the things that are going to be driving the business that year to development team. In this meeting, the key products to fulfilling the business strategy would be brought into focus. When a product was brought into focus, it would undergo a requirements elicitation phase involving sales, developers and support teams. The sales team represented general markets requirements and identified product development opportunities. Additionally, industry forms, exposs, trade shows and conferences were as ways to keep their product aligned with their competitors, by the marketing and development teams. The requirements elicited from these processes were documented at feature level.\n\n**Requirements Interpretation, Verification and Validation**\n\nOnce business level requirements were defined, a workshop was held with the Product Manager, development team and support team to determine what the requirement elicited means to product in hand. They looked at what must be delivered, what could be delivered and in what timeframe it should be delivered. This workshop was used to develop an understanding of what requirements needed to be implemented. For small discussions phone and email were also used. Since feature descriptions could often be vague business people were invited to meetings. As a result of these meetings the development team determined the system architecture and who would be responsible for what task. Once the functional specification was complete, the client was responsible for verifying and validating that the system specified met their requirements.\n\n**Requirements Selection and Prioritization**\n\nIn Company A, traditionally requirements selection and prioritization has been the role of the R&D Team. Recently, the Product Manager has taken on this role for Product A1. As for Product A2, Product Manager and Development Manager were responsible from this role. Requirements selection and prioritization was a part of the workshop mentioned in the above section. The first\nstage in requirements selection and prioritization was to ask if the requirements could be implemented. In both products, revenue, product differentiation and sales were the key aims in selecting and prioritizing requirements according to the Product Manager.\n\nThe value of requirements from the perspective of Company A and their clients formed part of the requirements selection and prioritization process. One of the participants listed key questions asked as part of this process:\n\nWhat is the value to (the company)? Is it something that is strategic? Is it eye candy? Is it limited to one particular market place?\nSo we don’t only look at the amount of effort required by (Company A), but what it delivers to our customers.\n\nAnother participant acknowledged if a client requested a requirement be implemented, but if this requirement was not seen as marketable to other clients, then it would not be rolled into the core product, but a client specific version would be created.\n\nWhile the input of the workshop played an important role, the final decision as the selection and prioritization of requirements laid with the Product Manager working closely with the Development Manager. Once agreed, the resultant list of requirements was usually made available. As Product A2 was relatively new, a large part of the development effort was rolling customer specific features that have been developed back into the core product as generic components. It was the product manager and development manager’s job to start by looking at what should be rolled back into the core product. In order to facilitate an open working environment, the Product Manager wrote a monthly report that detailed all work being done by the R&D team.\n\nRelease Planning\n\nCompany A has a defined direction for Product A1, but new and existing customers defining new requirements heavily influence this direction. In addition to the formal RE and release-planning project the product evolves with customer specific versions being developed between major releases. If there are features that need to be implemented to win a contract, then they will be made available in either the next release or a customer specific version, in which case they will be rolled back into the core product at a later date. Any requirements that are perceived to have a sufficient market are rolled back into the core product.\nThe product managers preferred method is to get all of the stakeholders into a meeting to discuss and analyze the business requirements. This process was described by one the product managers:\n\nSo we’ll sit down and put together a development brief and answer all of the requirements of what we’re developing, how long is it going to take, are we going to build for it, how much are we going to sell it for, who else can use it – so all these other questions will form that brief, we’ll submit that to R&D and they’ll take a look at it and say yep, it’ll take two hours, it will cost this much, cost that much, they’ll do the building, all the testing that they need to do and sort-of roll it out for that client and then later on roll it out in a major release.\n\nCompany A planned a major release of Product A1 every 18 to 24 months. They would try and include the features selected for inclusion. However, if a release needed to be out by certain date, then Company A would make a major release and follow it with a minor release. Although Company A normally worked on a two-year cycle for major releases of its software products, as Product A2 was relatively young, it was currently undergoing six monthly releases. As the time gets closer to a release date, Company A would renegotiate what would be in the release. If it was decided that certain features could not make the desired release date, an additional release with the postponed functionality would be planned to follow.\n\n2.4.2 Values Influencing Requirement Selection\n\nThe objective of this section is to capture and understand any differences on the product level when it comes to which criteria that are important when selecting which requirements to include in a release. The questionnaire allowed us to capture the decision criteria used in requirements selection for Product A1, Product A2, Product B and at Company C. The return rate for the questionnaire is described in Table 2.2.\n\nIn their study in Sweden, Wohlin and Aurum [109, 110] identified thirteen criteria, which influenced the selection and/or prioritization of a requirement covering the main stakeholders. While our pilot studies identified several more additional criteria, only one was substantially different to the others. This was the criteria “Function is promised/sold”. Hence, this study used fourteen criteria, based on the response from the participants as illustrated in Figure 2.1.\nFirst the respondents were asked to identify any additional criteria not listed. Then the respondents were asked to mark the criteria they felt were relevant in deciding whether to include a requirement in a release or project. Finally the respondents were asked to provide relative weights regarding the importance of the criteria in two sets, currently (today) and if the criteria were applied optimally (future). The respondents had 1000 points to spend amongst the criteria. A high number of points meant a criterion was important.\n\nParticipants, for Product A1 identified three additional criteria as being important in the decision making process in release planning: (i) creation of competitive advantage, (ii) preferred operating architecture, and (iii) adherence to corporate software design parameters. Participants of Product A2 identified two additional criteria as influencing the release planning process (i) non custom application (Resell a solution, save costs); (ii) future financial worth/new business applications.\n\nThe researchers decided these were covered in the existing set of criteria provided in the questionnaire.\n\nThe results for all case studies clearly showed that some criteria are more influential than others in the selection and prioritization of requirements. For products A1, A2 and B the value propositions of the business perspective are paramount. However, while the most influential criterion for Product C represents the business perspective the next four all represent the product and project perspective.\n\nSome change in the relative importance of the criteria is also perceived beneficial in all cases. There are no criteria that move consistently across all case studies, but there are some notable similarities between products A1 and A2. The participants for both felt that the influence of the criterion function is promised or sold was overly influential today, while not enough consideration was being given to the impact of delivery date/calendar time.\nFor each case study the order and relative importance of the different decision criteria for “today” and “future” is presented. The “movement” column whether a particular criterion moves up or down in the future situation when comparing with today. The “perspective” column shows to which perspective each criteria belongs.\n\nDecision Criteria for Product A1 (Today and Future)\n\nThe results for Product A1 are presented in Table 2.3.\n\nThe business perspective of Product A1 has the most significant influence on the selection and prioritization of requirements for inclusion in the software. When the criteria were ranked in order of influence, all four criteria representing business perspective of Product A1 appear in the first five places. Some project perspective criteria were considered much more important than others. Both the development cost-benefit of the requirement and the impact the requirement has on delivery date had percentage values above 9%, while others were below 3.5% in their importance. Three product perspective criteria were considered of higher importance – (11) the complexity of the requirement, (10) the impact on the system, and any (12) requirement dependencies.\n\nThe participants for Product A1 optimally saw a tighter distribution of the criteria. In describing the situation today the criteria were distributed over 8.8 percentage points, compared with an optimal distribution over 6.6 percentage points. The optimal application of the criteria remained business perspective focused; however, this area still reported a significant change. The importance of the criterion if the function has been promised or sold fell five places in the ranking of criteria. The development cost-benefit of the requirement, raised five places when the criteria were ranked how the participants would like to see them applied in future. The most significant change in the criteria representing the product perspective was a decrease in the importance of (11) the complexity of the requirement. This criterion fell five places when ranked against how the participants would like to see them applied.\n\nDecision Criteria for Product A2 (Today and Future)\n\nThe results for Product A2 are presented in Table 2.4.\n\nThe business perspective of Product A2 has the most significant influence on the selection and prioritization of requirements for inclusion in the software. When the criteria were ranked in order of influence, all four criteria representing the business perspective of Product A2 appear in the first five places. Unlike\nTable 2.3: Relative importance of different criteria for Product A1 today and in future\n\n<table>\n<thead>\n<tr>\n<th>Criteria</th>\n<th>Perspective</th>\n<th>Today (%)</th>\n<th>Future (%)</th>\n<th>Movement</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>3. Stakeholder Priority of Requirement</td>\n<td>Business</td>\n<td>11.5</td>\n<td>10.4</td>\n<td>−</td>\n</tr>\n<tr>\n<td>2. Requirement’s Issuer</td>\n<td>Business</td>\n<td>11.5</td>\n<td>10.3</td>\n<td>−</td>\n</tr>\n<tr>\n<td>4. Function is Promised/Sold</td>\n<td>Business</td>\n<td>9.0</td>\n<td>6.7</td>\n<td>−5</td>\n</tr>\n<tr>\n<td>11. Complexity</td>\n<td>Product</td>\n<td>8.9</td>\n<td>6.4</td>\n<td>−5</td>\n</tr>\n<tr>\n<td>1. Competitors</td>\n<td>Business</td>\n<td>8.8</td>\n<td>8.9</td>\n<td>+1</td>\n</tr>\n<tr>\n<td>10. System Impact</td>\n<td>Product</td>\n<td>7.8</td>\n<td>8.8</td>\n<td>+1</td>\n</tr>\n<tr>\n<td>12. Requirements Dependencies</td>\n<td>Product</td>\n<td>7.6</td>\n<td>7.3</td>\n<td>−</td>\n</tr>\n<tr>\n<td>7. Development Cost-Benefit</td>\n<td>Project</td>\n<td>7.3</td>\n<td>9.8</td>\n<td>+5</td>\n</tr>\n<tr>\n<td>9. Delivery Date/Calendar Time</td>\n<td>Project</td>\n<td>7.3</td>\n<td>7.8</td>\n<td>+3</td>\n</tr>\n<tr>\n<td>8. Resources/Competencies</td>\n<td>Project</td>\n<td>4.9</td>\n<td>4.4</td>\n<td>−3</td>\n</tr>\n<tr>\n<td>14. Maintenance</td>\n<td>Product</td>\n<td>4.8</td>\n<td>5.1</td>\n<td>−</td>\n</tr>\n<tr>\n<td>13. Evolution</td>\n<td>Product</td>\n<td>4.5</td>\n<td>5.8</td>\n<td>+2</td>\n</tr>\n<tr>\n<td>6. Support/Education/Training</td>\n<td>Project</td>\n<td>3.4</td>\n<td>3.8</td>\n<td>−1</td>\n</tr>\n<tr>\n<td>5. Volatility</td>\n<td>Business</td>\n<td>2.7</td>\n<td>4.4</td>\n<td>−3</td>\n</tr>\n</tbody>\n</table>\nTable 2.4: Relative importance of different criteria for Product A2 today and future\n\n<table>\n<thead>\n<tr>\n<th>Criteria</th>\n<th>Perspective</th>\n<th>Today (%)</th>\n<th>Future (%)</th>\n<th>Movement</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>4. Function is Promised/Sold</td>\n<td>Business</td>\n<td>14.5</td>\n<td>5.8</td>\n<td>-6</td>\n</tr>\n<tr>\n<td>8. Resources/Competencies</td>\n<td>Project</td>\n<td>11.9</td>\n<td>10.7</td>\n<td>-1</td>\n</tr>\n<tr>\n<td>1. Competitors</td>\n<td>Business</td>\n<td>11.3</td>\n<td>13.9</td>\n<td>+2</td>\n</tr>\n<tr>\n<td>7. Development Cost-Benefit</td>\n<td>Project</td>\n<td>10.1</td>\n<td>7.5</td>\n<td>-2</td>\n</tr>\n<tr>\n<td>3. Stakeholder Priority of Requirement</td>\n<td>Business</td>\n<td>8.5</td>\n<td>12.3</td>\n<td>+3</td>\n</tr>\n<tr>\n<td>2. Requirement’s Issuer</td>\n<td>Business</td>\n<td>8.3</td>\n<td>7.8</td>\n<td>+1</td>\n</tr>\n<tr>\n<td>11. Complexity</td>\n<td>Product</td>\n<td>7.1</td>\n<td>5.1</td>\n<td>-2</td>\n</tr>\n<tr>\n<td>9. Delivery Date/Calendar Time</td>\n<td>Project</td>\n<td>6.6</td>\n<td>10.3</td>\n<td>+4</td>\n</tr>\n<tr>\n<td>10. System Impact</td>\n<td>Product</td>\n<td>6.4</td>\n<td>4.0</td>\n<td>-4</td>\n</tr>\n<tr>\n<td>5. Volatility</td>\n<td>Business</td>\n<td>4.5</td>\n<td>5.0</td>\n<td>-1</td>\n</tr>\n<tr>\n<td>12. Requirements Dependencies</td>\n<td>Product</td>\n<td>3.1</td>\n<td>4.1</td>\n<td>-1</td>\n</tr>\n<tr>\n<td>14. Maintenance</td>\n<td>Product</td>\n<td>2.9</td>\n<td>5.6</td>\n<td>+4</td>\n</tr>\n<tr>\n<td>6. Support/Education/Training</td>\n<td>Project</td>\n<td>2.6</td>\n<td>5.1</td>\n<td>+3</td>\n</tr>\n<tr>\n<td>13. Evolution</td>\n<td>Product</td>\n<td>2.2</td>\n<td>2.7</td>\n<td>-</td>\n</tr>\n</tbody>\n</table>\nUnderstanding Software Product Requirements Selection\n\nProduct A1, the most important criteria for Product A2 represent both the business and project perspectives when ranked by importance in release planning. Product A2 also differed from the others in the project perspective. The most important issue from the project perspective was the available resources and their competencies. Two product perspective criterions considered of higher importance: (10) the impact on the system, and (11) the complexity of the requirement.\n\nThe optimal (future) application of the criteria remained business focused; however, this area reported a significant change in its makeup. The importance of the criteria, (4) if the function has been promised or sold, fell six places in the ranking of criteria going from the most important to the least important business perspective criterion. The order of the business perspective criteria was otherwise unchanged, with the status of (1) competitors with respect to the requirement, and the market’s priority of the requirement being the most significant in first and second place of all criteria respectively. The project perspective criterion (9) delivery date/calendar time rose four places when the criteria were ranked against how the participants would like to see them applied. The participants from Company A optimally saw a tighter distribution of the development criteria. In describing the current situation the criteria were distributed over 4.7 percentage points, compared with an optimal distribution over 1.4 percentage points.\n\nDecision Criteria in Company B (Today versus Future)\n\nThe results for Product B clearly indicate that some criteria are more important than others in the selection and prioritization of requirements for a release. It is worth noting that three of the criteria have percentage values above 10% and five have values below 5%. The order and relative importance of the different criteria can be seen in Table 2.5.\n\nThe business perspective of Product B has the most significant influence on the selection and prioritization of requirements for inclusion in the software. The three most important criteria all represent the business perspective of Product B; in order these are (4) if the function has been promised or sold, (3) the market’s priority of the requirement, and (2) the stakeholder responsible for issuing the requirement, Requirement’s Issuer.\n\nSome project perspective criteria were considered much more important than others. Both (7) the development cost-benefit of the requirement and (9) the impact the requirement has on delivery date had percentage values above 9%, while (5) a requirement’s volatility and (6) the ability to provide technical support, ed-\nTable 2.5: Relative importance of different criteria for Product B today and future\n\n<table>\n<thead>\n<tr>\n<th>Criteria</th>\n<th>Perspective</th>\n<th>Today (%)</th>\n<th>Future (%)</th>\n<th>Movement</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>4. Function is Promised/Sold</td>\n<td>Business</td>\n<td>14.1</td>\n<td>9.6</td>\n<td>−1</td>\n</tr>\n<tr>\n<td>3. Stakeholder Priority of Requirement</td>\n<td>Business</td>\n<td>12.1</td>\n<td>12.3</td>\n<td>+1</td>\n</tr>\n<tr>\n<td>2. Requirement's Issuer</td>\n<td>Business</td>\n<td>10.1</td>\n<td>10.1</td>\n<td>−1</td>\n</tr>\n<tr>\n<td>9. Delivery Date/Calendar Time</td>\n<td>Project</td>\n<td>9.4</td>\n<td>9.4</td>\n<td>+1</td>\n</tr>\n<tr>\n<td>7. Development Cost-Benefit</td>\n<td>Project</td>\n<td>9.1</td>\n<td>9.1</td>\n<td>−</td>\n</tr>\n<tr>\n<td>8. Resources/Competencies</td>\n<td>Project</td>\n<td>6.6</td>\n<td>6.6</td>\n<td>−3</td>\n</tr>\n<tr>\n<td>1. Competitors</td>\n<td>Business</td>\n<td>6.5</td>\n<td>6.5</td>\n<td>−3</td>\n</tr>\n<tr>\n<td>11. Complexity</td>\n<td>Product</td>\n<td>5.9</td>\n<td>5.9</td>\n<td>−3</td>\n</tr>\n<tr>\n<td>10. System Impact</td>\n<td>Product</td>\n<td>5.6</td>\n<td>5.6</td>\n<td>+1</td>\n</tr>\n<tr>\n<td>12. Requirements Dependencies</td>\n<td>Product</td>\n<td>4.9</td>\n<td>4.9</td>\n<td>−4</td>\n</tr>\n<tr>\n<td>14. Maintenance</td>\n<td>Product</td>\n<td>4.9</td>\n<td>4.9</td>\n<td>+5</td>\n</tr>\n<tr>\n<td>13. Evolution</td>\n<td>Product</td>\n<td>4.6</td>\n<td>4.6</td>\n<td>+5</td>\n</tr>\n<tr>\n<td>6. Support/Education/Training</td>\n<td>Project</td>\n<td>3.4</td>\n<td>3.4</td>\n<td>+3</td>\n</tr>\n<tr>\n<td>5. Volatility</td>\n<td>Business</td>\n<td>3.0</td>\n<td>3.0</td>\n<td>−4</td>\n</tr>\n</tbody>\n</table>\nucation and training for the requirement were below 3.5% in their importance. Product perspective criteria were considered of fairly equal importance, with all criteria representing these groups clustered together in the results between 5.9% and 4.6%.\n\nThe results for how the value criteria should be optimally (future) applied in requirements selection and prioritization for Product B indicate that some change would be perceived as being beneficial. The participants from Company B optimally saw a tighter distribution of the criteria. In describing the current situation the criteria were distributed over 11.1 percentage points, compared with an optimal distribution over 7.9 percentage points. The optimal application of the criteria remained business focused; however, the focus within this area has changed. The first two criteria swapped place, with Company B preferring to see (3) the stakeholder’s priority of the requirement as the most important criteria over (4) whether the function has been promised or sold. The optimal application of the criteria also saw the project perspective criteria of (9) the impact the requirement has on delivery date, overtake the importance of (2) the stakeholder responsible for issuing the requirement. It is also of interest to note that (6) the ability to provide technical support, education and training for the requirement rose three places, while (8) the available resources and their competencies fell three places in the ranking.\n\nThe criteria representing the product perspective became more evenly distributed when applied optimally. Instead of being distributed over 1.3 percentage points, they were distributed over 3.2 percentage points, despite the general reduction in range. The effect of a requirement on both (14) maintenance and (13) system evolution jumped five places in the ranking of the criteria, while considerations of (12), requirement dependencies fell four places in the ranking.\n\nDecision Criteria in Company C (Today versus Future)\n\nThe order and relative importance of the different criteria can be seen in Table 2.6. None of the stakeholder groups is prominent in their influence over the selection and prioritization of requirements at Company C. While the most influential criterion represents the view of the business perspective, the next two criteria represent project perspective criteria, followed by two product perspective criteria. This mixed distribution is continued with the remaining criteria. The results for how the value criteria should be optimally applied in requirements selection and prioritization for Product C1, Product C2 and Product C3 indi-\nTable 2.6: Relative importance of different criteria in Company C today and future\n\n<table>\n<thead>\n<tr>\n<th>Criteria</th>\n<th>Perspective</th>\n<th>Today (%)</th>\n<th>Future (%)</th>\n<th>Movement</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>3. Stakeholder priority of requirement</td>\n<td>Business</td>\n<td>11.2</td>\n<td>10.7</td>\n<td>-1</td>\n</tr>\n<tr>\n<td>9. Delivery date/Calendar time</td>\n<td>Project</td>\n<td>9.8</td>\n<td>7.8</td>\n<td>-4</td>\n</tr>\n<tr>\n<td>7. Development cost-benefit</td>\n<td>Project</td>\n<td>9.7</td>\n<td>8.8</td>\n<td>-1</td>\n</tr>\n<tr>\n<td>10. System impact</td>\n<td>Product</td>\n<td>9.2</td>\n<td>12.8</td>\n<td>+3</td>\n</tr>\n<tr>\n<td>12. Requirements dependencies</td>\n<td>Product</td>\n<td>8.3</td>\n<td>5.3</td>\n<td>-6</td>\n</tr>\n<tr>\n<td>4. Function is promised/sold</td>\n<td>Business</td>\n<td>7.2</td>\n<td>6.8</td>\n<td>-1</td>\n</tr>\n<tr>\n<td>8. Resources/competencies</td>\n<td>Project</td>\n<td>7.0</td>\n<td>4.3</td>\n<td>-5</td>\n</tr>\n<tr>\n<td>11. Complexity</td>\n<td>Product</td>\n<td>6.7</td>\n<td>5.4</td>\n<td>-1</td>\n</tr>\n<tr>\n<td>14. Maintenance</td>\n<td>Product</td>\n<td>6.7</td>\n<td>8.6</td>\n<td>+4</td>\n</tr>\n<tr>\n<td>6. Support/Education/Training</td>\n<td>Project</td>\n<td>5.8</td>\n<td>6.2</td>\n<td>+2</td>\n</tr>\n<tr>\n<td>2. Requirement’s issuer</td>\n<td>Business</td>\n<td>5.3</td>\n<td>3.3</td>\n<td>-1</td>\n</tr>\n<tr>\n<td>13. Evolution</td>\n<td>Product</td>\n<td>5.2</td>\n<td>10.6</td>\n<td>+9</td>\n</tr>\n<tr>\n<td>5. Volatility</td>\n<td>Business</td>\n<td>4.1</td>\n<td>4.1</td>\n<td>-</td>\n</tr>\n<tr>\n<td>1. Competitors</td>\n<td>Business</td>\n<td>3.8</td>\n<td>5.3</td>\n<td>+4</td>\n</tr>\n</tbody>\n</table>\ncate that some change would be perceived as being beneficial. The results can be seen in the table above.\n\nThe criteria representing the product perspective have all increased in importance, except for (12) requirements dependencies, showing a general feeling that the issues representing this perspective are currently undervalued. Of most note was (13) evolution, which moved up nine places. It should be noted that Company C only employs people with technical backgrounds. The developers swap between full time development and support, with the time in support used to determine market requirements. The other big movers were the influence of (1) competitors with respect to a requirement, which rose 4 places; and a decrease in importance of (8) resources/competencies, which fell five places.\n\n2.4.3 Perspectives Influencing Requirement Selection\n\nThe relative influence of the different stakeholder groups in each case can be seen in Table 2.7. The same information is also presented graphically in Figure 2.2 and Figure 2.3.\n\nFigure 2.2: Stakeholders’ perspective at business, project and product level (Today)\nTable 2.7: Relative importance of different criteria in Company C today and future\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Business</td>\n<td>45</td>\n<td>42</td>\n<td>46</td>\n<td>40</td>\n<td>46</td>\n<td>40</td>\n<td>32</td>\n<td>30</td>\n</tr>\n<tr>\n<td>Project</td>\n<td>23</td>\n<td>27</td>\n<td>33</td>\n<td>37</td>\n<td>28</td>\n<td>29</td>\n<td>32</td>\n<td>27</td>\n</tr>\n<tr>\n<td>Product</td>\n<td>32</td>\n<td>31</td>\n<td>21</td>\n<td>22</td>\n<td>26</td>\n<td>31</td>\n<td>36</td>\n<td>43</td>\n</tr>\n</tbody>\n</table>\nThe results for all cases, when grouped by stakeholder group, clearly indicate that some stakeholder groups are more important than others in the selection and prioritization of requirements for a release. The results for how the value criteria should be optimally applied in requirements selection and prioritization for all products indicate that some change would be perceived beneficial.\n\nThe business perspective is the most influential in all cases, both today and in the future, except for Company C. Additionally in all cases the participants felt that the business perspective was overly influential to the detriment of other perspectives.\n\nThe product perspective is second most important in selecting and prioritizing requirements for Product A1, with the project perspective is the least important. While the participants in the study felt that optimally, the ranking of these groups would remain the same, it was felt that the opinions of the groups should be valued more equally.\n\nThe results for Product A2 indicate that some changes in future would be perceived beneficial when value decision criteria are applied in requirements selection and prioritization. The project perspective is second most important\nin selecting and prioritizing requirements, while product perspective is least important. The participants in the study saw the release planning being conducted more effectively with a small decrease in the influence of the business perspective and an increase in the influence of the project perspective.\n\nAs illustrated in Table 2.7, the project perspective is higher than product perspective for Product A1, while the opposite is true for Product A2. We believe that this difference in requirements selection can be attributed to the respective maturity levels of these two products. This issue is further discussed in Section 2.5.\n\nThe project perspective is second most important in selecting and prioritizing requirements for Product B, while product perspective is least important. While the participants in the study felt that optimally, the ranking of these groups would remain the same, it was felt that the opinions of the groups should be valued more equally.\n\nIn Company C, participants perceived that both business perspective and project perspective are influencing the selection and prioritization of requirements to the detriment of the product perspective. The optimal application of the criteria ultimately saw a decrease in the influence of both the business and project perspective to give greater priority to product related issues. Company C is the only Company in this survey that did not have the business perspective as the most influential group, both today and optimally, in the selection and prioritization of requirements.\n\n2.5 Discussion of Results\n\nOur results highlighted several interesting aspects of decision making in requirements selection process in incremental development. While between them participants of our study raised the perspectives of each of the key stakeholder groups, it appeared that the value propositions that influenced their decision making process were more intrinsic than part of an explicitly planned process.\n\n2.5.1 Value-Based Approach in Release Planning\n\nRelease Planning\n\nCompany A in the past developed products for the market without the support of a specific client. This approach was unsuccessful for both clients with the products not meeting the needs of the market and therefore not selling. In order\nto create software product value, Company A have shifted the focus from fulfilling the perceived value propositions of the market to the much safer known value propositions of clients in a relationship with the company. This “real” client base is a more secure source of revenue for the software development company. There is a relationship between the two organizations and the software development company is creating software to meet the actual needs of the client. Company A moved to a development strategy that requires a client to request a product or feature before it will be developed. This approach created a situation where new features were only made available in customer specific implementations. This approach created two main problems; new features developed for a customer-specific implementation could not be made available to other clients easily, and when changes were made to the core product many customer-specific implementations need to be released involving a large human effort.\n\nCompany A created positions for product managers. The Product Manager for Product A1 and A2 saw his primary role as facilitating the rolling up of customer specific functionality into the core product so that it could be released to the market. An interview participant for Product B expressed a hope that the product manager for Product B would do likewise. A role of the product manager at both companies is to monitor similar products so that the company can react more competitively in bids and marketing material without the need to have functionality implemented. Both companies felt that with a better understanding of the market place sales bids would be more successful.\n\nCompany A expressed a need to remain client implementation driven – only implementing requirements when requested by a client. The elicitation of new requirements for a client for all products involves the client and a project manager and/or business analyst from Company A. Where the requirements are technically complex key developers, and in the case of Company A, the Product Manager will also get involved to ensure a common understanding is reached between all of the stakeholders in the requirements. It should be noted that whenever new functionality is to be implemented for Product A1 or Product A2 the client requesting the functionality is used to validate that it is correctly understood and when implemented, that it functions work as required. This ensures that the functionality is meeting the real market need, and not what Company A perceives as the market need.\n\nWhen a software product has a small client base it is easier to keep the product in line with individual clients’ requirements. The client base of Product A2 is both measured in the tens, while the client base of Product A1 is a few hundred. It is much more feasible to create client specific versions of Product A2 with the intension to roll this functionality back into the core product at a later\ndate as the number of customer specific versions of the software can be kept relatively low. This is reflected through the approaches to product development for the three products; RE for Product A1 follows an implementation project lifecycle, whereas Product A2 follow a product release plan except where a client has specific needs that must be met in the short term.\n\nWhere development is implementation project driven the requirements selection and release planning are largely defined by the client and will usually be very similar as the client requires the software to meet their needs. However, where software is developed as a product and includes the requirements of many customers the requirements selection and release planning are more easily separated. Dependant on the situation of the Product Manager for Products A1 and A2, issues like time to market are more critical when releasing a product not for a specific customer and it may be desirable to release a version of software that does not fulfil all the requirements with the intension to follow a release with updates. Failing to meet all requirements is unlikely to affect all customers; there are more market opportunities to be considered in this approach.\n\nDeveloping a software product to individual clients’ requirements is beneficial in the early stages as it facilitates the products growth in line with the needs of the client base and the general market. All features that are developed are requirements of the clients, and nothing is developed that is not a requirement of a client. This practice minimises the time to market with a fully featured product, bringing forward revenue generation. The product manager of Product Manager for Product A1 and A2 noted:\n\nIt gives us more credibility if we release the product soon; it gives it more functionality, better saleable product.\n\nHowever, when a company only develops functionality requested, they risk losing competitive advantage where other marketing offerings contain features that have not been requested, but are sufficient to win a contract. In both Products A1 and A2, release planning was very focused towards meeting customer objectives. Customer specific versions of the software acted as a testing ground for requirements and are considered to represent real needs of the market. Selective and controlled rolling of these requirements into the software product core allowed the most suitable requirements to be released to a market that is better understood. The processes followed for both products A1 and A2 involved bringing the success critical stakeholders together so that a common understanding of requirements could be found. The understanding gained then acted as a base for further analysis. The product manager was then responsible\nfor taking all of these perspectives and information on board in making the final decision as to what should be implemented.\n\nWe observed the similar approach to product development with Company B in Germany, who also changed their market driven approach to customer specific development. On the other hand, Company C, which was producing to a larger market (4600 customers across 60 countries), paid more attention to market requirements and their focus on decision criteria in requirements selection was primarily on product perspective, which was different from Companies A and B.\n\n**Product Maturity**\n\nIn two products that we studied at Company A, Product A2 was much younger than Product A1 i.e. Product A1 had been evolving over the past 10 years, whereas Product A2 was much newer, at two years, and it was still trying to gain credibility within the market place. This can be seen through the most important criteria representing this stakeholder group, for Product A1 these were (3) the stakeholders’ prioritization of the requirement and (2) the party responsible for issuing the requirement, while for Product A2 these were (4) whether the function has been promised or sold and (1) the status of competitors with respect to the requirement. Similarly (8) the resources and competencies of development personnel were more important for Product A2 than Product A1. As Product A1 was more mature, greater expertise existed within the company to support this product. However, Product A2 took the company through “unknown waters”. This is inline with the research that says a companies strategy and product management will change with market demands [75].\n\nDevelopment cost-benefit (7) was also a bigger issue for Product A2 as a lot of money has been spent in its early development and management was more cautious about revenue prospects, whereas Product A1 had become highly profitable for Company A. Looking at the optimal application of criteria, the product manager felt that the (7) development cost-benefit for Product A1, was perceived as undervalued due to the time and resources being put into other projects. There was a perception within the organization that the highly profitable Product A1 would lose competitive advantage while resources were focused elsewhere. However, the PM also conceded that there was a greater desire to build functionality with less concern over the revenue it would generate.\n\nThe increase in importance of (9) the impact a criterion has on the delivery date for both Product A1 and Product A2 can be explained with reference to how it helps to create a positive market perception when the company is first\n2.5 Discussion of Results\n\n...to bring new functionality to the market place. The massive decrease in the importance of (4) the functionality being promised or sold can be explained with reference to the fact that Company A would like to start taking a more structured approach to bringing new functionality into the market place. Rather than developing client specific versions of the software, the company would like to see more controlled release planning, which implements functionality and releases it to the general market.\n\n2.5.2 Values Influencing Requirement Selection\n\nDecision Criteria in Requirements Selection\n\nThe in depth analysis of two products from Company A has provided noteworthy results. Most people were unable to express how value was created through requirements selection and prioritization in their company; however working with customers was seen as the most effective way to make product valuable. The decision criteria and release planning were affected by several factors e.g. the product maturity, customer importance, the size of the customer-base, the services that were provided to customers etc.\n\n2.5.3 Perspectives Influencing Requirement Selection\n\nStakeholder Influence in Requirements Selection\n\nThe results of the second research question, based on the data collected from three companies, further highlighted the results of the first research question. The business perspective was the most critical group in creating software product value for Company A and B where the product development involved both market-driven and customer specific approaches. As for Company C, the most influential perspective was the product perspective. Although the ranking in decision criteria changed between the products as well as the companies, the overall results clearly pointed out the influence of business perspective in requirements selection, i.e. the first criterion in ranking always related to the business perspective. There was no major disparity between product and project perspectives for Company A and B. The results showed that practitioners were quite aware of the fact that the requirements selection had to be aligned with business strategies which drive the value creation for their companies. Overall, the results showed that there was no significant differences between what practitioners were applying today and how they would like to see it in future in relation to requirements selection. In both companies A and B, the business\nperspective came out as the most influential perspective overall (today and future). However, there was a slight push down to the business perspective and push up in both project and product perspectives in future criteria selection. On the other hand, the product perspective was the most influential perspective in requirements selection for Company C (today and future), however, there was a slight push up for project perspective in future criteria selection. Furthermore, in future criteria selection, the product and project perspectives were more evenly distributed. This indicates that software practitioners accept the importance of the business perspective in requirement selection; however, in future, they would like to see the product perspective receiving more attention during requirements selection.\n\nCustomer importance\n\nJust as different stakeholder groups exert different amounts of pressure on the selection and prioritization of requirements, not all customers are equal in the level of influence. Company B identified that some customers are strategically more important than others to the software development company. The factors identified that determine whether a customer is strategically important include the prestige, credibility and marketability of having a particular high profile customer; the ability for larger clients to pay higher premiums, and in the case of multinationals, there is a potential for repeat work in many countries with similar requirements. For these reasons, the software development company is more likely to accommodate changes to the base system as part of the contract for strategically important customers.\n\nFor small customers [Company B] won’t make a lot of customizations:\n\n... we will ... force them down a track that is easier for our developers to do. But if they are a really big customer, either from the respect of paying a lot of money or basically they are important to the company, we will go in there and gather all the requirements come back and work out what it is we can and cannot do and then make a decision based on man-hours and the improvement to the product if it is worth development for that customers.\n\n2.6 Validity Threats\n\nThe following presents the validity threats to the findings, considering four kinds of validity, including conclusion validity, internal validity, construct validity, and\n2.6 Validity Threats\n\nexternal validity.\n\nConclusion validity: Threats to conclusion validity, are lack of statistical calculations or misuse of statistical assumptions that leads to incorrect conclusions made by the researcher. There may be a risk that conclusions from this study are inaccurate due to low statistical power. We did not use statistical calculations to find patterns in the result. Instead, deductive logic was used because of limited data points. To receive high reliable measures and to avoid poor question and poor layout several pilot studies were conducted. The results of this study must be interpreted with caution as the three companies that we investigated are not a representative sample of the software development industry. The small number of people involved in the decision making process for the inclusion of a requirement in a software system has limited the number of possible responses for each company.\n\nInternal validity: The research instrument in this study was developed with a close reference to literature. In addition, we conducted pilot studies to ensure that the questions relate to the stated objectives of this study. The participants in this study were experienced software practitioners. Two of the participants were involved in both the interview and questionnaire for both Product A1 and Product A2 affecting the internal validity of the results. Each of the products has the same Product Manager and Development Manager. It is possible that these participants applied the same values to product development in general. However, comparing the the Product Manager’s responses for the two products showed that more than half of the points were awarded differently both for the criteria today and the optimal application of the criteria, 54% and 59% respectively. The differences for the Development Manager were not as high, with 27% and 30% of the points being awarded respectively. Another potential threat to internal validity is related to the questionnaire. It is always difficult to know whether the respondents have understood the questions as intended and in a similar fashion to one another. This threat was partially address during the third stage of this study, where the results were presented to the product manager in an unstructured interview with the researcher for confirmation.\n\nConstruct validity: We asked participants to evaluate the need for further criteria, however it is easier for the participants to agree with the set of criteria identified by the researchers than disagree. It was easier for the participants to agree with the set of criteria identified by the researchers in advance than disagree, because they knew that the criteria on the list indicated that the researcher considered them as relevant. In addition, it was easier to stick to the stated criteria than proposing new criteria. This is partially taken care of by allowing the participants to assign a relative importance of zero or propose new\ncriteria where they see fit. However, the effect of examining the criteria at a different level of abstraction has not been considered for this study.\n\n**External Validity:** This threat can cause incorrect conclusions to be drawn from empirical study. There are two threats to external validity that are relevant for this study: interaction of selection and treatment, and interaction of history and treatment [111]. Participants were selected from different geographic locations in Australia and Germany. Both male and female participants were represented. The small sample size was another threat to the external validity of this study. The sample size may affect the conclusions; hence they may not be generalized for the whole SE industry population.\n\n### 2.7 Conclusions and Future Study\n\nThis article addresses value based approach in requirements engineering when creating product value through requirements selection for a software release. It particularly addresses the issues related to (a) value-based approach in release planning, (b) values influencing requirements selection and (c) stakeholders’ perspectives influencing requirements selection.\n\nInterviews at an Australian software development company showed that there is no silver bullet for a value-based approach to release planning. While the interviewees raised the perspectives of each of the key key stakeholder groups involved in the development process, it appeared that the value propositions that influenced the selection and prioritisation of requirements were more intrinsic than part of an explicitly planned process.\n\nWith respect to the values that influencing requirements selection, VBRE is a new area of study and is still in the theory building stage. Questionnaires at three software companies operating in either Australia or Germany have shown that some criteria are more important than others in the selection of requirements to include in a specific project or release. Moreover, this study has shown that the business perspectives are more influential than the project and product perspectives in general; however this may change due to product and project requirements. The following aspects influenced the requirements selections.\n\n- Maturity of the product\n- Requirements source, customer type (big or small – importance: potential for future business, can change a premium on larger companies), contract type\n• Size of the customer base – this aspect influences the process more than the result\n\nFurthermore, our findings showed that requirements selection is tightly linked to the business situation and release planning. The requirements selection process for the product was affected by the release data. In other words, in the event that a release is going to be very late, the requirements selection would be different and client business situation would be used to select what they would prefer to release. These findings were particularly true for Company A and Company B where the requirements were defined by specific customers. On the other hand for Company C, where the product is developed based on a wider set of market requirements with many more customers, it was a different story. The selection and prioritization is made by a committee comprised of employees of the software development team representing the views of customers. As the customer base is so large no individual client has the level of influence or control that can be seen in Company A and Company B. The choice is made to provide “the greatest bang for the buck,” to maximize the value for the customer base at large.\n\nWith respect to stakeholders’ perspectives influencing requirements selection, the following can be said about alignment of product, project and business perspectives:\n\n• It is interesting to see how these perspectives are represented in the entire process. For example, at Company C the business perspective is represented by the developers through their interaction with users in support forums. All developers rotate between support and coding. At companies A and B the developers are more distant from the requirements and these are generally expressed by the project manager (albeit through the product manager).\n\n• With Company C’s approach they like to think of the customers’ problem as the developers’ problem – because the developer will have to deal with it – so is more likely to correct it, add the feature, etc. Whereas you do not get this opportunity with the approach by the other companies.\n\n• Because of the way the customers’ requirements are presented, they have always been filtered by at least one other stakeholder group’s perspective.\n\nThese conclusions have some implications. First, as the creation of software product value through requirements selection is not very well understood, it\ncannot be managed in the most effective way. Greater insight into how value is created through release planning would allow this process to be more effectively managed. Secondly the management of software product value is dependant on the context in which the product exists. Factors such as: the maturity of the product, the marketplace in which it exists and the development tools and methods available influence the criteria that decide whether a requirement is included in a specific project or release. A young product will have a greater need to recoup initial development costs, a more competitive marketplace requires more adaptive development, and standard software tools and techniques speed up development and reduce development resource issues. However, further research is required to determine what aspects of a software product’s context influence the decision-making criteria and how these contextual elements influence the priority given to the different decision-making criteria. These issues pose great challenges when it comes to creating software product value through requirements selection.\nChapter 3\n\nBalancing Software Product Qualities\n\nAbstract\n\nSoftware qualities are in many cases tacit and hard to measure. Thus, there is a potential risk that they get lower priority than deadlines, cost and functionality. Yet software qualities impact customers, profits and even developer efficiency. This chapter presents a method to evaluate the priority of software qualities in an industrial context. The method is applied in an exploratory case study, where the ISO 9126 model for software quality is combined with Theory-W to create a process for evaluating the alignment between success-critical stakeholder groups in the area of software product quality. The results of the case study using this tool is then presented and discussed. It is shown that the method provides valuable information about software qualities.\n\n3.1 Introduction\n\nSoftware quality forms an important part of a product offering. But which qualities that are valuable is a very context dependant problem, changing with both the product and perspective you bring. Maximising the value of a product’s quality involves reconciling any conflicts between the key stakeholder groups — including customer, business and technical perspectives — so that these groups\ncan work together effectively towards a common goal. However, there is always a risk that qualities get a lower priority than delivery date, cost and functionality. This risk comes from the fact that the qualities are most difficult to measure in relation to delivery date, cost and functionality. The balance between delivery time, cost, scope and quality is discussed as part of XP [13].\n\nThis obvious risk forms the starting point of the research presented in this chapter. The main objective is to understand the priorities, responsibilities and management of software qualities in an industrial context. This chapter makes three main contributions. First of all, a method for analysing qualities in an industrial organisation is presented. Second, the method is applied and an industrial study exploring the alignment of priorities given to various software qualities between the groups involved in the software development process is presented. The third contribution is related to exploring the ambiguities present in the management of a software product.\n\nAsking what defines an adequate level of quality in a software system is a highly context dependent question [71]. Software quality affects more than just the user of the software and each group involved with a software product brings its own perspective on quality [71]. Customers, developers, product managers, project managers and testers can all value the same qualities of the same product in different ways. Looking at the software supporting a social networking site, one could reasonably expect that customers would value usability higher than the other groups, developers value maintainability due to the dynamic nature of the product and management values efficiency due to the scale and resources required of the application. Ultimately these value stances need to be reconciled.\n\nThe qualities each group values will also change depending on the product. Functionality is becoming increasingly important for mobile phones, reliability is more important in financial and medical domains, as is portability for web-based applications.\n\nUnderstanding both (a) the groups impacted by a software product and (b) the value provided to each group by the various software product qualities is useful information for companies developing software. As any development project will have time, resource and financial constraints, this information will allow the development effort to be focused in the most critical areas.\n\nThe importance of understanding who is responsible for setting quality goals and making sure they are achieved has also been recognised [71]. The management structures supporting features are generally more clearly defined than those supporting qualities. This creates a potential for key qualities to be overlooked, with no one taking responsibility or perceived responsibility.\n\nThe remainder of this chapter is outlined as follows. Section 3.2 presents\nsome background in terms of related work, objectives and the context of the\ncase study. In Section 3.3, the method for studying qualities with respect to\npriorities and management in an industrial context is presented. The results\nof the case study are presented in Section 3.4. In Section 3.5, the applicability\nof the method and the findings from the case study are discussed. Finally,\nSection 3.6 presents the conclusions.\n\n3.2 Background\n\nIn the software development process there are four variables that need to be\ncontrolled — cost, time, quality and scope [13]. Further there is an axiom that\nstates that external forces can set at most three of these variables with the\nremainder being set by the development team.\n\nTime, cost and scope can all operate within acceptable ranges, but quality is\na terrible control variable as it only allows very short term gains at a very high\ncost to all parties involved [13]. That said, quality does not need to be perfect\n[113] but the development process is much simpler when the success-critical\nstakeholders agree on what action should be taken [26].\n\nThis section examines different perspectives of quality, processes to manage\nquality in a software engineering context, and the research objectives.\n\n3.2.1 Definitions of Quality\n\nThe definitions of quality are both many and conflicting, even when only ex-\namining the topic in relation to software engineering. Looking across different\ndisciplines it is possible to see a complex multifaceted concept of quality that\ncan be described from five different perspectives [45]:\n\n- The transcendental perspective defines quality as something that can be\n recognized but not defined in advance.\n\n- The user perspective defines quality as fit for purpose.\n\n- The manufacturing perspective defines quality as conformance to specifi-\n cation.\n\n- The product view defines quality in terms of essential characteristics of the\n product in question.\n• The value-based view defines quality in terms of the amount a customer is willing to pay for it.\n\nBy far the most common perspectives taken in the software development industry are that of the user and manufacturer. [71, 58]. However, there is an increasing body of literature that recognises the importance of taking advantage of all of the perspectives involved in software development. Theory-W states that success requires all of the success-critical stakeholders to compromise [26], while requirement specification reading techniques that take advantage of different perspectives have been found to catch 35% more defects than non-directed alternatives [12, 24], and value-based software engineering now recognises the value brought by different perspectives into the development process [71].\n\nSoftware quality is not only defined by the relevant perspectives, but also by the context in which it exists [71]. Just as each line of cars has a target market, software quality must be planned to allow a development company to meet its business objectives. Less than perfect software quality can in fact be ideal [113], but deciding how much less than perfect can only be decided in a given business context [71].\n\n3.2.2 Quality Models for Software Development\n\nNumerous models have been developed to support software quality. Examples of these models include McCall’s quality model, Boehm’s quality model, Dromey’s quality model and ISO 9126.\n\nMcCall’s quality model is the first of the modern software product quality models [71]. The model uses a hierarchy of factors, criteria and metrics to address internal and external product quality. Eleven factors define an external or user perspective of quality. Each of these factors is linked to between two and five of 23 criteria that define an internal or development perspective of quality. Further metrics are associated with the factors allowing quality to be measured and managed.\n\nMcCall’s quality model was followed by Boehm’s quality model [71]. Like McCall’s model, Boehm’s model presents product quality in a hierarchy with three high level characteristics linked to seven intermediate factors, which are in turn linked to 15 primitive characteristics. Boehm’s model has a wider scope than that of McCall’s, with more emphasis on the cost-effectiveness of maintenance [83].\n\nMore recently work has been done to create an international standard for software product quality measurement — ISO 9126 [60]. This standard is again\norganised in a hierarchy with six characteristics at the top level and 20 sub-characteristics with indicators used to measure the sub-characteristics. In addition to aspects of internal and external quality, covered by McCall and Boehm’s models, ISO 9126 includes quality characteristics of functionality [83]. Internal, external, and functional qualities are also mixed at all levels of the hierarchy. However, ISO 9126 does not clearly state how quality should be measured [71].\n\nNone of these three models present a rationale for the selection of characteristics to be included in the quality model and it is not possible to tell if a model presents a complete or consistent definition of quality [71]. Further the placement of items appears arbitrary in ISO 9126, for example, with no justification as to why Interoperability is not related to Portability.\n\nDromey presents a different type of model that attempts to address some of the issues presented and support developers to build product quality [40]. Dromey believes that it is impossible to build high-level quality attributes like reliability or maintainability into a product, but developers must instead build properties that manifest in achieving these goals. The distinction this model makes is important, as using the model will verify that the model allows the quality required to be achieved [71]. Before Dromey’s model can be successfully applied, the various groups involved in the development of a software product must agree on what quality attributes should be achieved and to what level. This process can be supported using other models.\n\n### 3.2.3 Merging Perspectives on Software Quality\n\nSoftware product quality can easily become an area of problems and conflict, as each stakeholder group has its own perspective on what is important. A number of methods can be applied to help reconcile this situation and select the best way forward. These methods include expert judgement, the NFR Framework, Quality Functional Deployment and Theory-W.\n\nExpert judgement involves one or more experienced professionals using their experiences and knowledge to make a decision on an issue. The decisions are not necessarily supported by modelling or numerical assessment.\n\nThe NFR Framework uses diagrams to relate non-functional requirement goals with different decisions that can be made in the design and operation of a system that affect it positively or negatively, allowing trade-offs to be identified and made [36]. While this method makes the results of a choice to be made more explicit, it requires a set of common priorities to be identified to allow effective decisions to be made.\n\nQuality function deployment (QFD) considers the priority of customer and\ntechnical requirements in achieving the goals of the system to help prioritize the requirements [54]. However, the other perspectives involved in the development of the software product are not considered.\n\nValue-based software engineering (VBSE) recognises the problems created by conflicting perspectives in the software development process [25]. Central to resolving conflict in VBSE is Theory-W, which requires [26]:\n\n1. Success-critical stakeholder groups to be identified;\n2. The requirements of these groups to be elicited;\n3. Negotiation between the groups to create a win-win situation; and\n4. A control process to support success-critical stakeholder win-win realisation and adaption to a changing environment.\n\nThe key advantage of Theory-W is that it explicitly brings all of the parties on whom success depends together to understand each other’s needs, compromise and agree. But in order to be successful Theory-W must be managed to ensure the plans are achieved and any deviations from the plans are corrected [26]. Management requires an understanding of why the goals are being pursued, what is the required result, who is responsible for the result, how the result will be achieved and at what cost the result can be achieved. The answer to these questions will be specific to the context in which they are answered.\n\n3.2.4 Research Objectives\n\nThe objective of the research presented in this chapter is to create and validate a method capable of determining the level of alignment between the internal success-critical stakeholder groups. The method should be able to:\n\n- Identify the degree to which the groups are aligned in how they perceive operations today with respect to quality, and\n- Elicit how each group thinks the organisation should be operating today with respect to quality — highlighting differences of opinion and potential improvement areas. This is referred to as the ideal situation.\n\nThis method should be evaluated in an industrial case, answering the research questions presented in this section.\n3.3 Methodology\n\n**RQ1:** Is the method proposed in this chapter capable of identifying the degree to which the internal success-critical stakeholder groups are aligned in how they perceive the priorities on software product quality today?\n\nHowever, alignment itself only ensures that the success-critical stakeholder groups have a common understanding of what is happening today, it does not mean the groups agree this is what should be happening today. As each group represents a different, and potentially conflicting, perspective on software product quality it is important to discover what each of these groups perceive should be happening the situation today, in a hypothesised ideal situation. This is addressed by the second research question:\n\n**RQ2:** Is the method proposed in this chapter capable of identifying what the different internal success-critical stakeholder groups perceive as the ideal set of priorities on software product qualities in the situation today? And to what degree are the groups aligned?\n\nFurther, the method should be able to identify how united the internal success-critical stakeholder groups are in whom they perceive as managing the different software product qualities.\n\n**RQ3:** Is the method proposed in this chapter capable of identifying the level of consensus between the success-critical stakeholder groups as to who is responsible for managing software product quality attributes? And what types of ambiguity exist, if any?\n\n3.3 Methodology\n\nTo address the research questions a method using Theory-W as a starting point is developed. By exploiting the early phases of Theory-W it is possible to determine the level of alignment between the internal success-critical stakeholder groups – addressing the first two research questions. This involves identifying the internal success-critical stakeholder groups and eliciting their value propositions with respect to quality.\n\nFurther, by collecting information on who each of the internal success-critical stakeholder groups identify as responsible for and managing each quality, it is possible to analyse the level of consensus between these groups — addressing RQ3.\nThe method should support the continued application of Theory-W, to negotiate between the success-critical stakeholders to achieve a better situation and realise this goal through clearer management.\n\n### 3.3.1 Quality Model\n\nThe literature on software product quality recognises that quality depends both on the perspective of the observer and the actual software product in question. As such, using any model as it appears in the literature risks not adequately defining quality in the context being studied. To use one of the quality models briefly introduced in Section 3.2 is a good starting point, but company specific needs have to be taken into account, as illustrated in the case study in Section 3.4.\n\n### 3.3.2 Questionnaire\n\nThis method proposes the cumulative voting (CV) [78] technique to elicit both (a) how important each quality is today, and (b) how important each quality should be today in a perceived ideal situation – answering the first two research questions. CV asks participants to spend 1000 points across all of the qualities previously identified, to represent their relative influence. For example, if a participant thought testability does not matter at all today and security was twice as important as scalability they might award these qualities zero, 200 and 100 respectively, leaving 700 points to be spent on the remaining qualities.\n\nThe third research question is addressed by asking the participants to consider each quality individually and answer:\n\n- The degree to which they thought the quality was being managed today, with the answer presented on a five point Likert scale;\n\n- The group perceived as ultimately responsible for managing the quality; and\n\n- The group perceived as managing the quality on a day-to-day basis.\n\nAdditionally, participants are given the opportunity to make comments about any quality, or general comments.\n3.3 Methodology\n\n3.3.3 Analysis\n\nThe analysis techniques used to address the research questions are presented in the following subsections.\n\nImportance of Qualities\n\nCV allows participants’ responses to be grouped logically for analysis — for this method into the success-critical stakeholder groups. The results of each participant in the group can be averaged for each quality, ultimately producing a list that shows each quality and the averaged notion of its importance.\n\nFrom here it is possible to rank the qualities from most to least influential for each success-critical stakeholder group. The degree to which the groups are aligned can then be calculated pairwise using a Spearman rank correlation matrix.\n\nFramework for Management Analysis\n\nParticipants are asked to identify the group or groups within the organisation ultimately responsible for and managing each of the software product qualities in order to address RQ3. A group is defined as managing a quality if they are looking after the implementation of the quality on a day-to-day basis and are likely to serve as the first point of contact if an issue arose. To be defined ultimately responsible a group should be heavily involved in setting the direction of and strategy for that quality.\n\nWhile thresholds are needed to structure the results, these are not defined as part of the methodology as purpose and requirements may change depending on the context of the case studied.\n\nAmbiguity in leadership can be presented in four ways. The results are analysed using the framework described in this section.\n\nBlank responses: A blank response indicates that a participant does not know who is in one of the leadership roles for a quality.\n\nInsufficient votes: It is also possible that no group or groups will be identified using the defined thresholds.\n\nMultiple groups: While participants are able to select multiple groups as responsible for or managing each quality, it is possible that multiple groups are identified where the participants disagree over which group is in either leadership role for a quality.\nPushing/Pulling: It is important to understand whether the group or groups in a leadership role have taken on that role or think that it belongs to another group. This is a two-step process:\n\n1. Look at the responses from all participants to determine which group or groups are taking on a leadership role for a given quality as defined previously.\n\n2. Look at the responses of each of the identified groups to see which group these participants identified as taking on the same leadership role. If the group selects itself, it agrees with the majority and pulls this responsibility to itself. Alternatively, the identified group could push the responsibility onto another group.\n\nFor example, the results could indicate that project management is ultimately responsible for one quality. If we look at the project managers responses there are two possibilities; (a) if a majority of the project managers identify their own role as ultimately responsible then the group pulls responsibility onto themselves, (b) alternatively it is possible that a majority will identify another group — pushing responsibility to that group.\n\nPushing and pulling of roles can be broken down into several subgroups:\n\n1. Pull: Where all participants identify one or more groups as responsible and each of the identified groups also identifies itself as responsible. Figure 3.1 shows an example where two groups — A and B — were identified as responsible, and each of these groups identifies itself as responsible. There are two types of pulling:\n\n (a) Single group: a single group is identified as responsible for or managing a quality, and the identified group agrees with this finding.\n\n (b) Multiple groups: multiple groups are identified by all participants as responsible for or managing a quality and each group identified itself as responsible or sharing the responsibility with the other identified groups. An example of this can be seen in Figure 3.1.\n\n2. Pull/Push: This situation is where multiple groups are identified as responsible for or managing a quality, with one or more of the identified groups identifying another group as responsible, and one or more groups identifying themselves as responsible. For example, given groups A, B\n3.3 Methodology\n\n3.3.1 Identified Groups\n\nIdentified Groups\n\nA\n\nB\n\nC\n\nFigure 3.1: Example of (1b) pulling by multiple identified groups\n\nand C it is possible that groups A and B are identified as responsible for scalability. Group B might identify itself as responsible for scalability — pulling the responsibility to themselves, while group A might also identify group B as responsible — thus pushing the responsibility onto another group.\n\n(a) Push to pullers: Where one or more of the identified groups nominates themselves as responsible and the remaining groups nominate the one or more of the groups as pulling responsibility. An example of this scenario can be seen in Figure 3.2.\n\n(b) Combination of 2a and 3a, 3b or 3c.\n\nIdentified Groups\n\nA\n\nB\n\nC\n\nFigure 3.2: Example of (2a) push to pullers within identified groups\n\n3. Push: Where each group identified as responsible for or managing a quality perceives another group taking on this role. For example, groups A, B and C identify groups A and B as responsible for security. Group A identifies group B as responsible for security, and group B identifies group A as responsible.\n\n(a) To group not identified: Where the group or groups identified by all the participants as responsible for or managing a quality perceive\nanother group or groups as responsible. An example of this scenario can be seen in Figure 3.3.\n\n(b) Push to pushers: Where each group identified as responsible for or managing a quality identifies another group that also pushes their identified responsibility.\n\n(c) Combination of 3a and 3b.\n\n\n\nFigure 3.3: Example of (3a) push to a group not identified\n\nThe most ideal situation is (1a), with a single group being identified and pulling that responsibility onto themselves as the responsibility is clearly defined. Second is (2a) the situation where multiple groups are identified, but between them they agree one group holding responsibility as the responsibility is clearly defined to those holding or perceived as holding it. Third is (1b) where multiple groups identify themselves as responsible, as responsibility is still being taken, but there is potential for conflicts with many groups. Finally situations involving only (3) pushing are the most dangerous as no group is taking responsibility.\n\nTo answer the research questions, this method can now be piloted and trialled. The results are presented in Section 3.4.\n\n### 3.4 Case Study\n\nThe case study was conducted during autumn 2007 for one product at Ericsson. Ericsson is a world leading company in telecommunication, providing a wide range of products and solutions. Products are developed and sold as generic solutions offered to an open market, although customized versions of the products are also developed.\n3.4 Case Study\n\n3.4.1 Success-Critical Stakeholder Groups\n\nHigh-level R&D management supported the authors to identify internal success-critical stakeholder groups for this case study. Participants in the case study represent:\n\n- *Strategic Product Management (SPM)* has the strategic product responsibility and decides the overall product development direction.\n\n- *Project Management (PM)* is responsible for planning and executing projects aligned with the priorities of the strategic product management.\n\n- *Tactical Product Management (TPM)* supports the strategic product management with expert knowledge of the systems and their architecture. It is also responsible for providing analysis of pre-project requirements in the form of feasibility, impact and technical dependencies.\n\n- *Development and Testing (R&D)* are responsible for the implementation, verification and validation of requirements.\n\nThe high-level management further recommended that the results of SPM and PM be combined when determining the priorities given to the software product qualities, the first research question. These groups work closely together; with SPM prioritising the development activities that PM is responsible for planning.\n\nA description of this case study was sent out to the managers of the identified success-critical stakeholder groups requesting volunteers from their teams to take part in the case study.\n\nIn total 44 potential participants were identified to take part in this case study, with 31 usable results being obtained. A breakdown of the participants can be seen in Table 3.1. Two of the participants identified felt they were not appropriate and identified other people in their team to replace themselves, two people declined to participate, one questionnaire result was lost in an Excel crash and nine people could not find time to complete the questionnaire.\n\nThe low response rate for Strategic Product Managers was anticipated, so extra participants for this role were selected to ensure a sufficient number of responses.\n\nThe questionnaire was conducted as a one-on-one structured interview, which each participant taking between 30 and 75 minutes. The interviews were conducted over a two-month period.\nTable 3.1: Study response rate\n\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Candidates</th>\n<th>Replacements</th>\n<th>Responses</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Strategic Product Management</td>\n<td>15</td>\n<td>1</td>\n<td>6</td>\n</tr>\n<tr>\n<td>Project Management</td>\n<td>6</td>\n<td>0</td>\n<td>4</td>\n</tr>\n<tr>\n<td>Tactical Product Management</td>\n<td>9</td>\n<td>0</td>\n<td>9</td>\n</tr>\n<tr>\n<td>Development and Testing</td>\n<td>14</td>\n<td>1</td>\n<td>12</td>\n</tr>\n<tr>\n<td><strong>Total</strong></td>\n<td><strong>44</strong></td>\n<td><strong>2</strong></td>\n<td><strong>31</strong></td>\n</tr>\n</tbody>\n</table>\n\n3.4.2 Software Product Qualities\n\nThe process of defining a model of software product qualities was a collaborative exercise involving the academic and industrial perspectives. The list of qualities was defined specifically for the product studied at Ericsson, thus maximising the relevance for this industrial partner and possibilities for using the results to support improvements within the company.\n\nHowever, just as some qualities can be more important than others, there are other aspects of the development process that compete with the implementation of software product quality. To understand the importance of software product quality it must be placed in the context of all aspects of software product development that are controlled. These are time, cost, quality and scope [13].\n\nThese four control variables have been complemented with ISO 9126, the international standard for software product quality, providing more detail on the components of quality and scope. The authors then wrote preliminary definitions for these terms.\n\nA workshop was held within Ericsson to review and refine the terms defining software product quality. The aim was to ensure the final list of terms and definitions would be complete, meaningful and useful to Ericsson. The model was split into three categories — the ISO 9126 qualities relating to functionality, the ISO 9126 qualities relating to system properties and project management to cover time and cost. Moreover, security was moved from functionality to system properties. Two new qualities were identified and added to system properties; these are scalability and performance management/statistics. Finally, five of the quality terms were complemented with alternative names used in Ericsson.\n\nThe terms and definitions used in the case study presented in this chapter are reprinted in the appendix.\n3.4 Case Study\n\n3.4.3 Pilot Study\n\nA questionnaire was developed using the methodology described in Section 3.3 and piloted. The participants in the pilot had trouble making comparisons between qualities related to features, system properties and aspects of project management. An example of such a comparison could include accuracy of features, resource behaviour of the system and development cost. In order to address this issue the authors modified the questionnaire to use a hierarchical cumulative voting (HCV) method as described by Berander and Jönsson [16]. This effectively splits the questionnaire up into four independent CV exercises; one parent list that includes the three category terms — features, system properties and project management — and one list for each of the categories, each containing the relevant qualities. A pilot of the new questionnaire found that the participants’ capacity to respond was much improved. In order to conduct the subsequent analysis each participant’s response needs to be changed from HCV to CV, converting the four cumulating voting lists into one that covers all of the qualities.\n\nRemember that one of the four lists includes the categories features, system properties and project management, while the remaining lists each detail the qualities that make up one of the categories. This allows the number of points awarded to each quality to be multiplied with the category from which it came [16]. It is also necessary to multiply each of these results by the number of qualities from the same category as the resultant value. Finally the set of number for each quality can be scaled so that the sum is 1000.\n\nFor example, if 200 points are awarded to project management and 600 points are awarded to time, then category * quality * numberofqualities = 200 * 600 * 2 = 240,000. The scaling of this result then depends on the other values, but if the other values were to sum to 4,800,000 then the number would be scaled to result/totalsum * 1000 = 240,000/4,800,000 * 1000 = 50.\n\nIt is necessary to multiply each value by the number of qualities in the same category to ensure that qualities with many categories are not underrepresented and that categories with few qualities are not overrepresented [16].\n\nThe individual responses can now be grouped and averaged, allowing ranks to be determined and the Spearman rank correlation can then be calculated.\n\nThe final version of the questionnaire is available online [10].\n3.4.4 Software Product Quality Priorities\n\nThe first objective of this case study is to determine the degree to which the key stakeholders are aligned regarding how they see software product quality today. The results show that the groups are very aligned, with Spearman’s rank correlation values between 0.80 and 0.90 indicating each group ranked the qualities in a very similar order. The full results are presented in Table 3.2.\n\nTable 3.2: Correlation matrix showing the degree to which the groups are aligned in how they perceive the priorities today\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>SPM & PM</th>\n<th>TPM</th>\n<th>R&D</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SPM & PM</td>\n<td>1.00</td>\n<td>0.80</td>\n<td>0.90</td>\n</tr>\n<tr>\n<td>TPM</td>\n<td>1.00</td>\n<td>0.86</td>\n<td></td>\n</tr>\n<tr>\n<td>R&D</td>\n<td></td>\n<td>1.00</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nSimilarly the key stakeholder groups are aligned in how they ranked the software qualities should be today, in their perceived ideal situation. The results in Table 3.3 show correlation values between 0.65 and 0.74 between the groups.\n\nTable 3.3: Correlation matrix showing the degree to which the groups are aligned in how they perceive the priorities should be today (ideal)\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>SPM & PM</th>\n<th>TPM</th>\n<th>R&D</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SPM & PM</td>\n<td>1.00</td>\n<td>0.74</td>\n<td>0.71</td>\n</tr>\n<tr>\n<td>TPM</td>\n<td>1.00</td>\n<td>0.65</td>\n<td></td>\n</tr>\n<tr>\n<td>R&D</td>\n<td></td>\n<td>1.00</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nThe similarities between the perceived situation today and the perceived ideal situation were striking. Looking at all responses the correlation between the two situations is 0.82. However, each group individually saw the need for more changes. The results in Table 3.4 show, for example, a correlation of 0.62 comparing what R&D perceived as the priorities today against what they thought the priorities should ideally be today.\n\nWhile there was variation between participants of the same perspective, there was no individual that stood out as being consistently different in their results to the other members of their group.\nTable 3.4: Correlation between perceived situation today and perceived ideal situation\n\n<table>\n<thead>\n<tr>\n<th>Groups</th>\n<th>Correlation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>All groups</td>\n<td>0.82</td>\n</tr>\n<tr>\n<td>SPM & PM</td>\n<td>0.72</td>\n</tr>\n<tr>\n<td>TPM</td>\n<td>0.77</td>\n</tr>\n<tr>\n<td>R&D</td>\n<td>0.62</td>\n</tr>\n</tbody>\n</table>\n\nLooking at the underlying data it is possible to further understand the differences and similarities between the groups. The remainder of this section highlights key aspects of similarity and difference.\n\nThe qualities studied have been grouped into three categories — features, project management and system properties. All of the groups today ranked these groupings in the same order, with features as the most important category, followed by project management and finally system properties. Interestingly all groups would like to see system properties overtake project management in their perception of the ideal situation. This helps explain the high correlation values attained.\n\nHowever, looking at the individual qualities it is possible to explain why the collective results from all participants shows less need for change than the result of any of the groups individually. While confidentiality does not allow the ranked qualities to be published in this chapter, some groups are more affected by some of the qualities than other groups; so they perceive these qualities as more important, while the other groups perceive the same quality as less important. For example, Time Behaviour is ranked seventh today, with all groups placing it in the seventh or eighth position today. In the perceived ideal situation the overall rank is only increased one place to sixth, but the same criterion is ranked second most important by R&D, sixth most important by TPM and tenth most important by SPM & PM. This situation acts to reduce the correlation coefficients for the individual groups, but still keeps it high when examining all results together.\n\nThere was a high level of agreement in the ranks given to qualities relating to features and project management both today and in the ideal situation. The area of greatest contention between the groups concerns qualities relating to system properties. SPM differs the most when examining the results of the three groups. The results highlight which qualities the groups agree\n86 Balancing Software Product Qualities\n\non as important — such as Scaleability, Time Behaviour, Robustness/Stability, Configurability/Product Customisability/Adaptability and Resource Behaviour — and which qualities for which there are differing priorities — Recoverability, Operability, Performance Management/Statistics, Upgradeability/Replaceability, Analysability, Testability, Containment/ISP/Fault Tolerance and Security.\n\n3.4.5 Responsibility and Management\n\nWhile the main aim of the third research question is to determine ambiguity in responsibility and management of the software qualities, it was also considered important to ask participants the degree to which each area was being managed. For example, it is possible that an important quality has a clear management line, but the managers are not sufficiently with respect to the quality. Respondents answered on a Likert scale from 1 (Not managed) to 5 (Clearly and explicitly managed).\n\nIn general, the more important a quality is today, the greater the degree to which it is managed. This can be seen with the Spearman rank correlation of 0.81 between the importance of a quality today and the degree to which it is being managed today. The results can also be seen in Figure 3.4, showing the criteria in order from most important today at the left to least important today at the right. The line of best fit shows that the less important qualities are less managed. It should also be noted that the correlation between the perceived ideal situation and the degree to which the qualities are being managed today is 0.56.\n\nAmbiguity in who is ultimately responsible for or managing a quality can be presented in many different ways, as discussed in Section 3.3.3. The remainder of this section discusses these ambiguities with respect to the results collected.\n\nFor a group to be identified in one of these two leadership roles in this case study it must receive at least half of the non-blank responses. For two groups to be identified, each must receive more than a third of the non-blank responses; and for three groups to be identified each group must receive more than a quarter of the non-blank responses. This chapter highlights the qualities where one third or more of the responses are blank.\n\nBlank responses: There were four qualities with a significant number of blank responses as to which group had a leadership role. These can be seen in Table 3.5, with the qualities showing a significant number of blank responses marked with a tick. For example we can see maturity has a significant number of blank responses for both types of leadership. It is interesting to note that with the exception of maturity, all of the ambiguity presented through blank\nresponses concerned the group that was ultimately responsible for a quality. It should also be noted that each of these qualities comes from the category of system properties. These qualities are also ranked quite low, thus being relatively less important.\n\nTable 3.5: Qualities with a significant number of blank responses\n\n<table>\n<thead>\n<tr>\n<th>Quality (Rank: Today/Ideal)</th>\n<th>Responsible</th>\n<th>Managing</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Maturity (19/23)</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Understandability (21/19)</td>\n<td>X</td>\n<td></td>\n</tr>\n<tr>\n<td>Resource Behaviour (14/12)</td>\n<td>X</td>\n<td></td>\n</tr>\n<tr>\n<td>Analysability (24/22)</td>\n<td>X</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n*Insufficient votes:* Similarly four qualities received insufficient votes to pass the thresholds. The qualities are listed in Table 3.6, which show the number of votes received by the most selected group where the threshold was not met. For example one group received 11 of the 23 non-blank responses for the management of Understandability. Again almost all ambiguity exists in who is ultimately responsible for the qualities. However, it should be noted that\nthe result is only slightly below the threshold for one group to be identified in each case. The qualities with insufficient votes represent the categories system properties and project management.\n\nTable 3.6: Qualities with insufficient votes\n\n<table>\n<thead>\n<tr>\n<th>Quality (Rank: Today/Ideal)</th>\n<th>Responsible</th>\n<th>Managing</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Maturity (19/23)</td>\n<td>11/23</td>\n<td></td>\n</tr>\n<tr>\n<td>Understandability (21/19)</td>\n<td>11/23</td>\n<td></td>\n</tr>\n<tr>\n<td>Resource Behaviour (14/12)</td>\n<td>12/27</td>\n<td></td>\n</tr>\n<tr>\n<td>Analysability(24/22)</td>\n<td>10/27</td>\n<td>13/28</td>\n</tr>\n</tbody>\n</table>\n\nPushing: Ambiguity is also presented in how a group identified as having a leadership role for a quality perceives their role with respect to this task. In the case study there is a strong tendency for the identified groups to pull responsibility to themselves, even when multiple groups were identified.\n\nFrom Table 3.7 it is possible to see that the most common scenario in describing the ultimate responsibility and management of a software product quality is (1a) for a single group to be identified and for that group to pull this responsibility to themselves. For example, the SPMs were identified as ultimately responsible for Configurability/Product Customisability/Adaptability and the SPMs identified themselves as ultimately responsible for this same quality. Further R&D was identified as managing this quality and also pulled this responsibility onto themselves.\n\nTable 3.7: Pushing and pulling of ultimate responsibility and management\n\n<table>\n<thead>\n<tr>\n<th>Management</th>\n<th>Responsible</th>\n<th>Managing</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1a. Pull, single group</td>\n<td>10</td>\n<td>16</td>\n</tr>\n<tr>\n<td>1b. Pull, multiple groups</td>\n<td>7</td>\n<td>6</td>\n</tr>\n<tr>\n<td>2a. Push/Pull, push to puller(s)</td>\n<td>6</td>\n<td>2</td>\n</tr>\n<tr>\n<td>2b. Combination of 2 & 3</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>3a. Push to unidentified group(s)</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>3b. Push to pusher(s)</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>3c. Combination of 3a & 3b</td>\n<td>0</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n3.5 Discussion\n\nThe second most common scenario found for both ultimate responsibility and management was (1b) where multiple groups were identified as taking on this role and all of the identified groups pulled this responsibility onto themselves. There were only two types of pushing found in the case study — types 2a and 3a.\n\nOf type 2a, all but one of the cases fitted the same form: two groups were identified as ultimately responsible and/or managing a quality. One of the groups was always R&D, the other group was SPM or TPM. R&D always pulled responsibility to itself while the other group pushed responsibility to R&D. The exception to this case was for Upgradeability/Replaceability where SPM, TPM and R&D were all identified as ultimately responsible, with R&D and SPM pulling this responsibility onto themselves and TPM pushing the responsibility onto R&D.\n\nFinally, one quality was identified as having (3a) one group as ultimately responsible for that quality, but the identified group perceived another group as being ultimately responsible. The management of this quality was being reviewed and changed while the case study was being conducted. Thus, it should be noted that the application of a method, such as the one presented in Section 3.3, allows for identification of this type of situation and hence also appropriate actions.\n\n3.5 Discussion\n\nThe methodology proposed in Section 3.3 has been applied to identify the level of alignment between internal success-critical stakeholders with the modification made after the pilot study described in Section 3.4.3. While the results from the case presented in this chapter are not generalisable, it highlights what situations can be detected by the method and acts as a reference point for future applications of the method.\n\nWhile in the case study some changes to the priorities given to the software product qualities would be perceived as beneficial by each of the internal success-critical stakeholder groups, the extent of the changes required is reduced when considering all perspectives together. This can be seen most clearly with a number of qualities where the groups agree on their importance today, but some of the groups think some should be more important while other groups think they should be less important and they thus end up in almost the same place. This result shows Theory-W in action, with the organisation having to balance conflicting stakeholder perspectives in order to achieve the optimal balance.\nWhile the current processes seem to have done a reasonable job to balance the various concerns of software product quality, this is not explicitly visible to all of the stakeholders who felt that their needs were not being adequately addressed. One of the ongoing aims within Ericsson is to use these results to foster a greater understanding and dialogue between the internal success-critical stakeholders in terms of each other’s needs.\n\nRespondents in the case study had greater difficulty in identifying and agreeing upon who was ultimately responsible for a quality than who was managing a quality at a more hands-on level. This does not indicate a problem, as people generally know to whom they need to turn regarding an issue of software product quality. What they were less aware of was to whom the manager could turn regarding the same issue.\n\nDiscussions of the results within Ericsson confirmed that some multiple groups were responsible for some software product qualities. This was identified as a potential risk, with no one feeling the need to be an advocate for some qualities. The responsibility of these qualities has since been more clearly defined. The same was not felt true of the day-to-day management of the qualities as different parts of the organisation could turn to the area most appropriate to them provided there is a clearly communicated and common strategy.\n\nIn terms of the three categories of software product qualities — features, project management and system properties — the results highlighted that most ambiguity exists around system properties. This is primarily the result of two factors; system properties are the least important of the categories today, yet account for 18 of the 24 qualities studied. However, the internal success-critical stakeholder groups all agree that these qualities should be more important when going forward. These results supported discussions to clear up the management lines and helped present these messages to relevant parties. Most of the ambiguities raised in the ultimate responsibility of project management were because people were not sure whether to identify PM as ultimately responsible for ensuring that the product was delivered on time and cost, or SPM as the group that approves a project.\n\nWhile it was anticipated that a blank response meant the respondent was unaware who was responsible, it became apparent that this response was also used to indicate that a respondent perceived no one was responsible. The interpretation of this result should be made with caution and future work should allow responses in the questionnaire to differentiate between the two cases. The pushing and pulling of responsibility and management of software product qualities also provided some interesting insights. There is a strong culture of groups taking on a management role with respect to qualities. This is a positive at-\ntribute with employees taking care of the product they produce and doing what they can to ensure the best outcome.\n\nWhile some pushing of responsibility and management was observed, in almost all cases the groups identified agreed between themselves who was responsible — one group would pull responsibility to themselves, while the other groups pushed responsibility to this group.\n\nIt is also interesting to note the types of pulling and pushing not observed in the results of this case study. There was only one case of (3a) pushing without a group pulling and there were no cases of (3b, 3c) multiple groups pushing. As (3) pushing poses the greatest risks to the software development organisation this is a positive result. It means, for example, that there are no cases where group A believes group B to be responsible while group B believes group A to be responsible. Two qualities were identified by a number of participants of this case study as missing from the list of qualities and should be considered for future work. These were the packaging of requirements into releases and client contracts — as both impact upon the value that is delivered to customers.\n\n3.6 Conclusion\n\nThis chapter presents a methodology and results of a case study for examining the alignment between the internal success-critical stakeholder groups in software product quality. The results obtained by the method were interesting, valuable and very positive from the perspective of the industrial partner, Ericsson, with:\n\n- The groups found to be aligned in perceiving the priorities placed on different software product quality today;\n- Overall the participants in the case study perceive few changes necessary to improve the current situation;\n- The most important qualities are the most clearly and explicitly managed; and\n- The majority of qualities have clear management.\n\nThe case study results highlight that different stakeholder groups have different priorities, and companies must be able to balance these differing opinions in order to achieve an optimal outcome. Key to achieving this outcome appears\nto be open and transparent dialogue and cross group communication and understanding. The results also provide an understanding of the context of software product quality for future work within the case setting.\n\nThe results of the case study have helped the company make their employees more aware of the priorities other groups face in the development of their software product, and the need to gain a balance to achieve an optimal outcome. The results have also been used to support changes to the management of software qualities to help ensure better outcomes.\n\nThe case study presented in this chapter may not be representative of the software development industry, only involving one product from one company. Still, it provides some insights into how qualities are handled in an industrial context. Furthermore, the method can be applied in other situations to support the alignment of success-critical stakeholders in issues of software product quality and identify potential management issues. In turn, these additional results can help determine which of the results, if any, can be generalised.\n\nThis research will be used in three ways:\n\n- This work is the first in a series of studies examining, with the intention to help improve, the alignment of company strategy, product strategy, product management and development efforts.\n\n- This work is also the first in another series that is looking at different investment options and trade-offs in software development — like features, quality and staff training. Going forward the aim of this work is to support organisations improve the investment choices they make.\n\n- The authors are also hoping to replicate parts of this study at different organisations to help achieve greater alignment in issues of software product quality and draw more general conclusions in this topic area.\nChapter 4\n\nBalancing Software Product Investment Options\n\nAbstract\n\nThe long-term sustainability of a software product depends on more than developing features. Priorities are placed on aspects that support the development of software, like software product quality (e.g. ISO 9126), project constraints – time and cost, and even the development of intellectual capital. A greater focus on any one aspect takes priority from another, but as each aspect delivers a different type of value, managers have trouble comparing and balancing these aspects. This chapter presents a method to help determine the balance between key priorities in the software development process. The method is applied to a new case study, that also combines with results from previous studies. The results show it is possible to compare features, quality, time, cost and IC in a comprehensive way, with the case study showing that participants perceive a change from a shorter-term product perspective to a longer-term organisation beneficial to the business.\n\n4.1 Introduction\n\nThe value of developing features for a software product is clear – if a product fails to satisfy the needs of its users the product is worthless. But developing\nsuccessful and sustainable software requires investment in more than just features, with other investment types requiring time and funding. XP identifies four key areas to control in the development of software [13] – features, quality, time and cost. However, given that software development is human-intensive, it is crucial to also include intellectual capital (IC) when it comes to the investment in and evolution of a software organisation. These areas represent investment types – features, software product quality and IC, and project constraints – time and cost.\n\nUltimately software development managers must be able to balance these investment types and constraints against one another, as an over-investment in any one of these areas will come at the expense of the others – as shown in Figure 4.1. But people in the software development industry have trouble comparing the importance of the aspects that make up these areas [11]. A hypothetical example would be to ask people to state the relative importance of security, employee satisfaction and delivering on time, which is sure to bring confused faces.\n\nFigure 4.1: Conflict of investment types and constraints in software development\n\nBalancing investment types and constraints is difficult because the investments are intangible, and the aspects being examined are interrelated. For example, the act of writing code has the benefit of training the developer –\nproviding benefits both in terms of the feature-base of the software product and the skills of an employee. Managers are interested in knowing the return on investment to be derived from a software product and/or software process improvement, but the value delivered by each investment type differs in who it impacts and how it impacts them. This means value cannot only be considered in monetary terms as there are temporal and human aspects, which make it much harder to make direct comparisons between different types.\n\nDespite any difficulties software development managers may have, they must still make decisions that impact the balance of investment types and constraints. This chapter presents a quantitative empirical case study, which combines the results from previously completed studies in the areas of software product quality using ISO 9126 [11] and IC [8] with new data. The extra step presented in this chapter allows the previous results to be combined and compared in a comprehensive way, through a single list that shows the relative importance of the aspects that make up features, quality, time, cost and IC. This is the first study to combine these aspects in such a way that they can be compared on a detailed level to the best of the authors’ knowledge. This method is used to both describe the current situation within the case study, and any changes the participants perceived ought to occur.\n\nIn this chapter Section 4.2 presents an overview of related work. Section 4.3 details the research questions and the method used to them. A case study is presented in Section 4.4, with a discussion of the results and method in Section 4.5. Threats to the validity are discussed in Section 4.6. Finally conclusions are drawn in Section 4.7.\n\n4.2 Background\n\nThis section examines the investment types and constraints in more detail, with particular focus on quality and IC. Reasons why people have trouble balancing these concerns are discussed along with the reasons why it is important to get this balance right.\n\n4.2.1 Investment Types and Constraints\n\nLiterature from XP identifies four variables that need to be controlled in the software development process – features, quality, time and cost [13]. The features are described in terms of functional requirements, while quality is described as non-functional requirements. Constraints on development project time and\ncost are used to ensure that an economically feasible product is delivered at an appropriate time. However, this view only presents a project and product perspective of software development.\n\nFrom an organisational perspective, IC must also be considered as an important investment type in the development of sustainable software products, as it is both the key input and tool used in the development of software [95]. IC covers a range of issues from employee training and satisfaction to organisational processes and the knowledge held in the relationships with existing customers.\n\nThus features and quality present the product perspective; time and cost come from the project perspective; and IC represents the longer-term organisational perspective.\n\nThis chapter focuses on software product quality and IC in a greater level of detail than the other attributes, as the body of literature covering the prioritisation and selection of features is considerably more established and the project constraints—time and cost—are much more basic. The chosen areas of interest also fall within the scope of the line management position, supporting change within small and focused parts of the organisation. These areas are also of key interest to the authors’ industrial partners. Other investment types in the development of software products, such as the location of office space, are outside the scope of this chapter.\n\nIn most software development organisations resources are limited. This means funding one type of investment will come at the expense of one or more other types of investment, as shown in Figure 4.1. For example, to deliver a solution on time and budget, with a desired level of quality, it is a common method to exclude the least important features from the release plan.\n\nWhile it is known that people have trouble comparing the relative importance of these different investment types against one another [11], these are important decisions that managers must face. This only makes understanding the nature of these choices and decision support even more important.\n\n### 4.2.2 Software Product Quality\n\nQuality is a complex multifaceted concept. Definitions will vary between people, their relationship to the product for which they are describing quality, and the context.\n\nMultidisciplinary research has identified five perspectives from which quality can be described [45]:\n\n- The transcendental perspective defines quality as something that can be\nrecognised but not defined in advance.\n\n- The user perspective defines quality as fit for purpose.\n\n- The manufacturing perspective defines quality as conformance to specification.\n\n- The product view defines quality in terms of essential characteristics of the product in question.\n\n- The value-based view defines quality in terms of the amount a customer is willing to pay for it.\n\nThe user and manufacturer views are the most commonly taken in the development of software [58, 71]. But the increasing body of value-based software engineering (VBSE) literature recognises the importance of taking advantage of all perspectives involved in software development [71]. Central to VBSE is Theory-W [26], which states that success requires all of the success-critical stakeholders to compromise. Similarly requirement specification reading techniques that take advantage of different perspectives have been found to catch 35% more defects than non-directed alternatives [12, 24].\n\nThe concept of software quality also changes on the context in which it exists [71]. Software quality must be planned to allow a development company to meet its business objectives. This means that different levels of software quality may be acceptable for software product offerings, just as there is a range of quality when it comes to cars. Less than perfect software quality may be ideal [113], but deciding how much less than perfect can only be decided in a given business context [71].\n\nThere are many models that seek to define software product quality. Some examples of these models are McCall’s quality model, Boehm’s quality model, Dromey’s quality model and ISO 9126.\n\nThe first of the modern software product quality models was that of McCall [71]. The model uses a hierarchy of factors, criteria and metrics to address internal and external product quality. Eleven factors define an external or user perspective of quality. Each of these factors is linked to between two and five of 23 criteria that define an internal or development perspective of quality. Further metrics are associated with the factors allowing quality to be measured and managed.\n\nMcCall’s quality model was closely followed by Boehm’s quality model [71]. Both models present product quality in a hierarchy, but Boehm’s model has\nBalancing Software Product Investment Options\n\nthree high level characteristics linked to seven intermediate factors, which are in turn linked to 15 primitive characteristics. Boehm’s model has a wider scope than that of McCall’s, with more emphasis on the cost-effectiveness of maintenance [83].\n\nMore recently work has been done to create an international standard for software product quality measurement – ISO 9126 [60]. This standard is again organised in a hierarchy with six characteristics at the top level and 20 sub-characteristics with indicators used to measure the sub-characteristics. In addition to aspects of internal and external quality, covered by McCall’s and Boehm’s models, ISO 9126 includes quality characteristics of functionality [83]. Internal, external and functional qualities are also mixed at all levels of the hierarchy. However, ISO 9126 does not clearly state how quality should be measured [71].\n\nNone of the three models discussed present a rationale for the selection of characteristics to be included in the quality model and it is not possible to tell if a model presents a complete or consistent definition of quality [71]. Further, the placement of items are not motivated in ISO 9126, with no justification as to why Interoperability is not related to Portability, for example.\n\nDromey’s model attempts to address some of the issues presented with the other models and support developers achieve software product quality [40]. Dromey states that it is impossible to build high-level quality attributes like reliability or maintainability into a product, but developers must instead build properties that manifest in achieving these goals. The distinction this model makes is important, as using it will verify that it allows the quality required to be achieved [71]. Before Dromey’s model can be successfully applied, the various groups involved in the development of a software product must agree on what quality attributes should be achieved and to what level. This process can be supported using other models.\n\nThe investment options in software development are more complex than quality, and any quality model must be considered in terms of other options, like IC.\n\n4.2.3 Intellectual Capital\n\nThe origin of the IC concept can be traced to the balanced scorecard, developed by Skandia – a multinational insurance and financial services company based in Stockholm. Skandia proposed using IC as a management tool for the first time, with an objective to better manage intangible assets when creating further sustainable value for the organisation [30]. Dow Chemical collaborated with Skandia to define the components of IC in terms of human capital, organisation\n4.2 Background\n\ncapital and customer capital [61].\n\nDespite attempts to develop a general model of IC, organisations tend to customise models to suit their own context [50].\n\nFour aspects of IC are defined by Brooking [29]: market assets, human centre assets, intellectual property assets and infrastructure assets. Lowendahl [80] identifies intangible assets in terms of competence and relational resources. Sullivan [103] develops a model based on human capital and defines human capital as the capabilities of stakeholders which is supported by structural capital – for example computers and information systems.\n\nBontis [28] divided IC into human capital, relational capital and structural capital with several indicators that each described. Human capital is the capabilities of individuals who provide solutions to customers. These include knowledge, experiences, skills and abilities of employees, combined human ability to solve business problems. Structural capital refers to the structures and processes within the organisation that meets market requirements – for example patents, trademarks, information systems. Relational capital refers to an organisation’s relations with stakeholders including customers, suppliers and public. This model is one of the most frequently used models by practitioners and academics.\n\nPrevious research and business practices have led to various models and indicators of IC [104, 103, 41].\n\nThere are several techniques, systematic processes and models used to measure IC of organisations. These include balanced scorecard, relative value, competency models, subsystem performance, benchmarking, business worth, business process auditing, knowledge bank, brand equity valuation, calculated intangible value, micro-lending, colorised reporting [85].\n\nOver the years, several methods of measuring IC have also been developed. For example Skandia Navigator, Intellectual Capital Services’ IC Index™ and Philip M’Pherson’s Inclusive Valuation Methodology (IVM™) [57]. The starting point of every method is the identification of intellectual assets and grouping of these into categories. For example, Skandia’s Navigator model includes 112 indices of IC whereas Edvinsson and Malone measure IC by developing 140 indicators, using four perspectives, namely financial, customer, human, and renewals and development [57].\n\nWhile many researchers have examined attributes of IC, there appears to have been no systematic attempt in the intellectual, structural or human capital literature to list the attributes that constitute these areas of study until very recently [86, 34]. Most researchers have only examined aspects of these areas, recognising any list of attributes as incomplete. Moon and Kym [86] noted\nwithout a clear and comprehensive framework for IC, managers are likely to lack the detail required to effectively manage their organisations’ IC, so they created a model of IC by synthesising the attributes and model fragments from many studies. This model is used in this chapter.\n\nMeasuring IC has several benefits. For example it allows companies to assess the risk present and identify areas to develop and improve, it provides a systematic approach when comparing several units within a company or companies, it provides very useful information on companies’ future potential and helps providing a comprehensive company report.\n\nBenefits can be direct, indirect or long term [38]. Direct benefits improve financial performance of the organisation. Indirect benefits are related to changes in elements of performance which may be beneficial for the company – for example motivating staff members which allows managers to be more productive or increase in code reuse or reduction in testing time. Long term benefits include an improvement of the relationships within a company.\n\nAlthough measurement of IC has several benefits to a company, this is a costly process because of the time needed to collect the data, analyse it and take actions on those measurements. In order to lower the cost, companies may need to automate the measurement and cut down on the number of people involve in the process as in many cases benefits achieved are difficult to quantify [38].\n\nAdditionally, the body of knowledge of investment in IC in a software engineering context is limited. The authors found that the majority of literature covers investment issues in software product line practice, and the impact of up-front investment on cumulative return in terms of money, effort and time [55]. Managers need to be able to understand the balance of the various aspects they are managing in order to make informed decisions.\n\n4.3 Methodology\n\nThis section presents the research questions, and describes the method to be used to answer them. The approach taken in this chapter to answer the research questions is presented in two ways. This section presents the general method, which can be applied to all cases. Section 4.4 presents the actual steps taken in the case study presented in this chapter.\n4.3 Methodology\n\n4.3.1 Research Objectives\n\nFinding the right balance between investment types and constraints is critical for the long-term success of all software development organisations. The major investment types come from the product perspective, with issues of features, quality; and from the organisational perspective with issue of IC; while time and cost represent the major project perspective constraints. Too much focus on any one of these areas will result in an under-investment in other areas as they compete with each other, as shown in Figure 4.1.\n\nGetting people to identify the balance between investment types and constraints is a difficult task, but an essential one if these investment options and constraints are going to be successfully managed [11].\n\nPrevious research by the authors has sought to find the balance between aspects of individual investment types – from a product perspective aspects of software product quality were studied using ISO 9126 [11] and from an organisational perspective aspects of IC were studied [8]. However, these aspects must ultimately be understood and balanced together. The research presented in this chapter aims to bring these previous studies together with other feature and project perspective constraints, as shown in Figure 4.2, to understand how these areas interrelate in terms of importance. The areas covered in the case studies are discussed in more detail in Section 4.4, with a complete listing of the areas in Figure 4.4.\n\nThus the research questions addressed in this chapter are:\n\n**RQ1:** Is it possible to identify the relative importance between aspects of features, software product quality using ISO 9126, the project constraints time cost, and IC for a given situation?\n\nIf it is possible to find the relative balance between this aspects, then it is of interest to ask:\nRQ2: What is the balance between aspects of features, software product quality using ISO9126, the project constraints time cost, and IC for a given situation today?\n\nHowever, being able to identify the current balance of investment types does not ensure that the correct balance has been achieved. Thus it is also important to identify what is perceived as the ideal balance for the current situation faced in an organisation. This is addressed by the third research question:\n\nRQ3: What is the perceived ideal balance between aspects of features, software product quality using ISO9126, the project constraints time cost, and IC for a given situation today?\n\n4.3.2 Approach\n\nTo address the research questions a method has been developed, expanding on previous work by the authors in quality [11] and IC [8]. The previous studies were conducted to determine the level of alignment between key stakeholder groups over the priorities of aspects of quality and IC respectively, however, they also generated lists showing the relative importance of the aspects related to each study.\n\nThe method presented in this section expands on the work already done, to combine the previous results with new data to answer the research questions. While details of the case study are presented in Section 4.4, this section details a more general methodology to answer the research questions.\n\nThe process to determine the balance between different investment options and constraints in this chapter has five phases:\n\n1. First identify the investment types and constraints that should be covered, and develop the model.\n\n2. Then associate stakeholder groups to the different parts of the model to identify who should participate in the study.\n\n3. Put together the questionnaires for eliciting the balance of investment types and constraints.\n\n4. The results are analysed.\n\n5. Finally hold a workshop with key stakeholders to develop a deeper understanding of the results.\n\nThe following sections explains each of these phases in more detail.\n4.3 Methodology\n\n4.3.3 Investment Types and Constraints\n\nThe investment types and constraints vary depending on both the organisation and roles studied. Thus it is important that any study tailor the attributes for the context being studied. Using one or more of the quality models and IC models introduced in Section 4.2 is a good starting point, but company specific needs have to be taken into account, as illustrated in the case study in Section 4.4.\n\nThe selection and refinement of models to represent the investment types and constraints should be a consultative process between academia and industry to ensure that a representative and meaningful result is obtained. A workshop or series of workshops should be run to ensure the terms identified provide sufficient coverage and are clearly defined from the perspective of those participating in the study and those using the results.\n\nHowever, it is important that the model developed is hierarchical in order to take advantage of the methodology presented in this chapter, or flat for a simple case. As an example, the model of investment types and constraints used in the case study presented in this chapter can be seen in Figure 4.4. This model is discussed in more detail in Section 4.4.\n\n4.3.4 Stakeholders\n\nWhen considering a range of investment options and constraints, it is likely that no one person or group will have detailed oversight of all of the areas of interest. Managers may be able to provide insight on high-level priorities, but not be able to go into the detail about technical qualities. Similarly a developer may not need to be aware of all of the external stakeholder groups with whom the company has a relationship.\n\nThis is where the value of the hierarchy comes into play. It is possible to ask different groups of people to be involved in the prioritisation of different parts of the hierarchy, as the method then allows the separate responses to be brought together.\n\nParticipants should only be responsible for prioritising parts of the hierarchy for which they have understanding and oversight.\n\n4.3.5 Questionnaire\n\nNow it is possible to develop a questionnaire or series of questionnaires to answer the research questions. As discussing different parts of a hierarchy is confus-\ning in the abstract, a *running example* will be used in the remainder of this methodology section, based on the model of investment types and constraints in Figure 4.3.\n\n\n\nThe hierarchical cumulative voting (HCV) method [16] is used to elicit the relative importance of the investment option and constraint. This method has been found useful when asking people to make comparisons between areas in which they would normally have trouble [11], as it breaks the problem up into a series of simpler tasks. It also allows different people to respond to different parts of the model of investment types and constraints.\n\nHCV is made up of a number of cumulative voting (CV) tasks. CV asks participants to spend 1000 points across different sets of aspects to represent their relative influence. Using the top level of the hierarchy in Figure 4.3, for example, if a participant thought $IC$ does not at all matter today and $features$ was twice as important as $quality$ they might award these qualities zero, 200 and 100 respectively with 700 points distributed amongst the remaining criteria.\n\nEach CV task should contain a logical group of attributes at the same level of abstraction. The master CV task asks participants to compare the top level of the hierarchy. In the example, there would be two CV exercises – the one comparing the three types of $IC$ and the master CV exercise asking participants to compare the five items in the top level of the hierarchy.\n\n### 4.3.6 Analysis\n\nAnalysing the results of the HCV task will answer the research questions.\n\nThe HCV task is analysed in two stages. The first stage looks at each individual CV task to see the relative weight and priority given to each option. The second stage is to combine the results of the individual HCV tasks into a single prioritised list of attributes, allowing comparisons between the CV tasks.\n\nFor the first stage, it is possible to average the points awarded to each aspect. Then each CV task can be analysed individually considering the rank order of the aspects covered and the range of points awarded to the CV set.\nThe second stage involves using the results of the first stage and converting the sets of CV tasks making up the HCV task into a single list of aspects, with each aspect assigned its own relative weighting. Remembering that HCV has a master CV task, and for each aspect in that master CV task there may be a related set of sub-aspects in their own CV task. The example in Figure 4.3 shows a master list containing features, quality, time, cost and IC; with another CV task asking participants to prioritise between three aspects that make up IC.\n\nThis set up allows the number of points awarded to each aspect in the master list to be multiplied with the number of points awarded to each aspect in the related CV task [16]. To ensure that aspects from CV tasks with many options are not underrepresented and that CV tasks with few aspects are not over-represented it is also necessary to multiply each of these results by the number of aspects from the non-master CV task. Finally the set of numbers for each aspect can be scaled so that the sum is 1000.\n\nFor example, if 200 points are awarded to IC and 400 points are awarded to human capital, then:\n\n\\[ IC \\times humancapital \\times numberofaspectsofIC \\]\n\n\\[ = 200 \\times 400 \\times 3 \\]\n\n\\[ = 240,000 \\]\n\nThe scaling of this result then depends on the other values, but if the other values were to sum to 4,800,000 then the number would be scaled to:\n\n\\[ result \\div totalsum \\times 1000 \\]\n\n\\[ = 240,000 \\div 4,800,000 \\times 1000 \\]\n\n\\[ = 50 \\]\n\nIt is possible to deal with aspects in the master CV task with no related CV task, such as features in the running example. In this case create a dummy CV task that contains one item with the same name, and award it 1000 points.\n\n4.3.7 Review\n\nFinally the results should be reviewed with the participating organisation in order to gain a deeper understanding of what the results mean and the reasons behind them. This can be done in a workshop setting.\n4.4 Case Study\n\nThis research has grown from two previous case studies that each looked at the relative importance of different aspects related to one investment types – quality [11] and IC [8] – as shown in Figure 4.2. While the original intent of these studies was to determine the degree to which priorities across the organisation were aligned and working towards a common goal, the results generated lists showing the relative importance of the various aspects that make up each investment type.\n\nThere was a desire, both academically and from within the industrial partner, to join these studies together to understand the relative importance of both sets of investment options together with features, time and cost. This is the aim of the study presented in this chapter, and involved the collection of additional data and an expansion of the methodology to join these areas together.\n\nThis case study was conducted during autumn 2008 for one product at Ericsson. Ericsson is a world leading company in telecommunication, providing a wide range of products and solutions. Products are developed and sold as generic solutions offered to an open market, although customised versions of the products are also developed.\n\n4.4.1 Attribute Selection and Definition\n\nIn order to both validate the work previously done and be able draw greater understanding from the research it was decided to reuse the models from the previous research. But there was a desire to understand these concepts in terms of features and the project constraints time and cost, as previously discussed. Combined these areas represented the major concerns of line managers within our case study and formed the base of the model of investment types and constraints, and to the best of the authors knowledge is the first time researchers have attempted to find the balance between these aspects in a software engineering context.\n\nInterview time constraints meant it was not possible to use the models exactly as presented in the previous studies as combining all of these elements resulted in too many aspects to consider, however, as the models used are hierarchical it is possible to move to a higher level of abstraction.\n\nThe first author created a new model of investment types and constraints based on the control variables for XP [13] and the models created for the previous research into quality [11] and IC [8]. A workshop was then held with people identified by Ericsson to ensure the new model covers the issues of interest to\nthe organisation, makes sense, and can be understood. Some of the definitions were revised, but no major changes were made to the model.\n\nFigure 4.4 shows the model of investment types and constraints used across the three studies that make up this research. This study asked participants to complete the master CV task – comparing features, qualities, time, cost and IC. However, as this study was conducted several months after the first two studies, two additional CV tasks were added to check the priorities had not changed. These consist of the aspects describing quality and IC that are bolded in Figure 4.4.\n\nThe first study asked participants to mark the relative importance of the detailed quality aspects, which are shown in the diagram without bolding. Similarly the second study asked participants to mark the relative importance of the detailed IC aspects, which are also shown in the diagram without bolding.\n\nA questionnaire was developed based on the bolded sections of this model for the third study. One CV task asked participants to compare aspects of IC, the second asked participants to compare aspects of software product quality and the final CV task asked participants to compare features, quality, intellectual capital, time and cost. The final version of the definitions of the terms used in the model can be found in the appendix.\n\n### 4.4.2 Participant Selection\n\nThe authors were supported by the R&D management to select and identify participants for this case study. It was decided that people in line management positions would be able to best address the areas of greatest interest to the company from this study. This group also has the greatest control over the balance being studied. However, this limited the number of possible participants as few people hold this role for the product studied. In total nine participants were selected to take part in the case study. The first author conducted one-on-one interviews with each participant to collect the data. All responses were used in the analysis.\n\nHowever, as this study combines the results of the previous studies, the number of participants and their roles is presented in Table 4.1.\n\n### 4.4.3 Additional Analysis\n\nThe results of the IC study [8] contained several aspects of management that are outside the scope of this study as they are not directly related with IC. In order to manage this situation the aspects of management were removed. The\nrelative weights of the remaining aspects were scaled to 1000 using the same process used in the final stages of the method described in Section 4.3.\n\n### 4.4.4 Results\n\nWhile confidentiality prevents the prioritised list of attributes being published, the results are described and discussed in this section.\n\nThe results were fairly consistent between the participants for the additional data collected as part of the combined and extended study, with one exception that is discussed in this section.\nTable 4.1: Number and roles of participants in each study\n\n<table>\n<thead>\n<tr>\n<th>Study</th>\n<th>No.</th>\n<th>Role(s)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Quality Study</td>\n<td>31</td>\n<td>Strategic Product Managers, Tactical Product Managers, Project Managers, Developers, Testers</td>\n</tr>\n<tr>\n<td>IC Study</td>\n<td>32</td>\n<td>Strategic Product Managers, Tactical Product Managers, Project Managers, Line Managers, Developers, Testers</td>\n</tr>\n<tr>\n<td>Combined & Extended Study</td>\n<td>9</td>\n<td>Line Managers</td>\n</tr>\n</tbody>\n</table>\n\n**Comparison to Previous Studies**\n\nThis research aims to bring the results of three studies together. As there were some months between the collection of data for each study, some additional data was collected about aspects of quality and IC to ensure that the situation had not changed substantially between data collection points.\n\nThe quality study collected data about the 18 aspects of quality listed at the top of Figure 4.4. This study collected data about the six aspects of quality listed in the same figure in bold. The results of both studies showed strong parallels for both what people perceive is happening today and what people perceive should be happening in an ideal situation.\n\nSimilarly it was possible to make a comparison between this study and the IC study based on the three main areas of areas of IC shown in bold at the bottom of Figure 4.4, as both studies used HCV in similar ways. The averaged results for line managers in both studies placed these three aspects in the same order in both the situation today and the ideal situation.\n\n**Overall**\n\nLooking first at the prioritisation of the CV group containing features, quality, time, cost and intellectual capital there are a couple of interesting results. These results are presented in Table 4.2.\n\nThe results show that success is most dependent on delivering features within some constraint of time, with these two aspects coming out most important in\nTable 4.2: Priorities on investment types and constraints\n\n<table>\n<thead>\n<tr>\n<th>Today</th>\n<th>Ideal</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1. Features</td>\n<td>1. Time</td>\n</tr>\n<tr>\n<td>2. Time</td>\n<td>2. Features</td>\n</tr>\n<tr>\n<td>3. Quality</td>\n<td>3. Intellectual Capital</td>\n</tr>\n<tr>\n<td>4. Cost</td>\n<td>4. Quality</td>\n</tr>\n<tr>\n<td>5. Intellectual Capital</td>\n<td>5. Cost</td>\n</tr>\n</tbody>\n</table>\n\nthe situation as it is perceived today, and how the participants would like to see the situation today.\n\nHowever, some change was perceived beneficial to the situation today in the perceived ideal situation. The participants would ultimately like to see a stronger focus on intellectual capital. Additionally the participants would like to see a more equal focus on the different aspects, with a difference of 196 points between the most and least important aspects today, and a difference of 41 points in the perceived ideal situation.\n\nIt should be noted that participants were not consistent with their prioritisation of all five aspects, with quality being placed anywhere between most important to least important by different participants. The level of agreement on the other aspects in this group was much higher for the situation today. While the level of consensus was lower in how the participants prioritised what should be happening in the ideal situation today, the differences between the aspects studied was quite small.\n\nDetailed Priorities\n\nUsing the method described in Section 4.3 the three CV results from the three studies were used to create a single list covering 36 aspects of investment types and constraints – features, all 18 aspects of quality, time, cost and all 17 aspects of IC. These can be seen in Figure 4.4.\n\nIn describing the situation today, the results show a strong product perspective, although the project perspective is important with respect to time. The top 10 aspects consist of eight different aspects of quality, features and time – suggesting the organisation likes to deliver functional requirements to schedule, with a certain set of quality requirements being met. The remainder of the slit evenly across the different aspects, with no investment type group standing out.\nIt is worth noting that the two most important aspects of IC today represent the customer, with customer (operator) and customer (service provider). The third most important aspect of IC today is organisational process.\n\nParticipants were also asked to complete the tasks to show what they think should be happening today, in their perceived ideal situation. These results show no clear preference for any one investment type except features, which remains with a relatively high priority.\n\nIdeally there are aspects of both quality and IC at the top, middle and bottom of the prioritised list. Looking at the difference in ranking between the situation today and the perceived ideal situation there are a number of interesting results:\n\n- All but one of the aspects that participants identified should have a higher rank in the ideal situation were aspects of IC. In particular they were mostly aspects of human capital and relationship capital.\n- A greater focus on the end user is one of the biggest changes desired.\n- The aspects that fell the greatest number of places were from quality, but to a more limited extent features and time also fell.\n- One aspect of IC fell a notable number of places. It was organisational process.\n\nThe results also show that the participants would ideally like the aspects to be more equal in their relative priority. In describing the situation today the most important aspect received 57 points and least important aspect received nine, giving a difference of 48 points. However, in the ideal situation there were only 27 points between the most and least important aspects as everything was brought closer together.\n\n### 4.5 Discussion\n\nThe method presented in Section 4.3 appears to be robust. The method was able to combine priorities from the product, project and organisational perspectives — showing the relative importance of different aspects that make up features, quality, time, cost and IC.\n\nThe results of the case study show a strong product perspective within the organisation, with features and quality coming out as the most important investment types today. However, there is still a strong customer focus in terms of the priorities within IC.\nUltimately the participants in the case study would like to see a stronger organisational perspective taken, with a much greater emphasis on aspects of *human capital* and *relationship capital*. This means taking a longer-term focus when balancing the investment types and constraints against one-another, and being able to deliver value to customers both now and in the future. This result can be partially explained by a restructure within the organisation studied and the economic downturn. Both of these events act to make people feel less secure about their jobs, and the results show a desire for greater security and respect.\n\nThe one aspect of *IC* that bucked the trend set by all other was *organisational process*. Ideally the participants thought this should be less important. However, the organisation studied had also come to the same conclusion, and reducing processes and decision points was one of the major goals of the restructuring.\n\nThe perceived ideal situation remained customer focused, but saw a big increase in the importance of the *end user*. The *end user* in this case Ericsson’s customers’ customers.\n\nThe results of the third study, involving line managers, was interesting in that no major changes were proposed by the participants. This result is not entirely unexpected from a group of people in line management positions. This result is supported by the garbage can model [37], which found that managers try to address issues with change, rather than solutions, and prefer to take smaller steps rather than bigger ones.\n\nIn the case study as it was described today there were 48 points between the most and least important aspects. The description of the perceived ideal situation, however, only had 27 points between the least and most important aspects. There are two possible explanation for this outcome; either the participants believe that the various aspects should be more equal in importance, or when presented with a list of important things, there is a desire to make everything more equal. This result has also been seen in previous studies [7, 11], but there is at least one exception [8].\n\nFinally, communication is critical for the groups involved in the development of software to work together effectively. Knowledge and priorities need to be shared and reconciled, as proposed by Theory-W [26].\n\n### 4.6 Validity Threats\n\nWhile it may not be possible to generalise the results of the case study presented in this chapter to other organisations, or even Ericsson as a whole, the\nmethod shows potential for reuse in other settings. The authors’ research has found people have trouble making comparisons between aspects of different investment types [11], however, the approach used in this chapter was able to balance aspects of IC against product and project perspective issues.\n\nIt should be noted that it is easier for the participants to agree with the set of criteria identified by the researchers than disagree in the workshops and questionnaire. This threat is partially taken care of by allowing the participants to assign a relative importance of zero to any aspect or set of aspects.\n\nIt is also difficult to know whether the respondents have understood the questions as intended and in a similar fashion to one another. This threat was partially addressed in the third stage of this study where the results were presented in the second workshop for confirmation and discussion with the researcher.\n\n4.7 Conclusion\n\nBeing able to balance different investment types within the bounds of certain constraints is a difficult task for software managers, but one that must be undertaken on a daily basis. In this chapter the authors presented a method for determining the balance between different aspects of the software development process. The method brought together the results of three separate studies, and examined the balance between:\n\n- The product perspective – with features and software product quality,\n- The project perspective – with time and cost, and\n- The organisational perspective – with IC.\n\nThe method proposed in Section 4.3 was successfully applied to a complex case, thus answering RQ1 – it is possible to identify the relative importance between aspects of features, software product quality using ISO9126, the project constraints time cost, and IC for a given situation using the method proposed.\n\nThus the method was also able to answer RQ2 and RQ3 for this case. That is RQ2 – What is the balance between aspects of features, quality, time, cost and IC for a given situation today? – and RQ3 – What is the perceived ideal balance between aspects of features, quality, time, cost and IC for a given situation today?\n\nThe answers resulted in a number of interesting findings:\n• The organisation studied currently has a product focus in the priority placed on the aspects studied, but ultimately the participants would like to see a stronger organisational focus – with more emphasis on longer-term issues.\n\n• The results of the study targeted at people in line management positions showed only a desire for small changes, which is inline with research into management practices [37].\n\nThe results of this method can be used to start a dialogue within the organisation to ensure all success-critical stakeholder groups understand what activities and investments must be made in order for a company to achieve long term prosperity and sustainability. This will in turn help the different groups within the company work towards and achieve a common goal.\n\nGoing forward it is important to understand if the participants in the study have an organisational or individual perspective. While improving the work environment for employees will bring benefits to the organisation to a point, the right balance needs to be achieved between these aspects.\n\nIt is also essential to understand what stops organisations from achieving their ideal state, so that they can be supporting in reaching these end goals.\nChapter 5\n\nAttitudes to Value and Risk in Requirement Selection\n\nAbstract\n\nFinding a balance between commercial (customer specific, market pull and external quality requirements) and internal quality requirements is a recognized challenge in market driven software product development (MDSPD). In order to address this challenge it is important to understand the preferences and biases influencing decision makers selecting requirements for software releases. Prospect theory has been successfully applied to many disciplines. Applying it to MDSPD suggests decision makers will avoid risk when selecting between commercial requirements, take risk with internal quality requirements, and prefer commercial requirements over internal quality requirements in order to maximize their perceived value. This chapter seeks to investigate this claim. This chapter presents an experiment investigating whether the biases proposed by prospect theory can be seen operating in MDSP requirements engineering (RE). The results indicate risk avoidance when dealing commercial requirements, while greater risk is taken when dealing with internal quality requirements. As this is the first research paper to use prospect theory to explain requirements selection decisions, it presents opportunity to educate people in the biases they bring to the RE process, and facilitate the creation of strategies for balancing the different requirements types.\n5.1 Introduction\n\nRequirements engineering (RE) is a decision rich activity, and RE decision support as a field has received increasing attention as market-driven software product development (MDSPD) has taken off [88, 3, 92, 32]. Due to the growing popularity and complexity of MDSPD, it is important to understand how inherit biases influence decisions made in this area. This chapter explores one key bias presented through prospect theory, and how it impacts value and risk perception.\n\nMDSPD is focused on the task of selecting a set of requirements that should be included in the coming releases of a product. The success of the product is measured in sales and is related to how much the product features are valued by the customers.\n\nThe requirements selection process in MDSPD is often perceived as a very complex activity. This complexity is explained by:\n\n- A large number of requirements that need to be considered;\n\n- A variety of different technical aspects that need to be taken into account before a selection of the requirements can be made; and\n\n- The challenge associated with taking decisions based on the decision material of variable quality (such as uncertain cost and value estimations).\n\nThus, the authors of this chapter classify requirements selection as occurring in a high-risk environment.\n\nRequirements selection in MDSPD often involves situations where a decision maker must choose between requirements of different types. Key requirement types include commercial requirements – originating from the market and key customers; and system requirements (internal quality requirements) – often connected with system maintenance, quality and architecture. The challenge here is to find a balance between commercial and system requirements, such as to allow satisfying the immediate market and customer needs, as well as assuring the healthy product architecture evolution.\n\nRecent studies on MDSPD show that commercial requirements are perceived more important than system requirements [109, 110, 7, 9]. However, these studies also show that system requirements are generally undervalued. Considering the impact of requirements selection decisions on the business of a development company, it would be useful to have an understanding of the heuristics and cognitive biases behind these decisions, which according to the classical decision theory govern the decision outcome [90].\n5.1 Introduction\n\nIn this chapter prospect theory [63, 106] is used to explore biases behind requirement selection decisions in a MDSPD context. While this breaks normative assumptions about decision making in risky situations referenced in most engineering literature [76], decisions made by software project managers have found to be better modelled by prospect theory than the more common utility theory.\n\nProspect theory models decision makers’ attitudes towards risk in terms of gains and losses [90]. It predicts that people will be risk adverse when selecting between options described in terms of gains, and risk taking when deciding between options described in terms of losses. Given that software requirements in MDSPD RE can be described in terms of revenues (gains) and/or costs (losses) it seems interesting to apply prospect theory in order to explain the choices of decision makers.\n\nAssuming that in MDSPD commercial requirements are normally associated with revenue, while system requirements are associated with costs, applying prospect theory would suggest decision makers will take risks with system requirements. As these requirements are associated with cost, the preference is to delay spending in the short-term, despite the potential for increased costs later and thus taking a risk.\n\nConversely, since commercial requirements are associated with gains, decision makers will be more risk adverse when selecting and prioritizing these requirements. This means preference will be given to requirements with a more reliable revenue stream, even if the alternatives could yield greater ROI.\n\nIn the experiment presented in this chapter the authors investigate how well prospect theory applies to MDSPD RE. To the best of the author’s knowledge this is the first time prospect theory has been applied to MDSPD. The primary objective is to investigate the decision maker’s attitude towards risk, as well as perception of requirements value when it comes to choosing between alternatives of both cost and benefit.\n\nThe structure of this chapter is as follows; Section 5.2 presents the special characteristics of MDSPD and provides an overview of how prospect theory can be used to explain and model requirements selection decisions in an MDSPD environment; Section 5.3 details the research question and the experiment design; the experiment results and analysis are found in Section 5.4 and finally Section 5.5 presents conclusions and future work.\n5.2 Background\n\nThe following section provides a brief summary of the characteristics of requirements selection process in MDSPD. This is followed by a presentation of prospect theory and an experiment that explore attitudes towards losses and gains. The section concludes with a discussion on how prospect theory can be used to explain requirements selection decisions in MDSPD.\n\n5.2.1 Market Driven Software Product Development\n\nIn typical MDSPD the development organization is the main stakeholder and owner of a developed product. The product evolves over time with new functionality added and offered to the general market through product releases. In MDSPD the development organization takes most risks and is responsible for development costs of the product. Delivering the right set of functionality when the market is ready for it is critical for the success of the software product.\n\nMarket-driven development is largely product focused and many important activities are performed prior to the initiation of the development projects (i.e. pre-project). The goal of pre-project activities is to catch, analyse, select and plan requirements for future releases of the product. Pre-project activities should result in a prioritized list of requirements that are assigned to a specific release. These requirements are then realized through one or more development projects.\n\nThe importance of correct decision making pre-project is acknowledged and highlighted by both industry and academia. However, finding a perfect set of requirements is considered impossible due to a variety of different criteria that need to be taken into account and conflicting interests of stakeholders. Each stakeholder group is interested to see their requirement in the next release [66, 93, 89].\n\nDifferent requirement types that are typically involved in requirements selection process are shown in Table 5.1 [92, 65, 48]. Customer specific features and Market pull requirements, which are often referred to as commercial requirements originate from the customers. In the case of Customer specific features the main stakeholder is one key customer, whereas for Market pull requirements the main stakeholder is often a marketing or sales unit representing a number of customers.\n\nInnovation requirements can originate from Key customers, however mostly these requirements are defined by the R&D unit of a company.\n\nThe stakeholders of External quality aspects can be represented by both\nTable 5.1: Requirement types in MDSPD\n\n<table>\n<thead>\n<tr>\n<th>Requirement Type</th>\n<th>Explanation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Customer specific features</td>\n<td>Requirement originating from one of the key customers</td>\n</tr>\n<tr>\n<td>Market pull requirements</td>\n<td>Requirements originating from more than one customers that represent a certain market</td>\n</tr>\n<tr>\n<td>Innovation</td>\n<td>Requirement usually originating from the company’s R&D. Examples of this may be innovative technology, patents, innovative features, etc.</td>\n</tr>\n<tr>\n<td>External quality aspects</td>\n<td>Requirements concerning usability, security, reliability and other quality issues</td>\n</tr>\n<tr>\n<td>System requirements</td>\n<td>These are system architecture specific requirements, connected to system architecture health, flexibility, and evolution.</td>\n</tr>\n</tbody>\n</table>\n\nexternal parties, such as customers and internal parties such as R&D. Finally, System requirements mainly focus on system architecture and evolution aspects and almost always originate from organisations’ R&D units.\n\nRecent studies on MDSPD show that commercial requirements are perceived more important than system requirements [109, 110, 7, 9]. However, these studies also show that system requirements are generally undervalued. The situation where system requirements are usually given a lower priority is troubling system engineers as it will lead to system architecture deterioration and collapse in the longer term, which can be connected to serious losses for the company.\n\nFinding a trade-off and profitable balance between commercial and system requirements is very important for the success of a product. But before this trade-off can be found, the authors believe an understanding should be reached of the reasoning and decision frames that govern decision making process in MDSPD RE. This is where the authors believe prospect theory may be useful.\n\n5.2.2 Prospect Theory and Related Works\n\nProspect theory was developed by Daniel Kahneman and Amos Tversky [63], for which Kahneman won a Nobel Prize in economics in 2002. It examines possible outcomes in terms of gains and losses to determine the value of these\noutcomes [90]. When asked about the preferred choice between the “sure thing” and a risky option, it is assumed that the decision maker’s attitude to risk is revealed. If $X$ is the monetary outcome, 0.5 is the probability of “winning” $X$ and $V$ is the value of a choice option, the preferences in Table 5.2 reveal the risk attitude of an individual.\n\n<table>\n<thead>\n<tr>\n<th>Scenario</th>\n<th>Risk Attitude</th>\n<th>Risk Preference</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$V(X) = V(0.5 \\times 2X)$</td>\n<td>Risk neutral</td>\n<td>Indifferent between the options</td>\n</tr>\n<tr>\n<td>$V(X) > V(0.5 \\times 2X)$</td>\n<td>Risk adverse</td>\n<td>Prefers the “sure thing”</td>\n</tr>\n<tr>\n<td>$V(X) < V(0.5 \\times 2X)$</td>\n<td>Risk taker</td>\n<td>Prefers the risky option</td>\n</tr>\n</tbody>\n</table>\n\nWhile prospect theory is built on utility theory, prospect theory differs in that it considers issues from within a reference frame. Utility theory looks at net wealth, where prospect theory considers gains and losses. Thus prospect theory can explain why a loss of $500 is felt more strongly than a gain of $500.\n\nProspect theory has many practical applications, even within software engineering. It has been used to understand the reasons behind software project escalation [67], explain why early involvement in software project bidding leads to higher quotes [62], and support with the pricing of software bundling [35]. What is interesting about prospect theory is the relationship between the outcome and value is not linear, as seen in Figure 5.1. The function is steepest around zero and flattens out as the losses and gains become greater. It is also steeper for losses than gains.\n\nThe properties of the function mean that $500 loss is felt more strongly than a $500 gain as the relative value for losses is greater than the value for a similar sized gain. This can be seen in Figure 5.1 by using the guide markings.\n\nGiven the choice between (a) a 50% chance of gaining $1000 or (b) a sure gain of $500, most people select the safer option, B [63]. Figure 5.1 shows that a doubling in gains is not equivalent to a doubling in value, so the value delivered by option B on average is actually less than option A (as the value derived from the average of no gain and a $1000 gain is less than the value of a $500 gain).\n\nConversely when presented with options to (a) lose $1000 with 50% probability or (b) a sure loss of $500, most people chose the riskier option A [63]. As more value is lost from $0 to $500 than from $500 to $1000, the expected value of the outcome is less than the guaranteed loss of $500.\nAnother implication of prospect theory is that preferences will depend on how a problem is framed [90]. If the decision maker perceives the outcome as a gain they will accordingly act in a risk-adverse manner, while acting in a risk-taking manner where the perceived outcome is a loss.\n\nFraming has been found to play an important role in medicine. How the benefits of a vaccine are framed will yield very different take-up rates [76]. Patients who are told a vaccine is guaranteed to stop a virus are more likely to take it, than patients who are told a vaccine will stop two equally likely viruses with 50% probability.\n\nHowever, these results would suggest that most people would not buy insurance. Replicas of the original experiments into prospect theory have found that most people act differently depending on whether the cost is framed as a gamble or an insurance [53, 100]. When a cost scenario is framed as insurance most people are risk adverse preferring to pay the smaller fixed amount, while when it is presented as a gamble people prefer to take on the risk.\n\nKahneman and Tversky [63] also found that people overweighed low probabilities and underweighted higher probabilities. This explains why people are prepared to buy lottery tickets.\n5.2.3 Using Prospect Theory to Explain Requirements Selection Decisions\n\nGiven prospect theory can be applied to decision-making processes in disciplines from finance to medicine [112], this section proposes how prospect theory can be used to explain the requirements selection decisions in MDSPD – in this context losses are described in terms of costs and gains in terms of revenues.\n\nThe requirements types presented in Section 5.2.1 are represented in Table 5.3 with information on whether each is perceived as generating costs or revenues. Commercial requirement types are marked with an asterisk, while system requirement types are not.\n\n<table>\n<thead>\n<tr>\n<th>Requirement Type</th>\n<th>Cost/Revenue Driver</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Customer specific features</td>\n<td>* Revenue</td>\n</tr>\n<tr>\n<td>Market pull requirements</td>\n<td>* Revenue</td>\n</tr>\n<tr>\n<td>Innovation</td>\n<td>* Revenue</td>\n</tr>\n<tr>\n<td>External Quality aspects</td>\n<td>* Revenue</td>\n</tr>\n<tr>\n<td>System Requirements (internal quality)</td>\n<td>Cost</td>\n</tr>\n</tbody>\n</table>\n\nCommercial and system requirements are obviously very different in nature. Commercial requirements are clearly associated with customers – and therefore with revenue, while system requirements are associated with costs. This result can be seen through the language used to describe the different requirement types. Commercial requirements are referred to as business opportunities, and are discussed in terms revenue generation and expanding markets. In contrast system requirements are discussed as costs and must be justified with either, “If we do not do this now it will lead to higher costs in the future,” or, “If we make this change now we will be able to lower our production costs.”\n\nAs commercial and system requirements can be described in terms of gains and losses, prospect theory has an obvious connection in how these different requirement types are valued. This is seen most clearly by replacing gains and losses with revenue and costs, and placing requirements of different types on the graph in Figure 5.1.\n\nLooking at a commercial requirement with an expected gain, one can see that a doubling of the gain does not double the value of the requirement. Similarly halving the gain does not halve the value of the requirement. The results\nfrom previous studies of prospect theory would therefore suggest that decision makers would be risk adverse when selecting commercial requirements, preferring guaranteed returns over larger riskier returns. Conversely decision makers would prefer to take more risk with system requirements, trying to minimize costs, even if these savings come at the risk of spending more money.\n\nDifferent levels of risk are associated with the various requirement types. A customer specific requirement often has a customer willing to foot the entire cost, and one may reasonably assume that an individual customer is indicative of wider market demands. The return on investment of an innovation, however, does not have the same guaranteed revenue stream, but there is a potential for large revenues if the requirement proves popular. Internal system quality requirements are likewise risky as they involve investments in the longer-term sustainability of a software product. This could mean, for example, a requirement is developed allowing different database systems to be used with the product, but if this is never used the cost was unnecessarily incurred. It should also be noted that the customer is only aware of commercial requirements, with only the development organisation having clear visibility into internal system quality.\n\nGiven the clear link between prospect theory and MDSPD RE, the aim of the experiment presented in this chapter is to investigate whether prospect theory holds in an MDSPD RE setting. While the authors acknowledge MDSPD RE is a complex decision making setting, the focus of this chapter is on understanding the bias towards the perception of value as proposed by prospect theory, and how it may impact the decision making process.\n\n5.3 Experiment Planning and Operation\n\nThis section presents the research question and major steps in the experiment planning and operation.\n\n5.3.1 Research Question\n\nThe goal of the experiment presented in this chapter is to investigate if the results of the experiments conducted by Tversky and Kahneman [63, 106] can be seen in the MDSPD RE context - that is people are more risk taking when it comes to losses (costs) and risk adverse when it comes to gains (revenue).\n\nIn order to investigate this idea, the experiment follows the arrangement of the experiments conducted by Tversky and Kahneman [63, 106], but places\nthe participants in a MDSPD RE context. Thus the research question for the experiment is formulated as follows:\n\nWhen selecting requirements, do product managers show more risk-adverse behaviour with requirements formulated in terms of revenue, than with requirements formulated in terms of cost?\n\n5.3.2 Experiment Instrumentation\n\nA questionnaire was developed to investigate whether the participants behave in a manner that can be predicted by prospect theory. A range of risk levels and monetary values was used. The questions included are presented in Table 5.4. In order to control the variable for value gains and losses are only described in monetary terms. While providing a richer context would better simulate reality, it is not easy to assess what value participants place on the different aspects that make up this context.\n\nEach set of questions is designed in the similar style used in the original experiments by Tversky and Kahneman [63, 106]. Examples of the original questions can be found in Table 5.5.\n\nFrom the questions presented in Table 5.4 and Table 5.5 it is easy to see the similarities between formulation of the questions from the authors’ experiment and the original experiment. However, the question formulation differed between the original and authors’ experiment with the original experiment using zero gain and zero loss as an option in each case. The effect of this difference in the design of the questions is discussed in Section 5.4.\n\nA number of measures were undertaken to reduce systematic biases in the results. The order effect was addressed by systematically varying the order of the questions in the study. Additionally questions were placed between questions on revenue and cost to distract the participant from their previous answers.\n\nA pilot of the questionnaire was completed prior to conducting the experiment. Two lecturers in software engineering completed the questionnaire, with both feeling they had a clear understanding of what was required, and were able to make informed decisions.\n\n5.3.3 Experiment Subjects\n\nThe experiment involved 71 student participants completing either their final year of undergraduate studies or a masters in Software Engineering at\nTable 5.4: Question sets for revenue and cost\n\n<table>\n<thead>\n<tr>\n<th>Set</th>\n<th>Revenue</th>\n<th>Cost</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Select one requirement:</td>\n<td>Select one requirement:</td>\n</tr>\n<tr>\n<td></td>\n<td><strong>A</strong> has a guaranteed revenue</td>\n<td><strong>A</strong> has a cost of €10,000.</td>\n</tr>\n<tr>\n<td></td>\n<td>of €10,000.</td>\n<td><strong>B</strong> could cost €200 with 30% probability and €14,200 with 70%</td>\n</tr>\n<tr>\n<td></td>\n<td><strong>B</strong> could raise €2,400 revenue with 75% probability, and €32,800</td>\n<td>probability.</td>\n</tr>\n<tr>\n<td></td>\n<td>revenue with 25% probability.</td>\n<td></td>\n</tr>\n<tr>\n<td>2</td>\n<td>Select one requirement:</td>\n<td>Select one requirement:</td>\n</tr>\n<tr>\n<td></td>\n<td><strong>A</strong> has a guaranteed revenue</td>\n<td><strong>A</strong> has a cost of €10,000.</td>\n</tr>\n<tr>\n<td></td>\n<td>of €10,000.</td>\n<td><strong>B</strong> could cost €2,000 or €18,000 with equal probability.</td>\n</tr>\n<tr>\n<td></td>\n<td><strong>B</strong> could raise €2,000 or €18,000 revenue with equal probability.</td>\n<td></td>\n</tr>\n<tr>\n<td>3</td>\n<td>Select one requirement:</td>\n<td>Select one requirement:</td>\n</tr>\n<tr>\n<td></td>\n<td><strong>A</strong> has a guaranteed revenue</td>\n<td><strong>A</strong> has a cost of €10,000.</td>\n</tr>\n<tr>\n<td></td>\n<td>of €10,000.</td>\n<td><strong>B</strong> could cost €200 revenue with 30% probability, and €14,200</td>\n</tr>\n<tr>\n<td></td>\n<td><strong>B</strong> could raise €200 revenue with 30% probability, and €14,200</td>\n<td>revenue with 70% probability.</td>\n</tr>\n<tr>\n<td></td>\n<td>revenue with 70% probability.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\nTable 5.5: Questions from related studies\n\n<table>\n<thead>\n<tr>\n<th>Ref</th>\n<th>Gain</th>\n<th>Loss</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>[106]</td>\n<td>Select one:</td>\n<td>Select one:</td>\n</tr>\n<tr>\n<td></td>\n<td>• A sure gain of $250.</td>\n<td>• A sure loss of $750.</td>\n</tr>\n<tr>\n<td></td>\n<td>• A 25% chance to gain $1000, and a 75% chance to gain nothing.</td>\n<td>• A 75% chance to lose $1000, and a 25% chance to lose nothing.</td>\n</tr>\n</tbody>\n</table>\n\n[63] Scenario: In addition to whatever you own, you have been given $1000. You are now asked to choose between the alternatives:\n\n| Scenario: In addition to whatever you own, you have been given $2000. You are now asked to choose between alternatives: |\n| • A 50% chance of gaining $1000. | • A 50% chance of losing $1000. |\n| • A sure gain of $500. | • A sure loss of $500. |\n\nBlekinge Institute of Technology, Sweden. The group consisted mostly of international masters students, who came from Pakistan, India, China, Iran, Nepal, Bangladesh, Nigeria, Germany and Jordan; with four undergraduate students, all Swedish.\n\nForty-nine of the participants had prior experience of working in the software industry. The Swedish students had experience from software engineering projects in terms of project courses which are run in tight cooperation with industry and very much resemble real development in industry. At the time of the experiment most of the students had completed the courses in Software Requirements Engineering and Software Verification and Validation, thus the students were assumed to be familiar with requirements engineering concepts.\n5.4 Results and Analysis\n\n5.3.4 Experiment Operation\n\nThe experiment was conducted at Blekinge Institute of Technology in the spring of 2008 during a single two-hour session.\n\nPrior to starting the experiment the participants were introduced to the role of a software product manager and presented with the key performance indicators (KPIs) used to assess a person in this position. The list of KPIs included responsibility over the selection of requirements in a release to maximize the profit (return on investment) generated by the sales of a product. The KPIs remained visible for the duration of the experiment and the participants were encouraged to act in accordance to them.\n\n5.4 Results and Analysis\n\nThis section presents the results, with an analysis and discussion.\n\n5.4.1 Presentation of Results\n\nThe results of the experiment are presented in Table 5.6. The table shows the percentage of participants that chose the safe and risky options for the cost and revenue related questions in each of the question sets presented in Section 5.3.2.\n\n<table>\n<thead>\n<tr>\n<th>Set</th>\n<th>Revenue Safe</th>\n<th>Revenue Risk</th>\n<th>Cost Safe</th>\n<th>Cost Risk</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>0.69</td>\n<td>0.31</td>\n<td>0.49</td>\n<td>0.51</td>\n</tr>\n<tr>\n<td>2</td>\n<td>0.68</td>\n<td>0.32</td>\n<td>0.68</td>\n<td>0.32</td>\n</tr>\n<tr>\n<td>3</td>\n<td>0.56</td>\n<td>0.44</td>\n<td>0.52</td>\n<td>0.48</td>\n</tr>\n</tbody>\n</table>\n\nAs shown in Table 5.6, most participants were risk adverse when answering questions related to revenue, with most selecting the safer option. For the revenue questions presented in Question Set 1, 69% chose a safe option, in Question Set 2 a similar 68% chose the safe option, while in Question Set 3 56% chose the safe option.\n\nThe results for the cost related questions show only a small difference in preference between the safe and risky options in Question Set 1 and Question\nSet 3. However, in Question Set 2 the participants were more risk adverse, which was the opposite of what was expected (68% safe).\n\nComparing the answers between the revenue and cost related questions, the results show increased risk taking attitude in cost related questions for Question Set 1 (from 31% to 51%) and Question Set 3 (from 44% to 48%). The attitude towards risk is unchanged for Question Set 2.\n\n5.4.2 Analysis\n\nThe results for revenue related questions show a preference for avoiding risk in each and every case, demonstrating alignment with the original experiment conducted by Tversky and Kahneman [63]. While the results showed more risk-taking behavior in the questions related to cost, the results were not as strong as the original prospect theory experiments.\n\nThe level of risk avoidance is higher for the revenue questions in Question Set 1 and Question Set 3 than for the questions regarding cost in the same question sets. When it comes to cost related questions, two of the three tested cases (Set 1 & Set 3) do not show a strong preference to take or avoid risk. These combined results, when considered relative to one another, indicate a more risk-adverse behaviour with requirements formulated in terms of revenue, than with requirements formulated in terms of cost.\n\nThe results for Question Set 1 and Question Set 3 show a clear change in attitudes towards risk between requirements termed as costs and requirements termed as revenue. While the result for Question Set 2 did not show a strong difference, the majority of the cases support the application of prospect theory to software requirements selection.\n\n5.4.3 Discussion\n\nThe results of the experiment indicate that decision makers will be more risk adverse when choosing between requirements formulated in terms of revenue, compared to when choosing between requirements formulated in terms of cost. This provides ground for concluding that prospect theory can be used to understand and explain decision making in MDSPD requirements selection situation.\n\nThe observed attitude towards risk taking for cost related questions was not as strong as expected, however, aspects of this may be explained by the experiment design. The participants of the experiment are students and do not have the same sense of ownership and responsibility towards the money of a real product manager. This could mean that they were not as sensitive to losing\n5.4 Results and Analysis\n\nmoney. For example, looking at the cost related questions in Question Set 2, it is reasonable to assume that the students did not see the value of taking the risky option because it was not their own budget, own reputation or job position that was at stake. Another difference is that in original experiments in prospect theory, the subjects were offered to decrease the loss to zero, which may have motivated more to risk as other psychological factors are involved with zero [98].\n\nThe authors expect an experiment involving professional software product managers would be more aligned with the original experiments as people in this role have a greater sense of ownership in the product for which they are responsible and will face a greater loss in reputation for failing to meet budget than the experiment participants. This assumption is supported by findings of the study on application of prospect theory on software project decisions, where project managers’ decisions were found to be aligned with prospect theory [76].\n\n5.4.4 Validity Threats\n\nInternal and external validity threats are most important to address for experiments in software engineering field [111] and social sciences [94].\n\nInternal validity is concerned with identifying whether the observed result of the experiment is influenced by other factors than the experiment treatment. For the experiment presented in this chapter an ordering effect (learning) and experiment instrumentation (the way questions are formulated) are the most significant threats.\n\nTreatment order effect would mean the order the questions are presented will affect the participants’ answers. To minimize this threat, the order of cost and revenue questions were systematically varied in the study.\n\nTo minimize the risk associated with the question formulations, a pilot of the experiment was conducted involving three participants. The intention of the pilot was to discover ambiguities and improve the formulation of the questions.\n\nExternal validity is associated with the possibility to generalize the outcome of the experiment. While using students as experiment subjects usually puts a threat for generalizing the results [14], most of the students participating in the experiment have prior industrial experience and are trained in the requirements engineering field at a masters level. However, the participants may not have felt the responsibility for the success of the product in the same way that a product manager in industry would. As discussed earlier in Section 5.4.3 this provides ground for assuming that an experiment involving professionals will be more aligned with the original experiments in prospect theory.\nMDSPD RE operates in a much more complex setting than that modelled in this experiment, potentially impacting the generalisability of the result. For example, while it can be argued that software requirement selection decisions are more commonly group decisions, and not up to individuals as modelled in this experiment. However, the application of the results in a group situation should still be possible as research has shown than individuals’ attitudes to risk are translated into a groups attitudes to risk [42]. Similarly, while requirements are more complex than questions of cost and revenue, in order to control the participants perceived gains and losses and how these impact value, the problems were reduced to monetary terms.\n\nThe results presented in this chapter are inline with other findings from industry, recognising the importance commercial requirements with a fixed return over more variable market opportunities [7]. Similarly, literature recognises the risk-taking attitude towards system requirements [109, 110, 7, 9].\n\n5.5 Conclusions and Future Work\n\nThe intention of the research presented in this chapter is to investigate if the ideas behind prospect theory, one of the prominent theories in decision making, can explain requirements selection decisions in market-driven software product development (MDSPD). The experiment presented in this chapter replicates the design of the original experiments into prospect theory, but places it in the context of requirements selection situations in MDSPD.\n\nThe experiment results show a clear potential for applying prospect theory in MDSPD setting. The participants consistently displayed risk adverse behaviour when selecting between requirements described in terms of revenue. In two of the three cases investigated the participants were more risk taking when selecting between requirements described in terms of cost when compared to the revenue situation. The increase in risk taking attitude was not as distinct as anticipated. However, the authors’ expect that an experiment involving professionals would show larger difference between risk taking approach between the revenue and cost related situations.\n\nTo the best of the authors’ knowledge the work presented in this chapter is the very first application of prospect theory in MDSPD requirements selection context. The insights found in this chapter provide contributions both to researchers and practitioners in this field, as they open up possibilities for explaining the behaviour of decision makers in different requirements selection situations. This provides an answer to why resent studies observe internal quality\nrequirements being consistently undervalued compared to commercial requirements, as well as help in finding ways for managing the balance between different types of commercial requirements originating from market pull and technology push.\n\nLooking more closely at commercial requirements, prospect theory suggests preference favour for the guaranteed revenue stream over more uncertain options. Looking at the different requirements types, this would translate to a preference for customer specific features over innovation related requirements, as predicting market demands brings with it more risk.\n\nThe situation for system requirements is more complex. As these requirements are viewed as cost-drivers, they cannot be directly compared with the other types of requirements that are perceived as delivering revenue. This highlights the need to describe system requirements in terms of the gains that they deliver, so that a comparison between requirements of different types can be made. However, it should be noted that the risk associated with system requirements is still higher – so even when described in terms of gains, natural preference will be given to less riskier options. Putting this in MDSPD context implies that unless there is a clear strategy for balancing commercial and internal quality requirements, the later will be consistently down-prioritized until the point when the architecture issues will pose an impediment for the production of commercial features.\n\nA number of actions should be undertaken as future work. A follow-up study is planned involving software product managers from companies working in a market-driven software development context, helping address issues faced in the experiment presented in this chapter. Additionally this work should be used to educate software project managers to the biases they bring to the development process, and will be used as an input to a model to help software product managers balance requirement types when selecting requirements for a release.\nAttitudes to Value and Risk in Requirement Selection\nBibliography\n\n\nAppendix\n\nSoftware Product Quality Definitions\n\nThis section details the terms and definitions used in the study into investment types and constraints in Chapter 3.\n\n**Features:** Related to the existence of a set of functions and their specified properties; both stated and implied needs:\n\n- **Suitability:** The functionality is appropriate for its purpose and situation.\n- **Accuracy:** The functionality is correctly understood and implemented.\n- **Interoperability:** The system works with the other systems required.\n- **Certification/Standardisation/Compliance:** The system conforms to both standards and legislation.\n\n**Qualities:** This area is made up of the following attributes:\n\n- **Security:** The system software is safe from danger or threat.\n- **Scalability:** Ability for the system to expand the computing solution to support a larger system load without impacting performance.\n- **Availability/Reliability:**\n - Maturity: The system has achieved an appropriate level of sophistication.\n - Recoverability: Able to regain operation after a fault or failure.\n- **Containment/ISP/Fault tolerance:** Capacity to endure adverse conditions and remain in operation.\n\n**Usability:**\nLearnability: The ease with which a user can gain or acquire knowledge about the system.\nUnderstandability: Degree to which the system is as one expects.\nOperability: Degree to which the system can be used.\n\nPerformance/Efficiency:\nTime behaviour: The time taken to complete given activities.\nResource behaviour: The computing resources required to complete given activities.\n\nMaintainability:\nRobustness/Stability: Ability to operate without failure when there has been an unintended change as part of a maintenance activity.\nPerformance Management/Statistics: Ability of the system to provide statistics, logs and information to the user in order to implement a performance management process for continuous monitoring of capacity utilisation and success rates for applications, platforms and interfaces.\nAnalysability: Ability for the system to be examined methodically and in detail in order to understand the impact of and make changes to the system. For example, artefacts that may help with this process are system architecture diagrams, system documentation and comments in code.\nChangeability: Ability for the system to be modified. This can be to complete any maintenance activity corrective, adaptive, perfective and preventative.\nTestability: Ability to confirm if an action, item, situation, etc is operating as desired.\n\nPortability:\nInstallability: Capacity to place or fix into a new environment.\nUpgradability/Replaceability: Ease with which the system can replace or be replaced by a new version of the system or a different system that performs the same task.\nConfigurability/Product Customisability/Adaptability: Degree to which the system can adjust to new conditions.\n\nTime: Development time for a project and in particular release date.\n\nCost: Total cost for development, primarily in terms of person-hours, but also other costs.\nInvestment Type and Constraint Definitions\n\nThis section details the terms and definitions used in the study into investment types and constraints in Chapter 4.\n\n**Features:** New or changed functionality of the system. This should meet the needs of specific customers or the more general needs of the target market of the software product.\n\n**Qualities:** This area is made up of the following attributes:\n\n- **Security:** The system software is safe from danger or threat.\n- **Scalability:** Ability for the system to expand the computing solution to support a larger system load without impacting performance.\n- **Availability/Reliability:** Related to the capacity of software to maintain its level of performance under stated conditions for a stated period of time. It should have achieved an appropriate level of sophistication, endure adverse conditions and remain in operation, and regain operation after a fault or failure.\n - Maturity: The system has achieved an appropriate level of sophistication.\n - Recoverability: Able to regain operation after a fault or failure.\n - Containment/ISP/Fault tolerance: Capacity to endure adverse conditions and remain in operation.\n- **Usability:** Related to the effort needed for use, and on the individual evaluation of such use, by stated or implied set of users. It covers the ease with which a user can acquire knowledge about the system, the degree to which it is as a user expects and the degree to which it can be used. This includes, for example, GUIs, CPI, training and alarm handling.\n - Learnability: The ease with which a user can gain or acquire knowledge about the system.\n - Understandability: Degree to which the system is as one expects.\n - Operability: Degree to which the system can be used.\n- **Performance/Efficiency:** This covers both the time taken and the computing resources required to complete specified activities.\n - Time behaviour: The time taken to complete given activities.\nResource behaviour: The computing resources required to complete given activities.\n\nMaintainability: Related to the effort needed to make specified modifications to both the generic system and customer specific versions. The design of system should be robust, stable, analysable, changeable and testable. The system should also provide logs and statistics to allow continuous monitoring. This includes corrective maintenance (diagnosis and correction of errors), adaptive maintenance (modifications to interfaces to adapt to a changing environment), perfective maintenance (enhancements to create new or modify existing functionality) and preventative maintenance (changes to improve future maintainability).\n\nRobustness/Stability: Ability to operate without failure when there has been an unintended change as part of a maintenance activity.\n\nPerformance Management/Statistics: Ability of the system to provide statistics, logs and information to the user in order to implement a performance management process for continuous monitoring of capacity utilisation and success rates for applications, platforms and interfaces.\n\nAnalysability: Ability for the system to be examined methodically and in detail in order to understand the impact of and make changes to the system. For example, artefacts that may help with this process are system architecture diagrams, system documentation and comments in code.\n\nChangeability: Ability for the system to be modified. This can be to complete any maintenance activity corrective, adaptive, perfective and preventative.\n\nTestability: Ability to confirm if an action, item, situation, etc is operating as desired.\n\nPortability: Related to the ability of software to be installed, upgraded or replaced. This also covers the degree to which a product can be customised/configured/adapted to meet the needs on a specific clients setting.\n\nInstallability: Capacity to place or fix into a new environment.\n\nUpgradability/Replaceability: Ease with which the system can replace or be replaced by a new version of the system or a different system that performs the same task.\nConfigurability/Product Customisability/Adaptability: Degree to which the system can adjust to new conditions.\n\n**Time:** Development time for a project and in particular release date.\n\n**Cost:** Total cost for development, primarily in terms of person-hours, but also other costs.\n\n**Intellectual Capital:** This area is made up of the following attributes:\n\n*Human Capital:* Human capital is held in the people employed by an organisation. It covers individuals’ education, experience, soft skills, and attitudes to work and life. It is affected by an employee’s satisfaction with their workplace. It consists of:\n\n Employee capacity: An individual's education, experience, tacit knowledge, competencies and soft skills. Education can be formal or informal, tacit knowledge is what people carry in their minds and is often difficult to write down, and soft skills refer to attributes like an individual's communication skills, entrepreneurship and creativity.\n\n Employee satisfaction: The difference between the employees' job satisfaction and their perception of the offering. It impacts organisational commitment and the capacity for an organisation to retain staff. Many factors impact an employee's satisfaction, for example salary, the physical work environment and how they feel fellow employees treat them.\n\n Employee sustainability: Individuals' attitudes to work and life. This encompasses an employee's conscientiousness and willingness to engage in lifelong learning, increasingly critical attributes in the current dynamic marketplace. As it is difficult to change an individual's attitude to work and life this issue is best addressed at the time of recruitment for a given role.\n\n*Structural Capital:* Structural capital is described as the intellectual capital that is retained by the organisation when all the employees go home. It includes the legally protected intellectual property, organisational culture and organisational processes. This includes the shared perceptions, assumptions, understandings and ways of working in the context of the organisation.\nOrganisational culture: Shared perceptions of organisational practices within organisational units and shared assumptions and understandings, often at a non-conscious level.\n\nOrganisational process: Activities with defined actions that become part of an organisation’s way of working and potential source of competitive advantage.\n\nInformation systems: Information systems can increase the value of intellectual capital to the business by successfully leveraging work processes and knowledge held within the organisation.\n\nIntellectual property: This covers both legally protected intellectual capital (e.g., patents, trademarks, copyright) and other documented materials (e.g., strategy, competitive market intelligence).\n\nRelational Capital: The relationships and networks that support an organisation are both formal and informal. Relational capital refers to the knowledge held in the relationships between a company and its customers (operators), customers (users), end users, suppliers, partners, community, regulators and competitors.\n\nCustomers (Service Provider): The legal entity that purchased the system. Accumulated knowledge between a company and a customer.\n\nCustomers (Operator): Expert users working at service provider. Accumulated knowledge between a company and a customer.\n\nEnd user: Subscribers to the telecommunications services.\n\nSuppliers: Relationship in supply chain management to achieve benefits such as reduced costs, greater quality, flexibility, reliable delivery – through methods like information sharing, technical assistance, training, direct investment.\nPartners: Build reputation and industry standing through strategic alliances, collaborative relationships, business partnerships, joint ventures and industry associations. These may be used to fill a gap in a market offering.\n\nCommunity: Trust based on corporate ethics, cooperation, collective action and reputation. Communities include both (i) professional, which the company can lead, share or take a more passive role; and (ii) social communities, including society-at-large.\n\nRegulators: Intelligence and knowledge of the legal environment and lobbying skills and contacts.\n\nCompetitors: Critical understanding and intelligence about competitors who they are and what are they doing.\nThe sustainable development of a software product depends on a number of groups working together to achieve a common goal. However, each of the groups interacts with the product in different ways, and can have conflicting aims and objectives. For example, developers trying to correct issues in the software architecture, which will impact future releases of the product, can be stopped by a project manager who is charged with delivering a release on time and within budget. While the functional requirements of a software product are usually documented, there are a number of other investments in software development that are not always as explicitly agreed upon but are still essential to a product’s long-term success. The major investment types include software product quality -- a main control variable in software development, and intellectual capital (IC) -- being the key input and tool used in software development.\n\nAs management requires measurement, it is necessary understand the priorities placed on investment options by the various groups involved in the development of a software product. The objective of this thesis is to develop a method capable of both determining the priorities of different groups for software product quality, and IC. The method elicited the required information from a series of case studies to build up a picture of the priorities placed on major investment options and constraints -- features, quality, IC, time and cost. The results highlight strengths, and areas for improvement -- through the identification of differing priorities and ambiguities in management of different aspects studied.\n\nIn conducting this research, systematic biases in the selection of requirements appear to be occurring, adding an objective to understand how bias impacts decision making in a requirements engineering context.\n\nThis thesis provides a method that determines the priorities on the level of investment on different options in the development of software products. It is concluded that people involved in the development of software need to be aligned on issues of software product quality as these priorities set expectations. The same was not found true for issues of IC, where groups can complete tasks without negatively impacting others, as long as the organisation works effectively as a single entity. On the issue of biases in the prioritisation of these aspects, prospect theory is found to apply to requirements selection in an academic experiment -- suggesting people will prefer functionality over software product quality, and to meet the known requirements of customers over predicting general market requirements."}}},{"rowIdx":255,"cells":{"id":{"kind":"string","value":"1f0185fcfa7286fac3cc1dcc8d013ccb49304078"},"text":{"kind":"string","value":"IBM 1130/1800 Macro Assembler Programming\n\nThis manual describes how to use the Macro Assembler of the 1130 Disk Monitor System, Version 2, and the 1800 Multiprogramming Executive Operating System, Versions 2 and 3. It should be used by programmers who have a basic knowledge of the assembler language and use this language to write programs for these systems.\n\nThis publication is supplemental to the 1130 and 1800 Assembler Language manuals and should be used in conjunction with them. This manual describes the 1130/1800 Macro Assembler: the definition and usage of the macro instruction, features of macro and assembler-language programming, and creation of a language for a specific need; the Macro Update Program; and the error messages, error flags, and warning flags of the Macro Assembler and Macro Update Program.\nFirst Edition (June, 1970)\n\nThis edition applies to the IBM 1130 Disk Monitor System, Version 2, and the IBM 1800 Multiprogramming Executive Operating System, Versions 2 and 3, and to all subsequent versions and modifications until otherwise indicated in new editions or Technical Newsletters. Significant changes and/or additions to the specifications contained in this publication are being made from time to time; therefore, before using this publication in connection with IBM systems, consult the latest SRL Newsletter, Order Number GN20-1130 or Order Number GN20-1800, for editions that are applicable and current.\n\nRequests for copies of IBM publications should be made to the IBM Branch Office serving your locality.\n\nForms are provided at the back of this publication for the reader's comments. If the forms have been removed, comments may be addressed to IBM Corporation, Programming Publications, Department D78, Monterey and Cottle Roads, San Jose, California 95114.\n\n© Copyright International Business Machines Corporation 1970\nPreface\n\nThis publication is a guide for assembler-language programmers of the 1130 Disk Monitor System, Version 2, or the 1800 Multiprogramming Executive Operating System, Version 3. It is supplemental to, and should be used in conjunction with, the 1130 and 1800 Assembler-Language manuals.\n\nThe first chapter, \"Introduction,\" discusses the fundamentals of the Macro Assembler: what it is, how it operates, how much main storage it requires, how fast it performs, what types of macros there are, how to incorporate macros into your system; and, briefly, the Macro Update Program and error detection.\n\nThe second chapter, \"The Macro Instruction,\" discusses how to define and use a macro instruction.\n\nThe third chapter, \"Macro Assembler Features,\" discusses conditional assembly pseudo-operations, the ANOP, SET, and PURG pseudo-operations, automatic name generation, concatenation, optional remarks, indirect parameter substitution, the division operator, and the symbolic tag field. At the end of this chapter is a section on programming techniques. This section includes a sample program and programming tips. The sample program is for 1800 MPX but is also valid for the 1130 (an 1130 DM2 sample program is in Appendix A).\n\nThe fourth chapter, \"Macro Assembler Language,\" describes how the Macro Assembler can be used to create a language for a specific purpose. The example is for the 1800 MPX system but is a general illustration that is also valid for 1130 users.\n\nThe fifth chapter, \"The Macro Update Program,\" describes how you can set up and maintain your macro libraries through various statements. These statements may refer to whole libraries, macros within the libraries, or statements within the macros.\n\nThe sixth chapter, \"Errors and Warnings,\" discusses the various error messages, error flags, and warning flags you may receive when using the Macro Assembler and the error messages you may receive when using the Macro Update Program.\n\nMarginal notes have been included in this publication to allow easy reference to matter within the text.\n\nThe coding forms used in this manual are: for Macro Assembler statements, the 1130/1800 Assembler Coding Form, Order Number GX33-8000; for other statements, the General Purpose Card Punching Form, Order Number GX20-8030.\nRequired Reading\n\n1130 publications:\nAssembler Language manual, Order Number GC26-5927\n\n1800 publications:\nAssembler Language manual, Order Number GC26-5882\nSystem Introduction, Order Number GC26-3718\n\nSuggested Reading\n\n1130 publications:\n\n1800 publications:\n\nError Messages and Recovery Procedures manual, Order Number GC26-3727, for information on the warning flags, error codes, and error messages.\nINTRODUCTION .................................................. 1\nThe 1130/1800 Macro Assembler ............................... 1\n The Macro Instruction ........................................ 1\n Pseudo-Operations .......................................... 3\n Nested Macro Definitions and Calls ......................... 3\n Main-Storage Requirements .................................. 3\n Macro Assembler Performance ................................ 4\nMacro Update Program .......................................... 4\nError Messages, Error Flags, and Warning Flag .............. 4\n\nTHE MACRO INSTRUCTION ...................................... 5\nDefining a Macro Instruction .................................. 5\n The Definition Prototype Statement ......................... 5\n An Example of Macro Definition .............................. 6\nUsing a Macro Instruction ..................................... 7\nSubstituting a Character String for a Parameter .......... 10\nContinuing Calls to Additional Records ...................... 12\n\nMACRO ASSEMBLER FEATURES ................................. 15\nConditional Assembly Pseudo-Operations ..................... 15\n AIF, AIFB Pseudo-Ops ...................................... 15\n AGO, AGOB Pseudo-Ops ..................................... 17\nUnspecified Parameter Checking ............................. 17\n Special Considerations Using AIFB and AGOB ............... 18\nANOP Pseudo-Operation ....................................... 19\nSET Pseudo-Operation ........................................ 20\nPURG Pseudo-Operation ........................................ 22\nAutomatic Name Generation ................................. 22\nConcatenation .................................................. 23\nOptional Remarks ............................................. 25\nIndirect Parameter Substitution ............................. 26\nDivision Operator ............................................. 27\nSymbolic Tag Field .......................................... 27\nProgramming Techniques ...................................... 28\n Checking for Blank Parameters .............................. 28\nRestrictions on AIF, AIFB, and SET Pseudo-Operations .... 29\nLabel and Blank Parameter Checking Using AGO .............. 30\nMacro Parameter Substitution ............................... 32\nSample Program .............................................. 33\n\nMACRO ASSEMBLER LANGUAGE ................................. 37\n\nTHE MACRO UPDATE PROGRAM ................................. 47\nInitializing Disk Space ..................................... 47\nSpecifying the Macro Library ............................... 48\nJoining Macro Libraries Physically ......................... 48\nJoining Macro Libraries Logically ......................... 49\nUpdating a Macro in a Library .............................. 50\nRenaming a Macro in a Library .............................. 51\nDefining a Macro During a Macro Update Run ............... 51\n ADD Statement ............................................. 52\nDeleting a Macro From a Library ............................ 53\nPunching Source Statements ................................. 54\nInserting a Statement in a Macro ......................... 54\nDeleting a Statement from a Macro ........................ 55\nObtaining a Listing of Macro Libraries by Statements or Macros 56\n Special Requirements on the Use of Automatic Name Generation in Nested Definitions 57\nDesignating Comments ....................................... 58\nTerminating a Macro Update Run ............................. 58\nSequencing MUP Control Statements ......................... 59\nTables\n\nTable 1. Error Flags .............................................. 64\nTable 2. Macro Assembler Error Codes and Messages. .......................... 65\nTable 3. Macro Update Program Error Messages ............................. 66\nThe 1130/1800 Macro Assembler\n\nThe 1130/1800 Macro Assembler allows you to condense a sequence of assembler-language coding that you use over and over again into one instruction, a macro instruction.\n\nIf you use the Macro Assembler, you can generalize a sequence of coding and then modify it slightly each time it is used. You code the sequence only once, defining macro parameters that cause the appropriate code to be generated for a particular use. The exact code generated when the macro instruction is used is based on the conditional assembly, automatic name generation, and/or parameter substitution facilities of the Macro Assembler.\n\nThe Macro Assembler also allows you to define a language that is unique to your application; such a language may be simple and/or meaningful enough to be used by a person other than a professional programmer.\n\nTHE MACRO INSTRUCTION\n\nA macro instruction, or macro, is a source program statement. When the Macro Assembler encounters a macro, it expands the macro by processing a sequence of assembler-language statements. This sequence must have been defined in a macro definition before it can be used.\n\nWhen you define a macro, you specify its operation code (macro name), its parameters, and the sequence of assembler-language statements to be processed when the Macro Assembler encounters the macro name in a source program.\n\nUsing the Macro Assembler, you can define two kinds of macros, temporary macros and stored macros. You should define every macro as a temporary macro until you are sure that it will execute properly. If it does execute properly, and you want to store it, you can include it in a macro library.\n\nTEMPORARY MACROS\n\nA temporary macro can be used only during the assembly of the program in which it is defined. This kind of macro isn't saved by the system; if you want to use it in another program, you have to define it again during assembly of that program. You do not have to define stored macros in order to use temporary macros.\n\nIf temporary macros are to be defined, you will need an *OVERFLOW SECTORS control statement. Two new parameters, N2 and N3, have been added to this statement. The N1 parameter remains the same. N2 is the number of sectors you allocated for the overflow of macro parameters from main storage to\ndisk. This parameter can be zero, and space will not be required if the overflow from a macro that is defined or called with another macro definition never exceeds 100 words. The required size of N2 may be estimated by using the following formula:\n\n\\[ \\text{Number of words} = 3 + N + \\sum_{i=1}^{N} \\frac{1}{2} (m_i + 1) \\]\n\nN is the number of parameters and \\( m_i \\) is the number of characters per parameter. For example, the call \\text{EXPND} \\text{ALPHA,BETA,C} would be computed as:\n\n\\[ 3 + 3/2 + (5+1)/2 + (4+1)/2 + (1+1)/2 = 12 \\text{ words} \\]\n\nThe remainders of individual terms are ignored. N3 is the number of sectors you allocated for temporary macro definitions. You can estimate the number of sectors needed by dividing the total number of statements in all macro definitions within the assembly by 40. If you want to retain remarks, you may have to increase N3 to accommodate them. For further information on the *OVERFLOW SECTORS statement, see the 1130 Programming and Operator’s Guide, Order Number GC26-3717, or the 1800 Programmer’s Guide, Order Number GC26-3720.\n\nSTORED MACROS\n\nA stored macro, on the other hand, resides on disk in a macro library and can be used by any program. When you assemble a program that uses or defines stored macros, you must specify which macro library you wish to use during the assembly with the *MACLIB Macro Assembler control statement.\n\nThe macro library specified on the *MACLIB statement must be defined and initialized before it can be used by the Macro Assembler. For details on how to initialize a macro library, refer to the discussion on initializing disk space in the chapter \"The Macro Update Program.\" The *MACLIB statement enables you to access one library selectively without having to access all of the stored macros. Multiple macro libraries may be accessed in one assembly if you logically concatenate the libraries before the assembly. Additional information on macro libraries may be found in the chapter on the Macro Update Program.\n\nYou cannot define a stored macro within an assembly unless you have used an *MACLIB statement. If your program attempts to call a stored macro which cannot be found in the specified library, the macro call will be flagged as an illegal operation. The format of the *MACLIB is as follows:\n\n```\n*MACLIB LNAME\n```\n\n<table>\n<thead>\n<tr>\n<th>1-10</th>\n<th>11-20</th>\n<th>21-30</th>\n<th>31-40</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1234567890</td>\n<td>1234567890</td>\n<td>1234567890</td>\n<td>1234567890</td>\n</tr>\n</tbody>\n</table>\n\n2 1130/1800 Macro Assembler Programming\nLNAME is the name of the macro library to be used in the current assembly. For further information on the *MACLIB statement, see the 1130 Programming and Operator's Guide, Order Number GC26-3717, or the 1800 Programmer's Guide, Order Number GC26-3720.\n\n**PSEUDO-OPERATIONS**\n\nPseudo-operations, or pseudo-ops, extend the capabilities of the assembly process. Pseudo-ops are written like assembler-language statements, but they are used to provide information to the Macro Assembler rather than to generate executable code for the program. They can appear anywhere within an assembler-language program, providing you follow the other rules for their use.\n\nSeveral new pseudo-ops have been included for use in programs that use the Macro Assembler. These are described in detail under \"Features of the Macro Assembler\" and perform the following functions:\n\n- Defining the beginning and the end of a macro definition.\n- Determining during an assembly whether certain statements are to be processed, based on a specific condition.\n- Permitting a program label to be set to two or more different values at different points in a program without a multiple-definition error condition.\n- Logically removing a macro from a library.\n\n**NESTED MACRO DEFINITIONS AND CALLS**\n\nA macro can be defined or called within another macro definition. This process is called nesting. The nesting of macro definitions is limited only by the physical size of your system. You may want to nest definitions to allow the dynamic definition (with decisions) of an inner macro when you are expanding the outer macro. This can also be used to advantage to conserve library space if the same code is being used in both macros (the inner one can be called only by the outer one).\n\nThe nesting of macro calls is limited to 20 calls per nest. You may wish to nest calls to macros so that values from one macro can be passed to the other macro.\n\n**MAIN-STORAGE REQUIREMENTS**\n\n**THE 1130**\n\nIn the 1130 Disk Monitor System, Version 2, the Macro Assembler functions as and is fully compatible with the 1130 Disk Monitor System, Version 2, Assembler. However, the Macro Assembler requires 8K words of main storage for the macro capability. The symbol table in main storage has been reduced in size to accommodate approximately 750 words for the resident macro processor. Assemblies that almost\nexhaust the symbol table area of the Assembler will probably require symbol table overflow sectors for successful assembly using the Macro Assembler (see the 1130 DM2 Programming and Operator's Guide, Order Number GC26-3717). The pseudo-operations SET, ANOP, AIF, and AGO (discussed later) are also available to the 4K 1130 user.\n\nTHE 1800\n\nThe 1800 MPX Macro Assembler requires a VCORE of 5140 words. It occupies no more main storage than, and is fully compatible with, the 1800 MPX Version 1 Assembler.\n\nMACRO ASSEMBLER PERFORMANCE\n\nIf you have a program that has been assembled successfully under the 1130 Disk Monitor Version 2 Assembler or the 1800 MPX Version 1 Assembler, the performance of the Macro Assembler will be approximately equal to that of the earlier Assemblers. Assembly time will be greater for new programs if the Macro Assembler encounters either a macro definition, a macro call, or an invalid op code. In the case of an invalid op code, the Macro Processor of the Macro Assembler will search the temporary macros and/or the specified macro library to determine whether the unrecognized op code is the name of a macro.\n\nMacro Update Program\n\nThe Macro Update Program assists you in initializing and maintaining macro libraries. Using this program, you can add or delete macros from your library, alter those that are already in your library, physically or logically join two libraries, and perform other functions necessary to maintaining macro libraries.\n\nError Messages, Error Flags, and Warning Flag\n\nDuring the assembly process, the Macro Assembler checks for source program errors. If an error is detected, an error flag or an error code and message are printed. If a questionable instruction is encountered, it is flagged with the warning flag (Q). At the end of each assembly, the Macro Assembler prints a message to indicate the number of errors and warnings it encountered during that assembly. Any errors in the Macro Update Program are detected by the Disk Utility Program (DUP) for the 1130 or the Disk Management Program (DMP) for the 1800.\nDefining a Macro Instruction\n\nA macro definition can appear any time after the Macro Assembler has completed processing the control statements. The definition must appear before the first call to the macro.\n\nThe first statement in a macro definition in an assembly must be the MAC (for a temporary macro) or the SMAC (for a stored macro) statement. The last statement of a macro definition must be the MEND statement. The pseudo-op names MAC, SMAC, and MEND must appear in the op code fields of the statements.\n\nNo label and no operand are required on these statements. Column 35 of the MAC and SMAC statements can be used to specify that remarks are retained so that they can be printed on listings (see \"Optional Remarks\"). Note that if you exercise this option, you will need additional disk space to accommodate these remarks. Comment statements (* in column 21) within the definition are always retained and listed within the expansion.\n\nTHE DEFINITION PROTOTYPE STATEMENT\n\nThe statement immediately following the MAC or SMAC statement is called the definition prototype statement. This statement contains the macro name in its op code field. The macro name may be from one to five characters long. You cannot use a period, a comma, and a left or right parenthesis in macro names. A macro name can contain embedded blanks or can consist of all blanks. An invalid macro name is flagged as an illegal op code.\n\nIf you define a stored macro with a name that is already in the library named in the *MACLIB statement, it will be flagged as an invalid macro name. A temporary macro of the same name will not be flagged; it will be expanded when the macro is called since the temporary macros are searched before the stored macros. An apostrophe should not be used in the name of a stored macro because once this macro has been stored, it cannot be modified or removed from your library.\n\nThe label and operand fields of the definition prototype statement contain the names of parameters which are supplied when the macro is used. A parameter name can be any valid assembler-language symbol; an invalid parameter name is flagged as an op code error. You may use an op code as a parameter, but it must be done carefully because substitution will occur for all uses of the op code. Parameter names in the operand field are separated by commas. Do not include a blank within a parameter name or between parameters, as a blank terminates the parameter list. If the label field is blank, it is ignored when the macro is used. The definition prototype statement must\ndefinition\n\nconsist of one source statement; no continuation is allowed. A maximum of 20 parameter names is allowed.\n\nThe text of the macro follows the definition prototype statement and is a sequence of assembler-language instructions, calls to other macros, and/or pseudo-ops. The statements in the text may contain the parameter names specified in the definition prototype statement. During assembly, the parameters specified in the call to the macro are substituted positionally for the corresponding parameter names in the text statements (see \"An Example of Macro Definition\"). Whenever the Macro Assembler prints macro definition prototype statements, five-digit decimal sequence numbers are printed to the left of each statement.\n\nobtaining a listing\n\nThe list control pseudo-operations (see the 1130 Assembler Language manual, Order Number GC26-5927, or the 1800 Assembler Language manual, Order Number GC26-5882) can be used within a macro definition to control the listing of a macro call. If you use an 1800, you may inhibit printing by turning sense switch 2 to the ON position.\n\nparameter substitution\n\nYou can substitute a parameter into any field or subfield of a text statement in the macro definition. A parameter substituted into the operand field of a text statement may be any valid assembler-language expression. The number of characters in the parameter name has no relationship to the number of characters actually substituted, except in the case of format and tag fields. Both the parameter name and the parameter substituted must be exactly one character long in order for the parameter to be substituted correctly into the format or tag field. Note that the number of characters in a parameter on a call may also be significant. For example, an increase in the number of characters caused by the substitution of longer parameters during the expansion may cause the operand field (columns 35-71) to be exceeded. Any information beyond column 71 will be ignored.\n\nspecial characters\n\nThe slash, comma, period, plus sign, minus sign, and asterisk retain their usual meaning. When a blank occurs in an operand field (except where permitted by the assembler language), the rest of the operand field is ignored. Special characters used in Macro Assembler statements must conform to the character code summaries as listed in the 1130 Assembler Language manual, Order Number GC26-5927, or the 1800 Assembler Language manual, Order Number GC26-5882.\n\nAN EXAMPLE OF MACRO DEFINITION\n\nThe temporary macro SUM is completely defined by the following sequence. A definition of the macro SUM is shown below and the call and statements generated by the call are shown in the next section.\nUsing a Macro Instruction\n\nAfter a macro has been defined, you call it by using its name as an op code and specifying in the label and/or operand field the parameters to be substituted for the parameter names in the definition prototype statement. The parameter names must follow the order outlined under \"The Definition Prototype Statement.\" If a parameter name is omitted (two commas in a row or a trailing comma), it is ignored when the macro is used.\n\nWhen the Macro Assembler encounters a macro instruction, it processes the statements in the macro definition text with the parameters you have specified for substitution.\n\nThe assembled instructions are listed along with the macro call in the assembly listing. Any statement within a program that is a result of a macro expansion is flagged with a plus sign to the left of the label field of the Macro Assembler listing.\n\nA sample definition of the macro SUM was illustrated in the previous section. Below is an example of a call to that macro, and the code generated by that call.\nParameters specified in the call to SUM are substituted for the dummy parameters of the SUM definition prototype statement. LOOP is substituted for NAME, 2 for X, 10 for COUNT, FROM for LIST, and TEMP for STOR. There's nothing special about the parameter in the label field of the call; it's substituted just like any other parameter. In fact, it need not even be used as a label in a macro definition; it can be used as an op code or an operand. For example, the macro DIVBY could be defined as follows (note that a while A appears in the label field of the definition prototype statement, it is used as an operand in the text of the macro):\n\nWhen you call a macro, you may want to leave out one or more of the parameters. If the parameter to be left out would ordinarily be in the label field of the call, just leave it out. If the parameter would ordinarily appear followed by a comma in the operand field, leave out the character string to be substituted, but include the comma that would ordinarily follow the parameter. If the parameter ordinarily comes at the end of the operand field, you may leave it out. If you leave out one or more parameters that ordinarily come at the end, you may leave out all the commas that immediately precede them. If you anticipate omitting parameters that will be parts of AIF or AIFB expressions, refer to the section \"Unspecified Parameter Checking\" for restrictions on this operation.\n\nThe following examples illustrate the omission of parameters.\nThe macro DCS generates DC statements. For example:\n\n```\nM A C\nD C S\nD C\nD C\nD C\nM E N D\n```\n\nwould generate\n\n```\nD C S\nD C\nD C\nD C\n```\n\nOmitting parameter B in a call\n\n```\nD C S\nD C\nD C\n```\n\nwould cause\n\n```\nD C\nD C\nD C\n```\n\nto be generated. Note that the operand of the second DC statement is blank because its associated parameter was omitted.\n\nYou should be extremely careful when omitting parameters because nothing is substituted for the parameter that is missing. Consider the following example; in the first call, the parameter is not missing and the code is generated properly. In the second call, the second parameter is missing and the generated code is in error.\nSubstituting a Character String for a Parameter\n\nYou can substitute a character string containing embedded blanks and special characters (such as commas, periods, or slashes) for a macro parameter name by enclosing the string in parentheses. This makes it easy to pass a set of parameters to a nested macro call. However, you must be careful in passing character strings to ensure that parameters do not exceed the record length, as any information beyond column 71 will be ignored.\n\nAssume in the example given below that SEE is a previously defined macro with a maximum of three parameters specified in the operand field. If another macro SCAN calls SEE, parameters may be passed to SEE as shown:\nWithout this facility the same SCAN macro would have to be defined as follows in order to generate the above statement sequence. Notice that this second method may be restrictive in passing parameters, because a definition prototype statement may have no more than 20 parameters.\n\nYou can also use character-string substitution to generate messages. An example of this is given below.\n\n<table>\n<thead>\n<tr>\n<th>Label</th>\n<th>Operation</th>\n<th>F</th>\n<th>T</th>\n<th>Operands & Remarks</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>21</td>\n<td>'SCAN'</td>\n<td>MACRO, DEFINITION</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>MAC</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>SCAN</td>\n<td>D, H</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>LD</td>\n<td>D</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>SEE</td>\n<td>H</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>MEND</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>22</td>\n<td>'SCAN'</td>\n<td>TABLE, (VAL1, VAL2, VAL3)</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>LD</td>\n<td>TABLE</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>SEE</td>\n<td>VAL1, VAL2, VAL3</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nThe Macro Instruction 11\nContinuing Calls to Additional Records\n\nA call to a macro may be too long to fit on one record, so the Macro Assembler allows calls to be continued onto one or more additional records. When you call a macro, you indicate that there is another record in the call by placing any character other than a blank in the format field (column 32). You can then continue the macro call beginning in column 35 of the next record. The first 31 columns of the next record are ignored; column 32, if used, specifies continuation of the call onto still another record.\n\nNote that on continued calls, you must be careful in substituting parameters that have more characters than those in the original definition, because you may cause the operand field to be exceeded on either the CALL record or any subsequent continuation records. Therefore, some of your values may be lost (see \"Macro Parameter Substitution\" in the section on programming techniques).\n\nWhen a macro call is continued onto an additional record, the Macro Assembler will stop its parameter scan of the first record when either there is a blank (not within parentheses) in the operand field or the operand extends to and includes column 71. The next character in your parameter list is assumed to be in column 35 of the next record.\n\nUsing parentheses and continuation records, you can replace any number of consecutive fields in a macro definition statement. Look at this example:\nHere's a call to the ONION macro:\n\n```\nLabel Operation F T 35 40 45 50 55\n21 25 27 30 32 33\n1...1 MAC\n1...1 ONI ON\nA...1 LD\nB...1\n1...1 S.TO\n1...1 M. E. N. D\n```\n\nA punch other than a blank (the S in the above example) in the format field means that the macro call is continued on a second record.\n\nThe following code is generated from the above macro call.\n\n```\nLabel Operation F T 35 40 45 50 55\n21 25 27 30 32 33\nNAME LD ADDR LD XYZ\nS.R.T.\nS.TO.\n```\n\nIn the macro call, the instruction NAME LD ADDR replaces the label. The remaining fields, LD XYZ, are displaced to the right. The Macro Assembler treats these fields as remarks because in this example there are two blanks after ADDR.\nConditional Assembly Pseudo-Operations\n\nYou may want different calls to the same macro to produce different lines of assembled code, depending on some condition to be examined during the assembly. Conditional assembly pseudo-ops allow you to do this. These pseudo-operations do not generate any executable code and do not modify the address counter.\n\nApplications which require slight code modifications to a general technique need be coded only once using conditional assembly pseudo-ops within macro calls. This saves time for the programmer.\n\nAIF, AIFB PSEUDO-OPS\n\nTwo conditional-assembly pseudo-ops, the \"assemble if\" and \"assemble if back\" pseudo-ops AIF and AIFB, have the following format:\n\n- An optional label.\n- The op code (AIF, AIFB).\n- In the operand field, a left parenthesis, an expression, one or more blanks, a condition, one or more blanks, another expression, a right parenthesis, a comma, and a name.\n\nThe two expressions can be any valid assembly expressions. The name should be a valid assembler-language symbol or may be left blank. It may also be any combination of from one to five characters if this combination is used in the label field of one of these pseudo-ops: AIF, AIFB, AGO, AGOB, ANOP, PURG, LIST, EJCT, HDNG, MEND, END, or SPAC. All symbols used within AIF or AIFB statement expressions must have been predefined or the statement will be flagged with a U (undefined symbol). If the name is left blank, the statement will be flagged with a warning flag (Q).\n\nThe condition must be one of the following:\n\n- EQ—Equal to\n- GT—Greater than\n- LT—Less than\n- NE—Not equal to\n- GE—Greater than or equal to\n- LE—Less than or equal to\n\nDuring assembly, the condition statement between the parentheses is evaluated. If it is true, the AIF statement causes all the following statements to be skipped (and not processed) until the Macro Assembler finds a statement with a label corresponding to the symbol specified in the AIF statement. If the statement between the parentheses is false, the assembly continues with the statement immediately.\nfollowing the AIF statement. The AIF statement may be used anywhere in a assembler-language program.\n\nThe AIFB (AIF back) statement functions as the AIF statement, except that the Macro Assembler returns to the beginning of the current (innermost within a nest) macro definition being expanded (called) before searching for a label. Unlike the AIF statement, the AIFB statement may occur within a macro definition only; it is flagged as an illegal op code if it appears outside of a macro definition. If the search is unsuccessful, the MEND statement will terminate the search and the expansion of that macro.\n\nIf the name subfield of the AIF or AIFB operand is left blank and the label search is to be performed, statements are skipped until the first statement with no label is encountered, at which time assembly continues. In any case, when a label search is performed, the search can continue until an END statement is encountered; the END statement will be processed and flagged with a Q. If the AIF statement is in a definition, a MEND statement will terminate the search.\n\nLet's look at an example of the use of AIF.\n\nThe assembly of this code depends on the values of X+1 and Y when the Macro Assembler evaluates them. If they are not equal, all the instructions shown above are processed. If they are equal, only the following three instructions are assembled.\n\nThe assembly of this code depends on the values of X+1 and Y when the Macro Assembler evaluates them. If they are not equal, all the instructions shown above are processed. If they are equal, only the following three instructions are assembled.\n\n16 1130/1800 Macro Assembler Programming\nNotice that the second AIF has a blank name field. As a result, the first instruction following this statement with a blank label field is assembled.\n\n**AGO, AGOB PSEUDO-OPS**\n\nTwo other instructions are used along with AIF and AIFB to effect conditional assembly. These pseudo-ops, AGO and AGOB, cause unconditional branching and have the following format:\n\n- An optional label.\n- The op code (AGO, AGOB).\n- A valid assembler-language symbol or five blanks in the operand field. If the name field is left blank, the statement will be flagged with a warning flag (Q).\n\nThe name should be a valid assembler-language symbol, or may be left blank. It may also be any combination of from one to five characters if this combination is used in the label field of one of these pseudo-ops: AIF, AIFB, AGO, AGOB, ANOP, PURG, LIST, EJCT, HDNG, MEND, END, or SPAC.\n\nThe AGO statement causes the Macro Assembler to skip (and not process) statements following the AGO statement until it encounters a statement with a label corresponding to the symbol specified in the AGO statement. See the ANOP section of this manual for an example of the use of the AGO instruction. The AGO statement may be used anywhere in an assembler-language program.\n\nThe AGOB (AGO back) statement functions as the AGO statement, except that the Macro Assembler returns to the beginning of the current (innermost within a nest) macro definition being expanded before performing the label search. If the search is unsuccessful, the MEND statement will terminate the search. Unlike the AGO statement, the AGOB statement may occur within a macro definition only; it is flagged as an illegal op code if it appears outside of a macro definition.\n\nIf the operand of the AGO or AGOB statement is left blank and the label search is to be performed, statements are skipped until the first statement with no label is encountered. In any case, when a label search is performed, the search can continue until an END statement is encountered. Like the AGOB statement, if the AGO statement is in a definition, a MEND statement will terminate the search.\n\n**UNSPECIFIED PARAMETER CHECKING**\n\nThe name searching technique used by the AIF and AGO pseudo-ops may be utilized in checking for unspecified parameters.\n\nAssume that the COUNT parameter on the following prototype statement is a count of how many data words are to be moved from one area to another.\nIf COUNT is not specified in a call to MOVE, the name search prompted by the AGO COUNT statement will be terminated on the ANOP statement that follows immediately, because a blank was substituted for COUNT and the ANOP has a blank label field.\n\nIf COUNT is specified, the COUNT that is a label on an ANOP statement will be replaced with the COUNT specified in the call. Thus, the name search prompted by the AGO COUNT statement will terminate on the ANOP statement that has COUNT as a label.\n\nSPECIAL CONSIDERATIONS USING AIFB AND AGOB\n\nNote that if the AIFB or the AGOB causes a second assembly of the same code, multiple label definition errors may occur. It is your responsibility to ensure that the label to be skipped to is either unique or not entered in the symbol table, that is, a label on an AIF, AIFB, AGO, AGOB, SPAC, EJCT, HDNG, LIST, MEND, END, PURG, or ANOP statement. Also note that with the capability of the AIFB and AGOB, you can put the Macro Assembler into a loop. This will occur if the conditions never get changed, thus causing the Macro Assembler to loop between the AIFB and AGOB statements. The call below will cause the AIFB expression to be evaluated always as true (8 LE 20) because the AIFB to A will cause a branch to the first statement labeled A within the macro. Thus, the Macro Assembler will loop interminably between \"A SET X\" and the AIFB statement.\n\n<table>\n<thead>\n<tr>\n<th>Label</th>\n<th>Operation</th>\n<th>F</th>\n<th>T</th>\n<th>FF</th>\n<th>TT</th>\n<th>FF</th>\n<th>TT</th>\n<th>FF</th>\n<th>TT</th>\n<th>FF</th>\n<th>TT</th>\n<th>FF</th>\n<th>TT</th>\n<th>FF</th>\n<th>TT</th>\n<th>FF</th>\n<th>TT</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>21</td>\n<td>MAC</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>25</td>\n<td>MOVE FROM,T0,COUNT</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>27</td>\n<td>AG0</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>30</td>\n<td>COUNT</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>X</td>\n<td>SET</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>32</td>\n<td>AG0</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>33</td>\n<td>B,EGIN</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>COUNT</td>\n<td>ANOP</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>X</td>\n<td>SET</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>B,EGIN</td>\n<td>ANOP</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>*</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>*</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>*</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>MEND</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n18 1130/1800 Macro Assembler Programming\nANOP Pseudo-Operation\n\nThe purpose of the ANOP pseudo-op is to provide a label which an AIF, AGO, AIFB, or AGOB can reference to resume assembling. Assembling an ANOP label has the same effect as assembling the instruction immediately following it. The label on an ANOP is not placed in the symbol table, so statements other than AIF, AGO, AIFB, and AGOB can't use it as a reference. This is also true of other labels as discussed previously under \"Special Considerations Using AIFB and AGOB.\"\n\nThe format of the ANOP statement is:\n\n- A label.\n- The op code ANOP.\n\nThe ANOP pseudo-operation allows you to associate temporary and permanent labels with the same instruction. Thus, the temporary label can be used to clarify a conditional assembly sequence while the permanent label can be used to clarify the instruction sequence.\n\nThe following is an example of a way in which ANOP might be used. In this example, A is assumed to have been defined prior to the AIF statement.\nWhen A is less than 0, the generated code is:\n\n\\[\n\\begin{align*}\n\\text{SET} & 01 \\\\\nL & D \\\\\nS & T \\ C h\n\\end{align*}\n\\]\n\nWhen A is greater than or equal to 0, the generated code is:\n\n\\[\n\\begin{align*}\n\\text{SET} & 01 \\\\\nL & D \\\\\nS & T \\ C h\n\\end{align*}\n\\]\n\nANOP is useful when you're using the SET pseudo-op. An example of this usage is given in the \"SET Pseudo-Operation\" section.\n\nSET Pseudo-Operation\n\nSET allows you to assign a value to a symbol and, later in the assembly, assign another value to the same symbol without a multiple label definition error resulting. The symbol retains the value of the last SET statement associated with it from the first pass of the Macro Assembler until the Macro Assembler encounters an associated SET in the second pass. You can't use the EQU statement this way because the EQU statement is not processed on the second pass of the Macro Assembler and, consequently, cannot be used to change the value of a symbol during the assembly.\n\nThe format of the SET statement is:\n\n- A label.\n- The op code SET.\n- A valid assembler-language expression in the operand field.\n\nThe label is set equal to the value of the expression in the operand field. Any symbols used within the expression on a SET statement must have been predefined, or the statement will be flagged with a U (undefined symbol).\nHere's an example of the use of SET. Suppose A is the starting address of some data to be sent to disk, and B is the address of the end of the data. Assume we know the data will take up no more than two sectors and we want to set SECT equal to the number of sectors. The Macro Assembler automatically calculates the value of SECT in the following statement sequence.\n\n<table>\n<thead>\n<tr>\n<th>Label</th>\n<th>Operation</th>\n<th>F T</th>\n<th>Operands & Remarks</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>21</td>\n<td>25</td>\n<td>27</td>\n<td>B-A</td>\n</tr>\n<tr>\n<td></td>\n<td>EQU</td>\n<td>30</td>\n<td></td>\n</tr>\n<tr>\n<td>21</td>\n<td>25</td>\n<td>27</td>\n<td>N-320</td>\n</tr>\n<tr>\n<td></td>\n<td>SET</td>\n<td>30</td>\n<td></td>\n</tr>\n<tr>\n<td>21</td>\n<td>25</td>\n<td>27</td>\n<td>(K,L.E.,0).ONE</td>\n</tr>\n<tr>\n<td></td>\n<td>AIF</td>\n<td>30</td>\n<td></td>\n</tr>\n<tr>\n<td>21</td>\n<td>25</td>\n<td>27</td>\n<td>2</td>\n</tr>\n<tr>\n<td></td>\n<td>SET</td>\n<td>30</td>\n<td></td>\n</tr>\n<tr>\n<td>21</td>\n<td>25</td>\n<td>27</td>\n<td>0.K</td>\n</tr>\n<tr>\n<td></td>\n<td>AGO</td>\n<td>30</td>\n<td></td>\n</tr>\n<tr>\n<td>21</td>\n<td>25</td>\n<td>27</td>\n<td>ONE</td>\n</tr>\n<tr>\n<td></td>\n<td>ANOP</td>\n<td>30</td>\n<td></td>\n</tr>\n<tr>\n<td>21</td>\n<td>25</td>\n<td>27</td>\n<td>1</td>\n</tr>\n<tr>\n<td></td>\n<td>SET</td>\n<td>30</td>\n<td></td>\n</tr>\n<tr>\n<td>21</td>\n<td>25</td>\n<td>27</td>\n<td>(next instruction)</td>\n</tr>\n</tbody>\n</table>\n\nIn the above example, N, the difference between B and A, is compared to 320 by the AIF instruction. If the difference is greater than 320, the first SET following the AIF statement sets SECT to 2. The AGO then causes the assembly to continue around the next SET and the assembly proceeds.\n\nIf the difference (N) is less than or equal to 320, AIF causes the assembly to continue at ONE. This is equivalent to a continuation at the second SET following the AIF statement, since ONE is an ANOP instruction. Notice that it is impossible to branch directly to the correct SET instruction, since two SET instructions in the sequence contain the label SECT. If the AIF statement specified a branch to SECT, the Macro Assembler would continue processing with the next statement having SECT in its label field—in this case, the wrong instruction.\n\nHere's another example of a macro that uses SET.\nGiven variables A and B, the TAB macro defines a constant equal to A times B. It next defines a constant equal to this product times B. It continues this way until the result reaches a specified value, C. Note that if A and B are equal, TAB builds a table of powers of B.\n\nPURG Pseudo-Operation\n\nThe PURG pseudo-operation removes the specified macro name from the macro library associated with the assembly by the *MACLIB control statement. PURG causes operations to occur only on the library associated with the *MACLIB control statement; it does not affect any other library even if it has been concatenated to the associated library (see MUP section on \"Joining Macro Libraries Logically\").\n\nYou can then define another macro with the same name, but the space occupied by the purged macro isn't available for reuse until the next DMP/DUP macro update job is performed on the library (see \"Macro Update Program\"). The space is reclaimed by any macro update function run on that library.\n\nThe format of the PURG statement is:\n\n- Optional label (can be used as a target for pseudo-ops).\n- Op code PURG.\n- Macro name in the operand field.\n\nThe macro name must be enclosed in apostrophes (the first apostrophe must be in column 35). If the macro name is not properly formatted, is missing, or cannot be found, the PURG statement will be flagged with a warning flag (Q) and the PURG operation will not be performed.\n\nAutomatic Name Generation\n\nIf your macro definition contains a label that isn't a parameter of the macro, and if you call the macro more than once in a given assembly, you'll get a multiple-definition error for that label. You can get around this problem by making all labels used in macros parameters of the macros, but then you have to supply all the labels every time you call a macro. An easier method to use is automatic name generation.\n\nInstead of writing out a complete label in the macro definition, you write from one to four alphameric characters, the first of which must be alphabetic, followed by an apostrophe. Each time a macro is called in a given assembly, the Macro Assembler replaces the apostrophe with a number—a different number each time.\n\nThe number of digits added to your label always causes a five character label to be generated. For example, repeated uses of the label P' result in the labels P0001, P0002, P0003, and so on. Repeated uses of the label PAM' result in PAM01, PAM02, PAM03, and so on.\n\nThe digits inserted into your label by the above method are determined by a counter maintained by the Macro Assembler. When the Macro Assembler encounters a macro that utilizes the automatic name generation feature, the counter is\nincremented by one and remains at that value until the expansion of that macro is complete. This causes a problem when other macro calls are included in the first macro (that is, the nesting of macros) and one of them is called twice. MAC3 in the diagram at the left is called twice within the nest. If MAC3 contains labels in the form of letters followed by an apostrophe, the same set of labels will be generated twice because the counter is not incremented until MAC1 is completed.\n\nThe way around this problem is to place an apostrophe before the characters in the label. The Macro Assembler replaces this apostrophe with a different alphabetic character (beginning with A) each time a macro is called within a given nest. Thus, if the label 'RAB' is used in a macro and the macro is called four times in the same nest, the labels generated are ARAB, BRAB, CRAB, and DRAB.\n\nYou can use apostrophes at both the beginning and the end of a label; in fact, this is the simplest way of ensuring that you don't get multiply-defined labels. The label 'C' can result in labels from AC001 through TC999 (T rather than Z because only 20 levels of macro nesting are allowed). The label 'SPY' can result in labels from ASPY1 through TSPY9.\n\nNote that if you alternately call macros with automatic name generation, the numbers of the generated labels will also alternate. For example, if you call two macros alternately and the first has a label C' and the second has a label D', the resulting labels would be C0001, D0002, C0003, D0004, and so on.\n\nThe Macro Assembler also automatically generates labels in the remarks field (not on comment records) of assembler-language statements. For this reason, you must be careful when using apostrophes within a remark.\n\nConcatenation\n\nBy concatenating two parts of a field, you can join a parameter to a character string, two parameters, or two character strings. You can use either a period or an ampersand as a concatenator. The ampersand functions as a concatenator only if it appears as the first character in a parameter of a definition prototype statement. Otherwise, it functions as a plus operator. If you use the ampersand as a concatenator, you may use six characters, including the ampersand, for the parameter name.\n\nThe following example shows several uses of period concatenation.\nUsing the above definition with the macro calls below, the code following the calls would be generated.\n\n<table>\n<thead>\n<tr>\n<th>Label</th>\n<th>Operation</th>\n<th>F</th>\n<th>T</th>\n<th>Operands & Remarks</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>M</td>\n<td>'MOVE'</td>\n<td>0</td>\n<td>2</td>\n<td>MACRO, CALL</td>\n</tr>\n<tr>\n<td>F</td>\n<td></td>\n<td>1</td>\n<td>5</td>\n<td></td>\n</tr>\n<tr>\n<td>X</td>\n<td>'FIRS'</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>X</td>\n<td>'FIRS'</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>A</td>\n<td>'ABLE'</td>\n<td>3</td>\n<td>1</td>\n<td></td>\n</tr>\n<tr>\n<td>X</td>\n<td>'ABLE'</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nNotice that in the above examples, parameter substitution does not occur for A and B in the names A.B.C and B.B.C. You need to be careful when you are using any op code as a parameter, because substitution will occur for all uses of that op code.\n\nThe following examples show several ways in which the ampersand can be used as a concatenator. Notice in the second example that the B in the macro definition is not preceded by an ampersand and, therefore, the B is a parameter, but the &B is not.\nBecause a period is used frequently as a decimal point when writing DEC and XFLC statements, the Macro Assembler inhibits period concatenation when writing these statements. The ampersand concatenation feature may still be used.\n\n### Optional Remarks\n\nWhen you define a macro, you specify whether or not you want remarks on the macro definition statements to be reproduced each time the macro is expanded. If you want to keep the remarks, place any nonblank character in column 35 of the MAC or SMAC statement. The disk space required for the macro is increased according to the amount of space required for your remarks. Comment statements within the definition are always retained and listed within the expansion.\n\nIf parameters occur in remarks, parameter substitution is performed for the remarks also. This substitution includes automatically-generated names. The Macro Assembler also substitutes parameters into comments statements (asterisk in column 21), but it does not substitute automatically-generated names into comments statements. On such statements, the apostrophe is treated like any other character.\n\nAll records are truncated following column 71 of the record, and no error indication is given.\n\n---\n\n**Macro Assembler Features 25**\nIndirect Parameter Substitution\n\nThe indirect parameter substitution feature allows you to substitute one parameter for another when a macro is expanded. You do this by specifying a semicolon followed by any valid assembler-language expression, instead of the parameter you wish to replace, in the macro call.\n\nThe value of this expression is evaluated by the Macro Assembler and is considered to be the position of the replacement parameter in this macro call. For example, if the expression is evaluated as 3, the parameter in the third position is the replacement parameter. Remember, in determining the position of the replacement parameter, the label field of the call is the first parameter.\n\nThe position number and semicolon are counted as one parameter. If the replacement parameter position referenced is not specified in the macro call, an empty parameter is substituted. An indirectly-specified parameter may select as many as 19 other indirectly-specified parameters. If this limit is exceeded, an empty parameter is substituted, and the macro call is flagged with a syntax error indicator. Processing continues with the next statement.\n\nIf a symbol within a parameter substitution specification is not defined before its use, the substituted expression is evaluated as zero, the referenced parameter is evaluated as a blank parameter, and processing continues.\n\nThe following examples demonstrate the use of indirect parameter substitution.\n\n<table>\n<thead>\n<tr>\n<th>Label</th>\n<th>Operation</th>\n<th>F</th>\n<th>T</th>\n<th>Operands & Remarks</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>MAC</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>LO, C</td>\n<td>BRT, B</td>\n<td>A</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>LO, C</td>\n<td>BSC, L</td>\n<td>A</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>MEND</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>BRT, B</td>\n<td>; A, LOC1, LOC2, LOC3</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>BSC, L</td>\n<td>LOC2</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>LOC3</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nIn a nested macro call, if the symbol following the semicolon is a parameter of the outer macro, the parameter must be concatenated to the semicolon for recognition by the Macro Assembler. (Concatenation was described previously under \"Concatenation\").\nThe Macro Assembler interprets any slash in the operand field as a division operator, unless it can be interpreted as a hexadecimal number indicator. A hexadecimal constant is indicated by a slash in column 35. A slash preceded by an operator is interpreted as the hexadecimal indicator. A slash preceded by a term is interpreted as a division operator. A division operator may be immediately followed by a + or - to indicate whether the divisor is positive or negative. If no + or - follows the division operator, the divisor is assumed to be positive. A division operator followed immediately by a multiplication operator is flagged as a syntax error (S). Division by the internal address register (IAR) is allowed in an absolute assembly; in a relocatable assembly, it is flagged as a relocation error (R).\n\nEach division operation within each term is performed from left to right. The 16-bit quotient is the result of a division operation; the remainder is lost.\n\nThe Macro Assembler performs all operations in an expression algebraically. For example:\n\n(1) 3+2*4/2 = 7 (2) 5*2/3+9/-3 = 0\n\nIn example 1 the entire term 2*4/2 is evaluated from left to right before it is combined with 3. In example 2 the term 5*2/3 is evaluated (left to right) first. Then the term 9/-3 is evaluated and combined with the first term. Note that since the result of a division is always an integer with the remainder ignored, the first term in example 2 if written as 2/3*5 would be evaluated as 0 but 3 would result when the term is written as 5*2/3.\n\nNote that division by zero results in a zero quotient and a warning flag. A relocation error flag (R) will be issued if either the dividend or divisor is relocatable. If two consecutive division operators are found in a single term, the term will be replaced by zero. For example, 27/9/3 will not be correctly evaluated and will be replaced by zero; the statement in which it occurred will be flagged as a syntax error (S).\n\nSymbolic Tag Field\n\nIf you wish to change an index register designation once you have coded that portion of your program, you can do this by using the symbolic tag field feature. You specify the tag field with a one-character symbol which is defined in the assembly by means of an EQU or SET statement (see the 1130 Assembler Language manual, Order Number GC26-5927 or the 1800 Assembler Language manual, Order Number GC26-5882).\n\nYou may change the value of the tag symbol dynamically when using the SET pseudo-operation to define the tag field. The tag symbol retains the value of the last SET statement associated with it from the first pass of the Macro Assembler until the Macro Assembler encounters an associated SET statement in the second pass. The EQU statement is not read on the second pass of the Macro Assembler and,\nconsequently, cannot be used to change the value of the tag symbol during assembly.\n\nThe following example illustrates use of the symbolic tag field in instructions and the code generated by those instructions.\n\n<table>\n<thead>\n<tr>\n<th>Label</th>\n<th>Operation</th>\n<th>F</th>\n<th>T</th>\n<th>Operands & Remarks</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>21</td>\n<td>SET</td>\n<td>1</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>26</td>\n<td></td>\n<td>5</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>LOP1</td>\n<td>LD</td>\n<td>LA</td>\n<td>TABL1</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>ST.</td>\n<td>LA</td>\n<td>TABL2</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>MD.</td>\n<td>A</td>\n<td>-1</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>SET</td>\n<td>2</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nProgramming Techniques\n\nThe following items should help you in using the Macro Assembler.\n\n**CHECKING FOR BLANK PARAMETERS**\n\nIt is generally desirable to simplify macro calls by defining macros so that parameters (preferably the last parameter in the call) may be optionally omitted. Passing a blank parameter to the macro can cause a special sequence of code or no code to be generated. This blank parameter in the call causes no substitution to occur for the parameter when the macro is expanded. Consider the following examples:\nThe SET statement is used in Example 2 to avoid Macro Assembler errors that can result from passing blank parameters. Note the use of $ in the label field. Use of $, a, and # in macro labels may help prevent conflict with other labels used in the program. These characters may also be used in conjunction with the automatic name generation feature.\n\n**RESTRICTIONS ON AIF, AIFB, AND SET PSEUDO-OPERATIONS**\n\nWe have said that symbols used either in the SET operand field or in the AIF or AIFB expression must have been defined before the referencing SET, AIF, or AIFB statement is processed. Since symbols used as above in AIF, AIFB, and SET are evaluated at the time they are first encountered, they are flagged with the U error even if the symbols are defined later in the program. This error flagging has been implemented to help ensure that code generated by SET, AIF,\nor AIFB statements is the code intended by the user. See Example 3.\n\n// JOB 01 JAN 70 00.517 HRS\n// * EXAMPLE 3 ILLUSTRATES THE RESTRICTION ON THE AIF OPERATION\n// * THAT A SYMBOL MUST BE DEFINED PRIOR TO ITS USE IN\n// * THE SET, AIF, OR AIFB OPERATIONS\n// ASM SAMPL 01 JAN 70 00.517 HRS\n*LIST\n*OVERFLOW SECTORS **2\nMAC C BEGIN MACRO DEFINITION\nTABLE MAC C AIFP (A LE 0),EXIT EXIT MACRO IF A LE 0\n00001 CONT ANOP\n00002 DC /00F0+A CONSTANT DEFINED\n00003 A SET A+1 INCR A\n00004 AIFB (A LE /F),CONT END TABLE IF A GT 15\n00005 EXIT MEND END MACRO DEFINITION\n* IF A IS NOT DEFINED PRIOR TO THE CALL\n* TO TABLE, NO TABLE WILL BE GENERATED\n* SINCE A IS EVALUATED AS ZERO\n\n0000 0 1000 BEGIN NOP TABLE MACRO CALL\n MAC C U+ AIF (A LE 0),EXIT EXIT MACRO IF A LE 0\n0001 30 059C98C0 EXIT\n0004 0000 END BEGIN\n\n001 ERROR(S) AND 000 WARNING(S) IN ABOVE ASSEMBLY.\n\nLABEL AND BLANK PARAMETER CHECKING USING AGO\n\nThe Macro Assembler does not have an explicit method for character string comparison. However, the AGO and ANOP pseudo-operations provide a means of label checking both within and outside of a macro. Consider Example 4.\n\n// JOB 01 JAN 70 00.525 HRS\n// * EXAMPLE 4 ILLUSTRATES THE USE OF THE AGO AND ANOP OPERATIONS\n// * TO HANDLE BLANK MACRO PARAMETERS WITHOUT CAUSING ASSEMBLER\n// * ERRORS TO OCCUR\n// DUP 01 JAN 70 00.525 HRS\n*DELET D MACRO *****\n*DFILE MACRO 0007\nWILL RESERVE AT SCTR ADDR 0380\nDMP FUNCTION COMPLETED\n*MACRO UPDATE\nBUILD 'MACRO'\n 0380 0005 ** LIBRARY END **\n0000\nENDUP\nUPDATE COMPLETED\n// ASM SAMPL 01 JAN 70 00.531 HRS\n*MACLIB MACRO\n*LIST\nSMAC C BEGIN MACRO DEFINITION\nLABEL DISK FUN1,ARE1,ERR1\n00001 LABEL LIBF DISKN CALL TO DISKN SUBR\n00002 AIF (FUN1 EQ 0),READ TEST FOR READ FUNC\n00003 AIF (FUN1 EQ 3),WRITE TEST FOR WRITE FUNC\n00004 AIF (FUN1 EQ 0),TEST TEST FOR TEST FUNC\n00005 LIST ON\n00006 = ILLEGAL REQUEST\n00007 LIST AG0 EXIT EXIT MACRO\n0008 READ ANOP\n\n30 1130/1800 Macro Assembler Programming\nMacro Assembler Features 31\nNote that if a macro parameter, which may be a character string greater than one character, is used in an AIF statement to check for character values, a syntax flag will be generated by such a statement and the value of the substituted expression will be zero. See Example 5.\n\nMACRO PARAMETER SUBSTITUTION\n\nWhen special features such as call continuation and indirect parameter substitution are used in nested macro calls you must account for such special instances as you code your macro. If, for example, you anticipate that a nested macro call may be a continued call, you must pass the continuation indicator and ensure that any parameter string from the first call is completed on each nested continuation record. See Example 6. If you wish to pass a symbolic value to a nested macro call and an indirect substitution expression and that symbol appears next to the semicolon, you must concatenate the symbol to the semicolon. See Example 7.\nSAMPLE PROGRAM\n\nThe following sample program illustrates three macros: their definitions, calls to them, and the code generated.\n**a move macro**\n\n```assembly\nmacro definition\nMOVE FROm,TO,CNT\nLABEL MOVE FROM,TO,CNT\nLIST OFF\n00002 AIF (CNT LE 0),NDMVE\n00003 LIST OFF\n00004 LABEL LDX L1 -CNT INITIALIZE LOOP COUNTER\n00005 LOUP LD L1 FROM+CNT GET WD TO BE MOVED\n00006 STD L1 TO+CNT MOVE IT\n00007 MDX 1 1 RUMP MOVE (LOOP) COUNTER\n00008 MDX LOOP LOOP UNTIL MOVE COMPLETED\n00009 NDMVE LIST OFF\nMEND\n```\n\n**a message macro**\n\n```assembly\nmacro definition\nMSG TEXT\nMAC MSG TEXT\n00001 ONE S TEXT 'E\nMEND\n```\n\n**a parameter checking macro**\n\n```assembly\nmacro definition\nVKUS PARAM\n00001 AGO PARAM\n00002 ANOP\n00003 #VKUS SET 0\n00004 AGO QUIT\n00005 PARAM ANOP\n00006 #VKUS SET 1\nQUIT MEND\n```\n\n**DC-generating macros**\n\n```assembly\nmacro call\n00001 LIST OFF\n00002 VKUS LABEL (VKUS EQ 0),BLANK\n00003 AIF\n00004 LIST OFF\n00005 LABEL EQU *\n00006 BLANK LIST OFF\n00007 Z SET CNT\n00008 X SET 3\n00009 RETRN AIF (Z EQ 0),QUIT\n00011 X SET XI\n00012 Z SET Z-1\n00013 AGOB RETRN\n00014 QUIT LIST OFF\nMEND\n```\nThe 1 indicates the overflow sector necessary to house temporary macro definitions in this assembly.\n\nIf CNT is less than or equal to 0, the definition is not expanded.\n\nSequence numbers of definition statements are printed for easier visual perception.\n\nThe move loop is generated with your program's parameters.\n\nThis AlF checks the call to the DCS macro to determine if you want a label to be associated with the first DC.\n\nYou can significantly alter a printed listing when a macro is called through use of the LIST pseudo-op.\n\nAll statements resulting from a macro expansion are flagged with a plus in column 20.\n\nThis is a call to DCS without the label specified.\n\nNote how use of the LIST pseudo-op caused this expansion to be printed.\n\nThis is a call to DCS with the label specified.\n\nNOTES\n\nBy using parentheses, the parameter TEXT (see the MSG definition) is replaced by a string of characters into a DMES statement.\nThe features of the Macro Assembler permit you to create a language that can help programmers who are new to your installation or who don't understand the more detailed aspects of certain operations. This specialized language may also be used by programmers who know the operation and want to simplify their job or who need to interact with persons other than programmers. Such a specialized language may also be used to help others learn to write simple programs for your system.\n\nConsider the following 1800 MPX example.\n\nMr. Jones is a programmer who works for a sports information service center and is in charge of all baseball statistics. He has been assigned the following project in response to a customer requisition.\n\n<table>\n<thead>\n<tr>\n<th>SPORTS INFORMATION SERVICE CENTER</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>programmer: A.B. Jones</td>\n</tr>\n<tr>\n<td>date needed: September 10, 1972</td>\n</tr>\n<tr>\n<td>customer: 126-3381-07</td>\n</tr>\n</tbody>\n</table>\n\nProblem:\n1. Read a batch of data cards having the following format:\n columns 1–20 Player's name\n 25–28 Number of at-bats\n 30–33 Number of singles\n 35–38 Number of doubles\n 40–43 Number of triples\n 45–48 Number of home-runs\n2. Compute the player's batting average, slugging percentage, and home-run ratio.\n3. Print all the information mentioned in 1 and 2.\n4. Terminate execution of the program when a data card containing an asterisk (*) in column 1 is read.\n\nMr. Jones knows that in order to answer this request, he will have to use some macros from the general purpose library, use some macros from his own library, and use the following computations in his solution.\n\nBatting average=number of hits number of times at bat.\nFor example, if hits=13 and at-bats=64, 13 ÷ 64=.203\nThe batting average would be .203.\n\nSlugging percentage=(number of singles + 2 x number\nof doubles + 3 x number of triples + 4 x number\nof home runs) ÷ number of at-bats.\nFor example, if at-bats=64, singles=8, doubles=3,\ntriples=1, and home runs=1, the slugging percentage\nwould be [8+2(3)+3(1)+4(1)] ÷ 64 or 21 ÷ 64 or .328\nHome run ratio = number of at-bats ÷ home runs.\nFor example, if at-bats = 64 and home runs = 4, the home run ratio would be 64 ÷ 4 or 16.\n\nMr. Jones then looks in the guide to general purpose macros and determines which ones he wants to use. The guide lists the macros in a library that have been built by all the programmers who work with Mr. Jones. These macros are ones that are used frequently by the programmers, such as, read a card and print a line.\n\nThe following listing demonstrates how this library of macros was created. In this case the library has been named SYSTM.\n\n```plaintext\n// JOB 00 JAN 00 00:235 IRS\n// DMP 00 JAN 00 00:235 IRS\n*MACRO UPDATE\nDMPP FUNCTION COMPLETED\nWILL RESERVE AT SCTA ADDR 04CO\nDMP FUNCTION COMPLETED\nBUILD 'SYSTM',\nNAME LABEL, INPUT, OUTPUT\nADD 'DCBIN'\n04CO 0005 DCBIN\nX 00001 LABEL CALL DCBIN\nX 00002 DC INPUT\nX 00003 DC OUTPUT\n00004 ** MACRO END **\nADD 'BINDC'\n04CO 0019 BINDC\nX 00001 LABEL CALL BINDC\nX 00002 DC INPUT\nX 00003 DC OUTPUT\n00004 ** MACRO END **\nNAME LABEL, CNTL, AREA, WDCNT\nADD 'LLIST'\n04CO 0020 LLIST\nX 00001 LABEL DC 0\nX 00002 DC 0\nX 00003 BSS 4\nX 00004 DC CNTL\nX 00005 DC AREA\nX 00006 DC WDCNT\nX 00008 BSS WDCNT\n00009 ** MACRO END **\nNAME LABEL, LIST, CNTL, AREA, WDCNT\nADD 'RCRD'\n04CO 0034 RCRD\nX 00001 LABEL CALL CARON\nX 00002 DC LIST\nX 00003 LD L LIST\nX 00004 BSS L **-4,2\n00005 ** MACRO END **\nADD 'PRINT'\n04CO 006F PRINT\nX 00001 LABEL CALL PRNTN\nX 00002 DC LIST\nX 00003 LD L LIST\nX 00004 BSS L **-4,2\n00005 ** MACRO END **\nNAME LABEL, INPUT, OUTPUT, CHRCT\nADD 'HOLPR'\n04CO 0094 HOLPR\nX 00001 LABEL CALL HOLPR\nX 00002 DC A+1\nX 00003 DC INPUT\nX 00004 DC OUTPUT\nX 00005 DC A+1\nX 00006 DC AREA\nX 00007 A+2 DC CNTL\nX 00008 DC CHRCT\n00009 ** MACRO END **\nNAME LABEL, CNTL, AREA, LABL1, LBL2\nADD 'SLIST'\n04CO 009A SLIST\nX 00001 LABEL DC 0\nX 00002 DC 0\nX 00003 BSS 4\nX 00004 DC 0\nX 00005 DC AREA\nX 00006 DC L LIST\nX 00007 ** MACRO END **\n04CO 009D ** LIBRARY END **\n00020\nENDUP\nUPDATE COMPLETED\n```\n\n38 1130/1800 Macro Assembler Programming\nHe then determines which macros from his library, which he has named JONES, are required. This library contains macros that he has written because he finds them useful in his job of providing baseball statistics.\n\nThe following listing demonstrates how his library was created.\n\n```assembly\n*FILE O JONES 10\nWILL RESERVE AT SCRN ADDR O4CA\n*MACRO UPDATE\nBUILD *JONES*\nNAME LABEL FROM: TO COUNT\nADD *MOVE* O4CA 0005 MOVE\n X 0001 0LX L1 FROM\n X 0002 0LX L2 TO\n X 0003 0LX 3 COUNT\n X 0004 *A LO 1 0\n X 0005 STD 2 0\n X 0006 MX 1 1\n X 0007 MX J 1\n X 0008 MX 3 -1\n X 0009 MX *A\nNAME LABEL X COUNT LIST STORE\nADD *SUM* O4CA 0034 SUM\n X 0001 LABEL 0LX X - COUNT\n X 0002 S LA 1 6\n X 0003 B A LKS T - COUNT\n X 0004 STD L STORE\n X 0005 MX X 1\n X 0006 MX B 1\n X 0007 ** MACRO END **\nNAME LABEL AB HITS BAVG\nADD *BA* O4CA 0056 BA\n X 0001 0LX L HITS\n X 0002 0LX H\n X 0003 0LX A\n X 0004 0STD L BAVG\n X 0005 MX ++1\n X 0006 0LX D\n X 0007 ** MACRO END **\nADD *COEU* O4CA 0076 COEU\n X 0001 CCE EQU LABEL+1\n X 0002 CCE EQU LABEL+5\n X 0003 CCE EQU LABEL+10\n X 0004 CCE EQU LABEL+15\n X 0005 CCE EQU LABEL+20\n X 0006 CCE EQU LABEL+25\n X 0007 CCE EQU LABEL+30\n X 0008 CCE EQU LABEL+35\n X 0009 CCE EQU LABEL+40\n X 0010 CCE EQU LABEL+45\n X 0011 CCE EQU LABEL+50\n X 0012 CCE EQU LABEL+55\n X 0013 CCE EQU LABEL+60\n X 0014 CCE EQU LABEL+65\n X 0015 CCE EQU LABEL+70\n X 0016 CCE EQU LABEL+75\n X 0017 ** MACRO END **\nNAME LABEL NUMBR BY PROD\nADD *MPY* O4CA 0099 MPY\n X 0001 0LABEL D L NUMBR\n X 0002 0H C\n X 0003 0SLT 1 6\n X 0004 0STD L PROD\n X 0005 MX ++1\n X 0006 C 1 DC\n X 0007 ** MACRO END **\nNAME LABEL AB HR RESULT\nADD *HRATE* O4CA 011A HRATE\n X 0001 0LABEL D L AB\n X 0002 0KTE 1 6\n X 0003 SLA 1K\n X 0004 0L HR\n X 0005 0STD L RESULT\n X 0006 ** MACRO END **\nNAME LABEL TEXT X\nADD *MSG1* O4CA 0135 MSG1\n X 0001 LDL DC 'AB'-+1\n X 0002 'Y' DMES X TEXT\n X 0003 'Z' BES 0\n X 0004 ** MACRO END **\nNAME LABEL TEXT TEXT2 X\nADD *MSG2* O4CB 00DC MSG2\n X 0001 LDL DC 'AB'-+1\n X 0002 'Y' DMES X TEXT1\n X 0003 'Z' BES 0\n X 0004 'Z' BES 0\n X 0005 ** MACRO END **\n```\n\n21 27 35 Format: LABEL MOVE FROM: TO COUNT FROM = address of the data to be transferred TO = address at which the data will be transferred COUNT = number of words to be transferred The MOVE macro transfers a block of data from one area to another.\n\n21 27 35 Format: LABEL SUM X: COUNT LIST STORE X = index register to be used COUNT = number of words to add LIST = address of the first word to be added STORE = address where the sum shall be placed The SUM macro calculates the sum of a block of contiguous words and places the result into a word designated by the STORE parameter.\n\n21 27 35 Format: LABEL BA AB HITS BAVG AB = address of the word which contains the number of at-bats HITS = address of the word which contains the number of hits BAVG = address where the batting average shall be placed The BA macro calculates a batting average and places it into a word designated by the BAVG parameter.\n\n21 27 35 Format: LABEL CDEQU The CDEQU macro generates a series of EQU statements tailored for the processing of data cards. LABEL = address of the word count word which precedes the buffer into which a data card will be read Since EQU statements do not increase the size (in words) of a program, it is not wasteful if all of the labels generated by CDEQU are not used.\n\n21 27 35 Format: LABEL MPY NUMBR BY PROD NUMBR = address of one number to be multiplied BY = second number (not an address) to be multiplied PROD = address of the word where the product will be stored The MPY macro multiplies two given numbers and stores the result into a word designated by the PROD parameter.\n\n21 27 35 Format: LABEL HRATE AB HR RESULT AB = address of the word which contains the number of at-bats HR = address of the word which contains the number of home-runs RESULT = address where the home-run ratio will be stored The HRATE macro calculates a home-run ratio and places the result into a word designated by the RESULT parameter.\n\n21 27 35 Format: LABEL MSG1 TEXT X TEXT = text, using DMES syntax, of the message X = 0 if 1053 message, 1 if 1443 message The MSG1 macro facilitates the printing of a message. A word count and DMES statement are generated.\n\n21 27 35 Format: LABEL MSG2 TEXT TEXT2 X The MSG2 macro is the same as the MSG1 macro except that two DMES statements (for longer messages) are generated.\nMr. Jones has now selected all the macros he is going to use, and the next step is for him to write the coding. The following is a list of the source coding Mr. Jones decided to use. Note that he could have further reduced the coding by using more complex macros. (In order to aid understanding, the macros in this sample are not complex; therefore, the coding required by Mr. Jones is far more extensive than would be needed in actual applications.)\nMr. Jones then submitted the coding punched on cards to his system operator and requested that the job be performed and a listing of the operation supplied. The following listing shows the assembly and execution of his program. (The explanation of the coding is given to the side of the listing; the macro instructions are enclosed in rectangles.)\nMove and convert the four columns for triples (40 through 43) and store the result into location TRPLS.\n\nMove and convert the four columns for homers (45 through 48) and store the result into location HOMRS.\n\nCompute SNGLE+DBLES+TRPLS+HOMRS and store the result into location HITS.\n\nCompute the batting average and store the result into location BTAVG.\n\nCompute the home-run ratio and store the result into location RATIO.\n\nIn preparing for the slugging percentage calculation, multiply DBLES by 2 and store the result in location DBLES.\n\nMultiply HOMRS by 4 and store the result in HOMRS.\n\nCompute SNGLES+DBLES+TRPLS+HOMRS and store the result into location HITS.\n\nCompute the slugging percentage and store the result into location SPTC.\n\nMove 4 words beginning at WKBUF+2 to words 50-53 of the card buffer. This puts the batting average into the card buffer which will then be converted to 1443 code and printed.\n\nConvert and move the slugging percentage to columns 55-58 of the card buffer.\nMacro Assembler Language 43\nConvert and move the home-run ratio to columns 60-63 of the card buffer.\n\n**Supress leading zeros to facilitate an easy-to-read printout by replacing all leading zeros (0/2000 in card code) with blanks (0 in card code). Do this for the at-bat field.**\n\n- Suppress leading zeros in the singles field.\n- Suppress leading zeros in the doubles field.\n- Suppress leading zeros in the triples field.\n- Suppress leading zeros in the home-runs field.\n\nSupppress leading zeros in the home-runs field\n\nSuppress the first character in the batting average field since batting averages are always written with 3 digits. (The first character will always be zero.)\nFrom this example you should realize how the use of macros with meaningful names helped Mr. Jones and his fellow workers make efficient use of their system. Similarly, you can design your macros and libraries to aid your programmers and others who must work with the programmers.\nThe Macro Update Program\n\nThe Macro Update Program (MUP) assists you in maintaining macro libraries. It performs the following functions:\n\n- Initializes disk space for macro libraries.\n- Adds macros to libraries.\n- Deletes macros from libraries and reclaims the space they occupied.\n- Joins macro libraries, physically or logically.\n- Renames macro libraries.\n- Obtains a listing of the contents of macro libraries by macro name or by macro name and statement.\n- Inserts or deletes statement(s) within a macro.\n- Provides macro definition source statements on cards.\n\nTo call the Macro Update Program, you must first load the Disk Utility Program (for DM2) or the Disk Management Program (for MPX) into main storage. After it has been loaded, you use an *MACRO UPDATE control statement to call MUP. Following this statement, you should use MUP control statements to indicate the functions you want to perform. The function field must begin in column one, and at least one blank is required to separate it from the operand field. If you leave the first column blank, the statement will be ignored. If you want to specify more than one operand, you must separate the operands by commas and leave no blanks within or between them. Any unused columns in MUP control statements are reserved for system use. With the exception of the NAME function (described later in this chapter), control statement continuation is not allowed in MUP.\n\nNote that once a Macro Update function has been started, it should not be aborted, because an incompletely modified library may cause the library to be unusable.\n\nAll special characters used in the Macro Update Program must conform to the character code summaries as listed in the 1130 Assembler Language manual, Order Number GC26-5927, or the 1800 Assembler Language manual, Order Number GC26-5882.\n\nInitializing Disk Space\n\nBefore initializing disk space, you must reserve a data file to serve as your macro library. This can be accomplished by means of an *DFILE statement or an *STOREDATA statement. For a detailed description of *DFILE and *STOREDATA, see the Programming and Operator’s Guide (for DM2), Order Number GC26-3717, or the Programmer’s Guide (for MPX), Order Number GC26-3720.\nTo initialize disk space for a macro library, you must use a BUILD statement. The library name in the BUILD statement must be the same as the one defined in the *DFILE or *STOREDATA statement. After you have named a library, you must use that library's name in all LIB, BUILD, JOIN, or CONCAT statements (described later) that refer to that library. You must initialize disk space before requesting the Macro Assembler or the Macro Update Program to operate on a specific library. The format of a BUILD statement is as follows:\n\n```\n LNAME is the name of the macro library that was reserved by the *DFILE or *STOREDATA statement (discussed above). LNAME is a 1-5 character name for the macro library. The apostrophes are delimiters and, as such, are required by MUP for the names of all macros and libraries. You can use alphabetic characters A-Z and the characters 0-9, #, @, and $ within your library name. The digits 0-9 may not be used as the first character. A library name is considered a symbol, and therefore, it must conform to the rules for symbols as stated in the Assembler Language manual, Order Number GC26-5927 (for the 1130) or Order Number GC26-5882 (for the 1800). If LNAME applies to a previously initialized library containing macros, the function purges the library and reinitializes it.\n```\n\n**Specifying the Macro Library**\n\nTo specify the macro library to be operated on, you use the LIB statement. The format of a LIB statement is as follows:\n\n```\n LNAME (discussed above) is the name for the macro library.\n```\n\n**Joining Macro Libraries Physically**\n\nIf you want to physically join a macro library to the end of the library specified in the last BUILD or LIB statement,\nyou use a JOIN statement. For example, if you wanted to physically join LIB06 to LIB05, you would use the following statements.\n\nThese statements cause the contents of LIB06 to be added (physically copied) to the end of the contents of LIB05. This does not change the contents of library LIB06.\n\nIf the first library cannot accommodate the library being joined to it, the JOIN operation is suppressed. Neither library is changed and processing continues with the next LIB or BUILD statement. If you specify a new library name in a BUILD and then join an existing library to it, you physically copy the existing library.\n\nJoining Macro Libraries Logically\n\nIf you want to logically join a macro library to the library specified in the last BUILD or LIB statement, you use a CONCAT statement. This statement allows you to maintain individual libraries, and then unite them for assembly purposes without using additional disk space.\n\nFor example, if you wanted to logically join LIB22 to LIB15, you would use the following statements.\n\nThese statements cause both libraries to be available for assembly purposes when LIB15 is referenced by the Macro Assembler. However, in any Macro Update Program operation, only the library named on the last LIB or BUILD statement is operated upon.\n\nIt is possible to concatenate a multiplicity of libraries, so that several libraries may be available to the Macro Assembler even though the assembly references only one. You\nwould perform this multiple concatenation by concatenating library B to library A, library C to B, library D to C, library E to D, and so on until all the libraries that you wanted were linked together. You can concatenate only one library to any other library, but you can concatenate up to a total of 16 libraries, making a total of up to 17 available for assembly purposes. If the Macro Assembler does not find a macro and has searched through 17 libraries, the statement containing the name of the macro will be flagged as an op code violation and the assembly will continue.\n\nIf you want to disconnect a library that has been concatenated to another library, you can use the following statements.\n\n<p>| | | | |</p>\n<table>\n<thead>\n<tr>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n\nThe CONCAT statement would cause the library (LIB22) that has been concatenated to library LIB15 to be disconnected. The physical contents of the libraries remain unchanged.\n\nUpdating a Macro in a Library\n\nIf you want to alter a macro that has been stored in the library specified in the last BUILD or LIB statement, you specify that macro with the UPDATE function. An example of specifying the macro TAXES might be as follows.\n\n<p>| | | | |</p>\n<table>\n<thead>\n<tr>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n\nThe UPDATE statement is normally followed by an INSERT or DELETE statement. Descriptions of these two statements are discussed under \"Inserting Statements in a Macro\" and \"Deleting Statements From a Macro.\"\nRenaming a Macro in a Library\n\nIf you want to rename a macro in a library, you use the RENAME statement. Once you have renamed a macro, the original name is lost, and the macro can be referenced only by its new name. The format for the RENAME statement is as follows:\n\n```\nNAME P 1 P 2 P 3 . . . P n\n\nRENAME 'BOLTS', 'RIVET'\n```\n\nThis statement would cause the macro BOLTS to be renamed RIVET. BOLTS represents the name of the current macro; it must be enclosed in apostrophes and separated from the new name by a comma. RIVET represents the new name for the macro. The macro must now be referenced by this new name. BOLTS can now be used as a name for another macro. The RENAME statement may be followed by INSERT or DELETE statements.\n\nDefining a Macro During a Macro Update Run\n\nYou can define a macro during a macro update run by using essentially the same method you use during an assembly. The differences are that you don't use MAC or SMAC and MEND statements, and you don't use a definition prototype statement. Instead, you use a NAME statement to name the parameters to be used in a subsequent definition and an ADD statement to name the macro (discussed below). The format of the NAME statement is as follows:\n\n```\nNAME P 1 P 2 P 3 . . . P n\n```\n\nP1 is the symbol for parameter 1, P2 is the symbol for parameter 2, and so on.\n\nNote that parameter 1 is the parameter used in the label field of the macro call. Parameter 2 would be the first parameter in the operand field. If you need more than one record for all your parameters (limited to 20 possible), use as many NAME records as needed immediately following the first, and continue the parameters on these records.\nsuch a case, a comma must not follow the last parameter on each record.\n\nIf your NAME statement does not have sufficient parameter names for the parameters in the macro being processed, one of the following will occur:\n\n- On input, the additional parameters will be assumed to be standard Macro Assembler variables instead of macro parameters.\n\n- On output, the operation will be aborted and a D117 error message printed. This also occurs if a parameter that is used in the format or tag fields is given a name that is greater than one character.\n\n- On listing, extra parameters will be replaced by // N where N is the number (1-20) of the parameter. A D117 error message will be printed. Note that the parameter number may be truncated if it exceeds the field length.\n\nThe names specified in the NAME statement are used in all subsequent operations until the next LIB or BUILD statement is encountered or another NAME statement is read.\n\n**ADD STATEMENT**\n\nAfter the NAME statement, you use the ADD statement. The ADD statement adds the macro to the library specified in the last LIB or BUILD. The ADD statement in conjunction with the NAME statement performs the same function as the definition prototype statement of the Macro Assembler definition. The format of the ADD statement is as follows:\n\n```\nADD 'PARTS'\n```\n\nThis statement causes the macro PARTS to be added to the end of the macro library specified in the last BUILD or LIB statement.\n\nFollowing the ADD statement, you place the assembler-language source statements that you want to include in the definition. The macro being thus defined by the ADD function is terminated by the occurrence of a MUP control statement. An example of how to define a macro during a macro update run is as follows:\nIf there is not sufficient space in the library to accommodate the macro you want to store, the macro is not added. Processing continues with the next LIB or BUILD statement; the library is not changed by this occurrence.\n\nIf you define another macro within a macro definition, then the MAC or SMAC and MEND statements of the nested macro are included in the definition of the outer macro. Thus, if a macro is defined with an ADD statement and its source statements include a MAC or SMAC and MEND statement, then every time it is called in an assembly, a macro definition is generated.\n\nThe definition prototype statement cannot be used in a macro defined by the ADD function except in conjunction with a MAC or SMAC statement. If one is present, no error is diagnosed. Note also that macro source statements stored during a MUP run are not diagnosed for errors.\n\nDeleting a Macro From a Library\n\nIf you want to delete a macro from the library named in the last LIB or BUILD statement, you use a PURGE statement. This function deletes the macro that is specified, and automatically reclaims the space it occupied. The format of a PURGE statement is as follows:\n\n```\n1-10 11-20 21-30 31-40\n1234567890 1234567890 1234567890 1234567890\nPURGE 'WAGES'\n```\nThis statement causes the macro WAGES to be deleted from the library named in the last LIB or BUILD statement and reclaims the space WAGES occupied.\n\nThe Macro Update Program PURGE statement should not be confused with the Macro Assembler PURG statement. The Macro Assembler PURG statement does not automatically reclaim the space occupied by the macro named in that statement. Instead, the space is reclaimed by running the Macro Update Program. Any macro update run affecting a particular library will reclaim the space occupied by a macro deleted from that library with the Macro Assembler PURG statement. The PURG and PURGE statements cause operations to occur in regard to the specific library named in the last LIB, BUILD, or *MACLIB statement. They do not affect any other library.\n\nPunching Source Statements\n\nIf you want to punch the source statements of a specified macro definition, you can use the OUTPUT statement. This statement must have been preceded by a NAME statement. Blank cards must be available for punching as soon as the OUTPUT statement is read.\n\nCare should be taken in preparing the NAME statement since the OUTPUT function will be aborted if a parameter is defined incorrectly or is left undefined (see NAME statement described previously). The definition to be punched must be part of the library specified in the last LIB or BUILD statement. The format of the OUTPUT statement is as follows:\n\n```\n 1-10 | 11-20 | 21-30 | 31-40 |\n | | | |\n 1234567890 | 1234567890 | 1234567890 | 1234567890 |\n\nuse OUTPUT 'SALES'\n```\n\nSALES is the name of the macro definition to be punched. This statement also causes an ADD 'SALES' statement to be punched prior to the source statement to facilitate loading of the definition at a later time. The source statements will contain an identification (first three characters of the macro name) and a sequence number in columns 73-80.\n\nInserting a Statement in a Macro\n\nIf you want to insert additional macro definition source statements into a macro, you can use the INSERT statement. This statement must be preceded by a RENAME or UPDATE statement and a NAME statement (discussed previously) that specifies the macro to be modified and its parameters, and it must be followed by the source statements to be inserted. The format of an INSERT statement is as follows:\n### Inserting Statements Into a Macro\n\n**Format**\n\n`INSERT NNNNN`\n\n**Notes**\n\n- **NNNNN** is a decimal integer (maximum of 32767) up to five digits long. It references a macro definition source statement sequence number. The source statements are inserted after NNNNN; so, if you want the statements inserted before any other statements in that macro, you must specify NNNNN as zero.\n\n- Whenever **MUP** or the Macro Assembler prints macro definition source statements, five-digit decimal sequence numbers are printed to the left of each statement. These sequence numbers are referenced by **INSERT** and **DELETE** statements. Any statements inserted into a library by the ADD, **INSERT**, or **DELETE** (described in the next section) function are flagged with an X when the definition is printed. Macro definition source statements are automatically sequenced when the **ADD** function is used, and resequenced when the **INSERT** or **DELETE** functions are used.\n\n- You can insert only as many statements as the library has room for. In other words, if you have 25 statements to add to a macro, and there is enough space to accommodate only 15 of those statements, those fifteen statements will be added. A DI03 LIBRARY OVERFLOW message will be printed; processing will continue with the next **LIB** or **BUILD** statement. If you want to include the ten statements left out of your macro after regaining enough space to accommodate them, you will have to alter your **INSERT** control statement because of the resequencing of the statements in the macro library that has occurred.\n\n### Deleting a Statement From a Macro\n\n**Deletion**\n\nIf you want to delete one or more statements from a macro, you can use the **DELETE** statement. The **DELETE** statement must be preceded by a **RENAME** or **UPDATE** statement that specifies the macro to be altered and a **NAME** statement (discussed previously) that specifies parameter names used for alteration. The format of a **DELETE** statement is as follows:\n\n**Format**\n\n```\nDELETE MNNNN,NNNNN\n```\nObtaining a Listing of Macro Libraries by Statements or Macros\n\nThe SELECT control statement is used to control the Macro Update Program printed output and remark inclusion. The output is always printed on the list (principal) printer, and MUP control statements are always printed. You can also specify in a SELECT statement that remarks are to be included with any macro text statement being placed on disk. An example of the print format may be seen in the sample program that is at the end of this chapter.\n\nThe format of the SELECT statement is as follows:\n\n```\n<p>| | | | |</p>\n<table>\n<thead>\n<tr>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1-10</td>\n<td>11-20</td>\n<td>21-30</td>\n<td>31-40</td>\n</tr>\n<tr>\n<td>12345678901234567890123456789012345678901234567890</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SELECT M, P, I, C, N</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n```\n\nno parameters—suppresses printing of macro headers and macro text.\n\nM—causes headers to be printed.\n\nP—causes text and headers to be printed. If you select this option, it should have been preceded by a NAME statement (discussed previously). On an OUTPUT operation with this option, the 1800 will not list the macro text. Note that if a LIB, BUILD, or ENDUP statement is encountered and no name statement is available, SELECT P will be reset and the text will not be printed. On the 1800, if sense switch 2 is ON, printing will be suppressed.\n\nI—causes headers to be printed except during an ADD, INSERT, or DELETE operation, in which case, the macro headers and text are printed. If you do not specify a SELECT statement, I is assumed.\nOn the 1800, if sense switch 2 is ON, printing will be suppressed.\n\nC--indicates that remarks are to be included with any macro text statement being placed on disk.\n\nSELECT N\n\nN--indicates that both of the following conditions are true (see also the section following):\n\n- You want to update a nested definition.\n- The statement(s) inserted uses the automatic name generation feature.\n\nYou may use any combination of parameters in a SELECT statement; however, I will override M and P will override either I or M, or both. Each two consecutive parameters must be separated by a comma, with no embedded blanks. If you use more than one SELECT statement, the latest is assumed, and the prior SELECT statements are overridden.\n\nSPECIAL REQUIREMENTS ON THE USE OF AUTOMATIC NAME GENERATION IN NESTED DEFINITIONS\n\nWhen automatic name generation is used with nested definitions, the indicators for automatic name generation (leading and/or trailing apostrophes) must be suppressed until the call (expansion) of the outer macro occurs. Otherwise, the automatic name generation feature will not function properly. To suppress this feature, the statements in a nested definition must be stored as data. In a nested definition, the MAC statement(s) of the inner nested definitions indicates that the Macro Update Program (on an ADD statement) or the Macro Assembler (on an SMAC statement) should store the statements between the MAC and its associated MEND.\n\nWhen inserting statements that use automatic name generation in a nested definition, you must precede the INSERT or DELETE statements with a SELECT statement that includes N as one of its parameters. This should be done to indicate the Macro Update Program should store these inserted statements as data. The SELECT N option should be followed by another SELECT option (without N as a parameter) when all inserts to the nested definition are completed. If suppressing the automatic name generation feature by SELECT N is not done properly, the consequences will not be observed until an assembly with the call (expansion) of the nested macro is attempted.\nConsider the following example:\n\nLIB 'LIB01'\nSELECT P\nNAME LABEL,A,B,C\n\nUPDATE COMPLETED\n\nThe macro MOVE is a nested definition and uses the automatic name generation feature. Hence, a SELECT N statement must precede any updates (statements for insertion into the macro MOVE) that use the automatic name generation feature. Failure to do so will result in the symbol actually being expanded at this time, which is not desired.\n\nNote that any updates using automatic name generation outside the macro MOVE should not be preceded by a SELECT N statement, since the automatic name generation will be suppressed. In the above example, an insert that uses automatic name generation made between statement number 00003 and statement number 00010 should be preceded by a SELECT N statement. An insert made elsewhere in the macro MOVE that does not use automatic name generation should not be preceded by a SELECT N.\n\nDesignating Comments\n\nA period in column one of any record designates that record as a MUP comment and it is printed on the list (principal) printer. If, however, an error has occurred, and MUP is ignoring all statements until the next LIB or BUILD statement, comments will also be ignored and not printed. Note also that MUP comment records are never included in your macro library.\n\nTerminating a Macro Update Run\n\nTo terminate a Macro Update Program run properly, you must use an ENDUP statement. This statement must be the last MUP control statement used, or else none of the statements that follow it will be processed. You don't specify any parameters in an ENDUP statement; the format is as follows:\nThe UPDATE COMPLETED message (see the following sample program, note 9) indicates that the Macro Update run has been properly terminated. This does not imply that all the operations requested were successful.\n\nSequencing MUP Control Statements\n\nThe following table illustrates the required order of MUP control statements. Each x in the matrix indicates that the function at the top of the column must precede the statement to the left side of the x. MUP statements not included in this table have no precedence requirements.\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>BUILD or LIB</th>\n<th>RENAME or UPDATE</th>\n<th>NAME</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>LIBRARY FUNCTIONS</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>JOIN</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>CONCAT</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>NAME STATEMENT</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>MACRO FUNCTIONS</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>UPDATE</td>\n<td>X</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>ADD</td>\n<td>X</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>PURGE</td>\n<td>X</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>RENAME</td>\n<td>X</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>OUTPUT</td>\n<td>X</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>STATEMENT FUNCTIONS</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>INSERT</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>DELETE</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>PRINT FUNCTIONS</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>ANY SELECT P</td>\n<td></td>\n<td></td>\n<td>X</td>\n</tr>\n</tbody>\n</table>\n\nNote that a new LIB or BUILD function removes the previous NAME statement and a new one must be used. On any function where you use a SELECT P option, you must have a NAME statement available to SELECT P or else the print or punch operation will not be as you wanted it.\n\nMaking Efficient Use of the Macro Update Program\n\nThe Macro Update Program searches sequentially through the library it is operating on for the macro specified in a RENAME, OUTPUT, UPDATE, or PURGE statement. It joins\nlibraries and adds macros to the end of each library. Consequently, the printing may be voluminous while the Macro Update Program is positioning for the requested function. Therefore, to make the most efficient use of the program, you should request the macro functions in the order in which the macros appear in the library, and the JOIN and ADD functions after all other functions for that library have been performed.\n\nFor example, suppose LIB01 contains four macros: MAC1, MAC2, MAC3, and MAC4, respectively and you want to perform an OUTPUT function on MAC1 and MAC4, a PURGE function on MAC2, a RENAME function on MAC3, and a JOIN function on LIB02. The following statement sequence is the most efficient to perform these functions.\n\n```\nLIB 'LIB01'\nOUTPUT 'MAC1'\nPURGE 'MAC2'\nRENAME 'MAC3','GET'\nOUTPUT 'MAC4'\nJOIN 'LIB02'\nENDUP\n```\n\nThe concatenate function does not cause library positioning, and thus, its position within a MUP run is not important.\n\nA Sample Macro Update Program\n\nThe following sample program illustrates a sample Macro Update Program run.\n**MACRO UPDATE**\n\n1. The library named in a **BUILD** statement must have been defined previously with an \"DFILE control statement.\n\n2. The **NAME** statement is required and may specify parameter names to be used in a subsequent definition.\n\n3. **\"LIBRARY END\"** is printed each time the Macro Update Program encounters the end of the library. The two numbers indicate (1) the logical drive number and sector address of the last sector of the library currently used, and (2) the relative address of the last word on that sector which is used.\n\n By inspecting these two words, you can determine how much of your library file has been filled.\n\n4. The name of the macro being operated upon is printed. The two numbers preceding the macro name indicate where on the disk the subject macro was built. Word one indicates the logical drive number and sector address of the definition and word two indicates the relative location of where that definition begins on that sector.\n\n5. An X is printed with each statement that is added to a library or macro.\n\n6. Sequence numbers are printed whenever a macro text is printed.\n\n7. **\"MACRO END\"** is printed whenever the Macro Update Program is through processing a definition.\n\n8. If the library being worked upon is concatenated to another library, this number indicates the logical drive number and sector address of the concatenated library. If no concatenation exists, this number is zero.\n\n9. The Macro Update Program prints the macro names it encounters when scanning through a library. Two numbers in front of the macro name indicate information as described in 4.\n\n10. The library named in a **LIB, JOIN, or CONCAT** statement must have been defined previously with an \"DFILE control statement and initialized with a **BUILD** statement.\n\n11. This message is printed when the Macro Update run has been completed. It does not imply successful completion; messages prior to this one may indicate error conditions.\nADD A MACRO TO MOVE THE CONTENTS OF A SPECIFIED \\nINDEX REGISTER TO ANOTHER SPECIFIED INDEX REGISTER \\nCALLING FORMAT IS \\nLABEL LOADX FROMX,TOX \\nWHERE 'FROMX' IS THE INDEX REGISTER WHOSE CONTENTS ARE MOVED TO THE \\nINDEX REGISTER 'TOX'.\n\nNAME LABEL,XY ADD 'LOADX' 00003 $ MACRO END $ \\n1487 0004 LOADX 00003 LABEL STX X 00002 LOX XY 00001 \\nPHYSICALLY JOIN LIBRARY 'LIB03' TO LIBRARY 'LIB01'.\n\nLIB 'LIB01' 00000 00006 00004 00005 00000 00007 00003 \\nJOIN 'LIB03' 00005 00000 00005 00003 00006 00005 00006 \\n1480 0029 MOVE 1480 0043 ACCNX 1480 0058 LOADX \\nUPDATE THE 'MOVE' MACRO TO SAVE AND RESTORE INDEX REGISTER 1\nUPDATE 'MOVE' 1480 0048 ACCNX 1480 0058 LOADX \\nNAME LABEL,XY FROMX,TO,COUNT \\nDELETE 1 00001 LABEL STX 1 0 00002 LOX LI COUNT \\nINSERT 5 00003 LOAD FROM1 00004 STD LI TO1 00000 00005 MDX 1 -1 \\n00006 MDX 1 -1 00007 LOX LI 0 0 \\nRENAME THE 'MOVE', MACRO AS 'MOVEL' 0000000 $ MACRO END $ \\nRENAME 'MOVE', 'MOVEL' 00480 0053 ACCNX \\n1480 0063 LOADX 1480 0073 $ LIBRARY END $ 0000000 00005 00000 00000 \\n1480 0055 ACCNX 1480 0060 MDX 00006 00007 00008 \\n1480 0029 MOVE \\nONLY THE NAME 'MOVEL' CAN NOW BE USED TO REFERENCE THE MACRO \\nFORMERLY NAMED 'MOVE'.\n\nPUNCH THE MACRO NOW CALLED 'MOVEL' OUTPUT 'MOVEL' 00480 0053 ACCNX \\n1480 0063 LOADX 1480 0073 $ LIBRARY END $ 0000000 00000 00000 \\n1480 0055 ACCNX 1480 0060 MDX 1480 0029 MOVE \\n1480 0053 ACCNX 1480 0060 MDX 1480 0073 $ LIBRARY END $ 0000000\nENDUP 00000 $ UPDATE COMPLETED $\nDuring the assembly process, the Macro Assembler checks for source program errors. If an error is detected, an error flag or an error code and message will be printed. If a questionable instruction is encountered, it is flagged with a warning flag, Q. Errors in the Macro Update Program are detected by the DM2 Disk Utility Program or the MPX Disk Management Program.\n\nMacro Assembler Sign-Off Message\n\nAt the end of each assembly, the Macro Assembler indicates the number of errors and warnings it encountered during that assembly. The message reads:\n\nXXX ERROR(S) AND XXX WARNING(S) IN ABOVE ASSEMBLY.\n\nXXX represents a three-digit decimal number.\n\nMacro Assembler Warning Flag\n\nIf the source program contains certain questionable instructions, the Macro Assembler will interpret and process them and flag them with a Q. For example, the statement MDX L PLACE is assembled as MDX L PLACE,0 and is flagged with the warning indicator. Warning flags are not counted as errors and will not prevent the execution of the object program. It is suggested that you check to make sure that the Macro Assembler has performed the task that you really wanted it to do on each statement flagged with a Q.\n\nMacro Assembler Error Detection Codes\n\nDuring the assembly process, the Macro Assembler checks the source program for errors. Error and warning flags are printed to the left of the label field of each source statement that is in error or is questionable. For a complete description of the listing format of an assembly, see the 1130 DM2 Programming and Operator's Guide, Order Number GC26-3717, or the 1800 Error Messages manual, Order Number GC26-3727.\n\nSee Table 1 for an explanation of the error flags and Table 2 for a listing of the Macro Assembler error messages and their meanings.\n\nMacro Update Program Error Messages\n\nWhen the DM2 Disk Utility Program or the MPX Disk Management Program encounters an error in the Macro Update Program, one of the error messages in Table 3 is printed.\n### Table 1. Error Flags\n\n<table>\n<thead>\n<tr>\n<th>Flag</th>\n<th>Cause and Macro Assembler Action</th>\n</tr>\n</thead>\n</table>\n| A | - Address Error. Attempt made to specify, directly or indirectly, a displacement field outside range of -128 to +127. Displacement is set to zero. \n- Invalid reference to CE Core in a long form instruction. Address field is set to zero. (1800 only) |\n| C | Condition Code Error. Character other than +, −, Z, E, C, or D detected in first operand of short branch or second operand of long BSC, BOSC, or BSI statement. Displacement is set to zero. |\n| F | Format Code Error. Character other than L, I, X, or blank detected in column 32, or L or I format specified for an instruction valid only in short form, or I format specified when not allowed. Instruction processed as if L format were specified, unless that instruction is valid only in short form, in which case it is processed as if the X format were specified. |\n| L | Label Error. Invalid symbol detected in label field. Label is ignored. |\n| M | Multiply Defined Label Error. Same symbol encountered in label fields of two or more statements. First occurrence of symbol in label field defines its value; subsequent occurrences of symbol in label field are ignored and cause an M error flag to be printed. |\n- Invalid op code. Statement is ignored and address counter is incremented by 2. \n- ABS used when +COMMON is used to define FORTRAN common table. Statement is ignored. (1800 only) \n- ISS, ILS, ENT, LIBR, SPR, EPR, or ABS incorrectly placed. Statement is ignored. |\n| Q | Warning. A statement whose syntax is questionable was encountered. |\n| R | Relocation Error. \n- Expression does not have a valid relocation. Expression is set to zero. \n- Non-absolute displacement specified. Displacement is set to zero. \n- Absolute origin specified in relocatable program. Origin is ignored. \n- Non-relocatable operand in END statement of relocatable mainline program. Columns 9-12 are left blank; entry is assumed to be relative zero. \n- Non-absolute operand specified in BSS or BES. Operand is assumed to be zero. \n- ENT operand is non-relocatable. Statement is ignored. \n- Invalid reference to CE Core. Address field is set to zero. (1800 only) \n- Invalid reference to a symbol defined in a COMMON area. Address field is set to zero. (1800 only) |\n| S | Syntax Error. \n- Invalid expression, for example, invalid symbol, adjacent operators, or illegal constant. Expression is set to zero. \n- Illegal character in record. If illegal character appears in expression, label, op code, format, or tag field, additional errors may be caused. \n- Main program entry point not specified in END operand. Columns 9-12 are left blank; entry is assumed to be relative zero. \n- Incorrect syntax in EBC statement (such as no delimiter in column 35, or zero character count). Columns 9-12 are not punched; address counter is incremented by 17. \n- Invalid label in ENT or ISS operand. Statement is ignored. |\n| T | Tag Error. Column 33 contains character other than blank, 0, 1, 2, or 3 in instruction statement. Tag of zero is assumed. |\n| U | Undefined symbol. Undefined symbol in expression. Expression is set to absolute zero. |\n\n**1130 ONLY**\n\n| W | X or Y coordinate, or both, not within the specified range, or invalid operand. Operand set to zero. |\n| X | Character other than R or I in column 32, or character other than D or N in column 33. Field set to zero. |\n| Z | Invalid condition in a conditional branch or interrupt order. Condition bits in first word set to zero. |\n### Table 2. Macro Assembler Error Codes and Messages\n\n<table>\n<thead>\n<tr>\n<th>Error Code</th>\n<th>Message</th>\n<th>Cause</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A01</td>\n<td>MINIMUM W.S. NOT AVAILABLE</td>\n<td>Working Storage (for DM2) or Batch Processing Working Storage (for MPX) available is less than the number of overflow sectors specified plus one.</td>\n</tr>\n<tr>\n<td>A01</td>\n<td>MINIMUM W.S. NOT AVAILABLE...</td>\n<td>Number of sectors of symbol table overflow is greater than the number of overflow sectors specified.</td>\n</tr>\n<tr>\n<td>A02</td>\n<td>SYMBOL TABLE OVERFLOW</td>\n<td>Intermediate output in pass 1 or final disk system format output in pass 2 is larger than Working Storage (for DM2) or Batch Processing Working Storage (for MPX) minus the number of overflow sectors specified.</td>\n</tr>\n</tbody>\n</table>\n| A03 | DISK OUTPUT EXCEEDS W.S. | With *SAVE SYMBO L TABLE option specified: \n1. Program in relocatable assembly. \n2. Program contains an assembly error. \n3. Source program causes more than 100 symbols to be present in the System Symbol Table. |\n| A04 | SAVE SYMBOL TABLE INHIBITED | XXX number of ORG, BSS, BES, and/or EQU statements that were undefined in pass 1. At the end of pass 1, these erroneous statements are printed on the list printer. If the error was due to forward referencing, it will not be detected during pass 2. |\n| A05 | XXX ERRONEOUS ORG, BSS, OR EQU STATEMENTS IN ABOVE ASSEMBLY | Errors were detected during pass one. This warning message is printed at the end of pass one. |\n| A06 | LOAD BLANK CARDS | A card containing a nonblank column in columns 1-71 has been read while punching the symbol table (as a result of an *PUNCH SYMBOL TABLE control statement). |\n| A07 | ABOVE CONTROL STATEMENT INVALID | An invalid control statement has been read by the Macro Assembler. The control statement is ignored and the assembly is continued. |\n| A08 | MACLIB UNDEFINED | The Macro Assembler has been asked to process a SMAC statement and either no *MACLIB control statement was previously read, or the name on the *MACLIB statement is not found in a disk area search. The library named in the *MACLIB statement has a library concatenated to it and this library could not be found. |\n| A09 | PARAMETER LIST OVERFLOW | A call to a macro exceeds the space specified in the N2 field of the *OVERFLOW SECTORS control statement used with this assembly. If the *OVERFLOW SECTORS control statement was not used or if the N2 field was not specified, the Macro Assembler assumes the value of the N2 field to be zero. |\n| A10 | MACRO AREA OVERFLOW | An attempt was made to define a temporary macro and either the N3 field of the *OVERFLOW SECTORS control statement was not specified, or the space specified by N3 was not large enough, or the macro library was exceeded. |\n| A12 | NEST LEVEL EXCEEDS 20 ASSEMBLY TERMINATED | A macro call exceeded the allowable nest level limit of 20. |\n| A21 | *LEVEL CONTROL STATEMENT MISSING | The program listed above was assembled as an ISS subroutine without the required *LEVEL control card. (1130 only) |\n| A22 | INVALID LIST DECK OPTION ASSEMBLY TERMINATED | An attempt was made to punch macro statements in two pass mode. (1130 only) |\n| A40 | MAIN PROG NO NAME | Mainline program being assembled has no name specified on a // ASM statement. (1800 only) |\n| A41 | // CARD READ | A Supervisor control statement has been read by the Macro Assembler. The Macro Assembler has passed this statement along to the Supervisor before terminating the assembly. Loading and DMP operations are inhibited. (1800 only) |\n| A42 | ABSOLUTE REENTRANT PROG | A non-relocatable program has been specified as reentrant. (1800 only) |\n| A43 | INVALID SFRL FILE | When loading the source deck via *SFRL, the file was truncated due to insufficient sector allocation. (1800 only) |\n| A44 | LIT TBL OVFL | The size of the literal table as specified on the fourth parameter of the *OVERFLOW SECTORS control statement was too small. (1800 only) |\n| A46 | XREF DATA OVFL | VCORE was too small to sort and merge the data for building the cross-reference table. (1800 only) |\nTable 3. Macro Update Program Error Messages\n\n<table>\n<thead>\n<tr>\n<th>Error Code and Message</th>\n<th>Cause and Corrective Action</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>D100 LIBRARY NOT FOUND</td>\n<td>Library named on a LIB, BUILD, JOIN, or CONCAT statement could not be found on drives currently in use. If LIB, BUILD, or JOIN statement, all statements are ignored until the next LIB, BUILD, or ENDUP statement is encountered. If CONCAT statement, processing continues with the next control statement. Correct the name field in the statement in error, or change the // JOB statement to include the drive on which the named library resides, or define the macro library using an *DFILE or *STOREDATA control statement.</td>\n</tr>\n<tr>\n<td>D101 INVALID SUBFIELD COL XX</td>\n<td>If on an INSERT or DELETE statement, the sequence number was incorrectly specified, that is, it was negative, or non-numeric, or sequence numbers were reversed. If on a SELECT statement, an incorrect parameter was specified. Processing continues with the next control statement. If on a NAME statement, an invalid parameter was detected. Processing continues with next LIB, BUILD, or ENDUP statement. XX indicates the column in which the error was found. Correct the error and rerun the portion of the job affected.</td>\n</tr>\n<tr>\n<td>D102 ILLEGAL REQUEST</td>\n<td>An invalid control statement was detected, an INSERT or DELETE statement was not preceded by an UPDATE or RENAME statement, or on an 1130, request was made for output to paper tape or to a pack configured for paper tape. Processing continues with the next control statement. Correct the error and rerun the portion of the job affected.</td>\n</tr>\n<tr>\n<td>D103 LIBRARY OVERFLOW</td>\n<td>The library last specified by a LIB or BUILD statement does not have enough room to perform the operation. If on a JOIN or an ADD statement, the operation is suppressed and the library is restored to its previous state. If on an INSERT statement, the statements listed prior to the message were the only ones that could be included. Processing continues with the next LIB, BUILD, or ENDUP statement. Additional space can be obtained in the current library by purging unneeded macros or deleting unneeded statements. If this is not possible, define a larger library using an *DFILE or *STOREDATA control statement, join the old library to a new one, and delete the old library. Once the additional space has been obtained, rerun the portion of the job affected. If on an INSERT, it may be necessary to alter your INSERT control statement as the statements in the macro library may have been resequenced.</td>\n</tr>\n<tr>\n<td>D104 MACRO NOT FOUND</td>\n<td>The macro name specified on an OUTPUT, PURGE, RENAME, or UPDATE statement could not be found in the library being processed. Processing continues with the next control statement. Correct the macro name on the statement in error, or specify the correct macro library and rerun the portion of the job affected.</td>\n</tr>\n<tr>\n<td>D105 SEQUENCE NUMBER NOT FOUND</td>\n<td>The sequence number on an INSERT or DELETE statement was out of range of the macro and could not be found or the sequence numbers on multiple INSERT and/or DELETE statements for the same macro were out of order. Processing continues with the next control statement. Place a correct sequence number on the statement in error and rerun the portion of the job affected.</td>\n</tr>\n<tr>\n<td>D106 LIBRARY NOT SPECIFIED</td>\n<td>An attempt was made to operate on a macro without specifying a macro library. Processing continues with the next LIB, BUILD, or ENDUP statement. Place a LIB or BUILD statement before the statement in error and rerun the portion of the job affected.</td>\n</tr>\n<tr>\n<td>D107 SPILL OVERFLOW</td>\n<td>Macro text insertions have caused the capacity of Working Storage spill to be exceeded. Processing continues with the next LIB, BUILD, or ENDUP statement. Correct the sequence numbers in the unprocessed INSERT statements, if necessary, and rerun these statements. It may be necessary to define additional disk drives to provide adequate Working Storage.</td>\n</tr>\n<tr>\n<td>D108 CONTROL STATEMENT READ</td>\n<td>An * or // statement has been read and the MUP run is terminated. On the 1800, control is passed to the Supervisor which will begin processing with the next // JOB statement. On the 1130 control is returned to the Supervisor for a // statement or to DUP for an * statement.</td>\n</tr>\n<tr>\n<td>D109 NAME STATEMENT NOT FOUND</td>\n<td>The operation attempted requires a NAME statement and one has not been processed following the last LIB or BUILD statement. Processing continues with the next LIB, BUILD, or ENDUP statement. Insert a NAME statement and rerun the part of the job that was affected.</td>\n</tr>\n<tr>\n<td>Error Code and Message</td>\n<td>Cause and Corrective Action</td>\n</tr>\n<tr>\n<td>-----------------------</td>\n<td>-----------------------------</td>\n</tr>\n<tr>\n<td>D110 INVALID NAME</td>\n<td>The name field on a LIB, BUILD, JOIN, CONCAT, UPDATE, ADD, PURGE, RENAME, or OUTPUT statement was left blank, the name specified was invalid, or the apostrophes are improperly placed. If on a LIB, BUILD, or JOIN statement, processing continues with the next LIB, BUILD, or ENDUP statement. If on a CONCAT, UPDATE, ADD, PURGE, RENAME, or OUTPUT statement, processing continues with the next control statement.</td>\n</tr>\n<tr>\n<td>D112 NONBLANK CARD READ. ENTER BLANK CARDS</td>\n<td>A nonblank card has been read by a 1442-6 or -7 during a punch operation. Remove stacked input from hopper, NPRO nonblank cards, place blank cards followed by NPRO cards and stacked input in the hopper, and press reader START and for the 1130 press program START.</td>\n</tr>\n<tr>\n<td>D116 LIBRARY NOT INITIALIZED</td>\n<td>Library named on a LIB, JOIN, or CONCAT statement has not been initialized previously. If on a LIB, or JOIN statement, processing continues with the next LIB, BUILD, or ENDUP statement. If on a CONCAT statement, processing continues with the next control statement. Initialize the library with a BUILD statement, and rerun the portion of the job affected.</td>\n</tr>\n<tr>\n<td>D117 INVALID PARAMETER</td>\n<td>On a NAME statement, more than 20 parameters were specified. If during the processing of a macro, a parameter has been detected which was not defined in the NAME statement or a parameter greater than one character was used in the format or tag field. If during an OUTPUT operation, the operation is aborted and processing continues with the next control statement. If during a listing operation, this is a warning message and the invalid parameter is printed as /N where N is 1-20. (Note: N may be truncated if the field size is exceeded.) If on OUTPUT, correct the NAME statement and rerun the portion of the job affected.</td>\n</tr>\n</tbody>\n</table>\nAppendix A: General Examples of Macros and 1130 DM2\nMacro Assembler Features\n\nThe following group of macros and the examples of their use are intended to demonstrate how macro instructions can be used to simplify assembler-language programming. If all these macros were defined in your system, then you could use two new statements—the READ statement and the WRITE statement—to accomplish all the programming normally required to effect input and output on an 1130 system having a disk, a 1442 card read punch, and a 1403 printer. When you issue a READ or WRITE macro, you need specify only the name (DISK, CARD, or PRINT) of the device you want to use, the name of the I/O area, and, if you want, the name of your error-handling program. This system of macros then issues calls to the appropriate I/O control subroutines, handles data conversion and blocking, and, at your option, handles error checking and retries.\n\nYou could, of course, expand this set of macros to include all I/O devices supported by the 1130 system; you could also write a similar set of macros to simplify I/O programming on the 1800 system.\n\nRefer to the 1130 Subroutine Library manual, Order Number GC26-5929, for a complete description of the 1130 I/O control subroutines (DISKN, CARD1, and PRNT3) referred to in these macros.\n\nThe first part of this sample program (until the *MACRO UPDATE statement) is a FORTRAN program that builds a one sector file of one-word integers having the value 1 through 320. This is necessary to handle the data file in the sample program that follows it.\n\n```fortran\n// JOB\nLOG DRIVE CART SPEC CART AVAIL PHY DRIVE 0000 0578 0578 0000\nV2 M06 ACTUAL 32K CONFIG 32K\n\n// * CREATE A DISK DATA FILE NAMED 'FILE1' AND FILL IT WITH * SMAC0020\n// * 320 INTEGER VALUES 1 TO 320 VIA FORTRAN. * SMAC0040\n\n// DUP\n*DELETE FILE1\nD 26 NAME NOT FOUND IN LET/FLET\n\n*STOREDATA WS UA FILE1 1 CART ID 0578 DB ADDR 3220 DB CNT 0010\n\n// FOR\n*IDCS(DISK)\n*LIST ALL\n```\n\nSMAC0010\n\nSMAC0020\n\nSMAC0030\n\nSMAC0040\n\nSMAC0050\n\nSMAC0060\n\nSMAC0070\n\nSMAC0080\n\nSMAC0090\n\nSMAC0100\n\nSMAC0110\n*ONE WORD INTEGERS\nDEFINE FILE 1(320,1,U,K)\n K = 1\n IVAL = 1\n DU 100 I = 1,320\n WRITE (1,K) IVAL\n IVAL = IVAL + 1\n100 CONTINUE\n CALL EXIT\nEND\n\nVARIABLE ALLOCATIONS\n K(I) = 0008 IVAL(I) = 0009 I(I) = 000A\n\nSTATEMENT ALLOCATIONS\n 100 = 0028\n\nFEATURES SUPPORTED\n ONE WORD INTEGERS\n IOCS\n\nCALLED SUBPROGRAMS\n SDFIO SDWRT SDCOM SDI\n\nINTEGER CONSTANTS\n I = 000C 320 = 000D\n\nCORE REQUIREMENTS FOR\n COMMON 0 VARIABLES 12 PROGRAM 38\n\nEND OF COMPILATION\n\n// XEQ L 1\n\n*FILES(1,FILE1)\nFILES ALLOCATION\n 1 0322 0001 0578 FILE1\nSTORAGE ALLOCATION\n R 41 7AFC (HEX) WDS UNUSED BY CORE LOAD\nLIBF TRANSFER VECTOR\n PAUSE 0408\n SDCOM 02A5\n SDI 025E\n SDWRT 02DA\n SDFIO 02DF\nSYSTEM SUBROUTINES\n ILS04 00C4\n ILS02 00B3\n 020C (HEX) IS THE EXECUTION ADDR\n\n// JOB\n\nLOG DRIVE CART SPEC CART AVAIL PHY DRIVE\n 0000 1111 1111 0002\n\nV2 M07 ACTUAL 32K CONFIG 32K\n\n// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n// * DEFINE A DISK FILE AND INITIALIZE IT FOR A MACRO LIBRARY. *\n// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n// *DELETE* PURGE\n*CART ID 1111 DB ADDR 2620 DB CNT 0050\n*DFILE* UA PURGE 0005\n*CART ID 1111 DB ADDR 2620 DB CNT 0050\n*MACRO UPDATE*\nBUILD 'PURGE'\n0262 0005 ** LIBRARY END **\n0000\n\nENDUP\n\nUPDATE COMPLETED\n\n// DEFINE 11 MACROS FOR THE MACRO LIBRARY NAMED 'PURGE'\n\n// ASM\n\nMACLIB PURGE\n\nLIST\n\n* ILLRQ MACRO\n* PRINTS ILLEGAL REQUEST MESSAGE WHEN CALLED\n* SMAC ILLRQ\n* LIST ON ILLEGAL REQUEST LIST\n00001 LIST ON ILLEGAL REQUEST LIST\n00002 LIST ON ILLEGAL REQUEST LIST\n00003 LIST ON ILLEGAL REQUEST LIST\n\n* AUTO ERROR\n* Generates a default error routine when ERRDR parameter is 0 or not passed.\n* SMAC AUTOE AUTOMATIC ERROR GENERATOR\n00001 DC ++1 CALL SEQ-ERROR ENTRY ADDR\n00002 MDX ++3 SKIP AROUND ERROR SUBR\n00003 DC ++4 ENTER HERE ON ERROR\n00004 BSC I ++5 RETURN TO RETRY OPERATION\n\n* READ MACRO\n* Sets function code and calls specific device\n* SMAC GENERAL READ MACRO\n00001 LABEL READ DEVC, AREA, ERROR\n\n* WRITE MACRO\n* SMAC GENERAL WRITE MACRO\n00001 LABEL DEVc 1, AREA, ERROR\n\nAppendix A: General Examples of Macros and Macro Assembler Features\nGENERAL WRITE MACRO\n\n0001 LABEL WRITE DEVC,AREA,ERROR\nMEND\n\n0001 LABEL DEVC 3,AREA,ERROR\nMEND\n\nDISK MACRO\n\n* Generates a LIBF call to DISKN.\n* To test for DISKN busy you must call the DISK\n* Macro directly with a func code of 0.\n\n* Label = Label\n* Func = 1 for read, 3 for write and 0 for test\n* Area = I/O area address or label\n* Error = optional users error routine\n\nSMAC DISK CALL GENERATOR\n\n0001 LABEL DISK FUNC,AREA,ERROR\n0002 LABEL LIBF DISK CALL DISK SUBR\n0003 AIF (FUNC EQ 1),READ TEST FOR READ FUNC\n0004 AIF (FUNC EQ 3),WRITE TEST FOR WRITE FUNC\n0005 ILLRQ ILLEGAL REQUEST,ABORT CALL\n0006 AGO END TERMINATE MACRO\n0007 READ ANOP DC /1000 READ FUNC CODE\n0008 AGO AREA GO ASSEMBLE I/O AREA ADDR\n0009 WRITE ANOP DC /3000 WRITE FUNC CODE\n0010 AGO AREA GO ASSEMBLE I/O AREA ADDR\n0011 TEST ANOP DC /0000 TEST FUNC CODE\n0012 DC **2 I/O AREA ADDR\n0013 MDX **2 BRANCH TO CONTINUE BUSY TEST\n0014 MDX **2 BRANCH AROUND I/O AREA\n0015 BSS 2 DUMMY I/O AREA\n0016 AGO END EXIT MACRO\n0017 AREA ANOP\n0018 DC AREA-1 I/O AREA ADDRESS\n0019 QERR SET DEFAULT ERROR CK FOR DEFAULT ERROR\n0020 AIF (QERR EQ 0),AUTOE\n0021 DC ERROR USER SPECIFIED ERROR PARAM\n0022 AGO END EXIT MACRO\n0023 AUTOE ANOP\n0024 AUTOE GENERATE ERROR SUBR\n0025 END ANOP MEND\n\nCARD MACRO\n\n* Generates a LIBF call to CARD1 subroutine.\n* To test for CARD1 busy you must call the CARD\n* Macro directly with a func code of 0.\n\n* Label = Label\n* Func = 1 for read, 3 for write and 0 for test\n* Area = I/O area address or label\n* Error = optional users error routine\n\nSMAC CARD CALL GENERATOR\n\n0001 LABEL CARD FUNC,AREA,ERROR\n0002 LABEL LIBF CARD1 CALL CARD SUBR\n0003 AIF (FUNC EQ 1),READ TEST FOR READ FUNC\n0004 AIF (FUNC EQ 3),WRITE TEST FOR WRITE FUNC\n0005 ILLRQ ILLEGAL REQUEST,ABORT CALL\n0006 AGO END TERMINATE MACRO\n0007 READ ANOP DC /1000 READ FUNC CODE\n0008 AGO AREA GO ASSEMBLE I/O AREA ADDR\n0009 WRITE ANOP\n\n72 1130/1800 Macro Assembler Programming\n# Macros and Macro Assembler Features\n\n**APPENDIX A: GENERAL EXAMPLES OF MACROS AND MACRO ASSEMBLER FEATURES**\n\n### PRINT MACRO\n- Generates a LIBF call to PRNT3 subroutine.\n- To test for PRNT3 busy, you must call the print macro directly with a FUNC code of 0.\n- **LABEL** = LABEL\n- **FUNC** = 3 for PRINT and 0 for TEST\n- **AREA** = I/O area address or label\n- **ERROR** = Optional users error routine\n\n### CONVERT MACRO\n- Handles Hollerith to printer code via 'HOLPR'.\n- 1 BINARY TO 6 HOLLERITH CHARS via 'BINDC'.\n- 6 HOLLERITH TO 1 BINARY CHAR via 'DCBIN'.\n- **WHERE**\n - **AREA** = INPUT AREA (OUTPUT FOR BINDC)\n - **RT** = CONVERSION RT, HOLPR, BINDC OR DCBIN\n - **+PRNTR** = OUTPUT CODE FOR HOLPR\n - **0** for console, 1 for 1403 printer\n - **OUTPT** = OUTPUT AREA FOR HOLPR\n - **CHCT** = CHARACTER COUNT FOR HOLPR\n\n### SMAC CODE CONVERSION CALL\n\n---\n\n**LABEL** CNVRT AREA, RT, +PRNTR, OUTPT, CHCT\n\n---\n\n### PRINT MACRO\n\n```assembly\nDC +/2000 WRITE FUNC CODE SMAC1610\nAGO AREA GO ASSEM I/O AREA ADDR SMAC1620\nSMAC1630\nTEST ANOP SMAC1640\nDC +/0000 TEST FUNC CODE SMAC1650\nMDX +3 BRANCH TO CONTINUE BUSY TEST SMAC1650\nSMAC1660\nEND DC SMAC1670\nEND ANOP SMAC1680\nSMAC1690\nDC AREA+ AREA ADDRESS SMAC1700\nQERR SET ERROR CK FOR DEFAULT ERROR SMAC1710\nSMAC1720\nAIF (QERR EQ 0) AUTOE SMAC1730\nSMAC1740\nDC ERROR USER SPECIFIED ERROR PARAM SMAC1750\nSMAC1760\nAUTOE ANOP SMAC1770\nSMAC1780\nAUTOE GENERATE ERROR SUBR SMAC1790\nSMAC1800\nEND ANOP SMAC1810\nMEND SMAC1820\n```\n\n---\n\n### CONVERT MACRO\n\n```assembly\n00001 LABEL PRINT FUNC, AREA, ERROR SMAC1830\nSMAC1840\n00002 LABEL LIBF PRNT3 CALL PRINT SUBR SMAC1850\nSMAC1900\n00003 AIF (FUNC EQ 3), WRITE TEST FOR WRITE FUNC SMAC1910\nSMAC1920\n00004 AIF (FUNC EQ 0), TEST TEST FOR TEST FUNC SMAC1930\nSMAC1940\n00005 AGO END TERMINATE MACRO SMAC1950\nSMAC1960\n00006 WRITE ANOP SMAC1970\nSMAC1980\n00007 DC +/2000 WRITE FUNC CODE SMAC1990\nSMAC2000\n00008 AGO AREA GO ASSEM I/O AREA ADDR SMAC2010\nSMAC2020\n00009 TEST ANOP SMAC2030\nSMAC2040\n00010 DC +/0000 TEST FUNC CODE SMAC2050\nSMAC2060\n00011 MDX +3 BRANCH TO CONTINUE BUSY TEST SMAC2070\nSMAC2080\n00012 AGO END EXIT MACRO SMAC2090\nSMAC2100\nSMAC2110\nEND ANOP SMAC2120\nSMAC2130\nSMAC2140\nSMAC2150\nSMAC2160\nSMAC2170\nSMAC2180\nEND ANOP SMAC2190\nSMAC2200\nSMAC2210\nSMAC2220\nSMAC2230\nSMAC2240\nSMAC2250\nSMAC2260\nSMAC2270\nSMAC2280\n```\n\n---\n\n### SMAC CODE CONVERSION CALL\n\n```assembly\n00001 LABEL CNVRT AREA, RT, +PRNTR, OUTPT, CHCT SMAC2290\nSMAC2300\n00002 AGO RT GEN APPROPRIATE CODE SMAC2310\nSMAC2320\nSMAC2330\nHOLPR ANOP SMAC2340\nSMAC2350\nDC +/PRNTR CONVERSION CODE SMAC2360\nSMAC2370\nSMAC2380\nDC AREA INPUT SMAC2390\nSMAC2400\n```\n\n---\n\n### Appendi x A: General Examples of Macros and Macro Assembler Features\n\n73\nDC OUTPT OUTPUT SMAC2340\nDC CHCT CHAR COUNT SMAC2350\nAGO END SMAC2360\nRT ANOP STOP HERE FOR BINDC AND DCBIN SMAC2370\nDC AREA I/O AREA SMAC2380\nEND MEND SMAC2390\n\n* BLOCK MACRO SMAC2410\n* GENERATE A BLOCK OF CONSTANTS. SMAC2420\n* A = CONSTANT TO FILL BLOCK WITH SMAC2430\n* B = NUMBER OF CONSTANTS TO GENERATE SMAC2440\n* SMAC CONSTANT DATA BLOCK SMAC2450\nLABEL BLOCK A,B GENERATOR SMAC2460\n\nLIST OFF SMAC2480\nCOUNT SET B SMAC2500\nDATA ANOP SMAC2510\nLIST SMAC2520\nDC A SMAC2530\nLIST OFF SMAC2540\nCOUNT SET COUNT-1 SMAC2550\nAIFB (COUNT GT 0),DATA SMAC2560\nLIST SMAC2570\nMEND SMAC2580\n\n* INREG MACRO SMAC2610\n* LOAR AN INDEX REGISTER WITH A VALUE SMAC2620\n* A = THE VALUE, B = THE REGISTER NUMBER SMAC2630\n* SMAC SET REGISTER B TO VALUE A SMAC2640\nA INREG B SMAC2650\nAIF (A GT 127),LONG SMAC2660\nAIF (A LT -128),LONG SMAC2670\nLDX B A SMAC2680\nAGO END SMAC2700\nLONG ANOP SMAC2710\nLDX LB A SMAC2720\nEND ANOP MEND SMAC2740\n\n* DECK MACRO SMAC2760\n* DECREMENT A COUNTER FOR LOOP CONTROL. SMAC2770\n* A = STORAGE ADDRESS OF COUNTER, IF ANY SMAC2780\n* B = REGISTER NUMBER SMAC2800\n* C = THE DECREMENT VALUE SMAC2810\n* SMAC DECREMENT COUNTER SMAC2820\nA DECK B,C SMAC2830\nAIF (B EQ 0),LONG TEST FOR INDEXING SMAC2850\nMDX B -C INDEXED COUNTER SMAC2860\nAGO END SMAC2870\nLONG ANOP SMAC2880\nMDX L A,-C NON-INDEXED COUNTER SMAC2890\nEND ANOP MEND SMAC2910\nSAMPLE PROGRAM\n\nPROGRAM WHICH\n\nA - READS ONE SECTOR DATA FILE WHICH CONTAINS INTEGER DATA FROM DISK\n\nB - READS EVERY 5TH ENTRY FROM CARD\n\nC - PUNCHES EVERY 3RD ENTRY TO CARD WITH SECOND ENTRY\n\nD - ADDS ONE TO EVERY OTHER ENTRY BEGINNING WITH SECOND ENTRY\n\nE - WRITES MODIFIED FILE TO PRINTER, 5 ENTRIES PER LINE\n\nPROGRAM WHICH\n\nA - READ THE DISK DATA FILE\n\nB - READ DATA CARDS AND STORE IN EVERY 5TH ENTRY\n\nC - PUNCHES EVERY 3RD ENTRY TO CARD\n\nD - ADDS ONE TO EVERY OTHER ENTRY BEGINNING WITH SECOND ENTRY\n\nE - WRITES MODIFIED FILE TO PRINTER, 5 ENTRIES PER LINE\n\nAppendix A: General Examples of Macros and Macro Assembler Features 75\nA I F (0 EQ 0),TEST\n+TEST\nANOP\n0013 0 0000\n+ DC /0000\n+ M D X *-3\n+ A G O END\n+END\nANOP\nCNVRT DATA,DCBIN CONVERT 1ST 5 CARD COLUMN SMAC3200\n0015 20 040C2255\n+ LIBF DCBIN\n+ A G O DCBIN\n+DCBIN\nANOP\nSTOP\n0016 1 01A5\n+ DC DATA\n0017 01 D6000062\nSTO L2 FILE SAVE AS 5TH CHARACTER SMAC3210\nDECR 2,5 DECREMENT LOOP CONTROL SMAC3220\n0019 0 72FB\n+ MDX 2 -5\n+ A G O END\n+END\nANOP\n001A 0 70EF\n* B STEP8 CONTINUE STEP B SMAC3230\n+ READ CARD,DATA PRIME 1442 FOR PUNCHING SMAC3240\n+ CARD L1,DATA READ ONE BLANK CARD SMAC3250\n001B 20 03059131\n+ A I F CARD1\n+ A I F (1 EQ 1),READ\n001C 0 1000\n+ DC /1000\n+ A G O DATA\n+DATA\nANOP\n001D 1 01A4\n+ QERR\nSET\n+ A I F (QERR EQ 0),AUTOE\n+A U T O E ANOP\n+A U T O E\n001E 1 0020\n+ DC **1\n001F 0 7003\n+ M D X *+3\n0020 0 0000\n+ DC\n0021 01 4C800020\n+ B S C I *+3\n+END\nANOP\n319 INREG 2 SET LOOP CONTROL SMAC3260\n+ A I F (319 GT 127),LONG\n+LONG\nANOP\n+ LDX L2 319\n+END\nANOP\n\n* C - CONVERT AND PUNCH EVERY 3RD ENTRY SMAC3280\n* SMAC3290\n+ SMAC3300\n+ SMAC3310\n+ SMAC3320\n0025 01 C6000061\nSTEPC LD L2 FILE-1 CONVERT INTEGER TO CARD 0 BUSY TEST SMAC3320\n0027 20 03059131\n+ LIBF CARD1\n+ A I F (0 EQ 1),READ\n+ A I F (0 EQ 3),WRITE\n+ A I F (0 EQ 0),TEST\n+TEST\nANOP\n0028 0 0000\n+ DC /0000\n+ M D X *-3\n+ A G O END\n+END\nANOP\nCNVRT DATA,BINDC CARD CODE SMAC3330\n002A 20 02255103\n+ LIBF BINDC\n+ A G O BINDC\n+BINDC\nANOP\nSTOP\n002B 1 01A5\n+ DC DATA\nWRITE CARD,DATA PUNCH DATA WORD SMAC3340\n002C 20 03059131\n+ LIBF CARD1\n+ A I F (3 EQ 1),READ\n+ A I F (3 EQ 3),WRITE\n+WRITE\nANOP\n002D 0 2000\n+ DC /2000\n+ A G O DATA\n+DATA\nANOP\n002E 1 01A4\n+ DC DATA-1\n0000\n+QERR\nSET\n+ A I F (QERR EQ 0),AUTOE\n\n76 1130/1800 Macro Assembler Programming\nAppendix A: General Examples of Macros and Macro Assembler Features 77\n\n+AUTOE ANOP\n+ AUTOE\n+ DC ++1\n0030 0 7003\n+ MDX **3\n0031 0 0000\n+ DC **-2\n0032 01 4C800031\n+ BSC 1 * -3\n+END ANOP\nDECR 2,3 DECR LOOP CONTROL SMAC3350\n+ AIF (2 EQ 0),LONG\n0034 0 72FD\n+ MDX 2 -3\n+ AGO END\n+END ANOP\n0035 0 70EF\nB STEPC CONTINUE STEP C SMAC3360\n319 INREG 2 SET LOOP CONTROL SMAC3370\n+ AIF (319 GT 127),LONG\n+LONG ANOP\n0036 00 6600013F\n+ LDX L2 319\n+END ANOP\n\n* D - ADD ONE TO EVERY OTHER ENTRY * SMAC3390\n* SMAC3400\n+ SMAC3410\n0038 01 C6000062\nSTEPD LD L2 FILE ADD 1 TO EVERY OTHER SMAC3420\n003A 0 8025\nA ONE DATA ENTRY STARTING WITH SMAC3430\n0038 01 D6000062\nSTO L2 FILE THE 2ND ENTRY SMAC3440\n003D 0 72EF\n+ MDX 2 -2\n+ AGO END\n+END ANOP\n003E 0 70F9\nB STEPD CONTINUE STEP D SMAC3450\n-320 INREG 1 SET OUTER LOOP COUNT SMAC3460\n+ AIF (-320 GT 127),LONG\n+ AIF (-320 LT -128),LONG\n+LONG ANOP\n003F 00 6500FEC0\n+ LDX L1 -320\n+END ANOP\n5 INREG 2 SET A TO 5 SMAC3470\n+ AIF (5 GT 127),LONG\n+ AIF (5 LT -128),LONG\n0041 0 6205\n+ LDX 2 5\n+ AGO END\n+END ANOP\n\n* E - WRITE FILE TO 1403 * SMAC3500\n* SMAC3510\n0042 01 C50001A3\nSTEP2 LD L1 FILE+321 FETCH DATA WORD SMAC3520\n0044 20 02255103\nCNVRT DATA+7,BINDC CONVERT DATA TO 1403 SMAC3530\n0045 1 01AC\n+ LIBF BINDC\n+ AGO BINDC\n+BINDC ANOP STOP\n0046 20 085935D9\n+ CNVRT DATA+7,HOLPR,1,PRINT,6 CODE SMAC3540\n+ LIBF HOLPR\n+ AGO HOLPR\n+HOLPR ANOP\n0047 0 0001\n+ DC /1\n0048 1 01AC\n+ DC DATA+7\n0049 1 01F6\n+ DC PRINT\n004A 0 0006\n+ DC 6\n+ AGO END\n+ AGO END\n0049\nOUTPT EQU 4 -2 SMAC3560\n004A 0 74040049\nMDX L OUTPT,4 ADJUST BUFFER ADDR SMAC3570\nSTEPF DECR 2,1 DECR LINE COUNT SMAC3580\n+ AIF (2 EQ 0),LONG\n004D 0 72FF\n+ MDX 2 -1\n+ AGO END\n+END ANOP\n004E 0 700E\nB STEPG CONTINUE TO FILL BUFFER SMAC3590\nOUTPT DECR 0,20 RESET BUFFER ADDR,NEW LINE SMAC3600\n+ AIF (0 EQ 0),LONG\n+LONG ANOP\n004F 01 74EC0049 + MDX L OUTPT,-20\n+END\n+ANOP\n+PRINT 0 BUSY TEST SMAC3610\n0051 20 176558F3 + LIBF PRNT3\n+ AIF (0 EQ 3),WRITE\n+ AIF (0 EQ 0),TEST\n+END\n+ANOP\n+TEST\n+WRITE\n+PRINT\n+PRINT\n+PRINT LINE\n0054 20 176558F3 + LIBF PRNT3\n+ AIF (3 EQ 3),WRITE\n+END\n+ANOP\n+WRITE\n+ANOP\n0055 0 2000 + DC /2000\n+ AGO PRINT\n0056 1 01F5 + DC PRINT-1\n0000 +QERR SET\n+ AIF (QERR EQ 0),AUTOE\n+AUTCE ANOP\n+AUTOE\n0057 1 0059 + DC ++1\n0058 0 7003 + MDX ++3\n0059 0 000D + DC **9\n005A 01 4C000059 + BSC 1 **3\n+END\n+ANOP\n% INREG 2 RESET LINE COUNT SMAC3630\n+ AIF (5 GT 127),LONG\n+ AIF (5 LT -128),LONG\n005C 0 6205 + LDX 2 5\n+ AGO END\n+END\nANOP\n005D 0 7101 STEP MDX 1 1 INCR DATA POINTER SMAC3640\n005E 0 70E3 MDX STEP2 CONTINUE TO PRINT SMAC3650\n005F 0 6038 EXIT EXIT SMAC3660\n**CONSTANTS AND BUFFERS** SMAC3670\n**CONSTANTS AND BUFFERS** SMAC3680\n+ ONE DC 1 CONSTANT 1 SMAC3690\n0060 0 0001 FILE EQU *+1 DATA FILE SECTOR ADDRESS SMAC3700\n0062 31 00140 BSS 320 DATA AREA SMAC3710\n0064 0 0050 DC 80 SMAC3720\n0065 0 0050 DATA BSS 80 CARD BUFFER SMAC3730\n01F5 0 0014 DC 20 SMAC3740\n01F6 0 0000 END STEPA SMAC3750\n01F6 0 7F7F + DC /7F7F\n01F7 0 7F7F + DC /7F7F\n01F8 0 7F7F + DC /7F7F\n01FA 0 7F7F + DC /7F7F\n01FB 0 7F7F + DC /7F7F\n01FC 0 7F7F + DC /7F7F\n01FD 0 7F7F + DC /7F7F\n01FF 0 7F7F + DC /7F7F\n0200 0 7F7F + DC /7F7F\n0201 0 7F7F + DC /7F7F\n0202 0 7F7F + DC /7F7F\n0203 0 7F7F + DC /7F7F\n0204 0 7F7F + DC /7F7F\n0205 0 7F7F + DC /7F7F\n0206 0 7F7F + DC /7F7F\n0207 0 7F7F + DC /7F7F\n0208 0 7F7F + DC /7F7F\n0209 0 7F7F + DC /7F7F\n020A 0 0000 END STEPA SMAC3790\n\n000 OVERFLOW SECTORS SPECIFIED\n000 OVERFLOW SECTORS REQUIRED\n\n78 1130/1800 Macro Assembler Programming\n014 SYMBOLS DEFINED\nNO ERROR(S) AND NO WARNING(S) FLAGGED IN ABOVE ASSEMBLY\n\n// XEQ L 1 N\n\n*FILES1, FILE1\nR 41 761E (HEX) WDS UNUSED BY CORE LOAD\nLIBF TRANSFER VECTOR\nPRTY 095C\nHOLL 090C\nPRNT3 0708\nHOLPR 0774\nBINDC 072C\nDCBIN 0604\nCARD1 05CA\nDISK N 00F9\n\nSYSTEM SUBROUTINES\nILS04 00C4\nILS02 00B3\nILS00 09AD\n\n03C0 (HEX) IS THE EXECUTION ADDR\n-00319 +00319 +00319 +00317 +00317\n-00315 +00315 +00313 +00313 +00311\n-00309 +00309 +00309 +00307 +00307\n-00305 +00305 +00303 +00303 +00301\n-00299 +00299 +00299 +00297 +00297\n-00295 +00295 +00293 +00293 +00291\n-00289 +00289 +00289 +00287 +00287\n-00285 +00285 +00283 +00283 +00281\n-00279 +00279 +00279 +00277 +00277\n-00275 +00275 +00273 +00273 +00271\n-00269 +00269 +00269 +00267 +00267\n-00265 +00265 +00263 +00263 +00261\n-00259 +00259 +00259 +00257 +00257\n-00255 +00255 +00253 +00253 +00251\n-00249 +00249 +00249 +00247 +00247\n-00245 +00245 +00243 +00243 +00241\n-00239 +00239 +00239 +00237 +00237\n-00235 +00235 +00233 +00233 +00231\n-00229 +00229 +00229 +00227 +00227\n-00225 +00225 +00223 +00223 +00221\n-00219 +00219 +00219 +00217 +00217\n-00215 +00215 +00213 +00213 +00211\n-00209 +00209 +00209 +00207 +00207\n-00205 +00205 +00203 +00203 +00201\n-00199 +00199 +00199 +00197 +00197\n-00195 +00195 +00193 +00193 +00191\n-00189 +00189 +00189 +00187 +00187\n-00185 +00185 +00183 +00183 +00181\n-00179 +00179 +00179 +00177 +00177\n-00175 +00175 +00173 +00173 +00171\n-00169 +00169 +00169 +00167 +00167\n-00165 +00165 +00163 +00163 +00161\n-00159 +00159 +00159 +00157 +00157\n-00155 +00155 +00153 +00153 +00151\n-00149 +00149 +00149 +00147 +00147\n-00145 +00145 +00143 +00143 +00141\n-00139 +00139 +00139 +00137 +00137\n-00135 +00135 +00133 +00133 +00131\n-00129 +00129 +00129 +00127 +00127\n-00125 +00125 +00123 +00123 +00121\n-00119 +00119 +00119 +00117 +00117\n-00115 +00115 +00113 +00113 +00111\n-00109 +00109 +00109 +00107 +00107\n-00105 +00105 +00103 +00103 +00101\n-00099 +00099 +00099 +00097 +00097\n-00095 +00095 +00093 +00093 +00091\n-00089 +00089 +00089 +00087 +00087\n-00085 +00085 +00083 +00083 +00081\n-00079 +00079 +00079 +00077 +00077\n-00075 +00075 +00073 +00073 +00071\n-00069 +00069 +00069 +00067 +00067\n\nAppendix A: General Examples of Macros and Macro Assembler Features 79\n*DFILE Statement 47-48, 61-62\n*MACLIB Control Statement 2, 22\n*MACRO UPDATE Control Statement 47\n*OVERFLOW SECTORS Control Statement 1-2\n*STOREDDATA Statement 47-48\n*, Used to Designate Comment Statements 5\n**LIBRARY END** 61-62\n**MACRO END** 61-62\n@ Sign 48\n$ Sign 48\n+ Sign\nused as a macro expansion indicator, 7\nused to indicate a positive number, 27\n# Sign 48\n\nADD Statement 51, 52-53\nAdditional Records, Continuing\nCalls to 12-13\nAGO Pseudo-Op\nuse in label and blank parameter\nchecking, 30\nAGO Pseudo-Op 17-18\nspecial considerations in use, 18-19\nAIF Pseudo-Op 15-16, 17\nrestriction of use, 29-30\nAIFB Pseudo-Op 15-16\nrestriction of use, 29-30\nspecial considerations in use, 18-19\nAmpersand, Used as a Concatenator 23\nequation, 24-25\nANOP Pseudo-Op 19-20\nApostrophe\nrestriction of use in the name of a\nstored macro, 5\nused in automatic name\ngeneration, 22-23\nAssemble if Back Pseudo-Op\nAssemble if Pseudo-Op\nAssembler Language, A symbolic\nprogramming language.\nAssembler-Language Statement, An\nassembler-language instruction or a\npseudo-operation.\nAssembler-Language Instruction, An\ninstruction that the Macro Assembler\ncan translate into exactly one\nmachine-language instruction.\nAutomatic Label Generation\nSee Automatic Name Generation.\nAutomatic Name Generation 1, 22-23.\nThe method by which different labels\ncan be generated during each\nexpansion of a macro instruction in\nthe same assembly.\n\nGlossary—Index\n\nspecial requirements on its use in\nnested definitions, 57-58\n\nBlank and Label Parameter Checking\nUsing AGO 30\n\nBUILD Statement 48\n\nCalling\nmacros, 7\nMacro Update Program, 47\nCalls\ncontinuation of to additional\nrecords, 12-23\nmacro, 7, 12\n\nCharacter String\nin message generation, 11-12\nsubstitution for a parameter, 10-11\n\nCharacters, Special 6, 10, 47\n\nChecking\nfor blank parameters, 28-29\nfor label and blank parameters\nusing AGO, 30-31\nfor unspecified parameters, 17-18\nfor unspecified parameters, a\nmacro, 34\n\nComma\nlack of use in continuation of NAME\nstatement, 52\nuse in a macro instruction, 7-8\n\nComments\ndesignating, 5, 58\nlisted within the expansion, 25\nSee also Remarks.\nCONCAT Statement 49-50\n\nConcatenation 2. The process by which\ntwo things (such as two parts of an\ninstruction, or two macro libraries)\nare logically joined together.\nof macro instructions, 23-25\nof macro libraries, 49-50\n\nConcatenating a Multiplicity of\nLibraries, 49-50\n\nConcatenators\nampersand, 23\nCONCAT statement, 49-50\nperiod, 23\n\nConditional Assembly Pseudo-Ops 15-18\nContinuing Calls to Additional\nRecords 12-13\n\nControl Statement 47. A statement that\nprovides instructions to some part of\nthe Disk Management Program or Disk\nUtility Program.\ncontinuation of, 47\n\nCopying an Existing Library 49\nCore Storage\nSee Main Storage.\nCreating a Language 1,37-45\n\nDC-Generating Macro 34-35\n\nDefining\na language, 1\na macro, 1,6\na macro during a Macro Update Run, 51-53\na macro instruction, 5\n\nDefinition Prototype Statement 5-6,53.\nThe statement in a macro definition that specifies the\nop code and parameters of the macro.\n\nprinting of, 6\nDELETE Statement 55-56\nin automatic name generation in nested\ndefinitions, 57-58\nin renaming a library, 51\nin updating a library, 50\n\nDeleting a Macro from a Library 53\nDeleting Statements from a Macro 55-56\n\nDesignating Comments 5,58\n\nDisconnecting Concatenated Libraries 50\n\nDisk Management Program (DMP) 47. A group\nof 1800 MPX disk utility and\nmaintenance programs that operate\nunder control of the Batch-Processing\nMonitor Supervisor.\n\nDisk Monitor System, Version 2 (DM2), The\nsecond version of an operating and\nprogramming system that provides for\nthe continuous batch-processing\noperation of the 1130.\nestimating size required, 1-2\ninitializing, 2,47-48\n\nDisk Utility Program (DUP) 47. A group of\n1130 disk utility and maintenance\nprograms that operate under control of\nthe Supervisor.\n\nDivision Operator 27\n\nDMP\nSee Disk Management Program.\n\nDM2\n\nDUP\nSee Disk Utility Program.\n\nEJCT Pseudo-Op 15,17,18\nEND Statement 15,17,18\nENDUP Statement 58-59\n\nEQU Statement 20\nsymbolic tag field in, 27\n\nError Flags 4,63-64\n\nError Messages 4,63,65-67\n\nEstimating\nsize of N2, 2\nsize of N3, 2\n\nExpansion 7. The coding generated when\nthe Macro Assembler encounters a macro\ninstruction; also, the process of\ngenerating this coding.\n\nField Specifications on Macro Update\nControl Statements 47\n\n84 1130/1800 Macro Assembler Programming\n\nFlags\nerror, 4,63-64\nwarning, 4,63\n\nHDNG Pseudo-Op 15,17,18\n\nIndirect Parameter Substitution 26,32-33.\nThe feature of the Macro Assembler\nthat allows different parameters on\nthe macro call statement to be\nsubstituted for a specific\nparameter in the macro expansion,\ndepending on some condition to be\ninspected during assembly.\n\nInitializing Disk Space 2,47-48\n\nINSERT Statement 54,55\nin automatic name generation in nested\ndefinitions, 57-58\nin renaming a library, 51\nin updating a library, 50\n\nInserting Statements in a Macro 54-55,56\nRestrictions on, 55,56\n\nInsufficient Parameter Names 52\n\nJOIN Statement 49-50\n\nJoining Macro Libraries\nlogically, 2,22,49-50\nphysically, 49-50\n\nLabel Field Parameters 8\n\nLabel and Blank Parameter Checking\nUsing AGO 30\n\nLabel Generation\nSee Automatic Name Generation.\n\nLanguage Creation 1,37-45\n\nLibrary\nSee Macro Library.\n\nLIB Statement 48\n\nList Control Pseudo-Ops 6\nLIST Pseudo-Op 15,17,18\n\nListing of\ncomment statements, 6\nmacro calls, 25\nmacro libraries, 56-57\n\nLNAME 3,48\n\nLogically Joining Macro\nLibraries 2,22,49-50\n\nMAC Statement 5,25,51,53\n\nMacro Assembler, The translating program\nthat accepts as input\nassembler-language instructions,\npseudo-operations, and macro\ninstructions.\nerror flags, 63-64\nerror messages, 63-65\nlanguage, 37-45\nmain-storage requirements, 3,4\nperformance, 4\npurpose, 1\nsample programs, 33-35,69-84\nsign-off message, 63\n\nwarning flag, 63\nMacro Calls 7, 12\ncontinuation to additional records, 12\nlisting of, 6\nnested, 3, 10, 23, 26, 32\n\nMacro Definition 1, 2. A sequence of\ninstructions that define the op code\nand parameters of a macro instruction\nand the coding to be generated when\nthe macro is assembled.\nduring a macro update run, 51-53\nnested, 3\n\nMacro Expansion 7\n\nMacro instruction 1. A source program\nstatement that, when encountered by\nthe Macro Assembler, causes a\npredefined sequence of statements to\nbe assembled.\ndefining, 5\nusing, 7\n\nMacro Library 3. A collection of macro\ndefinitions, saved on disk, that can\nbe used by any program that references\nthat library.\ncopying, 49\ndisconnecting, 50\ninitializing, 3\njoining logically, 49-50\njoining physically, 48-49\nmaintaining, 3\nnaming, 47-48\nspecifying, 48\n\nMacro Name 1, 5, 22\n\nMacro Parameter Substitution 32-33\n\nMacro Update Program 4, 47-62. A DMP or\nDM2 program that allows you to\ninitialize and maintain macro\nlibraries.\ncalling, 47\ncontrol statement sequencing, 59\nerror messages, 65-67\nmaking efficient use of, 59-60\nsample program, 61-62\n\nMacros\nstored, 1, 2-3\ntemporary, 1-2\nMain Storage Requirements\n1130, 3-4\n1800, 4\n\nMaking Efficient Use of the Macro\nUpdate Program 59-60\n\nMEND Statement 5, 51, 53\ntermination of AGO and AGOB\nsearch, 17\ntermination of AIFB search, 16\nMessage Generation 11-12\nMessage Macro 34\nMessages, Error 4, 63, 65-67\nMove Macro 34\n\nSee Multiprogramming Executive\nOperating System.\n\nMultiple Concatenation 49-50\n\nMultiprogramming Executive Operating\nSystem (MPX), An operating system\nfor the 1800 that can control\nprocesses and provide\nmultiprogramming and background\nprocessing.\n\nMUP\nSee Macro Update Program.\n\nN2 1, 2\nN3 1, 2\nName\nof a library, 47-48\nof a macro, 1, 5, 22\nof a parameter, 5-6, 7, 52\n\nName Generation, Automatic 1, 22-23, 57-58\n\nNAME Statement 47, 51-52\ncontinuation of, 51-52\nused in the sample program, 61-62\n\nName Subfield Left Blank on AIF and\nAIFB Statements 16\n\nNested Macro Calls 3\nin automatic name generation, 23\nin continued calls, 32\nin definitions defined during a macro\nupdate run, 53\nin indirect parameter\nsubstitution, 26, 32\npassing a set of parameters, 10\nrestrictions on, 3\n\nNested Macro Definitions 3. Macro\ndefinitions that are defined\nso that a call to one occurs\nwithin the expansion of the other.\nSELECT N considerations, 57-58\n\nObtaining a Listing of Macro\nLibraries 56-57\n\nOmitting\nname subfields on AIF and AIFB\nstatements, 16\noperand on AGO and AGOB statements, 17\nparameters, 8-9\n\nOp Code 5. That field of an\nassembler-language statement that\nspecifies the operation to be carried\nout by the CPU.\n\nOperand Field 6\n\nOperand Left Blank on AGO and AGOB\nStatements 17\n\nOptional Remarks 25\n\nOUTPUT Statement 54\n\nParameters\n\nblank, checking for, 28-29\nin a macro instruction, 1\nindirect substitution, 26, 32-33\ninsufficient names, 52\nlabel field, 8\nmacro to check for unspecified\nparameters, 34\nname, 5-6, 7\nomitting, 8-9\nsubstituting a character string\nfor, 10-11\nsubstitution, 6, 32-33\nunspecified, checking for, 17-18\n\nPerformance of the Macro Assembler 4\n\nGlossary-Index 85\nPeriod\nexample of use as a concatenator, 24\nin DEC and XPLC statements and\nconcatenation, 25\nused as a concatenator, 23\nused to designate comments, 58\nPhysically Joining Macro\nLibraries 48-49\nPlus Sign,\nused as a macro expansion indicator, 7\nused to indicate a positive number, 27\nPrinting\ndefinition prototype statements, 6\ninhibition of, 6,56-57\nsequence numbers, 6,55,61-62\nPseudo-Operation 3. An assembler-language\nstatement that provides information\nfor the Macro Assembler rather than\ngenerating executable code.\nAGO, 17-18\nAGOB, 17-18\nAIF, 15-16,17\nAIFB, 15-16\nANOP, 19-20\nconditional assembly, 15-17\nEJCT, 15,17,18\nEND, 15,17,18\nHDNG, 15,17,18\nLIST, 15,17,18\nMEND, 15,17,18\nPURG, 15,17,18\nSET, 20-22\nSPAC, 15,17,18\nPseudo-Ops\nSee Pseudo-Operation.\nPunching Source Statements 54\nPURG Statement 22\nPURG vs. PURGE 54\nPURGE Statement 53-54\nReclaiming Library Space 53-54\nRecords, Continuing Calls to\nAdditional 12-13\nRemarks\noptional, 25\nretaining, 5\nRENAME Statement 51\nRenaming a Macro in a Library 51\nRestrictions\non AIF, AIFB, and SET pseudo-ops, 29-30\non inserting statements, 55,56\non nested macro calls, 3\non nested macro definitions, 3\non parameter names, 6,11,51\nRetaining Remarks 5\nSample Programs\ncreating a language, 37-45\nMacro Assembler, 33-35\nMacro Update Program, 61-62\n1130 Macro Assembler, 69-84\nSELECT Statement 56-57\nSELECT N as Used with Automatic Name\nGeneration in a Nested\nDefinition 57-58\nSELECT P as Used with NAME\nStatement 59\nSemicolon, Used in Indirect Parameter\nSubstitution 26-32\nSense Switch 2 6,56-57\nSequencing MUP Control Statements 59\nSequence Numbers, Printing of 6,55,61-62\nSET Pseudo-Op 20-22\nrestriction of use, 29-30\nsymbolic tag field in, 27\nSign-Off Message 63\nSigns,\n@, 48\n$, 48\n+, 7,27\n#, 48\nSMAC Statement 5,25,51,53\nSource Statements, Punching\nof 54\nSpace, Reclaiming 53-54\nSPAC Pseudo-Op 15,17,18\nSpecial Characters 6,10,47\nSpecial Requirements on the Use of\nAutomatic Name Generation in\nNested Definitions 57-58\nSpecifying the Macro Library 48\nStatements\ndeleting from a macro, 55-56\ninserting into a macro, 54-55,56\nSee also the name of a particular\nstatement or the function it performs.\nStored Macro 1,2-3,5. A macro\ninstruction that is saved on disk\nand can be used by any program.\nSubstituting a Character String for a\nParameter 10-11\nin message generation, 1-12\nSubstitution\nindirect parameters, 26,32-33\nparameter, 6,32-33\nSymbol Table, for 1130 DM2 3-4\nSymbolic Tag Field 27-28\nTag Field, Symbolic 27-28\nTemporary Macro 1-2,5. A macro\ninstruction that is defined for use\nonly during one specific assembly.\nTerminating a Macro Update Run 58-59\nText 6,7. A list of assembler-language\ninstructions, calls to other macros,\nand/or pseudo-ops to be generated\nwhen a macro call is encountered.\nTruncation of Information Following\nColumn 71 6,10,25\n\n86 1130/1800 Macro Assembler Programming\nUnspecified Parameter Checking 17-18\nUPDATE COMPLETED 59, 62\nUPDATE Statement 50\nUpdating a Macro in a Library 50\nSee also DELETE Statement and INSERT Statement.\nUsing a Macro Instruction 7\n\nWarning Flag 4, 63\nX, Used to Designate an Addition of a Statement to a Macro or Library 55, 61-62\n• Please comment on the usefulness and readability of this book, suggest additions and deletions, and list specific errors and omissions (give page numbers). All comments and suggestions become the property of IBM. If you want a reply, be sure to give your name and address.\n\nName ___________________________________ Occupation ______________________________\nAddress ________________________________________________________________\n\n• Thank you for your cooperation. No postage necessary if mailed in the U.S.A.\nYOUR COMMENTS, PLEASE...\n\nThis publication is one of a series which serves as reference sources for systems analysts, programmers and operators of IBM systems. Your answers to the questions on the back of this form together with your comments, will help us produce better publications for your use. Each reply will be carefully reviewed by the persons responsible for writing and publishing this material. All comments and suggestions become the property of IBM.\n\nPlease note: Requests for copies of publications and for assistance in utilizing your IBM system should be directed to your IBM representative or to the IBM sales office serving your locality.\n• Please comment on the usefulness and readability of this book, suggest additions and deletions, and list specific errors and omissions (give page numbers). All comments and suggestions become the property of IBM. If you want a reply, be sure to give your name and address.\n\nName __________________________ Occupation __________________________\nAddress __________________________\n\n• Thank you for your cooperation. No postage necessary if mailed in the U.S.A.\nYOUR COMMENTS, PLEASE...\n\nThis publication is one of a series which serves as reference sources for systems analysts, programmers and operators of IBM systems. Your answers to the questions on the back of this form together with your comments, will help us produce better publications for your use. Each reply will be carefully reviewed by the persons responsible for writing and publishing this material. All comments and suggestions become the property of IBM.\n\nPlease note: Requests for copies of publications and for assistance in utilizing your IBM system should be directed to your IBM representative or to the IBM sales office serving your locality.\nPlease comment on the usefulness and readability of this book, suggest additions and deletions, and list specific errors and omissions (give page numbers). All comments and suggestions become the property of IBM. If you want a reply, be sure to give your name and address.\n\nName ___________________________ Occupation ___________________________\n\nAddress ___________________________\n\nThank you for your cooperation. No postage necessary if mailed in the U.S.A.\nYOUR COMMENTS, PLEASE...\n\nThis publication is one of a series which serves as reference sources for systems analysts, programmers and operators of IBM systems. Your answers to the questions on the back of this form together with your comments, will help us produce better publications for your use. Each reply will be carefully reviewed by the persons responsible for writing and publishing this material. All comments and suggestions become the property of IBM.\n\nPlease note: Requests for copies of publications and for assistance in utilizing your IBM system should be directed to your IBM representative or to the IBM sales office serving your locality.\n\nIBM\nInternational Business Machines Corporation\nData Processing Division\n112 East Post Road, White Plains, N.Y. 10601\n[USA Only]\n\nIBM World Trade Corporation\n821 United Nations Plaza, New York, New York 10017\n[International]\nThis technical newsletter provides pages for IBM 1130/1800 Macro Assembler Programming (Order Number GC26-3733-0). Pages to be replaced are listed below:\n\niii-iv\n63-66\n\nA change to the text is indicated by a vertical line in the left margin. A revised illustration is indicated by a bullet to the left of the caption.\n\nSummary of Amendments\n\nThe Macro Assembler Error Flags table and Error Codes and Messages table have been updated to reflect the changes made in Version 3 of the 1800 Multiprogramming Executive Operating System.\n\nPlease put this cover letter at the back of the manual to provide a record of changes.\n\nIBM Corporation, Programming Publications. Dept. D78, San Jose, Calif. 95114\n\nPRINTED IN U.S.A."}}},{"rowIdx":256,"cells":{"id":{"kind":"string","value":"71510a2d8b010376751ed911ab83bdf7e0318f28"},"text":{"kind":"string","value":"Contextual Governance for Service Oriented Architecture Composition\n\nThesis by P. de Leusse\n\nIn partial fulfilment of the requirements for the degree of doctor of philosophy\n\nNewcastle University\nNewcastle upon Tyne, UK\n2010\nAcknowledgements\n\nI am fortunate to have worked in the School of Computing Science at Newcastle University in close collaboration with the Security Architecture Group at BT Design and Innovate between 2006 and 2009. Many people in the School and at BT have helped me during this period and I have received valuable feedback on my research work. I do not have the space to acknowledge them all individually.\n\nSeveral people deserve special mention with respect to the work in this thesis. First, I thank my initial supervisors, Dr Panos Periorelis and Dr Theo Dimitrakos, for their supports, guidance and insights. It has been a privilege to work closely with Panos and Theo, and with Professor Paul Watson and Mr David Brossard. Paul has had a significant influence on the work I did at the school. David and I have worked together closely on this topic during this period, which has been a rewarding experience. I must also thank Dr Graham Morgan for useful discussions about this thesis. He is not responsible for any misconceptions that may persist. In addition, as reviewer, he has suggested a number of important improvements to this thesis. Dr Nektarios Georgalas of BT Design and Innovate was equally helpful.\n\nFinally, and most importantly, I thank Anna. I owe her an incalculable debt. This has been a long journey for me. I know it must have seemed longer to her.\nAbstract\n\nCurrently, business requirements for rapid operational efficiency, customer responsiveness as well as rapid adaptability are driving the need for ever increasing communication and integration capabilities of the software assets.\n\nFunctional decomposition into re-usable software entities, loose coupling, and distribution of resources are all perceived benefits of the investment on Service Oriented Architecture (SOA). This malleability can also bring about the risk of a more difficult oversight. The same service is ideally used in different applications and contexts. This situation forces a supporting infrastructure to allow and manage the adaptability to these different contexts of use.\n\nIn this thesis, the author proposes to govern such variations in a cost efficient way by composing the core business function offered by a service with other services implementing infrastructure capabilities that fulfil varying non-functional requirements.\n\nHowever, as the number of services increases and their use in different contexts proliferates, it becomes necessary to automate policy enforcement and compliance monitoring. Furthermore, the composition of services into different business applications over a common infrastructure intensifies the need for end-to-end monitoring and analysis in order to assess the business performance impact. Managing the full life-cycle of service definition, deployment, exposure and operation requires management processes that take into account their composition with the infrastructure capabilities that take of non-functional requirements. In addition, policies may change during the life-time of a service. Policy updates may be the result of various reasons including business optimisation, of reaction to new business opportunities, of risk / threat mitigation, of operational emergencies, etc. It becomes therefore clear that a well-designed governance architecture is a prerequisite to implementing a SOA capable of dealing with a complex and dynamic environment.\n## Content\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Description</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>CONTENT</td>\n<td></td>\n<td>4</td>\n</tr>\n<tr>\n<td>LIST OF FIGURES</td>\n<td></td>\n<td>6</td>\n</tr>\n<tr>\n<td>LIST OF TABLES</td>\n<td></td>\n<td>8</td>\n</tr>\n<tr>\n<td>1.</td>\n<td>INTRODUCTION</td>\n<td>9</td>\n</tr>\n<tr>\n<td>1.1.</td>\n<td>EXAMPLE APPLICATION</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.1.1.</td>\n<td>Virtual music store scenario</td>\n<td>12</td>\n</tr>\n<tr>\n<td>1.2.</td>\n<td>SCOPE OF WORK</td>\n<td>15</td>\n</tr>\n<tr>\n<td>1.3.</td>\n<td>THESIS CONTRIBUTIONS AND OVERVIEW OF THESIS</td>\n<td>17</td>\n</tr>\n<tr>\n<td>1.3.1.</td>\n<td>Overview of thesis</td>\n<td>17</td>\n</tr>\n<tr>\n<td>2.</td>\n<td>BACKGROUND</td>\n<td>19</td>\n</tr>\n<tr>\n<td>2.1.</td>\n<td>THE RECENT HISTORY OF MODERN INTEGRATION TECHNIQUES</td>\n<td>19</td>\n</tr>\n<tr>\n<td>2.1.1.</td>\n<td>Evolution of middleware</td>\n<td>19</td>\n</tr>\n<tr>\n<td>2.1.2.</td>\n<td>Enterprise Service Bus</td>\n<td>22</td>\n</tr>\n<tr>\n<td>2.1.3.</td>\n<td>Conclusions on the recent history</td>\n<td>23</td>\n</tr>\n<tr>\n<td>2.2.</td>\n<td>MODELS AND ARCHITECTURES</td>\n<td>24</td>\n</tr>\n<tr>\n<td>2.2.1.</td>\n<td>Reference models and architecture for SOA</td>\n<td>24</td>\n</tr>\n<tr>\n<td>2.2.2.</td>\n<td>Autonomic computing based SOA governance model</td>\n<td>29</td>\n</tr>\n<tr>\n<td>2.2.3.</td>\n<td>Service Delivery Framework</td>\n<td>30</td>\n</tr>\n<tr>\n<td>2.2.4.</td>\n<td>Conclusions of reference models and architectures</td>\n<td>32</td>\n</tr>\n<tr>\n<td>2.3.</td>\n<td>FLEXIBLE CONTEXTUALISATION</td>\n<td>33</td>\n</tr>\n<tr>\n<td>2.3.1.</td>\n<td>Conclusions of flexible contextualisation</td>\n<td>35</td>\n</tr>\n<tr>\n<td>2.4.</td>\n<td>SAFETY OF CONTEXTUALISATION</td>\n<td>37</td>\n</tr>\n<tr>\n<td>2.1.</td>\n<td>SOA Governance</td>\n<td>38</td>\n</tr>\n<tr>\n<td>2.2.</td>\n<td>CONCLUSIONS OF BACKGROUND</td>\n<td>39</td>\n</tr>\n<tr>\n<td>2.2.1.</td>\n<td>Summary of research challenges</td>\n<td>39</td>\n</tr>\n<tr>\n<td>3.</td>\n<td>ANATOMY OF A SOA GOVERNANCE ARCHITECTURE</td>\n<td>42</td>\n</tr>\n<tr>\n<td>3.1.</td>\n<td>INTRODUCTION OF THE ANATOMY</td>\n<td>42</td>\n</tr>\n<tr>\n<td>3.2.</td>\n<td>ANATOMY CONCEPTS</td>\n<td>42</td>\n</tr>\n<tr>\n<td>3.2.1.</td>\n<td>Capability</td>\n<td>42</td>\n</tr>\n<tr>\n<td>3.2.2.</td>\n<td>Policies</td>\n<td>43</td>\n</tr>\n<tr>\n<td>3.2.3.</td>\n<td>Processes</td>\n<td>43</td>\n</tr>\n<tr>\n<td>3.2.4.</td>\n<td>Users</td>\n<td>44</td>\n</tr>\n<tr>\n<td>3.2.5.</td>\n<td>Governance times</td>\n<td>44</td>\n</tr>\n<tr>\n<td>3.3.</td>\n<td>DATA STRUCTURES ANATOMY</td>\n<td>45</td>\n</tr>\n<tr>\n<td>3.3.1.</td>\n<td>Infrastructure profile</td>\n<td>45</td>\n</tr>\n<tr>\n<td>3.3.2.</td>\n<td>Context</td>\n<td>48</td>\n</tr>\n<tr>\n<td>3.3.3.</td>\n<td>Context selector</td>\n<td>49</td>\n</tr>\n<tr>\n<td>3.3.2.</td>\n<td>Summary of the data structure descriptions</td>\n<td>50</td>\n</tr>\n<tr>\n<td>3.4.</td>\n<td>COMPONENTS ANATOMY</td>\n<td>51</td>\n</tr>\n<tr>\n<td>3.4.1.</td>\n<td>Core infrastructure capabilities</td>\n<td>51</td>\n</tr>\n<tr>\n<td>3.4.2.</td>\n<td>Profile management infrastructure capabilities</td>\n<td>52</td>\n</tr>\n<tr>\n<td>3.4.3.</td>\n<td>Summary of the components descriptions</td>\n<td>58</td>\n</tr>\n<tr>\n<td>3.5.</td>\n<td>PROCESSES ANATOMY</td>\n<td>59</td>\n</tr>\n<tr>\n<td>3.5.1.</td>\n<td>Define infrastructure capability</td>\n<td>59</td>\n</tr>\n<tr>\n<td>3.5.2.</td>\n<td>Define policy templates</td>\n<td>60</td>\n</tr>\n<tr>\n<td>3.5.3.</td>\n<td>Define infrastructure capability dependencies</td>\n<td>62</td>\n</tr>\n<tr>\n<td>3.5.4.</td>\n<td>Define information flow</td>\n<td>63</td>\n</tr>\n<tr>\n<td>3.5.5.</td>\n<td>Define profile management processes</td>\n<td>64</td>\n</tr>\n<tr>\n<td>3.5.6.</td>\n<td>Select infrastructure profile instance</td>\n<td>65</td>\n</tr>\n<tr>\n<td>3.5.7.</td>\n<td>Define service-specific policies</td>\n<td>66</td>\n</tr>\n<tr>\n<td>3.5.8.</td>\n<td>Define information flow</td>\n<td>66</td>\n</tr>\n<tr>\n<td>3.5.9.</td>\n<td>Define service exposure management processes</td>\n<td>67</td>\n</tr>\n<tr>\n<td>3.5.10.</td>\n<td>Publish service instance</td>\n<td>67</td>\n</tr>\n</tbody>\n</table>\nList of figures\n\nFigure 1. Interaction governance ................................................................. 11\nFigure 2. To the right is the long tail; to the left are the few that dominate [9] ...... 13\nFigure 3. The Jazz Music Store VO ............................................................ 15\nFigure 4. Figure 1 Integration history [18] .................................................. 20\nFigure 5. A Service-Oriented Architecture Maturity Model [23] .................... 21\nFigure 6. Integration approaches [25] ....................................................... 22\nFigure 7. Generic ESB example .................................................................. 23\nFigure 8. Execution Context [29] ............................................................... 25\nFigure 9. Relationship among types of governance [30] ............................... 26\nFigure 10. The Middleware View of the SOA Reference Architecture [31] .... 27\nFigure 11. Conceptual SOA Governance Model - Global View [39] .............. 29\nFigure 12. Service Delivery Platforms .......................................................... 31\nFigure 13. TMF Service Delivery Framework Reference Model ..................... 31\nFigure 14. An Architectural Overview of the MDD framework proposed in [47]... 34\nFigure 15. SSB-based Composition of the Application with Security Components [49] ............................................................................................................................... 35\nFigure 16. Design time governance ............................................................. 44\nFigure 17. Run time governance ................................................................. 45\nFigure 18. Illustration of the Profile definition XML schema ....................... 46\nFigure 19. Profile description taxonomy ...................................................... 48\nFigure 20. Illustration of the Context definition XML schema ..................... 49\nFigure 21. Illustration of the Context Selector definition XML schema ......... 50\nFigure 22. Governance data model concepts and their relationships ............ 51\nFigure 23. Architectural diagram of the governance framework – interactions at design time ................................................................. 53\nFigure 24. Profile initiator interface description ........................................... 54\nFigure 25. Management interface overview ............................................... 54\nFigure 26. Profile composition interface description .................................... 54\nFigure 27. Profile composition management interface description ................ 55\nFigure 28. Profile life-cycle management interface description ..................... 55\nFigure 29. Profile selector interface description ......................................... 56\nFigure 30. Service management overview ................................................ 57\nFigure 31. Profile management overview .................................................. 59\nFigure 32. UML sequence diagram of the define infrastructure capability governance process .......................................................... 60\nFigure 33. UML sequence diagram of the define policy templates governance process ...................................................................................................................................... 61\nFigure 34. UML sequence diagram of the define service dependencies governance process .......................................................................................................................... 63\nFigure 35. Infrastructure profile creation ........................................................................................................................................ 65\nFigure 36. UML sequence diagram of the select infrastructure profile instance governance process ...................................................................................................... 66\nFigure 37. Business capability exposure ............................................................................................................................................... 68\nFigure 38. Governance life-cycle ....................................................................................................................................................... 69\nFigure 39. Internal governance pattern ........................................................................................................................................... 70\nFigure 40. Perimeter governance pattern ........................................................................................................................................ 71\nFigure 41. Shared governance pattern ............................................................................................................................................... 71\nFigure 42. Federated governance pattern ........................................................................................................................................ 71\nFigure 43. Virtual Music Store - user interface ........................................................................................................................................ 75\nFigure 44. Virtual music store scenario with security governance gateway ........................................................................................................... 75\nFigure 45. SOA security governance overview [81] .......................................................................................................................... 77\nFigure 46. Governance user interface and “I Love My Classics Store” profile .... 83\nFigure 47. CP1 Exposition profile ....................................................................................................................................................... 85\nFigure 48. Test 1 result ............................................................................................................................................................................ 88\nFigure 49. Test 1 validation test result ............................................................................................................................................... 88\nFigure 50. Mapping the Governance Model on the SDF standard ................................................................................................... 97\nFigure 51. Layered view of the governance architecture .................................................................................................................. 98\nList of tables\n\nTable 1. Comparison of modern approaches to integration 24\nTable 2. Comparison of reference models and architecture for SOA 33\nTable 3. Comparison of approaches investigating adaptability of contextualisation 37\nTable 4. Comparison of approaches investigating safety of contextualisation 38\nTable 5. Registration data of logging infrastructure 79\nTable 6. Registration data of HTTP digest authentication and decoding infrastructure 80\nTable 7. Registration data of SecPAL Authorization infrastructure 81\nTable 8. Registration data of VMS business capability 82\nTable 9. Contextual data for “CP3: I Love My Classics Store” profile in the VMS 83\nTable 10. Context selector for “CP3: I Love My Classics Store” profile and the “CreateContentQuery” operation of the business capability 84\nTable 11. CP1 Exposition profile 85\nTable 12. Implementation tests results 89\nTable 13. Adaptability tests results 91\nTable 14. Summary of research challenges 96\nTable 15. WS-Profile XML Schema 112\nTable 16. WS-Context XML Schema 113\nTable 17. WS-ContextSelector XML Schema 115\n1. Introduction\n\nThe way enterprises conduct business today is changing greatly. The enterprise has become more pervasive with a mobile workforce, outsourced data centres, different engagements with customers and distributed sites [1]. In addition, companies seeking to optimise their processes across their supply chains are implementing integration strategies that include their customers and suppliers rather than looking inward. This increases the need for governing end-to-end transactions between business partners and the customer (B2B2C and B2B2G) [2].\n\nAs pervasive organisations connect their heterogeneous environments and systems, cross- and intra-enterprise compliance becomes more critical. The legal and regulatory frameworks become more complex and less forgiving. Companies have to comply with their own directives and regulations as well as comply with different legislations and regulations depending on the region of operation and the client or partner organisations’ rules and legal constraints. IT use in the corporate environment, and in particular the governance of the IT infrastructure that enables business services, will need to provide means to measure and control compliance.\n\nGlobalisation and agility of integration require more systems along with more partners and more constraints and produce more complex environments where decision making processes are equally increasingly complex and crucial for this connected organisation. Change in a single process has the potential to impact more than one partner and disrupt a wider range of business processes.\n\nIt is important for any enterprise to understand how its business has performed at any given time in the past, present, and in the future. However, single partners no longer have a full visibility of all processes and their consequences. It becomes much harder for a single enterprise to therefore govern its collaboration with other enterprises in a safe and controlled way, to understand the use of its information and resources across the value chain, and to identify and assess the impact of violations of policies or agreements. There is a need for well-orchestrated, end-to-end operations management that provides controlled visibility, governance of network and IT state, timely assessment of the impact of security policy violations and the availability of resources. Hence, there is an increasing interest in Service Oriented Infrastructure (SOI) dashboards [3] showing real-time state of the corporate infrastructure including the B2B integration points.\n\nFinally, another consequence of these changes in the organisational environment is the emergence of the notion of Virtual Organisations (VO). These are defined in [4] as “temporary or permanent coalitions of individuals, groups, organisational units or entire organisations that pool resources, capabilities and information to achieve common objectives”. According to this definition, VOs can provide services and thus participate as a single entity in the formation of further VOs, hence creating recursive structures with multiple layers of “virtual” value-adding service providers. The required scalability, responsiveness, and adaptability, requires a cost effective resource distribution management solution for dynamic VO environments.\n\nEffective solutions addressing these challenges require interdisciplinary approaches integrating tools from law, economics and business management in addition to distributed or “Cloud” computing. However, in this latter category, there are three\nmain aspects, as illustrated in Figure 1 to achieving effective governance in the context of high-value B2B interactions:\n\n1. **Resource visibility** - brings the best fit for purpose visibility into the IT infrastructure used and its state. This aims at making sure that not only it is possible to find the resource but also that its purpose and constraints are well understood. With complex systems comprised of many resources (e.g. Web service, policy) there is a strong requirement to increase the visibility of each resource. Indeed a same functionality could be provided by different services and advertised in different places. In addition, one of the strengths of SOA being reuse and composition, there is an obligation to know how resources communicate and are wired together. The relevant management of dependencies amongst resources is indeed a crucial element of the visibility. Furthermore, with a single resource involved in several collaborations or discussions it is necessary to keep track of how this same functionality is proposed (i.e. its attached constraints). Increasing the visibility includes advertising its functionality as well as Non Functional Properties (NFP) correctly and its issuer or provider.\n\n2. **Policy administration and management** - administers policies coming from different sources of authority and that may apply to different, potentially interrelated, contexts and business collaborations. In an organisation, the different levels of hierarchy manage their resources according to their responsibilities. As such managers set up rules on how certain requests from clients are going to be dealt with when the directors will set up the roles and limits of the manager’s authority. As IT services attempt more and more to support business functions, the same types of policies should be applied to them, allowing for different levels of authority that apply in particular or more general cases. The same apply for the different areas of expertise where an account manager will dictate the pricing policy for a client and the lawyer will know how to write legal contracts. IT services are dependants of the IT specialists at different levels (e.g. deployment, security) as well as non-IT specialists. This aspect also deals with managing the selection and integration of the best policy decision and policy enforcement mechanisms to support the optimal use of IT resources and services in a given context and in compliance with corporate agreements. As introduced in the three points above, an SOA will suffer from having many services that may be available in different contexts and at different stages of their life-cycle. The management of the SOA is made through the use of policies and as such it is crucial to be able to manage how these are going to be used and enforced. In addition, such policy administration and management should allow detecting potential conflicts within the imbrications of services and their policies.\n\n3. **Service provisioning** - deals with the processes that allow organisations to effectively manage the exposure conditions of their services. This aspect of governance aims at both allowing an efficient contextualisation of the service interface provided to potential partners as well as supplying this contextualisation with the processes necessary to render its governance flexible.\nIn this thesis, the author aims to address the latter aspect of governance. The work presented in this thesis concerns the flexible management of services interactions where the properties of these exchanges are not a priori known. A related concern is that services should not suffer security and performance disadvantages as a result from exposing in this flexible manner. Thus governance can extend to supporting the safety of the interaction and scalability of the infrastructure supporting the exchanges.\n\nThe main contributions of this work are the design and evaluation of a flexible middleware architecture supporting the governance of B2B interactions. The author designed this architecture to support two domains of action – design and run times – that address requirements of the interactions management. The author shows how the middleware architecture can be implemented with a set of middleware services. The segregation of concerns proposed presents different advantages such as dynamic composition of the interaction contextualisation and systematic auditing. Additionally, this allows presenting an abstraction layer that is familiar from the enterprise context while providing regulated interactions in B2B context. For example, governed interactions can be used to secure exchanges in a more flexible manner than traditional approaches (c.f. section 2).\n\nIn Section 1.1 of this chapter the author describes an example application that serves to motivate the work presented in this thesis and provide requirements for that work. Section 1.2 summarises the scope of the work. Finally, section 1.3 concludes the chapter with the assertion of thesis contributions and an overview of the remainder of the thesis.\n1.1. Example application\n\nThis section describes a scenario that motivates the work in this thesis. This application is in part used to derive research challenges defined in section 1.2. In Chapter 4, it also serves as proof-of-concepts for the implementation and discussion of the interaction governance middleware that address the challenges.\n\nThe example application is a virtual music store. This music store is a public interface that aggregates and resells content and services from different specialised providers (e.g. Jazz or Classic music specialists).\n\nThis example does not mean that the proposed approach is limited to this type of scenario. Indeed, a service oriented enterprise architecture with an environment of services providing functions (e.g. payroll, fleet management) would have also been a good motivation scenario. In the same manner, a service oriented e-health environment where devices, data and functions are available through network interfaces could have been used. Indeed, any scenario that would provide strong reuse and exposition flexibility requirements could have been presented.\n\nIn the following text, the term profile is associated with a set of NFPs provided as a managed composition of services.\n\n1.1.1. Virtual music store scenario\n\n1.1.1.1 Description\n\nThis section describes the virtual music store as an example of a Virtual Organisation (VO). According to [5], VOs are frequently restructured, sustained to capture the value of a market opportunity and dissolved again to give way for the creation of the next VO from within the network of independent partners. This represents a need for adaptability that current systems, such as the GOLD middleware [6] or the current B2B gateway [7], attempt to address by providing one type of security profile.\n\nThe aggregated services are virtual music stores serving specialised markets or communities of interest. The basic service providers include copyright owners of musical recordings or their representatives who make these recordings available online and syndicated blogs or review sites. The music stores reach agreement with music providers enabling them to act as resellers of bundles of recordings from their catalogues. The virtual store is a VO consisting of the music store operator as well as content providers and it runs on top of an infrastructure provided by an infrastructure provider.\n\nThis scenario is based on the increasing trend of Long Tail retailing. The Long Tail concept describes the niche strategy of selling a large number of unique items in relatively small quantities, usually in addition to selling fewer popular items in large quantities. The concept was popularised by Chris Anderson in [8], in which he mentioned Amazon.com and Netflix as examples of businesses applying this strategy. Figure 2 illustrates the Long Tail concept.\nThe end customer of the virtual music store will be a member of the public. What they will see is a normal website where they will be able to search for and buy tracks and read reviews and blogs. This could be presented to them in much the same way as AbeBooks does, i.e. a search page and then each returned item is linked in from an independent seller; or stores could hide the aggregated nature of the service.\n\n1.1.1.2 Stakeholders\n\nIn the music store, the main categories of partner are:\n\n- **Infrastructure provider:** This role involves providing the VMS with a Virtual Hosting Environment (VHE), the B2B gateway. The purpose of the infrastructure is to hide the technical complexity of the middleware involved to the different participants in the virtual music store.\n\n- **Music content provider:** This is a specialist content provider (e.g. record labels or other copyright owners).\n\n- **Virtual music store operator:** The broker of music. It is assumed that the store operator will be the VO Initiator. As such the operator is responsible for instigating the opening federation process.\n\n- **Value adding service provider:** This is a third party entrusted with providing Value Adding Services (VAS). These services provide non-functional proprieties (e.g. security, audit, translation) and allow the content providers and music store operator to leverage on the VHE to enhance their interoperability and quality of service.\n\n1.1.1.3 VO Lifecycle\n\nSo let us look closer into the life-cycle of the virtual music store. The music store life-cycle starts with the initial agreements and discovery of the potential partners, the VO foundation. This is followed by the negotiation between these partners and the VO initiator to reach a firm collaboration agreement, this stage is called the partners’ federation. Following this, the capabilities are virtualised and made available to the partners in the newly formed VO. Finally the adaptability faculty of the virtual store infrastructure is introduced.\n**VO foundation.** Prior to any task and once the virtual shop has decided to establish the music store, it needs to reach an agreement with the infrastructure provider. The infrastructure provider is said to provide a VHE, on which it instantiates an ‘empty’ VO which is configured by the virtual shop operator. The VHE being in place, the shop operator contacts the potential participants of the music shop (i.e. content providers). Agreements are reached between these music providers and the shop operator and access to the VO Manager is granted to the content providers to setup their accounts and modify their data. The content providers can consequently publish the business functions they want to expose. These selected capabilities are published as services into a capability registry.\n\n**Partner federation.** At this stage it becomes possible for the virtual shop operator to put in place the different services offered by the music store.\n\nTo achieve this, as introduced above, the operator creates a new VO for each federation of content providers it wants to create. Additionally, the operator defines a collaborative process to describe the interactions between the different business functions potentially present in the federation. Once this structure is in place, the operator can search the capability registry for the specific business functions it wants to aggregate and using the VO Manager sends a participation request to the relevant providers.\n\nThe providers contacted can inspect the process description and interaction description already provided by the store operator to take a decision upon participating in this federation. Having accepted the invitation, the content providers associate to the VO the VAS profile they want to apply to this federation. The VAS profiles are defined for each capability by its provider.\n\nThese profiles include infrastructure services used to secure and monitor the services. They are created and managed in much the same way as the federation between the operator and the music providers but include the VAS providers. The services are typically comprised of policy enforcement, authentication, authorisation and other added value services such as billing or auditing. In addition, the profiles are composed of policy templates that define the policies to be applied to each of the selected infrastructure services in the profile.\n\nFollowing this, the operator can review and select the best matches in the positive answers it has received. With all the targeted business functions fulfilled, the virtual shop operator can continue the VO creation process and sends a creation order.\n\nThe VO management tool subsequently interacts with each partner’s gateway. To allow the different identity providers to recognise each other’s authority, it sends the relevant list of business cards associated with each business partner (role). In addition, the VO management tool sends the policies related to the implementation of the collaboration management for each business function. These policies come on the top of the security profiles setup and made available by the service providers.\n\nBrokered services, such as the jazz music store aggregating the different content providers’ services that offer jazz music, can be created along with their federation data following this method. The jazz music store is illustrated in Figure 3.\nCapability virtualization. With the federation in place, it is possible for the participants to finalise the configuration of the instances of the services they selected and prepared for this specific VO. Before undertaking this, the gateway management interface allows the participant to inspect the configuration of its infrastructure. At this stage, the configuration of the infrastructure will have evolved as the services are exposed and activated. Additionally, the selected Federated Identity Provider (FIP) has built trust with the FIPs of the other partners in the VO. Furthermore, the baseline policies that restrict who can issue access policies about which resources have been activated.\n\nFinally, the VAS profile that will be applied by the Partner for the business functions it performs is stored in a specific registry. To keep track of the configuration, the settings are associated with a unique collaboration ID. Upon configuration of the infrastructure, provisioning of policy templates and establishment of trust between the different VOs it becomes possible for the capability instances exposed to be invoked within the context of the virtual music store.\n\nAdaptability. A music provider might want to participate in several such federations to increase its visibility. But different partners in various VOs will have distinct security needs and settings. By adjusting the VAS profile used in each federation to its specific needs, the content provider can more promptly offer its services.\n\n1.2. Scope of work\n\nThe ever increasing amount of IT services along with all the potential states and types of configurations necessitate the development of adequate methods and tools for services governance. In [10], the concept of SOA governance is derived from corporate and IT governances. Corporate governance is referred to as the set of processes, customs, policies, laws and institutions affecting the way in which a corporation is directed, administered or controlled. IT governance is a subset of\ncorporate governance that focuses on the control, performance and risk of IT systems. For SOA, the term governance refers to the processes used to oversee and control the adoption and implementation of an SOA in accordance with recognised policies, audit procedures and management policies. SOA governance aims at providing optimum service quality, consistency, predictability and performance. An SOA governance environment should offer the ability to define, administer and enforce a combination of processes, practices and tools that facilitate the management of the life-cycle of the services in the SOA as well as the life-cycle of the different policies that apply on these services.\n\nFunctional decomposition into services, reuse, loose coupling, and distribution of resources are all perceived benefits of the investment on SOA. This malleability can also bring about the risk of a more difficult oversight. As the same service is used in different applications the infrastructure will have to adapt to these different contexts of use in order to provide variations in required functionality, quality of service, billing schemes and security requirements. Achieving such variations in a cost efficient way can be achieved by composing the core business function offered by a service with other services implementing infrastructure capabilities that fulfil varying Non-Functional Requirements (NFRs).\n\nHowever, as the number of services increases and their use in different contexts proliferates, it becomes necessary to automate policy enforcement and compliance monitoring. Furthermore, the composition of services into different business applications over a common infrastructure intensifies the need for end-to-end monitoring and analysis to assess the business performance impact. Managing the full life-cycle of service definition, deployment, exposure and operation requires management processes that take into account their composition with the infrastructure capabilities that take charge of the NFRs. Finally, policies may change during the life-time of a service. Policy updates may be the result of various reasons including business optimisation, of reaction to new business opportunities, of risk / threat mitigation, of operational emergencies, etc. It becomes therefore clear that a well designed governance model is a prerequisite to successfully deploying services in a dynamic environment. More details on the objectives of such a SOA governance framework are given in the following paragraphs:\n\n- **Resource contextualisation**: Permits resources to be efficiently configured for and managed at an end-to-end level is one of the main objectives of SOA governance.\n\n- **Resource adaptation**: Enables diagnosis and remediation in an as automated as possible fashion. SOA systems can potentially become very complex, with many different policies and services. This not only allows to adapt resources to specific transactions in function of an organisation's rules but to manage this adaptation in a more configurable, reliable and secured way.\n\n- **Contextualisation safety**: Manages the contextualisation so that contextual information cannot infringe into another context. Safety mechanisms should also ensure that the adaptation does not result in a loss or inadequate sharing of data.\n1.3. **Thesis contributions and overview of thesis**\n\nSection 1.2 identified three domains – resource contextualisation and adaptation as well as safety of the contextualisation process – that provide broad coverage of B2B interactions and a challenging set of requirements to support the governance of exchanges. In this context, the author’s thesis contributes:\n\n1. A set of middleware services that provide an efficient support for flexible resource contextualisation.\n2. This enhanced flexible contextualisation can be governed in such a manner that it preserves the safety of the exchanges.\n\nThis statement will be justified by the design, implementation and deployment of novel middleware.\n\nThe remainder of the thesis substantiates the claim of novelty with respect to these systems. Before providing an overview of the thesis, the author elaborates on novel contributions in these three areas.\n\n### 1.3.1. Overview of thesis\n\nThe work presented in this thesis addresses the research challenges identified in Section 1.2 by providing middleware to support the governance of B2B interactions. To this effect, the author proposes an SOA based architecture where the infrastructure capabilities providing support for NFPs that are not known a priori potentially come from third party providers. The approach is to provide a coherent definition of the interaction needs (i.e. in terms of NFPs) and compute these needs into an implementable and manageable aggregation of services. The architecture proposed also identifies the supporting – i.e. core – infrastructure necessary to provide the governance. The inherent flexibility of the architecture ensures that its implementation can be adapted to different application-specific requirements. Given this architecture, the author develops a prototype implementation. In addition, a proof-of-concepts application demonstrates the utility of the architecture implementation in the domain of SOA security. The thesis has the following structure.\n\n**Chapter 2** provides an overview of related works. The chapter concentrates on work on middleware that is fundamental to the architecture presented. The author also surveys work on contract-mediated interaction, policy driven middleware and on middleware support for flexible interactions management.\n\n**Chapter 3** describes the anatomy of the SOA based architecture for service exposure governance that, along with its implementation and proof of concepts utilisation, are the novel contributions. The services are based on an interceptor-mediated view of interactions that: (i) allows end users (e.g. web service manager, other governance system) to define their requirements in term of NFPs, (ii) supports the design of adaptable services, and (iii) provides a set of processes to checks the safety of the adaptation. This chapter develops work first reported in [11], [12] and [13].\n\n**Chapter 4** describes the implementation of the architecture described in Chapter 3. A proof-of-concept application based on the example in Section 1.1.1 demonstrates the utility of the implementation. In addition, this chapter describes a qualitative evaluation of the proof-of-concept application. This is based on work first reported in [14] and [15].\nChapter 5 concludes the thesis with a summary of contributions, including an evaluation with respect to the requirements set out in this chapter, and an overview of future work.\n2. Background\n\nIn this chapter, the author introduces the reader to the domain of software integration in distributed computing and reviews the most pertinent related. These are: software architecture definition in an SOA, flexible resource contextualisation in an SOA, and management of this contextualisation’s safety (c.f. section 1.3).\n\nIn section 2.1, the author introduces a short history of modern software integration through middleware. This part comprises content about how SOAs came to be and the development of the Enterprise Service Bus (ESB) concept which is a SOA based software infrastructure that acts as an intermediary layer of middleware through which distributed services and information can be made available. Section 2.2 identifies the principal reference models and architectures that could influence the author’s definition of a concrete architecture for governance of safe and flexible resource contextualisation in an SOA. Section 2.3 reviews the most relevant works in the domain of flexible contextualisation while part 2.4 evaluates their counterparts in the domain of contextualisation safety. Finally, a conclusion on the related work and a summary of the different research challenges is proposed in section 2.2.\n\nThroughout this chapter, the different elements described are assessed against potential research problematic that are then summarised in section 2.2.1.\n\n2.1. The recent history of modern integration techniques\n\nDistributed systems have become more and more complex. This is partly due to the amount of technologies developed and the frequency in which they appear. In particular the amount of platforms implemented (e.g. .NET, Java, Axis, WebSphere) as well as the various specifications related to the different issues associated with Enterprise Application Integration (EAI) or SOA (with several standardisation bodies such as W3C, OASIS or WS-I) have rendered the middleware environment more opaque. This situation, linked with the raise of inter-application communications [16] and the possible repeated changes of partnerships in these interactions [17], have caused a situation where Return On Investment (ROI) and ease of integration can be difficult to reach.\n\nThe traditional opportunistic integration is generally achieved using conventional application-to-application or point-to-point communication [18]. But these approaches have their limits. The complexity grows exponentially with the number of applications or points and the frequency they change. Furthermore, the maintenance and integration costs increase as the application becomes more complex.\n\nTherefore, one objective of more recent integration approaches is to reduce the complexity of integration by replacing the point-to-point ad-hoc with systematic integration through a specialised integration platform. In the next sections, this trend will be analysed and its main outcome in term of integration practice for SOA.\n\n2.1.1. Evolution of middleware\n\nThe first wave of integration practices aimed to provide APIs and interfaces between systems. As shown on Figure 4, this was mostly achieved either using custom Remote Procedure Calls (RPC) or messaging technologies like CORBA. This generation of middleware primarily aimed to achieve point to point integration and most of the\nconnectors were custom built. This generally allowed heterogeneous systems to communicate and in the case of messaging technologies, allowed to store and to forward messages. On the other hand, specific interfaces had to be developed for every system involved but at the same time the lack of widely spread communication semantics meant that many different formats prospered, thus generating a low level of reusability and rendering all coding and maintenance complex.\n\nThe next generation mainly aimed to improve the reusability as well as connectivity issues and introduced the spoke-hub distribution paradigm. Common integration infrastructures subsequently developed include, application servers and EAI brokers such as hub-and-spoke architectures that can potentially offer features such as message routing, transformation, business rules enforcement, transaction monitoring and auditing. This approach allowed reducing the connection complexity as with n nodes, a maximum of n - 1 routes are necessary to connect all nodes, compared to \\( n(n - 1)/2 \\) nodes that would be required in a point-to-point network. In addition, this made possible to re-use and share the integration logic among multiple expositions. These advantages provided connectors that were potentially faster to put in place and easier to maintain. However, the broker or application server due to its hub-and-spoke nature can create a bottleneck effect, impacting on the performance as well as creating a single point of failure. Furthermore, although this type of infrastructure can support exchange format standards, this aspect was still being neglected during this age.\n\nFinally, this type of middleware links the connected systems together in a tightly coupled fashion, as it often intertwines the application and the integration logic.\n\nWith inter-application integration passing from a consideration to one of the main centres of interest, the current generation of middleware focuses on loosening the coupling and developing common exchange semantics. This brought up the emerging growth of the SOA paradigm and technologies such as Representational State Transfer (REST) [19] or Web Services (WS) and Message Oriented Middleware (MOM) in particular. With this concept, distributed systems can rely upon independent services in which the application specific logic is independent from the connection infrastructure. In addition, with the adoption of XML and the large effort put into defining common specifications and standards, more flexibility has been granted. Both software layers’ segregation and semantic rationalisation allow the\ncreation of applications that are built by combining loosely coupled and interoperable end points. Services are widely used to abstract different application specific logics to reflect business activities [20]. These activities can be reused and combined to compose new services or processes [21] without impacting the underlying activities. This is generally acknowledged as being the main commercial interest of SOA [22] as it allows a faster and safer ROI. But one major factor that slows down the development of efficient process composition is the fair amount of hard coding still required by current middleware infrastructures to be connected to each other. Furthermore, the extensive use of connecting infrastructures, their complexity and the increasing need to connect them are rendering the middleware landscape more complex.\n\nThe author acknowledges that the acronym SOA for some people is simply a marketing term for the packaging of the communication infrastructure, which in actual fact should not matter. Interoperability and connectivity issues have been discussed for the past 20 years, however what SOA has brought about is the need to integrate at the middleware level using standardised technologies.\n\nIt is indeed interesting to note that while SOA eases the diversity and heterogeneity issues inherent to distributed systems; it does not completely solve them. In fact, the present standardised ways to abstract and simplify application specific logic used by middleware to address inter-software communication issues can also cause problems between middleware structures. These issues are intrinsic to heterogeneous environments where different interests and practices meet. The next generation of middleware should respond to this challenge and alleviate inter-middleware communications to allow more dynamic service and process compositions, thus enabling more effective business collaboration. This is suggested in the SOA Maturity model [23] which advocates that top level SOA infrastructures should be able to more dynamically adapt to changes.\n\nFigure 5. A Service-Oriented Architecture Maturity Model [23]\n2.1.2. Enterprise Service Bus\n\nA possible way of potentially enhancing middleware adaptability has been found in leveraging the infrastructures and practices produced during the evolution of integration software previously introduced.\n\nThe hub-and-spoke architecture has the benefit of being centralised, which provides a good structure for key features such as message routing or auditing as well as allows a higher level of reusability. However it does not scale well across heterogeneous and large distributed systems due to the centralised nature of the middleware itself. In addition, the historical lack of common exchange semantics hinders the creation of evolving collaborations. These issues were partially solved by SOA, but while allowing a more loosely coupled model, it requires time consuming low level coding. Moreover in a highly evolving environment, Message Oriented Middleware (MOM) necessitates a higher level of abstraction to allow the reusability and integration levels necessary for a fast ROI.\n\nFigure 6 shows some of the higher level qualities of these infrastructures and introduces the concept of ESB. The ESB architecture applies knowledge learnt throughout the evolution of middleware and attempts to leverage the technologies subsequently developed [24]. Indeed the bus takes the centralised approach of the application server, the abstracted nature of the EAI broker with the distributed nature of MOM to provide a solution for rapidly adaptable middleware.\n\n\n\n**Figure 6. Integration approaches [25]**\n\nAlthough the exact definition of ESB varies according to author, company or features it includes, it is possible to draw a general picture.\n\nAn ESB is a SOA based software infrastructure that acts as an intermediary layer of middleware through which distributed end points are made available. It provides an abstraction layer that acts as entry point to a bus. Once the messages have been intercepted by the entry point, series of actions can take place in the bus. These actions take the form of services which are called according to various elements such as: message content, origin, destination and sets of rules predefined.\nFigure 7 shows a basic ESB infrastructure in which services can communicate through an abstracted interface provided by the bus. Once a message is received by the bus end-point, series of actions can take place. The type of actions taking place is influenced by both the content of the messages received and the way the bus has been configured to handle them. In this specific example the bus offers authentication, transformation, content base routing and orchestration services. Finally, once the messages have been treated it is sent to the appropriate end point with the suitable data. A more detailed discussion on ESB can be found in [26].\n\n2.1.3. Conclusions on the recent history\n\nThe concept of ESB tries to leverage different technologies and designs used throughout the middleware landscape thus moving away from the opportunistic point to point inter-software communication and adopting the centralised approach already introduced by the traditional EAI broker. In addition, the ESB concept takes advantage of the SOA paradigm benefits which jointly provides a potential architecture for highly distributed and adaptable as well as loosely coupled middleware. Table 1 summarises the key elements discussed in this section.\nTables 1-4 legend:\n/ No support\nL Light support\nX Fully supported\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>(1) Reusability of integration layer</th>\n<th>(2) Shared communication semantics</th>\n<th>(3) Decentralised model</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>“First wave” of integration practices</td>\n<td>/</td>\n<td>/</td>\n<td>/</td>\n</tr>\n<tr>\n<td>Spoke-hub distribution paradigm</td>\n<td>L</td>\n<td>/</td>\n<td>/</td>\n</tr>\n<tr>\n<td>Custom built SOA middleware</td>\n<td>L</td>\n<td>L</td>\n<td>X</td>\n</tr>\n<tr>\n<td>ESB</td>\n<td>L+</td>\n<td>L+</td>\n<td>L</td>\n</tr>\n</tbody>\n</table>\n\nTable 1. Comparison of modern approaches to integration\n\nHowever, if it is possible to increase the number of interaction enhancing infrastructures (e.g. non-repudiation, message level security) offered by an ESB (c.f. [26] for list), it is clear that simply aggregating them does not suffice. Indeed, mechanisms to both define what infrastructures are to be used, how to use them and to provide a control over the information flow between these infrastructures are necessary.\n\n2.2. Models and architectures\nThe main research challenge of this work is to investigate the two points listed in section 1.3 and provide a concrete architecture that describes a potentially implementable solution. There has been plenty of work from both academia and industry around the definition of architecture and indeed more specifically, architecture for SOA governance. Many of these works, such as [27] are not mentioned in this section as they have not reached a certain level of visibility and or do not bring any addition to the models and architecture mentioned below. The following section reviews briefly the major efforts in this domain and describes their influential elements in the context of the current work.\n\n2.2.1. Reference models and architecture for SOA\nAn abundance of specifications and standards have emerged from open standard organisations such as OASIS, OMG or The Open Group on the topic of SOA. In [28] the major instances are introduced and categorised.\nThese models and architectures, as expected from their status of “reference”, do not present a readymade and expressive manner to implement a specific SOA. Indeed, they rather introduce the reader to the main artefacts forming a SOA along with, for some of them, guiding principles, processes, and technologies that could help organisations in the process of defining their own SOA.\n\nIn [29] however, an Execution Context illustrates the set of technical and business elements that form a path between those with needs and those with capabilities in the context of service providers and consumers interaction. All interactions are grounded in a particular execution context, which permits service providers and consumers to interact and provides a decision point for any policies and contracts that may be in force. On Figure 8, the Execution Context is represented with its links to the Interaction and Contract & Policy elements. The presence of the Service and Service description elements on this figure also give us a sign of their importance in this context.\n\n\n\nAlthough this reference model provides valuable information on related concepts, it is insufficient to define a concrete architecture or implement a SOA governance infrastructure. Indeed, there is no description of the execution context itself or how it can be manipulated. These sets of information are necessary in order to design the contextualisation and adaptation processes which are key elements of the governance this thesis aims to describe.\n\nIn [30], SOA governance is defined as: “Governance in the context of SOA is that organisation of services: that promotes their visibility; that facilitates interaction among service participants; and that directs that the results of service interactions are those real world effects as described within the service description and constrained by policies and contracts as assembled in the execution context.”\n\nFigure 9 illustrates the vision of SOA governance in this report by lining the different types of governances within an organisation.\nFigure 9. Relationship among types of governance [30]\n\nAlways according to this report, SOA governance applies to three aspects of service definition and use:\n\n- SOA infrastructure – the “plumbing” that provides utility functions that enable and support the use of the service\n- Service inventory – the requirements on a service to permit it to be accessed within the infrastructure\n- Participant interaction – the consistent expectations with which all participants are expected to comply\n\nAs introduced in section 1, this thesis specifically looks into supporting the first item on this list, the SOA infrastructure.\n\nWith regards to this item, the Reference Architecture Foundation for SOA Version 1.0 defines ([30] page 95) a single requirement; a SOA governance architecture should take into account:\n\n- “Governance requires that the participants understand the intent of governance, the structures created to define and implement governance, and the processes to be followed to make governance operational.”\n\nThis point is focusing on the visibility and readability aspects of the governance processes as well as the availability of these processes as SOA services.\n\nAlthough this reference architecture provides valuable information on related concepts and different requirements, it is insufficient to define a concrete architecture or design a SOA governance architecture.\n\nIn [31] a SOA reference architecture is described. This reference architecture defines a governance layer that mostly aims at managing different types of policies such as QoS or security. It is unclear from its short description if this layer is meant to only verify the compliance of services against these policies or if execution is also thought of.\n\nHowever as illustrated on Figure 10, the authors of the SOA reference architecture take into account the challenge of contextualisation and interaction management.\nThis reference architecture does provide valuable information about different requirements for SOA governance although they are not explicitly defined. Moreover, there lacks a discussion on designing issues which renders the creation of a concrete architecture and its implementation difficult to plan just from this reference architecture.\n\nThe most promising development with regard to an emerging SOA Governance architecture is the work conducted by the Open Group. Their proposal, presented in [32], for a SOA Governance framework describes the governance activities that are impacted by an SOA and puts forward some best-practice governance rules and procedures for those activities. However, as of September 2009 it has only the status of a Draft Technical Standard and still lacks essential elements such as a specification of detailed accountabilities along the service life cycle or a sound taxonomy that relates the core governance elements to each other.\n\nTwo of the main goals of this document are to provide a definition of a SOA Governance Reference Model (SGRM) and its constituent parts as well as a SOA governance vitality method to guide the customisation of the aforementioned model for specific contexts. A relevant approach for this thesis in relation to these two points would be to see how they are defined and can be elaborated upon in order to provide a concrete architecture that allows designing an efficient SOA governance infrastructure.\n\nFrom the guiding principles listed in the SGRM and in the context of the current thesis the following points must be taken into account:\n\n- **Contracts**: provider and consumer contracts shall exist between service providers and consumers in order to ensure the correct delivery of service.\n\n- **Service metadata**: decisions and descriptions relating to services and their contracts shall be stored in a well known location, including relationships among services and their associated artefacts.\n\n- **Automated processes**: SOA Governance processes need to be automated as it improves the reliability and traceability of the governance.\nThe two first points on contract and service metadata are indeed crucial elements when designing a SOA governance, as they impact on the ways the service exposition, discovery and assembly processes will be achieved. But without a clearer definition, all the work of investigating these points is left to the entity designing the governance. These topics are complex research issues on their own and have seen consequent research and industry efforts in the past, with the most widely accepted outcomes being WSDL [33], SAWSDL [34], WSMO [35] and OWL-S [36]. But many other solutions have been provided (e.g. WADL [37], METEOR-S [38]). It is therefore unrealistic to go as far as advising a concrete technology or implementation stack at the generic concrete architecture level as each approach will have its own advantages and inconvenient. However, providing a set of general, but precise and helpful, requirements falls into the role of an architecture and this point is lacking in this work.\n\nRegarding this last point on processes, the SGRM defines three governing processes: compliance, dispensation, and communication which need to be performed on an ongoing basis.\n\n- **Compliance**: the purpose of this type of process is to define a method to ensure that the SOA policies, Guidelines and Standards are adhered to. The compliance process provides the mechanism for review and approval or rejection against the criteria established in the governance framework (i.e. principles, standards, roles, and responsibilities etc.).\n\n- **Dispensation**: this type of process has the reverse function of the aforementioned type of compliance; it allows managing non compliance.\n\n- **Communication**: these processes ensure access to and use of governance information.\n\nThese processes are during the three different stages of governance that are planning, design and operational. At the planning level, the processes are concerned with portfolio management. At design and operational time the governance processes aim at efficiently managing service and solution life-cycles.\n\nIn the context of this thesis, only design and operational times are relevant. For these stages, the SGRM lists the principal following requirements:\n\n- Establishing and approving service\n- Publishing services to enable reuse\n- Managing multiple versions of a service\n- Enabling service assembly for building composite services and applications\n- Validating service contracts, functional and non-functional requirements\n- Ensuring change management for SOA services which includes accurate impact analysis of deployed services\n\nAs for the contract and metadata points, this list of processes is a helpful hint of what needs to be taken into account. However, this work is lacking a discussion of the issues (e.g. virtualisation, management, safety) raised when designing these processes.\n\nThe TOG SOA Governance Framework mainly aims at describing SOA governance, its goals and how it impacts on the enterprise from a management point of view.\nThere are relevant principles that can be learnt from it, such as the points listed in this section. However, as of the time of writing, this work is still a draft. Additionally, it lacks the level of details about contextualisation description and execution that are vital for implementing contextualisation governance.\n\n### 2.2.2. Autonomic computing based SOA governance model\n\nThe authors of [39] explore the relation between SOA Governance and Autonomic Computing, showing how principles and properties developed for the later can support SOA Governance. This leads the authors to create the term of Autonomic SOA Governance Infrastructures (ASGI) which is a governance infrastructure with autonomic capabilities. Following this, the authors describe a conceptual model for SOA governance based on the OASIS Reference Model for SOA, the work in [40], [41] and [42]. This conceptual model is represented on Figure 11.\n\n![Figure 11. Conceptual SOA Governance Model - Global View [39]](image)\n\nOn this conceptual model, policies and processes are divided in two stages:\n\n- **Design time governance**: this group involves service identification, definition, creation and reuse.\n- **Runtime governance**: this comprises management of the service life-cycle (i.e. deployment, consumption, versioning & change and retirement).\n\nIn this context, [39] defines the two key elements of the model as being policy and processes.\n\n**Governance policies**: specify rules that SOA parties must adhere to. These can differ in function of the type, purpose and scope of the rule (e.g. business and corporate policies, behavioural policies, process policies, technical policies, QoS policies, testing policies).\n**Governance processes:** identify actions that when executed contribute to achieve the goals of SOA governance.\n\nWith this in mind, [39] then approaches the autonomic computing domain and map the different types of governance policy to an autonomic property (Self-*). The attribute relevant to the current thesis is that of Self-configuration and its domain of application is defined according of the two stages aforementioned.\n\n- Design time Self-Configuration concerns governance policies scope updating.\n- Runtime Self-Configuration concerns enforcement of the governance policies.\n\nThis conceptual model does not specify any concrete pattern for the enforcement of the policies it introduces, nor identifies what the governance processes are. However, it gives information about the different stages the governance is active at and what are the main concerns for each of these phases.\n\n### 2.2.3. Service Delivery Framework\n\nTwenty first century (21C) Communication Service Providers (CSPs) are currently shifting their portfolios from traditional network-based to include more software-orientated products and services. The boundaries between networks, Information and Communication Technologies (ICT) and applications become very blurred allowing for the integration of all these capabilities into new wave services. Service Delivery Platforms (SDPs) [43] are the technology environments that facilitate this integration. More specifically, an SDP aims at enabling rapid development and deployment of new converged multimedia services. These services are composed of telecoms and IT capabilities. As illustrated in Figure 12, an SDP sits in the middle and bridges across to different sources of service capability. Examples of such capability include telephony, wireless, IP, content, Operational Support Systems (OSS) and 3rd party. Capabilities are exposed through standard functional interfaces. SDPs typically provide a service control environment, a service creation/assembly environment, a service orchestration and execution environment and abstractions for media control, presence/location, integration and other low-level communications capabilities. They are used for the composition of both consumer and business applications. In order to make SDPs carrier grade, i.e. sufficiently reliable and scalable for CSP adoption, it is current best practice to apply SOA principles to expose service capability, being network, OSS or 3rd party, through SOA adapters into a SOA based SDP [44]. The latter constitutes an IT platform, mostly an application server, using Web Service or other SOA technology standards to integrate services and compose applications.\nSDPs available today are optimized for the delivery of a service in a given technological or network domain (examples include web, IMS, IPTV, Mobile TV, etc.).\n\nThere is lack of standardization work for SDPs. This gave rise to the TM Forum’s Service Delivery Framework (SDF) programme [45]. In the context of SDF, services are defined as components that expose their functionality via one or more functional interfaces. A service becomes an SDF Service when it exposes one or more SDF Service Management Interfaces (SDF SMIs) which manage the service lifecycle. The SDF programme focuses on the management of SDF Services, where management is referred to SDF Service Lifecycle management.\n\nFigure 13, depicts a typical SDF service and the overall SDF Reference Model [46]. Functional capability of an SDF Service is exposed through service functional interfaces (SDF SFIs), which are graphically shown as “lollipops”. Special case of SFIs are the SDF SMIs, which contain lifecycle management capabilities of the SDF\nService. Such capabilities include, but are not limited to: configuration, performance management, retirement, fault handling, versioning, monitoring and usage.\n\nFinally, an SDF Service may itself rely on capabilities exposed by other services. This is called SDF Service consumer and is graphically denoted by a \"socket\". The rest of Figure 13 illustrates the SDF Reference Model comprising: SDF Management Support Services (SDF MSS): SDF MSS are responsible for the end-to-end SDF Service lifecycle management. This includes the support for operational (e.g. provisioning, installation, update/activation, monitoring capabilities) as well as business process automation. SDF MSS capabilities may either invoke SDF SMI capabilities, in which case they receive SDF Service management meta-data, or invoke other support services from the Infrastructure or the Management Services domains of Figure 13.\n\nInfrastructure and SDF Infrastructure Support Services (SDF ISS): the Infrastructure domain provides specific capabilities to Management processes or SDF MSS that are usable across all SDF Services and facilitate their lifecycle management.\n\nThese capabilities constitute the SDF ISSs. Examples of SDF ISSs include: SDF Service catalogues, metadata repositories, user data (specific information for subscribers or other actors), resource management capabilities and charging capabilities.\n\nResources: Resources are capabilities that can be used by SDF Services and are exposed by network, IT infrastructure, OSS/BSS applications, or services on the Internet. They can exist anywhere, within or outside the CSP’s domain, and offer their capability to SDF Services through their functional interfaces.\n\nIts issuance from existing implementations into a reference model and its concrete approach make the SDF an interesting model to draw knowledge from. The main components of the framework as well as their relationships and the way they interact with their managed resources are described in the context of service delivery. However the SDF does not take the contextualisation governance domain into account and key elements such as policies or element visibility are not thought off.\n\n2.2.4 Conclusions of reference models and architectures\n\nThe models and architectures for SOA, SOA governance and service delivery introduced above define, to a certain extent, the main architectural elements forming a SOA as well as the principal concepts related to governance. Indeed, these works define key concepts such as run and design times governance together with their roles. In addition the core concepts around service interaction (e.g. behaviour) are introduced and the main elements needed to manage the delivery of services are defined (e.g. management services). Table 2 summarises the key elements discussed in this section.\n\nTables 1-4 legend:\n\n/ No support\nL Light support\nX Fully supported\n\n32\n<table>\n<thead>\n<tr>\n<th></th>\n<th>(4) Definition of SOA governance and related concepts</th>\n<th>(5) High level description of key contextualisation elements and concepts</th>\n<th>(6) Technical description of key contextualisation elements and their relationships</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>OASIS Reference Model</td>\n<td>L</td>\n<td>L</td>\n<td>/</td>\n</tr>\n<tr>\n<td>OASIS Reference Architecture</td>\n<td>L</td>\n<td>/</td>\n<td>/</td>\n</tr>\n<tr>\n<td>TOG SOA Reference Architecture</td>\n<td>L</td>\n<td>L</td>\n<td>/</td>\n</tr>\n<tr>\n<td>TOG SOA Governance Framework</td>\n<td>X</td>\n<td>L</td>\n<td>/</td>\n</tr>\n<tr>\n<td>Autonomic computing based SOA governance model</td>\n<td>X</td>\n<td>L</td>\n<td>/</td>\n</tr>\n<tr>\n<td>SDF</td>\n<td>/</td>\n<td>L</td>\n<td>L</td>\n</tr>\n</tbody>\n</table>\n\nTable 2. Comparison of reference models and architecture for SOA.\n\nHowever, these references do not specify how to design the process of contextualisation and manage the visibility of the different elements required to enact it.\n\n### 2.3. Flexible contextualisation\n\nAn area of interest that has focused on certain aspects of this investigation and that has received interest from the research community is the management of NFPs as a way to improve the adaptability of a resource exposed over the network.\n\nUsing previous work on NFP description (c.f. section 2.2 Conclusions of related works) and how to allow a concrete separation between a resource’s functionality and its NFPs has been investigated.\n\nIn [47] a solution is proposed to manage a Web service NFPs using handlers. This work proposes a new model-driven development (MDD) framework, through the notion of feature modelling, to explicitly and graphically model a series of non-functional constraints in SOA. The framework consists of a:\n\n- **feature model**: that defines non-functional properties in SOA.\n- **NFP profile**: written using Unified Modeling Language (UML) to specify the NFPs, called UP-SNFR [48].\n\n- **Model-Driven Development tool (MDD)**: called Ark, which generates application code (program code and deployment descriptors) according to a configuration (or instance) of the proposed feature model and a UML model defined with UP-SNFRs.\n\n![Figure 14. An Architectural Overview of the MDD framework proposed in [47]](image)\n\nThe architecture proposed by the authors of the MDD framework is illustrated in Figure 14. By allowing developers to model NFP as features, the proposed framework allows logically constructing and validating NFPs in SOA. Ark automatically enforces NFPs in applications by transforming a feature configuration to application code with UP-SNFRs.\n\nThe separation of concerns between the different levels of abstractions in the domain model, the NFP as a feature description and the generation of application code allows decoupling the descriptions of the different types of NFPs possible from the specific handlers implementing them and the way they will be aggregated to support the exposure of the service.\n\nHowever by using a strategy that provides NFPs by the way of handlers the authors assume that the service providers take ownership of the NFPs implementations which limits their reuse and availability. In addition, this framework does not provide any support for the service life-cycle management which restricts the use of the service in one particular context. Finally, the use of NFP profiles could allow the use of different semantics and grammars, providing another level of flexibility, but current approaches have not investigated this possibility.\n\nIn [49], the authors present a Security Service Bus (SSB), an infrastructure that relies on a communication bus for providing flexible composition between application components and security components and mutually between security components. This SSB is evaluated against a scenario with a personal content management system platform that aims to offer its users a uniform interface for managing and sharing their personal content that is scattered over various devices.\nIn the SSB there are two types of component security and application bindings.\n\n**Security:** this type provides the security functionalities. It is assumed in this architecture that the security components are reusable modules that can be invoked, managed and composed with applications and with each other. The functionality is expressed through a security interface and the component can be configured through a management interface.\n\n**Application binding:** This type of component has two roles enforcing decisions and providing policy information.\n\nIn this architecture, the aggregation of components is made through an artefact named the security contract. This contract is expressed using the same data model as the one used to define component interfaces. It comprised two parts: the required and provided sections, defining what is expected from a contract and what is offered.\n\nThe SSB architecture describes a component based design that supports run time aggregation of security related functionalities. However, this work only takes into account security related functionalities, more complex exposure requirements that encompass more than security may require a different type of architecture. In addition, the SSB does not show how to support the life-cycle of the aggregation of added functionalities which is an important factor when dealing with independent, distributed components that could be, for instance, unavailable at times. Finally, the SSB does not describe how to support the management of components fulfilling the security contract. The author believes that such architecture should define at a more concrete level this type of mechanism rather than stating the existence of a management interface.\n\n### 2.3.1. Conclusions of flexible contextualisation\n\nThe works discussed in the previous section present interesting characteristics as well as limitations for the domain of flexible contextualisation. In this section, both advantages and limitations are presented together with their impacts on the current thesis.\n\nBoth MDD and SSB demonstrate that the hard coded handlers approach, which is currently the most widely spread approach [50], has strong limits in terms of\nflexibility and reusability. In a distributed environment where components could be reused many times, the impact changes on these components could have on their many clients could prove difficult to manage. Additionally, unless a strict control is put in place and a physical track of what handler is used on what service kept, keeping track of their usage in large scale systems seems effort consuming and further advocates against this practice. Moreover, managing the exposition of a same service in different contexts is difficult as the handlers are hard coded. Finally, hard coding the handlers into the service themselves can be costly time wise as a developer is required to understand how they work and how they can be assembled with the service they are expected to support the exposition of.\n\nThe MDD [47] approach deals with this limitation by dynamically aggregating handlers in a NFP profile through a model. This method presents the benefit of dividing the representation of the contextualisation strategy (i.e. NFP profile) from the complete domain definition (i.e. feature meta model) and from the run implementation of the strategy. This allows for more flexibility and reuse. However, the code enacting each NFP cannot be shared and allowed to evolve (e.g. reconfigured).\n\nThe SSB approach attempts to mitigate this limit by using distributed components that can be invoked and configured to fulfil the NFPs. For supporting the exposition of services in large scale distributed systems, this technique of using discoverable and configurable network enabled components looks more efficient in regards of early comments. Not only does it allow reuse and configuration for specific contexts but through the use of a common transport layer it permits to keep track of what components are used in what context. Furthermore, it authorizes the governance infrastructure to audit the message exchanges and evaluate how the components perform.\n\nYet these different techniques still present strong limitations. They necessitate an additional layer in order to allow using a resource in different contexts. In addition, they do not allow controlling the life-cycle of the NFP profile, which would bring further flexibility. Furthermore, they each use their own set of NFP description semantics which can be a limited approach when dealing with distributed resources that can be deployed in different organisations or countries.\n\n**Tables 1-4 legend:**\n\n/ No support \nL Light support \nX Fully supported\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>(7) NFP description model</th>\n<th>(8) NFP profile description</th>\n<th>(9) NFP profile instance</th>\n<th>(10) Reusable & manageable NFP providers</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>MDD Framework</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n<td></td>\n</tr>\n<tr>\n<td>----------------</td>\n<td>---</td>\n<td>---</td>\n<td>---</td>\n<td></td>\n</tr>\n<tr>\n<td>SSB</td>\n<td>L</td>\n<td>L</td>\n<td>/</td>\n<td>X</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>(11) Run time aggregation of NFPs</th>\n<th>(12) Domain agnostic</th>\n<th>(13) Life-cycle management of the aggregation of NFPs</th>\n<th>(14) Semantically described components</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>MDD Framework</td>\n<td>L</td>\n<td>X</td>\n<td>/</td>\n</tr>\n<tr>\n<td>SSB</td>\n<td>X</td>\n<td>/</td>\n<td>L</td>\n</tr>\n</tbody>\n</table>\n\nTable 3. Comparison of approaches investigating adaptability of contextualisation\n\n### 2.4. Safety of contextualisation\n\nThere is no work, as far as the author is aware, that targets the safety of contextualisation processes or middleware for distributed systems.\n\nHowever, the domains of contextualisation can be, in this context, divided into two parts, the validity of the contextualisation strategy (c.f. NFP profile in section 2.3) and the security of the message exchanges between the different components enacting this strategy and the infrastructure supporting these exchanges.\n\nIn the context of this work, the optimal solution to support a flexible contextualisation strategy is an aggregation of distributed and reusable components that can be managed. Indeed, section 2.3 demonstrates that this approach is optimal to provide adaptive contextualisation for SOA. In order to control the safety of this strategy it is therefore critical to control what components are selected and the manner they are aggregated. Dynamic selection and composition of distributed components, such as web services, is a complex research topic on its own and will not be discussed here. The reader can instead refer to key works in this domain such as [51] or [52]. It is however noticeable that dynamic composition of services aims at bringing flexibility about the services selected, as opposed to allowing defining and enacting a contextualisation strategy.\nSOA security will not be examined in this work as it is a complex research topic on its own.\n\nTables 1-4 legend:\n/ No support\nL Light support\nX Fully supported\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>(14) support for end to end message level security</th>\n<th>(15) verify validity of the contextualisation strategy</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SOA security</td>\n<td>X</td>\n<td>/</td>\n</tr>\n<tr>\n<td>Dynamic selection and composition</td>\n<td>/</td>\n<td>L</td>\n</tr>\n</tbody>\n</table>\n\nTable 4. Comparison of approaches investigating safety of contextualisation\n\nThe present work does not aim at making significant contributions in these two fields. It aims however at leveraging on them in this new context in order to provide an enhanced investigation.\n\n2.1. **SOA Governance**\n\nSOA governance has been much talked about over the past few years. Industry middleware actors (e.g. SOA middleware vendors, consultants) have been the biggest sources of both hype and innovation [10].\n\nThe term “SOA governance” has also sometimes been treated as a marketing term for the packaging of the set of features that allow managing and improving the visibility of distributed resources. Such issues are well understood and solutions have been researched and developed for the past 10 years. In fact, SOA governance frameworks build on top of such work by addressing the need to make the supporting service management and monitoring layer interoperable and introduce processes that allow governing multiple interrelated services and policies in SOA deployments as one whole.\n\nESB vendors, services deployment platforms and Service registry providers (e.g. HP, IBM) include what they define as governance tools in their products. These products such as HP Systinet with its Governance Interoperability Framework (GIF) [55] or IBM WebSphere Service Registry and Repository (WSRR) [56] are mainly providing service registry and metadata (e.g. policy) repository services along with their supporting features. Some of these products also provide some support for service versioning and policy as well as service management. These are valuable contributions towards a common SOA governance specification. However, these products only address the challenges of visibility and for some of them policy\nadministration and management which, although are central issues, do not provide solutions for the problem of service provisioning. Indeed, preparing SOA assets to be used by consumers in a flexible and efficient manner is a key aspect of SOA governance as it allows reducing integration expenses.\n\n2.2. Conclusions of background\n\nThe work surveyed in section 2, and the short history of integration techniques, can be viewed as the basis to provide resource exposition governance in a flexible and efficient manner. The surveyed work illustrates the need to design the architecture of the governance infrastructure as a distributed system where elements can be discovered, assembled and managed adequately. An aim of this work is to provide a concrete architecture that allows for safe and flexible governance of resource exposition in SOA as proposed in section 3.\n\nAnother area of interest that has focused on certain aspects of governance and that has received more interest from the research community is the description of Quality of Service (QoS) attributes, NFPs, services functionalities and architecture descriptions.\n\nSeveral projects have looked into different ways of defining and expressing NFPs, using either Architecture Description Language [57], taxonomy [58] or ontology [59]. Some of these projects do not target any precise type of IT systems [57], while a few specifically investigate the domain of SOA [58]. As underlined at several points (c.f. 2.2.2, 2.2.3) in the previous section on related works, being able to describe the different components of a dynamic system is a critical element. However the author feels that this topic has already reached the stage where efficient descriptions of architectures, services and their properties can be used. Additionally, as illustrated several times in the aforementioned works, knowledge can be delegated to a specific layer of an architecture.\n\nIn the next chapter, the research challenges for flexible and safe resource contextualisation in a SOA are summarised.\n\n2.2.1. Summary of research challenges\n\nLarge scale and dynamic service-oriented systems require a set of technologies and mechanisms to be deployed in order to be rendered more easily manageable and transparent through governance. A wide spectrum of complementary concerns needs to be taken into account when designing such a solution.\n\nThe following challenges have been defined using the scenario described in section 1.1 and the description of the related works listed in chapter 2.\n\n1. Reusability of integration layer. The different functionalities forming the governance infrastructure and Value Adding Services (VAS) that may be invoked should be adequately segregated so as to allow reuse.\n\n2. Shared communication semantics. Interoperability is a key element in middleware design.\n\n3. Decentralised model. The governance infrastructure should enable a flexible resource location mechanism where the choice of the resource depends on contextual information in addition to the network endpoint of the governed services. Additionally, the infrastructure should support resource virtualisation, policy segregation and execution state in multi-tenancy usage scenarios.\n4. Definition of SOA governance and related concepts. For the readers of the concrete architecture it is critical to explicitly make the goals understandable.\n\n5. High level description of key contextualisation elements and concepts. For the concrete architecture to be implemented, its different elements and their relationships must be made understandable.\n\n6. Technical description of key contextualisation elements and their relationships. For the concrete architecture to be implemented, the way its different elements can be designed and assembled must be defined.\n\n7. NFP description model. A model or sets of models allowing the different elements potentially entering in the resource exposition governance should be provided. Alternatively or in addition, this type of model should be extendable.\n\n8. NFP profile description. A resource provider should be allowed to express resource exposition requirements.\n\n9. NFP profile instance. A same profile description can be enacted using different middleware. This includes allowing the selection of infrastructure capabilities and the corresponding policy schemes.\n\n10. Reusable & manageable NFP providers. When relevant, the different elements composing a resource’s exposition and its supporting infrastructure should be proposed in such a manner that they can be configured for the specific interactions they required for. In addition, the use of reusable elements should be supported.\n\n11. Run time aggregation of NFPs. The composition of the different elements composing a resource’s exposition and its supporting infrastructure should be supported at run time.\n\n12. Domain agnostic. The exposition governance should not be specialised into a specific kind of exposition attribute. Additionally, it should not allow governing the exposition of only a specific type of resource.\n\n13. Life-cycle management of the aggregation of NFPs. The composition of reusable and manageable elements supporting the exposition of a resource should be made manageable as a process. As such, the governance infrastructure should allow for the management of its life-cycle.\n\n14. Semantically described components. The different elements entering in a exposition and its support should be adequately describe to allow for their automatic discovery and usage.\n\n15. Semantic agnostic. The infrastructure should enable translating its own internal understanding of what are the objectives for specific governance instances into a way that is comprehended by partners.\n\n16. Support for end to end message level security. The proposed architecture should ensure a safe exposition of the services. Potential clients or threats should not be able to bypass the governance capability put in place due to one of its capabilities failure (e.g. security, bad design).\n\n17. Verify validity of the contextualisation strategy. A resource provider should be allowed to express its needs in a clear manner that doesn’t leave any ambiguity as to how the governance should enact them. It should also support communicating\ngovernance requirements to trusted partners and ensure consistency persists between \nthe internal governance logic and what is advertised or agreed persists.\n\nAs shown in this section, there currently is no model, architecture or technology that \nfulfils the aforementioned sets of challenges. Instead, vendors have a tendency to \naggregate the different products they have developed over the years that supports the \nmanagement of distributed resources and academic works tend to investigate specific \nissues related to this topic. Finally the architectures and models proposed by open \ngroups of experts are too abstract and general to allow implementing such \nmiddleware.\n\nThese challenges, coupled with leveraging the technical advantages discussed in the \nprevious section on background, led to singling out a specific architecture which, \naccording to the author experience and previous work in this domain (c.f. section on \nsummary of contribution) sufficiently address the core need of exposition governance \nfor SOA.\n3. Anatomy of a SOA governance architecture\n\nIn Chapter 2, the author described relevant background and related works. Four main areas, evolution of middleware, models and architectures, flexible contextualisation and safety of contextualisation have allowed the identification of 17 research challenges.\n\n3.1. Introduction of the anatomy\n\nIn the following section, the concrete architecture for governance of safe and flexible contextualisation of resources for SOA governance is presented. Initially, the author defines the main concepts necessary to the good understanding of the anatomy’s description. Next, the data structures used in the concrete architecture are presented. Then, the components forming the architecture are described and categorised in either a core category or a management category. Finally, the processes that link these different data structures and components are shown.\n\nThis architecture is meant to be platform and language independent and no specific tools or frameworks will be discussed in this chapter.\n\nThe elements defined in this section are derived from the knowledge acquired through Chapter 2. Additionally, the implementation described in section 4.2 relies on the concepts, data structures, components and processes described in the current chapter.\n\n3.2. Anatomy concepts\n\nPrior to the descriptions of the concrete elements forming the architecture it is necessary to define several key concepts: capability, policies, processes, users, and governance times.\n\n3.2.1. Capability\n\n**Capability**: a capability is a functional unit in the governance context. Each capability is assumed to be capable of being deployed as a web service with its own service management, policy administration framework (control pane) and operational interfaces (data pane). Each capability is also policy driven as this permits configurability and flexibility. The different capabilities are meant to have their own distinct grammars and policy languages in order to keep their own advantages, capacities and evolution potential in their respective domains. For instance, the identity and access management can be separated and can use different grammars.\n\nThe interoperability issues generated by this situation are addressed at the messaging level, which is in itself a core capability, and through transformations that are possible thanks to transformation policies as shown in the transformation process step (section 3.5 point 7).\n\nThis also enables the interchange of core capabilities within their categories and according to the research challenges specified in section 2.2.4 when necessary. Non-core capabilities (e.g. auditing) can also be added through the same manner.\n\nAll capabilities are either a business or an infrastructure:\n\n**Business capability**: This is an organisation’s traditional function (e.g. accountancy, fleet management, credit check). It is exposed as a service and can be the result of an...\naggregation of other business capabilities. In the case of the virtual music store content providers are business capabilities.\n\n**Infrastructure capability:** This is a supporting capability fulfilling non-functional requirements such as identity management or access control. In an SOA, a set of infrastructures are typically aggregated to support the exposition of a business capability. Infrastructure capabilities can be segregated in two categories: core and non-core. Core infrastructures are functionalities that are vital to the governance architecture internal behaviour, these are described in section 3.4.1. The non-core infrastructures can include all type of non-functional property providers (e.g. billing, audit, transport protocol).\n\nSome capabilities may be treated as business in a context and infrastructure in another. For instance, an identity management service in the virtual music store use case is treated as an infrastructure as it provides a non functional property. However, the identity management service can make use of its own exposure governance in which context it is treated as a business capability.\n\nSection 3.4 on Components anatomy presents the components specific to exposure governance.\n\n### 3.2.2. Policies\n\nPolicies are documents describing behaviours that capabilities or processes must comply with. They typically comply with different specific standards (e.g. WS-Policy [63], XACML). The main issues about policy in the governance framework are their enforcement and the potential necessity to translate same policies into different grammars (e.g. an access control infrastructure could be using either XACML or SecPAL). In the following paragraphs, the main policy types of SOA governance are introduced.\n\n**Profile policies:** Profile policies identify and define policies or template that applies within their domains. The most important ones will regard the dependences and constraints related to the use of a profile.\n\n**Infrastructure capability policies:** These policies are attached to particular infrastructures and consider potential I/O metadata, usage and management schemes.\n\n**Business capability policies:** The business capabilities are similar to the infrastructure but for the possibility to assign exposure strategies to them.\n\nSection 3.3 on Data structures anatomy shows the data specific to exposure management.\n\n### 3.2.3. Processes\n\nA process is a procedure that uses the above building blocks in order to meet exposure governance objectives. A distinction can be made between governance as well as policy and service management processes. The management processes target policies (e.g. authoring, association, enforcement, reporting) and services (e.g. publication, exposure) and are outside of the scope of this investigation. The governance processes aim at coordinating management and exposure governance processes.\n\nSection 3.5 on Processes anatomy describes the processes specific to exposure governance.\n3.2.4. Users\n\nUser: the entity, physical or logical that uses a service. More concretely, in the current context, there are three types of user:\n\nBusiness or infrastructure capability administrator: these users should be allowed to define their requirements and/or to specify the context in which their resources should be exposed. They can also change the configuration of the profiles they want applied to their resources. An infrastructure administrator can also change the description of its resources or when relevant change the context (e.g. SLA, type of client) the infrastructure will be available for.\n\nFor instance, a music content provider, as a business capability is administered by a user. The same applies to an infrastructure capability such as an identity management service.\n\nGovernance administrator: much in the same way as the capability administrators, this user can modify the configuration or change the services that serve as core capabilities.\n\nAnother system: as specified in section 2.2.4 on research challenges, there is a need for automation of management tasks. Through the management interface, other systems such as another governance middleware or a management tool can extract, modify or deleted data (c.f. section 3.6 on Usage patterns). This type of access is managed in the same way as human user in regards to security.\n\n3.2.5. Governance times\n\nThis governance architecture targets two phases, the design and run times of the capabilities which contextualisation it is meant to govern.\n\nDesign time governance: at design time, users are allowed to define their choices in terms of exposition behaviour. This phase is illustrated in Figure 16 where a user configures part of the governance to suits its needs.\n\nRun time governance: At run time, the governance enacts the requirements specified at design time and allows for the conversations between the business capabilities, and its clients to take place. This is achieved by brokering the messages forming these interactions and by aggregating infrastructure capabilities which provide the NFPs. This stage is shown on Figure 17 where the governance middleware links the business capability to a client and call infrastructure capabilities to supply the NFPs for the interaction. In this case, the infrastructures are sitting somewhere in the Cloud [66], but different options for their deployments are proposed in section 3.6.1.\nThe separation between these two stages is not always as clear as it appears in Figure 16 and Figure 17. Indeed, the need to re-configure the properties or the quality of the enactment of an interaction can arise during run time and requires the governance to at least partially fall back to the design time phase. Additionally, the registration of new infrastructure capabilities can happen at any moment, so do the potential changes in their configurations or in the content of any policy they make use of.\n\n### 3.3. Data structures anatomy\n\nFollowing is the list of the core data elements that take part in the governance model and their properties.\n\n#### 3.3.1. Infrastructure profile\n\nInfrastructure profiles are descriptors that define which aggregation of infrastructure capabilities (e.g. security services, audit) to use for the exposition of a business capability along with the different constraints associated with the use of these capabilities. Each profile associates infrastructures with their corresponding policy schemes, dependences (policy and service) and management processes.\n\nIn order to achieve this, the NFP requirements of the resource exposed are expressed in a normalised manner in a profile document which is used to define the way the resource is exposed. Figure 18 illustrates the schema that formally defines the data structure of the profile description. The XML schema can be found in appendix 1 and an instance of a profile can be found in section 4.2.4. In the following paragraphs the different elements forming the profile data structure are defined. Element names are\nA **WS-Profile** is the top element of the description, it is uniquely identified by a number. Concretely, a profile could be used to \"expose a music content provider service\" in the context of the virtual music store.\n\nThe profile is composed of one-to-many **Service Types** that provide the top level of abstraction from a capability functionality and categorisation point of view. An examples of service types are \"identity management\" and \"access control management\".\n\nEach service types can provide different **Interfaces** that allow to further decompose the logical structure of the profile. Examples of interfaces are \"management\" and \"operational\".\nThe next level of decomposition is the **Functionality** which allow to differentiate practical aspects of the same interface. Examples of functionalities are \"user management\" and \"token management\".\n\nFinally, the **Operations** permit to describe concrete pieces of distributed software in the most granular manner. Examples of operations are \"add user\" and \"delete token\".\n\nIt is noticeable that the structure defined above matches closely the structure of WSDL [33]. This reflects the SOA nature of the architecture proposed while allowing users to define their needs in terms of NFPs as well as the governance system to locate and classify capabilities.\n\nAll **Service Type**, **Interface**, **Functionality** and **Operation** elements listed above inherit from a common element **Activity**. Activities allows to specify **Constraints** to these elements. A constraint permits to define the data flow between the different elements of the profile. For instance, before using an \"validate token\" operation, the operation \"build trust\" is required to be used. In the same manner, data types requirements can be specified. A certain \"XACML access control policy template\" can be attached to specific \"evaluate assertion\" operation.\n\nThis granular approach aims to allow the definition of different levels of abstraction when writing the profile. For instance, a music content provider administrator may not be knowledgeable in security but trusts the governance provider to be. In this case the first could specify in its profile a simple \"service type\" \"security\". The governance through the taxonomy describing the infrastructure capabilities would then be able to refine \"security\" into \"identity management\" and \"access control\" and subsequently build a concrete exposition profile. Similarly, a music content provider administrator user requesting a profile could specify two \"service types\" \"access control\" and \"identity management\" and leave the selection of the appropriate specific and more technical choices to the instance of the governance architecture that is governing its exposure. On the other hand a knowledgeable business capability administrator could go as far as specifying the anatomy of \"access control\" infrastructure capabilities it wants with specific \"security policy grammar\" and \"policy templates\".\n\nThe author is aware that methods for dynamic service selection based on taxonomy or ontology exist. These methods can allow functionality based selection as well Quality of Service (QoS) and Service Level Agreement (SLA). However it is not the objective of the current work to investigate this topic. The proposed approach is to provide answers to the challenges of dynamic selection of infrastructure capability and their aggregation.\n\n**Management plan:** The management plan is a specific type of WS-Profile and is provided by infrastructure capability providers and compiles the necessary steps necessary to achieve in order to include provided activities. For instance, a \"XACML policy decision point access control\" infrastructure capability provider can specify that before using the \"evaluate access request\" \"operation\" the \"operation\" \"build trust\" needs to be successful.\n\n**Coordination plan:** The coordination plan is another type of WS-Profile that is progressively assembled and completed with the business capability exposition profile. The coordination plan is an ordered list of management plans that need to be taken into account in order to activate an instance of the profile. Additional coordination plans can be provided for the different stages in a profile life-cycle: deactivate, reactivate and remove.\nIn Figure 19, the different entities forming the profile and their relationships are shown.\n\n3.3.2. Context\n\nContexts are documents that allow the specification of a) a domain of contextualisation and b) what is the data specific to this domain. Another document, called a context selector, allows c) associating profiles and contexts.\n\nFigure 20 illustrates the schema that formally defines the data structure of the context description. The XML schema can be found in appendix 2 and an instance of a context can be found in section 4.2.4.\n\nContext specific data: The context specific data is a combination of data passed to the profile instantiation by the business capability and data created by infrastructure capabilities passed to others through the governance model in order to configure them. For instance, when requesting security in the exposition profile, a music content provider can pass its own “credentials” in order to complete the context. In the XML context definition, this part is defined by the configData element, the target being the activity in the profile the data applies to.\n3.3.1. Context selector\n\nAssociation of profiles and contexts: This document allows to link different contexts to the profiles their associated with.\n\nDomain of contextualisation: The domain of contextualisation allows the governance architecture to recognise what a context applies to. The interception domain is a combination of a potentially shared scope and state. This allows linking a profile to business capabilities or message exchanges. This part of the context is typically formed by a “transaction ID”, a “federation ID” as introduced in [53], a WS-Addressing [62] “message ID” or even an operation type the profile instance is required for (e.g. “request” or “response”). In the XML context definition, this part is defined by the configSelector, the target being the identifier of the document containing the selection logic, the data being the potential representation of the selection logic (i.e. if it is a simple XPath in the implementation proposed) and the operation being request, response or both.\n\nUp time: This element allows specifying the availability of the exposition. For better performance, the profile and exposition logic can be requested to be maintained “all the time”. Alternatively, the exposition logic can be maintained “only when relevant” or at “precise dates and times”. In the XML context definition, this part is defined by the upTime, the type allowing to define periods the profile will be maintained for.\n\nFigure 21 illustrates the schema that formally defines the data structure of the context selector description. The XML schema can be found in appendix 3 and an instance of a context selector can be found in section 4.2.4.\n3.3.2. Summary of the data structure descriptions\n\nEach exposure, with its data flows, dependencies, policies and management processes is defined through the three data structures defined above: profile, context and context selector. These elements, together with the capabilities they are attached to along with their relationships are recapitulated in Figure 22.\n\nFigure 21 illustrates that a profile instance is formed by the combination of a profile and contextual data. This contextual data is divided into two categories: profile and capability oriented.\n3.4. **Components anatomy**\n\nIn the following chapters, the capabilities forming the governance middleware are described. In a first time, the core and non specific infrastructures are listed and their purposes in the current context explained. Subsequently, the key infrastructures that are the profile management capabilities are described in more detail.\n\n**3.4.1. Core infrastructure capabilities**\n\nThe core capabilities are the working base of the model as they each provide specific functionalities that are necessary to the execution of either all or part of the governance.\n\nFollowing is the list of the governance model core infrastructures and their basic properties. It is noticeable that all these capabilities, are not specific to the governance anatomy. Therefore, describing them in details is out of the scope of this current investigation.\n\n*User interface:* the user interface is a set of capabilities that allow users (e.g. administrator, other system) to access parts or all functionalities of the governance middleware.\n\n*Access control:* An access control infrastructure is used in order to check authorization. It generally consists of a specialised service that checks security assertions against access control requests. This is typically achieved through the use of access control policies and security assertions written in specialised grammar such as XACML [60] or SecPAL [61].\n\nThe role of the access control capability in the governance anatomy is to ensure end to end control of the massages’ content access.\n\n*Identity management:* The role of the identity broker is to allow users to identify themselves. Authentication of the entity that acts as user is indeed a key aspect of SOA where different domains (e.g. companies, branches) will interoperate. This is generally accomplished by using security tokens. Depending on their anatomies,\nsecurity infrastructure capabilities can provide both access control and identity management.\n\nThe role of the identity management infrastructure is to ensure that the different capabilities and users are indeed who they claim to be.\n\n**Message interceptor:** The message broker, often called the mediator, acts as an intermediary between two points. It can receive messages from multiple destinations, determine the correct destination and route the message to appropriate channels.\n\nThe role of the message broker is to allow the exposure governance infrastructure to be seamlessly placed between the business capability and its client. Additionally, the message broker allows the deployment of context based routing in order to assign the relevant profile to a specific context.\n\n**Event notification engine:** This capability allows infrastructures to send notifications about a change in their states. For instance if a policy is changed, all capabilities that depend from it will be informed.\n\nThe role of the event notification capability is to allow different infrastructures to learn about a change of state and update their own behaviour accordingly.\n\n**Metadata repository:** Often referred to as a policy store or simply a repository, the role of this infrastructure is to allow storing metadata such as policies, taxonomies or ontology. Together with the service registry, this is the most commonly found element in existing governance solution.\n\n**Policy management:** The policy management is a set of capabilities that allow manipulating policies (e.g. apply metrics, detect and resolve conflicts). The author assumes that policy management capabilities are provided and their specific characteristics are left opened. Policy management is a complex topic in itself that is investigated in both academia and industry. Throughout this document, as stated in section 3.2.2, policies are meant as statements that define and constraint some aspect of a capability’s behaviour.\n\n**Service registry:** The service registry is a repository where Web services are listed. On production of their credential, users and systems can then discover the services which are potentially organised in different categories.\n\n**Service management:** Service management comprises a set of capabilities that allow manipulating (e.g. configure, instantiate) services and when relevant their instances.\n\n### 3.4.2. Profile management infrastructure capabilities\n\nThe management model supports the interactions between the different elements of the infrastructure. The main elements of this layer are the user interface, the profile management, policy management and the service management services. In this section, the author will describe the profile management and define its links with the user interface, policy and service management capabilities.\n\n**Profile management:** Profile management represents the key element of this research. It aims at allowing the administration of profiles life-cycles and connects to the other services in order to so. This is done to guarantee that profiles are defined, enabled, monitored and disabled when relevant in agreement to user’s needs and infrastructures requirements.\nFigure 23 presents a top level view of the profile management infrastructure together with the user interface, management infrastructures, registry and repository along with their relationships. On this figure, it can be observed that through the user interface a user can define a profile and specify a context. This data is then sent to the profile management that stores it in the metadata repository. When relevant, the policy management infrastructure performs tasks related to policies such as indicating and fixing inconsistencies. The profile management is also connected to the service management, which enables tasks related to capability selection and usage. The service management is connected to the service registry which stores capability specific data including the location of the infrastructure capabilities.\n\nIn the following paragraphs the components related to profile management are described in more detail.\n\n**Profile initiator:** The first step of the profile management is to translate the external request, received from the user interface, into the grammar used internally by the components described in section 3.3. This flexibility in terms of language is meant to bring an increase level of adaptability towards specific domains or types of users.\n\nIn order to allow for different grammars to be used, this component is based on the abstract factory pattern [67]. The factory proposes a set of different functions that are implemented by the instances and profile specific implementation for each case. Using services allows improving the flexibility of the system by permitting physical distribution as well as reuse of existing software.\nThe expected core functions of the profile initiator capability are illustrated in Figure 24.\n\n\n\nAll the functions on this component (Create, Read, Update, Delete profile, context and context selector) allow external users (e.g. human administrator, other governance system) to interact with the documents holding the governance data.\n\nFigure 25 illustrates how the factory pattern can be used in order to provide support for natural language processing, an abstract profile grammar and a profile name or id selection query system.\n\n\n\n**Profile composition**: The profile composition engine selects the infrastructure capabilities according to the requirement given by the initiator. The component works recursively to deal with dependencies. At different stages of the infrastructure profile life cycle, this engine will select infrastructures at different levels of abstraction, more abstract (e.g. category in the taxonomy) at the beginning and more concrete (e.g. Web service) towards the enactment stage.\n\nThe core functions of the profile composition capability are illustrated in Figure 26.\n\n\nThe *compose abstract profile* function permits the definition of a complete and safe profile at the abstract level (e.g. without the concrete services). This process is further described in 3.5.1, 3.5.2 and 3.5.3.\n\nThe *compose concrete profile* function serves the same purpose as its abstract counterpart but with the selection of concrete services that enact the infrastructure capabilities required. This process is further described in 3.5.4 and 3.5.5. Given the sequential nature of the profile composition process it is possible that an abstract profile cannot be composed into a concrete one. This may occur when no service implementation is available to enact a service type described in the abstract process. In this case, mediation over the nature of the abstract process and whether it can be modified has to take place between the Business Capability owner and the Contextualisation Governance provider.\n\nThe *verify profile* function allows to go through the elements (e.g. dependencies, usage policy) forming the profile in order to insure the completeness and safety of execution.\n\nFinally, *bind profile* is the function that connects the profile to the business capability whose exposure it manages.\n\n**Profile composition management:** When the composition engine has deemed a profile to be complete, with no gap in the data flow, this one is sent to the profile composition management. Upon reception, this one starts creating the profile coordination plan to be able to manage the different infrastructures together.\n\nThe core functions of the profile composition capability are illustrated in Figure 27.\n\n```\n«interface»\nProfile composition management\n+composeAbstractCoordinationPlan(in profile_reference, out coordination_plan_reference)\n+composeConcreteCoordinationPlan(in profile_reference, out coordination_plan_reference)\n```\n\nFigure 27. Profile composition management interface description\n\nThe *compose abstract coordination plan* builds the coordination plan at the abstract level.\n\n*Compose concrete coordination* is its counterpart at the concrete level.\n\n**Profile life-cycle management:** The life-cycle management supervises the profile life-cycle. It contacts the composition engine management when it's been informed that a profile is ready to be instantiated (by the management counterpart) and according to the up time agreement, requires the composition management to start the instantiation according to the coordination process built by the profile composition management. Additionally, the life-cycle management can request update(s) from the composition engine when necessary (e.g. service not adequate anymore, etc).\n\nThe core functions of the profile composition capability are illustrated in Figure 28.\n\n```\n«interface»\nProfile life-cycle management\n+activateProfile(in profile_reference, out acknowledgement)\n+deactivateProfile(in profile_reference, out acknowledgement)\n+enactProfile(in profile_reference, out deployed_profile_reference)\n```\n\nFigure 28. Profile life-cycle management interface description\nActivate profile allows to start and register the status of an exposition logic, deactivate profile enforces the opposite. Both of these functions should assume that the profile is ready to be used and expose the business capability when called.\n\nThe enact profile function is called in order to finalise the instantiation and exposed the profile enhanced business capability.\n\nProfile selector: When relevant, the profile selector chooses the relevant profile using a set of given parameters. Typically, the parameter is the context, however different cases can arise when the profile selector can request the life-cycle management to verify the profile and react accordingly. This separation of concern between the profile selector and the life cycle management and the fact that the profile selector advises its life-cycle counterpart, allows for different selection mechanisms that can specialised according to data and environment.\n\nFor instance, when an event specifying that an used policy has been changed in an infrastructure capability is triggered, the selector can then decide what profile it should ask the life-cycle management to review first. This selection could be based on how much resource (e.g. network, number of infrastructures involved) the different active profiles use, for performance reason, or what is the SLA with the different users involved.\n\nThe core functions of the profile composition capability are illustrated in Figure 29.\n\n\n\nFigure 29. Profile selector interface description\n\nBoth select profile function of the profile selector infrastructure allow deciding on what particular profile is relevant. In the top example, the context is used to make the selection.\n\n3.4.2.1. Service management requirements\n\nService management infrastructures are less commonly encountered pieces of infrastructure than their policy management counterparts. In this regard, the author felt it necessary to define the key requirements and expectations from the exposition governance point of view.\n\nAs underlined in section 3.2.1 in the definition of the concepts, capabilities are expected to be manageable when relevant (i.e. when it is sensible for configuration, performance or security reason).\n\nThe capability management component should be comprised of a) a capability instance factory, b) a capability selector factory and c) a capability management factory. These three elements respect the abstract software factory pattern in order to allow for a more flexible support of additional types of capabilities.\n\nThe management and instance factory elements are used to configure (e.g. setup with context aware policy) and/or replicate a capability (e.g. copy service onto another server). The latter is particularly useful for infrastructure capabilities that may have to deal with heavy workloads (e.g. included in many or demanding profile instances) or different requirements (e.g. a Service Level Agreement could necessitate high\navailability). The management interface takes advantage of a management layer of a service, typically implemented using WS-DM [68], in order to configure the said service. This is also useful for infrastructures such as security service which require some sort of interaction and configuration before they can be used.\n\nThe selection factory allows selecting capabilities according to specific characteristics and grammars.\n\nIn Figure 30, the three functions previously introduced are illustrated along two examples of factories for each. The capability instance factory is implemented in two different manners, one making use of the Apache Muse [69] software, the other one indicating that capabilities provided through it cannot be instantiated. The capability selector instances drawn suggest that a QoS based and a user experience based selections are available. Finally, the manager factory illustrates the choices between a WS-DM and custom based remote capability management.\n\nFigure 30. Service management overview\n3.4.3. Summary of the components descriptions\n\nProfile management is divided into two main logical domains, the profile consistency management and the profile life-cycle management.\n\nThese domains can be respectively split in several steps: defining the infrastructure capabilities, the policy templates, the service dependencies and the information flow for the first one and defining the profile management process as well as publishing the infrastructure profile for the second.\n\nThe first aim of the profile management is to manage the life-cycle of the profiles. This consists in allowing the profile to be defined, instantiated, maintained accessible, updated and deleted.\n\nIn addition to the profile instance’s life-cycle management, an important task that is attributed to the profile manager is to handle the adaptability of the profile instance. This feature is needed to allow for an efficient interchange between the infrastructures used.\n\nAdditionally, together with the policy management infrastructure, the role of the profile management is to determinate the best possible way to achieve the profile in the context requested. The decision making process is based on the requirements given by the user, the capabilities held by the system along with their associated constraints and the information contained in the context. The degree of automation of this activity is directly related to the quality of the data held in the other core elements as introduced before.\n\nThe principal components of the profile management are illustrated in Figure 31. Please refer to Figure 23 to see the external connections. On this figure, the main expected functionalities of the service and policy management are illustrated.\nThis distribution of roles and the potential hierarchical anatomy of the model is meant to reflect the unreliable nature of distributed systems where components, here infrastructure capabilities, are provided by third parties and may not be always available or present in the same state.\n\nIn this section, the author described the infrastructure capabilities forming the exposure governance architecture. The roles of these infrastructures and their communication interfaces have been defined. In the next section, the governance processes that allow the infrastructures to work together are explained.\n\n### 3.5. Processes anatomy\n\nIn the previous section, the author described the infrastructure capabilities forming the exposure governance architecture. In this section, the governance processes that allow the infrastructures to work together are explained.\n\nThe steps that lead to the creation of a safe and sound infrastructure profile are listed in the following paragraphs along with the components they involve. Concrete examples illustrating all the steps are shown in chapter 4 on implementation.\n\n#### 3.5.1. Define infrastructure capability\n\nThe first phase of the life-cycle is to gather all the information available about each infrastructure type listed in the profile formed by the profile initiator.\n\nThis task is enacted by the profile composition infrastructure capability and only targets infrastructures that are explicitly mentioned in the profile description document.\n\nThis phase is typically activated by the profile life-cycle management infrastructure upon reception of a request from the profile selector. In the case where the availability of the profile is specified to be permanent, the profile life-cycle manager is sent a request for profile activation upon the submission of a profile and of its associated context and context selector by the profile initiator.\n\nThis phase is divided in four steps as follows (steps illustrated in Figure 32):\n\n1. **Define service description**: in the taxonomy used to categorise infrastructures, this corresponds to the type. The operation is repeated for each capability in the profile.\n\n2. **Define capability policy scheme**: this information is held in the constraints of the infrastructure type.\n\n3. **Define capability usage policy**: this information is held in the constraints for the data flow part.\n\n4. **Define capability management process**: this information is held in the management plan.\nProfile life-cycle management: activateProfile\n\nProfile composition: composeAbstractProfile\n\nService management: getServiceData\n\ncompose profile\n\nreturns valid service description\n\ndefine capability policy scheme\n\nreturns valid capability policy scheme\n\ndefine capability usage policy\n\nreturns valid capability usage policy\n\ndefine capability management process\n\nreturns valid capability management process\n\nreturns composed profile reference\n\nFigure 32. UML sequence diagram of the define infrastructure capability governance process\n\nAll this data is supplied within the profile description taxonomy depicted in section 3.3.1. This taxonomy is strictly based on the requirements of this research. The author takes into account that more advanced description techniques such as ontology based ones could be used. However complex the description is, these four basic steps remain and would be subdivided in more technology specific ones.\n\nIt is assumed that the infrastructure providers have registered their infrastructures correctly.\n\n3.5.2. Define policy templates\n\nThe second phase aims at getting more information about each infrastructure’s type policy templates and how to manage them. Amongst this information, the meta-data transformations specify how to translate data from different grammars and policy types into this particular type.\n\nThis step is also performed by the policy composition capability when composing a profile (stages illustrated in Figure 33).\n\n5. Select capability: the operation is repeated for each capability in the profile.\n6. **Define policy template**: the policy templates are held as constraints in the capability descriptions when relevant.\n\n7. **Define domain of meta-data transformations (i/o meta-data)**: this step looks into the data flow of this activity in the profile description and define if a transformation is required.\n\n8. **Define policy management processes**: when a transformation is required, the profile composition looks for such transformation in the infrastructure repository. This is achieved by looking at the data flows and usage of the infrastructures registered as translators. Upon selection of the appropriate translation infrastructure, this one is inserted accordingly in the profile.\n\n\n\nFigure 33. UML sequence diagram of the define policy templates governance process\n\nIn a similar manner as in the previous stage on infrastructure type definition, this data is provided by the profile taxonomy when infrastructures are registered. Based on the level of complexity of the semantics used in an implementation, transformation strategies could be generated by the policy management capability. However, this level of automation is both potentially complex and resource demanding and the\nauthor assumes that it is more realistic for the translations to be provided as infrastructure capabilities.\n\n3.5.3. Define infrastructure capability dependencies\n\nOnce all the infrastructure types provided in the profile request have been defined and their policies identified, the profile composition engine verifies if the profile is safe and complete. In order to achieve this, this capability works recursively and identifies potential gaps in the data flows and infrastructure usages. The capability management process and usage policy are parsed and check for consistency against the other infrastructure capabilities present in the profile at this stage. For instance, if an access control capability type is present at this stage, depending on its anatomy, it may require an external identity management infrastructure. In this case, this relationship would be present in the usage or management policies of the specific access control capability category. The stages forming this step are illustrated in Figure 34.\n\n9. Select infrastructure capabilities: the operation is repeated for each capability in the profile.\n\n10. Define operation bindings: at this stage, the data flow is checked, the data should pass from a capability’s operation into another operation without any gap. If a gap is detected, the missing operation is looked after and the profile composition capability goes through steps 3.5.1 and 3.5.2.\n\n11. Define capability invocation pattern: for each operation registered in the profile, when relevant, an invocation pattern is available and defines what potential other operation would need to be invoked before it. This type of data is stored as a constraint when the infrastructure is registered and defines it behaviour. If a dependency is detected, it is looked after and the profile composition capability goes through steps 3.5.1 and 3.5.2.\n\n12. Validate capability dependencies: for each step in the profile this stage checks if both steps 10 and 11 defined above are fulfilled.\nFollowing step twelve, the profile is stored and deemed safe and complete at an abstract level by the governance.\n\n3.5.4. Define information flow\n\nAt this stage specific services enacting the infrastructure capability categories listed in the profile are selected. Additionally, the manner in which these services are aggregated and the transformations needed in order for the relevant data to pass from one to another are confirmed and validated.\n\n13. Select infrastructure capabilities: the concrete service implementing the infrastructure required in the profile is sought.\n\n14. Define policy meta-data transformations: the meta-data transformation specific to the service are resolved in the same manner as defined in section 3.5.2. It is noticeable here that according to how the semantics describing the\nprofile and the potential infrastructure forming it are defined, this stage could be useless.\n\n15. **Validate policy dependencies**: in the same manner as the previous stage for meta-data transformation, this stage looks into dependency validation specific to the service as 3.5.3 at the infrastructure category level.\n\nBy step fifteen, the profile is a set of defined and ordered infrastructure capabilities along with their specific management plans.\n\n### 3.5.5. Define profile management processes\n\nWith a complete list of what services will allow enacting the profile, the profile composition management capability attempts to order the management processes and define an implementation strategy, named coordination process, which orders the operations needed in order to create the profile instance.\n\n16. **Select service management processes**: for each service, the profile composition management infrastructure gather the management plan.\n\n17. **Select policy management processes**: in a system where policies are managed through defined and enforceable management processes, the later are also obtained.\n\n18. **Define coordination process**: the different services management plans are correlated and duplicates when they exist are removed.\n\n19. **Bind management processes & coordination process**: the coordination plan document is assembled.\n\n20. **Validate dependencies**: finally, the coordination plan is checked for completeness.\n\nUpon completion of the coordination process, the different management processes are attached to it at their relevant positions. Following this, the profile instance is sent back to the composition engine for validation.\n\nStep twenty signifies that the profile is complete at the concrete level; it contains information related to what services will be used, how to configure them and how to pass data from one operation to the next. In this state, it only lacks contextual data to render it operational as required.\n\nThese steps are summarised in Figure 35, where the transformation of profile into profile instance with specific services fulfilling the infrastructure capabilities can be visualised.\nOnce a profile is complete at the concrete level, the next stage is the instantiation. Finally, the business capability can be enhanced with the instantiated profile and exposed. This separation of logic insures that a profile can be reused with different services. Additionally, the enhanced service is only used in the particular context that is relevant to its specific users.\n\nOnce a profile has been validated (c.f. steps from one to twenty), it can be used in order to allow the exposition of a business capability. The following steps define this process.\n\n### 3.5.6. Select infrastructure profile instance\n\nThe first stage of the business capability exposure sees the profile selector component choosing the relevant profile instance. The selector then contacts the profile life-cycle management, which upon receiving the request of business capability exposure, requires the profile composition engine to define how the capability and profile instance work together. The stages forming this step are illustrated in Figure 36.\n\n1. **Discover infrastructure profiles**: this step makes use of the context and context selector to find the relevant profile(s) associated with the targeted exposure.\n\n2. **Select infrastructure profile(s)**: the relevant profile is selected.\n\n3. **Define bindings to business capability**: the goal of this step is to define how the business capability will be linked to the instantiated profile. Concretely, the data flow between the business capability and the profile needs to be completed.\n4. **Validate service dependencies**: The previous step that looked into how to operationally link the business capability to the profile may have necessitate the inclusion of an additional set of capabilities. This step insures that this new addition is safely made.\n\n\n\nDue to the relatively unreliable nature of such a large scale distributed system where different entities provide components it is necessary to insure that the profile is still complete and can still be instantiated.\n\n### 3.5.7. Define service-specific policies\n\nSteps five to seven allow the profile composition engine to refine the different policies with the business capability data when relevant. This is the first step towards the contextualisation of the profile.\n\n5. **Select infrastructure capability**: This step is repeated for each infrastructure in the profile.\n\n6. **Refine policy template**: Existing templates are instantiated with contextual data found in the context document.\n\n7. **Update service policies**: The previously filled template is then pushed to the service through its management interface when relevant.\n\n### 3.5.8. Define information flow\n\nThe same actions are then taken with the transformation strategies in the next three steps. This is made to insure that the transformations are adequate and match the filled templates.\n8. **Select infrastructure capabilities:** This step is repeated for each infrastructure in the profile. For performance reason, an implementation could here decide to only take capabilities where translations are required into account.\n\n9. **Refine policy meta-data transformations:** The existing transformation template is here refined with context specific transformation logic.\n\n10. **Validate policy dependencies:** Once again, the profile is checked for completeness and safety. For performance reason, an implementation can decide to either skip this step or target the specific infrastructures that the previous step 9 looked into.\n\n### 3.5.9. Define service exposure management processes\n\nThis phase defines how the profile enhanced business capability is going to be exposed. The goal is to identify the chronological list of actions that need to take place in order for the service exposure to take place in a safe manner.\n\n11. **Select profile management processes:** All the management processes are here selected again.\n\n12. **Select business capability management processes:** the same is done for the management processes relevant to the business capability.\n\n13. **Define coordination process:** The coordination is validated and completed when a gap in the data flow is found.\n\n14. **Bind management processes & coordination process:** At this stage, the business capability management processes are included in the profile coordination.\n\n15. **Validate dependencies:** The latest stage may have introduced new infrastructures or translations, the dependencies are therefore validated along with the overall data flow of the exposition logic management process.\n\n### 3.5.10. Publish service instance\n\nFinally, the coordination plan is executed, the different infrastructure configured and their bindings is done. Additionally, policy stores are updated and the business capability, now enhanced with the appropriate NFPs, is published.\n\n16. **Update capability policy stores:** The goal of this stage is to update policy stores with contextualised versions of the templates when relevant.\n\n17. **Update infrastructure bindings:** During this phase, the specific bindings for each service enacting an infrastructure capability is defined and updated.\n\n18. **Expose profile enhanced business capability to service endpoint:** The instantiated profile and the business capability are exposed as a service.\n\n19. **Publish service:** Finally, the enhanced business capability exposed though the instantiated profile is advertised as relevant and awaiting traffic.\n\nThe process of refining the policies with the contextual data and the exposition of the governed business capability are illustrated end the profile management. These steps that allow contextualising the profile and publishing the enhanced business capability are summarised in Figure 37.\n3.5.11. **Summary of processes anatomy**\n\nThe four main stages of the governance life-cycle are illustrated in Figure 38. In stage one, the profile is prepared and made ready to use in a specific context. At stage two, the business capability and exposition context requirements and conditions are inspected and prepared. Later on, at stage three the profile is refined and adapted to a specific exposition context. Finally, the instantiated profile and business capability are bound together and exposed to users.\n\nThe proposed approach divides the governance process in logical steps which are enacted by specialised components. This permits increasing the flexibility and reusability of the exposition logic as well as supporting the high level of distribution of the infrastructure as a service paradigm.\n3.6. Usage patterns\n\nIn this section, the different situations the architecture described in the previous sections can be used in are presented. Segregation is made between the deployment options for the deployment of the infrastructures forming the governance middleware and the usage of the governance itself.\n\n3.6.1. Infrastructure capabilities deployment patterns\n\nThe core capabilities deployment patterns define how these capabilities are physically deployed. This impacts the governance middleware in terms of performance, ease of maintenance and accessibility for the capability providers.\n\n**Distributed pattern:** In this pattern, the infrastructures are distributed over the network. This pattern is used in the Virtual music store scenario presented in section 4.2.1.\n\n**Hub and spoke pattern:** In order to reduce potential network latency or insure that the physical location of the governance middleware is suitable for the workload it is meant to handle, it is possible to deploy the core infrastructures at the same location.\n\n**Standalone pattern:** The stand alone pattern encompasses that all infrastructures potentially used in the governance are at the same location. This pattern can be required when the context requires that the traffic network be minimal.\n\nThese patterns can be applied in an assorted manner. For instance, an environment where the security related infrastructures are going to know of be very demanding could take advantage of having only these specific capabilities deployed in a standalone or hub and spoke pattern, with the rest of the infrastructures distributed over the network.\n\n3.6.2. Governance middleware deployment patterns\n\nGovernance patterns identify who has ownership of the governance middleware configuration, the responsibility to monitor events and transaction characteristics and\ntherefore who defines and authorizes changes to the existing middleware. In addition, this defines who decides when and in what conditions new infrastructure services can be added.\n\nThe patterns described in the following paragraphs are derived from studying how other pieces of middleware such as brokers, message queues or Enterprise Service Buses (ESBs) are deployed and used.\n\nApproaches to governance middleware deployment patterns range from internal to federated:\n\n**Internal governance**: All the interactions requiring governance may lie wholly within the organisation’s perimeter and not be accessible from outside of it. For example, a single entity may span over several sites or country where each area uses different software with different transport protocols or interface styles.\n\n\n\n**Perimeter governance**: All business capabilities lying within one organisation are made accessible to other organisations through the governance middleware. This situation may arise when an organisation wants to leverage on the governance middleware to expose its business capabilities to potential partners in a more flexible manner than internally. This pattern is the one used in the Virtual Music Store scenario in section 4.2.\n**Shared governance:** The business capabilities for which interactions are governed belong to cooperating organisation that share the governance middleware.\n\n**Federated governance:** In this pattern the organisations governance middleware are federated. The interactions between business capabilities inside of this federation can take advantage of the collaboration between the governance middleware.\nThese patterns can be applied as such, but they can also be mixed with one another. For instance, an organisation could use the internal governance pattern within its perimeter and the perimeter pattern to expose by default its business capabilities. The same organisation could still choose to make use of both shared and federated governance patterns for specific situations or partners.\n\n3.7. **Summary of the anatomy**\n\nIn this section, the concrete architecture for governance of safe and flexible contextualisation of resources for SOA governance was presented. Firstly, the author defined the main concepts necessary to the good understanding of the anatomy’s description. Next, the data structures used in the concrete architecture were presented. Then, the components forming the architecture were described and categorised in either a core or a management category. Finally, the processes that link these different data structures and components were shown. Additionally, the governance architecture usage patterns were briefly described.\n\nIn the chapter 4, the author will describe how the architecture presented in this chapter was implemented in a concrete example of virtual music store as presented in chapter 1.1.1.\n4. Implementation of resource contextualisation governance\n\nThis chapter describes the implementation of the concrete architecture for resource contextualisation governance in SOA defined in Chapter 3. The implementation is used in the context of a Virtualised Music Store as presented in 1.1.1. Finally, a series of tests are performed on the functional validity of the implementation and the results are discussed.\n\nThe use of the resource exposure governance is essentially seamless. The resource owner or the governance middleware administrator, depending on how the responsibilities are shared, is responsible for inspecting when governance requests (e.g. profiles) are sensible or can be a threat to the governed resource’s integrity (e.g. conflicting business goal, inadequate security). Additionally, the only significant supplementary effort, in comparison of not using any NFP support for the governed resource, is the provision of adequately described infrastructure capabilities. This is alleviated by the fact that infrastructure providers will want to expose their services in order, for instance, to generate revenue.\n\nThe objective of this implementation is to implement a Virtual Music Store connected to content providers. In this scenario, the role of the governance middleware is to allow seamlessly connect content providers that are using different security settings.\n\n4.1. Governance middleware\n\nThis section provides a brief overview of relevant aspects of Web Service development with the Java language [70] and the Apache Axis2 [71] SOAP [72] and WSDL [33] engine that has been chosen as the demonstrator platform for implementation of resource contextualisation middleware services. Nevertheless, as is apparent from the following discussion, the general approach to development of the middleware is neither Axis2 nor Java specific.\n\nThe Apache Axis2 engine deployed on an Apache Tomcat [73] application server was chosen because it provides straightforward mechanisms for developing, deploying and using Web Services. It is also a widely used platform with which to experiment.\n\nEach core infrastructure capability was developed, deployed and then registered in the registry using the same registration data as the none core infrastructure capabilities described further (c.f. Table 5 for example of infrastructure registration data). This approach was used to allow sharing the same code to discover and enact all the capabilities.\n\nThe registry itself was provided by an instance of the eXist-db Open Source Native XML Database [74] which natively exposes the data it holds through a SOAP interface provided by a servlet [75] mode based on Apache Axis. In addition, this web enabled XML database can be queried using XQuery 1.0 [76] or XPath 2.0 [77]. All these elements permit an efficient and straightforward manipulation of XML data over the network.\n\nFinally, the message interceptor was provided by Apache Synapse [78]. This choice was driven by the relatively well documented usage of this project, its undemanding development and deployment requirements. In addition, the implementation required\na relatively efficient message broker as all the messages in the scenario were going to pass through it.\n\n4.2. Virtual music store scenario\n\n4.2.1. Description\nThis section presents the virtual music store (VMS) scenario introduced in section 1.1.1. This presentation is a practical illustration of the concrete architecture proposed in chapter 3. The security governance gateway presented intercepts messages addressed to a VMS, enforces security policies and integrates the defined security capabilities (e.g. identity management, authorization service) in order to secure the VMS communications with its content providers.\n\nWith this scenario, the author aims to demonstrate that the concrete architecture presented in section 3 can be applied to provide complex NFPS such as access control, identity management and policy enforcement. Indeed, these security-related NFPS necessitate configuration of the capabilities themselves, but also between them. For instance, in a certain federation anatomy, a Secure Token Service (STS) [54] providing identity management will not only need to be configured, but will also require a process of trust establishment with the different STSs it is meant to interact with. The situation can be different in different federation anatomies, thus necessitating a tight management of how to control the assembly of capabilities in a safe manner.\n\n4.2.2. Partners and roles\nIn this scenario, the aggregated services are virtual music stores serving specialised markets or communities of interest. The basic content providers include copyright owners of musical recordings or their representatives who make these recordings available online. The virtual music store reaches agreement with content providers enabling it to act as re-seller of bundles of recordings from their catalogues. The VMS is a VO consisting of the music store operator that communicates to content providers through a security governance gateway whose security services are provided by external security providers through the SaaS (Security as a Service) paradigm.\n\nThe end customer of the VMS will be a member of the public. What they will see is a web site where they will be able to search for tracks. The user interface of the VMS setup for the implementation is presented in Figure 43.\nAs shown in Figure 44, in the music store scenario, the main categories of partners are:\n\n**Content Provider (CP):** The CP is a stakeholder of the role music content provider as described in chapter 1.1.1. It is a specialist content provider (e.g. record labels or other copyright owners). Three different content providers take part in this particular scenario. Each one of them is using a different security profile that it shares with the VMS operator through the security governance gateway. The security profiles express their requirements in term of security in a set of XML files using the formalised way\nillustrated in Figure 19. Following is the list of the content providers with an overview of their security settings:\n\n- CP1 “SomeMusicStore” requires HTTP digest access authentication [80]. CP1’s profile is fully presented in Table 11.\n\n- CP2 “RockYourWorldStore” requires SecPAL for both expressing the access control requests and identify the requesters.\n\n- CP3 “ILoveMyClassicsStore” requires login and password with its own xml schema for the token.\n\nThese three profiles have been selected as they represent the main approaches to securing resource access in distributed systems and present three level of difficulty in term of integration and contextualisation support.\n\nHTTP Digest access authentication is a common way of controlling resources access in internet oriented software. It requires the exchange of data such as user name, password, nonce and Quality of Protection (QoP) and is none trivial. It does necessitate the deployment of a specific infrastructure capability to support it (c.f. Table 6). Because it is complex and yet does not require a lot of content (e.g. message payload) to demonstrate, this profile will be used in the rest of this section to illustrate the scenario.\n\nSecPAL is used for expressing decentralised authorization policies. It is similar to XACML in that it uses a set of subject, resource and action to define access control rules and requests. Both technologies can be used together with WS-Trust [82] standard. WS-Trust defines a trust model together with how to issue, renew and cancel tokens that are used to identify users. This method for identifying user is common in SOA.\n\nThe third method used to test the usability and efficiency of the architecture proposed uses a custom made xml schema to pass user credentials in the message header. Although this manner is not recommended, it presents with the opportunity to test a simple contextualisation in term of infrastructure support needed.\n\nSecurity governance provider: The security governance provider is a particular stakeholder of the value adding service provider as described in chapter 1.1.1 that provides the assembly and management of other value adding services. This role involves providing the VMS with a security governance gateway. The purpose of the gateway is to hide the technical complexity of the security middleware involved and enhance the visibility of the security actions that need to be enforced. In addition, it allows connecting the VMS to different content providers that expose their catalogs using diverse security configurations.\n\nVirtual Music Store (VMS) operator: The VMS is a stakeholder of the virtual music store operator as described in chapter 1.1.1. Ultimately, the administrator of the VMS is responsible for selecting its different CP partners.\n\nSecurity as a Service (SaaS) provider: The SaaS provider is a stakeholder of the value adding service provider as described in chapter 1.1.1. This is a third party entrusted with providing a security service such as identity management, access control or audit. These services are managed by the security governance and allow the content providers and music store operator to leverage on the security governance gateway to enhance their interoperability while keeping the necessary level of security. In this experiment, these services, shown in Figure 44 are registered and\ndescribed using the same taxonomy as the one used in the security profile. Although these providers are not known from the VMS and CPs, for the sake of this experiment, it is assumed that these actors trust the security governance provider who in turn trusts the security service providers. The author believes that in a production environment this would be overcome by providing solutions such as QoS [83] or dynamic trust based [84] selection of services.\n\n4.2.3. SOA security governance\n\nIn the music store scenario, an instance of the governance middleware named security governance is designed.\n\nFigure 45 illustrates how security capabilities can be composed into a security management solution during service operation. In this figure, the contextual governance discussed throughout this document is part of the SOA Security Governance Layer element. This solution intercepts messages addressed to a set of resources, enforces security policies and integrates the defined core security capabilities, such as identity brokerage, authorisation services, or other managed security services in order to secure the resources' communications.\n\nIt is noticeable that defining an independent enforcement layer (c.f. SOA Security Governance Layer on Figure 45) connected through messaging middleware to the security capabilities that are governed by another dedicated layer implies an additional level of complexity. However this trade-off is compensated by the gains in flexibility, dynamicity and by allowing auditing of the results of each action separately if necessary.\n\nFigure 45. SOA security governance overview [81]\n4.2.4. Security governance life-cycle\n\nThis section describes the life-cycle of the virtual music store’s security. It starts with the governance gateway configuration then continues with the initial agreements and discovery of the potential partners which leads to the formation of a new VO. This is followed by the security profile management that allows for the verification and instantiation of the security profile given by content providers. Finally, the adaptability faculty of the virtual store infrastructure is introduced.\n\nSecurity governance gateway configuration. Prior to the VO formation and at any time during the following steps, the security governance gateway is meant to reach agreements with security service providers to use their services within a particular context (e.g. VO) and/or with specific requirements (e.g. QoS) in order to be able to provide security for the different content providers used by the VMS. In a production environment, these agreements could be reached through Quality of Service (QoS) based selection, commercial agreement after human or electronic negotiation. In our case, different services are added, included relevant ones.\n\nIn the experiment presented, three infrastructure capabilities are registered as such in the service repository. The infrastructure are: two security related services including a HTTP digest authentication and a SecPAL Authorization as well as a logging service.\n\nThe logging service keeps a track of the text sent to it, in a preconfigured collection. This logging infrastructure’s registration data is shown in Table 5. The XML schema defining how capabilities can be registered is shown in Table 15. In this prototype, the same schema is used for registering the capabilities and expressing the profiles.\n\nIn Table 5, the reader can see that the logging infrastructure capability posses two interfaces, including one for management purpose that allows the creation and removal of collections of logs. The other interface is defined for the actual functionality of logging. Both interfaces link the related WSDLs and their locations. It is noticeable that the functionalities are ordered through the use of the constraint “BeforeorAfter”, allowing for automatic usage.\n\n```xml\n<ws-p:Capability ID=\"ac06e340-6763-11df-a08a-0800200c9a66\" xmlns:ws-p=\"com.bt.ws-profile\">\n <ws-p:name>Logging</ws-p:name>\n <ws-p:Interface ID=\"ac06e341-6763-11df-a08a-0800200c9a66\">\n <ws-p:name>Management</ws-p:name>\n <ws-p:Functionality ID=\"8db9cd54-676b-11df-a08a-0800200c9a66\">\n <ws-p:name>CreateLogEntriesCollection</ws-p:name>\n <ws-p:Constraint ID=\"8f07b5c1-6764-11df-a08a-0800200c9a66\">\n <ws-p:BeforeorAfter>before</ws-p:BeforeorAfter>\n <ws-p:Activity>self:8db9cd54-676b-11df-a08a-0800200c9a66\"/>\n </ws-p:Constraint>\n </ws-p:Functionality>\n <ws-p:Functionality ID=\"9d940791-676b-11df-a08a-0800200c9a66\">\n <ws-p:name>RemoveLogEntriesCollection</ws-p:name>\n <ws-p:Constraint ID=\"ac06e343-6763-11df-a08a-0800200c9a66\">\n <ws-p:BeforeorAfter>before</ws-p:BeforeorAfter>\n <ws-p:Activity>self:8db9cd54-676b-11df-a08a-0800200c9a66\"/>\n </ws-p:Constraint>\n </ws-p:Functionality>\n </ws-p:Interface>\n <ws-p:Location>muker.ncl.ac.uk:8080/LoggingInfrastructure/mgt</ws-p:Location>\n</ws-p:Capability>\n```\nTable 5. Registration data of logging infrastructure\n\nIn Table 6, the HTTP digest authentication and decoding infrastructure capability is registered in much the same way.\nTable 6. Registration data of HTTP digest authentication and decoding infrastructure\n\nIn Table 7, the SecPAL authorization infrastructure capability is registered in much the same way.\nTable 7. Registration data of SecPAL Authorization infrastructure\n\nVO formation. Prior to any collaborative task and once the virtual shop has decided to establish the music store, it needs to reach an agreement with the security governance provider.\n\nVO formation and management as such are out of the scope of the current work. However, the author uses a form of virtual context that supports the level of functionality required in order to demonstrate the feasibility of the proposed concrete architecture. As suggested in section 5.4 on future works, collaborative governance spanning across multiple organisations and user domains of expertise should be investigated in the future.\n\nTherefore, in the current context, all negotiations between the different partners are meant to take place outside of the scope of the implementation.\nWith a governance gateway in place, the VMS operator can register his business capabilities. In this scenario, there is one business capability that has two functionalities 1) consume music content (i.e. input point for content providers) 2) send request for content (i.e. search query to content providers). The data used for the registration of this business capability is shown in Table 8.\n\nTable 8. Registration data of VMS business capability\n\nAdditionally, the VMS operator can contact the potential participants of the music shop (i.e. content providers). Agreements are reached between these content providers and the VMS operator regarding the conditions in which the business will be run and the VO operated. Following this, the content providers deposit their security profiles in the gateway together with the relevant data about their business functions (e.g. music catalogue web service). These security profiles contain the data necessary for the governance gateway to understand how to securely connect to the CPs services. More precisely, this means that CP3’s security profile will comport a reference to the appropriate login XML schema. CP2’s security profile on the other hand will provide for instance a reference to the SecPAL assertion it expects and what service, interface and operation the security governance gateway needs to contact in order establish trust and therefore allow for its identity to be established.\n\nFigure 46 shows the governance user interface that connects to the profile initiator component in order to manipulate the different elements of the exposure governance. In this figure, the “governance features” in the left menu allow accessing and modifying business capabilities, abstract and concrete profiles, contexts and context selectors. In the same illustration the profile used to govern the exposure in the\ncontext of the content provider 3 is shown. This profile is remarkable as the interaction with the content provider 3 does not require any infrastructure, the logging infrastructure being added by the governance operator. The implemented governance, by convention, will add the given XML nodes in the SOAP header of the request for which the profile is used.\n\n**Figure 46. Governance user interface and “I Love My Classics Store” profile**\n\nThe contextual data for the “I Love My Classics Store” profile is shown in Table 9. The configuration data specifies that for the given targeted element, particular values are to be changed accordingly. The targeted element in the case illustrated is the profile constraint shown in the “I Love My Classics Store” profile.\n\nFinally, the context selector allows connecting a profile, a context, a business capability and a routing definition. Table 10 shows the context selector data for the CP3 profile and VMS business capability. This context selector specifies that when\n\n```xml\n<ws:c:WS-Context ID=\"f80176e4-2d8a-45c9-a36f-b10f3185335\" xmlns:ws-c=\"com.bt.ws-context\">\n <ws:c:name>cILoveMyClassicsStore</ws:c:name>\n <ws:c:configData>\n <ws:c:target>b625512a-e08d-4109-b249-eb171361c58c</ws:c:target>\n <ws:c:misc>\n replace:\n <login-value/>=cp3\n <pwd-value/>=pwd\n </ws:c:misc>\n </ws:c:configData>\n</ws:c:WS-Context>\n```\n\n**Table 9. Contextual data for “CP3: I Love My Classics Store” profile in the VMS**\nthe VMS business capability sends a request containing the \"ILoveMyClassicsStore\" expression, the CP3 profile and CP3 context should be used. Additionally, the up time property is set to always.\n\n```\n<ws-cs:WS-ContextSelector ID=\"d4b4bb5e-8e31-4140-a57c-7fb7d3e88ed0\" xsi:schemaLocation=\"com.bt.ws-context-selector context-selector.xsd\" xmlns:ws-cs=\"com.bt.ws-context-selector\">\n <ws-cs:name>csILoveMyClassicsStore</ws-cs:name>\n <ws-cs:profile>b6dc69d8-7da2-4025-b47b-504e49b1b68a</ws-cs:profile>\n <ws-cs:context>f80176e4-2dfa-45c9-a36f-d1603185335</ws-cs:context>\n <ws-cs:internalTarget>8b73c255-6af7-11df-a08a-0800200c9a66</ws-cs:internalTarget>\n <ws-cs:configSelector>\n <ws-cs:data>ILoveMyClassicsStore</ws-cs:data>\n <ws-cs:operation>request</ws-cs:operation>\n </ws-cs:configSelector>\n <ws-c:upTime>\n <ws-c:type>always</ws-c:type>\n </ws-c:upTime>\n</ws-cs:WS-ContextSelector>\n```\n\nTable 10. Context selector for \"CP3: I Love My Classics Store\" profile and the \"CreateContentQuery\" operation of the business capability.\n\nTable 11 holds the profile registered for CP1: Some Music Store. The content of this profile is shown in a more readable manner in Figure 47. The profile specifies the VMS business capability interaction with CP1 for both request and response. From this profile, the governance middleware knows that the interaction requires HTTP digest authentication mechanism. The credentials expected are provided in the context. Additionally, the governance middleware learns that the content of the response message is \"encrypted\" and the method used to encrypt it. The method of encryption is provided in the context.\n\nThe context and context selector for this interaction take the same form as the examples given in Table 9 and Table 10.\n\n```\n<ws-p:WS-Profile ID=\"edf66321-683f-11df-a08a-0800200c9a66\" xmlns:ws-p=\"com.bt.ws-profile\">\n <ws-p:name>CP1: Some Music Store profile</ws-p:name>\n <ws-p:Capability ID=\"218ee5e1-6836-11df-a08a-0800200c9a66\" xmlns:ws-p=\"com.bt.ws-profile\">\n <ws-p:name>HTTP Digest Authz</ws-p:name>\n <ws-p:Interface ID=\"5f913a01-6836-11df-a08a-0800200c9a66\">\n <ws-p:name>Functionality</ws-p:name>\n <ws-p:Functionality ID=\"639220c5-897d-4f52-8db4-5d03456d4eab\"/>\n </ws-p:Interface>\n </ws-p:Capability>\n <ws-p:Constraint ID=\"0e91d933-f999-465b-8b80-2126b151c5cc\">\n <ws-p:misc>operation</ws-p:misc>\n <ws-p:value>request</ws-p:value>\n </ws-p:Constraint>\n <ws-p:Capability ID=\"218ee5e1-6836-11df-a08a-0800200c9a66\" xmlns:ws-p=\"com.bt.ws-profile\">\n <ws-p:name>HTTP Digest Authz</ws-p:name>\n </ws-p:Capability>\n</ws-p:WS-Profile>\n```\nSecurity profile management. At this stage it becomes possible for security gateway to validate and enact the different security profiles.\n\nTo achieve this, the profile management component of the gateway goes through a set of actions that starts with the verification of the security profile proposed to the definition of the processes necessary for the instantiation and management of the future implementation of the security profile.\n\nThese domains can be respectively as described in section 3.5 split in several steps: defining the infrastructure capabilities, the policy templates, the service dependencies and the information flow for the first one and defining the profile management process as well as publishing the infrastructure profile for the second.\n\nMore details on the specific stages of the profile management and how they execute are given in the following paragraphs. Tests assessing the relevance and quality of these stages are found in sections 4.2.5 and 4.2.6.\n\nDefine security infrastructure (c.f. section 3.5.1): The first stage of this process is to check for each security service if the description given in the security profile is adequate and complete according to the profile description taxonomy. If that test passes, the abstract definition of the service as well as its requirements are gathered. Please note that at this stage the governance has not selected a particular instance of any running service but has selected the appropriate categories in the taxonomy.\nThe security governance gateway does separate copies of the security profile at the beginning and end of this process. This allows keeping a track of what the domain of governance requested is as opposed to the profile that will be completed and proposed.\n\nDefine policy templates (c.f. section 3.5.2): This second stage verifies if the policy type that will be used require any translation (when using different grammars). In addition, this stage checks how they need to be managed. In the described implementation this stage is not necessary.\n\nDefine infrastructure dependencies (c.f. section 3.5.3): Following this individual check, the relationships between the services, both on the managerial and operational sides are verified.\n\nThe last stage goes through the security profile and check for missing components. For instance, a content provider could have specified an access control method without mentioning any identity management.\n\nFollowing this, the VMS operator could review and select the best matches in the positive answers it has received, potentially eliminating content provider with too weak or too costly security configurations.\n\nDefine information flow (c.f. section 3.5.4): With the security profile complete and safe, the fourth stage aims at checking how the data will flow from one operation to the next. In addition, the governance determines, when relevant, whether a translation process is necessary amongst them and/or with the content provider's security settings. Please note that translation mechanisms may be provided by external tools and are not described in the current work. Finally, the concrete services enacting the infrastructure capabilities are selected.\n\nThe result of this step is saved as a security profile that can be instantiated.\n\nDefine profile management processes (c.f. section 3.5.5): With the profile instance in place and the services selected, the final stage is for the profile composition management component to define the different steps that will be necessary in order to call, configure and connect the security services. The result of this last stage is stored together with the now complete and safe security profile as a coordination plan.\n\nWhen necessary the security governance gateway can then enact this complete profile through this management process.\n\nSelect infrastructure profile instance (c.f. section 3.5.6): When required to enact a security profile, the gateway search into its database and selects it. It then makes sure that the data can flow between the enacted security profile and the VMS interactions they manage.\n\nDefine service-specific policies (c.f. section 3.5.7): The profile management goes through all the concrete services selected in the security profile and instantiates the policy templates by inserting the context data.\n\nDefine information flow (c.f. section 3.5.8): If necessary, the transformations templates are also instantiated according to the results of the previous step on translation.\n\nDefine service exposure management processes (c.f. section 3.5.9): The profile manager orders and binds the different management processes of the security profile and the VMS interactions they manage.\nPublish service instance (c.f. section 3.5.10): Finally, the policies created in step 26 are pushed to the different relevant stores (e.g. the SaaS capabilities driven by them) through the enactment of the management processes. To finish, the VMS clients of the CP services are bound to their instantiated profiles and exposed.\n\nAdaptability. A VMS will want to be able to include as many content providers as it can, but different partners will have distinct security needs and settings. By reviewing and accepting the different security profiles used by each partner according to its specific needs, the VMS can more promptly make use of their contents. This necessitates and is limited by the capability of the security governance gateway to find security related services that provide for these different requirements.\n\n4.2.5. Functional tests\n\nIn this section, the different tests done in order to evaluate if the Virtual Music Store functions according to expectations are presented together with their results. For each test, a parallel “witness test” is performed to ensure that the result is valid.\n\nFor the purpose of testing, the VMS does not perform any caching and any query is directly forwarded to the Content Providers. This is possibly not an adequate practice for this type of system in a commercial environment, but renders the testing easier.\n\nTest 1: Content Provider 1 integration. For this first test, all the infrastructure capabilities are registered in the governance gateway. However, only the first exposition profile is made available. If the gateway is well implemented, the infrastructures and profile description well written, this test is expected to pass.\n\nValidation test. In order to insure that test 1 result is valid, in this validation stage, the logging infrastructure capability is unregistered. As it has been marked as a mandatory infrastructure in all profiles, this test is expected to fail.\n\nTest 2: Content Provider 2 integration. For this second test, all the infrastructure capabilities are registered in the governance gateway. However, only the second exposition profile is made available. If the gateway is well implemented, the infrastructures and profile description well written, this test is expected to pass.\n\nValidation test: In order to verify test 2 result, the Functionality Token interface is erased from the SecPAL Authz infrastructure description. As this renders the SecPAL Authz infrastructure unsuitable for the contextualisation this test is expected to fail.\n\nTest 3: Content Provider 3 integration. For this third test, all the infrastructure capabilities are registered in the governance gateway. However, only the third exposition profile is made available. If the gateway is well implemented, the infrastructures and profile description well written, this test is expected to pass.\n\nValidation test: In this validation test, the schema defining user credentials supported by the custom authorization infrastructure used by CP3 is modified (username node is changed to user). This test is expected to fail.\n\nTest 4: All Content Provider integration. For this fourth test, all the infrastructure capabilities are registered in the governance gateway. In addition, all the exposition profiles are made available. If the gateway is well implemented, the infrastructures and profile descriptions well written, this test is expected to pass.\n\nValidation test: In this validation test, the HTTP digest infrastructure capability is unregistered. The expected outcome of this test is that only content coming from\ncontent providers 2 and 3 will appear on the VMS interface and therefore the test will fail.\n\nTable 12 shows the results of the tests. The result is set as passed when the adequate music tracks per content provider are displayed on the web interface and failed otherwise. As all the tests produce the expected outcomes, the exposition governance implementation is therefore validated from a functional point of view.\n\nFigure 48 and Figure 49 illustrate the outcomes of test 1 and its validation counterpart.\n\nFigure 48. Test 1 result\n\n<table>\n<thead>\n<tr>\n<th>Search</th>\n<th>Music</th>\n<th>Miles Davis</th>\n</tr>\n</thead>\n</table>\n\nBrowse\nGenres\n- Cool Jazz\n- European Jazz\n- Jazz Fusion\n- Latin Jazz\n- Orchestral Jazz\n- Smooth Jazz\n\nMusic\n- \"Round About Midnight\" – Miles Davis\nProvider: Some Music Store\n- \"The Legendary Prestige Quintet Sessions\" – Miles Davis\nProvider: Some Music Store\n\nFigure 49. Test 1 validation test result\n\n<table>\n<thead>\n<tr>\n<th>Search</th>\n<th>Music</th>\n<th>Miles Davis</th>\n</tr>\n</thead>\n</table>\n\nBrowse\nGenres\n- Cool Jazz\n- European Jazz\n- Jazz Fusion\n- Latin Jazz\n- Orchestral Jazz\n- Smooth Jazz\n\nMusic\n<table>\n<thead>\n<tr>\n<th>Test</th>\n<th>Result</th>\n<th>Expected result</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>1 validation</td>\n<td>Failed</td>\n<td>Failed</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>2 validation</td>\n<td>Failed</td>\n<td>Failed</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>3 validation</td>\n<td>Failed</td>\n<td>Failed</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>4 validation</td>\n<td>Failed</td>\n<td>Failed</td>\n</tr>\n</tbody>\n</table>\n\nTable 12. Implementation tests results\n\n4.2.6. Adaptability tests\n\nThe purpose of this evaluation is to demonstrate the adaptability of the security governance middleware. In order to do so, the author has assessed its capacity for integration with different systems and the capacity to manage this adaptability when dealing with different types of unavailability, change or event.\n\nCommunications between the VMS and the security governance solution are secured using the VMS security settings. The security of this type of middleware is assumed to be equivalent to that of the security profiles it enacts. Indeed, the message exchanges between the different components of the middleware are secured as well as the exchanges with external services as provided by the external service. External security services that are used to provide security requirements are trusted. For each test, a parallel “witness test” is performed to ensure that the result is valid.\n\nAdaptability to external factors\n\nTest 1: Infrastructure capability change. This test is similar to “test 3: Content Provider 3 integration validation test”. In order to demonstrate that the governance middleware is capable to adapt to changes in the way the external infrastructure capabilities behave, this earlier test was repeated. Once again, this test is expected to fail.\n\nValidation test. In order to insure that test 1 result is valid, in this validation stage, the custom authorization infrastructure used by CP3 is registered twice. The first registration makes use of the unmodified and valid node while the second one is registered with the modified node as in the earlier test. This test is expected to fail.\n\nTest 2: Introduction of new infrastructure capability. To ensure that the introduction of new infrastructure capabilities is supported and does not hamper the good functioning of the governance middleware, the same type of infrastructure is deployed and registered several times. In this case, the custom authorization infrastructure used by CP3 is deployed and registered three times. This test is expected to pass.\nValidation test. In order to insure that aforementioned test’s result is valid, each registered custom authorization infrastructure was in turn unregistered until none was left. The first two tests are expected to pass while the third iteration leaves no authorization service for CP3 is expected to fail.\n\nTest 3: Change a profile. In this test, the mandatory logging infrastructure capability is taken out of the abstract profile and is therefore not required anymore. This test is expected to pass.\n\nValidation test. In this validation test, the logging infrastructure capability is put back in the abstract profile but unregistered from the service registry. This test is expected to fail.\n\nTest 4: Change a security policy In this test, the values of the username and password are modified in the profile description and at CP3’s side authorization code. This test is expected to pass.\n\nValidation test. To verify the validity of the previous test, CP3’s side authorization code is changed back to allow only the previous values to be accepted. This test is expected to fail.\n\nAdaptability to internal factors\n\nTest 5: Swap a security component for another, similar, component. This test is similar to “Test 2: Introduction of new infrastructure capability”. However, the HTTP digest infrastructure capability was used instead of the custom authorization infrastructure. This test is expected to pass.\n\nValidation test. As for “Test 2: Introduction of new infrastructure capability” validation test. The first two iterations are expected to pass while the third iteration leaves no authorization service for CP1 is expected to fail.\n\nReusability\n\nTest 6: Use an infrastructure capability in different profiles. With the presence of the logging infrastructure capability in the abstract profile and the use of the abstract profile as the base for all security profiles, this test has been performed through previous tests. This test is expected to pass.\n\nValidation test. In order to demonstrate that the governance middleware tolerates the presence of a registered but unused infrastructure, the logging infrastructure was taken out of the abstract profile, but still registered in the service registry. This test is expected to pass.\n\nTest 7: Reuse stored profile in a different context. An abstract profile has been used, in order to define minimum requirements, as the base for all security profiles. This test has therefore been performed through previous tests. This test is expected to pass.\n\nValidation test. In this scenario, the use of the abstract profile was made mandatory in order to guaranty a minimum security. However, in different scenarios, this might not be the case and it is trivial to deduce from the previous tests that this possibility, when implemented can be supported by a governance middleware.\n\nTable 13 shows the results of the adaptability tests. The result is set as passed when the adequate music tracks per content provider are displayed on the web interface and\nfailed otherwise. As all the tests produce the expected outcomes, the exposition governance implementation is therefore validated from a functional point of view.\n\n<table>\n<thead>\n<tr>\n<th>Test</th>\n<th>Result</th>\n<th>Expected result</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Failed</td>\n<td>Failed</td>\n</tr>\n<tr>\n<td>1 validation</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>2 validation</td>\n<td>Passed, Passed, Failed</td>\n<td>Passed, Passed, Failed</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>3 validation</td>\n<td>Failed</td>\n<td>Failed</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>4 validation</td>\n<td>Failed</td>\n<td>Failed</td>\n</tr>\n<tr>\n<td>5</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>5 validation</td>\n<td>Passed, Passed, Failed</td>\n<td>Passed, Passed, Failed</td>\n</tr>\n<tr>\n<td>6</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>6 validation</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>7</td>\n<td>Passed</td>\n<td>Passed</td>\n</tr>\n<tr>\n<td>7 validation</td>\n<td>/</td>\n<td>/</td>\n</tr>\n</tbody>\n</table>\n\nTable 13. Adaptability tests results\n\nThe potential scope of the contextualisation governance is wide and the concrete architecture has been thought of to take into account complex scenarios as well as simple ones. The tests presented in this section do not cover all aspects possible as this would necessitate more effort than it is possible in the timeframe of this thesis. Instead, the tests showed a practical illustration of the possibilities made available by the use of a well-defined contextualisation governance architecture.\n\n4.1. Discussion\n\nThe authors of [42] (cf. related work section 2.2.2), have devised six types of adaptation that a flexible security middleware suite should support:\n\nS1 Change a local parameter of a security component (e.g. the encryption method for an audit service).\n\nS2 Introduce new security functionality (e.g. add a secure logging component).\nS3 Compose/recompose a deployed security component with one or more application components. Application components depend on the security component but the security component can also depend on the application component(s) (e.g. for context-based access control).\n\nS4 Swap a security component for another one (e.g. replace the authorization decision engine).\n\nS5 Compose a security component using a (new) third-party component that is deployed elsewhere.\n\nS6 Change a security policy. Since the security policy explicitly depends on application-level concepts, any change in a security policy can require further adaptations.\n\nThe system proposed in this paper, based on the security profile, is meant to introduce flexibility to the way in which the NFP aggregation lifecycle is managed and user requirements expressed. Therefore the following discussion points have been added:\n\nS7 Enact the security profile at different stages in different situations (e.g. CP1 steps 1-39, CP2 steps 21-39).\n\nS8 Express identical requirements using different semantics.\n\nThe objective of this discussion is to review the adaptability and to define its limits. The security profiles submitted by the content provider to the security governance middleware have been used in order to determine the scope of the adaptation.\n\nS1 Changing a security service's configuration requires the user to change the security profile. With the change committed, the governance middleware will make use of Service Management's access to the security service's management interface to perform the change. However, the governance infrastructure will go through the process of profile management to ensure that the change is valid and can be realized. If the security service does not support this change a different one may be selected or the modification rejected.\n\nS2 If the relevant security services are registered as accessible in this context and with these requirements, a security profile needs to be updated with the additional security functionality.\n\nS3 Composition of security as well as other value-adding services can be realized. Of course, the quality of the segregation of a security service between different contexts (e.g. different interactions and conversations) depends on its implementation and may not be possible. For instance, a service may or may not support multi-domain instantiations and configurations.\n\nS4 As presented in section 3.5, replacing a security service with another, similar one is achievable as long as a potential replacement is registered and accessible. If a security service is found missing at runtime, it is possible to start again from step 13 onwards, to regenerate an instantiated profile while storing the incoming and outgoing messages.\n\nS5 The ability to compose external providers' security services is the very foundation of this work.\n\nS6 In this model, modifying a security policy is equivalent to changing a security component local parameter (c.f. S1). This is due to the expected policy driven nature.\nof the infrastructure capabilities. A component local parameter will be modified using policy, in the same technical manner as an access control assertion (i.e. security policy).\n\nS7 It is possible to store a profile's state at any stage of its lifecycle. However, validation stages are required in most cases to ensure the profile's validity at the time of use (e.g. whether the security service is still available).\n\nS8 This point has not been verified in this set of experiments. However, it depends on the different semantic styles used as well as their interoperability.\n5. Summary of contributions and future work\n\nIn the previous section, an implementation of the proposed concrete architecture was presented. Subsequently, series of tests both functional and targeting the adaptability were presented to demonstrate the validity of the implementation. Finally, a discussion based on the evaluation of a similar approach was proposed.\n\nIn this chapter the author summarises the contributions of the work and then concludes the thesis with suggestions for future work.\n\n5.1. Summary of research challenges\n\nIn the following paragraphs, the author assesses the proposed approach with respect to each of the research challenge provided in Chapter 2.\n\n1. Reusability of integration layer. The separation of concerns in the architecture proposed (c.f. Figure 17, Figure 23, Figure 31) aims at providing a coarse-grained distribution of the components. In this architecture the level of granularity proposed answers to the levels or reutilisation and potential performance optimisation techniques (e.g. replication) that can be used in distributed systems. In addition the message broker nature of the approach proposed offers a high potential for reusability.\n\n2. Shared communication semantics. This requirement is principally dealt with by the brokering nature of the architecture proposed and the service orientation that brings ease of connectivity.\n\n3. Decentralised model. The separation of concern and service orientation of the architecture allows avoiding a central core and relying on distributed components. The use of dedicated layers to administrate policies (c.f. policy management core infrastructure in section 3.4.1) and potential components (c.f. service management core infrastructure in section 3.4.1) permits the architecture to be flexible when dealing with resource location.\n\n4. Definition of SOA governance and related concepts. The core objectives of the proposed architecture are presented in section 1 and further developed through a practical example in section 1.1.\n\n5. High level description of key contextualisation elements and concepts. Sections 3.2 and 3.3 present the different elements forming the governance architecture and their relationships. Each element is described individually before a more global definition where the components are presented together is proposed.\n\n6. Technical description of key contextualisation elements and their relationships. In addition to the descriptions as mentioned in point 5, sections 3.4 and 3.5 give a more detailed description of the key elements and a point by point description of all the steps happening prior and during a contextualisation. These steps are further divided into actions to give further details on the different processes taking place.\n\n7. Non Functional Property (NFP) description model. With the use of the infrastructure profile definition proposed in section 3.3.1, potential partners (e.g. end users, other governance middleware, NFP providers) and this current architecture are able to express requirements in term of NFP and communicate them.\n8. NFP profile description. The infrastructure profile along with the mechanisms that allow selecting capabilities and their policies are described in Chapter 3 on the anatomy of the infrastructure. The grammar used to describe the profile can be adapted to fit specific needs. The selection of capabilities and policies are also handled by dedicated layers enabling flexible and adaptable mechanisms.\n\n9. NFP profile instance. The stages described in the series of steps necessary in order to create a safe and complete profile and then instantiate it as well as expose the business capabilities are described in section 3.5. The policy driven approach used in the architecture presented along with a dedicated layer for service management (c.f. section 3.4.2.1 on Capability management) allow specific management processes and policies to efficiently specify and supervise the characteristics of the infrastructures and profiles life-cycle. For the profile, these life cycles management processes are used by a dedicated component (i.e. Profile Life-Cycle Management in Figure 31). Finally the process of instantiating the profile and its different components (e.g. services, policies) allows multi-tenancy usage scenarios.\n\n10. Reusable & manageable NFP providers. The choice of service based architecture was partly to be able to rely upon distributed pieces of software that can be made configurable and reusable. As presented in point 9 above, the architecture comprises a dedicated layer management to manage the different components and allow for their optimal reusability. This in turn, allows for the governance to interchange and reconfigure the different capabilities taking part in the governance process.\n\n11. Run time aggregation of NFPs. The stages described in the series of steps necessary in order to create a safe and complete profile and then instantiate it as well as expose the business capabilities (c.f. section 3.5) present such policy schemes and how they can be contextualised. The transformation mechanism relies on three elements, the policy template, the transformation policy and the contextualised data. The first two elements are provided at design time while the later is given at run time. This system is flexible but becomes more and more complex as the number of transformation potentially necessary increase.\n\n12. Domain agnostic. The limitations of the architecture proposed in terms of the types of resources it can govern and the categories of contextualisation it can provide are limited by the NFP description models it holds and the NFP providing components (i.e. infrastructure capabilities) it is aware of.\n\n13. Life-cycle management of the aggregation of NFPs. The stages described in the series of steps necessary in order to create a safe and complete profile and then instantiate it as well as expose the business capabilities are described in section 3.5. These stages are progressing from an abstract profile with a high level view of what the domain of exposition will be into an instantiated and enacted profile that is complete and comprises concrete as well as configured instance of services.\n\n14. Semantically described components. A normalised manner is used to define the way infrastructure capabilities are exposed. This taxonomy is described in Figure 19 of section 3.3.1.\n\n15. Semantic agnostic. The proposed architecture can be made to understand different manners to express the domain of exposition thanks to the user interface abstract service pattern used (c.f. section 3.4.2) and the policy driven approach of the architecture. The limitation to this approach being that a translation between a new\nsemantic and an existing one, understood by the governance middleware, must be provided.\n\n16. **Support for end to end message level security.** By maintaining no visible link between the final enhanced exposed resource and its pre-governance source (i.e. the business capability), the architecture, within the scope of its contextualisation, prevents threats from reaching the resource directly (c.f. steps 23 and 38 of the business capability exposure in section 3.5). In addition, the state of the different resources (e.g. NFP providers, policies) can be constantly monitored to prevent an unwanted execution of a profile. Finally, in order to prevent information leaks, security and auditing capabilities such as a logging service (c.f. section 4.2), when available, can be seamlessly included in the profile to evaluate data miss-management or prevent privacy issue. A tested scenario covering such requirement is described in the evaluation section (c.f. section 4).\n\n17. **Verify validity of the contextualisation strategy.** During the profile life-cycle, dependencies are systematically sought and resolved. In addition, the profile usability can be enhanced for particular environments using different ways to express the exposition requirements through the user interface abstract service pattern (c.f. section 3.4.2).\n\n<table>\n<thead>\n<tr>\n<th>Table 14. Summary of research challenges</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Legend</strong></td>\n</tr>\n<tr>\n<td>L – supported</td>\n</tr>\n<tr>\n<td>X – supported</td>\n</tr>\n<tr>\n<td>and specified in detail</td>\n</tr>\n<tr>\n<td>“” – not supported</td>\n</tr>\n<tr>\n<td><strong>Proposed concrete architecture</strong></td>\n</tr>\n<tr>\n<td>X X X X X X L X L X L X X X X X X X X</td>\n</tr>\n</tbody>\n</table>\n\nTable 14 recapitulates the research challenges in the same manner as Table 1, Table 2, Table 3 and Table 4, but specifying what points are fulfilled by the proposed concrete architecture as opposed to those satisfied by the related works.\n\n5.2. **SOA governance model and Service Delivery Frameworks**\n\nThis section focuses on the framework's conformance to the principles of the standard Service Delivery Framework developed by the TeleManagement Forum, introduced in section 2.2.3 and more thoroughly described in [44].\n\nFigure 50 presents the main SDF concepts overlaid by those of governance model, showing the detailed mapping of the proposed governance model on top of the standard framework.\nThe governance model presented in the previous section has been developed in full compliance with the SDF standard of the TMF. This alignment extends the applicability of the governance model in service domains that conform to SDF and fulfils the respective research challenges 5 and 6 introduced in section 2.2.4.\n\nThe functional interface of the SDF in this mapping is the governance management interface as it is the governance model interface that allows for the management of capability.\n\nThe management service consists of the different components described in section 3.4. Specifically these are the Profile management, Capability management and the governance layer base which allows cementing and managing the governance enabling infrastructures.\n\nThe infrastructure support services are these governance enabling infrastructures that allow for the governance model to run along with the potential infrastructure capabilities that can be used to provide non functional support.\n\nThe SDF Infrastructure may host further supporting facilities for the remaining governance model aspects. It can provide Policy-based Management facilities in order to handle service policies and rules, as specified in the governance model description. It can also use the service catalogue to capture dependencies of a service onto other component artefacts. Finally, it can offer authentication and authorisation mechanisms for access control in order to define and assign privileges regarding the scope of operations entities can conduct within the SDF or capabilities they bear and can make available to SDF.\n\n**5.3. General summary**\n\nIn this thesis, the author has provided a description of an architecture for contextual governance for SOA. This model is based on requirements that underline the need for policy and process management, resource life-cycle management, visibility and contextualisation. One of the roles and tested use case of the proposed model is to\nhandle the security of web services exposed through it by managing their security configuration.\n\nThe chapter 1 identifies the domain for action as managing the contextualisation of a resource in a SOA in a flexible manner. This creates the need to support the integration and composition of as many infrastructures allowing the enhancement of the exposure as well as the life cycle of the exposure thus created. Additionally, the enhancement of the exposure must be made safe and secured. To this end, the author proposed a model for governing the different aspects of the exposure. This model describes a set of middleware services along with their interactions and an infrastructure composition structure called profile. The core of the work in this thesis comprises:\n\n1. A set of requirements that define what is needed in order to establish the governance of a service exposure.\n2. A description of the architecture that fulfil these requirements.\n3. An implementation of this model along with an evaluation against the requirements aforementioned.\n\nThis work addresses the requirements for contextualisation governance specified in Section 2.2.4.\n\nA notable feature of the author's approach is a careful separation of concerns and modularity of the architecture. Figure 51 recalls the architecture presented in section 3 and presents a layered view of it.\n\nThe contextualisation governance is realised through a set of middleware that allow enhancing the exposition of resources by composing external NFP infrastructures and managing the composition. This set of middleware is itself separated in four logical layers: the external capabilities that encompass both the business and infrastructure capabilities, the management layer that comprises core infrastructure capabilities with supervision roles, the operational layer which includes the functional core capabilities such as event processing, repositories and registries and finally the data and security layers allowing to describe the components and secure the architecture. This separation is fundamental to the flexibility of the middleware.\nIn these layers, each of these capabilities can be deployed as a components with its own management, policy administration framework (control pane) and operational interfaces (data pane). Each capability is also policy driven as this permits configurability and flexibility. The different capabilities are meant to have their own distinct grammars and policy languages in order to keep their own advantages, capacities and evolution potential in their respective domains.\n\nThe interoperability issues generated by this situation are addressed at the messaging level through transformation and governance as demonstrated by the transformation steps (section 3.5.2 point 7).\n\nThis also enables the interchange of core capabilities within their categories when necessary. Non-core capabilities (e.g. auditing) can also be added through the same manner.\n\nIt is noticeable that choosing to have these components to be independent and follow their own path implies an additional level of complexity. However this trade-off is compensated by the gains in flexibility, dynamicity and by allowing auditing of the results of each action separately if necessary.\n\nThe author has demonstrated the novelty of the design and implementation of the contextualisation governance middleware with respect to the related work discussed in chapter 2. Novel contributions include:\n\n(i) the development of a flexible SOA based architecture that is based on fundamental work on distributed systems flexibility,\n\n(ii) the provision of systematic support for exposure governance that is adaptable to different application contexts,\n\n(iii) the implementation of a governance middleware in order to secure the exposure of resources in the shared domain.\n\nIn summary, as proposed in the introduction, through a SOA based architecture for distributed resource contextualisation governance, the author has established that:\n\n1. A set of middleware services can provide an efficient support for flexible resource contextualisation governance.\n\n2. This enhanced flexible contextualisation can be organised in such a manner that it preserves the safety of the exchanges.\n\nAnnex 4 lists the published work related to the architecture described in this thesis. The following section will present a discussion of potential future works that continue the theme of exploring fundamental concepts in the context of realistic systems implementation.\n\n5.4. Future work\n\nThe current state of this work defines a concrete architecture for governance of safe and flexible contextualisation of resources in a SOA. Future investigation could evolve the material and expand on a variety of relevant topics. The following are some possible areas.\n\n5.4.1. Different use cases\n\nPotential future works include the use of governance middleware in different types of scenarios. Following is a list of potential use cases considered by the author:\n• The Product and Service Assembly (PSA initiative) Catalyst [85], relies on a set of catalogues grouped in an infrastructure named the Active Catalog. One potential future research would be to investigate the place of such complex registry in the governance architecture or alternatively how the PSA initiative could take advantage of the architecture presented in this thesis.\n\n• The Internet of Things and Service (IoTS) could be another environment where the governance architecture presented could play an interesting role. In [86] the co-authors and I identify the interest of security governance in the IoTS where Things could learn of potential threats and how to deal with them from other governed Things. Scenarios in Service Oriented Manufacturing chains are currently being discussed.\n\n5.4.2. Flexible SOI governance\nThe investigation currently undertaken by the author and following this work comprises the study of this architecture in the context of flexible Service Oriented Infrastructure (SOI).\n\nSOI provides a system for supplying information technology infrastructure as a service. Key aspects of SOI include virtualisation of all configurable infrastructure resources such as compute, storage, and networking hardware and software to support the running of applications. Consistent with the objectives for SOA, SOI facilitates the reuse and dynamic allocation of necessary infrastructure resources [53].\n\nThe main objective of this investigation is to determine how it would be possible to provide support to end users of SOI through a high level dashboard providing user centric semantics. Through this user centric layer, levels of NFPs and preferences (e.g. performance, security) could be chosen and selected. These preferences would then create sets of rules (i.e. profile in section 3.3.1) that would govern the SOI through monitoring, dynamic selection of infrastructures and virtualisation.\n\n5.4.3. Improved profile expression\nIn section 2.2, the author has established that investigating the semantics necessary to describe IT system requirements is a legitimate and complex research topic on its own. One potential topic for future work is to utilise the requirements presented in paragraphs 2 on background in order to provide a more comprehensive and useable profile description model.\n\nAlternatively, future work could explore how different semantics used to describe such requirements in different domains could be taken into account and used by governance middleware.\n\n5.4.4. Federated governance\nIn section 3.6.2 on deployment patterns, the federation of governance middleware is introduced. The study of such use of governance middleware could attempt to determine a) what are the processes and techniques necessary in order to achieve efficient federation and b) what are the different types of federation achievable (e.g. 1 master with dependant governance middleware, equally ranked) and c) in what context it would interesting to use them. In such environments it would then be possible to investigate the potential of negotiating properties of the governance.\n5.4.5. Trust brokering\n\nIn the context of governed interactions, service providers could find themselves in a situation where they do not know what services and by extension which providers are catering for different properties of the exchanges (e.g. security in the security governance scenario in section 4.2). This presents the governance architecture with the issue of allowing the different potential participants to express how they would define the level of trust required for entities in order to enter in collaboration with them. The following are some of the challenges of trust brokering in this type environment:\n\n- Allowing a coarse grained definition of the level of trust required: a participant should be permitted to express what it expects from each property of the interaction (e.g. identity management, access control, virtualisation). Additionally, the participant should also be able to specify the level of trust required to access certain types of data in the interaction.\n\n- Dynamic trust allocation: in this type of rapidly evolving environment, a participant’s life-span can be very short. How to define how trustable this entity is when it has never been part of any collaboration and is potentially unknown to all participants should be taken into account.\n\n- Properties and enforcement of trust: with potentially many different actors covering diverse aspects of a collaboration, defining what trust is and how it should be enforced could also become a challenge and should therefore be examined.\n\n5.4.6. SOA governance middleware performance improvement\n\nIn the SOA security governance middleware presented in section 4, policy templates, instances and processes are exchanged over the network. In complex scenarios or environments where the network is critical, this could create a stress on the physical infrastructure and the core infrastructure capabilities used as the more complex the profile, the more such data need to be exchanged.\n\nOne possible future research direction would be to investigate a) potential techniques that could be used to reduce the amount of data necessary to exchange or b) the number and types of the exchanges themselves between the core infrastructure capabilities of the architecture while keeping the level of distribution as high as possible.\n\n5.4.7. Monitoring and Auditing\n\nIn chapters 3 and 5, the author introduces the relevance and possibility of introducing elements of monitoring and auditing into the architecture. These elements could further enhance the safety and reactivity of the architecture and allow further investigations towards autonomous behaviours. Due to the loosely coupled and distributed nature of the model, introducing such capabilities could be made on the top of the architecture proposed.\n6. References\n\n\n[31] The Open Group SOA Reference Architecture (The Open Group SOA RA), Draft Technical Standard (to be published in 2009); refer to www.opengroup.org/projects/soa-ref-arch\n\n\n[46] TMF061, Service Delivery Framework Reference Architecture, Release 1.0\n\n\n[68] OASIS Web Services Distributed Management (WSDM), www.oasis-open.org/committees/wsdm/\n\n\n106\n\n[85] Product and Service Assembly Initiative, available at: http://www.psainitiative.co.uk/\n\nList of acronyms\n\nADL: Architecture Description Language\nAS: Application Server\nASGI: SOA Governance Infrastructures\nB2B: Business To Business\nBC: Business Capability\nBSS: Business Support Systems\nCORBA: Common Object Request Broker Architecture\nCP: Content Provider\nCPU: Central Processing Unit\nEAI: Enterprise Application Integration\nESB: Enterprise Service Bus\nGIF: Governance Interoperability Framework\nIoTS: Internet of Things and Service\nIT: Information Technology\nICT: Information and Communication Technologies\nJSON: JavaScript Object Notation\nMDD: Model-Driven Development tool\nMOM: Message Oriented Middleware\nNFP: Non-Functional Property\nNFR: Non-Functional Requirement\nOASIS: Organization for the Advancement of Structured Information Standards\nOSS: Operational Support Systems\nPSA: Product and Service Assembly\nQoS: Quality of Service\nREST: REpresentational State Transfer\nROI: Return On Investment\nRPC: Remote Procedure Call\nSAML: Security Assertion Markup Language\nSaaS: Security as a Service\nSDF: Service Delivery Framework\nSDF ISS: SDF Infrastructure Support Services\nSDF SMI: SDF Service Management Interfaces\nSDF MSS: SDF Management Support Services\nSDP: Service Delivery Platform\nSecPAl: Security Policy Assertion Language\nSLA: Service Level Agreement\nSMC: Self-Managed Cell\nSOA: Service Oriented Architecture\nSOI: Service Oriented Infrastructure\nSSB: Security Service Bus\nTMF: TeleManagement Forum\nTOGAF: The Open Group Architecture Framework\nUDDI: Universal Description Discovery and Integration\nUDP: User Datagram Protocol\nUML: Unified Modelling Language\nVAS: Value Adding Service\nVHE: Virtual Hosting Environment\nVMS: Virtual Music Store\nVO: Virtual Organisation\nW3C: World Wide Web Consortium\nWS: Web Service\nWS-A: WS Addressing\nWS-I: WS Interoperability\nWS-DM: WS Distributed Management\nWSDL: WS Description Language\nWSRR: WebSphere Service Registry and Repository\nXACML: eXtensible Access Control Markup Language\nXML: eXtensible Markup Language\nXSL: eXtensible Stylesheet Language\nXSLT: XSL Transformation\nYAML: YAML Ain't Markup Language\nAppendix\n\n1. Profile description XML schema\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n targetNamespace=\"com.bt.ws-profile\" elementFormDefault=\"qualified\"\n attributeFormDefault=\"unqualified\">\n <xs:element name=\"WS-Profile\" type=\"ws-p:tProfile\">\n <xs:annotation>\n <xs:documentation>Schema for WS-Profile</xs:documentation>\n </xs:annotation>\n </xs:element>\n <xs:element name=\"Constraint\" type=\"ws-p:tConstraint\">\n <xs:annotation>\n <xs:documentation>Schema for WS-Profile</xs:documentation>\n </xs:annotation>\n </xs:element>\n <xs:complexType name=\"tProfile\">\n <xs:annotation>\n <xs:documentation>tProfile is the top level node of a WS-Profile. It contains all the information expressed or required.</xs:documentation>\n </xs:annotation>\n <xs:sequence>\n <xs:element name=\"name\" type=\"xs:string\"/>\n <xs:element name=\"ServiceType\" type=\"ws-p:tServiceType\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n <xs:element name=\"Constraint\" type=\"ws-p:tConstraint\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n <xs:element name=\"CoordinationPlan\" type=\"ws-p:tProfile\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n </xs:sequence>\n <xs:attribute name=\"ID\" type=\"ws-p:tUUID\"/>\n </xs:complexType>\n\n <xs:element name=\"Capability\" type=\"ws-p:tServiceType\"/>\n\n <xs:complexType name=\"tServiceType\">\n <xs:annotation>\n <xs:documentation>tServiceType is the top level of abstraction for an activity in the WS-Profile.</xs:documentation>\n </xs:annotation>\n <xs:complexContent>\n <xs:extension base=\"ws-p:tActivity\">\n <xs:sequence>\n <xs:element name=\"Interface\" type=\"ws-p:tInterface\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n </xs:sequence>\n </xs:extension>\n </xs:complexContent>\n </xs:complexType>\n\n <xs:complexType name=\"tInterface\">\n <xs:annotation>\n <xs:documentation>tInterface may allow to differentiate different parts of the same activity in the WS-Profile. For instance, one activity could have both management and operational interfaces.</xs:documentation>\n </xs:annotation>\n <xs:complexContent>\n <xs:extension base=\"ws-p:tActivity\">\n <xs:sequence>\n <xs:element name=\"Functionality\" type=\"ws-\n```\ntFunctionality may allow to differentiate different functions of the same interface in the WS-Profile. For instance, one interface could allow to manage users and items, these would be two different functionalities.\n\ntOperation links to the concrete operations of a functionality in the WS-Profile. For instance, one user management functionality could have operations about deleted, updating or creating users.\n\ntConstraint allows connecting constraints to the different levels of abstraction in the WS-Profile. For instance, an operation could require another one to called immediately before in order to work.\nTable 15. WS-Profile XML Schema\n\n```xml\n<xs:element name=\"value\" type=\"xs:string\"/>\n<xs:element name=\"Constraint\" type=\"ws-p:tConstraint\"\n minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n <xs:choice>\n <xs:attribute name=\"ID\" type=\"ws-p:tUUID\"/>\n </xs:choice>\n</xs:complexType>\n<xs:complexType name=\"tActivity\">\n <xs:annotation>\n <xs:documentation>T Activity defines an abstract component of the\n Policy.</xs:documentation>\n </xs:annotation>\n <xs:sequence>\n <xs:element name=\"name\" type=\"xs:string\"/>\n <xs:element name=\"Constraint\" type=\"ws-p:tConstraint\"\n minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n </xs:sequence>\n <xs:attribute name=\"IO\" type=\"ws-p:tUUIO\"/>\n</xs:complexType>\n<xs:simpleType name=\"tUUIO\">\n <xs:restriction base=\"xs:string\">\n <xs:pattern value=\"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\"/>\n </xs:restriction>\n</xs:simpleType>\n```\n\n112\n<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:ws-c=\"com.bl.ws-context\" targetNamespace=\"com.bl.ws-context\" elementFormDefault=\"qualified\" attributeFormDefault=\"unqualified\">\n <xs:element name=\"WS-Context\" type=\"ws-c:tContext\">\n <xs:annotation>\n <xs:documentation>Schema for WS-Context</xs:documentation>\n </xs:annotation>\n </xs:element>\n <xs:complexType name=\"tContext\">\n <xs:sequence>\n <xs:element name=\"name\" type=\"xs:string\"/>\n <xs:element name=\"configData\" type=\"ws-c:tConfigData\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n </xs:sequence>\n <xs:attribute name=\"IO\" type=\"ws-c:tUUID\"/>\n </xs:complexType>\n <xs:complexType name=\"tConfigData\">\n <xs:sequence>\n <xs:element name=\"target\" type=\"ws-c:tUUID\"/>\n <xs:element name=\"data\" type=\"ws-c:tUUID\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n <xs:element name=\"misc\" type=\"xs:anyType\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n </xs:sequence>\n <xs:attribute name=\"IO\" type=\"ws-c:tUUID\"/>\n </xs:complexType>\n <xs:simpleType name=\"tUUID\">\n <xs:restriction base=\"xs:string\">\n <xs:pattern value=\"[a-fD-9]{8}-[a-fD-9]{4}-[a-fD-9]{4}-[a-fD-9]{12}\"/>\n </xs:restriction>\n </xs:simpleType>\n</xs:schema>\n\nTable 16. WS-Context XML Schema\n3. Context Selector description XML schema\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\nelementFormDefault=\"qualified\" attributeFormDefault=\"unqualified\">\n <xs:element name=\"WS-ContextSelector\" type=\"ws-cs:tContextSelector\"/>\n <xs:complexType name=\"tContextSelector\">\n <xs:sequence>\n <xs:element name=\"name\" type=\"xs:string\"/>\n <xs:element name=\"profile\" type=\"ws-cs:tUUID\" minOccurs=\"1\" maxOccurs=\"unbounded\"/>\n <xs:element name=\"context\" type=\"ws-cs:tUUID\" minOccurs=\"1\" maxOccurs=\"unbounded\"/>\n <xs:element name=\"internalTarget\" type=\"ws-cs:tUUID\"/>\n <xs:element name=\"upTime\" type=\"ws-cs:tValidity\" minOccurs=\"1\" maxOccurs=\"1\"/>\n <xs:element name=\"configSelector\" type=\"ws-cs:tSelector\" minOccurs=\"1\" maxOccurs=\"unbounded\"/>\n </xs:sequence>\n <xs:attribute name=\"ID\" type=\"ws-cs:tUUID\"/>\n </xs:complexType>\n <xs:complexType name=\"tValidity\">\n <xs:sequence>\n <xs:element name=\"type\" type=\"ws-cs:tPeriod\" minOccurs=\"0\" maxOccurs=\"1\"/>\n <xs:element name=\"when\" type=\"ws-cs:tDateAndLength\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n </xs:sequence>\n <xs:attribute name=\"ID\" type=\"ws-cs:tUUID\"/>\n </xs:complexType>\n <xs:complexType name=\"tPeriod\">\n <xs:restriction base=\"xs:string\">\n <xs:enumeration value=\"always\"/>\n <xs:enumeration value=\"on-request\"/>\n <xs:enumeration value=\"time-frame\"/>\n </xs:restriction>\n </xs:complexType>\n <xs:complexType name=\"tDateAndLength\">\n <xs:sequence>\n <xs:element name=\"startdate\" type=\"xs:dateTime\" maxOccurs=\"1\"/>\n <xs:element name=\"period\" type=\"xs:duration\" maxOccurs=\"1\"/>\n </xs:sequence>\n <xs:attribute name=\"ID\" type=\"ws-cs:tUUID\"/>\n </xs:complexType>\n <xs:complexType name=\"tSelector\">\n <xs:sequence>\n <xs:element name=\"target\" type=\"ws-cs:tUUID\"/>\n <xs:element name=\"data\" type=\"xs:string\"/>\n <xs:element name=\"operation\" type=\"ws-cs:tOperation\"/>\n </xs:sequence>\n <xs:attribute name=\"ID\" type=\"ws-cs:tUUID\"/>\n </xs:complexType>\n <xs:complexType name=\"tOperation\">\n <xs:restriction base=\"xs:string\">\n <xs:enumeration value=\"request\"/>\n <xs:enumeration value=\"response\"/>\n <xs:enumeration value=\"both\"/>\n </xs:restriction>\n </xs:complexType>\n</xs:schema>\n```\n<xs:schema>\n <xs:restriction base=\"xs:string\">\n <xs:pattern value=\"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\"/>\n </xs:restriction>\n</xs:schema>\n\nTable 17. WS-ContextSelector XML Schema\n4. Publications\n\nBook chapter\n\n\nRefereed journal articles\n\n\nRefereed conference publications\n\n\n[6] de Leusse, P. and Brossard, D., Distributed systems security governance, a SOA based approach, Third IFIP International Conference on Trust Management, Springer, June 15-19, 2009, Purdue University, West Lafayette, USA\n\n\nNon-Refereed Publications"}}},{"rowIdx":257,"cells":{"id":{"kind":"string","value":"08430f00ff3a1f4e5bf66805c36c9dc6f851dfa3"},"text":{"kind":"string","value":"A LOGIC-BASED METHODOLOGY FOR BUSINESS PROCESS ANALYSIS AND DESIGN: LINKING BUSINESS POLICIES TO WORKFLOW MODELS\n\nby\n\nHarry Jiannan Wang\n\nCopyright © Harry Jiannan Wang 2006\n\nA Dissertation Submitted to the Faculty of the\n\nCOMMITTEE ON BUSINESS ADMINISTRATION\n\nIn Partial Fulfillment of the Requirements\nFor the Degree of\n\nDOCTOR OF PHILOSOPHY\nWITH A MAJOR IN MANAGEMENT\n\nIn the Graduate College\n\nTHE UNIVERSITY OF ARIZONA\n\n2006\nAs members of the Dissertation Committee, we certify that we have read the dissertation prepared by Harry Jiannan Wang entitled A Logic-Based Methodology for Business Process Analysis and Design: Linking Business Policies to Workflow Models and recommend that it be accepted as fulfilling the dissertation requirement for the Degree of Doctor of Philosophy.\n\nJ. Leon Zhao \nDate: 7/25/2006\n\nJay F. Nunamaker \nDate: 7/25/2006\n\nMohan Tanniru \nDate: 7/25/2006\n\nFinal approval and acceptance of this dissertation is contingent upon the candidate’s submission of the final copies of the dissertation to the Graduate College.\n\nI hereby certify that I have read this dissertation prepared under my direction and recommend that it be accepted as fulfilling the dissertation requirement.\n\nDissertation Director: J. Leon Zhao \nDate: 7/25/2006\nSTATEMENT BY AUTHOR\n\nThis dissertation has been submitted in partial fulfillment of requirements for an advanced degree at The University of Arizona and is deposited in the University Library to be made available to borrowers under rules of the Library.\n\nBrief quotations from this dissertation are allowable without special permission, provided that accurate acknowledgment of source is made. Requests for permission for extended quotation from or reproduction of this manuscript in whole or in part may be granted by the copyright holder.\n\nSIGNED: _____Harry Jiannan Wang_____\n\nACKNOWLEDGEMENTS\n\nMy thanks and great appreciation first go to my advisor Professor J. Leon Zhao for his guidance, encouragement, patience and kindness over the years. He literally brought me into this academic world, taught me how to be a researcher, helped me reach my full potential, and kept me going when I wanted to give up. I always think I am blessed to have him as my advisor and I do not believe I can finish my PhD without him. Thank you, Dr. Zhao. Thank you for everything.\n\nI am also grateful to my other dissertation committee members, Professor Jay F. Nunamaker and Professor Mohan Tanniru, for their valuable suggestions and feedback on my research and continuous support during my doctoral program.\n\nI must also thank all my friends for always being there for me, sharing their experiences, and offering me their help. In particular, I would like to thank Alan Wang, Lizhi Yang, Jason Li, Wei Chang, Ying Liu, Ming Lin, Aaron Sun, who made these five years much easier and more colorful.\nDEDICATION\n\nThis dissertation is dedicated\n\nto my wife, Chen Fang,\nfor always being by my side, and\n\nto my father, Jiachun Wang, my mother, Xiugui Li, and my sister, Yunshu Wang,\nfor their love and support.\n# TABLE OF CONTENTS\n\nLIST OF FIGURES .................................................................................................................. 8\n\nLIST OF TABLES .................................................................................................................... 10\n\nABSTRACT ................................................................................................................................. 12\n\n1. INTRODUCTION .................................................................................................................. 14\n\n2. LITERATURE REVIEW ........................................................................................................ 19\n 2.1 WORKFLOW DEVELOPMENT METHODOLOGY .......................................................... 19\n 2.2 PROCESS DESIGN .......................................................................................................... 21\n 2.3 PROCESS MODELING AND ANALYSIS ....................................................................... 23\n 2.3.1 Control Flow Modeling and Analysis ...................................................................... 24\n 2.3.2 Organization and Data flow Modeling ...................................................................... 27\n 2.3.3 Workflow Authorization Constraints ....................................................................... 29\n 2.4 PROCESS MODELING FOR E-BUSINESS ....................................................................... 32\n 2.5 PROCESS CHANGE AND ADAPTIVE WORKFLOW ....................................................... 36\n\n3. A POLICY PERSPECTIVE ON PROCESS ANALYSIS AND DESIGN .................................. 39\n 3.1 THE POLICY MISMATCH PROBLEM IN BUSINESS PROCESS MANAGEMENT .......... 41\n 3.2 A CASE STUDY OF BUSINESS POLICIES .................................................................... 42\n 3.3 PROCESS POLICY TAXONOMY .................................................................................... 45\n\n4. POLICY-DRIVEN PROCESS DESIGN ................................................................................. 51\n 4.1 POLICY-DRIVEN PROCESS DESIGN PROCEDURE ....................................................... 51\n 4.2 PROCESS POLICY TEMPLATE AND PROCESS MAP CONCEPTS ..................................... 53\n 4.3 PROCESS MODEL EXTRACTION PROCEDURE ............................................................. 57\n 4.4 VALIDATION OF POLICY-DRIVEN PROCESS DESIGN ................................................ 64\n 4.5 ARCHITECTURE OF PPD Prototype System ................................................................. 72\n5. A UNIFIED PREDICATE LANGUAGE ......................................................... 79\n 5.1 LANGUAGE DEFINITION ........................................................................ 79\n 5.2 PROCESS DESIGN VIA UPL ................................................................. 85\n 5.3 COMPARISON WITH OTHER LANGUAGES .......................................... 94\n\n6. PROCESS CHANGE ANALYSIS .......................................................... 97\n 6.1 A PROCUREMENT APPROVAL PROCESS .......................................... 98\n 6.2 PROCESS CHANGE TYPES AND RELATIONSHIP ............................. 103\n 6.3 PROCESS CONSTRAINT ANOMALIES ................................................. 106\n 6.4 PROCESS CONSTRAINT VERIFICATION ............................................. 109\n 6.5 VALIDATION OF THE CONSTRAINT VERIFICATION METHOD ........... 115\n 6.6 DESIGN OF A PROCESS CHANGE ANALYSIS TOOL ...................... 118\n\n7. CONCLUSIONS .................................................................................. 121\n\nREFERENCES ........................................................................................... 125\nLIST OF FIGURES\n\nFigure 1. Three process design approaches ................................................................. 16\nFigure 2. Routing constructs in UML ......................................................................... 25\nFigure 3. An example of corporate policies................................................................. 39\nFigure 4. Screenshot of an online business policy manual .......................................... 40\nFigure 5. The policy mismatch problem in business process management ................. 41\nFigure 6. Screenshot of travel policy section in an online manual ............................... 42\nFigure 7. Process policy taxonomy ........................................................................... 45\nFigure 8. Preliminary travel reimbursement process based on control flow policies ...... 48\nFigure 9. Policy-driven process design procedure ..................................................... 52\nFigure 10. Detailed process map extraction procedure .............................................. 57\nFigure 11. Task view example ................................................................................ 59\nFigure 12. Data view example .................................................................................. 61\nFigure 13. Draft process map based on the task sequences ....................................... 66\nFigure 14. Enhanced process map based on data view ............................................. 68\nFigure 15. Revised process map based on PMRules ............................................... 69\nFigure 16. Process map after removing semantic errors ......................................... 70\nFigure 17. System architecture of PPD tool ............................................................... 73\nFigure 18. Screenshot of policy wizard .................................................................... 73\nFigure 19. Entity relationship diagram for process policy ....................................... 74\nFigure 20. Screenshot of visual editor ...................................................................... 75\nFigure 21. Process policy representation stack ....................................................... 76\nFigure 22. Procedure for process design via UPL .................................................... 86\nLIST OF FIGURES - Continued\n\nFigure 23. Draft control flow diagram based on process policies analysis ...................... 89\nFigure 24. Control flow of travel reimbursement process ................................................ 93\nFigure 25. Procurement process in UML.......................................................................... 98\nFigure 26. Organization model for the procurement process ........................................... 100\nFigure 27. Change relationships among process components ........................................... 104\nFigure 28. Redesigned procurement process ................................................................. 116\nFigure 29. Remodeled organization structure................................................................... 117\nFigure 30. Constraint verification algorithm implemented using Jess ......................... 119\nLIST OF TABLES\n\nTable 1. Algorithm for drafting process map based on task view .............................. 58\nTable 2. Algorithm for process map enhancement based on data view ...................... 60\nTable 3. Identified process policies from a business policy manual ............................ 64\nTable 4. Formalized travel reimbursement process policies ....................................... 65\nTable 5. Data view of travel reimbursement process ................................................... 67\nTable 6. Process matrix for travel reimbursement process design .............................. 72\nTable 7. Database schema for a policy base ................................................................. 74\nTable 8. Process policies represented in RuleML ......................................................... 77\nTable 9. Control flow predicates .................................................................................. 80\nTable 10. Organization modeling predicates ............................................................... 81\nTable 11. Data flow predicates .................................................................................... 82\nTable 12. Auxiliary functions ..................................................................................... 83\nTable 13. Built-in UPL rules ....................................................................................... 84\nTable 14. Travel reimbursement policies ................................................................. 86\nTable 15. Identified process elements from process policies ...................................... 87\nTable 16. Data dependency rules ............................................................................... 88\nTable 17. Data inputs and outputs .............................................................................. 88\nTable 18. Partial control flow information .................................................................. 89\nTable 19. Algorithm for syntactical verification of control flows ............................... 92\nTable 20. Identified design problems ......................................................................... 92\nTable 21. Complete control flow information ......................................................... 92\nTable 22. Constraints for routing constructs ................................................................. 94\nTable 23. Comparisons of three process modeling and analysis approaches ............... 96\nTable 24. Descriptions of tasks in procurement process ............................................. 99\nTable 25. Control flow of procurement process .......................................................... 99\nTable 26. Data items in procurement process ............................................................. 100\nTable 27. Organization structure in UPL ................................................................. 100\nTable 28. Constraints of requisition approval process .............................................. 101\nTable 29. Process Constraints in UPL .................................................................... 102\nTable 30. Classification of process changes .............................................................. 103\nTable 31. Algorithm for process constraint verification ........................................... 114\nTable 32. Changes in the procurement process ....................................................... 115\nTable 33. Redesigned procurement process in UPL ................................................. 116\nTable 34. New organization structure in UPL .......................................................... 117\nABSTRACT\n\nToday, organizations often need to modify their business processes to cope with changes in the environment, such as mergers/acquisitions, new government regulations, and new customer demand. Most organizations also have a set of business policies defining the way they conduct their business. Although there has been extensive research on process analysis and design, how to systematically extract workflow models from business policies has not been studied, resulting in a missing link between the specification of business policies and the modeling of business processes.\n\nGiven that process changes are often determined by executives and managers at the policy level, the aforementioned missing link often leads to inefficient and inaccurate implementation of process changes by business analysts and process designers. We refer to this problem as the policy mismatch problem in business process management. For organizations with large-scale business processes and a large number of business policies, solving the policy mismatch problem is very difficult and challenging.\n\nIn this dissertation, we attempt to provide a formal link between business policies and workflow models by proposing a logic-based methodology for process analysis and design. In particular, we first propose a Policy-driven Process Design (PPD) methodology to formalize the procedure of extracting workflow models from business policies. In PPD, narrative process policies are parsed into precise information on various workflow components, and a set of process design rules and algorithms are applied to generate workflow models from that information.\n\nWe also develop a logic-based process modeling language named Unified Predicate\nLanguage (UPL). UPL is able to represent all workflow components in a single logic format and provides analytical capability via logic inference and query. We demonstrate UPL’s expressive power and analytical ability by applying it to process design and process change analysis. In particular, we use UPL to define and classify process change anomalies and develop algorithms to verify and enforce process consistency.\n\nThe Policy-driven Process Design, Unified Predicate Language, and process change analysis approach found in this dissertation contribute to business process management research by providing a formal methodology for resolving the policy mismatch problem.\n\n**Keywords**: process analysis, process design, process modeling, policy management, predicate logic, workflow management systems\n1. INTRODUCTION\n\nBusiness policies enable the efficient management of an organization by defining the standard procedures for its daily business operations (Peltier 2004). Recently, many organizations are investing a great amount to revamp their business policies in order to comply with new government regulations and quality assurance standards such as Sarbanes-Oxley and ISO9001 (Cobb 2004). For organizations with large-scale business processes, maintaining those processes to meet the changing policies is a non-trivial problem. Therefore, there is an imperative need for a more advanced process analysis and design methodology that can formally link business policies with workflow models to manage their consistency and compatibility in an effective and efficient manner.\n\nProcess analysis and design received much attention as a major technique used in business process reengineering initiatives during the 1990s (Hammer et al. 1993). Many process analysis and design projects have successfully enabled organizations to view their business system graphically at any level of detail and complexity and helped them achieve higher level cross-functional collaborations and tangible cost reduction (Madison 2005). However, traditional process analysis and design methods have taken a participative approach which can be resource-intensive and time-consuming, involving extensive meetings, workshops, and interviews to collect data on business processes (Hunt 1996; Reijers et al. 2003). Different from the participative approach, an analytical approach aims to derive and analyze workflow models by applying formal theories and algorithms (Aldowaisan et al. 1999; Datta 1998; Hofacker et al. 2001; Reijers et al. 2003;\nvan der Aalst 2000a). However, very few analytical approaches have been implemented in real process analysis and design projects due to their restricted assumptions and steep learning curve (Wang et al. 2005). Furthermore, none of the existing process analysis and design methods explicitly investigate the relationship between business policies and workflow models, resulting in a missing link between the specification of business policies and the modeling of business processes.\n\nIn this dissertation, we propose an innovative process analysis and design procedure that leverages detailed business policies to build workflow models, which we refer to as Policy-driven Process Design (PPD). In PPD, narrative process policies are first formalized into precise information on different workflow components, such as control flow, data flow, organizational model, and process constraints. Then, a set of process design rules and algorithms are developed to systematically extract workflow models from those formalized process policies. As shown in Figure 1, PPD advocates a new way of discovering processes different from participative and analytical approaches (Cobb 2004; Datta 1998; Hunt 1996; Madison 2005; Reijers et al. 2003; Weske et al. 1999). Specifically, PPD minimizes the time-consuming and ambiguous data collection used in participative approaches by systematically analyzing existing business policies to extract useful process information. It is also more pragmatic than analytical approaches because it provides detailed instructions on process extraction procedure via intuitive design rules and algorithms. Furthermore, PPD builds the formal linkage between business policies and workflow models, which facilitates process change propagation from high-level organizational policies to low-level operational processes and enables systematic,\nefficient and accurate policy-process compatibility maintenance.\n\nWe demonstrate the feasibility of Policy-driven Process Design methodology by designing and developing two process design tools, namely, Policy Wizard and Visual Editor. In particular, policy wizard are implemented as a set of dynamic webpages based on PPD rules and algorithms. Policy wizard provides step-by-step instructions to help process designers parse narrative business policies into precise information on different process components. The visual editor can visualize control flow as a directed graph and assist process designers to identify potential process design errors.\n\n\n\n**Figure 1. Three process design approaches**\n\nIn today’s dynamic business environment, companies need to modify their business processes in response to new customer demand and market opportunities. Without proper analysis and management, dynamic process changes can lead to costly runtime workflow errors. For instance, mergers/acquisitions may result in removing organizational roles. Then, the tasks assigned to those roles must be delegated to other resources, otherwise a runtime role resolution error will occur and the tasks will never be executed. Given that a\nworkflow model consists of four major components, namely, control flow, data flow, organizational model, and process constraints, changes in one component may have significant impact on other components (Basu et al. 2000; Wang et al. 2004). Although many process modeling languages have been proposed, such as UML (OMG 2003), Petri nets (Adam et al. 1998; van der Aalst 1998), and Metagraphs (Basu et al. 2000; Basu et al. 2003), different workflow components are usually modeled in different notations, which makes the change analysis among those components very difficult. As well as being a new process design methodology, our proposed Policy-driven Process Design also provides a unified policy view of different workflow components, which leads us to the development of a logic-based process modeling language named Unified Predicate Language (UPL).\n\nUPL is grounded in predicate logic and consists of a set of predicates, functions, and rules. UPL is expressive yet simple enough to represent different workflow components in a single logical format, and it also has rich analytical capabilities based on logic inferences and queries. We demonstrate the power of UPL by applying it in process design and process change analysis. In particular, UPL is able to provide control flow design insights by reasoning about data flow and verify process design syntactical correctness by conducting logic queries.\n\nThen, we investigate process changes and classify them into three basic operations on different workflow components, namely, insertion, deletion, and update. After discussing different types of process change relationships, we study how changes in control flow and organizational model can affect process constraints. We use UPL to formally define four process constraint change anomalies, i.e., missing constraint, redundant constraint, invalid\nconstraint, and conflicting constraint. We prove that a set of process constraints is consistent if those four process constraint anomalies do not exist. An algorithm is developed to verify and enforce process constraint consistency. A Java-based rule engine named Jess is used to provide the running environment for logic-based process change analysis. In particular, Unified Predicate Language is mapped into the Jess language and the constraint verification algorithm is implemented as Jess programs. UPL is also compared with two other well-know process modeling languages: Petri nets and Metagraphs. The comparison result shows that UPL has several advantages over Petri nets and Metagraphs, especially in unified process modeling and capability in process design and change analysis.\n\nThe rest of the dissertation proceeds as follows. We first review the related literature in Section 2. Then we present a new policy perspective on process design and analysis in Section 3. We show that rich information on process models can be found in business policies, and workflow models can be retrieved from those policies with the help of a process policy taxonomy. In Section 4, we discuss our innovative policy-driven process design methodology. The Unified Predicate Language is defined and applied in process design in Section 5, and process change analysis is conducted in Section 6. We conclude this dissertation in Section 7 by highlighting our contributions and outlining a future research plan.\n2. LITERATURE REVIEW\n\nIn this section, we review related literature in three major research areas in business process management: workflow development methodology, process modeling and analysis, and adaptive workflow.\n\n2.1 Workflow Development Methodology\n\nAlthough workflow management systems have been deployed in many organizations, most workflow development projects are still conducted on an ad hoc basis resulting in inefficient and low quality process design and workflow applications. Several workflow development methodologies and reference models have been proposed to provide guidelines to process analysts and designers. A workflow-aware information system development methodology named WISDM was presented in (Kwan et al. 1998). Five key phases in workflow development are identified, namely, study phase, analysis phase, design phase, coding, testing and documentation phase, and implementation and evaluation phase. A set of process modeling techniques, such as data flow diagram, entity relationship diagram, IDEF3, PERT, and flow chart, are compared in terms of their capabilities to model different perspectives of workflow model. Another reference model for workflow application development processes is discussed in (Weske et al. 1999). Compared with WISDM, this model provides more details on each step of a workflow development process. For instance, for the survey phase, the authors includes detailed information on various activities that should be conducted, such as interviews, group\nmeetings, organization structure analysis, and review meetings, etc. Several case studies are also presented to illustrate the reference model.\n\nBajaj and Sudha (2002) proposed a State-Entity-Activity-Model (SEAM) workflow development methodology (Bajaj et al. 2002). SEAM emphasizes on providing a single view of different aspects of workflow model including data, control flow and organization by defining a set of workflow modeling constructs and schemes. SEAM is also capable to map the conceptual workflow model into relational database systems to facilitate workflow application development. ARIS (Architecture of Integrated Information Systems) is another well-known process development methodology (Scheer 2000a). It offers a framework to completely describe business processes, integrates the most suitable methods for process modeling, and provides reference models as tools for administrating workflow applications (Scheer 2000b). ARIS has been widely adopted by industry practitioners and has been incorporated in several commercial product offerings from companies like SAP and IDS Scheer.\n\nDifferent from the approaches aforementioned, we study workflow development from a unique policy perspective, where different process components, such as control flow, data flow, organizational model, and constraints are represented as a set of process policies and workflow models can be constructed by systematically analyzing those policies. We will illustrate that this policy-driven process development methodology can greatly improve the efficiency of process design and reduce development cost. In addition, although analyzing and designing AS-IS process model is identified as a major step in all methodologies aforementioned, the procedure is only discussed at a very high level and\ntends to be ad hoc. The our proposed methodology fills this void in workflow development methodology research by providing detailed and systematic guidelines for extracting workflow models from business policies.\n\n2.2 Process Design\n\nSince early 90s, Business Process Reengineering (BPR) has attracted much attention in both industry and academia. As a critical stage of BPR, identifying and analyzing existing organizational processes is the foundation for any further process changes and improvements (Hammer et al. 1993; Kettinger et al. 1997). The goal of process design projects is to help organizations identify, understand, and improve their AS-IS processes by applying process mapping methodologies and related tools (Hunt 1996). Most process design projects are mainly conducted in a participative manner, where process information is obtained via extensive interviews, meetings, and workshops (Cobb 2004; Kettinger et al. 1997; Madison 2005). Although participative process mapping projects can collect the most detailed process information, they tend to be time-consuming and resource-intensive. Moreover, due to their subjective nature and incorporation of different user opinions, the collected data usually contains ambiguous, uncertain, and conflicting information, which makes process model extractions from those data very difficult (Reijers et al. 2003).\n\nComputer-Aided techniques for structured documentation and analysis of information systems have been proposed to improve manual documentation (Nunamaker 1971; Teichroew et al. 1977; Teichroew et al. 1979). In particular, PSL (Problem\nStatement Language)/PSA (Problem Statement Analyzer) approach has been developed to express system requirements in an unambiguous machine-processable form, which can be checked for correctness and consistency by computers (Teichroew 1970). PSL is designed with precise syntax and semantics and system requirements are represented as objects and their relationships using predefined object and relationship names. Once system statement is specified in PSL format, PSA can performs numerous checks and analyses and generates warnings, diagnostics, and reports (Teichroew et al. 1979). However, due to a series of problems including high license fee, restricted documentations in public domain, and obsolete technologies, PSL/PSA is not widely adopted nowadays (www.pslpsa.com).\n\nDifferent from participative approaches, an analytical process design approach aims to derive process model by using formal theories and techniques. Various formal methods such as linear programming (Aldowaisan et al. 1999), cost optimization (van der Aalst 2000a), computational experiments (Hofacker et al. 2001), probability theory (Datta 1998) have been applied to analytical process design and redesign. Reijers et al. (2003) proposed a product-based workflow design (PBWD) method. PBWD takes the structure and characteristics of information intensive products, such as bill of material and insurance plan, as the major workflow design inputs and derives a favorable design of the process based on the analysis of data dependency, task execution sequences, product rules, and three process design criteria, namely, quality, costs and time. Another workflow design method based on data flow analysis is presented in (Sun et al. 2004a). Intuitively, if a task $t_1$ outputs some data items that are inputs for a task $t_2$, then $t_1$ should be executed...\nand if there are no data dependencies among two tasks, they can be executed in parallel without creating any data flow errors. Although analytical process design approaches provide theoretical foundation for the development of advanced process analysis tools, the learning curve for those methods are very steep due to their mathematical nature resulting in very few implementations in real process design projects.\n\nIn this dissertation, we propose a policy-driven process design, which incorporates features from both participative and analytical approaches and tries to minimize their drawbacks by leveraging systematic process policy analysis. In addition, none of the existing approaches aforementioned explicitly leverages business policies in the process design procedure, which often leads to the incompatibility between organizational policies and process models. Our approach builds the formal linkage between business policies and processes, which makes policy-process compatibility maintenance more systematic, efficient and accurate.\n\n2.3 Process Modeling and Analysis\n\nA business process is defined as “a set of one or more linked procedures or activities which collectively realize a business objective or policy goal, normally within the context of an organizational structure defining functional roles and relationships” by Workflow Management Coalition (WfMC 1999b). Aligned with WfMC’s business process definition, a process model can be studied from five perspectives, namely, behavioral, informational, organizational, functional, and operational perspectives (Curtis et al. 1992;\nJablonski et al. 1996; Stohr et al. 2001). The behavioral perspective specifies the relationships among tasks, agents, roles and data. Specifically, it defines the execution order of tasks such as sequence, parallelism, split, and iteration, which is often referred to as control flow. In addition, constraints or rules are defined to specify how agents are associated with roles, how roles are assigned to tasks, and what data are related to each task. The informational perspective describes data and information that are consumed, produced and transferred by tasks. The organizational perspective defines the organizational hierarchy of users, roles, and organization units. The functional perspective describes functions and outcomes accomplished by activities and the operational perspective focuses on tools and applications that carry out the execution of tasks in a process model.\n\nBecause functional and operational perspectives emphasize more on the implementation and system, most existing research on process modeling and analysis focus on the behavioral, informational, and organizational perspectives (Basu et al. 2002). Specifically, control flow, data flow, organizational model, and process constraints are the key components of a process model, which have been extensively studied in the literature as we discuss next.\n\n2.3.1 Control Flow Modeling and Analysis\n\nThe structural aspect of business process modeling is captured by control flow (Stohr et al. 2001). Control flow usually specifies tasks, their execution sequences, and various routing conditions (WfMC 1999b). There has been extensive research effort on control\nflow modeling, resulting in many process modeling methods, such as Unified Modeling Language (UML) (OMG 2003), Petri Nets (Murata 1989; van der Aalst 1998), Metagraphs (Basu et al. 1999; Basu et al. 2000; Basu et al. 2003), and logic-based languages (Davulcu et al. 1998). The activity diagram in UML is one of the mostly adopted business process modeling standards. In terms of control flow, it supports five basic routing constructs as shown in Figure 2 (WfMC 1999b).\n\nSequence means that tasks are executed sequentially if the execution of one task is followed by the next task as shown in Figure 2(a). Fork and Join are used to model parallel task execution. In Figure 2(b), after the execution of t₁, t₂ and t₃ are activated at the same time. In Figure 2(c), only after both t₁ and t₂ complete execution, t₃ can be triggered. Branch and Merge are used to model conditional routing. In Figure 2(d), after t₁, either t₂ or t₃ but not both are executed. In Figure 2(e), any one of t₁ and t₂ finishes execution, t₃ is executed. These five basic routing constructs can model most common business processes, whereas more thorough and complicated study on control flow\nstructure can be found in research about workflow patterns (van der Aalst et al. 2003b). However, activity diagram lacks of rigorous mathematical foundation and therefore has little analytical capability.\n\nAs a graphical and mathematical modeling tool, Petri nets have been used to represent and analyze process models (Adam et al. 1998; Murata 1989; van der Aalst 1998). A Petri net consists of three main components: transition, place, and directed arc. Transitions represent activities or tasks; places specify different routing conditions, and directed arcs are execution path linking transitions and places. In addition, places can hold tokens, which represent the states of workflow execution. The main advantages of Petri nets formalism include a formal theory base, a token-based representation of workflow states, and its rigorous analysis and verification tools. Metagraphs are another rigorous process modeling tool with a mathematical foundation and strong analytical capability. Metagraphs provide three different views of a process model, namely, task view, data view and resources view. The interactions among those three views can be analyzed via matrix computations (Basu et al. 1995; Basu et al. 1999; Basu et al. 2000; Basu et al. 2003). Various logic formalisms have also been applied to process modeling and analysis, such as temporal logic, event algebra, and concurrent transaction logic (Davulcu et al. 1998; Mukherjee et al. 2003). One unique feature of logic-based approaches is the capability to model and enforce various constraints on task dependency and execution orders.\n\nIn this dissertation, we propose a process modeling language based on predicate logic. Our language leverages concepts in UML to model basic control flow structure, which\nmake it succinct yet expressive. We also incorporate research in logic-based workflow modeling to conduct process analysis via logic inference and queries. More details on our proposed language will be discussed in Section 4.\n\n2.3.2 Organization and Data flow Modeling\n\nOrganizational modeling in workflow has been identified as an important research area in business process management, which provides the organizational context of workflow application (Basu et al. 2002). An organizational model represents the organization structure and related business rules, where organization structure is usually specified in the form of role hierarchy and business rules are translated into process constraints. Role-based access control model is proposed to simplify management of authorization and provide greater flexibility in specifying and enforcing security policies (Ferralolo et al. 2001; Sandhu et al. 1996). Roles represent business functions in a given organization, such as CEO, purchasing manager, buyer, etc. Authorizations to execute tasks are granted to roles rather than individual users. Moreover, roles are usually structured into role hierarchies to reflect organization’s lines of authority and responsibility (Sandhu et al. 1996). Organizations also have policies in place defining what tasks can be executed by which users. More sophisticated security policies such as separation of duties, binding of duties are also specified to maintain process integrity. Although organizational modeling is very important for proper workflow execution, most existing workflow management systems focus on control flow modeling and oversimplify the organizational dimension (Basu et al. 2002).\nSeveral organizational meta models have been proposed to make workflow management systems more “organizational aware” (Basu et al. 2002). A reference organization model has been issued by Workflow Management Coalition, which defines a list of workflow participants and their relationship (WfMC 1999a). In particular, four types of workflow participants are identified, namely, human (user), role, organization unit, and resource (program or machine agent). A more complicated organization model is presented in (van der Aalst et al. 2003a), which includes additional features like availability of resources, delegation and role inheritance. Their organization model is specified in UML and then converted into an XML DTD, which is used by eXchangeable Routing Language (XRL) to exchange organization information in cross-organizational processes (van der Aalst et al. 2003a). Another organization meta-model is proposed as a benchmark to evaluate different workflow management systems (zur Muhlen 1999a). Besides defining workflow participant types and their relationships, another important aspect of organizational modeling is the specification of policies and patterns that define how to assign different workflow participants to various tasks. Some basic assignment and synchronization policies are discussed in (zur Muhlen 1999b; zur Muhlen 2004). As we will show in section 4, we leverage the research in organizational modeling to design organizational predicates in our proposed logic-based language for process analysis and design.\n\nThe modeling, specification, and validation of data flow in workflow system is also an importation research area, because potential data flow problems may prevent the process from proper execution if not detected prior to workflow deployment (Sadiq et al. 2004; Sun\net al. 2004b). Specifically, seven data validation problems are identified as redundant data, lost data, missing data, mismatched data, inconsistent data, misdirected data, and insufficient data (Sadiq et al. 2004). A set of validation algorithms are designed to identify those data flow anomalies (Sun et al. 2004b). Recent research on workflow data patterns aims to capture the various ways in which data is represented and utilized in workflow (Russell et al. 2005). For instance, there are basically two data allocation mechanisms, namely, push and pull (Russell et al. 2005; zur Muhlen 2004). In the push approach, the business process management system allocates the work items to workers. In contrast, in the pull approach, the workers can take the initiative to allocate or start a work item once it is made available by the system. Analysis on data dependency can also facilitate process design by validate the correctness of activity sequencing (Reijers et al. 2003; Sun et al. 2004a). We leverage the concepts and techniques developed in data flow research to design data predicates in our proposed language as discussed later in section 4.\n\n2.3.3 Workflow Authorization Constraints\n\nAs we discussed in previous sections, process design involves modeling different aspects of business processes, among which workflow security modeling has been identified as an important issue (Basu et al. 2002; Stohr et al. 2001). In particular, the proper execution of processes requires authorization constraints to enforce the assignment of tasks to organizational resources, such as human users, roles, organization units, or machine agents (Casati et al. 2001; Casati et al. 1999). Traditional access control models, such as mandatory and discretionary security model (Atluri et al. 1997), role-based access\ncontrol (Sandhu et al. 1996), task-based access control (Thomas 1997; Thomas et al. 1997), have been applied to workflow management (Wu et al. 2002).\n\nFerraiolo et al. (2001) proposed role-based access control (RBAC) model to simplify management of authorization while providing an opportunity for greater flexibility in specifying and enforcing enterprise-specific security policies. In RBAC model, roles represent business functions in a given organization, such as CEO, purchasing manager, buyer, etc. Authorizations are then granted to roles, rather than users. The authorizations granted to a role are strictly related to the data objects and resources that are needed for executing the functions associated with that role (Ferralolo et al. 2001). RBAC has been a basic access control model supported by most existing workflow management systems. Workflow systems also have more specific authorization requirements that cannot be handled by RBAC. For instance, Task-based Access Control (TBAC) uses tasks as an important parameter for access control and authorization (Thomas 1997; Thomas et al. 1997). It is an active security model that is well suited for information processing activities, where users access data and applications in order to perform certain tasks. TBAC approaches security management from an application perspective rather than from a system-centric subject-object view. In the subject-object paradigm, access decision function checks whether a subject has the required permissions for the operation, but it does not take into account the context of the access. In addition, TBAC paradigm also considers the temporal constraints where access is permitted based on a just-in-time fashion for the activities or tasks in consideration (Thomas et al. 1997). By incorporating these traditional access control models into workflow management, a set of workflow\nauthorization models have been proposed (Atluri et al. 1996a; Atluri et al. 2000; Huang et al. 1998).\n\nWorkflow authorization constraints can be classified into two categories based on their verification time: static vs. dynamic authorization constraints (Bertino et al. 1999; Casati et al. 1998). Static authorization constraints can be evaluated without executing the workflow, while dynamic constraints can only be evaluated during workflow execution because they require the comparison between current and previous states of the workflow (Casati et al. 1998). Many types of workflow authorization constraints have been identified and summarized in (Casati et al. 1998). In particular, separation of duties and binding of duties are two well-known dynamic constraints. Separation of duties constraint is designed to reduce the risk of fraud by limiting any individual’s authority to commit fraud on his own. For instance, an example can be “a purchase request cannot be approved by the same person who submitted it”. Binding of duties constraint aims to improve efficiency by grouping a set of activities and assigning them to the same resource. For example, be that “the same representative who approves a customer’s credit card application should also handle all that customer’s questions if any” is an instance of binding of duties constraint.\n\nDifferent mechanisms have been proposed to specify and enforce workflow authorization constraints. Atluri and Huang (1996) extended Petri nets by proposing a Secure Petri Net (SPN) to specify multi-level security constraints. Then, SPN is used to detect and prevent task dependencies that violate those constraints (Atluri et al. 1996b). Bertino et al. (1999) presented a logic-based framework for the specification and enforcement of workflow authorization constraints. Their work focused on the automatic\nrole and user assignment to tasks without violating any predefined constraints (Bertino et al. 1999). In particular, a constraint specification language is proposed to express both static and dynamic authorization constraints as logic clauses and formal definitions on constraint consistency were provided. They also developed a set of algorithms to verify constraint consistency and generate different plans on valid user-task assignments. Casati et al. (2001) studied workflow authorization constraints using active database technology. Process constraints are described as ECA (event-condition-action) rules based on workflow instance, time, and history (Casati et al. 2001). A set of patterns for ECA rule design is presented in (Casati et al. 2000).\n\nHowever, none of those research efforts has thus far addressed the dynamic change problem of workflow constraints. How process changes in control flow, organizational model, and data flow can affect the consistency of workflow authorization constraints has not been studied in the literature. In this dissertation, our proposed logic-based language borrows ideas from existing logic-based constraint specification languages and extends them to model all basic workflow routing constructs and complex organizational model. In addition, we formally define workflow constraint consistency under various process changes and develop algorithms to verify constraint consistency and detect potential constraint anomalies.\n\n2.4 Process Modeling for E-business\n\nIn order to offer easy integration with a wide range of applications, many companies are investing considerable resources to expose their business operations with web services\ntechnology (Geer 2003). Built on existing and emerging standards such as HTTP, Extensible Markup Language (XML), Simple Object Access Protocol (SOAP), Web Services Description Language (WSDL), and Universal Description, Discovery and Integration (UDDI), web services allow business functions from different companies to be loosely coupled more rapidly and less expensively (Oellermann 2001). Furthermore, a higher business value can be achieved if individual web services in a supply chain can be connected to form composite business processes (Leymann et al. 2002).\n\nAs an open and standards-based approach for web services connectivity, web services orchestration is receiving increasing attention. This standard describes how web services can interact with one another at the message level and defines the business logic and execution order of web services interactions (Peltz 2003). It also assumes that one of the business parties central controls the process, which makes the process management easier. Web services orchestration provides an open, standard-based approach for connecting web services together to create higher-level business processes (Peltz 2003). Standards have been developed to reduce the complexity required to orchestrate web services. Some early work in this standard development includes XLANG from Microsoft and Web Services Flow Language (WSFL) from IBM. Recently, Business Process Execution Language (BPEL) was jointly released by IBM, Microsoft, and BEA as a combination of the best standards for web services composition, such as XLANG and WSFL (Andrews et al. 2003). BPEL is built on top of Web Service Definition Language (WSDL), which is used to describe the entry and exit points of BPEL processes, the external services and the data type of information exchanged between requests (Peltz 2003). BPEL includes support for\nboth basic and structured activities. Basic activities are in charge of receiving or replying to message requests as well as invoking external services, whereas structured activities manage the overall process flow, specifying what activities should run and in what order. BPEL also supports conditional looping and dynamic branching using <switch>, <while>, and <pick> tags. The rich set of elements makes BPEL very expressive in terms of control flow modeling, which has been discussed from workflow pattern perspective in (Wohed et al. 2002). BPEL has received remarkable attention and moved into a number of product implementations, such as IBM’s WebSphere Process Server© and Oracle’s BPEL Process Manager©.\n\nDespite the promise, the absence of security is proving to be a major obstacle in convincing companies to participate in web services orchestration. As such, there have been lots of research efforts in the development of web services security, and several security specifications have been proposed, such as WS-Security, Extensible Access Control Markup Language (XACML), and Security Assertion Markup Language (SAML) (Naedele 2003). WS-Security can ensure that messages are not modified or forged while in transit or while residing at destinations. Extensible Access Control Markup Language (XACML) is an XML based access control policy specification language. It was developed by OASIS under the sponsorship of several major industry vendors, such as IBM, SUN, BEA and Entrust (OASIS 2003). This policy language is used to describe access control requirements in any environments, form a query to ask whether or not a given action should be allowed, and interpret the result. Although web services technology facilitates inter-organizational computing and integration, there has been no standard on how to share\nsecurity information across different security domains. Security Assertion Makeup Language (SAML) is used to communicate the authorization information among different companies (OASIS, 2002). In SAML, the security information exchanged is in the form of an assertion about subjects. There are three types of core assertions defined by SAML, namely, authentication assertion, attribute assertion, and authorization assertion. With these technologies, various authorization mechanisms can be specified and enforced across organization boundaries, which gives companies enough confidence to expose their internal business operations as web services and participate in web services orchestration.\n\nSemantic Web is to provide a common framework for data sharing and reuse across applications, enterprises, and community boundaries. Being a key enabling technology of semantic web, ontology facilitates data sharing by defining the terms and their relationships for a particular domain (W3C 2004). Rule markup language has been a mainstream research topic in semantic web, resulting in several business rule markup languages, such as XRML (Lee et al. 2003) and RuleML (Grosof 2001). In particular, RuleML is based on situated courteous logic, which provides a strong theory foundation and some unique features such as prioritized conflict handling and disciplined procedural attachments (Grosof 2001). Moreover, tools have been developed to map RuleML to prolog and production rules, which enables RuleML to run on most well-known rule-based engines, such as XSB, Jess, and Jena (Grosof et al. 2003). The logic-based process modeling languages discussed in section 2.2.3 cannot be understood and exchanged among e-business partners. Given the features and analytical capability of RuleML, it is a good candidate XML-based representation language for process constraints. As we will discuss\nin section 7, the techniques and standards reviewed in this section provide a set of enabling\ntechnologies for the development of our prototype system.\n\n2.5 Process Change and Adaptive Workflow\n\nBy automating well-defined business processes, workflow management systems have\ndelivered increased productivity, faster cycle time, less errors, and lower operation costs.\nHowever, while workflow applications grow in number and size, organizations are\nrecognizing that in order to release the real power of process automation workflow\nmanagement systems must be able to adapt efficiently and effectively to changes in\nbusiness and the needs of the people (Kammer et al. 2000; Ultimus 2006). As such,\nresearch in dynamic and adaptive workflow has received increasing attention in recent\nyears (Klein et al. 2000b).\n\nWorkflow changes can be made to workflow model or workflow instance (Sadiq et al.\n2000). Workflow instances are particular occurrences of a workflow model. The changes to\nworkflow model are often permanent as the result of process improvement, process\nredesign or reengineering, merger/acquisitions, etc., whereas changes in individual or a\nfew workflow instances are usually due to unforeseen and rare situations in process\noperations (Sadiq et al. 2000). If not properly handled, workflow changes can cause\ninefficiencies, inconsistencies, high runtime costs, or catastrophic enterprise system\nbreakdowns (Ellis et al. 1995).\n\nWhen workflow changes happen, different actions can be taken to handle the changes,\nwhich have different impacts to the existing workflow instances. Sadiq et al (2000) defined\nfive workflow modification policies to cope with workflow changes, namely, Flush, Abort, Migrate, Adapt, and Build. Specifically, in flush situations, all current workflow instances are permitted to complete according to the old process model, while new instances must follow the new model. Active workflow instances may also be aborted, which may incur losses to the organization without compensating for the tasks already accomplished when abortion is executed. Migrate method aims to introduce the changes to running instances without either aborting or flushing. This kind of migration involves thorough analysis of process structure and current process status in order to avoid process errors known as “dynamic change bugs” (van der Aalst 2001). In particular, several mathematical models have been proposed to formally represent workflow dynamic changes and identify “safe” ways to migrate existing instances without incurring dynamic change bugs (Ellis et al. 2000; Reichert et al. 1998; van der Aalst 2001). Furthermore, a set of correctness criteria for dynamic workflow changes has been summarized to help validate process change migration results (Rinderle et al. 2003).\n\nProcess change adaptation means that there are some workflow instances that need to be treated differently due to exceptions. Exceptions are defined as “deviations from an ideal collaborative workflow process caused by errors, failures, resource or requirements changes” (Klein et al. 2000a). Different methods for exception specification and handling have been proposed in the literature, such as knowledge-based approach (Klein et al. 2000a), active rule based approach (Casati et al. 1999), and meta modeling approach (Chiu et al. 1999). The importance of flexibility of workflow systems has also been recognized by industry vendors. For instance, one of the leading BPM software companies Ultimus\nhas incorporated a patented technology named Adaptive Discovery © to enable runtime deviation from pre-defined process model to cope with dynamic process changes (Ultimus 2006).\n\nAlthough there has been noticeable amount of research in process change and adaptive workflow, most research only focus on change analysis of one process aspect, especially on control flow. Research on the change relationship among different process aspects such as control flow, data flow, organizational model and process constraints has been scant. In this dissertation, we investigate how changes in one process aspect can affect other aspects. In particular, we formally define various process constraint change anomalies due to changes in control flow and organizational model, and develop algorithms to automatically detect those anomalies as discussed later in Section 6.\n3. A POLICY PERSPECTIVE ON PROCESS ANALYSIS AND DESIGN\n\nMost organizations have a set of business policies that govern the way they conduct their business, e.g. twelve organization-wide policies are identified in (Peltier 2004), such as Employee Standards of Conduct, Workplace Security, Business Continuity Planning, etc. (Figure 3). Each organization-wide policy may also include many more specific sub-policies. Due to the trend towards e-business, organizations are also digitalizing their business policies and publishing those policies on the Internet for easy access and dissemination (Wang et al. 2005). For instance, Figure 4 shows an online business policy manual. Many of these business policies are used to define business processes often in terms of standard procedures, e.g., procedures for travel reimbursement, procedures for purchasing, procedures for payroll and cash handling, etc.\n\n\nAlthough these process policies are the key elements for efficient running and control of organizations, many organizations do not have their business processes clearly documented, and in some cases their business processes are not documented at all. Lack of process documents may lead to inefficiency, misunderstanding across different functions and, more seriously, business fraud such as the financial scandals of WorldCom and Enron (Bloem et al. 2006). As such, recent government regulations related to Sarbanes-Oxley require organizations to clearly define and document their processes in organizational policies in order to increase internal control and governance (Cobb 2004). Furthermore, organizations are investing a great amount to revamp their business processes in order to be compliant with quality control standards such as ISO9001. As a result, many organizations have volumes of process policies in place.\n\nFigure 4. Screenshot of an online business policy manual\n3.1 The Policy Mismatch Problem in Business Process Management\n\nAs shown in Figure 5, high-level narrative business policies are usually not directly mapped into the field operations, resulting in a missing link between business policies and process models. In today’s dynamic business environment, organizations often need to modify their business processes to cope with ever-changing customer demand and market opportunities. In addition, organizations are investing a great amount to revamp their business policies to comply with recent regulations related to Sarbanes-Oxley. Because of the missing link between business policies and process models, policy changes cannot be efficiently propagated to the operational level. For the same reason, real process operations often deviate from defined policies after several process changes. We refer to this problem as the policy mismatch problem in business process management. As such, for organizations with large-scale business processes, maintaining compatibility between business policies and process models can be a very challenging task. Therefore, a systematic linkage between business policies and process models must\nbe establish to provide solutions.\n\nThe policy aspect of business process has been largely overlooked in the literature, and how to systematically retrieve process information from business policies to build process models has not been studied. Next, we present a case study of a major public university’s business policy manual and show how process information can be identified from those policies by applying a process policy taxonomy.\n\n### 3.2 A Case Study of Business Policies\n\nIn this section, we present a case study of the business policy manual of a major American public university. This business policy manual is published online and is accessible to the public as shown in Figure 6.\n\n**Figure 6. Screenshot of travel policy section in an online manual**\n\nThe policy manual has nineteen sections covering various organizational aspects, such as accounting, finance, information systems, etc. For the case study, we focus on\n“Travel Regulations” section, because travel approval and reimbursement processes are implemented in most organizations and are therefore representative. Furthermore, these processes involve many different scenarios, rules, and constraints, which make the corresponding process model non-trivial.\n\nAs we discussed in the previous section, we are interested in how high-level process polices are linked to operational process models. In this study, we chose travel approval and reimbursement processes as the operational process model. To see how these processes are defined in the policies, we summarize some key sentences and paragraphs from the manual:\n\n- Heads of academic and administrative units authorize travel for their faculty and staff.\n- All claims for the reimbursement of expenses for approved university business travel are made on a Travel Reimbursement Form.\n- There is a list of reimbursable and non-reimbursable expenses.\n- There is detailed information on lodging and meal allowance.\n- The Travel Reimbursement Form must be submitted promptly, preferably within 30 calendar days, but no later than 60 days, after completing the travel.\n- If the Travel Reimbursement Form is not submitted within 60 days of the completion of travel, the reimbursement is considered taxable income to the traveler, unless a reasonable justification for an exception is presented.\n- If a reasonable justification for an exception is not submitted or not approved, the reimbursement amount will be submitted to University Payroll and included on the employee's Form W-2.\n• If the traveler submits a Travel Reimbursement Form for reimbursement more than 60 days after the completion of travel but feels he/she has a reasonable justification for the late submission, the Reasonable Exception Request must be submitted as well.\n\n• The completed and approved Travel Expense Reimbursement Form should be mailed to the Disbursement Services Center.\n\n• After the Travel Expense Reimbursement Form is reviewed for compliance with University/State policies, a check is issued to the traveler in less than 10 working days.\n\n• The Employee must submit a Travel Exception Request Form if the reimbursement request is not compliant with university policies, e.g. total amount exceeds the reimbursement limit.\n\n• Exceptions are not considered without the approval of the department head or delegate.\n\n• The Office of Business and Financial Services reviews and records all exceptions claimed on travel vouchers.\n\n• All exceptions are reported quarterly to the Higher Education Travel Control Board for review. If the exception is denied, the traveler must refund the disallowed amount to the university account charged when the employee was reimbursed.\n\nGiven these narratives policies, we ask the following questions:\n\n• What process information can be identified from these policies?\n\n• What are the types of process policies?\n\n• Can these narrative policies be formalized and systematically analyzed?\n\n• What is the procedure to transform process policies into workflow models?\n- What changes can happen to process policies?\n\n- How can the workflow model be affected by process policy changes?\n\nThe rest of this dissertation will answer these questions. Next, we propose a taxonomy of process policies to help identify process information from business policies.\n\n3.3 Process Policy Taxonomy\n\nBased on the study of several business policy manuals, we discovered that rich information for workflow models can be found in business policies. Given that a workflow model consists of four major components, namely, control flow, data flow, organizational model, and constraints, we classify process policies into four categories corresponding to those components (Basu et al. 2002). Each category is further divided into sub-categories to provide more detailed characteristics on different process policies to facilitate process policy identification. The resulting process policy taxonomy is shown in Figure 7.\n\n\nControl flow policy has three types: task identification policy, task dependency policy, and routing constraint identification policy. For instance, a policy saying “all claims for the reimbursement of travel expenses are made on a Travel Reimbursement Form” is a task identification policy which specifies a task, “Travel Reimbursement Form submission.” Task dependency policy can be used to determine the task execution sequence. For example, a policy stating that “after the Reimbursement Form is approved, a check will be issued” identifies that the task “issue check” should be executed after the task “Reimbursement Form approval”. A policy can be used to identify routing constructs, such as parallel execution or decision points, is a routing construct identification policy. For example, a policy stating that “if reimbursement amount exceeds the limit, a Travel Exception Form must be filled out” specifies a routing condition: the next task is determined by whether or not the reimbursement amount exceeds the limit. Data flow and resource policies are defined similarly.\n\nProcess constraints restrict the execution of processes. In particular, three types are defined: assignment policies, routing constraints, and process rules. Assignment policies specify how each resource is assigned to each task and how different routing constraints are associated with routing constructs. For instance, a sample assignment policy can be “department head must approve the travel” which assigns a role “department head” to execute a task “travel approval.” Routing constraints are defined to decide the execution path when a decision point is met. Normally, policies with an “if then” format indicate routing conditions. Process rule policies define additional constraints that the process execution must follow. Examples of process rules include well-know dynamic\nauthorization constraints, such as separation or binding of duties, temporal constraints, such as “task t must be completed by 5pm on July 25th, 2006”, and exception handling constraints, such as “if the dean will not be able to sign the form within two weeks, the vice dean is authorized to sign on his behalf.”\n\nBy applying the process policy taxonomy to the case presented in the previous section, we identify the following control flow policies:\n\n- **P1**: All claims for reimbursement of expenses for approved university business travel are made on a Travel Reimbursement Form.\n- **P2**: If the Travel Reimbursement Form is submitted more than 60 days after completing the travel, a Reasonable Exception Request Form must be submitted.\n- **P3**: If the Reasonable Exception Request is not approved, then the reimbursement amount will be taxable, showing on employee’s Form W-2.\n- **P4**: If the reimbursement amount exceeds the limit, a Travel Exception Form must be filled out.\n- **P5**: After the reimbursement form is approved, a check will be issued.\n- **P6**: If the quarterly travel exception review is denied, the reimbursed amount must be refunded.\n\nFrom these policies, the following tasks can be identified: \n- **t1** submit Travel Reimbursement Form, \n- **t2** approve travel, \n- **t3** submit Reasonable Exception Form, \n- **t4** review reasonable exception, \n- **t5** make reimbursement taxable, \n- **t6** submit Travel Exception Form, \n- **t7** review Travel Exception Form, \n- **t8** review Travel Reimbursement Form, \n- **t9** issue check, \n- **t10** quarterly review travel exception, \n- **t11** refund back the reimbursement check. In addition, the\nfollowing routing constructs (decision points/branches) are identified: b₁ whether or not the reimbursement form is submitted more than 60 days after completion of travel, b₂ whether or not reasonable exception request is approved, b₃ whether or not the reimbursement amount exceeds the limit and b₄ whether or not the quarterly travel exception review is denied. Furthermore, some sequential execution orders between tasks and decision points are also indicated in the policies. For example, P2 indicates that t₃ is executed after b₁. Based on the control flow policies, a preliminary control flow diagram of the travel reimbursement process can be developed as illustrated in Figure 8.\n\nWe can also extract two data flow policies from the case study as listed below:\n\n- **P7:** There is a list of reimbursable and non-reimbursable expenses (e.g., alcoholic beverages are a non-reimbursable expense).\n- **P8:** There are detailed lodging, meal, and per diem allowances (e.g., the lodging allowance in the Chicago metropolitan area is $149).\n\n\nNote that P7 and P8 are actually two sets of similar data flow policies. These data will be used to review the Reimbursement Form. Some other data items are implicitly identified in the control flow policies, including Travel Expense Reimbursement Form, Reasonable Exception Form, Travel Exception Form, and Check. This also demonstrates that different types of business process policies are not exclusive and can be overlapping in terms of their functionalities.\n\nThe following shows the role-task assignment policies defined in the case policies:\n\n- P9: Department or unit head must approve the travel.\n- P10: Department or unit head must approve the Reasonable Exception Request.\n- P11: Disbursement Services Center (DSC) must review the Reimbursement Form.\n- P12: The Office of Business and Financial Services (OBFS) reviews the Travel Exception Form.\n- P13: The Higher Education Travel Control Board (HETC) reviews the travel exceptions quarterly.\n\nFour organization resources are identified: department head, Disbursement Services Center, Office of Business and Financial Services, and Higher Education Travel Control Board, each of which is assigned to a particular task. In addition, a process rule is also identified, which is a temporal constraint - P14: It is preferred that the Reimbursement Form is submitted with 30 days upon completing the travel. Note that P14 is a “soft” performance policy, which is not always enforced. In contrast, the violation of some mandatory process rules may cause process execution exceptions.\n\nIn summary, the process policy taxonomy presented in this section classifies process\npolicies into control flow policies, data flow policies, resource policies, and constraint policies. This taxonomy is sufficiently inclusive to contain most commonly used process policies and is also concise and extendible. By applying this taxonomy to the case study, we identified 11 tasks, numerous data items, and 14 process policies, which help derive a preliminary process model as shown in Figure 8.\n\nThis case study demonstrates that rich process information can be extracted from narrative business policies to help construct process models. However, those process policies are still not precisely represented and cannot be formally analyzed. The process model extraction procedure is not well defined, and the criteria for a process model to be complete have not been discussed. In the next section, we go one step further in this research direction by formalizing the process extraction procedure.\n4. POLICY-DRIVEN PROCESS DESIGN\n\nIn this section, we propose an innovative process design methodology named Policy-driven Process Design (PPD). PPD takes narrative business policies as process design input and generates process models by formalizing and parsing those policies. One unique feature provided by PPD is the formal linkage between business policies and workflow models, which enables efficient and systematic management of policy-process consistency under various changes. Furthermore, PPD also builds the foundation for policy-based process design automation.\n\nNext, we first present overall PPD procedure, followed by the formalization of process policy. Then, we discuss the process model extraction process, where a set of new concepts are introduced, such as task view, data view, and process design rules. A case study is conducted to validate our policy-driven process design methodology and the architecture of PPD prototype system is also discussed.\n\n4.1 Policy-driven Process Design Procedure\n\nAs shown in Figure 9, PPD consists of four major steps, which are defined as follows:\n\n- Extract process policies. Most organizations have a standard set of policies that govern the way they conduct their business, which we refer to as business policies (Peltier 2004). Among those business policies, some policies are not related to business processes such as workplace security policies, employee standards of\nconduct, etc. The first step for process analysts using PPD approach is to distill process policies from general business policies and express them in a succinct and clear format. This step greatly relies on human intelligence and related training may be needed for better process policy extraction results.\n\n\n\n- Applying process policy template. The process policies identified in step one are narrative sentences. In order to facilitate policy analysis, those process policies need to be formalized using process policy template. In particular, according to the process policy template, process policies are precisely decomposed into information on task, task dependency, task execution order, data items, data dependency, and process constraints. This step is also conducted by process analysis with the assistant of a process parsing tool and all formalized process policies information is stored in\ndatabase for further analysis.\n\n- Execute process extraction procedure. In this step, a set of process design algorithms and rules are applied to the formalized process policies to construct a preliminary process model. For example, identified tasks are first linked based on the execution ordering information extracted from the policies, and then additional links among tasks are added based on the data dependency analysis. Part of this step is automated via a set of algorithms, such as initial control flow generation, task dependency analysis, data flow analysis, process completeness checking, etc. However, revising process model according to design rules and removing potential semantic errors still need human intelligence. A visualization tool is developed to help process analysts better understand and enhance the process model.\n\n- Refine process model. In this step, the preliminary process model is reviewed and refined for completeness and correctness. Additional process data collections may be needed if the process policies cannot provide all necessary information to finalize the process model.\n\nGiven that step one and four are mainly based on human intelligence, we focus our discussion on step two and three, where computer technology can help improve process design efficiency and accuracy. Next, we first present the formalization of process policy and process map.\n\n4.2 Process Policy Template and Process Map Concepts\n\nAs we discussed in section 3, process policies consists of information on control flow,\ndata flow, organizational model, and process constraints. Although those narrative process policies are intuitive and easy for human to understand, they cannot be interpreted by computers until they are formalized into a precise and rigorous format. Similarly, process models also need to be formally defined and represented. In this section, we use process policy template and process map to formalize process policies and process models respectively. First, process policy template is formally defined as follows:\n\n**Definition 1 (Process Policy Template).** Let \\( P \\) be a finite set of process policies, \\( P = \\{p_1, p_2, \\ldots, p_n\\} \\). We define a process policy template \\( p_i \\in P \\) as an 8-tuple: \\( p_i = <\\text{pid}_i, D_i, T_i, C_i, R_i, TSI_i, TR_i, TDi_i> \\), where\n\n- \\( \\text{pid}_i \\) is the process policy ID, which is unique in order to identify a policy:\n \\[\n \\forall p_i, p_j \\in P, i \\neq j, \\text{pid}_i \\neq \\text{pid}_j\n \\]\n- \\( D_i = \\{d_1^i, d_2^i, \\ldots, d_m^i\\} \\) is the set of data items related to \\( p_i \\). \\( D = D_1 \\cap D_2 \\cap \\ldots \\cap D_n \\) represents all data items in all process policies.\n- \\( T_i = \\{t_1^i, t_2^i, \\ldots, t_l^i\\} \\) is the set of tasks related to \\( p_i \\). \\( T = T_1 \\cap T_2 \\cap \\ldots \\cap T_n \\) is the set of all tasks included in all process policies.\n- \\( C_i = \\{c_1^i, c_2^i, \\ldots, c_k^i\\} \\) is the set of constraints related to \\( p_i \\). \\( C = C_1 \\cap C_2 \\cap \\ldots \\cap C_n \\) is the set of all constraints. \\( c_k^i \\) is either an expression or a statement that returns a Boolean value.\n- \\( R_i = \\{r_1^i, r_2^i, \\ldots, r_s^i\\} \\) is the set of resources related to \\( p_i \\). \\( R = R_1 \\cap R_2 \\cap \\ldots \\cap R_n \\) is the set of all resources. \\( r_s^i \\in U \\cap RL \\cap OC \\cap AG \\), where \\( U \\) is set of users, \\( RL \\) is set of\nroles, e.g., general manager, salesperson, accountant, etc., OC is set of organizational units, e.g., bursar’s office, graduate college, etc., and AG is set of machine agents, e.g., accounting system, ERP, etc.\n\n- \\( TS_i = T_i \\times T_i \\times C_i = \\{(t_a^i, t_b^i, c_e^i) : t_a^i \\text{ is executed before } t_b^i \\text{ if } c_e^i \\text{ is true}\\} \\) is the set of task sequences related to \\( p_i \\).\n- \\( TR_i = T_i \\times R_i = \\{(t_i^i, r_k^i) : t_i^i \\text{ is executed by } r_k^i\\} \\) is the set of task resource relationships in \\( p_i \\).\n- \\( TD_i = T_i \\times D_i = \\{(t_i^i, d_m^i) : d_m^i \\text{ is used in } t_i^i\\} \\) is the set of task data relationships in \\( p_i \\).\n\nThe goal of process policy template is to parse narrative process policies into small pieces of precise information on different workflow components. For instance, a travel reimbursement policy: “If Travel Reimbursement Form is submitted later than 60 days upon completing the travel, a Reasonable Exception Request Form must be submitted” can be formalized according to process policy template as follows. Assume the \\( pid \\) for this policy is 1. Then, two data items can be identified: \\( d_{11} = \\text{“Travel Reimbursement Form (TRF)”} \\) and \\( d_{21} = \\text{“Reasonable Exception Request Form (RERF)”} \\). Two tasks can be extracted: \\( t_{11} = \\text{“Submit TRF”} \\) and \\( t_{21} = \\text{“Submit RERF”} \\). There is one constraint: \\( c_{11} = \\text{“TRF submission later than 60 days upon completing the travel”} \\). In summary, this policy can be expressed as \\( p_1 = \\langle 1, \\{d_{11}, d_{21}\\}, \\{t_{11}, t_{21}\\}, \\{c_{11}\\}, \\emptyset, \\{(t_{11}, t_{21}, c_{11})\\}, \\emptyset, \\{( t_{11}, d_{11}),( t_{21}, d_{21})\\} >. \\) Because no resources can be identified by this policy, the corresponding sets are empty. As we will discuss later in the system architecture and prototyping chapter, tools are developed to help process analyst parse process policies according to the template. In particular, the system automatically indexes and records identified workflow\nelements to avoid duplications and support efficient search.\n\nThe result of process design is a process model. To simplify and facilitate policy-driven process design, we introduce the concept of process map, which is a process model defined as a directed graph with some special properties as discussed below (Wilson 1996).\n\n**Definition 2 (Process Map).** Given process policy template \\( p_i = \\langle \\text{pid}_i, D_i, T_i, C_i, R_i, TS_i, TR_i, TD_i \\rangle \\), a process map is defined as a directed graph \\( G = \\langle V_t(G), V_c(G), V_{se}(G), A(G) \\rangle \\), where:\n\n- **task vertex set** \\( V_t(G) = \\{ (v_t, D_t, R_t) : v_t \\in T, D_t \\subset D, R_t \\subset R, D_t \\neq \\emptyset, R_t \\neq \\emptyset \\} \\) is a non-empty finite set of all tasks in the process map and each task is associated with a set of data items \\( D_t \\) and resources \\( R_t \\). \\( d^-(v_t), d^+(v_t) \\geq 1, d^-(v_t) = 1 \\), where \\( d^-(v_t) / d^+(v_t) \\) is \\( v_t \\)'s in-degree/out-degree.\n\n- **decision vertex set** \\( V_c(G) = C \\) is a finite set of all constraints in the process map, and \\( \\forall v_c \\in V_c(G), d^-(v_c) \\geq 1, d^+(v_c) = 2 \\).\n\n- **start/end vertex set** \\( V_{se}(G) = \\{ s, e \\} \\), where \\( s \\) is the start node and \\( e \\) is the end node in the process map, and \\( d^-(s) = 0, d^+(s) = 1, d^-(e) \\geq 1, d^+(s) = 0 \\).\n\n- **directed arc set** \\( A(G) \\) is a non-empty finite set of distinct ordered pairs of distinct elements of vertex set \\( V(G) = V_t(G) \\cup V_c(G) \\cup V_{se}(G) \\).\n\nBesides enabling formal process analysis, Definition 2 also implies some assumptions we make in order to simplify the structure of process maps: 1) tasks are executed sequentially, and task parallelism can be introduced later to improve process\nperformance; 2) each decision vertex has two and only two outgoing arcs, which means that each decision vertex is an exclusive OR and its value is a Boolean value returned by corresponding process constraint. It has been proved that any OR vertex can be converted to exclusive OR vertex (Bi et al. 2004a); 3) a task can have only one outgoing arc and at least one incoming arc; 4) an end node can have more than one incoming arcs. As we will discuss later, a set of rules are developed to ensure that the process map follows the assumptions. Next, we show a systematic procedure to extract process maps from process policies.\n\n4.3 Process Model Extraction Procedure\nFigure 10 shows the procedure to extract a process map from formalized process policies. We propose a set of new concepts to facilitate the extraction procedure, namely, task view, data view, and process design rules. Each step of the procedure is discussed in detail as follows:\n\n**Step 1: Draft process map based on task view.** In this step, the first draft of process map is generated based on the task sequences $TS$ identified from policy analysis. In particular, a task view is first constructed based on $TS$ to simplify the drafting process.\n\n<table>\n<thead>\n<tr>\n<th>Algorithm 1:</th>\n</tr>\n</thead>\n</table>\n| **Input:** initial process map $G = (V_i(G), V_c(G), V_{sc}(G), A(G))$<br>where, $V_i(G) = V_c(G) = V_{sc}(G) = A(G) = \\emptyset$,<br>and task view $TV$, where $T = \\{t_1, t_2, ..., t_n\\}$, $C = \\{c_1, c_2, ..., c_m\\}$<br>**Output:** draft process map $G'$<br>**Begin**<br>$V_{sc}(G) = \\{s, e\\}$ // add start and end node<br>$V_c(G) = C$ // add decision points<br>$V_i(G) = \\{(v_i, D, R_i) : v_i \\in T, D = R_i = \\emptyset\\}$ // add tasks<br>for each $tv_{ij} \\in TV$ // add arcs among tasks and decision points based on task view<br>if $tv_{ij} = 1$ and $i < n, j < n$ then add $(t_i, t_j)$ to $A(G)$<br>if $tv_{ij} = 1$ and $n < i < n + m, j < n$ then add $(c_i, t_j)$ to $A(G)$<br>if $tv_{ij} = 1$ and $i < n, n < j < n + m$ then add $(t_i, c_j)$ to $A(G)$<br>if $tv_{ij} = 1$ and $n < i < n + m, n < j < n + m$ then add $(c_i, c_j)$ to $A(G)$<br>**end for**<br>$G' = (V_i(G), V_c(G), V_{sc}(G), A(G))$<br>**End**\n\nTable 1. Algorithm for drafting process map based on task view\n\n**Definition 3 (Task View).** Given $T = \\{t_1, t_2, ..., t_n\\}$ are identified tasks and $C = \\{c_1, c_2, ..., c_m\\}$ are identified constraints. A task view $TV$ is defined as a $(m+n+1)$-square matrix, whose rows and columns correspond to the set $T \\cup C \\cup \\{s\\}$ and\n$T \\cup C \\cup \\{e\\}$ where $s$ is the start node and $e$ is the end node. $tv_{ij} = 1$ and if the corresponding task, constraints, or start/end nodes are connected, otherwise $tv_{ij} = 0$.\n\nGiven the initial process map $G$, which is an empty graph, and task view $TV$, the following algorithm is used to draft the process map.\n\nBased on the task view, a preliminary process map can be easily drafted. For instance, a $TV$ matrix with three tasks and two constraints is mapped into a draft process map in Figure 11. Normally, task view only provides limited information on process map, and additional enhancements and refinements are needed to complete the process map.\n\n<table>\n<thead>\n<tr>\n<th>TV</th>\n<th>t₁</th>\n<th>t₂</th>\n<th>t₃</th>\n<th>c₁</th>\n<th>c₂</th>\n<th>e</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>t₁</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>t₂</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>t₃</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>c₁</td>\n<td>0</td>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>c₂</td>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>s</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n\nFigure 11. Task view example\n\n**Step 2: Refine the Process Map based on Data View.** In this step the draft process map $G'$ is enhanced based on the identified task data relationship $TD$. A data view is constructed to help this process, which is defined as following:\n\n**Definition 4 (Data View).** Given $T = \\{t₁, t₂,..., tₙ\\}$ are identified tasks, $C = \\{c₁, c₂,..., cₘ\\}$ are identified constraints, and $D = \\{d₁, d₂,..., dₖ\\}$ are identified data items. A data view $DV$ is defined as a $(m+n) \\times k$ matrix whose rows correspond to the set $T \\cup C$, and whose columns correspond to the set $D$. $dv_{ij} = 0$ ($dv_{ij} = 1$) if $d_j$ is the output\n(input) of corresponding task or constraint, otherwise $d_{ij} = 0$.\n\nBased on data view, additional arcs between tasks and decisions can be identified. Intuitively, if a data item $d$ is the output of task $t_1$ and input of $t_2$, then an arc $(t_1, t_2)$ should be added. Formally, the following algorithm is used to refine process map $G'$. Note that the task view is rebuilt based on data view at the end of the algorithm.\n\n**Algorithm 2:**\n\nInput: draft process map $G = \\langle V_t(G), V_c(G), V_{sc}(G), A(G) \\rangle$\n\ndata view $DV$, where $T = \\{t_1, t_2, \\ldots, t_n\\}$, $C = \\{c_1, c_2, \\ldots, c_m\\}$, $D = \\{d_1, d_2, \\ldots, d_k\\}$\n\nOutput: refined process map $G$\n\nBegin\n\nvar TAIL // a set variable to store tails for new arcs\nvar HEAD // a set variable to store heads for new arcs\n\nfor $j = 1 \\ldots k$\n\nfor $i = 1 \\ldots (n + m)$\n\n$dv_{ij} \\in DV$\n\nif $dv_{ij} = O$ and $i < n$ then add $t_i$ to TAIL\n\nif $dv_{ij} = O$ and $n < i < n + m$ then add $c_i$ to TAIL\n\nif $dv_{ij} = I$ and $i < n$ then add $t_i$ to HEAD\n\nif $dv_{ij} = I$ and $n < i < n + m$ then add $c_i$ to HEAD\n\nend for\n\nend for\n\nfor $tail \\in TAIL, head \\in HEAD$\n\nif $(tail, head) \\notin A(G)$ then add $(tail, head)$ to $A(G)$\n\nend for\n\n$G' = \\langle V_t(G), V_c(G), V_{sc}(G), A(G) \\rangle$\n\nrun Algorithm 1 // rebuild the task view based on data view\n\nEnd\n\n**Table 2. Algorithm for process map enhancement based on data view**\n\nFor example, Figure 12 shows how the draft process map in Figure 11 can be enhanced based on a data view.\nStep 3: Refine process map based on Process Map Rules (PMRules). The previous two steps try to get as much information on the process map as possible by adding arcs among tasks and decision points, which may result in a process map that does not confine to the process map definition specified in Definition 2. Such process maps are usually not well organized and hard to understand. Thus, we say a process map is syntactically correct, if it satisfies all process map structure properties defined in Definition 2, which is formally specified in Definition 5.\n\nDefinition 5 (Syntactical Correctness of Process Map). Given task view $TV$, where $T = \\{t_1, t_2, \\ldots, t_n\\}$, $C = \\{c_1, c_2, \\ldots, c_m\\}$, a process map is syntactically correct if and only if:\n\n$$i = 1, \\ldots, n, n + m + 1 \\sum_{j=1}^{n+m+1} tv_{ij} = 1 \\text{ // single outing arc for tasks and start node}$$\n\nand $j = 1, \\ldots, n + m + 1, \\sum_{i=1}^{n+m+1} tv_{ij} \\geq 1 \\text{ // at least one incoming arc for tasks, decisions, and end node}$\n\nand $i = n + 1, \\ldots, m, \\sum_{j=1}^{n+m+1} tv_{ij} = 2 \\text{ // two outgoing arcs for decisions}$\nIn this step, the enhanced process map $G''$ is further refined according to a set of PMRules for syntactical correctness. In particular, the following PMRules are enforced:\n\n**PMRule 1 (Single Task Outgoing Arc).** If there exists tasks that have more than one outgoing arcs, those links must be merged. Basically, this rule ensures the proper execution of a process by avoiding ambiguous execution paths. Given tasks in $G''$ are connected to either other tasks or decisions, we use the following two sub PMRules to enforce PMRule 1.\n\n**PMRule 1.1 (No One-to-Many Task-Task Arcs).** If a task $t$ links to more than one other tasks directly, the other tasks must be sequentially linked and connected to $t$.\n\n**PMRule 1.2 (No One-to-Many Task-Decision Arcs).** Similar to PMRule 1.1, if a task $t$ links to more than one decision points directly, those decision points must be sequentially linked and connected to $t$.\n\n**PMRule 2 (Boolean Decision Outgoing Arc).** If a decision point has less than two outgoing arcs, additional arcs need to be added to link the decision point to other tasks or decision points. Similarly, if there are more than two outgoing arcs, the decision point should be split into multiple ones. According to process policy definition, a constraint returns a Boolean value and each decision point is associated with one constraint. Therefore, a decision point must have two and only two outgoing arcs.\n\n**PMRule 3 (Close Start/End Node).** All tasks and decisions without incoming arc should be connected to the start node; and all tasks without outgoing arc should be connected to the end node; After that, if more than one task/decision is linked to the start node, those tasks/decisions need to be sequentially linked first and then connected to the start node;\nand if there are still no arcs linked to start and end nodes, link them directly.\n\n**Step 4: Remove semantic errors.** Semantic error is defined as inappropriate arcs resulting in process maps that are logically wrong. For example, a direct arc from start node to end node represents a semantic error. In this step, a thorough walkthrough of the process map should be conducted to identify and remove semantic errors if any. Semantic errors inspection relies mainly on human intelligence, although some simple errors, such as the start-to-end arc aforementioned, can be identified by computers. We defer the thorough investigation of process design semantic errors to future research.\n\n**Step 5: Process review.** In this step, the process map is reviewed to ensure it captures all tasks and constraints required by corresponding policies. Process review usually includes review meetings with process owners, e.g., managers who oversee the process, and people who are conducting process operations. Given that a process map has been developed based on existing process policies, this review is more focused and efficient than data collections in traditional participative approach. It is also possible that the business policies are out of date. In that case, the extracted process map is revised to match the real process in the field and corresponding business policies are also updated.\n\nTo the best of our knowledge, the policy-driven process design procedure presented in this section is the first attempt to formalize the procedure of process design based on policy analysis. PPD advocates a new process mapping methodology and creates a critical step towards process design automation. In the next section, we demonstrate and validate the PPD approach via a case study.\n4.4 Validation of Policy-driven Process Design\n\nIn section 3, we conducted a case study of a major public university’s business policy manual, from which we identified a set of process policies as shown in Table 3 (Wang et al. 2005). In this section, we show how those twelve narrative process policies are transformed into a process map using the PPD approach.\n\n| P1: All claims for the reimbursement of expenses for an approved university business travel are made on a Travel Reimbursement Form (TRF). |\n| P2: If Travel Reimbursement Form is submitted later than 60 days upon completing the travel, a Reasonable Exception Request Form (RERF) must be submitted. |\n| P3: If reasonable exception request is not approved, the reimbursement amount will be taxable. |\n| P4: If reimbursement amount (RA) exceeds limit, a Travel Exception Form (TEF) must be filled. |\n| P5: After the reimbursement form is approved, a check will be issued. |\n| P6: If the quarterly travel exception review is denied, the reimbursed amount must be refunded. |\n| P7: Department or unit head must approve the travel. |\n| P8: Department or unit head must approve the reasonable exception. |\n| P9: Disbursement Services Center (DSC) must review the reimbursement form. |\n| P10: The Office of Business and Financial Services (OBFS) reviews the travel exception form. |\n| P11: Higher Education Travel Control Board (HETC) quarterly reviews the travel exceptions. |\n| P12: Bursar’s office (BO) is responsible to issue reimbursement check. |\n\nTable 3. Identified process policies from a business policy manual\n\nFirst, we formalize the policies according to process policy definition specified in\nDefinition 1 as shown in Table 4. In particular, eleven tasks, five constraints, five data items, and six resources are identified.\n\n<table>\n<thead>\n<tr>\n<th>PID</th>\n<th>Data Items (D)</th>\n<th>Tasks (T)</th>\n<th>Constraints (C)</th>\n<th>Resource (R)</th>\n<th>Task Sequences (TS)</th>\n<th>Task Resources (TR)</th>\n<th>Task Data (TD)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>d1 = TRF</td>\n<td>t1 = Submit d1</td>\n<td>NA</td>\n<td>r1 = traveler</td>\n<td>(t1, r1)</td>\n<td>(t1, d1)</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>d2 = RERF</td>\n<td>t1 = Submit d2</td>\n<td>c1: TRF is submitted later than 60 days upon completing the travel</td>\n<td>NA</td>\n<td>(t1, t2, c1)</td>\n<td>(t2, r1)</td>\n<td>(t2, d2)</td>\n</tr>\n<tr>\n<td>2</td>\n<td>d2 = RA</td>\n<td>t3 = Approve d2, t4 = Make d3 taxable</td>\n<td>c2: RERF is approved</td>\n<td>NA</td>\n<td>(t3, t4, c2)</td>\n<td>NA</td>\n<td>(t3, d2)</td>\n</tr>\n<tr>\n<td></td>\n<td>d3 = TEF</td>\n<td>t5 = Submit d4</td>\n<td>c3: Reimbursement Amount exceeds the limit</td>\n<td>NA</td>\n<td>(null, t5, c3)</td>\n<td>(t5, r1)</td>\n<td>(t5, d4)</td>\n</tr>\n<tr>\n<td>3</td>\n<td>d1 = Check</td>\n<td>t6 = Approve d1, t7 = Issue d5</td>\n<td>c4: TRF is approved</td>\n<td>NA</td>\n<td>(t6, t7, c4)</td>\n<td>NA</td>\n<td>(t6, d1) (t7, d6)</td>\n</tr>\n<tr>\n<td></td>\n<td>d4, d5</td>\n<td>t8 = Review d4 quarterly, t9 = Refund d5</td>\n<td>c5: TEF quarterly review is not passed</td>\n<td>NA</td>\n<td>(t8, t9, c5)</td>\n<td>(t9, r1)</td>\n<td>(t8, d4) (t9, d5)</td>\n</tr>\n<tr>\n<td>4</td>\n<td>d1</td>\n<td>t6</td>\n<td>NA</td>\n<td>r2 = Dept. Head</td>\n<td>NA</td>\n<td>(t6, r2)</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>5</td>\n<td>d2</td>\n<td>t3</td>\n<td>NA</td>\n<td>NA</td>\n<td>NA</td>\n<td>(t3, r2)</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>6</td>\n<td>d1</td>\n<td>t10 = Review d1</td>\n<td>NA</td>\n<td>r3 = DSC</td>\n<td>NA</td>\n<td>(t10, r3)</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>7</td>\n<td>d4</td>\n<td>t11 = Review d4</td>\n<td>NA</td>\n<td>r4 = OBFS</td>\n<td>NA</td>\n<td>(t11, r4)</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>8</td>\n<td>d4</td>\n<td>t8</td>\n<td>NA</td>\n<td>r5 = HETC</td>\n<td>NA</td>\n<td>(t12, r5)</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>9</td>\n<td>d5</td>\n<td>t7</td>\n<td>NA</td>\n<td>r6 = BO</td>\n<td>NA</td>\n<td>(t7, r6)</td>\n<td>NA</td>\n</tr>\n</tbody>\n</table>\n\nTable 4. Formalized travel reimbursement process policies\n\nBased on the task sequences in Table 4, a draft process map is constructed as shown in\nFigure 13. In traditional participative process design projects, figuring out these tasks and task relationship may involve many rounds of interviews and meetings that can easily span over several days. With systematic parsing process policies, this draft process map can be accomplished by an individual process analyst in hours. It is worth noting that once Table 4 is generated, this step can be fully automated by visualization software, which greatly improves process design efficiency.\n\nFigure 13. Draft process map based on the task sequences\n\nHowever, the draft process map Figure 13 contains only limited information on the relationship among tasks and constraints, which is not enough for thorough understanding of the whole process. Therefore, we use data flow analysis to enhance the draft process map. In particular, Table 5 shows the data view of travel reimbursement process. Based on the algorithms in Table 2, additional arcs are added to represent more relationship among\ntasks, and the enhanced process map is depicted in Figure 14. Compared with Figure 13, Figure 14 contains significant more information on the process, which is also automatically added by the process design tool.\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>d1</th>\n<th>d2</th>\n<th>d3</th>\n<th>d4</th>\n<th>d5</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>t1</td>\n<td>O</td>\n<td>O</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t2</td>\n<td>O</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t3</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t4</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t5</td>\n<td></td>\n<td>O</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t6</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t7</td>\n<td></td>\n<td>O</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t8</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t9</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t10</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t11</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>c1</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>c2</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>c3</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>c4</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>c5</td>\n<td>I</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTable 5. Data view of travel reimbursement process\n\nHowever, according to process map definition, the enhanced process map is not syntactically correct. For instance, \\( t_1 \\) has five outgoing arcs and start node has no outgoing arc. Additional refinements are conducted using the PMRules. For example, task \\( t_1 \\) has no incoming arc, which should link to the start node. Similarly, \\( t_9 \\) has no outgoing arc, which should be linked to the end node. One outgoing arc is added to each decision point to represent the Boolean value returned by each constraint.\n\nCompared with the previous two steps, this step needs human intervention and cannot yet be automated. However, some implicitly stated rules can help expedite the refinement process. For instance, one example implicit rule in our case study can be that before the travel reimbursement is reviewed, all kinds of exception forms must be submitted if any.\nUsing this rule, we can easily decide that task $t_{10}$ (review TRF) should be executed after all tasks related to TEF (travel exception form) and RERF (reasonable exception request form). Finally, the revised process map shown in Figure 15, which is syntactically correct. Note that in this step, some arcs identified in the task view and data view have been removed.\n\n\n\nFigure 14. Enhanced process map based on data view\n\nAccording to policy-driven process model extraction procedure, a syntactically correct process model may contain semantic errors. In our case, two semantic errors are identified in Figure 15: $t_7$ (issue the check) is linked to $t_9$ (refund back the check), which is logically wrong, and $t_{11}$ (Review TEF) is linked to $t_8$ (Review TEF quarterly), which results in the corresponding reimbursement request form never gets reviewed in $t_{10}$. To remove those semantic errors, two constraints $c_6$ and $c_7$ are added as shown in Figure 16.\nA review meeting involving process analysts, process owners, and process users should be conducted to verify the process map in Figure 16. The goal is to make sure the process map reflects the real processes running in the field and it contains all the tasks and constraints. In addition, process map in Figure 16 only graphically illustrate the control flow aspect of a process. As shown in Table 4, all other information on data flow, resources, resource-task assignments should be provided as supplementary documents to the process map. In our case, this updated process map contains all the necessary tasks and constraints for the travel reimbursement process, leading to the final process map.\n\nFigure 15. Revised process map based on PMRules\n\nThe process extraction procedure can also be depicted conveniently with a process matrix in Table 6. Initially, the process matrix contains the P’s based on the given process\npolicies. Then, the matrix is updated by adding D’s for the arcs identified from the data view in Table 5. Next, the semantic analysis removes a number of arcs as represented in the process matrix by the symbols of $P \\rightarrow 0$ and $D \\rightarrow 0$, respectively. The arcs added after applying all PMRules are depicted with the R’s. While the process maps in Figure 13 through Figure 16 are easy to read by process analysts, the process matrix is easier to automate with computer procedures. Note that the process matrix is closely related to the task view defined previously.\n\n\n\n**Figure 16. Process map after removing semantic errors**\n\nWe have demonstrated the feasibility of Policy-driven Process Design (PPD) by\nsuccessfully extract a travel reimbursement process from the corresponding business policies. Besides being an efficient process design methodology, PPD is also of great benefit to organizations by improving the quality of their business policies. The quality of business policies can be measured in terms of preciseness, consistency, and completeness (Agarwal et al. 1993b; Teichroew et al. 1977). Business policies are written in natural languages that are not precise enough to describe process models and different readers may interpret same sentences in different ways. PPD greatly reduces the ambiguity of narrative process policies by precisely representing them using process policy template. For organizations with large-scale business processes, the corresponding process policies can be very large, which makes it very difficult to ensure the consistency of those policies. In PPD, once process policies are formalized, various analyses can be conducted to check policy consistency. For instance, a policy defining t₂ is executed after t₁ conflicts with another policy saying t₁ is executed after t₂. These types of conflicting policies can be easily identified using process matrix shown in Table 6 by finding non-zero values for matrix elements with index ij and ji.\n\nA set of process policies are said to be complete if they provide all information needed to build the target process model. For large and complex business processes, it is difficult to determine what process information is missing by examining narrative process policies. Although completeness can never be fully guaranteed, PPD can facilitate detecting gaps and omissions by making them more obvious. For example, we defined syntactical correctness of process map in Definition 5 and one syntactical error is that there are tasks without outgoing arc, which means additional process information is\nneeded to determine how process will be routed after those tasks. Algorithms can be easily developed to check the syntactical correctness of a process map and therefore identify the missing process information.\n\nIn summary, we have shown that PPD can expedite process design by leveraging process policy analysis and improve the quality of business policies by formalizing narrative process policies. Next, we present the architecture of a prototype process design system developed based on Policy-driven Process Design methodology.\n\n<table>\n<thead>\n<tr>\n<th>t1</th>\n<th>t2</th>\n<th>t3</th>\n<th>t4</th>\n<th>t5</th>\n<th>t6</th>\n<th>t7</th>\n<th>t8</th>\n<th>t9</th>\n<th>t10</th>\n<th>t11</th>\n<th>c1</th>\n<th>c2</th>\n<th>c3</th>\n<th>c4</th>\n<th>c5</th>\n<th>e</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>D</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n\nTable 6. Process matrix for travel reimbursement process design\n\n4.5 Architecture of PPD Prototype System\n\nFigure 17 shows the architecture of our web-based PPD prototype system, which consists of three major components, namely, Policy Wizard, Visual Editor, and Process Exchanger.\nPolicy wizard is a process policy analysis and parsing tool that provides step by step instructions for process policy formalization and extraction. For example, when a new process policy is entered, policy wizard provides intuitive interface for entering new identified tasks, task sequence information, data items, and task-data relationships. The system also keeps records of entered tasks, data items, process constraints and\nautomatically indexes those information to avoid duplicate data. Policy wizard is implemented as a set of JSP pages, and Figure 18 is a screenshot.\n\nThe formalized process policies are stored at a policy based, which is implemented using Oracle 10g ©. Figure 19 is the entity-relationship diagram of process policies, which is designed based on formal process policy definition presented in Definition 1 in section 4. Note that the cardinality between any two entities is many-to-many, which is not depicted in the figure. Then, the ERD is translated into a relation schema as shown in Table 7 with primary keys underlined.\n\n<table>\n<thead>\n<tr>\n<th>Policy (PID, PType, Keywords, Memo)</th>\n<th>PolicyData(PID, DID)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Task (TID, TName)</td>\n<td>PolicyResource(PID, RID)</td>\n</tr>\n<tr>\n<td>DataItem (DID, DName)</td>\n<td>PolicyConst(PID, CID)</td>\n</tr>\n<tr>\n<td>PConstraint (CID, Content)</td>\n<td>TaskSequence (TID1, TID2, CID)</td>\n</tr>\n<tr>\n<td>PResource (RID, RName, Type)</td>\n<td>TaskData (TID, DID)</td>\n</tr>\n<tr>\n<td>PolicyTask(PID, TID)</td>\n<td>TaskResource (TID, RID)</td>\n</tr>\n</tbody>\n</table>\n\nTable 7. Database schema for a policy base\n\nFigure 19. Entity relationship diagram for process policy\nOnce the process policies are mapped into database, Visual Editor is used to visualize the process design. Given a process is defined as a directed graph as discussed in Definition 2 in section 4, Visual Editor is implemented on top of Java Universal Network/Graph Framework (JUNG) (http://jung.sourceforge.net/). JUNG is a free open-source software library that provides a common and extendible language for the manipulation, analysis, and visualization of data that can be represented as a graph or network. JUNG is developed in Java, allowing JUNG-based applications to make use of the extensive built-in capabilities of the Java API and other existing third-party Java libraries (Madadhain et al. 2005). We extended JUNG with special extensions for policy-based process design.\n\nAs shown in Figure 20, the draft travel reimbursement process depicted in Figure 16\n\n\nis visualized into a directed graph, where different shapes and colors are used to represent tasks, start/end nodes, and decision points. Advanced process analysis, such as adding arcs based on data view, enhancing process using process design rules, is also implemented based on graph theory. Visual Editor also allows process analysts to visually edit process map, e.g., adding/deleting vertices and arcs, which is very convenient and useful for removing semantic errors. Process designer has been tested using the illustrative example presented in section 4 and the travel reimbursement process map was successfully extracted and visualized.\n\n<table>\n<thead>\n<tr>\n<th>Narrative Documentations</th>\n<th>Simplified Sentences</th>\n<th>Formalized Statements</th>\n<th>Logic Formulas</th>\n<th>XML Files</th>\n</tr>\n</thead>\n</table>\n\nFigure 21. Process policy representation stack\n\nProcess exchanger provides an interface to interoperable with other systems using different process modeling languages. Process policies are represented in different formats as illustrated by the process policy representation stack shown in Figure 21. In particular, process policies are initially embedded in narrative business policy documents, which is then distilled and represented into more precise and succinct sentences according to process policy taxonomy. After that, process policies are formalized using a template and specified as logic formulas using our Unified Predicate Language. However,\nUPL is designed as an intra-organizational process modeling language without considering the collaboration among different organizations. Therefore, UPL must be translated into a standard format for process policy exchange and interoperability among different workflow management systems.\n\nPolicy $P_4$ in RuleML:\n\n```xml\n<Imp>\n <head>\n <Atom>\n <opr><Rel>next</Rel></opr>\n <Ind>Submit TRF</Ind>\n <Ind>Submit TEF</Ind>\n </Atom>\n </head>\n <body>\n <And>\n <Atom>\n <opr><Rel>greater</Rel></opr>\n <Var>reimbursement amount</Var>\n <Ind>limit</Ind>\n </Atom>\n </And>\n </body>\n</Imp>\n```\n\nPolicy $P_5$ in RuleML:\n\n```xml\n<Imp>\n <head>\n <Atom>\n <opr><Rel>next</Rel></opr>\n <Ind>Submit TRF</Ind>\n <Ind>TRF Approval</Ind>\n </Atom>\n </head>\n <body>\n <And>\n <Atom>\n <opr><Rel>approved</Rel></opr>\n <Var>TRF</Var>\n </Atom>\n </And>\n </body>\n</Imp>\n```\n\nTable 8. Process policies represented in RuleML\n\nProcess exchanger is able to convert UPL-based process representation into a set of well-known XML-based process modeling standards. In particular, control flow can be converted into BPEL (Andrews et al. 2003) and process constraints can be specified using XACML (OASIS 2003). In addition, Jess-based UPL implementation can be converted into RuleML using the tools provided in SweetRules project (Grosof et al. 2003). As an example, policies “$P_4$: If reimbursement amount exceeds the limit, a Travel Exception Form must be filled” and “$P_5$: After the reimbursement form is approved, a check will be issued” are expressed using RuleML as shown in Table 8. Given RuleML can run on top of\nmost well-known rule engines such as XSB (http://xsb.sourceforge.net/), Jena (http://jena.sourceforge.net/), IBM CommonRules (http://www.research.ibm.com/rules/),\n\nBesides exporting functions, process exchanger can also import process model represented in BPEL into UPL format, which makes our PPD tool a powerful plug-in to existing BPEL-based workflow engine for process design and change verification.\n\nIn this section, we propose an innovative process design approach by means of formal process policy analysis, which is referred as Policy-driven Process Design (PPD). PPD is a new process design methodology different from the existing participative and analytical process design methods. In particular, we formalized the process policy, developed several new concepts such as task view, data view, and process map rules, and designed a set of process design algorithms to facilitate process model extraction. These artifacts build the theoretical foundation for systematic process policy analysis and process design automation.\n\nHowever, PPD is only discussed by means of representing process model graphically in UML, which is lack of analytical capability. Given different process components including control flow, data flow, resources, and constraints are all extracted from narrative process policies, we propose a process analysis and design language to unify their representation, which we refer to as Unified Predicate Language (UPL). UPL is grounded in predicate logic, whose declarative nature makes it a perfect language to represent policy-based process components. In addition, UPL can facilitate process design by automating several steps discussed in this section via logic inference and queries. UPL is defined and discussed in the next section.\n5. A UNIFIED PREDICATE LANGUAGE\n\nDriven by the needs for formally representing process models from a policy perspective and analyzing process changes among different workflow components, we propose a logic-based language for process analysis and design named Unified Predicate Language (UPL). UPL is able to represent control flow, data flow, organizational model, and constraint in a unified logic form and provides various process analysis capabilities based on logic inference and queries. After formally defining UPL, we apply it to process design to demonstrate its power and validate it via a comparison with other two well-know analytical process modeling languages. In section 6, we will use UPL to analyze process changes.\n\n5.1 Language Definition\n\nIn this section we specify our Unified Predicate Language (UPL) by defining its variables, predicates and functions. Then, we define the rules that can be expressed in the language. We define the sets of variable symbols as follows:\n\n- \\( T = \\{t_1, \\ldots, t_n, s, e\\} \\) is the set of tasks, which includes two special tasks: \\( s \\) (the start node of a workflow) and \\( e \\) (the end node of a workflow);\n- \\( RC = \\{f, j, d, m\\} \\) is the set of routing constructs. \\( f \\) (fork) and \\( j \\) (join) are used to represent parallel execution and synchronization of a set of task. \\( d \\) (decision) and \\( m \\) (merge) are used to choose one task from a set of tasks for execution based on routing constraints.\n• $D = \\{d_1, \\ldots, d_j\\}$ is the set of data.\n\n• $U = \\{u_1, \\ldots, u_k\\}$ is the set of users. Users can be human or machine agents.\n\n• $R = \\{r_1, \\ldots, r_l\\}$ is the set of roles, which represents sets of organizational responsibilities that can be assigned to a user, such as department head, account manager, etc. Note that a role can have multiple users and a user can play multiple roles.\n\n• $G = \\{g_1, \\ldots, g_m\\}$ is the set of organizational groups or functional units, such as Bursar’s Office, Graduate College, MIS departments, etc.\n\n• $C = \\{c_1, \\ldots, c_n\\}$ is the set of process constraints, which includes routing constraints, assignment constraints, authorization constraints, etc. As we will discuss later in this section, each constraint is a rule defined in our language.\n\nThese variables represent all fundamental elements of a process model, which are used next along with a set of predicates to model different process perspectives.\n\n<table>\n<thead>\n<tr>\n<th>Control Flow Predicate</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>next$(t_i, t_j)$, next$(t_i, rc_j)$, next$(rc_i, t_j)$, next$(rc_i, rc_j)$</td>\n<td>Sequential execution order among tasks and routing constructs.</td>\n</tr>\n<tr>\n<td>fork$(f_i, [t_{j1}, t_{j2}, \\ldots, t_{jn}])$</td>\n<td>Routing construct $f_i$ leads to a list of parallel task $t_{j1}, t_{j2}, \\ldots, t_{jn}$</td>\n</tr>\n<tr>\n<td>join$([t_{i1}, t_{i2}, \\ldots, t_{in}], j_j)$</td>\n<td>A list of parallel tasks converges to routing construct $j_j$</td>\n</tr>\n<tr>\n<td>branch$(b_i, [t_{j1}, t_{j2}, \\ldots, t_{jn}])$</td>\n<td>After routing construct $d_i$, exactly one of the tasks in $t_{j1}, t_{j2}, \\ldots, t_{jn}$ is to be executed.</td>\n</tr>\n<tr>\n<td>merge$([t_{i1}, t_{i2}, \\ldots, t_{in}], j_j)$</td>\n<td>Routing construct $m_j$ is triggered once one of the task in $t_{i1}, t_{i2}, \\ldots, t_{in}$ completes</td>\n</tr>\n</tbody>\n</table>\n\nTable 9. Control flow predicates\n\nThe control flow perspective defines the execution order of tasks. In particular, five\nprimitive workflow building blocks have been defined as shown in Figure 2 (WfMC 1999b). Accordingly, we propose five predicates to represent the five workflow building blocks as depicted in Table 9.\n\n<table>\n<thead>\n<tr>\n<th>Organization Predicate</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>role($u_i$, $r_j$)</td>\n<td>user $u_i$’s role is $r_j$</td>\n</tr>\n<tr>\n<td>belong($r_i$, $g_j$)</td>\n<td>role $r_i$ belongs to organizational group $g_j$</td>\n</tr>\n<tr>\n<td>has($g_i$, $g_j$)</td>\n<td>organization group $g_i$ has group $g_j$</td>\n</tr>\n<tr>\n<td>manage($r_i$, $r_j$)</td>\n<td>role $r_i$ manages role $r_j$</td>\n</tr>\n<tr>\n<td>manage($u_i$, $u_j$)</td>\n<td>user $u_i$ manages user $u_j$</td>\n</tr>\n<tr>\n<td>execute($u_i$, $t_j$)</td>\n<td>user $u_i$ is assigned to execute task $t_j$</td>\n</tr>\n<tr>\n<td>execute($r_i$, $t_j$)</td>\n<td>role $r_i$ is assigned to execute task $t_j$</td>\n</tr>\n<tr>\n<td>execute($g_i$, $t_j$)</td>\n<td>organization group $g_i$ is responsible to handle task $t_j$</td>\n</tr>\n<tr>\n<td>cannot-execute($u_i$, $t_j$)</td>\n<td>user $u_i$ cannot be assigned to execute task $t_j$</td>\n</tr>\n<tr>\n<td>cannot-execute($r_i$, $t_j$)</td>\n<td>role $r_i$ cannot be assigned to execute task $t_j$</td>\n</tr>\n<tr>\n<td>cannot-execute($g_i$, $t_j$)</td>\n<td>organization group $g_i$ cannot be assigned to handle task $t_j$</td>\n</tr>\n<tr>\n<td>constraint($t_i$, $c_j$)</td>\n<td>constraint $c_j$ is assigned to task $t_i$</td>\n</tr>\n<tr>\n<td>constraint($b_i$, $c_j$)</td>\n<td>constraint $c_j$ is assigned to routing construct branch $b_i$</td>\n</tr>\n</tbody>\n</table>\n\nTable 10. Organization modeling predicates\n\nThe organizational perspective defines the hierarchy of organizational resources including users, roles, and organization units. It also specifies their access privileges and responsibilities in terms of tasks they are authorized to handle. In addition, we also capture organizational policies on tasks and routing constructs by specifying their associated constraints if any. For instance, each decision point must have routing constraints to define routing conditions and paths, and temporal policies may restrict certain tasks from execution during non-business hours. Table 10 shows the set of\npredicates for modeling the organizational perspective.\n\nThe data flow perspective concerns what data is consumed and produced by each task and what are the dependency relationship among data items. Therefore, we specify data flow perspective using the predicates defined in Table 11.\n\n<table>\n<thead>\n<tr>\n<th>Data Flow Predicate</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>input($t_i$, $d_j$)</td>\n<td>data item $d_j$ is the input of task $t_i$</td>\n</tr>\n<tr>\n<td>output($t_i$, $d_j$)</td>\n<td>data item $d_j$ is the output of task $t_i$</td>\n</tr>\n<tr>\n<td>depend($d_i$, $d_j$)</td>\n<td>data item $d_i$ depends on data item $d_j$</td>\n</tr>\n</tbody>\n</table>\n\nTable 11. Data flow predicates\n\nTo facilitate process analysis, we also define a set of comparison functions, two Boolean operation functions, and a set of query functions in Table 12. For example, $\\text{count}($execute$(u_i, t_1), n)$ returns the total number of users assigned to task $t_1$ and $\\text{findall}($manage$(r_i, r_1), S)$ returns all the roles that have higher level of authorities than role $r_1$ in the organization model.\n\n<table>\n<thead>\n<tr>\n<th>Function Name</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>equal($v_1$, $v_2$), greater($v_1$, $v_2$), greaterequal($v_1$, $v_2$), less($v_1$, $v_2$), lessequal($v_1$, $v_2$)</td>\n<td>binary comparison functions corresponding to $=$, $>$, $\\geq$, $<$, $\\leq$, which return true or false based on comparison results</td>\n</tr>\n<tr>\n<td>plus($v_1$, $v_2$), minus($v_1$, $v_2$), multiply($v_1$, $v_2$), divideby($v_1$, $v_2$)</td>\n<td>arithmetic operators corresponding to $+$, $-$, $\\times$, $/$</td>\n</tr>\n<tr>\n<td>true($v$), false($v$)</td>\n<td>unary function that returns true or false based on the Boolean value of its argument $v$</td>\n</tr>\n<tr>\n<td>count($Q$, $n$)</td>\n<td>count the number of different answers of query $Q$ and return the value to $n$</td>\n</tr>\n<tr>\n<td>findall($Q$, $S$)</td>\n<td>find all different answers of query $Q$ and return them</td>\n</tr>\n</tbody>\n</table>\nto a set $S$\n\n| $\\text{findelements}(e, c, E)$ | $e \\in \\{t, rc, d, u, r, g, c\\}$ is a process element. This function returns all process elements of type $e$ involved in constraint $c$ into a set $E$ |\n| $\\text{findpredicates}(p, c, P)$ | $P$ is one of the control flow, data flow, or organization predicates. This function returns all predicates of type $p$ involved in constraint $c$ into a set $E$ |\n\nTable 12. Auxiliary functions\n\nThe rules in our language have the following form:\n\n$$H \\leftarrow B_1, B_2, \\ldots, B_n, n>0$$\n\nwhere $H$, $B_1$, $B_2$, \\ldots, $B_n$ are predicates or functions. $H$ is the head of the rule and $B_1$, $B_2$, \\ldots, $B_n$ consist of the rule body. A rule is triggered if and only if $B_1$, $B_2$, \\ldots, $B_n$ are all true, resulting in $H$ inferred to be true. As we mentioned before, process constraints are represented as rules. In particular, we present some build-in rules that are fundamental to process analysis in Table 13.\n\n<table>\n<thead>\n<tr>\n<th>Built-in rules</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>research((t_i, t_j)) $\\leftarrow$ next((t_i, t_j))</td>\n<td>Task reachability rules</td>\n</tr>\n<tr>\n<td>research((t_i, t_j)) $\\leftarrow$ next((t_i, f_x)), fork((f_x, [t_{y1}, \\ldots, t_{yn}])), member((t_j, [t_{y1}, \\ldots, t_{yn}]))</td>\n<td></td>\n</tr>\n<tr>\n<td>research((t_i, t_j)) $\\leftarrow$ next((j_x, t_j)), join(([t_{y1}, \\ldots, t_{yn}], j_x)), member((t_i, [t_{y1}, \\ldots, t_{yn}]))</td>\n<td></td>\n</tr>\n<tr>\n<td>research((t_i, t_j)) $\\leftarrow$ next((t_i, b_x)), branch((b_x, [t_{y1}, \\ldots, t_{yn}])), member((t_j, [t_{y1}, \\ldots, t_{yn}]))</td>\n<td></td>\n</tr>\n<tr>\n<td>research((t_i, t_j)) $\\leftarrow$ next((m_x, t_j)), merge(([t_{y1}, \\ldots, t_{yn}], m_x)), member((t_i, [t_{y1}, \\ldots, t_{yn}]))</td>\n<td></td>\n</tr>\n<tr>\n<td>research((t_i, t_j)) $\\leftarrow$ next((t_i, t_k)), reach((t_k, t_j))</td>\n<td></td>\n</tr>\n</tbody>\n</table>\nTable 13. Built-in UPL rules\n\n<table>\n<thead>\n<tr>\n<th>Rule Description</th>\n<th>Rule</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>User and role hierarchy rules</td>\n<td><code>manage(u_i, u_j) ← role(u_i, r_i), role(u_j, r_j), manage(r_i, r_j)</code></td>\n</tr>\n<tr>\n<td></td>\n<td><code>manage(r_i, r_j) ← manage(r_i, r_k), manage(r_k, r_j)</code></td>\n</tr>\n<tr>\n<td></td>\n<td><code>manage(u_i, u_j) ← manage(u_i, u_k), manage(u_k, u_j)</code></td>\n</tr>\n<tr>\n<td>Authorization inheritance rules</td>\n<td><code>execute(u_i, t_j) ← execute(r_k, t_j), role(u_i, r_j)</code></td>\n</tr>\n<tr>\n<td></td>\n<td><code>execute(u_i, t_j) ← execute(g_k, t_j), belong(u_i, g_k)</code></td>\n</tr>\n</tbody>\n</table>\n\nTask reachability rules are defined for incomplete path detection. Basically, we say that \\( t_j \\) is reachable from \\( t_i \\), if there exists at least one path from \\( t_i \\) to \\( t_j \\) in the process model. Intuitively, one task can be reached by another task if they are next to each other or they are directly connected to a routing construct that is of the type Fork, Join, Branch, or Merge.\n\nTask reachability is recursively defined in Table 13, where \\( \\text{member}(t_i, [t_{i1}, t_{i2}, ..., t_{in}]) \\) means that \\( t_i \\) is a member of the list \\([t_{i1}, t_{i2}, ..., t_{in}]\\). If the query \\( \\text{reach}(t_i, t_j) \\) returns false, then if \\( t_i \\) and \\( t_j \\) are not executed in parallel there is an incomplete path between them. Furthermore, for a correctly design process, \\( \\text{reach}(s, e) \\) should always return true. In this dissertation, we are not focusing on control flow verification and therefore refer interested readers to (Bi et al. 2003a; Bi et al. 2004b; Choi et al. 2002; Sadiq et al. 1996; van der Aalst 1997; van der Aalst 2000b; van der Aalst et al. 2000).\n\nUser and role hierarchy rules represent the organization structure and its transitive property. For instance, if \\( r_1 \\) manages \\( r_2 \\), and \\( r_2 \\) manages \\( r_3 \\), then \\( r_1 \\) also manages \\( r_3 \\). These rules can also be used to support dynamic role assignment policies. For example, if a policy states that the role executes task 2 must be the manager of the role that executes task 1. Assume \\( r_1 \\) executes task 1, and \\( r_2 \\) is assigned to execute task 2. During runtime, the system conducts a query \\( manage(r_2, r_1) \\) and only when the query returns true \\( r_2 \\) is allowed to\nexecute task 2. Authorization inheritance rules define that users can inherit task execution authorizations from the role and/or organization units they are affiliated with. For example, if an authorization policy says that bursar’s office is in charge of issue reimbursement check, then everyone in bursar’s office is authorized to issue those checks. Authorization inheritance rules are created to support role-based and team-based access control.\n\nWith a succinct set of predicates, UPL is expressive enough to model control flow, data flow, organization model, and process constraints. It also provides great extensibility and flexibility via its capability of defining different sets of rules for different process modeling and analysis requirements. Next, we show how our language can help process design.\n\n5.2 Process Design via UPL\n\nIn this section, we demonstrate the unique capability of our unified predicate language (UPL) in terms of facilitating process design. Specifically, UPL is able to represent narrative process information in a succinct and accurate form, provide process design insights via reasoning about relationship among process elements, and help detect design errors by conducting queries.\n\nTable 14 shows a set of travel reimbursement process policies we synthesized from a major public university’s business policy manual. In the rest of this section, we illustrate how a travel reimbursement process can be systematically designed from these narrative process policies by applying our Unified Predicate Language (UPL).\nP1: All claims for the reimbursement of expenses for an approved university business travel are made on a Travel Reimbursement Form (TRF).\n\nP2: If Travel Reimbursement Form is submitted later than 60 days upon completing the travel, a Reasonable Exception Request Form (RERF) must be submitted.\n\nP3: If reasonable exception request is not approved, then the reimbursement amount will be taxable.\n\nP4: If reimbursement amount exceeds the limit, a Travel Exception Form (TEF) must be filled.\n\nP5: After the reimbursement form is approved, a check will be issued.\n\nP6: Department or unit head must approve the travel.\n\nP7: Department or unit head must approve the reasonable exception request form.\n\nP8: Disbursement Services Center (DSC) must review and approve the reimbursement form.\n\nP9: The Office of Business and Financial Services (OBFS) reviews the travel exception form.\n\nP10: All travel exceptions must be submitted to Higher Education Travel Control Board (HETC) for quarterly review.\n\nP11: Bursar’s Office (BO) is responsible to issue reimbursement check.\n\nTable 14. Travel reimbursement policies\n\nFigure 22. Procedure for process design via UPL\nFigure 22 shows the procedure of process design using UPL. This procedure is similar to process extraction procedure presented in Figure 10. However, instead of using graphical modeling language UML and manually go through the procedure, UPL further facilitate process design by recording process design steps in an accurate and computational logic form and automating process design via logic deduction. In addition, we discuss more about UPL-based organization and constraints modeling, which was not covered in the procedure in Figure 10. According to the procedure, we first identify a set of tasks, data, roles, organization units, and routing constructs as shown below:\n\n<table>\n<thead>\n<tr>\n<th>Tasks</th>\n<th>t₁(request travel), t₂(approve travel), t₃(submit TRF), t₄(submit RERF), t₅(approve RERF), t₆(make reimbursement taxable), t₇(submit TEF), t₈(approve TEF), t₉(submit TEF for quarterly review), t₁₀(approve reimbursement), t₁₁(issue check)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Data</td>\n<td>d₁(TRF), d₂(RERF), d₃(TEF), d₄(check), d₅(travel completion time), d₆(reimbursement request submission time), d₇(reimbursement amount), d₈(TRF approval), d₉(RERF approval), d₁₀(TEF approval), d₁₁(check), d₁₂(travel amount limit), d₁₃(travel request), d₁₄(travel approval)</td>\n</tr>\n<tr>\n<td>Roles</td>\n<td>r₁(department/unit head)</td>\n</tr>\n<tr>\n<td>Organization Units</td>\n<td>g₁(Disbursement Services Center), g₂(Office of Business and Financial Services), g₃(Higher Education Travel Control Board), g₄(Bursar’s Office)</td>\n</tr>\n<tr>\n<td>Routing Constructs</td>\n<td>b₁(whether TRF is submitted after 60 days of travel completion date), b₂(whether reimbursement amount exceeds the limit), b₃(whether RERF is approved), b₄(whether TEF is approved), b₅(whether TRF is approved)</td>\n</tr>\n</tbody>\n</table>\n\nTable 15. Identified process elements from process policies\n\nWe can also obtain control flow information from the policies. For instance, policy P3 implies that based on the decision (b₃) of reasonable exception approval (t₃), the reimbursement amount should be made taxable (t₆), which can be precisely represented in\nUPL as $\\text{branch}(b_3, [t_6]), \\text{next}(t_5, b_3)$. Similarly, we can get other control flow information as follows: $\\text{branch}(b_1, [t_4]), \\text{branch}(b_3, [t_6]), \\text{next}(t_5, b_3), \\text{branch}(b_2, [t_7]), \\text{branch}(b_4, [t_9]), \\text{next}(t_8, b_4), \\text{branch}(b_5, [t_{11}]), \\text{next}(t_{10}, b_5)$. However, these control flow information directly retrieved from process policies contains only limited information on the whole travel reimbursement process. Therefore, more information on the execution order among tasks needs to be added.\n\nEach task in a process model is associated with a set of input and output data. There is also dependency relationship among data items, e.g., the Travel Exception Form (TEF) depends on the Travel Reimbursement Form (TRF), because only after TRF is submitted, TEF can be created. Data flow based workflow design has been studied in (Sun et al. 2004a). Intuitively, if there is a data dependency among the sets of data items associated with two tasks, those two tasks should be executed sequentially; otherwise, they can be executed in parallel. In UPL, we can define the data dependency rules as follows:\n\n| $\\text{next}(t_i, t_j) \\leftarrow \\text{output}(t_i, d_k)$, $\\text{input}(t_j, d_k)$ | $t_i$ is executed before $t_j$ if $t_i$ outputs $d_k$ that is $t_j$’s input |\n| $t_i$ is executed before $t_j$ if $t_i$ outputs $d_m$, $t_j$ inputs $d_m$, and $d_n$ depends on $d_m$ |\n\n**Table 16. Data dependency rules**\n\n| inputs and outputs: $\\text{output}(t_1, d_{13}), \\text{input}(t_2, d_{13}), \\text{output}(t_2, d_{14}), \\text{output}(t_3, d_1), \\text{output}(t_3, d_5), \\text{output}(t_3, d_6), \\text{output}(t_3, d_7), \\text{output}(t_4, d_2), \\text{input}(t_5, d_2), \\text{output}(t_5, d_{10}), \\text{input}(t_6, d_7), \\text{output}(t_7, d_3), \\text{input}(t_8, d_3), \\text{output}(t_8, d_{11}), \\text{input}(t_9, d_3), \\text{input}(t_{10}, d_1), \\text{output}(t_{10}, d_9), \\text{input}(t_{11}, d_9), \\text{input}(t_{11}, d_7), \\text{output}(t_{11}, d_4), \\text{input}(b_1, d_5), \\text{input}(b_1, d_6), \\text{input}(b_2, d_7), \\text{input}(b_2, d_{12}), \\text{input}(b_3, d_2), \\text{input}(b_4, d_3), \\text{input}(b_5, d_1)$ |\n\n**Table 17. Data inputs and outputs**\nIn our example, the inputs and outputs for each task are shown in Table 17. By applying data dependency rules, additional control flow information can be inferred as follows: \\( \\text{next}(t_1, t_2), \\text{next}(t_3, t_{10}), \\text{next}(t_3, t_{11}), \\text{next}(t_4, t_5), \\text{next}(t_7, t_8), \\text{next}(t_7, t_9) \\). These new control flow information need to be checked against process policies to ensure they are semantically right. Based on additional policy analysis, we can draft a control flow diagram as shown in Figure 23. According to control flow information we get directly from process policies and information in Figure 23, we can decide that \\( \\text{next}(t_3, t_{10}), \\text{next}(t_3, t_{11}), \\text{next}(t_7, t_9) \\) should be removed and \\( \\text{next}(t_2, t_3), \\text{next}(t_3, f_1), \\text{fork}(f_1, [b_1, b_2]), \\text{join}([m_1, m_2], j_1), \\text{next}(j_1, t_{10}), \\text{next}(s, t_1) \\) should be added. So far, all control flow information are listed in Table 18.\n\n\\[\n\\begin{align*}\n\\text{next}(s, t_1), & \\quad \\text{next}(t_1, t_2), \\quad \\text{next}(t_2, t_3), \\quad \\text{next}(t_3, f_1), \\quad \\text{fork}(f_1, [b_1, b_2]), \\quad \\text{decision}(b_1, [t_4]), \\quad \\text{next}(t_4, t_5), \\\\\n\\text{next}(t_5, b_3), & \\quad \\text{decision}(b_3, [t_6]), \\quad \\text{decision}(b_2, [t_7]), \\quad \\text{next}(t_7, t_8), \\quad \\text{next}(t_8, d_4), \\quad \\text{decision}(b_4, [t_9]), \\\\\n\\text{join}([m_1, m_2], j_1), & \\quad \\text{next}(j_1, t_{10}), \\quad \\text{next}(t_{10}, b_3), \\quad \\text{decision}(b_5, [t_{11}])\n\\end{align*}\n\\]\n\nTable 18. Partial control flow information\n\nNow we want to know whether the control flow is correct. Next, we first define the syntactical correctness for control flow modeling and then demonstrate how UPL can help complete control flow design.\n**Definition 4 (Syntactical Correctness of Control Flow Design).** A control flow diagram is correct if the following conditions hold\n\n1. there is one and only one outgoing link for the start node and one and only one incoming link for the end node;\n2. there is one and only one incoming and outgoing link for each task;\n3. there must be one and only one incoming link and at least two outing links for routing construct *fork* and *branch*;\n4. there must be at least two incoming links and one and only one outing link for routing construct *join* and *merge*.\n\nNote that Definition 4 releases some assumptions we made about a process model syntactical correctness as defined in Definition 3. In particular, UPL provides predicates to model parallelism, which was not available in process map definition. Once the control flow information is represented using UPL as in Table 18, we can use auxiliary functions in Table 12 to quickly check its syntactical correctness. In particular, an algorithm for process syntactical correctness checking is developed as shown in Table 19. We use ‘\\_\\_’ to represent a single logic symbol and use ‘\\&\\_\\_’ to represent any number of symbols. For instance, \\(\\text{count}(\\text{next}(s, \\_), n)\\) returns \\(n\\) as the number of outgoing links for the start node.\n\nIf \\(n \\neq 1\\), then \\(s\\) is identified to be incorrect for control flow design. Similarly, for task \\(t_i\\), \\(\\text{count}(\\text{next}(\\_, t_i), x_1), \\text{count}(\\text{fork}(\\_, [\\&\\_\\_, t_i]), x_2), \\text{count}(\\text{branch}(\\_, [\\&\\_\\_, t_i]), x_3)\\) return the number of possible incoming links to \\(x_1, x_2,\\) and \\(x_3\\), and \\(t_i\\) is considered correctly designed only when \\((x_1 + x_2 + x_3) = 1\\).\n\n<table>\n<thead>\n<tr>\n<th><strong>INPUT:</strong></th>\n<th>control flow information in UPL</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>OUTPUT:</strong></td>\n<td>1. TRUE if the control flow is syntactical correct, otherwise</td>\n</tr>\n<tr>\n<td></td>\n<td>2. FALSE with identified problems</td>\n</tr>\n</tbody>\n</table>\n**Procedure** ControlFlowSyntacticalCorrectnessVerification\n\nBEGIN\n\n//check rule 1\n\n`count(next(s, _), n); count(next(_, e), m);`\n\nif `n ≠ 1`\n\n`return FALSE and s;`\n\n`exit;`\n\nend if\n\nif `m ≠ 1`\n\n`return FALSE and e;`\n\n`exit;`\n\nend if\n\n// check rule 2\n\nfor each task `t`\n\n`count(next(_, t), x1); count(fork(_, [&_, t]), x2); count(branch(_, [&_, t]), x3);`\n\n`count(next(ti, _), y1); count(join([&_, t], _), y2); count(merge([&_, t], _), y3);`\n\nif `(x1+x2+x3) ≠ 1`\n\n`return FALSE and t;`\n\n`exit;`\n\nend if\n\nif `(y1+y2+y3) ≠ 1`\n\n`return FALSE and t;`\n\n`exit;`\n\nend if\n\nend for\n\n//check rule 3 and 4\n\nfor each routing construct `f, b, j, m`\n\n`count(next(_, f), x1); count(fork(f, [_ , _ , &]), x2);`\n\n`count(next(_, b), x3); count(branch(b, [_ , _ , &]), x4);`\n\n`count(next(_, j), x5); count(join([& _, _], j), x6);`\n\n`count(next(_, m), x7); count(merge([& _, _], m), x8);`\n\nif `(x1≠1 or x2≠1)`\n\n`return FALSE and f;`\n\n`exit;`\n\nend if\n\nif `(x3≠1 or x4≠1)`\n\n`return FALSE and b;`\n\n`exit;`\n\nend if\n\nif `(x5≠1 or x6≠1)`\n\n`return FALSE and j;`\n\n`exit;`\n\nend if\n\nif `(x7≠1 or x8≠1)`\n\n```\nreturn FALSE and $m$;\nexit;\nend if\nend for\nEND\n\nTable 19. Algorithm for syntactical verification of control flows\n\nBy running the verification algorithm on facts in Table 18, we are able to identify control flow design problems for the travel reimbursement process as shown in Table 20. Without modeling process design in UPL, the verification of control flow syntactical correctness is largely based on human inspection. Human inspection is error-prone and very inefficient when the control flow is complicated. UPL can greatly improve process design efficiency and correctness by transforming graphical process representation into rigorous logic format and detecting design problems via automatic logic reasoning.\n\n<table>\n<thead>\n<tr>\n<th>Identified problems</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$b_1, b_2, b_3, b_4, b_5$</td>\n<td>these decision points only have one outgoing link</td>\n</tr>\n<tr>\n<td>$m_1, m_2$</td>\n<td>these merges have no incoming link</td>\n</tr>\n<tr>\n<td>$t_{11}, e$</td>\n<td>$t_{11}$ has no outgoing link and $e$ has no incoming link</td>\n</tr>\n</tbody>\n</table>\n\nTable 20. Identified design problems\n\nTable 21 shows the final control flow information after correcting identified design problem, which corresponds to the travel reimbursement process diagram in Figure 24.\n\nTable 21. Complete control flow information\nAfter the control flow design is complete, the organizational design of the process model should be conducted including identifying process related resources, such as users, role, and organization units, assigning resources to tasks, capturing process constraints, and assigning constraints to proper routing constructs. In our example, we have identified one role and four organization units from process policies as shown in Table 15. Process policies \\( p_6, p_7, p_8, p_9, \\) and \\( p_{11} \\) explicitly state how the identified resources are assigned to different tasks, which can be represented in UPL as follows: \\( \\text{execute}(r_1, t_2), \\text{execute}(r_1, t_3), \\text{execute}(g_1, t_{10}), \\text{execute}(g_2, t_8), \\text{execute}(g_4, t_{11}). \\) In order to make a process executable, each task must be assigned to some resources for execution. The query \\( \\text{count}(\\text{execute}(\\_ , t_i), n) \\) returns the number of resources assigned to a task \\( t_i \\), which enables us to easily identify tasks without resources where \\( n \\) equals to 0.\n\nFigure 24. Control flow of travel reimbursement process\nFor each routing construct branch, there must be constraints to define how to route process instance under different conditions. In our example, we have process policies p2, p3, p4, p5, p8 in Table 14 defining the routing constraints, which can be expressed in UPL as shown in Table 22. Then, we assign those constraints to different routing constructs as follows: constraint(b1, c1), constraint(b1, c2), constraint(b2, c3), constraint(b2, c4), constraint(b3, c5), constraint(b3, c6), constraint(b4, c7), constraint(b4, c8), constraint(b5, c9), constraint(b5, c10). For each decision point, there must be at least two constraints to control the routing. The query count(constraint(bi, _), n) returns the number of constraints associated with branch bi. When the query result n is less than 2, additional constraints need to be added to corresponding routing constructs.\n\nIn this section, we demonstrated that our Unified Predicate Language can record process design in a succinct and accurate manner. It can also provide process design insights and identify design problems via logic reference and queries. Next, we further validate UPL by comparing it with other process modeling languages.\n\n5.3 Comparison with other languages\n\nIn this section, we compare our proposed Unified Predicate Language (UPL) with other two well-know process modeling and analysis approaches, namely, Petri nets (van\nder Aalst 1998) and Metagraphs (Basu et al. 2000). Note that we exclude graphical languages such as UML (OMG 2003), IDEF3 (Mayer et al. 1995), and BPMN (OMG 2006) that have few analytical capability, execution languages such as BPEL (Andrews et al. 2003) and WSCI (Arkin et al. 2002), and languages used to specifically model workflow authorization constraints and exceptions (Bertino et al. 1999; Casati et al. 1999). The comparison result is shown in Table 23, where ‘n/a’ means that the information is not found in the referenced papers.\n\nCompared with the other two approaches, UPL has richer expressiveness, because it is the only approach that can represent all four major process perspectives, namely, control flow, data flow, organization model, and process constraints. In particular, Petri nets focus mainly on control flow aspect and Metagraphs totally ignore process constraint modeling. UPL is able to facilitate process design by providing design insights and identifying design problems via logic inferences and queries, which cannot be handled by other two approaches. In addition, as we will discuss in the next section, the unified logic representation of different process components also endorses UPL the capability to analyze process constraint changes, which is also missing from Petri nets and Metagraphs methods.\n\nIn terms of tool support, Petri nets based workflow modeling and analysis tools are limited and to the best of our knowledge, there is no Metagraphs based tools reported in the literature. UPL is grounded in first-order logic and its syntax is similar to the well-known logic programming language Prolog (Sterling et al. 1994). There has been many research and implementations of rule engines, such as JESS and XSB, which enable UPL to take advantage of those rule engines for execution. Although by itself UPL has no graphical\ninterface, due to the clearly defined process modeling predicates with formal semantics, visual representation for UPL can be easily developed.\n\n<table>\n<thead>\n<tr>\n<th>Control Flow Modeling</th>\n<th>UPL</th>\n<th>Petri nets</th>\n<th>Metagraphs</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>● Sequential</td>\n<td>● Sequential</td>\n<td>● Sequential</td>\n<td>● Sequential</td>\n</tr>\n<tr>\n<td>● Fork/Join</td>\n<td>● Fork/Join</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>● Branch/Merge</td>\n<td>● Branch/Merge</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>● Iteration</td>\n<td>● Iteration</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Data Flow Modeling</td>\n<td>● Data dependency</td>\n<td>n/a</td>\n<td>Data-task interaction</td>\n</tr>\n<tr>\n<td>● Data-task interaction</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Organization Modeling</td>\n<td>● Users, roles, groups</td>\n<td>n/a</td>\n<td>roles</td>\n</tr>\n<tr>\n<td>● Role hierarchy</td>\n<td>● Role hierarchy</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>● Authorization</td>\n<td>● Authorization</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>● Inheritance</td>\n<td>● Inheritance</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Process Constraint Modeling</td>\n<td>● Assignment constraint</td>\n<td>Routing constraint</td>\n<td>n/a</td>\n</tr>\n<tr>\n<td>● Routing constraint</td>\n<td>● Routing constraint</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>● Policy constraint</td>\n<td>● Policy constraint</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Graphical Representation</td>\n<td>No</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>Process Design Facilitation</td>\n<td>Yes</td>\n<td>n/a</td>\n<td>n/a</td>\n</tr>\n<tr>\n<td>Constraint Change Analysis</td>\n<td>Yes</td>\n<td>n/a</td>\n<td>n/a</td>\n</tr>\n<tr>\n<td>Tool support</td>\n<td>most rule engines, e.g., JESS, XSB, etc.</td>\n<td>Woflan</td>\n<td>n/a</td>\n</tr>\n</tbody>\n</table>\n\nTable 23. Comparisons of three process modeling and analysis approaches\n\nIn this section, we proposed a Unified Predicate Language (UPL) to unify the representation of different process perspectives. We demonstrated power of UPL by applying it to process design. We also illustrated the advantages of UPL over other process modeling languages through a comparison. Besides all the features we have discussed so far, UPL also enables the change analysis among different process perspectives as we will present next.\n6. PROCESS CHANGE ANALYSIS\n\nTo be successful and competitive, organizations need to quickly adapt their business processes to changes in the business environment, such as mergers/acquisitions, new regulations and customer demand, and advance of technology. For organizations with large scale business processes, maintaining process consistency under various changes is a very challenging task. Although process changes have been discussed in adaptive and flexible workflow research area, most existing discussions are usually focusing on changes within one process perspective, such as control flow (Kammer et al. 2000; Sadiq et al. 2000; van der Aalst 2001), data flow (Sadiq et al. 2004), and process constraints (Casati et al. 2001; Casati et al. 1999). Little research has been done on the analysis of change relationship among different process perspectives. For instance, questions like “how the remodeling of organization structure due to the merger can affect our existing processes?” and “what are the consequences of removing these tasks in terms of process consistency?” cannot be easily answered without a systematic mechanism of process change analysis. Consequently, most existing business process management systems lack process change analysis capability and cannot support efficient and flexible process adaptation.\n\nIn this section, we first summarize different types of changes into three basic operations on different process components, i.e., insertion, deletion, and update. Then, we discuss process change relationship and focus on how changes in control flow and organization model can affect process constraint. We use UPL to formally define the\ndifferent types of process constraint anomalies due to process changes and develop algorithms to verify and enforce process consistency. The algorithm is validated via an example. Next, we first describe an example process we will in the rest of this section.\n\n6.1 A Procurement Approval Process\n\nA procurement approval workflow is represented using an UML activity diagram in Figure 25, and each task is described in Table 24. Basically, this process consists of two major parts: procurement request approval and order processing.\n\n<table>\n<thead>\n<tr>\n<th>Task</th>\n<th>Name</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>t1</td>\n<td>Purchase Request</td>\n<td>Employees submit purchase request.</td>\n</tr>\n<tr>\n<td>t2</td>\n<td>Supervisor Approval</td>\n<td>The supervisor of task initiator approves the request</td>\n</tr>\n</tbody>\n</table>\n\nFigure 25. Procurement process in UML\nWhen request amount is greater than 1000, a checking is conducted to make sure there is sufficient fund.\n\nWhen fund is sufficient, higher level manager needs to approve.\n\nPurchase Request is reviewed and sent to inventory. PO is requested to be printed.\n\nInventory checking. If in stock, start shipping; otherwise back order.\n\nPO is printed.\n\nThe requested item is back ordered.\n\nProper department is billed for the items ordered.\n\nItem is shipped.\n\nThe purchase transaction information is summarized and archived.\n\nThe requestor is notified that his/her purchase request is declined via email.\n\nThe control flow can be represented using UPL as shown below:\n\n```\nnext(s, t1), next(t1, t2), next(t2, b1), branch(b1, [b2, t12]), branch(b2, [t3, t5]), next(t3, b3),\nbranch(b3, [t4, t12]), next(t4, b4), branch(b4, [t5, t12]), next(t5, t7), next(t7, b5), branch(b5, [t8, f1]),\nnext(t8, b6), branch(b6, [t7, m1]), fork(f1, [t6, t9]), next(t9, t10), join([t6, t10], j1),\nmerge([j1, b6], m1), next(m1, t11), merge([t11, t12], m2), next(m2, e)\n```\n\nThe data items in the procurement approval process are summarized in Table 26. The role hierarchy associated with the workflow is presented in Figure 26. The employee appointment information (user-role assignment) is as follows: GM: {John}; ED: {Joe}; PD: {Jason}; AD: {Maggie}; SE: {Eric, Ray}; PC: {Peter}; IC: {Sam}; DC: {Dan, Jack};\nAC: {Steve, Ben}.\n\nd₁: purchase request; d₂: supervisor approval; d₃: purchase amount; d₄: fund amount; d₅: mgmt approval; d₆: requested item amount; d₇: requested item inventory; d₈: back order time; d₉: item receiving time; d₁₀: purchase order; d₁₁: billing information; d₁₂: shipping information; d₁₃: purchase archive; d₁₄: disapproval notice\n\nTable 26. Data items in procurement process\n\n\n\nThe organizational model in Figure 26 can be expressed as the logical statements in Table 27.\n\nmanage(GM, ED), manage(GM, PD), manage(GM, AD), manage(ED, SE), manage(PD, PC), manage(PD, IC), manage(PD, DC), manage(AD, AC), role(John, GM), role(Joe, ED), role(Jason, PD), role(Maggie, AD), role(Eric, SE), role(Ray, SE), role(Peter, PC), role(Sam, IC), role(Jack, DC), role(Dan, DC), role(Steve, AC), role(Ben, AC)\n\nTable 27. Organization structure in UPL\n\nGiven the build-in rules on role hierarchy and authorization inheritance shown in Table 13, we can retrieve useful information by querying the organizational facts. For instance, query manage(_, Eric) shows the supervisor of Eric, which is Joe in this case and query manage(Jason, Eric) returns False, because Jason is not the manager of Eric. These\nqueries are used to implement runtime user or role resolution and can also be utilized to analyze organizational structure changes.\n\n<table>\n<thead>\n<tr>\n<th>Constraint</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>c1</td>\n<td>t2 (Supervisor Approval) must be executed by the supervisor of the purchase requestor.</td>\n</tr>\n<tr>\n<td>c2</td>\n<td>t3 (Fund Checking) must be executed by an Accounting Clerk (AC).</td>\n</tr>\n<tr>\n<td>c3</td>\n<td>The role associated with t4 (Mgmt. Approval) must be the supervisor of the role that executes t2.</td>\n</tr>\n<tr>\n<td>c4</td>\n<td>t5 (Purchasing) is handled by a Purchasing Clerk (PC)</td>\n</tr>\n<tr>\n<td>c5</td>\n<td>t6 (Inventory Checking) is conducted by an Inventory Clerk (IC).</td>\n</tr>\n<tr>\n<td>c6</td>\n<td>t9 (Billing) must be handled by a Distribution Clerk (DC).</td>\n</tr>\n<tr>\n<td>c7</td>\n<td>t10 (Shipping) must be handled by a Distribution Clerk (DC).</td>\n</tr>\n<tr>\n<td>c8</td>\n<td>t11 (Archiving) is handled by a Purchasing Clerk (PC).</td>\n</tr>\n<tr>\n<td>c9</td>\n<td>t1 (Purchase Request) and t3 (Fund Checking) cannot be done by the same person.</td>\n</tr>\n<tr>\n<td>c10</td>\n<td>t5 (Billing) and t10 (Shipping) must be handled by the same person.</td>\n</tr>\n<tr>\n<td>c11</td>\n<td>if supervisor approves the request, b2 will be activated.</td>\n</tr>\n<tr>\n<td>c12</td>\n<td>if supervisor does not approve the request, t12 (disapproval notification) is activated.</td>\n</tr>\n<tr>\n<td>c13</td>\n<td>if request amount is greater than one thousand, t3 (Fund Checking) is executed.</td>\n</tr>\n<tr>\n<td>c14</td>\n<td>if request amount is less than one thousand, t5 (Purchasing) is executed.</td>\n</tr>\n<tr>\n<td>c15</td>\n<td>if there is enough fund, then t4 (Mgmt Approval) is executed.</td>\n</tr>\n<tr>\n<td>c16</td>\n<td>if there is not enough fund, t12 (disapproval notification) is activated.</td>\n</tr>\n<tr>\n<td>c17</td>\n<td>if management approves the request, t5 (Purchasing) is executed.</td>\n</tr>\n<tr>\n<td>c18</td>\n<td>if management does not approve the request, t12 (disapproval notification) is activated.</td>\n</tr>\n<tr>\n<td>c19</td>\n<td>if requested items are out of stock, t8 (Back Order) is executed.</td>\n</tr>\n<tr>\n<td>c20</td>\n<td>if requested items are in stock, a set of parallel order processing tasks are executed.</td>\n</tr>\n<tr>\n<td>c21</td>\n<td>if items are received within 6 days after back ordering, inventory should be updated and rechecked.</td>\n</tr>\n<tr>\n<td>c22</td>\n<td>if items are not received 6 days after being back-ordered, the request should be archived and completed.</td>\n</tr>\n</tbody>\n</table>\n\nTable 28. Constraints of requisition approval process\nTo ensure the proper execution of the process, roles and users may be assigned to tasks and process constraints should be specified to enforce business requirements. Table 28 shows the constraints for the requisition approval process. Constraints $c_1$ through $c_8$ are role-task assignments. Constraint $c_9$ is an instance of separation of duties policy, whereas $c_{10}$ is a binding of duties policy. Constraints $c_{11}$ through $c_{22}$ are routing rules for the six decision points in the process. In particular, $c_1$, $c_3$, $c_9$, $c_{10}$, and $c_{11}$ to $c_{22}$ are dynamic constraints, which can be evaluated only during process execution. These constraints can be precisely represented in UPL as follows:\n\n<table>\n<thead>\n<tr>\n<th>Constraint</th>\n<th>UPL Representation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$c_1$: execute($r_i$, $t_2$) ← manage($r_i$, $r_j$), execute($r_i$, $t_1$)</td>\n<td>$c_{11}$: next($b_1$, $b_2$) ← true($d_3$)</td>\n</tr>\n<tr>\n<td>$c_2$: execute($AC$, $t_3$)</td>\n<td>$c_{12}$: next($b_1$, $t_{12}$) ← false($d_3$)</td>\n</tr>\n<tr>\n<td>$c_3$: manage($r_i$, $r_j$) ← execute($r_i$, $t_4$), execute($r_j$, $t_2$)</td>\n<td>$c_{13}$: next($b_2$, $t_3$) ← greaterequal($d_3$, 1000)</td>\n</tr>\n<tr>\n<td>$c_4$: execute($PC$, $t_5$)</td>\n<td>$c_{14}$: next($b_2$, $t_5$) ← less($d_3$, 1000)</td>\n</tr>\n<tr>\n<td>$c_5$: execute($IC$, $t_6$)</td>\n<td>$c_{15}$: next($b_3$, $t_4$) ← greaterequal($d_3$, $d_3$, 0)</td>\n</tr>\n<tr>\n<td>$c_6$: execute($DC$, $t_9$)</td>\n<td>$c_{16}$: next($b_3$, $t_{12}$) ← less($d_3$, $d_3$, 0)</td>\n</tr>\n<tr>\n<td>$c_7$: execute($DC$, $t_{10}$)</td>\n<td>$c_{17}$: next($b_4$, $t_3$) ← true($d_3$)</td>\n</tr>\n<tr>\n<td>$c_8$: execute($PC$, $t_{12}$)</td>\n<td>$c_{18}$: next($b_4$, $t_3$) ← false($d_3$)</td>\n</tr>\n<tr>\n<td>$c_9$: cannot_execute($u_i$, $t_3$) ← execute($u_i$, $t_4$)</td>\n<td>$c_{19}$: next($b_5$, $t_8$) ← greater($d_6$, $d_7$)</td>\n</tr>\n<tr>\n<td>$c_{10}$: execute($u_i$, $t_{10}$) ← execute($u_i$, $t_9$)</td>\n<td>$c_{20}$: next($b_5$, $f_1$) ← lessequal($d_6$, $d_7$)</td>\n</tr>\n<tr>\n<td></td>\n<td>$c_{21}$: next($b_6$, $t_7$) ← lessequal($d_9$, $d_8$, 6)</td>\n</tr>\n<tr>\n<td></td>\n<td>$c_{22}$: next($b_6$, $m_1$) ← greater($d_9$, $d_8$, 6)</td>\n</tr>\n</tbody>\n</table>\n\nTable 29. Process Constraints in UPL\n\nGiven the UPL representation of the workflow model, we will show later in this section that process change analysis can be carried out via logic inference and queries. Next, we first study the types of process changes and change relationship among different process components.\n6.2 Process Change Types and Relationship\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Insertion</th>\n<th>Deletion</th>\n<th>Update</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Control flow</td>\n<td>● Adding a task</td>\n<td>● Remove a task</td>\n<td>● Change task execution order</td>\n</tr>\n<tr>\n<td></td>\n<td>● Adding a routing construct</td>\n<td>● Remove a routing construct</td>\n<td>● Change sequential execution into parallel execution</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Organization</td>\n<td>● Hire a employee</td>\n<td>● Employee leaves organization</td>\n<td>● Reassign employee to a new position</td>\n</tr>\n<tr>\n<td></td>\n<td>● Create a new position (role)</td>\n<td>● Remove a position</td>\n<td>● Reorganize the members of an organization unit</td>\n</tr>\n<tr>\n<td></td>\n<td>● Create an organization unit</td>\n<td>● Dismiss an organization unit</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Data flow</td>\n<td>● Adding new data item</td>\n<td>● Remove data item</td>\n<td>● Change data item value</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Constraints</td>\n<td>● Assign more resources to task</td>\n<td>● Remove resources from task execution</td>\n<td>● Revise routing conditions</td>\n</tr>\n<tr>\n<td></td>\n<td>● Assign more constraints to routing constructs</td>\n<td>● Remove routing constraints</td>\n<td>● Revise process execution rules</td>\n</tr>\n<tr>\n<td></td>\n<td>● Define more process execution rules,</td>\n<td>● Remove process execution rules</td>\n<td>such as temporal constraints, dynamic authorization constraints,</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td>exception handling constraints</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTable 30. Classification of process changes\n\nA process model has four major components, namely, control flow, data flow, organizational model, and constraints. Different changes can occur to any one of those components, e.g., altering task execution sequence, relocating organization resources, adding constraints for regulation compliance, etc. Although different changes have different semantics, all those changes can be classified into three basic operations from database implementation perspective, i.e., Insertion, Deletion, and Update. For example, adding a task is an insertion change to the control flow, removing a role is a deletion change\nto the organizational model, and redefining the routing conditions for a decision point is an update change to process constraints. Table 30 demonstrates some typical process changes.\n\nGiven that different process components interact with one another in a process model, changes in one component can have significant consequences in other components. For instance, process redesign that removes a set of non-value-added tasks may lead to organization downsizing, and process policy changes may force adding additional tasks. For organizations with large scale business processes, identifying change consequences to different process components in an efficient way is a very challenging task. Figure 27 illustrates the change relationships among different process component, which are discuss in more detail as follows:\n\nFigure 27. Change relationships among process components\n\n- Change relationship 1. The changes in the control flow can greatly affect process constraint consistency. For example, we have a separation of duty constraint saying “Purchase request and fund checking cannot be done by the same person”. If the task fund checking is removed due to process redesign, the constraint will never be violated.\nHowever, if the constraint is not removed or inactivated, the workflow system will still keep evaluating and enforcing this constraint resulting in waste of system resources and inefficiency.\n\n- Change relationship 2. Data is produced and consumed by tasks in the control flow. Data dependency and anomalies have been studied in (Sadiq et al. 2004; Sun et al. 2004b). The changes in control flow may lead to data flow anomalies, which can cause runtime data access errors or data inconsistency. For instance, if a task $t_1$ consumes a data item produced by $t_2$, a missing data error will occur if $t_2$ is removed.\n\n- Change relationship 3. Some process constraints are defined based on data item values. For example, a routing constraint may define that “if the credit score of the applicant is above 750, then a special APR is applied”. This constraint relies on the credit score for its evaluation. If this credit score data item is not produced by tasks before this constraint is evaluated, a runtime error occurs.\n\n- Change relationship 4. Processes are running in an organization setting. When organization changes, processes are also subject to change. For instance, mergers/acquisitions may result in integrating business processes from different organizations, in which the control flow must be refined to best serve the new organization’s structure.\n\n- Change relationship 5. A major set of process constraints are related to resource-task assignment. When some organizational resources become unavailable, assignment constraints must be revised to avoid runtime resource resolution errors. For instance, a constraint can specify that “the inventory clerk is responsible for back order all items...”\nthat are out of stock”. This constraint assigns a role “inventory clerk” to a task “back ordering”. When the role “inventory clerk” is unavailable, either the role is removed or no employee is currently assigned to the role, another user or role must be delegated to handle the task. Otherwise, the process is stalled resulting in long cycle time and low customer satisfaction.\n\nAnalyzing each of the changes aforementioned in detail is not the focus of this dissertation. Instead, we aim to show how process changes among different process components can be formally analyzed using our proposed unified predicate language. Given process constraints contains information on all other three process components, we emphasize on how the changes in control flow and organization model can affect process constraints, i.e., change relationship 1 and 5. Next, we first investigate a set of potential process constraint anomalies due to process changes.\n\n6.3 Process Constraint Anomalies\n\nProcess constraints are business rules defined to control and restrict process execution. We can classify process constraints into three categories, namely, Routing Constraints, Assignment Constraints, and Policy Constraints. Routing constraints defines the routing conditions for each decision point in the control flow. Assignment constraints define who executes each task and what routing constraints are related to each routing construct. Authority constraints represent the organizational structure and use-role relationship. Policy constraints specify the rules that the process execution must follow, e.g., a separation of duty policy may state that an employee cannot approve the procurement\nrequest submitted by himself, and a temporal policy may require a credit approval task to complete within three days.\n\nProcess constraints can involve information on control flow, data flow, and organization, which includes all process elements, i.e., task, routing construct, data, user, role, and organization units. Therefore, when changes happen to those process elements, process constraints must be verified for correctness and consistency, otherwise process constraint anomalies can occur. In particular, process constraint anomalies can be classified into four categories, namely, *Missing Constraints*, *Redundant Constraint*, *Invalid Constraint*, and *Conflicting Constraint*, which are described in detail as follows:\n\nMissing constraint anomaly occurs when a process cannot be properly executed due to the lack of assignment constraints. The following scenarios can cause missing constraint anomaly.\n\n**Scenario 1.** A task has no resource associated with it for execution.\n\n**Scenario 2.** A decision point has no constraint associated with it to specify routing conditions.\n\nConstraints are identified as redundant if they are never evaluated in process execution. Redundant constraints are usually caused by the deletion of tasks and routing constructs and can result in inefficiency and waste of resources. The following scenarios can cause redundant constraint anomaly.\n\n**Scenario 3.** All tasks and routing constructs in the constraint do not exist. For example, constraint $c_8$ says that $t_{11}$ (Archiving) is handled by a Purchasing Clerk (PC). If $t_{11}$ is removed, $c_8$ becomes a redundant constraint although role ‘PC’ still exists, because $c_8$ is\nnever evaluated.\n\nInvalid constraints contain erroneous information, which leads to runtime process execution exceptions. The following scenarios can cause invalid constraints.\n\n**Scenario 4.** Resources or constraints specified in assignment constraints do not exist. For example, constraint c7 says t_{10} (Shipping) must be handled by a Distribution Clerk (DC). If role ‘DC’ is not available, c_{7} becomes an invalid constraint that leads to a runtime role resolution exception.\n\n**Scenario 5.** Task information in routing constraints does not exist. For example, routing constraint c_{13} defines that if request amount is greater than one thousand, t_{3} (Fund Checking) is executed. If t_{3} is deleted, c_{13} becomes an invalid resulting in a runtime routing exception.\n\nConflicting constraint anomaly occurs when there are constraints that contradict with one another preventing process from normal execution. The following scenarios can cause conflicting constraint anomaly.\n\n**Scenario 6.** There are conflicting assignment constraints. For instance, if there is one constraint specifying a role r_{i} can execute task t_{j}, while another constraint defines that r_{i} cannot execute task t_{j}, a contradiction is reached.\n\n**Scenario 7.** There are conflicting routing constraints. For instance, if there is one constraint specifying task t_{m} is executed after task t_{n}, while another constraint defines that t_{k} is executed after task t_{n}, a routing confliction happens.\n\nGiven the four types of process constraint anomalies, the process constraints must be verified when changes happen to process model. Proper actions must also be taken\naccording to the anomaly types to remove inconsistency. Specifically, additional\nconstraints need to be added to remove missing constraint anomaly. Redundant constraints\ncan be directly deleted or disabled. Invalidated and conflicting constraints need to be\nrevised to preventing runtime exceptions. However, in this paper we focus on detecting\nprocess constraint anomalies and leave the anomalies correction to future research.\n\nIt is also worth noting that based on the time that process constraints can be evaluated\nthey can also be classified into two categories: static vs. dynamic. Static constraints can be\nchecked without running workflow, whereas dynamic constraints can only be enforced and\nevaluated during workflow runtime. For instance, constraint c1: t2 (Supervisor Approval)\nmust be executed by the supervisor of the purchase requestor is a dynamic role resolution\nconstraint, where the role to execute t2 can only be decided during runtime. Other\nwell-know dynamic process constraints including separation of duties and binding of\nduties. As we will present later, dynamic constraints can transformed into static ones\nduring runtime for consistency verification. Next, we present the verification rules\ndefined using our unified predicate language, which enables the automatic detection of\nprocess constraint anomalies.\n\n6.4 Process Constraint Verification\n\nAccording to the definition of unified predicate language, a process model includes\nthe following process elements: a set of tasks $T$, a set of routing constructs $RC=\\{f, j, b, m\\}$,\na set of data items $D$, a set of resources including users $U$, roles $R$, groups $G$, and a set of\nconstraints $C$. We also define that for any constraint $c$, the involved tasks, routing\nconstructs, data, resources, and constraints are denoted as $T_c, RC_c, D_c, U_c, R_c, G_c, C_c$.\n\n**Lemma 1 (Condition for Missing Constraint Anomaly).** Missing constraint anomaly occurs if $\\exists t_i, \\text{count}(\\text{execute}(\\_, t_i), n), n = 0$ or if $\\exists b_j, \\text{count}(\\text{constraint}(b_j, \\_), m), m < 2$.\n\nDiscussion: $\\text{count}(\\text{execute}(\\_, t_i), n)$ returns the number of resources assigned to task $t_i$. $n = 0$ means that there is no resource assigned to task $t_i$, therefore a missing constraint anomaly happens. $\\text{count}(\\text{constraint}(b_j, \\_), m)$ returns the number of routing constraints associated with $b_j$. A decision point must have at least outgoing links, which means there must be at least two routing constraints associated with $b_j$. Therefore, when $m$ is less than 2, a missing constraint anomaly occurs.\n\n**Lemma 2 (Condition for Redundant Constraint Anomaly).** Redundant constraint anomaly occurs if the following conditions hold for any constraint $c$: $\\forall t_i \\in T_c, t_i \\notin T$ and $\\forall rc_j \\in RC_c, rc_j \\notin RC$.\n\nDiscussion: $\\forall t_i \\in T_c, t_i \\notin T$ means that any tasks defined in the constraint does not exist in the control flow. Similarly, $\\forall rc_j \\in RC_c, rc_j \\notin RC$ means that any routing constructs specified in the constraint does not exist. If the tasks and routing constructs in the constraint do not exist, the constraint will never be evaluated during process execution, which makes it a redundant constraint.\n\n**Lemma 3 (Condition for Invalid Constraint Anomaly).** Invalid constraint anomaly occurs if for any of the following conditions hold for a constraint $c$:\n\n1) $\\exists x, x \\in U_c \\cup R_c \\cup G_c, x \\notin U \\cup R \\cup G$\n\n2) $\\exists \\text{next}(a, b), a \\in T \\cup RC, b \\notin T \\cup RC$\n\n3) $\\exists e, e \\in C_c, e \\notin C$. \nDiscussion: Conditions 1 states that some resources assigned to a task have been removed resulting in an invalid constraint, because the system could not find the specified resource to execute the task. Condition 2 specifies while a particular task has been removed there are still constraints defining routing path to the deleted task. Condition 3 represents invalid association between non-exist constraints to tasks and routing constructs.\n\n**Lemma 4 (Condition for Conflicting Constraint Anomaly).** Conflicting constraint anomaly occurs if any of the following conditions hold: 1) $\\text{execute}(x, y)$ and $\\text{cannot_execute}(x, y)$ both exist; 2) $\\text{count}(\\text{next}(t, _), n)$, $n > 1$\n\nDiscussion: Condition 1 means that there exists conflicting resource assignment. Condition 2 means that task $t_i$ has more than one outgoing links.\n\n**Theorem 1 (Process Constraint Consistency).** A set of process constraints is consistent if they are free from missing, redundant, invalid, and conflicting process constraint anomalies, which means the following conditions are satisfied:\n\n1) $\\forall t, \\text{count}(\\text{execute}(\\_, t), m) \\geq 0$\n\n2) $\\forall b, \\text{count}(\\text{constraint}(b, _), n) \\geq 2.$\n\n3) $\\forall c, T_c \\subseteq T, R_c \\subseteq R, U_c \\subseteq U, R_c \\subseteq R, G_c \\subseteq G, C_c \\subseteq C$\n\n4) $\\exists c_i : \\text{execute}(x, y), c_j : \\text{cannot_execute}(x, y)$ where $c_i \\in C$ and $c_j \\in C$\n\n5) $\\forall t, \\text{count}(\\text{next}(t, _), k) \\leq 1$\n\n**Proof:** Let Lemmas 1, 2, 3, and 4 be the only situations under which process constraint anomalies can occur. We use enumeration to prove that a set of process constraints will avoid those situations if they satisfy the five conditions in theorem 1. First, $\\forall t, \\text{count}(\\text{execute}(\\_, t), m) \\geq 0$ ensures that there is at least one resource is assigned to each\ntask, and $\\forall b, \\text{count}(\\text{constraint}(b_\\_), n), n \\geq 2$ ensures that each decision point has at least two constraints defining different routing conditions. According to Lemma 1, missing constraint anomaly is avoided. Second, $\\forall c, T_c \\subseteq T$, $RC_c \\subseteq RC$, $U_c \\subseteq U$, $R_c \\subseteq R$, $G_c \\subseteq G$, $C_c \\subseteq C$ means that all process elements involved in every constraint exists in the process model. According to Lemma 2 and 3, redundant and invalid constraint anomalies cannot occur. Finally, $\\forall c : \\text{execute}(x, y)$, $c_j : \\text{cannot}_\\_\\text{execute}(x, y)$ where $c_i \\in C$ and $c_j \\in C$ prevents contradictory assignment constraints, and $\\forall t, \\text{count}(\\text{next}(t, _\\_), k), k = 1$ ensures there is only one outgoing link from each task, which prevents contradictory routing constraints. According to Lemma 4, conflicting constraint anomaly is prevented. Therefore, theorem 1 holds.\n\nTheorem 1 provides the theoretical foundation for automatic detection of process constraint anomalies. Based on theorem 1, we developed a constraint verification algorithm using unified predicate language as shown in Table 31. The algorithm can not only identify four types of process constraint anomalies, it can also pinpoint the process element causing the anomaly, which greatly improves the effectiveness and efficiency of anomaly correction. By applying the algorithm to process constraints shown in Table 29, we can identify four missing policies for tasks $t_1$ (Purchase Request), $t_2$ (Supervisor Approval), $t_4$ (Mgmt. Approval), $t_7$ (Print PO). In particular, $t_1$ can be executed any employee in the organization. We add one meta role ‘Any Employee’ and assign it to $t_1$ by adding a constraint $c_{23}: \\text{execute}(\\text{’Any Employee’}, t_1)$. As defined in constraints $c_1$ and $c_3$, the roles executing tasks $t_2$ and $t_4$ are dynamically resolved based on role hierarchy. We add\nanother meta role ‘Dynamic Role’ to execute t_2, t_4 for achieving static process consistency. Therefore, two more constraints are added: c_{24}: execute('Dynamic Role', t_2), c_{25}: execute('Dynamic Role', t_4). In addition, we assign ‘purchasing clerk’ to execute t_7 by adding constraint c_{26}: execute('PC', t_7), which makes process constraints in the procurement approval process consistent.\n\n**INPUT**: Facts on process model including sets of T(tasks), RC(routing constructs), D(data items), U(users), R(roles), G(groups), C(constraints)\n\n**OUTPUT**: 1) SUCCESS if the set of process constraints is consistent\n2) MISSING if there is a missing constraint anomaly\n3) REDUNDANT if there is a redundant constraint anomaly\n4) INVALID if there is a invalid constraint anomaly\n5) CONFLICTING if there is a conflicting constraint anomaly\n\n**Procedure** ProcessConstraintVerification\n\nBegin\n\nfor each \\( t_i \\in T \\)\n\n\\[\n\\text{count(execute(\\_, t_i), m)}; \\\\\n\\text{count(next(t_i, \\_), n)};\n\\]\n\nif \\( m = 0 \\) then\n\nreturn MISSING and \\( t_i \\) // missing assignment constraint identified\n\nexit;\n\nend if\n\nif \\( n > 1 \\) then\n\nreturn CONFLICTING and \\( t_i \\) // conflicting routing constraint identified\n\nexit;\n\nend if\n\nfindall(execute(\\_, t_i), S_1);\n\nfindall(cannot_execute(\\_, t_i), S_2);\n\nif \\( (S_1 \\cup S_2) \\cap (U \\cup R \\cup G) = \\emptyset \\) then\n\nreturn INVALID and \\( t_i \\) // invalid assignment constraint identified\n\nexit;\n\nend if\n\nend for\n\nfor each \\( rc_j \\in RC \\)\n\n\\[\n\\text{count(constraint(rc_j, \\_), n)}\n\\]\n\nif \\( n < 2 \\) then\n\nreturn MISSING and \\( rc_j \\) // missing routing constraint identified\n\nend if\n\nend for\nAs we mentioned before, dynamic process constraints can only be evaluated during workflow execution. In order to leverage algorithm in Table 31 for dynamic constraint verification, we adopt generate-and-test technique widely used in logic programming to\ntransform dynamic constraints into static ones during workflow runtime. Before each task is executed, we first assert new facts as the task has been completed and run the verification algorithm. If anomalies are detected, we suspend workflow execution, retract newly inserted facts, and trigger a dynamic constraint violation alert.\n\nSo far, we have verified that process constraints in procurement process are consistent. Next, we propose some process changes in the example processes and show what process constraint anomalies can be detected after those changes, which further validate our constraint verification algorithm.\n\n6.5 Validation of the Constraint Verification Method\n\nIn this section, we propose a set of process changes to the procurement approval process and show how the verification algorithm presented in the previous section can help detect different types of process anomalies.\n\n<table>\n<thead>\n<tr>\n<th>Insertion</th>\n<th>Deletion</th>\n<th>Update</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Control flow</strong></td>\n<td><strong>Organization</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>$t_{13}$ (Procurement Notification) is added</td>\n<td>a new role ‘<em>Vice President (VP)</em>’ is added</td>\n<td>$t_5$ (Purchasing) is modified to include inventory checking task.</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>$t_3$ (fund checking), $t_6$ (Print PO), $t_7$ (inventory checking), $t_{11}$ (Archiving), $b_3$ are removed</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>previous inventory clerks are reassigned as purchasing clerks</td>\n</tr>\n</tbody>\n</table>\n\nTable 32. Changes in the procurement process\n\nThe changes are listed in Table 32. In particular, a new task $t_{13}$ (Procurement Notification) is added to notify the purchase requestor that the item has been shipped or is out of stock. Tasks $t_3$ (fund checking), $t_7$ (inventory checking) are removed to shorten the\napproval cycle time and improve overall process efficiency. Due to the integration of ERP and workflow system, tasks $t_6$ (Print PO) and $t_{11}$ (Archiving) are automatically handled by computers in a digital format, which are removed from process model. For organizational model, a new role ‘Vice President’ is added, while role ‘Inventory Clerk’ is removed by assigning all inventory clerks to role ‘purchasing clerk’.\n\nThe new control flow diagram is shown in Figure 28 and its corresponding UPL representation is presented in Table 33. The new organization chart is shown in Figure 29, which is represented in UPL in Table 34.\n\nFigure 28. Redesigned procurement process\n\nnext($s$, $t_1$), next($t_1$, $t_2$), next($t_2$, $b_1$), branch($b_1$, [$b_2$, $t_{12}$]), branch($b_2$, [$t_4$, $t_5$]), next($t_4$, $b_4$), branch($b_4$, [$t_5$, $t_{12}$]), next($t_5$, $b_5$), branch($b_5$, [$t_8$, $t_9$]), next($t_8$, $b_6$), branch($b_6$, [$t_5$, $m_1$]), next($t_9$, $t_{10}$), merge([$t_{10}$, $b_6$], $m_1$), next($m_1$, $t_{13}$), merge([$t_{13}$, $t_{12}$], $m_2$), next($m_2$, $e$)\n\nTable 33. Redesigned procurement process in UPL\nAfter applying constraint verification algorithm to the process model after changes, we can identify one missing constraint, four redundant constraints, and four invalid constraints. In particular, `count(execute(_, t13), m)` and `m = 0` shows that `t13` (Procurement Notification) has no resource assigned to it. We add a role ‘Agent’ to represent computer system, such as email server, printer, etc. and assign it to `t13` by adding constraint `c27`: `execute('Agent', t13).\n\nFor constraint `c2`: `execute(AC, t3)`, `t3` has been removed which makes `c2` never be evaluated. According to Lemma 2, `c2` is identified as a redundant constraint. Similarly, `c5`, `c8`, and `c25` are also identified as redundant. These redundant constraints are directly\nremoved. Constraint $c_{13}$: $\\text{next}(b_2, t_3) \\leftarrow \\text{greaterEqual}(d_3, 1000)$ defines that $t_3$ is triggered after $b_2$ if $d_3$ is greater or equal to 1000. However, due to the deletion of $t_3$, the evaluation of constraint will lead to a runtime process exception. According to Lemma 3, $c_{13}$ is identified as an invalid constraint. In the same way, $c_{15}$, $c_{16}$, $c_{21}$ are also detected as invalid. According to different constraint type, different actions may be taken to correct invalid process constraint anomalies. For instance, constraint $c_{13}$ should be revised as $\\text{next}(b_2, t_4) \\leftarrow \\text{greaterEqual}(d_3, 1000)$ to reflect the change of task deletion and different routing path. For the binding of duty constraint $c_9$: $t_1$ (Purchase Request) and $t_3$ (Fund Checking) cannot be done by the same person, it can be removed because task $t_3$ has been deleted.\n\nIn this section, we use an example to validate our constraint verification algorithm and a set of process constraint anomalies were detected. Next, we discuss the design of a process change analysis tool developed based on the constraint verification algorithm.\n\n6.6 Design of a Process Change Analysis Tool\n\nOnce a process model is formalized using process designer, a corresponding process representation in our Unified Predicate Language (UPL) can be generated. Then, the algorithms for design correctness checking and constraint verification presented in section 5.2 and 6.4 can be applied. We have been developing a logic-based process change analysis tool named Process Change Analyzer (PCA) by adopting the well-know Java-based rule engine (http://www.jessrules.com/) and map our UPL into Jess language.\n\nJess is one of the most popular Java-based rule engines developed at Sandia National Laboratories (Friedman-Hill 2003). Jess is free for academic use and has many\nunique features including backwards chaining and working memory queries, and\ncapability of directly manipulating and reasoning about Java objects. Jess also provides a\npowerful Java scripting environment, where Java objects can be created and Java APIs\ncan be called. Jess program can also be invoked in Java program, which enables easy\nintegration between Jess-based Process Change Analyzer with Java-based process design\ntools we discussed in section 4.5. In addition, Jess also provides an IDE based on Eclipse,\nwhich further simplify Jess application development as shown in Figure 30.\n\nFigure 30. Constraint verification algorithm implemented using Jess\n\nGiven that the syntax of UPL is similar to Jess language, the mapping between UPL\npredicates to Jess constructs is easily implemented. In particular, fact templates are used\nto define the routing constructs fork, join, branch, and merge, which include unordered\nlist of multiple tasks. Sequential execution, data flow, and organizational models are\nsimply mapped into ordered fact lists. Then, the algorithm for constraint verification is\ntranslated into a set of Jess rules. Another set of Jess functions are created to control Jess\nprogram logic and the interaction with users. Process changes are carried out by\nmodifying the fact base using Jess build-in function ‘assert’ and ‘retract’. ‘assert’ inserts\na new fact into the fact base, whereas ‘retract’ removes a fact, e.g., assert (next t2 t5)\ninserts a new link between task t2 and t5. Whenever the fact base is changed, i.e., the\nprocess model is changed, the verification rules are triggered and the verification results\nare inferred.\n7. CONCLUSIONS\n\nToday, workflow management systems have been widely deployed in organizations to help streamline their business processes, improve product quality, and enhance customer satisfaction. Process analysis and design are the most important phase in workflow application development, determine the overall structure and quality of the workflow model, and therefore largely decide the result of process automation: success or failure. One key requirement of process analysis and design is to make sure that resulting workflow models are compliant with organization policies. Due to new government regulations such as Sarbanes-Oxley and quality assurance standards such as ISO9001, many organizations are revising their policies and business processes in order to achieve compliance. Given those frequent changes, maintaining consistency between business policies and processes can be a very challenging task. Therefore, there is a need for advanced process analysis and design methods to better support dynamic policy and process changes.\n\nIn this dissertation, we provide solutions by proposing a logic-based methodology for process analysis and design, which builds a formal linkage between business policies and workflow models. Our contribution is threefold. First, we advocate a new Policy-driven Process Design (PPD) methodology which is different from existing participative and analytical methods. PPD is more efficient, effective, and accurate than participative approaches. It avoids traditional time-consuming, ambiguous process data collections by leveraging and systematically analyzing detailed process policies. It is also more practical\nand intuitive than analytical approaches, because it offers specific process design rules and detailed procedure for extracting workflow models from narrative business policies. Several steps in that procedure can be automated and a set of algorithms have been developed for that purpose. As far as we know, PPD is the first attempt towards policy-based process design automation. Furthermore, PPD provides a unique policy perspective on process analysis and design, where different workflow components are unified as policies.\n\nSecond, we propose a predicate logic-based process modeling language to formally represent the unified policy view of workflow models, which we refer to as Unified Predicate Language (UPL). In UPL different workflow components, including control flow, data flow, organizational model, and process constraints, are represented as logic formulas. This unified logic format enables analysis of the interaction among different workflow components via logic inference and queries. In particular, we demonstrate the expressive power and analytical capability of UPL by applying it in process design. UPL consists of a succinct set of predicates that are also expressive enough to model most commonly used control flow structures, data dependencies, organizational hierarchy, and process constraints. It also provides a set of functions that can be used to develop algorithms for offering design insights and detecting design problems. UPL is compared to other process modeling languages and the result shows that UPL is the only analytical process modeling language that can model all workflow components and support intelligent process design.\n\nThird, while most existing research on process changes only focus on one workflow\naspect, generally control flow, we emphasize the analysis of changes between different workflow components. In particular, we thoroughly investigate how changes in control flow and organizational model can affect process constraints. We summarize all possible scenarios where process constraints can be compromised due to process changes and formally define those scenarios into four process constraint anomalies using our proposed Unified Predicate Language, namely, missing constraint, redundant constraint, invalid constraint, and conflicting constraint. We demonstrate that process constraint anomalies can lead to serious runtime workflow errors. We prove that if none of these four process constraint anomalies exist the process constraints are consistent. A verification algorithm is developed to verify process constraint consistency whenever process changes happen and a constraint enforcement algorithm is designed to evaluate dynamic process constraints during runtime.\n\nIn summary, this dissertation fills a critical void in business process management by bridging the gap between commercial needs for advanced process analysis and design methodology and existing workflow research. As such, our research will have important impact in both theory and practice.\n\nWe are planning to extend our research in a number of directions. First, we are exploring methods for automatic process policy extraction from narrative business policies. In particular, we are investigating the possibility of leveraging semantic web research on rule markup languages, such as XRML (Lee et al. 2003) and RuleML (Grosof 2001). Similar to the procedure described in (Lee et al. 2003), narrative business policies are first analyzed by a knowledge engineer, where process related information is marked\nusing predefined XML tags. Then, process information can be automatically extracted by applying information retrieval techniques.\n\nSecond, we are interested in analyzing semantic errors in process design. Compared to syntactical errors that can be detected by formal methods, semantic errors can only be identified by human inspection, which is error-prone and inefficient. We plan to first work on summarizing and classifying process design semantic errors. Then, based on the different types of semantic errors, we will try to provide systematic procedures to help prevent and detect semantic errors.\n\nThird, we continue developing and enhancing our prototype system for policy-driven process design and logic-based process change analysis, which includes Policy Wizard (PW), Visual Editor (VE), and Process Change Analyzer (PCA). Once the system development is complete, we will test the usability of our system by conducting user studies and further validate our methodology by doing controlled experiments. In particular, we want to demonstrate that PW and VE can significantly improve the efficiency of process design and PCA can perform the task of identifying process change anomalies better or as well as human process analysts. Many techniques on information system verification and validation can be leveraged to design our user studies and experiments (Agarwal et al. 1993a; Sakthivel et al. 1988). The experiment results can help us refine our logic-based process analysis and design methodology and enhance our prototype system.\nREFERENCES\n\n\nBajaj, A., and Ram, S. \"SEAM: A state-entity-activity-model for a well-defined workflow development methodology,\" *Ieee Transactions on Knowledge and Data\n\n\nSun, S.X., and Zhao, J.L. \"A Data Flow Approach to Workflow Design,\" Proceedings of\n\n\n"}}},{"rowIdx":258,"cells":{"id":{"kind":"string","value":"dd86e28cccbac7d078520a8eba9ba47e18b8d291"},"text":{"kind":"string","value":"USING Microsoft Expression Web 2\n\nThe Only Expression Web 2 Book You Need\n\nJim Cheshire\nWho Should Read This Book?\n\nExpression Web 2 is a powerful Web development product, and there are plenty of books about it. That puts readers in a tight spot when trying to figure out which book to purchase to learn how to use Expression Web 2 to its fullest. I’ve read a lot of technical books in my career, and the ones that I find most helpful are the ones that teach me everything about a particular product instead of only teaching me the features and techniques that the author prefers. If that’s the kind of book you appreciate, then this is the book for you.\n\nI have also found that many technical books are frustratingly light on any meaningful content. In fact, most of them are just complex rewrites of the documentation that ships with the product. I get the documentation with the product, and I’d rather not pay for it again from a third party. Instead, I want a book that tells me what the documentation doesn’t tell me.\n\nThat’s exactly what this book will do. It will show you how to use the features in Expression Web 2 for real-world Web design. I’ll give you pointers on how to effectively use several features together to achieve a common goal. I’ll give you a strong foundation in the technologies involved (for example, Cascading Style Sheets [CSS], Extensible Hypertext Markup Language [XHTML], ASP.NET, PHP, and more) so you aren’t working in a vacuum.\n\nWhen the first edition of this book was released, I read plenty of quotes from people saying that, because it is comprehensive and covers all features in Expression Web, it was best for advanced users. I agree that this book is a great resource for advanced users, but it also is great for users new to Expression Web 2. If you want a book that will continue to provide you with valuable information as your knowledge of Expression Web 2 and Web design grows, this book is a great choice for you.\n\nThe goal of this book is to equip you to be a better Web designer using Expression Web 2 as one of the tools in your arsenal. If that sounds like something you’re interested in, keep reading!\n**WHY USE EXPRESSION WEB 2?**\n\nAsk any professional Web designer what features are important for a Web design application and he or she will tell you that it must adhere to current Web standards and make creating and maintaining a standards-driven Web site easy. Not only that, but a solid Web design tool should be created from the ground up to support ASP.NET and PHP from a designer's perspective. Expression Web 2 meets all those needs.\n\nYou’ll not only be able to create dynamic, standards-compliant Web sites with Expression Web 2, but you’ll be able to do so in a way that allows you to take advantage of your creativity. It doesn’t drag you down with complex dialogs and frustrating code changes. After using Expression Web 2 for a while, you’ll never consider going back to your previous Web design tool.\n\n**HOW THIS BOOK IS ORGANIZED**\n\nThis book is broken up into multiple sections so you can quickly find the information you need. Here is the rundown on all the sections:\n\n\n- **Part II, “Web Sites in Expression Web 2”**—The chapters in this section teach you how to work with Web sites in Expression Web 2. You’ll learn about creating sites, publishing sites, managing sites, and working with other site-related features.\n\n- **Part III, “Creating and Editing Web Content”**—In this section, you’ll learn how to create Web pages and add content to them. I not only talk about adding and formatting text, but also how to add graphics and dynamic content. Finally, this section covers the details of how to take advantage of some of the great productivity features in Expression Web 2.\n\n- **Part IV, “Using CSS in Expression Web 2”**—Instead of including CSS as an afterthought, I’ve dedicated two complete chapters to using this important design concept. You’ll learn not only the details of CSS in general, but also how to use the powerful CSS tools in Expression Web 2.\n\n- **Part V, “Optimizing Your Web Site”**—A good Web designer doesn’t just slap pages together. It’s important to make your site work well in all the major browsers, and it’s also important to pay attention to accessibility issues. You’ll learn about both in this section.\n\n- **Part VI, “Scripting, DHTML, and Other Dynamic Content”**—In this section, you’ll learn tricks to differentiate your Web site from the status quo. You’ll learn how to add dynamic components automatically in Expression Web 2. You’ll also learn how to read and write client-side JavaScript so you can understand what goes on under the covers when Expression Web 2 adds code to your page.\nPart VII, “ASP.NET and PHP Development in Expression Web 2”—Expression Web 2 fully supports Microsoft ASP.NET and provides some support for PHP. In this section, you’ll find out what ASP.NET gives you as a Web designer and how to use Expression Web 2 to create some pretty powerful site features, all without writing any code. You’ll also learn how to take advantage of the PHP support included in Expression Web 2.\n\nPart VIII, “Accessing Data in Expression Web 2”—Connecting a Web site to external data has become commonplace. In this section, you’ll discover how to easily design a data-driven Web site with ASP.NET and Expression Web 2.\n\nI’ve also included three appendixes that cover using Expression Web 2 to make money on the Web with e-commerce solutions, my insights into the future of Web development, and a resource guide on Expression Web 2, Web design, ASP.NET, and PHP.\n\n- Appendix A, “Taking Advantage of E-commerce”\n- Appendix C, “Resources on Expression Web 2, Web Design, ASP.NET, and PHP”\n\nSpecial Elements\n\nThroughout the book, you’ll find some special elements that are designed to make it easy to locate important information or special tips to help you get the most out of Expression Web 2.\n\nWhen an important term is used for the first time, it is printed in italics and defined close by. When instructions require you to enter text or values into a dialog, the data you are to enter appears bolded. Finally, for those of you who find it faster to work without a mouse, hotkey indicators appear for all menu commands. Simply press Alt and the underlined character.\n\nCross-References\n\nNothing’s worse than a technical book that assumes you will read it from beginning to end like a novel. Most folks use technical books like reference materials, so this book makes generous use of cross-references.\n\nIf a feature is mentioned that is covered elsewhere in the book, there is a cross-reference directing you to where you can find details on that topic.\n\nNotes, Tips, Cautions, and Sidebars\n\nYou’ll find numerous bits of information in these special elements.\nIntroduction\n\nRead Sidebars for the Big Picture\nYou won’t find sidebars in every chapter; they’re designed to give you more insight into a particular topic. If you’re the kind of person who wants to know all the details, you’ll find sidebars extremely valuable.\n\nTroubleshooting\nThe “Troubleshooting” section is where you can go when things don’t quite work out right. Chances are you’ll find the solution to your problem there.\n\nI’ve included notes in the chapters to direct you to these sections.\n\nThis is what a Troubleshooting note looks like. Text here describes a possible problem and tells you where to look for the solution.\n\nIn keeping with the concept of this book as a reference book, it includes a complete table of all the troubleshooting topics from the entire book. You’ll find this table after the Table of Contents at the front of the book.\n\nLagniappe (lan yap’) n., a gift or bonus\n\nI always include a special section at the end of each chapter that gives you some bonus material. I wanted this section to have a name with character—one that truly illustrates the purpose of the section. I chose lagniappe as the name of this section. Lagniappe is an American French word that refers to a special gift given out of gratitude by a merchant at the end of a transaction. I felt that lagniappe was the perfect name for this section because it truly denotes the intent. (Thanks, Dad, for the recommendation.)\n\nI sincerely hope you enjoy this book and find it to be an invaluable resource as you build Web sites with Expression Web 2.\n\nThank you for purchasing this book, and I hope you enjoy reading it as much as I enjoyed writing it for you!\n\n—Jim\nIn this chapter\n\nWhat Is Publishing?\nServer Options for Publishing\nPublishing Content\nTroubleshooting\nLagniappe: Hosting Your Web Site\nWhat Is Publishing?\n\nThe best Web site is worthless unless people can see it. You can be the cream of the Web designer crop, but if no one can access your site, it doesn’t matter a bit. Therefore, you have two choices when it comes to designing a Web site with Expression Web 2: You can either design the site live on a Web server that hosts your domain, or you can create your site offline and then publish it to a live server.\n\nDeveloping a site offline and then publishing it to a live server is always the preferred choice. If you develop directly against a live site, any problems you encounter while developing your site (and there will be some) will be visible to everyone who visits your site. You could, of course, put up one of those graphics that you see on many sites that say “Under Construction,” but the way I see it, if a site is under construction, it should be on a development computer, not on a live Web server. After all, an artist doesn’t paint a masterpiece while the canvas hangs on a museum wall. A professional Web developer will always develop a site offline and then publish it to the Internet or intranet.\n\nPublishing is simply the process of copying Web content from one place to another. It might be content copied from one directory to another on the same machine, one Web site to another on the same machine, or from one machine to a different machine. You can also publish content to any of the numerous storage devices available today, such as a removable hard drive, a Universal Serial Bus (USB) key, or even a portable music player! If you can copy a file to a device or location, you can publish to it.\n\nTip\n\nIt might sound strange to publish a Web site to a portable music player, but it’s actually a convenient way to carry copies of your Web site from place to place. I’ve got copies of several of my Web sites on my iPod, and it’s been a great convenience to be able to access the files anytime I need them.\n\nServer Options for Publishing\n\nAs shown in Figure 3.1, Expression Web 2 offers many options for publishing content:\n\n- FrontPage Server Extensions (via HTTP or HTTPS)\n- WebDAV\n- FTP\n- File System\nOne of these methods is sure to be suitable for your purposes. In fact, you'll likely have a choice between a couple of them, so you'll need to understand the pros and cons of each option to make an educated decision when the time comes to publish your site.\n\n**FrontPage Server Extensions**\n\nThe FrontPage Server Extensions are a set of files that is installed onto a Web server to add functionality to a Web site. The FrontPage Server Extensions have been around for many years. Perhaps the reason why they are so pervasive is that most hosting companies offer support for them.\n\n**NOTE**\n\nMicrosoft still supports the FrontPage Server Extensions on Windows Server 2003. Microsoft also has engaged Ready to Run software to develop a version of the FrontPage Server Extensions for Windows Vista and Windows Server 2008, but the new version has not been released as of this writing.\nWhen to Choose the FrontPage Server Extensions\n\nThere will be times when you won’t have any choice but to use the FrontPage Server Extensions. If you can’t connect to a remote server using one of the other connectivity methods provided by Expression Web 2, you’ll have to use the FrontPage Server Extensions. You’ll also need to use the FrontPage Server Extensions if you are using an Expression Web 2 Web component that requires FrontPage Server Extensions for functionality on the server.\n\nOutside of those situations when you have no other choice, I recommend that you do not use the FrontPage Server Extensions. Although a version of the FrontPage Server Extensions is available for IIS 7, Microsoft does not develop it. It’s likely that Microsoft will not provide security updates and bug fixes.\n\n**CAUTION**\n\nThere are some Expression Web 2 Web components that rely on the FrontPage Server Extensions to operate. If you are using any of these components, you will need to choose the FrontPage Server Extensions option when publishing.\n\nThe FrontPage Server Extensions use either the HTTP or secure HTTP (HTTPS) protocol to publish site content. These same protocols are used when browsing Web sites. Because the FrontPage Server Extensions use the same protocols as your Web browser, they can easily publish to remote servers even if you are behind a firewall. Almost all firewalls are configured to allow HTTP and HTTPS traffic to freely pass through. The FrontPage Server Extensions take advantage of that fact when publishing content.\n\n*If you are prompted multiple times for a username and password when publishing with the FrontPage Server Extensions, see “Username and Password Not Accepted” in the “Troubleshooting” section of this chapter.*\n\nThe Remote Web Site Properties dialog shown in Figure 3.2 displays the options available when choosing to publish a Web site using the FrontPage Server Extensions.\n\nAfter the FrontPage Server Extensions have been installed on the Web server, they must be configured for your Web site by an administrator of the Web server. During the configuration process, the FrontPage Server Extensions add folders to your Web site that begin with _vti. These folders contain configuration information that the FrontPage Server Extensions use to keep track of changes to your Web site.\n\n*NOTE*\n\n“VTI” stands for Vermeer Technologies Incorporated, the company from which Microsoft purchased the first version of FrontPage. Ironically, references to that original company still remain in Microsoft products even after the discontinuation of FrontPage.\n\nThe FrontPage Server Extensions offer functionality at both design time and runtime. In addition to offering the ability to connect to remote Web sites and publish content, they also provide components that generate HTML and client script while you are developing the site, as well as components that provide special functionality when the Web site is browsed.\nTo publish with the FrontPage Server Extensions, you will need to have the FrontPage Server Extensions installed on the remote Web site. It is not necessary to install the FrontPage Server Extensions on the local Web site.\n\nIf you get an error telling you that the FrontPage Server Extensions are not installed when publishing, see “FrontPage Server Extensions Aren’t Installed” in the “Troubleshooting” section of this chapter.\n\nWhen you publish with FrontPage Server Extensions, you will usually publish to the same address that you would use when browsing the remote Web site in your Web browser. For example, if I were publishing a local copy of my Web site from `c:\\WebSites\\JimcoSoftware` to my public Web site using the FrontPage Server Extensions, I would enter a destination address of `http://www.jimcosoftware.com`.\nWebDAV\n\nWebDAV is really just an extension of the HTTP protocol, and therefore shares many of the same benefits offered by the FrontPage Server Extensions. In fact, the options available in the dialog for publishing a Web site in Expression Web 2 via WebDAV are identical to those available when publishing using the FrontPage Server Extensions.\n\nThere are many benefits to using WebDAV:\n\n- Firewalls generally are not an issue because WebDAV extends HTTP, the protocol used when browsing the Web.\n- WebDAV supports strong authentication so you can ensure the security of your data.\n- WebDAV supports encryption for another layer of protection for your data.\n- WebDAV includes support for file versioning and resource locking so that one user won’t overwrite another user’s work.\n\nWebDAV is already a part of your operating system. In fact, when you create a shortcut to an HTTP location in My Network Places, Windows uses WebDAV to create that link if the FrontPage Server Extensions are not installed on the remote server.\n\nNOTE\n\nMany people in the technical community seriously believe that WebDAV will eventually replace all the publishing protocols in wide use today. In fact, Microsoft has released a WebDAV authoring extension for IIS 7 that works perfectly with Expression Web 2.\n\nTo use WebDAV to publish your Expression Web 2 Web site, your hosting company or system administrator must provide support for WebDAV. I have had great success using WebDAV on IIS 7 and Expression Web 2, but Microsoft’s implementation of WebDAV isn’t complete. Even so, you can open a remote Web site and publish your Web site using Microsoft’s implementation of WebDAV and Expression Web 2.\n\nIf you are publishing with WebDAV and you receive an error saying that the FrontPage Server Extensions are not installed, see “FrontPage Server Extensions Are Used Instead of WebDAV” in the “Troubleshooting” section of this chapter.\n\nFTP\n\nFTP has been around a long time and is widely used by many Web developers for transferring Web content. In fact, the first FTP standard appeared in 1971, long before the advent of the World Wide Web.\n\nFTP is generally not secured. That means it’s possible for someone to intercept your username and password. There are actually several options available for secure FTP. However, Expression Web 2 does not support any of these methods. If you want to use secure FTP, you’ll need to use a third-party FTP client.\nFTP is a reliable method of transferring files between computers. However, there are some things to keep in mind when using FTP. There are two types of FTP connections: passive FTP and **active** FTP. If you experience trouble when using FTP (especially when publishing through a firewall), enabling passive FTP usually will resolve the issue.\n\nTo enable passive FTP in Expression Web 2, select **Tools**, **Application Options** and check the **Use Passive FTP** check box on the **FTP tab**, as shown in Figure 3.3.\n\n**Figure 3.3**\nExpression Web 2 supports both passive and active FTP. One of the two will work fine in almost all cases.\n\n**NOTE**\nAs mentioned in Chapter 1, Microsoft plans to support secure FTP in the next version of Expression Web.\n\nIf you publish content using FTP but the content doesn’t show up on the remote Web site, see “Content Missing after Publishing” in the “Troubleshooting” section of this chapter.\n\n**FILE SYSTEM**\n\nThe File System method of publishing is used most often in situations where both the local and remote locations are on the same network. For this method to work, you must have a connection to the remote server that allows for access via a UNC (Universal Naming Convention) path.\n\nA UNC path consists of a server name and a share name using the syntax `\\server\\share`. It’s also possible to set up a mapped drive so you can refer to a UNC share using a drive letter. UNC paths and mapped drives use the same underlying architecture.\nCAUTION\n\nMapped drives are user-specific. If you log in to a computer and map a drive, other users who log in to that computer will not see that mapped drive.\n\nIf you map a drive with the intention of allowing other users of the same computer to publish to the mapped drive, keep in mind that you will need to map the drive for each user individually.\n\nPUBLISHING CONTENT\n\nNow that you have a rundown of all the methods available when publishing a Web site in Expression Web 2, let’s look at how to publish content to a Web site.\n\nCONFIGURING PUBLISH OPTIONS\n\nAfter you’ve opened the Web site you want to publish, select File, Publish Site to display the Remote Web Site Properties dialog. You’ll then need to select the method you’ll use for publishing and enter the location for the remote Web site.\n\nIf you’d like to review or change the options for publishing your Web site, click the Publishing tab. As shown in Figure 3.4, you can choose to publish only those files that have changed since the last publish, or you can choose to publish all files.\n\nFigure 3.4\nExpression Web 2 lets you choose whether to publish everything or just those files that have changed since the last time you published.\nBy default, Expression Web 2 publishes only those pages that have changed since the last time you published. It uses one of two methods to determine which files need to be published:\n\n- **Determine changes by comparing source and destination sites**—By default, Expression Web 2 stores information on all the files in your Web site. If you choose this option, Expression Web 2 will use that information to determine what files need to be published.\n\n- **Use source file timestamps to determine changes since last publish**—This method simply uses the timestamp on the files to determine what should be published. This method may not be as reliable as the first option.\n\nExpression Web 2 also gives you the option of whether to include subsites. Even though Expression Web 2 will display subsites in the folder list of your Web site, it will only publish the main site by default. If you want to publish the main site and all the subsites, you’ll need to check the Include Subsites check box.\n\n➔ For more information on subsites, see “Web Sites and Subsites,” p. 29.\n\nIf you’d like Expression Web 2 to create a log of your publish operation, check the Log Changes During Publish check box. Expression Web 2 will then create an HTML file in your Temporary Internet Files folder, as shown in Figure 3.5. You can view this file by clicking View Your Publish Log File in the Copy Web Site view after you have published the Web site.\n\n**Figure 3.5**\nThe Expression Web 2 publish log is easy to filter using the Show Only drop-down. If you’d like to keep the log, save it after publishing the site.\nOptimizing HTML During Publishing\n\nIn addition to publishing your files, Expression Web 2 can also optimize your HTML. The main purpose of this feature is to remove code that may not be needed on the remote Web server.\n\nYou can configure what type of HTML optimization takes place using the Optimize HTML tab on the Remote Web Site Properties dialog, as shown in Figure 3.6.\n\nFigure 3.6\nExpression Web 2 can remove any unnecessary code so that your pages are as small as possible for better load times, but don’t expect miraculous increases in speed with this feature.\n\nThere are many options available for HTML optimization:\n\n- **All HTML Comments**—Removes all HTML comments in code. HTML comments are designated by the `<!--` and `-->` characters. The closing comment character may also simply be `-->`.\n\n- **Dynamic Web Template Comments**—Expression Web 2 adds comments to pages that use Dynamic Web Templates so that editable regions can be identified. This option removes those comments.\n\n- **Layout Tables and Cell Formatting Comments**—Expression Web 2 adds comments to layout tables and cells. This option removes those comments.\n\n- **Script Comments**—This option removes comments added to client-side scripts.\n\n- **All Other HTML Comments**—This option removes comments that are not covered in any of the previous categories.\n\n- **HTML Leading Whitespace**—Removes the leading whitespace from your lines of code.\n\n- **HTML All Whitespace**—Removes all HTML whitespace, including whitespace between lines.\n■ **Expression Web Tracing Image and Interactive Button Attributes**—Removes attributes that are added for the purpose of tracing images and also removes interactive button attributes. These attributes are used only for editing purposes, so they aren’t needed on live files.\n\n■ **Generator and ProgID Tags**—Removes the Generator and ProgID Meta tags that are added by Expression Web 2.\n\nIf you’ve made changes to the Optimize HTML settings and you notice no effect on your HTML code, see “HTML Optimization Doesn’t Affect Web Files” in the “Troubleshooting” section of this chapter.\n\n### The Remote Web Site View\n\nAfter you’ve configured all the publishing options for your Web site, click the OK button. If the remote Web site that you specify doesn’t exist, Expression Web 2 will prompt you to create it, as shown in Figure 3.7. Expression Web 2 will create a Web site with an `images` folder and a `_private` folder. No other files or folders are created in the remote Web site until you publish files to it.\n\nFigure 3.7\nExpression Web 2 prompts you to create a new Web site if the remote Web site you specify doesn’t exist.\n\nAfter the remote Web site has been created, the Remote Web Site view is activated, showing the local Web site on the left and the remote Web site on the right. From the Remote Web Site view, you can choose from one of three different publish settings:\n\n- **Local to remote**—Files are copied from the local Web site on the left to the remote Web site on the right.\n\n- **Remote to local**—Files are copied from the remote Web site on the right to the local Web site on the left.\n\n- **Synchronize**—Changed files are synchronized between the two sites. This option is enabled only when the Changed Pages Only option is enabled in the Remote Web Site Properties dialog.\n\nExpression Web 2 displays an icon next to pages in the Remote Web Site view to indicate what will happen when the Web site is published, as shown in Figure 3.8. These icons are not displayed for folders, but if you select a folder, Expression Web 2 will display the files within the folder along with appropriate icons indicating whether or not the files will be published.\nFigure 3.8\nExpression Web 2 displays arrows next to files that will be copied when the Web site is published. The direction of an arrow indicates the direction of the file copy that will take place on that particular file.\n\nBecause I have chosen the option to synchronize the Web sites, Figure 3.8 indicates that default.htm will be copied to the remote Web site and master.dwt will be copied to the local Web site when the site is published.\n\nYou can also use the arrow buttons that appear between the local Web site and remote Web site views to publish files and/or folders. If you’d like to copy just a few files (or just one), you can simply drag and drop them between the two views.\n\nIf your Web site consists of just a few files, it’s pretty easy to tell which files will be published using the Remote Web Site view. However, as your Web site increases in size, it becomes more difficult to manage. If your Web site contains a lot of folders like the one shown in Figure 3.8, you’re not going to be able to easily see what will happen when you publish. Fortunately, Expression Web 2 offers the ability to filter the Remote Web Site view using the View drop-down, as shown in Figure 3.9.\n\nConfusing Web Site Terminology\nExpression Web 2 refers to the Web site open in Expression Web 2 as the local Web site; the Web site you are publishing to is called the remote Web site. However, the terms “local Web site” and “remote Web site” are misleading.\n\nThe local Web site isn’t necessarily located on the local machine, nor is the remote Web site necessarily located on a remote machine. For example, if you are publishing your Web site from the Internet to your home computer, the local Web site would be located on a remote computer on the Internet, while the remote Web site would be your home computer.\n\nKeep this in mind when working with your Web sites. Just remember that the Web site that is open in Expression Web 2 is always referred to as the local Web site and you should be fine.\nFigure 3.9\nYou can quickly filter the Remote Web Site view using the View drop-down. In this case, I’ve decided to view all the files that will be published. Notice that Expression Web 2 does not display any folders in this view.\n\nTroubleshooting HTTP Publishing\n\nRule number 1 of publishing is this: If you’re going to have a problem with a hosting company, it’s going to happen when you are publishing your content. Most hosting companies do a great job of ensuring that people can always browse your site, but publishing is more complex and requires a more precise configuration.\n\nThe second rule of publishing is that most hosting companies will deny responsibility when it comes to publishing problems. That means you are going to have to do your own troubleshooting.\n\nTIP\nMany hosting companies that support the FrontPage Server Extensions for publishing will also blame them for problems while publishing. This is another reason for choosing FTP over the FrontPage Server Extensions if you can. FTP problems are uncommon, but if you do have them, almost all hosting companies are competent in troubleshooting them.\n\nTo troubleshoot publishing problems, you’re going to need to install software that can capture information between your computer and the remote computer. The two tools I use for doing this are Ethereal and Fiddler, both of which are free tools and available for download on the Internet.\nEthereal (see Figure 3.10) is a network protocol analyzer. That’s a fancy way of saying that it captures all traffic that flows to and from the network card on your computer. It features a great filter so that you can zero in on just the traffic you want to see. When dealing with Expression Web 2 publishing issues, you’re going to be interested in HTTP or FTP traffic. Ethereal is available from www.ethereal.com.\n\n**NOTE**\n\nNone of the techniques I discuss in this section will work if you are using SSL (HTTPS) because all traffic that flows over an SSL connection is encrypted. You’d be able to see the traffic, but you wouldn’t be able to decipher it into anything meaningful.\n\nThe other tool I use is Fiddler (see Figure 3.11), which is an HTTP debugging proxy. That’s a fancy way of saying that it logs all HTTP traffic on your machine. Fiddler has the added benefit of being able to log local traffic that doesn’t travel over your network card. Fiddler is available from www.fiddlertool.com.\nHTTP Authentication Traffic\n\nMost of the problems you'll encounter during publishing are authentication problems, meaning that the remote server doesn't accept your username and password. To troubleshoot this type of problem, you need to first understand what happens when things are working correctly.\n\nTo publish a Web site, you need to be able to write content to the remote Web site. For the Web server to verify that it should allow you to write to the content of the remote Web site, it needs to authenticate you. It does that by sending a 401 status code in response to your attempt to publish.\n\n**Tip**\n\nA 401 status code means that access was denied. You can see a full list of HTTP status codes at http://support.microsoft.com/kb/318380/en-us.\n\nThe client (in this case, Expression Web 2) responds to the 401 status code in one of two ways, depending on the type of authentication being used. You'll generally be using one of two authentication methods:\n\n- **Windows Integrated Authentication**—Windows Integrated authentication is authentication that's built into Windows itself. If your Web server indicates that it can accept Windows Integrated authentication, Expression Web 2 will attempt to authenticate you...\nusing the user logged on to your computer. If that fails, you'll be prompted for a user-\nname and password.\n\n- **Basic Authentication**—Basic authentication will always prompt for a username and password.\n\nWindows Integrated authentication uses encrypted data to authenticate you to the remote Web site. In fact, one of the benefits of Windows Integrated authentication is that it’s a secure authentication mechanism. However, it was not designed to work on the Internet. In many cases, if your host is using Windows Integrated authentication, you’ll be repeatedly prompted for a username and password and publishing will fail.\n\nBasic authentication doesn’t use encrypted credentials. Instead, your username and password are encoded using Base64 encoding before they are sent across the wire. Base64 encoding is a common encoding method used to transmit data across networks. It was actually developed for sending binary data, but it works well for sending text as well.\n\n**TIP**\n\nIn most cases, if Windows Integrated authentication fails, the Web server automatically tries basic authentication. Chances are you won’t even know if or when this happens.\n\nIt’s important to keep in mind that Base64 encoding provides nothing in the way of security. A quick Google search turns up scores of utilities for decoding Base64-encoded data. You shouldn’t think of this as a flaw in the method used by basic authentication. It’s actually the way it was designed to work.\n\n**NOTE**\n\nWindows Integrated authentication is naturally Windows-specific. Basic authentication, however, is used in non-Windows Web servers such as Apache.\n\n**Using Fiddler to Troubleshoot HTTP Publishing Errors**\n\nFiddler is a convenient tool to use for troubleshooting HTTP publishing because it targets only HTTP traffic. To start Fiddler, select it from the Start menu in Windows or use the Fiddler button in Internet Explorer, as shown in Figure 3.12.\n\nAfter you start Fiddler, it will begin capturing HTTP traffic, as shown previously in Figure 3.11. At the right side of the Fiddler interface, you can see different views of the data. By clicking the Session Inspector tab, you can view the local computer traffic in the top half of the display and the remote traffic in the bottom half. A series of buttons appears above both panels, allowing you to change the format of the data that is displayed. When troubleshooting publishing issues, it’s probably most helpful to click the Headers button for both panes, as shown in Figure 3.13.\nFigure 3.12\nFiddler installs a button into Internet Explorer so you can always access it quickly when you need it.\n\nFigure 3.13\nFiddler can break local and remote traffic into two panes. In this case, you can see that the server is using basic authentication.\n\nYou can use the information that Fiddler provides to help in troubleshooting publishing issues by analyzing the authentication information. You want to look for the 401 status sent by the remote server and select the line just below it in Fiddler, as shown in Figure 3.14. You should then see your local machine respond with the authorization information.\n\nIf you see that you are not sending authorization information to the server, you’ve got a problem on your end. However, if you see that you are sending information to the server, you’re either sending the wrong credentials or there’s a problem somewhere other than on your end.\nUsing Ethereal to Troubleshoot HTTP Publishing Errors\n\nEthereal is a much more powerful tool than Fiddler because it will capture all network traffic on your computer. However, with that power comes additional complexity. For that reason alone, I usually choose Fiddler over Ethereal for simple troubleshooting, but you may find that Ethereal offers features that are useful to you.\n\n**TIP**\n\nBecause Ethereal captures all network traffic, it can also be used to troubleshoot FTP publishing. Fiddler only captures HTTP traffic and cannot aid in troubleshooting FTP.\n\nTo use Ethereal, select Capture, Interfaces to display a list of network interfaces that you can capture. Browse to any Web site and look for the interface that shows an increasing number of packets (as shown in Figure 3.15), and then click the Capture button.\n\nAfter you’ve started the capture, begin your publishing in Expression Web 2. When you encounter a problem, switch back over to Ethereal and click the Stop button in the capture dialog, as shown in Figure 3.16.\nYou will want to capture the interface that is connected to the Internet. Look for the interface with an increasing number of packets.\n\nThe capture dialog shows the packet statistics during a capture. Click the Stop button to end the capture process.\n\nIf Ethereal doesn’t capture any network traffic, see “Ethereal Captures Nothing” in the “Troubleshooting” section of this chapter.\n\nEthereal captures all traffic on the network, so there’s a good chance it will have captured a significant amount of data that is not related to your work in Expression Web 2. Fortunately, you can filter the captured data easily by simply entering http in the Filter textbox, as shown in Figure 3.17.\n\nThe data is collected in Ethereal in a similar format to the data collected in Fiddler. Once again, you want to look for Expression Web 2’s response to the 401 status code sent by the Web server. (I’ve highlighted the 401 status code in Figure 3.17.)\n\nAnother powerful feature of Ethereal is its ability to display a conversation between Expression Web 2 and the remote Web server in a readable format. By right-clicking on any of the captured data and choosing Follow TCP Stream from the menu, Ethereal will display the entire conversation, as shown in Figure 3.18. You can even save this information and send it to your host to demonstrate the problem.\nFiltering in Ethereal is a simple task using the Filter textbox.\n\nAn enormous benefit to Ethereal is its ability to display captured data as an entire conversation.\n\nBy using the data captures from Ethereal or Fiddler, you should have all you need to isolate publishing problems and possibly convince a stubborn host that the problem isn’t on your end.\n**TROUBLESHOOTING**\n\n**USERNAME AND PASSWORD NOT ACCEPTED**\n\nI'm publishing my site to my host and my username and password aren't being accepted. I know they're right and I know that my host has the FrontPage Server Extensions installed. What could be wrong?\n\nThe FrontPage Server Extensions recognize different levels of access to a site. If you are entering the correct information and publishing has never worked, it's possible that your host has not granted you proper permissions.\n\nContact your host and tell them to make sure you have permission to author against your Web site.\n\n**FRONTPAGE SERVER EXTENSIONS AREN’T INSTALLED**\n\nMy host promises me that the FrontPage Server Extensions are installed, but when I try to publish, I keep getting a message telling me that the FrontPage Server Extensions aren’t installed.\n\nIt's possible that the permissions on the remote Web site are not set correctly. This can prevent Expression Web 2 from being able to tell if the FrontPage Server Extensions are installed. If Expression Web 2 can't tell that the FrontPage Server Extensions are installed, it will assume that they aren’t.\n\nUse Ethereal or Fiddler and see what you can turn up. If you see something that looks out of the ordinary, send it to your host.\n\n**FRONTPAGE SERVER EXTENSIONS ARE USED INSTEAD OF WEBDAV**\n\nI'm publishing to my Web site using WebDAV, but I'm getting a message saying that the FrontPage Server Extensions aren't installed. Do I need the FrontPage Server Extensions to publish using WebDAV?\n\nNo. The FrontPage Server Extensions and WebDAV are mutually exclusive. That means that if the FrontPage Server Extensions are installed on the Web server, you can’t publish using WebDAV. As soon as you try to publish using HTTP, the Web server will expect you to use the FrontPage Server Extensions.\n\nIf you are getting an error about the FrontPage Server Extensions when publishing via WebDAV, it indicates that the FrontPage Server Extensions are installed on the site and you cannot use WebDAV to publish. Contact your host and let them know that you want to remove the FrontPage Server Extensions and use WebDAV instead.\n\n**CONTENT MISSING AFTER PUBLISHING**\n\nI've published my content using FTP, but when I browse my Web site, nothing’s there. Have I lost everything?\n\nYou haven't lost everything. Chances are you just uploaded information to the wrong directory. Your host has a specific directory that contains your Web site's files. Most of the time,\nyou are automatically placed into that directory when you log in. However, in some cases, you will need to specify the directory within Expression Web 2 in the FTP Directory text box.\n\nAsk your host for the directory you should be using when publishing.\n\n**HTML Optimization Doesn’t Affect Web Files**\n\n*I’ve made some changes to the HTML Optimization feature in Expression Web 2, but when I check the code in my pages, nothing has changed.*\n\nMany of the comments and other special code that gets cleaned out as a function of HTML optimization are actually needed by Expression Web 2 while you are creating your pages. Therefore, Expression Web 2 will only optimize the HTML when you publish your Web site. The local files will remain unchanged.\n\n**Ethereal Captures Nothing**\n\n*I’m trying to use Ethereal to capture network traffic on my wireless network card. It doesn’t seem to be capturing anything at all. What could be wrong?*\n\nYou should be able to capture against your wireless network card, but you might need to disable promiscuous mode.\n\nIn the Capture Interfaces dialog shown previously in Figure 3.15, click the Prepare button and then uncheck the Capture Packets in Promiscuous Mode check box in the Capture Options dialog.\n\n**Lagniappe (lan yap’) n., a gift or bonus**\n\n**Hosting Your Web Site**\n\nOne of the most commonly asked questions by many Web designers is one that might appear to be simple: “What should I consider when choosing a host for my Web site?” There are many options available for hosting, and most of them are more affordable than you might think.\n\nFirst, outline your requirements. For example, are you going to need a database? If so, do you need a high-performance system like Microsoft SQL Server or a lower-level system? Most hosting companies offer support for SQL Server for a nominal monthly fee. However, if you don’t need that kind of power, you can probably save some money by going with a file-based database such as Microsoft Access. You also may want to investigate using SQL Server 2005 Express Edition. It’s a high-performance, file-based system that is available free from Microsoft, but keep in mind that some hosting companies do not support the Express Edition of SQL Server.\nYou’ll also want to try and determine how much traffic you expect. Most hosting companies charge for a specific amount of bandwidth. After you surpass that bandwidth limit, you’ll have to pay a premium for additional bandwidth. This is especially important if you plan on offering large files for download such as video or audio files.\n\nAnother important decision to make is whether to go with a hosting company that runs Windows servers. It seems to be all the rage these days to try and convince people to stay away from Windows Server. I encourage you to not fall for those who push their own agenda without any factual information. Make your decision based on the technology you want to use. If you want to use ASP.NET, you’ll need to go with a host that runs Windows Server. If you want to use PHP, you have a choice of a Windows or non-Windows host.\n\n\\[\\text{NOTE}\\]\nAs of IIS 7 and the release of FastCGI, running PHP on a Windows server running IIS 7 provides application performance that is comparable to the performance that PHP enjoys on Apache Web servers.\n\nIf you just want to host a simple Web site without any fancy features and you do not expect a lot of traffic, you might want to consider hosting the site yourself. If you’re a technology guru, you can get Linux and Apache running on a spare computer lying around the house and get good performance. Setting up Internet Information Services (IIS) on Windows Server is easier, but it will require a more powerful computer.\n\nYou can use Windows XP Professional or Windows Vista Home Premium Edition or better to host your own site, but both have a limitation on the number of connections that can be serviced. Keep in mind, too, that a single person browsing a site is going to be opening multiple connections. Chances are you will reach the connection limit at two or three people.\n\n\\[\\text{NOTE}\\]\nWindows Vista also has a limited number of connections, but it’s designed in such a way as to not generate errors when that limit is reached. Instead, it will allow the user to wait in a queue until a connection is available. Because of this, it’s possible to host a fairly busy personal site on Windows Vista without any problems.\n\nIf you do choose to host your own site, you might want to invest in a router that has Dynamic Domain Name System (DNS) capability. (Most routers these days have this feature.) Dynamic DNS will allow you to configure a static host name (such as mySite.dyndns.org) that will always go to the IP address of your computer. Because most Internet service providers (ISPs) assign dynamic IP addresses, your IP address will change periodically. A router that supports Dynamic DNS can update a Dynamic DNS service (like www.dyndns.com) with your new IP address whenever it changes.\n\nMore information on Dynamic DNS is available at www.dyndns.com/services/dns/dyndns/. The service is free of charge and works great with most routers.\nSYMBOLS\n\\ (escape) characters in regular expressions, 277\n{} (curly braces) in regular expressions, 281\n- (dash) characters in regular expressions, 277\n<body> tags (Master Pages), 548\n<div> tags. See also layers\nAJAX Library, 638\npositioning, 438\n<script> tags, PHP, 644\n<table> tags (HTML tables), 146\nalign attribute, 147-148\nborder attribute, 149\ncellpadding attribute, 149-150\ncellspacing attribute, 149-150\nframe attribute, 151-152\n<td> (column) tags (HTML tables), 152-153\n<tr> (row) tags (HTML tables), 152-153\n++ symbol (JavaScript), 434\n\nNUMBERS\n2CO (www.2checkout.com), 701\n4GuysFromRolla.com Website, 717\n\nA\nabsolute positioning, 305\nAccess denied error messages, 594\nAccessDataSource control, 678\naccessibility\nAccessibility Checker task pane, 347, 359\nCheck Where section, 348\ncorrecting problems in, 350\ngenerating HTML reports from, 351\nProblem Details dialog, 349\nShow section, 348\nAccessibility Properties dialog, 347\ndesigning for, 344-347\nframes, 346\nhyperlinks, 344-345\nRehabilitation Act of 1973, Section 508, 344\nScreenTips, 345\ntables, 345\nVischeck software, 352\nWCAG (Web Content Accessibility Guidelines), 344\nWorkforce Investment Act, 344\nAccessibility Properties dialog, 347\nAccessibility Reports feature, 18-19, 359\nactions (behaviors), 397\nactive FTP (File Transfer Protocol), 49\nActiveX Controls options (General tab, Page Editor Options dialog), 265\nAdd Current Web Site box (New dialog), 33\nadding users to ASP.NET Forms authentication, 585\nAddress step (Wizard control), 517-518\nAdRotator control (ASP.NET), 555-556\nadvertisement files, creating, 503-506\nImpression element, 502\nAdRotator control, 502\nKeyword element, 502\nWeb pages, creating, 502\nXML coding for, 501\nXML elements list, 501\nAdvanced tab\nPage Properties dialog, 115\nSite Settings dialog\ndefault validation script language, setting, 69\nDelete Files button, 70\nShow Hidden Files and Folders check box, 70\nWindows Media Player Properties dialog, 254-255\nadvertisement files, creating via AdRotator control (ASP.NET), 503-506\nadvertising, e-commerce, 702\nAjax, 707-709\nAJAX ASP.NET Control Toolkit, 631\nAJAX Extensions, 631\nAJAX Library, 630, 638\nadding client script to ScriptManager control, 640-641\ncreating client libraries, 639\n<div> tags, 638\ntroubleshooting, 638\nWeb forms, adding functionality to, 632\nScriptManager control, 635-636\nserver-side code, 634-635\nUpdatePanel control, 637\nAJAX Extensions controls (ASP.NET), 496\nalert method (JavaScript), 436\nalign attribute (HTML tables), 147-148, 153\naligning\ncell content (HTML tables), 160\ntext, Interactive Buttons, 387\nAll Files reports, 72\nAll Pages option (find and replace tool), 278\nAllow Line Breaks Within Tags check box (Code Formatting tab, Code View), 138\nanimation, inserting into Web sites, 250-252\nAnonymousTemplate view, 576-577\nAppearance tab (Flash SWF Properties dialog), 250\nAppearanceEditorPart control, 613, 625\nApplication object model, 457\nApplication Options dialog, 75\nApply New Style to Document Selection check box (Style Builder), 334\nApply Style option (Apply Styles task pane), 328\nApply Styles task pane (CSS), 18, 301, 309, 316-317, 327\nApply Style option, 328\nAttach Style Sheet option, 302, 313, 329\nDelete option, 328\nGo To Code option, 328\nManage Style Sheet Links option, 329\nModify Style option, 328\nNew Style Copy option, 328\nNew Style option, 328\nRemove Class option, 329\nRemove ID option, 329\nRemove Inline Style option, 329\nRemove Link option, 328\nSelect All x Instances option, 328\nSelect Style Sheet dialog, 302\nASP.NET, 65, 492\nAdRotator control, 555-556\nAjax\nadding functionality to Web forms, 632-637\nAJAX ASP.NET Control Toolkit, 631\nAJAX Extensions, 496, 631\nAJAX Library, 630, 638-641\ntroubleshooting, 638\nauthorization settings, configuring, 581\nContent Pages, 548\n.aspx file extension, 546\nContent control, 549-550, 560\ncontents of, 551\ncreating, 548-549, 559\ndefining custom content, 560\ntroubleshooting, 561\nControl Errors Visual Aid (Design View), 127\ncontrols\naccessing properties, 497-499\nadding to Web pages, 497\nAdRotator control, 501-506\nCalendar control, 507-511\ndeclarative syntax, 500\ninserting into Web pages, 496\nlist of, 500-501\nrendering, 495-496\nStandard controls, 501-521\nsupport for, 22\nWizard control, 512-521\nXML elements list, 501\ndata access tools, 672-673\nData controls, 495\ndetail views, creating, 692\nDetailsView control, 692\nDevelopment Server, 35, 42, 498, 601\nExpression Web 2 support, 493\nformatting, CSS styles, 521\nforms authentication\nadding users to, 585\nconfiguring\nAuthorization Rules, 587\nconfiguring Web sites for, 579-582\nenabling, 584\nfunctions of, 484\nGridView control, 681-682\ncreating master views, 690-691\nsorting, 684-685\nimpersonation, 589\nlanguages, choosing, 493\nLogin controls, 495, 564\nlogin controls\nChangePassword control, 569-573\nCreateUserWizard control, 575-576, 591\nLogin control, 565-568\nLoginName control, 569\nLoginStatus control, 568\nLoginView control, 576-577\nPasswordRecovery control, 574-575\nlogin systems, troubleshooting, 592-593\nMaster Pages\nattaching Web Forms to, 548\n<body> tags, 548\nContentPlaceHolder control, 546-548\nconverting Web sites to, 562\ncreating, 547, 552\nDynamic Web Templates versus, 546, 551-552\nmaster file extensions, 546\nnavigating Web sites via, 542\ntroubleshooting, 561\nWeb page property configuration, 114\nWeb Site development, 552-558\nwriting server-side code, 547\nmaster views, creating, 690-691\nnavigation controls, 495\ncreating test Web sites, 528\nMenu control, 527-534, 542\nroot nodes in sitemap files, 530\nsitemap files, 526\nSiteMapPath control, 540-541\nTreeView control, 534-536, 539, 542\ntroubleshooting, 542\nweb.sitemap files, 528\n.NET Framework 2.0, 485\nNonvisual Controls Visual Aid (Design View), 127\npasswords, storing, 574\npersonalization, 610, 621\nproviders, 673\nSqlDataSource control, 678\nStandard controls versus HTML controls, 496\ntroubleshooting, 520-521, 689-690\nuser controls\ncreating, 611-612, 617-620\ntroubleshooting, 625\nvalidation controls, 495\nadding to validation forms, 604-606\nCompareValidator control, 598\nControlToValidate property, 600\nCustomValidator control, 599\nDisplay property, 600\nEnableClientScript property, 600\nErrorMessage property, 599\nErrorState property, 599\nRangeValidator control, 598\nRegularExpressionValidator control, 598\nRequiredFieldValidator control, 599\nSetFocusOnError property, 601\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\ntroubleshooting, 607\nValidationGroup property, 601\nValidationSummary control, 599\nWeb Forms\nattaching to Master Pages, 548\ncreating, 493-494\nWeb site creation, 590-592\nWeb page formats, 100\nWeb Part catalog, 621-623\nWeb Part controls, 496\nadding to Web Part pages, 621-623\nAppearanceEditorPart control, 613, 625\nBehaviorEditorPart control, 625\nCatalogZone control, 613\nediting, 625-626\nEditorZone control, 613\nLayoutEditorPart control, 625\nPropertyGridEditorPart control, 625\nWebPartManager control, 613, 624\nWebPartZone control, 613\nWeb Part pages\nadding Web Part controls to, 621-623\nBrowseDisplayMode view, 616\nCatalogDisplayMode view, 616\nConnectDisplayMode view, 616\ncreating, 613-616\ncreating user controls that set display mode, 617-620\nDesignDisplayMode view, 617\nEditorDisplayMode view, 617\nnull value messages, 624\nSQLServer connections, 624\ntroubleshooting, 624\nWeb resources, 717-718\nasp.netPRO Web site, 717\nASP (Active Server Pages), 489, 672\n.aspx file extension (Content Pages), 546\nAssign Unique IDs to New Tables option (General tab, Page Editor Options dialog), 263\nAssigned To reports, 74\nAttach Dynamic Web Template dialog (Dynamic Web Templates), 372-374\nAttach Style Sheet dialog, 302, 313, 329, 334\nAttribute Names Are Lowercase check box (Code Formatting tab, Code View), 137\nattributes (HTML tag properties)\nadding ScreenTips to hyperlinks, 218\nevent handler attribute, 214\nhref attribute, 214\nopening hyperlinks in other windows, 219\nsetting in Tag Properties task pane, 216-217, 219\naudio (Windows Media), inserting into Web sites, 252-253\nAuthoring tab (Page Editor Options dialog), 268\nAuthorization Rules (ASP.NET Forms authentication), configuring, 587\nAuto step type (Wizard control), 513\nauto thumbnails, 245-246\nAutoFormat feature\nHTML tables, 156\nMenu control (ASP.NET navigation controls), 532-533\nSiteMapPath control (ASP.NET navigation controls), 541\nAutomatically Enclose Form Fields Within a Form option (General tab, Page Editor Options dialog), 262\nAutomatically Switch Keyboard to Match Language of Surrounding Text option (General tab, Page Editor Options dialog), 263\nAutoThumbnail tab (Page Editor Options dialog), 265\nbackground images (CSS), 314\nBackground section (Insert Table dialog), 155\nbanks as e-commerce solutions, 701\nbase hrefs, Web pages, 114\nBasecamp project planning/collaboration tool, 710\n\nbaseline value (valign attribute, HTML tables), 154\n\nbasic authentication, 58\n\nBehaviorEditorPart control, 625\n\nbehaviors, 21\n actions, 397\n applying, 397\n Behaviors task pane, 396-397\n Call Script behaviors, 398-399\n Change Property behaviors, 399-401\n Change Property Restore behaviors, 402\n Check Browser behaviors, 402-403, 413-415\n Check Plug-in behaviors, 403\n editing, 398, 414-415\n events, 397\n Go To URL behaviors, 404\n Jump Menu behaviors, 404\n Jump Menu Go behaviors, 405\n Open Browser Window behaviors, 406\n Play Sound behaviors, 407\n Pop-up Message Window behaviors, 407\n precedence of, 397\n Preload Images behavior, 408, 430\n processing, 396\n Set Text behaviors, 408, 410-411\n\nSet Text of Frame behaviors, 408\nSet Text of Layer behaviors, 410\nSet Text of Status Bar behaviors, 410\nSet Text of Text Field behaviors, 411\nSwap Image behavior, 396, 411, 430\nSwap Image Restore behavior, 396, 412, 430\ntroubleshooting, 412, 452\n\nBehaviors task pane, 21\n accessing, 396\n Change Property dialog, displaying, 449\n events, availability in, 397\n\nBlock Selection Visual Aid (Design View), 125\n\nBlock Selectors (CSS), 305\n\nblogs, 710\n\n<body> tags (Master Pages), 548\n\nBodyFileName field (MailDefinition property), 571\n\nBOM (Byte Order Marks), 117\n\nBookmark dialog, 111\n\nbookmarks\n Code View, 141\n HTML, 111\n\nborder attribute (HTML tables), 149\n\nborders (frames), 180, 187\n\nBorders section (Insert Table dialog), 155\n\nbread crumb navigation systems, Web site navigation via, 525\n\nBreakpoints, 477\n\nBrowse-time Web component comments, troubleshooting, 478\n\nBrowseDisplayMode view (Web Parts pages), 616\n\nbrowsers\n Check Browser behaviors, 402-403, 413\n compatibility, 354-355\n development of, 354\n quirks rendering mode, 357\n schemas, 357\n scripting, history of, 418\n\nButton dialog\n Button tab, 385-386\n Font tab, 386-387\n Image tab, 388-389\n\nbuttons (interactive)\n aligning text, 387\n Button dialog\n Button tab, 385-386\n Font tab, 386-387\n Image tab, 388-389\n editing, 391\n inserting, 385\n previewing, 386\n saving, 390\n scripting, disabling, 384\n security, 384\n styles, choosing, 385\n troubleshooting, 392\n uses for, 392-393\n\nby-Expression Web site, 716\nC# (programming language), 493\n\nCalendar control (ASP.NET)\n- adding title attributes to, 623\n- CaptionAlign property, 508\n- DayNameFormat property, 508\n- FirstDayOfWeek property, 509\n- formatting, 507\n- NextMonthText property, 509\n- NextPrevFormat property, 509\n- PrevMonthText property, 509\n- properties of, 508\n- SelectedDate property, 510\n- SelectionMode property, 510\n- SelectMonthText property, 510\n- SelectWeekText property, 510\n- ShowDayHeader property, 510\n- ShowGridLines property, 510\n- ShowNextPrevMonth property, 510\n- ShowTitle property, 511\n- SideBarButtonStyle property, 521\n- SideBarStyle property, 521\n- StepStyle property, 521\n- TitleFormat property, 511\n- UseAccessibleHeader property, 511\n- VisibleDate property, 511\n\nCalendar Tasks pop-up, 507\n\nCall Script behaviors, 398-399\n- Campfire chat tool, 710\n- CaptionAlign property, 508\n- Calendar control (ASP.NET), 508\n- Capture Interfaces dialog, 64\n- Capture Packets in Promiscuous Mode check box, Capture Options dialog, 64\n- cascading order (CSS), 322\n- case-sensitivity, PHP scripts, 645\n- CatalogDisplayMode view (Web Parts pages), 616\n- CatalogZone control, 613, 621\n- Categories reports, 74\n- Categorize by Element option (Manage Styles task pane), 323\n- Categorize by Order option (Manage Styles task pane), 323\n- Categorize by Type option (Manage Styles task pane), 324\n- Category list (Style Builder), 334\n- cboSites_Change event, 470\n- CC field (MailDefinition property), 571\n- Cell Properties dialog\n - Table menu, 161\n - Tag Properties task pane, 216\n- cellspacing attribute (HTML tables), 149-150\n- cells (HTML tables)\n - aligning content in, 153, 160\n - merging, 158-159\n - selecting, 158\n - valign attribute, 153-155\n- certificates (digital), 149-150\n- ChangePassword Tasks pop-up (ChangePassword control), 570\n- Change Property behaviors, 399-401\n- Change Property dialog (Behaviors task pane), 449\n- Change Property Restore behaviors, 402\n- ChangePassword control, 569\n - ChangePassword pop-up, 570\n - DisplayUserName property, 570\n - MailDefinition property, 571-572\n - PasswordHintText property, 573\n - PasswordRecoveryUrl property, 573\n - SuccessPageUrl property, 573\n- changeStatus function (JavaScript), 423\n- changeVisibility function (JavaScript), 428\n- Check Browser behaviors, 402-403, 413-415\n- Check Plug-in behaviors, 403\nCheck Where section (Accessibility Checker feature), 348\nCheckout Status reports, 73\nchild layers\n creating, 442\n inserting into Web pages, 445\n positioning, 443\n renaming, 443\nChoose Data Source dropdown, Menu Tasks dialog, 542\nChris Hanscom’s PHP Resource Center Web site, 717\nClass module, 456\nClass Selectors option (CSS Reports dialog, Usage tab), 338\nclasses (CSS)\n basic application of, 308-310\n Class Selectors option (CSS Reports dialog, Usage tab), 338\n moving, 339\n multiple classes, 310-311\n pseudo-classes, 311\n Remove Class option (Apply Styles task pane), 329\n syntax of, 308\n troubleshooting, 313\n Undefined Classes option (CSS Reports dialog, Errors tab), 336\nclick events, 220, 465, 472\nclient Ajax libraries, creating, 639\nCode Block scripts (PHP), 663\nCode Error icon (Code View), 356\nCode Formatting tab\n Code View, 137-139\n Page Editor Options dialog, 266\ncode snippets, 117, 122\nCode Snippets tab (Page Editor Options dialog), 270\nCode View, 124, 136, 143\n Bookmarks, 141\n Code Error icon, 356\n Code Formatting tab, 137-139\n code problems, identifying, 355-357\n code snippets, 117\n Compatibility Checker errors, troubleshooting, 362\n Context menu, 140\n Dynamic Web Templates, modifying, 375-376\n IntelliSense, 139-140, 657-659\n Page Editor Options dialog options, 264-265\n Quick Tag tools, 139, 142\n syntax highlighting, 656, 665\n Tag Properties task pane, 215, 221-222\nCode View options (General tab, Page Editor Options dialog), 264-265\ncolor blindness, 352\nColor Coding tab (Page Editor Options dialog), 267\ncolspan attribute (HTML tables), 152-153\ncolumn (<td>) tags (HTML tables), 152-153\nColumn Properties dialog, 168\ncolumns (HTML tables)\n adding/deleting, 164\n configuring, 166-169\ncommand prompt, starting Microsoft Expression Development Server from, 490\nComment scripts (PHP), 663\ncomments (PHP), 645\nCommon CatalogZone Tasks pop-up, 621\nCommon DeclarativeCatalogPart Tasks pop-up, 622\nCommon DropdownList Tasks pop-up, 617\nCommon Language Runtime, 485\nCommon WebPartZone Tasks pop-up, 614\nCompareValidator control, 598\ncompatibility\n Accessibility Reports, 359\n backward compatibility, 355\n code problems, identifying, 355-357\n Compatibility Reports, 359\n CSS Reports, 359\ndefining, 354\ndevelopment of, 354\ndoctype declarations\n Compatibility Checker dialog, 360\n configuring, 358\n troubleshooting, 358\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\ninvalid code, marking, 358-359\nolder browsers, designing for, 355\nschemas, 357-358\ntroubleshooting, 362\nWeb standards enforcement, 363\nCompatibility Checker dialog\nCode View errors, troubleshooting, 362\nCompatibility pane, 360-362\nCompatibility Reports, 19, 359\nRun Check Based on Doctype Declaration in Page if Available check box, 360\nComplete step type (Wizard control), 513\ncomplex regular expressions, 279\ncompliancy in Web sites. See Accessibility Reports feature\nconfiguring\nASP.NET authorization settings, 581\nAuthorization Rules (ASP.NET forms authentication), 587\nauto thumbnails, 246\ndoctype declarations (XHTML), 358\nfile editors, 119-120\nframes in framesets, 179-180\nHTML tables, 166-169\nMenu control (ASP.NET navigation controls), 529\nschemas (Web browsers), 358\nWeb page properties, 113 advanced properties, 115\nASP.NET Master Pages, 114\ncustom properties, 115-116\nDefault Target Frame property, 114\nDynamic Web Templates, 114\nformatting properties, 115\ngeneral properties, 114-115\nlanguage properties, 116\nMETA tags, 116\npage margins, 116\nWeb sites\nASP.NET forms authentication, 579-582\nMicrosoft Expression Development Server, 588-590\nreports, 74\nConfirmation Page tab (Form Properties dialog), 202\nConnectDisplayMode view (Web Parts pages), 616\nconsistency in web site design. See Dynamic Web Templates\nContent control (Content Pages), 549-550, 560\ncontent management systems, data access, 674\nContent Pages (ASP.NET) .aspx file extension, 546\nContent control, 549-550, 560\ncontents of, 551\ncreating, 548-549, 559\ncustom content, defining, 560\ntroubleshooting, 561\nContentPlaceHolder control (Master Pages), 546-548\nContext menu (Code View), 140\nContextual Selectors section, Apply Styles task pane, 328\nContradicting Width check box, 168\ncontrols (ASP.NET)\nAJAX Extensions controls, 496\ndeclarative syntax, 500\nHTML controls versus, 496\nLogin controls, 495\nNavigation controls, 495\nproperties, accessing, 497-499\nrendering, 496\nStandard controls, 495\nAdRotator control, 501-506\nCalendar control, 507-511\nlist of, 500-501\nWizard control, 512-521\nValidation controls, 495\nWeb pages adding to, 497\ninserting into, 496\nWebParts controls, 496\nControlToValidate property, 600, 605\nconverting\nLogin controls to templated controls, 566\nWeb sites to Master Page sites, 562\nCookie variables (PHP), 662\nCopy Web Site view, 53, 84\ncorrupt temporary files, 70\nCreate Hover Image check box (Button dialog, Image tab), 388\nCreate Pressed Image check box (Button dialog, Image tab), 388\nCreateUserIconUrl property (Login control), 567\nCreateUserText property (Login control), 567\nCreateUserWizard control, 575-576, 591\nCSS (Cascading Style Sheets), 16\nApply Styles task pane, 18, 316-317, 327\nApply Style option, 328\nAttach Style Sheet option, 329\nDelete option, 328\nGo To Code option, 328\nManage Style Sheet Links option, 329\nModify Style option, 328\nNew Style Copy option, 328\nNew Style option, 328\nRemove Class option, 329\nRemove ID option, 329\nRemove Inline Style option, 329\nRemove Link option, 328\nSelect All x Instances option, 328\narranging styles, 339\nASP.NET, formatting, 521\nAttach Style Sheet dialog, 334\nbackground images, 314\nbenefits of, 295\nBlock Selectors, 305\ncascading order, 322\nchanging standards of Web development, 706\nclasses\nbasic application of, 308-310\nmoving, 339\nmultiple classes, 310-311\npseudo-classes, 311\nsyntax of, 308\ntroubleshooting, 313\ncode formats, 301\nCSS ID, 323, 329\ndevelopment of, 294\nelements\npseudo-elements, 312\ntroubleshooting, 313\nembedded files, 313\nEmbedded Style sheets, 297-299\nExternal Style sheets, 297-298\nformatting\nASP.NET, 521\nWeb pages, 296-297\nWeb sites, 299-304\nframes versus, 177\nHTML\nformatting tables, 163-164\nselectors, 300\ninheritance, 322\nInline styles, 297-299, 308\nLayouts option (New dialog), 100\nLink Style Sheet dialog, 317, 334-335\nManage Styles task pane, 17, 317, 321-322\nCategorize by Element option, 323\nCategorize by Order option, 323\nCategorize by Type option, 324\nDisplay Selected Style Preview menu, 326\nSeparate Grouped Selectors option, 326\nShow All Styles option, 324\nShow Styles Used in Current Page option, 324\nShow Styles Used on Selection option, 324-325\nMaster Pages reports, 73\nmenus, creating, 527\npositioning content\nabsolute positioning, 305\nimages, 305-307\nProperties task pane, 318-319, 330-331\nReports dialog, 20, 319, 336-338, 359\nQuick Tag Selectors, 305\nStyle Builder, 320, 332\nApply New Style to Document Selection check box, 334\nCategory list, 334\ncreating styles, 333-334\nSelector drop-down, 333\nStyle Builder tool, 16\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\nstyles\ncreating, 333-334\nMenu control\n(ASP.NET navigation controls), 533-534\nTreeView control\n(ASP.NET navigation controls), 539\ntroubleshooting, 313, 338-339\nWeb pages\ncreating, 101\nformatting, 296-297\nWeb sites\nformatting, 299-304\ntemplates, 30\n\nCSS Display:none Visual Aid (Design View), 126\nCSS ID, 323, 329\nCSS tab (Page Editor Options dialog), 266-267\ncurly braces ({ }) in regular expressions, 281\nCurrent Page option (find and replace tool), 278\nCustom AutoFilter dialog (CSS Reports dialog), 337\nCustom tab (Page Properties dialog), 115-116\ncustomizing\nDynamic Web Templates, 374-376\nHTML tables, 156\nTag Properties task pane, 214\nCustomValidator control, 599\n\nD\n\ndash (-) characters, regular expressions (find and replace tool), 277\ndata access\nASP.NET tools, 672-673\ncontent management systems, 674\nData Source Library task pane, 24\ndatabase design, 674\nhistory of, 672\n.NET Framework tools, 674\nPHP tools, 674\nData controls (ASP.NET), 495\nData Source Configuration Wizard, 530\nData Source Library task pane, 24\ndatabases\ndesigning, 674\nsaving HTML form results to, 204, 206\nupdating, HTML form fields, 207\nDataFile property (AccessDataSource control), 679\nDataSourceMode property (AccessDataSource control), 679\nDayNameFormat property, Calendar control (ASP.NET), 508\nDebug toolbar, 477\ndebugging\nJavaScript, 436\nmacros, 477\nDeclarativeCatalogPart control, 621\nDefault Fonts tab (Page Editor Options dialog), 265\nDefault Page Encoding drop-down (Language tab), 71\nDefault Page Language drop-down (General tab, Page Editor Options dialog), 263\nDefault Target Frame property, Web page property configuration, 114\nDelete Files button (Advanced tab), 70\nDelete option (Apply Styles task pane), 328\nDeleteQuery property (AccessDataSource control), 680\ndeleting\ncolumns from HTML tables, 164\nfiles\nFolder List task pane, 10\nmanually, 70\nframes, 182\nmetadata, 34\nrows from HTML tables, 164\nWeb sites, 34\n_vti folders, 34\ndelimiters (PHP), 644\ndependencies, showing in Personal Web Packages, 90\nDependency Checking drop-down (Export Web Package dialog), 90\ndeprecated attributes, HTML tables, 147\ndesign surface, 10\n\nDesign View, 124, 143, 655\nformatting marks, 128\nmultiple layers, selecting in, 446\nPage Size menu, 135\nRuler and Grid feature\nenabling grids, 131\nmoving layers, 130\norigins, 129-130\nSnap to Grid feature, 131\nsizing Web pages, 134-135\nTracing Image feature, 132-133, 142\nVisual Aids\nASP.NET Control\nErrors, 127\nASP.NET Non-visual Controls, 127\nBlock Selection, 125\nCSS Display:none, 126\nEmpty Containers, 126\nMargins and Padding, 126\nTemplate Region Labels, 127\nVisible Borders, 126\nDesignDisplayMode view (Web Parts pages), 617\nDestinationPageUrl property (Login control), 567\ndetail views, creating, 692\nDetailsView control, 692\nDevelopment computer, 44\nDHTML\nmenu system\nchoosing, 527\nWeb site navigation via, 524\nmenus, 422\ndigital certificates, Personal Web Packages, 94\nDigital River (e-commerce example), 699-700\nDisableCreatedUser property (CreateUserWizard control), 575\ndisk-based Web sites, 31, 41\ncreating, 32\nmapped drives, 32-33\ntesting, 35, 42\nUNC shares, 32\nDisplay mode\nadding code to change, 618\nuser control that sets, 617\nDisplay property, validation controls, 600\nDisplay Selected Style preview menu option (Manage Styles task pane), 326\nDisplayRememberMe property (Login control), 567\nDisplayUserName property (ChangePassword control), 570\n<div> tags. See also layers\nAJAX Library, 638\npositioning, 438\ndocking task panes, 8\ndoctitle, 381\ndoctitle region (Dynamic Web Templates), 368\ndoctype declarations (XHTML), 269\ncode problems, identifying, 356\nconfiguring, 358\nmissing declarations, quirks of, 357\nRun Check Based on Doctype Declaration in Page if Available check box (Compatibility Checker dialog), 360\ntroubleshooting, 358, 362\nDOM (Document Object Model)\ndocument object, 424\nwindow object, 423\nDotNetJunkies Web site, 717\ndragging/dropping task panes, 8\nDraw Layer button (Layers task pane), 439\nDraw Layout Cell tools, 171\nDraw Layout Table tools, 171\nDraw Table feature (Tables Toolbar), 165\nDropDown Box control, 617\nDropdownList control, 617-619, 624, 632-634\ndrpMusicGroup control, 635-637\ndynamic content in Web sites\nbehaviors, 21\nInteractive Buttons, 20\nlayers, 22\nDynamic Domain Name System (DNS), 65\nDynamic Web Templates, 14, 30, 543\nAttach Dynamic Web Template dialog, 374\ncode examples, 381-382\nHow can we make this index more useful? Email us at indexes@quepublishing.com\ncomments, 52\ncreating, 368\ncustomizing, 374-376\ndoctitle region, 368\neditable regions, 370-371\nadding, 377\nproviding default content, 373\nremapping, 379\nrenaming, 378-380\nresolving mismatched regions, 378\nfunctions of, 368\nMaster Pages (ASP.NET) versus, 546, 551-552\nmaster.dwt files, 321\nmetadata storage, 33\nmodifying, 374-376\npage layouts, creating, 369-370\nreports, 73\ntroubleshooting, 380\nupdating sites with, 374\nWeb pages\nattaching to, 372-373\ndetaching to, 376, 380\nproperty configuration, 114\nWeb sites, updating, 374-375\n\n**E**\n\n**e-commerce**\nadvertising, 702\nexamples of, 698-700\npayment processing, 700-701\nrisks of, 703\nsecurity, 702\ntime management and, 699\n\n**echo statements (PHP),**\n644, 663\n\n**Edit Rule dialog, configuring ASP.NET authorization settings,** 581\n\n**Edit Tag option (Quick Tag Editor),** 228\n\n**editable regions (Dynamic Web Templates),** 370-371\nadding, 377\nproviding default content, 373\nremapping, 379\nrenaming, 378-380\nresolving mismatched regions, 378\n\nediting\nbehaviors, 398, 414-415\nfiles in frames, 184\nInteractive Buttons, 391\nRegistry searches, 288-289\ntags, Tag Properties task pane, 15\nWeb Part controls, 625-626\n\n**EditorDisplayMode view (Web Parts pages),** 617\n\n**EditorZone control, 613, 625\n**\n\n**Element Selectors option (CSS Reports dialog, Usage tab),** 338\n\n**elements**\nCSS pseudo-elements, 312\nXML ASP.NET\nAdRotator control, 501-502\ncapturing of traffic on the network, 61\nnetwork protocol analyzer, 56, 60-61\nnumber of packets, 60\nusing to troubleshoot HTTP publishing errors, 60\nevent handler attribute\n(HTML tag properties), 214\n\n**Embedded Style Sheets (CSS),** 297-299\n\n**EmbeddedObjects field (MailDefinition property),** 571\n\n**Embossed Capsule button style (Button dialog, Image tab),** 389\n\n**emerging technologies (Web development),** 707-710\n\n**Empty Containers Visual Aid (Design View),** 126\n\n**Empty Web Site option (Web site templates),** 30\n\n**EnableClientScript property, validation controls,** 600\n\n**Errors option (Accessibility Checker feature, Check Where section),** 348\n\n**Errors, reported in Accessibility Checker dialog,** 348\n\n**Errors tab (CSS Reports dialog),** 336\n\n**ErrorMessage property,** 599-600\n\n**escape (\\) characters, regular expressions (find and replace tool),** 277\n\n**Ethereal**\ncapturing of traffic on the network, 61\nnetwork protocol analyzer, 56, 60-61\nnumber of packets, 60\nusing to troubleshoot HTTP publishing errors, 60\nevents\nbehaviors, 397\nHTML tag properties\nclick events, 220\nhooking, 214\nmousemove events, 429\nExpandDephth property\n(TreeView control), 537\nExport Web Package dialog\nDependency Checking\ndrop-down, 90\nPersonal Web Package\ncreation\nadding files to, 90\nMy Web Packages, 88\nnaming packages, 88\npersonalizing packages, 89\nshowing dependencies, 90\nShow Dependencies but-\nton, 90\nExpression Designers Web\nsite, 716\nExpression Development\nServer (Microsoft), 484\nASP pages, 489\ncommand prompt, starting\nfrom, 490\ninstalling, 485\nlimitations of, 488-489\nmanually stopping, 487-488\nPreview tab, 486\nsupport for, 486\ntroubleshooting, 490\nWeb site configuration, 588-590\nExpression Web Help Web\nsite, 716\nExternal Style Sheets\n(CSS), 297-298\nFind in Source Code\ncheck box, 279\nFind tab, 277\nHTML\nRules feature, 283-285\nTags tab, 277, 286\nOpen Page(s) option, 278\nRegular Expression check box, 279\nregular expressions\ncurly braces ({} ) in, 281\ndash (-) characters, 277\nescape (\\) characters, 277\ntagged expressions, 281-282\ntext, 276, 279\nReplace tab, 277\nsaving queries, 287\nSelected Page(s) option, 278\nFind and Replace dialog, 278\ntext, 276-282\ntroubleshooting, 287-288\nFEED Validator, 712\nFiddler debugging tool,\n56-59\nfile editors, configuring,\n119-120\nFile menu, Recent Sites\noption, 34\nFile Results tab (Form\nProperties dialog), 199-200\nFile Save dialog, saving\nPersonal Web Packages, 91\nFile System method of pub-\nlishing, 49\nFilterExpression property\n(AccessDataSource con-\ntrol), 680\nFilterParameters property\n(AccessDataSource con-\ntrol), 680\nfind and replace tool, 14-15\nAll Page option, 278\nCurrent Page option, Find\nand Replace dialog, 278\nFlash movies, inserting into\nWeb sites, 248-249\nFailed to access IIS\nmetabase error messages,\n591\nFailed to start monitoring...\nerror messages, 593\nFailureAction property\n(Login control), 567\nFailureText property\n(Login control), 567\nFastCGI\ninstalling\nVista, 648\nWindows Server 2008,\n649\nPHP, enabling, 650-652\nFind in Source Code\ncheck box, 279\nFind tab, 277\nHTML\nRules feature, 283-285\nTags tab, 277, 286\nOpen Page(s) option, 278\nRegular Expression check box, 279\nregular expressions\ncurly braces ({} ) in, 281\ndash (-) characters, 277\nescape (\\) characters, 277\ntagged expressions, 281-282\ntext, 276, 279\nReplace tab, 277\nsaving queries, 287\nSelected Page(s) option, 278\nFind and Replace dialog, 278\ntext, 276-282\ntroubleshooting, 287-288\nFEED Validator, 712\nFiddler debugging tool,\n56-59\nfile editors, configuring,\n119-120\nFile menu, Recent Sites\noption, 34\nFile Results tab (Form\nProperties dialog), 199-200\nFile Save dialog, saving\nPersonal Web Packages, 91\nFile System method of pub-\nlishing, 49\nFilterExpression property\n(AccessDataSource con-\ntrol), 680\nFilterParameters property\n(AccessDataSource con-\ntrol), 680\nfind and replace tool, 14-15\nAll Page option, 278\nCurrent Page option, Find\nand Replace dialog, 278\nFlash movies, inserting into\nWeb sites, 248-249\nFirstDayOfWeek property,\nCalendar control\n(ASP.NET), 509\nFirstLetter property value\n(DayNameFormat prop-\nerty), 509\nFirstTwoLetters property\nvalue (DayNameFormat\nproperty), 509\nFlash movies, inserting into\nWeb sites, 248-249\nFind in Source Code\ncheck box, 279\nFind tab, 277\nHTML\nRules feature, 283-285\nTags tab, 277, 286\nOpen Page(s) option, 278\nRegular Expression check box, 279\nregular expressions\ncurly braces ({} ) in, 281\ndash (-) characters, 277\nescape (\\) characters, 277\ntagged expressions, 281-282\ntext, 276, 279\nReplace tab, 277\nsaving queries, 287\nSelected Page(s) option, 278\nFind and Replace dialog, 278\ntext, 276-282\ntroubleshooting, 287-288\nFind in Source Code\ncheck box, 279\nFind tab, 277\nHTML\nRules feature, 283-285\nTags tab, 277, 286\nOpen Page(s) option, 278\nRegular Expression check box, 279\nregular expressions\ncurly braces ({} ) in, 281\ndash (-) characters, 277\nescape (\\) characters, 277\ntagged expressions, 281-282\ntext, 276, 279\nReplace tab, 277\nsaving queries, 287\nSelected Page(s) option, 278\nFind and Replace dialog, 278\ntext, 276-282\ntroubleshooting, 287-288\nFind in Source Code\ncheck box, 279\nFind tab, 277\nHTML\nRules feature, 283-285\nTags tab, 277, 286\nOpen Page(s) option, 278\nRegular Expression check box, 279\nregular expressions\ncurly braces ({} ) in, 281\ndash (-) characters, 277\nescape (\\) characters, 277\ntagged expressions, 281-282\ntext, 276, 279\nReplace tab, 277\nsaving queries, 287\nSelected Page(s) option, 278\nFind and Replace dialog, 278\ntext, 276-282\ntroubleshooting, 287-288\nFind in Source Code\ncheck box, 279\nFind tab, 277\nHTML\nRules feature, 283-285\nTags tab, 277, 286\nOpen Page(s) option, 278\nRegular Expression check box, 279\nregular expressions\ncurly braces ({} ) in, 281\ndash (-) characters, 277\nescape (\\) characters, 277\ntagged expressions, 281-282\ntext, 276, 279\nReplace tab, 277\nsaving queries, 287\nSelected Page(s) option, 278\nFind and Replace dialog, 278\ntext, 276-282\ntroubleshooting, 287-288\nFind in Source Code\ncheck box, 279\nFind tab, 277\nHTML\nRules feature, 283-285\nTags tab, 277, 286\nOpen Page(s) option, 278\nRegular Expression check box, 279\nregular expressions\ncurly braces ({} ) in, 281\ndash (-) characters, 277\nescape (\\) characters, 277\ntagged expressions, 281-282\ntext, 276, 279\nReplace tab, 277\nsaving queries, 287\nSelected Page(s) option, 278\nFind and Replace dialog, 278\ntext, 276-282\ntroubleshooting, 287-288\n\nFlash SWF Properties dialog, 249-250\nFolder List task pane, 10\nFont dialog, 107-108\nFont Families tab (Page Editor Options dialog), 271\nFont Size drop-down (Font dialog), 108\nFont tab (Button dialog), 386-387\nfonts (text)\n Default Fonts tab (Page Editor Options dialog), 265\n families, formatting Web page text, 107\n Font Families tab (Page Editor Options dialog), 271\n Font tab (Button dialog), 386-387\n sizes, formatting Web page text, 107-108\nFor All Web Pages option (Microsoft Expression Development Server, Preview tab), 486\nfor loop, 434\nFor Only PHP and ASP.NET Web Pages option (Microsoft Expression Development Server, Preview tab), 486\nform controls (HTML), 192\n list of, 193-194\n troubleshooting, 208\nForm Properties dialog\n Confirmation Page tab, 202\n Email Results tab, 200-202\n File Results tab, 199-200\nSaved Field tab, 203\nSaving Results dialog, 198\nSend To Database option, 198-200, 204-206\nSend To option, 198-199\nSend To Other option, 198\nform validation, 432-435\n ASP.NET validation controls, 598\n adding to forms, 604-606\n CompareValidator control, 598\n ControlToValidate property, 600\n CustomValidator control, 599\n Display property, 600\n EnableClientScript property, 600\n ErrorMessage property, 599\n RangeValidator control, 598\n RegularExpressionValidator control, 598\n RequiredFieldValidator control, 599\n SetFocusOnError property, 601\n ValidationGroup property, 601\n ValidationSummary control, 599\n form creation, 601-603\n changing form field ID, 604\n testing forms, 607\n troubleshooting, 607\n validation groups, 608\nForm variable (PHP), 661\nFormatString property (LoginName control), 569\nformatting\n ASP.NET, CSS styles, 521\n Calendar control (ASP.NET), 507\n Code Formatting tab (Code View), 137-139\n HTML tables, 156, 163-164\n hyperlinks, 115\n Login control, 565\n Menu control (ASP.NET navigation controls), 531-533\n PasswordRecovery control, 574\n SiteMapPath control (ASP.NET navigation controls), 541\n TreeView control (ASP.NET navigation controls), 536\n Web pages\n CSS, 296-297\ntext, 105-108\n Web sites, CSS, 299-304\nformatting marks (Design View), 128\nFormatting tab (Page Properties dialog), 115\nforms\n authentication (ASP.NET)\n adding users to, 585\n configuring\n Authorization Rules, 587\n configuring Web sites for, 579-582\n enabling, 584\n HTML\n creating, 194-197\ndatabase updates, 207\n hidden fields, 208-209\n saving results, 197-206\n HTTP, components of, 192\nFP_checkBrowser function, 414\nframe attribute (HTML tables), 151-152\nframe pages, Web page creation, 101\nFrame Properties dialog, 179-180\nFrame Size Width and Row Height property (Frame Properties dialog), 180\nFrame Spacing option (Frames Page dialog), 180\nframes, 176\n accessibility, designing for, 346\n alternative content, creating, 182-183\n borders, 187\n CSS versus, 177\n deleting, 182\n drawbacks of, 177\n editing files in, 184\nFrames pages\n adding existing pages to, 179\n adding URL to, 179\n creating frameset pages, 177-178\n creating new pages, 178\n displaying web content in, 179\nframesets\n configuring in, 179-180\n creating pages for, creating, 177-178\n nested framesets, 189\nhyperlinks, 183, 187\ninline frames, 184-185\nlayout choices, 178\nlinks, 177\nMSDN Library, 176\nnested frames, 177\nNo Frames view, 182-183\nsearch engines, 177\nsizing, 188\nsplitting, 181\ntargeting, 183\ntext, sizing, 177\ntroubleshooting, 187\nuses for, 176\nFrames Page dialog, 180\nFrom field (MailDefinition property), 572\nFrontPage 97, 672\nFrontPage Server Extensions, 195, 205\n configuration abnormalities, 47\n configuring for your Web site, 46\n defined, 45\n functionality, 46\n HTML forms, creating, 194\n HTTP Web sites, 37-39\n importing Web sites, 79-80\n installation, 63\n phasing out of, 551\n publishing content, 44\nServer Message Language drop-down (Language tab, Site Settings dialog), 71\ntroubleshooting, 46\nusername/password not accepted, 63\nwhen to choose, 46\nFTP (File Transfer Protocol)\n active FTP, 49\n and publishing of content, 44\n passive FTP, 49\n security, 48\n Web sites, 35-36, 41\nFull property value (DayNameFormat property), 509\nfull tags (PHP), 644\nfunctions\n JavaScript\n changeStatus function, 423\n changeVisibility function, 428\n hidAllDivs function, 428\n indexOf function, 434\n swapImage function, 430-431\n validateForm function, 434-435\n writeDateTime function, 420-422\n PHP, 647\nG\nGeneral tab\n Flash SWF Properties dialog, 250\n Page Editor Options dialog\n ActiveX Controls options, 265\n Assign Unique IDs to New Tables option, 263\n Automatically Enclose Form Fields Within a Form option, 262\n Automatically Switch Keyboard to Match Language of Surrounding Text option, 263\n Code View options, 264-265\n Default Page Language drop-down, 263\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\nMake ID Unique on Paste option, 263\nPaste Options button, 263\nPrompt for Accessibility Properties when Inserting Images option, 263\nShow Paste Options Buttons check box, 263\nSpelling Options dialog, 263\nUse <strong> and <em> when Using Bold and Italic Toolbar Buttons option, 263\nPage Properties dialog, 114-115\nSite Settings dialog, 68\nWindows Media Player Properties dialog, 253-254\nGenerator and ProgID tags, 53\nGetSubWebs function, 466\nGetWebSites function, 468\nGo To Code option (Apply Styles task pane), 328\nGo To URL behaviors, 404\nGoogle Analytics, 76\nGridView control, 681-682\nmaster views, creating, 690-691\nsorting, 684-685\nGridView Tasks pop-up, 686\nHelpPageIconUrl property (Login control), 567\nHelpPageText property (Login control), 567\nHelpPageUrl property (Login control), 567\nhidden HTML form fields, 208-209\nhideAllDivs function (JavaScript), 428\nhiding/viewing Web page elements, 425-429\nhooking events (HTML tag properties), 214\nhosting Web sites, 64-65, 259\nhotspots (images), 247\nhref attribute (HTML tag properties), 214\nHTML (HyperText Markup Language)\naccessibility reports, generating, 351\nbookmarks, 111\nchanging standards of Web development, 706\n<div> tags, positioning, 438\nForm Properties dialog\nConfirmation Page tab, 202\nEmail Results tab, 200-202\nFile Results tab, 199-200\nSaved Fields tab, 203\nformatting marks (Design View), 128\nforms\ncomponents of, 192\ncontrols, 192-194, 208\ncreating, 194-197\ndatabase updates, 207\nhidden fields, 208-209\nsaving results, 197-206\nframes\nborders, 187\nconfiguring in framesets, 179-180\ncreating alternative content, 182-183\nCSS versus, 177\ndeleting, 182\ndrawbacks of, 177\ningoing files in, 184\nFrames pages, 177-179\nhyperlinks, 183, 187\ninline frames, 184-185\nlinks, 177\nMSDN Library, 176\nnested frames, 177\nnested framesets, 189\nNo Frames view, 182-183\nsearch engines, 177\nsizing, 188\nsizing text, 177\nsplitting, 181\ntargeting, 183\ntroubleshooting, 187\nuses for, 176\nIntelliSense, 139-140\nleading whitespace, 52\noptimization, 52, 64\nRules feature (Find and Replace tool), 283-285\nselectors (CSS), 300\nStandard ASP.NET controls versus, 496\ntables\nadding columns, 164\nadding rows, 164\naligning cell content, 160\ncell attributes, 153-155\nconfiguring columns, 166-169\nconfiguring rows, 166-169\ncustomizing, 156\ndeleting columns, 164\ndeleting rows, 164\ndeprecated attributes, 147\ndevelopment of, 146\ndrawing, 165\nformatting, 156, 163-164\ninserting, 155\nLayout Tables task pane, 169-171\nmerging cells, 158-159\nmonitor resolution design, 172-173\nrowspan attribute, 152-153\nselecting cells, 158\nsizing, 161-163\n<table> tags, 146-152\n<td> (column) tags, 152-153\n<tr> (row) tags, 152\ntroubleshooting, 172\ntags\nattributes, 214-219\nchanging via JavaScript, 429-431\nevents, 214, 220\nfinding/replacing, 286\nhyperlinks, 214\ntroubleshooting, 221\nviewing in Tag Properties task pane, 215-216\nWeb standards, 221-222\nTags tab (Find and Replace tool), 277, 286\nwhitespace, 52\nHTTP (Hypertext Transfer Protocol), 46\nauthentication traffic, 57\npublishing, 55-59, 62\nWeb sites\ncreating, 38-39\nFrontPage Server Extensions, 39\nimporting, 82-83\nopening live, 37\nHTTPS protocol, 46\nHyperlink Parameters dialog, 111\nhyperlinks\naccessibility, designing for, 344-345\nchecking, 74\nformatting, 115\nframes, 183, 187\nHTML\nbookmarks, 111\ntag properties, 214\nInsert Hyperlink ScreenTip dialog, 345\nManage Style Sheet Links option (Apply Styles task pane), 329\nopening in other windows, 219\nquery strings, 110\nRemove Link option (Apply Styles task pane), 328\nreports, 74\nScreenTips, 112, 218, 345\nWeb pages, creating in, 108-109\nIDC/HTX, 672\nif statements (PHP), 663\nIIS 7, installing\nVista, 648\nWindows Server 2008, 649\nimages\nbackground images (CSS), 314\nhotspots, creating, 247\nHTML tags\nadding to, 431\nclick events, 220\npreloading, 430\nImage tab (Button dialog), 388-389\nmaps, creating, 247\npositioning via CSS, 305-307\nPreload Images behavior, 430\nPrompt for Accessibility Properties when Inserting Images option (General tab, Page Editor Options dialog), 263\nsizing, 258\nslicing, 132\nSwap Image behavior, 411, 430\nSwap Image Restore behavior, 412, 430\nthumbnails, 245-246\nTracing Image feature (Design View), 132-133, 142\ntroubleshooting, 258\nImageSet property (TreeView control), 537\nimgObj variable, 431\nImmediate Window, 477\nImpersonation (ASP.NET), 589\nImport dialog, importing files to Web pages, 102\nImport Web Package dialog, 91-93\nImport Web Site wizard, 78\n Copy Web Site view, 84\ndestination locations, specifying, 84\nFrontPage Server\n Extensions method, 79-80\nHTTP method, 82-83\ntroubleshooting, 85\nWebDAV method, 80-82\nimporting files to Web pages, 101-102\nPersonal Web Packages, 89-93\nWeb sites, 78\n FrontPage Server\n Extensions method, 79-80\nHTTP method, 82-83\npublishing versus, 86\nspecifying destination locations, 84\ntroubleshooting, 85\nWebDAV method, 80-82\nImpressions element, 505\nImpressions XML element, AdRotator control (ASP.NET), 502\nInclude Once scripts (PHP), 662\ninclude statements (PHP), 662\nindexOf function (JavaScript), 434\nInformIT Web site, 716\ninheritance (CSS), 322\nInitial Page property (Frame Properties dialog), 179\ninline frames, 184-185\nInline styles (CSS), 297-299, 308, 329\nInsert HTML option (Quick Tag Editor), 228, 231-232\nInsert Hyperlink dialog, 108, 183\n ScreenTip button, 112\n Select Place in Document dialog, 111\n Target Frame dialog, 109\nInsert Hyperlink ScreenTip dialog, 345\nInsert Layer button (Layers task pane), 439\nInsert Rows or Columns dialog, 164\nInsert Table dialog, 148-149, 155\ninstalling\n FastCGI\n Vista, 648\n Windows Server 2008, 649\n IIS 7\n Vista, 648\n Windows Server 2008, 649\nMicrosoft Expression Development Server, 485\nPHP, 485, 647-650\nInstructionText property (Login control), 567\nIntelliSense\n Code View, 139-140\n PHP, 657-659\nIntelliSense tab (Page Editor Options dialog), 271\nInteractive Buttons, 20\n aligning text, 387\n Button dialog\n Button tab, 385-386\n Font tab, 386-387\n Image tab, 388-389\ndocument editing, 391\ninserting, 385\npreviewing, 386\nsaving, 390\nscripting, disabling, 384\nsecurity, 384\nstyles, choosing, 385\ntroubleshooting, 392\nuses for, 392-393\ninteractive menus (layers), creating, 442-445\ninteractivity, adding to layers, 448-452\nInternet Explorer, 221\nInternet Information Services (IIS), 65\nInternet Service Providers (ISP), 65\ninvalid code, marking, 358-359\niPod, 44\nIsBodyHtml field (MailDefinition property), 572\nJ# (programming language), 493\nJavaScript, 220, 419\n ++ symbol, 434\nalert method, 436\ndebugging, 436\nDOM (Document Object Model)\n document object, 424\n window object, 423\nexternal script files, linking to, 421\nform field validation, 432-435\nfunctions\n changeStatus function, 423\n changeVisibility function, 428\n hideAllDivs function, 428\n indexOf function, 434\n swapImage function, 430-431\n validateForm function, 434-435\n writeDateTime function, 420-422\nHTML tags\n adding images to, 431\n changing attributes, 429-431\nimages\n adding images to\n HTML tags, 431\n preloading, 430\ninline JavaScript, 421\nlogic errors, 436\nsyntax errors, 436\ntroubleshooting, 435-436\nWeb pages\n adding to, 419-420\n hiding/showing elements in, 425-429\nJimcoBooks.com Web site, 716\nJump Menu behaviors, 404\nJump Menu Go behaviors, 405\nKeyword XML element, AdRotator control (ASP.NET), 502\n\nK - L\nLabel control, 632\nLanguage tab\n Page Properties dialog, 116\n Site Settings dialog, 71\nLayer ID column (Layers task pane), 440\nLayer Visibility column (Layers task pane), 440, 447\nLayer Z-Index column (Layers task pane), 440\nlayers, 22, 438\n adding content to, 440\n child layers\n creating, 442\n inserting into Web pages, 445\n positioning, 443\n renaming, 443\n ID, choosing, 440\n interactive menus, creating, 442-445\n interactivity, adding, 448-452\n mainMenu layer, child layers, 442-443\n multiple layers, selecting in Design View, 446\n positioning, 442-446\n ProdSubmenu, 444, 448-451\n resizing, 441\n Ruler and Grid feature, moving via, 130\n SupportSubmenu, 451-452\n troubleshooting, 452\n uses of, 438\n visibility, setting, 447\n z-order, 452\nLayers task pane, 438\n displaying, 439\n Draw Layer button, 439\n Insert Layer button, 439\n Layer ID column, 440\n Layer Visibility column, 440, 447\n Layer Z-Index column, 440\n navigating, 439\nLayout section (Insert Table dialog), 155\nLayout Tables task pane, 13, 166, 169-171\nLayout Tool, configuring table columns/rows, 166-169\nLayoutEditorPart control, 625\nlblDisplayGroup Label control, 634-637\nleaf nodes, TreeView control (ASP.NET navigation controls), 536\nLink Style Sheet dialog (CSS), 317, 334-335\nListItem Collection Editor dialog, 617\nLists step (Wizard control), 518\nLocal Web site, 54\nLocals Window, 477\nLock Project for Viewing check box, 479\nLog Changes During Publish check box, 51\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\nLoggedInTemplate view, 576-577\n\nlogic errors, JavaScript, 436\n\nlogin controls, 495, 564\n ChangePassword control\n ChangePassword pop-up, 570\n DisplayUserName property, 570\n LoginText property, 569\n MailDefinition property, 571-572\n PasswordHintText property, 573\n PasswordRecoveryUrl property, 573\n SuccessPageUrl property, 573\n CreateUserWizard control, 575-576, 591\nLogin control\n adding to title attributes, 623\n built-in functionality of, 566\n converting to templated controls, 566\n CreateUserIconUrl property, 567\n CreateUserText property, 567\n DestinationPageUrl property, 567\n DisplayRememberMe property, 567\n FailureAction property, 567\n FailureText property, 567\n formatting, 565\n HelpPageIconUrl property, 567\n HelpPageText property, 567\n InstructionText property, 567\n Login Tasks pop-up, 565\n LoginButtonImageUrl property, 567\n LoginButtonText property, 567\n LoginButtonType property, 567\n Orientation property, 567\n PasswordLabelText property, 567\n PasswordRecoveryIcon property, 567\n PasswordRecoveryText property, 567\n PasswordRecoveryUrl property, 568\n PasswordRequiredText property, 568\n Remember Me checkbox, 565\n RememberMeSet property, 568\n RememberMeText property, 568\n TextLayout property, 568\n TitleText property, 568\n UserName property, 568\n UserNameLabelText property, 568\n UserNameRequiredError property, 568\n VisibleWhenLoggedIn property, 568\n LoginName control, 569\n LoginStatus control, 568-569\n LoginView control, 576-577\nPasswordRecovery control, 574\n formatting, 574\n PasswordRecovery Tasks pop-up, 575\n properties of, 575\nweb resources, 564\n\nlogin systems, 564\n ASP.NET Forms authentication\n adding users to, 585\n configuring\n Authorization Rules, 587\n configuring Web sites for, 579-582\n enabling, 584\n Microsoft Expression Development Server,\n Web site configuration, 588-590\n passwords, modifying requirements of, 594-595\n security, 564\n troubleshooting, 592-593\n Web site creation, 590-592\n\nLogin Tasks pop-up (Login control), 565\nLoginButtonImageUrl property (Login control), 567\nLoginButtonText property (Login control), 567\nLoginButtonType property (Login control), 567\nLoginCreatedUser property (CreateUserWizard control), 575\nLoginName control, 569\nLoginStatus control, 568-569\nLoginText property (LoginStatus control), 568\nLoginView control, 576-577\nLoginView Tasks pop-up (LoginView control), 577\nLogo Creator, The (Laughingbird Software), 703\nLogoutAction property (LoginStatus control), 569\nLogoutImageUrl property (LoginStatus control), 569\nLogoutPageUrl property (LoginStatus control), 569\nLogoutText property (LoginStatus control), 569\nLong Description property (Frame Properties dialog), 179\nLulu (e-commerce example), 700\n\nMake ID Unique on Paste option (General tab, Page Editor Options Options dialog), 263\nMake the Button a GIF Image and Use a Transparent Background button (Button dialog, Image tab), 389\nMake the Button a JPEG Image and Use This Background Color button (Button dialog, Image tab), 389\nManage Style Sheet Links option (Apply Styles task pane), 329\nManage Styles task pane (CSS), 17, 317, 321-322\nManage The Web Site Using Hidden Metadata Files check box (Site Settings dialog), 33\nManual Checklist option (Accessibility Checker feature, Check Where section), 348\nmapped drives, creating on disk-based Web sites, 32-33\nmapping Dynamic Web Template editable regions, 379\nmaps (image), creating, 247\nMargin Width and Height property (Frame Properties dialog), 180\nmargins (Web pages), configuring, 116\nMargins and Padding Visual Aid (Design View), 126\nMarkup Validation Service, 363\nMaster Pages (ASP.NET), 561\n<body> tags, 548\nContentPlaceHolder control, 546-548\ncreating, 547, 552\nDynamic Web Templates versus, 546, 551-552\nmaster file extensions, 546\nnavigating Web sites via, 542\nreports, 73\nserver-side code, writing, 547\ntroubleshooting, 561\nWeb Forms, attaching to, 548\nWeb page property configuration, 114\nWeb sites converting existing sites to, 562\ndeveloping, 552-558\nmaster views, creating, 690-691\nmaster.dwt files, 321\nmaster.master files, 554, 560\nmaximizing task panes, 9\nmaxInvalidPasswordAttempts attribute (machine.config file), 595\nMenu control (ASP.NET navigation controls), 527-529\n adding, 530-531\n AutoFormat feature, 532-533\n configuring, 529\n CSS styles, 533-534\n formatting, 531-533\ntroubleshooting, 542\nMenu Tasks dialog, 529, 532\nmenus (CSS), creating, 527\nmerging cells (HTML tables), 158-159\nMETA tags, configuring for Web pages, 116\nmetadata, 28-29\n Dynamic Web Templates, storing in, 33\n Manage The Web Site Using Hidden Metadata Files check box, 33\n troubleshooting, 40-41\n _vti folders, deleting, 34\nMicrosoft Access, 64\nMicrosoft Expression Development Server, 484\n ASP, 489\n installing, 485\n limitations of, 488-489\n manually stopping, 487-488\n Preview tab, 486\n starting from command prompt, 490\n support for, 486\n troubleshooting, 490\n Web site configuration, 588-590\nmiddle value (valign attribute, HTML tables), 154\nminRequiredNonphanumericCharacters attribute (machine.config file), 595\nminRequiredPasswordLength attribute (machine.config file), 595\nMismatched Case option (CSS Reports dialog, Errors tab), 336\nModify Style option (Apply Styles task pane), 328\nmonitors resolution,\n HTML table design, 172-173\nMore Colors dialog, 555\nMosaic Web browser, development of, 354\nmovies (Flash), inserting into Web sites, 248-249\nmoving\n classes (CSS), 339\n layers (Ruler and Grid feature), 130\ntask panes, 8\nMSDN Library frames, 176\nmultimedia\n Flash movies, inserting into Web sites, 248-249\n Silverlight applications, inserting into Web sites, 250-252\n video, web hosting fees, 259\n Windows Media audio, inserting into Web sites, 252-253\nMy Web Packages, 88\n\nName property (Frame Properties dialog), 179\nName/E-mail step (Wizard control), 517\nnaming\n child layers, 443\n editable regions, Dynamic Web Templates, 378-380\n Personal Web Packages, 88\n Web sites, 68\nNavigation controls (ASP.NET), 495\nnavigation systems\n ASP.NET controls\n creating sitemap files, 526\n creating test Web sites, 528\n Menu Control, 527-534, 542\n root nodes in sitemap files, 530\n saving sitemap files, 526\n SiteMapPath Control, 540-541\n TreeView Control, 534-536, 539, 542\ntroubleshooting, 542\n web.sitemap files, 528\nbread crumb systems, 525\nDHTML menu system, 524, 527\nMaster Pages (ASP.NET), 542\ntree view systems, 524, 534-536, 539\n\nNavigationButtonStyle property, Wizard control (ASP.NET), 521\nnested frames, 177\nnested framesets, 189\n\n.NET Framework 2.0\nASP.NET, 485\nCommon Language Runtime, 485\ndata access tools, 674\n\nNew dialog\nAdd Current Web Site box, 33\ndisk-based Web sites, 32\nDynamic Web Template, creating via, 369\nOne Page Web Site option, 30\nWeb page creation\nASP.NET page formats, 100\nCSS Layouts option, 100\nFrame Pages section, 101\ngeneral page formats, 98\nstyle sheets, 101\n\nNew Extension button, 120\nNew settings, troubleshooting, 478\nNew Style Copy option (Apply Styles task pane), 328\nNew Style option (Apply Styles task pane), 328\nNextMonthText property, Calendar control (ASP.NET), 509\nNextPrevFormat property, Calendar control (ASP.NET), 509\nNo Frames view, 182-183\nNodeIndent property (TreeView control), 538\n\nnonbreaking spaces, controlling spacing with, 138\nnull value message, troubleshooting, 624\n\nObject Browser, 458\nObject models, 457\nObject Tag tab (Windows Media Player Properties dialog), 255-256\nOffline site development, 44\nOlder Files reports, 73\nOne Page Web Site option (New dialog), 30\nonline resources\nASP.NET, 717-718\nExpression Web 2, 716\nPHP, 717-718\nWeb design, 716-717\nonmouseover events, 429\nOpen Browser Window behavior, 110, 406, 412\nOpen Page(s) option, 278\nOpen With dialog, 120\nOptimizeSite function, 473\noptimizing Web sites\nAccessibility Reports feature, 18-19\nCompatibility Reports feature, 19\nCSS Reports feature, 20\nO’Reilly Network Web site, 717\nOrientation property (Login control), 567\nnull value message, troubleshooting, 624\nPage Editor Options dialog, 105, 273\nAuthoring tab, 268\nAutoThumbnail tab, 265\nCode Formatting tab, 266\nCode Snippets tab, 270\nColor Coding tab, 267\nCSS tab, 266-267\nDefault Fonts tab, 265\ndoctype declarations, configuring, 358\nFont Families tab, 271\nGeneral tab\nActiveX Controls options, 265\nAssign Unique IDs to New Tables option, 263\nAutomatically Enclose Form Fields Within a Form option, 262\nAutomatically Switch Keyboard to Match Language of Surrounding Text option, 263\nCode View options, 264-265\nDefault Page Language drop-down, 263\nMake ID Unique on Paste option, 263\nPaste Options button, 263\nPrompt for Accessibility Properties when Inserting Images option, 263\nShow Paste Options Buttons check box, 263\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\nSpelling Options dialog, 263\nUse <strong> and <em> when Using Bold and Italic Toolbar Buttons option, 263\nIntelliSense tab, 271\nPicture tab, 269\nRuler and Grid tab, 270-271\nschemas, configuring, 358\nPage object model, 458\nPage Properties dialog, 113\nAdvanced tab, 115\nCustom tab, 115-116\nFormatting tab, 115\nGeneral tab, 114-115\nLanguage tab, 116\nPage Size menu (Design View), 135\npages\nencoding, 76, 117\nlayouts, creating via Dynamic Web Templates, 369-370\nmargins, configuring for Web pages, 116\ntransitions, troubleshooting, 259\nParameters tab (Windows Media Player Properties dialog), 256\nparent nodes, TreeView control (ASP.NET navigation controls), 536\nParentLevelsDisplayed property (SiteMapPath control), 541\npassive FTP (File Transfer Protocol), 49\npasswordAttemptWindow attribute (machine.config file), 595\nPasswordHintText property (ChangePassword control), 573\nPasswordLabelText property (Login control), 567\nPasswordRecovery control, 574-575\nPasswordRecoveryTasks pop-up, 575\nPasswordRecoveryIcon property (Login control), 567\nPasswordRecoveryText property (Login control), 567\nPasswordRecoveryUrl property (ChangePassword control), 573\nPasswordRecoveryUrl property (Login control), 568\nPasswordRegularExpression property (CreateUserWizard control), 576\nPasswordRequiredText property (Login control), 568\npasswords\nFTP Web sites, 36, 41\nRemember My Password check box, 36\nrequirements, 594-595\nPaste Options button (General tab, Page Editor Options dialog), 263\nPathDirection property (SiteMapPath control), 541\nPathSeparator property (SiteMapPath control), 541\npayment processing (e-commerce), 700-701\nPayPal, 701\nPersonal Web Packages\ncreating, 88\ndependencies, showing, 90\ndigital certificates, 94\nfiles, adding to, 90\nimporting, 89, 91-93\nMy Web Packages, 88\nnaming, 88\npersonalizing, 89\nsaving, 91\ntroubleshooting, 93\nPhotoshop, importing files to Web pages, 102\nPHP (PHP: Hypertext Preprocessor), 644\nCode Block scripts, 663\nCode View\nIntelliSense, 657-659\nsyntax highlighting, 656, 665\ncomments scripts, 663\ncookie variables, 662\ndata access tools, 674\nDesign View, 655\ndisplaying information, 665-667\necho statements, 644, 663\nelse statements, 664\nFastCGI, enabling via, 650-652\nForm variable, 661\nfunctions of, 484\nif statements, 663\nInclude Once scripts, 662\ninclude statements, 662\ninstalling, 485, 647-650\npages\ncreating, 652\npreviewing, 653-654\nphpinfo() function, 665-667\nrequire statements, 663\nrequire_once statements, 663\nSession variables, 661\nsupport for, 23\nsyntax of\n case-sensitivity, 645\n comments, 645\ndelimiters, 644\nfull tags, 644\nfunctions, 647\nprogram flow, 646\n<script> tags, 644\nshort tags, 645\nsyntax highlighting, 656, 665\nvariables, 645\ntroubleshooting, 664-665\nURL variable, 661\nWeb resources, 717-718\nPicture tab (Page Editor Options dialog), 269\nPlay Sound behaviors, 407\nPop-up Message behaviors, 407\npositioning\n content via CSS\n absolute positioning, 305\n images, 305-307\n <div> tags, 438\n layers, 442-446\nPositioning option (Quick Tag Editor), 228, 234\nPreload Images behavior, 408, 430\nPreview tab\n Microsoft Expression Development Server, 486\n Site Settings dialog, 68-69\npreviewing PHP pages, 653-654\nPrevMonthText property, Calendar control\n (ASP.NET), 509\nPriority field\n (MailDefinition property), 572\nProblem Details dialog\n (Accessibility task pane), 349\nProdSubmenu layer, 444, 448-451\nProject Explorer, 454-456, 464\nProject Properties dialog, 478-479\nPrompt for Accessibility Properties when Inserting Images option (General tab, Page Editor Options dialog), 263\nProp Control control, 623\nProperties window, 454\nProperties, classes, 456\nPropertyGridEditorPart control, 625\nproportions (images),\n Maintain Proportions check box (Button dialog, Image tab), 388\npseudo-classes (CSS), 311-313\npseudo-elements (CSS), 312\nPublish log, 51\nPublish Status reports, 74\npublishing, 50, 63\n HTTP, 55-59, 62-64\n server options for, 44\nto storage devices, 44\nWeb sites, 13, 86\nqueries\n Find and Replace tool queries, saving, 287\n strings, hyperlinks in Web pages, 110\nQuick Tag tools, 16, 139\n Quick Tag Editor, 225, 235\n displaying errors, 230\n Edit Tag option, 228\n HTML checks, 229\n Insert HTML option, 228, 231-232\n Positioning option, 228, 234\n Remove Tag option, 228, 231, 234\n Tag Properties option, 228, 234\n Wrap Tag option, 233\nQuick Tag Selector, 225-226, 305\ntroubleshooting, 142, 234\nquirks rendering mode\n (browsers), 357\nRangeValidator control, 598\nReally Simple Syndication.\n See RSS (Really Simple Syndication)\nRecent Sites option (File menu), 34\nRecently Added Files report, 73\nRecently Changed Files reports, 73\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\nRegistry, recent searches \nediting, 288-289 \nremoving, 290\n\nRegular Expression check box (Find and Replace tool), 279\n\nRegular Expression Editor, 605\n\nregular expressions, 276 \n complex expressions, 279 \ncurly braces ({ }) in, 281 \ndash (-) characters, 277 \n escape (\\) characters, 277 \n finding/replacing text, 276, 279\n\ntagged expressions, 281-282\n\nRegularExpressionValidator control, 598, 606\n\nRehabilitation Act of 1973, Section 508, 344\n\nremapping editable regions (Dynamic Web Templates), 379\n\nRemember Me check box, Login control, 565\n\nRemember My Password check box, FTP Web sites, 36\n\nRememberMeSet property (Login control), 568\n\nRememberMeText property (Login control), 568\n\nRemote Web site, 54 \n Properties dialog, 46, 52, 476 \n publishing Web sites, 13\n\nRemove Class option (Apply Styles task pane), 329\n\nRemove Inline Style option (Apply Styles task pane), 329\n\nRemove Link option (Apply Styles task pane), 328\n\nRemove Tag option (Quick Tag Editor), 228, 231, 234\n\ntagging\n child layers, 443 \neditable regions (Dynamic Web Templates), 378-380\n\nReplace tab (Find and Replace tool), 277\n\nreports\n Accessibility Reports, 18-19, 359 \n Compatibility Reports, 19, 359 \n CSS Reports, 20, 359 \n Custom AutoFilter dialog, 337 \n Errors tab, 336 \n Usage tab, 338 \n troubleshooting via, 359 \n Web sites, 12, 71 \n All Files reports, 72 \n Assigned To reports, 74 \n Categories reports, 74 \n Checkout Status reports, 73 \n configuring, 74 \n Dynamic Web Template reports, 73 \n Hyperlinks reports, 74 \n Master Pages reports, 73 \n Older Files reports, 73 \n Publish Status reports, 74 \n Recently Changed Files reports, 73 \n Review Status reports, 74\n\nsaving, 76 \n Site Summary view, 72 \n Slow Pages reports, 74 \n Style Sheet Links reports, 73 \n Unlinked Files reports, 73\n\nrequire statements (PHP), 663\n\nrequire_once statements (PHP), 663\n\nRequiredFieldValidator control, 599\n\nResetForm procedure, 467\n\nResetForm subprocedure, 466\n\nResizable in Browser property (Frame Properties dialog), 180\n\nresizing layers, 441\n\nresolution (monitors), HTML table design, 172-173\n\nReview Status reports, 74\n\nRoleGroup Collection Editor, 577\n\nRoleGroups, editing, 577-578\n\nroot nodes, TreeView control (ASP.NET navigation controls), 536\n\nrow (<tr>) tags (HTML tables), 152-153\n\nrows (HTML tables) \n adding/deleting, 164 \n configuring, 166-169\n\nrowspan attribute (HTML tables), 152-153\n\nRSS (Really Simple Syndication), 710-712\nRuby on Rails, 709-710\n\nRuler and Grid feature\n(Design View)\n- enabling grids, 131\n- moving layers, 130\n- origins, 129-130\n- Snap to Grid feature, 131\n\nRuler and Grid tab (Page Editor Options dialog), 270-271\n\nRun Check Based on Doctype Declaration in Page if Available check box (Compatibility Checker dialog), 360\n\nSaved Fields tab (Form Properties dialog), 203\n\nsaving\n- Find and Replace tool queries, 287\n- HTML form results, 197-202\n- Interactive Buttons, 390\n- Personal Web Packages, 91\n- sitemap files, ASP.NET navigation controls, 526\n- Web site reports, 76\n\nSaving Results dialog (Form Properties dialog), 198\n\nschemas (Web browsers), 357-358\n\nScreenTips\n- accessibility, 345\n- hyperlinks, 112, 218, 345\n- Insert Hyperlink dialog, 112\n- Quick Tag Tools, 225\n\n<script> tags, PHP, 644\n\nscripting\n- disabling, Interactive Buttons, 384\n- history of, 418\n- JavaScript\n - accessing HTML tag attributes, 429\n - adding images to HTML tags, 431\n - adding to Web pages, 419-420\n - alert method, 436\n - changing HTML tag attributes, 429-431\n - debugging, 436\n - DOM (Document Object Model), 423-424\n - form field validation, 432-435\n - functions, 420\n - hiding/showing elements in Web pages, 425-429\n - inline JavaScript, 421\n - linking to external script files, 421\n - logic errors, 436\n - preloading images, 430\n - syntax errors, 436\n - troubleshooting, 435-436\n\nScriptManager control, 631, 635-637, 640-641\n\nScriptManagerProxy control, 631\n\nscripts\n- comments, 52\n- default validation language, setting, 69\n\nsearch engines, frames, 177\n\nsearches (Registry)\n- editing, 288-289\n- removing, 290\n\nSection 508 (Rehabilitation Act of 1973), 344\n\nSection 508 Web site guidelines. See Accessibility Reports feature\n\nSecure HTTP (HTTPS) protocol, 46\n\nsecurity\n- e-commerce, 702\n- FTP, 48\n- Interactive Buttons, 384\n- login systems, 564\n- scripting, disabling, 384\n\nSelect All x Instances option (Apply Styles task pane), 328\n\nSelect Place in Document dialog (Insert Hyperlink dialog), 111\n\nSelect Style Sheet dialog (Apply Styles task pane), 302\n\nSelect Tag Contents, 226\n\nSelected Page(s) option (Find and Replace tool), 278\n\nSelectedDate property, Calendar control (ASP.NET), 510\n\nSelectionMode property, Calendar control (ASP.NET), 510\n\nSelectMonthText property, Calendar control (ASP.NET), 510\n\nSelector drop-down (Style Builder), 333\n\n---\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\nSelectQuery property\n(AccessDataSource control), 679\n\nSelectWeekText property,\nCalendar control\n(ASP.NET), 510\n\nSend To Database option\n(Form Properties dialog), 198-200, 204-206\n\nSend To option (Form\nProperties dialog), 198-199\n\nSend To Other option\n(Form Properties dialog), 198\n\nSeparate Grouped\nSelectors option (Manage\nStyles task pane), 326\n\nServer Message Language\ndrop-down (Language\ntab), 71\n\nsession variables (PHP), 661\n\nSet As Default For New\nTables check box (Insert\nTable dialog), 149\n\nSet section (Insert Table\ndialog), 155\n\nSet Text behaviors,\n408-411\n\nSet Text of Frame behav-\niors, 408\n\nSet Text of Layer behav-\niors, 410\n\nSet Text of Status Bar\nbehaviors, 410\n\nSet Text of Text Field\nbehaviors, 411\n\nSetFocusOnError property,\nvalidation controls, 601\n\nShort property value\n(DayNameFormat property), 509\n\nshort tags (PHP), 645\n\nShortest property value\n(DayNameFormat property), 509\n\nShow All Styles option\n(Manage Styles task\npane), 324\n\nShow Alphabetized List\noption\nCSS Properties task pane, 331\nTag Properties task pane, 214\n\nShow Borders check box\n(Frames Page dialog), 180\n\nShow Categorized List\noption\nCSS Properties task pane, 331\nTag Properties task pane, 214\n\nShow Dependencies button\n(Export Web Package\ndialog), 90\n\nShow Hidden Files and\nFolders check box\n(Advanced tab), 70\n\nShow Paste Options\nButtons check box\n(General tab, Page Editor\nOptions dialog), 263\n\nShow Scrollbars property\n(Frame Properties dialog), 180\n\nShow section (Accessibility\nChecker feature), 348\n\nShow Set Properties On\nTop option\nCSS Properties task pane, 331\nTag Properties task pane, 214\n\nShow Styles Used in\nCurrent Page option\n(Manage Styles task\npane), 324\n\nShow Styles Used on\nSelection option (Manage\nStyles task pane), 324-325\n\nShow Tag Properties but-\nton (Tag Properties task\npane), 214-216\n\nShowCheck boxes property\n(TreeView control), 538\n\nShowDayHeader property,\nCalendar control\n(ASP.NET), 510\n\nShowExpandCollapse\nproperty (TreeView con-\ntrol), 538\n\nShowGridLines property,\nCalendar control\n(ASP.NET), 510\n\nShowLines property\n(TreeView control), 538\n\nShowNextPrevMonth\nproperty, Calendar con-\ntrol (ASP.NET), 510\n\nShowTitle property,\nCalendar control\n(ASP.NET), 511\n\nSideBarButtonStyle prop-\nerty, Calendar control\n(ASP.NET), 521\n\nSideBarStyle property,\nCalendar control\n(ASP.NET), 521\nSilverlight applications, inserting into Web sites, 250-252\n\nsite development, offline, 44\n\nSite Settings dialog\nAdvanced tab\nDelete Files button, 70\nsetting default validation script language, 69\nShow Hidden Files and Folders check box, 70\nGeneral tab, 68\nLanguage tab, 71\nManage The Web Site\nUsing Hidden Metadata Files check box, 33\nPreview tab, 68-69\n\nSite Summary view, Web Site reports, 72\n\nsitemap files\nASP.NET navigation controls\ncreating for, 526\nroot nodes, 530\nsaving, 526\n\nsiteMapNode root, 526\n\nSiteMapPath control (ASP.NET navigation controls), 540-541\n\nSize section (Insert Table dialog), 155\n\nsizing\nframes, 188\nHTML tables, 161-163\nimages, troubleshooting, 258\nlayers, 441\ntask panes, 9\ntext, frames, 177\ntext fonts, 107-108\nWeb pages, 134-135\nslicing (images), 132\nSlow Pages reports, 74\nSnap to Grid feature (Ruler and Grid feature, Design View), 131\nSoftware Passport, 700\nsound, inserting Windows Media audio into Web sites, 252-253\nspell-checking, 113, 122\nSpelling Options dialog (General tab, Page Editor Options dialog), 263\n\nSplit View, 124, 141\nSQL Server, 624\nSQL Server 2005 Express Edition, 64, 592\nSqlDataSource control, 678\nSQLExpress database file auto-creation error, 615\n\nSSL (Secure Sockets Layer), User Encrypted Connection (SSL) check box, 39-40\n\nStandard ASP.NET controls, 495\nAdRotator control, 501\ncreating advertisement files, 503-506\ncreating Web pages, 502\nImpression element, 502\nKeyword element, 502\nXML elements list, 501\nCalendar control\nCaptionAlign property, 508\nDayNameFormat property, 508\n\nFirstDayOfWeek property, 509\nformatting, 507\nNextMonthText property, 509\nNextPrevFormat property, 509\nPrevMonthText property, 509\nproperties of, 508-511\nSelectedDate property, 510\nSelectionMode property, 510\nSelectMonthText property, 510\nSelectWeekText property, 510\nShowDayHeader property, 510\nShowGridLines property, 510\nShowNextPrevMonth property, 510\nShowTitle property, 511\nSideBarButtonStyle property, 521\nSideBarStyle property, 521\nStepStyle property, 521\nTitleFormat property, 511\nUseAccessibleHeader property, 511\nVisibleDate property, 511\n\nHTML controls versus, 496\nlist of, 500-501\nWizard control, 512-521\n\nStart step type (Wizard control), 513\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\nStartHTMLOptimizer macro, 475\nStatus Bar, 11\ncode problems, identifying, 355-357\nsizing Web pages, 134-135\nStyle Application setting\nformatting Web page\ntext, 105\nTarget Rule drop-down, 106-107\nVisual Aids (Design View), 125\nStep step type (Wizard control), 513\nStepStyle property,\nCalendar control\n(ASP.NET), 521\nStyle Application setting\n(Status Bar)\nformatting Web page text, 105\nTarget Rule drop-down, 106-107\nStyle Application toolbar, 267\nStyle Builder (CSS), 10, 320, 332\nApply New Style to\nDocument Selection\ncheck box, 334\nCategory list, 334\nSelector drop-down, 333\nstyles, creating, 333-334\nStyle Sheet Links reports, 73\nstyle sheets. See CSS\n(Cascading Style Sheets)\nstyless (CSS)\narranging, 339\ncreating, 333-334\nstyles.css, 298, 303\nSubject field\n(MailDefinition property), 572\nsubsites, 29, 38-39, 51\nSuccessPageUrl property\n(ChangePassword control), 573\nSummary option (CSS Properties task pane), 331\nSupportedDisplayModes\nmethod of the\nWebPartDisplayMode, 619\nSupportSubmenu layer, 451-452\nSwap Image behavior, 396, 411, 430\nSwap Image Restore\nbehavior, 396, 412, 430\nswapImage function\n(JavaScript), 430-431\nSynchronize setting (Copy\nWeb Site View), 53\nsyntax\nerrors, JavaScript, 436\nhighlighting (PHP), 656, 665\n\n<table>\n<thead>\n<tr>\n<th>T</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Table AutoFormat dialog, 156</td>\n</tr>\n<tr>\n<td>Table context menu, 156-157</td>\n</tr>\n<tr>\n<td>Table menu, 156-157</td>\n</tr>\n<tr>\n<td><table> tags (HTML tables), 146</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>T</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>align attribute, 147-148</td>\n</tr>\n<tr>\n<td>border attribute, 149</td>\n</tr>\n<tr>\n<td>cellspacing attribute, 149-150</td>\n</tr>\n<tr>\n<td>frame attribute, 151-152</td>\n</tr>\n</tbody>\n</table>\n\ntables\naccessibility, designing for, 345\nLayout Tables task pane, 13, 170\ncells\nalign attribute, 153\naligning content in, 160\nmerging, 158-159\nselecting, 158\nvalign attribute, 153-155\ncustomizing, 156\ndeprecated attributes, 147\ndevelopment of, 146\ndrawing, 165\nformatting, 156, 163-164\ninserting, 155\nLayout Tables task pane, 169-171\nmonitor resolution design, 172-173\nrows\nadding, 164\nconfiguring, 166-169\ndeleting, 164\nsizing, 161-163\n<table> tags, 146\nalign attribute, 147-148\nborder attribute, 149\ncellpadding attribute, 149-150\ncellspacing attribute, 149-150\nframe attribute, 151-152\n<td> (column) tags, 152-153\n<tr> (row) tags, 152-153\ntroubleshooting, 172\nTables Toolbar, Draw Table feature, 165\ntabs, adding as task panes, 8-10\nTag Names Are Lowercase check box (Code Formatting tab, Code View), 137\ntag properties (HTML)\nattributes, 214\nadding ScreenTips to Hyperlinks, 218\nopening hyperlinks in other windows, 219\nsetting in Tag Properties task pane, 216-219\nevents\nclick events, 220\nhooking, 214\nhyperlinks, 214\nTag Properties task pane, viewing in, 215-216\ntroubleshooting, 221\nWeb standards, 221-222\nTag Properties option (Quick Tag Editor), 228, 234\nTag Properties task pane, 212, 497, 534, 537-539\nASP.NET control properties, accessing, 499\nCell Properties dialog, 216\nCode View, 215, 221-222\ncollapsing categories in, 213\ncontext-sensitivity in, 213\ncustomizing, 214\nediting tags, 15\nevents, 220\nsetting attributes in, 216-219\nShow Alphabetized List button, 214\nShow Categorized List button, 214\nShow Set Properties on Top button, 214\nShow Tag Properties button, 214-216\ntroubleshooting, 221\nviewing tag properties in, 215-216\ntagged expressions, 281-282\ntags (HTML)\nediting, Tag Properties task pane, 15\nJavaScript, changing via, 429-431\nQuick Tag tools, 16\nTags section (Code Formatting tab, Code View), 138\nTarget Frame dialog (Insert Hyperlink dialog), 109, 183\nTarget Rule drop-down (Style Application setting, Status Bar), 106-107\ntargeting\nframes, 183\nhyperlinks in Web pages, 109\ntask panes\nactivating, 8\ndocking, 8\ndragging/dropping, 8\nmaximizing, 9\ntabs, adding as, 8-10\n<tt> (column) tags (HTML tables), 152-153\ntemplates\nDynamic Web Templates, 14, 30\nAttach Dynamic Web Template dialog, 374\nattaching to Web pages, 372-373\ncode examples, 381-382\ncreating, 368-370\ncreating page layouts, 369-370\ndetaching to Web pages, 376, 380\ndoctitle region, 368\ndoctype editable regions, 370-373, 377-380\nfunctions of, 368\nMaster Pages (ASP.NET) versus, 546, 551-552\nmaster.dwt files, 321\nmetadata storage, 33\nreports, 73\ntroubleshooting, 380\nupdating Web sites, 374-375\nWeb page property configuration, 114\nWeb site templates, 29-30\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\ntemporary files, corrupted files, 70\n\ntest Web sites, creating via ASP.NET navigation controls, 528\n\ntesting\ndisk-based Web sites, 35, 42\nvalidation forms, 607\ntext\naligning, Interactive Buttons, 387\nfinding/replacing, 276-282\nFont tab (Button dialog), 386-387\nfonts\nDefault Fonts tab (Page Editor Options dialog), 265\nfamilies, 107\nFont Families tab (Page Editor Options dialog), 271\nsizes, 107-108\nframes, sizing in, 177\nWeb pages, formatting in, 105-108\n\nTextLayout property (Login control), 568\n\nthumbnail images, 245-246\n\ntime management, 699\n\ntimer control, 631\n\nTitle property (Frame Properties dialog), 179\n\nTitleFormat property, Calendar control (ASP.NET), 511\n\nTitleText property (Login control), 568\n\ntop value (valign attribute, HTML tables), 154-155\n\n<tr> (row) tags (HTML tables), 152-153\n\nTracing Image feature (Design View)\nSnap to Grid feature, 132-133\ntroubleshooting, 142\ntree view navigation systems\n\nTreeView control (ASP.NET navigation controls), 534-535\nCSS styles, 539\nformatting, 536\nWeb site navigation via, 524\n\nTreeView control (ASP.NET navigation controls), 534-535\nCSS styles, 539\nExpandDepth property, 537\nformatting, 536\nImageSet property, 537\nleaf nodes, 536\nNodeIndent property, 538\nparent nodes, 536\nroot nodes, 536\nShowCheck boxes property, 538\nShowExpandCollapse property, 538\nShowLines property, 538\ntroubleshooting, 542\n\nTreeView Tasks dialog, 542\ntroubleshooting\nAjax, 638\nASP.NET, 520-521, 542, 689-690\nbehaviors, 412, 452\ncode snippets, 122\nCode View, Compatibility Checker errors, 362\ncompatibility, 362\nCompatibility Checker dialog, 362\nContent Pages (ASP.NET), 561\nCSS, 313, 338-339\ndoctype declarations (XHTML), 358, 362\nDynamic Web Templates, 380\nExpression Development Server, 490\nFind and Replace tool, 287-288\nframes, 187\nFTP Web site passwords, 41\nHTML form controls, 208\ntables, 172\nimages, sizing, 258\nimporting Web sites, 85\nInteractive Buttons, 392\nJavaScript, 435-436\nlayers, 452\nlogin systems, 592-593\nMaster Pages (ASP.NET), 561\nmetadata, 40-41\nMicrosoft Expression Development Server, 490\npage encoding, 76\npage transitions, 259\npasswords, FTP Web sites, 41\nPersonal Web Packages, 93\nPHP, 664-665\npublishing, 55-59, 62-64\nQuick Tag tools, 142, 234\nspell-checking, 122\nstyle sheets, 313\ntag properties (HTML), 221\nTracing Image feature (Design View), 142\nuser controls, 625\nvalidation forms, 607\nWeb Parts, 624\nWeb sites, 40-41\nFTP Web site passwords, 41\nimporting, 85\n_vti folders, 40-41\n\nvalidation controls, 495\nadding to validation forms, 604-606\ncommon properties, 599\nCompareValidator control, 598\nControlToValidate property, 600\nCustomValidator control, 599\nDisplay property, 600\nEnableClientScript property, 600\nErrorMessage property, 599\nRangeValidator control, 598\nRegularExpressionValidator control, 598\nRequiredFieldValidator control, 599\nSetFocusOnError property, 601\nValidationGroup property, 601\nValidationSummary control, 599\nform creation, 601-603\nchanging form field ID, 604\ntesting forms, 607\ntroubleshooting, 607\nvalidation groups, 608\nvalidating forms\nASP.NET validation controls\nadding to forms, 604-606\nCompareValidator control, 598\nControlToValidate property, 600\n\nvalidateForm function (JavaScript), 434-435\n\nWeb sites, 40-41\nFTP Web site passwords, 41\nimporting, 85\n_vti folders, 40-41\n\nUNC (Universal Naming Convention)\npaths, 49\nshares, creating on disk-based Web sites, 32\n\nUndefined Classes option (CSS Reports dialog, Errors tab), 336\nUnlinked Files reports, 73\nUnused Styles option (CSS Reports dialog, Errors tab), 336\nUpdatePanel control, 631, 635-637\nUpdateProgress control, 631\nUpdateQuery property (AccessDataSource control), 680\nupdates\ndatabases, HTML form fields, 207\nWeb sites via Dynamic Web Templates, 374-375\n\nURL (Uniform Resource Locators), adding to Frames pages, 179\nURL variable (PHP), 661\nUsage tab (CSS Reports dialog), 338\nUse <strong> and <em> when Using Bold and Italic Toolbar Buttons option (General tab, Page Editor Options dialog), 263\nUseAccessibleHeader property, Calendar control (ASP.NET), 511\nuser controls, 610\ncreating, 611-612, 617-620\ndisplay mode, setting, 617\ntroubleshooting, 625\nUser Encrypted Connection (SSL) check box, HTTP Web site creation, 39-40\nUserForm, 456\nadding controls to, 460\ncontrols, types of, 461-463\ncreating, 459\ninserting into project, 460\ntroubleshooting, 478\nUserName property (Login control), 568\nUserNameLabelText property (Login control), 568\nUserNameRequiredError property (Login control), 568\n\nvalidateForm function (JavaScript), 434-435\nvalidating forms\nASP.NET validation controls\nadding to forms, 604-606\nCompareValidator control, 598\nControlToValidate property, 600\n\nU\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\nRequiredFieldValidator control, 599\nSetFocusOnError property, 601\ntroubleshooting, 607\nValidationGroup property, 601\nValidationSummary control, 599\nvalidation groups, 608\nvalign attribute (HTML tables), 153-155\nvariables (PHP), 645\nVB (programming language), 493\nVBA (Visual Basic for Applications)\naccessing Web sites with, 456\nApplication object model, 457\nlimitation of, 454\nmacros, creating, 453\nPage object model, 458\nprogramming with, 454\nWeb object model, 457\nvideo\nFlash movies, inserting into Web sites, 248-249\nweb hosting fees, 259\nviews\nCode View, 124, 136, 143\nBookmarks, 141\nCode Error icon, 356\nCode Formatting tab, 137-139\ncode snippets, 117\nContext menu, 140\nidentifying code problems, 355-357\nIntelliSense, 139-140\nmodifying Dynamic Web Templates, 375-376\nPage Editor Options dialog options, 264-265\nQuick Tag tools, 139, 142\ntroubleshooting\nCompatibility\nChecker errors, 362\nCopy Web Site view\n(Import Web Site Wizard), 84\nDesign View, 124, 143\nformatting marks, 128\nPage Size menu, 135\nRuler and Grid feature, 129-131\nselecting multiple layers in, 446\nsizing Web pages, 134-135\nTracing Image feature, 132-133, 142\nVisual Aids, 125-127\nNo Frames view, 182-183\nRemote Web Site view, publishing Web sites, 13\nSplit View, 124, 141\nVischeck software, 352\nvisibility, setting in layers, 447\nVisible Borders Visual Aid (Design View), 126\nVisibleDate property, Calendar control (ASP.NET), 511\nVisibleWhenLoggedIn property (Login control), 568\nVista (Windows), installing FastCGI and IIS 7, 648\nVisual Aids (Design View)\nASP.NET\nControl Errors, 127\nNon-visual Controls, 127\nBlock Selection, 125\nCSS Display:none, 126\nEmpty Containers, 126\nMargins and Padding, 126\nTemplate Region Labels, 127\nVisible Borders, 126\nVisual Basic Editor, 454, 458-459, 477-478\nVTI (Vermeer Technologies Incorporated), 46\n_vti folders\ndeleting, 34\nmetadata, 28-29\ntroubleshooting, 40-41\nW\nW3C (World Wide Web Consortium) Web site, 717\nWarnings option\n(Accessibility Checker feature, Check Where section), 348\nWaSP (Web Standards Project), 706\nWatch Window, 477\nWCAG (Web Content Accessibility Guidelines).\nSee Accessibility Reports feature\nWeb banners, 702-703\nWeb browsers\nCheck Browser behaviors, 402-403, 413\ncompatibility, 354-355\ndevelopment of, 354\npage transitions, troubleshooting, 259\nquirks rendering mode, 357\nschemas, 357\nscripting, history of, 418\nWeb design resources, 716-717\nWeb Designer Tracing\nImage and Interactive Button attributes, 53\nWeb development\nchanging standards of, 706\nemerging technologies, 707-710\nRSS, 710-712\nXHTML, 707\nWeb forms (ASP.NET)\ncreating, 493-494\nMaster Pages, attaching to, 548\nWeb site creation, 590-592\nweb hosting fees for video, 259\nWeb object model, 457\nWeb pages\nAdRotator control (ASP.NET), creating sites from, 502\nAjax functionality, adding to, 632\nScriptManager control, 635-636\nserver-side code, 634-635\nUpdatePanel control, 637\nASP.NET controls, adding to, 496-497\nbase hrefs, 114\ncode snippets, 117\nCode View, 124, 136, 143\nBookmarks, 141\nCode Formatting tab, 137-139\nContext menu, 140\nIntelliSense, 139-140\nQuick Tag tools, 139, 142\ncreating\nASP.NET page formats, 100\nCSS layouts, 100\nframe pages, 101\ngeneral page formats, 98\nstyle sheets, 101\nDesign View, 124, 143\nformatting marks, 128\nPage Size menu, 135\nRuler and Grid feature, 129-131\nsizing in, 134-135\nTracing Image feature, 132-133, 142\nVisual Aids, 125-127\nDynamic Web Templates\nattaching to, 372-373\ndetaching to, 376, 380\nformatting\nCSS (Cascading Style Sheets), 296-297\ntext, 105-108\nhiding/showing elements, 425-429\nHTML bookmarks, 111\nhyperlinks\ncreating, 108-109\nHTML bookmarks, 111-112\nquerystrings, 110\nScreenTips, 112\ntargeting, 109\nimporting files, 101-102\nJavaScript, adding, 419-420\nlayers\nadding content to, 440\nadding interactivity to, 448-452\nchild layers, 442-445\nchoosing ID, 440\ncreating interactive menus, 442-445\nmainMenu layer, 442-443\npositioning, 442-446\nProdSubmenu, 444, 448-451\nresizing, 441\nselecting multiple layers in Design View, 446\nSupportSubmenu, 451-452\ntroubleshooting, 452\nuses of, 438\nvisibility, 447\nz-order, 452\nproperties, configuring, 113\nadvanced properties, 115\nASP.NET Master Pages, 114\ncustom properties, 115-116\nDefault Target Frame property, 114\nDynamic Web Templates, 114\nformatting properties, 115\ngeneral properties, 114-115\n\nHow can we make this index more useful? Email us at indexes@quepublishing.com\nlanguage properties, 116\nMETA tags, 116\npage margins, 116\nsizing, 134-135\nspell-checking, 113\nSplit View, 124, 141\n\nWeb Part controls\nAppearanceEditorPart control, 625\nBehaviorEditorPart control, 625\nLayoutEditorPart control, 625\nPropertyGridEditorPart control, 625\n\nWeb Parts\nAppearanceEditorPart control, 613\nCatalogZone control, 613\ncomponents of, 610\ncontrols, 610\nadding to Web Part pages, 621-623\nAppearanceEditorPart control, 625\nBehaviorEditorPart control, 625\nCatalogZone control, 613\nediting, 625-626\nEditorZone control, 613\nLayoutEditorPart control, 625\nPropertyGridEditorPart control, 625\n\nWeb Parts Catalog, 621-623\n\nWeb Parts zone, 610\n\nWeb sites\nAjax functionality, adding to, 632\nScriptManager control, 635-636\nserver-side code, 634-635\nUpdatePanel control, 637\ncomponents of, 28\ncreating, 12, 41\ndeleting, 34\ndisk-based sites, 31, 41\ncreating, 32\nmapped drives, 32-33\ntesting, 35, 42\nUNC shares, 32\ndynamic content behaviors, 21\nInteractive Buttons, 20\nlayers, 22\nfinding, Recent Sites option (File menu), 34\nformatting, CSS, 299-304\nFTP sites, 35-36, 41\nhosting, 64-65\nHTTP sites, 41\ncreating, 38\nFrontPage Server Extensions, 39\nopening live, 37\nsubsite creation, 38-39\nUser Encrypted Connection (SSL) check box, 39-40\nimporting, 78\nFrontPage Server Extensions method, 79-80\nHTTP method, 82-83\nmoving by, 78-84\npublishing versus, 86\nspecifying destination locations, 84\n\npages\nadding Web Part controls to, 621-623\nBrowseDisplayMode view, 616\nCatalogDisplayMode view, 616\nConnectDisplayMode view, 616\ncreating, 613-614, 616\ncreating user controls that set display mode, 617-620\nDesignDisplayMode view, 617\ndisplay modes, 616\nEditorDisplayMode view, 617\nnull value messages, 624\nSQLServer connections, 624\ntroubleshooting, 624\nuser controls\ncreating, 611-612, 617-620\ndocumentation, 611\ntroubleshooting, 625\nWebPartManager control, 613, 624\nWebPartZone control, 613\n\nWeb resources\nASP.NET, 717-718\nExpression Web 2, 716\nPHP, 717-718\nWeb design, 716-717\ntroubleshooting, 85\nWebDAV method, 80-82\nmetadata, 28-29\nmoving by importing, 78-84\nnaming, 68\nnavigating\n bread crumb systems, 525\n DHTML menu systems, 524, 527\n Master Pages (ASP.NET), 542\n tree view systems, 524, 534-536, 539\noptimization\n Accessibility Reports feature, 18-19\n Compatibility Reports feature, 19\n CSS Reports feature, 20\npreviewing, 68-69\npublishing, 13, 86\nreports, 12, 71\n All Files reports, 72\n Assigned To reports, 74\n Categories reports, 74\n Checkout Status reports, 73\n configuring, 74\n Dynamic Web Template reports, 73\n Hyperlinks reports, 74\n Master Pages reports, 73\n Older Files reports, 73\n Publish Status reports, 74\n Recently Changed Files reports, 73\n Review Status reports, 74\nsaving, 76\nSite Summary view, 72\nSlow Pages reports, 74\nStyle Sheet Links reports, 73\nUnlinked Files reports, 73\nsubsites, 29\ntemplates, 29\n CSS, 30\n Dynamic Web Templates, 30, 33\nEmpty Web site option, 30\nOne Page Web site option (New dialog), 30\ntest Web sites, creating via ASP.NET navigation controls, 528\ntroubleshooting, 40-41\nupdating via Dynamic Web Templates, 374-375\nWeb standards\n compatibility, 363\n HTML tag properties, 221-222\nweb.sitemap file (ASP.NET navigation controls), 528\nWebDAV, 44\n FrontPage Server Extensions used instead of, 63\nWeb sites\n importing, 80-82\n publishing Expression Web Designer Web sites, 48\nWebmonkey Web site, 716\nWebPartManager control, 613, 619, 624\nWebParts controls (ASP.NET), 496\nWebPartZone control, 613-614\nWelcome step (Wizard control), 516\nwidths, adjusting in HTML tables, 161-163\nwindow object (DOM), 423\nWindows Integrated Authentication, 57\nWindows Media audio, inserting into Web sites, 252-253\nWindows Media Player Properties dialog\n Advanced tab, 254-255\n General tab, 253-254\n Object Tag tab, 255-256\n Parameters tab, 256\nWindows Server 2008, installing\n FastCGI, 649\n IIS 7, 649\nWindows Vista, installing\n FastCGI, 648\n IIS 7, 648\nWizard control (ASP.NET)\n NavigationButtonStyle property, 521\n steps of, 512\n wizards, creating, 513-515\n Address step, 517-518\n Finish step, 519\n Lists step, 518\n Name/E-mail step, 517\n Welcome step, 516\n wizard.aspx, 513\n wizards\n creating, 513-515\n Address step, 517-518\n Finish step, 519\nLists step, 518\nName/E-mail step, 517\nWelcome step, 516\nData Source\nConfiguration Wizard, 530\nImport Web Site wizard, 78\nCopy Web Site view, 84\nFrontPage Server\nExtensions method, 79-80\nHTTP method, 82-83\nspecifying destination\nlocations, 84\ntroubleshooting, 85\nWebDAV method, 80-82\nWizardSteps, 514\nWorkforce Investment Act, 344\nworkgroups, Assigned To\nreports, 74\nWrap Tag option (Quick\nTag Editor), 233\nwriteDateTime function\n(JavaScript), 420-422\n\nX - Y - Z\n\nXHTML (Extensible Hypertext Markup Language)\ndoctype declarations\nconfiguring, 358\nidentifying code problems, 356\nquirks of missing decla-\nations, 357\nRun Check Based on\nDoctype Declaration\nin Page if Available\ncheck box\n(Compatibility\nChecker dialog), 360\ntroubleshooting, 358,\n362\nrequirements for, 707\nXML (Extensible Markup\nLanguage)\nelements, AdRotator con-\ntrol (ASP.NET), 501-502\nfiles, saving HTML form\nresults, 199\nz-order (layers), 452\nz-position, 307"}}},{"rowIdx":259,"cells":{"id":{"kind":"string","value":"221d2d1fd106cc7ef63ab83096a4ecd15c9c2e36"},"text":{"kind":"string","value":"### GETTING STARTED\n\n1 **Installation** \n1.1 System Requirements \n1.2 Binary Packages \n1.3 Updating \n1.4 Installing Specific Versions \n\n2 **Building From Source** \n2.1 Dependencies \n2.2 Building and Updating \n2.3 Statically Linked Routinator \n2.4 Platform Specific Instructions \n\n3 **Configuration** \n3.1 Setup When Installed From a Package \n3.2 Setup When Built with Cargo \n3.3 Trust Anchor Locators \n3.4 Using Tmpfs for the RPKI Cache \n3.5 Verifying Configuration \n\n4 **Data Processing** \n4.1 Fetching \n4.2 Validating \n4.3 Storing \n\n5 **VRP Output Formats** \n\n6 **Local Exceptions** \n6.1 Limiting Prefix Length \n\n7 **Logging** \n7.1 Interactive Mode \n7.2 Detached Server Mode \n\n8 **Running as a Daemon** \n\n9 **RTR Service** \n9.1 Secure Transports \n9.2 Configuring Routers \n\n10 **HTTP Service** \n10.1 Query Parameters \n\n---\n\n### Table of Contents\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1 Installation</td>\n<td>3</td>\n</tr>\n<tr>\n<td>1.1 System Requirements</td>\n<td>3</td>\n</tr>\n<tr>\n<td>1.2 Binary Packages</td>\n<td>3</td>\n</tr>\n<tr>\n<td>1.3 Updating</td>\n<td>7</td>\n</tr>\n<tr>\n<td>1.4 Installing Specific Versions</td>\n<td>8</td>\n</tr>\n<tr>\n<td>2 Building From Source</td>\n<td>11</td>\n</tr>\n<tr>\n<td>2.1 Dependencies</td>\n<td>11</td>\n</tr>\n<tr>\n<td>2.2 Building and Updating</td>\n<td>12</td>\n</tr>\n<tr>\n<td>2.3 Statically Linked Routinator</td>\n<td>13</td>\n</tr>\n<tr>\n<td>2.4 Platform Specific Instructions</td>\n<td>13</td>\n</tr>\n<tr>\n<td>3 Configuration</td>\n<td>17</td>\n</tr>\n<tr>\n<td>3.1 Setup When Installed From a Package</td>\n<td>17</td>\n</tr>\n<tr>\n<td>3.2 Setup When Built with Cargo</td>\n<td>18</td>\n</tr>\n<tr>\n<td>3.3 Trust Anchor Locators</td>\n<td>19</td>\n</tr>\n<tr>\n<td>3.4 Using Tmpfs for the RPKI Cache</td>\n<td>20</td>\n</tr>\n<tr>\n<td>3.5 Verifying Configuration</td>\n<td>20</td>\n</tr>\n<tr>\n<td>4 Data Processing</td>\n<td>23</td>\n</tr>\n<tr>\n<td>4.1 Fetching</td>\n<td>23</td>\n</tr>\n<tr>\n<td>4.2 Validating</td>\n<td>24</td>\n</tr>\n<tr>\n<td>4.3 Storing</td>\n<td>25</td>\n</tr>\n<tr>\n<td>5 VRP Output Formats</td>\n<td>27</td>\n</tr>\n<tr>\n<td>6 Local Exceptions</td>\n<td>33</td>\n</tr>\n<tr>\n<td>6.1 Limiting Prefix Length</td>\n<td>34</td>\n</tr>\n<tr>\n<td>7 Logging</td>\n<td>35</td>\n</tr>\n<tr>\n<td>7.1 Interactive Mode</td>\n<td>35</td>\n</tr>\n<tr>\n<td>7.2 Detached Server Mode</td>\n<td>35</td>\n</tr>\n<tr>\n<td>8 Running as a Daemon</td>\n<td>37</td>\n</tr>\n<tr>\n<td>9 RTR Service</td>\n<td>39</td>\n</tr>\n<tr>\n<td>9.1 Secure Transports</td>\n<td>39</td>\n</tr>\n<tr>\n<td>9.2 Configuring Routers</td>\n<td>41</td>\n</tr>\n<tr>\n<td>10 HTTP Service</td>\n<td>43</td>\n</tr>\n<tr>\n<td>10.1 Query Parameters</td>\n<td>43</td>\n</tr>\n</tbody>\n</table>\nRoutinator 3000 is free, open-source RPKI (Resource Public Key Infrastructure) Relying Party software made by NL.net Labs. The project is written in Rust, a programming language designed for performance and memory safety.\n\n**Lightweight and portable** Routinator has minimal system requirements and it can run on almost any hardware and platform, with packages available for most. You can also easily run with Docker or Cargo, the Rust package manager.\n\n**Full-featured and secure** Routinator runs as a service that periodically downloads and verifies RPKI data. The built-in HTTPS server offers a user interface, API endpoints for various file formats, as well as logging, status and Prometheus metrics.\n\n**Flexible RPKI-to-Router (RTR) support** Routinator has a built-in RTR server to let routers fetch verified RPKI data. You can also run RTR as a separate daemon using our RPKI data proxy RTRTR, letting you centralise validation and securely distribute processed data to various locations.\n\n**Open-source with professional support services** NL.net Labs offers professional support and consultancy services with a service-level agreement. Community support is available on Discord, Twitter and our mailing list. Routinator is liberally licensed under the BSD 3-Clause license.\nCHAPTER ONE\n\nINSTALLATION\n\n1.1 System Requirements\n\nRoutinator has minimal system requirements. When choosing a system, a powerful CPU is not required. Make sure you have 1GB of available memory and 4GB of disk space for the application.\n\nPlease keep in mind that the RPKI consists of a great number of small files. As a result, Routinator will use a large amount of inodes. You should accommodate for at least 500,000 inodes, but one million will provide more breathing room. This will give you ample margin for the RPKI repositories to grow over time, as adoption increases.\n\nTip: The `df -i` command shows the amount of inodes available, used, and free.\n\nAs new RPKI repositories can emerge in any IP address range and on any domain name, outbound traffic must not be blocked based on IP or DNS in any way. Routinator only needs to establish outbound connections via HTTPS and rsync, on ports 443 and 873, respectively.\n\n1.2 Binary Packages\n\nGetting started with Routinator is really easy by installing a binary package for either Debian and Ubuntu or for Red Hat Enterprise Linux (RHEL) and compatible systems such as Rocky Linux. Alternatively, you can run with Docker.\n\nYou can also build Routinator from the source code using Cargo, Rust’s build system and package manager. Cargo lets you to run Routinator on almost any operating system and CPU architecture. Refer to the Building From Source section to get started.\n\nDebian\nUbuntu\nRHEL/CentOS\nDocker\n\nTo install a Routinator package, you need the 64-bit version of one of these Debian versions:\n\n- Debian Bullseye 11\n- Debian Buster 10\n- Debian Stretch 9\n\nPackages for the `amd64/x86_64` architecture are available for all listed versions. In addition, we offer `armhf` architecture packages for Debian/Raspbian Bullseye, and `arm64` for Buster.\nFirst update the `apt` package index:\n\n```\nsudo apt update\n```\n\nThen install packages to allow `apt` to use a repository over HTTPS:\n\n```\nsudo apt install ca-certificates curl gnupg lsb-release\n```\n\nAdd the GPG key from NLnet Labs:\n\n```\ncurl -fsSL https://packages.nlnetlabs.nl/aptkey.asc | sudo gpg --dearmor -o /usr/share/keyrings/nlnetlabs-archive-keyring.gpg\n```\n\nNow, use the following command to set up the `main` repository:\n\n```\necho \"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/nlnetlabs-archive-keyring.gpg] https://packages.nlnetlabs.nl/linux/debian $(lsb_release -cs) main\" | sudo tee /etc/apt/sources.list.d/nlnetlabs.list > /dev/null\n```\n\nUpdate the `apt` package index once more:\n\n```\nsudo apt update\n```\n\nYou can now install Routinator with:\n\n```\nsudo apt install routinator\n```\n\nAfter installation Routinator will run immediately as the user `routinator` and be configured to start at boot. By default, it will run the RTR server on port 3323 and the HTTP server on port 8323. These, and other values can be changed in the `configuration file` located in `/etc/routinator/routinator.conf`.\n\nYou can check the status of Routinator with:\n\n```\nsudo systemctl status routinator\n```\n\nYou can view the logs with:\n\n```\nsudo journalctl --unit=routinator\n```\n\nTo install a Routinator package, you need the 64-bit version of one of these Ubuntu versions:\n\n- Ubuntu Jammy 22.04 (LTS)\n- Ubuntu Focal 20.04 (LTS)\n- Ubuntu Bionic 18.04 (LTS)\n- Ubuntu Xenial 16.04 (LTS)\n\nPackages are available for the `amd64/x86_64` architecture only.\n\nFirst update the `apt` package index:\nsudo apt update\n\nThen install packages to allow apt to use a repository over HTTPS:\n\n```bash\nsudo apt install ca-certificates curl gnupg lsb-release\n```\n\nAdd the GPG key from NLnet Labs:\n\n```bash\ncurl -fsSL https://packages.nlnetlabs.nl/aptkey.asc | sudo gpg --dearmor -o /usr/share/keyrings/nlnetlabs-archive-keyring.gpg\n```\n\nNow, use the following command to set up the main repository:\n\n```bash\necho \"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/nlnetlabs-archive-keyring.gpg] https://packages.nlnetlabs.nl/linux/ubuntu $(lsb_release -cs) main\" | sudo tee /etc/apt/sources.list.d/nlnetlabs.list > /dev/null\n```\n\nUpdate the apt package index once more:\n\n```bash\nsudo apt update\n```\n\nYou can now install Routinator with:\n\n```bash\nsudo apt install routinator\n```\n\nAfter installation Routinator will run immediately as the user routinator and be configured to start at boot. By default, it will run the RTR server on port 3323 and the HTTP server on port 8323. These, and other values can be changed in the configuration file located in `/etc/routinator/routinator.conf`.\n\nYou can check the status of Routinator with:\n\n```bash\nsudo systemctl status routinator\n```\n\nYou can view the logs with:\n\n```bash\nsudo journalctl --unit=routinator\n```\n\nTo install a Routinator package, you need Red Hat Enterprise Linux (RHEL) 7 or 8, or compatible operating system such as Rocky Linux. Packages are available for the `amd64`/`x86_64` architecture only.\n\nFirst create a file named `/etc/yum.repos.d/nlnetlabs.repo`, enter this configuration and save it:\n\n```{yaml}\n[nlnetlabs]\nname=NLnet Labs\nbaseurl=https://packages.nlnetlabs.nl/linux/centos/$releasever/main/$basearch\nenabled=1\n```\n\nAdd the GPG key from NLnet Labs:\n\n```bash\nsudo rpm --import https://packages.nlnetlabs.nl/aptkey.asc\n```\n\n### 1.2. Binary Packages\n\n5\nYou can now install Routinator with:\n\n```bash\nsudo yum install -y routinator\n```\n\nAfter installation Routinator will run immediately as the user `routinator` and be configured to start at boot. By default, it will run the RTR server on port 3323 and the HTTP server on port 8323. These, and other values can be changed in the configuration file located in `/etc/routinator/routinator.conf`.\n\nYou can check the status of Routinator with:\n\n```bash\nsudo systemctl status routinator\n```\n\nYou can view the logs with:\n\n```bash\nsudo journalctl --unit=routinator\n```\n\nRoutinator Docker images are built with Alpine Linux. The supported CPU architectures are shown on the Docker Hub Routinator page per Routinator version (aka Docker “tag”) in the OS/ARCH column.\n\nTo run Routinator as a background daemon with the default settings (RTR server on port 3323 and HTTP server on port 8323) can be done like so:\n\n```bash\nsudo docker run -d --restart=unless-stopped --name routinator\n -p 3323:3323\n -p 8323:8323\n nlnetlabs/routinator\n```\n\nTip: If no arguments are supplied the Routinator Docker image configures Routinator to run in server mode, with `--rtr` 3323 and `--http` 8323.\n\nFor backward compatibility with earlier releases it also configures Routinator with `--http` 9556, the port number allocated by the Prometheus project for Routinator metric publication.\n\nThe Routinator container is known to run successfully run under gVisor for additional isolation.\n\nTo adjust the configuration you can pass command line arguments to Routinator (try `--help` for more information) and/or supply your own Routinator configuration file (by mapping it from the host into the container using `--v host/path/to/routinator.conf:/etc/routinator.conf` and passing `--config /etc/routinator.conf` when running the container).\n\nFor example in an IPv6 only network you could invoke Routinator like so to have it listen on IPv6 as well as IPv4:\n\n```bash\nsudo docker run <your usual arguments>\n server --rtr [::]:3323 --http [::]:8323\n```\n\nNote the `server` command passed to Routinator. When you override the default arguments passed to Routinator by the Docker image you must provide all of the arguments required by Routinator. See the Manual Page for more information.\n\nTo persist the RPKI cache data you can create a separate Docker volume and mount it into the container like so:\n\n```bash\nsudo docker volume create rpki-cache\nsudo docker run <your usual arguments>\n -v rpki-cache:/home/routinator/.rpki-cache\n nlnetlabs/routinator\n```\n\nNew in version 0.9.0: RPM packages\nNew in version 0.11.0: Debian packages for armhf and arm64 architecture\nNew in version 0.11.2: Ubuntu packages for Jammy 22.04 (LTS)\nDeprecated since version 0.12.0: routinator-init and --accept-arin-rpa\n\n1.3 Updating\n\nDebian\nUbuntu\nRHEL/CentOS\nDocker\n\nTo update an existing Routinator installation, first update the repository using:\n\n```bash\nsudo apt update\n```\n\nYou can use this command to get an overview of the available versions:\n\n```bash\nsudo apt policy routinator\n```\n\nYou can upgrade an existing Routinator installation to the latest version using:\n\n```bash\nsudo apt --only-upgrade install routinator\n```\n\nTo update an existing Routinator installation, first update the repository using:\n\n```bash\nsudo apt update\n```\n\nYou can use this command to get an overview of the available versions:\n\n```bash\nsudo apt policy routinator\n```\n\nYou can upgrade an existing Routinator installation to the latest version using:\n\n```bash\nsudo apt --only-upgrade install routinator\n```\n\nTo update an existing Routinator installation, you can use this command to get an overview of the available versions:\n\n```bash\nsudo yum --showduplicates list routinator\n```\n\nYou can update to the latest version using:\n\n```bash\nsudo yum update -y routinator\n```\n\nAssuming that you run Docker with image nlnetlabs/routinator, upgrading to the latest version can be done by running the following commands:\n\n```bash\nsudo docker pull nlnetlabs/routinator\nsudo docker rm --force routinator\nsudo docker run <your usual arguments> nlnetlabs/routinator\n```\n1.4 Installing Specific Versions\n\nBefore every new release of Routinator, one or more release candidates are provided for testing through every installation method. You can also install a specific version, if needed.\n\nDebian\n\nUbuntu\n\nRHEL/CentOS\n\nDocker\n\nIf you would like to try out release candidates of Routinator you can add the `proposed` repository to the existing `main` repository described earlier.\n\nAssuming you already have followed the steps to install regular releases, run this command to add the additional repository:\n\n```\n\n```\n\nMake sure to update the `apt` package index:\n\n```\nsudo apt update\n```\n\nYou can now use this command to get an overview of the available versions:\n\n```\nsudo apt policy routinator\n```\n\nYou can install a specific version using `<package name>=<version>`, e.g.:\n\n```\nsudo apt install routinator=0.9.0-rc2-1buster\n```\n\nIf you would like to try out release candidates of Routinator you can add the `proposed` repository to the existing `main` repository described earlier.\n\nAssuming you already have followed the steps to install regular releases, run this command to add the additional repository:\n\n```\n\n```\n\nMake sure to update the `apt` package index:\n\n```\nsudo apt update\n```\n\nYou can now use this command to get an overview of the available versions:\n\n```\nsudo apt policy routinator\n```\n\nYou can install a specific version using `<package name>=<version>`, e.g.:\nTo install release candidates of Routinator, create an additional repo file named `/etc/yum.repos.d/nlnetlabs-testing.repo`, enter this configuration and save it:\n\n```\n[nlnetlabs-testing]\nname=NLnet Labs Testing\nbaseurl=https://packages.nlnetlabs.nl/linux/centos/$releasever/proposed/$basearch\nenabled=1\n```\n\nYou can use this command to get an overview of the available versions:\n\n```\nsudo yum --showduplicates list routinator\n```\n\nYou can install a specific version using `<package name>-<version info>`, e.g.:\n\n```\nsudo yum install -y routinator-0.9.0-rc2\n```\n\nAll release versions of Routinator, as well as release candidates and builds based on the latest main branch are available on Docker Hub.\n\nFor example, installing Routinator 0.9.0 RC2 is as simple as:\n\n```\nsudo docker run <your usual arguments> nlnetlabs/routinator:v0.9.0-rc2\n```\nCHAPTER TWO\n\nBUILDING FROM SOURCE\n\nIn addition to meeting the system requirements, there are three things you need to build Routinator: rsync, a C toolchain and Rust. You can run Routinator on any operating system and CPU architecture where you can fulfil these requirements.\n\n2.1 Dependencies\n\nTo get started you need rsync because some RPKI repositories still use it as its main means of distribution. Some of the cryptographic primitives used by Routinator require a C toolchain. Lastly, you need Rust because that’s the programming language that Routinator has been written in.\n\n2.1.1 rsync\n\nCurrently, Routinator requires the rsync executable to be in your path. Due to the nature of rsync, it is unclear which particular version you need at the very least, but whatever is being shipped with current Linux and *BSD distributions, as well as macOS should be fine. Alternatively, you can download rsync from the Samba website.\n\nOn Windows, Routinator requires the rsync version that comes with Cygwin – make sure to select rsync during the installation phase.\n\n2.1.2 C Toolchain\n\nSome of the libraries Routinator depends on require a C toolchain to be present. Your system probably has some easy way to install the minimum set of packages to build from C sources. For example, this command will install everything you need on Debian/Ubuntu:\n\n```\napt install build-essential\n```\n\nIf you are unsure, try to run cc on a command line. If there is a complaint about missing input files, you are probably good to go.\n2.1.3 Rust\n\nThe Rust compiler runs on, and compiles to, a great number of platforms, though not all of them are equally supported. The official Rust Platform Support page provides an overview of the various support levels.\n\nWhile some system distributions include Rust as system packages, Routinator relies on a relatively new version of Rust, currently 1.60.0 or newer. We therefore suggest to use the canonical Rust installation via a tool called rustup. Assuming you already have curl installed, you can install rustup and Rust by simply entering:\n\n```\ncurl --proto '=https' --tlsv1.2 -ssf https://sh.rustup.rs | sh\n```\n\nAlternatively, visit the Rust website for other installation methods.\n\n2.2 Building and Updating\n\nIn Rust, a library or executable program such as Routinator is called a crate. Crates are published on crates.io, the Rust package registry. Cargo is the Rust package manager. It is a tool that allows Rust packages to declare their various dependencies and ensure that you’ll always get a repeatable build.\n\nCargo fetches and builds Routinator’s dependencies into an executable binary for your platform. By default you install from crates.io, but you can for example also install from a specific Git URL, as explained below.\n\nInstalling the latest Routinator release from crates.io is as simple as running:\n\n```\ncargo install --locked routinator\n```\n\nThe command will build Routinator and install it in the same directory that Cargo itself lives in, likely $HOME/.cargo/bin. This means Routinator will be in your path, too.\n\n2.2.1 Updating\n\nIf you want to update to the latest version of Routinator, it’s recommended to update Rust itself as well, using:\n\n```\nrustup update\n```\n\nUse the --force option to overwrite an existing version with the latest Routinator release:\n\n```\ncargo install --locked --force routinator\n```\n\n2.2.2 Installing Specific Versions\n\nIf you want to install a specific version of Routinator using Cargo, explicitly use the --version option. If needed, use the --force option to overwrite an existing version:\n\n```\ncargo install --locked --force routinator --version 0.9.0-rc2\n```\n\nAll new features of Routinator are built on a branch and merged via a pull request, allowing you to easily try them out using Cargo. If you want to try a specific branch from the repository you can use the --git and --branch options:\n\n```\ncargo install --git https://github.com/NLnetLabs/routinator.git --branch main\n```\n2.2.3 Enabling or Disabling Features\n\nWhen you build Routinator, “features” provide a mechanism to express conditional compilation and optional dependencies. The Routinator package defines a set of named features in the `[features]` table of Cargo.toml. The table also defines if a feature is enabled or disabled by default.\n\nRoutinator currently has the following features:\n\n- **socks** — *Enabled by default* \n Allow the configuration of a SOCKS proxy.\n\n- **ui** — *Enabled by default* \n Download and build the the routinator-ui crate to run the user interface.\n\n- **native-tls** — *Disabled by default* \n Use the native TLS implementation of your system instead of rustls.\n\n- **rta** — *Disabled by default* \n Let Routinator validate Resource Tagged Attestations.\n\nTo disable the features that are enabled by default, use the `--no-default-features` option. You can then choose which features you want using the `--features` option, listing each feature separated by commas.\n\nFor example, if you want to build Routinator without the user interface, make sure SOCKS support is retained and use the native TLS implementation, enter the following command:\n\n```\ncargo install --locked --no-default-features --features socks,native-tls routinator\n```\n\n2.3 Statically Linked Routinator\n\nWhile Rust binaries are mostly statically linked, they depend on libc which, as least as glibc that is standard on Linux systems, is somewhat difficult to link statically. This is why Routinator binaries are actually dynamically linked on glibc systems and can only be transferred between systems with the same glibc versions.\n\nHowever, Rust can build binaries based on the alternative implementation named musl that can easily be statically linked. Building such binaries is easy with rustup. You need to install musl and the correct musl target such as x86_64-unknown-linux-musl for x86_64 Linux systems. Then you can just build Routinator for that target.\n\nOn a Debian (and presumably Ubuntu) system, enter the following:\n\n```\nsudo apt-get install musl-tools\nrustup target add x86_64-unknown-linux-musl\ncargo build --target=x86_64-unknown-linux-musl --release\n```\n\n2.4 Platform Specific Instructions\n\n**Tip:** GÉANT has created an Ansible playbook defining a role to deploy Routinator on Ubuntu.\n\nFor some platforms, rustup cannot provide binary releases to install directly. The Rust Platform Support page lists several platforms where official binary releases are not available, but Rust is still guaranteed to build. For these platforms, automated tests are not run so it’s not guaranteed to produce a working build, but they often work to quite a good degree.\n2.4.1 OpenBSD\n\nOn OpenBSD, patches are required to get Rust running correctly, but these are well maintained and offer the latest version of Rust quite quickly.\n\nRust can be installed on OpenBSD by running:\n\n```\npkg_add rust\n```\n\n2.4.2 CentOS 6\n\nThe standard installation method does not work when using CentOS 6. Here, you will end up with a long list of error messages about missing assembler instructions. This is because the assembler shipped with CentOS 6 is too old.\n\nYou can get the necessary version by installing the Developer Toolset 6 from the Software Collections repository. On a virgin system, you can install Rust using these steps:\n\n```\nsudo yum install centos-release-scl\nsudo yum install devtoolset-6\nscl enable devtoolset-6 bash\ncurl https://sh.rustup.rs -sSf | sh\nsource $HOME/.cargo/env\n```\n\n2.4.3 SELinux using CentOS 7\n\nThis guide, contributed by Rich Compton, describes how to run Routinator on Security Enhanced Linux (SELinux) using CentOS 7.\n\n1. Start by setting the hostname:\n\n```\nsudo nmtui-hostname\n```\n\n2. Set the interface and connect it:\n\n```\nNote: Ensure that “Automatically connect” and “Available to all users” are checked.\n```\n\n```\nsudo nmtui-edit\n```\n\n3. Install the required packages:\n\n```\nsudo yum check-update\nsudo yum upgrade -y\nsudo yum install -y epel-release\nsudo yum install -y vim wget curl net-tools lsof bash-completion yum-utils \\\n htop nginx httpd-tools tcpdump rust cargo rsync policycoreutils-python\n```\n\n4. Set the timezone to UTC:\n\n```\nsudo timedatectl set-timezone UTC\n```\n\n5. Remove `postfix` as it is unneeded:\n6. Create a self-signed certificate for NGINX:\n\n```bash\nsudo mkdir /etc/ssl/private\nsudo chmod 700 /etc/ssl/private\nsudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \\\n -keyout /etc/ssl/private/nginx-selfsigned.key \\\n -out /etc/ssl/certs/nginx-selfsigned.crt\n# Populate the relevant information to generate a self signed certificate\nsudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048\n```\n\n7. Add in the ssl.conf file to /etc/nginx/conf.d/ssl.conf and edit the ssl.conf file to provide the IP of the host in the server_name field.\n\n8. Replace /etc/nginx/nginx.conf with the nginx.conf file.\n\n9. Set the username and password for the web interface authentication:\n\n```bash\nsudo htpasswd -c /etc/nginx/.htpasswd <username>\n```\n\n10. Start NGINX and set it up so it starts at boot:\n\n```bash\nsudo systemctl start nginx\nsudo systemctl enable nginx\n```\n\n11. Add the user routinator, create the /opt/routinator directory and assign it to the routinator user and group:\n\n```bash\nsudo useradd routinator\nsudo mkdir /opt/routinator\nsudo chown routinator:routinator /opt/routinator\n```\n\n12. Sudo into the routinator user:\n\n```bash\nsudo su - routinator\n```\n\n13. Install Routinator and add it to the $PATH for user routinator:\n\n```bash\ncargo install --locked routinator\nvi /home/routinator/.bash_profile\nEdit the PATH line to include \"/home/routinator/.cargo/bin\"\nPATH=$PATH:$HOME/.local/bin:$HOME/bin:/home/routinator/.cargo/bin\n```\n\n14. Create a routinator systemd script using the template below:\n\n```bash\nsudo vi /etc/systemd/system/routinator.service\n[Unit]\nDescription=Routinator RPKI Validator and RTR Server\nAfter=network.target\n[Service]\nType=simple\nUser=routinator\nGroup=routinator\nRestart=on-failure\n```\n\n(continues on next page)\n**RestartSec=90**\n**ExecStart=/home/routinator/.cargo/bin/routinator -v -b /opt/routinator server \\**\n --http 127.0.0.1:8080 --rtr <IPv4 IP>:8323 --rtr [<IPv6 IP>]:8323\n**TimeoutStartSec=0**\n**[Install]**\n**WantedBy=default.target**\n\n**Note:** You must populate the IPv4 and IPv6 addresses. In addition, the IPv6 address needs to have brackets ‘[ ]’ around it. For example:\n\n```\n/home/routinator/.cargo/bin/routinator -v -b /opt/routinator server \\n--http 127.0.0.1:8080 --rtr 172.16.47.235:8323 --rtr [2001:db8::43]:8323\n```\n\n15. Configure SELinux to allow connections to localhost and to allow `rsync` to write to the `/opt/routinator` directory:\n\n```\nsudo setsebool -P httpd_can_network_connect 1\nsudo semanage permissive -a rsync_t\n```\n\n16. Reload the systemd daemon and set the routinator service to start at boot:\n\n```\nsudo systemctl daemon-reload\nsudo systemctl enable routinator.service\nsudo systemctl start routinator.service\n```\n\n17. Set up the firewall to permit `ssh`, HTTPS and port 8323 for the RTR protocol:\n\n```\nsudo firewall-cmd --permanent --remove-service=ssh --zone=public\nsudo firewall-cmd --permanent --zone public --add-rich-rule='rule family=\"ipv4\" \\n source address=\"<IPv4 management subnet>\" service name=ssh accept'\nsudo firewall-cmd --permanent --zone public --add-rich-rule='rule family=\"ipv6\" \\n source address=\"<IPv6 management subnet>\" service name=ssh accept'\nsudo firewall-cmd --permanent --zone public --add-rich-rule='rule family=\"ipv4\" \\n source address=\"<IPv4 management subnet>\" service name=https accept'\nsudo firewall-cmd --permanent --zone public --add-rich-rule='rule family=\"ipv6\" \\n source address=\"<IPv6 management subnet>\" service name=https accept'\nsudo firewall-cmd --permanent --zone public --add-rich-rule='rule family=\"ipv4\" \\n source address=\"<peering router IPv4 loopback subnet>\" port port=8323 protocol=tcp → accept'\nsudo firewall-cmd --permanent --zone public --add-rich-rule='rule family=\"ipv6\" \\n source address=\"<peering router IPv6 loopback subnet>\" port port=8323 protocol=tcp → accept'\nsudo firewall-cmd --reload\n```\n\n18. Navigate to `https://<IP-address>/metrics` to see if it’s working. You should authenticate with the username and password that you provided in step 10 of setting up the RPKI Validation Server.\n\n**Important:** With Routinator 0.12.0 and newer, initialisation to accept the ARIN Relying Party Agreement (RPA) is no longer required. The RPA has been updated to allow the ARIN TAL to be embedded in Relying Party software. By default, Routinator is now set up to fetch and validate all RPKI data needed for production environments.\nRoutinator has a large number of configuration options, but in most cases running it with the defaults will work just fine. You can specify options as command line arguments, but you can also use a configuration file.\n\nRoutinator uses the TOML format for specifying options in the configuration file. Its entries are named similarly to the command line options. A complete sample configuration file showing all the default values can be found in the repository.\n\nRoutinator can run as a daemon but you can also use it interactively from the command line. There are several considerations with regards to how you’ve installed and how you intend to use Routinator, which we’ll cover below.\n\n3.1 Setup When Installed From a Package\n\nThe installation script will set up Routinator to run as the user routinator and be configured to start at boot. Routinator will use the configuration file /etc/routinator/routinator.conf which contains the following pre-configured options:\n\n```plaintext\nrepository-dir = \"/var/lib/routinator/rpki-cache\"\nrepository-dir = \"/var/lib/routinator/rpki-cache\"\nrtr-listen = [\"127.0.0.1:3323\"]\nhttp-listen = [\"127.0.0.1:8323\"]\n```\n\nFor security reasons the HTTP and RTR server will only listen on localhost, so you will have to change these values to make them accessible to other devices on your network.\n\nThe service script that starts Routinator uses the --config option to explicitly refer to this configuration file, so any desired changes should be made here. If you would like to know what default settings Routinator runs with in addition to the settings in the config file, you can check with the config subcommand:\n\n```plaintext\nroutinator --config /etc/routinator/routinator.conf config\n```\n\nThis output will also provide you with the correct syntax in case you want to make changes.\n\n**Important:** Once you have started Routinator as a system service you should not invoke interactive validation runs from the command line using routinator vrps. If there is specific information you would like to have from Routinator, you should retrieve it via the user interface or one of the HTTP endpoints.\n3.2 Setup When Built with Cargo\n\nIf you have built Routinator using Cargo, you have made your own decisions with regards to the user that it runs as and the privileges it has. There is no default configuration file, as it is your choice if you want to use one.\n\nIf you run Routinator without referring to a configuration file it will check if the file $HOME/.routinator.conf exists and if it does, use it. If no configuration file is available, the default values are used.\n\nYou can specify the location of the RPKI cache directory using the **--repository-dir** option. If you don’t, one will be created in the default location $HOME/.rpki-cache/repository. The HTTP service and RTR service must be started explicitly using the command line options **--http** and **--rtr**, respectively, or via the configuration file.\n\nYou can view the default settings Routinator runs with using:\n\n```\nroutinator config\n```\n\nIt will return the list of defaults in the same notation that is used by the configuration file, which will be largely similar to this and can serve as a starting point for making your own:\n\n```\nallow-dubious-hosts = false\ndirty = false\ndisable-rrdp = false\ndisable-rsync = false\nenable-bgpsec = false\nexceptions = []\nexpire = 7200\nhistory-size = 10\nhttp-listen = []\nhttp-tls-listen = []\nlog = \"default\"\nlog-level = \"WARN\"\nmax-ca-depth = 32\nmax-object-size = 2000000\nrefresh = 600\nrepository-dir = \"~/Users/routinator/.rpki-cache/repository\"\nretry = 600\nrrdp-fallback-time = 3600\nrrdp-max-delta-count = 100\nrrdp-proxies = []\nrrdp-root-certs = []\nrrdp-timeout = 300\nrsync-command = \"rsync\"\nrsync-timeout = 300\nrtr-client-metrics = false\nrtr-listen = []\nrtr-tcp-keepalive = 60\nrtr-tls-listen = []\nstale = \"reject\"\nstrict = false\nsyslog-facility = \"daemon\"\nsystemd-listen = false\nunknown-objects = \"warn\"\nunsafe-vrps = \"accept\"\nvalidation-threads = 10\n```\n3.3 Trust Anchor Locators\n\nFetching data is done by connecting to the Trust Anchor Locators (TALs) of the five Regional Internet Registries (RIRs): AFRINIC, APNIC, ARIN, LACNIC and RIPE NCC. TALs provide hints for the trust anchor certificates to be used both to discover and validate all RPKI content. By default, Routinator will be set up for use in production environments and run with the production TALs of the five RIRs.\n\nSome RIRs and third parties also provide separate TALs for testing purposes, allowing operators to gain experience with using RPKI in a safe environment. Both the production and testbed TALs are bundled with Routinator and can be enabled and disabled using command line and configuration file options.\n\nRun the following command to list all available TALs:\n\n```\nroutinator --tal=list\n```\n\nThis displays the following overview:\n\n```\n.---- RIR TALs\n| | RIR test TALs\nV V\nX afrinic AFRINIC production TAL\nX apnic APNIC production TAL\nX arin ARIN production TAL\nX lacnic LACNIC production TAL\nX ripe RIPE production TAL\n X apnic-testbed APNIC RPKI Testbed\n X arin-ote ARIN Operational Test and Evaluation Environment\n X ripe-pilot RIPE NCC RPKI Test Environment\n nlnetlabs-testbed NLnet Labs RPKI Testbed\n```\n\nYou can influence which TALs Routinator uses with the `--tal` option, which can be combined with the `--no-rir-tals` option to leave out all RIR production TALs, as well as the `--extra-tals-dir` option to specify a directory containing extra TALs to use.\n\nFor example, if you want to add the RIPE NCC RPKI Test Environment to the default TAL set, run:\n\n```\nroutinator --tal=ripe-pilot\n```\n\nIf you want to run Routinator without any of the production TALs and only fetch data from the ARIN Operational Test and Evaluation Environment, run:\n\n```\nroutinator --no-rir-tals --tal=arin-ote\n```\n\nLastly, if you would like to use a TAL that isn’t bundled with Routinator you can place it in a directory of your choice, for example `/var/lib/routinator/tals`, and refer to it by running:\n\n```\nroutinator --extra-tals-dir=\"/var/lib/routinator/tals\"\n```\n\nRoutinator will use all files in this directory with an extension of `.tal` as TALs. These files need to be in the format described by RFC 8630. Note that Routinator will use all TALs provided. That means that if a TAL in this directory is one of the bundled TALs, then these resources will be validated twice.\n\nNew in version 0.9.0: `--list-tals, --rir-tals, --rir-test-tals, --tal` and `--skip-tal`\n\nDeprecated since version 0.9.0: `--decline-arin-rpa, use --skip-tal instead`\nNew in version 0.12.0: **--extra-tals-dir**\n\nDeprecated since version 0.12.0: The `init` subcommand, **--list-tals**\n\n### 3.4 Using Tmpfs for the RPKI Cache\n\nThe full RPKI data set consists of hundreds of thousands of small files. This causes a considerable amount of disk I/O with each validation run. If this is undesirable in your setup, you can choose to store the cache in volatile memory using the `tmpfs` file system.\n\nIf you have installed Routinator using a package, by default the RPKI cache directory will be `/var/lib/routinator/rpki-cache`, so we’ll use that as an example. Note that the directory you choose must exist before the mount can be done. You should allocate at least 3GB for the cache, but giving it 4GB will allow ample margin for future growth:\n\n```bash\nsudo mount -t tmpfs -o size=4G tmpfs /var/lib/routinator/rpki-cache\n```\n\n`Tmpfs` will behave just like a regular disk, so if it runs out of space Routinator will do a clean crash, stopping validation, the API, HTTP server and most importantly the RTR server, ensuring that no stale data will be served to your routers.\n\nAlso keep in mind that every time you restart the machine, the contents of the `tmpfs` file system will be lost. This means that Routinator will have to rebuild its cache from scratch. This is not a problem, other than it having to download several hundred megabytes of data, which usually takes about ten minutes to complete. During this time all services will be unavailable.\n\nNote that your routers should be configured to have a secondary relying party instance available at all times.\n\n### 3.5 Verifying Configuration\n\nYou should verify if Routinator has been configured correctly and your firewall allows the required outbound connections on ports 443 and 873. From a cold start, it will take ten to fifteen minutes to do the first validation run that builds up the validated cache. Subsequent runs will be much faster, because only the changes between the repositories and the validated cache need to be processed.\n\nIf you have installed Routinator from a package and run it as a service, you can check the status using:\n\n```bash\nsudo systemctl status routinator\n```\n\nAnd check the logs using:\n\n```bash\nsudo journalctl --unit=routinator\n```\n\n**Important:** Because it is expected that the state of the entire RPKI is not perfect at all times, you may see several warnings about objects that are either stale or failed cryptographic verification, or repositories that are temporarily unavailable.\n\nIf you have built Routinator using Cargo it is recommended to perform an initial test run. You can do this by having Routinator print a validated ROA payload (VRP) list with the `vrps` subcommand, and using `-v` twice to increase the log level to `debug`:\n\n```bash\nroutinator -vv vrps\n```\n\nNow, you can see how Routinator connects to the RPKI trust anchors, downloads the contents of the repositories to your machine, verifies it and produces a list of VRPs in the default CSV format to standard output.\n[INFO] Using the following TALs:\n[INFO] * afrinic\n[INFO] * apnic\n[INFO] * arin\n[INFO] * lacnic\n[INFO] * ripe\n\n\nASN, IP Prefix, Max Length, Trust Anchor\nAS137884, 103.116.116.0/23, 23, apnic\nAS9003, 91.151.112.0/20, 20, ripe\nAS38553, 120.72.19.0/24, 24, apnic\nAS58045, 37.209.242.0/24, 24, ripe\nAS9583, 202.177.175.0/24, 24, apnic\nAS50629, 2a0f:ba80::/29, 29, ripe\nAS398085, 2602:801:a008::/48, 48, arin\nAS21050, 83.96.22.0/24, 24, ripe\nAS55577, 183.82.223.0/24, 24, apnic\nAS44444, 157.167.73.0/24, 24, ripe\nAS197695, 194.67.97.0/24, 24, ripe\n\n...\n4.1 Fetching\n\nThere are two protocols in use to transport RPKI data: rsync and the \\textit{RPKI Repository Delta Protocol (RRDP)}, which relies on HTTPS. RRDP was designed to be the successor to rsync in the RPKI. As all RPKI repositories currently advertise support for both protocols, Routinator will prefer RRDP if available.\n\nIn the RPKI, the certificate hierarchy follows the same structure as the Internet number resource allocation hierarchy. Routinator starts traversing the tree by connecting to the trust anchors of the Regional Internet Registries (RIRs). Along the way Routinator will find several pointers to child publication points, such as the ones operated by National Internet Registries (NIRs), Local Internet Registries (LIRs) and organisations running delegated RPKI. Each pointer explicitly states if RRDP is offered in addition to rsync.\n\n\\begin{figure}[h]\n\\centering\n\\includegraphics[width=\\textwidth]{rpki_hierarchy.png}\n\\caption{The RPKI hierarchy}\n\\end{figure}\n\nAs a precaution, Routinator will not accept rsync and HTTPS URIs from RPKI repositories with dubious hostnames. In particular, it will reject the name \\textit{localhost}, URIs that consist of IP addresses, and hostnames that contain an explicit port. You can change this behaviour with the \\texttt{--allow-dubious-hosts} option.\n\n### 4.1.1 RRDP Fallback\n\nIf an RRDP endpoint is unavailable but it has worked in the past, Routinator will assume this is a transient problem. What action is taken is determined by the \\texttt{--rrdp\\_fallback} option. The default policy is \\texttt{stale}. This means Routinator will retry using RRDP for up to 60 minutes since the last successful update, during which it will rely on the locally cached data for this repository. After this time, Routinator will try to use rsync to fetch the data instead. To spread out load on the rsync server, the exact moment fallback happens is picked randomly between the refresh time and the \\texttt{--rrdp\\_fallback\\_time} value. If rsync communication is unsuccessful too, the local cache is used until the objects go stale and ultimately expire.\n\nAnother policy for \\texttt{--rrdp\\_fallback} is \\textit{never}. This means that rsync is never tried for a CA that advertises the availability of RRDP. Lastly, the policy \\texttt{new} means that rsync is tried if an update via RRDP fails and there is no local copy of the RRDP repository at all. In other words, an update via RRDP has never succeeded for the repository. Choosing this policy allows a repository operator some leeway when first enabling RRDP support.\n\nNew in version 0.9.0.\n\nChanged in version 0.12.0: The \\texttt{--rrdp\\_fallback} option\n4.1.2 Update Interval\n\nRoutinator will fetch new RPKI data ten minutes after the last successful update has finished. The interval can be changed using the \n--refresh option. It is possible that it takes very long to update a repository due to temporary\nnetwork problems. To ensure a slow repository doesn’t stop the entire update process from completing, Routinator has\na timeout for stalled connections. For RRDP, this timeout is implemented as an HTTP request timeout. For rsync,\nthe timeout is around the spawned rsync process. The default is five minutes for both and can be changed via the\n--rsync-timeout and --rrdp-timeout options.\n\n4.2 Validating\n\nThe validation process determines if all certificates, Route Origin Attestations (ROAs) and other signed objects that\nmay appear in the RPKI have the correct signatures. It will also verify if the hashes are correct, no objects have expired\nand the entire data set is complete. If any of the objects do not pass these checks, the data will be discarded.\n\nCurrently, only certificates (.cer), certificate revocation lists (.crl), manifests (.mft), ROAs (.roa), and Ghostbuster\nRecords (.gbr) are allowed to appear the RPKI. If another type of object is encountered Routinator will warn by default,\nbut this can be changed with the --unknown-objects option.\n\nNote that even if unknown objects are accepted, they must appear in the manifest and the hash over their content must\nmatch the one given in the manifest. If the hash does not match, the Certificate Authority (CA) and all its objects are\nstill rejected.\n\n4.2.1 Stale Objects\n\nDuring the validation process, Routinator may encounter objects that are stale. In RPKI, manifests and CRLs (Certificate\nRevocation Lists) can be stale if the time given in their next-update field is in the past, indicating that an update\nto the object was scheduled but didn’t happen. This can be because of an operational issue at the issuer or an attacker\ntrying to replay old objects.\n\nOngoing standards efforts and operational experiences suggest that stale objects should be rejected, which is the default\npolicy set by the --stale option since Routinator 0.8.0. As a result, all material published by the CA issuing this\nmanifest and CRL is considered invalid, including all material of any child CA.\n\n4.2.2 ROAs and VRPs\n\nROAs are cryptographic objects that contain a statement authorising a single Autonomous System Number (ASN) to\noriginate one or more IP prefixes, along with their maximum prefix length. ROAs can only be created by the legitimate\nholder of the IP prefixes contained within it, but they can authorise any ASN.\n\nIf the ROA passes validation, Routinator will produce one or more plain text validated ROA payloads (VRPs) for each\nROA, depending on how many IP prefixes are contained within it. Each VRP is a tuple of an ASN, a single prefix and\nits maximum prefix length. The complete collection of VRPs can be expressed in formats such as CSV or JSON, or\nexposed via the RPKI-to-Router (RTR) protocol so that they can be compared to all BGP origins seen by your routers.\nFor each route origin it can be determined if they are RPKI “Valid”, “Invalid” or “NotFound\".\n4.2.3 Unsafe VRPs\n\nIf the address prefix of a VRP overlaps with any resources assigned to a CA that has been rejected because it failed to validate completely, the VRP is said to be *unsafe* since using it may lead to legitimate routes being flagged as RPKI Invalid.\n\nRoutinator has an `--unsafe-vrps` option that specifies how to deal with these types of VRPs. Currently, the default policy is `warn` in order to gain operational experience with the frequency and impact of unsafe VRPs. This default may change in future versions.\n\nYou can learn more about this topic in the *Unsafe VRPs* section.\n\n4.3 Storing\n\nTo be resistant against accidental or malicious errors in the data published by repositories, Routinator retains two separate data sets: one that keeps the data of all publication points as it was received from their remote repository, and another – which we call the *store* – keeps the most recent data of a given RPKI publication point that was found to be correctly published.\n\nData is only transferred into the store if a manifest was found to be valid and if all files mentioned on the manifest are present and have the correct hash. Otherwise the data for the publication point already present in the store will be used for validation.\n\nIf you ever want or need to clear all stored data, you can use the `--fresh` option. This will be like starting Routinator for the very first time:\n\n```\nroutinator --fresh vrps\n```\n\nNew in version 0.9.0.\nRoutinator can perform RPKI validation as a one-time operation or run as a daemon. In both operating modes validated ROA payloads (VRPs) can be generated in a wide range of output formats for various use cases.\n\n**Tip:** In many of the output formats, the name of the trust anchor from where the VRP originated is provided. This name is derived from the file name of the TAL, without the `.tal` extension. If you would like a different name, the *tal-label* option in the *configuration file* lets you create a mapping between the file name and your desired label.\n\n**csv** The list is formatted as lines of comma-separated values of the following items:\n\n- The prefix in slash notation,\n- the maximum prefix length,\n- the Autonomous System Number, and\n- the name of the trust anchor the entry is derived from.\n\n```\nASN,IP Prefix,Max Length,Trust Anchor\nAS196615,2001:7fb:fd03::/48,48,ripe\nAS196615,2001:7fb:fd04::/48,48,ripe\nAS196615,93.175.147.0/24,24,ripe\n```\n\n**csvcompat** This is the same as the *csv* format except that all fields are embedded in double quotes and the Autonomous System Number is given without the prefix AS. This format is pretty much identical to the CSV format produced by the RIPE NCC RPKI Validator.\n\n```\n\"ASN\",\"IP Prefix\",\"Max Length\",\"Trust Anchor\"\n\"196615\",\"2001:7fb:fd03::/48\",\"48\",\"ripe\"\n\"196615\",\"2001:7fb:fd04::/48\",\"48\",\"ripe\"\n\"196615\",\"93.175.147.0/24\",\"24\",\"ripe\"\n```\n\n**csvext** This is an extended version of the *csv* format, which was used by the RIPE NCC RPKI Validator 1.x. Each line contains these comma-separated values:\n\n- The rsync URI of the ROA the line is taken from (or “N/A” if it isn’t from a ROA),\n- the Autonomous System Number,\n- the prefix in slash notation,\n- the maximum prefix length, and\n- the not-before and not-after date of the validity of the ROA.\n**Note:** This format is available for backwards compatibility reasons only. One particular limitation is that it does not consider duplicate ROAs. Please use `jsonext` as a comprehensive output format.\n\n```\nrsync://rpki.ripe.net/repository/DEFAULT/73/fe2d72-c2dd-46c1-9429-e66369649411/1/49sMtcwyAuAW2lVDSQBGhOhD9og.roa,AS196615,2001:7fb:fd03::/48,48,2021-05-03 14:51:30,2022-07-01 00:00:00\n\nrsync://rpki.ripe.net/repository/DEFAULT/73/fe2d72-c2dd-46c1-9429-e66369649411/1/49sMtcwyAuAW2lVDSQBGhOhD9og.roa,AS196615,2001:7fb:fd04::/48,48,2021-05-03 14:51:30,2022-07-01 00:00:00\n\nrsync://rpki.ripe.net/repository/DEFAULT/73/fe2d72-c2dd-46c1-9429-e66369649411/1/49sMtcwyAuAW2lVDSQBGhOhD9og.roa,AS196615,93.175.147.0/24,24,2021-05-03 14:51:30,2022-07-01 00:00:00\n```\n\n**json** The output is in JSON format. The list is placed into a member named `roas` which contains an array of objects with four elements each:\n\n- `asn` lists the Autonomous System Number of the network authorised to originate a prefix,\n- `prefix` has the prefix in slash notation,\n- `maxLength` states the maximum prefix length of the announced route, and\n- `ta` has the trust anchor from which the authorisation was derived.\n\nThis format of the `roas` element is identical to that produced by the RIPE NCC RPKI Validator except for different naming of the trust anchor.\n\nThe output object also includes a member named `metadata` which provides additional information. Currently, this is a member `generated` which provides the time the list was generated as a Unix timestamp, and a member `generatedTime` which provides the same time but in the standard ISO date format.\n\n```\n{\n \"metadata\": {\n \"generated\": \"1626853335\",\n \"generatedTime\": \"2021-07-21T07:42:15Z\"\n },\n \"roas\": [\n { \"asn\": \"AS196615\", \"prefix\": \"2001:7fb:fd03::/48\", \"maxLength\": 48, \"ta\": \"ripe\" },\n { \"asn\": \"AS196615\", \"prefix\": \"2001:7fb:fd04::/48\", \"maxLength\": 48, \"ta\": \"ripe\" },\n { \"asn\": \"AS196615\", \"prefix\": \"93.175.147.0/24\", \"maxLength\": 24, \"ta\": \"ripe\" }\n ]\n}\n```\n\nChanged in version 0.10.0: Add the `metadata` member\n\n**jsonext** The list is placed into a JSON object with three members:\n\n- `roas` contains the validated route origin authorisations,\n- `routerKeys` contains the validated BGPsec router keys, and\n- `metadata` contains some information about the validation run itself.\nAll three members are always present, even if BGPsec has not been enabled. In this case, routerKeys will simply be empty.\n\nThe roas member contains an array of objects with four elements each:\n- \\( \\text{asn} \\) lists the Autonomous System Number of the network authorised to originate a prefix,\n- \\( \\text{prefix} \\) has the prefix in slash notation,\n- \\( \\text{maxLength} \\) states the maximum prefix length of the announced route, and\n- \\( \\text{source} \\) contains information about the source of the authorisation.\n\nThe routerKeys member contains an array of objects with four elements each:\n- \\( \\text{asn} \\) lists the autonomous system using the router key,\n- \\( \\text{SKI} \\) has the key identifier as a string of hexadecimal digits,\n- \\( \\text{routerPublicKey} \\) has the actual public key as a Base 64 encoded string, and\n- \\( \\text{source} \\) contains extended information about the source of the key.\n\nThis source information the same for route origins and router keys. It consists of an array. Each item in that array is an object providing details of a source. The object will have a type of roa if it was derived from a valid ROA object, cer if it was derived from a published router certificate, or exception if it was an assertion in a local exception file.\n\nFor RPKI objects, tal provides the name of the trust anchor locator the object was published under, uri provides the rsync URI of the ROA or router certificate, validity provides the validity of the ROA itself, and chainValidity the validity considering the validity of the certificates along the validation chain.\n\nFor assertions from local exceptions, path will provide the path of the local exceptions file and, optionally, comment will provide the comment if given for the assertion.\n\nThe output object also includes a member named metadata which provides additional information. Currently, this is a member generated which provides the time the list was generated as a Unix timestamp, and a member generatedTime which provides the same time but in the standard ISO date format.\n\nPlease note that because of this additional information, output in jsonext format will be quite large.\n\n```json\n{\n \"metadata\": {\n \"generated\": 1658818561,\n \"generatedTime\": \"2022-07-26T06:56:01Z\"\n },\n \"roas\": [{\n \"asn\": \"AS211321\",\n \"prefix\": \"185.49.142.0/24\",\n \"maxLength\": 24,\n \"source\": [{\n \"type\": \"roa\",\n \"tal\": \"ripe\",\n \"uri\": \"rsync://testbed.krill.cloud/repo/local-testbed-child/0/3138352e34392e3334322e302f32342d3234203d3e2032331333231.roa\",\n \"validity\": {\n \"notBefore\": \"2022-07-25T20:47:37Z\",\n \"notAfter\": \"2023-07-24T20:52:37Z\"\n },\n \"chainValidity\": {\n \"notBefore\": \"2022-07-25T20:47:37Z\",\n```\nNew in version 0.9.0.\n\nChanged in version 0.10.0: Add metadata\n\nChanged in version 0.11.0: Add BGPsec information\n\n**slurm** The list is formatted as locally added assertions of a local exceptions file defined by RFC 8416 (also known as SLURM). The produced file will have empty validation output filters.\n\n```json\n{\n \"slurmVersion\": 1,\n \"validationOutputFilters\": {\n \"prefixFilters\": [],\n \"bgpsecFilters\": []\n },\n \"locallyAddedAssertions\": {\n \"prefixAssertions\": [\n {\n \"asn\": 196615,\n \"prefix\": \"93.175.147.0/24\",\n \"maxPrefixLength\": 24,\n \"comment\": \"ripe\"\n },\n {\n \"asn\": 196615,\n \"prefix\": \"2001:7fb:fd03::/48\",\n \"maxPrefixLength\": 48\n }\n ]\n }\n}\n```\nNew in version 0.11.0.\n\n**openbgpd** Choosing this format causes Routinator to produce a *roa-set* configuration item for the OpenBGPD configuration.\n\n```\nroa-set {\n 2001:7fb:fd03::/48 source-as 196615\n 2001:7fb:fd04::/48 source-as 196615\n 93.175.147.0/24 source-as 196615\n}\n```\n\n**bird1** Choosing this format causes Routinator to produce a ROA table configuration item for use with BIRD 1.6.\n\n```\nroa 2001:7fb:fd03::/48 max 48 as 196615;\nroa 2001:7fb:fd04::/48 max 48 as 196615;\nroa 93.175.147.0/24 max 24 as 196615;\n```\n\n**bird2** Choosing this format causes Routinator to produce a route table configuration item for BIRD 2.0 configuration.\n\n```\nroute 2001:7fb:fd03::/48 max 48 as 196615;\nroute 2001:7fb:fd04::/48 max 48 as 196615;\nroute 93.175.147.0/24 max 24 as 196615;\n```\n\n**rpsl** This format produces a list of RPSL (Routing Policy Specification Language) objects with the authorisation in the fields *route*, *origin*, and *source*. In addition, the fields *descr*, *mnt-by*, *created*, and *last-modified*, are present with more or less meaningful values.\n\n```\nroute: 93.175.147.0/24\norigin: AS196615\ndescr: RPKI attestation\nmnt-by: NA\ncreated: 2021-05-07T14:28:17Z\nlast-modified: 2021-05-07T14:28:17Z\nsource: ROA-RIPE-RPKI-ROOT\n```\n\n**summary** This format produces a summary of the content of the RPKI repository. It does not take filters into account and will always provide numbers for the complete repository.\n\nFor each trust anchor, it will print the number of verified ROAs and VRPs, as well as router certificates and keys. Note that router keys will only be verified and included in the totals if you have enabled *BGPsec*.\n<table>\n<thead>\n<tr>\n<th>Network</th>\n<th>ROAs</th>\n<th>VRPs</th>\n<th>VRP Safe</th>\n<th>VRP Final</th>\n<th>Router Certs</th>\n<th>Router Keys</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>afrinic</td>\n<td>3587 verified</td>\n<td>4545 verified, 3 unsafe, 4466 final</td>\n<td>0 verified</td>\n<td>0 final</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>apnic</td>\n<td>18612 verified</td>\n<td>85992 verified, 0 unsafe, 85711 final</td>\n<td>0 verified</td>\n<td>0 final</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>arin</td>\n<td>41500 verified</td>\n<td>50495 verified, 5 unsafe, 1812 final</td>\n<td>0 verified</td>\n<td>0 final</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>lacnic</td>\n<td>11744 verified</td>\n<td>23628 verified, 0 unsafe, 21235 final</td>\n<td>0 verified</td>\n<td>0 final</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>ripe</td>\n<td>27195 verified</td>\n<td>149164 verified, 17 unsafe, 149162 final</td>\n<td>2 verified</td>\n<td>2 final</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**Total:**\n- ROAs: 141922 verified\n- VRPs: 361536 verified, 25 unsafe, 307434 final\n- Router Certs: 2 verified\n- Router Keys: 2 verified\n\nChanged in version 0.11.0: Reformat, sort alphabetically and add BGPsec information\nIn some cases, you may want to override the global RPKI data set with your own local exceptions. For example, when a legitimate route announcement is inadvertently flagged as invalid due to a misconfigured ROA, you may want to temporarily accept it to give the operators an opportunity to resolve the issue.\n\nYou can do this by specifying route origins that should be filtered out of the output, as well as origins that should be added, in a file using JSON notation according to the SLURM (Simplified Local Internet Number Resource Management with the RPKI) standard specified in RFC 8416.\n\nYou can use this example file as a starting point, but you can also build your own exceptions file based on existing VRPs in the global RPKI data set using the SLURM output format in combination with the --select-asn and --select-prefix options.\n\nSee also:\n\n- Running Interactively\n\nFor example, this command will create a SLURM file that always authorises all announcements that are currently done from AS196615:\n\n```\nroutinator vrps --format slurm --select-asn 196615\n```\n\nThe output will look like this:\n\n```json\n{\n \"slurmVersion\": 1,\n \"validationOutputFilters\": {\n \"prefixFilters\": [],\n \"bgpsecFilters\": []\n },\n \"locallyAddedAssertions\": {\n \"prefixAssertions\": [\n {\n \"asn\": 196615,\n \"prefix\": \"93.175.147.0/24\",\n \"maxPrefixLength\": 24,\n \"comment\": \"ripe\"\n },\n {\n \"asn\": 196615,\n \"prefix\": \"2001:7fb:fd03::/48\",\n \"maxPrefixLength\": 48,\n \"comment\": \"ripe\"\n }\n ]\n }\n}\n```\n\n(continues on next page)\nUse the `--exceptions` option to refer to your file with local exceptions. Routinator verifies that the JSON itself is valid, as well as the specified values. The exceptions file will be re-read on every validation run, so you can simply update the file whenever your exceptions change.\n\nIn the metrics Routinator provides, there are counters indicating how many VRPs are added and excluded from the final data set as a result of your exceptions.\n\n### 6.1 Limiting Prefix Length\n\nIt's possible to set the maximum length of IPv4 and IPv6 prefixes that will be included in the VRP data set. You can set this with the `--limit-v4-len` and `--limit-v6-len` options, respectively.\n\nTo illustrate this option we'll use an extreme example:\n\n```bash\nroutinator --limit-v4-len=8 --limit-v6-len=19 vrps\n```\n\nNow, all VRPs will be ignored that have a prefix with a length that is longer than /8 IPv4 and /19 IPv6:\n\n<table>\n<thead>\n<tr>\n<th>ASN, IP Prefix, Max Length, Trust Anchor</th>\n<th>ASN, IP Prefix, Max Length, Trust Anchor</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>AS6253, 48.0.0.0/8, 24, arin</td>\n<td>AS6253, 48.0.0.0/8, 24, arin</td>\n</tr>\n<tr>\n<td>AS31399, 53.0.0.0/8, 8, ripe</td>\n<td>AS31399, 53.0.0.0/8, 8, ripe</td>\n</tr>\n<tr>\n<td>AS7922, 73.0.0.0/8, 8, arin</td>\n<td>AS7922, 73.0.0.0/8, 8, arin</td>\n</tr>\n<tr>\n<td>AS3320, 2003::/19, 19, ripe</td>\n<td>AS3320, 2003::/19, 19, ripe</td>\n</tr>\n<tr>\n<td>AS5511, 2a01:c00::/19, 48, ripe</td>\n<td>AS5511, 2a01:c00::/19, 48, ripe</td>\n</tr>\n</tbody>\n</table>\n\nNote that only the prefix length itself and not the maximum prefix length value of the ROA is considered.\n\nNew in version 0.12.0.\nTo let you analyse the validated ROA payload (VRP) data set as well as its overall health, Routinator logs an extensive amount of information. The log levels used by syslog are utilised to allow filtering this information for particular use cases.\n\nThe log levels represent the following information:\n\n- **error** Information related to events that prevent Routinator from continuing to operate at all, as well as all issues related to local configuration even if Routinator will continue to run.\n- **warn** Information about events and data that influences the set of VRPs produced by Routinator. This includes failures to communicate with repository servers, or encountering invalid objects.\n- **info** Information about events and data that could be considered abnormal but do not influence the set of VRPs produced. For example, when filtering of unsafe VRPs is disabled, the unsafe VRPs are logged with this level.\n- **debug** Information about the internal state of Routinator that may be useful for debugging.\n\n### 7.1 Interactive Mode\n\nWhen running interactively logging information will be printed to standard error by default. You can redirect logging to syslog using the `--syslog` option, or to a file with the `--logfile` option. You can influence the amount of information returned with these options:\n\n- **-v, --verbose** Print more information. If given twice, even more information is printed. More specifically, a single `-v` increases the log level from the default of warn to `info`, specifying it twice increases it to `debug`.\n- **-q, --quiet** Print less information. Given twice, print nothing at all. A single `-q` will drop the log level to `error`. Specifying `-q` twice turns logging off completely.\n\n### 7.2 Detached Server Mode\n\nWhen running Routinator detached in server mode logging to syslog is implied. Using the `--syslog-facility` option you can specify the syslog facility to use, which is `daemon` by default. You also redirect logging output to a file using the `--logfile` option.\n\n**Tip:** Though almost all settings are available as command line options, you would likely want to configure logging options in the *configuration file.*\nWhen you run the HTTP service logging information is also available at the /log path. This will produce logging output of the last validation run. The log level matches that set upon start. Note that the output is collected after each validation run and is therefore only available after the initial run has concluded.\nRoutinator can run as a service that periodically fetches RPKI data, verifies it and makes the resulting data set available through the built-in HTTP and RPKI-to-Router (RTR) servers.\n\nIf you have installed Routinator through our software package repository, the HTTP and RTR servers are enabled by default via the pre-installed configuration file. However, they are only available on localhost for security reasons. You will have to explicitly change these options to make the services available to other network devices.\n\nIf you have built Routinator using Cargo, no servers are enabled by default at all. From the command line you can start Routinator as a daemon using the `server` subcommand. Use the `--http` command line option or the `http-listen` configuration file option to start the HTTP server. To enable the RTR server, use the `--rtr` command line option or the `rtr-listen` option in the configuration file. Of course you also start both.\n\nHTTPS and secure transports for RTR are supported as well. Please read the HTTP Service and RTR Service sections for details.\n\n**Note:** Both servers will only start serving data once the first validation run has completed. Routinator will not reread the trust anchor locators after it has started the service. Thus, if you add or change a TAL you must restart Routinator or send it a `SIGUSR1`.\n\nUsing 192.0.2.13 as an example IPv4 address, enter the following command to start Routinator with the HTTP server listening on port 8323 and the RTR server on port 3323:\n\n```\nroutinator server --http 192.0.2.13:8323 --rtr 192.0.2.13:3323\n```\n\nMake sure IPv6 addresses are in square brackets, e.g.:\n\n```\nroutinator server --rtr [::]:3323\n```\n\nBy default Routinator will stay attached to your terminal and log to standard error. You can provide the `--detach` option to run it in the background instead, in which case logging information is written to syslog. To learn more about what kind of information is returned and how to influence what is logged and where, refer to the Logging section.\n\n**Attention:** On Linux systems there is an overlap between IPv4 and IPv6. You can’t bind to all interfaces on both address families, i.e. `0.0.0.0` and `[::]`, as it will result in a 'address already in use' error. Instead, to listen to both IPv4 and IPv6 you can simply enter:\n\n```\nroutinator server --rtr [::]:3323\n```\nRoutinator has a built-in server for the RPKI-to-Router (RTR) protocol, which can be started with the `--rtr` command line option or the `rtr-listen` option in the configuration file.\n\nRoutinator supports RTR version 1 described in RFC 8210, as well as the older version from RFC 6810. After the first validation run has completed, routers with support for route origin validation (ROV) can connect to Routinator to fetch the processed data.\n\nTip: If you would like to run the RTR server as a separate daemon, for example because you want to centralise validation and distribute processed data to various locations where routers can connect, then NLnet Labs provides RTRTR.\n\nIn the examples throughout the documentation we use port 3323 for RTR connections, but please note that this is not the IANA (Internet Assigned Numbers Authority)-assigned default port for the protocol, which would be 323. But as this is a privileged port, you would need to be running Routinator as `root` when otherwise there is no reason to do that.\n\n### 9.1 Secure Transports\n\nAlthough there is no mandatory-to-implement transport that provides authentication and integrity protection, RFC 6810#section-7 defines a number of secure transports for RPKI-RTR that can be used to secure communications, including TLS, SSH, TCP MD5 and TCP-AO.\n\nRoutinator has native support for TLS connections, and can be configured to use SSH Transport with some additional tooling.\n\n#### 9.1.1 TLS Transport\n\nIt’s possible to natively use RTR-over-TLS connections with Routinator. There is an IANA-assigned default port for `rpki-rtr-tls` as well, in this case 324.\n\nCurrently, very few routers have implemented support for TLS, but it may be especially useful to use secure connections when deploying our RTR data proxy RTRTR, as data may be flowing across the public Internet.\n\nIn this example we’ll start Routinator’s RTR server listening on the IP addresses 192.0.2.13 and 2001:0DB8::13 and use port 3324 to make sure it’s not a privileged port.\n\nFirst, indicate that you want a TLS connection with the `--rtr-tls` option. Then use the `--rtr-tls-cert` option to specify the path to a file containing the server certificates to be used. This file has to contain one or more certificates encoded in PEM format. Lastly, use the `--rtr-tls-key` option to specify the path to a file containing the private key to be used for RTR-over-TLS connections. The file has to contain exactly one private key encoded in PEM format:\nIf you want to securely connect to Routinator with RTRTR using the RTR-TLS Unit, a certificate that is trusted by the usual set of web trust anchors will work with no additional configuration. In case you generated a self-signed certificate for Routinator, make sure to copy the certificate to your machine running RTRTR and refer to the path of the file in your unit using the `cacerts` configuration option.\n\nNew in version 0.11.0.\n\n### 9.1.2 SSH Transport\n\nThese instructions were contributed by Wild Kat.\n\nSSH transport for RPKI-RTR can be configured with the help of netcat and OpenSSH.\n\n1. Begin by installing the `openssh-server` and `netcat` packages.\n\nMake sure Routinator is running as an RTR server on localhost:\n\n```\nroutinator server --rtr 127.0.0.1:3323\n```\n\n2. Create a username and a password for the router to log into the host with, such as `rpki`.\n\n3. Configure OpenSSH to expose an `rpki-rtr` subsystem that acts as a proxy into Routinator by editing the `/etc/ssh/sshd_config` file or equivalent to include the following line:\n\n```\n# Define an `rpki-rtr` subsystem which is actually `netcat` used to\n# proxy STDIN/STDOUT to a running `routinator server --rtr 127.0.0.1:3323`\nSubsystem rpki-rtr /bin/nc 127.0.0.1 3323\n\n# Certain routers may use old KEX algos and Ciphers which are no longer enabled by default.\n# These examples are required in IOS-XR 5.3 but no longer enabled by default in OpenSSH 7.3\nCiphers +3des-cbc\nKexAlgorithms +diffie-hellman-group1-sha1\n\n# Only allow the rpki user to execute this one command\nMatch User rpki\n ForceCommand /bin/nc localhost 3323\n PasswordAuthentication yes\nMatch all\n```\n\n4. Restart the OpenSSH server daemon.\n\n5. Set up the router running IOS-XR using this example configuration:\n\n```\nrouter bgp 65534\n rpki server 192.168.0.100\n username rpki\n password <password>\n transport ssh port 22\n```\n9.2 Configuring Routers\n\nRoute Origin Validation is supported on most hardware and software routers. This documentation does not provide authoritative information on how to configure each router platform, but aims to provide helpful pointers.\n\n9.2.1 Hardware Routers\n\n- Arista EOS\n- Cisco IOS and IOS XE\n- Cisco IOS-XR\n- Extreme Networks SLX-OS\n- Huawei VRP\n- Juniper Junos\n- Nokia SR OS\n- MikroTik\n\n9.2.2 Software Routers\n\n- BIRD\n- FRRouting\n- GoBGP\n- OpenBGPD\n- VyOS\n\nSee also:\nRejecting RPKI Invalid BGP Routes in the NLNOG BGP Filter Guide.\n\nNote: For additions or corrections, please open an issue or submit a pull request.\nCHAPTER\nTEN\n\nHTTP SERVICE\n\nRoutinator has a built-in HTTP server, which can be started with the `--http` command line option or the `http-listen` option in the configuration file. Routinator natively supports TLS Transport and the endpoints are set up in such a way that it’s easy to configure a reverse proxy as well.\n\nIn addition to the various VRP output formats, Routinator’s HTTP server also provides a user interface, an API, monitoring and logging endpoints.\n\nAfter fetching and verifying all RPKI data for the first time, paths are available for each VRP output format. For example, at the /json path you can fetch a list of all VRPs in JSON format.\n\n```bash\ncurl http://192.0.2.13:8323/json\n```\n\n10.1 Query Parameters\n\nAll paths accept selector expressions to limit the VRPs returned in the form of a query parameter. You can use `select-asn` to select ASNs and `select-prefix` to select prefixes. These expressions can be repeated multiple times. The output for each additional parameter will be added to the results.\n\nFor example, to only show the VRPs in JSON format authorising AS196615, use:\n\n```bash\ncurl http://192.0.2.13:8323/json?select-asn=196615\n```\n\nThis will produce the following output:\n\n```json\n{\n \"metadata\": {\n \"generated\": 1626853335,\n \"generatedTime\": \"2021-07-21T07:42:15Z\"\n },\n \"roas\": [\n {\n \"asn\": \"AS196615\", \"prefix\": \"2001:7fb:fd03::/48\", \"maxLength\": 48, \"ta\": \"ripe\"\n },\n {\n \"asn\": \"AS196615\", \"prefix\": \"2001:7fb:fd04::/48\", \"maxLength\": 48, \"ta\": \"ripe\"\n },\n {\n \"asn\": \"AS196615\", \"prefix\": \"93.175.147.0/24\", \"maxLength\": 24, \"ta\": \"ripe\"\n }\n ]\n}\n```\n10.1.1 More Specific Prefixes\n\nWhen you query for a prefix, by default Routinator will return the exact match, as well as less specifics. The reason is that a VRP of an overlapping less specific prefix can also affect the RPKI validity of a BGP announcement, depending on the Maximum Prefix Length (MaxLength) that is set.\n\nIn some cases you may want more specifics to be displayed as well. For this the more-specifics query string can be used. For example, when querying for 82.221.32.0/20:\n\n```\ncurl http://192.0.2.13:8323/json?select-prefix=82.221.32.0/20\n```\n\nRoutinator will return the exact match and the VRP for the less specific /17 prefix:\n\n```\n{\n \"metadata\": {\n \"generated\": 1644266267,\n \"generatedTime\": \"2022-02-07T20:37:47Z\"\n },\n \"roas\": [\n { \"asn\": \"AS30818\", \"prefix\": \"82.221.32.0/20\", \"maxLength\": 20, \"ta\": \"ripe\" },\n { \"asn\": \"AS44515\", \"prefix\": \"82.221.0.0/17\", \"maxLength\": 17, \"ta\": \"ripe\" }\n ]\n}\n```\n\nWhen including the more-specifics parameter in the same query:\n\n```\ncurl http://192.0.2.13:8323/json?select-prefix=82.221.32.0/20&include=more-specifics\n```\n\nYou will now see that a more specific /23 prefix is returned as well:\n\n```\n{\n \"metadata\": {\n \"generated\": 1644266267,\n \"generatedTime\": \"2022-02-07T20:37:47Z\"\n },\n \"roas\": [\n { \"asn\": \"AS44515\", \"prefix\": \"82.221.46.0/23\", \"maxLength\": 23, \"ta\": \"ripe\" },\n { \"asn\": \"AS30818\", \"prefix\": \"82.221.32.0/20\", \"maxLength\": 20, \"ta\": \"ripe\" },\n { \"asn\": \"AS44515\", \"prefix\": \"82.221.0.0/17\", \"maxLength\": 17, \"ta\": \"ripe\" }\n ]\n}\n```\n\nTip: The more-specifics parameter will also work if there is no exactly matching or less specific prefix. In that case you will get a list of all more specific VRPs covered by the prefix you supplied in the query.\n\nChanged in version 0.11.0: more-specifics query parameter\n10.2 TLS Transport\n\nRoutinator offers native TLS support for both HTTP and RTR connections. In this example we’ll start Routinator’s HTTPS server listening on the IP addresses 192.0.2.13 and 2001:0DB8::13 and use port 8324.\n\nFirst, indicate that you want a TLS connection with the `--http-tls` option. Then use the `--http-tls-cert` option to specify the path to a file containing the server certificates to be used. This file has to contain one or more certificates encoded in PEM format. Lastly, use the `--http-tls-key` option to specify the path to a file containing the private key to be used for HTTPS connections. The file has to contain exactly one private key encoded in PEM format:\n\n```\nroutinator server --http-tls 192.0.2.13:8324 \\\n --http-tls [2001:0DB8::13]:8324 \\\n --http-tls-cert \"/path/to/http-tls.crt\" \\\n --http-tls-key \"/path/to/http-tls.key\"\n```\n\nNew in version 0.11.0.\n\n10.3 Using a Reverse Proxy\n\nThough TLS is natively supported, it may be more convenient to set up a reverse proxy to serve HTTPS data. This way you’ll be using a production grade web server that for example allows automation of certificate renewal.\n\nFor convenience, all the files and folders for the user interface are hosted under the /ui path and the API endpoints are under /api. For example, this allows you to just expose the UI and not any of the other paths, such as those serving the various VRP output formats.\n\nIn this example we’ll use NGINX, but other web servers will allow a similar, simple configuration. To only expose the user interface, this is what your configuration needs at a minimum when running it on the same server as Routinator runs on, using port 8323.\n\nUsing the `=` modifier, the first entry only forwards if the path is exactly / so that paths not explicitly mentioned, such as /json, are not forwarded. For more information, please refer to the NGINX documentation.\n\n```\nlocation = / { \n proxy_pass http://127.0.0.1:8323/; \n }\nlocation /ui { \n proxy_pass http://127.0.0.1:8323/ui; \n }\nlocation /api { \n proxy_pass http://127.0.0.1:8323/api; \n }\n```\nRoutinator’s HTTP service offers a web-based user interface on the /ui path. In addition to displaying detailed statistics from the last validation run Routinator has performed, as well as HTTP and RTR connection metrics, the most prominent functionality is the Prefix Check.\n\nBy default, you only need to provide an IP address or prefix. When clicking Validate, Routinator will look up from which Autonomous System the closest matching prefix is announced in BGP and perform RPKI validation. Alternatively, you can manually provide an ASN.\n\nThe returned RPKI validity state will be Valid, Invalid or NotFound and is based on the current set of Validated ROA Payloads (VRPs) in the cache. Routinator will provide an overview of all VRPs that led to the result, along with the reason for the outcome.\n\nRoutinator doesn’t just retrieve the ASN for a specific prefix, but it also fetches related information. In addition to validating the longest matching prefix (or exact match if this is what you selected), details can be provided on less specific and more specific announcements seen in BGP, as well as other resources allocated to the same organisation.\n\nRoutinator does not perform the BGP and allocation lookups itself, but relies on the open-source roto-api service, developed and hosted by NLnet Labs at bgp-api.net. The service uses these data sources:\n\n- BGP information based on RISWhois data, which is part of the RIPE NCC’s Routing Information Service (RIS). This data set is currently updated every 8 hours.\n- Resource allocations retrieved from statistics hosted by the five Regional Internet Registries. These are updated daily.\n\nNew in version 0.8.3.\n\nChanged in version 0.10.0: The Prefix Check\nFig. 1: The Routinator Prefix Check\nFig. 2: Prefixes related to your query\nAPI ENDPOINTS\n\nThe HTTP service supports GET requests on the following paths:\n\n/api/v1/status Returns exhaustive information in JSON format on all trust anchors, repositories, RRDP and rsync connections, as well as RTR and HTTP sessions. This data set provides the source for the Routinator user interface.\n\n/api/v1/validity/as-number/prefix Returns a JSON object describing whether the route announcement given by its origin AS Number and address prefix is RPKI valid, invalid, or not found. A complete list of VRPs that caused the result is included.\n\n/validity?asn=as-number&prefix=prefix Same as above but with a more form-friendly calling convention.\n\n/json-delta, /json-delta?session=session?serial=serial Returns a JSON object with the changes since the dataset version identified by the session and serial query parameters. If a delta cannot be produced from that version, the full data set is returned and the member reset in the object will be set to true. In either case, the members session and serial identify the version of the data set returned and their values should be passed as the query parameters in a future request.\n\nThe members announced and withdrawn contain arrays with route origins that have been announced and withdrawn, respectively, since the provided session and serial. If reset is true, the withdrawn member is not present.\n\nIn addition, the /log endpoint returns logging information and the /metrics, /status and /version endpoints provide monitoring data.\n\nNew in version 0.9.0: The /json-delta path\n\nChanged in version 0.9.0: The /api/v1/status path\nThe HTTP server in Routinator provides endpoints for monitoring the application on the following paths:\n\n/version Returns the version of the Routinator instance\n\n/metrics Exposes exhaustive time series data specifically for Prometheus, containing metrics on all trust anchors, repositories, RRDP and rsync connections, as well as RTR and HTTP sessions. If desired, dedicated port 9556 is allocated for the exporter.\n\n/api/v1/status Returns exhaustive information in JSON format on all trust anchors, repositories, RRDP and rsync connections, as well as RTR and HTTP sessions. This data set provides the source for the Routinator user interface.\n\n/status Returns a subset of the metrics information in a concise plain text format\n\n13.1 Metrics\n\nUpdate metrics\n\n- When the last update started and finished\n- The total duration of the last update\n- The retrieval duration and exit code for each rsync publication point\n- The retrieval duration and HTTP status code for each RRDP publication point\n\nObject metrics\n\n- For each cryptographic object that can appear in the RPKI, the number of valid, invalid and stale items per trust anchor and repository\n- The number of validated ROA payloads (VRPs) per Trust Anchor and repository\n- The number of VRPs added and excluded locally\n\nRTR server\n\n- The current RTR serial number\n- The current number of RTR connections\n- The total amount of bytes sent and received over the RTR connection\n- Metrics for each RTR client is available if the --rtr-client-metrics option is provided\n\nHTTP server\n\n- The current number of HTTP connections\n• The total amount of bytes sent and received over the HTTP connection\n\n• The number of HTTP requests\n\nRefer to the Reference section for a complete overview for all metrics in the JSON format and the Prometheus format.\n\n### 13.2 Grafana\n\nUsing the Prometheus endpoint it’s possible to build a detailed dashboard using for example Grafana. We provide a template to get started.\n\n\n\n---\n\n54 Chapter 13. Monitoring\nFig. 2: Time series for each Trust Anchor\nRoutinator can perform RPKI validation as a one-time operation and print a validated ROA payload (VRP) list in various formats using the `vrps` subcommand and specifying the desired format.\n\n**Warning:** If you have installed Routinator through the NLnet Labs software package repository, the installation script will set up the application to run as a service. You should not run Routinator as a daemon and interactively at the same time on the same machine.\n\nFor example, to print the VRPs in CSV format to standard output, run:\n\n```\nroutinator vrps --format csv\n```\n\nTo generate a file with the validated ROA payloads in JSON format, run:\n\n```\nroutinator vrps --format json --output authorisedroutes.json\n```\n\nDuring the validation process, logging information will be printed to standard error. You can influence the amount of details returned with the `--verbose` and `--quiet` options. To learn more about what kind of information returned, refer to the *Logging* section.\n\n### 14.1 Query Options\n\nIn case you are looking for specific information in the output, Routinator allows you to add selectors to see if a prefix or ASN is covered or matched by a VRP. You can do this using the `--select-asn` and `--select-prefix` options.\n\nWhen using `--select-asn`, you can use both AS64511 and 64511 as the notation. With `--select-prefix`, the result will include VRPs regardless of their ASN and MaxLength. Both selector flags can be combined and used multiple times in a single query. The output for each additional selector will be added to the results.\n\nA validation run will be started before returning the result, making sure you get the latest information. If you would like a result from the current cache, you can use the `--noupdate` option.\n\nHere is an example selecting VRPs related to a specific ASN, produced in JSON format:\n\n```\nroutinator vrps --format json --select-asn 196615\n```\n\nThis results in:\n\n```json\n{\n \"metadata\": {\n \"generated\": 1626853335,\n```\n\n14.1.1 More Specific Prefixes\n\nWhen you query for a prefix, by default Routinator will return the exact match, as well as less specifics. The reason is that a VRP of an overlapping less specific prefix can also affect the RPKI validity of a BGP announcement, depending on the *Maximum Prefix Length (MaxLength)* that is set.\n\nIn some cases you may want more specifics to be displayed as well. For this the `--more-specifics` option can be used. For example, when querying for 82.221.32.0/20:\n\n```bash\nroutinator vrps --format json --select-asn 82.221.32.0/20\n```\n\nRoutinator will return the exact match and the VRP for the less specific /17 prefix:\n\n```json\n{\n \"metadata\": {\n \"generated\": 1644266267,\n \"generatedTime\": \"2022-02-07T20:37:47Z\"\n },\n \"roas\": [\n { \"asn\": \"AS30818\", \"prefix\": \"82.221.32.0/20\", \"maxLength\": 20, \"ta\": \"ripe\" },\n { \"asn\": \"AS44515\", \"prefix\": \"82.221.0.0/17\", \"maxLength\": 17, \"ta\": \"ripe\" }\n ]\n}\n```\n\nWhen including the `--more-specifics` option in the same query:\n\n```bash\nroutinator vrps --format json --select-asn 82.221.32.0/20 --more-specifics\n```\n\nYou will now see that a more specific /23 prefix is returned as well:\n\n```json\n{\n \"metadata\": {\n \"generated\": 1644266267,\n \"generatedTime\": \"2022-02-07T20:37:47Z\"\n },\n \"roas\": [\n { \"asn\": \"AS44515\", \"prefix\": \"82.221.46.0/23\", \"maxLength\": 23, \"ta\": \"ripe\" },\n { \"asn\": \"AS30818\", \"prefix\": \"82.221.32.0/20\", \"maxLength\": 20, \"ta\": \"ripe\" },\n { \"asn\": \"AS44515\", \"prefix\": \"82.221.0.0/17\", \"maxLength\": 17, \"ta\": \"ripe\" }\n ]\n}\n```\n**Tip:** The `--more-specifics` option will also work if there is no exactly matching or less specific prefix. In that case you will get a list of all more specific VRPs covered by the prefix you supplied in the query.\n\nDeprecated since version 0.9.0: `--filter-asn` and `--filter-prefix`\n\nChanged in version 0.11.0: Add the `--more-specifics` option\nYou can check the RPKI origin validation status of one or more BGP announcements using the `validate` subcommand and by supplying the ASN and prefix. A validation run will be started before returning the result, making sure you get the latest information. If you would like a result from the current cache, you can use the `--noupdate` option:\n\n```\nroutinator validate --asn 12654 --prefix 93.175.147.0/24\n```\n\nThis will simply return the RPKI validity state:\n\n```\nInvalid\n```\n\nYou can also add the `--json` option:\n\n```\nroutinator validate --json --asn 12654 --prefix 93.175.147.0/24\n```\n\nThis will produce a detailed analysis of the reasoning behind the validation outcome is printed in JSON format. In case of an Invalid state, whether this because the announcement is originated by an unauthorised AS, or if the prefix is more specific than the maximum prefix length allows. Lastly, a complete list of VRPs that caused the result is included:\n\n```\n{\n \"validated_routes\": [\n {\n \"route\": {\n \"origin_asn\": \"AS12654\",\n \"prefix\": \"93.175.147.0/24\"\n },\n \"validity\": {\n \"state\": \"invalid\",\n \"reason\": \"as\",\n \"description\": \"At least one VRP Covers the Route Prefix, but no VRP ASN matches the route origin ASN\",\n \"VRPs\": {\n \"matched\": [\n ],\n \"unmatched_as\": [\n {\n \"asn\": \"AS196615\",\n \"prefix\": \"93.175.147.0/24\",\n \"max_length\": \"24\"\n }\n ],\n \"unmatched_length\": [\n```\n\n(continues on next page)\nIf you run the HTTP service in daemon mode, validation information is also available via the user interface and at the /validity API endpoint.\n\n### 15.1 Reading Input From a File\n\nRoutinator can also read input to validate from a file using the `--input` option. If the file is given as a single dash, input is read from standard input. You can also save the results to a file using the `--output` option.\n\nYou can provide a simple plain text file with the routes you would like to have verified by Routinator. The input file should have one route announcement per line, provided as a prefix followed by an ASCII-art arrow `=>` surrounded by white space and followed by the AS Number of the originating Autonomous System.\n\nFor example, let's provide Routinator with this file, saved as `beacons.txt`:\n\n```\n93.175.147.0/24 => 12654\n2001:7fb:fd02::/48 => 12654\n```\n\nNow we refer to the file with the `--input` option:\n\n```\nroutinator validate --input beacons.txt\n```\n\nRoutinator provides the RPKI validity state in the output:\n\n```\n93.175.147.0/24 => AS12654: invalid\n2001:7fb:fd02::/48 => AS12654: valid\n```\n\nWith the `--json` option you can provide a file in JSON format. It should consist of a single object with one member `routes` which contains an array of objects. Each object describes one route announcement through its `prefix` and `asn` members which contain a prefix and originating AS number as strings, respectively.\n\nFor example, let's provide Routinator with this `beacons.json` file:\n\n```\n{\n \"routes\": [\n {\n \"asn\": \"AS12654\",\n \"prefix\": \"93.175.147.0/24\"\n },\n {\n \"asn\": \"AS12654\",\n \"prefix\": \"2001:7fb:fd02::/48\"\n }\n ],\n \"generatedTime\": \"2021-07-21T11:36:44Z\"\n}\n```\n\nThen refer to the file with the `--json` and `--input` options:\nroutinator validate --json --input beacons.json\n\nRoutinator produces a JSON object that includes the validity state and a detailed analysis of the reasoning behind the outcome of each route:\n\n```json\n{\n \"validated_routes\": [\n {\n \"route\": {\n \"origin_asn\": \"AS12654\",\n \"prefix\": \"93.175.147.0/24\"\n },\n \"validity\": {\n \"state\": \"invalid\",\n \"reason\": \"as\",\n \"description\": \"At least one VRP Covers the Route Prefix, but no VRP ASN matches the route origin ASN\",\n \"VRPs\": {\n \"matched\": [],\n \"unmatched_as\": [\n {\n \"asn\": \"AS196615\",\n \"prefix\": \"93.175.147.0/24\",\n \"max_length\": \"24\"\n }\n ],\n \"unmatched_length\": []\n }\n }\n },\n {\n \"route\": {\n \"origin_asn\": \"AS12654\",\n \"prefix\": \"2001:7fb:fd02::/48\"\n },\n \"validity\": {\n \"state\": \"valid\",\n \"description\": \"At least one VRP Matches the Route Prefix\",\n \"VRPs\": {\n \"matched\": [\n {\n \"asn\": \"AS12654\",\n \"prefix\": \"2001:7fb:fd02::/48\",\n \"max_length\": \"48\"\n }\n ],\n \"unmatched_as\": [\n ],\n \"unmatched_length\": []\n }\n }\n }\n ]\n}\n```\n\n(continues on next page)\nNew in version 0.9.0.\nThe `dump` subcommand writes the contents of all stored data to the file system. This is primarily intended for debugging but can be used to get access to the view of the RPKI data that Routinator currently sees. This subcommand has only one option, `--output`, which specifies the directory where the output should be written.\n\nThree directories will be created in the output directory:\n\n- **rrdp** This directory contains all the files collected via RRDP from the various repositories. Each repository is stored in its own directory. The mapping between rpkiNotify URI and path is provided in the `repositories.json` file. For each repository, the files are stored in a directory structure based on the components of the file as rsync URI.\n\n- **rsync** This directory contains all the files collected via rsync. The files are stored in a directory structure based on the components of the file’s rsync URI.\n\n- **store** This directory contains all the files used for validation. Files collected via RRDP or rsync are copied to the store if they are correctly referenced by a valid manifest. This part contains one directory for each RRDP repository similarly structured to the `rrdp` directory and one additional directory `rsync` that contains files collected via rsync.\n\n- **ta** This directory contains the trust anchor certificates. Files are stored in a directory structure two levels deep. The first level is the schema portion of the certificate’s URI, i.e., `https` or `rsync`, and the second level is the authority portion of the URI, e.g., `tal.apnic.net`. Within this second level, the certificate is stored in a file that has the hexadecimal encoding of the SHA-256 hash of the certificate’s URI as the file name with the extension `.cer` appended.\n\nNew in version 0.9.0.\n\nChanged in version 0.11.1: Stored trust anchor certificates are dumped into the `ta` directory.\n17.1 Synopsis\n\nroutinator [options] vrps [vrps-options] [-o output-file] [-f format]\nroutinator [options] validate [validate-options] [-a asn] [-p prefix]\nroutinator [options] server [server-options]\nroutinator [options] update [update-options]\nroutinator man [-o file]\nroutinator -h\nroutinator -V\n\n17.2 Description\n\nRoutinator collects and processes Resource Public Key Infrastructure (RPKI) data. It validates the Route Origin Attestations contained in the data and makes them available to your BGP routing workflow.\n\nIt can run in one-shot mode outputting a list of validated ROA payloads in various formats, as a server for the RPKI-to-Router (RTR) protocol that many routers implement to access the data, or via HTTP.\n\nThese modes and additional operations can be chosen via commands. For the available commands, see COMMANDS below.\n\n17.3 Options\n\nThe available options are:\n\n-c path, --config=path\n Provides the path to a file containing basic configuration. If this option is not given, Routinator will try to use\n $HOME/.routinator.conf if that exists. If that doesn’t exist, either, default values for the options as described\n here are used.\n\n See CONFIGURATION FILE below for more information on the format and contents of the configuration file.\n\n-r dir, --repository-dir=dir\n Specifies the directory to keep the local repository in. This is the place where Routinator stores the RPKI data it\n has collected and thus is a copy of all the data referenced via the trust anchors.\n If omitted, defaults to $HOME/.rpki-cache/repository.\n--no-rir-tals\nIf present, Routinator will not use the bundled trust anchor locators (TALs) of the five Regional Internet Registries (RIRs).\n\nTrust anchor locators are the starting points for collecting and validating RPKI data. Each of the five RIRs provides a TAL that adds resources from their area. For normal production installations, these are the only TALs that should be used.\n\nUsing this option as well as the --tal and --extra-tals-dir options you can change which TALs Routinator should use.\n\n--tal=name\nUse the bundled TAL with the given name in addition to any other TAL.\n\nEach RIR TAL is available through this option as well as TALs for a few select test environments. If you use this option with the name list, Routinator will print a list of all available bundled TALs and exit.\n\nThe option can be given more than once.\n\n--extra-tals-dir=dir\nSpecifies a directory containing additional trust anchor locators (TALs) to use. Routinator will use all files in this directory with an extension of .tal as TALs. These files need to be in the format described by RFC 8630.\n\nNote that Routinator will use all TALs provided. That means that if a TAL in this directory is one of the bundled TALs, then these resources will be validated twice.\n\n-x file, --exceptions=file\nProvides the path to a local exceptions file. The option can be used multiple times to specify more than one file to use. Each file is a JSON file as described in RFC 8416. It lists both route origins that should be filtered out of the output as well as origins that should be added.\n\n--strict\nIf this option is present, the repository will be validated in strict mode following the requirements laid out by the standard documents very closely. With the current RPKI repository, using this option will lead to a rather large amount of invalid route origins and should therefore not be used in practice.\n\nSee RELAXED DECODING below for more information.\n\n--stale=policy\nThis option defines how deal with stale objects. In RPKI, manifests and CRLs can be stale if the time given in their next-update field is in the past, indicating that an update to the object was scheduled but didn't happen. This can be because of an operational issue at the issuer or an attacker trying to replay old objects.\n\nThere are three possible policies that define how Routinator should treat stale objects.\n\nA policy of reject instructs Routinator to consider all stale objects invalid. This will result in all material published by the CA issuing this manifest and CRL to be invalid including all material of any child CA.\n\nThe warn policy will allow Routinator to consider any stale object to be valid. It will, however, print a warning in the log allowing an operator to follow up on the issue.\n\nFinally, the accept policy will cause Routinator to quietly accept any stale object as valid.\n\nIn Routinator 0.8.0 and newer, reject is the default policy if the option is not provided. In version 0.7.0 the default for this option was warn. In all previous versions warn was hard-wired.\n\n--unsafe-vrps=policy\nThis option defines how to deal with “unsafe VRPs.” If the address prefix of a VRP overlaps with any resources assigned to a CA that has been rejected because it failed to validate completely, the VRP is said to be unsafe since using it may lead to legitimate routes being flagged as RPKI invalid.\n\nThere are three options how to deal with unsafe VRPs:\nA policy of `reject` will filter out these VRPs. Warnings will be logged to indicate which VRPs have been filtered.\n\nThe `warn` policy will log warnings for unsafe VRPs but will add them to the valid VRPs.\n\nFinally, the `accept` policy will quietly add unsafe VRPs to the valid VRPs. This is the default policy.\n\nFor more information on the process of validation implemented in Routinator, see the section `VALIDATION` below.\n\n`--unknown-objects=policy` \nDefines how to deal with unknown types of RPKI objects. Currently, only certificates (.cer), CRLs (.crl), manifests (.mft), ROAs (.roa), and Ghostbuster Records (.gbr) are allowed to appear in the RPKI repository.\n\nThere are, once more, three policies for dealing with an object of any other type:\n\nThe `reject` policy will reject the object as well as the entire CA. Consequently, an unknown object appearing in a CA will mark all other objects issued by the CA as invalid as well.\n\nThe policy of `warn` will log a warning, ignore the object, and accept all known objects issued by the CA.\n\nThe similar policy of `accept` will quietly ignore the object and accept all known objects issued by the CA.\n\nThe default policy if the option is missing is `warn`.\n\nNote that even if unknown objects are accepted, they must appear in the manifest and the hash over their content must match the one given in the manifest. If the hash does not match, the CA and all its objects are still rejected.\n\n`--limit-v4-len=length, --limit-v6-len=length` \nIf present, defines the maximum length of IPv4 prefixes or IPv6 prefixes, respectively, that will be included in the VRP data set. All VRPs for prefixes with a longer prefix length will be ignored. Note that only the prefix length itself, not the max length is considered.\n\nIf either option is missing, VRPs for all prefixes of that particular address family are included.\n\n`--allow-dubious-hosts` \nAs a precaution, Routinator will reject rsync and HTTPS URIs from RPKI data with dubious host names. In particular, it will reject the name `localhost`, host names that consist of IP addresses, and a host name that contains an explicit port.\n\nThis option allows to disable this filtering.\n\n`--fresh` \nDelete and re-initialize the local data storage before starting. This option should be used when Routinator fails after reporting corrupt data storage.\n\n`--disable-rsync` \nIf this option is present, rsync is disabled and only RRDP will be used.\n\n`--rsync-command=command` \nProvides the command to run for rsync. This is only the command itself. If you need to provide options to rsync, use the `rsync-args` configuration file setting instead.\n\nIf this option is not given, Routinator will simply run rsync and hope that it is in the path.\n\n`--rsync-timeout=seconds` \nSets the number of seconds an rsync command is allowed to run before it is terminated early. This protects against hanging rsync commands that prevent Routinator from continuing. The default is 300 seconds which should be long enough except for very slow networks. Set the option to 0 to disable the timeout.\n\n`--disable-rrdp` \nIf this option is present, RRDP is disabled and only rsync will be used.\n\n`--rrdp-fallback=policy` \nDefines the circumstance when access via rsync should be tried for a CA that announces it can be updated via\nRRDP. In general, access via RRDP is less resource intensive and more secure than rsync and will therefore be preferred. This option specifies what to do when access to an RRDP repository fails.\n\nThe policy **never** means that rsync is never tried for a CA that announces RRDP.\n\nThe policy **stale** means that rsync is tried if an update via RRDP fails and there is no current local copy of the RRDP repository. A local copy is considered current if it was last updated within a time span chosen on a per-repository basis between the `--refresh` time and `--rrdp-fallback-time`.\n\nThe policy **new** means that rsync is tried if an update via RRDP fails and there is no local copy of the RRDP repository at all. In other words, an update via RRDP has never succeeded for the repository. Choosing this policy allows a repository operator some leeway when first enabling RRDP support.\n\nThe default policy if this option is not given is **stale**.\n\n`--rrdp-fallback-time=seconds`\nSets the maximum time in seconds since a last successful update of an RRDP repository before Routinator falls back to using rsync. The default is 3600 seconds. If the given value is smaller than twice the refresh time, it is silently increased to that value.\n\nThe actual time is chosen at random between the refresh time and this value in order to spread out load on the rsync server.\n\n`--rrdp-max-delta-count=count`\nIf the number of deltas necessary to update an RRDP repository is larger than the value provided by this option, the snapshot is used instead. If the option is missing, the default of 100 is used.\n\n`--rrdp-timeout=seconds`\nSets the timeout in seconds for any RRDP-related network operation, i.e., connects, reads, and writes. If this option is omitted, the default timeout of 300 seconds is used. Set the option to 0 to disable the timeout.\n\n`--rrdp-connect-timeout=seconds`\nSets the timeout in seconds for RRDP connect requests. If omitted, the general timeout will be used.\n\n`--rrdp-tcp-keepalive=seconds`\nSets the value of the TCP keepalive duration in seconds for RRDP connections. The default if this option is omitted is 60 seconds. Set the option to 0 to disable the use of TCP keepalives.\n\n`--rrdp-local-addr=addr`\nIf present, sets the local address that the RRDP client should bind to when doing outgoing requests.\n\n`--rrdp-root-cert=path`\nThis option provides a path to a file that contains a certificate in PEM encoding that should be used as a trusted certificate for HTTPS server authentication. The option can be given more than once.\n\nProviding this option does **not** disable the set of regular HTTPS authentication trust certificates.\n\n`--rrdp-proxy=uri`\nThis option provides the URI of a proxy to use for all HTTP connections made by the RRDP client. It can be either an HTTP or a SOCKS URI. The option can be given multiple times in which case proxies are tried in the given order.\n\n`--rrdp-keep-responses=path`\nIf this option is enabled, the bodies of all HTTPS responses received from RRDP servers will be stored under *path*. The sub-path will be constructed using the components of the requested URI. For the responses to the notification files, the timestamp is appended to the path to make it possible to distinguish the series of requests made over time.\n\n`--max-object-size=BYTES`\nLimits the size of individual objects received via either rsync or RRDP to the given number of bytes. The default value if this option is not present is 20,000,000 (i.e., 20 MBytes). Use a value of 0 to disable the limit.\n**--max-ca-depth=count**\nThe maximum number of CAs a given CA may be away from a trust anchor certificate before it is rejected. The default value is 32.\n\n**--enable-bgpsec**\nIf this option is present, BGPsec router keys will be processed during validation and included in the produced data set.\n\n**--dirty**\nIf this option is present, unused files and directories will not be deleted from the repository directory after each validation run.\n\n**--validation-threads=count**\nSets the number of threads to distribute work to for validation. Note that the current processing model validates trust anchors all in one go, so you are likely to see less than that number of threads used throughout the validation run.\n\n**-v, --verbose**\nPrint more information. If given twice, even more information is printed.\n\nMore specifically, a single `-v` increases the log level from the default of `warn` to `info`, specifying it more than once increases it to `debug`.\n\nSee [LOGGING](#) below for more information on what information is logged at the different levels.\n\n**-q, --quiet**\nPrint less information. Given twice, print nothing at all.\n\nA single `-q` will drop the log level to `error`. Repeating `-q` more than once turns logging off completely.\n\n**--syslog**\nRedirect logging output to syslog.\n\nThis option is implied if a command is used that causes Routinator to run in daemon mode.\n\n**--syslog-facility=facility**\nIf logging to syslog is used, this option can be used to specify the syslog facility to use. The default is `daemon`.\n\n**--logfile=path**\nRedirect logging output to the given file.\n\n**--help, -h**\nPrint some help information.\n\n**--version, -V**\nPrint version information.\n\n### 17.4 Commands\n\nRoutinator provides a number of operations around the local RPKI repository. These can be requested by providing different commands on the command line.\n\n**vrps**\nThis command requests that Routinator update the local repository and then validate the Route Origin Attestations in the repository and output the valid route origins, which are also known as Validated ROA Payloads or VRPs, as a list.\n\n**-o file, --output=file**\nSpecifies the output file to write the list to. If this option is missing or file is `-` the list is printed to standard output.\n-f format, --format=format\nThe output format to use. Routinator currently supports the following formats:\n\n**csv** The list is formatted as lines of comma-separated values of the autonomous system number, the prefix in slash notation, the maximum prefix length, and an abbreviation for the trust anchor the entry is derived from. The latter is the name of the TAL file without the extension `.tal`. This can be overwritten with the `tal-labels` config file option.\n\nThis is the default format used if the `-f` option is missing.\n\n**csvcompat** The same as `csv` except that all fields are embedded in double quotes and the autonomous system number is given without the prefix `AS`. This format is pretty much identical to the CSV produced by the RIPE NCC Validator.\n\n**csvext** An extended version of csv each line contains these comma-separated values: the rsync URI of the ROA the line is taken from (or “N/A” if it isn’t from a ROA), the autonomous system number, the prefix in slash notation, the maximum prefix length, the not-before date and not-after date of the validity of the ROA.\n\nThis format was used in the RIPE NCC RPKI Validator version 1. That version produces one file per trust anchor. This is not currently supported by Routinator – all entries will be in one single output file.\n\n**json** The list is placed into a JSON object with a single element `roas` which contains an array of objects with four elements each: The autonomous system number of the network authorized to originate a prefix in `asn`, the prefix in slash notation in `prefix`, the maximum prefix length of the announced route in `maxLength`, and the trust anchor from which the authorization was derived in `ta`. This format is identical to that produced by the RIPE NCC RPKI Validator except for different naming of the trust anchor. Routinator uses the name of the TAL file without the extension `.tal` whereas the RIPE NCC Validator has a dedicated name for each.\n\nThe output object also includes a member named `metadata` which provides additional information. Currently, this is a member `generated` which provides the time the list was generated as a Unix timestamp, and a member `generatedTime` which provides the same time but in the standard ISO date format.\n\n**jsonext** The list is placed into a JSON object with three members: `roas` contains the validated route origin authorizations, `routerKeys` contains the validated BGPsec router keys, and `metadata` contains some information about the validation run itself.\n\nAll three members are always present, even if BGPsec has not been enabled. In this case, `routerKeys` will simply be empty.\n\nThe `roas` member contains an array of objects with four elements each: The autonomous system number of the network authorized to originate a prefix in `asn`, the prefix in slash notation in `prefix`, the maximum prefix length of the announced route in `maxLength`, and extended information about the source of the authorization in `source`.\n\nThe `routerKeys` member contains an array of objects with four elements each: The autonomous system using the router key is given in `asn`, the key identifier as a string of hexadecimal digits in `SKI`, the actual public key as a Base 64 encoded string in `routerPublicKey`, and extended information about the source of the key is contained in `source`.\n\nThis source information the same for route origins and router keys. It consists of an array. Each item in that array is an object providing details of a source. The object will have a type of `roa` if it was derived from a valid ROA object, `cer` if it was derived from a published router certificate, or `exception` if it was an assertion in a local exception file.\n\nFor RPKI objects, `tal` provides the name of the trust anchor locator the object was published under, `uri` provides the rsync URI of the ROA or router certificate, `validity` provides the validity of the ROA itself, and `chainValidity` the validity considering the validity of the certificates along the validation chain.\nFor assertions from local exceptions, *path* will provide the path of the local exceptions file and, optionally, *comment* will provide the comment if given for the assertion.\n\nThe output object also includes a member named *metadata* which provides additional information. Currently, this is a member *generated* which provides the time the list was generated as a Unix timestamp, and a member *generatedTime* which provides the same time but in the standard ISO date format.\n\nPlease note that because of this additional information, output in *jsonext* format will be quite large.\n\n**slurm** The list is formatted as locally added assertions of a local exceptions file defined by RFC 8416 (also known as SLURM). The produced file will have empty validation output filters.\n\n**openbgpd** Choosing this format causes Routinator to produce a *roa-set* configuration item for the OpenBGPD configuration.\n\n**bird1** Choosing this format causes Routinator to produce a *roa table* configuration item for the BIRD1 configuration.\n\n**bird2** Choosing this format causes Routinator to produce a *roa table* configuration item for the BIRD2 configuration.\n\n**rpsl** This format produces a list of RPSL objects with the authorization in the fields *route*, *origin*, and *source*. In addition, the fields *descr*, *mnt-by*, *created*, and *last-modified*, are present with more or less meaningful values.\n\n**summary** This format produces a summary of the content of the RPKI repository. For each trust anchor, it will print the number of verified ROAs and VRPs. Note that this format does not take filters into account. It will always provide numbers for the complete repository.\n\n**none** This format produces no output whatsoever.\n\n- **-n, --noupdate** The repository will not be updated before producing the list.\n\n- **--complete** If any of the rsync commands needed to update the repository failed, complete the operation but provide exit status 2. If this option is not given, the operation will complete with exit status 0 in this case.\n\n- **-a asn, --select-asn=asn** Only output VRPs for the given ASN. The option can be given multiple times, in which case VRPs for all provided ASNs are provided. ASNs can be given with or without the prefix AS.\n\n- **-p prefix, --select-prefix=prefix** Only output VRPs with an address prefix that covers the given prefix, i.e., whose prefix is equal to or less specific than the given prefix. This will include VRPs regardless of their ASN and max length. In other words, the output will include all VRPs that need to be considered when deciding whether an announcement for the prefix is RPKI valid or invalid.\n\n The option can be given multiple times, in which case VRPs for all prefixes are provided. It can also be combined with one or more ASN selections. Then all matching VRPs are included. That is, selectors combine as “or” not “and”.\n\n- **-m, --more-specifics** Include VRPs with prefixes that are more specific of those given by the *-p* option. Without this option, only VRPs with prefixes equal or less specific are included.\n\n Note that VRPs with more specific prefixes have no influence on whether a route is RPKI valid or invalid and therefore these VRPs are of an informational nature only.\n\n**validate**\n\nThis command can be used to perform RPKI route origin validation for one or more route announcements. Routinator will determine whether the provided announcements are RPKI valid, invalid, or not found.\nA single route announcement can be given directly on the command line:\n\n- `a asn, --asn=asn`\n The AS Number of the autonomous system that originated the route announcement. ASNs can be given with or without the prefix AS.\n\n- `p prefix, --prefix=prefix`\n The address prefix the route announcement is for.\n\n- `j, --json`\n A detailed analysis on the reasoning behind the validation is printed in JSON format including lists of the VRPs that caused the particular result. If this option is omitted, Routinator will only print the determined state.\n\nAlternatively, a list of route announcements can be read from a file or standard input.\n\n- `i file, --input=file`\n If present, input is read from the given file. If the file is given is a single dash, input is read from standard output.\n\n- `j, --json`\n If this option is provided, the input is assumed to be JSON format. It should consist of a single object with one member `routes` which contains an array of objects. Each object describes one route announcement through its `prefix` and `asn` members which contain a prefix and originating AS Number as strings, respectively.\n\n If the option is not provided, the input is assumed to consist of simple plain text with one route announcement per line, provided as a prefix followed by an ASCII-art arrow => surrounded by white space and followed by the AS Number of originating autonomous system.\n\nThe following additional options are available independently of the input method.\n\n- `o file, --output=file`\n Output is written to the provided file. If the option is omitted or `file` is given as a single dash, output is written to standard output.\n\n- `n, --noupdate`\n The repository will not be updated before performing validation.\n\n- `--complete`\n If any of the rsync commands needed to update the repository failed, complete the operation but provide exit status 2. If this option is not given, the operation will complete with exit status 0 in this case.\n\n**server**\n\nThis command causes Routinator to act as a server for the RPKI-to-Router (RTR) and HTTP protocols. In this mode, Routinator will read all the Trust Anchor Locators and will stay attached to the terminal unless the `-d` option is given.\n\nThe server will periodically update the local repository, every ten minutes by default, notify any clients of changes, and let them fetch validated data. It will not, however, reread the trust anchor locators. Thus, if you update them, you will have to restart Routinator.\n\nYou can provide a number of addresses and ports to listen on for RTR and HTTP through command line options or their configuration file equivalent. Currently, Routinator will only start listening on these ports after an initial validation run has finished.\n\nIt will not listen on any sockets unless explicitly specified. It will still run and periodically update the repository. This might be useful for use with `vrps` mode with the `-n` option.\n\n- `d, --detach`\n If present, Routinator will detach from the terminal after a successful start.\n--rtr=addr:port\nSpecifies a local address and port to listen on for incoming RTR connections.\n\nRoutinator supports both protocol version 0 defined in RFC 6810 and version 1 defined in RFC 8210. However, it does not support router keys introduced in version 1. IPv6 addresses must be enclosed in square brackets. You can provide the option multiple times to let Routinator listen on multiple address-port pairs.\n\n--rtr-tls=addr:port\nSpecifies a local address and port to listen for incoming TLS-encrypted RTR connections.\n\nThe private key and server certificate given via the --rtr-tls-key and --rtr-tls-cert or their equivalent config file options will be used for connections.\n\nThe option can be given multiple times, but the same key and certificate will be used for all connections.\n\n--http=addr:port\nSpecifies the address and port to listen on for incoming HTTP connections. See HTTP SERVICE below for more information on the HTTP service provided by Routinator.\n\n--http-tls=addr:port\nSpecifies a local address and port to listen of for incoming TLS-encrypted HTTP connections.\n\nThe private key and server certificate given via the --http-tls-key and --http-tls-cert or their equivalent config file options will be used for connections.\n\nThe option can be given multiple times, but the same key and certificate will be used for all connections.\n\n--listen-systemd\nThe RTR listening socket will be acquired from systemd via socket activation. Use this option together with systemd’s socket units to allow a Routinator running as a regular user to bind to the default RTR port 323.\n\nCurrently, all TCP listener sockets handed over by systemd will be used for the RTR protocol.\n\n--rtr-tcp-keepalive=seconds\nThe number of seconds to wait before sending a TCP keepalive on an established RTR connection. By default, TCP keepalive is enabled on all RTR connections with an idle time of 60 seconds. Set this option to 0 to disable keepalives.\n\nOn some systems, notably OpenBSD, this option only enables TCP keepalives if set to any value other than 0. You will have to use the system’s own mechanisms to change the idle times.\n\n--rtr-client-metrics\nIf provided, the server metrics will include separate metrics for every RTR client. Clients are identified by their RTR source IP address. This is disabled by default to avoid accidentally leaking information about the local network topology.\n\n--rtr-tls-key\nSpecifies the path to a file containing the private key to be used for RTR-over-TLS connections. The file has to contain exactly one private key encoded in PEM format.\n\n--rtr-tls-cert\nSpecifies the path to a file containing the server certificates to be used for RTR-over-TLS connections. The file has to contain one or more certificates encoded in PEM format.\n\n--http-tls-key\nSpecifies the path to a file containing the private key to be used for HTTP-over-TLS connections. The file has to contain exactly one private key encoded in PEM format.\n--http-tls-cert\n Specifies the path to a file containing the server certificates to be used for HTTP-over-TLS connections. The file has to contain one or more certificates encoded in PEM format.\n\n--refresh=seconds\n The amount of seconds the server should wait after having finished updating and validating the local repository before starting to update again. The next update will be earlier if objects in the repository expire earlier. The default value is 600 seconds.\n\n--retry=seconds\n The amount of seconds to suggest to an RTR client to wait before trying to request data again if that failed. The default value is 600 seconds, as recommended in RFC 8210.\n\n--expire=seconds\n The amount of seconds to an RTR client can keep using data if it cannot refresh it. After that time, the client should discard the data. Note that this value was introduced in version 1 of the RTR protocol and is thus not relevant for clients that only implement version 0. The default value, as recommended in RFC 8210, is 7200 seconds.\n\n--history=count\n In RTR, a client can request to only receive the changes that happened since the last version of the data it had seen. This option sets how many change sets the server will at most keep. If a client requests changes from an older version, it will get the current full set.\n\n Note that routers typically stay connected with their RTR server and therefore really only ever need one single change set. Additionally, if RTR server or router are restarted, they will have a new session with new change sets and need to exchange a full data set, too. Thus, increasing the value probably only ever increases memory consumption.\n\n The default value is 10.\n\n--pid-file=path\n States a file which will be used in daemon mode to store the processes PID. While the process is running, it will keep the file locked.\n\n--working-dir=path\n The working directory for the daemon process. In daemon mode, Routinator will change to this directory while detaching from the terminal.\n\n--chroot=path\n The root directory for the daemon process. If this option is provided, the daemon process will change its root directory to the given directory. This will only work if all other paths provided via the configuration or command line options are under this directory.\n\n--user=user-name\n The name of the user to change to for server mode. If this option is provided, Routinator will run as that user after the listening sockets for HTTP and RTR have been created. This may cause problems, if the user is not allowed to write to the directory given as repository directory or is not allowed to read the TAL directory or local exception files.\n\n--group=group-name\n The name of the group to change to for server mode. If this option is provided, Routinator will run as that group after the listening sockets for HTTP and RTR have been created.\n\nupdate\n Updates the local repository by resyncing all known publication points. The command will also validate the updated repository to discover any new publication points that appear in the repository and fetch their data.\n\n As such, the command really is a shortcut for running routinator vrps -f none.\n--complete\nIf any of the rsync commands needed to update the repository failed, Routinator completes the operation and exits with status code 2. If this option is not given, the operation will complete with exit status 0 in this case.\n\ndump\nWrites the content of all stored data to the file system. This is primarily intended for debugging but can be used to get access to the view of the RPKI data that Routinator currently sees.\n\n-o dir, --output=dir\nWrite the output to the given directory. If the option is omitted, the current directory is used.\n\nThree directories will be created in the output directory:\nThe rrdp directory will contain all the files collected via RRDP from the various repositories. Each repository is stored in its own directory. The mapping between rpkiNotify URI and path is provided in the repositories.json file. For each repository, the files are stored in a directory structure based on the components of the file as rsync URI.\n\nThe rsync directory contains all the files collected via rsync. The files are stored in a directory structure based on the components of the file’s rsync URI.\n\nThe store directory contains all the files used for validation. Files collected via RRDP or rsync are copied to the store if they are correctly referenced by a valid manifest. This part contains one directory for each RRDP repository similarly structured to the rrdp directory and one additional directory rsync that contains files collected via rsync.\n\nman\nDisplays the manual page, i.e., this page.\n\n-o file, --output=file\nIf this option is provided, the manual page will be written to the given file instead of displaying it. Use -o to output the manual page to standard output.\n\n17.5 Configuration File\n\nInstead of providing all options on the command line, they can also be provided through a configuration file. Such a file can be selected through the -c option. If no configuration file is specified this way but a file named $HOME/.routinator.conf is present, this file is used.\n\nThe configuration file is a file in TOML format. In short, it consists of a sequence of key-value pairs, each on its own line. Strings are to be enclosed in double quotes. Lists can be given by enclosing a comma-separated list of values in square brackets.\n\nThe configuration file can contain the following entries. All path values are interpreted relative to the directory the configuration file is located in. All values can be overridden via the command line options.\n\nrepository-dir A string containing the path to the directory to store the local repository in. This entry is mandatory.\nno-rir-tals A boolean specifying whether the five RIR Trust Anchor Locators (TALs) should not be added to the set of evaluated TALs. If missing, the RIR TALs will be used.\ntals A list of strings, each containing the name of a bundled TAL to be added to the set of TALs to be evaluated.\nextra-tals-dir A string containing the path to a directory that contains additional TALs.\nextceptions A list of strings, each containing the path to a file with local exceptions. If missing, no local exception files are used.\nstrict A boolean specifying whether strict validation should be employed. If missing, strict validation will not be used.\nstale A string specifying the policy for dealing with stale objects.\n \nreject Consider all stale objects invalid rendering all material published by the CA issuing the stale object to be\n invalid including all material of any child CA. This is the default policy if the value is missing.\nwarn Consider stale objects to be valid but print a warning to the log.\naccept Quietly consider stale objects valid.\n\nunsafe-vrps A string specifying the policy for dealing with unsafe VRPs.\n \nreject Filter unsafe VRPs and add warning messages to the log.\nwarn Warn about unsafe VRPs in the log but add them to the final set of VRPs.\naccept Quietly add unsafe VRPs to the final set of VRPs. This is the default policy if the value is missing.\n\nunknown-objects A string specifying the policy for dealing with unknown RPKI object types.\n \nreject Reject the object and its issuing CA.\nwarn Warn about the object but ignore it and accept the issuing CA. This is the default policy if the value is\n missing.\naccept Quietly ignore the object and accept the issuing CA.\n\nlimit-v4-len An integer value which, if present, limits the length of IPv4 prefixes for which VPRs are included in the\n data set to the given value.\n\nlimit-v6-len An integer value which, if present, limits the length of IPv6 prefixes for which VPRs are included in the\n data set to the given value.\n\nallow-dubious-hosts A boolean value that, if present and true, disables Routinator’s filtering of dubious host names\n in rsync and HTTPS URIs from RPKI data.\n\ndisable-rsync A boolean value that, if present and true, turns off the use of rsync.\n\nrsync-command A string specifying the command to use for running rsync. The default is simply rsync.\n\nrsync-args A list of strings containing the arguments to be passed to the rsync command. Each string is an argument\n of its own.\n\nIf this option is not provided, Routinator will try to find out if your rsync understands the --contimeout option\nand, if so, will set it to 10 thus letting connection attempts time out after ten seconds. If your rsync is too old to\nsupport this option, no arguments are used.\n\nrsync-timeout An integer value specifying the number seconds an rsync command is allowed to run before it is being\n terminated. The default if the value is missing is 300 seconds. Set the value to 0 to turn the timeout off.\n\ndisable-rrdp A boolean value that, if present and true, turns off the use of RRDP.\n\nrrdp-fallback A string value specifying the circumstances under which an update via rsync is tried if an update via\n RRDP fails. See --rrdp-fallback for details on the available policies.\n\nrrdp-fallback-time An integer value specifying the maximum number of seconds since a last successful update of an\n RRDP repository before Routinator falls back to using rsync. The default in case the value is missing is 3600\n seconds. If the value provided is smaller than twice the refresh time, it is silently increased to that value.\n\nrrdp-max-delta-count An integer value that specifies the maximum number of deltas necessary to update an RRDP\n repository before using the snapshot instead. If the value is missing, the default of 100 is used.\n\nrrdp-timeout An integer value that provides a timeout in seconds for all individual RRDP-related network operations,\n i.e., connects, reads, and writes. If the value is missing, a default timeout of 300 seconds will be used. Set the\n value to 0 to turn the timeout off.\n**rrdp-connect-timeout** An integer value that, if present, sets a separate timeout in seconds for RRDP connect requests only.\n\n**rrdp-tcp-keepalive** An integer value that provides the duration in seconds for the TCP keepalive option on RRDP connections. If the value is missing, a duration of 60 seconds is used. Set the value to 0 to disable the use of TCP keepalive for RRDP connections.\n\n**rrdp-local-addr** A string value that provides the local address to be used by RRDP connections.\n\n**rrdp-root-certs** A list of strings each providing a path to a file containing a trust anchor certificate for HTTPS authentication of RRDP connections. In addition to the certificates provided via this option, the system’s own trust store is used.\n\n**rrdp-proxies** A list of string each providing the URI for a proxy for outgoing RRDP connections. The proxies are tried in order for each request. HTTP and SOCKS5 proxies are supported.\n\n**rrdp-keep-responses** A string containing a path to a directory into which the bodies of all HTTPS responses received from RRDP servers will be stored. The sub-path will be constructed using the components of the requested URI. For the responses to the notification files, the timestamp is appended to the path to make it possible to distinguish the series of requests made over time.\n\n**max-object-size** An integer value that provides a limit for the size of individual objects received via either rsync or RRDP to the given number of bytes. The default value if this option is not present is 20,000,000 (i.e., 20 MBytes). A value of 0 disables the limit.\n\n**max-ca-depth** An integer value that specifies the maximum number of CAs a given CA may be away from a trust anchor certificate before it is rejected. If the option is missing, a default of 32 will be used.\n\n**enable-bgpsec** A boolean value specifying whether BGPsec router keys should be included in the published dataset. If false or missing, no router keys will be included.\n\n**dirty** A boolean value which, if true, specifies that unused files and directories should not be deleted from the repository directory after each validation run. If left out, its value will be false and unused files will be deleted.\n\n**validation-threads** An integer value specifying the number of threads to be used during validation of the repository. If this value is missing, the number of CPUs in the system is used.\n\n**log-level** A string value specifying the maximum log level for which log messages should be emitted. The default is *warn*.\n\nSee [LOGGING](#) below for more information on what information is logged at the different levels.\n\n**log** A string specifying where to send log messages to. This can be one of the following values:\n\n- **default** Log messages will be sent to standard error if Routinator stays attached to the terminal or to syslog if it runs in daemon mode.\n- **stderr** Log messages will be sent to standard error.\n- **syslog** Log messages will be sent to syslog.\n- **file** Log messages will be sent to the file specified through the log-file configuration file entry.\n\nThe default if this value is missing is, unsurprisingly, *default*.\n\n**log-file** A string value containing the path to a file to which log messages will be appended if the log configuration value is set to file. In this case, the value is mandatory.\n\n**syslog-facility** A string value specifying the syslog facility to use for logging to syslog. The default value if this entry is missing is *daemon*.\n\n**rtr-listen** An array of string values each providing an address and port on which the RTR server should listen in TCP mode. Address and port should be separated by a colon. IPv6 address should be enclosed in square brackets.\nrtr-tls-listen An array of string values each providing an address and port on which the RTR server should listen in TLS mode. Address and port should be separated by a colon. IPv6 address should be enclosed in square brackets.\n\nhttp-listen An array of string values each providing an address and port on which the HTTP server should listen. Address and port should be separated by a colon. IPv6 address should be enclosed in square brackets.\n\nhttp-tls-listen An array of string values each providing an address and port on which the HTTP server should listen in TLS mode. Address and port should be separated by a colon. IPv6 address should be enclosed in square brackets.\n\nlisten-systemd The RTR TCP listening socket will be acquired from systemd via socket activation. Use this option together with systemd’s socket units to allow Routinator running as a regular user to bind to the default RTR port 323.\n\nrtr-tcp-keepalive An integer value specifying the number of seconds to wait before sending a TCP keepalive on an established RTR connection. If this option is missing, TCP keepalive will be enabled on all RTR connections with an idle time of 60 seconds. If this option is present and set to zero, TCP keepalives are disabled.\n\nOn some systems, notably OpenBSD, this option only enables TCP keepalives if set to any value other than 0. You will have to use the system’s own mechanisms to change the idle times.\n\nrtr-client-metrics A boolean value specifying whether server metrics should include separate metrics for every RTR client. If the value is missing, no RTR client metrics will be provided.\n\nrtr-tls-key A string value providing the path to a file containing the private key to be used by the RTR server in TLS mode. The file must contain one private key in PEM format.\n\nrtr-tls-cert A string value providing the path to a file containing the server certificates to be used by the RTR server in TLS mode. The file must contain one or more certificates in PEM format.\n\nhttp-tls-key A string value providing the path to a file containing the private key to be used by the HTTP server in TLS mode. The file must contain one private key in PEM format.\n\nhttp-tls-cert A string value providing the path to a file containing the server certificates to be used by the HTTP server in TLS mode. The file must contain one or more certificates in PEM format.\n\nrefresh An integer value specifying the number of seconds Routinator should wait between consecutive validation runs in server mode. The next validation run will happen earlier, if objects expire earlier. The default is 600 seconds.\n\nretry An integer value specifying the number of seconds an RTR client is requested to wait after it failed to receive a data set. The default is 600 seconds.\n\nexpire An integer value specifying the number of seconds an RTR client is requested to use a data set if it cannot get an update before throwing it away and continuing with no data at all. The default is 7200 seconds if it cannot get an update before throwing it away and continuing with no data at all. The default is 7200 seconds.\n\nhistory-size An integer value specifying how many change sets Routinator should keep in RTR server mode. The default is 10.\n\npid-file A string value containing a path pointing to the PID file to be used in daemon mode.\n\nworking-dir A string value containing a path to the working directory for the daemon process.\n\nchroot A string value containing the path any daemon process should use as its root directory.\n\nuser A string value containing the user name a daemon process should run as.\n\ngroup A string value containing the group name a daemon process should run as.\n\ntal-labels An array containing arrays of two string values mapping the name of a TAL file (without the path but including the extension) as given by the first string to the name of the TAL to be included where the TAL is referenced in output as given by the second string.\nIf the options missing or if a TAL isn’t mentioned in the option, Routinator will construct a name for the TAL by using its file name (without the path) and dropping the extension.\n\n17.6 HTTP Service\n\nRoutinator can provide an HTTP service allowing to fetch the Validated ROA Payload in various formats. The service does not support HTTPS and should only be used within the local network.\n\nThe service only supports GET requests with the following paths:\n\n- **/metrics**\n Returns a set of monitoring metrics in the format used by Prometheus.\n\n- **/status**\n Returns the current status of the Routinator instance. This is similar to the output of the /metrics endpoint but in a more human friendly format.\n\n- **/api/v1/status**\n Returns the current status in JSON format.\n\n- **/log**\n Returns the logging output of the last validation run. The log level matches that set upon start.\n\n Note that the output is collected after each validation run and is therefore only available after the initial run has concluded.\n\n- **/version**\n Returns the version of the Routinator instance.\n\n- **/api/v1/validity/as-number/prefix**\n Returns a JSON object describing whether the route announcement given by its origin AS Number and address prefix is RPKI valid, invalid, or not found. The returned object is compatible with that provided by the RIPE NCC RPKI Validator. For more information, see [https://ripe.net/support/documentation/developer-documentation/rpki-validator-api](https://ripe.net/support/documentation/developer-documentation/rpki-validator-api)\n\n- **/validity?asn=as-number&prefix=prefix**\n Same as above but with a more form-friendly calling convention.\n\n- **/json-delta, /json-delta?session=session&serial=serial**\n Returns a JSON object with the changes since the dataset version identified by the session and serial query parameters. If a delta cannot be produced from that version, the full data set is returned and the member reset in the object will be set to true. In either case, the members session and serial identify the version of the data set returned and their values should be passed as the query parameters in a future request.\n\n The members announced and withdrawn contain arrays with route origins that have been announced and withdrawn, respectively, since the provided session and serial. If reset is true, the withdrawn member is not present.\n\nIn addition, the current set of VRPs is available for each output format at a path with the same name as the output format. E.g., the CSV output is available at /csv.\n\nThese paths accept selector expressions to limit the VRPs returned in the form of a query string. The field select-asn can be used to filter for ASNs and the field select-prefix can be used to filter for prefixes. The fields can be repeated multiple times.\n\nIn addition, the query parameter include=more-specifics will cause the inclusion of VRPs for more specific prefixes of prefixes given via select-prefix.\n\nThese parameters work in the same way as the options of the same name to the vrps command.\n17.7 Logging\n\nIn order to allow diagnosis of the VRP data set as well as its overall health, Routinator logs an extensive amount of information. The log levels used by syslog are utilized to allow filtering this information for particular use cases.\n\nThe log levels represent the following information:\n\n- **error** Information related to events that prevent Routinator from continuing to operate at all as well as all issues related to local configuration even if Routinator will continue to run.\n- **warn** Information about events and data that influences the set of VRPs produced by Routinator. This includes failures to communicate with repository servers, or encountering invalid objects.\n- **info** Information about events and data that could be considered abnormal but do not influence the set of VRPs produced. For example, when filtering of unsafe VRPs is disabled, the unsafe VRPs are logged with this level.\n- **debug** Information about the internal state of Routinator that may be useful for, well, debugging.\n\n17.8 Validation\n\nIn vrps and server mode, Routinator will produce a set of VRPs from the data published in the RPKI repository. It will walk over all certification authorities (CAs) starting with those referred to in the configured TALs.\n\nEach CA is checked whether all its published objects are present, correctly encoded, and have been signed by the CA. If any of the objects fail this check, the entire CA will be rejected. If an object of an unknown type is encountered, the behaviour depends on the unknown-objects policy. If this policy has a value of reject the entire CA will be rejected. In this case, only certificates (.cer), CRLs (.crl), manifests (.mft), ROAs (.roa), and Ghostbuster records (.gbr) will be accepted.\n\nIf a CA is rejected, none of its ROAs will be added to the VRP set but also none of its child CAs will be considered at all; their published data will not be fetched or validated.\n\nIf a prefix has its ROAs published by different CAs, this will lead to some of its VRPs being dropped while others are still added. If the VRP for the legitimately announced route is among those having been dropped, the route becomes RPKI invalid. This can happen both by operator error or through an active attack.\n\nIn addition, if a VRP for a less specific prefix exists that covers the prefix of the dropped VRP, the route will be invalidated by the less specific VRP.\n\nBecause of this risk of accidentally or maliciously invalidating routes, VRPs that have address prefixes overlapping with resources of rejected CAs are called unsafe VRPs.\n\nIn order to avoid these situations and instead fall back to an RPKI unknown state for such routes, Routinator allows to filter out these unsafe VRPs. This can be enabled via the --unsafe-vrps=reject command line option or setting unsafe-vrps=reject in the config file.\n\nBy default, this filter is currently disabled but warnings are logged about unsafe VRPs. This allows to assess the operation impact of such a filter. Depending on this assessment, the default may change in future versions.\n\nOne exception from this rule are CAs that have the full address space assigned, i.e., 0.0.0.0/0 and ::/0. Adding these to the filter would wipe out all VRPs. These prefixes are used by the RIR trust anchors to avoid having to update these often. However, each RIR has its own address space so losing all VRPs should something happen to a trust anchor is unnecessary.\n17.9 Relaxed Decoding\n\nThe documents defining RPKI include a number of very strict rules regarding the formatting of the objects published in the RPKI repository. However, because RPKI reuses existing technology, real-world applications produce objects that do not follow these strict requirements.\n\nAs a consequence, a significant portion of the RPKI repository is actually invalid if the rules are followed. We therefore introduce two decoding modes: strict and relaxed. Strict mode rejects any object that does not pass all checks laid out by the relevant RFCs. Relaxed mode ignores a number of these checks.\n\nThis memo documents the violations we encountered and are dealing with in relaxed decoding mode.\n\n**Resource Certificates (RFC 6487)** Resource certificates are defined as a profile on the more general Internet PKI certificates defined in RFC 5280.\n\n**Subject and Issuer** The RFC restricts the type used for CommonName attributes to PrintableString, allowing only a subset of ASCII characters, while RFC 5280 allows a number of additional string types. At least one CA produces resource certificates with Utf8Strings.\n\nIn relaxed mode, we will only check that the general structure of the issuer and subject fields are correct and allow any number and types of attributes. This seems justified since RPKI explicitly does not use these fields.\n\n**Signed Objects (RFC 6488)** Signed objects are defined as a profile on CMS messages defined in RFC 5652.\n\n**DER Encoding** RFC 6488 demands all signed objects to be DER encoded while the more general CMS format allows any BER encoding – DER is a stricter subset of the more general BER. At least one CA does indeed produce BER encoded signed objects.\n\nIn relaxed mode, we will allow BER encoding.\n\nNote that this isn’t just nit-picking. In BER encoding, octet strings can be broken up into a sequence of sub-strings. Since those strings are in some places used to carry encoded content themselves, such an encoding does make parsing significantly more difficult. At least one CA does produce such broken-up strings.\n\n17.10 Signals\n\n**SIGUSR1: Reload TALs and restart validation** When receiving SIGUSR1, Routinator will attempt to reload the TALs and, if that succeeds, restart validation. If loading the TALs fails, Routinator will exit.\n\n17.11 Exit Status\n\nUpon success, the exit status 0 is returned. If any fatal error happens, the exit status will be 1. Some commands provide a `--complete` option which will cause the exit status to be 2 if any of the rsync commands to update the repository fail.\nRoutinator’s monitoring service provides comprehensive metrics in JSON format /api/v1/status endpoint. Here you can find an overview of all metrics and their meaning.\n\nThe JSON metrics consists of an object with the following members:\n\n- **version** The version of Routinator.\n- **serial** The current serial number for data served to RTR clients.\n- **now** The date and time in UTC when this report was created.\n- **lastUpdateStart** The date and time in UTC when the last validation run started.\n- **lastUpdateDone** The date and time in UTC when the last validation run completed.\n- **lastUpdateDuration** The duration of the last validation run in seconds.\n- **tals** Metrics for each configured trust anchor. In most cases these will be the five Regional Internet Registries, but will include the trust anchors of any configured testbeds as well.\n\n Each element of this object contains a publication metrics value as described below.\n\n- **repositories** Metrics for each repository encountered during validation. Note that the data given here relates to the repository content used during validation. If the repository failed to update, then these numbers are from the stored old data.\n\n Each element of this object contains a publication metrics value as described below. In addition, there is a member type that describes whether the repository is an RRDP or rsync repository.\n\n- **vrpsAddedLocally** The number of VRPs added to the final data set from local exceptions.\n\n- **rsync** Metrics for updates via rsync.\n\n This is an object with one element for each repository that was updated via rsync during the last validation run. Each element contains an rsync update metrics value as described below.\n\n- **rrdp** Metrics for updates via RRDP.\n\n This is an object with one element for each repository that was updated via rsync during the last validation run. Each element contains an RRDP update metrics value as described below.\n\n- **rtr** Metrics for the built-in RTR server. See RTR metrics below.\n\n- **http** Metrics for the built-in HTTP server. See HTTP metrics below.\n18.1 Publication Metrics\n\nPublication metrics are provided both for all trust anchors and for each RPKI repository. They contain the following information:\n\n- **vrpsTotal** The total number of VRPs found to be present and valid.\n- **vrpsUnsafe** The number of VRPs that are considered unsafe. Depending on configuration, these may be included in the final set or dropped from it.\n- **vrpsLocallyFiltered** The number of VRPs that are filtered as the result of a local exception.\n- **vrpsDuplicate** The number of duplicate VRPs resulting from ROAs containing the same authorisation.\n \n Note that if a VRP appears in multiple trust anchors or repositories, which occurrence is considered the duplicate depends on the order of processing which may change between validation runs. Thus, this number may change unexpectedly.\n- **vrpsFinal** The number of VRPs that are contributed by this trust anchor or repository to the final set provided to your routers. This is the total number of VRPs, minus the ones that are locally filtered, duplicate, and, if configured to be dropped, unsafe.\n- **validPublicationPoints** The number of valid publication points.\n- **rejectedPublicationPoints** The number of rejected publication points.\n \n A publication point is rejected if its manifest is invalid or if any objects listed on the manifest are missing or have a different content hash.\n- **validManifests** The number of valid manifests.\n- **invalidManifests** The number of invalid manifests.\n \n A manifest is invalid if it is not correctly encoded, has expired or is not correctly signed by the issuing CA.\n- **staleManifests** The number of stale manifests.\n \n A manifest is stale if the current time is past the time an update to the manifest should have been issued. Whether a stale manifest is valid or invalid depends on configuration. By default it is considered invalid.\n- **missingManifests** The number of missing manifests.\n- **validCRLs** The number of valid certificate revocation lists.\n- **invalidCRLs** The number of invalid certificate revocation lists.\n \n A CRL is invalid if it is not correctly encoded or is not correctly signed by the issuing CA.\n- **staleCRLs** The number of stale certificate revocation lists.\n \n A CRL is stale if the current time is past the time an update should have been issued. Whether a stale CRL is valid or invalid depends on configuration. By default it is considered invalid.\n- **strayCRLs** The number of stray certificate revocation lists.\n \n Each CA should only issue one CRL. This CRL should both be listed on the manifest and used by the manifest’s certificate itself. Any manifest listed on the manifest that is not also the manifest’s own CRL is considered a stray.\n- **validCACerts** The number of Certificate Authority (CA) certificates found to be present and valid.\n- **validEECerts** The number of End Entity (EE) certificates found to be present and valid.\n \n This only refers to such certificates included as stand-alone files which are BGPsec router certificates.\n- **invalidCerts** The number of invalid stand-alone certificates, either CA or EE certificates.\nvalidROAs The number of valid Route Origin Attestations.\ninvalidROAs The number of invalid Route Origin Attestations.\nvalidGBRs The number of valid Ghostbusters Records.\nInvalidGBRs The number of invalid Ghostbusters Records.\notherObjects The number of objects found that are not certificates (.cer), Certificate Revocation Lists (.crl), manifests (.mft), ROAs (.roa), or Ghostbuster Records (.gbr).\n\n18.2 Rsync Update Metrics\n\nFor each repository updated via rsync the following values are given.\n\nstatus The status code returned by the rsync process. A value of 0 means the process has finished successfully. The meaning of other values depends on the rsync client used. Please refer to its documentation for further details.\nduration The duration the rsync process was running in seconds.\n\n18.3 RRDP Update Metrics\n\nFor each repository updated via RRDP the following values are given.\n\nstatus The overall status of the update. This will be 200 if the updated succeeded, 304 if no update was necessary because the data was already current, and any other value for a failed update. If the value is -1, it was not possible to reach the HTTPS server at all.\nnotifyStatus The status of retrieving the notification file. This is the first step of an RRDP update. A value of 200 indicates that the file was successfully retrieved. A value of 304 indicates that the file hasn’t changed since last update and no actual update is necessary. Any other value represents an error.\npayloadStatus The status of retrieving the actual payload. This is the second step of an RRDP update and may either represent a single HTTPS request for the snapshot file or a series of HTTPS request for the sequence of delta files necessary to update from the last known state.\n A value of 0 means that no payload retrieval was necessary. A value of 200 means that the update was successful. Any other value indicates an error. In case of a sequence of delta updates, this error may have been preceded by one or more successful requests.\nduration The overall duration of the RRDP update in seconds.\nserial The serial number stated by the RRDP server for the current data set. With each update the serial number is increased by one.\nsession The identifier of the current session of the RRDP server. Serial numbers are only valid within the same session. If the server needs to restart its sequence for whatever reason, it needs to choose a new session ID and all data will have to be updated through a snapshot.\ndelta Whether data was updated via a sequence of deltas (true) or a full snapshot had to be retrieved (false).\nn snapshotReason If this is not null, it provides a reason why a snapshot was used instead of a delta as a short explanatory string.\n18.4 RTR Server Metrics\n\nA number of metrics are provided describing the state of the included RTR server. These metrics are available whether the RTR server is actually enabled or not.\n\n- **currentConnections** The number of currently open RTR connections.\n- **bytesRead** The total number of bytes read from RTR connections. In other words, describes how much data has been sent by clients.\n- **bytesWritten** The total number of bytes written to RTR connections. In other words, describes how much data has been sent to clients.\n\nIf `rtr-client-metrics` are enabled via configuration or command line, an additional object `clients` will appear that list the IP addresses of clients seen by the RTR server providing the following information for them.\n\n- **connections** The number of currently open connections from that address. The number should normally be 0 or 1 but can be higher if the address is the public side of a NAT.\n- **updated** Contains the time of the last successful update by the client.\n- **lastReset** Contains the time of the last successful cache reset by the client.\n- **resetQueries** Contains the number of reset queries by the client.\n- **serialQueries** Contains the number of serial queries by the client.\n- **serial** The highest serial of the data provided to a client from that address. This can be used to determine when the client has last updated.\n- **read and written** Bytes read from and written to clients from that address.\n\n18.5 HTTP Server Metrics\n\nA number of metrics are provided describing the state of the included HTTP server.\n\n- **totalConnections** The total number of connections made with the HTTP server.\n- **currentConnections** The number of currently open connections. This should at least be 1 as there is a connection open when requesting the JSON metrics.\n- **requests** The total number of requests received and answered by the HTTP server.\n- **bytesRead and bytesWritten** The number of bytes read from and written to HTTP clients.\nRoutinator’s monitoring service provides comprehensive metrics in Prometheus format at the /metrics endpoint. Here you can find an overview of all metrics and their meaning.\n\n**routinator_last_update_start** Seconds since the start of the last update.\n\n**routinator_last_update_duration** Duration of the last update in seconds.\n\n**routinator_last_update_done** Seconds since the end of the last update.\n\n**routinator_serial** The current serial number for data served to RTR clients.\n\n### 19.1 Publication Metrics\n\nPublication metrics are provided for all trust anchors and for each RPKI repository.\n\nAll metrics for trust anchors have a label **name**, named after the Trust Anchor Locator file name without the .tal extension, e.g. **arin**. All metrics for repositories have a label **uri** specifying the URI of the notification file of the RRDP repository, or the base URI of the rsync repository.\n\n**routinator_{ta,repository}_publication_points_total** The number of publication points per trust anchor. In most cases these will be the five Regional Internet Registries, but will include the trust anchors of any configured testbeds as well.\n\nThis metric has two labels: either **name** or **uri**, followed by the **state** which is **valid** or **rejected**.\n\n**routinator_{ta,repository}_objects_total** Metrics for each configured trust anchor. In most cases these will be the five Regional Internet Registries, but will include the trust anchors of any configured testbeds as well.\n\nThis metric has three labels: either **name** or **uri**, followed by **type** for the type of object, e.g. **crl**, and lastly **state** describing its validity state, such as **valid** or **stale**.\n\nThe types and states of objects can be:\n\n- **manifest** - The number of manifests for each of the states valid, invalid, stale and missing. A manifest is invalid if it is not correctly encoded, has expired or is not correctly signed by the issuing CA. It is considered stale if the current time is past the time an update to the manifest should have been issued. Whether a stale manifest is valid or invalid depends on configuration. By default a stale manifest is considered invalid.\n\n- **crl** - The number of certificate revocation lists for each of the states valid, invalid, stale and stray. A CRL is invalid if it is not correctly encoded or is not correctly signed by the issuing CA. It is considered stale if the current time is past the time an update to the manifest should have been issued. Whether a stale manifest is valid or invalid depends on configuration. By default a stale CRL is considered invalid. Lastly, each CA should only issue one CRL. This CRL should both be listed on the manifest.\nand used by the manifest’s certificate itself. Any manifest listed on the manifest that is not also the manifest’s own CRL is considered a stray.\n\n- **ca_cert** - The number of Certificate Authority (CA) certificates with the state *valid*.\n- **router_cert** - The number of End Entity (EE) certificates found to be present and *valid*. This only refers to such certificates included as stand-alone files which are BGPsec router certificates.\n- **roa** - The number of *Route Origin Attestations* for each of the states *valid* and *invalid*.\n- **gbr** - The number of *Ghostbusters Records* for each of the states *valid* and *invalid*. Note that currently the content of a Ghostbuster Record is not checked.\n- **other** - The number of objects found that are not certificates (.cer), Certificate Revocation Lists (.crl), manifests (.mft), ROAs (.roa), or Ghostbuster Records (.gbr) and have the state *invalid*.\n\nThe following metrics all have just one label, either name in case of a trust anchor or uri for repositories:\n\n- **routinator_{ta,repository}_valid_vrps_total** The number of *VRPs* found to be present and valid.\n- **routinator_{ta,repository}_unsafe_vrps_total** The number of *VRPs* found to be *unsafe*.\n- **routinator_{ta,repository}_locally_filtered_vrps_total** The number of *VRPs* that are filtered as the result of a *local exception*.\n- **routinator_{ta,repository}_duplicate_vrps_total** The number of duplicate *VRPs* resulting from ROAs containing the same authorisation.\n\n Note that if a VRP appears in multiple trust anchors or repositories, which occurrence is considered the duplicate depends on the order of processing which may change between validation runs. Thus, this number may change unexpectedly.\n\n- **routinator_{ta,repository}_contributed_vrps_total** The number of *VRPs* that are contributed by this trust anchor or repository to the final set provided to your routers. This is the total number of VRPs, minus the ones that are locally filtered, duplicate, and, if configured to be dropped, unsafe.\n\n### 19.2 Rsync Update Metrics\n\nFor each repository updated via rsync the following values are given.\n\n- **routinator_rsync_status** The status code returned by the rsync process. A value of 0 means the process has finished successfully. The meaning of other values depends on the rsync client used. Please refer to its documentation for further details.\n\n- **routinator_rsync_duration** The duration the rsync process was running in seconds.\n\n### 19.3 RRDP Update Metrics\n\nFor each repository updated via RRDP the following values are given. All metrics have a label *uri* specifying the URI of the notification file of the RRDP repository.\n\n- **routinator_rrdp_status** The overall status of the update. This will be 200 if the updated succeeded, 304 if no update was necessary because the data was already current, and any other value for a failed update. If the value is -1, it was not possible to reach the HTTPS server at all.\n\n- **routinator_rrdp_notification_status** The status of retrieving the notification file. This is the first step of an RRDP update. A value of 200 indicates that the file was successfully retrieved. A value of 304 indicates that the file hasn’t changed since last update and no actual update is necessary. Any other value represents an error.\n**routinator_rrdp_payload_status** The status of retrieving the actual payload. This is the second step of an RRDP update and may either represent a single HTTPS request for the snapshot file or a series of HTTPS requests for the sequence of delta files necessary to update from the last known state.\n\nA value of 0 means that no payload retrieval was necessary. A value of 200 means that the update was successful. Any other value indicates an error. In case of a sequence of delta updates, this error may have been preceded by one or more successful requests.\n\n**routinator_rrdp_duration** The overall duration of the RRDP update in seconds.\n\n**routinator_rrdp_serial_info** The serial number stated by the RRDP server for the current data set. With each update the serial number is increased by one.\n\n### 19.4 RTR Server Metrics\n\nA number of metrics are provided describing the state of the included RTR server. These metrics are available whether the RTR server is actually enabled or not.\n\n**routinator_rtr_current_connections** The number of currently open RTR connections.\n\n**routinator_rtr_bytes_read** The total number of bytes read from RTR connections. In other words, describes how much data has been sent by clients.\n\n**routinator_rtr_bytes_written** The total number of bytes written to RTR connections. In other words, describes how much data has been sent to clients.\n\n**routinator_rtr_client_last_reset_seconds** The amount of seconds since last cache reset by a client address.\n\n**routinator_rtr_client_reset_queries** The number of reset queries by a client address.\n\n**routinator_rtr_client_serial_queries** The number of serial queries by a client address.\n\nNew in version 0.12.0: **routinator_rtr_client_last_reset_seconds**, **routinator_rtr_client_reset_queries** and **routinator_rtr_client_serial_queries**\n\n### 19.5 HTTP Server Metrics\n\nA number of metrics are provided describing the state of the included HTTP server.\n\n**routinator_http_connections** The total number of connections made with the HTTP server.\n\n**routinator_http_current_connections** The number of currently open connections. This should at least be 1 as there is a connection open when requesting the JSON metrics.\n\n**requests** The total number of requests received and answered by the HTTP server.\n\n**routinator_http_bytes_read** and **routinator_http_bytes_written** The number of bytes read from and written to HTTP clients.\nRoutinator is unique among relying party software in its ability to alert operators to a subtle condition we refer to as “Unsafe VRPs”. We will explore that concept here.\n\nIf the address prefix of a Validated ROA Payload (VRP) overlaps with any resources assigned to a Certification Authority (CA) that has been rejected because it failed to validate completely, the VRP is said to be unsafe since using it may lead to legitimate routes being flagged as RPKI Invalid.\n\nIn the Hosted RPKI systems that the five Regional Internet Registries offer, all certificates and ROAs reside within a single system and all related objects are published in a single repository. In addition, these systems do not allow sub-delegation of resources. As a result, relying party software will normally fetch and validate the entire set of objects, or in case of an outage nothing at all. This makes the occurrence of unsafe VRPs highly unlikely.\n\nWhen an organisation runs RPKI with their own CA, they can delegate a subset of their resources to another party, such as their customer, who in turn runs their own CA. Both parties can publish in a repository they host themselves, or one that is offered by a third party as a service. Because there are now more variables at play, such as broken CAs or unavailable repositories, there is a possibility of unsafe VRPs emerging.\n\nUnsafe VRPs typically occur when the organisation that holds the superset of resources publishes a ROA for their aggregate prefix, e.g. 2001:db8::/32-32, and the customer publishes a ROA to authorise a more specific, e.g. 2001:db8:abcd:/48-48. Now, when the customer CA is unavailable for any reason and validation fails, the VRP for 2001:db8:abcd:/48 will be marked as unsafe. Note that the reason for the unavailability can be that the CA itself is broken, or because the repository that hosts the ROA is unavailable for a prolonged period.\n\nRoutinator has an --unsafe-vrps option that specifies how to deal with unsafe resources when conditions creating unsafe VRPs exist. Currently, the default policy is to accept unsafe VRPs. This means VRPs will not be analysed for being unsafe at all, nor will any metrics be generated. The other options are warn, which will report any unsafe VRP that was encountered and reject, filtering out VRPs that are marked as unsafe. For the latter two options metrics are made available.\nRoutinator offers several advanced features to let operators gain operational experience with some of the ongoing work in the Internet Engineering Task Force to improve and augment RPKI.\n\n### 21.1 Resource Tagged Attestations\n\nResource Tagged Attestations (RTAs) allow any arbitrary file to be signed ‘with resources’ by one or more parties. The RTA object is a separate file that cryptographically connects the document with a set of resources. The receiver of the object can use Routinator to show these resources, and verify that it was created by their rightful holder(s).\n\nOne practical example where RTA could be valuable is to authorise a Bring Your Own IP (BYOIP) process, where you bring part or all of your publicly routable IPv4 or IPv6 address range from your on-premises network to a cloud provider. The document authorising BYOIP could be signed using RTA.\n\nRTA objects can be generated using Krill, the RPKI Certificate Authority software from NLnet Labs, and you can use the MyAPNIC hosted service. The objects can be validated using Routinator if it is built with RTA support, using the `features` functionality provided by Cargo:\n\n```bash\ncargo install --locked --features rta routinator\n```\n\nYou can now interactively validate an RTA signed object. If it is valid, Routinator will report the resources used to sign the object:\n\n```bash\nroutinator rta acme-corp-byoip.rta\n```\n\n```\n192.0.2.0/24\n203.0.113.0/24\n2001:db8::/48\n```\n\nSee also:\n\n- A profile for Resource Tagged Attestations (RTAs)\n- Moving RPKI Beyond Routing Security\n- A proof-of-concept for constructing and validating RTAs\n\nNew in version 0.8.0.\n21.2 BGPsec\n\nThe goal of BGPsec, as described in RFC 8209, is to provide full AS path validation. For this operators will need to publish BGPsec router keys in the RPKI. As there is currently very limited deployment, validating these objects with Routinator is not enabled by default.\n\nYou can let Routinator process router keys and include them in the published dataset, as well as the metrics, using the `--enable-bgpsec` option or by setting `enable-bgpsec` to True in the configuration file. BGPsec information will be exposed via RTR, as well as in the `SLURM` and `jsonext` output format, e.g.:\n\n```json\n{\n \"metadata\": {\n \"generated\": 1626853335,\n \"generatedTime\": \"2021-07-21T07:42:15Z\"\n },\n \"roas\": [{\n \"asn\": \"AS196615\",\n \"prefix\": \"93.175.147.0/24\",\n \"maxLength\": 24,\n \"source\": {\n \"type\": \"roa\",\n \"uri\": \"rsync://rpki.ripe.net/repository/DEFAULT/73/fe2d72-c2dd-46c1-9429-e6639649411/1/49sMtCwyAuAW21VDSQBGbOHd9og.roa\",\n \"validity\": {\n \"notBefore\": \"2021-01-01T04:39:56Z\",\n \"notAfter\": \"2022-07-01T00:00:00Z\"\n },\n \"chainValidity\": {\n \"notBefore\": \"2021-05-06T12:51:30Z\",\n \"notAfter\": \"2022-07-01T00:00:00Z\"\n }\n }\n },\n \"routerKeys\": [{\n \"asn\": \"AS65535\",\n \"SKI\": \"E2F075EC50E9F2EFCED81D44491D25D42A298D89\",\n \"routerPublicKey\": \"kwEwYHKoZIzj0CAtig5-QfEKPtTfgiqfiiAFQg--LAQerAH2Mpp-GucoDAG8hIlqMFQYIKoZIzj0DAQcDQgAEgFcjQ_D33wNPsXxnAGb--mtZ7XQrV09DQ6U1ASh\",\n \"source\": {\n \"type\": \"roa\",\n \"uri\": \"rsync://acmecorp.example.net/rpki/RIPE-NLACMECORP/R0tgREopjYdyeI-wXUJQ4p786.cer\",\n \"validity\": {\n \"notBefore\": \"2021-11-09T17:04:40Z\",\n \"notAfter\": \"2022-11-09T17:04:39Z\"\n },\n \"chainValidity\": {\n \"notBefore\": \"2022-01-16T14:45:51Z\",\n \"notAfter\": \"2022-08-06T00:00:00Z\"\n }\n }\n }\n}]\n```\nNew in version 0.11.0.\nCertificate Revocation List (CRL) A list of digital certificates that have been revoked by the issuing Certificate Authority (CA) before their scheduled expiration date and should no longer be trusted. Each entry in a Certificate Revocation List includes the serial number of the revoked certificate and the revocation date. The CRL file is signed by the CA to prevent tampering. The RPKI CRL profile is defined in RFC 6487.\n\nGhostbusters Record (GBR) An RPKI object described in RFC 6493 that contains human contact information that may be verified (indirectly) by a CA certificate. The data in the record are those of a severely profiled vCard. Note that support for publication of GBR records is not widely implemented yet. As a result, Routinator will validate the object, but not produce any output for it.\n\nManifest A manifest is a signed object that contains a listing of all the signed objects in the repository publication point associated with an authority responsible for publishing in the repository. Refer to RFC 6486 for more information.\n\nMaximum Prefix Length (MaxLength) The most specific announcement of an IP prefix an Autonomous System is authorised to do according to the published ROA.\n\nPublication Point A directory within a repository that contains all the objects published by a single CA.\n\nRepository The RPKI repository system consists of multiple distributed and delegated repository publication points. Each repository publication point is associated with one or more RPKI certificates’ publication points.\n\nResource Public Key Infrastructure (RPKI) RPKI proves the association between specific IP address blocks or Autonomous System Numbers (ASNs) and the holders of those Internet number resources. The certificates are proof of the resource holder’s right of use of their resources and can be validated cryptographically. RPKI is based on an X.509 certificate profile defined in RFC 3779. Using RPKI to support secure Internet routing is described in RFC 6480.\n\nRoute Origin Attestation (ROA) A cryptographically signed object that contains a statement authorising a single Autonomous System Number (ASN) to originate one or more IP prefixes, along with their maximum prefix length. A ROA can only be created by the legitimate holder of the IP prefixes contained within it.\n\nRoute Origin Validation (ROV) A mechanism by which route advertisements can be authenticated as originating from an expected, authorised Autonomous System (AS).\n\nRPKI Relying Parties Those who want to use a Public Key Infrastructure (PKI) to validate digitally signed attestations.\n\nRPKI Repository Delta Protocol (RRDP) Described in RFC 8182, RRDP is a repository access protocol based on Update Notification, Snapshot, and Delta Files that a Relying Party can retrieve over the HTTPS protocol.\n\nRPKI-to-Router (RPKI-RTR) The RPKI to Router protocol provides a simple but reliable mechanism for routers to receive RPKI prefix origin data from a trusted cache. It is standardised in RFC 6810 (v0) and RFC 8210 (v1).\n\nStale Object In RPKI, manifests and CRLs can be stale if the time given in their next-update field is in the past, indicating that an update to the object was scheduled but didn’t happen. This can be because of an operational issue at the issuer or an attacker trying to replay old objects.\nTrust Anchor (TA) Each of the five Regional Internet Registries (RIRs) publishes a trust anchor that includes all resources (a ‘0/0’ self-signed X.509 CA certificate). They issue a child certificate containing all the resources that are held and managed by the RIR.\n\nTrust Anchor Locator (TAL) The Trust Anchor Locator (TAL) is used to retrieve and verify the authenticity of a trust anchor. Specified in RFC 8630, a TAL contains one or more URIs pointing to the RIR root certificate, as well as the public key of the trust anchor in DER format, encoded in Base64. The TAL is constant so long as the trust anchor’s public key and its location do not change.\n\nUnsafe VRPs If the address prefix of a VRP overlaps with any resources assigned to a CA that has been rejected because if failed to validate completely, the VRP is said to be unsafe since using it may lead to legitimate routes being flagged as RPKI Invalid.\n\nValidated ROA Payload (VRP) RPKI Relying Party software performs cryptographic verification on all published ROAs. If everything checks out, the software will produce one or more validated ROA payloads (VRPs) for each ROA, depending on how many IP prefixes are contained with in it. Each VRP is a tuple of an ASN, a single prefix and its maximum prefix length. If verification fails, the ROA is discarded and it’ll be like no statement was ever made.\nSymbols\n\n-v command line option, 71\n--allow-dubious-hosts command line option, 69\n--asn=asn command line option, 74\n--chroot=path command line option, 76\n--complete command line option, 73, 74, 76\n--config=path command line option, 67\n--detach command line option, 74\n--dirty command line option, 71\n--disable-rrdp command line option, 69\n--disable-rsync command line option, 69\n--enable-bgpsec command line option, 71\n--exceptions=file command line option, 68\n--expire=seconds command line option, 76\n--extra-tals-dir=dir command line option, 68\n--format=format command line option, 71\n--fresh command line option, 69\n--group=group-name command line option, 76\n--help command line option, 71\n--history=count command line option, 76\n--http=addr:port command line option, 75\n--http-tls=addr:port command line option, 75\n--http-tls-cert command line option, 75\n--http-tls-key command line option, 75\n--input=file command line option, 74\n--json command line option, 74\n--limit-v4-len=length command line option, 69\n--limit-v6-len=length command line option, 69\n--listen-systemd command line option, 75\n--logfile=path command line option, 71\n--max-ca-depth=count command line option, 70\n--max-object-size=BYTES command line option, 70\n--more-specifics command line option, 73\n--no-rir-tals command line option, 67\n--noupdate command line option, 73, 74\n--output=dir command line option, 77\n--output=file command line option, 71, 74, 77\n--pid-file=path command line option, 76\n--prefix=prefix command line option, 74\n--quiet command line option, 71\n--refresh=seconds command line option, 76\n--repository-dir=dir command line option, 67\n--retry=seconds command line option, 75\ncommand line option, 76\n--rrdp-connect-timeout=seconds\ncommand line option, 70\n--rrdp-fallback=policy\ncommand line option, 69\n--rrdp-fallback-time=seconds\ncommand line option, 70\n--rrdp-keep-responses=path\ncommand line option, 70\n--rrdp-local-addr=addr\ncommand line option, 70\n--rrdp-max-delta-count=count\ncommand line option, 70\n--rrdp-proxy=uri\ncommand line option, 70\n--rrdp-root-cert=path\ncommand line option, 70\n--rrdp-tcp-keepalive=seconds\ncommand line option, 70\n--rrdp-timeout=seconds\ncommand line option, 70\n--rsync-command=command\ncommand line option, 69\n--rsync-timeout=seconds\ncommand line option, 69\n--rtr=addr:port\ncommand line option, 74\n--rtr-client-metrics\ncommand line option, 75\n--rtr-tcp-keepalive=seconds\ncommand line option, 75\n--rtr-tls-addr:port\ncommand line option, 75\n--rtr-tls-cert\ncommand line option, 75\n--rtr-tls-key\ncommand line option, 75\n--select-asn=asn\ncommand line option, 73\n--select-prefix=prefix\ncommand line option, 73\n--stale=policy\ncommand line option, 68\n--strict\ncommand line option, 68\n--syslog\ncommand line option, 71\n--syslog-facility=facility\ncommand line option, 71\n--tal=name\ncommand line option, 68\n--unknown-objects=policy\ncommand line option, 69\n--unsafe-vrps=policy\ncommand line option, 69\n--user=user-name\ncommand line option, 76\n--validation-threads=count\ncommand line option, 71\n--verbose\ncommand line option, 71\n--version\ncommand line option, 71\n--working-dir=path\ncommand line option, 76\n-a as\ncommand line option, 73, 74\n-c path\ncommand line option, 67\n-d\ncommand line option, 74\n-f format\ncommand line option, 71\n-h\ncommand line option, 71\n-i file\ncommand line option, 74\n-j\ncommand line option, 74\n-m\ncommand line option, 74\n-n\ncommand line option, 73, 74\n-o dir\ncommand line option, 77\n-o file\ncommand line option, 71, 74, 77\n-p prefix\ncommand line option, 73, 77\n-q\ncommand line option, 71\n-r dir\ncommand line option, 67\n-v\ncommand line option, 71\n-x file\ncommand line option, 74\n\nA\nallow-dubious-hosts, 78\n\nB\nbird1, 31\nbird2, 31\n\nC\nCertificate Revocation List (CRL), 99\nchroot, 80\ncommand line option\n -V, 71\n --allow-dubious-hosts, 69\n --asn=asn, 74\n --chroot=path, 76\n --complete, 73, 74, 76\n --config=path, 67\n --detach, 74\n --dirty, 71\n --disable-rrdp, 69\n --disable-rsync, 69\n --enable-bgpsec, 71\n --exceptions=file, 68\n --expire=seconds, 76\n --extra-tals-dir=dir, 68\n --format=format, 71\n --fresh, 69\n --group=group-name, 76\n --help, 71\n --history=count, 76\n --http=addr:port, 75\n --http-tls=addr:port, 75\n --input=file, 74\n --json, 74\n --limit-v4-len=length, 69\n --limit-v6-len=length, 69\n --listen-systemd, 75\n --logfile=path, 71\n --max-ca-depth=count, 70\n --max-object-size=BYTES, 70\n --more-specifics, 73\n --no-rir-tals, 67\n --noupdate, 73, 74\n --output=dir, 77\n --output=file, 71, 74, 77\n --pid-file=path, 76\n --prefix=prefix, 74\n --quiet, 71\n --refresh=seconds, 76\n --repository-dir=dir, 67\n --retry=seconds, 76\n --rrdp-connect-timeout=seconds, 70\n --rrdp-fallback=policy, 69\n --rrdp-fallback-time=seconds, 70\n --rrdp-keep-responses=path, 70\n --rrdp-local-addr=addr, 70\n --rrdp-max-delta-count=count, 70\n --rrdp-proxy=uri, 70\n --rrdp-root-cert=path, 70\n --rrdp-tcp-keepalive=seconds, 70\n --rrdp-timeout=seconds, 70\n --rsync-command=command, 69\n --rsync-timeout=seconds, 69\n --rtr=addr:port, 74\n --rtr-client-metrics, 75\n --rtr-tcp-keepalive=seconds, 75\n --rtr-tls=addr:port, 75\n --rtr-tls-cert, 75\n --rtr-tls-key, 75\n --select-asn=asn, 73\n --select-prefix=prefix, 73\n --stale=policy, 68\n --strict, 68\n --syslog, 71\n -- syslog-facility=facility, 71\n --tal=name, 68\n --unknown-objects=policy, 69\n --unsafe-vrps=policy, 68\n --user=user-name, 76\n --validation-threads=count, 71\n --verbose, 71\n --version, 71\n --working-dir=path, 76\n -a asn, 73, 74\n -c path, 67\n -d, 74\n -f format, 71\n -h, 71\n -i file, 74\n -j, 74\n -m, 73\n -n, 73, 74\n -o dir, 77\n -p prefix, 71, 74, 77\n -q, 71\n -r dir, 67\n -v, 71\n -x file, 68\n csv, 27\ncsvcompat, 27\ncsvext, 27\n\nD\ndirty, 79\ndisable-rrdp, 78\ndisable-rsync, 78\ndump\n module sub-command, 77\n\nE\nenable-bgpsec, 79\nexceptions, 77\nexpire, 80\nextra-tals-dir, 77\nG\nGhostbusters Record (GBR), 99\n\nH\nhistory-size, 80\nhttp-listen, 80\nhttp-tls-cert, 80\nhttp-tls-key, 80\nhttp-tls-listen, 80\n\nJ\njson, 28\njsonext, 28\n\nL\nlimit-v4-len, 78\nlimit-v6-len, 78\nlisten-systemd, 80\nlog, 79\nlog-file, 79\nlog-level, 79\n\nM\nman\n module sub-command, 77\nManifest, 99\nmax-ca-depth, 79\nmax-object-size, 79\nMaximum Prefix Length (MaxLength), 99\nmodule sub-command\n dump, 77\n man, 77\n server, 74\n update, 76\n validate, 73\n vrps, 71\n\nN\nno-rir-tals, 77\n\nO\nopenbgpd, 31\n\nP\npid-file, 80\nPublication Point, 99\n\nR\nrefresh, 80\nRepository, 99\nrepository-dir, 77\nResource Public Key Infrastructure (RPKI), 99\nretry, 80\nRFC\n RFC 3779, 99\n RFC 5280, 83\n RFC 5652, 83\n RFC 6480, 99\n RFC 6486, 99\n RFC 6487, 83, 99\n RFC 6488, 83\n RFC 6493, 99\n RFC 6810, 39, 75, 99\n RFC 6810#section-7, 39\n RFC 8182, 99\n RFC 8209, 96\n RFC 8210, 39, 75, 76, 99\n RFC 8416, 30, 33, 68\n RFC 8630, 19, 68, 100\nRoute Origin Attestation (ROA), 99\nRoute Origin Validation (ROV), 99\nRPKI Relying Parties, 99\nRPKI Repository Delta Protocol (RRDP), 99\nRPKI-to-Router (RPKI-RTR), 99\nrpsl, 31\nrrdp-connect-timeout, 79\nrrdp-fallback, 78\nrrdp-fallback-time, 78\nrrdp-keep-responses, 79\nrrdp-local-addr, 79\nrrdp-max-delta-count, 78\nrrdp-proxies, 79\nrrdp-root-certs, 79\nrrdp-tcp-keepalive, 79\nrrdp-timeout, 78\nrsync-args, 78\nrsync-command, 78\nrsync-timeout, 78\nrtr-client-metrics, 80\nrtr-listen, 79\nrtr-tcp-keepalive, 80\nrtr-tls-cert, 80\nrtr-tls-key, 80\nrtr-tls-listen, 80\n\nS\nserver\n module sub-command, 74\nslurm, 30\nstale, 78\nStale Object, 99\nstrict, 77\nsummary, 31\nsyslog-facility, 79\nT\ntal-labels, 80\ntals, 77\nTrust Anchor (TA), 100\nTrust Anchor Locator (TAL), 100\n\nU\nunknown-objects, 78\nUnsafe VRPs, 100\nunsafe-vrps, 78\nupdate\n module sub-command, 76\nuser, 80\n\nV\nvalidate\n module sub-command, 73\nValidated ROA Payload (VRP), 100\nvalidation-threads, 79\nvrps\n module sub-command, 71\n\nW\nworking-dir, 80"}}},{"rowIdx":260,"cells":{"id":{"kind":"string","value":"7b99268fbf164bf33de62a6bbf4008d80c0934a9"},"text":{"kind":"string","value":"Software development processes and software quality assurance\n\nZsolt Dr. Ulbert\n\nCopyright © 2014 University of Pannonia\n\n\nManuscript completed: February 2014\n\nLanguage reviewed by: Bódis László, Kismödi Péter\n\nPublished by: University of Pannonia\n\nEditor by: University of Pannonia\n\n2014\nSoftware development process and software quality assurance\nTable of Contents\n\nPreface ........................................................................................................................................ 7\n\n1 Introduction ........................................................................................................................ 8\n 1.1 Software ....................................................................................................................... 9\n 1.2 Software process and software process models ........................................................... 9\n 1.3 The attributes of good software ................................................................................. 10\n 1.4 Exercises .................................................................................................................... 11\n\n2 System design ................................................................................................................... 12\n 2.1 System engineering .................................................................................................... 12\n 2.1.1 System requirements definition .......................................................................... 13\n 2.1.2 System architecture design ................................................................................. 13\n 2.1.3 Sub-system development .................................................................................... 14\n 2.1.4 Systems integration ............................................................................................ 15\n 2.1.5 System evolution ................................................................................................ 15\n 2.2 Exercises .................................................................................................................... 15\n\n3 Software processes ........................................................................................................... 17\n 3.1 Software process models ........................................................................................... 17\n 3.1.1 The waterfall model ........................................................................................... 17\n 3.1.2 Evolutionary development ................................................................................. 19\n 3.1.3 Component-based software engineering ............................................................ 20\n 3.2 Process iteration ......................................................................................................... 20\n 3.2.1 Incremental delivery ........................................................................................... 21\n 3.2.2 Spiral development ............................................................................................. 22\n 3.3 Process activities ........................................................................................................ 22\n 3.3.1 Software specification ........................................................................................ 23\n 3.3.2 Software design and implementation ................................................................. 23\n 3.3.3 Software validation ............................................................................................ 24\n 3.3.4 Software evolution ............................................................................................. 24\n 3.4 The Rational Unified Process .................................................................................... 24\n 3.5 Exercises .................................................................................................................... 26\n\n4 Agile methods .................................................................................................................. 28\n 4.1 Extreme programming ............................................................................................... 31\n 4.1.1 Testing in XP ...................................................................................................... 34\n 4.1.2 Pair programming............................................................................................... 35\n 4.2 Scrum ......................................................................................................................... 35\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Title</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>10.2</td>\n<td>Critical systems development</td>\n<td>105</td>\n</tr>\n<tr>\n<td>10.2.1</td>\n<td>Fault tolerance</td>\n<td>106</td>\n</tr>\n<tr>\n<td>10.3</td>\n<td>Real-time software design</td>\n<td>107</td>\n</tr>\n<tr>\n<td>10.3.1</td>\n<td>System design</td>\n<td>108</td>\n</tr>\n<tr>\n<td>10.3.2</td>\n<td>Real-time operating systems</td>\n<td>109</td>\n</tr>\n<tr>\n<td>10.4</td>\n<td>Exercises</td>\n<td>110</td>\n</tr>\n<tr>\n<td>11</td>\n<td>Project management</td>\n<td>111</td>\n</tr>\n<tr>\n<td>11.1</td>\n<td>Management activities</td>\n<td>111</td>\n</tr>\n<tr>\n<td>11.2</td>\n<td>Project planning</td>\n<td>111</td>\n</tr>\n<tr>\n<td>11.2.1</td>\n<td>The project plan</td>\n<td>112</td>\n</tr>\n<tr>\n<td>11.3</td>\n<td>Project scheduling</td>\n<td>113</td>\n</tr>\n<tr>\n<td>11.4</td>\n<td>Risk management</td>\n<td>113</td>\n</tr>\n<tr>\n<td>11.4.1</td>\n<td>Risk identification</td>\n<td>114</td>\n</tr>\n<tr>\n<td>11.4.2</td>\n<td>Risk analysis</td>\n<td>115</td>\n</tr>\n<tr>\n<td>11.4.3</td>\n<td>Risk planning</td>\n<td>115</td>\n</tr>\n<tr>\n<td>11.4.4</td>\n<td>Risk monitoring</td>\n<td>116</td>\n</tr>\n<tr>\n<td>11.5</td>\n<td>Exercises</td>\n<td>116</td>\n</tr>\n<tr>\n<td>12</td>\n<td>Software quality management</td>\n<td>117</td>\n</tr>\n<tr>\n<td>12.1</td>\n<td>Process and product quality</td>\n<td>117</td>\n</tr>\n<tr>\n<td>12.2</td>\n<td>Quality assurance and standards</td>\n<td>118</td>\n</tr>\n<tr>\n<td>12.2.1</td>\n<td>ISO</td>\n<td>118</td>\n</tr>\n<tr>\n<td>12.2.2</td>\n<td>Documentation standards</td>\n<td>119</td>\n</tr>\n<tr>\n<td>12.3</td>\n<td>Quality planning</td>\n<td>119</td>\n</tr>\n<tr>\n<td>12.4</td>\n<td>Quality control</td>\n<td>119</td>\n</tr>\n<tr>\n<td>12.4.1</td>\n<td>Quality reviews</td>\n<td>120</td>\n</tr>\n<tr>\n<td>12.5</td>\n<td>Software measurement and metrics</td>\n<td>120</td>\n</tr>\n<tr>\n<td>12.5.1</td>\n<td>The measurement process</td>\n<td>120</td>\n</tr>\n<tr>\n<td>12.5.2</td>\n<td>Product metrics</td>\n<td>121</td>\n</tr>\n<tr>\n<td>12.6</td>\n<td>Exercises</td>\n<td>121</td>\n</tr>\n<tr>\n<td>13</td>\n<td>Software cost estimation</td>\n<td>122</td>\n</tr>\n<tr>\n<td>13.1</td>\n<td>Software productivity estimation</td>\n<td>122</td>\n</tr>\n<tr>\n<td>13.2</td>\n<td>Development cost estimation techniques</td>\n<td>123</td>\n</tr>\n<tr>\n<td>13.3</td>\n<td>Algorithmic cost modelling</td>\n<td>124</td>\n</tr>\n<tr>\n<td>13.4</td>\n<td>Exercises</td>\n<td>124</td>\n</tr>\n<tr>\n<td>14</td>\n<td>References</td>\n<td>126</td>\n</tr>\n</tbody>\n</table>\nPreface\n\nIn the last decades we have been witness to the rapid development in computer technology. Due to the technological development in production of hardware and software tools new challenges have emerged. The dynamic and global economic environment requires the development of new software development techniques that are suitable for producing high quality software meeting requirements of the business environment and high level of professional standards. The new approaches to software development techniques and methodologies make it possible to use the technique best fits the structure and business objectives of an organization. In addition, the software development processes have to support the development requirements of new types of systems and new applications that control these systems. For example they are embedded systems and their software, mobile systems and mobile applications, safety-critical systems and dependable system developments, etc. Today, the large number of available methodologies ensures the use of appropriate methodology and the successful completion of software development projects.\n\nEmergence of agile methodologies are very favourable for flexibly and adaptive organizations. However, there are a number of software development projects when conventional development methodologies are preferable to use due to the nature of development task and organization.\n\nUse of object-oriented development principles have become very popular in both system and software development projects. Over the object-oriented programming the object-oriented technology has become an effective development tool in the systems and software development methodologies. This course book deals with the phases of software development process, such as software requirements, analysis and design that are discussed in the frame of the Rational Unified Process (RUP) software development process in several chapters. RUP is based on the Unified Modelling Language (UML) as an object-oriented graphical modelling language, so theoretical knowledge and practical examples presented in this student book reflect the object-oriented design and development principles.\n\nIn chapters 1-4. the basic concepts of software development and the conventional and agile software development methodologies are presented.\n\nChapter 5. and 6. discuss the basic of object-oriented design and UML graphical modelling language. Chapter 7. and 8. describe in detail the requirements, analysis and design software development phases. These chapters are well illustrated with examples using the notations of UML graphical modelling language. In chapter 10. related to development issues of embedded systems the characteristics of the critical systems, development of critical systems, and development of real-time systems are discussed. The topics of the last three chapters are related to software projects management including project management, software quality management and software cost estimation.\n\nAlthough this student book is about basic knowledge of software development process, the programming is not subject of any chapters, so the processing of chapters do not require any prior programming experience. Processing of chapters related to software development process requires object-oriented design approach, but it is helped by knowledge provided in chapter 5. and 6.\n1 Introduction\n\nComputer software has become a driving force in our life, everyone uses it either directly or indirectly. The role of computer software has undergone significant change over the last 50 years. Software affects nearly every aspect of our lives and has become an unavoidable part of commerce, our culture and our everyday activities. It serves as the basis for modern scientific investigation and engineering problem solving. It drives business decision making. It is embedded in systems of all kinds: entertainment, office products, transportation, medical, telecommunications, industrial processes, etc. Software as a product delivers the computing potential embodied by computer hardware. It can be considered an information transformer producing, managing, acquiring, modifying, displaying, or transmitting data. Software provides a connection to worldwide information networks Internet and makes it possible to acquire information in all of its forms [1,4,14,15].\n\nAs the importance of software grows, the software community continually attempts to develop technologies that will make it easier, faster, and less expensive to build high-quality computer programs. Some of these technologies are targeted at a specific application domain such as website design; others focus on a technology domain (for example object-oriented systems); there are technologies that deliver dependable software. However, we have yet to develop a software technology that does it all. The technology encompasses a process, a set of methods, and an array of tools that we call software engineering. Software engineering has been an engineering discipline, it focuses on the cost effective development of high-quality software systems.\n\nThe notion of software engineering was first proposed in 1968 at a conference held to discuss what was then called the software crisis. This software crisis resulted directly from the introduction of new computer hardware based on integrated circuits. Dramatic improvements in hardware performance, profound changes in computing architectures, increases in memory and storage capacity, have all led to more complex computer-based systems. The resulting software was orders of magnitude larger and more complex than previous software systems. Due to the high demand for complex software systems the individual programmers of the earlier periods has been replaced by a team of software developers, each focusing on one part of the technology required to deliver a complex application. At large-scale systems developments, that requires extensive co-operation of developers to complete developments within a prescribed duration of time, it has become increasingly apparent that the existing development methods were not good enough to efficiently drive the development processes.\n\nDevelopment projects were sometimes years late. The development cost was over the budget, software was unreliable, difficult to maintain and performed poorly. Hardware costs were consumedly decreased while software costs were rising rapidly. This phenomenon was recognised by software developers and they stated that the software development practice was in crisis. To solve problems it was necessary to recognize that software has become a product, and similarly to other products a technology was required to develop it.\n\nWhat does it means that software is a product? It is that:\n\n1. Software has to provide services and functionalities as it specified.\n2. Software has quality attributes.\n3. There is a cost of its production.\n4. There is a time limit for developing software.\n\nNew techniques and methods were needed to control the complexity inherent in large software systems. These techniques have become part of software engineering and are now widely used. Software industry has made tremendous progress since 1960s and the\ndevelopment of software engineering has significantly improved the quality of software. The activities involved in software development have been much better understood. Software engineers and development organizations have developed effective methods of software specification, design and implementation. However, the large number of different types of systems and organizations that use these systems means that we need different approaches to software development.\n\n1.1 Software\n\nComputer software is the product that software engineers design and build. A software product is composed of computer programs, data and documents. A definition of software can be given by these items as follows:\n\n1. Software consists of computer programs that when executed provide desired function and performance.\n2. It includes data structures that enable the programs to adequately manipulate information.\n3. It has a documentation that describes the operation and use of the programs.\n\nThere are two fundamental types of software product:\n\n1. Generic software. These software are produced by a development organization and sold on the open market to any customer.\n2. Customized software. These software are developed especially for a particular customer by a software contractor.\n\nThe main difference between these two types of software is the following. In the case of generic software products the organization that develops the software specifies the software requirements. For custom products, the specification is usually developed and controlled by the organization that is buying the software.\n\nThe breadth of software applications can be indicated by the following software areas: system software, real-time software, business software, engineering and scientific software, embedded software, personal computer software, web-based software and artificial intelligence software.\n\n1.2 Software process and software process models\n\nA software process also known as a software development life-cycle is composed of a number of clearly defined and distinct work phases which are used to design and build software. Development phases represent four fundamental process activities that are common to all software processes:\n\n1. Software specification. During this activity customers and engineers define the functional and non-functional requirements of software to be produced.\n2. Software development. It is the development activity for designing and implementing software.\n3. Software validation. In this activity the software is checked that it works failure free and to ensure that it provides the functionalities what the customer requires.\n4. Software evolution. The aim of software evolution is to implement changes to the system due to the changes in user and market requirements.\n\nThese fundamental activities may be organized in different ways and described at different levels of detail for different types of software. Use of an inappropriate software process may reduce the quality of the software product to be developed and may increase the development costs.\nA software process model is a simplified description of a software process that presents an overall view of the software process. Process models may include activities that are part of the software process, software products and the roles of people involved in software engineering. Most software process models are based on one of the next general models of software development:\n\n1. The waterfall approach. The waterfall model is a sequential design process in which progress is seen as flowing steadily downwards through the phases of software development such as requirements specification, software analysis and design, implementation, testing, etc. Development only goes on to the following phase when the preceding phase is finished, reviewed and verified.\n\n2. Iterative development. The basic idea of this method is to develop a system iterative through repeated cycles in smaller portions at a time. At each iterations, design modifications are made and new functional capabilities are added. This approach interleaves the activities of specification, development and validation. An initial system is rapidly developed from very abstract specifications. The goal for this initial implementation is to create a product to which the user can react. The initial system is then refined with customer input to produce a system that satisfies the customer’s needs.\n\n3. Component-based software engineering. It is a reuse-based approach of software development. This technique assumes that parts of the system already exist. The system development process focuses on integrating these parts into a system.\n\n1.3 The attributes of good software\n\nFunctional quality of software reflects how well it complies with a given design, based on functional requirements or software specifications. Besides functional quality, software has a number of other associated attributes that also reflect the quality of that software. These attributes are usually called non-functional attributes. They reflect the behaviour of software while it is executing and the structure and organization of the source program. Examples of these attributes are the maintainability, reliability, efficiency, etc. The specific set of attributes expected from a software system depends on its application. Some essential quality attributes of a software system are the following [13]:\n\n- **Maintainability.** Maintainability is defined as the ease with which changes can be made to a software system. These changes may be necessary for the correction of faults, adaptation of the system to meet a new requirement, addition of new functionality, removal of existing functionality or corrected when errors or deficiencies occur and can be perfected, adapted or action taken to reduce further maintenance costs.\n\n- **Dependability.** Dependability of software includes characteristics such as availability, reliability, safety and security. Dependable software should not cause physical or economic damage in the event of system failure.\n\n- **Efficiency.** Efficiency is the ability of the software to do the required processing on least amount of system hardware such as memory or processor cycles.\n\n- **Usability.** Usability is the ability of a software to offer its interfaces in a user friendly and elegant way.\n\n- **Reusability.** Reusability defines the capability for components and subsystems to be suitable for use in other applications and in other scenarios. Reusability minimizes the duplication of components and also the implementation time.\n\n- **Testability.** Testability is a measure of how easy it is to create test criteria for the system and its components, and to execute these tests in order to determine if the\ncriteria are met. Good testability makes it more likely that faults in a system can be isolated in a timely and effective manner.\n\n1.4 Exercises\n\nExplain software crisis!\nGive the definition of software!\nWhat is the difference between generic and customized software?\nWhat is the software process?\nList the main activities of software process!\nWhat does the software process model mean?\nList the main types of software process model!\nWhat is the meaning of component based software development?\nList five quality attributes of a good software!\nWhat is the meaning of software maintainability?\nWhat is the meaning of software reusability?\n2 System design\n\nThe term system is one that is universally used. A system is a purposeful set of interrelated components that form an integrated whole and work together to achieve some objective. Systems are usually hierarchical and so include other systems. These other systems are called sub-systems. Some systems share common characteristics, including [1]:\n\n1. A system has structure, it contains parts or components that are directly or indirectly related to each other.\n2. A system has behaviour, it contains processes that transform inputs into outputs.\n3. A system has interconnectivity, the parts and processes are connected by structural and/or behavioural relationships.\n4. Structure and behaviour of a system may be decomposed via sub-systems and sub-processes to elementary parts and process steps.\n\nThe technical computer-based systems are systems that include hardware and software components. Socio-technical systems include one or more technical systems but also include knowledge of how the system should be used to achieve some broader objective. This means that these systems have defined operational processes, include people who operate the system, are governed by organisational policies and rules and may be affected by external constraints such as national laws and regulatory policies.\n\nSoftware engineering is critical for the successful development of complex, computer based socio-technical systems. Software engineer should not simply be concerned with the software itself but they should also have a broader awareness of how that software interacts with other hardware and software systems and how it is supposed to be used by end users.\n\nThe complexity of relationships between the components in a system means that the system is more than simply the sum of its parts. It has properties that are properties of the system as a whole. There are two types of emergent properties of system:\n\n1. Functional properties. These properties appear when all the parts of a system work together to achieve some objective. For example, when an alarm system turns on the siren it is due to the co-operation between its components.\n2. Non-functional properties. These properties are related to the behaviour of the system in its operational environment. Examples of non-functional properties are reliability, performance, safety and security for computer-based systems.\n\n2.1 System engineering\n\nSystems engineering focuses on how to design and manage complex engineering projects over their life cycles. It includes the activity of specifying, designing, implementing, validating, deploying and maintaining socio-technical systems. Systems engineers are not just concerned with software but also with hardware and the interactions of a system with users and its environment. Important aspects of system development that should be addressed the services that the system provides, the constraints under which the system must be built and operated and the way in which the system is used to fulfil its purpose. The stages of the systems engineering process are the following:\n\n- System requirements definition\n- System architecture design\n- Sub-system development\n- System integration\n- System evolution\n2.1.1 System requirements definition\n\nSystem requirement definitions specify what the system should do, its functionality and its essential and desirable system properties. The techniques applied to elicit and collect information in order to create system specifications and requirement definitions involve consultations, interviews, requirements workshop with customers and end users. The objective of the requirements definition phase is to derive the two types of requirement:\n\n1. Functional requirements. They define the basic functions that the system must provide and focus on the needs and goals of the end users.\n2. System requirements (non-functional requirements). These are non-functional system properties such as availability, performance and safety etc. They define functions of a system, services and operational constraints in detail.\n\n2.1.2 System architecture design\n\nSystem architecture design is concerned with how the system functionality is to be provided by the components of the system. The activities involved in this process are:\n\n1. Partition of requirements. After analysing the system requirements they are organized into related groups using several partitioning options.\n2. Identification of sub-systems. The objective of this activity is to identify the sub-systems that can individually or collectively meet the system requirements. The relationships between sub-systems should be also identified at this time.\n3. Assignment of requirements to sub-systems. In this activity the requirements are assigned to the identified sub-systems. If the sub-system identification is based on the results of requirements partitioning it provides an unambiguous assignment.\n4. Specification of sub-system functionality. It is the specification of functionality provided by each sub-system. There shall be no overlapping or similar functions, the architecture shall be followed.\n5. Definition of sub-system interfaces. Interfaces provide the communication between the sub-systems. Once the interfaces have been defined it becomes possible to develop sub-systems in parallel.\n\nThere may be a lot of feedback and iteration from one stage to another in this design process. As problems, questions, new requirements arise the revision of earlier stages may be required. The processes of requirements engineering and design in practice closely linked. Constraints determined by existing systems may limit design choices, and these choices may be specified in the requirements. During the design process problems with existing requirements may arise and new requirements may emerge. These have effect on design decisions again and vice versa. Therefore the linked processes can be represented by a spiral, as shown in Figure 2.1.\nStarting in the centre, each round of the spiral may add more detail to the requirements and the design. Some rounds may focus on requirements, some on design.\n\nDuring the phase of requirements and design, systems may be modelled as a set of components and relationships between these components. These are usually illustrated graphically in a system architecture model that gives an overview of the system architecture. The system architecture may be simpler presented as a block diagram showing the major sub-systems and the interconnections between these sub-systems. The relationships indicated may include data flow or some other type of dependency relationship. For an example, Figure 2.2 shows the decomposition of an alarm system into its principal components.\n\n2.1.3 Sub-system development\n\nDuring sub-system development, the sub-systems identified are implemented. This may involve starting another system engineering process for individual sub-systems or, if the sub-system is software, a software process involving requirements, design, implement and testing.\n\nUsually all sub-systems of the system are designed and developed during the development process. However, some of the sub-systems may be bought as commercial system for the reason of integration into the system. Sometime it is cheaper to buy existing products than to develop specific components. However, commercial systems may not meet all the requirements exactly. In these cases, it is necessary to change the requirements and repeat the design phase of development to correctly accommodate the purchased component. Another possibility is to request or make changes on the purchased component.\n2.1.4 Systems integration\n\nDuring the system integration process, the independently developed subsystems are put together to make up a complete system. Integration can be done using such an approach, where all the sub-systems are integrated at the same time. However, for technical and managerial purposes, an incremental integration process where sub-systems are integrated one at a time looks a better approach, for two reasons:\n\n1. It is usually impossible to schedule the development of all the sub-systems so that they are all finished at the same time.\n2. Incremental integration reduces the cost of error location. If many sub-systems are simultaneously integrated, an error that arises during testing may be in any of these sub-systems. When a single sub-system is integrated with an already working system, errors that occur are probably in the newly integrated sub-system or in the interactions between the existing sub-systems and the new sub-system.\n3. The resources can be shared, their usage can be scheduled on a better way. The costs may be optimized. For example the team which is responsible to test the sub-systems, can consist less engineers and the can test the sub-systems one after another, or the usage of an expensive machine can be shared, etc.\n\nOnce the components have been integrated, an extensive system testing takes place. This testing should be aimed at testing the interfaces between components and the behaviour of the system as a whole.\n\n2.1.5 System evolution\n\nLarge and complex systems may have a very long lifetime. During their life, they are changed to correct errors in the original system requirements and to implement new requirements that have emerged. Other reasons for changes: the computers in the system are likely to be replaced with new high-performance machines, the organization that uses the system may reorganize itself and hence use the system in a different way, the external environment of the system may change, forcing changes to the system, etc.\n\nSystem evolution is inherently costly for several reasons:\n\n1. Proposed changes have to be analyzed very carefully from a business and a technical viewpoint. Changes have to contribute to the goals of the system and should not simply be technically motivated.\n2. Because sub-systems are never completely independent, changes to one subsystem may affect the performance or behaviour of other sub-systems. Consequent changes to these sub-systems may therefore be needed.\n3. The reasons for original design decisions are often unrecorded. Those responsible for the system evolution have to work out why particular design decisions were made.\n4. As systems age, their structure typically becomes corrupted by change so the costs of making further changes increases.\n\n2.2 Exercises\n\n1. Give definition of system!\n2. What are the socio-technical systems?\n3. What are the functional requirements?\n4. What is the different between functional and non-functional requirements?\n5. What are the phases of system engineering process?\n6. List the iterative processes of spiral model!\n7. What are the types of system integration?\n8. Explain the process of system integration!\n9. What is the similarity between incremental system integration and spiral model of design?\n10. What is the meaning of system evolution?\n3 Software processes\n\nA software development process, also known as a software development lifecycle, is a structure imposed on the development of a software product. A software process is represented as a set of work phases that is applied to design and build a software product. There is no ideal software process, and many organisations have developed their own approach to software development. Software development processes should make a maximum use of the capabilities of the people in an organisation and the specific characteristics of the systems that are being developed [1,14,15].\n\nThere are some fundamental activities that are common to all software processes:\n\n1. **Software specification.** In this activity the functionality of the software and constraints on its operation must be defined.\n2. **Software design and implementation.** The software that meets the specification is produced.\n3. **Software validation.** The software must be validated to ensure that it has all the functionalities what the customer needs.\n4. **Software evolution.** The software must evolve to meet changing customer needs.\n\n3.1 Software process models\n\nA software process model is an abstract representation of a software process. In this section a number of general process models are introduced and they are presented from an architectural viewpoint. These models can be used to explain different approaches to software development. They can be considered as process frameworks that may be extended and adapted to create more specific software engineering processes. In this chapter the following process models will be introduced:\n\n1. **The waterfall model.** In this model of software process the fundamental process activities of specification, development, validation and evolution are represented as sequential process phases such as requirements specification, software design, implementation, testing and so on.\n2. **Evolutionary development.** This approach interleaves the activities of specification, development and validation. An initial system is rapidly developed from abstract specifications. Then the initial system is refined by customer inputs to produce a system that satisfies the customer’s needs.\n3. **Component-based software engineering.** The process models that use this approach are based on the existence of a significant number of reusable components. The system development process focuses on integrating these components into a system rather than developing them.\n\nThese three generic process models are widely used in current software engineering practice. They are not mutually exclusive and are often used together, especially for large systems development. Sub-systems within a larger system may be developed using different approaches. Therefore, although it is convenient to discuss these models separately, in practice, they are often combined.\n\n3.1.1 The waterfall model\n\nThe waterfall model was the first software process model to be introduced (Figure 3.1.). It is also referred to as a linear-sequential life cycle model. The principal stages of the model represent the fundamental development activities:\n\n1. **Requirements analysis and definition.** Software requirements specification establishes the basis for agreement between customers and contractors or suppliers on what the\nA software product is to do. Software requirements specification permits a rigorous assessment of requirements before design can begin. It should also provide basis for estimating product costs, risks, and schedules.\n\n2. **System and software design.** Design activity results in the overall software architecture. Software design involves identifying and describing the fundamental software system components and their relationships. The systems design process partitions the requirements to either hardware or software components.\n\n3. **Implementation and unit testing.** During this phase, the software design is realised as a set of software components. Components are tested ensuring each component meets its specification.\n\n4. **Integration and system testing.** The program units or components are integrated and tested as a complete system to ensure that the software requirements have been met. After successful testing, the software system is delivered to the customer.\n\n5. **Operation and maintenance.** The system is delivered and deployed and put into practical use. Maintenance involves correcting errors which were not discovered in earlier stages of the life cycle, improving the implementation of system units and providing new functionalities as new requirements emerge.\n\n\n\n**Figure 3.1. The software life cycle.**\n\nIn principle, the result of each phase is one or more documents. The following phase shall not start until the previous phase has finished. In practice, these stages overlap and feed information to each other. During design, problems with requirements are identified; during coding design problems are found and so on. The software process is not a simple linear model but involves a sequence of iterations of the development activities. Because of the costs of producing and approving documents, iterations are costly and involve significant rework. Therefore, the waterfall model should only be used when the requirements are well understood and unlikely to change significantly during system development.\n\n### 3.1.1.1 V-model of software process\n\nThe V-model represents a software process model that may be considered an extension of the waterfall model. Instead of moving down in a linear way, the process steps are bent upwards after the implementation phase, to form the typical V shape. The V-model demonstrates the relationships between each phase of the development life cycle and its associated phase of testing. The horizontal and vertical axes represent time and level of abstraction respectively. Similarly to waterfall model the process steps follow each other in a sequential order but V-model allows the parallel execution of activities.\nIn the requirements definition phase the requirements of the system are collected by analyzing the needs of the user, and in parallel the user acceptance or functional test cases are also designed. At the level of architectural design the software architecture, its components with their interface are designed at high-level to provide functional requirements of software. The design of integration testing is also carried out in this phase. In the component design phase the units and modules are designed at low-level. The low level design document or program specifications will contain a detailed functional logic of the units and modules. The unit test cases are also developed in this phase. After the implementation phase the development process continues upward by unit, integration and system testing.\n\n\n\n3.1.2 Evolutionary development\n\nEvolutionary development is based on the idea of developing an initial implementation, exposing this to user comment and refining it through many versions until an adequate system has been developed (Figure 3.3). Specification, development and validation activities are interleaved with rapid feedback across activities.\n\n\n\nThere are two fundamental types of evolutionary development:\n\n1. *Exploratory development.* The objective of the process is to work with the customer in order to explore their requirements and deliver a final system. The development starts with the parts of the system that are well understood. The system evolves by adding new features proposed by the customer.\n2. **Throwaway prototyping.** In this case the objective of the evolutionary development process is to understand the customer’s unclear requirements, namely to validate and derive the requirements definition for the system. The prototype concentrates on experimenting with the customer requirements that are poorly understood.\n\nAn evolutionary approach to software development is often more effective than the waterfall approach in producing systems that meet the immediate needs of customers. The advantage of a software process that is based on an evolutionary approach is that the specification can be developed incrementally. As users develop a better understanding of their problem, this can be reflected in the software system. However the evolutionary approach has also problems. Regular deliverables are need for monitoring progress. If systems are developed quickly, it is not cost-effective to produce documents that reflect every version of the system. Continual change tends to corrupt the software structure.\n\n### 3.1.3 Component-based software engineering\n\nIn the majority of software projects, there is some software to reuse. The reusable components are systems that may provide specific functionality for the system. This reuse-oriented approach relies on a large base of reusable software components and some integrating framework for these components. The stages of component-based software process which are different to other processes are the followings:\n\n1. **Component analysis.** Based on the requirements specification, a search is made for components that can implement the given specification. Usually, there is no exact match, and the components that may be used only provide some of the functionality required.\n2. **Requirements modification.** During this stage, the requirements are analysed using information about the new components. Requirements are then modified to reflect the services of available components.\n3. **System design with reuse.** During this phase, the framework of the system is designed or an existing framework is reused. The designers take into account the components that are reused. Some new software may have to be designed if reusable components are not available.\n4. **Development and integration.** Software that cannot be externally procured is developed, and the components and reusable systems are integrated to create the new system.\n\nComponent-based software engineering has the obvious advantage of reducing the amount of software to be developed and so reducing cost and risks. It usually also leads to faster delivery of the software. However, requirements compromises are inevitable and this may lead to a system that does not meet the real (original) needs of users.\n\n### 3.2 Process iteration\n\nChanges are usually unavoidable in all large software projects. The system requirements change as organization continuously responds to the changing environment and conditions. Management priorities may change. Due to the quick progress in technologies, designs and implementation will change. This means that the process activities are regularly repeated as the system is reworked in response to change requirements. The following two process models have been designed to support process iteration:\n\n1. **Incremental delivery.** The software specification, design and implementation are broken down into a series of increments that are each developed in turn.\n2. **Spiral development.** The development of the system spirals outwards from an initial outline through to the final developed system.\n### 3.2.1 Incremental delivery\n\nThe waterfall model of development requires defining the requirements for a system before design begins. On contrary, an evolutionary development allows requirements to change but it leads to software that may be poorly structured and difficult to understand and maintain.\n\nIncremental delivery (Figure 3.4) is an approach that combines the advantages of these two models. In an incremental development process, customers identify the services to be provided by the software system. They decide which subset of the services is most important and which are least important to them. A number of delivery increments are then defined, with each increment providing a sub-set of the system functionality. The allocation of services to increments depends on the priority of service. The highest priority services are delivered first.\n\n\n\nFigure 3.4. Incremental development.\n\nOnce the system increments have been identified, the requirements for first increment are defined in detail, and that increment is developed using the best suited software process. In the example given in Figure 3.4, the waterfall model is used to develop the increments in every iteration. As new increments are completed, they are integrated with existing increments and the system functionality improves with each delivered increment. The incremental development process has a number of advantages:\n\n1. Customers do not have to wait until the entire system is delivered before they can gain value from it. The first increment satisfies their most critical requirements so they can use the software immediately.\n2. Customers can use the early increments as prototypes and gain experience that informs their requirements for later system increments.\n3. There is a lower risk of overall project failure. Although problems may be encountered in some increments, it is likely that these will be solved in later versions.\n4. As the highest priority services are delivered first, and later increments are integrated with them, it is unavoidable that the most important system services receive the most testing. This means that software failures are less likely to occur in the most important parts of the system.\n3.2.2 Spiral development\n\nThe spiral model of the software process (Figure 3.5.) represents the software process as a sequence of activities with some backtracking from one activity to another, the process is represented as a spiral. Each loop in the spiral represents a phase of the software process. Thus, the innermost loop might be concerned with system feasibility, the next loop with requirements definition, the next loop with system design and so on.\n\n\n\nEach loop in the spiral is split into four sectors:\n\n1. **Objective setting.** Specific objectives for that phase of the project are defined. Constraints on the process and the product are identified and a detailed management plan is drawn up. Project risks are identified. Alternative strategies, depending on these risks, may be planned.\n\n2. **Risk assessment and reduction.** For each of the identified project risks, a detailed analysis is carried out. Steps are taken to reduce the risk.\n\n3. **Development and validation.** After risk evaluation, a development model for the system is chosen.\n\n4. **Planning.** The project is reviewed and a decision made whether to continue with a further loop of the spiral. If it is decided to continue, plans are drawn up for the next phase of the project.\n\nThe main difference between the spiral model and other software process models is the explicit recognition and handling of risk in the spiral model.\n\n3.3 Process activities\n\nThe four basic process activities of specification, development, validation and evolution are organised differently in different development processes. In the waterfall model, they are\norganised in sequence, whereas in evolutionary development they are interleaved. How these activities are carried out depends on the type of software, people and organisational structures involved.\n\n3.3.1 Software specification\n\nA software requirement is defined as a condition to which a system must comply. Software specification or requirements management is the process of understanding and defining what functional and non-functional requirements are required for the system and identifying the constraints on the system’s operation and development. The requirements engineering process results in the production of a software requirements document that is the specification for the system.\n\nThere are four main phases in the requirements engineering process:\n\n1. *Feasibility study.* In this study an estimate is made of whether the identified user needs may be satisfied using current software and hardware technologies. The study considers whether the proposed system will be cost-effective from a business point of view and whether it can be developed within existing budgetary constraints.\n2. *Requirements elicitation and analysis.* This is the process of deriving the system requirements through observation of existing systems, discussions with potential users, requirements workshop, storyboarding, etc.\n3. *Requirements specification.* This is the activity of translating the information gathered during the analysis activity into a document that defines a set of requirements. Two types of requirements may be included in this document: user (functional) requirements and system (non-functional) requirements.\n4. *Requirements validation.* It is determined whether the requirements defined are complete. This activity also checks the requirements for consistency.\n\n3.3.2 Software design and implementation\n\nThe implementation phase of software development is the process of converting a system specification into an executable system through the design of system. A software design is a description of the architecture of the software to be implemented, the data which is part of the system, the interfaces between system components and, sometimes, the algorithms used. The design process activities are the followings:\n\n1. *Architectural design.* The sub-systems of system and their relationships are identified based on the main functional requirements of software.\n2. *Abstract specification.* For each sub-system, an abstract specification of its services and the constraints under which it must operate is defined.\n3. *Interface design.* Interfaces allow the sub-system’s services to be used by other sub-systems. The representation of interface should be hidden. In this activity the interface is designed and documented for each sub-system. The specification of interface must be unambiguous.\n4. *Component design.* Services are allocated to components and the interfaces of these components are designed.\n5. *Data structure design.* The data structures used in the system implementation are designed in detail and specified.\n6. *Algorithm design.* In this activity the algorithms used to provide services are designed in detail and specified.\n\nThis general model of the design process may be adapted in different ways in the practical uses.\nA contrasting approach can be used by *structured methods* for design objectives. A structured method includes a design process model, notations to represent the design, report formats, rules and design guidelines. Most these methods represent the system by graphical models and many cases can automatically generate program code from these models. Various competing methods to support object-oriented design were proposed in the 1990s and these were unified to create the Unified Modeling Language (UML) and the associated unified design process.\n\n### 3.3.3 Software validation\n\nSoftware validation or, more generally, verification and validation (V & V) is intended to show that a system conforms to its specification and that the system meets the expectations of the customer buying the system. It involves checking the processes at each stage of the software process. The majority of validation costs are incurred after implementation when the operation of system is tested.\n\nThe software is tested in the usual three-stage testing process. The system components, the integrated system and finally the entire system are tested. Component defects are generally discovered early in the process and the interface problems during the system integration. The stages in the testing process are:\n\n1. *Component (or unit) testing*. Individual components are tested to ensure that they operate correctly. Each component is tested independently, without other system components.\n2. *System testing*. The components are integrated to make up the system. This testing process is concerned with finding errors that result from interactions between components and component interface problems. It is also concerned with validating that the system meets its functional and non-functional requirements.\n3. *Acceptance testing*. It is considered a functional testing of system. The system is tested with data supplied by the system customer.\n\nUsually, component development and testing are interleaved. Programmers make up their own test data and test the code as it is developed. However in many process model, such as in V-model, Test Driven Development, Extreme Programming, etc., the design of the test cases starts before the implementation phase of development. If an incremental approach to development is used, each increment should be tested as it is developed, with these tests based on the requirements for that increment.\n\n### 3.3.4 Software evolution\n\nSoftware evolution, specifically software maintenance, is the term used in software engineering to refer to the process of developing software initially, then repeatedly updating it for various reasons.\n\nThe aim of software evolution would be to implement the possible major changes to the system. The existing larger system is never complete and continues to evolve. As it evolves, the complexity of the system will grow. The main objectives of software evolution are ensuring the reliability and flexibility of the system. The costs of maintenance are often several times the initial development costs of software.\n\n### 3.4 The Rational Unified Process\n\nThe Rational Unified Process (RUP) methodology is an example of a modern software process model that has been derived from the UML and the associated Unified Software Development Process. The RUP recognises that conventional process models present a single view of the process. In contrast, the RUP is described from three perspectives [3,11,17,22]:\n1. A dynamic perspective that shows the phases of the model over time.\n2. A static perspective that shows the process activities.\n3. A practice perspective that suggests good practices to be used during the process.\n\nThe RUP (Figure 3.6.) identifies four discrete development phases in the software process that are not equated with process activities. The phases in the RUP are more closely related to business rather than technical concerns. These phases in the RUP are:\n\n1. **Inception.** The goal of the inception phase is to establish a business case for the system, identify all external entities, i.e. people and systems that will interact with the system and define these interactions. Then this information is used to assess the contribution that the system makes to the business.\n2. **Elaboration.** The goals of the elaboration phase are to develop an understanding of the problem domain, establish an architectural framework for the system, develop the project plan and identify key project risks.\n3. **Construction.** The construction phase is essentially concerned with system design, programming and testing.\n4. **Transition.** The final phase of the RUP is concerned with moving the system from the development community to the user community and making it work in a real environment.\n\nIteration within the RUP is supported in two ways. Each phase may be enacted in an iterative way with the results developed incrementally. In addition, the whole set of phases may also be enacted incrementally.\n\nThe static view of the RUP focuses on the activities that take place during the development process. These are called workflows in the RUP description. There are six core process workflows identified in the process and three core supporting workflows. The RUP has been designed in conjunction with the UML so the workflow description is oriented around associated UML models. The core engineering and support workflows are the followings:\n\n1. **Business modelling.** The business processes are modelled using business use cases.\n2. **Requirements.** Actors who interact with the system are identified and use cases are developed to model the system requirements.\n3. **Analysis and design.** A design model is created and documented using architectural models, component models, object models and sequence models.\n\n4. **Implementation.** The components in the system are implemented and structured into implementation sub-systems. Automatic code generation from design models helps accelerate this process.\n\n5. **Testing.** Testing is an iterative process that is carried out in conjunction with implementation. System testing follows the completion of the implementation.\n\n6. **Deployment.** A product release is created, distributed to users and installed in their workplace.\n\n7. **Configuration and change management.** This supporting workflow manages changes to the system.\n\n8. **Project management.** This supporting workflow manages the system development.\n\n9. **Environment.** This workflow is concerned with making appropriate software tools available to the software development team.\n\nThe advantage in presenting dynamic and static views is that phases of the development process are not associated with specific workflows. In principle at least, all of the RUP workflows may be active at all stages of the process. Of course, most effort will probably be spent on workflows such as business modelling and requirements at the early phases of the process and in testing and deployment in the later phases.\n\nThe practice perspective on the RUP describes good software engineering practices that are recommended for use in systems development. Six fundamental best practices are recommended:\n\n1. **Develop software iteratively.** Plan increments of the system based on customer priorities and develop and deliver the highest priority system features early in the development process.\n2. **Manage requirements.** Explicitly document the customer’s requirements and keep track of changes to these requirements. Analyze the impact of changes on the system before accepting them.\n3. **Use component-based architectures.** Structure the system architecture into components.\n4. **Visually model software.** Use graphical UML models to present static and dynamic views of the software.\n5. **Verify software quality.** Ensure that the software meets the organisational quality standards.\n6. **Control changes to software.** Manage changes to the software using a change management system and configuration management procedures and tools.\n\nThe RUP is not a suitable process for all types of development but it does represent a new generation of generic processes. The most important innovations are the separation of phases and workflows, and the recognition that deploying software in a user’s environment is part of the process. Phases are dynamic and have goals. Workflows are static and are technical activities that are not associated with a single phase but may be used throughout the development to achieve the goals of each phase.\n\n### 3.5 Exercises\n\n1. What software development project does waterfall model recommended for?\n2. What software development project does waterfall model not recommended for?\n3. List application problems related to waterfall development!\n4. What is the meaning of requirements validation?\n5. What are the main activities of software design phase?\n6. What is the different between the system and acceptance testing?\n7. Explain the role of prototypes in the evolutionary development!\n8. Explain the reason for software developed by an evolutionary development are often more difficult to maintain!\n9. What are the support workflows in RUP?\n10. How does RUP support the iterative software process?\n4 Agile methods\n\nNowadays, most organizations and companies have to work under rapidly changing conditions. Software is used in almost all business so it is essential that new software is developed quickly. Rapid software development is therefore one of the most critical requirement for software systems [1,23].\n\nThe conventional software development processes that are based on completely specifying the requirements then designing, building and testing the system are not applicable to rapid software development. As the requirements change the system design or implementation has to be reworked and retested. As a consequence, the development process is usually late and the final software is delivered to the customer long after it was originally specified. In some cases the original reason for developing software may have changed so radically that the software becomes effectively useless when it is delivered. Therefore, development processes, especially in the case of business systems, have to focus on rapid software development and delivery.\n\nIn the 1980s and early 1990s, it was considered that the best way to achieve better software quality was provided by rigorously planned and controlled conventional software development processes that were normally used for development of large-scale systems. These development processes usually involve a significant overhead in planning, designing and documenting the system. However, when this plan-based development approach was applied to small and medium-sized business systems, the overhead involved was so large that it sometimes dominated the software development process. Software engineers often spent more time on how the system should be developed, than on program development and testing.\n\nDissatisfaction with these approaches led a number of software developers in the 1990s to propose new agile methods. These allowed the development team to focus on the software itself rather than on its design and documentation. Agile methods universally rely on an iterative approach to software specification, development and delivery, and were designed primarily to support business application development where the system requirements usually changed rapidly during the development process. They are intended to deliver working software quickly to customers, who can then propose new and changed requirements to be included in later iterations of the system.\n\nIn February 2001, 17 software developers met at the Snowbird, Utah resort, to discuss lightweight development methods. They published the Manifesto for Agile Software Development to define the approach now known as agile software development. The Agile Manifesto reads, in its entirety, as follows:\n\n*We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:*\n1. Individuals and interactions over Processes and tools\n2. Working software over Comprehensive documentation\n3. Customer collaboration over Contract negotiation\n4. Responding to change over Following a plan\n\nThat is, while there is value in the items on the right, we value the items on the left more. The meanings of the manifesto items on the left within the agile software development context are:\n\n- **Individuals and interactions.** In agile development, self-organization and motivation are important, as are interactions like co-location and pair programming.\n\n- **Working software.** Working software will be more useful and welcome than just presenting documents to clients in meetings.\n\n- **Customer collaboration.** Requirements cannot be fully collected at the beginning of the software development cycle, therefore continuous customer or stakeholder involvement is very important.\n\n- **Responding to change.** Agile development is focused on quick responses to change and continuous development.\n\nThe Agile Manifesto is based on twelve principles:\n\n1. Customer satisfaction by rapid delivery of useful software.\n2. Welcome changing requirements, even late in development.\n3. Working software is delivered frequently (weeks rather than months).\n4. Working software is the principal measure of progress.\n5. Sustainable development, able to maintain a constant pace.\n6. Close, daily cooperation between business people and developers.\n7. Face-to-face conversation is the best form of communication (co-location).\n8. Projects are built around motivated individuals, who should be trusted.\n9. Continuous attention to technical excellence and good design.\n10. Simplicity, the art of maximizing the amount of work not done, is essential.\n11. Self-organizing teams.\n12. Regular adaptation to changing circumstances.\n\nAgile software development processes are designed to produce useful software quickly. Generally, they are iterative processes where specification, design, development and testing are interleaved. The software is not developed and deployed in its entirety but in a series of increments, with each increment including new system functionality. Although there are many approaches to rapid software development, they share some fundamental characteristics:\n\n1. The processes of specification, design and implementation are concurrent. There is no detailed system specification, and design documentation is minimised or generated automatically by the programming environment used to implement the system. The user requirements document defines only the most important characteristics of the system.\n2. The system is developed in a series of increments. End-users and other system stakeholders are involved in specifying and evaluating each increment. They may propose changes to the software and new requirements that should be implemented in a later increment of the system.\n3. System user interfaces are often developed using an interactive development system that allows the interface design to be quickly created by drawing and placing icons on the interface.\nIncremental development involves producing and delivering the software in increments rather than in a single package (Figure 4.2.). Each process iteration produces a new software increment. The two main advantages to adopting an incremental approach to software development are:\n\n1. *Accelerated delivery of customer services.* Early increments of the system can deliver high-priority functionality so that customers can get value from the system early in its development. Customers can see their requirements in practice and specify changes to be incorporated in later releases of the system.\n2. *User engagement with the system.* Users of the system have to be involved in the incremental development process because they have to provide feedback to the development team on delivered increments.\n\n\n\n**Figure 4.2. Incremental development process.**\n\nHowever, there can be real difficulties with incremental development, particularly in large companies with fairly rigid procedures and in organisations where software development is usually outsourced to an external contractor. The major difficulties with iterative development and incremental delivery are:\n\n1. *Management problems.* Software processes that are generally applied for large system development regularly generate documents that can be used to assess the progress of development. However, in an iterative development process a lots of system documentation is produced that is not cost effective. Furthermore, managers may have difficulties relating to the applied technologies and skill of staff.\n2. *Contractual problems.* The contract between a customer and a software developer is normally based on the system specification. In the case of iterative development the complete specification is only available at the end of development, so it may be difficult to design a contract for the system development.\n3. *Validation problems.* An independent V & V team can start work as soon as the specification is available and can prepare tests in parallel with the system implementation. However, iterative development processes interleave specification and development. Hence, independent validation of incrementally developed systems is difficult.\n4. *Maintenance problems.* Continual change may corrupt the structure of any software system and makes it difficult to understand. This problem can be reduced by continual refactoring program codes.\n\nOf course, there are some types of systems where incremental development and delivery is not the best approach. These are very large systems where development may involve teams\nworking in different locations, some embedded systems where the software depends on hardware development and some critical systems where all the requirements must be analysed to check for interactions that may compromise the safety or security of the system.\n\nProbably the best-known agile method is extreme programming. Other agile approaches include Scrum, Crystal, Adaptive Software Development, DSDM and Feature Driven Development. Although these agile methods are all based around the notion of incremental development and delivery, they propose different processes to achieve this. However, they share a set of principles and therefore have much in common. In this chapter the Extreme Programming, Scrum and Feature Driven Development are overviewed.\n\n4.1 Extreme programming\n\nExtreme Programming (XP) is a software development methodology which is intended to improve software quality and responsiveness to changing customer requirements. As a type of agile software development, it advocates frequent releases in short development cycles, which is intended to improve productivity and introduce checkpoints at which new customer requirements can be adopted [1,20].\n\nOther elements of Extreme Programming include: programming in pairs or doing extensive code review, unit testing of all code, avoiding programming of features until they are actually needed, a flat management structure, simplicity and clarity in code, expecting changes in the customer's requirements as time passes and the problem is better understood, and frequent communication with the customer and among programmers. The methodology takes its name from the idea that the beneficial elements of traditional software engineering practices are taken to \"extreme\" levels.\n\nExtreme Programming was created by Kent Beck in 1999 [16]. Although extreme programming itself is relatively new, many of its practices have been around for some time; the methodology, after all, takes best practices to extreme levels. For example, to shorten the total development time, some formal test documents have been developed in parallel the software is ready for testing. In XP, this concept is taken to the extreme level by writing automated tests which validate the operation of even small sections of software coding, rather than only testing the larger features.\n\nXP attempts to reduce the cost of changes in requirements by having multiple short development cycles, rather than a long one. On this basis, changes are a natural, unavoidable and desirable aspect of software-development projects, and should be planned for, instead of attempting to define a non-variable set of requirements.\n\nExtreme programming also introduces a number of basic values, principles and practices on top of the agile programming framework.\n\nValues\n\nExtreme Programming initially recognizes five values:\n\n− Communication\n− Simplicity\n− Feedback\n− Courage\n− Respect\n\nThese five values are described below.\n\nCommunication\nBuilding software systems requires communicating system requirements to the developers of the system. In formal software development methodologies, this task is accomplished through documentation. Extreme programming techniques can be considered as methods for rapid developments and sharing best practices and knowledge among members of a development team. The goal is to give all developers a shared view of the system which matches the user’s view of the system. For this reason extreme programming favors simple designs, collaboration of users and programmers, frequent verbal communication, and feedback.\n\nSimplicity\n\nExtreme programming encourages starting with the simplest solution. Extra functionality can then be added later. The difference between this approach and more conventional system development methods is the focus on designing and coding for the needs of today instead of those of tomorrow, next week, or next month. This is sometimes summed up as the \"You aren't gonna need it\" (YAGNI) approach. Proponents of XP acknowledge the disadvantage that this can sometimes entail more effort tomorrow to change the system; their claim is that this is more than compensated for by the advantage of not investing in possible future requirements that might change before they become relevant. Coding and designing for uncertain future requirements implies the risk of spending resources on something that might not be needed, while perhaps delaying crucial features. Related to the \"communication\" value, simplicity in design and coding should improve the quality of communication. A simple design with very simple code could be easily understood by most programmers in the team.\n\nFeedback\n\nWithin extreme programming, feedback relates to different dimensions of the system development:\n\n- **Feedback from the system**: by writing unit tests, or running periodic integration tests, the programmers have direct feedback from the state of the system after implementing changes.\n- **Feedback from the customer**: The functional tests are written by the customer and the testers. They will get concrete feedback about the current state of their system. This review is planned once in every two or three weeks so the customer can easily steer the development.\n- **Feedback from the team**: When customers come up with new requirements in the planning game the team directly gives an estimation of the time that it will take to implement.\n\nFeedback is closely related to communication and simplicity. Flaws in the system are easily communicated by writing a unit test that proves a certain piece of code will break. The direct feedback from the system tells programmers to recode this part. A customer is able to test the system periodically according to the functional requirements, known as user stories.\n\nCourage\n\nSeveral practices embody courage. One is the commandment to always design and code for today and not for tomorrow. This is an effort to avoid getting intense in design and requiring a lot of effort to implement anything else. Courage enables developers to feel comfortable with refactoring their code when necessary. This means reviewing the existing system and modifying it so that future changes can be implemented more easily. Another example of courage is knowing when to throw code away: courage to remove source code that is out of date, no matter how much effort was used to create that source code. Also, courage means\npersistence: A programmer might be stuck on a complex problem for an entire day, then solve the problem quickly the next day, but only if they are persistent.\n\n**Respect**\n\nThe respect value includes respect for others as well as self-respect. Programmers should never commit changes that break compilation, that make existing unit-tests fail, or that otherwise delay the work of their peers. Members respect their own work by always striving for high quality and seeking for the best design for the solution at hand through refactoring.\n\nAdopting the four earlier values leads to respect gained from others in the team. Nobody on the team should feel unappreciated or ignored. This ensures a high level of motivation and encourages loyalty toward the team and toward the goal of the project. This value is very dependent upon the other values, and is very much oriented toward people in a team.\n\nRequirements are recorded on Story Cards and the Stories to be included in a release are determined by the time available and their relative priority. The developers break these Stories into development “Tasks”. Developers work in pairs, checking each other’s work and providing the support to always do a good job. An automated unit test framework is used to write tests for a new piece of functionality before that functionality itself is implemented. The Figure 4.3. shows the release cycle of extreme programming.\n\n\n\nExtreme programming involves a number of practices, summarised in Table 4.1.\n\n<table>\n<thead>\n<tr>\n<th>Principle or practice</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Incremental planning</td>\n<td>Requirements are recorded on Story Cards and the Stories to be included in a release are determined by the time available and their relative priority. The developers break these Stories into development “Tasks”.</td>\n</tr>\n<tr>\n<td>Small releases</td>\n<td>The minimal useful set of functionality that provides business value is developed first. Releases of the system are frequent and incrementally add functionality to the first release.</td>\n</tr>\n<tr>\n<td>Simple design</td>\n<td>Enough design is carried out to meet the current requirements and no more.</td>\n</tr>\n<tr>\n<td>Test-first development</td>\n<td>An automated unit test framework is used to write tests for a new piece of functionality before that functionality itself is implemented.</td>\n</tr>\n<tr>\n<td>Refactoring</td>\n<td>All developers are expected to refactor the code continuously as soon as possible code improvements are found. This keeps the</td>\n</tr>\n</tbody>\n</table>\nIn an XP process, customers are intimately involved in specifying and prioritising system requirements. The customer is part of the development team and discusses scenarios with other team members. Together, they develop a ‘story card’ that encapsulates the customer needs. The development team then aims to implement that scenario in a future release of the software.\n\nOnce the story cards have been developed, the development team breaks these down into tasks and estimates the effort and resources required for implementation. The customer then prioritises the stories for implementation, choosing those stories that can be used immediately to deliver useful business support.\n\nExtreme programming takes an extreme approach to iterative development. New versions of the software may be built several times per day and increments are delivered to customers roughly every two weeks. When a programmer builds the system to create a new version, he or she must run all existing automated tests as well as the tests for the new functionality. The new build of the software is accepted only if all tests execute successfully.\n\n4.1.1 Testing in XP\n\nIn the iterative development processes there is no system specification that can be used by an external testing team to develop system tests. As a consequence, some approaches to iterative development have only a very informal testing process. For this reason XP places more emphasis than other agile methods on the testing process. The key features of testing in XP are:\n\n1. Test-first development.\n2. Incremental test development from scenarios.\n3. User involvement in the test development and validation.\n4. The use of automated test harnesses.\n\nTest-first development is one of the most important characteristic in XP. Writing tests first implicitly defines both an interface and a specification of behaviour for the functionality being developed. User requirements in XP are expressed as scenarios or stories and the customer prioritises these for development. The role of the customer in the testing process is to help develop acceptance tests for the stories that are to be implemented in the next release of the\nAcceptance testing is the process where the system is tested using customer data to check that it meets the customer’s needs.\n\nIn the test-first development the test is written before the code. More precisely, the test is written as an executable component before the task is implemented. Once the software has been implemented, the test can be executed immediately. The testing component simulates the submission of input to be tested and check that the result meets the output specification.\n\nThe automated test harness is a system that submits these automated tests for execution.\n\nUsing test-first development, there is always a set of tests that can be quickly and easily executed. This means that whenever any functionality is added to the system, the tests can be run and problems that the new code has introduced can be recognised immediately.\n\n4.1.2 Pair programming\n\nAnother innovative practice that has been introduced is that programmers work in pairs to develop the software. They actually sit together at the same workstation to develop the software. Development does not always involve the same pair of people working together. Rather, the idea is that pairs are created dynamically so that all team members may work with other members in a programming pair during the development process.\n\nThe use of pair programming has a number of advantages:\n\n- **Collective code ownership.** When everyone on a project is Pair Programming, and pairs rotate frequently, everybody gains a working knowledge of the entire codebase.\n- **Better code.** Pair programming acts as an informal review process because each line of code is looked at by at least two people. Code inspections and reviews are very successful in discovering a high percentage of software errors.\n- **Increased discipline.** Pairing partners are more likely to \"do the right thing\" and are less likely to take long breaks.\n- **Resilient flow.** Pairing leads to a different kind of flow than programming alone, but it does lead to flow. Pairing flow is more resilient to interruptions: one programmer deals with the interruption while the other keeps working.\n- **Improved morale.** Pair programming, done well, is much more enjoyable than programming alone, done well.\n- **Mentoring.** Everyone, even junior programmers, has knowledge that others don’t. Pair programming is a painless way of spreading that knowledge.\n- **Team cohesion.** People get to know each other more quickly when pair programming.\n- **Fewer interruptions.** People are more reluctant to interrupt a pair than they are to interrupt someone working alone.\n- **One less workstation.**\n\n4.2 Scrum\n\nScrum is an iterative and incremental agile software development framework for managing software projects and product or application development. In rugby football, a scrum refers to the manner of restarting the game after a minor infraction [19].\n\nIn 1986 by Hirotaka Takeuchi and Ikujiro Nonaka described a new approach to commercial product development that would increase speed and flexibility, based on case studies from manufacturing firms in the automotive, photocopier and printer industries. They called this rugby approach, as the whole process is performed by one cross-functional team across multiple overlapping phases, where the team tries to go the distance as an unit, passing the ball back and forth.\nScrum enables teams to self-organize by encouraging physical co-location of all team members and daily face to face communication among all team members and disciplines in the project. A key principle of Scrum is its recognition that during a project the customers can change their minds about what they want and need, and that unpredicted challenges cannot be easily addressed in a traditional predictive or planned manner. Scrum focuses on maximizing the team's ability to deliver quickly and respond to emerging requirements.\n\nThe Scrum framework consists of Scrum Teams and their associated roles, events, artifacts, and rules. Each component within the framework serves a specific purpose and is essential to Scrum’s success and usage.\n\n4.2.1 Scrum roles\n\nThe Scrum Team consists of a Product Owner, the Development Team, and a Scrum Master. Scrum Teams are self-organizing and cross-functional. Self-organizing teams choose how best to accomplish their work, rather than being directed by others outside the team. Cross-functional teams have all competencies needed to accomplish the work without depending on others not part of the team.\n\nScrum Teams deliver products iteratively and incrementally, maximizing opportunities for feedback. Incremental deliveries of “Done” product ensure a potentially useful version of working product is always available.\n\nProduct Owner\n\nThe Product Owner is responsible for maximizing the value of the product and the work of the Development Team and for managing the Product Backlog. Product Backlog management includes: ordering the items in the Product Backlog to best achieve goals and missions; ensuring that the Product Backlog is visible, transparent, and clear to all; ensuring the Development Team understands items in the Product Backlog to the level needed.\n\nThe Product Owner may represent the desires of a committee in the Product Backlog, but those wanting to change a backlog item’s priority must convince the Product Owner. For the Product Owner to succeed, the entire organization must respect his or her decisions.\n\nDevelopment Team\n\nThe Development Team consists of 3-9 professionals who do the work of delivering a potentially releasable Increment of “Done” product at the end of each Sprint. Only members of the Development Team create the Increment. Development Teams have the following main characteristics:\n\n- They are self-organizing. No one (not even the Scrum Master) tells the Development Team how to turn Product Backlog into Increments of potentially releasable functionality;\n- Development Teams are cross-functional, with all of the skills as a team necessary to create a product Increment;\n- Individual Development Team members may have specialized skills and areas of focus, but accountability belongs to the Development Team as a whole;\n\nScrum Master\n\nThe Scrum Master is responsible for ensuring Scrum is understood and enacted. Scrum Masters do this by ensuring that the Scrum Team adheres to Scrum theory, practices, and rules. The Scrum Master is a servant-leader for the Scrum Team.\n\nThe Scrum Master helps those outside the Scrum Team understand which of their interactions with the Scrum Team are helpful and which aren’t. The Scrum Master helps everyone change these interactions to maximize the value created by the Scrum Team.\n### 4.2.2 Scrum artifacts\n\nScrum’s artifacts represent work or value in various ways that are useful in providing transparency and opportunities for inspection and adaptation. Artifacts defined by Scrum are specifically designed to maximize transparency of key information needed to ensure Scrum Teams are successful in delivering a “Done” Increment.\n\n**Product backlog**\n\nThe Product Backlog is an ordered list of everything that might be needed in the product and is the single source of requirements for any changes to be made to the product. The Product Owner is responsible for the Product Backlog, including its content, availability, and ordering.\n\nA Product Backlog is never complete. The earliest development of it only lays out the initially known and best-understood requirements. The Product Backlog evolves as the product and the environment in which it will be used evolves.\n\nThe Product Backlog lists all features, functions, requirements, enhancements, and fixes that constitute the changes to be made to the product in future releases. Product Backlog items have the attributes of a description, order, and estimate.\n\nAs a product is used and gains value, and the marketplace provides feedback, the Product Backlog becomes a larger and more exhaustive list. Requirements never stop changing, so a Product Backlog is a living artifact. Changes in business requirements, market conditions, or technology may cause changes in the Product Backlog.\n\n**Sprint backlog**\n\nThe Sprint Backlog is the set of Product Backlog items selected for the Sprint plus a plan for delivering the product Increment and realizing the Sprint Goal. The Sprint Backlog is a forecast by the Development Team about what functionality will be in the next Increment and the work needed to deliver that functionality.\n\nThe Sprint Backlog defines the work the Development Team will perform to turn Product Backlog items into a “Done” Increment. The Sprint Backlog makes visible all of the work that the Development Team identifies as necessary to meet the Sprint Goal.\n\nAs new work is required, the Development Team adds it to the Sprint Backlog. As work is performed or completed, the estimated remaining work is updated. When elements of the plan are deemed unnecessary, they are removed. Only the Development Team can change its Sprint Backlog during a Sprint. The Sprint Backlog is a highly visible, real-time picture of the work that the Development Team plans to accomplish during the Sprint, and it belongs solely to the Development Team.\n\n**Increment**\n\nThe Increment is the sum of all the Product Backlog items completed during a Sprint and all previous Sprints. At the end of a Sprint, the new Increment must be “Done,” which means it must be in useable condition and meet the Scrum Team’s Definition of “Done.” It must be in useable condition regardless of whether the Product Owner decides to actually release it.\n\n### 4.2.3 Scrum events\n\nPrescribed events are used in Scrum to create regularity and to minimize the need for meetings not defined in Scrum. Scrum uses time-boxed events, such that every event has a maximum duration. This ensures an appropriate amount of time is spent planning without allowing waste in the planning process.\n\nOther than the Sprint itself, which is a container for all other events, each event in Scrum is a formal opportunity to inspect and adapt something. These events are specifically designed to enable critical transparency and inspection. Failure to include any of these events results in reduced transparency and is a lost opportunity to inspect and adapt.\nThe Sprint\nThe Sprint (Figure 4.4) is a time-box of one month or less during which a “Done”, useable, and potentially releasable product Increment is created. The duration of Sprint is fixed in advance for each sprint and is normally between one week and one month, although two weeks is typical.\n\nEach Sprint has a definition of what is to be built, a design and flexible plan that will guide building it, the work, and the resultant product.\n\nEach sprint is started by a planning meeting, where the tasks for the sprint are identified and an estimated commitment for the sprint goal is made, and ended by a sprint review.\n\nScrum emphasizes working product at the end of the Sprint that is really \"done\"; in the case of software, this means a system that is integrated, fully tested, end-user documented, and potentially shippable.\n\nSprint planning meeting\nThe work to be performed in the Sprint is planned at the Sprint Planning Meeting. This plan is created by the collaborative work of the entire Scrum Team.\n\nIn this part, the Development Team works to forecast the functionality that will be developed during the Sprint. The Product Owner presents ordered Product Backlog items to the Development Team and the entire Scrum Team collaborates on understanding the work of the Sprint.\n\nThe number of items selected from the Product Backlog for the Sprint is solely up to the Development Team. By the end of the Sprint Planning Meeting, the Development Team should be able to explain to the Product Owner and Scrum Master how it intends to work as a self-organizing team to accomplish the Sprint Goal and create the anticipated Increment.\n\nDaily Scrum meeting\nThe Daily Scrum is a 15-minute time-boxed event for the Development Team to synchronize activities and create a plan for the next 24 hours. The Daily Scrum is held at the same time and place each day to reduce complexity. During the meeting, each Development Team member explains:\n\n– What has been accomplished since the last meeting?\n– What will be done before the next meeting?\nWhat obstacles are in the way?\n\nThe Development Team uses the Daily Scrum to assess progress toward the Sprint Goal and to assess how progress is trending toward completing the work in the Sprint Backlog. Daily Scrums improve communications, eliminate other meetings, identify and remove impediments to development, highlight and promote quick decision-making, and improve the Development Team’s level of project knowledge.\n\nSprint review\n\nThis is an informal meeting, and the presentation of the Increment. A Sprint Review is held at the end of the Sprint to inspect the Increment and adapt the Product Backlog if needed. During the Sprint Review, the Scrum Team and stakeholders collaborate about what was done in the Sprint. Based on that and any changes to the Product Backlog during the Sprint, attendees collaborate on the next things that could be done.\n\nThe result of the Sprint Review is a revised Product Backlog that defines the probable Product Backlog items for the next Sprint. The Product Backlog may also be adjusted overall to meet new opportunities.\n\n4.3 Feature driven development (FDD)\n\nFeature driven development is an iterative and incremental software development process. It is one of a number of agile methods. FDD blends a number of industry recognized best practices into a cohesive whole. The description of FDD was first introduced by Peter Coad, Eric Lefebvre and Jeff De Luca in 1999 [21].\n\nFDD is a model-driven short-iteration process that consists of five basic activities. For accurate state reporting and keeping track of the software development project, milestones that mark the progress made on each feature are defined. Figure 4.5 shows the whole development process. During the first two sequential activities, an overall model shape is established. The final two activities are iterated for each feature.\n\n\n\nThe detailed activities of development process are the followings:\n\n**Develop overall model**\n\nThe project started with a high-level walkthrough of the scope of the system and its context. Next, detailed domain walkthroughs were held for each modelling area. In support of each domain, walkthrough models were then composed by small groups, which were presented for peer review and discussion. One of the proposed models, or a merge of them, was selected which became the model for that particular domain area. Domain area models were merged into an overall model, and the overall model shape was adjusted along the way.\n\n**Build feature list**\n\nThe knowledge that was gathered during the initial modelling was used to identify a list of features. This was done by functionally decomposing the domain into subject areas. Subject areas each contain business activities, the steps within each business activity formed the categorized feature list. Features in this respect were small pieces of client-valued functions expressed in the form \"<action> <result> <object>\", for example: “Calculate the total of a\nsale” or “Validate the password of a user”. Features should not take more than two weeks to complete, else they should be broken down into smaller pieces.\n\n**Plan by feature**\nAfter the feature list had been completed, the next step was to produce the development plan. Class ownership has been done by ordering and assigning features (or feature sets) as classes to chief programmers.\n\n**Design by feature**\nA design package was produced for each feature. A chief programmer selected a small group of features that are to be developed within two weeks. Together with the corresponding class owners, the chief programmer worked out detailed sequence diagrams for each feature and refines the overall model. Next, the class and method prologues are written and finally a design inspection is held.\n\n**Build by feature**\nAfter a successful design inspection a per feature activity to produce a completed client-valued function (feature) is being produced. The class owners develop the actual code for their classes. After a unit test and a successful code inspection, the completed feature is promoted to the main build.\n\n### 4.3.1 Milestones\nSince features are small, completing a feature is a relatively small task. For accurate state reporting and keeping track of the software development project it is however important to mark the progress made on each feature. FDD therefore defines six milestones per feature that are to be completed sequentially. The first three milestones are completed during the Design By Feature activity, the last three are completed during the Build By Feature activity. To help with tracking progress, a percentage complete is assigned to each milestone. In the table below the milestones (and their completion percentage) are shown. A feature that is still being coded is 44% complete (Domain Walkthrough 1%, Design 40% and Design Inspection 3% = 44%).\n\n<table>\n<thead>\n<tr>\n<th>Domain Walkthrough</th>\n<th>Design</th>\n<th>Design Inspection</th>\n<th>Code</th>\n<th>Code Inspection</th>\n<th>Promote To Build</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1%</td>\n<td>40%</td>\n<td>3%</td>\n<td>45%</td>\n<td>10%</td>\n<td>1%</td>\n</tr>\n</tbody>\n</table>\n\nFeature-Driven Development is built around a core set of industry-recognized best practices, derived from software engineering. These practices are all driven from a client valued feature perspective. It is the combination of these practices and techniques that makes FDD so compelling. The best practices that make up FDD are shortly described below. For each best practice a short description is given:\n\n− **Domain Object Modelling.** Domain Object Modelling consists of exploring and explaining the domain of the problem to be solved. The resulting domain object model provides an overall framework in which to add features.\n− **Developing by Feature.** Any function that is too complex to be implemented within two weeks is further decomposed into smaller functions until each sub-problem is small enough to be called a feature. This makes it easier to deliver correct functions and to extend or modify the system.\n− **Individual Class (Code) Ownership.** Individual class ownership means that distinct pieces or grouping of code are assigned to a single owner. The owner is responsible for the consistency, performance, and conceptual integrity of the class.\n\n− **Feature Teams.** A feature team is a small, dynamically formed team that develops a small activity. By doing so, multiple minds are always applied to each design decision and also multiple design options are always evaluated before one is chosen.\n\n− **Inspections.** Inspections are carried out to ensure good quality design and code, primarily by detection of defects.\n\n− **Configuration Management.** Configuration management helps with identifying the source code for all features that have been completed to date and to maintain a history of changes to classes as feature teams enhance them.\n\n− **Regular Builds.** Regular builds ensure there is always an up to date system that can be demonstrated to the client and helps highlighting integration errors of source code for the features early.\n\n− **Visibility of progress and results.** By frequent, appropriate, and accurate progress reporting at all levels inside and outside the project, based on completed work, managers are helped at steering a project correctly\n\n### 4.4 Exercises\n\n1. List the main values of Agile Manifesto!\n2. Explain the process of iterative software development!\n3. What are the disadvantages of iterative developments?\n4. What is the refactoring?\n5. What are the main values of Extreme Programming:\n6. What are the benefits of Pair Programming?\n7. Explain the meaning of test-first development!\n8. Explain the meaning of Scrum sprint!\n9. List the basic activities of FDD process!\n10. What are the milestones of FDD process?\n5 Object-oriented development\n\nThe terms object and object-oriented are applied to different types of entity, design methods, systems and programming languages. An object-oriented system is made up of interacting objects that maintain their own local state and provide operations on that state. There is a general acceptance that an object is an encapsulation of information. The representation of the state is private and cannot be accessed directly from outside the object [1,2,4].\n\nAn object is an entity that has a state and a defined set of operations that operate on that state. The state is represented as a set of object attributes. The operations associated with the object provide services to other objects that request these services when some computation is required. Objects communicate by exchanging the information required for service provision. The copies of information needed to execute the service and the results of service execution are passed as parameters.\n\nObjects are created according to an object class definition. An object class definition is both a type specification and a template for creating objects. It includes declarations of all the attributes and operations that should be associated with an object of that class.\n\nObject-oriented design processes involve designing object classes and the relationships between these classes. These classes define the objects in the system and their interactions. When the design is realised as an executing program, the objects are created dynamically from these class definitions.\n\nObject-oriented design is part of object-oriented development where an object-oriented strategy is used throughout the development process:\n\n− **Object-oriented analysis.** It is concerned with developing an object-oriented model of the application domain. The objects in that model reflect the entities and operations associated with the problem to be solved.\n− **Object-oriented design.** It is concerned with developing an object-oriented model of a software system to implement the identified requirements.\n− **Object-oriented programming.** It is concerned with implementing a software design using an object-oriented programming language, such as Java.\n\nThe transition between these stages of development should, ideally, be seamless, with compatible notations used at each stage. Moving to the next stage involves refining the previous stage by adding detail to existing object classes and devising new classes to provide additional functionality.\n\nThe object-oriented systems might have some advantages in comparison to systems, which have been developed with other methods, for example realizing changes with an object-oriented system can be easier because the objects are independent. They may be understood and modified as standalone entities. Changing the implementation of an object or adding services should not affect other system objects.\n\nObjects are, potentially, reusable components because they are independent encapsulations of state and operations. Designs can be developed using objects that have been created in previous designs. This reduces design, programming and validation costs. It may also lead to the use of standard objects and reduce the risks involved in software development.\n\nIn 1990s several object-oriented design methods have been proposed and the Unified Modelling Language (UML) became a unification of the notations used in these methods. In year 2000 the UML was accepted by the International Organization for Standardization (ISO) as a standard for modelling software-intensive systems [3,4,5,6,7,9,18].\nIn the UML, an object class is represented as a named rectangle with two sections. The object attributes are listed in the top section. The operations that are associated with the object are set out in the bottom section. Figure 5.1. illustrates this notation using an object class that models an employee in an organisation. The UML uses the term operation to mean the specification of an action; the term method is used to refer to the implementation of an operation.\n\n\n\nThe class Employee defines a number of attributes that hold information about employees including their name and address, social security number, tax code, and so on. Operations associated with the object are join (called when an employee joins the organisation), leave (called when an employee leaves the organisation), retire (called when the employee becomes a pensioner of the organisation) and changeDetails (called when some employee information needs to be modified). For examples, in Figure 5.2. two objects of class Employee are shown.\n\n\n\nThere are a lot of object-oriented systems where classes may have methods with similar name. In this case, the services of this method are determined by the implementation of methods in the classes. This is called polymorphism in the object-oriented design. In practice, polymorphism appears at the design of the class hierarchy by inheritance. Figure 5.3. shows an example of polymorphism. Classes Circle, Triangle and Square have the same method called area(). These methods are implemented differently in all classes by application of different expression for calculating the area.\n\n\n\nObject-oriented systems are usually modelled by interacting objects. An object model represents the static and most stable phenomena in a modelled domain. Main concepts are\nclasses and associations with attributes and operations. Aggregation and generalization with multiple inheritances are predefined relationships. In UML the objects and their static relationships are presented by class diagrams.\n\nUML supports stereotypes, which are an inbuilt mechanism for logically extending or altering the meaning, display, characteristics or syntax of a basic UML model element such as class and object. Extending classes in UML the next stereotypes are often used:\n\n- **<<boundary>>** stereotype. A boundary class represents a user interface.\n- **<<entity>>** stereotype. Entity classes represent manipulated units of information.\n- **<<control>>** stereotype. Control objects encapsulate logic that is not particularly related to user interface issues.\n\nUML representation of stereotypes applied to classes Car, Login and Bank account are shown in Figure 5.4. together with an icon for their default representation.\n\n\n\nDynamic models describe the dynamic structure of the system and show the interactions between the system objects. Interactions that may be documented include the sequence of service requests made by objects and the way in which the state of the system is related to these object interactions. UML uses interaction diagrams such as sequence diagram to model dynamic behaviour.\n\nThe interactions of a system with its environment can be modelled using an abstract approach that does not include too much detail. The approach that is proposed in the RUP is to develop an use-case model where each use-case represents an interaction with the system. Each of these use-cases can be described in structured natural language. This helps designers identify objects in the system and gives them an understanding of what the system is intended to do\n\n### 5.1 Generalisation\n\nObject classes can be arranged in a generalisation or inheritance hierarchy that shows the relationship between general and more specific object classes. The more specific object class is completely consistent with its parent class but includes further information. In the UML, an arrow that points from a class entity to its parent class indicates generalisation. In object-oriented programming languages, generalisation is implemented using inheritance. The child class inherits attributes and operations from the parent class.\nFigure 5.5. A generalisation hierarchy.\n\nFigure 5.5. shows an example of an object class hierarchy where different classes of plane are shown. Classes lower down the hierarchy have the same attributes and operations as their parent classes but may add new attributes and operations or modify some of those from their parent classes. Class Circle and Polygon contain same attributes and methods. Generalizing these classes the same attributes and methods are added the class Plain. In this hierarchy the class Plain is considered as parent class and classes Circle and Polygon are child classes. The relationship of generalization is denoted by a hollow triangle shape on the parent class end of the line that connects it to one or more child classes.\n\nThe generalisation relationship is often used to create base classes in order to derive subclasses. These classes are called abstract classes and generally cannot be instantiated, but they can be subclasses.\n\n5.2 Association\n\nObjects that are members of an object class participate in relationships with other objects. These relationships may be modelled by describing the associations between the object classes. In the UML, associations are denoted by a line between the object classes that may optionally be annotated with information about the association. Association is a very general relationship and is often used in the UML to indicate that either an attribute of an object is an associated object or the implementation of an object method relies on the associated object. This association relationship indicates that at least one of the two related classes make reference to the other. The association relationship may have and an optional notation at each end indicating the multiplicity of instances of that entity (the number of objects that participate in the association). Multiplicity is given by an integer or an interval of integers. Examples multiplicities are given in the following:\n\n- 1, exactly one instance participates in the association\n- 0..1, no instances, or one instance participates in the association\n- 0..*, zero or more instances participates in the association.\n- 9, exactly 9 instances participates in the association.\n- 3..9, the number of instances in the association between 3 and 9.\nAn example of association relationship is illustrated in Figure 5.6, which shows the association between objects of class Firm and objects of class Manager and Worker. This association represents relationships of such firms, managers and workers where 10 or more workers and 1, 2 or 3 managers work. A worker can be employed only at one firm but managers can be employed at two firms at the same time.\n\n\n\nOne of the most common associations is aggregation that represents a part-whole or part-of relationship and illustrates how objects may be composed of other objects. Composition is a stronger variant of aggregation. Composition usually has a strong life cycle dependency between instances of the container class and instances of the contained class(es). If the container is destroyed, normally every instance that it contains is destroyed as well.\n\n### 5.3 Object-oriented design process\n\nA software development methodology is an organized process of fundamental activities of specification, development, validation and evolution and represents them as separate process phases such as requirements specification, software analysis and design, implementation, testing and so on.\n\nThe purpose of requirements specification phase is to define the complete functional and non-functional software requirements for the system. Domain requirements are a subcategory of requirements. These are requirements that come from the application domain of the system and that reflect characteristics and constraints of that domain.\n\nThe overall purpose of the analysis and design phases is to understand and model the application domain and to translate the requirements into a specification of how to implement the system. Analysis and design phases result in analysis and design model. Analysis is mainly involved with transforming the requirements into an architecture and collection of components that could fully support an implementation of the proposed system. The design model serves as an abstraction of the source code, it consists of design classes structured into design packages and design subsystems with well-defined interfaces, representing what will become components in the implementation.\n\nThe general process for an object-oriented design has a number of stages:\n\n1. Understand and define the context and the modes of use of the system.\n2. Design the system architecture.\n3. Identify the principal objects in the system.\n4. Develop design models.\n5. Specify object interfaces.\n\nAlthough these activities look separate stages the object-oriented design is not a simple, well-structured process. All of the above activities are interleaved and so influence each other. Objects are identified and the interfaces fully or partially specified as the architecture of the\nsystem is defined. As object models are produced, these individual object definitions may be refined, which leads to changes to the system architecture.\n\n### 5.3.1 System context and models of use\n\nThe first stage in any software design process is to develop an understanding of the relationships between the software and its external environment. This helps to provide the required system functionality and structure the system to communicate with its environment. The system context and the model of system use represent two complementary models of the relationships between a system and its environment:\n\n1. The system context is a static model that describes the other systems in that environment.\n2. The model of the system use is a dynamic model that describes how the system actually interacts with its environment.\n\nThe context model of a system may be represented using associations where a simple block diagram of the overall system architecture is produced. The interactions of a system with its environment can be modelled by use-case models where each use-case represents an interaction with the system. Use-cases can be described in structured natural language. This helps designers identify objects in the system and gives them an understanding of what the system is intended to do.\n\n### 5.3.2 Architectural design\n\nThe system architecture can be represented by a number of architectural views. These views capture the major structural design decisions. Architectural views are the abstractions or simplifications of the entire design, in which important characteristics are made more visible by leaving details aside.\n\nDesign activities are centred around the notion of architecture. Once the interactions between the software system and its environment have been defined by use case models, this information can be used as a basis for designing the system architecture. During architectural design the architecturally significant use cases are selected by performing use case analysis on each one and the system is decomposed to a collection of interacting components.\n\nIn UML the architecture of system can be represented by a component diagram. It shows a collection of model elements, such as components, and implementation subsystems, and their relationships, connected as a graph to each other. Component diagrams can be organized into, and owned by implementation sub-systems, which show only what is relevant within a particular implementation subsystem.\n\n### 5.3.3 Object and class identification\n\nThe analysis process starts with the identification of a set of conceptual classes that are the categories of things which are of significance in the system domain. When identifying appropriate classes, a good understanding of the system domain is important.\n\nPossible classes for inclusion may emerge during the course of the requirements specification process. There are a number of other techniques can be used to help identify appropriate classes from a requirements document. Because a class is conceptually a set of objects of the same kind and objects represent things in the system domain, nouns and noun phrases in the requirements document can be used to identifying possible classes. There have been various proposals to identify object classes:\n\n1. Grammatical analysis of a natural language description of a system. Objects and attributes are nouns; operations or services are verbs.\n2. Using tangible entities, things, in the application domain such as car, roles such as worker, events such as request, interactions such as meetings, locations such as offices and so on.\n\n3. Using a behavioural approach where the designer first understands the overall behaviour of the system. The various behaviours are assigned to different parts of the system and an understanding is derived of who initiates and participates in these behaviours. Participants who play significant roles are recognised as objects.\n\n4. Using a scenario-based analysis where various scenarios of system use are identified and analysed in turn. As each scenario is analysed, the team responsible for the analysis must identify the required objects, attributes and operations.\n\nThese approaches help to get started with object identification. Further information from application domain knowledge or scenario analysis may then be used to refine and extend the initial objects. This information may be collected from requirements documents, from discussions with users and from an analysis of existing systems.\n\n5.3.4 Design models\n\nDesign models show the objects or object classes in a system and the relationships between these entities. The design of system essentially consists of design models. Design models can be considered as a transformation of system requirements to a specification of how to implement the system. Design models have to be abstract enough to hide the unnecessary details. However, they also have to include enough detail for programmers to make implementation decisions.\n\nIn general, models are developed at different levels of detail. An important step in the design process, therefore, is to decide which design models has to be developed and the level of detail of these models. This usually depends on the type of system that is being developed. There are two types of models that should be produced to describe an object-oriented design:\n\n1. *Static models*. They describe the static structure of the system using object classes and their relationships. Important relationships are the association, generalisation, dependency, aggregation and composition relationships.\n\n2. *Dynamic models*. They describe the dynamic structure of the system and show the interactions between the system objects. Interactions that may be documented include the sequence of service requests made by objects and the way in which the state of the system is related to these object interactions.\n\nThe UML provides for 14 different static and dynamic models that may be produced to document a design. For examples, some models:\n\n1. *Sub-system models*. This model shows logical groupings of objects into coherent sub-systems. These are represented using a form of class diagram where each sub-system is shown as a package. Sub-system models are static models.\n\n2. *Sequence models*. This model shows the sequence of object interactions. These are represented using an UML sequence or a collaboration diagram. Sequence models are dynamic models.\n\n3. *State machine models*. This model shows how individual objects change their state in response to events. These are represented in the UML using state-chart diagrams. State machine models are dynamic models.\n\nOther models will be discussed in the next chapters: use-case models show interactions with the system; object models describe the object classes; generalisation or inheritance show how classes may be generalisations of other classes; and aggregation models show how collections of objects are related.\n5.3.5 Object interface specification\n\nSoftware components communicate each other using their interfaces. Object interface design is concerned with specifying the detail of the interface to an object or to a group of objects.\n\nThe same object may have several interfaces, each of which is a viewpoint on the methods that it provides. Equally, a group of objects may all be accessed through a single interface.\n\nThe interface representation should be hidden and object operations are provided to access and update the data. If the representation is hidden, it can be changed without affecting the objects that use these attributes. This leads to a design that is inherently more maintainable.\n\nInterfaces can be specified in the UML using the same notation as in a class diagram. However, there is no attribute section, and the UML stereotype <<interface>> should be included in the name part.\n\n5.4 Exercises\n\n1. What is the different objects and object classes?\n2. Explain the information encapsulation of objects!\n3. Can abstract classes be instantiated?\n4. What is the stereotyping?\n5. What is the meaning of polymorphism?\n6. Explain the importance of generalisation of classes!\n7. What types of association exist between classes?\n8. What are the general stages of object-oriented design process?\n9. How objects and classes can be identified?\n10. What is the functionality of interface classes?\nUnified Modelling Language\n\nDue to the rapid development in computer hardware the complexity of computer-based systems continuously increases. New technologies resulting from developments place new demands on software and software engineers. Producing and maintaining high-quality software systems cost-effectively is essential for software industry.\n\nActivities involved in software development such as software specification, design and implementation have already well understood to produce large and complex software systems.\n\nBut application of unified notations, languages and modelling tools can reduce the development costs effectively. The Unified Modelling Language (UML) is such a language. In the last decades, the most significant developments in software engineering are related the emergence of the UML as a standard for object-oriented system description [3,4,5,6,7,9,18].\n\nIn the years after 1980 many object-oriented modelling techniques were being developed to model software development processes. These modelling techniques used different visual modelling techniques and notations.\n\nThree methodologies among them have become popular: the Object Modelling Technique (Jim Rumbaugh), the Object-Oriented Software Engineering method (Ivar Jacobson) and Booch method (Grady Booch). In the mid of 1990s, Rational Software integrated the methods of Object Modelling Technique and Booch method into version 0.8 of UML what was then called the Unified Method. In 1995, Jacobson, who developed Object-Oriented Software Engineering method, joined Rational Software and together with Rumbaugh and Booch developed version 0.9 of the Unified Method in 1996. Later other IT companies joined the UML Consortium developing UML. In 1997 they submitted version 1.0 of the Unified Method, renamed as the Unified Modelling Language to the independent standards body Object management Group. As an independent standards body, the OMG took over the UML development and released subsequent versions of the UML. The latest version, UML 2.5, is released by OMG in 2013.\n\nAlthough the UML is a standard OMG the UML is not just for modelling object-oriented software applications. The UML is a graphical language that was designed to be very flexible and customizable.\n\nThe UML features an underlying meta-model that enables the UML to be flexible enough so that you can do what you need to do with it.\n\nA meta-model is a model of a model. The UML meta-model expresses the proper semantics and structure for UML models. A UML model is made up of many different elements. The meta-model defines the characteristics of these elements, the ways in which these elements can be related, and what such relationships mean. In other words, the UML meta-model sets the rules for how it can be used to model.\n\nThe UML meta-model is also the foundation for UML's extensibility. Using the definitions of UML elements in the meta-model new UML modelling elements can be created. We can add additional properties to the new elements. This allows to give additional characteristics and behaviours to the new element for specific needs, while it still remains compliant with the structure and semantics of the original element that it was based upon. In this way, users can customize the UML to their specific needs.\n\nThe ability of extensibility makes UML to accommodate present as well as future needs. It makes possible to model different systems such as software and business system in the same language that helps the communications of developers and helps easier to understand developments of different areas.\n6.1 Model, modelling\n\nIn a general sense, a *model* is anything used in any way to represent anything else. A model is considered a simplified, abstract view of a complex reality. It can represent objects, phenomena, and processes in a logical way. Modelling helps to better understand the processes and to develop systems that have to meet prescribed requirements. Modelling helps to identify how changes will affect the system. It can help to identify strengths and weaknesses, identify areas that need to be changed or optimized and simulate different process options. It also helps to communicate designs, to clarify complex problems, and ensure that designs come closer to reality prior to implementation. This can save a lot of time and money for the organization, and it enables teams of people to work together more effectively. In software industry modelling is primarily used to visually model the static and dynamic views of software.\n\nUML provides a common modelling language to bring together business analysts, software developers, architects, testers, database designers, and the many other professionals who are involved in software design and development so that they can understand the business, its requirements, and how the software and architectures will be created. A business analyst who practiced in using UML can understand what a software developer is creating using the UML because the UML is a common language. With the ongoing need to think globally when building software, the ability provided by the UML to communicate globally becomes very important.\n\nThe UML can be applied to model business processes, database design, application architectures, hardware designs, and much more. Designing software and systems is a complicated task requiring the coordinated efforts of different groups performing various activities: define of requirements for business and systems, designing software components, constructing databases, assembling hardware to support the systems, and so on.\n\nIn UML different types of diagrams can be used to create various types of models. The UML models consist of different diagram types, model elements, and linkages between model elements. These models are to describe different information from different viewpoints.\n\n6.2 Diagrams in UML\n\nUML diagrams represent two different views of a system model:\n\n1. Static (or *structural*) view: emphasizes the static structure of the system using objects, attributes, operations and relationships. The structural view includes class diagrams and composite structure diagrams.\n\n2. Dynamic (or *behavioural*) view: emphasizes the dynamic behaviour of the system by showing collaborations among objects and changes to the internal states of objects. This view includes sequence diagrams, activity diagrams and state machine diagrams.\n\nUML has 14 types of diagrams divided into two categories. Seven diagram types represent *structural* information, and the other seven represent general types of *behaviour*, including four that represent different aspects of *interactions*.\n\nUML does not restrict UML element types to a certain diagram type. In general, every UML element may appear on almost all types of diagrams. UML profiles may define additional diagram types or extend existing diagrams with additional notations.\n\nStructure diagrams emphasize the things that must be present in the system being modelled. Since structure diagrams represent the structure, they are used extensively in documenting the software architecture of software systems. The UML structure diagrams are the followings:\n\n1. *Class diagram* describes the structure of a system by showing the system's classes, their attributes, and the relationships among the classes.\n2. **Component diagram** describes how a software system is split up into components and shows the dependencies among these components.\n\n3. **Composite structure diagram** describes the internal structure of a class and the collaborations that this structure makes possible.\n\n4. **Deployment diagram** describes the hardware used in system implementations and the execution environments and artifacts deployed on the hardware.\n\n5. **Object diagram** shows a complete or partial view of the structure of an example modelled system at a specific time.\n\n6. **Package diagram** describes how a system is split up into logical groupings by showing the dependencies among these groupings.\n\n7. **Profile diagram** operates at the meta-model level to show stereotypes as classes with the `<<stereotype>>` stereotype, and profiles as packages with the `<<profile>>` stereotype. The extension relation (solid line with closed, filled arrowhead) indicates what meta-model element a given stereotype is extending.\n\nBehaviour diagrams emphasize what must happen in the system being modelled. Since behaviour diagrams illustrate the behaviour of a system, they are used extensively to describe the functionality of software systems:\n\n1. **Activity diagram** describes the business and operational step-by-step workflows of components in a system. An activity diagram shows the overall flow of control.\n\n2. **State machine diagram** describes the states and state transitions of the system.\n\n3. **Use Case diagram** describes the functionality provided by a system in terms of actors, their goals represented as use cases, and any dependencies among those use cases.\n\nInteraction diagrams, a subset of behaviour diagrams, emphasize the flow of control and data among the things in the system being modelled:\n\n1. **Communication diagram** shows the interactions between objects or parts in terms of sequenced messages. They represent a combination of information taken from Class, Sequence, and Use Case Diagrams describing both the static structure and dynamic behaviour of a system.\n\n2. **Interaction overview diagram** provides an overview in which the nodes represent communication diagrams.\n\n3. **Sequence diagram** shows how objects communicate with each other in terms of a sequence of messages. Also indicates the lifespans of objects relative to those message.\n\n4. **Timing diagram** a specific type of interaction diagram where the focus is on timing constraints.\n\n### 6.3 Business models\n\nUML is frequently used in the area of business modelling. Examples of simple business models can effectively present the practical use of UML and provide a good starting point to solve more complex developments. The purpose of this section is to introduce the use of UML diagrams, model elements, and linkages through a simple business modelling example. More examples provided in the next chapters to understand UML in more detail.\n\nBusiness model is an abstract representation of a business that provides a simplified look at various aspects of the business. A business isn't represented with just one type of business model. Different models will emphasize certain business characteristics or concepts while hiding other aspects at the same time. The simplest business models are the organization charts, which are models of a business's overall organizational structure. Other models such as business process models show specific business functions by sequence of activities.\nEach model provides a different view of the business. In the case of an overall business model it is requested to model the structure and interactions between the business's organizations, stakeholders, customers, workers, business functions, business assets, etc.\n\nThe business model should also reflect the architecture, the static structures in the company, the flows of business activities, that is, the dynamic behaviour of the elements in the architecture.\n\nWhen modelling a business using the UML first the next questions is generally considered:\n1. Who will be related to business?\n2. What do they want your business to do for them?\n3. How does your business meet its needs?\n\nFor an example, let us consider an retail shop. People, like customer, seller, shipping worker, etc. or systems, like shipping companies, suppliers, etc. can relate this business. All these people and systems play a role related to this business and they are called business actors. Figure 6.1. shows UML representation of business actors.\n\n\n\nThe reasons or goals for business actors interacts retail shop may be the followings:\n- customers purchase products,\n- sellers billing,\n- sales manager orders goods,\n- shipping companies deliver products to retail shop,\n- bank manages account,\n- and more.\n\nFor these needs retail shop provides services or business. Some typical business functions in retail might be the following:\n- Goods order,\n- Ship order,\n- Shipping,\n- Billing,\n- Storage,\n- And more.\n\nThese actions are called business use cases when business actors will use the business. Figure 6.2. shows the UML representation of business use cases.\n\n\n6.3.1 Business use case diagrams\n\nThe *business use case diagram* represents the functionality of business system in term of business actors. Their goals are represented by business use cases. Use case diagram also shows what is outside of business (the business actors), what is inside the business (the business use cases), and the relationships between the two (Figure 6.3.).\n\n\n\nFigure 6.3. Business use case diagram.\n\nThe lines with arrowheads between a business actor and business use case are association. Associations define a relationship between the two model elements they connect. The direction of the arrow shows which element initiates the activity. In the example in Figure 6.3., the transport worker uses or initiates the Shipping business use case. An association can exist without an arrowhead representing a bi-directional communication path.\n\nBesides association UML contains various linkages defining relationships between elements. They are listed in Table 6.1.\n\n**Table 6.1. Relationships used in UML.**\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Notation</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Association</td>\n<td></td>\n<td>Logical connection or relationship between classes</td>\n</tr>\n<tr>\n<td>Bi-directional association</td>\n<td></td>\n<td>Bi directional logical connection or relationship between classes</td>\n</tr>\n<tr>\n<td>Generalization</td>\n<td></td>\n<td>The generalization relationship indicates that one of the two related classes (the subclass) is considered to be a specialized form of the other (the super type) and superclass is considered as generalisation of subclass.</td>\n</tr>\n<tr>\n<td>Dependency</td>\n<td></td>\n<td>Dependency indicates that one class depends on another because it uses it at some point in time.</td>\n</tr>\n<tr>\n<td>Aggregation</td>\n<td></td>\n<td>Aggregation is an association that represents a part-whole relationship.</td>\n</tr>\n<tr>\n<td>Composition</td>\n<td></td>\n<td>Composition is a stronger variant of association relationship. Composition usually has a strong</td>\n</tr>\n</tbody>\n</table>\nlife cycle dependency between instances of the container class and instances of the contained class(es): If the container is destroyed, normally every instance that it contains is destroyed as well.\n\nRealization\n\nA realization relationship is a relationship between two model elements, in which one model element (the client) realizes (implements or executes) the behaviour that the other model element (the supplier) specifies.\n\n### 6.3.1.1 Use case relationships\n\nUse cases can have relationships with other use cases. UML defines two directed relationships between use cases, the include and extend relationships.\n\nFor an example of these relationships let’s again consider the retail shop business example. In business process models the specific business functions (business use cases) can be modelled by a flow of different activities and could have many different alternate scenarios. Both use case Goods Order and Ship Order certainly includes the activity Send Order. The include relationship in this respect means that the included use case (Send Order) behaviour is inserted in the flow of the base use case(s) (Goods Order, Ship Order).\n\nThis common behaviour can be represented by a dashed arrow with an open arrowhead from the including (base) use case to the included (common part) use case. The arrow is labelled with the keyword «include» (Figure 6.4.).\n\n\n\nScenarios of business use cases in retail business system can be extended by many different optional behaviours. For example the use case Billing can be extended by the optional extending use case Payment by Card. This behaviour can be represented by the extend relationship. It means that the extending use case (Payment by Card) optionally may change the flow (scenario) of the base use case (Billing). Extend relationship is shown as a dashed line with an open arrowhead directed from the extending use case to the extended (base) use case. The arrow is labelled with the keyword «extend» (Figure 6.5.).\n\n\n\nIncludes and extends relationships are useful tools to structure use case models, identify common use cases and simplify complex scenarios.\n\n### 6.3.1.2 Generalisation\n\nBusiness actors are the people or any system that interact with business system. They are not a specific people or system they represent a role that the actor plays with respect to\nbusiness system. An actor can also represent a set of roles. In this case the actor can be represented by an actor who inherits several actors and each inherited actor represents one of the roles. In the other case several actors can play the same role in a particular use case. In this case the shared role can be modelled as an actor inherited by the original actors.\n\nIn the generalization of use cases a parent use case may be specialized into one or more child use cases that represent more specific forms of the parent. A child inherits all structure, behaviour, and relationships of the parent. Generalization is used when two or more use cases have common behaviour, structure, and purpose. In this case the shared parts are captured in a new abstract use case that can be specialized by child use cases.\n\n### 6.3.1.3 Activity diagrams\n\nConsidering again the retail shop example, now we have known the people, businesses, and systems interacting the business and we know what services are provided to meet their needs. What we have to understand now is how business actors interacts the system to provide the business use cases. What are the steps taken and by whom? Business use cases are described by a flow of separate activities. Scenarios define these activities in a textual form and they are called actions in UML. For the graphical representation of activities UML uses activity diagrams.\n\nActivity diagram makes the flow of activities visible and show how a use case is realised. The elements of UML activity diagram are shown in Table 6.2.\n\n<table>\n<thead>\n<tr>\n<th>Notation</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><img src=\"start.png\" alt=\"start\" /></td>\n<td>This element represents the start (initial state) of the workflow.</td>\n</tr>\n<tr>\n<td><img src=\"end.png\" alt=\"end\" /></td>\n<td>The encircled black circle represents the end (final state) of the workflow.</td>\n</tr>\n<tr>\n<td><img src=\"activity.png\" alt=\"activity\" /></td>\n<td>Rounded rectangles represent actions.</td>\n</tr>\n<tr>\n<td><img src=\"decision.png\" alt=\"decision\" /></td>\n<td>Diamonds represent decision points.</td>\n</tr>\n<tr>\n<td><img src=\"synchronization.png\" alt=\"synchronization\" /></td>\n<td>Synchronization point. Black bar represents the start (split) or end (join) of concurrent activities.</td>\n</tr>\n<tr>\n<td><img src=\"arrows.png\" alt=\"arrows\" /></td>\n<td>Arrows run from the start towards the end and represent the order in which activities happen.</td>\n</tr>\n</tbody>\n</table>\n\nDuring design phase business use cases are usually described by alternate scenarios. For an example the use case Sale Process can be realised by the following scenario:\n1. Customer enters retail shop.\n2. Customer chooses products.\n3. Customer presents products to seller.\n4. Seller scans all products.\n5. Seller provides total cost.\n6. Seller inquires the payment method.\n7. If customer provides payment by cash customer pass payment and seller accepts it, otherwise payment is by credit card and customer authorizes payment by giving PIN code.\n8. Customer receives receipt and products.\n\nThis scenario gives the activity diagram shown in Figure 6.6. The activity diagram shows how Customer and Seller interacts the business system in the realization of use case Sale Process. The two business actors are shown at the top of the columns in the diagram. These columns are called swimlanes. Any activity in a given column is performed by the actor listed at the top of the swimlane. The flow starts at the start state and flows as indicated by the arrows.\n\nAt the decision point the flow of activities is controlled by the payment method required by Seller.\n\nThe diagram show two activities, Receive Receipt and Receive Products, can happen in parallel. This is shown in activity diagram by using a synchronization point. The two flows that come out of the bar indicate that they can happen independently. When two or more flows come into a synchronization point, it indicates that the workflow cannot continue until all the inflowing activities are complete. The last activity, Customer Leaves, is the terminating activity to the flow.\n6.3.2 Business analysis model\n\nAfter development of business use case models and realizing the use cases by activity diagrams we have the knowledge of how business actors outside of business want to use the\nsystem, how they interact with the system and what services the system provides for them. Now the purpose is to find what people, assets, etc. will be used to provide the services of business. Review of business use case diagrams and activity diagrams helps to determine business workers (internal people) and business entities (assets, information, etc.) that are involved in these activities. Figure 6.7 shows an example of business workers and business entities for the retail shop.\n\n\n\nThe relations between business workers and entities are shown in the business analysis model. This provides an inside look at how people interact with other business workers, business actors, and business entities to achieve the business processes defined in the business use case model.\n\nA partial business objects diagram is shown in Figure 6.8 including business workers, business entities and their static relationships.\n\n\n\n### 6.3.2.1 Sequence diagrams\nThe business objects diagram presented in the previous section captured the static relationships between the business actors, workers and entities. The view of dynamic interactions between these elements over time is also an important aspect in system development. The dynamic views of the system can be represented by using a type of UML interaction diagram called sequence diagram. A sequence diagram shows all the interactions between the model elements for a given scenario arranged in a time sequence. It represents graphically how object interacts each other by messages [18].\n\nFor an example let’s consider the sequence diagram shown in Figure 6.9. In the diagram a scenario of an online order process is captured. The purpose of using sequence diagram is the graphical representation of interactions between objects that realise the functionality of the given scenario. Objects that live simultaneously are shown as parallel vertical lifelines and horizontal arrows represent the messages exchanged between them.\n\nDiagram shows how the online order process is realised in a time sequence:\n\n1. An Order Entry Window object (instantiated by an business actor) send a message „prepare” to Order object\n2. An Order object send a message „prepare” to OrderLine for all order line in the order.\n3. Every Order Line objects send a „check” message to the related Stock Item object to check the amount of item in the stock. If the required amount of item is available the Stock Item reduces the amount of available item in the stock by the amount of ordered item. If the amount of item in stock is not sufficient Stock Item object creates a Reorder Item object and then Order Line object creates a new Delivery Item object.\n4. It is shown in the diagram that an object may send message to itself. This event is indicated by a line returning back to itself and called self-delegation.\n5. The diagram also shows an example of the use of iteration marker of *. Application of iteration marker provides a multiple send of message prepare() to Order Line object, i.e. Order object creates as many Order Line objects as included in order. In the diagram three conditional events are captured.\n6. Stock Item object creates a Reorder Item object only if needsToReorder==true, Order Line object creates a new Delivery Item object if hasStock==false and Stock Item object reduces the amount of item if hasStock=true.\n7. For an example the diagram contains a return arrow indicating that the control is given back to Order Line object after reorder Item objects is created.\n6.3.2.2 Concurrent processes\n\nSequence diagrams are also capable to represent dynamic interaction of concurrent objects. The example shown in Figure 6.10. depicts objects controlling transactions in a bank.\n\nAfter the Transaction object is instantiated it creates (by new method) a Transaction Coordinator object. Transaction Coordinator has a function to check the transaction. It creates as many Transaction Checker object as several control task has to be done in accordance with bank rules. In this example two of them (first and second) are created. Both have the own independent control function. The two control tasks are carried out in parallel and there is no need for any timing or synchronization between them. They operate asynchronously. As one of Transaction Checker finishes its control task notifies the Transaction Coordinator object. At this time Transaction Coordinator object checks whether other Transaction Checker has finished its task. If both control task are finished Transaction Coordinator object send a message to Transaction object that transaction is OK.\n\nThe rectangles located along lifelines indicate a time interval during which object is activated. These rectangles are called activation. Some of the arrowhead on Figure 6.10. are incomplete. These half-arrowheads denote asynchronous messages. If an object sends an asynchronous message, it can continue processing and doesn’t have to wait for a response. Asynchronous messages sent to an object start a new thread or communicate an existing thread.\nThe examples of other interaction diagrams will be presented in Chapter 8.\n\n6.4 Exercises\n\n1. What is the meaning of model?\n2. What can behaviour diagrams be used for?\n3. What can structure diagrams be used for?\n4. Explain the concept of actor!\n5. What relationship can be defined between actors?\n6. What is different between use case model and use case diagram?\n7. What can use case diagrams be used for?\n8. List the graphical elements of activity diagram!\n9. What can business analysis model used for and what elements it may has?\n10. List the graphical elements of sequence diagram!\n11. What does the „extend” relationship mean between two use cases?\n12. What does the „include” relationship mean between two use cases?\n7 Requirements analysis\n\nThe phases of requirements analysis and design are discussed in the frame of the Rational Unified Process (RUP) software development process in the next two chapters. RUP is based on the Unified Modelling Language (UML) as an object-oriented graphical modelling language, so the practical examples presented should not be considered general in the practice of other development methodologies [3,10,11,12,17,22].\n\nThe purpose of requirements discipline in RUP is to definition of the requirement specification capturing the complete functional and non-functional software requirements for the system.\n\nIt is important, first of all, to understand the definition and scope of the problem which we are trying to solve with this system. The models developed during Business Modelling can serve as valuable input to this effort. Business modelling helps to understand the structure and the dynamics of the organization in which a system is to be deployed and derive the system requirements needed to support the target organization.\n\nA requirement is defined as a condition or capability to which a system must conform. Requirements management is a systematic approach to finding, documenting, organizing and tracking the changing requirements of a system.\n\nThere are many different kinds of requirements. Requirements are usually looked upon as statements of text fitting into one of the following categories:\n\n1. **User requirements**. User requirements focus on the needs and goals of the end users. They are statements of what services the system is expected to provide and the constraints under which it must operate.\n2. **System requirements**. They set out the system’s functions, services and operational constraints in detail.\n\nSoftware system requirements are often classified as functional and non-functional requirements:\n\n1. **Functional requirements**. They specify actions that a system must be able to perform, without taking physical constraints into consideration. Functional requirements thus specify the input and output behaviour of a system.\n2. **Non-functional requirements**. Many requirements are non-functional, and describe only attributes of the system or attributes of the system environment. They are often categorized as usability, reliability, performance, and substitutability requirements. They are often requirements that specify need of compliance with any legal and regulatory requirements. They can also be design constraints due to the operating system used, the platform environment, compatibility issues, or any application standards that apply.\n\nDomain requirements are a subcategory of requirements. These are requirements that come from the application domain of the system and that reflect characteristics and constraints of that domain. They are formulated by domain-specific terminology. They may be functional or non-functional requirements.\n\nThe user requirements are provided by functional requirements. The functional requirements are often best described in a UML use-case model and in use cases. Every functionality of system is modelled by one or more use cases.\n\nThe general objectives of the requirements discipline is:\nTo establish and maintain agreement with the customers and other stakeholders on what the system should do.\n\nTo provide system developers with a better understanding of the system requirements.\n\nTo define the boundaries of the system.\n\nTo provide a basis for planning the technical contents of iterations.\n\nTo provide a basis for estimating cost and time to develop the system.\n\nTo define a user-interface for the system, focusing on the needs and goals of the users.\n\nIn the frame of RUP methodology the activities and artifacts are organized into workflow details as follows:\n\n- Analyze the Problem\n- Understand Stakeholder Needs\n- Define the System\n- Manage the Scope of the System\n- Refine the System Definition\n- Manage Changing Requirements\n\nEach workflow detail represents a key skill that need to be applied to perform effective requirements management. Analyze the Problem and Understand Stakeholder Needs are focused on during the Inception phase of a project, whereas the emphasis is on Define the System and Refine the System Definition during the Elaboration phase. Manage the Scope of the System and Manage Changing Requirements are done continuously throughout the development project.\n\nThe workflow details are listed above in the sequence that is most likely applied to the first iteration of a new project. They are applied continuously in varied order as needed throughout the project.\n\n### 7.1 Analyse the problem\n\nProblem analysis is done to understand problems, initial stakeholder needs, and propose high-level solutions. It is an act of reasoning and analysis to find \"the problem behind the problem\". During problem analysis, agreement is gained on the real problems and stakeholders are identified. Also, initial boundaries of the solution and constraints are defined from both technical and business perspectives.\n\nThe purpose of this workflow detail is to:\n\n- Gain agreement on the problem being solved,\n- Identify stakeholders,\n- Define the system boundaries, and\n- Identify constraints imposed on the system.\n\n### 7.1.1 Definition of glossary\n\nThe first step in any problem analysis is to make sure that all parties involved agree on what is the problem that we are trying to solve with our system. In order to avoid misunderstandings, it is important to agree on common terminology which will be used throughout the project and provide a consistent set of definitions for the system. Early on, we should begin defining our project terms in a glossary which will be maintained throughout the project lifecycle.\n7.1.2 Find actors\n\nIn order to fully understand the problem, it is very important to identify the stakeholders. Some of these stakeholders, the users of the system, will be represented by actors in our use-case model.\n\nA use-case model is a model of the system's intended functions and its surroundings, and serves as a contract between the customer and the developers. It describes a system's requirements in terms of use cases. The most important purpose of a use-case model is to communicate the system's behaviour to the customer or end user.\n\nThe functionality of a system is defined by different use cases, each of which represents a specific flow of events. The description of a use case defines what happens in the system when the use case is performed. Each use case has a task of its own to perform. The collected use cases constitute all the possible ways of using the system.\n\nTo fully understand the system's purpose it must be known who the system is for, that is, who will be using the system. Different user types are represented as actors. An actor defines a role that users of the system can play when interacting with it. An actor instance can be also played by either an individual or an external system. An actor may be anything that exchanges data with the system. The difference between an actor and an individual system user is that an actor represents a particular class of user rather than an actual user. Several users can play the same role, which means they can be one and the same actor. In that case, each user constitutes an instance of the actor.\n\nThe principal symbol representing an actor in UML is shown in Figure 7.1.\n\n\n\nFigure 7.1. UML representation of an actor.\n\nFinding the actors means the establishing the boundaries of the system, which helps in understanding the purpose and extent of the system. Only those who directly communicate with the system need to be considered as actors. The following set of questions is useful to have in mind when you are identifying actors:\n\n- Who will supply, use, or remove information?\n- Who will use this functionality?\n- Who is interested in a certain requirement?\n- Where in the organization is the system used?\n- Who will support and maintain the system?\n- What are the system’s external resources?\n- What other systems will need to interact with this one?\n\nAfter identifying an actor a brief description of it should be given including information about:\n\n- What or who the actor represents.\n- Why the actor is needed.\n- What interests the actor has in the system.\n\n7.1.3 Develop requirements management plan\n\nSince requirements are things to which the system being built must be conform, it makes sense to find out what the requirements are, write them down, organize them, and track them...\nin the event they change. The requirements management emphasizes the importance of tracking changes to maintain agreements between stakeholders and the project team.\n\nThe effective requirements management include maintaining a clear statement of the requirements, along with applicable attributes for each requirement type and traceability to other requirements and other project artifacts. It provides guidance on the requirements artifacts that should be developed, the types of requirements that should be managed for the project, the requirements attributes that should be collected and the requirements traceability that will be used in managing the product requirements.\n\nA Requirements Management Plan specifies the control mechanisms which will be used for measuring, reporting, and controlling changes to the product requirements.\n\n7.1.4 Develop Project Vision document\n\nThe primary artifact in which we document the problem analysis information is the Vision document, which identifies the high-level user or customer view of the system to be built.\n\nThe Vision document provides a complete vision for the software system under development and supports the contract between the funding authority and the development organization. Every project needs a source for capturing the expectations among stakeholders. The vision document is written from the customer’s perspective, focusing on the essential features of the system and acceptable levels of quality. The Vision should include a description of what features will be included. It should also specify operational capacities (volumes, response times, accuracies), user profiles (who will be using the system), and inter-operational interfaces with entities outside the system boundary, where applicable. The Vision document provides the contractual basis for the requirements visible to the stakeholders.\n\n7.2 Understand stakeholder needs\n\nThe purpose of this workflow detail is to elicit and collect information from the stakeholders of the project in order to understand what their needs are. The collected stakeholder requests can be regarded as a \"wish list\" that will be used as primary input to defining the high-level features of our system, as described in the Vision. This activity is mainly performed during iterations in the inception and elaboration phases.\n\nThe key activity of this workflow is to elicit stakeholder requests using such input as business rules, enhancement requests, interviews and requirements workshops. The primary outputs are collections of prioritized features and their critical attributes.\n\nThis information results in a refinement of the Vision document, as well as a better understanding of the requirements attributes. Another important output is an updated Glossary of terms to facilitate common vocabulary among team members.\n\nAlso, during this workflow detail discussion of the functional requirements of the system in terms of its use cases and actors is started. Those non-functional requirements, which do not fit easily into the use-case model, should be documented in the Supplementary Specifications.\n\n7.2.1 Elicit stakeholder requests\n\nIn this step, the purpose is to elicit the stakeholder’s needs relating to the project. Examples of stakeholders are investor, shareholder, buyer, designer, documentation writer and so on. The following techniques can be applied to collect and elicit relevant information from the stakeholders:\n\n- Interviews.\n- Requirements Workshop.\n- Brain-storming and idea reduction.\n− Use-Case Workshop.\n− Storyboarding.\n− Role playing.\n− Review of existing requirements.\n\n7.2.2 Find use cases\n\nAfter finding actors and collecting stakeholder’s needs we have to identify use cases defining the functionality of the system. Use cases are a technique for capturing the functional requirements of a system. A use case describes what happens in the system when an actor interacts with the system to execute the use case, it specifies the behaviour of a system or some subset of a system.\n\nThe collected use cases constitute all the possible ways of using the system. Each of use cases represents a specific flow of events. Then Flow of Events of a use case contains the most important information derived from use-case modelling work. It should describe the use case's flow of events clearly enough for an outsider to easily understand it. The flow of events should present what the system does, not how the system is designed to perform the required behaviour.\n\nUse cases are graphically represented as an oval with the name of its functionality written below it (Figure 7.2.).\n\n\n\nFollowing questions can be useful when identifying use cases:\n\n− For each actor you have identified, what are the tasks in which the system would be involved?\n− Does the actor need to be informed about certain occurrences in the system?\n− Will the actor need to inform the system about sudden, external changes?\n− Does the system supply the business with the correct behaviour?\n− Can all features be performed by the use cases you have identified?\n− What use cases will support and maintain the system?\n− What information must be modified or created in the system?\n\nUse cases that are often overlooked, since they do not represent what typically are the primary functions of the system, can be of the following kind:\n\n− System start and stop.\n− Maintenance of the system. For example, adding new users and setting up user profiles.\n− Maintenance of data stored in the system. For example, the system is constructed to work in parallel with a legacy system, and data needs to be synchronized between the two.\n− Functionality needed to modify behaviour in the system. An example would be functionality for creating new reports.\n\nSimilarly to actors the brief description of the use case should be given reflecting its purpose, the actors involved in the use case and the related glossary items.\n\nDiagrams with actors, use cases, and relationships among them are called use-case diagrams and illustrate relationships in the use-case model (Figure 7.3.).\nA use-case model is a model of the system's intended functions and its surroundings, and serves as a contract between the customer and the developers. It describes a system's requirements in terms of use cases.\n\n### 7.2.3 Manage dependencies\n\nThe introduction of notion of requirements types helps separate the different levels of abstraction and purposes of the requirements. Changes to requirements naturally impact the models produced.\n\nKeys to effective requirements management include maintaining a clear statement of the requirements, along with applicable attributes for each requirement type and traceability to other requirements and other project artifacts. A Requirements Management Plan should be developed to specify the information and control mechanisms that will be collected and used for measuring, reporting, and controlling changes to the product requirements. Its purpose is to describe how the project will set up requirements documents and requirement types, and their respective requirement attributes and traceability. Using attributes requirements can be specified more:\n\n- It helps the allocation of resources\n- It helps the effective project monitoring\n- We can define metrics\n- We can manage risks\n- It helps to estimate costs\n- It helps to manage the Vision\n\nSetting dependencies between requirements provides relations between them and we can keep track how the changes in requirements influence other requirements. Regular reviews, along with updates to the attributes and dependencies, should be done whenever the requirements specifications are updated.\n\n### 7.3 Define the system\n\nThe purpose of this workflow detail is to:\n\n- Align the project team in their understanding of the system.\n- Perform a high-level analysis on the results of collecting stakeholder requests.\n- Refine the Vision to include the features to include in the system, along with appropriate attributes.\n- Refine the use-case model, to include outlined use cases.\n- More formally document the results in models and documents.\nProblem Analysis and activities for Understanding Stakeholder Needs create early iterations of key system definitions, including the features defined in the Vision document, a first outline to the use-case model and the Requirements Attributes. In Defining the System you will focus on identifying actors and use cases more completely, and expand the global non-functional requirements as defined in the Supplementary Specifications. Refining and structuring the use-case model has three main reasons for:\n\n- To make the use cases easier to understand.\n- To partition out common behaviour described within many use cases\n- To make the use-case model easier to maintain.\n\nAn aspect of organizing the use-case model for easier understanding is to group the use cases into packages. A model structured into smaller units is easier to understand. It is easier to show relationships among the model's main parts if they are expressed in terms of packages. The use-case model can be organized as a hierarchy of use-case packages, with \"leaves\" that are actors or use cases.\n\nA use-case package contains a number of actors, use cases, their relationships, and other packages; thus, there may be a multiple levels of use-case packages. Use-case packages can reflect order, configuration, or delivery units in the finished system. The packages can be organised according the principles:\n\n- A package of use cases can be related to a subsystem.\n- A package of use cases can be related to an actor.\n- Packages can be formed by any logical grouping.\n\n7.4 Manage the scope of the system\n\nThe objectives of this workflow detail are to:\n\n- Prioritize and refine input to the selection of features and requirements that are to be included in the current iteration.\n- Define the set of use cases (or scenarios) that represent some significant, central functionality.\n- Define which requirement attributes and traceabilities to maintain.\n\nThe scope of a project is defined by the set of requirements allocated to it. Managing project scope, to fit the available resources such as time, people, and money is key to managing successful projects. Managing scope is a continuous activity that requires iterative or incremental development, which breaks project scope into smaller more manageable pieces.\n\nUsing requirement attributes, such as priority, effort, and risk, as the basis for negotiating the inclusion of a requirement is a particularly useful technique for managing scope.\n\nProject scope should be managed continuously throughout the project. A better understanding of system functionality is obtained from identifying most actors and use cases. Non-functional requirements, which do not fit in the use-case model, should be documented in the Supplementary Specifications. The values of requirements attributes: priority, effort, cost, risk values etc., are determined from the appropriate stakeholders. These will be used in planning the iterations and identifying the architecturally significant use cases.\n\n7.5 Refine the system definition\n\nThe purpose of this workflow detail is to further refine the requirements in order to:\n\n- Describe the use case's flow of events in detail.\n- Detail Supplementary Specifications.\n- Develop a Software Requirements Specification, if more detail is needed, and\n- Model and prototype the user interface.\n\nThe output of this workflow detail is a more in-depth understanding of system functionality expressed in detailed use cases, revised and detailed Supplementary Specifications, as well as user-interface elements. A formal Software Requirements Specification may be developed, if needed, in addition to the detailed use cases and Supplementary Specifications.\n\nIt is important to work closely with users and potential users of the system when modelling and prototyping the user-interface. This may be used to address usability of the system, to help uncover any previously undiscovered requirements and to further refine the requirements definition.\n\nThe Requirements Management Plan defines the attributes to be tracked for each type of requirement. The most important attributes are the benefit, the effort to implement, the risk to the development effort, the stability, and architectural impact of each requirement.\n\nRegular reviews, along with updates to the attributes and dependencies, should be done, as shown in the Manage Changing Requirements workflow detail, whenever the requirements specifications are updated.\n\n### 7.5.1 Details of use cases\n\nThe functionality of a system is defined by the use cases, each of which represents a specific flow of events. A use case describes what happens in the system when an actor interacts with the system to execute the use case. The use cases describe all the possible ways of using the system. The use case does not define how the system internally performs its tasks in terms of collaborating objects. This is left for the use-case realizations to show.\n\nIn an executing system, an instance of a use case corresponds to a specific flow of events that is invoked by an actor and executed as a sequence of events among a set of objects. We call this the realization of the use case. Often, the same objects participate in realizations of more than one use case.\n\nThe Flow of Events of a use case contains the most important information derived from use-case modelling work. It should describe the use case's flow of events clearly enough for an outsider to easily understand it. Guidelines for the contents of the flow of events are:\n\n- Describe how the use case starts and ends\n- Describe what data is exchanged between the actor and the use case\n- Describe the flow of events, not only the functionality. To enforce this, start every action with \"When the actor ...\n- Describe only the events that belong to the use case, and not what happens in other use cases or outside of the system\n- Detail the flow of events, all \"what\" should be answered. Remember that test designers are to use this text to identify test cases.\n\nThe two main parts of the flow of events are basic flow of events and alternative flows of events. The basic flow of events should cover what \"normally\" happens when the use case is performed. The alternative flows of events cover behaviour of optional or exceptional character in relation to the normal behaviour, and also variations of the normal behaviour.\n\nBoth the basic flow of events and the alternative flows events should be further structured into steps or sub-flows. A sub-flow should be a segment of behaviour within the use case that has a clear purpose, and is \"atomic\" in the sense that either all or none of the actions is done.\n7.5.2 Modelling and prototyping user-interface\n\nThe purpose of modelling user-interface is to build a model of the user interface that supports the reasoning about, and the enhancement of, its usability. For each use case prioritized to be considered from a usability perspective in the current iteration, we have to take the following steps:\n\n- Describing the characteristics of actors related to use case\n- Creating a use-case storyboard. A use-case storyboard is a logical and conceptual description of how a use case is provided by the user interface, including the interaction required between the actors and the system. The use-case storyboard has various properties, such as text fields and diagrams that describe the usability aspects of the use case.\n- Describing the flow of events - storyboard. The step-by-step description of each use case that is input to this activity need to be refined and focused on usability issues; this refinement is captured in the Flow of Events - Storyboard property of the use-case storyboard.\n- Capturing usability requirements on the use-case storyboard\n- Identification of boundary classes needed by the use-case storyboard. In this step we identify the boundary classes needed to provide the user interface of the use case.\n- Describe Interactions Between Boundary Objects and Actors. Illustration of the interactions between the participating boundary objects by creating one or more collaboration diagrams. The collaboration diagram should also show interactions between the system and its actors. The flow of events usually begins when one of the actors requests something from the system, since an actor always invokes the use case.\n\nFor the identified boundary classes, we have to describe:\n\n- Responsibilities of boundary classes\n- Attributes of boundary classes\n- Relationships between boundary classes\n- Usability requirements on boundary classes\n\n7.6 Manage changing requirements\n\nThe purpose of this workflow detail is to:\n\n- Evaluate formally submitted change requests and determine their impact on the existing requirement set.\n- Structure the use-case model.\n- Set up appropriate requirements attributes and traceabilities.\n- Formally verify that the results of the Requirements discipline conform to the customer's view of the system.\n\nChanges to requirements naturally impact the developed models. Identifying the relationships between requirements and other artifacts are the key to understanding the impact of requirements change.\n\nRegular reviews, along with updates to the attributes and dependencies, should be done as shown in this workflow detail whenever the requirements specifications are updated.\n\n7.6.1 Structure the use case model\n\nThere are three main reasons for structuring the use-case model:\n\n- To make the use cases easier to understand.\n- To partition out common behaviour described within many use cases\n- To make the use-case model easier to maintain.\n\nIn order to structure the use cases models, we have three kinds of relationships: the extend and include relationships between use cases and generalization.\n\n**Extend relationship between use cases**\n\nIf there is a part of a base use case that is optional, or not necessary to understand the primary purpose of the use case, it can be factor out to an addition use case in order to simplify the structure of the base use case. The addition is implicitly inserted in the base use case, using the extend-relationship\n\nAn extend-relationship is a relationship from an extension use case to a base use case, specifying how the behaviour defined for the extension use case can be inserted into the behaviour defined for the base use case. It is implicitly inserted in the sense that the extension is not shown in the base use case. The extensions can be used for several purposes:\n\n- To show that a part of a use case is optional, or potentially optional, system behaviour.\n- To show that a sub-flow is executed only under certain conditions, such as triggering an alarm.\n- To show that there may be a set of behaviour segments of which one or several may be inserted at an extension point in a base use case. The behaviour segments that are inserted will depend on the interaction with the actors during the execution of the base use case.\n\nThe extension is conditional, which means its execution is dependent on what has happened while executing the base use case. The base use case does not control the conditions for the execution of the extension, the conditions are described within the extend relationship. The extension use case may access and modify attributes of the base use case. The base use case, however, cannot see the extensions and may not access their attributes.\n\nThe base use case is implicitly modified by the extensions. We can say that the base use case defines a modular framework into which extensions can be added, but the base does not have any visibility of the specific extensions.\n\nThe base use case should be complete in and of itself, meaning that it should be understandable and meaningful without any references to the extensions. However, the base use case is not independent of the extensions, since it cannot be executed without the possibility of following the extensions.\n\nFigure 7.4. shows an example for application of extend relationship.\n\n\n\n**Include relationship between use cases**\n\nIf there is a part of a base use case that represents a function of which the use case only depends on the result, not the method used to produce the result it can be factored out to an addition use case. The addition is explicitly inserted in the base use case, using the include-relationship.\n\nAn include-relationship is a relationship from a base use case to an inclusion use case, specifying how the behaviour defined for the inclusion use case is explicitly inserted into the behaviour defined for the base use case.\n\nThe include-relationship connects a base use case to an inclusion use case. The inclusion use case is always abstract. It describes a behaviour segment that is inserted into a use-case\ninstance that is executing the base use case. The base use case has control of the relationship to the inclusion and can depend on the result of performing the inclusion, but neither the base nor the inclusion may access each other's attributes. The inclusion is in this sense encapsulated, and represents behaviour that can be reused in different base use cases.\n\nReasons for using the include-relationship are as follows:\n\n- Factor out behaviour from the base use case that is not necessary for the understanding of the primary purpose of the use case, only the result of it is important.\n- Factor out behaviour that is in common for two or more use cases.\n\nThe include relationship is shown in Figure 7.5.\n\n\n\n**Generalization**\n\nIf there are use cases that have commonalities in behaviour and structure and similarities in purpose, their common parts can be factored out to a base use case (parent) that is inherited by addition use cases (children). The child use cases can insert new behaviour and modify existing behaviour in the structure they inherit from the parent use case. A generalization is a taxonomic relationship between a more general element and a more specific element. The more specific element is fully consistent with the more general element, and contains additional information.\n\nMany things in real life have common properties. Objects can have common properties as well, which can be clarified using a generalization between their classes. By extracting common properties into classes of their own, it is possible to change and maintain the system more easily in the future.\n\nA generalization shows that one class inherits from another. The inheriting class is called a descendant. The class inherited from is called the ancestor. Inheritance means that the definition of the ancestor including any properties such as attributes, relationships, or operations on its objects is also valid for objects of the descendant. The generalization is drawn from the descendant class to its ancestor class.\n\nA use-case-generalization is a relationship from a child use case to a parent use case, specifying how a child can specialise all behaviour and characteristics described for the parent.\n\nA parent use case may be specialized into one or more child use cases that represent more specific forms of the parent. A child inherits all structure, behaviour, and relationships of the parent. Children of the same parent are all specializations of the parent. This is generalization as applicable to use cases.\n\nGeneralization is used when two or more use cases have commonalities in behaviour, structure, and purpose. When this happens, the shared parts can be described in a new, often abstract, use case that is then specialized by child use cases. The representation of use case generalization is shown in Figure 7.6.\n\n\n\nAn actor-generalization from an actor type (descendant) to another actor type (ancestor) indicates that the descendant inherits the role the ancestor can play in a use case.\nA user can play several roles in relation to the system, which means that the user may, in fact, correspond to several actors. To make the model clearer, the user can be represented by one actor who inherits several actors. Each inherited actor represents one of the user's roles relative to the system.\n\nSeveral actors can play the same role in a particular use case. The shared role is modelled as an actor inherited by the two original actors. This relationship is shown with actor-generalizations. The representation of use case generalization is shown in Figure 7.7.\n\n\n\n### 7.6.2 Review requirements\n\nThe purpose is to formally verify that the results of Requirements conform to the customer's view of the system. The following guidelines are helpful when reviewing the results of Requirements:\n\n- Always conduct reviews in a meeting format, although the meeting participants might prepare some reviews on their own.\n- Continuously check what is produced to make sure the product quality is as high as possible. Checkpoints are provided for this purpose; refer to the checkpoints for each analysis activity. They can be used for informal review meetings or in daily work.\n- Normally, the review should be divided into the following meetings:\n \n a) A review of change requests which impact the existing requirements set.\n b) A review of the entire use-case model.\n c) A review of the use cases, along with their diagrams. If the system is large, break this review into several meetings, possibly one per Use-Case Package or Software Requirements Specification.\n\n### 7.7 Exercises\n\n1. What are the requirements?\n2. What are the workflow details of Requirement discipline?\n3. What are the types of requirements?\n4. List some non-functional requirements!\n5. List some stakeholders in a software development project!\n6. Why requirement management is so important?\n7. How use cases can be structured?\n8. What is a scenario?\n9. Explain the main points of workflow detail Manage the Scope of the System!\n10. How generalization and specialisation can be realised?\n8 Analysis and design\n\nThe overall purpose of the Analysis and design workflow is to translate the requirements into a specification of how to implement the system. The activity spans a range of abstraction, looking at fairly abstract architectural issues in the early iterations but becoming increasingly detailed with later iterations. The main objectives in this workflow are the followings [3,10,11,12,17,22]:\n\n- To transform the requirements into a specification of how to implement the system.\n- To evolve a robust architecture for the system. This means that system can be easily changed when its functional requirements change.\n- To adapt the design to match the implementation environment, designing it for performance.\n\nAnalysis and design results in a design model and optionally in an analysis model. The design model serves as an abstraction of the source code; that is, the design model acts as a 'blueprint' of how the source code is structured and written. The design model consists of design classes structured into design packages and design subsystems with well-defined interfaces, representing what will become components in the implementation. It also contains descriptions of how objects of these design classes collaborate to perform use cases.\n\nDesign activities are centred around the notion of architecture. The production and validation of this architecture is the main focus of early design iterations. Architecture is represented by a number of architectural views. These views capture the major structural design decisions. In essence, architectural views are abstractions or simplifications of the entire design, in which important characteristics are made more visible by leaving details aside.\n\nAnalysis is mainly involved with transforming the requirements into an architecture and collection of components that could fully support an implementation of the proposed system. The focus is mainly on functional requirements and the creation of a number of design components. Analysis creates an idealised view of the design of the system that will be likely modified during detailed design.\n\nThe analysis model is usually an abstraction of the design model it is the primary artifact of the workflow detail called Analyze Behaviour. It is a platform independent model, which means that it does not contain technology-based decisions. It omits much of the detail of the design model.\n\nThe major content of the analysis model includes UML collaborations, which group class and sequence diagrams. The collaborations are traced back to the use cases from which they are realized, using an UML realization relationship. The analysis model also contains analysis classes, which are organized according to the logical architectural pattern.\n\nDesign begins where analysis leaves off. Taking the idealised design as the starting point the design process attempts to create the framework for an implementation that is able to meet all the non-functional requirements that are largely ignored in the analysis phase. Design should be detailed enough that it determines the structure of the implementation sufficiently that we can be sure any implementation meeting the design will satisfy the requirements. A consequence of this is that the level at which design stops will vary depending on the experience of the implementation team, the nature of the development environment, and the precision to which the requirements are specified.\n\nThe design model is the primary artifact of the analysis and design workflow. It comprises class definitions and how they collaborate to provide requirements specified by use cases.\nThese may be further aggregated into packages and subsystems that group related classes to allow us to hide unnecessary detail where necessary.\n\nDesign ensures that non-functional requirements are met. The design model has a mixture of behaviour and technology, and is considered a platform-specific model.\n\nIn the frame of RUP methodology the activities and artifacts are organized into workflow details as follows:\n\n- Define a candidate architecture.\n- Refine the architecture.\n- Analyze behaviour.\n- Design components.\n\n8.1 Define a candidate architecture\n\nIn this workflow detail some candidate architectures are proposed and tested against the relevant use cases. The purpose of this workflow detail is to:\n\n- Create the candidate architecture of the system\n a. Define an initial set of architecturally significant elements to be used as the basis for analysis.\n b. Define an initial set of analysis mechanisms.\n c. Define the initial layering and organization of the system.\n d. Define the use-case realizations to be addressed in the current iteration.\n- Identify analysis classes from the architecturally significant use cases.\n- Update the use-case realizations with analysis class interactions.\n\nWe perform an initial pass at the architecture, then we choose architecturally significant use cases, performing an Use-Case Analysis on each one. After each use case is analyzed, we update the architecture as needed to reflect adaptations required to accommodate new behaviour of the system and to address potential architectural problems which are identified.\n\n8.1.1 Architectural analysis\n\nIn this activity the purpose is:\n\n- To define a candidate architecture for the system, based on experience gained from similar systems or in similar problem domains.\n- To define the architectural patterns, key mechanisms and modelling conventions for the system.\n- To define the reuse strategy.\n- To provide input to the planning process.\n\nWhere the architecture already exists, either from a prior project or iteration, change requests may need to be created to change the architecture to account for the new behaviour the system must support. These changes may be to any artifact in the process, depending on the scope of the change.\n\nAnalysis pattern\nAn analysis mechanism represents a pattern that constitutes a common solution to a common problem. They may show patterns of structure, patterns of behaviour, or both. They are used during analysis to reduce the complexity of analysis, and to improve its consistency by providing designers with a short-hand representation for complex behaviour. Mechanisms allow the analysis effort to focus on translating the functional requirements into software.\nAnalysis mechanisms often result from the instantiation of one or more architectural or analysis patterns. They provide specific behaviours to a domain-related class or component, or correspond to the implementation of cooperation between classes and/or components [8].\n\n**Reuse strategy**\nDeveloping reuse strategy the reusable elements have to be identified and the possibilities for reuse have to be investigated.\n\n**Layers**\nThe design model is normally organized in layers that are a common architectural pattern for moderate to large sized systems.\n\nSubsystems should be organized into layers with application-specific sub-systems located in the upper layers of the architecture, hardware and operating-specific subsystems located in the lower layers of the architecture, and general-purpose services occupying the middleware layers.\n\nLayering represents an ordered grouping of functionality, with the application-specific located in the upper layers, functionality that spans application domains in the middle layers, and functionality specific to the deployment environment at the lower layers.\n\nThe number and composition of layers is dependent upon the complexity of both the problem domain and the solution space.\n\nThe following sample architecture has four layers:\n\n- The top layer, *application layer*, contains the application specific services.\n- The next layer, *business-specific layer*, contains business specific components, used in several applications.\n- The *middleware layer* contains components such as GUI-builders, interfaces to database management systems, platform-independent operating system services, and OLE-components such as spreadsheets and diagram editors.\n- The bottom layer, *system software layer*, contains components such as operating systems, databases, interfaces to specific hardware and so on.\n\nLayering provides a logical partitioning of sub-systems into a number of sets, with certain rules as to how relationships can be formed between layers. The layering provides a way to restrict inter-subsystem dependencies, with the result that the system is more loosely coupled and therefore more easily maintained.\n\nSubsystems and packages within a particular layer should only depend upon subsystems within the same layer, and at the next lower layer.\n\n**Packages**\nUML uses packages to structure models into smaller elements. A model structured into smaller units is easier to understand. It is easier to show relationships among the model's main parts if they are expressed in terms of packages. A package is either the top-level package of the model, or stereotyped as an use-case package.\n\nBy grouping model elements into packages and subsystems, then showing how those groupings relate to one another, it is easier to understand the overall structure of the model. A package should be identified for each group of classes that are functionally related. Packages can be specialized and stereotyped (Figure 8.1.).\nIf a class in one package has an association to a class in a different package, then these packages depend on each other. Package dependencies are modelled using a dependency relationship between the packages. Figure 8.2 shows dependency between two packages.\n\nUse cases describe interacts between actors and systems, they specify the functional behaviour of a system or subsystem.\n\nA use-case realization describes how a particular use case is realized within the model, in terms of collaborating objects. For each use-case realization there may be one or more class diagrams depicting its participating classes. A class and its objects often participate in several use-case realizations. It is important during design to coordinate all the requirements on a class and its objects that different use-case realizations may have.\n\nA use-case realization represents the design perspective of a use case. It is an organization model element used to group a number of artifacts related to the design of a use case, such as class diagrams of participating classes and subsystems, and sequence diagrams which illustrate the flow of events of a use case performed by a set of class and subsystem instances.\n\nFor each use case in the use-case model, there is a use-case realization in the design model with a realization relationship to the use case. In the UML this is shown as a dashed arrow, with an arrowhead like a generalization relationship, indicating that a realization is a kind of inheritance, as well as a dependency. Figure 8.3 shows a realization relationship.\n\nFor each use-case realization there is one or more interaction diagrams depicting its participating objects and their interactions. There are two types of interaction diagrams: sequence diagrams and collaboration diagrams. They express similar information, but show it in different ways. Sequence diagrams show the explicit sequence of messages and are better when it is important to visualize the time ordering of messages, whereas collaboration diagrams show the communication links between objects and are better for understanding all of the effects on a given object.\n\n8.1.2 **Use case analysis**\n\nAfter performing Architectural Analysis we choose architecturally significant use cases, performing Use-Case Analysis on each one. Purpose of use case analysis is:\n- To identify the classes which perform a use case’s flow of events.\n- To distribute the use case behaviour to those classes, using use-case realizations.\n- To identify the responsibilities, attributes and associations of the classes.\n- To note the usage of architectural mechanisms\n\n8.1.2.1 Find analysis classes\n\nThe purpose of this activity is to identify a candidate set of analysis classes which will be capable of performing the behaviour described in use cases.\n\nFinding a candidate set of analysis classes is the first step in the transformation of the system from a statement of required behaviour to a description of how the system will work. In this effort, analysis classes are used to represent the roles of model elements which provide the necessary behaviour to fulfil the functional requirements specified by use cases and the non-functional requirements specified by the supplemental requirements. As the project focus shifts to design, these roles evolve a set of design elements which realize the use cases.\n\nThe roles identified in Use-Case Analysis primarily express behaviour of the upper-most layers of the system i.e. application-specific behaviour and domain specific behaviour. Boundary classes and control classes typically evolve into application-layer design elements, while entity classes evolve into domain-specific design elements. Lower layer design elements typically evolve from the analysis mechanisms which are used by the analysis classes identified here.\n\nThree different perspectives of the system are used in the identification of candidate classes. The three perspectives are that of the boundary between the system and its actors, the information used by system, and the control logic of the system. The corresponding class stereotypes are boundary, entity and control.\n\nIdentification of classes means just that they should be identified, named, and described briefly in a few sentences.\n\nIn UML models, a stereotype is a model element that is an extensibility mechanism, which can be used to identify the purpose of the model element to which we apply it. A stereotype can be used to refine the meaning of a model element. Figure 8.4. shows an example of stereotyping a class as interface.\n\n\n\nAnalysis classes may be stereotyped as one of the following:\n\n- Stereotype <<boundary>> - Boundary classes.\n- Stereotype <<control>> - Control classes.\n- Stereotype <<entity>> - Entity classes.\n\nThis stereotyping results in a robust object model because changes to the model tend to affect only a specific area.\n\nA *boundary class* is a class used to model interaction between the system's surroundings and its inner workings. They are modelled according to what kind of boundary they represent. Communication with another system and communication with a human actor (through a user interface) have very different objectives.\nA system may have several types of boundary classes:\n\n- **User interface classes.** Classes which intermediate communication with human users of the system.\n- **System interface classes.** Classes which intermediate communication with other system.\n- **Device interface classes.** Classes which provide the interface to devices, which detect external events.\n\nThere is at least one boundary object for each use-case actor-pair. This object can be viewed as having responsibility for coordinating the interaction with the actor. Sketches, use screen shots from a user-interface prototype can illustrate the behaviour and appearance of the boundary objects.\n\nFor analysis goals only key abstractions of the system necessary to model. Examples of boundary classes are shown in Figure 8.5.\n\n\n\nAn **entity class** is a class used to model information and associated behaviour that must be stored. Entity objects represent the key concepts of the system being developed, such as an event, a person, or some real-life object. They are usually persistent, having attributes and relationships needed for a long period, sometimes for the life of the system. A frequent source of inspiration for entity classes are the Glossary developed during requirements. Figure 8.6. shows examples for entity classes.\n\n\n\nA **control class** is a class used to model control behaviour specific to one or a few use cases. Control objects often control other objects, so their behaviour is of the coordinating type. Control classes encapsulate use-case specific behaviour.\n\nThe system can perform some use cases without control objects (just using entity and boundary objects). They are particularly use cases that involve only the simple manipulation of stored information.\n\nMore complex use cases generally require one or more control classes to coordinate the behaviour of other objects in the system. Examples of control objects include programs such as transaction managers, resource coordinators, and error handlers.\n\nControl classes effectively de-couple boundary and entity objects from one another, making the system more tolerant of changes in the system boundary. Control classes are represented as shown in Figure 8.7.\n8.1.2.2 Distribute behaviour to analysis classes\n\nThe purpose of this activity is to express the use-case behaviour in terms of collaborating analysis classes and to determine the responsibilities of analysis classes.\n\nFor each use-case realization there is one or more interaction diagrams depicting its participating objects and their interactions. There are two types of interaction diagrams: sequence diagram and collaboration diagram. They express similar information, but show it in different ways. Sequence diagrams show the explicit sequence of messages and are better when it is important to visualize the time ordering of messages, whereas collaboration diagrams show the communication links between objects and are better for understanding all of the effects on a given object.\n\nSequence diagrams\n\nWe use a sequence diagram to illustrate use-case realizations and show how objects interact to perform the behaviour of all or part of a use case. A sequence diagram describes a pattern of interaction among objects, arranged in a chronological order; it shows the objects participating in the interaction by their \"lifelines\" and the messages that they send to each other.\n\nSequence diagrams are particularly important to designers because they clarify the roles of objects in a flow and thus provide basic input for determining class responsibilities and interfaces.\n\nWe can have objects and actor instances in sequence diagrams, together with messages describing how they interact. The diagram describes what takes place in the participating objects, in terms of activations, and how the objects communicate by sending messages to one another.\n\nAn object is shown as a vertical dashed line called the \"lifeline\". The lifeline represents the existence of the object at a particular time. In sequence diagrams, a message is shown as a horizontal solid arrow from the lifeline of one object to the lifeline of another object.\n\nFor example, the sequence diagram shown in Figure 8.8. illustrates the use case realization of a course registration. In this use case student successfully registers a course coded by UML-01. Students can communicate the system through two user interfaces realized by boundary classes Login and CourseRegistration. The use case realization is controlled by the control class named Control. There are four entity classes: Student, Subject, Course, and Registration.\nCollaboration diagrams\n\nCollaboration diagrams are used to show how objects interact to perform the behaviour of a particular use case, or a part of a use case.\n\nA collaboration diagram describes a pattern of interaction among objects; it shows the objects participating in the interaction by their links to each other and the messages that they send to each other.\n\nAlong with sequence diagrams, collaborations are used by designers to define and clarify the roles of the objects that perform a particular flow of events of a use case. They are the primary source of information used to determining class responsibilities and interfaces.\n\nWe can have objects and actor instances in collaboration diagrams, together with links and messages describing how they are related and how they interact. The diagram describes what takes place in the participating objects, in terms of how the objects communicate by sending messages to one another. A link is a relationship among objects across which messages can be sent. In collaboration diagrams, a link is shown as a solid line between two objects. In collaboration diagrams, a message is shown as a labelled arrow placed near a link. This means that the link is used to transport, or otherwise implement the delivery of the message to the target object. The arrow points along the link in the direction of the target object (the one that receives the message). The arrow is labelled with the name of the message, and its parameters. The arrow may also be labelled with a sequence number to show the sequence of the message in the overall interaction.\n\nFor an example, the use case realization illustrated in Figure 8.8. is shown in a collaboration diagram in Figure 8.9.\nIn order to distribute behaviour to analysis classes we follow the next steps for each independent scenario:\n\n− **Create one or more collaboration diagrams.** At least one diagram is usually needed for the main flow of events of the use case, plus at least one diagram for each alternate/exceptional flow.\n− **Identify the analysis classes** responsible for the required behaviour by stepping through the flow of events of the scenario, ensuring that all behaviour required by the use case is provided by the use-case realization.\n− **Illustrate interactions between analysis classes in the collaboration diagram.** The collaboration diagram also shows interactions of the system with its actors.\n\n### 8.1.2.3 Describe responsibilities\n\nThe purpose of this activity is to describe the responsibilities of a class of objects identified from use-case behaviour. A responsibility is a statement of something an object can be asked to provide. Responsibilities evolve into operations on classes in design; they can be characterized as:\n\n− The actions that the object can perform.\n− The knowledge that the object maintains and provides to other objects.\n\nEach analysis class should have several responsibilities; a class with only one responsibility is probably too simple, while one with a dozen or more is pushing the limit of reasonability and should potentially be split into several classes.\n\nResponsibilities are derived from messages in collaboration diagrams. For each message, the class of the object is examined to which the message is sent. If the responsibility does not yet exist, we create a new responsibility that provides the requested behaviour.\n\nResponsibilities are documented with a short name for the responsibility, and a short description. The description states what the object does to fulfil the responsibility, and what result is returned when the responsibility is invoked.\n\nFigure 8.10. shows the class Subject with operations identified using diagrams in Figure 8.8. and 8.9.\nAttributes\n\nAttributes are used to store information by a class. Specifically, attributes are used where the information is:\n\n- Referred to \"by value\"; that is, it is only the value of the information, not its location or object identifier which is important.\n- Uniquely \"owned\" by the object to which it belongs; no other objects refer to the information.\n- Accessed by operations which only get, set or perform simple transformations on the information; the information has no \"real\" behaviour other than providing its value.\n\nIf, on the other hand, the information has complex behaviour, is shared by two or more objects, or is passed \"by reference\" between two or more objects, the information should be modelled as a separate class.\n\nThe attribute name should be a noun that clearly states what information the attribute holds. The description of the attribute should describe what information is to be stored in the attribute; this can be optional when the information stored is obvious from the attribute name. The attribute type is the simple data type of the attribute. Examples include string, integer, number. In Figure 8.12. the attributes of class Subject are shown.\nIn order to carry out their responsibilities, classes frequently depend on other classes to supply needed behaviour. Associations document the inter-class relationships and help us to understand class coupling.\n\nIn the collaboration diagrams, links between classes indicate that objects of the two classes need to communicate with one another to perform the Use Case. Once we start designing the system, these links may be realized in several ways:\n\n- The object may have \"global\" scope, in which case any object in the system can send messages to it.\n- One object may be passed the second object as a parameter, after which it can send messages to the passed object.\n- The object may have a permanent association to the object to which messages are sent.\n\nAssociations represent structural relationships between objects of different classes; they represent connections between instances of two or more classes that exist for some duration. It can be used to show that objects know about another objects. Sometimes, objects must hold references to each other to be able to interact, for example send messages to each other; thus, in some cases associations may follow from interaction patterns in sequence diagrams or collaboration diagrams.\n\nMost associations are binary, and are drawn as solid paths connecting pairs of class symbols (Figure 8.14.). An association may have either a name or the association roles.\n\nEach end of an association is a role specifying the face that a class plays in the association. The role name should be a noun indicating the associated object's role in relation to the\nassociating object. In the example shown in Figure 8.14, the role employee is assigned to class Firm and role employer is assigned to class Person.\n\n**Figure 8.14.** Association relationship between classes.\n\n**Multiplicity**\n\nFor each role we can specify the *multiplicity* of its class, how many objects of the class can be associated with one object of the other class. Multiplicity is indicated by a text expression on the role. The expression is a comma-separated list of integer ranges. A range is indicated by an integer for the lower value, two dots, and an integer for the upper value.\n\nSome examples are given in the followings:\n\n- 1 : exactly one object is associated.\n- * : any number of object including none.\n- 0..1 : 0 or 1 object is associated.\n- 1..* : 1 or more object is associated.\n- 22..44 : the number of object associated is from the range [22;44].\n- 9 : exactly 9 object is associated.\n\nThe *navigability* property on a role indicates that it is possible to navigate from an associating class to the target class using the association. Navigability is indicated by an open arrow, which is placed on the target end of the association line next to the target class.\n\nThe Figure 8.15. shows the association between class Firm and Person when specifying multiplicity. In the example we represent an association in which every person has an employee and every firm may have number of employer between 1 and 10.\n\n**Figure 8.15.** Representation of multiplicity.\n\nAn *association class* is an association that also has class properties (such as attributes, operations, and associations). It is shown by drawing a dashed line from the association path to a class symbol that holds the attributes, operations, and associations for the association. The attributes, operations, and associations apply to the original association itself. Each link in the association has the indicated properties. Fig 8.16. shows the application of an association class. In this case associations can be regarded as instances of class Employment. Using attribute payment we can order different payment to employers.\n\n**Figure 8.16.** Representation of association class.\n**Aggregation and composition**\n\nAn *aggregation* is a special form of association that models a whole-part relationship between an aggregate (the whole) and its parts. Aggregation is used to model a compositional relationship between model elements. In UML diagrams a hollow diamond is attached to the end of an association path on the side of the aggregate (the whole) to indicate aggregation.\n\n*Composition* is a form of aggregation with strong ownership and coincident lifetime of the part with the aggregate. The multiplicity of the aggregate end may not exceed one. Composition represented by a solid filled diamond attached to the end of an association path. Figure 8.17. shows an example of aggregation and composition. A polygon may have a number of vertices and characteristics such as color and surface area. Using the aggregation we define Polygon have vertices at most 5. The composition is used to express that lifetime of characteristics depends on lifetime of polygon.\n\n\n\nFigure 8.17. Representation of aggregation and composition relationship.\n\nFigure 8.18. show the class diagram of classes and their associations realizing the use case UML-01 course registration.\n\n\nEnforcing consistency\n\n− When a new behaviour is identified, it can be checked to see if there is an existing\nclass that has similar responsibilities, reusing classes where possible. The new class\nshould be created only when sure that there is not an existing object that can perform\nthe behaviour.\n− As classes are identified, we have to examine them to ensure they have consistent\nresponsibilities. When a classes responsibilities are disjoint, we have to split the object\ninto two or more classes. The collaboration diagrams are updated accordingly.\n− If a class is split because disjoint responsibilities are discovered, we have to examine\nthe collaborations in which the class plays a role to see if the collaboration needs to be\nupdated. The collaboration is updated if needed.\n− A class with only one responsibility is not a problem, per se, but it should raise\nquestions on why it is needed.\n\n8.2 Refine the architecture\n\nThe purpose of this workflow detail is to:\n\n− Provide the natural transition from analysis activities to design activities, identifying:\n a) appropriate design elements from analysis elements.\n b) appropriate design mechanisms from related analysis mechanisms.\n− Maintain the consistency and integrity of the architecture, ensuring that:\n a) new design elements identified for the current iteration are integrated with pre-\nexisting design elements.\n b) maximal re-use of available components and design elements is achieved as\nearly as possible in the design effort.\n− Describe the organization of the system's run-time and deployment architecture\n− Organize the implementation model so as to make the transition between design and\nimplementation seamless\n\n8.2.1 Identify design mechanisms\n\nThe purpose of this activity is to refine the analysis mechanisms into design mechanisms\nbased on the constraints imposed by the implementation environment.\n\nDesign mechanism is an architectural mechanism used during the design process. It is a\nrefinement of a corresponding analysis mechanism and it may bind one or more architectural\nand design patterns. A mechanism at the analysis level and the design level means the same\nthings, but at a different level of refinement. A design mechanism assumes some details of the\nimplementation environment.\n\nA design pattern provides a scheme for refining the subsystems or components of a\nsoftware system, or the relationships between them. It describes a commonly-recurring\nstructure of communicating components that solves a general design problem within a\nparticular context. The steps for refining the information gathered on the analysis mechanisms\nare as follows:\n\n− Identification of the clients of each analysis mechanism. We scan all clients of a given\nanalysis mechanism, looking at the characteristics they require for that mechanism.\n− Identification of characteristic profiles for each analysis mechanism. There may be\nwidely varying characteristics profiles, providing varying degrees of performance,\nfootprint, security, economic cost, etc. Each analysis mechanism is different, different\ncharacteristics will be applied to each.\nGrouping clients according to their use of characteristic profiles. We form groups of clients that need for an analysis mechanism with a similar characteristics profile and we identify a design mechanism based on each such characteristics profile. These groupings provide an initial cut at the design mechanisms. Different characteristic profiles will lead to different design mechanisms which emerge from the same analysis mechanism.\n\n8.2.2 Identify design elements\n\nPurpose of this activity is to analyze interactions of analysis classes to identify design model elements.\n\nThe use case analysis results in analysis classes, which represent conceptual things which can perform behaviour. In design, analysis classes evolve into a number of different kinds of design elements:\n\n- classes, to represent a set of rather fine-grained responsibilities;\n- subsystems, to represent a set of coarse-grained responsibilities, perhaps composed of a further set of subsystems, but ultimately a set of classes;\n- active classes, to represent threads of control in the system;\n- interfaces, to represent abstract declarations of responsibilities provided by a class or subsystem.\n\nWhen the analysis class is simple and already represent a single logical abstraction, it can be directly mapped, 1:1, to a design class. Typically, entity classes are converted into design classes. Since entity classes are typically also persistent, determine whether the design class should be persistent and note it accordingly in the class description.\n\nWhen the analysis class is complex, such that it appears to embody behaviours that cannot be the responsibility of a single class acting alone, the analysis class should be mapped to a design subsystem. The design subsystem is used to encapsulate these collaborations in such a way that clients of the subsystem can be completely unaware of the internal design of the subsystem, even as they use the services provided by the subsystem.\n\nIn the design model, interfaces are mainly used to define the interfaces for subsystems. Interfaces are important for subsystems because they allow the separation of the declaration of behaviour from the realization of behaviour.\n\n8.3 Analyze behaviour\n\nAfter creating an initial architecture or producing architecture in previous iterations the purpose is to refining the architecture and analysing behaviour and creating an initial set of design model elements which provide the appropriate behaviour.\n\nSteps of this workflow item are the followings:\n\n- Use case analysis. Identification of the classes which perform a use case’s flow of events and distribute the use case behaviour to those classes, using use-case realizations.\n- Identify design elements. Analyzing interactions of analysis classes to identify new design model elements.\n- Review the design. We have to verify that the design model fulfils the requirements on the system and serves as a good basis for its implementation. We have to ensure that the design model is consistent with respect to the general design guidelines.\n8.4 Design components\n\nAfter the initial design elements are identified, they are further refined. This workflow produces a set of components which provide the appropriate behaviour to satisfy the requirements on the system. In parallel with these activities, persistence issues are handled in Design the Database. The result is an initial set of components which are further refined in Implementation. The purpose of Design Components workflow detail is to:\n\n- Refine and update the use-case realizations based on new design element identified.\n- Refine the definitions of design elements (including capsules and protocols) by working out the details of how the design elements implement the behaviour required of them.\n- Reviewing the design as it evolves.\n- Implementing the design elements as components.\n- Testing the implemented components to verify functionality and satisfaction of requirements at the component/unit level.\n\nThe architecture of system can be represented by a component diagram in UML. It shows a collection of model elements, such as components, and implementation subsystems, and their relationships, connected as a graph to each other. Component diagrams can be organized into, and owned by implementation sub-systems, which show only what is relevant within a particular implementation subsystem.\n\nThe following structures are suitable for illustration in component diagrams:\n\n- Implementation sub-systems and their import dependencies.\n- The implementation sub-systems organized in layers.\n- Components (source code files) and their compilation dependencies.\n- Components (applications) and their run-time dependencies.\n- Important structure of components, for example to illustrate a typical use of a component.\n\n8.4.1 Use case design\n\nThe purpose of this workflow item is:\n\n- To refine use-case realizations in terms of interactions.\n- To refine requirements on the operations of design classes.\n- To refine requirements on the operations of subsystems and/or their interfaces.\n\n8.4.2 Sub-system design\n\nThe purpose of this activity is:\n\n- To define the behaviours specified in the subsystem's interfaces in terms of collaborations of contained classes.\n- To document the internal structure of the subsystem.\n- To define realizations between the subsystem's interfaces and contained classes.\n- To determine the dependencies upon other subsystems.\n\nThe external behaviours of the subsystem are defined by the interfaces it realizes. When a subsystem realizes an interface, it makes a commitment to support each and every operation defined by the interface. The operation may be in turn realized by:\n\n- an operation on a class contained by the subsystem; this operation may require collaboration with other classes or subsystems\nan operation on an interface realized by a contained subsystem\n\nThe collaborations of model elements within the subsystem should be documented using sequence diagrams which show how the subsystem behaviour is realized. Each operation on an interface realized by the sub-system should have one or more documenting sequence diagrams. This diagram is owned by the subsystem, and is used to design the internal behaviour of the subsystem.\n\nTo document the internal structure of the sub-system, create one or more class diagrams showing the elements contained by the subsystem, and their associations with one another. One class diagram should be sufficient, but more can be used to reduce complexity and improve readability.\n\nWhen an element contained by a sub-system uses some behaviour of an element contained by another sub-system, a dependency is created between the enclosing sub-systems. In figure 8.19. the UML representation of dependency between packages is shown. It expresses that package Payment schedule is dependent on package Billing.\n\n\n\n8.4.3 Class design\n\nThe initial design classes are created for the analysis class given as input to this activity, and assign trace dependencies. The design classes created in this step will be refined, adjusted in the subsequent design steps when various design properties assigned:\n\n1. Create Initial Design Classes.\n2. Identify Persistent Classes.\n3. Define Class Visibility.\n5. Define Methods.\n6. Define States.\n7. Define Attributes.\n8. Define Dependencies.\n9. Define Associations.\n10. Define Generalizations.\n11. Handle Non-Functional Requirements in General.\n\nDepending on the type of the analysis class (boundary, entity, or control) that is to be designed, there are specific strategies that can be used to create initial design classes.\n\nDesigning boundary classes\n\nThe general rule in analysis is that there will be one boundary class for each window, or one for each form, in the user interface. The consequence of this is that the responsibilities of the boundary classes can be on a fairly high level, and need then be refined and detailed in this step. The Figure 8.20. shows the class “Course registration” which is responsible for the control of the user interface of subject register system.\nThe design of boundary classes depends on the user interface (or GUI) development tools available to the project. Using current technology, it is quite common that the user interface is visually constructed directly in the development tool, thereby automatically creating user interface classes that need to be related to the design of control and/or entity classes. If the GUI development environment automatically creates the supporting classes it needs to implement the user interface, there is no need to consider them in design - it is only necessary to design what the development environment does not create.\n\nBoundary classes which represent the interfaces to existing systems are typically modelled as subsystems, since they often have complex internal behaviour. If the interface behaviour is simple one may choose to represent the interface with one or more design classes.\n\n**Designing entity classes**\n\nDuring analysis, entity classes represent manipulated units of information; entity objects are often passive and persistent. In analysis, these entity classes may have been identified and associated with the analysis mechanism for persistence.\n\n**Designing control classes**\n\nA control object is responsible for managing the flow of a use case and thus coordinates most of its actions; control objects encapsulate logic that is not particularly related to user interface issues (boundary objects), or to data engineering issues (entity objects).\n\n**Define operations and methods**\n\nTo identify Operations on design classes:\n\n- Study the responsibilities of each corresponding analysis class, creating an operation for each responsibility. Use the description of the responsibility as the initial description of the operation.\n- Study the use-case realizations in the class participates to see how the operations are used by the use-case realizations. Extend the operations, one use-case realization at the time, refining the operations, their descriptions, return types and parameters. Each use-case realization's requirements as regards classes are textually described in the Flow of Events of the use-case realization.\n- Study the use case Special Requirements, in order not to miss implicit requirements on the operation that might be stated there.\n\nOperations are required to support the messages that appear on sequence diagrams because scripts; messages (temporary message specifications) which have not yet been assigned to operations describe the behaviour the class is expected to perform.\nUse-case realizations cannot provide enough information to identify all operations. To find the remaining operations, consider the following:\n\n− Is there a way to initialize a new instance of the class, including connecting it to instances of other classes to which it is associated?\n− Is there a need to test to see if two instances of the class are equal?\n− Is there a need to create a copy of a class instance?\n− Are any operations required on the class by mechanisms which they use (for example, a garbage collection mechanism may require that an object be able to drop all of its references to all other objects in order for unused resources to be freed)?\n\nFor each operation, you should define the following:\n\n− The operation name. The name should be short and descriptive.\n− The return type.\n− A short description. Give the operation a short description consisting of a couple of sentences, written from the operation user's perspective.\n− The parameters. The brief description of parameters should include the following:\n a. The meaning of the parameters (if not apparent from their names).\n b. Whether the parameter is passed by value or by reference\n c. Parameters which must have values supplied\n d. Parameters which can be optional, and their default values if no value is provided\n e. Valid ranges for parameters (if applicable)\n f. What is done in the operation.\n g. Which by reference parameters are changed by the operation.\n\nOnce the operations have been defined the sequence diagrams are completed with information about which operations are invoked for each message. For each operation, identify the export visibility of the operation:\n\n− Public: the operation is visible to model elements other than the class itself.\n− Implementation: the operation is visible only within to the class itself.\n− Protected: the operation is visible only to the class itself, to its subclasses, or to friends of the class (language dependent)\n− Private: the operation is only visible to the class itself and to friends of the class\n\nA method specifies the implementation of an operation. In many cases, methods are implemented directly in the programming language. The method describes how the operation works, not just what it does.\n\nThe method, if described, should discuss:\n\n− How operations are to be implemented.\n− How attributes are to be implemented and used to implement operations.\n− How relationships are to be implemented and used to implement operations.\n− What other objects and their operations are to be used?\n\nSequence diagrams are an important source for this. From these it is clear what operations are used in other objects when an operation is performed.\n\n**State chart diagram**\n\nFor some operations, the behaviour of the operation depends upon the state the receiver object is in. A state machine is a tool for describing the states the object can assume and the events that cause the object to move from one state to another.\nEach state transition event can be associated with an operation. Depending on the object's state, the operation may have a different behaviour. States are often represented using attributes; the state-chart diagrams serve as input into the attribute identification step.\n\nState machines are used to model the dynamic behaviour of a model element. They are used to define state-dependent behaviour, or behaviour that varies depending on the state in which the model element is in. Model elements whose behaviour does not vary with its state of the element are passive classes whose primary responsible is to manage data.\n\nA state machine consists of states, linked by transitions. A state is a condition of an object in which it performs some activity or waits for an event. An object may remain in a state for a finite amount of time. A transition is a relationship between two states which is triggered by some event, which performs certain actions or evaluations, and which results in a specific end-state. Internal transitions are transitions that are handled without causing a change in state. Figure 8.21. shows the UML representations of state. In the right side case the lower part of state can be used to define actions done by the object.\n\nA transition has five properties: Source state, Event trigger, Guard condition, Action, Target state.\n\nThe event trigger is the event that makes the transition eligible if its guard condition is satisfied.\n\nThe guard condition is a boolean expression that is evaluated when the transition is triggered by the reception of the event trigger.\n\nThe action is an executable atomic computation, meaning that it cannot be interrupted by an event and therefore runs to completion. Entry and exit actions allow the same action to be dispatched every time the state is entered or left respectively. Internal transitions allow events to be handled within the state without leaving the state, thereby avoiding triggering entry or exit actions. The Figure 8.22. represent the actions related to a state.\n\n\n\n\nFigure 8.23. shows the state transitions of UML-01 course object introduced in the sequence diagram in figure 8.8. It shows four states and five transitions. Following the initial state symbol the object enter the state under initialization. The object may have two final states. The object may enter the state full when the number of course students reaches a limit number. The another final states is the state deleted. Object enters this state due to any course delete event. The fourth state is the state opened. The object remains in this state until the number of registered course students number is under the course limit.\n\n**Define attributes**\n\nAttributes provide information storage for the class instance, and are often used to represent the state of the class instance. Any information the class itself maintains is done through its attributes. For each attribute, define the following:\n\n1. Its name, which should follow the naming conventions of both the implementation language and the project.\n2. Its type, which will be an elementary data type supported by the implementation language.\n3. Its default or initial value, to which it is initialized when new instances of the class are created.\n4. Its visibility: Public, Protected, Private or Implementation.\n5. For persistent classes, whether the attribute is persistent (the default) or transient.\n\n**Define dependencies**\n\nFor each case where the communication between objects is required dependency between sender and receiver has to be established in the following case:\n\n- The reference to the receiver passed as an parameter to the operation. The visibility of link is set to „parameter“ in collaboration diagram.\n- The receiver a global object. In the collaboration diagram the visibility of link is set to „global“.\n- The receiver a temporary object created and destroyed during the operation itself. The visibility of link is set to „local“ in the collaboration diagram.\n8.5 Implementation\n\nThe purpose of implementation is:\n\n− to define the organization of the code, in terms of implementation subsystems organized in layers\n− to implement classes and objects in terms of components (source files, binaries, executables, and others)\n− to test the developed components as units\n− to integrate the results produced by individual implementers (or teams), into an executable system\n\nThe implementation is consists of the following workflow details:\n\n− Structure of implementation model. The purpose of this workflow detail is to ensure that the implementation model is organized in such a way as to make the development of components and the build process as conflict-free as possible. A well-organized model will prevent configuration management problems and will allow the product to built-up from successively larger integration builds.\n− Plan the integration. The purpose of this workflow detail is to plan which subsystems should be implemented, and the order in which the subsystems should be integrated in the current iteration.\n− Implement components. Writing source code, adapt existing components, compile, link and perform unit tests, as they implement the classes in the design model. If defects in the design are discovered, the implementer submits rework feedback on the design. The implementers also fix code defects and perform unit tests to verify the changes. Then the code is reviewed to evaluate quality and compliance with the Programming Guidelines.\n− Integrate each subsystem. Integration of the new and changed components from the individual implementers into a new version of the implementation subsystem. Integrate the System. Integration of the system, in accordance with the integration build plan, by adding the delivered implementation subsystems into the system integration workspace and creating builds. Each build is then integration tested by a tester.\n\n8.6 Deployment\n\nThe Deployment Discipline describes the activities associated with ensuring that the software product is available for its end users. The Deployment Discipline describes several modes of product deployment. The main activities of Plan Deployment workflow detail are the followings:\n\n− Plan the product deployment. Deployment planning needs to take into account how and when the product will be available to the end user.\n− Forming a high degree of customer collaboration. A successful conclusion to a software project can be severely impacted by factors outside the scope of software development such as the building, hardware infrastructure not being in place, and the staff being ill-prepared for cut-over to the new system.\n− Support of the system. The Deployment Plan needs to address not only the deliverable software, but also the development of training material and system support material to ensure that end users can successfully use the delivered software product.\n\nOnce the product has been tested at the development site it is prepared for delivery to the customer. The support materials that is required to install, operate, use and maintain the\ndelivered system are parts of the delivered system. In order to introduce the software as product to the software market and deliver it to end users the following activities are included in deployment discipline:\n\n- **Develop support material.** The purpose of this workflow detail is to produce the support materials needed to effectively deploy the product to its users.\n- **Manage acceptance test.** Acceptance testing is formal testing conducted to determine whether or not a system satisfies its acceptance criteria, and to enable the customer, user or authorized entity to determine whether or not to accept the system. Acceptance testing is often conducted at the development site, and then at the customer site using the target environment.\n- **Produce deployment unit.** In this workflow a deployment unit is created that consists of the software, and the necessary accompanying artifacts required to effectively install and use it.\n- **Package product.** This workflow detail describes the necessary activities to create the final software product by packaging the deployment unit, installation scripts, and user manuals together.\n- **Provide access to download site.** The purpose of this workflow detail is to make the product available for purchase, and download over the internet.\n- **Beta test product.** Development of a beta version of software helps to get feedback information on the product from users.\n\n### 8.7 Exercises\n\n1. List the workflow details of Analysis & Design discipline!\n2. What is software architecture?\n3. What are the responsibilities of classes?\n4. What is the use case realisation?\n5. What is the dependency of software components?\n6. What is stereotype?\n7. List stereotypes are used Analysis phase!\n8. List the graphical elements of collaboration diagram!\n9. List the graphical elements of state diagram!\n10. What is the function of association classes?\n11. What are the different between aggregation and composition relationships?\n9 Software testing\n\nThe general testing process starts with the testing of individual program units such as functions or objects. The aim of the component testing is to discover defects by testing individual program components. Components are usually integrated to form sub-systems and finally to the complete system. System testing focuses on establishing that the sub-system or the complete system meet its functional and non-functional requirements, and does not behave in unexpected ways. Component testing by developers is based on understanding of how the components should operate using test data. However, system testing is rigorously based on written system specifications [1].\n\nThe software testing process has the following main goals:\n\n1. To demonstrate that the software meets its requirements. This means that there should be at least one test for every user and system requirements.\n2. To discover faults or defects in the software. The objective of defect testing is the exploration and elimination of all kinds of undesirable system behaviour, such as system crashes, unwanted interactions with other systems, incorrect computations and data corruption.\n\nThe first goal is called validation testing. In this case the system is tested by a given set of test cases that reflect the system’s expected use. For validation testing, a test is considered to be successful if the system performs correctly. The second goal leads to defect testing, where the test cases are designed to expose defects. In this case, a successful test is one that exposes a defect that causes the system to perform incorrectly.\n\n\n\nA general model of the testing process is shown in Figure 9.1. Test cases are specifications of the inputs to the test, the expected output from the system and a statement of what is being tested. Test data are the inputs that have been created to test the system. Testing is based on a subset of possible test cases.\n\n9.1 Unit testing\n\nUnit testing tests the individual components in the system. It is a defect testing process so its purpose is to locate faults in these components. In most cases, the developers of components are responsible for component testing. The components may be tested at unit testing are the followings:\n\n1. Object classes, functions or methods within an object.\n2. Composite components that are consist of several different objects or functions. The composite components have a defined interface that can be used to access their functionality.\nFunctions or methods are tested by a set of calls to these routines with different input parameters. In the case of testing object classes the tests have to cover all of the features of the object. Object class testing includes the following tests:\n\n1. The testing all operations associated with the object\n2. The testing adjustability of all attributes associated with the object\n3. The testing all possible states of the object. This means that all events that cause a state change in the object have to be simulated.\n\nIn the case of inheritance the tests of object classes are more difficult. Where a superclass provides operations that are inherited by a number of subclasses, all of these subclasses should be tested with all inherited operations.\n\n9.1.1 Interface testing\n\nIn a software system many components are not simple functions or objects but they are composite components that consist of several interacting objects. The functionality of these components can be accessed through their defined interface. Testing these composite components is primarily concerned with testing the interface of the composite component created by combining these components. Interface testing is important for object-oriented and component-based development. Objects and components are defined by their interfaces and may be reused in combination with other components in different systems.\n\n9.2 System testing\n\nSystem testing involves integrating two or more components that implement any system functions or features and then testing this integrated system. In an iterative development process, system testing is concerned with testing an increment to be delivered to the customer. In the case of a waterfall development process, system testing is concerned with testing the entire system. Therefore, system testing may have two distinct phases:\n\n1. Integration testing. After integrating a new component the integrated system is tested. When a problem is discovered, the developers try to find the source of the problem and identify the components that have to be debugged.\n2. Functional testing. The version of the system that could be released to users is tested. Here, the main objective is to validate the system that it meets its requirements and ensure that the system is dependable. Where customers are involved in release testing, this is called acceptance testing. If the release is good enough, the customer may then accept it for use.\n\nFundamentally, the integration testing is considered as the testing of incomplete systems composed of clusters or groupings of system components. Functional testing is concerned with testing the system release that is intended for delivery to customers. Generally, the priority in integration testing is to discover defects in the system and the priority in system testing, is to validate that the system meets its requirements.\n\n9.2.1 Integration testing\n\nThe process of system integration involves building a system from its components and testing the resultant system for problems that arise from component interactions. Integration testing checks how these components work together across their interfaces.\n\nSystem integration integrates clusters of components that deliver some system functionality and integrating these by adding code that makes them work together. Sometimes, the overall skeleton of the system is developed first, and components are added to it. This is called top-down integration. Alternatively, the infrastructure components are\nintegrated first providing common services, such as network and database access, and functional components added after. This is *bottom-up integration*.\n\nIn order to locate errors easier an incremental approach to the system integration and testing is suggested. Initially, a minimal system configuration should be integrated and tested. Then the new components are added to this minimal configuration and tested after each added increment. If any problem arises in these tests, this probably means that they are due to interactions with the new component.\n\nBefore the process of integration, it is necessary to decide the order of integration of components. Usually, system integration is driven by customer priorities. When the customer is not involved in the developments, the components that have the most frequently used functionality are integrated first. Integrating and testing a new component can change the already tested component interactions. Errors may occur that were not exposed in the tests of the simpler configuration. This means that when a new increment is integrated, it is important to rerun the tests for previous increments as well. Rerunning an existing set of tests is called *regression testing*.\n\n### 9.2.2 Functional testing\n\nA release of the software is its final version that will be distributed to customers. The objective of release testing is to show that the software product delivers the specified functionality, performance and dependability, and that it does not fail during normal use. Another name of release testing is *functional testing* because it is only concerned with the functionality and not the implementation of the software.\n\nRelease testing is usually a black-box testing process where the tests are derived from the system specification. Figure 9.2. shows the model of black-box testing. The testing process presents inputs to the component or the system and examines the corresponding outputs. If the outputs are not those predicted, i.e. if the outputs are in set $O_e$, then the test has detected a problem with the software.\n\n\nDuring release testing, software is often tested by choosing test cases that are in the set $I_e$ in Figure 9.2. These inputs have a high probability of generating system failures i.e. outputs in set $O_e$.\n\nTo validate that the system meets its requirements, the best approach to use is scenario-based testing, where test cases are developed from scenarios. Usually, the most likely scenarios are tested first, and unusual or exceptional scenarios considered later. If use-cases are used to describe the system requirements, these use-cases and associated sequence diagrams can be a basis for system testing.\n\n9.2.3 Performance testing\n\nThe objective of performance tests is to ensure that the system can process its intended load. An effective way to discover defects is the stress testing, i.e. to design tests around the limits of the system. In performance testing, this means stressing the system by making demands that are over the design limits of the software. Stress testing has two functions:\n\n1. It tests the failure behaviour of the system under circumstances where the load placed on the system exceeds the maximum load.\n2. It continuously stresses the system and may cause such defects that would not normally be discovered.\n\n9.3 Exercises\n\nWhat are the objectives of software testing?\nReview the process of software testing!\nWhat are the types of test?\nWhat does the defect testing mean?\nWhat software components are tested by unit test?\nWhat is the regression testing?\nWhat is the different between integration and functional testing?\nWhat is the different between release and acceptance testing?\nExplain the functional testing!\nWhat is the objective of performance testing?\n10 Embedded system development\n\nAn embedded system is a computer system with a dedicated function within a larger mechanical or electrical system that serves a more general purpose, often with real-time computing constraints. It is embedded as part of a complete device often including hardware and mechanical parts.\n\nEmbedded systems are designed to do some specific task, rather than be a general-purpose computer for multiple tasks. Some also have real-time performance constraints that must be met, for reasons such as safety and usability; others may have low or no performance requirements, allowing the system hardware to be simplified to reduce costs. Since the embedded system is dedicated to specific tasks, design engineers can optimize it to reduce the size and cost of the product and increase the reliability and performance.\n\nThe processors used in embedded systems may be types ranging from rather general purpose to very specialized in certain class of computations, or even custom designed for the application at hand. A common standard class of dedicated processors is the digital signal processor (DSP).\n\nThe program instructions written for embedded systems are referred to as firmware, and are stored mainly in read-only memory or Flash memory chips. They run with limited computer hardware resources: little memory, small or non-existent keyboard or screen. As with other software, embedded system designers use compilers, assemblers, and debuggers to develop embedded system software.\n\nThe embedded system interacts directly with hardware devices and mostly must respond, in real time, to events from the system’s environment. In the real-time systems the embedded real-time software must react to events generated by the hardware and issue control signals in response to these events.\n\nEmbedded systems control many devices in common use today. They are commonly found in consumer, cooking, industrial, automotive, medical, commercial and military applications. Physically, embedded systems range from portable devices such as digital watches and MP3 players, to large stationary installations like traffic lights, factory controllers and largely complex systems like hybrid vehicles, MRI. Telecommunications systems employ numerous embedded systems from telephone to cell phones. Many household appliances, such as microwave ovens, washing machines and dishwashers, include embedded systems to provide flexibility, efficiency and features. Transportation systems from flight to automobiles increasingly use embedded systems.\n\nComputers are used to control a wide range of systems from simple domestic machines to entire manufacturing plants. These computers interact directly with hardware devices. The software in these systems is embedded real-time software that must react to events generated by the hardware from the environment of system and issue control signals in response to these events.\n\nSoftware failures are relatively usual. In most cases, these failures cause inconvenience but no serious, long-term damage. However, in some systems failure can result in significant economic losses, physical damage or threats to human life. These systems are called critical systems. Critical systems are technical or socio-technical systems that people or businesses depend on. If these systems fail to deliver their services as expected then serious problems and significant losses may result. Modern electronic systems increasingly make use of embedded computer systems to add functionality, increase flexibility, controllability and performance. However, the increased use of embedded software to control systems brings\nwith it certain risks. This is especially significant in safety critical systems where human safety is dependent upon the correct operation of the system.\n\nThe objective of this chapter is to introduce main characteristics of critical systems and the implementation techniques that are used in the development of critical and real-time systems.\n\n10.1 Critical systems\n\nThere are three main types of critical systems [1]:\n\n1. Safety-critical systems. A system whose failure may result in injury, loss of life or serious environmental damage.\n2. Mission-critical systems. A system whose failure may result in the failure of some goal-directed activity.\n3. Business-critical systems. A system whose failure may result in very high costs for the business using that system.\n\nThe most important property of a critical system is its dependability. The term dependability covers the related systems attributes such as availability, reliability, safety and security.\n\nThere are three system components where critical systems failures may occur:\n\n1. System hardware components may fail because of mistakes in their design or manufacturing errors.\n2. System software may fail due to mistakes in its specification, design or implementation.\n3. Human operators of the system may fail to operate the system correctly.\n\nBecause of the high cost of critical systems failure, trusted methods and well-known techniques must be used for development of these systems. Most critical systems are socio-technical systems where people monitor and control the operation of computer-based systems. Operators in these systems must successfully treat unexpected situations and cope with additional workload. However, this may cause more stress and so on mistakes.\n\n10.1.1 System dependability\n\nThe dependability is a property of systems. A dependable computer system provides a trustworthy operation to users. This means that system is expected to not fail in normal use. There are four principle attributes to dependability:\n\n1. Availability. The availability of a system is the probability that the system can provide the services requested by users at any time.\n2. Reliability. The reliability of a system is the probability, over a given period of time, that the system will correctly deliver services.\n3. Safety. The safety of a system shows the extent of damage may be caused by the system to people or its environment.\n4. Security. The security of a system shows that how the system can resist accidental or deliberate unauthorized intrusions.\n\nBesides these four attributes, other system properties can also be related to dependability:\n\n1. Reparability. Disruption caused by any failure can be minimized if the system can be repaired as soon as possible. Therefore, it is important to be able to diagnose the problem, access the component that has failed and make changes to fix that component.\n2. Maintainability. Once new requirements are emerged it is important to maintain the system by integration of new functionalities required.\n3. **Survivability.** Survivability is the ability of a system to continue operation of the service during a possible attack, even at the loss of certain parts of the system.\n\n4. **Error tolerance.** This property is considered as part of usability and shows how the system is designed to avoid and tolerate user input errors.\n\nSystem developers have usually to prioritize system performance and system dependability. Generally, high levels of dependability can only be achieved at the expense of system performance. Because of the additional design, implementation and validation costs, increasing the dependability of a system can significantly increase development costs.\n\n### 10.1.1.1 Availability and reliability\n\nThe **reliability** of a system is the probability that the system correctly provides services as defined in its specification. In other words, the reliability of software can be related to the probability that the system input will be a member of the set of inputs, which cause an erroneous output to occur. If an input causing an erroneous output is associated with a frequently used part of the program, then failures will be frequent. However, if it is associated with rarely used code, then users will hardly complain about failures.\n\nThe **availability** of a system is the probability that the system will provide its services to users when they request them. If users need for continuous service then the availability requirements are high.\n\nReliability and availability are primarily compromised by system failures. These may be a failure to provide a service, a failure to deliver a service as specified, or the delivery of a service unsafely and insecurely. However, many failures are a consequence of erroneous system behaviour that derives from faults in the system. To increase the reliability of a system the following approaches can be used:\n\n1. **Fault avoidance.** Program development techniques are used that can minimize the possibility of mistakes and/or eliminate mistakes before they cause system faults.\n2. **Fault detection and removal.** The use of verification and validation techniques that effectively helps to detect and remove the faults before the system is used.\n3. **Fault tolerance.** Techniques that ensure that faults in a system do not result in system errors or that ensure that system errors do not result in system failures.\n\n### 10.1.2 Safety\n\nThe essential feature of safety-critical systems is that system operation is always safe. These systems never compromise or damage people or the environment of the system, even if the system fail. Safety-critical software has two groups:\n\n1. **Primary safety-critical software.** This software is usually embedded as a controller in a system. Malfunctioning of such software can cause a hardware malfunction, which results in human injury and/or environmental damage.\n2. **Secondary safety-critical software.** This is software that can indirectly result in injury. For an example, software used for design has a fault can causes the malfunction of designed system and this may results in injury to people.\n\nThe safe operation, i.e. ensuring either that accidents do not occur or that the consequences of an accident are minimal, can be achieved in the next ways:\n\n1. **Hazard avoidance.** This type of system is designed so that hazards are avoided. For example, a safe cutting system equipped with two control buttons, where the two buttons can be operated by using separate hands.\n2. **Hazard detection and removal.** The system is designed so that hazards are detected and removed before they result in an accident. For example, pressure control in a chemical reactor system can reduce the detected excessive pressure before an explosion occurs.\n\n3. **Damage limitation.** These systems have a functionality that can minimize the effects of an accident. For example, automatic fire extinguisher systems.\n\n### 10.1.3 Security\n\nSecurity has become increasingly important attributes of systems connecting to the Internet. Internet connections provide additional system functionality, but it also allows systems to be attacked by people with hostile intentions. Security is a system attribute that shows the ability of the system to protect itself from accidental or deliberate external attacks. In some critical systems such as systems for electronic commerce, military systems, etc., security is the most important attribute of system dependability.\n\nExamples of attacks might be viruses, unauthorized use of system services and data, unauthorized modification of the system, etc. Security is an important attribute for all critical systems. Without a reasonable level of security, the availability, reliability and safety of the system may be compromised if external attacks cause some damage to the system. There are three types of damage that may be caused by external attack:\n\n1. **Denial of service.** In this case of attack the system is forced into a state where its normal services become unavailable.\n2. **Corruption of programs or data.** The software components of the system are damaged affecting reliability and safety of system.\n3. **Disclosure of confidential information.** Confidential information managed by the system is exposed to unauthorized people as a consequence of the external attack.\n\nThe security of a system may be assured using the following methods:\n\n1. **Vulnerability avoidance.** The system is designed not to be vulnerable. For example, if a system is not connected to Internet there is no possibility of external attacks.\n2. **Attack detection and neutralization.** The system is designed so that it detects and removes vulnerabilities before any damage occurs. An example of vulnerability detection and removal is the use of a virus checker to remove infected files.\n3. **Exposure limitation.** In these methods the consequences of attack are minimized. An example of exposure limitation is the application of regular system backups.\n\n### 10.2 Critical systems development\n\nDue to the quick progress in computer technology, improvement of software development methods, better programming languages and effective quality management the dependability of software has significantly improved in the last two decades. In system development special development techniques may be used to ensure that the system is safe, secure and reliable. There are three complementary approaches can be used to develop dependable software:\n\n1. **Fault avoidance.** The design and implementation process are used to minimize the programming errors and so on the number of faults in a program.\n2. **Fault detection.** The verification and validation processes are designed to discover and remove faults in a program before it is deployed for operational use.\n3. **Fault tolerance.** The system is designed so that faults or unexpected system behaviour during execution are detected and managed in such a way that system failure does not occur.\nRedundancy and diversity are fundamental to the achievement of dependability in any system. Examples of redundancy are the components of critical systems that replicate the functionality of other components or an additional checking mechanism that is added to system but not strictly necessary for the basic operation of system. Faults can therefore be detected before they cause failures, and the system may be able to continue operating if individual components fail. If the redundant components are not the same as other components, is the case of diversity, a common failure in the same, replicated component will not result in a complete system failure.\n\nSoftware engineering research intended to develop tools, techniques and methodologies that lead to the production of fault-free software. Fault-free software is software that exactly meets its specification. Of course, this does not mean that the software will never fail. There may be errors in the specification that may be reflected in the software, or the users may misunderstand or misuse the software system. In order to develop fault-free software the following software engineering techniques must be used:\n\n1. **Dependable software processes.** The use of a dependable software process with appropriate verification and validation activities can minimize the number of faults in a program and detect those that do slip through.\n2. **Quality management.** The software development organization must have a development culture in which quality drives the software process. Design and development standards should be established that provide the development of fault-free programs.\n3. **Formal specification.** There must be a precise system specification that defines the system to be implemented.\n4. **Static verification.** Static verification techniques, such as the use of static analysers, can find anomalous program features that could be faults.\n5. **Strong typing.** A strongly typed programming language such as Java must be used for development. If the programming language has strong typing, the language compiler can detect many programming errors.\n6. **Safe programming.** Some programming language constructs are more complex and error-prone than others. Safe programming means avoiding or at least minimizing the use of these constructs.\n7. **Protected information.** Design and implementation processes based on information hiding and encapsulation is to be followed. Object-oriented languages such as Java satisfy this condition.\n\nAlthough, development of fault-free software by application of these techniques is possible, it is economically disadvantageous. The cost of finding and removing remaining faults rises exponentially as faults in the program are discovered and removed. While the software becomes more dependable more tests are needed to find fewer and fewer faults.\n\n### 10.2.1 Fault tolerance\n\nA fault-tolerant system can continue its operation even after some of its part is faulty or not reliable. The fault-tolerance mechanisms in the system ensure that these system faults do not cause system failure. Where system failure could cause a catastrophic accident or where a loss of system operation would cause large economic losses it is necessary to develop fault-tolerant system. There are four complementary approaches to ensure fault-tolerance of a system:\n\n1. **Fault detection.** The system must detect a fault that causes a system failure. Generally, this based on checking consistency of the system state.\n2. **Damage assessment.** The parts of the system state that have been affected by the fault must be detected.\n\n3. **Fault recovery.** The system restores its state to a known safe state. This may be achieved by correcting the damaged state or by restoring the system to a known safe state.\n\n4. **Fault repair.** This involves modifying the system so that the fault does not recur.\n\n### 10.2.1.1 Fault detection and damage assessment\n\nThe first stage in ensuring fault tolerance is to detect that a fault either has occurred or will occur unless some action is taken immediately. To achieve this, the illegal values of state variables must be recognized. Therefore, it is necessary to define state constraints that define the conditions that must always hold for all legal states. If these predicates are false, then a fault has occurred.\n\nDamage assessment involves analyzing the system state to estimate the extent of the state corruption. The role of the damage assessment procedures is not to recover from the fault but to assess what parts of the state space have been affected by the fault. Damage can only be assessed if it is possible to apply some validity function that checks whether the state is consistent.\n\n### 10.2.1.2 Fault recovery and repair\n\nThe purpose of fault recovery process is to modify the state of the system so that the effects of the fault are eliminated or reduced. The system can continue to operate, perhaps in some degraded form. **Forward recovery** tries to correct the damaged system state and to create the intended state. Forward recovery is only possible in the cases where the state information includes built-in redundancy. **Backward recovery** restores the system state to a known correct state.\n\nFor an example, most database systems include backward error recovery. When a user starts a database operation, a transaction is initiated. The changes made during that transaction are not immediately incorporated in the database. The database is only updated after the transaction is finished and no problems are detected. If the transaction fails, the database is not updated.\n\n### 10.3 Real-time software design\n\nThe real-time embedded systems are significantly different from other types of software systems. Their correct operation is dependent on the system responding to events within a short time interval. The real-time system can be shortly defined as follows:\n\n*A real-time system is a software system where the correct operation of the system depends on the results produced by the system and the time at which these results are produced.*\n\nTimely response is an important factor in all embedded systems but, in some cases, very fast response is not necessary. The real-time system is a stimulus/response system. It must produce a corresponding response for a particular input stimulus. Therefore, the behaviour of a real-time system can therefore be defined by listing the stimuli received by the system, the associated responses and the time at which the response must be produced. Stimuli has two classes:\n\n1. **Periodic stimuli.** These stimuli are generated at predictable time intervals.\n2. **Aperiodic stimuli.** These stimuli occur irregularly.\n\nPeriodic stimuli in a real-time system are usually generated by sensors associated with the system and provide information about the state of the system’s environment. The responses of\nA real-time system must be able to respond to stimuli that occur at different times. Therefore, architecture should be designed so that, as soon as a stimulus is received, control is transferred to the correct handler. This cannot be achieved using sequential programs. Consequently, real-time systems are normally designed as a set of concurrent and cooperating processes. In order to manage these concurrent processes most real-time systems includes a real-time operating system.\n\nThe stimulus-response model of a real-time system consists of three processes. Each type of sensor has a sensor management process, computational processes to compute the required response for the stimuli received by the system and control processes for actuator to manage their operation. This stimulus-response model enables rapid collection of data from the sensor and allows the computational processes and actuator responses to be carried out later.\n\n### 10.3.1 System design\n\nDesigning a real-time system it is necessary to decide first which system capabilities are to be implemented in software and which in hardware. Then the design process of real-time software focuses on the stimuli rather than the objects and functions. The design process has a number of overlapped stages:\n\n1. Identification of the stimuli that the system must process and the associated responses.\n2. Specifying the timing constraints for each stimulus and associated response.\n3. Selection of hardware components and the real-time operating system to be used.\n4. Aggregation of the stimulus and response processing into a number of concurrent processes. It is usual in real-time systems design is to associate a concurrent process with each class of stimulus and response as shown in Figure 10.2.\n5. Design of algorithms of the required computations for each stimulus and response.\n6. Design a scheduling system ensuring that processes are started and completed in time.\n\n---\n\n**Figure 10.1. General model for a real-time system.**\n\n**Figure 10.2. Sensor – actuator control process.**\nProcesses must be coordinated in a real-time system. Process coordination mechanisms ensure mutual exclusion to shared resources. Once the process architecture has been designed and scheduling policy has been decided it should be checked that the system will meet its timing requirements.\n\nTiming constraints or other requirements often mean that some system functions, such as signal processing, should be implemented in hardware rather than in software. Hardware components can provide a better performance than the equivalent software.\n\n### 10.3.1 Real-time system modelling\n\nReal-time systems have to respond to events occurring at irregular intervals. These stimuli often cause the system to move to a new state. For this reason, state machine models are often used to model real-time systems. Application of state machine models is an effective way to represent the design of a real-time system. The UML supports the development of state models based on state-charts. A state model of a system assumes that the system, at any time, is in one of a number of possible states. When a stimulus is received it may cause a transition to a different state.\n\n### 10.3.2 Real-time operating systems\n\nMost of the embedded systems have real-time performance constraints that mean they have to work in conjunction with a real-time operating system (RTOS). Real-time operating systems guarantee a certain capability within a specified time constrain. It manages processes and resource allocation in a real-time system. It can starts and stops processes and allocate memory and processor resources, so that stimuli can be handled as concurrent processes.\n\nReal-time operating systems usually include the following components:\n\n1. **Real-time clock.** This provides information to schedule processes periodically.\n2. **Interrupt handler.** This manages aperiodic requests for service.\n3. **Process manager.** It is responsible for scheduling processes to be executed.\n4. **Resource manager.** Resource manager allocates resources (memory, processor, etc.) to processes.\n5. **Despatcher.** It is responsible for starting the execution of a process.\n\n### 10.3.2.1 Process management\n\nReal-time systems have to respond events from the hardware in real time. The processes handling events must be scheduled for execution and must be allocated processor resources to provide their deadline. In real-time operating systems the process manager is responsible for selecting the next process to be executed, allocating resources such as processor and memory resources and starting and stopping the process.\n\nThe process manager has to manage processes having different priority. Real-time operating systems define different priority levels for system processes:\n\n1. **Interrupt level.** This is the highest priority level. It is allocated to processes that need a very fast response.\n2. **Clock level.** This level of priority is assigned to periodic processes.\n3. **Background processes level.** This is the lowest priority level. It is allocated to background processes that have no timing constraints. These processes are scheduled for execution when processor capacity is available.\n\nIn most real-time systems, there are several types of periodic processes. They usually control the data acquisition and the actions of actuators. Periodic processes have different execution time and deadline. The timing requirements of all processes are specified by the\napplication program. The real-time operating system manages the execution of periodic processes and ensures that every process have to be completed by their deadline.\n\n\n\n**Figure 10.3.** RTOS actions required to start a process.\n\nFigure 10.3. shows the sequence of activities that are performed by the operating system for periodic process management. The scheduler examines all the periodic processes and chooses a process to be executed. The choice depends on the process priority, the process periods, the expected execution times and the deadlines of the ready processes.\n\n### 10.4 Exercises\n\n1. What does the embedded system mean?\n2. Give examples of embedded system!\n3. What are the three types of critical systems. What is the different between them?\n4. What are the main dimensions of system dependability?\n5. What approaches can be used for dependable software development?\n6. List some programming techniques that are not recommended in safe programming!\n7. What does the fault-tolerant system mean?\n8. What systems are called real-time systems?\n9. What types of stimulus are the real-time systems designed for?\n10. Explain the process management of real-time systems!\n11 Project management\n\nSoftware engineering projects are always subject to organizational budget and schedule constraints. Software project managers are the responsible person for planning and scheduling development project. They supervise the development work to ensure that it is carried out to the organizational standards and monitor the progress of the project. Project manager is also responsible for checking the development cost. Software engineering is differs from other engineering activities in a number of ways [1].\n\nThe manager of a civil engineering project can see how a product is being developed. However, software is an intangible product. Software project managers can only see the progress of software development by documents produced to review the software process. In manufacturing the production processes are continuously tried and tested and finally they may be standardized. The engineering processes for many systems are well understood. However, there are no standard software processes and software processes are very different from one organization to another. Due to the rapid technological changes in computers and communications software projects are usually different in some ways from previous projects. Experiences from previous projects usually may not be transferred to a new development project.\n\nBecause of these problems some software projects may be late, over budget and behind schedule.\n\n11.1 Management activities\n\nThe job of a software manager depends on the organization and the software product being developed. However, most managers have a certain responsibility for the following activities relating to a software project:\n\n− Proposal writing. The first task of managers in a software project is writing a proposal. It describes the objectives of the project and how it will be carried out. It usually includes cost and schedule estimates.\n\n− Project planning and scheduling. Project planning is concerned with identifying the activities, milestones and deliverables produced by the development project.\n\n− Project cost estimation. Cost estimation is concerned with estimating the resources required to accomplish the project plan.\n\n− Project monitoring and reviews. Project monitoring is a continuing project activity. The manager monitors the progress of the project and compares the actual and planned progress and costs. Project reviews are concerned with reviewing overall progress and technical development of the project and checking whether the project and the goals are still aligned.\n\n− Personnel selection and evaluation. Project managers are usually responsible for selecting people with appropriate skill and experience to work on the project.\n\n− Report writing and presentations. Project managers are usually responsible for reporting on the project to both the client and contractor organizations. They must be able to present this information during progress reviews.\n\n11.2 Project planning\n\nThe effective management of a software project greatly depends on careful planning the progress of the project. The plan prepared at the start of a project is considered an initial plan and it should be used as the driver for the entire project. The initial plan should be the best possible plan given by the available information. It evolves as the project progresses and more information becomes available.\nThe subsection 11.2.1. discusses the structure of the software project plan. In addition to the project plan managers have to prepare other types of plans such as quality plan, maintenance plan, etc. The planning is an iterative process. Effectively, the project plan can only be considered to be completed when the project has finished. As more information becomes available during the project, the project plan should be revised.\n\nThe planning process starts by defining constraints affecting the project (required delivery time, availability of labour, the total budget, etc.). In conjunction with this, project parameters such as its structure, size and project deliverables are defined. The process then enters a loop. Milestones and project schedule are defined and the scheduled activities are started. After a certain time the progress of project is reviewed and the deviation from the planned schedule are noted.\n\nProject manager has to revise his assumptions related to project plan as more information becomes available. If the project is delayed, project has to be rescheduled and the project constraints and deliverables have to be negotiated with the customer.\n\n11.2.1 The project plan\n\nThe project plan sets out the resources available to the project, the work breakdown and a schedule for carrying out the work. Most project plans includes the following sections:\n\n1. *Introduction.* This summarizes the objectives of the project and sets out the budget, time and other constraints.\n2. *Project organization.* This defines the development team, its members and the roles in the team.\n3. *Hardware and software resource requirements.* This specifies the hardware and the support software allocated to development activities.\n4. *Work breakdown.* This sets out the breakdown of the project into activities and identifies the milestones and deliverables associated with each activity.\n5. *Project schedule.* Project schedule shows the dependencies between activities, the estimated time required to complete activities and the allocation of people to activities.\n6. *Risk analysis.* This describes the possible project risks and the strategies to manage them.\n7. *Monitoring and reporting mechanisms.* This defines the management reports that should be produced, when these should be produced and the project monitoring mechanisms used.\n\n\n\nFigure 11.1. The project scheduling process.\n11.3 Project scheduling\n\nIn the project scheduling process project managers estimate the time and resources required to complete activities and organize them into a coherent sequence (Figure 11.1.). Usually, some of activities can be carried out in parallel. Managers have to coordinate these parallel activities and organize the work so that the labour is used optimally.\n\nThe duration of project activities are normally at least a week. Project manager has to estimate the resources needed to complete each task. The principal resource is the human effort required. Other resources are related to the hardware and software required to development activities.\n\nProject schedules are usually represented as a set of charts showing the work breakdown, activities dependencies and staff allocations. Bar charts (for example Gantt chart) and activity networks are graphical notations that are used to illustrate the project schedule. Bar charts show who is responsible for each activity and when the activity is scheduled to begin and end. Activity networks show the dependencies between the different activities. Activity networks help to identify which activities can be carried out in parallel and which must be executed in sequence because of a dependency on an earlier activity.\n\n11.4 Risk management\n\nRisk management is one of the main activities of project managers. It involves anticipating risks that might affect the project schedule or the quality of the software being developed and taking action to avoid these risks. The results of the risk analysis should be documented in the project plan along with an analysis of the consequences of a risk occurring. There are three categories of risk:\n\n1. Project risks. These risks affect the entire project schedule.\n2. Product risks. Product risks have influence on the quality and performance of the software.\n3. Business risks. These risks affect the organization developing or procuring the software.\n\nProject manager has to get ready for risks, understand the impact of these risks on the project, the product and the business, and take steps to avoid these risks. Project manager should prepare contingency plans so that, if the risks occur, he can take immediate actions.\n\nThe risk management process is shown in Figure 11.2. It has four stages:\n\n1. Risk identification. Possible project, product and business risks are identified.\n2. Risk analysis. Using risk analysis the probability and consequences of risks are analyzed.\n3. Risk planning. The objective of risk planning is to avoid the risks or minimize its effects.\n4. Risk monitoring. The identified risk is continuously assessed and the avoidance strategies are revised as more information becomes available about the risk.\nThe risk management process is an iterative process which continues throughout the project. As more information about the risks becomes available, the risks have to be reanalyzed and the avoidance and contingency plans has to be also modified. The outcomes of the risk management process should be documented in a risk management plan.\n\n11.4.1 Risk identification\n\nThe first stage of risk management is the identification of risks. It is concerned with discovering possible risks to the project. Risk identification may be carried out as a team work based on the experience of team members. Helping the process risks are usually classified into separate groups:\n\n1. **Technology risks.** These risks are related to the software or hardware technologies that are used to develop the system.\n2. **People risks.** Risk that are associated with the people in the development team.\n3. **Organizational risks.** Risk that derive from the changes in organizational environment.\n4. **Tools risks.** Risk that derive from the CASE tools and other support software used in the development process.\n5. **Requirements risks.** Risk that derive from changes to the customer requirements and the process of managing the requirements change.\n6. **Estimation risks.** Risk that derive from the management estimates of the system characteristics and the resources required to build the system.\n\nTable 11.1. gives some examples of possible risks in each of these categories.\n\n<table>\n<thead>\n<tr>\n<th>Risk type</th>\n<th>Possible risks</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Technology</td>\n<td>Purchased software component is defective.</td>\n</tr>\n<tr>\n<td>People</td>\n<td>Development manager regularly gets ill.</td>\n</tr>\n<tr>\n<td>Organizational</td>\n<td>The management of software company is restructured and other project management is responsible for the project.</td>\n</tr>\n<tr>\n<td>Tools</td>\n<td>The class skeleton generated by UML editor inefficient.</td>\n</tr>\n<tr>\n<td>Requirements</td>\n<td>Changes to software requirements which require development of additional increments.</td>\n</tr>\n</tbody>\n</table>\n11.4.2 Risk analysis\n\nDuring the risk analysis process, the probability and the effects of identified risks are determined. This process is mainly based on the experience of project managers. The risk estimates are generally assigned to different bands:\n\n1. The probability of the risk might be assessed as very low (<10%), low (10–25%), moderate (25-50%), high (50–75%) or very high (>75%).\n2. The effects of the risk might be assessed as catastrophic, serious, tolerable or insignificant.\n\nTable 11.2 illustrates results of risk analysis.\n\n<table>\n<thead>\n<tr>\n<th>Risk</th>\n<th>Probability</th>\n<th>Effects</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>It is not possible to recruit developers with appropriate skills</td>\n<td>High</td>\n<td>Catastrophic</td>\n</tr>\n<tr>\n<td>One of the software developers who regularly gets a flu in every years gets a flu again in this year</td>\n<td>High</td>\n<td>Serious</td>\n</tr>\n<tr>\n<td>The database used has a lower performance as expected.</td>\n<td>Moderate</td>\n<td>Serious</td>\n</tr>\n<tr>\n<td>Development time for a software component is underestimated.</td>\n<td>High</td>\n<td>Serious</td>\n</tr>\n</tbody>\n</table>\n\nOnce the risks have been analyzed and ranked, it is necessary to decide which risks are most significant. In general, the catastrophic risks and the serious risks having more than a moderate probability of occurrence should always be considered.\n\n11.4.3 Risk planning\n\nThe risk planning process identifies strategies to manage the identified risks. There is no general procedure to establish risk management plans. It is mostly based on the judgement and experience of the project manager. Table 11.3 shows possible strategies that have been identified for the key risks from Table 11.2.\n\nThe risk management strategies have three categories:\n\n1. *Avoidance strategies*. Following these strategies means that the probability that the risk will arise will be reduced.\n2. *Minimization strategies*. The objective of these strategies is to reduce the effect of risk. An example of a risk minimization strategy is that for staff illness shown in Table 11.3.\n3. *Contingency plans*. These are the strategies used when risk arises.\n11.4.4 Risk monitoring\n\nThe purpose of risk monitoring risk is to constantly assess each of the identified risks to decide whether its probability and effects have changed. Usually this cannot be observed directly and other factors should be monitored to detect the changes. Table 11.4. gives some examples of factors that may be helpful in assessing different types of risks.\n\n<table>\n<thead>\n<tr>\n<th>Risk type</th>\n<th>Potential indicators</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Technology</td>\n<td>One of the hardware supplier companies becomes bankrupt</td>\n</tr>\n<tr>\n<td>People</td>\n<td>Software engineer, who gets a flu in every year complains about weakness</td>\n</tr>\n<tr>\n<td>Organizational</td>\n<td>Poor managerial activity is seen</td>\n</tr>\n<tr>\n<td>Tools</td>\n<td>Using a CASE tool the first error occurs</td>\n</tr>\n<tr>\n<td>Requirements</td>\n<td>Customer complains about the performance of current version of software</td>\n</tr>\n<tr>\n<td>Estimation</td>\n<td>The status of the approved project schedule is very poor</td>\n</tr>\n</tbody>\n</table>\n\n11.5 Exercises\n\n1. What are the main differences between a software engineering and an industrial manufacturing project?\n2. List the main activities of a software project manager!\n3. List the parts of a project plan!\n4. Explain the project scheduling process!\n5. Explain the steps of risk management!\n6. What are the objectives for risk analysis?\n7. What strategies can be applied in risk planning?\n12 Software quality management\n\nThe quality of software has improved significantly over the past two decades. One reason for this is that companies have used new technologies in their software development process such as object-oriented development, CASE tools, etc. In addition, a growing importance of software quality management and the adoption of quality management techniques from manufacturing can be observed. However, software quality significantly differs from the concept of quality generally used in manufacturing mainly for the next reasons [1]:\n\n1. The software specification should reflect the characteristics of the product that the customer wants. However, the development organization may also have requirements such as maintainability that are not included in the specification.\n2. Certain software quality attributes such as maintainability, usability, reliability cannot be exactly specified and measured.\n3. At the early stages of software process it is very difficult to define a complete software specification. Therefore, although software may conform to its specification, users don’t meet their quality expectations.\n\nSoftware quality management is split into three main activities:\n\n1. Quality assurance. The development of a framework of organizational procedures and standards that lead to high quality software.\n2. Quality planning. The selection of appropriate procedures and standards from this framework and adapt for a specific software project.\n3. Quality control. Definition of processes ensuring that software development follows the quality procedures and standards.\n\nQuality management provides an independent check on the software and software development process. It ensures that project deliverables are consistent with organizational standards and goals.\n\n12.1 Process and product quality\n\nIt is general, that the quality of the development process directly affects the quality of delivered products. The quality of the product can be measured and the process is improved until the proper quality level is achieved. Figure 12.1. illustrates the process of quality assessment based on this approach.\n\n\n\nFigure 12.1. Process based quality assessment.\n\nIn manufacturing systems there is a clear relationship between production process and product quality. However, quality of software is highly influenced by the experience of software engineers. In addition, it is difficult to measure software quality attributes, such as maintainability, reliability, usability, etc., and to tell how process characteristics influence these attributes. However, experience has shown that process quality has a significant influence on the quality of the software.\nProcess quality management includes the following activities:\n\n1. Defining process standards.\n2. Monitoring the development process.\n3. Reporting the software.\n\n### 12.2 Quality assurance and standards\n\nQuality assurance is the process of defining how software quality can be achieved and how the development organization knows that the software has the required level of quality. The main activity of the quality assurance process is the selection and definition of standards that are applied to the software development process or software product. There are two main types of standards. The product standards are applied to the software product, i.e. output of the software process. The process standards define the processes that should be followed during software development. The software standards are based on best practices and they provide a framework for implementing the quality assurance process.\n\nThe development of software engineering project standards is a difficult and time consuming process. National and international bodies such as ANSI and the IEEE develop standards that can be applied to software development projects. Organizational standards, developed by quality assurance teams, should be based on these national and international standards. Table 12.1. shows examples of product and process standards.\n\n<table>\n<thead>\n<tr>\n<th>Product standards</th>\n<th>Process standards</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Requirements document structure</td>\n<td>Project plan approval process</td>\n</tr>\n<tr>\n<td>Method header format</td>\n<td>Version release process</td>\n</tr>\n<tr>\n<td>Java programming style</td>\n<td>Change control process</td>\n</tr>\n<tr>\n<td>Change request form</td>\n<td>Test recording process</td>\n</tr>\n</tbody>\n</table>\n\n### 12.2.1 ISO\n\nISO 9000 is an international set of standards that can be used in the development of a quality management system in all industries. ISO 9000 standards can be applied to a range of organizations from manufacturing to service industries. ISO 9001 is the most general of these standards. It can be applied to organizations that design, develop and maintain products and develop their own quality processes. A supporting document (ISO 9000-3) interprets ISO 9001 for software development.\n\nThe ISO 9001 standard isn’t specific to software development but includes general principles that can be applied to software development projects. The ISO 9001 standard describes various aspects of the quality process and defines the organizational standards and procedures that a company should define and follow during product development. These standards and procedures are documented in an organizational quality manual.\n\nThe ISO 9001 standard does not define the quality processes that should be used in the development process. Organizations can develop own quality processes and they can still be ISO 9000 compliant companies. The ISO 9000 standard only requires the definition of processes to be used in a company and it is not concerned with ensuring that these processes provide best practices and high quality of products. Therefore, the ISO 9000 certification doesn’t mean exactly that the quality of the software produced by an ISO 9000 certified companies will be better than that software from an uncertified company.\n12.2.2 Documentation standards\n\nDocumentation standards in a software project are important because documents can represent the software and the software process. Standardized documents have a consistent appearance, structure and quality, and should therefore be easier to read and understand. There are three types of documentation standards:\n\n1. Documentation process standards. These standards define the process that should be followed for document production.\n2. Document standards. These standards describe the structure and presentation of documents.\n3. Documents interchange standards. These standards ensure that all electronic copies of documents are compatible.\n\n12.3 Quality planning\n\nQuality planning is the process of developing a quality plan for a project. The quality plan defines the quality requirements of software and describes how these are to be assessed. The quality plan selects those organizational standards that are appropriate to a particular product and development process. Quality plan has the following parts:\n\n1. Introduction of product.\n2. Product plans.\n4. Quality goals.\n5. Risks and risk management.\n\nThe quality plan defines the most important quality attributes for the software and includes a definition of the quality assessment process. Table 12.2. shows generally used software quality attributes that can be considered during the quality planning process.\n\n<table>\n<thead>\n<tr>\n<th>Safety</th>\n<th>Understandability</th>\n<th>Portability</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Security</td>\n<td>Testability</td>\n<td>Usability</td>\n</tr>\n<tr>\n<td>Reliability</td>\n<td>Adaptability</td>\n<td>Reusability</td>\n</tr>\n<tr>\n<td>Resilience</td>\n<td>Modularity</td>\n<td>Efficiency</td>\n</tr>\n<tr>\n<td>Robustness</td>\n<td>Complexity</td>\n<td>Learnability</td>\n</tr>\n<tr>\n<td>Maintainability</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n12.4 Quality control\n\nQuality control provides monitoring the software development process to ensure that quality assurance procedures and standards are being followed. The deliverables from the software development process are checked against the defined project standards in the quality control process. The quality of software project deliverables can be checked by regular quality reviews and/or automated software assessment. Quality reviews are performed by a group of people. They review the software and software process in order to check that the project standards have been followed and that software and documents conform to these standards.\nAutomated software assessment processes the software by a program that compares it to the standards applied to the development project.\n\n### 12.4.1 Quality reviews\n\nQuality reviews are the most widely used method of validating the quality of a process or product. They involve a group of people examining part or all of a software process, system, or its associated documentation to discover potential problems. The conclusions of the review are formally recorded and passed to the author for correcting the discovered problems. Table 12.3 describes several types of review, including quality reviews.\n\n**Table 12.3. Types of review.**\n\n<table>\n<thead>\n<tr>\n<th>Review type</th>\n<th>Principal purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Design or program inspections</td>\n<td>To detect detailed errors in the requirements, design or code.</td>\n</tr>\n<tr>\n<td>Progress reviews</td>\n<td>To provide information for management about the overall progress of the project.</td>\n</tr>\n<tr>\n<td>Quality reviews</td>\n<td>To carry out a technical analysis of product components or documentation to find mismatches between the specification and the component design, code or documentation and to ensure that defined quality standards of the organization have been followed.</td>\n</tr>\n</tbody>\n</table>\n\n### 12.5 Software measurement and metrics\n\nSoftware measurement provides a numeric value for some quality attribute of a software product or a software process. Comparison of these numerical values to each other or to standards draws conclusions about the quality of software or software processes. Software product measurements can be used to make general predictions about a software system and identify anomalous software components.\n\nSoftware metric is a measurement that relates to any quality attributes of the software system or process. It is often impossible to measure the external software quality attributes, such as maintainability, understandability, etc., directly. In such cases, the external attribute is related to some internal attribute assuming a relationship between them and the internal attribute is measured to predict the external software characteristic. Three conditions must be hold in this case:\n\n1. The internal attribute must be measured accurately.\n2. A relationship must exist between what we can measure and the external behavioural attribute.\n3. This relationship has to be well understood, has been validated and can be expressed in terms of a mathematical formula.\n\n### 12.5.1 The measurement process\n\nA software measurement process as a part of the quality control process is shown in Figure 12.2. The steps of measurement process are the followings:\n\n1. Select measurements to be made. Selection of measurements that are relevant to answer the questions to quality assessment.\n2. Select components to be assessed. Selection of software components to be measured.\n3. **Measure component characteristics.** The selected components are measured and the associated software metric values computed.\n\n4. **Identify anomalous measurements.** If any metric exhibit high or low values it means that component has problems.\n\n5. **Analyze anomalous components.** If anomalous values for particular metrics have been identified these components have to be examined to decide whether the anomalous metric values mean that the quality of the component is compromised.\n\nGenerally each of the components of the system is analyzed separately. Anomalous measurements identify components that may have quality problems.\n\n\n\n**Figure 12.2.** The software measurement process.\n\n### 12.5.2 Product metrics\n\nThe software characteristics that can be easily measured such as size do not have a clear and consistent relationship with quality attributes such as understandability and maintainability. Product metrics has two classes:\n\n1. **Dynamic metrics.** These metrics (for example execution time) are measured during the execution of a program.\n2. **Static metrics.** Static metrics are based on measurements made of representations of the system such as the design, program or documentation.\n\nDynamic metrics can be related to the efficiency and the reliability of a program. Static metrics such as code size are related to software quality attributes such as complexity, understandability, maintainability, etc.\n\n### 12.6 Exercises\n\n1. Give examples of software quality attributes!\n2. What is the objective of product standards?\n3. What is the objective of process standards?\n4. Give examples of product and process standards!\n5. What international standards can be used in software quality assessment?\n6. What are the types of document standard?\n7. What are the main parts of a quality plan?\n8. What are the steps of software measurement process?\n9. Give examples of static software metric!\n13 Software cost estimation\n\nSoftware development processes are split into a number of separate activities. Cost estimation of software development project focuses on how associating estimates of effort and time with the project activities. Estimation involves answering the following questions [1]:\n\n1. How much effort is required to complete each activity?\n2. How much calendar time is needed to complete each activity?\n3. What is the total cost of each activity?\n\nProject cost estimation and project scheduling are usually carried out together. The costs of development are primarily the costs of the effort involved, so the effort computation is used in both the cost and the schedule estimate. The initial cost estimates may be used to establish a budget for the project and to set a price for the software for a customer. The total cost of a software development project is the sum of following costs:\n\n1. Hardware and software costs including maintenance.\n2. Travel and training costs.\n3. Effort costs of paying software developers.\n\nFor most projects, the dominant cost is the effort cost. Effort costs are not just the salaries of the software engineers who are involved in the project. The following overhead costs are all part of the total effort cost:\n\n1. Costs of heating and lighting offices.\n2. Costs of support staff (accountants, administrators, system managers, cleaners, technicians etc.).\n3. Costs of networking and communications.\n4. Costs of central facilities (library, recreational facilities, etc.).\n5. Costs of social security and employee benefits such as pensions and health insurance.\n\nThe aim of software costing is to accurately predict the cost of developing the software. The price of software is normally the sum of development cost and profit. During the development project managers should regularly update their cost and schedule estimates. This helps with the planning process and the effective use of resources. If actual expenditure is significantly greater than the estimates, then the project manager must take some action. This may involve applying for additional resources for the project or modifying the work to be done.\n\n13.1 Software productivity estimation\n\nProductivity estimates help to define the project cost and schedule. In a software development project managers may be faced with the problem of estimating the productivity of software engineers. For any software problem, there may be many different solutions, each of which has different attributes. One solution may execute more efficiently while another may be more readable and easier to maintain and comparing their production rates is very difficult.\n\nProductivity estimates are usually based on measuring attributes of the software and dividing this by the total effort required for development. Software metrics have two main types:\n\n1. *Size-related software metrics.* These metrics are related to the size of software. The most frequently used size-related metric is lines of delivered source code.\n2. *Function-related software metrics.* These are related to the overall functionality of the software. For example, function points and object points are metrics of this type.\nThe productivity estimation defined as lines of source code per programmer month is widely used software productivity metric. It is computed by counting the total number of lines of source code divided by the total development time in programmer-months required to complete the project.\n\nIn other cases, the total number of function points in a program measures or estimates the following program features:\n\n1. external inputs and outputs,\n2. user interactions,\n3. external interfaces,\n4. files used by the system.\n\nObviously, some features are more complex than others and take longer time to code. The function point metric takes this into account by application of a weighting factor. The unadjusted function point count (UFC) is computed by multiplying the number of a given feature by its estimated weight for all features and finally summing products:\n\n$$\\text{UFC} = \\sum (\\text{number of a given feature}) \\times (\\text{weight for the given feature})$$\n\nObject points are an alternative to function points. The number of object points is computed by the estimated weights of objects:\n\n1. *Separate screens that are displayed*. Simple screens count as 1 object point, moderately complex screens count as 2, and very complex screens count as 3 object points.\n2. *Reports that are produced*. For simple reports, count 2 object points, for moderately complex reports, count 5, and for reports that are likely to be difficult to produce, count 8 object points.\n3. *Modules that are developed to supplement the database programming code*. Each of these modules counts as 10 object points.\n\nThe final code size is calculated by the number of function points and the estimated average number of lines of code (AVC) required to implement a function point. The estimated code size is computed as follows:\n\n$$\\text{CODE SIZE} = \\text{AVC} \\times \\text{UFC}$$\n\nThe problem with measures based on the amount produced in a given time period is that they take no account of quality characteristics such as reliability and maintainability.\n\n### 13.2 Development cost estimation techniques\n\nIn the early stage in a project it is very difficult to accurately estimate system development costs. There is no simple way to make an accurate estimate of the effort required to develop software. Techniques listed in Table 13.1. may be used to make software effort and cost estimates. All of these techniques based on the experience of project managers who use their knowledge of previous projects to estimate of the resources required for the project.\n\n<table>\n<thead>\n<tr>\n<th>Technique</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Algorithmic cost modelling</td>\n<td>Relating some software metric a mathematical model is developed to estimate the project cost.</td>\n</tr>\n<tr>\n<td>Expert judgement</td>\n<td>Several experts on the proposed software development techniques and the application domain are asked to estimate</td>\n</tr>\n<tr>\n<td>Estimation Method</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>-------------------------------------------------------</td>\n<td>-----------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>Estimation by previous projects</td>\n<td>The cost of a new project is estimated by a completed project in the same application domain.</td>\n</tr>\n<tr>\n<td>Application of Parkinson’s Law</td>\n<td>Parkinson’s Law states that work expands to fill the time available and the cost is determined by the resources used.</td>\n</tr>\n<tr>\n<td>Pricing to win</td>\n<td>The software cost is estimated by the price what the customer has available to spend on the project.</td>\n</tr>\n</tbody>\n</table>\n\nEach estimation technique listed in Table 13.1. has its own strengths and weaknesses. It is recommended to use several cost estimation techniques and compare their results. If they predict significantly different costs more information is required about the product, the software process, development team, etc.\n\n### 13.3 Algorithmic cost modelling\n\nAlgorithmic cost modelling uses a mathematical expression to predict project costs based on estimates of the project size, the number of software engineers, and other process and product factors. An algorithmic cost model can be developed by analyzing the costs and attributes of completed projects and finding the closest fit mathematical expression to actual project. In general, an algorithmic cost estimate for software cost can be expressed as:\n\n$$EFFORT = A \\times SIZE^B \\times M$$\n\nIn this equation $A$ is a constant factor that depends on local organizational practices and the type of software that is developed. Variable $SIZE$ may be either the code size or the functionality of software expressed in function or object points. $M$ is a multiplier made by combining process, product and development attributes, such as the dependability requirements for the software and the experience of the development team. The exponential component $B$ associated with the size estimate expresses the non-linearity of costs with project size. As the size of the software increases, extra costs are emerged. The value of exponent $B$ usually lies between 1 and 1.5.\n\nAll algorithmic models have the same difficulties:\n\n1. *It is difficult to estimate SIZE in the early stage of development.* Function or object point estimates can be produced easier than estimates of code size but are often inaccurate.\n2. *The estimates of the factors contributing to $B$ and $M$ are subjective.* Estimates vary from one person to another person, depending on their background and experience with the type of system that is being developed.\n\nThe number of lines of source code in software is the basic software metric used in many algorithmic cost models. The code size can be estimated by previous projects, by converting function or object points to code size, by using a reference component to estimate the component size, etc. The programming language used for system development also affects the number of lines of code to be implemented. Furthermore, it may be possible to reuse codes from previous projects and the size estimate has to be adjusted to take this into account.\n\n### 13.4 Exercises\n\n1. What is the objective of software cost estimation?\n2. What are the main costs of a software development project?\n3. How programmer productivity can be measured by function points?\n4. How programmer productivity can be measured by object points?\n5. List some cost estimation techniques that is not based on any size related metric of software!\n6. Explain the expression of algorithmic cost modelling!\n14 References\n\n11. RUP: Overview http://sce.uchcl.edu/helm/RationalUnifiedProcess/indexRUP.htm"}}},{"rowIdx":261,"cells":{"id":{"kind":"string","value":"eff8dc043fed1df2f6a40f884d81cba1ba19f625"},"text":{"kind":"string","value":"This CMMI Implementation Guide is a reference book for anyone interested in implementing CMMI in their organization. The purpose of this book is to provide insight into CMMI Implementation phases and best practices to be followed in this journey. Most of us agree that CMMI is more a De facto model that IT Industry follows and other industries also has shown lot of interest in adopting this model. The day to day popularity and its adoption rate is on the surge for CMMI. In this scenario, this book will help the new organizations and implementers, on how to approach CMMI Implementation practically in their organization. This book is not a replacement to the Model or to the resources which CMMI Institute Publishes. This is only an additional resource which user can benefit from.\n\nCMMI Institute holds the complete authority and rights to CMMI model and all the components within the framework. This book is prepared based on the experience of a practitioner on implementing the model in various organizations. The Author has worked in multiple roles in CMMI Implementation and has global exposure in implementing the model. We reiterate that for all the model related details and updates, please visit CMMI Institute website and contact CMMI Institute team for any clarifications.\n\nThis book is intent to give you guidance on how to approach CMMI Implementation in your organization from initiation, planning, execution, appraisal and sustenance. This book gives various practical approaches followed by organizations as typical examples. Implementation of CMMI is not an activity for marketing and bidding, it’s more than that, its strengthening of your product development & Service delivery models to achieve your business results. Considering this you would want CMMI Implementation to bring in the real cultural change and value to your business. This book provides you information which is useful for deciding, planning and implementing CMMI in Successful way.\n\nBe clear, there are many ways to implement CMMI and its practices. Having a better consultant or Engaging a CMMI Institute Partner in your Journey is always helpful in removing the barriers at right time, however in this book we are giving the details, which one should be aware of in this journey to better utilize the resources and control the program.\n\nThis book is suggested for senior management people, process quality assurance people, delivery people and anyone interested to know about CMMI Implementation. Understanding on the topics given in this book will help them to strategize for successful CMMI Implementation.\nIntroduction to CMMI\n\nCMMI (Capability Maturity Model Integration) is a Process Improvement Model, which has collection of Industry best practices to implement in Organizations to achieve process capability and maturity. CMMI is a proven approach to achieve better performance results. CMMI is more of a framework which contains the model, trainings and appraisal components which helps an organization to implement the model in successful way to get benefit out of it. CMMI over the years has shown lot of success considering organizations are getting dramatic improvements in effectiveness, efficiency and quality.\n\nSoftware Engineering Institute in Carnegie Melon University has developed this model initially. The CMMI Model Evolution is given below.\n\n<table>\n<thead>\n<tr>\n<th>Year</th>\n<th>Model Development</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1987</td>\n<td>Initial Framework</td>\n</tr>\n<tr>\n<td>1990</td>\n<td>CMMv1.0</td>\n</tr>\n<tr>\n<td>1993</td>\n<td>CMMv1.1</td>\n</tr>\n<tr>\n<td>1998</td>\n<td>CMMv2.0</td>\n</tr>\n<tr>\n<td>2000</td>\n<td>CMMIv1.0</td>\n</tr>\n</tbody>\n</table>\nIn the year 2012 -2013 the CMMI Model and related components have been transitioned to the newly formed CMMI Institute for better management and results. For further details, please refer CMMI Institute site and/or contact Customer relations of CMMI Institute.\n\nThe current version of CMMI is Version 1.3 and it got released in year 2010 and related appraisal version SCAMPI v1.3 also available. The model can be downloaded for free in CMMI Institute site. CMMI has three different Constellations in its product suite. As definition “a constellation is subset of CMMI product suite relevant to improvement in a particular area of interest”. The constellations are CMMI for Development, CMMI for Services and CMMI for Acquisition.\n\nCMMI for Development - Addresses guidance on product/System development/Engineering\n\nCMMI for Services - Addresses guidance on delivering services to internal and external entities\n\nCMMI for Acquisition – Addresses supply chain management, acquisition and outsourcing processes in government and in Industry.\n\nThese CMMI Constellations are having set of Process Areas designed to achieve results in that area. However there are 16 common process areas between all the three models. The other process areas are specific to that constellation. In this book, we are limiting ourselves with CMMI Dev (CMMI for Development) and CMMI SVC (CMMI for Services). In CMMI Dev we have 6 specific Process Areas and in CMMI SVC we have 7+1 Specific Process Areas. The CMMI Dev consists in total 22 Process Areas and CMMI Svc consists in total 23(+ Service System Development) Process Areas.\n\nProcess Area is a cluster of related practices to achieve certain results. Process Areas are organized in terms of Goals and each Goal consists of set of practices, which would help to achieve the goals. An Example: Configuration related practices to be performed in product development or in Service Delivery are collected and established under one process area called “Configuration Management”. Risk identification and handling practices are established under “Risk Management” process area.\n\nCMMI consists of two representations, Staged Representation and Continuous Representation. Staged Representation is adopted by most of the organizations as its giving them guidance and benchmarking with other Organizations, Whereas continuous representation is adopted by\nOrganizations which are clear in their area of improvement and are comfortable with the practices in all other areas (or comfortable with the level of performance). In Staged Representation, Organization’s Maturity level is provided with 5 different process maturities. In Continuous Representation, Each process Areas’ capability levels are presented with 6 levels. A representation in CMMI is analogous to a view into a dataset provided by a database. Both representations provide ways of implementing process improvement to achieve business goals. Both representations provide the same technical content, but organized into different ways.\n\nIn this guide, we will concentrate on the Staged Representation based on Maturity Level. A Maturity Level is a well-defined evolutionary plateau on the path to becoming a mature organization. Each level provides foundation to the next Maturity level. Each Maturity level Consists of set of process areas to be implemented. There are five maturity levels in CMMI Staged representation.\n\n<table>\n<thead>\n<tr>\n<th>Maturity Level</th>\n<th>Definition</th>\n<th>Characteristic</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Level 1</td>\n<td>Initial</td>\n<td>Poor Control & Heroism</td>\n</tr>\n<tr>\n<td>Level 2</td>\n<td>Managed</td>\n<td>Project Processes & Reactive</td>\n</tr>\n<tr>\n<td>Level 3</td>\n<td>Defined</td>\n<td>Organization Process & Proactive</td>\n</tr>\n<tr>\n<td>Level 4</td>\n<td>Quantitatively Managed</td>\n<td>Predictable and controlled Process</td>\n</tr>\n<tr>\n<td>Level 5</td>\n<td>Optimizing</td>\n<td>Process Improvement & Innovation</td>\n</tr>\n</tbody>\n</table>\n\n*source – CMMI Model\n\nEach Process Area consists of Goals. Goals are further aligned with related practices and a goal indicates combined achievement of practices under it. There are two types of Goals,\n\n- **Specific Goals**: Implementation Specific to that Area of Interest is the target\n- **Generic Goals**: Institutionalization of the process area is the target\n\nEach Goal consists of set of Practices to be performed. A Practice indicates the related tasks to be performed. There are two types of practices,\n\n- **Specific practices**: Specific and unique itself. Information differs from level to level\n- **Generic practices**: Common practices across all process areas with a similar grouping\n\nIn addition to this there are sub practices, notes and sample work products. They help us to understand the intent of the model components and implement it better.\nFurther details on architecture and understanding on Goals and practices, please refer to the CMMI model (The model is a registered copyrighted product of CMMI Institute).\n\n<table>\n<thead>\n<tr>\n<th>Maturity Level</th>\n<th>CMMI Dev Process Areas</th>\n<th>CMMI Svc Process Areas</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Level 2</td>\n<td>Requirements Management</td>\n<td>Requirements Management</td>\n</tr>\n<tr>\n<td></td>\n<td>Project Planning</td>\n<td>Work Planning</td>\n</tr>\n<tr>\n<td></td>\n<td>Project Monitoring and Control</td>\n<td>Work Monitoring and Control</td>\n</tr>\n<tr>\n<td></td>\n<td>Supplier Agreement Management</td>\n<td>Supplier Agreement Management</td>\n</tr>\n<tr>\n<td></td>\n<td>Configuration Management</td>\n<td>Configuration Management</td>\n</tr>\n<tr>\n<td></td>\n<td>Measurement and Analysis</td>\n<td>Measurement and Analysis</td>\n</tr>\n<tr>\n<td></td>\n<td>______________________________</td>\n<td>Service Delivery</td>\n</tr>\n<tr>\n<td>Level 3</td>\n<td>Requirements Development</td>\n<td>Strategic Service Management</td>\n</tr>\n<tr>\n<td></td>\n<td>Technical Solution</td>\n<td>Incident Resolution and Prevention</td>\n</tr>\n<tr>\n<td></td>\n<td>Product Integration</td>\n<td>Service Transition</td>\n</tr>\n<tr>\n<td></td>\n<td>Verification</td>\n<td>Service Continuity</td>\n</tr>\n<tr>\n<td></td>\n<td>Validation</td>\n<td>Capacity and Availability Management</td>\n</tr>\n<tr>\n<td></td>\n<td>Integrated Project Management</td>\n<td>Integrated Work Management</td>\n</tr>\n<tr>\n<td></td>\n<td>Risk Management</td>\n<td>Risk Management</td>\n</tr>\n<tr>\n<td></td>\n<td>Decision Analysis and resolution</td>\n<td>Decision Analysis and resolution</td>\n</tr>\n<tr>\n<td></td>\n<td>Organizational Training</td>\n<td>Organizational Training</td>\n</tr>\n<tr>\n<td></td>\n<td>Organizational Process Definition</td>\n<td>Organizational Process Definition</td>\n</tr>\n<tr>\n<td></td>\n<td>Organizational Process Focus</td>\n<td>Organizational Process Focus</td>\n</tr>\n<tr>\n<td></td>\n<td>______________________________</td>\n<td>Service System Development (Add)</td>\n</tr>\n</tbody>\n</table>\nLevel 4\n\n<table>\n<thead>\n<tr>\n<th>Quantitative Project Management</th>\n<th>Quantitative Work Management</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Organizational Process Performance</td>\n<td>Organizational Process Performance</td>\n</tr>\n</tbody>\n</table>\n\nLevel 5\n\n<table>\n<thead>\n<tr>\n<th>Organizational Management Performance</th>\n<th>Organizational Management Performance</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Causal Analysis and Resolution</td>\n<td>Causal Analysis and Resolution</td>\n</tr>\n</tbody>\n</table>\n\n*Add – Additional Process Area: Applicability decided by Need of the Organization\n\nCMMI – Known Benefits:\n\n- Improvements in Project/Work performance Results\n- Achievement of Business Objectives\n- Delivery and Service Systems are streamlined\n- Quality Improvement in service and product\n- Lesser customer complaints\n- Improved employee morale\n- Standardized delivery approach in business\n- Understand the Strength and Weakness in process and plan improvements\n- Better process – product relationship achievement\n- Predictability and continual improvements helps business growth\n- Better Engineering and Service Processes\n- Helps in Adopting Newer Technologies in Quick time\n- Scaling up of process to new methodologies is comparatively easier\n- Better Project Management and Control in the Organization.\n\nPlease visit CMMI Institute site for further details and for reports on Quantitative gains.\n\nBeyond all this, we have to acknowledge the fact that CMMI from Information Technology Industry perspective is a De facto Model and it has ensured that more and more organizations has standard engineering process development practices, there by contributed to the industry and to\ncustomers. In last 15 years, as the industry and new technology practices has grown, CMMIs contribution is vital to the Industry. We have to thank SEI and CMMI Institute for ensuring this model is up to date and paved way for us to standardize and improve our delivery practices. CMMI is instrumental in bringing Process Based Delivery Approach, Stable quality management system, bringing Process Quality Assurance practices more explicit, Clarity in software Engineering Concepts and establishing Strong Process Working Groups in the Industry. Having said that, CMMI is beyond software and Systems, however in this guide we limit only to the IT Industry.\n\nFew Key Success Factors for its worldwide adoption:\n\n- The users can contribute and raise change requests to customer relations\n- Users of the model can ask clarifications and they are supported well by CMMI Institute\n- The New changes are discussed and piloted in many cases\n- New improvements are always welcome with CMMI Institute\n- The Model and related sources are free and users can download\n- Apart from Appraisal and official Training there is no mandated cost involved\n- The Proven results made it as a model widely adopted across the globe\n- CMMI Partners are available worldwide and getting services are easier\n- User groups in Yahoo, LinkedIn and other social sites help in people to understand and clarify doubts\n- Systematic working and bringing in changes to help users by the CMMI Institute and all its certified personnel is strength.\n- The Quality of the results are monitored and relevant policy updates are given by CMMI Institute to ensure that Users get good experience in Implementing the model and performing appraisals\n- The case studies, presentations, webinars on different topics performed by CMMI Institute to ensure that all kind of industries get relevant update.\n- SEIR repository provides enormous amount of user contributed materials, which helps every organization and its employees to get better understanding and implementation of the model.\n• CMMI Institute and associated members/partners work on different areas of interest and share updates on them to the community. Most of them are free articles. Example: Agile and CMMI, in this area lot of effort spent by community members and today we can say, we are no longer with many ambiguities in adopting CMMI and Agile together.\n\n• Combined Constellation implementations and combined appraisals has also become reality and many of the organizations are interested considering their business model.\n\n• CMMI Institute SEPG meetings which happens once in every 6 month, brings in lot new ideas and process approaches, which is critical for the evolving trends in the Industry. In short they work on maintaining the Model up to date.\n\nInitiating CMMI Implementation\n\nDo I need CMMI?\n\nThe first step in CMMI Implementation is to understand what you want to achieve in your product development or service delivery. For that you have to be clear with your current business model and the role of processes in your business. There can be no business without any process in this world. However the balance between process, technology and people could vary from one to another. Hence it’s important to understand what is the role of process in your business and by improving its maturity, what is the kind of result you expect with your business to be understood. This we can say, “Do I need CMMI?” CMMI may not be a solution for all the problems you have and just because someone has told, you may not start your implementation.\n\nYou are expected to have the clear understanding of current Business and related processes, in addition to that, now you are expected to set your objectives for CMMI Implementation. We can look at any similar organizations which has implemented the model and how the results have paid for them. With little more research on your own and with CMMI Institute site and relevant reports, you can have an idea about how CMMI Implementation can help in your business and in delivery.\n\nWhen we say understand your business, it means\n\n• What are the different products or services your organization offer\n\n• How many divisions and units are there\n\n• Do all of them produce same or similar products/services\n\n• Are all of them produce same business benefit or which of them are key for me to succeed in business\n• Are you already in the optimum level or there is scope for improvement\n• Which part of the business to improve or Business process to improve\n• What is the cycle time of my services or products\n• Do you produce part of product/service or complete product/service\n• Are you interacting with client directly or with your own resources (onsite teams)\n• What is the current resource competency I have\n• What is the level of Infrastructure you have\n• Whether you are clients are expecting you to perform with certain maturity in some processes\n\nThe Understanding on these questions will help you to think more on what you are going to gain by implementing CMMI. Also it will tell, do you really inclined to implement CMMI or its just for Attracting clients or for bidding purpose, you want to get some maturity level. Because when we are not aware of our business model and where exactly we feel CMMI Implementation will benefit us in our business, then we have more chances of not getting the real benefits of CMMI.\n\nEstablish Internal Commitment:\n\nDiscuss within management about what CMMI is, and what kind of benefits you are expecting from implementing the model in your organization. Be specific on the results and be clear that questions may come on the following. Why CMMI model and why not others, what benefit it will give, how can we apply in our business, etc. The reality is almost 90% of the organizations might have the same questions; however they have implemented the model and getting benefits today. It’s pretty normal that everyone thinks that their business is unique, their project is unique and they are unique. However most of them can be categorized in countable number of groups and many of them has similar characteristics, so CMMI is no difference to it. Set clear expectations with people on what level of involvement you expect and where the changes are likely to come. Many times, fear of change and modification of system will make people resist the Implementation. Hence clarity on what is expected, what might change, what benefit it will bring, motivating them to be part of change and making them own the changes will help to great extent. Involve the Heads of all the functions in your discussion, so that everyone feels part of the initiative.\n\nGive time to people to think and come back on the CMMI Initiative. Let the questions come on the initiative and anything on the model, it’s better to answer it through an Executive Session on CMMI. The Session could be typically for a day, so that better clarity and understanding all the\nsenior management people achieve. This could help you in removing the anxiety from the stakeholders.\n\nInitial discussion with Subject Matter Expert:\n\nOnce all the stakeholders are in alignment you can go ahead and have discussion with the CMMI Subject Matter Expert (SME). You may find one internally in your organization or you may contact any CMMI Partners in your region, who are providing the Consulting and Appraisal services. You can check the list of CMMI Partners and their services through CMMI Institute site. A discussion with Subject Matter Expert should be on the following,\n\n- Current Version and Status of CMMI Model\n- What are the different steps involved in Implementation\n- What phases and approach they generally suggest to the organization\n- Data/Experience related to Similar Cases of Implementation\n- Check the ROI that Other Organizations have achieved\n- What the different Objectives that Organization like yours can aim to achieve\n- What are the different requirements on Human, Infrastructure, training requirements\n- What is the right Constellation according to the SME for your business\n- Have them describe the overall expectation from the Organization\n- Collect the Contact points and relevant references for them (for external Service Providers)\n- It may be too early, however you can check with them the timeline typically it takes to implement CMMI Model on an Organization like yours and the maturity level you should target.\n\nCMMI Institute always keeps their database up to date on their Partners; hence selecting a Service Provider from there is not a difficult choice. At the same time, there are many other renowned organizations also providing CMMI Consulting services. You have the option of selecting among many, but for Appraisal and formal training services from CMMI Institute, it shall be done through CMMI Partners only with the CMMI Certified Individuals. However for consulting or SME services there is no such restriction.\n\nChoosing the right Constellation for you:\nAs we already discussed that you have worked on the basics of your business and what you expect from CMMI Implementation. However when it comes to selection of CMMI Constellations for your business, you may end up with question, which one to choose. It can be decided on few factors,\n\n- Business Model in the Organization\n- Typical Cycle Time to deliver your Product or Services\n- Volume of work in Service Delivery and Product Delivery\n- Business Income ratio between Service Delivery and Product Delivery\n- Complexity involved in Product Development\n- Areas where you need Improvement\n- Type of Activities Performed\n\nThere could be other factors which also can influence. However when you find they are smaller cycle times in which you have to deliver your product or services and less intensive engineering needs, then it’s recommended to go for CMMI Services. However if you are involved equally on development of product and in Services (Maintenance/migration/testing/etc) then you can go for combined CMMI Dev and CMMI Svc Constellations to have the best from both. In case if you have lot of medium (3 to 9 month) and Longer Projects (> 9 months) and need good Engineering Practices to strengthen your product, you can select CMMI Dev model.\n\nBe clear CMMI Svc doesn’t mean there are no engineering practices; it has Service System Development process area to support your needs. However you have to decide based on what level of complexity, your products have.\n\nFix your Goal on the Program:\n\nThe following aspects you have to be clear before engaging in to the planning part of CMMI Implementation in your organization.\n\n- Clear description on your business needs on CMMI Implementation\n- Performance Goals target for your business\n- Tools and Technology Improvements or positioning\n- Prioritization of process based delivery and Services\n- Competency level of Employees and target improvements\n• Possible Effort and Availability requirements of Management Team\n• Possible effort needs from SME and Process Quality Assurance people\n• Return on Investment expected from the program (direct and in-direct)\n\nOnce you have made up your mind on the above given points then it’s time for you to engage Service Provider.\n\nEngaging CMMI Institute Partner or Service Provider:\n\nAs explained earlier, you would definitely need a CMMI Institute Partner for performing a) CMMI Official Trainings b) Appraisal Services. For CMMI Consulting Activities, you can engage any Subject Matter Expert from your own organization or from other service provider or through a CMMI Institute Partner. If Appraisal is in your plan and you want to achieve a Maturity Level rating, then it’s important that you understand that you need a CMMI Institute certified Lead Appraiser for performing your appraisal. A Lead Appraiser services can be availed through the CMMI Institute Partner. Engaging Lead Appraiser early in your implementation helps you to be in alignment with his expectations and to ensure his availability for your program.\n\nThe following points you need to consider before engaging any of them:\n\na) Consider the overall experience of the Lead Appraiser and relevant experience in the area of working\n\nb) Interact with them to see how they are able to pick up your business model and services\n\nc) Check their credibility in the market\n\nd) Cost of the Appraisal services (include Logistics cost)\n\ne) Past experiences and similar organization appraisals performed by them\n\nf) Collect References for their work\n\ng) Get their view on your CMMI Implementation program\n\nh) Understand their schedule and how busy they are. (There is a cap of 12 appraisal per year/ per LA, hence check whether they are available for you)\n\ni) Sponsor of CMMI Program has to interact with the Lead Appraiser, before engaging them\nj) Check your comfort level with Lead Appraiser. Sometimes few are comfortable with aggressive type of Individual and some are comfortable with soft spoken, friendly Lead Appraiser.\n\nk) Check what are all the different product modules (Trainings, Appraisals) he is certified for, that can reduce your interaction with multiple Certified Individuals.\n\nl) Check on the best possible review schedule and Appraisal schedule they suggest to you.\n\nBe clear a Lead Appraiser who is going to perform your appraisal, cant’ be a consultant for you. Similarly if you have your own Lead Appraiser, then he/she can’t be from the same Organizational Unit (the Organizational unit which is within the scope of Appraisal).\n\nMost of the points given here holds true for selecting a Consultant, however for that you don’t need a CMMI Institute Partner. CMMI Institute doesn’t mandate consulting activities under any case and Implementation of the model, can be completely done by in house or with any known service provider. The fact is CMMI Institute monitors the conflict of Interest that same registered organization shall not consult and perform appraisals. Under any case, CMMI Institute collects declarations from Partners and from Individuals in different times.\n\nCommon Reasons for Ineffective CMMI Implementation:\n\nBefore you start the complete planning of your CMMI Implementation program, be aware of the Common reasons which could make your CMMI Implementation in-effective.\n\n- Lack of business alignment\n- Lack of management participation\n- CMMI Implementation Program for “customer demand”\n- Lack of project management competency\n- Not considering as “Organizational Program”\n- Resistance to change\n- Lack of belief in process improvement\n- Interpretation challenges\n- Lack of clarity in ROI\n- Lack of resources\n- Separation of Finance metric from Process metric\nFailure to understand the significance of “Product and Process relationship”\n\nPlanning CMMI Implementation\n\nThe first step recommended is to understand your current product and/or service delivery practices and its gap with CMMI Constellations which you are targeting. This would help you to plan your activities, timelines, estimation on resources, establishing/modifying working functions and strategize for effective implementation of CMMI. Hence a Gap Analysis is the recommended first step in Planning. Gap Analysis can be performed by internal Subject Matter Expert (SME) or with external one. Basically you do this exercise to understand the gaps in your defined processes (if you have one) and with Practices followed in Service/product delivery. Also a good understanding on the Organizational dynamics and gaps identified there would be values add for you.\n\nGap Analysis:\n\nPlanning a Gap Analysis, involves the service/delivery centers in different places, type of delivery models, type of business, duration of projects/programs, etc. Based on these factors identify set of projects/program/applications which you want to take as sample for your Gap Analysis. Performing Gap Analysis involves a) Artifact Study and b) Interview/Discussion with practitioners. A detailed Gap Study will reduce lot of ambiguities and estimation errors in the subsequent stages of the program. Fix time with your practitioners and perform gap analysis with CMMI constellation that has been chosen. Check the relevant artifacts given by them to understand the delivery model and the current maturity.\n\nPrepare a draft report in terms of Process Definition gaps and Process Implementation gaps for each of the Process Area. With certain number allocation for compliance with practices, you can also give an indicative value for Compliance with the model. Though it’s inaccurate, it definitely helps organizations to visualize the compliance and to understand how much gap they have. A Gap Analysis report is the basis for planning and to work on removing the weaknesses, hence a detailed report is required. The Draft report has to be discussed with the management and final report to be prepared. Consensus with your management team ensures accuracy is established in the report. A good Gap Analysis report will also have significant weaknesses identified and provides key recommendations for next level planning. The Gap Analysis should also consider the relevant tools available and used in your organization. Any existing standards compliance by your organization to be considered in the gap analysis, as this would help in evaluating the process understanding and Management system maturity.\n\nStrategize and Plan your CMMI Program:\nWe call it as a program here, considering that your entire organization is involved in it and it brings cultural change in the organization and beyond that you may need to run lot of smaller projects within this CMMI Implementation program to make it effective and bring desired results for you. Having said that, it also depends on how big is your organizational Unit, for which you are targeting the CMMI Implementation. Now based on the Gap Analysis, Understand the following,\n\na) Process Definition Gaps to be filled\nb) Delivery and Service practices where improvement is needed\nc) Roles and responsibilities update required\nd) Quality Management System Establishment (set of process, technology and role which is set up to achieve desired results in delivery)\ne) Type of Projects/Works targeted under CMMI Implementation\nf) Organization structure update\ng) Training Needs in your organization\nh) Where maximum benefit can be realized with CMMI Implementation\ni) Compliance Program and Metrics culture status update\n\nBased on these factors and understanding your organization’s dynamics and change management ease, derive your Goals on the following,\n\n- CMMI Constellation to be Implemented\n- Representation to be used\n- Target Maturity Level\n- Timeline Target for achieving the desired Maturity Level\n- Performance Goals for the Program\n- Business Performance Expected after CMMI Implementation\n- Coverage of Business Units/Delivery Centers within scope of Implementation\n\nBe clear your timeline has to be little aggressive than what you can achieve. Relaxed timelines and Very Aggressive timelines both can affect quality of implementation. Maturity Level consideration wise, you can select anything between Level 2 to level 5 as your target. However you can’t skip any Maturity Level, it means you need to implement all the Process Areas\nbelonging to the Lower Maturity Level, along with the one which you are targeting. Also understand it’s more of a good practice, that before you target Higher Maturity levels like ML4 and ML5, it’s better that you achieve ML3. A Maturity Level is not a rank, but it’s the actual process maturity status in organization. Unless you perform at certain level consistently, it would be difficult for you to understand what makes your organization perform at that maturity, and after knowing that and securing your strengths, you can move to the next Maturity Level. Else you might be working with unstable system and trying to simulate Maturity only on certain accounts, which could result in negative results and poor employee morale.\n\nDiscuss with your SME/CMMI Institute Partner:\n\nDiscuss the timelines, scope of implementation, Maturity Level targeting with your CMMI SME (Subject Matter Expert)/ CMMI Institute Partner and ensure that all of you are in alignment and see the possibilities of making the program success. Understand the additional points which you need to take care in this implementation program. You can’t have very different plans from your service provider that will not help to achieve your results. Be open and seek support as required. Do not consider CMMI Implementation as Process definition and Audit, such thinking will definitely cost your organization badly.\n\nPlanning the Elements in Implementation:\n\nOrganization Structure:\n\nIf you don’t have any existing process standard or model implementation in your organization, than you may need few new functions in your organization. Typically for CMMI Implementation you may need,\n\nSteering Committee:\n\nSteering Committee is formed to ensure that program runs smoothly and any barrier is removed without delay. The Steering committee consists of senior management, head of all relevant functions and CMMI program manager. If sponsor participates in the steering committee, then it will be very effective.\n\n- They decide on business needs and process needs\n- They Communicates to Organization\n- They decide on CMMI program and its implementation\n- Reviews progress periodically\n- They remove the barriers\n- They monitor the overall progress of the program\nCMMI Program Manager:\nThis person is responsible for monitoring and controlling the CMMI program in your organization. The person can be dedicated or partially allocated, though dedicated model always works better.\n\n- Prepares the plan for CMMI Program\n- Monitors and controls the program\n- Manages the projects and stakeholders\n- Reports to Steering Committee\n- Participates in SEPG, Steering Committee and CMMI progress meetings\n- Mobilizes the resources effectively to achieve target\n- Risk management is handled and timely escalations are performed\n\nSoftware Engineering Process Group (SEPG):\nThe group consists of Subject Matter Experts from various engineering and management areas and Process quality assurance members. Few of the SME’s can be permanent members and few can work on need basis (depending on how often their process is discussed). Typically each SME is identified with relevant processes in mind. The Process Quality Assurance Members who are contributing in process definition and who are performing facilitation & audits shall represent. This helps in getting real issues from the ground and discusses with SME and put it in presentable process format.\n\n- SEPG is responsible for Process Focus and alignment with business objectives\n- SEPG ensures that relevant processes are defined to support the delivery\n- SEPG ensures that process assets are created and maintained\n- SEPG makes deployment and process action plans\n- Process revision and maintenance is taken care by them\n- Process tailoring and relevant analysis is performed\n- Process Improvements achievement and sources maintenance\n- SEPG is responsible for process appraisals\nPractically most of the organizations, hands over the Organizational Process Focus and Organizational Process Definition process areas to SEPG. If you aim for ML4 and ML5, then Organizational Performance Management may be handled by them.\n\nProcess Quality Assurance Group:\n\nThis group consists of people who has competency on process quality assurance. Typically it includes people who can understand the process architecture, its application and improvement needs. Process compliance activities like QA reviews and Process compliance audits are performed by them. Independency and objectivity should be maintained on forming this group.\n\n- Project facilitation and hand holding on Process implementation\n- Process training performed by them\n- Product Quality Assurance review performed\n- Process Compliance Audits are performed\n- Project level metrics analysis support\n- Tailoring of processes are supported\n- Interact with SEPG, project teams and metrics team to provide relevant updates\n- Some organizations use them for Risk Assessment or other security compliance standards implementation.\n\nThe members in this team can be full time or part time. However full time people bring in lot of value addition, considering that they work on specific areas, bring objectivity, no conflict of interest, etc.\n\nMetrics Analyst Group:\n\nThis group consists of people who have understanding on project management, statistics and process control. Their ability to understand the data and process is important to do further analysis. The project management understanding is more of logical understanding of project’s phases and actual condition. The analysis and reporting shall be meaningful for the project and organization to use it for informed decision making. This group may not exist in all organizations and may be in High Maturity organizations (ML4 and ML5), and some organizations combines their project management office with metrics group.\n\nSchedule your CMMI Program:\n\nYou can make a realistic schedule based on estimation of effort and activities involved in the program. Most often people prefer to work back from the final target. Hence your schedule of\nactivities has to fit within that target, and your estimation is based on what you need to achieve within the time limit. However many a times organizations understand, that it’s a program for maturity and not for report card, so they revise their time limit. On any case, have a high level plan first to check, how good is the available time for you to achieve the target. Remember it’s not about a project, it’s about an organization which consists of multiple functions and many people, so it’s not that easy to fit any date and activity to get consensus, there is in fact lot more to think.\n\nThe following activities to be considered on making your schedule for CMMI implementation for ML2 and ML3,\n\n<table>\n<thead>\n<tr>\n<th>Activities</th>\n<th>Start Date</th>\n<th>End Date</th>\n<th>Remarks</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Gap Analysis and Strategizing</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Project Kick-off</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Steering Committee and SEPG formation</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Lead Appraiser/CMMI Partner selection</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Process Definition and CMMI Mapping</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Overview Training for key stakeholders</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Process Training by role in Organization</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Process Implementation in Projects</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>First Spot Check</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SCAMPI C Appraisal (Optional)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Update Process Definitions</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Special Trainings (recommendations from Scampi C) (PM, Audit & Metrics)</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Second Spot Check</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SCAMPI B Appraisal</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Official CMMI training</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Documents Collection for final appraisal</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\nIn case if you are working for High Maturity Levels then add the following to your schedule,\n\na) Process Capability Baselines Preparation \nb) Process Performance Model Development \nc) Business Objectives Fixing \nd) Business Objectives vs. Performance Evaluation \ne) Causal Analysis / Outcome Analysis Meetings \nf) High Maturity Reviews \ng) Quantitative Management Support activities\n\nThere are no timeline given here, because that’s based on the organizations current maturity and gaps with respect to targeted maturity. However be clear if you don’t have any previous experience with quality standards or don’t have detailed Engineering or Services processes, then for Maturity Level 2, you may take 9 to 14 months and for Maturity Level 3, you may take 14 to 20 months, and for Maturity Level 4 or 5, you may take 24 to 38 months from the day you are appraised at Maturity Level 3. These all are indicative numbers and we recommend you not to take them as a hard and fast rule.\n\nFor your Process definition, plan a minimum of 3 to 6 months as duration. Plan your first spot check after 1.5 to 3 months after process training. Perform Scampi C, as you believe it will help. We will see in detail on SCAMPI C, B and A in the Appraisal Topic. Plan your second spot check after 2 to 4 months, after first spot check. Your final phase of Document update, SCAMPI planning, Readiness review and SCAMPI A will happen in last 3 months.\n\nIn High Maturity, Business Goal identification is the first activity. PCB development can be once in 6 month or in a year, it’s based on lot of factors, we can see them in High Maturity section. PPM development shall start as early as possible. As the process is getting stable, initiate your Causal Analysis and Improvement Activities and ensure you have minimum 12 to 18 months to do better improvement.\nEstimating Effort/Cost for CMMI Program:\n\nEstimation of Effort in CMMI Program is typically performed with work break down structure method. Each task is allotted with effort based on the experience, its normal to check with your consultant on typically how much effort it will take. Also the estimate can be on Process QA group and Operational Members effort contribution, because most of the time your employees will ask what will be their level of effort involvement in this program.\n\n<table>\n<thead>\n<tr>\n<th>Activity</th>\n<th>Process Quality Assurance Effort</th>\n<th>Others ( SEPG/ Project teams/Functions/FAR Group)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Lead Appraiser selection</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>QMS Gap Study & Updation by Internal QA team</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>QMS Gap Study By Lead Appraiser or by his/her Organization with respect to L3</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>QMS Updation based on Gap Study Report (Including Alternate Practice Identification)</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Concentrated CMMI Implementation by SEPG Team</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Training for the Key Stakeholders</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>First Spot Check</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SCAMPI C</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Process Definition Update</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Special Trainings (recommendations from SCAMPI C)</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Document Availability and Appraisal preparation</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Internal Appraisal</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Official CMMI training and SCAMPI Training</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>PIID Development / Document Collection</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\nThe final effort can be presented in terms of Full time resource equivalent, though it has not much meaning for Operational teams, at least for management to calculate the cost it will be useful.\n\nIn addition don’t forget to add the cost of your appraisal or consulting. Typically the cost goes from 20000$ to 45000$ for appraisal related activities. It’s based on the services you avail and the scope of your appraisal and many other factors. The following appraisal related services, typically availed by organizations,\n\na) SCAMPI C Appraisal\nb) SCAMPI B Appraisal\nc) SCAMPI A Appraisal\nd) CMMI Official Introduction Training\ne) ATM Training\nf) Readiness Review\ng) Intermediate Review\n\nIn Addition you may have consulting activities planned with identified Consulting partner (service providers). You have to include that cost also. Typical areas where you may need your consultant is,\n\na) Training on Project Management, Reviews, Audits and Metrics\nb) Spot checks on Process Implementation\nc) Clarifications on Implementation\nd) Process Capability Baseline Development & Review\ne) Process Performance Models Development\nf) Sub Process Control – Clarifications\n\ng) Application of Causal Analysis\n\nh) Preparation for Appraisal\n\ni) Gap analysis on QMS\n\nHaving a consultant is not mandatory and it’s optional, however when you have internal resources who can do this, you can go ahead with them. It’s also common, that organizations bring external consultants, so that it helps in change management and reduces the internal frictions.\n\nWhen organizations don’t have process quality assurance teams, it’s pretty common they outsource the work to external consultants. In that case, the competency required for performing the work differs and typically the cost for such work is lower than consulting.\n\nFor High Maturity Projects, you have to ensure that you may need to spend on tools. It’s not mandatory to buy tools, there are freeware available and/or you can make your simple tools, which can support your needs. However as we know, freeware normally has its own limitations. Hence plan your budget accordingly. Few more details, we will on see on the High Maturity topic.\n\nStakeholder Management:\n\nIt’s very important to identify and involve the stakeholders in this program. Sometimes, if you miss out anyone, this can hurt your team. So plan the stakeholders well, and establish clear communication with them. Normally we prepare the activities in Y axis and all the stakeholders in X axis. The participation level of them is entered in the relevant cells. It can be like a RACI matrix, where Responsible, Accountable, Consulted and Informed can be their Involvement in that activity.\n\nChange Management:\n\nTo make any change at organizational level we need clear commitment from top management. If you get that, then you need a plan to introduce and grow that change in the organization. You need constant communication on the changes and bring more interest of people in that change. Ideally use all the milestone points in your program for better change management. Have a strong communication plan along with you, which reaches all levels of people in the organization. Appreciate the adoption of changes in every place, even you can create competition among internal units to ensure that change is accepted and implemented.\n\nYour communication plan for CMMI program can have the following tasks with weekly/milestone based communication,\n<table>\n<thead>\n<tr>\n<th>Sample Points of Communication</th>\n<th>Mode of Communication</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Communicate the Kick –off</td>\n<td>Posters/Mail/Spot</td>\n</tr>\n<tr>\n<td></td>\n<td>Event/Newsletters/Meeting/etc</td>\n</tr>\n<tr>\n<td>Awareness Campaign (Select any topic)</td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Training Completion - achievement</td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Slogan Contest</td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Status Report</td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Awareness Topics</td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Training Completion - Achievement of QMS Implementation Gap Analysis (SCAMPI C)</td>\n<td></td>\n</tr>\n<tr>\n<td>QMS Completion and Release - Achievement</td>\n<td></td>\n</tr>\n<tr>\n<td>Special Trainings Completion</td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Awareness Topics</td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Helpdesk Organizing</td>\n<td></td>\n</tr>\n<tr>\n<td>QUIZ Program on CMMI</td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Status - Audit Completion</td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Status - Appraisal Completion</td>\n<td></td>\n</tr>\n<tr>\n<td>SCAMPI B Schedule</td>\n<td></td>\n</tr>\n<tr>\n<td>SCAMPI B Report</td>\n<td></td>\n</tr>\n<tr>\n<td>SCAMPI A Schedule</td>\n<td></td>\n</tr>\n<tr>\n<td>CMMI Maturity Level Achievement</td>\n<td></td>\n</tr>\n</tbody>\n</table>\nExecuting CMMI Implementation\n\nProcess Definition:\n\nThe base of this activity can be based on the Gap Analysis report, in case if you have existing defined processes. However if you don’t have any existing processes, then it should start with discussion with your management team. Define the business goals of your organization, from there percolate it to process needs. The simpler and useful technique to have good process definition is, run it like development project, in the sense collect all the requirements with respect to your process needs, then make architecture for each process, its components and interface with other process, then develop the process along with relevant components and then validate with relevant Subject Matter Experts and with users.\n\nEstablish Requirements in a table,\n\n<table>\n<thead>\n<tr>\n<th>Process Detail</th>\n<th>Business Need</th>\n<th>Type of Service</th>\n<th>CMMI Practices</th>\n<th>ISO/ISMS Needs</th>\n<th>Policies/Others</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Req. Process</td>\n<td>First time Sign off</td>\n<td>ERP/NON ERP</td>\n<td>Requirement Development Practices</td>\n<td>Clause 7.1</td>\n<td>Others</td>\n</tr>\n<tr>\n<td>Design Process</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Coding process</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nWe can assign unique id and track the requirements.\n\nEstablish Design for the process,\n\n a) Description\n b) Interfaces (with other Process)\n c) Components (Templates, Guidelines, checklists, etc)\n d) Position in Overall process Architecture\ne) Entry Criteria\n\nf) Exit Criteria\n\nDevelop/Construct your Process,\n\nThe Process can be developed using ETVX methodology and with relevant components. ETVX – Entry, Task, Validation and Exit are the key details present in this method. In addition to that, we have other components which make that effective with this method.\n\nThe following can be the Process description details,\n\n1 Objective\n2 Scope\n3 Entry Criteria\n4 Acronyms and Abbreviations\n5 Inputs\n6 Process Description\n 6.1 Activity 1\n 6.2 Activity 2\n 6.3 Activity 3\n7 Recommendations\n8 Permitted Tailoring\n9 Measures\n10 Validations\n11 Quality Records\n12 Exit Criteria\n13 References (CMMI, Other Processes and Other Standards)\n14 Process Profile Matrix\n\nIn addition to this you can have work flow for each process that will help the users in great way.\nA process is not a standalone document, as we know it has relevant components associated with it to make it more effective. The following can be considered as definitions for them,\n\nPolicy\n\nIt is a directive from senior management, on objectives and responsibilities for various aspects of the process.\n\nIn CMMI there is a practice GP 2.1 Establish Policy under Generic Goal 2, this is achieved by few organizations by making policy handbook or by writing the policy per process in the definition itself.\n\nProcess\n\nIt is a framework consisting of inputs, entry criteria, output, and exit criteria with list of activities/tasks to be performed to convert inputs to outputs. Process will contain certain templates and forms to be used while executing the activity/task. Process provides a mechanism for implementing certain policies and requirements of international standards/models facilitating Plan-Do-Check-Act approach to continual improvement\n\nA process in your organization need not be the same as Process Area of CMMI. The Process needs and architecture is determined by various requirements you have identified. Some organizations just take the CMMI Specific practices in a Process Area and make them as practices; this may not really benefit them, as they don’t understand the process architecture needs of them.\n\nA Process of your organization may address multiple process Areas of CMMI and vice versa.\n\nStandard\n\nStandards specify uniform use of specific technologies, parameters or procedures when such use will benefit the organization. Ex: Coding Standards\n\nGuidelines\n\nGuidelines assist users in implementing policies/ procedures, which may warrant variations, or which are under trials and imposition of standards is not always achievable. Ex: Estimation Guideline\n\nProcedures\n\nProcedures assist in complying with applicable policies, standards and guidelines. They are detailed steps to be followed by users to accomplish a particular task. Procedures may contain certain templates to be followed while executing the task.\n\nTemplates\nThey are prescribed format for creating documents/deliverables expected by the processes. A well defined template helps us in achieving consistency in capturing information and reduces the redundancy.\n\nValidation of process:\n\nValidation of process happens through mostly reviews by relevant teams. The process is reviewed by Subject Matter Expert and then it’s reviewed by SEPG team. A checklist based review by the author or his peer will help in reducing the defects. Similarly a traceability matrix from requirements through validation will help in reducing the defects.\n\nRelease of Process:\n\nThe following should be taken care on release of process,\n\n a) Process and its components should have followed Naming Convention\n b) Processes are reviewed and approved by SEPG\n c) Relevant Training Records are updated\n d) Processes are updated in QMS or in portal and ready for announcement\n e) Process Transition plan is available\n f) Process Request documents/requirements documents are updated\n g) Master list of Processes are updated\n h) Release Notes is prepared\n i) Final Approval received from competent authority\n j) Release communication is ready\n\nSometime people want to know, the different processes they should have, it’s something which we can’t answer easily, and it needs lot of context. I would recommend you to follow the method given above to come out with them.\n\nQuality Management System Documents:\n\nEvery Quality management system contains quality manual as apex document, which provides detail on how the quality policy, objectives are achieved in the organization. The scope of processes, process architecture, and detail of every process is detailed in the manual. The Quality manual helps anyone to understand how the system is defined and helps to navigate the processes.\nQuality Manual contains the following sections,\n\n1.0 Introduction\n1.1 Purpose\n1.2 Scope\n1.3 References\n1.4 Definitions and Acronyms\n\n2.0 Business Overview\n2.1 Business Group\n2.2 Vision/ Mission\n2.3 About Organization\n2.4 Nature of Business\n2.5 Organization Structure\n2.6 Business Objectives\n\n3.0 Quality Management System\n3.1 Approach\n3.2 Documentation Structure\n\n4.0 Quality Management Scope and Policy\n4.1 Scope of Quality Management System\n4.2 Quality Policy\n\n5.0 Lifecycles\n\n6.0 Tailoring of Processes\n\n7.0 Quality Management Components\n7.1 Management Review Committee/Steering Committee\n7.2 SEPG\n7.3 Policies\nPublishing Processes/QMS in Organization:\n\nThere are various methods by which the Processes/QMS is published within the organization. The simplest of them is having a common shared folder in a drive and give read only access to all members in the organization. Some uses wiki pages to publish interfaces and use databases or back end server to access the documents. Some organizations use share point portal for complete control on the QMS site. Some of them use intranet web portal as front end and use any available document management system as back end. What is important is, the QMS should have simple navigation and that requires good arrangement of documents. If you can create front end GUI interfaces, then it’s good.\n\nSome organizations use the Type of business (development, maintenance, testing) as the primary level document and subsequently lifecycles are given, from there processes are linked. In some organizations, even you can select all the relevant processes by the role. In some organizations you can select the processes by function. You have to select the relevant method, so that time spent on navigation can be reduced.\n\nRoles and Responsibilities Documentation:\n\nWell defined roles and responsibilities will help in reducing lot of ambiguities. The roles need not be designation offered in your organization. If you have the mapping to some extent, it's good, however don’t allow people to get confused by designation. Roles have to be defined as you have identified in the processes and all the responsibilities given for the role in the processes shall be documented. Ensure that the roles required to perform some of the tasks as per the model is available with you. Example: Configuration activities shall be handled by a competent person in project, for that normally a configuration controller/manager role is identified. Check you have some role which is available to perform that activity. Unless you defined something at organizational level, it will never really get in to project level.\n\nMaintenance of QMS:\n\nThe Quality Management System is maintained by the Process Quality Assurance group members in practical. However the responsibility lies with SEPG team. SEPG has to ensure all\nthe processes are implemented and latest version is available for use by the users in the organization. A QMS revision can happen on need basis, as we get enough improvements/change requests coming in or based on following cases,\n\na) New Business Lines to be included\n\nb) Change in Delivery model\n\nc) Change in working methods\n\nd) Changes in Tools/Technologies\n\ne) Improvement Requests\n\nf) Roles and Responsibility change\n\ng) New Lifecycle\n\nh) New Product line/service line\n\ni) Audits/Compliance Standards triggered\n\nj) Statutory or Regulatory compliances\n\nk) Client Mandated changes\n\nl) Others\n\nThe changes in QMS can be handled with planned releases in a year (like quarterly or half yearly), or we can handle them as they come. Hybrid approach is mostly used by organizations to handle QMS releases. Remember you can have all configuration practices applied for QMS, for better control.\n\nOne thing which we missed here is what is the QMS (Quality Management System) is all about, normally it’s a system which is directed/guided in an organization to achieve quality in its products and services, and its comprises of roles, technology and processes. However over a period of time, people started recognizing QMS means, its set of processes in a shared place. In some companies they even refer QMS as Process QA group. However the intent of QMS has to be clearly understood, if not there will be problem in the basics itself.\n\nTraining in CMMI Program:\n\nThis is one of the Key components in this implementation program. It will take time and energy, but if we miss out this component, then all our implementation is only for the purpose of getting a rating, and also with lot of struggle. Training needs has to be determined clearly in every organization and time has to be allotted.\nTraining needs can be classified this way,\n\na) CMMI Model Training\nb) Concepts Training (ex: Project Management, Configuration Management, Metrics, Audit, Reviews, etc)\nc) Process Training /QMS Training\nd) Tools Training\ne) High Maturity Training (For ML4 and ML5)\n\nThere are various modes of training available,\n\na) Instructor driven\nb) E learning\nc) Self Study\nd) On the job\ne) Coaching and so on\n\nThe better way to determine the training needs are based on, which role needs what training, using a simple table/matrix and get it checked with SEPG and SME’s/Operations team.\n\n<table>\n<thead>\n<tr>\n<th>Role</th>\n<th>Model Training</th>\n<th>Concepts</th>\n<th>Process/QMS</th>\n<th>Tools</th>\n<th>HM Training</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Project Manager</td>\n<td>CMMI v1.3 Dev</td>\n<td>Project Management</td>\n<td>Project Management</td>\n<td>MS Project</td>\n<td>Statistical Process Control</td>\n</tr>\n<tr>\n<td></td>\n<td>CMMIv1.3 Svc</td>\n<td>Estimation</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Developer</td>\n<td>NA</td>\n<td>Reviews</td>\n<td>Coding</td>\n<td>Review Tools</td>\n<td>NA</td>\n</tr>\n</tbody>\n</table>\n\nWe are not talking about technical trainings required for a role that depends on the project and its taken care by CMMI Process areas themselves, on how to determine and address them.\n\nCMMI Institute offers many programs even for software development like Personal Software Process (PSP) and Team Software Process (TSP); however they are based on the need of the organizations to take.\nTypically a well organized training program can go around 1 to 2 months, to ensure all relevant roles got trained. Typical duration of your training program can be 1 to 3 hrs, and in the need of long training hours, you can split them in to multiple days. Training programs can be organized with adequate exercises, quizzes and so on, to break the monotony. The fact is everyone has their normal work and taking large inputs in a day and applying it over a period of time, is difficult. Hence understanding this, you can split training programs in to multiple levels in different time periods.\n\nProcess Hand Holding Period:\n\nEvery team has a role to play in this, but the major role is played by the Operations team. They are the one, who actually implement the processes and provide feedback to organization. In a poor system, it will be always seen that Process QA group as the implementer of the process and/or it’s for the Process QA group sake the Process related artifacts are produced. It’s the operational team, who truly takes the responsibility, implement them, provide feedback and improve the processes to fit into the practical delivery needs of service/product. In some cases, we see operations teams are getting rewarded for following processes and achieving >80% compliance, we have nothing to say for that. It’s expected that all the processes are complied by all the applicable projects, and even the case where they are not able to follow they have clear understanding of the situation and they are dealt in QMS in right way. Beyond everything, the success of CMMI Implementation program remains with the key implementation people, the operational team.\n\nHowever it needs a good amount of facilitation from Process QA group, as most of the templates, guidelines are new to the Operation teams. The Process QA group can have dedicated period, like one to three months to help all the projects to implement the process and relevant components. There can be walkthrough sessions, clarifications session and review sessions to support the implementation. Similarly this is an important period for SEPG team to understand how the process deployment goes on. Wherever required they can release supportive guidelines, newsletters and communication to ensure successful Process implementation. The initial period is crucial for the program.\n\nAlways implement processes in multiple projects and don’t go for pilot, once you have finalized your QMS, because getting feedback from different conditions and projects which has different characteristics is important. This helps in getting quick feedback and improving processes. However a caution can be made to projects, when really you are not sure about the process or you can go for piloting instead of a caution, but they should be based on adequate evaluation.\n\nKey points in Execution of CMMI Implementation:\n\nThe following are some of the key points in execution, and since you already made a schedule they should be easier for you to implement,\na) Selection of Projects and/or Units: We have already decided at the beginning of this program that what kind of projects we want to cover in implementation, like application development, application maintenance, testing, migration, etc. Also this is the time to ensure that the scope of implementation remains same. Similarly check whether Package projects are part of your implementation. Once you have selected the type of projects and technology, then you can decide on the centers which are all following the same QMS, and how many those of you want to include in implementation. The reason is there could be very small centers and they don’t produce/develop many services and including them in scope of implementation can have high impact in cost but not from benefit point of view. Remember here we are talking only about implementation of CMMI, not on appraisal. Implementation is for your business growth and for you delivery practices maturity, but appraisal is a stage in which you like to see whether you are doing alright when compared to external world and where your processes are good and where it can be improved. Sometimes we see organizations starting the implementation itself from appraisal point of view, which in larger picture is not the right thing and for your business it’s not good. Similarly when selecting any center for implementation check on a) people b) Type of business c) Contribution to business d) technology available e) Connectivity f) Standardization need, etc. The reason is sometimes remote centers are there, and people are specialized in some area in that center, for them actually such implementation which you do at corporate level may not yield same level of benefit. Even they may feel it’s too demanding, so you have to evaluate and then include them in Implementation. Basically whenever we talk on CMMI Implementation, most of the time we talk on process/QMS implementation, because apart from specific spot check/appraisals it’s the processes which are defined in the organization is implemented by operational and support teams.\n\nb) Broadcasting your program: Every stage in this program shall be broadcasted to the relevant members in the organization that will ensure the success of implementation. The more you keep the program within few members and few projects, in fact you are obstructing the implementation in full fledge. Involvement and belongingness shall be created by the level of communication you make. Involvement of senior management in such event is very important. Bring in methods like open forum discussion on monthly basis or stand up meeting on weekly/ bi weekly and involve all relevant stakeholders for 15 minutes or so. Discuss what you did in the last period and what the plan is for next period and what support you need from them. Not only this, but also discuss and attribute the success to operational teams. Neither the senior management nor the process quality assurance group needs any credit for the implementation, because for them its responsibility, however for operational team, it’s something like change in culture and way of working and once they come in to process way of working, that’s the best you can ask for. Be clear, we have to learn to appreciate others in this program than ourselves.\nc) Implementation across Projects: The QMS should be implemented in all the applicable projects as discussed earlier. The best way is to create competition among different projects to implement processes quickly. A good support from QA facilitation team will help quick compliance. However it’s also required the management people support process oriented approach. Often we see people searching to understand their process, only when client ask or when the quality compliant is received. The management people should be strong enough to ensure that every member is following process. This is very important when more than one member is working. Because you might be a hero to finish your work, but you don’t know the other person is a hero to finish his/her works, at the same time, if you have thousands of employees, how can one identify all the heroes and allocate work. Instead believe in process, which will ensure expected level of consistency in results. Also it’s important to ensure in appropriate phases the processes are implemented and relevant artifacts are produced. Sometime people allocate separate time for creating project artifacts for quality purpose; this is nothing but documentation work and will not yield real benefit. Some organization uses Quality Gates/Project gate mechanism based on milestones identified and relevant artifacts are checked and approved on that phase/period and then they are allowed to move to the next phase/milestone. This will ensure projects follow the applicable processes in the period. As discussed earlier the important benefit of implementing the processes across projects is to learn about the process on its ease of implementation, changes needed and elimination of complexity.\n\nd) Compliance Checks: There are two levels of checks are performed in the process of implementation. (i) Audit activities to ensure the projects/work units (Work Unit terminology given here, so that CMMI SVC users can relate) are following all the relevant processes (ii) Appraisal/Spot Checks to ensure that CMMI Model practices are met. It is expected that already your QMS is completely covering all the CMMI practices, which means just by following your QMS; the CMMI practices expectations are met. However if your QMS is not well aligned then Audits may not be really that effective. Apart from that, we have to be clear that Audit as a technique is sample based and sometime the checklist (if any) doesn’t address all the CMMI practices, which means by doing audit you may not be sure whether all practices are met in the organization. Also Audits may be designed in such a way that they only give non compliances, then again it’s of less use to us. Appraisal is designed to evaluate the process in terms of strength and weakness based on a model/standard/some reference. Hence it’s better to have both the approaches sometime to eliminate any gap in evaluation methodology. You may not do Audit and Appraisal together in same time for a project and you can plan it out with different period.\n\nWhen any Spot checks are planned with external consultant, it’s better to do an internal spot checks on your own. This will help in reducing the gaps and also your understanding\nand method of evaluation can be verified with external consultant. Otherwise your team learning such evaluation method is of reduced probability.\n\nNormally you can concentrate on Specific practices of process areas in the first few checks in projects, apart from a QMS gap study on Generic practices. Which means, you are aware that you have generic practices are mapped in your Processes and in Quality management system, and also you are aware, when projects use your QMS the Generic practices will get satisfied, and knowing this you are concentrating on Specific practices. Some of the process areas can take some time to streamline, so it’s better to concentrate on them (like measurement and analysis, decision analysis and resolution, etc)\n\ne) Consulting Activities: If you have an external consultant, then it’s better to create a log of questions to ask. You can keep it in central place, where different teams like SEPG, Process QA group, Operational teams, metrics team and others can update the log with their clarification needs. Prioritize them before you call your consultant and get it clarified with them. Many a times organization spends lot of time in template/guideline creation along with the consultant, this is not so effective way. You can ask your consultant to share some samples, and based on that you derive a model/log questions where clarifications needed and just get it reviewed. CMMI is no longer an unknown phenomenon; there are sources available now a day to take templates to everything and the best sources is the web. A consultant need comes, when you need someone to provide multiple solutions to a given area, because of their rich experience in that area. In some cases, the consultant may be actually performing the dedicated SQA/outsourced SQA in that case, you can use his/her time for various activities as you plan. However when they are hired for providing guidance and solution, then we have to be clear with our need and problem. Also when it comes from various teams, it’s more effective than one or two people thinking and deciding what to ask.\n\nf) Typical Challenges & Risk Management: The Implementation challenges can be broadly classified in to (i) Model Interpretation (ii) Lifecycle Application (iii) Process Definition (iv) Implementation Challenge and (v) Miscellaneous. First thing which we need to do is classify our challenges in to the categories, and if you are able to do this level, then you are solution is half done. Model and Process definition challenges can be mostly addressed by your consultant or SME. The Implementation challenges shall be addressed by senior management, SEPG and steering committee. The Lifecycle application challenges can be addressed by the SEPG and Operational SME’s. In addition to this, it’s a good practice to have Risk log created for the CMMI program. The common issues given in the earlier topics can be taken as list of possible risk and evaluate it. Enter all the risks which your team foresees and do not shy away in entering any risk, as this a program for organization and it involves members from CEO to Developer. Track the risks periodically and discuss the top risks in the steering committee. Many a times we know a good risk management is equivalent of good program management.\nFriction is good: The teams like SEPG, Process QA group, Metrics group and audit group might be having process people more. Sometimes the people are reporting to same functional head. This could trigger a case, where everyone is trying play down their role and taking care of their own people. Sometimes it might look all these are sub functions of one major process QA function and Operational teams will look completely as different group. If you don’t see any friction between any of your internal groups mentioned above, it means you are having the best of the best or you are facing a real problem there. Each function when do their role effectively, there will be friction and issues, this a good sign and to be appreciated. Too much of friction good mean, they are just trying to safe guard themselves. Hence keep an eye on this Organizational dynamics.\n\nTaking this opportunity lets discuss what SEPG is expected to perform typically,\n\n- Establish and Maintain the Apex documents like Quality manual and policy up to date\n- Establish and maintain Process Needs\n- Establish and maintain process repository and process assets\n- Deploy Processes and Process assets\n- Appraise the Processes in the Organization\n- Monitor and analyze Tailoring\n- Improve the Processes\n- Monitor Process alignment to meet business objectives\n- Monitor and analyze Process Compliance\n- Establish process action plans and execute them\n\nTypically SEPG,\n\n- To have its own plan for the year with clear planned schedule\n- To have Clear roles and responsibilities\n- Have configuration of documents\n- Regular Meetings with action items tracking\n- Analysis and decisions taken on meetings\n- SEPG head shall be there to moderate and conduct sessions\n\nSample Work Breakdown Structure for SEPG,\n\n<table>\n<thead>\n<tr>\n<th>Activity</th>\n<th>Responsible</th>\n<th>Month 1</th>\n<th>Month 2</th>\n<th>Month ‘n’</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Process Appraisal</td>\n<td>Name 1</td>\n<td>Yes</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>Internal Quality Audits (Refer Audit Calendar)</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Planned QMS Releases</td>\n<td></td>\n<td></td>\n<td>Yes</td>\n<td></td>\n</tr>\n<tr>\n<td>Lessons Learnt meetings</td>\n<td></td>\n<td>Yes</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>Process Improvement Reviews</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SEPG Measurement Analysis</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Risk Reviews</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Process Implementation Monitoring and Tracking</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Process Training - Need Analysis & Effectiveness Analysis</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Business Objectives tracking with Process</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Organizations' Tailoring and Process Asset - Analysis</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Reports to Senior Management</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Reports to Organization on deployment</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Incorporate Senior Management Review Feedback</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Process Compliance Review - For Monitoring Process and Process Assets usage in Projects</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Process Improvement Logs analysis</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Process Action plans tracking</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nProcess QA Group Activities:\n\nProcess QA group plays important role in ensuring that projects follow processes and healthy usage of process assets. Some of the activities of Process QA group given below,\n- Handhold Projects on applying new processes and templates\n- Project planning phase support\n- Process QA reviews on internal/external deliverables to check on standards, procedure, templates & guidelines application (work product review of Process and Product quality assurance)\n- Support on Metrics analysis\n- Perform Audits (if audit team is part of the same group) on projects and follow relevant standards (you can follow ISO19011 based internal quality audit process)\n- Track the non compliances coming out of Process QA reviews on deliverables and audits on process compliance, to closure\n- Early warning analysis by Process QA group is possible based on Risks, project deviation from schedule, compliance level, etc can be performed with well defined reporting mechanism\n- Final Deliverables check, sample configuration checks are other activities performed by Process QA group\n- Support in Tailoring activities and maintenance of tailoring\n\nKey points to note,\n\nProcess QA should not report to the Project manager, only an In-direct relationship should be there. Process QA should have a project level schedule to plan their deliverable review, and it could be part of the project schedule itself. Checklist based reviews and audits helps in establishing consistency; however it should not impact the investigative approach. Audits shall be based on Risk Impact approach, to ensure the points coming out of Audits are meaningful and well appreciated by operations team.\n\nh) Spot Checks: These are the points in your CMMI Implementation, where you actually come to know where you have reached in this program. A well defined program can keep giving you the indicators that you are maturing in many areas, however if you haven’t planned such tracking, then this is your evaluation point. Spot checks are performed by internal SME or by external consultant to evaluate the current level of meeting CMMI practices. This is ideally performed by selecting few projects from your implementation, which can demonstrate most of the phases in your development/services. The Projects are informed about the schedule and expectation well in advance to ensure their availability. The Spot check method includes, having a walk through with practitioner on relevant artifacts (outputs/documents) and asking them the clarifications. Basically this method\nhelps us to understand, for every relevant practice of CMMI, the Project has some or other artifact produced/evidenced and since the project team explains it, we believe that they have created/owns these artifacts as part of their project. This is a simple checking mechanism. Normally it takes 0.5 day to 1 day to have walkthrough with project. Similarly the support functions also included in it.\n\nSometimes the first few distinct type projects will be covered in detail and others will be checked only for few missing links.\n\nSimilarly it’s not a bad idea to concentrate only on specific practices in first few spot checks and then slowly moving to Generic practices also.\n\nRemember we are talking on practice level, it’s only to say, that in practical life practices mentioned in CMMI are similar to tasks to achieve something. If we don’t have some practice as mentioned in CMMI, we might have alternate practice. Similarly the goals are like activities in practical life, we can’t miss out the activities, which just leads to failure. We address in this book at practice level, so that less clarifications are needed and more details are provided.\n\nSpot Check Reports shall be at Practice Level. If the report doesn’t give any remark on a practice, it means we assume that practice is well met in the samples taken.\n\n<table>\n<thead>\n<tr>\n<th>Practice</th>\n<th>Compliance</th>\n<th>Gap</th>\n<th>Recommendations</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SP 1.1</td>\n<td>Training needs are identified from SEPG (process related), projects (technical) and also from role based training needs; and feasible training programs are rolled out</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.2</td>\n<td>Project specific and org level trainings are planed and responsibilities are spelled out in Annual</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n### Training Plan\n\n<table>\n<thead>\n<tr>\n<th>SP 1.3</th>\n<th>Annual Training Plan is established and maintained</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SP 1.4</td>\n<td>Training capability is established through identification of trainers (internal and external), repository of training materials and training facilities. Annual Training plan refers.</td>\n</tr>\n<tr>\n<td>SP 2.1</td>\n<td>Technical and Process trainings are conducted as per training calendar. Attendance records and training status reports are maintained</td>\n</tr>\n<tr>\n<td>SP 2.2</td>\n<td>Training calendars, attendance records, feedback records are maintained</td>\n</tr>\n<tr>\n<td>SP 2.3</td>\n<td>Training effectiveness is evaluated by analysis of training feedback Action tracking based on analysis to be created.</td>\n</tr>\n</tbody>\n</table>\n\nSimilarly if you can assign Compliance Level to each practice, you can get a score at Process Area level,\n\nHigh – No Gap and complete compliance\nMed- Few recommendations & no significant gap\n\nLow- Significant gap in practice compliance\n\nNow you can assign a rating of High = 1, Med = 0.5 and Low = 0\n\nNow at Process Area level you can get compliance, like out 12 specific practices you have 4 high + 6 Medium + 2 Low => 4 * 1 + 6 * 0.5 + 2 * 0 = 7\n\nThis means, 7/12 => 59% compliance\n\nIf you want you can go ahead and get compliance across all 22 (or) 24 process areas and take average out of them, which will give you a single figure like 62% compliance.\n\nThis is not a method suggested by CMMI Institute, however this helps us to quantify and get a rough value of where we stand in a moment. On subsequent Spot check, when we apply the same method, we get relative value of compliance. This helps us to see that we are moving well or not, again this is indicative only.\n\ni) Source of Process Improvements: There are various process improvement sources available in our organizations, they have to be identified and tracked continuously to improve our processes. The following are some of the sources,\n\n- Internal Audit Analysis\n- Tailoring Analysis\n- Metrics consolidated Analysis\n- Appraisal Reports\n- Client Feedbacks\n- Process QA facilitation reports\n- Senior management inputs\n- External Certification Audit reports\n- Process Suggestion portals/Operation team requests\n- Discussion forums organized in Organization\n\nAnd other sources based on your organizational components.\n\nj) Repositories Set Up: The processes used in the organization produces certain results and artifacts and these become important component for learning and for better preparation in\nfurther new projects. Repositories or Process Asset Repositories are helpful for the practitioners to get better prepared and to learn from experience of others. There are various repositories organizations maintain based on their need and effectiveness for delivery. Also it’s a cost for organizations to set up and maintain repositories. A repository is normally created by collecting data from projects, analyzing them, filling the missing components, and standardizes the data in the required format, adding to database of the repository, having a front end which is easy to retrieve the information for projects and keep updating the repository over a period of time.\n\nThe following are the typical repositories maintained in organizations,\n\n(i) Measurement Repository\n(ii) Estimation Repository\n(iii) Defect Repository\n(iv) Service issues Repository\n(v) Risk Repository\n(vi) Lifecycle Repository\n(vii) Tailoring Repository\n(viii) Best Practices Repository\n(ix) Lessons Learnt Repository\n(x) Samples Repository\n(xi) Technical Know How – FAQ’s\n\nAnd other different repositories like reusable repository, domain specific repositories, etc\n\nEvery repository shall have an identified person allocated to maintain it. The data cleansing activity is performed, before adding the data to a repository. Adequate Communication in this regard will help better utilization. Some organizations use share point or web portal to publish their repositories, and counters are enabled to check how many clicks to the portal happened for the repository.\n\nk) CMMI Development Implementation - Typical Artifacts: The following can be considered as typical artifacts in normal life, organizations produce and which could meet the CMMI practices. Do not consider them as only documents and also by name and by content they could be merged and used also. Hence this is only for sample purpose only.\n<table>\n<thead>\n<tr>\n<th><strong>Process Area- Specific Goals & Specific Practices</strong></th>\n<th><strong>Typical CMMI Artifact</strong></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Requirements Management</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Manage Requirements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Understand Requirements</td>\n<td>Requirements Document\\Collection of requirements & mails</td>\n</tr>\n<tr>\n<td>SP1.2 Obtain Commitment to Requirements</td>\n<td>Sign off on Requirement\\agreement on requirements</td>\n</tr>\n<tr>\n<td>SP 1.3 Manage Requirements Changes</td>\n<td>Change log</td>\n</tr>\n<tr>\n<td>SP 1.4 Maintain Bidirectional Traceability of Requirements</td>\n<td>Traceability matrix</td>\n</tr>\n<tr>\n<td>SP 1.5 Ensure Alignment between Project Work and Requirements</td>\n<td>Updation of project plan</td>\n</tr>\n<tr>\n<td>Requirements Development</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Develop Customer Requirements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Elicit Needs</td>\n<td>Requirements meeting MOM/prototype</td>\n</tr>\n<tr>\n<td>SP 1.2 Transform Stakeholder needs into Customer Requirements</td>\n<td>Business Requirements</td>\n</tr>\n<tr>\n<td>SG 2 Develop Product Requirements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Establish Product and Product-Component Requirements</td>\n<td>Software Requirements Specification document</td>\n</tr>\n<tr>\n<td>SP 2.2 Allocate Product-Component Requirements</td>\n<td>Software Requirements Specification document</td>\n</tr>\n<tr>\n<td>SP 2.3 Identify Interface Requirements</td>\n<td>Interface Requirements in SRS</td>\n</tr>\n<tr>\n<td>SG 3 Analyze and Validate Requirements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Establish Operational Concepts and Scenarios</td>\n<td>Use Case ,timeline scenarios, etc</td>\n</tr>\n<tr>\n<td>SP 3.2 Establish a Definition of Required Functionality and Quality Attributes</td>\n<td>activity diagram, use case</td>\n</tr>\n<tr>\n<td>SP 3.3 Analyze Requirements</td>\n<td>Requirements defect/review</td>\n</tr>\n<tr>\n<td>SP 3.4 Analyze Requirements to Achieve Balance</td>\n<td>Requirements allocation/module wise requirements, risks</td>\n</tr>\n<tr>\n<td>SP 3.5 Validate Requirements</td>\n<td>Analysis with client/prototype etc</td>\n</tr>\n<tr>\n<td>Technical Solution</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Select Product-Component Solutions</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Develop Alternative Solutions and Selection Criteria</td>\n<td>Alternative solutions/evaluation report/selection criteria</td>\n</tr>\n<tr>\n<td>SP 1.2 Select Product-Component Solutions</td>\n<td>Documented solution</td>\n</tr>\n<tr>\n<td>SG 2 Develop the Design</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Design the Product or Product Component</td>\n<td>Product Architecture</td>\n</tr>\n<tr>\n<td>SP 2.2 Establish a Technical Data Package</td>\n<td>Technical data package</td>\n</tr>\n<tr>\n<td>SG 1 Prepare for Product Integration</td>\n<td>SP 1.1 Establish and Integration Strategy</td>\n</tr>\n<tr>\n<td>SG 1 Prepare for Verification</td>\n<td>SP 1.1 Select Work Products for Verification</td>\n</tr>\n<tr>\n<td>SG 2 Verify Selected Work Products</td>\n<td>SP 1.2 Establish Verification Environment</td>\n</tr>\n<tr>\n<td>SG 2 Perform Peer Reviews</td>\n<td>SP 1.3 Establish Verification Procedures and Criteria</td>\n</tr>\n<tr>\n<td>SP 2.3 Design Interfaces Using Criteria</td>\n<td>Interface design/Criteria/Low Level design</td>\n</tr>\n<tr>\n<td>SP 3.2 Develop Product Support Documentation</td>\n<td>user manual/product manual</td>\n</tr>\n<tr>\n<td>SG 3 Assemble Product Components and Deliver the Product</td>\n<td>SP 3.1 Confirm Readiness of Product Components for Integration</td>\n</tr>\n<tr>\n<td>SG 2 Ensure Interface Compatibility</td>\n<td>SP 2.1 Review Interface Descriptions for Completeness</td>\n</tr>\n<tr>\n<td>SG 2 Perform Peer Reviews</td>\n<td>SP 2.2 Conduct Peer Reviews</td>\n</tr>\n<tr>\n<td>SP 2.3 Analyze Peer Review Data</td>\n<td>Defect closure</td>\n</tr>\n<tr>\n<td>SG 3 Verify Selected Work Products</td>\n<td>SP 3.1 Perform Verification</td>\n</tr>\n<tr>\n<td>SP 2.4 Perform Make or Buy Analysis</td>\n<td>make/buy/reuse analysis</td>\n</tr>\n<tr>\n<td>SG 3 Implement the Product Design</td>\n<td>SP 3.2 Analyze Verification Results and Identify Corrective Action</td>\n</tr>\n<tr>\n<td>SP 3.1 Implement the Design</td>\n<td>Source code</td>\n</tr>\n<tr>\n<td>SG 1 Prepare for Verification</td>\n<td>SP 1.1 Select Products for Validation</td>\n</tr>\n<tr>\n<td>SP 3.2 Develop Product Support Documentation</td>\n<td>user manual/product manual</td>\n</tr>\n<tr>\n<td>SG 1 Establish Estimates</td>\n<td>SP 1.1 Estimate the Scope of the Project</td>\n</tr>\n<tr>\n<td>-------------------------</td>\n<td>----------------------------------------</td>\n</tr>\n<tr>\n<td>SP 1.2 Establish Estimates of Work Product and Task Attributes</td>\n<td>SP 1.3 Define Project Life Cycle</td>\n</tr>\n<tr>\n<td>SP 1.4 Determine Estimates of Effort and Cost</td>\n<td>SP 2.1 Establish the Budget and Schedule</td>\n</tr>\n<tr>\n<td>SP 2.2 Identify Project Risks</td>\n<td>SP 2.3 Plan for Data Management</td>\n</tr>\n<tr>\n<td>SP 2.4 Plan for Project Resources</td>\n<td>SP 2.5 Plan for Needed Knowledge and Skills</td>\n</tr>\n<tr>\n<td>SP 2.6 Plan Stakeholder Involvement</td>\n<td>SP 2.7 Establish the Project Plan</td>\n</tr>\n<tr>\n<td>SG 2 Develop a Project Plan</td>\n<td>SP 3.1 Review Plans that Affect the Project</td>\n</tr>\n<tr>\n<td>SP 3.2 Reconcile Work and Resource Levels</td>\n<td>SP 3.3 Obtain Plan Commitment</td>\n</tr>\n<tr>\n<td>SG 1 Monitor Project Against Plan</td>\n<td>SP 1.1 Monitor Project Planning Parameters</td>\n</tr>\n<tr>\n<td>SP 1.2 Monitor Commitments</td>\n<td>SP 1.3 Monitor Project Risks</td>\n</tr>\n<tr>\n<td>SP 1.4 Monitor Data Management</td>\n<td>SP 1.5 Monitor Stakeholder Involvement</td>\n</tr>\n<tr>\n<td>SP 1.6 Conduct Progress Reviews</td>\n<td>SP 1.7 Conduct Milestone Reviews</td>\n</tr>\n<tr>\n<td>SP 1.8 Manage Corrective Action to Closure</td>\n<td>SP 1.2 Analyze Issues</td>\n</tr>\n</tbody>\n</table>\n\n**Project Planning**\n\n<table>\n<thead>\n<tr>\n<th>SG 2 Validate Product or Product Components</th>\n<th>SP 2.1 Perform Validation</th>\n<th>Test Execution Results</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SP 2.2 Analyze Validation Results</td>\n<td>Project Planning</td>\n<td>Defect Analysis & Defect prevention</td>\n</tr>\n<tr>\n<td>SP 2.2 Take Corrective Action</td>\n<td>Action items (mostly in MOM or in a log/tool)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.3 Manage Corrective Action</td>\n<td>Action Closure status and details (mostly in MOM or in a log/tool)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Risk Management</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Prepare for Risk Management</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Determine Risk Sources and Categories</td>\n<td>Risk Source and category (can be part of Risk log/sheet and applied to each risk)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.2 Define Risk Parameters</td>\n<td>Risk Parameters typically impact * probability => Risk Exposure</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.3 Establish a Risk Management Strategy</td>\n<td>Strategy document/guidance in Risk log itself (threshold/mitigation/contingency/acceptance/avoidance/roles)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 2 Identify and Analyze Risks</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Identify Risks</td>\n<td>List of Identified risks (risk log)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.2 Evaluate Risks</td>\n<td>Risk Exposure and priority</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 3 Mitigate Risks</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Develop Risk Mitigation Plans</td>\n<td>Mitigation actions (to reduce risk exposure- mostly in risk log)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.2 Implement Risk Mitigation Plans</td>\n<td>Action closure and Risk rating modifications</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Configuration Management</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Establish Baselines</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Identify Configuration Items</td>\n<td>Configurable items list (mostly in Configuration plan)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.2 Establish a Configuration Management System</td>\n<td>Configuration repository, approval mechanism (mostly in configuration Plan)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.3 Create or Release Baselines</td>\n<td>Baselines list/criteria (mostly in configuration plan)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 2 Track and Control Changes</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Track Change Requests</td>\n<td>Change requests logged</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.2 Control Configuration Items</td>\n<td>Change requests status update</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 3 Establish Integrity</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Establish Configuration Management Records</td>\n<td>Status Accounting/configuration history reports</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.2 Perform Configuration Audits</td>\n<td>Configuration audit(functional/physical)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Measurement and Analysis</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Align Measurement and Analysis Activities</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Establish Measurement Objectives</td>\n<td>Define measurement objectives (org level can be mapped to project level)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.2 Specify Measures</td>\n<td>Effort/defect/schedule/utilization, etc</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.3 Specify Data Collection and Storage Proc</td>\n<td>data source, collection, frequency(metric guideline/report itself)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.4 Specify Analysis Procedures</td>\n<td>procedure to analyze (graphs/chart/points to consider)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 2 Provide Measurement Results</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Obtain Measurement Data</td>\n<td>Metrics Report</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.2 Analyze Measurement Data</td>\n<td>Metrics Report</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.3 Store Data and Results</td>\n<td>Metrics Report</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.4 Communicate Results</td>\n<td>Meeting minutes/monthly/bimonthly reports</td>\n<td></td>\n</tr>\n<tr>\n<td>Process and Product Quality Assurance</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>--------------------------------------</td>\n<td>---------------------------------</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 1 Objectively Evaluate Processes and Work Products</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.1 Objectively Evaluate Processes</strong></td>\n<td>Audit report (Process Audit)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.2 Objectively Evaluate Work Products and Services</strong></td>\n<td>Work product Review Report (SQA review on deliverables)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 2 Provide Objective Insight</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.1 Communicate and Ensure Resolution of NC Issues</strong></td>\n<td>Non compliance closure Report</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.2 Establish Records</strong></td>\n<td>Non compliance closure Report</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Integrated Project Management</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 1 Use the Project’s Defined Process</strong></td>\n<td>Tailoring</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.1 Establish the Project’s Defined Process</strong></td>\n<td>tailoring checklist/document (of organization process with project context)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.2 Use Organizational Process Assets for Planning Project Activities</strong></td>\n<td>estimation/measurements/risks, etc used for planning (mostly in project plan)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.3 Establish Project’s work Environment</strong></td>\n<td>Documented Project environment (mostly in project plan)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.4 Integrate Plans</strong></td>\n<td>integrated project plan</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.5 Manage the Project Using the Integrated Plans</strong></td>\n<td>Revised integrated project plan/updates based on it</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.6 Establish Teams</strong></td>\n<td>Team roles and guidance (Mostly in project plan)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.7 Contribute to the Organizational Process Assets</strong></td>\n<td>Lessons learnt/best practices/improvements, etc</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 2 Coordinate and Collaborate with Relevant Stakeholders</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.1 Manage Stakeholder Involvement</strong></td>\n<td>Team Meetings/issue log/Project meetings</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.2 Manage Dependencies</strong></td>\n<td>Issue ,dependency log & closure of actions</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.3 Resolve Coordination Issues</strong></td>\n<td>Issue ,dependency log & closure of actions</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Organizational Training</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 1 Establish an Organizational Training Capability</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.1 Establish the Strategic Training Needs</strong></td>\n<td>Linked training needs with business objectives (mostly annual Training plan /strategy document)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.2 Determine Which Training Needs Are the Responsibility of the Organization</strong></td>\n<td>Project level & Org level training - listed (in plan)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.3 Establish an Organizational Training Tactical Plan</strong></td>\n<td>Training Calendar</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.4 Establish Training Capability</strong></td>\n<td>Training environment, trainer details documented at org. level</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 2 Provide Necessary Training</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.1 Deliver Training</strong></td>\n<td>Training delivery record (Invite/material/feedback/attendance)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.2 Establish Training Records</strong></td>\n<td>Training delivery record (Invite/material/feedback)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.3 Assess Training Effectiveness</td>\n<td>Training feedback evaluation/360 feedback/performance check, etc</td>\n<td></td>\n</tr>\n<tr>\n<td>------------------------------------</td>\n<td>-------------------------------------------------------------------</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Organizational Process Focus</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 1 Determine Process-Improvement Opportunities</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.1 Establish Organizational Process Needs</strong></td>\n<td>Process Needs & details (mostly in Quality Manual)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.2 Appraise the Organization’s Processes</strong></td>\n<td>Audit/appraise/review organization process</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.3 Identify the Organization's Process Improvements</strong></td>\n<td>Improvement log (based on appraisals and from projects)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 2 Plan and Implement Process Actions</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.1 Establish Process Action Plans</strong></td>\n<td>Improvement Log (with CR/improvement and action plan)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.2 Implement Process Action Plans</strong></td>\n<td>Improvement Log status (with CR/improvement and action plan)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 3 Deploy Organizational Process Assets and Incorporate experiences</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.1 Deploy Organizational Process Assets</strong></td>\n<td>Deployment plan with status</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.2 Deploy standard processes</strong></td>\n<td>Deployment plan with status</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.3 Monitor the Implementation</strong></td>\n<td>Deployment plan with status</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.4 Incorporate Experiences into the Organizational Process Assets</strong></td>\n<td>Updated Repositories (Estimation/risk/defects/samples, etc)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Organizational Process Definition</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 1 Establish Organizational Process Assets</strong></td>\n<td>Define Processes</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.1 Establish Standard Processes</strong></td>\n<td>Documented process Definitions</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.2 Establish Life-Cycle Model Descriptions</strong></td>\n<td>Lifecycle description (waterfall/incremental/iterative, etc)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.3 Establish Tailoring Criteria and Guidelines</strong></td>\n<td>Tailoring Guideline (mostly by process) and Criteria (small/large, etc)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.4 Establish the Organization’s Measurement Repository</strong></td>\n<td>Metrics repository</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.5 Establish the Organization’s Process Asset Library</strong></td>\n<td>Repositories (Estimation/risk/defects/samples, etc)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.6 Establish work Environment Standards</strong></td>\n<td>Work Environment details (mostly in Quality manual)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.7 Establish rules and guidelines for teams</strong></td>\n<td>Teaming norms (mostly in Quality manual)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Decision Analysis and Resolution</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SG 1 Evaluate Alternatives</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.1 Establish Guidelines for Decision Analysis</strong></td>\n<td>Guideline (when to use, criteria, responsible, etc)</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.2 Establish Evaluation Criteria</strong></td>\n<td>Criteria to evaluate decision (it will vary based on the context)</td>\n<td></td>\n</tr>\n<tr>\n<td>Process Area- Specific Goals & Specific Practices</td>\n<td>Typical CMMI Artifact</td>\n<td></td>\n</tr>\n<tr>\n<td>-------------------------------------------------</td>\n<td>-----------------------</td>\n<td></td>\n</tr>\n<tr>\n<td>Configuration Management</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Establish Baselines</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Identify Configuration Items</td>\n<td>Configurable items list (mostly in Configuration plan)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.2 Establish a Configuration Management System</td>\n<td>Configuration repository, approval mechanism (mostly in configuration Plan)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.3 Create or Release Baselines</td>\n<td>Baselines list/criteria (mostly in configuration plan)</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 2 Track and Control Changes</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Track Change Requests</td>\n<td>Change requests logged</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.2 Control Configuration Items</td>\n<td>Change requests status update</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 3 Establish Integrity</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Establish Configuration Management Records</td>\n<td>Status Accounting /configuration history reports</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.2 Perform Configuration Audits</td>\n<td>Configuration audit(functional/physical)</td>\n<td></td>\n</tr>\n<tr>\n<td>Measurement and Analysis</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Align Measurement and Analysis Activities</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Establish Measurement Objectives</td>\n<td>Define measurement objectives (org level can be mapped to project level)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.2 Specify Measures</td>\n<td>Effort/defect/schedule/utilization, etc</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.3 Specify Data Collection and Storage Procedures</td>\n<td>data source, collection, frequency(metric guideline/report itself)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.4 Specify Analysis Procedures</td>\n<td>procedure to analyze (graphs/chart/points to consider)</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 2 Provide Measurement Results</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Obtain Measurement Data</td>\n<td>Metrics Report</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.2 Analyze Measurement Data</td>\n<td>Metrics Report with Analysis</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.3 Store Data and Results</td>\n<td>Metrics Report in Database & Communication</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.4 Communicate Results</td>\n<td>Meeting minutes/monthly/bimonthly reports</td>\n<td></td>\n</tr>\n<tr>\n<td>Process and Product Quality Assurance</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Objectively Evaluate Processes and Work Products</td>\n<td>SP 1.1 Objectively Evaluate Processes</td>\n<td>Audit report (Process Audit) with Noncompliance & corrective actions Audit checklist</td>\n</tr>\n<tr>\n<td>------------------------------------------------------</td>\n<td>--------------------------------------</td>\n<td>------------------------------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>SP 2 Provide Objective Insight</td>\n<td></td>\n<td>Mail of report being shared with stakeholders</td>\n</tr>\n<tr>\n<td>SP 2.1 Communicate and Resolve Noncompliance Issues</td>\n<td>SP 2.2 Establish Records</td>\n<td>Audit plan Non compliance closure Report</td>\n</tr>\n<tr>\n<td>SP 2.2 Establish Records</td>\n<td></td>\n<td>Status of corrective actions</td>\n</tr>\n<tr>\n<td>SG 2 Provide Objective Insight</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Manage Requirements</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Understand Requirements</td>\n<td>SP 1.2 Obtain Commitment to Requirements</td>\n<td>Requirements Document\\Collection of requirements & mails Sign off on Requirement\\agreement on requirements</td>\n</tr>\n<tr>\n<td>SP 1.3 Manage Requirements Changes</td>\n<td>SP 1.4 Maintain Bidirectional Traceability of Requirements</td>\n<td>Change log</td>\n</tr>\n<tr>\n<td>SP 1.5 Ensure Alignment between Work Products and Requirements</td>\n<td>SP 1.5 Ensure Alignment between Work Products and Requirements</td>\n<td>Service Requirements traceability matrix</td>\n</tr>\n<tr>\n<td>Supplier Agreement Management</td>\n<td>Supplier Agreement Management</td>\n<td>Requirements tracking system</td>\n</tr>\n<tr>\n<td>SG 1 Establish Supplier Agreements</td>\n<td>SG 2 Satisfy Supplier Agreements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Determine Acquisition Type</td>\n<td>SP 2.1 Execute the Supplier Agreement</td>\n<td>Type of Suppliers and Acquisition types Receive Product, Track Supply - Tracking status</td>\n</tr>\n<tr>\n<td>SP 1.2 Select Suppliers</td>\n<td>SP 2.2 Accept the Acquired Product</td>\n<td>Supplier list and Vendor Evaluation sheet Acceptance report, inception report</td>\n</tr>\n<tr>\n<td>SP 1.3 Establish Supplier Agreements</td>\n<td>SP 2.3 Ensure Transition of Products</td>\n<td>Purchase Order, Contract, SOW Transition plans, handover report</td>\n</tr>\n<tr>\n<td>SG 2 Satisfy Supplier Agreements</td>\n<td>Service Delivery</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Establish Supplier Agreements</td>\n<td>SG 1 Establish Service Agreements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Analyze Existing Agreements and Service Data</td>\n<td>SP 1.2 Establish the Service Agreement</td>\n<td>Analysis of past SLA's and SOW & Analysis of reports</td>\n</tr>\n<tr>\n<td>SP 1.2 Establish the Service Agreement</td>\n<td>SG 2 Prepare for Service Delivery</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2 Prepare for Service Delivery</td>\n<td>SP 2.1 Establish the Service Delivery Approach</td>\n<td>Service agreement/ Contract etc</td>\n</tr>\n<tr>\n<td>SP 2.2 Prepare for Service System Operations</td>\n<td>SP 2.2 Prepare for Service System Operations</td>\n<td>Project/Service management plan with the agreed Service delivery approach (Incident/problem, etc)</td>\n</tr>\n<tr>\n<td>SP 2.3 Establish a Request Management</td>\n<td>SP 2.3 Establish a Request Management</td>\n<td>Validation of Knowledge Transfer/ Validation of Service System tool (training etc)/ operational readiness assessment</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Incident Management tool/ Log</td>\n</tr>\n<tr>\n<td>System</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>--------</td>\n<td>---</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 3 Deliver Services</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Receive and Process Service Requests</td>\n<td>Incident Management record in the tool/ Log</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.2 Operate the Service System</td>\n<td>Service logs from the tool/ Performance Status reports</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.3 Maintain the Service System</td>\n<td>Corrective or preventive maintenance change requests/ Change Requests on the service system</td>\n<td></td>\n</tr>\n<tr>\n<td>Work Planning</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Establish Estimates</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Establish the Service Strategy</td>\n<td>Service Strategy Document</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.2 Estimate the Scope of the Work</td>\n<td>Top Level WBS, work Package description</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.3 Establish Estimates of Work Product and Task Attributes</td>\n<td>Size, estimating model</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.4 Define Lifecycle Phases</td>\n<td>Life cycle documented ( mostly in Project /Service management plan)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.5 Estimate Effort and Cost</td>\n<td>Effort & cost of project ( mostly in Project plan)</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 2 Develop a Work Plan</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Establish the Budget and Schedule</td>\n<td>Budget and schedule ( mostly Kick off/initiation deck etc)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.2 Identify Risks</td>\n<td>Risk Identification checklist/Risk log</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.3 Plan Data Management</td>\n<td>Data Management plan (mostly in project plan/charter)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.4 Plan the Resources</td>\n<td>Project resources (mostly in project plan/charter)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.5 Plan Needed Knowledge and Skills</td>\n<td>Skill Matrix by roles</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.6 Plan Stakeholder Involvement</td>\n<td>Stakeholder Matrix</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.7 Establish the Work Plan</td>\n<td>Project plan/Service Management Plan</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 3 Obtain Commitment to the Plan</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Review Plans That Affect the Work</td>\n<td>Revised plan/Review comments</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.2 Reconcile Work and Resource Levels</td>\n<td>Revised Plan</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.3 Obtain Plan Commitment</td>\n<td>Approval & Plan commitment from stakeholders</td>\n<td></td>\n</tr>\n<tr>\n<td>Work Monitoring and Control</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Monitor the Work Against the Plan</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Monitor Work Planning Parameters</td>\n<td>Effort, schedule, other measures (Metrics report)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.2 Monitor Commitments</td>\n<td>Commitment monitoring (Meeting MOM/issues, etc)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.3 Monitor Risks</td>\n<td>Risk Log/weekly/biweekly/monthly reports</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.4 Monitor Data Management</td>\n<td>Data Confidentiality/availability and integrity monitoring (Meeting MOM)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.5 Monitor Stakeholder Involvement</td>\n<td>Stakeholder participation (Meeting MOM)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.6 Conduct Progress Reviews</td>\n<td>Monthly reviews/biweekly reviews</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.7 Conduct Milestone Reviews</td>\n<td>Milestone meeting (Sometimes Monthly/biweekly reviews)</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 2 Manage Corrective Action to Closure</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Analyze Issues</td>\n<td>Issue Log</td>\n<td></td>\n</tr>\n<tr>\n<td>----------------------------</td>\n<td>--------------------------------</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.2 Take Corrective Action</td>\n<td>Action items (mostly in MOM or in a log/tool)</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.3 Manage Corrective Actions</td>\n<td>Action Closure status and details (mostly in MOM or in a log/tool)</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nCapacity and Availability Management\n\nSG 1 Prepare for Capacity and Availability Management\n\n| SP 1.1 Establish a Capacity and Availability Management Strategy | Service management plan with details on Human/Infra/technological capacity and availability for agreed service |\n| SP 1.2 Select Measures and Analytic Techniques | Capacity and availability measures and analysis technique |\n| SP 1.3 Establish Service System Representations | process simulation (system simulation), Simulation of inflow and capacity and availability with excel |\n\nSG 2 Monitor and Analyze Capacity and Availability\n\n| SP 2.1 Monitor and Analyze Capacity | Trend charts on service resource usage data |\n| SP 2.2 Monitor and Analyze Availability | Trends on availability, analysis and action |\n| SP 2.3 Report Capacity and Availability Management Data | Service system performance reports Service availability reports |\n\nDecision Analysis and Resolution\n\nSG 1 Evaluate Alternatives\n\n| SP 1.1 Establish Guidelines for Decision Analysis | Guideline (when to use, criteria, responsible, etc) |\n| SP 1.2 Establish Evaluation Criteria | Criteria to evaluate decision(it will vary based on the context) |\n| SP 1.3 Identify Alternative Solutions | Document alternate solution (separate DAR sheet used in many org.) |\n| SP 1.4 Select Evaluation Methods | Evaluation techniques (Pugh matrix, cost benefit, weighted average, etc) (DAR sheet to have the method) |\n| SP 1.5 Evaluate Alternative Solutions | Valuation of each alternative solution (DAR sheet) |\n| SP 1.6 Select Solutions | Final Solution ( DAR sheet) |\n\nIncident Resolution and Prevention\n\nSG 1 Prepare for Incident Resolution and Prevention\n\n| SP 1.1 Establish an Approach to Incident Resolution and Prevention | SQP with details on Service Incident handling approach |\n| SP 1.2 Establish an Incident Management System | Service Incident logging Tool/ Log |\n\nSG 2 Identify, Control, and Address Individual Incidents\n\n<p>| SP 2.1 Identify and Record Incidents | Service Incident ticket record |\n| SP 2.2 Analyze Individual Incident Data | Major incident, repeat incident analysis |\n| SP 2.3 Resolve Incidents | Updated resolution in the tool/ log |\n| SP 2.4 Monitor the Status of Incidents to Closure | Closure Service incident log/ Status update/ Escalation data (mail/tool ref etc) |</p>\n<table>\n<thead>\n<tr>\n<th>SP 2.5 Communicate the Status of Incidents</th>\n<th>Status reports/ Communication mail</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SG 3 Analyze and Address Causes and Impacts of Selected Incidents</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Analyze Selected Incidents</td>\n<td>Report of underlying causes of incidents/ Documented causal analysis activities</td>\n</tr>\n<tr>\n<td>SP 3.2 Establish Solutions to Respond to Future Incidents</td>\n<td>Knowledge data base</td>\n</tr>\n<tr>\n<td>SP 3.3 Establish and Apply Solutions to Reduce Incident Occurrence</td>\n<td>Change in Service Delivery system like a tool/ procedure / policies etc.</td>\n</tr>\n<tr>\n<td>Service System Transition</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Prepare for Service System Transition</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Analyze Service System Transition Needs</td>\n<td>Compatibility analysis of current and post-transition service systems Baseline service system components Mitigations for of identified transition Issues and risks</td>\n</tr>\n<tr>\n<td>SP 1.2 Develop Service System Transition Plans</td>\n<td>Transition plans for service system transition (tools, process, competency)</td>\n</tr>\n<tr>\n<td>SP 1.3 Prepare Stakeholders for Changes</td>\n<td>Strategy of training and transition</td>\n</tr>\n<tr>\n<td></td>\n<td>Transition communication and notification artifacts (e.g., emails, system announcements, bulletin boards)</td>\n</tr>\n<tr>\n<td>Service System Development</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 2 Deploy the Service System</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Deploy Service System Components</td>\n<td>Installation records Installation instructions Operational scenarios and procedures</td>\n</tr>\n<tr>\n<td>SP 2.2 Assess and Control the Impacts of the Transition</td>\n<td>Post deployment review Back out / rollback results, if needed Service impacts due to deployment issues</td>\n</tr>\n<tr>\n<td>Service System Development</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Develop and Analyze Stakeholder Requirements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Develop Stakeholder Requirements</td>\n<td>Customer requirements End-user requirements</td>\n</tr>\n<tr>\n<td>SP 1.2 Develop Service System Requirements</td>\n<td>Service system Requirements & software requirement specification</td>\n</tr>\n<tr>\n<td>SP 1.3 Analyze and Validate Requirements</td>\n<td>Prototype, Validation of requirements</td>\n</tr>\n<tr>\n<td>SG 2 Develop Service Systems</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Select Service System Solutions</td>\n<td>Architecture of solution, Service system design</td>\n</tr>\n<tr>\n<td>SP 2.2 Develop the Design</td>\n<td>Code and develop service software, develop components of service system</td>\n</tr>\n<tr>\n<td>SP 2.3 Ensure Interface Compatibility</td>\n<td>Interface identification within components and external components of service system</td>\n</tr>\n<tr>\n<td>SP 2.4 Implement the Service System</td>\n<td>Implemented service system components</td>\n</tr>\n<tr>\n<td>Design</td>\n<td>Training materials</td>\n</tr>\n<tr>\n<td>--------</td>\n<td>--------------------</td>\n</tr>\n<tr>\n<td>User, operator, and maintenance manual</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.5 Integrate Service System Components</td>\n<td>Service system integration plan, build the service system</td>\n</tr>\n<tr>\n<td>SG 3 Verify and Validate Service Systems</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Prepare for Verification and Validation</td>\n<td>Verification tools, environment, test strategy, simulation plan</td>\n</tr>\n<tr>\n<td>SP 3.2 Perform Peer Reviews</td>\n<td>peer review checklist, peer review report</td>\n</tr>\n<tr>\n<td>SP 3.3 Verify Selected Service System Components</td>\n<td>Review and unit test</td>\n</tr>\n<tr>\n<td>SP 3.4 Validate the Service System</td>\n<td>Validation reports and results, Test Results</td>\n</tr>\n<tr>\n<td>Integrated Work Management</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Use the Defined Process for the Work</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Establish the Defined Process</td>\n<td>tailoring checklist/document (of organization process with project context)</td>\n</tr>\n<tr>\n<td>SP 1.2 Use Organizational Process Assets for Planning Work Activities</td>\n<td>estimation/measurements/risks, etc used for planning (mostly in project plan)</td>\n</tr>\n<tr>\n<td>SP 1.3 Establish the Work Environment</td>\n<td>Documented Project environment (mostly in project plan)</td>\n</tr>\n<tr>\n<td>SP 1.4 Integrate Plans</td>\n<td>integrated project plan</td>\n</tr>\n<tr>\n<td>SP 1.5 Manage the Work Using Integrated Plans</td>\n<td>Revised integrated project plan/updates based on it</td>\n</tr>\n<tr>\n<td>SP 1.6 Establish Teams</td>\n<td>Team roles and guidance (Mostly in project plan)</td>\n</tr>\n<tr>\n<td>SP 1.7 Contribute to Organizational Process Assets</td>\n<td>Lessons learnt/best practices/improvements, etc</td>\n</tr>\n<tr>\n<td>SG 2 Coordinate and Collaborate with Relevant Stakeholders</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Manage Stakeholder Involvement</td>\n<td>Team Meetings/issue log/Project meetings</td>\n</tr>\n<tr>\n<td>SP 2.2 Manage Dependencies</td>\n<td>Issue ,dependency log & closure of actions</td>\n</tr>\n<tr>\n<td>SP 2.3 Resolve Coordination Issues</td>\n<td>Issue ,dependency log & closure of actions</td>\n</tr>\n<tr>\n<td>Strategic Service Management</td>\n<td></td>\n</tr>\n<tr>\n<td>SSG 1 Establish Strategic Needs and Plans for Standard Services</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Gather and Analyze Data</td>\n<td>Analyzed data on the organization’s capabilities (past performance report)</td>\n</tr>\n<tr>\n<td></td>\n<td>Analyzed data on strategic needs, Analysis report</td>\n</tr>\n<tr>\n<td>SP 1.2 Establish Plans for Standard Services</td>\n<td>Strategic plan on standard service, catalogue, needs</td>\n</tr>\n<tr>\n<td>SG 2 Establish Standard Services</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Establish Properties of Standard Services and Service Levels</td>\n<td>Critical attributes of standard services</td>\n</tr>\n<tr>\n<td></td>\n<td>Organization’s set of standard service levels</td>\n</tr>\n<tr>\n<td></td>\n<td>Common and variable parts of standard services</td>\n</tr>\n<tr>\n<td>SP 2.2 Establish Descriptions of Standard</td>\n<td>Service Catalog with specific instructions</td>\n</tr>\n<tr>\n<td>Services</td>\n<td></td>\n</tr>\n<tr>\n<td>-------------------------------------------------------------------------</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Service Continuity</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Identify Essential Service Dependencies</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Identify and Prioritize Essential Functions</td>\n<td>Risk Assessment, Business continuity assessment report</td>\n</tr>\n<tr>\n<td>SP 1.2 Identify and Prioritize Essential Resources</td>\n<td>prioritization based on Assessment (Business continuity assessment report)</td>\n</tr>\n<tr>\n<td><strong>SG 2 Prepare for Service Continuity</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Establish Service Continuity Plans</td>\n<td>Business Continuity plan</td>\n</tr>\n<tr>\n<td>SP 2.2 Establish Service Continuity Training</td>\n<td>Service continuity training material Training records</td>\n</tr>\n<tr>\n<td>SP 2.3 Provide and Evaluate Service Continuity Training</td>\n<td>Training Records on business continuity</td>\n</tr>\n<tr>\n<td><strong>SG 3 Verify and Validate the Service Continuity Plan</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Prepare for the Verification and Validation of the Service Continuity Plan</td>\n<td>Plan for Business continuity check</td>\n</tr>\n<tr>\n<td>SP 3.2 Verify and Validate the Service Continuity Plan</td>\n<td>Review report</td>\n</tr>\n<tr>\n<td>SP 3.3 Analyze Results of Verification and Validation of the Service Continuity Plan</td>\n<td>Results of Simulation Test report & improvement recommendations</td>\n</tr>\n<tr>\n<td><strong>Risk Management</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Prepare for Risk Management</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Determine Risk Sources and Categories</td>\n<td>Risk Source and category (can be part of Risk log/sheet and applied to each risk)</td>\n</tr>\n<tr>\n<td>SP 1.2 Define Risk Parameters</td>\n<td>Risk Parameters typically impact * probability => Risk Exposure</td>\n</tr>\n<tr>\n<td>SP 1.3 Establish a Risk Management Strategy</td>\n<td>Strategy document/guidance in Risk log itself (threshold/mitigation/contingency/acceptance/avoidance/roles)</td>\n</tr>\n<tr>\n<td><strong>SG 2 Identify and Analyze Risks</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Identify Risks</td>\n<td>List of Identified risks (risk log)</td>\n</tr>\n<tr>\n<td>SP 2.2 Evaluate, Categorize, and Prioritize Risks</td>\n<td>Risk Exposure and priority</td>\n</tr>\n<tr>\n<td><strong>SG 3 Mitigate Risks</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Develop Risk Mitigation Plans</td>\n<td>Mitigation actions (to reduce risk exposure- mostly in risk log)</td>\n</tr>\n<tr>\n<td>SP 3.2 Implement Risk Mitigation Plans</td>\n<td>Action closure and Risk rating modifications</td>\n</tr>\n<tr>\n<td><strong>Organizational Training</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Establish an Organizational Training</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Establish Strategic Training Needs</td>\n<td>Linked training needs with business objectives (mostly</td>\n</tr>\n<tr>\n<td>SG 1 Determine Process Improvement Opportunities</td>\n<td>Organizational Process Definition</td>\n</tr>\n<tr>\n<td>-----------------------------------------------</td>\n<td>----------------------------------</td>\n</tr>\n<tr>\n<td>SP 1.1 Establish Organizational Process Needs</td>\n<td>SP 1.1 Establish Standard Processes</td>\n</tr>\n<tr>\n<td>SP 1.2 Appraise the Organization’s Processes</td>\n<td>SP 1.2 Establish Life-Cycle Model Descriptions</td>\n</tr>\n<tr>\n<td>SP 1.3 Identify the Organization's Process Improvements</td>\n<td>SP 1.3 Establish Tailoring Criteria and Guidelines</td>\n</tr>\n<tr>\n<td>SG 2 Plan and Implement Process Actions</td>\n<td>SP 1.4 Establish the Organization’s Metrics repository</td>\n</tr>\n<tr>\n<td>SP 2.1 Establish Process Action Plans</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.2 Implement Process Action Plans</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 3 Deploy Organizational Process Assets and Incorporate Experiences</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Deploy Organizational Process Assets</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.2 Deploy Standard Processes</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.3 Monitor the Implementation</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.4 Incorporate Experiences into Organizational Process Assets</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n---\n\n| SP 1.2 Determine Which Training Needs Are the Responsibility of the Organization | Project level & Org level training - listed (in plan) |\n| SP 1.3 Establish an Organizational Training Tactical Plan | Training Calendar |\n| SP 1.4 Establish a Training Capability | Training environment, trainer details documented at org. level |\n| SG 2 Provide Training | |\n| SP 2.1 Deliver Training | Training delivery record (Invite/material/feedback/attendance) |\n| SP 2.2 Establish Training Records | Training delivery record (Invite/material/feedback) |\n| SP 2.3 Assess Training Effectiveness | Training feedback evaluation/360 feedback/performance check, etc |\n\n---\n\n<table>\n<thead>\n<tr>\n<th>Organizational Process Focus</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SG 1 Determine Process Improvement Opportunities</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.2 Appraise the Organization’s Processes</td>\n<td>Audit/appraise/review organization process</td>\n</tr>\n<tr>\n<td>SP 1.3 Identify the Organization's Process Improvements</td>\n<td>Improvement log (based on appraisals and from projects)</td>\n</tr>\n<tr>\n<td>SG 2 Plan and Implement Process Actions</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Establish Process Action Plans</td>\n<td>Improvement Log (with CR/improvement and action plan)</td>\n</tr>\n<tr>\n<td>SP 2.2 Implement Process Action Plans</td>\n<td>Improvement Log status (with CR/improvement and action plan)</td>\n</tr>\n<tr>\n<td>SG 3 Deploy Organizational Process Assets and Incorporate Experiences</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Deploy Organizational Process Assets</td>\n<td>Deployment plan with status</td>\n</tr>\n<tr>\n<td>SP 3.2 Deploy Standard Processes</td>\n<td>Deployment plan with status</td>\n</tr>\n<tr>\n<td>SP 3.3 Monitor the Implementation</td>\n<td>Deployment plan with status</td>\n</tr>\n<tr>\n<td>SP 3.4 Incorporate Experiences into Organizational Process Assets</td>\n<td>Updated Repositories (Estimation/risk/defects/samples, etc)</td>\n</tr>\n</tbody>\n</table>\n\n---\nm) Generic Goals/Practices\n\n<table>\n<thead>\n<tr>\n<th>Generic Goals & Practices</th>\n<th>Typical Artifacts</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GG2: Institutionalize a Managed process</td>\n<td></td>\n</tr>\n<tr>\n<td>GP2.1 Establish an Organizational Policy</td>\n<td>Policy guide book/ policy within a process</td>\n</tr>\n<tr>\n<td>GP2.2 Plan the process</td>\n<td>Part of work break down structure</td>\n</tr>\n<tr>\n<td>GP2.3 Provide resources</td>\n<td>Resource allocation in Project plan/Service management plan</td>\n</tr>\n<tr>\n<td>GP2.4 Assign Responsibility</td>\n<td>Roles and Responsibility in Project plan/Service management plan</td>\n</tr>\n<tr>\n<td>GP2.5 Train People</td>\n<td>Skill matrix and training plan</td>\n</tr>\n<tr>\n<td>GP2.6 Control work products</td>\n<td>Configuration plan with Configurable items</td>\n</tr>\n<tr>\n<td>GP2.7 Identify and Involve Relevant Stakeholders</td>\n<td>Stakeholder management plan/matrix with tasks in Project/Service management plan</td>\n</tr>\n<tr>\n<td>GP2.8 Monitor and Control the process</td>\n<td>Metrics report/capacity report/meeting minutes</td>\n</tr>\n<tr>\n<td>GP2.9 Objectively Evaluate Adherence</td>\n<td>Audit reports for all processes</td>\n</tr>\n<tr>\n<td>GP2.10 Review Status with Higher Level Management</td>\n<td>Status reports/MOM ,etc</td>\n</tr>\n</tbody>\n</table>\n\nGG 3 Institutionalize a Defined Process\n\n| GP3.1 Establish a defined Process | Process Description and Tailoring details for process in a project |\nThe Generic practices should be applied for each of process area with that context. Here whatever we have given is a sample, if you try to understand that this will fit everywhere it’s a Risk. Hence be cautious this is only for sample purpose.\n\nn) Monitoring and Control of program: The Monitoring of the program is an important activity and should be continuous. As we discussed earlier, we have steering committee and we have SEPG running, however it’s important for the CMMI program manager to keep track of the happenings as per the schedule and generating the relevant measures in alignment with program management parameters.\n\nIt starts from reporting the schedule deviation and effort deviation; some organizations use earned value analysis method to show the overall deviation on schedule and effort. Some people may claim that effort can be estimated in a program like CMMI, however in normal life there are companies who have estimated effort, tracked and controlled it (not FTE). Estimation can always be revised, but what it makes you is taking decision in informed way. Considering the spot check compliance rating method we described earlier, you can go ahead and have targets for your CMMI compliance level by each spot check/appraisal, and see whether you are in that range.\n\nEx: Spot check 1, you wanted to achieve 55% compliance and spot check 2, you wanted to achieve 65% compliance etc. similarly before the appraisal, and you may want to reach more than 95% compliance with the model.\n\nOther monitoring is on the deliverables by timeline. If you have targeted QMS release on a particular period to support the implementation, any delay will have impact on the successor task in your schedule.\n\nCommunication of the Metrics report and compliance chart publishing in various places in the organization will give confidence and the information to employees and encourages them to progress further.\n\no) Other Points to take care in Implementation:\n\n- Monitor the scope of implementation throughout and not to deviate\n- The barriers has to be logged in issue log, but keep progressing in other areas ,while clearing them\n- Check the coverage level in implementation\n• Check the compliance level in implementation\n• Don’t go for any short cut, that’s not what is intended by your organizations. Work\n around is different from short cuts.\n• Be ready to face the challenges and don’t shy away from them\n• Be proactive and drive the implementation and don’t allow the program to drive you.\n• The time limit set should be always challenging than comfort, however too aggressive\n timeline can be devastating also. Always go for 20% more than your comfort zone.\n• Strong Management support is very important, because not every question can be\n answered with data or history, new things has to be experimented, and whenever you\n face challenges that people are not ready for change, and then management support is\n vital.\n• You may progress slower than what you aimed for, but if the progress is convincing\n and meaningful results are coming out, then don’t worry about them.\n• Manage the Ego between people, this is important for success. This is anyway part of\n change management, however ego and personal goal clashes sometime hinders the\n progress of the program. You have to ready to convince and include them sometime,\n or escalate as needed or change few things in organization to ensure that dynamics\n settles well to produce a supportive environment.\n• Never allocate a person to run a CMMI program, because they are free or you want\n them to work hard. You need a person, who is strategic and who can ensure that every\n arm is working towards the goal. Sometimes we see people, who are not very\n successful in delivery is suddenly allocated to this program to manage. The reality is\n this the important program in your organization and it’s going to change your culture,\n then why to allocate a poorly performing person there. However if you believe this\n only for achieving some rating and you are not going to change anything, it means\n you are already decided the failure, so feel free to allocate anyone.\n• Never call it as “Certification”. This is clarified many times by SEI and now by\n CMMI Institute that there is nothing like Certification at organization level. But still\n we see organizations calling it as certification. This is more than just wording, it\n reflects the mentality and approach they have over the program. It’s only a “Rating”\n based on Appraisal on Maturity or capability level on that instance of appraisal. Every\n time correct your employees when they use the word certification, this is important\n for them to understand and live up to the expectation of the program.\nExecution of all the tasks mentioned in your plan as per the suggestions given here will definitely lead you to a better position and to get ready for your appraisal.\n\nAppraising CMMI Implementation\n\nThis is an important phase to evaluate your processes and understand the strength and weaknesses and find the improvement opportunities to increase the efficiency and effectiveness of your processes. Also it gives a way to benchmark and see your process maturity level across industry through appraisal rating system.\n\nAppraisal phase has lot of different activities and terminologies to understand for better clarity. To Appraise the CMMI Model, there is a document called “ARC – Appraisal Requirements for CMMI” is available, which basically explains the different criteria and characteristics the appraisal method should possess. We are not much bothered about it, as CMMI Institute has an Appraisal Method called SCAMPI which is already in compliance with this requirement. SCAMPI stands for Standard CMMI based Appraisal Method for Process Improvement. SCAMPI has 3 types of Appraisals in it.\n\nSCAMPI C – The lightest method, the appraisals can be based on artifacts or Oral affirmation. The purpose of this appraisal method is quickly to understand the high level approach issues and interpretation issues. We need a Team Leader certified by CMMI Institute to do the SCAMPI C appraisal. This is not mandatory activity, if you are looking for achieving a particular maturity rating. However it’s preferred to have this kind of appraisal for early correction in approach.\n\nSCAMPI B – The method helps to understand in detail the weakness and strength in process areas. We can adopt this when we are in mid stage of implementation or in 75% progress in our journey. The missing elements can be identified and it gives deeper understanding. Cost wise this is lesser costlier than SCAMPI A. We need certified Team Leader for SCAMPI B appraisal to conduct this appraisal. We need a team of members to participate along with team leader to perform appraisal. If we have Appraisal Team Members (trained), it will be added advantage. This is again not mandatory, but definitely recommended to avoid any surprise.\n\nSCAMPI A – The only method which meets all the requirements of ARC and which can produce results in terms of “Rating” at organizational level is this method. To perform this we need a Certified Lead Appraiser (Up to ML3) or a Certified High Maturity Lead Appraiser (Up to ML5) and team of trained members in CMMI Model and in Appraisal Methodology. The Results provided this method is valid for 3 years and the sponsor of the program can select publishing it in PARS site of CMMI Institute, where your results based on confidentiality chosen will be available for external world to view. It’s a very detailed method and multiple analysis method is available like a) Verification method b) Discovery method and c) Managed Discovery Method. Most of them like to go with Managed Discovery method, where they collect minimum required\ninformation before appraisal and take the discovery approach to better understand the implementation. This greatly reduced the level of effort put in PIID (Process Implementation Indicator Document) preparation.\n\nFor more understanding on SCAMPI Method, you can download MDD (Method Definition Document) from CMMIInstitute.com\n\nAppraisal Phase Activities:\n\na) Appraisal Scope Discussion: Before you enter this phase, it’s expected that the Lead Appraiser is already identified and formal introduction about your organization and a meeting with sponsor should have been done. In this activity it’s important to discuss with him on the appraisal scope you are looking forward and define them clearly in a word document. This could be the one in later point of time, submitted in CMMI Institute Appraisal System (SAS) and may come in the Appraisal plan document. The terminologies shall be at industry standard and which your client can understand. Similarly discuss with lead appraiser on units to be included and projects which are falling under the scope of appraisal. Organizational unit is the terminology which defines the boundary of the organization which has implemented the model and to be included in appraisal. It can happen that only one production/service line you have considered in Implementation and then organizational unit is only inclusive of that line. Once you and the lead appraiser has come in to understanding, by this time, you will also have collected some idea from your lead appraiser that how he/she is planning to select the projects or samples for the given condition.\n\nThe SCAMPI v1.3 method contains sample case for the Organizations to understand the sampling. The key is finding the factors which introduce variation in implementation and create distinct sample groups out of them. Then based out of overall work units in the Organizational unit and the number of work unit in each distinctive sample group, the ratio are derived and the final number of sample work unit to be looked in appraisal is derived using the pre defined formula in the method. The simple clue you can take is, the lesser the variation and more or less equal number within in the sample groups, then you will end with less work units to look in to appraisal. This means less cost and typical normal schedule.\n\n<p>| Sampling of Sub groups – with three varying factors (site, Domain, Type) |\n|-----------------|-----------------|-----------------|-----------------|-----------------|-----------------|-----------------|\n| | Site | Domain | Type | Basic Units | Sample Calc | Sample Size |\n| Sub Group 1 | Paris | Banking | Implementation | 20 | 1.5 | 2 |</p>\n<table>\n<thead>\n<tr>\n<th>Sub Group</th>\n<th>City</th>\n<th>Industry</th>\n<th>Implementation</th>\n<th>Basic Units</th>\n<th>Percent</th>\n<th>Lead</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Sub Group2</td>\n<td>Paris</td>\n<td>Healthcare Upgrade</td>\n<td>4</td>\n<td>0.3</td>\n<td>1</td>\n<td></td>\n</tr>\n<tr>\n<td>Sub Group3</td>\n<td>Paris</td>\n<td>Manufacturing Implementation</td>\n<td>2</td>\n<td>0.1</td>\n<td>1</td>\n<td></td>\n</tr>\n<tr>\n<td>Sub Group4</td>\n<td>Beijing</td>\n<td>Banking Implementation</td>\n<td>40</td>\n<td>3.0</td>\n<td>3</td>\n<td></td>\n</tr>\n<tr>\n<td>Sub Group5</td>\n<td>Beijing</td>\n<td>Manufacturing Implementation</td>\n<td>1</td>\n<td>0.1</td>\n<td>1</td>\n<td></td>\n</tr>\n<tr>\n<td>Total 5</td>\n<td></td>\n<td></td>\n<td></td>\n<td>67</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nThe Formula application for sample size of Basic units from each sub group is (Total number of sub groups/ Total Basic Units) * Basic units in that sub group. In this case sub group 1 sample size is \\((\\frac{5}{67})*20 = 1.5 \\Rightarrow 2\\), similarly others are also calculated.\n\nb) Appraisal Team Member Selection: The appraisal members are selected typically nearer to the last quarter to ensure their stay in the organization for the period is confirmed. The Appraisal team members should have certain qualifications in terms of experience in technical and project management side, reporting clearance and competency. The expectations are set clear in the new method, and the lead appraiser will discuss with organization and will ensure the requirements are met. From organization’s point of view, you may need your best people or the practitioner to sit as Functional Area Representative (FAR) than as Appraisal Team Member (ATM). However you may need to have few people from your Process QA Group to be there, so process related doubts and working methods can be explained well. For smaller organizations who don’t have many , they can take external ATM’s or can declare the conflicts about a person representing the ATM team, that can be planned and managed by Lead Appraiser. It’s always a good practice to bring few external ATM’s to get better objective results. However it also has slight risk on not understanding the context on timely manner.\n\nAppraisal Team Members shall undergo formal “CMMI Introduction” training for the respective model which is planned to be appraised in your organization. If you go for combined appraisal, then CMMI Dev + CMMI Svc addition training is required or you can send them for training on both the method separately. This training can be provided only by a Certified CMMI Instructor, your lead appraiser may have this certification, so he can do this. The trained member names, dates of training and organizational name is collected and send to CMMI Institute, normally within weeks it’s added to their records. This is important for the members to be part of Appraisal, because the SAS will have to\nshow their record to the lead appraiser to add in to a newly created appraisal as Appraisal Team Member. The “Official Introduction to CMMI- Dev/Svc” can be a separate program planned for your organization or shared program with organizations or regular planned public programs conducted by the CMMI Instructors. This is of 3 days duration and at the end you will receive a certificate of training with CMMI Institute emblem.\n\nAppraisal Team training is provided by the Lead Appraiser of the appraisal. If you have already just participated in an appraisal for the same constellation as team member, the lead appraiser may chose not to give you the training but to include you as team member. CMMI Institute never gives any certificate for this role, if at all it’s given; it’s normally by the CMMI Partner. However in the ATM pool database in SAS (appraisal system- portal) the names of eligible people to participate in an appraisal for a constellation is listed by their training record. The ATM training is of 2 days duration and normally lead appraiser’s combined them with SCAMPI B or Readiness Review, which gives the ATM’s better understanding on applying the SCAMPI practices and getting ready for SCAMPI A. There is a simple open book pre qualifying test too.\n\nc) Appraisal Plan: Appraisal plan is prepared by the lead appraiser based on the various inputs collected in the organization to schedule the SCAMPI A appraisal. The scope, sampling, resources to be involved, plan for data collection, details on appraisal onsite schedule, Appraisal Team Member details, back ground on the organization and other details are documented in this. The Appraisal Plan normally undergoes multiple iterations to ensure accuracy and updated details. The Sponsor from your organization and Lead Appraiser have to sign the document. The Appraisal Team Member sign is also taken on this. Appraisal plan should be agreed before getting in to SCAMPI A onsite period.\n\nData collection activities have to be planned in every appraisal and these details are submitted to CMMI Institute. With many of them moving to Managed Discovery Approach, the huge exercise of PIID preparation is no longer a concern in the new SCAMPI V1.3 Method. The Important Artifacts which covers most of the practices and acts as evidence is collected and stored in relevant places. The Appraisal teams are given with relevant hints and they are able to locate and tag them in readiness review and they raise documents request to the internal teams. Based on the responses, the relevant documents are added to their evaluation system. In a sense the appraisal teams have to be a bit smarter, however this has reduced the workload a lot.\n\nd) Readiness Review: The Readiness in terms of Infrastructure, access needs, artifact availability and others are checked in this activity. Normally a target of 80 to 90% is set by Lead Appraisers. There is a time limit of gap between Readiness Review and SCAMPI A appraisal is there. Similarly the Overall SCAMPI A cycle is to be completed within 90 days.\ne) Preparation for SCAMPI A: It’s very normal that Organizations give some level understanding to the FAR group members on how to approach an appraisal. This is in one way helps the Appraisal activity, as totally out of context talks don’t happen and better utilization of interview time. However giving training on what to talk or rehearsal on how to deliver can be avoided, as that’s not the intent of interview. The FAR group member should communicate the actual and appraisal team members, basically listen and notes down the facts given by them.\n\nf) SCAMPI A Onsite Activity: Ensure that Sponsor, FAR group members and support teams are available, apart from your ATM’s availability. Ensure that relevant logistics, infrastructure teams are available for the support. The onsite coordinator is responsible for ensuring all the relevant logistics available and right communication happens with organization. Participation in Opening meeting, Preliminary findings and final findings could be the three meetings the FAR group members to attend apart from their scheduled Interview.\n\nThe Appraisal Team collects the facts from oral affirmation (Interviews) and checks the Artifacts supporting the practices. Then the findings are documented. With that information the rating generation happens. Before they generate practices, goals, and PA and Organizational Level ratings the team presents the findings to the FAR group members and gets their views, where the FAR group members believe they have additional information which the ATM’s to look, that’s been submitted. The entire Appraisal Team activities are guided and managed by the Lead Appraiser, the lesser the disturbance given to them, more the efficiency will result. Finally the final findings are presented. It’s the sponsor who has to decide, whether he/she wants everyone to be present or not as audience for this presentation, as only he/she is the entitled one.\n\nAll the artifacts created in the process have to be distinguished and the copies which have to be retained are well managed by the Lead Appraisers and others are destroyed.\n\nThe Lead Appraiser submits the results in the CMMI Appraisal System. Normally the CMMI Institute team looks at the appraisal plan and the relevant details provided to them and verify it. In some cases, the appraisal might be taken for Audit by SCAMPI Quality team and they ask for further information on the appraisal process to the Lead appraiser. Once the data is validated by them the audit process is cleared then your results will be published in the CMMI Institute PARS site, in case if it’s not selected for audit, the results will be published as soon as in CMMI Institute PARS site. The sponsor is kept informed in all the happenings by the CMMI Institute along with the Lead Appraiser.\n\nOnce you get your results in CMMI PARS it’s time to go for celebration and be proud of the system you have created in your Organization!\nSustaining CMMI Implementation\n\nSustenance Phase in CMMI is assumed to be the normal life in organization. If you have implemented CMMI well, by this time that’s your normal process and way of working and you have nothing to do in addition. The only roles which may disappear soon after CMMI rating achievement is CMMI program manager and steering committee specifically set up to reach the target. The other things which you need to take care is,\n\n- Do not dilute your Process QA group and not to reduce the strength\n- Do not modify the SEPG\n- Improvements should be your next course of action\n- Improve the effectiveness of Audits\n- Make an yearly appraisal plan with SEPG for your processes\n- Keep conducting meetings with senior management from process point of view\n- Do necessary evaluation based on CMMI on any new additional services added in your QMS\n- Keep Evaluating your business needs\n- Ensure your policies kept up to date\n- Bring in an award and appreciation mechanism to project teams on better compliance\n- Perform QMS Gap Analysis on regular basis\n- Process QA group can concentrate on effectiveness of audits and facilitation\n- Your communication channels can be used for appreciation of good performance\n- Continue Monthly newsletters as informative and community networking tool\n- Important to address all the recommendations given in SCAMPI A\n\nCMMI High Maturity Implementation\n\nCMMI High Maturity denotes the Maturity level 4 and 5, considering Organization needs to put additional effort and improve their competency with people, process and technology to reach these levels. Also the organizations achieve capability to find and eliminate in effective\ntasks/components in processes and bring in effective and efficient replacement components to achieve Business results, and all of these with well informed and applied quantitative techniques.\n\nConsidering High Maturity Practices needs detailed understanding and relevant application of techniques, this book would deal the High maturity practices only at concept level. We would recommend attending CMMI Institute courses or taking the help of good SME/Consultant to have better understanding on this.\n\nWhat is High Maturity?\n\n- Setting business & project goals\n- Understand the past performance of standard and defined processes\n- Develop prediction models and estimate / predict future performance of standard and defined processes\n- Manage project (Project Defined Process) using past performance and future predictions\n- Take appropriate corrections (either at the beginning / at different phases) towards meeting goals\n- Bring continuous improvements / innovations into processes, tools and technology to meet business goals\n- Develop highest potential from people, tools and technology\n\nThe following are considered to be Important in high maturity implementation,\n\na) Timeline: Organizations has to be already there in CMMI Maturity Level 3 to reach High Maturity Levels. This is not a mandate, but practically when you operate with standard set of processes; it would be easier for you to go the next maturity level. Remember the Maturity level can’t be skipped, which means, even you go for rating or not, you must have applied all the relevant applicable processes till the level you are looking forward. Hence Maturity Level 3 is a good plateau from where you can improve your processes to next maturity level. Typically you should plan minimum of 2 year road map for your High Maturity. Its normal not only the community but even CMMI Institute will look at your Maturity with surprise if you achieve your high maturity within a year from your CMMI ML3. It’s practical to suspect, because the time required implementing the quantitative practice, getting data from them, improving based on them and meeting the business goals actually needs a logical time period of minimum 2 years. Data points are not a concern here, let the organization has as much as data point, but the stability cycle and improvement cycle needs time.\nb) People Competency: Definitely you may need to ensure that the people also have relevant competency to accept these high maturity processes and techniques. Typically we would expect the project managers to have competency not only in project management but also in relevant Quantitative and Statistical techniques. The Project managers shall be able to understand their data/results and apply relevant techniques and interpret them accordingly to take decisions. Similarly the Causal analysis and QC tools understanding are required. Sometime in Lower maturity levels, organizations can survive with project managers who really don’t understand the measures or has less authority to take project decision, but in High Maturity levels we believe the project managers is self sufficient in terms of interpreting and taking decisions of quantitative results. Similarly the metrics group shall be trained in statistical methods and Process QA Group should be aware of Process performance models and their application. The Process QA group normally assists the project managers, hence they should be aware of basic statistics to perform the job. Even the management team should have understanding on basic statistics.\n\nc) Tools: The High Maturity levels need better maturity in terms of tools also. Typically the data need for analysis purpose of various process is priority. Hence if you have a poor timesheet tool, scheduling tool, defect management tool, etc. you may face problem. We have to understand the base measures most of the time revolves around effort, time and defect. When we don’t have precise data on them but the system has pre exist bias reporting, then those will not help in High Maturity. Improve the tools to ensure that precise and accurate data can be collected. Improve the process where required to increase the accuracy. In addition to these you may need statistical analysis tool and modeling tools. There are so many different tools available in the market, some of them free, some we can make with macros, and some are available for cost. Statistical tools like Minitab, Sigma XL, JMP and others are widely used by organizations. Floating/concurrent licenses are one way to reduce your cost in tools. Similarly for simulation purpose some of them create Excel based macros and some use tool like crystal ball. Most of the tools mentioned here can help you Process Performance Modeling (Like regression model, simulation, and Design of Experiments and Reliability models) and there are special tools available for process modeling and discrete event simulation methods (Processmodel tool) and for dynamic modeling. You have to spend time and energy to decide which one will be the best one for your case.\n\nd) Process: The Process in the organization will undergo changes for betterment, not only new processes will be written, even the existing processes will be re evaluated for better clarity and ensure distinctive and accurate measures can be established with the process. If you already have project management process, you may be interested in looking at your estimation process and planning process in detail. To some extent\nwe are talking on sub process here, but more than that clarity is required in the tasks and most of them should be measurable. The new processes will be written to bring in the new process area practices to implementation. The new practices at high maturity level helps your engineering/services and support processes to stabilize and to improve their capability. Organizations can write these processes on their own or where required they can check with their consultant to write these processes. We would recommend writing on their own with understanding clarity established with their consultant.\n\ne) Consulting and Review Needs: You may need a SME or Consultant to help in you in few areas when it comes to High Maturity. A consultant is required for providing clarification on High Maturity practices, Process Capability Baseline preparation, process performance model preparation and Review on Causal Analysis activities. In addition to this you may need them to check the implementation of high maturity practices. Information required for high maturity is mostly available in CMMI Institute release presentations, and information like Business objectives fixing, QPM/QWM interpretations are mostly available. In addition CMMI Institute also conducts High Maturity Training, which is more useful in implementation.\n\nHigh Maturity Process Areas Quick Look:\n\nOrganizational process Performance (ML4):\n\nBefore we look in to the practices of this process area, it’s important for your organization to have clear business objectives and as far as possible, keep them SMART (Specific, Measurable, Attainable, Relevant and Time bound) objective.\n\nSample Business Objective:\n\nBy Jul 2014, Organization will improve Customer Satisfaction from today’s baseline of mean 7.2 and Standard Deviation 2.2 to a new baseline of mean 7.5 and Standard deviation 1.5 with 95% confidence without sacrificing Profit Margin.\n\nThe usage of Mean is based should be after confirming the data is having Normal Distribution, for non normal data follow Median.\n\nSP1.1 Establish and maintain the organization’s quantitative objectives for quality and Process performance, which are traceable to business objectives.\n\nBrief: The factors which are affecting the business objectives are identified. Their relationship with Business Objectives is verified with data. On Confirmation of the relationship, the Quality and Process performance objectives are defined. Quality objectives are given to emphasize the importance of quality parameters.\nIn this case for example Customer Satisfaction is there, which could be analyzed with multiple factors in the development a) Effort b) schedule c) Resource competency d) Defects e) first time right, etc on Services a) SLA compliance b) Resource Competency c) Back log index d) Change Request clearance index ,etc\n\nYou can use simple technique like correlation study and regression analysis to understand the relationship with Business objective. Based on the identified factor which influences the Business objective, defined the Quality and Process Performance Objective (QPPO).\n\nSample QPPO:\n\nBy end of 2013, Organization will reduce effort variance from mean 14.5 and S.D 2.5 to a new baseline of mean 11 and S.D 2.5 with 95% confidence without increasing Defect density\n\nBy end of 2013, Organization will improve SLA compliance from mean 92 and S.D 3 to a new baseline of mean 95 and S.D 2 with 95% confidence without increasing Defect density\n\nSP1.2: Select processes or sub processes in the organizations set of processes to be included in the organizations process performance analysis and maintain traceability to business objectives\n\nBrief: Identify the processes or sub process which are having direct relationship with QPPO and B.O and where required having the data based analysis will help. On the other hand when you have process performance models, which contains factors coming out of your processes and sub processes they will become the one which you may want to include in analysis.\n\nExample: Analysis, design, coding and testing processes directly contributes to Effort variance, on the other hand competency management process may have influence on the same (established in process performance model), and so you may include all of them in process capability baseline.\n\nSimilarly the incident management process by priority and service request process influence the SLA compliance. Also the sub process like analyze, develop, test and fix sub processes can also be influencing the SLA compliance in certain priority. Hence they also may be selected for analysis. Typically the process performance model or specific relationship models are established to prove the traceability in quantitative manner.\n\nSP1.3: Establish and Maintain definitions of Measures to be included in the Organizations process performance analysis\n\nBrief: The measures has to be clearly defined with units, collection period, clarity in source, role, analysis details, usage of QC tools for analysis, guideline on how to interpret and for Metrics the formula for calculation has to be defined. The scale usage for the measure help in determining the relevant statistical analysis tests to be performed.\nIn this case on Effort, we have analysis, design, coding, testing all these processes will have measure on Effort normalized with the unit size produced. The measure of effort and relevant details can be given in a common definition document.\n\nSimilarly the time taken for analyze, develop, test and fix sub processes will have measures like cycle time which might be the influencing factor in the process performance model for the QPPO identified.\n\nSP1.4: Analyze the performance of the selected processes, and establish and maintain the process performance baselines.\n\nBrief: Process Performance baselines are derived from project data. Process Performance analyzes are derived by analyzing the collected measures to establish a distribution and range results that characterize the expected performance for selected processes when used on any individual project in the organization.\n\nThe PPB helps in,\n\n- Establish and verify the reasonableness of organizational and Project objectives\n- Compose the project defined processes\n- Establish Trail limits\n- Identify potential sources of problems for Outcome Analysis\n- Identify opportunities for improvement\n- Evaluate the effect of changes after pilot or improvement\n\nPPB’s are based on data available on frequent enough rate and timely fashion, based on common measures defined in the organization, it contains time ordered data and non time ordered data, it addresses all Processes and sub processes measures selected, it can have stable process data and Non stable process data ( indicate them appropriately ). The PPB’s also contains the analysis of measures and corrective action details to be taken to improve the performance.\n\nThe following are typically the checks performed on Measures reported in PPB,\n\na) Check the data for accuracy and precision\nb) Performing Gauge R&R will help in ensuring data quality\nc) Box Plot and verify the data for variations\nd) Check the data for Normality\ne) Perform Stability check on data (western electric rule or 8 point check)\n\nf) Perform data outlier analysis\n\ng) Process capability can be determined Cp and Cpk\n\nh) Establish Graphical Distribution analysis – Mean, S.D, Quartiles, median, Control limits, others\n\ni) Hypothesis testing (where required to prove, change in central tendency or variation) – with parametric test (Normal distribution) and Non Parametric test (Non Normal distribution) are performed\n\nTypically, the PPB has all the relevant measures and compares it with previous PPB and indicates if there is any change in Central tendency and variation and trend details apart from the measures.\n\nIn addition to that establish trend analysis for the QPPO.\n\nThe following could be the contents in your PPB,\n\n1) Process Performance baseline overview\n a. Process Performance baseline objective\n b. Process Performance baseline scope\n\n2) Definition, Acronyms and Abbreviations\n\n3) List of Project Buckets\n\n4) Segmentation and Stratification\n\n5) List of Process and sub process measures\n\n6) Current Goals and Objectives\n\n7) Process performance baseline summary\n a. Change in projects\n b. Changes in Project Baseline and Goals\n\n8) Graphical Summary and Analysis for Each Measure\n\n9) Causal Analysis\n\n10) Recommendations\n11) Assumptions\n\n12) Annexure\n\nKey steps in Process Performance baseline preparation are,\n\n- Collect and analyze measurement data from projects\n- Establish and maintain Organizational process performance baseline from the collected measurement data, using the steps given above\n- Review and get agreement with all relevant stakeholders about the process performance baselines\n- Publish your process performance baselines to the members in organization\n- Compare the baselines and associated business objectives and plan for improvements\n- Revise the Process Performance baselines as necessary (new service lines, significant changes, process changes, improvements, etc)\n\nTypically a Central Metrics/Statistical Process control team involves in preparation of PPB and it gets discussed in SEPG and final approval comes from SEPG Head for release.\n\nTools like Minitab, sigma XL, MS Excel with Macros, JMP and others can be used for making the PPB. Some organizations use word format, some uses Excel and some uses web pages.\n\nSP1.5: Establish and Maintain process performance models for the organization’s set of standard processes.\n\nProcesses Performance Models (PPM) s is used to predict the value of a process performance measure from the values of other process and product/service measurements. PPM’s typically use process and product/service measurements collected throughout the lifecycle to estimate progress towards achieving objectives, which can’t be measured until later in lifecycle.\n\nThese models typically let us know the critical processes which are influencing the business objective significantly. The result of PPM is an interval (prediction interval) than a single point prediction (that’s why earned value analysis is not a PPM).\n\nThese ranges typically help us to understand the probability of achieving results at project level, when used in projects. Typically the PPMs are based on static data (past performance) and few PPMs are based on dynamic data (the relationship of model established with live data). Static models like multiple regression, dummy variable regression are popular in community and similarly reliability growth model is an example of dynamic model.\n\nHow PPM’s are used,\n• Establish and verify meeting of Business Objectives or Project Objectives, hence reasonability is verified\n\n• Determine the project progress to meet final objectives\n\n• Analyze, impact and predict the benefit of\n o Outcome analysis corrective actions\n o Action proposal for improvements\n o Innovations proposed\n o Corrective actions aimed at improving critical process\n\n• Evaluate the proposed change in terms of predictable results\n\nEssential Ingredients of Process Performance Model are,\n\n• Model should relate behavior of a process or sub process to an outcome (QPPO)\n\n• The Model should be able to predict outcomes based on possible changes to the factors (support what if analysis)\n\n• The model uses factors of sub process or process to conduct the prediction. When more of controllable factors are figuring in that, we have more chance of controlling the final outcome; however it can have uncontrollable factors also to represent the reality.\n\n• The models are statistical or probabilistic in nature, which accounts variation, rather than deterministic\n\n• It could be collection of models which predicts outcome of Interest\n\nFew Types of Modeling:\n\n• Statistical Models – Multiple Regression, Dummy variable Regression, logistic , Log Normal regression and many\n\n• Monte Carlo simulation models\n\n• Process Simulation – Using computerized simulation\n\n• Discrete Event Simulation\n\n• Discrete Event Simulation with Queuing theory\n- Reliability growth\n- Neural network and many more\n\nProcess Performance Models can be generated first with a good overall system flow and by clearly noting the processes which are contributing to it. Then identify the factors which influence each of these processes. With this understanding the relevant data can be collected and their relationship with the final outcome can be studied. If there is positive or negative relationship they can be noted down. Select those factors of processes which have significant relationship (many cases correlation co-efficient helps) and feed them in to the model which are designing. Construct the model and see whether the results show relevant relationship of factors with Outcome. Where required, change the factors combination and try again. The best possible relationship model together and every individual factor distinctively contribute to the prediction and not hindered by other factors, will create a good model. Where the model results are not statistically verifiable, then use the actual data and see the prediction results and compare the allowable prediction variation.\n\nIn our case, if we are looking forward to effort variance at project level then Analysis, design, coding and testing process effort (normalized with size) might have relationship, similarly the factors impacting the processes also might have relationship, example - Complexity of design, stability in requirements, coverage in testing, customer type, competency of Business Analyst, test case number and so on (there can be many). However you have to narrow down the factors, first by analyzing with your team and finding the causes using fishbone, and then collect data on them to verify. The factors we gave earlier some of them are controllable and some of them are non controllable (ex: Customer Type), however your model can have both. Also based on type of data (discrete or continuous) the modeling technique and tools can differ.\n\nAssume that we use regression model and it’s based on continuous data, you may do correlation analysis with each factor and Effort variance and then select the ones which has significance and add it to Multiple Regression Analysis (you may be using Minitab, Sigma XL, R, JMP or any tool) and might achieve a better relationship equation like\n\n\\[ \\text{Effort Variance (Y)} = 0.25 \\times \\text{Complexity of Design (X1)} + 0.51 \\times \\text{Req. Stability (X2)} – 1.2 \\times \\text{Coverage in Testing} \\]\n\nNormally we will go with R2 adjusted value (more than 80%) and then study the individual relationship with factors, then look at F statistic (or) P value which should be less than 0.05 (if 95% C.I) to prove that at least one of the factor influence the Outcome (Y). Not only this, you need to see the standard residual and other parameters before concluding.\n\nSimilarly, in a dynamic model like process modeling the model is constructed with process flow with each and every step (sub process) and decision loops. The data on these sub processes are collected and factor influencing them (like complexity, competency level, etc) are configured.\nand the model is run with simulation. The running length is typically the period like a day/ week or month which you are trying to check with outcome. Remember when you are feeding in the data, you feed the range based on actual distribution model of data of these factors. The final result is the predicted outcome. However in this model, the model can be validated only be checking a particular period actual data and check the deviation of predicted outcome and actual outcome. As long as the deviation is within the range (risk accepted by organization) the model can be used in organization.\n\nThe PPM’s are revised when, there is change in any process, when improvement actions performed, significant change in any of the process measure or factor.\n\nQuantitative Project/Work Management:\n\nSP1.1: Establish and Maintain projects’ quality and process performance objectives\n\nBrief: Consider the Organizations’ QPPO and Client given objectives, based on that derive the first level project objectives, Cross check the Process performance baseline in the organization and use the process performance model with trail values and see whether the Project objectives are achievable. Negotiate the project objectives if required.\n\nSample: Effort variance in the project should be lesser than 10% with 95% confidence level\n\nSLA compliance should be greater than 95% with 95% confidence level\n\nSP1.2: Using Statistical and other quantitative techniques, compose a defined process that enables the work to achieve its quality and process performance objectives\n\nBrief: Typically the process performance model which you use is having all the relevant process in the lifecycle connected. Also we believe the project objectives are predictable by one or more PPM you have developed (in combination). In such a case, the process performance model is run with relevant simulation with identified process/sub process and what if analysis are performed by varying the process values (by depth variation or adjustment in tasks), similarly the alternate processes have been checked with their values in the final prediction. The composition of process/sub process which gives lesser risk in the probability of achieving the expected project objectives (using PPM) is selected for further analysis and monitoring and those processes are formalized for execution in Project.\n\nTools like Crystal ball, JMP, Process Model and other simulation enabled tools can help in performing this practice and learn the probability level/certainty level with relevant process composition. Obviously we might want a probability of more than 95%, and otherwise we have to consider the risk and make a plan to mitigate or accept it.\n\nSP1.3: Select sub processes and attributes critical to evaluating performance and that help to achieve the quality and process performance objectives for the work.\nBrief: The Sub Processes which are critical to achieve the QPPO can be selected based on a) The major contributors and predictors to the achievement of the projects objectives b) The subset of the organizationally selected processes and sub-processes c) The processes and sub processes reflected in the organizational baselines and models d) Also the sub process provides sufficient data for monitoring and control.\n\nThe sub processes which are part of the PPM will be considered in addition to this, and basically we try to stabilize these processes or alter the performance level so that the project objectives can be achieved.\n\nIn our sample case, we will select the sub process like Analyze, design, design review, code review and others. Please note that design review or code review can be sub process. We would recommend following the terminology description given for “Sub process” in CMMI Model. Similarly in services where you are trying to achieve SLA compliance as objectives, Priority 1 sub process, Priority 2 sub process, priority 3 analyze sub process, priority 3 develop sub process, etc can be the sub process (Incident management is considered as process in this case). These sub processes in our case, we assume has significance in final outcome/project objectives, and the same can be proven with our performance models or statistical relationships (don’t’ miss out logical relationship).\n\nSP1.4: Select Measures and analytic techniques to be used in quantitative management\n\nEach critical sub processes and its related measures of interest is selected for quantitative management and similarly the analytic techniques are identified for those measures. The techniques like Scatter plots, control charts, run chart, Box plot, Pareto chart, histogram, Hypothesis test ( T test, ANOVA, Kruskal Wallis, Chi-square test, etc) are identified for the purpose.\n\nExample: Code Review sub process, we may measure productivity/effort per unit and IMR chart could be the analysis technique we may use. Similarly Priority 3 develop sub process (Incident Management) may have measure cycle time and IMR chart may be the analysis technique used.\n\nSP2.1: Monitor the performance of selected sub processes using statistical and other quantitative techniques\n\nThe selected sub process are monitored based on the pre identified frequency (it depends on the execution of sub process), where the sub process is executed on daily basis a monitoring on daily or weekly could be more meaningful. The importance is, to understand the behavior of sub process and control the special causes, and when there is shift in process based on planned changes be aware and monitor them for changes.\n\n Mostly control charts are used to monitor the stability of process (selection of control charts should be based on type of data) and any special cause is analyzed and corrective actions are\ntaken. In our case, when code review has taken more time in a particular case (out of range), then analyzes performed and corrective action applied. At the beginning trail limits from PPB might be taken, as more the data comes from the sub process the natural limits for the sub process is established.\n\nExample: Code review effort control limits are 0.75 to 1.5 hrs per unit code, in a special case, if the outlier goes beyond 1.5 hrs or lesser than 0.75 its analyzed for special cause. Similarly if any trend is seen in the data plots (perform 8 point stability check/western electric rule) then analysis performed and sub process is notified as instable.\n\nSP2.2: Manage the work using statistical and other quantitative techniques to determine whether or not the quality and process performance objectives for the work/project will be satisfied\n\nThe process performance model is used at the beginning of each identified phase/month/milestones or any identified frequency to understand the probability of achieving the project objective. When the predicted values are deviated much or certainty level is low, causal analysis can be triggered to address the factors. Similarly in the middle of lifecycle on all the relevant milestones or in intermediate points the PPM can be used to predict the Project objectives. Remember to manage all the project objectives and in case of prioritization of project objectives, you can manage them using relevant PPM, however it’s important to verify no other project objectives are compromised.\n\nIn the case where we have taken Effort variance, at the beginning of every phase the PPM can be run with the actual data available till that phase and further phases with variation and simulation can be done to predict the values. Similarly in case of SLA compliance, beginning of the month and middle of the month the PPM can be run with the actual values of the attributes of the process.\n\nWhere the project objectives are not going to meet, apply corrective actions and bring in causal analysis as required.\n\nSP2.3: Perform root cause analysis of selected issues to address deficiencies in achieving the work group’s /projects quality process performance objectives\n\nThe causal analyses are triggered whenever there is potential issue that project objectives are not met or reactively looking at the actual on QPPO. The root causes are identified normally using fishbone diagram or other technique and the corrective actions are identified. The actions are tracked to closure, where required cost benefit analysis can be performed.\n\nThe change in performance is monitored and where required PPM is used to predict the Project objectives.\n\nIn the case of effort variance, where consistently the code reviews have taken higher effort and/or the PPM is predicting high Effort variance, root cause analysis can be performed and\nrelevant root cause identified, eliminated with corrective action, then the PPM can be re run with the new values of the factor. Similarly when we understand that SLA compliance is predicted to be on lower range for that period, root cause analysis can be triggered and corrective actions can be taken.\n\nCausal Analysis and Resolution (ML5):\n\nSP1.1 Select Outcome for Analysis:\n\nOutcome here refers to any value of our interest in project level. Typically the project objectives which we want to attain can be Outcomes for analysis, however it doesn’t limit only to them. Considering this is supportive process area the intent is to apply to any outcome.\n\nPPB and PPM’s can be useful in identifying the outcomes which can be considered for analysis. Consider the impact of the outcome, frequency of happening, cost of the analysis, ROI and time it will take, while selecting the outcome for analysis.\n\nIn our case, you can take effort variance which will not meet as per the prediction and SLA for a month which will not meet can be taken for analysis.\n\nSP1.2: Perform Causal Analysis of selected outcomes and propose actions to address them\n\nOrganizations sometime have special teams to coordinate the causal analysis activities at organizational level and at project level. This is purely depends on the need of the context and the kind of outcomes the organization has to address and how the organizational structure is, people availability, etc. Typically a good analysis of data and simple techniques like Pareto chart and fish bone diagram application can help in identifying the qualitative root causes. With adequate data the causes can be identified and corrective actions can be taken.\n\nSP2.1: Implement selected action proposals developed in causal analysis\n\nThe action proposal coming out of causal analysis can be evaluated with ROI, PPM usage to see if the action items are useful to apply and bring improvement in the outcome. Application of PPM and cost benefit analysis would help in getting the better action proposals.\n\nSP2.2: Evaluate the effect of Implemented actions on Process Performance\n\nAs the corrective actions are identified, they are tracked to closure. Their effect on the process performance shall be checked using quantitative and/or statistical techniques. Application of hypothesis testing on the results of outcome before and after change helps to confirm the effect of implemented action. The other techniques used are box plot and control charts; they help us to understand the significant changes in the process or Project objectives.\n\nIn the case of effort variance, an action taken to implement automated code review tool, how much it has changed the process performance of code review can be checked with box plot and\nstability understanding with control chart. Also the Hypothesis testing of before and after data will help in proving that they both are not same. Similarly reducing the time of analysis process of incident management by having knowledge data base could be the solution and its effect can be checked with relevant techniques.\n\nSP2.3: Record Causal analysis and resolution data for use across work groups and the organization\n\nEnsuring the actions are applied and the records are stored for use for others and availability of the solution across work groups (projects) helps in improving the system.\n\nIn this case the automated code review tool implementation across organization or implementing a Knowledge data base across Organization, which are solutions identified from causal analysis can be deployed with use of SEPG.\n\nOrganization Performance Management (ML5)\n\nSP1.1: Maintain business objectives based on an understanding of business strategies and actual performance results\n\nBrief: The organizational business objectives are established in SMART format already. Here we are trying to maintain the business objectives using any change in business strategies (new business line, change in service, etc) and looking at how good we are progressing on actual performance in terms of business objective. Trend Analysis of business objectives will provide details on how good we are progressing towards meeting business objectives. Similarly look at the QPPO’s and compare the actual and revise them as necessary.\n\nA revision of Business and/ or QPPO with relevant data or comparison of targeted objectives with actual values/ trend would help in this.\n\nSP1.2: Analyze Process performance data to determine the Organization’s ability to meet identified business objectives\n\nBrief: Considering that we are developing process performance baselines on periodically, the process performance data coming out these PPB’s can be used to determine, whether the business objectives will be achieved. The QPPOs are compared with the current PPB to evaluate whether the B.O can be achieved. Wherever there is risk of not meeting the objectives that can be documented and improvements can be planned.\n\nIn our case, when we understand that we have code review effort operating at some level, which leads to certain range of Effort variance (using PPM) and for that range the customer satisfaction range can be predicted. Similarly the SLA compliance level is lower (in current PPB) than the targeted one, this could be further analyzed for the risks.\nSP1.3: Identify potential areas for improvement that could contribute to meeting business objectives\n\nBrief: The potential areas for improvement can be identified using, shortfalls in not meeting the process objectives or process capability issues. These could be the indicators that a particular area needs improvement. In addition Causal Analysis technique can help us to determine them.\n\nThese potential areas can be evaluated for cost benefit and can be taken for further evaluation and prioritization.\n\nIn the case we have taken, If the design process is taking higher effort or injecting more defects, then it could be a potential area to look at (with data, do analysis including Pareto and fishbone, check variation, predict the impact) and improve. Perform cost benefit analysis, by understanding to what extent actually it would improve the QPPO and by that Business Objective. The same way, the Test process in P3 incident ticket if it’s a concern that it takes more time (less resource /more volume/improper code completion information/poor quality code), thereby increases queue. This could be a potential area for improvement, again use the relevant tools to diagnose it.\n\nSP2.1: Elicit and Categorize suggested Improvement\n\nBrief: Elicit the improvements in an area through various sources (Improvement log, Technical portals, contests, process appraisal, client feedback, others) and analyze them for their expected benefit. Categorize the improvements as Innovative (expected to make shift in performance or reduce the variation to good extent) or Incremental Improvements (gradual improvement in performance).\n\nInvestigate whether these improvements will make changes in processes and technologies.\n\nSP2.2: Analyze suggested improvements for their possible impact on achieving the organization’s quality and process performance objectives\n\nBrief: Analyze the improvements using cost benefit method and see whether they can be really effective. Check how to validate the improvement before deploying them throughout.\n\nIn our case, if we try to bring in a Design Architecture validation tool, which can reduce poor designing. Then we would like to evaluate, will this really work and what could be the cost and benefit of this.\n\nSP2.3: Validate Selected Improvements\n\nBrief: Where required plan for piloting and have a validation method. The validation method should be based on the actual values the improvement could achieve. Perform hypothesis testing as required to see, if the improvement has made effect in the final outcome.\nIn our case, if we have implemented the Design architecture tool in selected projects and have seen improvement in terms of better design quality and less design review effort that can be checked with hypothesis testing. The same way, assume that we have implemented test automation tool for P3 priority incidents and has automated test scripts to test similar incidents, then the results improvement achieved with this implementation can be validated with hypothesis test.\n\nSP2.4: Select and Implement improvements for deployment throughout the organization based on an evaluation of costs, benefits and other factors\n\nBrief: Once we decide with validation, that a particular improvement will help in achieving the objectives, and then it’s evaluated with costs, benefits and deploy ability (need in different units, resources, method, technology, communication, etc). If the evaluation results are good, then the improvement is selected for deployment in the organization. Remember we do the evaluation at the beginning on improvement area and to consider a improvement for implementation and validation. Not all the validated improvements may go for deployment, because the condition could differ. Hence again we do cost benefit analysis here.\n\nSP3.1: Establish and maintain plans for deploying selected improvements\n\nBrief: We make deployment plan to ensure all the relevant projects/work units can deploy the improvement. Deployment plan includes training plan, schedule, strategy of implementation, effort required, QMS release/process updates, Resource required, effectiveness checking, etc. The deployment plan made at the beginnings shall be kept up to date, based on the feedback or status. The schedule might undergo changes based on the kind of issues/barriers faced in deployment or support required. Hence maintain the deployment plan.\n\nSP3.2: Manage deployment of selected improvements\n\nBrief: The deployment is supported with resources and the plan is executed. During the course of deployment the trainings are executed, processes released, projects are added to the umbrella and many more. Hence effective tracking and corrective actions are required. At the end of deployment its expected as per the original plan (revised) you were able to deploy the improvements and records are available\n\nSP3.3: Evaluate the effects of deployed Improvements on Quality and Process Performance using statistical and other quantitative techniques\n\nBrief: As the deployment happens, the PPM can be used to predict the QPPO meeting target. As the deployment is complete, we could use techniques like hypothesis testing to validate if there is any change (ex: compare the previous and current PPB values) and also we can use PPM to see the probability of meeting QPPOs.\nAgile with CMMI mapping:\n\nThe following table contains mapping for CMMI when we execute agile projects. These are again typical artifacts and would vary from organization to organization. We would request you to evaluate accordingly.\n\n<table>\n<thead>\n<tr>\n<th>Process Area - Specific Goals & Specific Practices</th>\n<th>Agile Scrum</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Requirements Management</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Manage Requirements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Understand Requirements</td>\n<td>Product backlog</td>\n</tr>\n<tr>\n<td>SP 1.2 Obtain Commitment to Requirements</td>\n<td>Release planning meeting &MOM can be captured</td>\n</tr>\n<tr>\n<td>SP 1.3 Manage Requirements Changes</td>\n<td>change in product back log & CR for scope change</td>\n</tr>\n<tr>\n<td>SP 1.4 Maintain Bidirectional Traceability of Requirements</td>\n<td>product backlog ,a) Usage of Test& Review tool b) Add additional Sheet/column with Mapping to other Phases</td>\n</tr>\n<tr>\n<td>SP 1.5 Ensure Alignment between Project Work and Requirements</td>\n<td>update in Release plan/Release backlog, etc</td>\n</tr>\n<tr>\n<td>Requirements Development</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Develop Customer Requirements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Elicit Needs</td>\n<td>User stories</td>\n</tr>\n<tr>\n<td>SP 1.2 Transform Stakeholder needs into Customer Requirements</td>\n<td>Business Requirements Document/user stories</td>\n</tr>\n<tr>\n<td>SG 2 Develop Product Requirements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Establish Product and Product-Component Requirements</td>\n<td>Software Requirements Specification/user stories categorized by module</td>\n</tr>\n<tr>\n<td>SP 2.2 Allocate Product-Component Requirements</td>\n<td>Software Requirements Specification/user stories categorized by module</td>\n</tr>\n<tr>\n<td>SP 2.3 Identify Interface Requirements</td>\n<td>User Stories related to Interface Requirements</td>\n</tr>\n<tr>\n<td>SG 3 Analyze and Validate Requirements</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Establish Operational Concepts and Scenarios</td>\n<td>Use cases</td>\n</tr>\n<tr>\n<td>SP 3.2 Establish a Definition of Required Functionality and Quality Attributes</td>\n<td>Use cases</td>\n</tr>\n<tr>\n<td>SP 3.3 Analyze Requirements</td>\n<td>Use case review/Use Case prioritization</td>\n</tr>\n<tr>\n<td>SP 3.4 Analyze Requirements to Achieve Balance</td>\n<td>Use Case prioritization</td>\n</tr>\n<tr>\n<td>SP 3.5 Validate Requirements</td>\n<td>product backlog</td>\n</tr>\n</tbody>\n</table>\n\nTechnical Solution\n\nSG 1 Select Product-Component Solutions\n<table>\n<thead>\n<tr>\n<th>SP 1.1 Develop Alternative Solutions and Selection Criteria</th>\n<th>Minute of Architecture discussion/consolidated chits/Alternative solutions/evaluation report/selection criteria</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SP 1.2 Select Product-Component Solutions</td>\n<td>Minute of Architecture discussion/consolidated chits/Alternative solutions/evaluation report/selection criteria</td>\n</tr>\n<tr>\n<td>SG 2 Develop the Design</td>\n<td>Product Architecture/Architecture drawn in the board-photo copies/Consolidated chits/Minutes of Meeting on architecture discussion</td>\n</tr>\n<tr>\n<td>SP 2.1 Design the Product or Product Component</td>\n<td>Use case, architecture documents, Unit tests</td>\n</tr>\n<tr>\n<td>SP 2.2 Establish a Technical Data Package</td>\n<td>Use case on Interfaces/architecture</td>\n</tr>\n<tr>\n<td>SP 2.3 Design Interfaces Using Criteria</td>\n<td>Minutes of design discussion/consolidated chits/evaluation/solutions bought to integrate</td>\n</tr>\n<tr>\n<td>SG 3 Implement the Product Design</td>\n<td>Source code</td>\n</tr>\n<tr>\n<td>SP 3.1 Implement the Design</td>\n<td>user manual/product manual</td>\n</tr>\n<tr>\n<td>SP 3.2 Develop Product Support Documentation</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Prepare for Product Integration</td>\n<td>Plan for System/integration test to expand the strategy</td>\n</tr>\n<tr>\n<td>SP 1.1 Establish and Integration Strategy</td>\n<td>Build environment/Continuous integration details</td>\n</tr>\n<tr>\n<td>SP 1.2 Establish the Product Integration Environment</td>\n<td>Build steps in wiki/notes</td>\n</tr>\n<tr>\n<td>SP 1.3 Establish Product Integration Procedures and Criteria</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 2 Ensure Interface Compatibility</td>\n<td>Integration test/Continuous build</td>\n</tr>\n<tr>\n<td>SP 2.1 Review Interface Descriptions for Completeness</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.2 Manage Interfaces</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 3.1 Confirm Readiness of Product Components for Integration</td>\n<td>Unit test/Continuous build</td>\n</tr>\n<tr>\n<td>SP 3.2 Assemble Product Components</td>\n<td>Continuous build/Build</td>\n</tr>\n<tr>\n<td>SP 3.3 Evaluate Assembled Product Components</td>\n<td>Sprint demo</td>\n</tr>\n<tr>\n<td>SP 3.4 Package and Deliver the Product or Product Component</td>\n<td>Release Details</td>\n</tr>\n<tr>\n<td>SG 3 Assemble Product Components and Deliver the Product</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Select Work Products for Verification</td>\n<td>Definition of Done details/User stories tasks</td>\n</tr>\n<tr>\n<td>SP 1.2 Establish the Verification Environment</td>\n<td>Code standards/XP method/checkpoints/tools</td>\n</tr>\n<tr>\n<td>SP 1.3 Establish Verification Procedures and Criteria</td>\n<td>Code standards/XP method/checkpoints & Definition of Done</td>\n</tr>\n<tr>\n<td>SG 2 Perform Peer Reviews</td>\n<td>SP 2.1 Prepare for Peer Reviews</td>\n</tr>\n<tr>\n<td>---------------------------</td>\n<td>--------------------------------</td>\n</tr>\n<tr>\n<td>SP 2.2 Conduct Peer Reviews</td>\n<td>Automated code review reports/Pair Programming correction in code/Refactoring</td>\n</tr>\n<tr>\n<td>SP 2.3 Analyze Peer Review Data</td>\n<td>Corrected code /automated code test re-run report/Refactoring</td>\n</tr>\n<tr>\n<td>SG 3 Verify Selected Work Products</td>\n<td>SP 3.1 Perform Verification</td>\n</tr>\n<tr>\n<td>SP 3.2 Analyze Verification Results and Identify Corrective Action</td>\n<td>Defect Analysis activity to be made in addition to understand and prevent the Defects</td>\n</tr>\n<tr>\n<td>SG 1 Prepare for Validation</td>\n<td>SP 1.1 Select Products for Validation</td>\n</tr>\n<tr>\n<td>SP 1.2 Establish the Validation Environment</td>\n<td>Test Environment set up</td>\n</tr>\n<tr>\n<td>SP 1.3 Establish Validation Procedures and Criteria</td>\n<td>Test cases/Definition of Done</td>\n</tr>\n<tr>\n<td>SG 2 Validate Product or Product Components</td>\n<td>SP 2.1 Perform Validation</td>\n</tr>\n<tr>\n<td>SP 2.2 Analyze Validation Results</td>\n<td>Defect Analysis activity to be made in addition to understand and prevent the Defects</td>\n</tr>\n<tr>\n<td>Project Planning</td>\n<td>SG 1 Establish Estimates</td>\n</tr>\n<tr>\n<td>SP 1.1 Estimate the Scope of the Project</td>\n<td>User story sizing (story point, fibinnoci series, etc)</td>\n</tr>\n<tr>\n<td>SP 1.2 Establish Estimates of Work Product and Task Attributes</td>\n<td>Sprint cycles and release cycles</td>\n</tr>\n<tr>\n<td>SP 1.3 Define Project Life Cycle</td>\n<td>User story sizing (story point, fibinnoci series, etc)</td>\n</tr>\n<tr>\n<td>SP 1.4 Determine Estimates of Effort and Cost</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 2 Develop a Project Plan</td>\n<td>SP 2.1 Establish the Budget and Schedule</td>\n</tr>\n<tr>\n<td>SP 2.2 Identify Project Risks</td>\n<td>MOM of stand up meeting and Risk Log at product level proposed</td>\n</tr>\n<tr>\n<td>SP 2.3 Plan for Data Management</td>\n<td>Project plan/charter to be prepared</td>\n</tr>\n<tr>\n<td>SP 2.4 Plan for Project Resources</td>\n<td>Capacity planning</td>\n</tr>\n<tr>\n<td>SP 2.5 Plan for Needed Knowledge and Skills</td>\n<td>Scrum team guidelines & Skill identification</td>\n</tr>\n<tr>\n<td>SP 2.6 Plan Stakeholder Involvement</td>\n<td>Scrum team guidelines & Project charter/Meeting details</td>\n</tr>\n<tr>\n<td>SP 2.7 Establish the Project Plan</td>\n<td>Project plan/charter to be prepared</td>\n</tr>\n<tr>\n<td>SG 3 Obtain Commitment to the Plan</td>\n<td>SP 3.1 Review Plans that Affect the Project</td>\n</tr>\n<tr>\n<td>SP 3.2 Reconcile Work and Resource Levels</td>\n<td>Revised Plan/charter</td>\n</tr>\n<tr>\n<td>SP 3.3 Obtain Plan Commitment</td>\n<td>Revised Plan/charter</td>\n</tr>\n<tr>\n<td>-------------------------------</td>\n<td>----------------------</td>\n</tr>\n<tr>\n<td><strong>Project Monitoring and Control</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Monitor Project Against Plan</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.1 Monitor Project Planning Parameters</strong></td>\n<td>Velocity, Burn down charts, defects etc</td>\n</tr>\n<tr>\n<td><strong>SP 1.2 Monitor Commitments</strong></td>\n<td>Stand up Meeting, Running minutes of meeting/photos/snapshot/tool</td>\n</tr>\n<tr>\n<td><strong>SP 1.3 Monitor Project Risks</strong></td>\n<td>Stand up Meeting, Sprint planning & Risk log at release plan/product level, Running minutes of meeting/photos/snapshot/tool</td>\n</tr>\n<tr>\n<td><strong>SP 1.4 Monitor Data Management</strong></td>\n<td>Stand up Meeting, Running minutes of meeting/photos/snapshot/tool</td>\n</tr>\n<tr>\n<td><strong>SP 1.5 Monitor Stakeholder Involvement</strong></td>\n<td>Stand Up Meeting, Sprint Retrospective, sprint demo</td>\n</tr>\n<tr>\n<td><strong>SP 1.6 Conduct Progress Reviews</strong></td>\n<td>Stand up Meeting/sprint retrospective</td>\n</tr>\n<tr>\n<td><strong>SP 1.7 Conduct Milestone Reviews</strong></td>\n<td>Sprint retrospective/Steering Committee meeting, Use of wiki page/notes to capture MOM</td>\n</tr>\n<tr>\n<td><strong>SG 2 Manage Corrective Action to Closure</strong></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.1 Analyze Issues</strong></td>\n<td>Stand Up Meeting, Sprint Retrospective & Issue log at Product/release level, Running minutes of meeting/photos/snapshot/tool (distributed teams)</td>\n</tr>\n<tr>\n<td><strong>SP 2.2 Take Corrective Action</strong></td>\n<td>Stand up Meeting, Running minutes of meeting/photos/snapshot/tool (distributed teams)</td>\n</tr>\n<tr>\n<td><strong>SP 2.3 Manage Corrective Action</strong></td>\n<td>Stand up Meeting, Running minutes of meeting/photos/snapshot/tool (distributed teams)</td>\n</tr>\n<tr>\n<td><strong>Risk Management</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Prepare for Risk Management</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 1.1 Determine Risk Sources and Categories</strong></td>\n<td>To have broad classification of Risk (technical/process/environment, etc)</td>\n</tr>\n<tr>\n<td><strong>SP 1.2 Define Risk Parameters</strong></td>\n<td>Qualify risk with parameters at least by high/medium/low and use Product level/Release level Risk log & use in standup MOM</td>\n</tr>\n<tr>\n<td><strong>SP 1.3 Establish a Risk Management Strategy</strong></td>\n<td>Have a "Agile Guideline" document and update it</td>\n</tr>\n<tr>\n<td><strong>SG 2 Identify and Analyze Risks</strong></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 2.1 Identify Risks</strong></td>\n<td>Stand up meeting/sprint planning & release planning, Qualify risk with parameters at least by high/medium/low and use Product level/Release level Risk log & use in standup MOM</td>\n</tr>\n<tr>\n<td><strong>SP 2.2 Evaluate Risks</strong></td>\n<td>Stand up meeting/sprint planning & release planning, Qualify risk with parameters at least by high/medium/low and use Product level/Release level Risk log & use in standup MOM</td>\n</tr>\n<tr>\n<td><strong>SG 3 Mitigate Risks</strong></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>SP 3.1 Develop Risk Mitigation Plans</strong></td>\n<td>Stand up meeting/sprint planning & release planning, Qualify risk with parameters at least by high/medium/low and use Product level/Release level Risk log & use in standup MOM</td>\n</tr>\n<tr>\n<td>SG 3 Establish Integrity</td>\n<td>SP 3.1 Establish Configuration Management Records</td>\n</tr>\n<tr>\n<td>-------------------------</td>\n<td>--------------------------------------------------</td>\n</tr>\n<tr>\n<td>SP 3.2 Perform Configuration Audits</td>\n<td>Continuous integration reports, Sprint demo, release checks</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Measurement and Analysis</th>\n<th>SG 1 Align Measurement and Analysis Activities</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SP 1.1 Establish Measurement Objectives</td>\n<td>Velocity, defect, etc</td>\n</tr>\n<tr>\n<td>SP 1.2 Specify Measures</td>\n<td>Velocity, defect, etc</td>\n</tr>\n<tr>\n<td>SP 1.3 Specify Data Collection and Storage Proc</td>\n<td>Scrum tracking sheet can have guidance</td>\n</tr>\n<tr>\n<td>SP 1.4 Specify Analysis Procedures</td>\n<td>Burn down chart, velocity chart, etc</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Process and Product Quality Assurance</th>\n<th>SG 1 Objectively Evaluate Processes and Work Products</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SP 1.1 Objectively Evaluate Processes</td>\n<td>SQA Audit on process shall be conducted. Any trained person can do the audit (SQA can be part of the team)</td>\n</tr>\n<tr>\n<td>SP 1.2 Objectively Evaluate Work Products and Services</td>\n<td>Work products reviewed for Process by any trained person. (SQA can be part of the team)</td>\n</tr>\n<tr>\n<td>SG 2 Provide Objective Insight</td>\n<td>Non compliance closure Report</td>\n</tr>\n<tr>\n<td>SP 2.1 Communicate and Ensure Resolution of NC Issues</td>\n<td>Non compliance closure Report</td>\n</tr>\n<tr>\n<td>SP 2.2 Establish Records</td>\n<td>Non compliance closure Report</td>\n</tr>\n<tr>\n<td>Integrated Project Management</td>\n<td></td>\n</tr>\n<tr>\n<td>-----------------------------------------------</td>\n<td>--------------------------------------------------</td>\n</tr>\n<tr>\n<td>SG 1 Use the Project’s Defined Process</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Establish the Project’s Defined Process</td>\n<td>tailoring checklist/document (of organization process with project context)</td>\n</tr>\n<tr>\n<td>SP 1.2 Use Organizational Process Assets for Planning Project Activities</td>\n<td>Use of repository on defects/risks, etc</td>\n</tr>\n<tr>\n<td>SP 1.3 Establish Project’s work Environment</td>\n<td>Project plan to have environment details</td>\n</tr>\n<tr>\n<td>SP 1.4 Integrate Plans</td>\n<td>Consolidate the Project plan, delivery schedule , product back log ,sprint backlog ,etc</td>\n</tr>\n<tr>\n<td>SP 1.5 Manage the Project Using the Integrated Plans</td>\n<td>Sprint planning, stand up Meeting</td>\n</tr>\n<tr>\n<td>SP 1.6 Establish Teams</td>\n<td>Scrum roles</td>\n</tr>\n<tr>\n<td>SP 1.7 Contribute to the Organizational Process Assets</td>\n<td>Sprint retrospective, MOM/wiki pages/notes -> to improve SCRUM application</td>\n</tr>\n<tr>\n<td>SG 2 Coordinate and Collaborate with Relevant Stakeholders</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Manage Stakeholder Involvement</td>\n<td>Steering committee, stand up meeting</td>\n</tr>\n<tr>\n<td>SP 2.2 Manage Dependencies</td>\n<td>Steering committee, stand up meeting</td>\n</tr>\n<tr>\n<td>SP 2.3 Resolve Coordination Issues</td>\n<td>Steering committee, stand up meeting</td>\n</tr>\n<tr>\n<td>Organizational Training</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Establish an Organizational Training Capability</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.1 Establish the Strategic Training Needs</td>\n<td>Linked training needs with business objectives (mostly annual Training plan /strategy document)</td>\n</tr>\n<tr>\n<td>SP 1.2 Determine Which Training Needs Are the Responsibility of the Organization</td>\n<td>Project level & Org level training - listed (in plan)</td>\n</tr>\n<tr>\n<td>SP 1.3 Establish an Organizational Training Tactical Plan</td>\n<td>Training delivery schedule, etc</td>\n</tr>\n<tr>\n<td>SP 1.4 Establish Training Capability</td>\n<td>Training environment, trainer details documented</td>\n</tr>\n<tr>\n<td>SG 2 Provide Necessary Training</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Deliver Training</td>\n<td>Training delivery record (Invite/material/feedback/attendance)</td>\n</tr>\n<tr>\n<td>SP 2.2 Establish Training Records</td>\n<td>Training delivery record (Invite/material/feedback)</td>\n</tr>\n<tr>\n<td>SP 2.3 Assess Training Effectiveness</td>\n<td>Training feedback evaluation/360 feedback/performance check, etc</td>\n</tr>\n<tr>\n<td>Organizational Process Focus</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Determine Process-Improvement Opportunities</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 1.2 Appraise the Organization’s Processes</td>\n<td>Audit/appraise/review organization process</td>\n</tr>\n<tr>\n<td>SP 1.3 Identify the Organization's Process Improvements</td>\n<td>Improvement log (based on appraisals and from projects)</td>\n</tr>\n<tr>\n<td>SG 2 Plan and Implement Process Actions</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Establish Process Action Plans</td>\n<td>Improvement Log (with CR/improvement and action plan)</td>\n</tr>\n<tr>\n<td>SP 2.2 Implement Process Action Plans</td>\n<td>Improvement Log status(with CR/improvement and action plan)</td>\n</tr>\n<tr>\n<td>SG 3 Deploy Organizational Process Assets and Incorporate experiences</td>\n<td></td>\n</tr>\n<tr>\n<td>SP 2.1 Deploy Organizational Process Assets</td>\n<td>Deployment plan with status</td>\n</tr>\n<tr>\n<td>SP 2.2 Deploy standard processes</td>\n<td>Deployment plan with status</td>\n</tr>\n<tr>\n<td>SP 2.3 Monitor the Implementation</td>\n<td>Deployment plan with status</td>\n</tr>\n<tr>\n<td>SP 2.4 Incorporate Experiences into the Organizational Process Assets</td>\n<td>Updated Repositories (Estimation/risk/defects/samples, etc)</td>\n</tr>\n<tr>\n<td>Organizational Process Definition</td>\n<td></td>\n</tr>\n<tr>\n<td>SG 1 Establish Organizational Process Assets</td>\n<td>Same as CMMI as they are Org. level practices</td>\n</tr>\n<tr>\n<td>SP 1.1 Establish Standard Processes</td>\n<td>Documented process Definitions</td>\n</tr>\n<tr>\n<td>SP 1.2 Establish Life-Cycle Model Descriptions</td>\n<td>SCRUM guideline</td>\n</tr>\n<tr>\n<td>SP 1.3 Establish Tailoring Criteria and Guidelines</td>\n<td>Tailoring Guideline (mostly by process) and Criteria (Co-located/distributed teams, etc)</td>\n</tr>\n<tr>\n<td>SP 1.4 Establish the Organization’s Measurement Repository</td>\n<td>Metrics repository</td>\n</tr>\n<tr>\n<td>SP 1.5 Establish the Organization’s Process Asset Library</td>\n<td>Repositories (Estimation/risk/defects/samples, etc)</td>\n</tr>\n<tr>\n<td>SP 1.6 Establish work Environment Standards</td>\n<td>Work Environment details (mostly in Quality manual)</td>\n</tr>\n<tr>\n<td>SP 1.7 Establish rules and guidelines for teams</td>\n<td>Teaming norms (mostly in Quality manual)</td>\n</tr>\n</tbody>\n</table>\n\n**Decision Analysis and Resolution**\n\n| SG 1 Evaluate Alternatives | | |\n| SP 1.1 Establish Guidelines for Decision Analysis | Guideline (when to use, criteria, responsible, etc) | |\n| SP 1.2 Establish Evaluation Criteria | Criteria to evaluate decision (it will vary based on the context) | |\n| SP 1.3 Identify Alternative Solutions | Document alternate solution (separate DAR sheet used in many org.) | |\n| SP 1.4 Select Evaluation Methods | Evaluation techniques (Pugh matrix, cost benefit, weighted average, etc) (DAR sheet to have the method) | |\n| SP 1.5 Evaluate Alternatives | Valuation of each alternative solution (DAR sheet) | |\n| SP 1.6 Select Solutions | Final Solution (DAR sheet) | |\n\n**Alternate Practices:**\n\nIn CMMI Model the goals are required component and practices are only expected components. However considering the practices are based on the Industry experience to great extent they are\napplicable in most of the context. Also they are neither tasks nor redundant practices, they are exclusive in nature. The practices can be interpreted for any context accordingly and in most of the context they are applicable. However very rarely organizations may have a context in which the Specific Goal is applicable however the practices are not really applicable. In that case, the organizations can document the alternate practices which they follow. The same can be shared with CMMI Institute.\n\nA Sample case, when an organization’s project is working using a complete lifecycle management tool with integrated resource planning software, in such case the Configuration Management Specific Goal 3 Establish Integrity, is met actually with existing environment which has all the configurable items in an well managed automated life cycle management tool (which include project plan, schedule, code, etc) and the tool also manages the versioning and without relevant information the tool doesn’t allow you to save your work (such rules are part of the tool). In that case the Specific practice 3.1 and 3.2 may not be implemented but the Specific Goal is satisfied with the integrated life cycle tool environment and working within the tool. You can write the relevant practice and document as part of CMMI mapping with QMS and share with Appraisal team for evaluation. Again the case which we have taken here is for sample purpose and it can be interpreted and argued with more information.\n\nReferences\nWebsites:\n- www.cmmiinstitute.com\n- seir.sei.cmu.edu\n- sei.cmu.edu\n\nArticles, Whitepaper and Documents\n- CMMI Model v1.3 Dev (TR)\n- CMMI Model v1.3 Svc\n- A Jumpstart Method for Business Goals and Project Objectives Supporting CMMI High Maturity - By Robert W. Stoddard\n- High Maturity! How do we Know? – By Mike Konrad\n- SCAMPI v1.3\n- A Mini-Tutorial for Building CMMI Process Performance Models - Robert Stoddard, Kevin Schaaff, Rusty Young, and Dave Zubrow\n• CMMI or Agile: why not embrace both! – Jeff Dalton, Hillel Glazer, David Anderson\n Michael D.Konrad and Sandra shrum"}}},{"rowIdx":262,"cells":{"id":{"kind":"string","value":"1b799c8c42f47ed5dc2f350c41a16e8b5b08b965"},"text":{"kind":"string","value":"Dietrich Boles, Daniel Jasper\n\nHamster-Simulator\n\nVersion 2.9.6\n\nBenutzungshandbuch\n\n22.12.2017\n4 Bedienung des Hamster-Simulators ................................................................. 31\n 4.1 Grundfunktionen ....................................................................................... 32\n 4.1.1 Anklicken ......................................................................................... 32\n 4.1.2 Tooltipps .......................................................................................... 33\n 4.1.3 Button .............................................................................................. 33\n 4.1.4 Menü ................................................................................................. 33\n 4.1.5 Toolbar .............................................................................................. 34\n 4.1.6 Popup-Menü ....................................................................................... 34\n 4.1.7 Eingabefeld ....................................................................................... 35\n 4.1.8 Dialogbox ........................................................................................... 35\n 4.1.9 Dateiauswahl-Dialogbox ................................................................... 36\n 4.1.10 Dateibaum ....................................................................................... 37\n 4.2 Verwalten und Editieren von Hamster-Programmen ............................... 37\n 4.2.1 Schreiben eines neuen Hamster-Programms ....................................... 39\n 4.2.2 Öffnen eines existierenden Hamster-Programms ............................... 40\n 4.2.3 Ändern eines existierenden Hamster-Programms ............................... 41\n 4.2.4 Löschen eines existierenden Hamster-Programms ............................. 41\n 4.2.5 Umbenennen eines existierenden Hamster-Programms .................... 41\n 4.2.6 Verschieben eines existierenden Hamster-Programms in einen anderen Ordner 41\n 4.2.7 Kopieren eines existierenden Hamster-Programms in einen anderen Ordner 41\n 4.2.8 Drucken eines Hamster-Programms .................................................. 42\n 4.2.9 Schließen eines geöffneten Hamster-Programms ............................... 42\n 4.2.10 Editier-Funktionen ......................................................................... 42\n 4.2.11 Verwaltung von Ordnern .................................................................. 43\n 4.2.12 Speichern zusammen mit einem Territorium .................................... 43\n 4.2.13 Gleichzeitiges Öffnen eines Hamster-Programms und Territoriums .... 44\n 4.3 Compilieren von Hamster-Programmen .................................................... 44\n 4.3.1 Compilieren ...................................................................................... 44\n 4.3.2 Beseitigen von Fehlern ...................................................................... 44\n 4.3.3 Setzen des CLASSPATH ..................................................................... 45\n 4.4 Verwalten und Gestalten von Hamster-Territorien .................................... 45\n 4.4.1 Verändern der Größe des Hamster-Territoriums ............................... 46\n 4.4.2 Platzieren des Standard-Hamsters im Hamster-Territorium ................ 46\n 4.4.3 Setzen der Blickrichtung des Standard-Hamsters ............................. 46\n4.4.4 Abfragen und Festlegen der Körneranzahl im Maul des Standard-Hamsters 47\n4.4.5 Platzieren von Körnern auf Kacheln des Hamster-Territoriums........................................47\n4.4.6 Platzieren von Mauern auf Kacheln des Hamster-Territoriums........................................47\n4.4.7 Löschen von Kacheln des Hamster-Territoriums.................................................................48\n4.4.8 Abspeichern eines Hamster-Territoriums..............................................................48\n4.4.9 Wiederherstellen eines abgespeicherten Hamster-Territoriums............................................48\n4.4.10 Umbenennen eines abgespeicherten Hamster-Territoriums................................................49\n4.4.11 Löschen und Verschieben einer Datei mit einem Hamster-Territorium in einen anderen Ordner ..........................................................................................................................49\n4.4.12 Verändern der Größendarstellung des Hamster-Territoriums.................................................49\n\n4.5 Ausführen von Hamster-Programmen .........................................................................................49\n4.5.1 Starten eines Hamster-Programms....................................................................................50\n4.5.2 Stoppen eines Hamster-Programms..................................................................................50\n4.5.3 Pausieren eines Hamster-Programms..................................................................................51\n4.5.4 Während der Ausführung eines Hamster-Programms.........................................................51\n4.5.5 Einstellen der Geschwindigkeit ..........................................................................................51\n4.5.6 Wiederherstellen eines Hamster-Territoriums......................................................................52\n4.5.7 Mögliche Fehlerquellen.......................................................................................................52\n\n4.6 Debuggen von Hamster-Programmen .........................................................................................52\n4.6.1 Aktivieren bzw. deaktivieren des Debuggers.......................................................................53\n4.6.2 Beobachten der Programmausführung................................................................................53\n4.6.3 Schrittweise Programmausführung.....................................................................................54\n\n4.7 3D-Simulationsfenster und Sound ..............................................................................................55\n4.7.1 Steuerung mittels der Toolbar............................................................................................56\n4.7.2 Steuerung mittels der Maus.................................................................................................57\n\n4.8 Dateiverwaltung auf Betriebssystemebene .................................................................................57\n\n5 Properties ......................................................................................................................................58\n5.1 Vorhandene Properties ............................................................................................................58\n5.1.1 security .............................................................................................................................58\n5.1.2 workspace ........................................................................................................................59\n5.1.3 logfolder ............................................................................................................................59\n5.1.4 scheme ...............................................................................................................................60\n5.1.5 runlocally ..........................................................................................................................60\n5.1.6 language ............................................................................................................................60\n5.1.7 indent ..................................................................................................................................61\n5.1.8 color ........................................................................................................... 61\n5.1.9 3D ................................................................................................................ 62\n5.1.10 lego ............................................................................................................ 62\n5.1.11 prolog ....................................................................................................... 62\n5.1.12 plcon ......................................................................................................... 62\n5.1.13 laf .............................................................................................................. 63\n5.1.14 python ...................................................................................................... 63\n5.1.15 ruby ........................................................................................................... 63\n5.1.16 scratch ...................................................................................................... 64\n5.1.17 fsm ............................................................................................................. 64\n5.1.18 flowchart .................................................................................................. 65\n5.1.19 javascript .................................................................................................. 65\n5.2 Mehrbenutzerfähigkeit .................................................................................. 65\n6 Englischsprachiger Hamster ............................................................................. 66\n7 Scheme ............................................................................................................. 68\n 7.1 Funktionale Programmiersprachen ............................................................ 68\n 7.2 Die Programmiersprache Scheme .............................................................. 69\n 7.3 Scheme-Hamster-Programme ..................................................................... 69\n 7.4 Grundlagen und Befehle ........................................................................... 70\n 7.4.1 Territoriumsliste ...................................................................................... 70\n 7.4.3 Scheme-Hamster-Programme ............................................................... 72\n 7.5 Beispiele ....................................................................................................... 73\n 7.6 Scheme-Konsole .......................................................................................... 74\n 7.7 Implementierungshinweise ......................................................................... 75\n8 Prolog .................................................................................................................. 76\n 8.0 Voraussetzungen ......................................................................................... 76\n 8.1 Logikbasierte Programmierung .................................................................. 76\n 8.2 Die Programmiersprache Prolog ................................................................. 77\n 8.2.1 Syntax von Prolog .................................................................................... 78\n 8.2.2 Operationale Semantik ............................................................................ 82\n 8.2.3 Systemprädikate ...................................................................................... 84\n 8.2.4 Trace/Boxenmodell ................................................................................. 87\n 8.2.5 Kontrollfluss .......................................................................................... 89\n 8.2.6 Informationen zu Prolog im WWW ....................................................... 90\n 8.3 Prolog-Hamster-Modell .............................................................................. 90\n11.4.4 Anweisungssequenzen ................................................................. 126\n11.4.5 Programme .................................................................................. 126\n11.4.6 Kontrollstrukturen ....................................................................... 127\n11.4.7 Prozeduren und boolesche Funktionen ......................................... 128\n11.5 Ausführen von Scratch-Hamster-Programmen .................................. 129\n11.6 Generieren von Java-Hamster-Programmen ...................................... 130\n11.7 Beispielprogramme .......................................................................... 130\n12 Hamstern mit endlichen Automaten .................................................... 131\n12.1 Endliche Automaten ......................................................................... 131\n12.2 Hamster-Automaten ......................................................................... 131\n12.3 Voraussetzungen .............................................................................. 133\n12.4 Erstellen von Hamster-Automaten ..................................................... 133\n12.4.1 Zeichnen-Menü ............................................................................ 133\n12.4.2 Editieren-Modus ........................................................................ 134\n12.4.3 Definition einer Transition ........................................................ 135\n12.4.4 Automaten-Menü ......................................................................... 136\n12.5 Weitere Funktionen .......................................................................... 137\n13 Hamstern mit Programmablaufplänen ................................................ 138\n13.1 Programmablaufpläne ..................................................................... 138\n13.2 Hamster-PAPs ................................................................................ 138\n13.3 Voraussetzungen ............................................................................ 139\n13.4 Erstellen von Hamster-PAPs ............................................................ 140\n13.4.1 Auswahl-Menü ................................................................. 140\n13.4.2 Programmbereich ...................................................................... 140\n13.4.3 Elemente .................................................................................... 141\n13.4.4 Pfeile ......................................................................................... 141\n13.5 Weitere Funktionen .......................................................................... 142\n14 JavaScript ............................................................................................ 143\n14.1 Die Programmiersprache JavaScript .................................................. 143\n14.2 JavaScript-Hamster-Programme ....................................................... 143\n14.3 JavaScript-Beispielprogramme ........................................................... 145\n14.3.1 Territorium leeren .......................................................... 145\n14.3.2 Territorium leeren 2 .......................................................... 147\n14.3.3 Berg erklimmen ....................................................................... 149\n14.3.4 Wettlauf ................................................................. 150\n14.3.5 Objektorientiertes Territorium leeren ................................................. 150\n15 Noch Fragen? ............................................................................................. 153\n1 Einleitung\n\nProgrammieranfänger haben häufig Schwierigkeiten damit, dass sie beim Programmieren ihre normale Gedankenwelt verlassen und in eher technisch-orientierten Kategorien denken müssen, die ihnen von den Programmiersprachen vorgegeben werden. Gerade am Anfang strömen oft so viele inhaltliche und methodische Neuigkeiten auf sie ein, dass sie das Wesentliche der Programmierung, nämlich das Lösen von Problemen, aus den Augen verlieren.\n\n1.1 Das Hamster-Modell\n\n\nErgänzende Materialien werden im Internet unter www.java-hamster-modell.de bereitgestellt.\n1.2 Der Hamster-Simulator\n\n\nSie halten hier in Händen bzw. sehen am Bildschirm das Benutzungshandbuch des Hamster-Simulators. Im Prinzip ist dieser sehr einfach zu bedienen. Wenn Sie bereits etwas Erfahrung mit Computern haben, sollte Ihnen seine Handhabung keine Probleme bereiten. Trotzdem gibt es sicher Situationen, in denen Sie nicht weiterkommen oder in denen Ihnen nicht bewusst ist, welche Möglichkeiten Sie überhaupt haben. Für genau diese Fälle ist dieses Benutzungshandbuch konzipiert. Nach dieser Einleitung wird im zweiten Abschnitt erläutert, wie Sie den Simulator auf ihrem Rechner installieren und starten. Im dritten Abschnitt wird kurz und knapp erklärt, was Sie tun müssen, um Ihr erstes Hamster-Programm zu schreiben und ausführen zu lassen. Abschnitt 4 behandelt dann im Detail die einzelnen Funktionen des Simulators.\n\n\nSeit Version 2.4 ist der Hamster-Simulator auch in die englisch-sprachige Welt integriert worden. Das betrifft nicht nur die Benutzungsoberfläche sondern auch das Modell selbst. Werfen Sie dazu einen Blick in Abschnitt 6.\n\n\n1.3 Änderungen in Release 6 von Version 2.9\n\n- Es gibt ein paar kleinere Änderungen\n- Hauptsächlich erfolgte eine Umstellung interner Implementierungsdetails, um den Hamster-Simulator auch unter Java SE 9 lauffähig zu bekommen. Aufgrund zweier Java-Bugs in Java SE 9 ist nun zu beachten:\n - Der Hamster-Simulator läuft bei Benutzung von Java SE 8 sowohl mit einem Java JRE als auch mit einem JDK. Bei Benutzung von Java SE 9 ist ein JDK zwingend erforderlich! Unterschied:\nJava JRE steht für \"Java Runtime Environment\" und beinhaltet lediglich die virtuelle Maschine, die zum Ausführen von Java-Programmen benötigt wird.\n\nJava JDK steht für Java \"Java Development Kit\" und beinhaltet die JRE und spezielle Entwicklungstools, wie bspw. einen Java Compiler\n\n- Ausgeführt werden Java-Programme nun immer im Modus: security=false, d.h. der so genannte Security-Manager wird ausgeschaltet. Das bedeutet, Hamster-Programme dürfen bspw. auf die Festplatte zugreifen und dürfen Dateien lesen und in Dateien schreiben. Lehrer sollten vor der Ausführung von Hamster-Programmen, die ihnen von ihren Schülern zugeschickt werden, also immer erst einen kurzen Blick in die Programme werfen, damit nichts „Böses“ bei der Ausführung passiert.\n\n1.4 Änderungen in Release 5 von Version 2.9\n- Es wurden ein paar kleine Fehler beseitigt, die bei der Nutzung von JavaSE 8 auftraten.\n- Es gibt ein paar kleine Änderungen am Erscheinungsbild.\n\n1.5 Änderungen in Release 4 von Version 2.9\n- Hamster-Programme können nun auch in der Programmiersprache JavaScript geschrieben werden (siehe Kapitel 14)\n\n1.6 Änderungen in Release 3 von Version 2.9\n- Es wurden ein paar Fehler beseitigt, die sich bei der Umstellung auf das Java SE 8 eingeschlichen hatten.\n- Außerdem sollte die 3D-Ansicht nun wieder auf allen Rechnern funktionieren (Danke an Carsten Noeske!)\n- Wenn das Workspace-Verzeichnis nicht existiert, wird es angelegt\n- Die Property \"workspace\" in hamster.properties kann jetzt Umgebungsvariablen enthalten, z.B. workspace=$(HOMEDRIVE)/$(HOMEPATH)/HamsterProgramme\n\n1.7 Änderungen in Version 2.9 gegenüber Version 2.8\nIm Wesentlichen wurde der Hamster-Simulator um zwei Erweiterungen ergänzt:\nEs ist nun möglich, Hamster-Programme durch endliche Automaten auszudrücken (siehe Abschnitt 12).\n\nEs ist nun möglich, Hamster-Programme durch Programmablaufpläne zu beschreiben und auszuführen (siehe Abschnitt 13).\n\n1.8 Änderungen in Release 3 von Version 2.8\nEs wurden ein paar Fehler beseitigt, die sich bei der Umstellung auf das JDK 1.7 eingeschlichen hatten.\n\n1.9 Änderungen in Release 2 von Version 2.8\nWiederum wurden ein paar kleine Fehler korrigiert. Wichtige Erweiterungen betreffen die Scratch-Programmierung (siehe Kapitel 11):\n\n- Scratch-Hamster-Programme lassen sich nun ausdrucken.\n- Aus Scratch-Hamster-Programmen können nun Java-Hamster-Programme generiert werden.\n- Die Beschriftungen der Scratch-Blöcke lassen sich über Properties ändern.\n\n1.10 Änderungen in Version 2.8 gegenüber 2.7\nWiederum wurden ein paar kleine Fehler korrigiert. Wichtige Änderungen sind:\n\n- Hamster-Programme können nun auch in der Programmiersprache Python geschrieben werden (siehe Kapitel 9)\n- Hamster-Programme können nun auch in der Programmiersprache Ruby geschrieben werden (siehe Kapitel 10)\n- Hamster-Programme können nun auch in der visuellen Programmiersprache Scratch geschrieben werden (siehe Kapitel 11)\n\n1.11 Änderungen in Version 2.7 gegenüber 2.6\nWiederum wurden ein paar kleine Fehler korrigiert. Wichtige Änderungen sind:\n\n- Im Dateibaum des Editor-Fensters werden nun auch die Territorium-Dateien angezeigt. Beim Anklicken wird das entsprechende Territorium in das Simulation-Fenster geladen.\n- Existiert in einem Ordner zu einem Hamster-Programm ein gleichnamiges Territorium, wird beim Öffnen bzw. Aktivieren des Hamster-Programms das\nTerritorium automatisch in das Simulation-Fenster geladen. Im Editor-Fenster gibt es nun entsprechende Funktionen („Sichern mit Territorium“, ...) durch dessen Aktivierung das gerade aktive Programm und gleichzeitig auch das aktuelle Territorium in eine gleichnamige Datei gespeichert werden.\n\n- Über ein Property namens `laf` kann das Look-And-Feel (Erscheinungsbild) des Hamster-Simulators angepasst werden (siehe Abschnitt 5.1.13).\n- Beim Starten des Hamster-Simulators wird ein SplashScreen angezeigt.\n\n### 1.12 Änderungen in Version 2.6 gegenüber 2.5\n\nWiederum wurden ein paar kleine Fehler korrigiert. Wichtige Änderungen sind:\n\n- Farbliche Umgestaltung des Simulators\n- Es gibt ein neues Menü „Extras“, über das unter anderem die Fontgröße geändert werden kann.\n- Die größte Änderung war die Integration der logikbasierten Programmiersprache Prolog in den Hamster-Simulator (siehe Abschnitt 8).\n\n### 1.13 Änderungen in Version 2.5 gegenüber 2.4\n\nNeben der Korrektur einiger kleiner Fehler sind folgende wesentliche Erweiterungen am Hamster-Simulator vorgenommen worden:\n\n- Hamster-Programme können zusätzlich in einer 3D-Welt ausgeführt werden (siehe Abschnitt 4.7). Die 3D-Ansicht funktioniert momentan aber leider nur unter Windows.\n- Mitte des Jahres 2008 erscheint im Teubner-Verlag ein drittes Buch zum Java-Hamster-Modell, in dem in die parallele Programmierung mit\n\n- Prinzipiell ist es möglich, mit dem Hamster-Simulator einen Lego-Mindstorms-Roboter zu steuern. Da der Roboter jedoch oft noch ein wenig planlos herumläuft, wird die endgültige Freischaltung dieses Features auf die Version 2.6 des Hamster-Simulators verschoben.\n\n1.14 Änderungen in Version 2.4 gegenüber 2.3\n\nNeben der Korrektur einiger kleiner Fehler sind zwei wesentliche Erweiterungen am Hamster-Simulator vorgenommen worden:\n\n\n1.15 Änderungen in Version 2.3 gegenüber 2.2\n\nDie Version 2.3 des Hamster-Simulators enthält folgende Änderungen bzw. Erweiterungen gegenüber Version 2.2:\n\n- Es ist nun auch möglich, Hamster-Programme in der funktionalen Programmiersprache Scheme zu schreiben. Genaueres siehe im Abschnitt 7.\n\n- Die Properties wurden erweitert (siehe Abschnitt 5).\n• Der Hamster-Simulator ist nun Mehrbenutzer-fähig, d.h. er kann einmal auf einem Server installiert und dann von mehreren Nutzern gleichzeitig genutzt werden, wobei die Programme der Nutzer in unterschiedlichen Verzeichnissen abgespeichert werden können (siehe Abschnitt 5.2).\n\n• In der oberen Menüleiste des Editor-Fensters gibt es ein neues Menü „Fenster“. Über dieses Menü ist es möglich, das Simulation-Fenster sowie die Scheme-Konsole sichtbar bzw. unsichtbar zu machen.\n\n• Einige kleine Fehler wurden beseitigt.\n\n1.16 Änderungen in Version 2.2 gegenüber 2.1\n\nAn der generellen Funktionalität des Hamster-Simulators wurde nichts geändert. Die Änderungen beziehen sich nur auf den internen Programmcode. Was jedoch mit dieser neuen Version möglich ist, sind zwei Dinge:\n\n• Hamster-Programme lassen sich nun auch ohne den Editor des Hamster-Simulators erstellen und ausführen.\n\n• Der Hamster-Simulator wurde so angepasst, dass eine Integration in die Entwicklungsumgebung BlueJ möglich ist.\n\n1.16.1 Erstellen von Hamster-Programmen unabhängig vom Editor des Simulators\n\nAb dieser Version des Hamster-Simulators können Sie Hamster-Programme unabhängig vom Hamster-Editor erzeugen und ausführen. Dazu müssen Sie folgendermaßen vorgehen:\n\n• Erstellen Sie ein Hamster-Programm mit einem beliebigen Editor. Speichern Sie dies in einer Datei ab (bspw. test/sammler.ham) Dabei ist folgendes zu beachten: Wenn die Datei ein objektorientiertes Hamster-Programm enthält, muss sie mit folgendem Kommentar beginnen: /*object-oriented program*/ Wenn die Datei eine (Hamster-)Klasse enthält, muss sie mit folgendem Kommentar beginnen: /*class*/ Wenn die Datei ein imperatives Hamster-Programm enthält, ist nichts weiter zu beachten.\n\n• Aus der .ham-Datei muss zunächst eine gültige .java-Datei erzeugt werden. Das geht durch folgenden Aufruf:\n java -classpath hamstersimulator.jar;tools.jar de.hamster.ham2java <ham-Datei>.\n Im konkreten Beispiel: java -classpath hamstersimulator.jar;tools.jar de.hamster.ham2java test/sammler.ham\n\n• Die erzeugte .java-Datei muss compiliert werden. Das geht durch folgenden Aufruf:\n javac -classpath hamstersimulator.jar;tools.jar <java-Datei>\n Im konkreten Beispiel: javac -classpath hamstersimulator.jar;tools.jar\ntest/sammler.java\nInsofern das Programm keine Fehler enthält, wird eine .class-Datei mit dem Java-Byte-Code erzeugt.\n\n- Es muss mit dem Hamster-Simulator eine Datei mit einem Territorium erzeugt und gespeichert werden (in unserem Beispiel in die Datei test/sammler.ter)\n- Nun kann das Hamster-Programm in dem Territorium ausgeführt werden. Das geht durch folgenden Aufruf:\n java -classpath hamstersimulator.jar;tools.jar de.hamster.run <class-Datei> <ter-Datei>\n Im konkreten Beispiel: java -classpath hamstersimulator.jar;tools.jar de.hamster.run test/sammler.class test/sammler.ter\n- Dann erscheint das Hamster-Territorium und man muss nur noch auf den Start-Button drücken.\n\n1.16.2 Hamstern mit BlueJ\n\n\nWas ab Version 2.2 des Hamster-Simulators nun möglich ist, ist seine Integration in BlueJ. Hamster-Programme können mit den Werkzeugen und Möglichkeiten, die BlueJ bietet, entwickelt und im Hamster-Simulator ausgeführt werden. Konkret bedeutet das an Vorteilen für Programmieranfänger, BlueJ visualisiert die Programmsstruktur und erlaubt insbesondere die interaktive Erzeugung von Hamstern und den interaktiven Aufruf von Hamster-Befehlen und der Hamster-Simulator visualisiert die Programmausführung, d.h. der Programmierer sieht unmittelbar in einer graphischen Umgebung, was seine Anweisungen bzw. Programme bewirken.\n\nGenauere Informationen zum „Hamstern mit BlueJ“ können Sie dem PDF-Dokument HamsternMitBlueJ.pdf entnehmen, das Sie auf der Website zum Java-Hamster-Modell finden.\n1.17 Änderungen in Version 2.1 gegenüber 2.0\n\nGegenüber der Version 2.0 des Hamster-Simulators enthält Version 2.1 folgende Änderungen:\n\n- Ein paar Fehler wurden behoben, bspw. der Fehler beim Schließen des Simulators, wenn eine oder mehrere Dateien noch nicht gespeichert wurden.\n\n- Das Simulation-Fenster erscheint nun beim Start des Simulators größer.\n\n- Linkshänder können nun im Editor auch <ctrl><Einfg> zum Kopieren und <Shift><Einfg> zum Einfügen nutzen.\n\n- Über eine so genannte Property-Datei können sie bestimmte Voreinstellungen überlagern. Die Datei muss den Namen „hamster.properties“ haben und sich in dem Ordner befinden, wo sich auch die Dateien „hamstersimulator.jar“ bzw. „hamstersimulator.bat“ befinden. Momentan sind folgende Einstellungen möglich:\n\n - **security**: Befindet sich in der Datei „hamster.properties“ eine Zeile mit dem Text `security=false`, wird der so genannte Security-Manager ausgeschaltet. Das bedeutet, Hamster-Programme dürfen auf die Festplatte zugreifen und dürfen Dateien lesen und in Dateien schreiben. Damit ist es bspw. auch möglich, aus Hamster-Programmen heraus Sounds abzuspielen. Aber Vorsicht, sollten sie diese Option gesetzt haben, empfehle ich Ihnen dringend, keine fremden Hamster-Programme auszuführen. Sind diese bspw. böswillig geschrieben, könnten sie Ihnen prinziell die gesamte Festplatte löschen. Standardmäßig steht in der Property-Datei `security=true`. **Achtung:** Ab Version 2.9.6 ist aufgrund eines Java-Bugs `security` immer auf `false`, auch wenn hier was anderes eingetragen wird!\n\n\n ```plaintext\n workspace=C:/Dokumente und Einstellungen/karl\n ```\n\n oder\n\n ```plaintext\n workspace=C:/Dokumente und Einstellungen/heidi/Eigene\n ```\n\n Dateien. Der angegebene Ordner muss existieren und er muss lesbar und beschreibbar sein! Achten Sie bitte darauf, dass in dem Ordner-Namen keine Sonderzeichen vorkommen (bspw. ein Ausrufezeichen), da die aktuelle Java-Version (5.0) im Moment nicht damit zurecht kommt. Für Windows-Nutzer\n\n1 Aus Kompatibilität zu früheren Versionen des Hamster-Simulators kann diese Property auch **home** genannt werden.\nist es wichtig zu wissen, dass die `\\`-Zeichen in den Ordner-Namen durch ein `/`-Zeichen ersetzt werden müssen. Alternativ kann auch jedes `\\`-Zeichen verdoppelt werden. Standardmäßig steht in der Property-Datei `workspace=Programme`\nMehr Informationen zu Properties finden Sie im Abschnitt 5.\n\n1.18 Anmerkungen zur alten Version 1 des Hamster-Simulators\n\nVersion 1 des Hamster-Simulators wird nicht weiter unterstützt!\n\n\nWenn Sie trotzdem mit Version 1 des Simulators arbeiten möchten, weil Sie sich bspw. an die Version gewöhnt haben, sei Ihnen gesagt: Version 1 unterstützt nicht die Entwicklung objektorientierter Hamster-Programme, dient also lediglich als Begleitprogramm zum ersten Band der beiden Hamster-Bücher.\n\nHamster-Programme, die mit der Version 1 des Hamster-Simulators erstellt wurden, können auf zweierlei Art und Weise in die neue Version 2 übernommen werden:\n\n- Sie übertragen den alten Sourcecode mittels Copy-Paste in den Editor des neuen Hamster-Simulators, speichern diesen und kompilieren.\n\n- In dem Ordner, in dem die Datei `hamstersimulator.jar` liegt, befindet sich ein Unter-Ordner namens `Programme`. Kopieren Sie die alten `\".ham\"-Dateien einfach in diesen Ordner oder in Unter-Ordner des Ordners. Anschließend können Sie die Dateien über den Editor des neuen Hamster-Simulators öffnen und kompilieren. Achtung: Sie müssen die alten `\".ham\"-Dateien auf jeden Fall neu kompilieren. Die alten ausführbaren `\".class\"-Dateien funktionieren nicht mehr!\n\n2 Installation und Starten des Hamster-Simulators\n\nDer Hamster-Simulator läuft zur Zeit auf Windows-, Macintosh-, Linux- und Solaris-Rechnern. Dort haben wir ihn auch getestet.\n\nDa er in Java geschrieben ist, müsste er eigentlich auch auf allen anderen Rechnern laufen, für die eine Java JVM existiert.\n\n2.1 Laden und Installation einer Java-Laufzeitumgebung\n\nDer Hamster-Simulator ist ein in Java geschriebenes Programm. Um es ausführen zu können, muss auf Ihrem Rechner eine Java-Laufzeitumgebung installiert werden. In Java gibt es nun zwei Varianten, dies zu tun.\n\n\nNeben der benötigten Java-Laufzeitumgebung beinhaltet ein JDK noch weitere Werkzeuge zur Entwicklung von Java-Programmen, wie bspw. einen Compiler. Sie sollten also ein JDK installieren, wenn Sie außer Hamster-Programmen noch „richtige“ Java-Programme entwickeln möchten. Problem beim JDK ist: Es ist sehr groß (ca. 70 MByte). Es kann über den folgenden URL kostenlos aus dem WWW geladen werden:\n\n\nAchtung: Diese Variante funktioniert ab Version 2.9.6 leider nicht mehr: Die zweite Variante ist die Installation eines „Java SE Runtime Environment (JRE)“. Dieses stellt genau die benötigte Laufzeitumgebung dar. JREs sind in JDKs enthalten, existieren also in denselben Versionen. Die Vorteile von JREs sind: Sie sind weit weniger groß (ca. 20 MBytes). Auch JREs können über den folgenden URL kostenlos aus dem WWW geladen werden:\n\n\nSowohl das JDK als auch das JRE werden standardmäßig von der Firma Oracle für die Betriebssysteme Windows, Linux und Solaris zur Verfügung gestellt, leider nicht für Macintosh-Betriebssysteme.\n\nNachdem Sie entweder ein JDK oder ein JRE auf Ihren Rechner geladen haben, müssen Sie es installieren. Das geschieht normalerweise durch Ausführen der geladenen Datei (in Windows Doppelklick auf die .exe-Datei). Sie werden dann durch die weitere Installation geführt.\n2.2 Laden und Installation des Hamster-Simulators\n\nAuf der Hamster-Website (http://www.java-hamster-modell.de) befindet sich im Bereich „Simulator“ eine Datei namens „hamstersimulator-v29-06.zip“. .zip-Dateien sind Dateien, die mehrere andere Dateien komprimiert speichern. Die Datei „hamstersimulator-v29-06.zip“ müssen Sie auf Ihren Rechner laden und anschließend entpacken. Die Datei enthält eine Reihe von Dateien und vier Ordner. Die wichtigsten sind:\n\n- Datei hamstersimulator.jar: Enthält den ausführbaren Hamster-Simulator.\n- Datei handbuch.pdf: Das Handbuch zum Hamster-Simulator im PDF-Format.\n- Datei hamster.properties: Datei zum Einstellen bestimmter Eigenschaften.\n- Ordner Programme: Enthält standardmäßig alle Hamster-Programme der drei Hamster-Bücher. In diesem Ordner werden von Ihnen entwickelte Hamster-Programme abgespeichert. Dieser Ordner muss sich immer in demselben Ordner befinden, in dem auch die Dateien hamstersimulator.jar und hamstersimulator.bat liegen!\n- Ordner lib: Enthält diverse benötigte Java-Bibliotheken. Insbesondere die Datei tools.jar, in dem der Java-Compiler steckt.\n- Ordner handbuch: Das Handbuch im PDF-Format.\n\n2.3 Hamster-Simulator unter Java SE 6 und 7\n\nWenn Sie noch die veraltete Java-Version Java SE 6 bzw. 7 benutzen, laden Sie sich bitte anstelle der Datei „hamstersimulator-v29-06.zip“ die Datei „hamstersimulator-v29-01-java7.zip“ herunter. Das sollte prinzipiell auch noch funktionieren, wird aber in Zukunft nicht weiter unterstützt.\n\n2.4 Hamster-Simulator unter Java SE 4 und 5\n\nDie veraltete Java-Version 1.4 und auch die Version 5 werden nicht weiter unterstützt!\n2.5 Starten des Hamster-Simulators\n\nNachdem Sie eine Java-Laufzeitumgebung sowie den Hamster-Simulator wie oben beschrieben auf Ihrem Rechner installiert haben, können Sie den Simulator starten. Dies geschieht folgendermaßen:\n\n- Unter Windows: Führen Sie mit der Maus einen Doppelklick auf die Datei hamstersimulator.jar oder die Datei hamstersimulator.bat aus. ²\n\n- Unter Linux und Solaris: Rufen Sie in dem Ordner, in dem sich die Datei hamstersimulator.jar befindet, folgenden Befehl auf:\n\n `java -jar hamstersimulator.jar`\n\n- Unter Macintosh (OS X): Führen Sie mit der Maus einen Doppelklick auf die Datei hamstersimulator.jar aus.\n\nAnschließend öffnen sich zwei Fenster, die mit Editor und Simulation betitelt sind.\n\nHerzlichen Glückwunsch! Sie können mit der Entwicklung von Hamster-Programmen beginnen!\n\n2.5.1 Probleme und Lösungen beim Starten\n\njar-Dateien\n\nWenn es Probleme mit dem Doppelklick unter Windows gibt, kann es sein, dass die Endung .jar dem falschen Programm bzw. Java-Interpreter zugeordnet ist. Testen Sie dies, indem Sie in einem Eingabeaufforderungsfenster folgendes eingeben und in etwa die folgenden Ergebnisse angezeigt bekommen:\n\nEingabe: `assoc .jar`\n\nAusgabe: `.jar=jarfile`\n\nEingabe: `ftype jarfile`\n\nAusgabe: `jarfile=\"C:\\Program Files\\Java\\jre\\bin\\javaw.exe\" -jar \"%1\" %*`\n\nDen Java-Interpreter, der standardmäßig beim Doppelklick auf eine .jar-Datei aufgerufen werden soll, können Sie durch folgende Eingabe in einem Eingabeaufforderungsfenster ändern:\n\n`ftype jarfile=\"pfad\\javaw.exe\" -jar \"%1\" %*`\n\n²Eine weitere Alternative besteht darin, ein Eingabeaufforderung-Fenster zu öffnen, sich in den Ordner zu begeben, in dem sich die Datei hamstersimulator.jar befindet, und dort folgenden Befehl einzugeben: java -jar hamstersimulator.jar.\nwobei „pfad“ entsprechend Ihrer Java-Installation geändert werden muss, bspw. so:\n\n```\njarfile=\"C:\\Program Files\\Java\\jdk1.8.0.0\\bin\\javaw.exe\" -jar \"%1\" %*\n```\n\n**Java-Version**\n\nWenn du zwar Java SE 8 oder Java SE 9 installiert hast, aber trotzdem beim Starten des Hamster-Simulators eine entsprechende Fehlermeldung erscheint, ist der java-Befehl evtl. nicht der entsprechenden Java-Installation zugeordnet. In diesem Fall kannst du folgendes tun:\n\n1. Entweder musst du die PATH-Umgebungsvariable deines Betriebssystems richtig setzen. Wie das geht, steht bspw. hier: [https://docs.oracle.com/javase/tutorial/essential/environment/paths.html](https://docs.oracle.com/javase/tutorial/essential/environment/paths.html)\n\n2. Oder du machst folgendes: Öffne die Datei `hamstersimulator.bat`. Sie enthält standardmäßig folgenden Inhalt: `java -jar hamstersimulator.jar` Ersetze `java` durch den vollständigen Pfad. Wenn du das JDK bspw. unter `C:\\Programme\\Java\\jdk-9.0.1` installiert hast, musst du in die Datei `hamstersimulator.bat` folgendes schreiben:\n\n```\nC:\\Programme\\Java\\jdk-9.0.1\\bin\\java -jar hamstersimulator.jar\n```\n\nSpeichere und schließe die Datei und starte sie durch Doppelklick. Bitte achte darauf, dass in dem ersetzen Teil kein Leerzeichen auftritt. Ansonsten musst du Anführungszeichen verwenden, bspw.:\n\n```\n\"C:\\Program Files\\Java\\jdk-9.0.1\\bin\\java\" -jar hamstersimulator.jar\n```\n3 Ihr erstes Hamster-Programm\n\nNachdem Sie den Hamster-Simulator gestartet haben, öffnen sich auf dem Bildschirm zwei neue Fenster: das Editor-Fenster (siehe auch Abbildung 1) und das Simulation-Fenster (siehe auch Abbildung 2). Sie erkennen die beiden Fenster an ihren Titeln Editor bzw. Simulation. Im Großen und Ganzen kann man sagen: Im Editor-Fenster entwickeln Sie Hamster-Programme und im Simulation-Fenster führen Sie Hamster-Programme aus.\n\nAbbildung 1: Editor-Fenster\n\nAbbildung 2: Simulation-Fenster\nIm Folgenden wird im Detail beschrieben, was Sie machen müssen, um Ihr erstes Hamster-Programm zu schreiben und auszuführen. Insgesamt müssen/können fünf Stationen durchlaufen werden:\n\n- Gestaltung eines Hamster-Territoriums\n- Eingeben eines Hamster-Programms\n- Compilieren eines Hamster-Programms\n- Ausführen eines Hamster-Programms\n- Debuggen eines Hamster-Programms\n\n### 3.1 Gestaltung eines Hamster-Territoriums\n\nAls erstes wollen wir ein Hamster-Territorium aufbauen, in dem unser Programm ablaufen soll. Das geschieht im Simulation-Fenster (siehe auch Abbildung 2). In der Mitte sehen wir das Hamster-Territorium, darüber eine so genannte Toolbar mit graphischen Buttons. Fahren Sie einfach mal mit der Maus über die einzelnen Buttons der Toolbar, dann erscheint jeweils ein Tooltip, der beschreibt, wozu dieser Button dient.\n\n\nSie können übrigens auch die Körneranzahl auf mehreren Kacheln gleichzeitig festlegen. Klicken Sie dazu mit der Maus auf eine Kachel und ziehen Sie die Maus bei gedrückter Maustaste über die Kacheln, deren Körneranzahl Sie ändern möchten. Erst, wenn Sie die Maustaste loslassen, erscheint die Dialogbox. Geben Sie dann die Anzahl ein und klicken Sie den OK-Button. Die Körneranzahl wird auf allen Kacheln verändert, die Sie vorher markiert hatten.\n\n\nMöchten Sie bestimmte Kacheln im Territorium wieder leeren, so dass weder eine Mauer noch Körner auf ihnen platziert sind, so aktivieren Sie den „Kachel löschen“-Button (neunter Button von links). Klicken Sie anschließend auf die Kacheln, die geleert werden sollen.\n\nSo, jetzt wissen Sie eigentlich alles, was notwendig ist, um das Hamster-Territorium nach Ihren Wünschen zu gestalten. Bevor Sie weiterlesen, erzeugen Sie als nächstes das in Abbildung 2 skizzierte Territorium.\n\nSie können ein bestimmtes Territorium auch in einer Datei abspeichern, wenn Sie es irgendwann noch einmal benutzen möchten, ohne alle Eingaben erneut zu tätigen. Drücken Sie einfach auf den „Territorium speichern“-Button (dritter Button von links) und geben Sie in der sich öffnenden Dateiauswahl-Dialogbox einen Namen an, zum Beispiel MeinErstesTerritorium. Wenn Sie dann auf den OK-Button klicken, wird das Territorium in einer Datei mit diesem Namen gespeichert. Der Dateiname erhält übrigens automatisch die Endung „.ter“.\n\n\n3.2 Eingeben eines Hamster-Programms\n\nNachdem wir unser erstes Hamster-Territorium im Simulation-Fenster gestaltet haben, begeben wir uns nun in das Editor-Fenster. Dort werden wir unser erstes Hamster-Programm schreiben.\n\nIm Editor-Fenster befindet sich ganz oben eine Menüleiste und darunter eine Toolbar mit graphischen Buttons. Links sehen wir den Dateibaum und das große Feld rechts ist der Eingabebereich für den Sourcecode.\n\n\n```c\nvoid main() {\n}\n```\n\nUnser erstes Programm soll bewirken, dass der Hamster in dem gerade von uns gestalteten Territorium zwei Körner frisst. Wir klicken in die zweite Reihe des Eingabebereiches und tippen dort wie in einem normalen Editor bzw. Textverarbeitungsprogramm, wie Microsoft Word, die entsprechenden Hamster-Befehle ein, so dass letztlich folgendes im Eingabebereich steht:\n\n```c\nvoid main() {\n vor();\n vor();\n linksUm();\n vor();\n vor();\n nimm4();\n}\n\nvoid nimm4() {\n nimm();\n nimm();\n nimm();\n nimm();\n}\n```\n\n\nZu guter Letzt gibt es noch den „Drucken“-Button (sechster Button von links) zum Ausdrucken eines Hamster-Programms.\n\nAlle gerade erläuterten Funktionen zum Verwalten von Dateien mit Hamster-Programmen finden Sie auch im Menü „Datei“.\n\n### 3.3 Compilieren eines Hamster-Programms\n\n\nWenn das Programm korrekt ist, erscheint eine Dialogbox mit der Nachricht „Kompilierung erfolgreich“. Zur Bestätigung müssen Sie anschließend noch den OK-Button drücken. Das Programm kann nun ausgeführt werden. Merken Sie sich bitte: Immer, wenn Sie Änderungen am Sourcecode Ihres Programms vorgenommen haben, müssen Sie es zunächst abspeichern und dann neu kompilieren. Sonst werden die Änderungen nicht berücksichtigt!\n\nWenn das Programm syntaktische Fehler enthält – wenn Sie sich bspw. bei der Eingabe des obigen Programms vertippt haben –, werden unter dem Eingabebereich die Fehlermeldungen des Compilers eingeblendet. Diese erscheinen in englischer Sprache.\nWeiterhin wird die Zeile angegeben, in der der Fehler entdeckt wurde. Wenn Sie mit der Maus auf die Fehlermeldung klicken, springt der Cursor im Eingabebereich automatisch in die angegebene Zeile.\n\nVorsicht: Die Fehlermeldungen sowie die Zeilenangabe eines Compilers sind nicht immer wirklich exakt. Das Interpretieren der Meldungen ist für Programmieranfänger häufig nicht einfach und bedarf einiger Erfahrungen. Deshalb machen Sie ruhig am Anfang mal absichtlich Fehler und versuchen Sie, die Meldungen des Compilers zu verstehen.\n\nTipp: Arbeiten Sie die Fehler, die der Compiler entdeckt hat, immer von oben nach unten ab. Wenn Sie eine Meldung dann überhaupt nicht verstehen, speichern Sie ruhig erst mal ab und kompilieren Sie erneut. Häufig ist es (leider) so, dass der Compiler für einen einzelnen Fehler mehrere Fehlermeldungen ausgibt, was Anfänger leicht verwirren kann.\n\nNachdem Sie die Fehler korrigiert haben, müssen Sie das Programm zunächst erst wieder speichern und dann erneut kompilieren. Wiederholen Sie dies so lange, bis der Compiler die Meldung „Kompilierung erfolgreich“ ausgibt. Erst dann können Sie das Programm ausführen!\n\n### 3.4 Ausführen eines Hamster-Programms\n\nNach dem erfolgreichen Kompilieren ist es endlich soweit: Wir können den Hamster bei der Arbeit beobachten. Macht er wirklich das, was wir ihm durch unser Programm beigebracht haben?\n\n\nRechts neben dem Hamster-Territorium werden übrigens während der Programmausführung jeweils die Hamster-Befehle angezeigt, die der Hamster gerade ausführt.\n\nWenn Sie ein Programm mehrmals hintereinander im gleichen Territorium ausführen, können Sie mit dem „Rücksetzen“-Button (vierter Button von rechts) den Zustand des Territoriums wieder herstellen, der vor Ausführen des Programms bestand.\n\nDie Bedienelemente zum Steuern der Programmausführung („Ausführen“-Button, „Pause“-Button, „Stopp“-Button und Geschwindigkeitsregler) finden Sie übrigens auch im Editor-Fenster sowie im „Debugger“-Menü des Editor-Fensters. Welche Sie nutzen, ist Ihnen überlassen.\n\n3.5 Debuggen eines Hamster-Programms\n\n\nWenn der Debugger aktiviert ist und Sie über den „Ausführen“-Button ein Hamster-Programm starten, öffnen sich oberhalb des Eingabebereichs im Editor-Fenster zwei neue Bereiche. Im linken Bereich wird angezeigt, in welcher Funktion sich der Programmablauf gerade befindet. Im rechten Bereich werden die Variablen und ihre aktuellen Werte dargestellt. Außerdem wird im Eingabebereich durch einen blauen Balken gekennzeichnet, welche Zeile des Programms ausgeführt wird.\n\n\nSie können bei aktiviertem Debugger zunächst auch einfach das Programm durch Anklicken des „Ausführen“-Buttons starten und beobachten. Wenn Sie dann den „Pause“-Button drücken, haben Sie anschließend ebenfalls die Möglichkeit der schrittweisen Ausführung ab der aktuellen Position.\n\nDen „Pause“-Zustand mit der Möglichkeit der schrittweisen Ausführung eines Programms können Sie jederzeit wieder durch Anklicken des „Ausführen“-Buttons beenden. Das Programm läuft dann selbstständig wieder weiter.\n3.6 Zusammenfassung\n\nHerzlichen Glückwunsch! Wenn Sie bis hierhin gekommen sind, haben Sie Ihr erstes Hamster-Programm erstellt und ausgeführt. Sie sehen, die Bedienung des Hamster-Simulators ist gar nicht so kompliziert.\n\nDer Hamster-Simulator bietet jedoch noch weitere Möglichkeiten. Diese können Sie nun durch einfaches Ausprobieren selbst erkunden oder im nächsten Abschnitt nachlesen.\n4 Bedienung des Hamster-Simulators\n\nIm letzten Abschnitt haben Sie eine kurze Einführung in die Funktionalität des Hamster-Simulators erhalten. In diesem Abschnitt werden die einzelnen Funktionen des Simulators nun im Detail vorgestellt. Dabei wird sich natürlich einiges auch wiederholen.\n\nWenn Sie den Hamster-Simulator starten, öffnen sich zwei Fenster. Das eine heißt *Editor-Fenster*, das andere *Simulation-Fenster*. Sie erkennen die beiden Fenster an ihren Titeln: Editor bzw. Simulation. Abbildung 3 skizziert die einzelnen Komponenten des Editor-Fensters, Abbildung 4 die des Simulation-Fensters.\n\nAbbildung 3: Komponenten des Editor-Fensters\n\nIm Großen und Ganzen kann man sagen, dient das Editor-Fenster zum Editieren, Compilieren und Debuggen von Hamster-Programmen und das Simulation-Fenster zur Gestaltung des Hamster-Territoriums und zum Ausführen von Hamster-Programmen.\nAbbildung 4: Komponenten des Simulation-Fensters\n\nDamit wurden auch bereits die Hauptfunktionsbereiche des Hamster-Simulators genannt:\n\n- Verwalten und Editieren von Hamster-Programmen\n- Compilieren von Hamster-Programmen\n- Verwalten und Gestalten von Hamster-Territorien\n- Ausführen von Hamster-Programmen\n- Debuggen von Hamster-Programmen\n\nBevor im Folgenden anhand dieser Funktionsbereiche der Simulator im Detail vorgestellt wird, werden zuvor noch einige Grundfunktionen graphischer Benutzungsoberflächen erläutert.\n\n### 4.1 Grundfunktionen\n\nIn diesem Unterabschnitt werden einige wichtige Grundfunktionalitäten graphischer Benutzungsoberflächen beschrieben. Der Abschnitt ist für diejenigen unter Ihnen gedacht, die bisher kaum Erfahrungen mit Computern haben. Diejenigen von Ihnen, die schon längere Zeit einen Computer haben und ihn regelmäßig benutzen, können diesen Abschnitt ruhig überspringen.\n\n#### 4.1.1 Anklicken\n\nWenn im Folgenden von „Anklicken eines Objektes“ oder „Anklicken eines Objektes mit der Maus“ gesprochen wird, bedeutet das, dass Sie den Mauscursor auf dem Bildschirm\ndurch Verschieben der Maus auf dem Tisch über das Objekt platzieren und dann die – im Allgemeinen linke – Maustaste drücken.\n\n### 4.1.2 Tooltips\n\nAls **Tipps** werden kleine Rechtecke bezeichnet, die automatisch auf dem Bildschirm erscheinen, wenn man den Mauscursor auf entsprechende Objekte plaziert (siehe Abbildung 5). In den Tooltips werden bestimmte Informationen ausgegeben.\n\n\n\n### 4.1.3 Button\n\n**Buttons** sind Objekte der Benutzeroberfläche, die man anklicken kann und die daraufhin eine bestimmte Aktion auslösen (siehe Abbildung 6). Buttons besitzen eine textuelle Beschreibung (z.B. „OK“) oder eine Graphik, die etwas über die Aktion aussagen. Sie erkennen Buttons an der etwas hervorgehobenen Darstellung. Graphik-Buttons sind in der Regel Tooltips zugeordnet, die die zugeordnete Aktion beschreiben.\n\n\n\n### 4.1.4 Menü\n\n**Menüs** befinden sich ganz oben in einem Fenster in der so genannten **Menüleiste** (siehe Abbildung 7). Sie werden durch einen Text beschrieben (Datei, Bearbeiten, ...). Klickt man die Texte an, öffnet sich eine Box mit so genannten **Menüitems**. Diese bestehen wiederum aus Texten, die man anklicken kann. Durch Anklicken von Menüitems werden genauso wie bei Buttons Aktionen ausgelöst, die im Allgemeinen durch die Texte beschrieben werden (Speichern, Kopieren, ...). Nach dem Anklicken eines Menüitems wird die Aktion gestartet und die Box schließt sich automatisch wieder. Klickt man irgendwo außerhalb der Box ins Fenster schließt sich die Box ebenfalls und es wird keine Aktion ausgelöst.\n\nManchmal erscheinen bestimmte Menüitems etwas heller. Man sagt auch, sie sind ausgegraut. In diesem Fall kann man das Menüitem nicht anklicken und die zugeordnete Aktion nicht auslösen. Das Programm befindet sich in einem Zustand, in dem die Aktion keinen Sinn machen würde.\n\nAbbildung 7: Menü\n\n4.1.5 Toolbar\n\nDirekt unterhalb der Menüleiste ist die so genannte Toolbar angeordnet (siehe Abbildung 8). Sie besteht aus einer Menge an Graphik-Buttons, die Alternativen zu den am häufigsten benutzten Menüitems darstellen.\n\nAbbildung 8: Toolbar\n\n4.1.6 Popup-Menü\n\nPopup-Menüs sind spezielle Menüs, die bestimmten Elementen auf dem Bildschirm zugeordnet sind (siehe Abbildung 9). Man öffnet sie dadurch, dass man das Objekt zunächst anklikt und danach nochmal die rechte Maustaste drückt. Genauso wie bei normalen Menüs erscheint dann eine Box mit Menüitems.\n4.1.7 Eingabefeld\n\n\n4.1.8 Dialogbox\n\n4.1.9 Dateiauswahl-Dialogbox\n\n\nAbbildung 11: Dateiauswahl-Dialogbox\n\n\n4.1.10 Dateibaum\n\nEin *Dateibaum* repräsentiert die Ordner und Dateien des Dateisystems (siehe Abbildung 12).\n\nAbbildung 12: Dateibaum\n\nOrdner und Dateien werden dabei durch unterschiedliche Symbole dargestellt, hinter denen die Namen erscheinen. Durch Anklicken des Zeigers vor einem Ordnersymbol kann man den Ordner öffnen und schließen. Bei einem geöffneten Ordner werden die darin enthaltenen Unterordner und Dateien (genauer ihre Namen) angezeigt.\n\nDas Anklicken eines Dateinamens im Dateibaum entspricht im Hamster-Simulator dem Öffnen einer Datei. Der entsprechende Inhalt wird im Eingabebereich des Fensters dargestellt.\n\n\n4.2 Verwalten und Editieren von Hamster-Programmen\n\nDas Schreiben von Programmen bzw. genauer gesagt das Schreiben des Sourcecodes von Programmen bezeichnet man als *Editieren*. Im Hamster-Simulator dient das Editor-Fenster zum Editieren von Hamster-Programmen.\nSchauen Sie sich das Editor-Fenster einmal an (siehe Abbildung 13).\n\nAbbildung 13: Editorfenster\n\n\n4.2.1 Schreiben eines neuen Hamster-Programms\n\nWenn Sie ein neues Hamster-Programm schreiben möchten, klicken Sie bitte den „Neu“-Button an (erster Toolbar-Button von links). Es öffnet sich eine Dialogbox. In dieser Dialogbox müssen Sie auswählen, welchen Typ von Programm Sie schreiben möchten. Es existieren drei Alternativen:\n\n- Scheme-Programm: hierzu siehe Abschnitt 7.\n\nAchtung: Es ist nicht möglich, den Typ eines Programms nachträglich zu ändern!\n\n\nAbbildung 15: Karteireiter\n\n\nIm Dateibaum ist übrigens auch der Typ eines Programms ersichtlich: Bei imperativen Programmen ist dem Namen ein einzelner blauer Pfeil vorangestellt, bei objektorientierten Programmen drei Pfeile in den Farben blau, gelb und rot und Klassen erkennen Sie an einem blauen Pfeil in einem Rechteck.\n\n4.2.2 Öffnen eines existierenden Hamster-Programms\n\n4.2.3 Ändern eines existierenden Hamster-Programms\n\nUm ein Hamster-Programm zu ändern, müssen Sie es zuvor öffnen, so dass der Sourcecode im Eingabebereich erscheint. Im Eingabebereich können Sie nun die gewünschten Änderungen am Sourcecode vornehmen und anschließend mit Hilfe des „Speichern“-Buttons oder des „Speichern Als“-Buttons abspeichern.\n\n4.2.4 Löschen eines existierenden Hamster-Programms\n\n\n4.2.5 Umbenennen eines existierenden Hamster-Programms\n\n\nWenn Sie eine Datei mit einem Hamster-Programm umbenannt haben, müssen Sie sie neu kompilieren!\n\n4.2.6 Verschieben eines existierenden Hamster-Programms in einen anderen Ordner\n\nMöchten Sie eine Datei mit einem Hamster-Programm (oder auch einen kompletten Ordner) in einen anderen Ordner verschieben, klicken Sie den entsprechenden Namen im Dateibaum an und verschieben Sie den Mauscursor bei gedrückter Maustaste über den Namen des Ordners, in den die Datei bzw. der Ordner verschoben werden soll. Der Name verschwindet aus dem vorherigen Ordner und erscheint im neuen Ordner, falls dieser geöffnet ist.\n\nWenn Sie eine Datei mit einem Hamster-Programm in einen anderen Ordner verschoben haben, müssen Sie sie neu kompilieren!\n\n4.2.7 Kopieren eines existierenden Hamster-Programms in einen anderen Ordner\n\n\nEine Alternative hierzu sieht folgendermaßen aus: Möchten Sie eine Datei mit einem Hamster-Programm (oder auch einen kompletten Ordner!) in einen anderen Ordner kopieren, klicken Sie den entsprechenden Namen im Dateibaum an und verschieben Sie den Mauscursor bei gedrückter Maustaste und gedrückter „Strg“-Taste Ihrer Tastatur über den Namen des Ordners, in den die Datei bzw. der Ordner verschoben werden soll.\n\nZumindest unter Windows funktioniert die Alternative übrigens auch in Kombination mit dem Betriebssystem, d.h. Sie können Dateien bspw. auf den Desktop kopieren und umgekehrt!\n\nWenn Sie eine Datei mit einem Hamster-Programm in einen anderen Ordner kopiert haben, müssen Sie die neue Datei noch kompilieren!\n\n4.2.8 Drucken eines Hamster-Programms\n\n\n4.2.9 Schließen eines geöffneten Hamster-Programms\n\nMit dem „Schließen“-Button (siebter Toolbar-Button von links) können Sie die aktuell im Eingabebereich geöffnete Datei schließen, d.h. den Sourcecode inklusive Karteireiter aus dem Eingabebereich entfernen. Wenn Sie den Button anklicken und die aktuelle Datei noch nicht gespeicherte Änderungen enthält, wird über eine Dialogbox nachgefragt, ob diese Änderungen gespeichert werden sollen oder nicht.\n\n4.2.10 Editier-Funktionen\n\nIm Eingabebereich können Sie – wie bei anderen Editoren auch – über die Tastatur Zeichen eingeben bzw. wieder löschen. Darüber hinaus stellt der Editor ein paar weitere Funktionalitäten zur Verfügung, die über das „Bearbeiten“-Menü bzw. die entsprechenden Buttons in der Toolbar des Editor-Fensters aktiviert werden können.\n\n\n• „Wiederherstellen“-Button (dreizehnter Toolbar-Button von links): Rückgängig gemachte Änderungen können Sie mit Hilfe dieses Buttons wieder herstellen.\n\n\n4.2.11 Verwaltung von Ordnern\n\nUm Funktionen auf einem Ordner durchzuführen, klicken Sie zunächst den entsprechenden Ordner im Dateibaum an. Der Name des Ordners wird dadurch durch ein blaues Rechteck hinterlegt. Klicken Sie anschließend die rechte Maustaste, so dass sich das Popup-Menu des Ordners öffnet. Im Popup-Menü haben Sie nun folgende Funktionalitäten zur Verwaltung von Ordnern zur Verfügung:\n\n- Menüitem „Neuer Ordner“: Durch Anklicken dieses Items können Sie einen neuen Unterordner anlegen. Es öffnet sich eine Dialogbox, in der sie den Namen des Unterordners angeben müssen.\n- Menüitem „Löschen“: Durch Anklicken dieses Items können Sie den entsprechenden Ordner löschen. Achtung: Es werden automatisch auch alle Dateien und Unterordner des Ordners unwiderruflich gelöscht!\n- Menüitem „Einfügen“: Wenn Sie zuvor eine Datei mit dessen Popup-Menüitem „Kopieren“ kopiert haben, können Sie durch Anklicken dieses Items die entsprechende Datei in den aktuellen Ordner einfügen, d.h. die Datei wurde kopiert.\n- Menüitem „Umbenennen“: Mit Hilfe dieses Items können Sie den Namen des Ordners ändern. Es öffnet sich eine Dialogbox, in der Sie den gewünschten Namen eingeben können.\n\nMöchten Sie einen Ordner samt aller seiner Unterordner und Dateien in einen anderen Ordner verschieben, klicken Sie den entsprechenden Ordner im Dateibaum an und verschieben Sie den Mauscursor bei gedrückter Maustaste über den Namen des Ordners, in den der Ordner verschoben werden soll. Der Name verschwindet aus dem vorherigen Ordner und erscheint im neuen Ordner, falls dieser geöffnet ist. Führen Sie die Funktion bei gedrückter „Strg“-Taste durch, wird der Ordner samt Inhalt kopiert anstelle von verschoben.\n\n4.2.12 Speichern zusammen mit einem Territorium\n\n4.2.13 Gleichzeitiges Öffnen eines Hamster-Programms und Territoriums\n\nWenn Sie ein Hamster-Programm öffnen bzw. aktivieren, wird automatisch überprüft, ob es im gleichen Verzeichnis eine zum Hamster-Programm gleichnamige Territorium-Datei gibt. In diesem Fall wird gleichzeitig mit dem Hamster-Programm auch das entsprechende Territorium geladen und im Simulation-Fenster angezeigt.\n\n4.3 Compilieren von Hamster-Programmen\n\n\n4.3.1 Compilieren\n\nWenn Sie das „Kompilieren“-Menütem im „Kompilieren“-Menü oder in der Toolbar des Editor-Fensters den „Kompilieren“-Button (vierzehnter Toolbar-Button von links) anklicken, wird das Programm, das gerade im Eingabebereich des Editor-Fensters sichtbar ist, kompiliert. Wenn Sie zuvor Änderungen am Sourcecode vorgenommen und noch nicht abgespeichert haben, werden Sie durch eine Dialogbox gefragt, ob das Programm vor dem Kompilieren gespeichert werden soll oder nicht.\n\nWenn Ihr Programm korrekt ist, erscheint nach ein paar Sekunden eine Dialogbox mit einer entsprechenden Meldung. Es wurde ein (neues) ausführbares Programm erzeugt.\n\n4.3.2 Beseitigen von Fehlern\n\nWenn Ihr Programm Fehler enthält, öffnet sich unterhalb des Eingabebereichs ein neuer Bereich, der die Fehlermeldungen des Compilers anzeigt (siehe Abbildung 16). Es wurde kein (neues) ausführbares Programm erzeugt! Jede Fehlermeldung erscheint in einer eigenen Zeile. Jede Zeile enthält den (wahrscheinlichen) Fehler, die Anweisung, die den Fehler enthält, die Zeile der Anweisung im Programm und den Dateinamen. Wenn Sie eine Fehlermeldung anklicken, wird die entsprechende Anweisung im Eingabebereich blau markiert und der Mauscursor an die entsprechende Stelle gesetzt. Sie müssen nun die einzelnen Fehler beseitigen und dann erneut speichern und kompilieren, bis Ihr Programm keine Fehler mehr enthält. Der Fehlermeldungsbereich schließt sich dann automatisch wieder.\n\n4.3.3 Setzen des CLASSPATH\n\nAls zweites Menüitem enthält das „Kompilieren“-Menü ein Menüitem mit der Bezeichnung „CLASSPATH setzen“. Was es damit auf sich hat, entnehmen Sie bitte Kapitel 14 von Band 2 des Java-Hamster-Buches. Als Anfänger müssen Sie sich hiermit nicht auseinandersetzen.\n\n4.4 Verwalten und Gestalten von Hamster-Territorien\n\n\nAbbildung 17: Toolbar des Simulation-Fensters\n\n### 4.4.1 Verändern der Größe des Hamster-Territoriums\n\n\n### 4.4.2 Platzieren des Standard-Hamsters im Hamster-Territorium\n\n\nEine Deaktivierung der Hamster-Versetzen-Funktion ist durch Anklicken des „Körner setzen“, „Mauer setzen“- oder „Kachel löschen“-Buttons und der damit verbundenen Aktivierung der entsprechenden Funktion möglich.\n\n### 4.4.3 Setzen der Blickrichtung des Standard-Hamsters\n\n4.4.4 Abfragen und Festlegen der Körneranzahl im Maul des Standard-Hamsters\n\n\n4.4.5 Platzieren von Körnern auf Kacheln des Hamster-Territorium\n\n\nEs ist auch möglich, die Anzahl an Körnern auf mehreren Kacheln gleichzeitig festzulegen. Klicken Sie dazu die Maus auf einer der Kacheln und ziehen Sie den Mauscursor bei gedrückter Maustaste über die anderen Kacheln. Alle betroffenen Kachel werden zunächst durch ein Korn in der Mitte markiert. Wenn Sie dann die Maustaste loslassen, erscheint die Dialogbox zur Eingabe der Körneranzahl. Die Anzahl an Körnern, die sie jetzt eingeben, wird dann auf allen markierten Kacheln abgelegt.\n\nEine Deaktivierung der Körner-Setzen-Funktion ist durch Anklicken des „Hamster versetzen“-, „Mauer setzen“- oder „Kachel löschen“-Buttons und der damit verbundenen Aktivierung der entsprechenden Funktion möglich.\n\n4.4.6 Platzieren von Mauern auf Kacheln des Hamster-Territorium\n\nDabei gilt: Es nicht nicht möglich, auf einer Kachel, auf der sich aktuell ein Hamster befindet, eine Mauer zu platzieren. Liegen auf einer angeklickten Kachel Körner, werden diese gelöscht.\n\n\nEine Deaktivierung der Mauer-Setzen-Funktion ist durch Anklicken des „Hamster versetzen“-, „Körner setzen“ oder „Kachel löschen“-Buttons und der damit verbundenen Aktivierung der entsprechenden Funktion möglich.\n\n4.4.7 Löschen von Kacheln des Hamster-Territorium\n\n\nEs ist auch möglich, mehrere Kacheln gleichzeitig zu löschen. Klicken Sie dazu die Maus auf einer der Kacheln und ziehen Sie den Mauscursor bei gedrückter Maustaste über die anderen Kacheln. Alle Kacheln, die nach Loslassen der Maustaste gelöscht werden, werden durch ein rotes X gekennzeichnet.\n\n\n4.4.8 Abspeichern eines Hamster-Territoriums\n\n\nMit dem „Speichern mit Territorium“-Button des Editor-Fensters haben Sie auch die Möglichkeit, das aktuelle Hamster-Programm zusammen mit dem aktuellen Territorium abzuspeichern. Das Territorium wird dabei in einer dem Hamster-Programm gleichnamigen Territorium-Datei abgespeichert.\n\n4.4.9 Wiederherstellen eines abgespeicherten Hamster-Territoriums\n\nAbgespeicherte Hamster-Territorien können mit dem „Territorium öffnen“-Button (zweiter Toolbar-Button von links) wieder geladen werden. Klicken Sie hierzu den Button. Es erscheint eine Dateiauswahl-Dialogbox, in der Sie die zu ladende Datei auswählen\nkönnen. Nach dem Anklicken des OK-Buttons schließt sich die Dialogbox und das entsprechende Hamster-Territorium ist wiederhergestellt.\n\n\n4.4.10 Umbenennen eines abgespeicherten Hamster-Territoriums\n\n\nAlternativ können Sie auch im Dateibaum des Editor-Fensters ein Popup-Menü oberhalb einer Territorium-Datei aktivieren und hierin die Funktion „Umbenennen“ auswählen.\n\n4.4.11 Löschen und Verschieben einer Datei mit einem Hamster-Territorium in einen anderen Ordner\n\nDas Löschen und Verschieben einer Datei mit einem abgespeicherten Territorium ist analog zu Hamster-Programmen über den Dateibaum im Editor-Fenster möglich.\n\n4.4.12 Verändern der Größendarstellung des Hamster-Territoriums\n\n\n4.5 Ausführen von Hamster-Programmen\n\n4.5.1 Starten eines Hamster-Programms\n\n\nEs können nur solche Programme ausgeführt werden, die in Dateien vom Typ „imperatives Programm“ oder „objektorientiertes Programm“ abgespeichert sind, also keine separaten Klassen. Befindet sich aktuell eine Datei mit einer separaten Klasse im Eingabebereich, erscheint der „Ausführen“-Button auch ausgegraut und kann nicht angeklickt werden.\n\nNach dem Starten eines Hamster-Programms werden die Hamster im Hamster-Territorium aktiv und tun das, was das Programm ihnen befiehlt. Während des Ausführens eines Hamster-Programms wird der Eingabebereich im Editor-Fenster ausgegraut, d.h. es können während der Ausführung eines Programms keine Änderungen am Sourcecode durchgeführt werden.\n\nWenn Sie vor dem Anklicken des „Ausführen“-Buttons die Datei im Eingabebereich geändert, aber noch nicht gespeichert und/oder kompiliert haben, werden Sie über entsprechende Dialogboxen gefragt, ob das Abspeichern und Kompilieren noch vor dem Ausführen erledigt werden soll oder nicht.\n\n4.5.2 Stoppen eines Hamster-Programms\n\nDie Ausführung eines Hamster-Programms kann durch Anklicken des „Stopp“-Buttons (erster Toolbar-Button des Simulation-Fensters von rechts) jederzeit abgebrochen werden.\n4.5.3 Pausieren eines Hamster-Programms\n\nMöchten Sie ein in Ausführung befindliches Programm anhalten, können Sie dies durch Anklicken des „Pause“-Buttons (zweiter Toolbar-Button des Simulation-Fensters von rechts) tun. Wenn Sie anschließend auf den „Ausführen“-Button klicken, wird das Programm fortgeführt.\n\n4.5.4 Während der Ausführung eines Hamster-Programms\n\n\n4.5.5 Einstellen der Geschwindigkeit\n\n4.5.6 Wiederherstellen eines Hamster-Territoriums\n\n\n4.5.7 Mögliche Fehlerquellen\n\nIm Folgenden werden die häufigsten Fehlerquellen genannt, die bei der Ausführung eines Programms auftreten können:\n\n- Sie haben ein neues Programm geschrieben und auch abgespeichert, aber nicht kompiliert oder der Compiler hat Fehler gemeldet. In diesem Fall erscheint beim Starten des Programms die Laufzeitfehler-Dialogbox mit der Fehlermeldung „ClassNotFoundException“.\n\n- Sie haben den Sourcecode eines Programms verändert, eventuell auch noch abgespeichert, aber nicht neu kompiliert. Oder Sie haben zwar kompiliert, der Compiler hat jedoch Fehlermeldungen geliefert. In diesem Fall wird das alte Programm ausgeführt.\n\n- Bei objektorientierten Programmen müssen Sie darauf achten, dass, wenn Sie Werte von Konstanten im Sourcecode ändern, alle Dateien, die diese Konstanten benutzen, neu kompiliert werden müssen. Ansonsten arbeiten die nicht kompilierten Dateien noch mit den alten Werten.\n\n- Wenn in einem objektorientierten Programm eine Klasse X eine Klasse Y referenziert und umgekehrt, müssen Sie zunächst X kompilieren, dann Y und anschließend nochmal X.\n\n4.6 Debuggen von Hamster-Programmen\n\n\nDer Debugger ist im Hamster-Simulator dem Editor-Fenster zugeordnet. Seine Funktionen sind eng mit den Funktionen zur Programmausführung verknüpft. Sie finden die Funktionen im Menü „Debugger“. Es bietet sich jedoch an, die entsprechenden Graphik-Buttons der Toolbar zu verwenden. Neben dem „ Ausführen“-, dem „Pause“- und\n\nAbbildung 19: Toolbar des Editor-Fensters\n\n4.6.1 Aktivieren bzw. deaktivieren des Debuggers\n\nSie können den Debugger durch Anklicken des „Debugger aktivieren“-Buttons in der Toolbar (dritter Toolbar-Button von rechts) aktivieren bzw. durch erneutes Anklicken wieder deaktivieren. Der Debugger ist aktiviert, wenn der Hintergrund des Buttons dunkler erscheint.\n\nDas Aktivieren bzw. Deaktivieren des Debuggers ist vor, aber auch noch während der Ausführung eines Programms möglich.\n\n4.6.2 Beobachten der Programmausführung\n\nWenn der Debugger aktiviert ist und Sie ein Programm mit dem „Ausführen“-Button starten, öffnen sich im Editor-Fenster oberhalb des Eingabebereiches zwei neue Bereiche. Der linke dieser beiden Bereiche heißt Funktionen-Bereich, der rechte Variablen-Bereich (siehe auch Abbildung 20).\nAbbildung 20: Debugging-Fenster\n\n\nIm Variablen-Bereich werden die aktiven Variablen und ihre aktuellen Werte angezeigt. Die Darstellung erfolgt dabei analog zu einem Dateibaum, d.h. bei komplexen Variablen, wie Objekten oder Arrays, können Sie durch Anklicken des Symbols vor dem Variablennamen die Attribute bzw. Komponenten einsehen.\n\nIm Eingabebereich selbst wird jeweils der Sourcecode eingeblendet, der gerade ausgeführt wird. Die Zeile mit der gerade aktiven Anweisung wird durch einen blauen Balken hinterlegt. Bei (objektorientierten) Programmen, die aus mehreren Dateien bestehen, werden gegebenfalls Dateien automatisch geöffnet.\n\n\n4.6.3 Schrittweise Programmausführung\n\nMit den beiden Buttons „Schritt hinein“ (zweiter Toolbar-Button von rechts) und „Schritt über“ (erster Toolbar-Button von rechts) ist es möglich, ein Programm schrittweise, d.h.\nAnweisung für Anweisung auszuführen. Immer, wenn Sie einen der beiden Buttons anklicken, wird die nächste Anweisung – und nur die! – ausgeführt.\n\nDie beiden Buttons unterscheiden sich genau dann, wenn die nächste Anweisung ein Prozedur-, Funktions- oder Methodenaufruf ist. Das Anklicken des „Schritt hinein“-Buttons bewirkt in diesem Fall, dass in den entsprechenden Rumpf der Prozedur, Funktion oder Methode verzweigt wird, so dass man die dortigen Anweisungen ebenfalls Schritt für Schritt weiter ausführen kann. Beim Anklicken des „Schritt über“-Buttons wird die komplette Prozedur, Funktion oder Methode in einem Schritt ausgeführt.\n\n\nSie können die „Schritt hinein“- und „Schritt über“-Buttons auch nutzen, wenn der Debugger aktiv ist und die Programmausführung durch Anklicken des „Pause“-Buttons angehalten wurde. Wenn Sie also die Programmausführung erst ab einer bestimmten Stelle beobachten möchten, können Sie das Programm zunächst einfach starten, dann anhalten, den Debugger aktivieren und dann schrittweise weiter ausführen.\n\nWenn Sie irgendwann ein Programm nicht weiter schrittweise ausführen möchten, können Sie durch Anklicken des Ausführen-Buttons die automatische Programmausführung wieder aktivieren.\n\n4.7 3D-Simulationsfenster und Sound\n\n\nÖffnen Sie dazu im Editor-Fenster in der Menüleiste das Menü „Fenster“ und aktivieren Sie den Eintrag „3D-Simulation“. Nach ein paar Sekunden Wartezeit öffnet sich das in Abbildung 21 gezeigte Fenster. Wenn sich der Eintrag nicht aktivieren lässt, ist eine 3D-Ansicht auf Ihrem Rechner leider nicht möglich.\nDas 3D-Simulationsfenster enthält keine Buttons zur Gestaltung eines Territoriums. Die Territoriumsgestaltung findet ausschließlich im 2D-Simulationsfenster statt. Das 3D-Simulationsfenster wird aber immer automatisch entsprechend aktualisiert.\n\n\n### 4.7.1 Steuerung mittels der Toolbar\n\nMit den ersten beiden Buttons können Sie in das Territorium hein- und hinauszoomen. Die nächsten beiden Buttons erlauben das Drehen der Hamsterwelt. Gedreht wird dabei immer um den Punkt, auf den die Kamera schaut. Der Neigungswinkel der Kamera lässt sich mit dem nächsten Buttonpaar einstellen. Hier ist keine völlig freie Bewegung möglich; so lässt sich die Welt von einem recht flachen Winkel bis hin zur Vogelperspektive betrachten. Über 90 Grad lässt sich die Kamera nicht neigen; die Szene kann also nicht auf dem Kopf stehen.\n\nMit dem siebten Button der Toolbar kann die Ansicht in eine Ich-Perspektive umgeschaltet werden. In dieser Ansicht wird die Welt aus der Ansicht des Standard-Hamsters gezeigt und man folgt diesem auf seinem Weg durch das Territorium. Durch wiederholtes Drücken des Buttons wird die Ansicht wieder gewechselt.\n\nÜber den achten Button können die Gitterlinien entfernt bzw. eingeblendet werden.\n\n\nDie weiteren Elemente der Toolbar kennen Sie bereits aus dem 2D-Simulationsfenster. Sie dienen zum Starten, Pausieren und Stoppen der Ausführung eines Hamster-Programms sowie zum Einstellen der Ausführungsgeschwindigkeit.\n4.7.2 Steuerung mittels der Maus\n\n\n4.8 Dateiverwaltung auf Betriebssystemebene\n\n\nDateien mit Sourcecode von Hamster-Programmen haben die Endung „.ham“. Dateien mit Hamster-Territorien haben die Endung „.ter“. Ansonsten gibt es noch Dateien mit der Endung „.java“ und „.class“. Diese werden beim Kompilieren generiert und enthalten Java-Sourcecode („.java“) bzw. ausführbaren Java-Bytecode („.class“).\n\nSie können Hamster-Programme auch mit anderen Editoren entwickeln. Dabei gilt es allerdings folgendes zu beachten:\n\n- Objektorientierten Hamster-Programmen muss folgender Kommentar unmittelbar vorangestellt werden: /*object-oriented program*/\n- Separaten Klassen und Interfaces muss der Kommentar /*class*/ unmittelbar vorangestellt werden.\n- Imperativen Hamster-Programmen sollte (muss aber nicht) folgender Kommentar unmittelbar vorangestellt werden: /*imperative program*/\n\nDie Kommentare kennzeichnen den Typ der Programme. Sie werden vom Editor des Hamster-Simulators automatisch generiert.\n\n\nIm Workspace-Ordner befindet sich eine Datei namens settings.properties, in der der aktuelle CLASSPATH (siehe Abschnitt 4.3.3) gespeichert wird.\n5 Properties\n\nÜber so genannte Properties können sie bestimmte Voreinstellungen des Simulators überlagern.\n\n5.1 Vorhandene Properties\n\n\nMomentan sind folgende Properties möglich:\n\n5.1.1 security\n\nBefindet sich in der Datei „hamster.properties“ eine Zeile mit dem folgenden Text\n\nsecurity=false\n\n\nDurch Setzen der security-Property auf false ist es bspw. möglich, aus Hamster-Programmen heraus Sounds abzuspielen. Im folgenden Hamster-Programm wird ein Sound aus der angegebenen Datei abgespielt, während der Hamster zur Mauer läuft:\n\n```java\nvoid main() {\n try {\n java.io.File f = new java.io.File( \"C:\\fanfare.wav\" );\n java.applet.AudioClip audioClip =\n java.applet.Applet.newAudioClip(f.toURL() );\n audioClip.play();\n } catch (Exception exc) { }\n\n while (vornFrei()) vor();\n}\n```\n5.1.2 workspace\n\n\nworkspace=C:/Dokumente und Einstellungen/karl oder\n\nworkspace=C:/Dokumente und Einstellungen/heidig/Eigene Dateien oder\n\nWenn Sie den Workspace-Ordner verändern und mit Paketen arbeiten, muss im CLASSPATH anstelle von „Programme“ der String angegeben werden, den Sie der Property workspace zugewiesen haben, also bspw. C:\\DokumenteundEinstellungen\\karl oder ..\\test.\n\nSeit Version 2.9.3 des Hamster-Simulators kann die Property \"workspace\" auch Umgebungsvariablen enthalten, z.B.\nworkspace=${(HOMEDRIVE)/(HOMEPATH)/HamsterProgramme\n\n5.1.3 logfolder\n\n\nBefindet sich in der Datei eine Zeile, die mit dem Text logfolder= beginnt, wird der dahinter angegebene Ordner als Logfolder-Ordner gesetzt, bspw.\n\nlogfolder=C:/Dokumente und Einstellungen/karl oder\n\nlogfolder=C:/Dokumente und Einstellungen/heidig/Eigene Dateien oder\nlogfolder=../test. Der angegebene Ordner muss existieren und er muss lesbar und beschreibbar sein! Achten Sie bitte darauf, dass in dem Ordner-Namen keine Sonderzeichen vorkommen (bspw. ein Ausrufezeichen), da die einige Java-Versionen\n\n³Aus Kompatibilität zu früheren Versionen des Hamster-Simulators kann diese Property auch home genannt werden.\n\n5.1.4 scheme\n\n\n5.1.5 runlocally\n\n\n5.1.6 language\n\n5.1.7 indent\n\n\nÜber das Menu „Extras“ kann der indent-Modus auch während der Programmausführung noch geändert werden.\n\n5.1.8 color\n\nÜber die Property „color“ kann die Farbe des Standard-Hamsters geändert werden. Voreingestellt ist BLAU. Möglich sind folgende Farben: BLAU, BLUE, ROT, RED, GRÜEN, GREEN, GELB, YELLOW, CYAN, MAGenta, ORANGE, PINK, GRAU, GRAY, WEISS und WHITE.\n\nWeiterhin wurde für objektorientierte Programme in der Klasse Hamster ein zusätzlicher Konstruktor eingeführt, bei dem als fünften Parameter die Farbe des Hamsters angegeben werden kann. Die Klasse Hamster stellt hierfür entsprechenden Konstanten zur Verfügung:\n\n```java\npublic final static int BLAU = 0;\npublic final static int BLUE = 0;\n\npublic final static int ROT = 1;\npublic final static int RED = 1;\n\npublic final static int GRÜEN = 2;\npublic final static int GREEN = 2;\n\npublic final static int GELB = 3;\npublic final static int YELLOW = 3;\n\npublic final static int CYAN = 4;\n\npublic final static int MAGenta = 5;\n\npublic final static int ORANGE = 6;\n\npublic final static int PINK = 7;\n\npublic final static int GRAU = 8;\npublic final static int GRAY = 8;\n\npublic final static int WEISS = 9;\n```\npublic final static int WHITE = 9;\n\n// neuer zusätzlicher Konstruktor\npublic Hamster(int reihe, int spalte,\n int blickrichtung, int anzahlKoerner,\n int farbe)\n\n5.1.9 3D\n\n\n5.1.10 Lego\n\n\n5.1.11 Prolog\n\n\n5.1.12 Plcon\n\nÜber die Property „plcon“ kann der Pfad zum SWIProlog-Interpreter angegeben werden. Standardmäßig ist dort der Wert „swipl.exe“ angegeben. Wurde SWIProlog installiert und die PATH-Umgebungsvariable entsprechend angepasst, sollte das unter WINDOWS funktionieren. Für andere Betriebssysteme (LINUX, ...) muss hier eventuell der vollständige Pfad zum SWIProlog-Interpreter angegeben werden, bspw. in der Form\n\nplcon=C:/Programme/pl/bin/swipl.exe oder\nplcon=C:\\\\Programme\\\\pl\\\\bin\\\\swipl.exe\n\n5.1.13 laf\n\nÜber die Property „laf“ kann (seit der Version 2.7) das Look-And-Feel des Hamster-Simulators, d.h. sein Erscheinungsbild, verändert werden. Folgende Einstellungen sind dabei möglich:\n\nlaf=com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel\nlaf=com.sun.java.swing.plaf.windows.WindowsLookAndFeel\nlaf=com.sun.java.swing.plaf.motif.MotifLookAndFeel\nlaf=javax.swing.plaf.metal.MetalLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceBusinessLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceBusinessBlueSteelLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceBusinessBlackSteelLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceCremeLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceCremeCoffeeLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceSaharaLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceModerateLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceOfficeSilver2007LookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceOfficeBlue2007LookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceNebulaLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceNebulaBrickWallLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceAutumnLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceMistSilverLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceMistAquaLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceDustLookAndFeel\nlaf=org.jvnet.substance.skin.SubstanceDustCoffeeLookAndFeel\nlaf=org.jvnet.substance.api.skin.SubstanceGeminiLookAndFeel\nlaf=org.jvnet.substance.api.skin.SubstanceRavenGraphiteLookAndFeel\nlaf=default\n\nStandardeinstellung ist „default“. Probieren Sie doch einfach mal das ein oder andere LAF aus. Die meisten LAFs stammen übrigens aus dem Projekt substance (https://substance.dev.java.net/)\n\n5.1.14 python\n\n\n5.1.15 ruby\n\n5.1.16 scratch\n\n\n- scratch_new_procedure=Neue Prozedur\n- scratch_new_function=Neue Funktion\n- scratch_void_return=verlasse\n- scratch_bool_return=liefere\n- scratch_true=wahr\n- scratch_false=falsch\n- scratch_and=und\n- scratch_or=oder\n- scratch_not=nicht\n- scratch_if=falls\n- scratch_else_if=falls\n- scratch_else=sonst\n- scratch_while=solange\n- scratch_do=wiederhole\n- scratch_do_while=solange\n\n5.1.17 fsm\n\n5.1.18 flowchart\n\n\n5.1.19 javascript\n\n\n5.2 Mehrbenutzerfähigkeit\n\nSeit Version 2.3 ist der Hamster-Simulator Mehrbenutzer-fähig, d.h. er kann einmal auf einem Server installiert und dann von mehreren Nutzern (gleichzeitig) genutzt werden. Jeder Nutzer hat dabei seinen eigenen Ordner für die Hamster-Programme.\n\nUm die Mehrbenutzer-Fähigkeit des Hamster-Simulators zu nutzen, muss ein Nutzer eine Datei namens „hamster.properties“ in seinem HOME-Verzeichnis anlegen (bspw. durch Kopieren der gleichnamigen Datei aus dem Ordner, wo sich auch die Dateien „hamstersimulator.jar“ bzw. „hamstersimulator.bat“ befinden). Die Property-Einstellungen in der Datei im HOME-Verzeichnis haben dabei die höchste Priorität bezogen auf den Nutzer!\n\nIn der Datei „hamster.properties“ in seinem HOME-Verzeichnis sollte dann jeder Nutzer die Properties workspace und logfolder entsprechend seinen Wünschen setzen, d.h. dort sollten die Ordner eingetragen werden, in dem die Hamster-Programme dieses Nutzers gespeichert bzw. in dem die Log-Dateien sysout.txt und syserr.txt erzeugt werden sollen.\n6 Englischsprachiger Hamster\n\nSeit Version 2.4 des Hamster-Simulators ist der Hamster-Simulator in die englisch-sprachige Welt integriert worden. Das betrifft zunächst die Benutzungsoberfläche. Durch Einstellen der Property language auf den Wert en erscheinen alle Ausgaben in englischer Sprache.\n\nAber nicht nur die Oberfläche auch das Hamster-Modell selbst wurde angepasst. Bswp. versteht der Hamster ab sofort nicht mehr nur den Befehl vor();, sondern auch den Befehl move();, der dasselbe bewirkt: Der Hamster springt eine Kachel in Blickrichtung nach vorne.\n\nIm Folgenden wird ein Überblick über die entsprechenden englischen Befehle bzw. Klassen des Hamster-Modells gegeben:\n\nvor move\nlinksUm turnLeft\nnimn pickGrain\ngib putGrain\nvornFrei frontIsClear\nkornDa grainAvailable\nmaulLeer mouthEmpty\nliesZahl readNumber\nliesZeichenkette readString\nschreib write\ninit init\ngetReihe getRow\ngetSpalte getColumn\ngetBlickrichtung getDirection\ngetStandardHamster getDefaultHamster\ngetAnzahlKoerner getNumberOfGrains\ngetAnzahlHamster getNumberOfHamsters\nTerritorium Territory\n\nHamsterInitialisierungsException HamsterInitializationException\nHamsterNichtInitialisiertException HamsterNotInitializedException\nKachelLeerException TileEmptyException\nMauerDaException WallInFrontException\nMaulLeerException MouthEmptyException\nEin imperatives englisches Hamster-Programm, bei dem der Hamster alle vor ihm liegenden Körner einsammeln soll, sieht damit folgendermaßen aus:\n\nvoid main() {\n pickAll();\n while (frontIsClear()) {\n move();\n pickAll();\n }\n}\n\nvoid pickAll() {\n while (grainAvailable())\n pickGrain();\n}\n\nDas folgende Programm skizziert ein objektorientiertes englisches Hamster-Programm:\n\nclass MyHamster extends Hamster {\n MyHamster(Hamster h) {\n super(h.getRow(), h.getColumn(),\n h.getDirection(), h.getNumberOfGrains());\n }\n\n void turnRight() {\n this.turnLeft();\n this.turnLeft();\n this.turnLeft();\n }\n}\n\nvoid main() {\n MyHamster paul = new MyHamster(Hamster.getDefaultHamster());\n try {\n while (true) {\n paul.move();\n }\n } catch (WallInFrontException exc) {\n }\n paul.turnRight();\n paul.write(\"Number of Hamsters: \" +\n Territory.getNumberOfHamsters());\n}\n\nPrinzipiell kann man übrigens auch die deutschen und englischen Befehle mischen.\n7 Scheme\n\n\nDieses Benutzerhandbuch enthält keine Einführung in die funktionale Programmierung und auch keine Einführung in die Programmiersprache Scheme. Hierzu wird auf die im folgenden genannte Literatur verwiesen. Wenn Sie also Scheme lernen wollen, sollten Sie sich eines der genannten Bücher beschaffen oder die online-verfügbare Literatur sichten.\n\nEin Problem vieler Anfängerbücher für Scheme ist, dass nahezu alle Beispiele aus der Welt der Mathematik stammen, was Schüler bzw. Studierende, die keinen großen Bezug zur Mathematik haben, häufig abschreckt. An dieser Stelle setzt das Hamster-Modell an. Sie können Scheme quasi unabhängig von Ihren mathematischen Fähigkeiten lernen, in dem Sie einen Hamster durch ein Territorium steuern und ihn bestimmte (nicht-mathematische) Aufgaben lösen lassen.\n\n7.1 Funktionale Programmiersprachen\n\nDie wichtigsten Unterschiede funktionaler Programmiersprachen gegenüber imperativen Programmiersprachen sind:\n\n- Programme funktionaler Programmiersprachen werden als mathematische Funktionen betrachtet.\n- Funktionen werden als Daten behandelt.\n- Seiteneffekte von Funktionen werden stark eingeschränkt.\n- Es gibt keine Variablen.\n- Es gibt keine Schleifen.\n- Rekursion spielt in der funktionalen Programmierung eine entscheidende Rolle.\n- Zentrale Datenstruktur der funktionalen Programmierung ist die Liste.\n\n7.2 Die Programmiersprache Scheme\n\nDie erste funktionale Programmiersprache, die in den 60er Jahren entwickelt wurde, hieß LISP. Von Lisp wurden viele Dialekte entwickelt. Die beiden Dialekte, die zum Standard geworden sind, heißen Common Lisp und eben Scheme, d.h. Scheme ist ein standardisierter Lisp-Dialekt.\n\nScheme ist keine rein-funktionale Programmiersprache. Vielmehr enthält sie auch Konzepte der imperativen Programmierung (Schleifen, Variablen). Um funktional programmieren zu lernen, sollten Sie sich jedoch auf die funktionalen Konzepte beschränken und die imperativen Konzepte nicht benutzen!\n\nIm Internet finden sich eine Reihe von Informationen über und Online-Tutorials zu Scheme:\n\n- http://de.wikipedia.org/wiki/Scheme\n- http://www.htdp.org/ (How to design programs)\n- http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme-Z-H-1.html (Teach Yourself Scheme in Fixnum Days)\n- http://cs.wwc.edu/KU/PR/Scheme.html (kurzes Scheme-Tutorial)\n\n7.3 Scheme-Hamster-Programme\n\nUm Scheme-Hamster-Programme zu entwickeln und zu testen, müssen Sie die Property scheme auf true gesetzt haben (siehe Abschnitt\n5). Dies ist standardmäßig nicht der Fall.\nAnschließend müssen Sie eine neue Datei öffnen (Menü „Datei“, Item „Neu“) und in der Auswahl „Scheme-Programm“ auswählen. Es erscheint eine neue Datei mit folgendem Grundgerüst:\n\n```\n(define (start Territorium)\n ()\n)\n```\n\nDie zweite Zeile ersetzen Sie dabei durch entsprechende Scheme-Anweisungen. Bspw. lässt das folgende Scheme-Programm den Hamster zwei Schritte vorlaufen:\n\n```\n(define (start Territorium)\n (vor (vor Territorium))\n)\n```\n\nAnschließend müssen Sie die neue Datei abspeichern. Nach dem Speichern können Sie Ihr Scheme-Programm durch Drücken des Start-Buttons ausführen. Kompilieren ist nicht notwendig, Scheme-Programme werden interpretiert, d.h. wenn sie Fehler enthalten, werden Sie darüber zur Ausführungszeit informiert.\n\n### 7.4 Grundlagen und Befehle\n\n#### 7.4.1 Territoriumsliste\n\nDie grundlegende Datenstruktur des Scheme-Hamster-Modells ist die Territoriumsliste. Sie spiegelt das aktuelle Territorium des Simulation-Fensters wieder. Sie ist folgendermaßen aufgebaut (in EBNF):\n\n```\n<territorium> ::= \"(\" <feld-liste> <hamster-liste> \")\"\n<feld-liste> ::= \"(\" { <reihe-liste> } \")\"\n<reihe-liste> ::= \"(\" { <kachel> } \")\"\n<kachel> ::= \"(\" \"Kachel\" <koerner-auf-kachel> \")\"\n | \"(\" \"Mauer\" \")\"\n<hamster-liste> ::= \"(\" \"Hamster\"\n <reihe>\n <spalte>\n <koerner-im-maul>\n <blickrichtung>\n \")\"\n<blickrichtung> ::= \"Nord\"\n | \"Ost\"\n```\n| \"Sued\"\n| \"West\"\n\n<kerner-auf-kachel> ist positiver int-Wert\n<reihe> ist positiver int-Wert oder 0\n<spalte> ist positiver int-Wert oder 0\n<kerner-im-maul> ist positiver int-Wert\n\nDer Ursprung des Territoriums befindet sich in der linken oberen Ecke. Die Nummerierung von Spalten und Zeilen beginnt bei 0.\n\n\n```\n{\n ( (\"Kachel\" 0) (\"Kachel\" 3) (\"Mauer\") )\n ( (\"Kachel\" 0) (\"Kachel\" 3) (\"Mauer\") )\n (\"Hamster\" 1 0 3 \"Nord\")\n}\n```\n\n### 7.4.2 Hamster-Befehle\n\nDie Hamster-Befehle des Java-Hamster-Modells sind als Funktionen implementiert, die ein Territorium auf ein neues Territorium abbilden, und zwar mit der bekannten Semantik der Hamster-Grundbefehle:\n\n- **(vor Territorium)** liefert ein Territorium, in dem der Hamster gegenüber dem als Parameter übergebenen Territorium eine Kachel in Blickrichtung gelaufen ist\n- **(linksUm Territorium)** liefert ein Territorium, in dem sich der Hamster gegenüber dem als Parameter übergebenen Territorium um 90 Grad nach links umgedreht hat\n- **(nimmt Territorium)** liefert ein Territorium, in dem der Hamster gegenüber dem als Parameter übergebenen Territorium ein Korn mehr im Maul hat und sich auf der entsprechenden Kachel ein Korn weniger befindet\n- **(gibt Territorium)** liefert ein Territorium, in dem der Hamster gegenüber dem als Parameter übergebenen Territorium ein Korn weniger im Maul hat und sich auf der entsprechenden Kachel ein Korn mehr befindet\n- **(vornFrei? Territorium)** liefert true, wenn sich in dem als Parameter übergebenen Territorium keine Mauer vor dem Hamster befindet\n• **(maulLeer? Territorium)** liefert true, wenn in dem als Parameter übergebenen Territorium der Hamster keine Körner im Maul hat\n• **(kornDa? Territorium)** liefert true, wenn sich in dem als Parameter übergebenen Territorium auf der Kachel, auf der der Hamster steht, mindestens ein Korn befindet\n\nBei den Befehlen **vor, nimm** und **gib** können die bekannten Fehler auftreten.\n\nIm Hamster-Simulator geschieht nach dem Ausführen eines der vier Hamster-Grundbefehle folgendes: Das von der entsprechenden Funktion gelieferte Territorium wird im Simulation-Fenster angezeigt!\n\n### 7.4.3 Scheme-Hamster-Programme\n\nEin Scheme-Hamster-Programm hat immer folgende Gestalt:\n\n```\n(define (start Territorium)\n <Funktionsaufruf>\n)\n```\n\n**start** ist die Funktion, die beim Ausführen eines Hamster-Programms aufgerufen wird. Ihr wird als Parameter die entsprechende Listenrepräsentation des aktuell im Simulation-Fenster angezeigten Territoriums übergeben.\n\nIm folgenden Hamster-Programm hüft der Hamster eine Kachel nach vorne:\n\n```\n(define (start Territorium)\n (vor Territorium)\n)\n```\n\nIm folgenden Hamster-Programm hüft der Hamster eine Kachel nach vorne und dreht sich anschließend nach links:\n\n```\n(define (start Territorium)\n (linksUm (vor Territorium))\n)\n```\n\nVergeichen Sie mit diesem Programm bitte das folgende Hamster-Programm:\n\n```\n(define (start Territorium)\n (vor Territorium)\n (linksUm Territorium)\n)\n```\n\n\n### 7.5 Beispiele\n\nEs folgen ein paar Beispiele für nützliche Scheme-Hamster-Funktionen:\n\n```scheme\n(define (kehrt T)\n (linksUm (linksUm T)))\n\n(define (rechtsUm T)\n (kehrt (linksUm T)))\n\n(define (nimmAlle T)\n (if (kornDa? T)\n (nimmAlle (nimm T))\n T)\n)\n\n(define (gibAlle T)\n (if (not (maulLeer? T))\n (gibAlle (gib T))\n T)\n)\n\n(define (vorwärts n T)\n (if (and (vornFrei? T) (> n 0))\n (vorwärts (- n 1) (vor T))\n T)\n)\n```\n\n73\nScheme-Konsole\n\nkönnen Sie nun Scheme-Befehle eingeben und durch Anklicken des „Ausführen“-Buttons ausführen. Ausgaben erscheinen im Ausgabebereich der Konsole.\n\nTippen Sie bspw. mal in den Eingabebereich der Scheme-Konsole folgendes ein: `(vor (getTerritorium))`. Der Hamster hüft eine Kachel nach vorne. Die Funktion getTerritorium liefert dabei die entsprechende Territoriumsliste des aktuell im Simulation-Fenster sichtbaren Territoriums.\n\n\nAktuell ist es in der Konsole nur möglich, Befehle einzeln auszuführen. Wenn Sie versuchen, mehrere Befehle gleichzeitig ausführen zu lassen, wird nur der letzte tatsächlich ausgeführt.\n\nSowohl der Eingabe- als auch der Ausgabebereich der Konsole unterstützen „Copy und Paste“, und zwar über die Tastatureingaben „Strg-c“ bzw. „Strg-v“.\n\nBei Ausführung der Scheme-Funktion read in der Scheme-Konsole, erscheint eine Dialogbox, in der Sie die Eingabe tätigen müssen.\n\nWenn Sie über die Konsole Funktionsdefinitionen ausführen, geben Sie diese dem kompletten System bekannt. D.h. Sie können die entsprechenden Funktionen danach auch in Scheme-Programmen nutzen, ohne sie erneut definieren zu müssen. Umgekehrt gilt dies genauso! Bei Beendigung des Hamster-Simulators gehen jedoch alle entsprechenden Definitionen „verloren“.\n\n### 7.7 Implementierungshinweise\n\n8 Prolog\n\n\n8.0 Voraussetzungen\n\n\nDie PROLOG-Komponente verwendet die konsolenbasierte Version des Interpreters (plcon.exe bzw. swipl.exe). Die dafür verantwortliche Anwendungsdatei befindet sich nach der Installation im Unterverzeichnis ‘bin’ des Installationsverzeichnisses von SWIProlog. Damit die Anwendungsdatei von der Java Virtual Machine gefunden werden kann, muss die Umgebungvariable PATH um den Pfad, standardmäßig C:\\Programme\\pl\\bin\\ erweitert werden.\n\nWeiterhin muss in der Datei „hamster.properties“ das Property prolog auf true gesetzt sein und unter Umständen muss das Property plcon auf den vollständigen Pfad zum SWIProlog-Interpreter gesetzt werden (siehe Abschnitt 5.1.11 und 5.1.12).\n\n8.1 Logikbasierte Programmierung\n\n\nDazu werden eine Menge von so genannten Regeln und Anweisungen, die der Syntax gemäß aufgebaut sind, zusammen mit der Information, welche Lösungsmethode vorgesehen ist, in den Programmcode eingefügt. Logische Programmiersprachen gehören zu den deklarativen Programmiersprachen und haben ihre Ursprünge im Forschungsgebiet Künstliche Intelligenz.\nIn einem imperativen Programm wird genau beschrieben, wie und in welcher Reihenfolge ein Problem zu lösen ist. Im Gegensatz dazu wird in einem logikbasierten Programm idealerweise nur beschrieben, was gilt. Das \"wie\" ist bereits durch die Lösungsmethode vorgegeben. Die Lösung wird aus den vorhandenen Regeln hergeleitet. Meistens wird schon nur eine Menge von Regeln als \"das Programm\" bezeichnet, wenn klar ist, welche Lösungsmethode dazugehört: Nämlich die (einzige) in der vom regelbasierten System bereit gestellten Inferenzmaschine verwirklichte.\n\nDie bekannteste logische Programmiersprache ist Prolog.\n\n8.2 Die Programmiersprache Prolog\n\n\nGegenüber den traditionellen, prozeduralen Programmiersprachen wie beispielsweise JAVA oder C++ hat die Programmierung in PROLOG einen ganz anderen Charakter. Wie bereits erwähnt, orientiert sich PROLOG an den Möglichkeiten einer eher abstrakteren Wissensdarstellung mit Hilfe des Prä dikatenkalküls erster Stufe, anstatt sich bei der traditioneller Rechnerarchitektur, wie es bei den anderen Sprachen der Fall ist, zu\n\n\\(^4\\)Institute for New Generation Computer Technology\n\n\n8.2.1 Syntax von Prolog\n\nDieser Abschnitt beschreibt die Regeln für die syntaktische Zusammensetzung der PROLOG-Programme. Im ersten Teil erfolgt die Vorstellung der grundlegenden Datentypen der Sprache. Im zweiten Teil wird der generelle Aufbau eines PROLOG-Programms beschrieben.\n\n8.2.1.1 Datentypen von Prolog\n\nWie auch jede andere Programmiersprache hat auch PROLOG zur Beschreibung und Charakterisierung von Informationen primitive Datentypen. Im Vergleich zu JAVA gibt es aber in PROLOG nur schwache Typisierung. Der endgültige Datentyp zu einem Ausdruck wird in PROLOG erst zur Laufzeit dynamisch ermittelt und zugewiesen. Nachfolgend werden die wichtigsten Datentypen von PROLOG beschrieben.\n\nTerm\n\nEinfache Terme\n\n**Atom-Beispiele:** kornfeld, hamster, 123ham, ‘ROGGEN’, ‘Weizen’\n\nDie **Zahlen** werden in PROLOG ebenfalls als konstante Termen dargestellt. Diese können als Integerzahlen (12, 3500, ...) oder Dezimalzahlen (mit Dezimalpunkt - 3.1415) oder Exponentenschreibweise (1.34e10) geschrieben werden. PROLOG definiert eine Reihe arithmetischer Operatoren und und vordefinierter Systemprädikate, die in Verbindung mit Zahlen-Termen eingesetzt werden können.\n\n**Variablen** sind spezielle Termen, die als Platzhalter für beliebige andere PROLOG-Terme dienen. Bei den Variablen unterscheidet man zwischen **anonymen** und **nicht anonymen** bzw. **normalen** Variablen. Der Variablen-Term besitzt in PROLOG zum leichteren Erkennen eine besondere Schreibweise:\n\n- Die *normale* Variable beginnt immer mit einem Großbuchstaben. Der Rest der Variable besteht aus Kleinbuchstaben, Ziffern oder dem Unterstreichungszeichen.\n \n Nicht anonyme Variablen: A, B, HamsterXYZ.\n\n\n Anonyme Variablen: _a, _myHam, _\n\nKomplexe Terme (Strukturen)\nEin komplexer Term kann im Allgemeinen durch ein Ausdruck der Form: \\( p(a_1, ..., a_n) \\) beschrieben werden. Er besteht aus einem Funktor \\( p \\) und einer beliebigen Anzahl von Argumenten \\( (a_1, ..., a_n) \\). Beim Funktor handelt es sich um ein Atom, welches in der Regel in der Präfixnotation mit der in runde Klammern eingeschlossenen Argumentenliste\ngeschrieben wird\\textsuperscript{5}. An Stelle der Argumente können beliebige \\textsc{prolog}-Terme, also Konstanten, Variablen oder auch komplexe Terme, verwendet werden. Die Anzahl der Argumente des komplexen Terms definiert seine Stelligkeit. Bei dem Term mit der Stelligkeit 0 handelt es sich in diesem Sinne um ein einfaches Atom. Nachfolgend sind einige Beispiele der komplexen Terme aufgelistet.\n\n\\begin{verbatim}\nTier(hamster)\nkornFeld(X, Y)\nliebt(hamster, koerner)\n\\end{verbatim}\n\nDer erste Term drückt die Beziehung aus, dass der Hamster ein Tier ist. Die Stelligkeit des Terms \\texttt{tier(hamster)} ist 1. Die Stelligkeit des zweiten Terms, \\texttt{kornfeld(X,Y)} ist 2. Dabei sind Argumente des Terms noch nicht genau spezifiziert. Dabei kann es sich an Stelle von \\texttt{X} und \\texttt{Y} noch um beliebige, auch nicht numerische Terme handeln. Der dritte Term definiert eine Beziehung \\texttt{liebt/2} zwischen den Atomen \\texttt{hamster} und \\texttt{koerner}. Die Reihenfolge der Angabe der Atome ist dabei sehr wichtig, die ein mehrstelliger \\textsc{prolog}-Term nicht kommutativ ist.\n\nDie komplexen Terme werden in \\textsc{prolog}, wie bereits angedeutet, dazu verwendet, Beziehungen zwischen Objekten und deren Eigenschaften herzustellen und den vorliegenden Daten eine bessere Strukturierung zu verleihen. In diesem Fall können komplexe Terme auch einfach als Prädikate bezeichnet. Zusätzlich können komplexe Terme aber auch dazu verwendet, Anfragen an das \\textsc{prolog}-System zu formulieren. Einige Argumente eines komplexen Terms werden dabei als Variablen deklariert, mit der Aufgabe an \\textsc{prolog}, entsprechende Belegungen für die zu finden. Wird ein komplexer Term zur Abfrage an \\textsc{prolog} verwendet, so handelt es sich dabei um einen (Prozedur-) Aufruf.\n\n**Listen**\n\nEine der wichtigsten und meist genutzten Datenstrukturen in \\textsc{prolog} ist die Liste. Dabei handelt es sich um eine rekursiv definierte Struktur, die zur Darstellung einer beliebig langen, geordneten Menge von Termen verwendet wird. Prinzipiell sind Listen nur spezielle komplexe Terme und können in \\textsc{prolog} durch die übliche, allgemeine Notation eines Terms ausgedrückt werden. Eine Liste aus drei Elementen \\texttt{a}, \\texttt{b} und \\texttt{c} kann wie folgt geschrieben werden: \\texttt{.[a,.(b,.(c,.[]))]}. Die Konstante \\texttt{[]} bezeichnet dabei eine leere Liste. Als Funktor bei einem Listen-Term wird das „\\texttt{[}“-Zeichen verwendet. Zu einer besseren Lesbarkeit und Handhabung gibt es in \\textsc{prolog} für die Liste eine besondere Schreibweise. Die vorherige Liste kann dabei wie folgt geschrieben werden: \\texttt{[a,b,c]}. Die Elemente der Liste werden voneinander mit Komma getrennt und in eckige Klammern eingeschlossen.\n\nNachfolgend werden einige Beispiele zur Definition von Listen angegeben.\n\n\\begin{verbatim}\n5\n\\end{verbatim}\n\n\\textsuperscript{5}Mit dem vordefinierten Operator op/3 ist es aber auch möglich alternative Notationen, wie zweistellige Infix-, oder einstellige Präfix-/Postfix-Operatoren zu definieren. In diesem Fall können die Klammern auch weggelassen werden.\n\n80\nL1 = [a, b, [c, d], e, f} oder L1 = (a, (b, (c, (d, []), (e, (f))))).\nL2 = [[hamster, [liebt, koerner]], [koerner sind braun]].\nL3 = [eine, mauer, ist, [vorne, hinten, rechts, links]].\n\n8.2.1.2 Aufbau des Programms\nEin PROLOG-Programm besteht aus einer Menge von Fakten, Regeln und Abfragen. Jedes dieser Elemente kann durch eine spezielle Form einer PROLOG-Klausel ausgedrückt werden. Die allgemeine Form einer PROLOG-Klausel hat die folgende Struktur\n\nKlauselkopf :- Klauselkörper.\n\n\nA :- B₁, ..., Bₙ.\n\n\nDeklarative und prozedurale Sicht auf das Programm\nbetrachtet werden. Die Auswertung der Regel würde in diesem Fall mit einer negativen Antwort (false) beendet werden. Bei der Abarbeitung einer Regel während der Programmausführung setzt PROLOG für die Definition der Regel-Klauseln die deklarative Sichtweise voraus.\n\n8.2.2 Operationale Semantik\n\nBei der Ausführung eines Programms führt das PROLOG-System für eine zuvor formulierte Zielklausel mehrere Berechnungsschritte durch. Die angegebene Zielklausel wird vorerst nur als These betrachtet, die im Nachfolgenden entweder zu beweisen oder zu widerlegen ist. Das PROLOG-System versucht daraufhin zu prüfen, ob die angegebene Zielklausel sich logisch aus den Prädikaten des vorliegenden Programms ableiten lässt.\n\nDer erste Schritt beim Abarbeiten einer Abfrage besteht darin, die einzelnen Subtermen der Zielklausel zur erfüllen. Dafür kommt in PROLOG der Unifikationsalgorithmus zum Einsatz. Der nachfolgende Abschnitt beschreibt das Wesen und die Funktionsweise der Unifikation.\n\n8.2.2.1 Unifikation\n\nDie Unifikation bezeichnet ein Vorgehen, bei welchem versucht wird, zwei Terme durch Auswahl gültiger Substitutionen zur Deckung zu bringen. Zwei Terme $t_1$ und $t_2$ sind dabei unifizierbar, wenn es eine Substitution $s$ gibt, sodass gilt: $s(t_1) = s(t_2)$. Das Ziel einer Unifikation liegt in der Suche nach einer solchen Substitution, die am wenigsten einschränkend auf die beiden Terme $t_1$ und $t_2$ wirkt. Das heißt, alle Variablen innerhalb eines Terms bleiben weiterhin unbelegt, sofern dies nicht unbedingt für die Deckung der Terme notwendig ist. Eine nach diesem Vorgehen gefundene Lösung wird als allgemeinster Unifikator bezeichnet.\n\nBeispiele\n\n- Die Terme $t_1 = f(X,b)$ und $t_2 = f(a,Y)$ sind unifizierbar, wenn $X$ durch $a$ und $Y$ durch $b$ ersetzt wird. Die dabei gesuchte Substitution lautet $\\sigma = \\{X/a, Y/b\\}$.\n\n- Die Terme $t_1 = f(a,b)$ und $t_2 = f(c,Y)$ sind nicht unifizierbar, da keines der ersten Argumente der Terme eine Variable beinhaltet.\n\n- Die Terme $t_1 = F$ und $t_2 = f(m(W,d),Y)$ sind unifizierbar, wenn $F = f(m(W,d),Y)$, $\\sigma = \\{F/f(m(W,d),Y)\\}$.\n\n- Die Terme $t_1 = f(m(X),X,Y)$ und $t_2 = f(Z,a,p(Z))$ sind unifizierbar, wenn $\\sigma = \\{X/a, Z/m(a), Y/p(m(a))\\}$.\n\nBeispiele\n\n- \\( t_1 = [a,b|C] \\) und \\( t_2 = [D|e,f] \\) sind unifizierbar mit \\( \\sigma = \\{ C/e, f, D/[a,b] \\} \\).\n- \\( t_1 = [a,b,c] \\) und \\( t_2 = [A,B|Z] \\) sind unifizierbar mit \\( \\sigma = \\{ A'/a, B'/b, Z'/c \\} \\).\n- \\( t_1 = [a] \\) und \\( t_2 = [A|B] \\) sind unifizierbar mit \\( \\sigma = \\{ A/a, B/[\\} \\} \\).\n\n8.2.2.2 Resolutionsalgorithmus\n\nDer Resolutionsalgorithmus bildet die Grundlage für die automatische Beweisführung von PROLOG-Klauseln. Der Algorithmus verwendet das Verfahren der Unifikation sowie das Verfahren der automatischen Rücksetzung (das Backtracking).\n\n\nIst es möglich, alle Teilziele der Zielklausel auf diese Weise zu erfüllen, so liefert das PROLOG-System die ermittelten Variablenbelegungen zurück und beantwortet die Anfrage mit einem true. Andernfalls, nach dem Erschöpfen aller verfügbaren Backtracking-Punkte, schlägt die Bearbeitung der Abfrage fehl und das PROLOG-System liefert ein false zurück.\n\nWährend der Bearbeitung eines PROLOG-Programms führt das System bei der Suche nach einer Lösung eine Reihe von Unifizierungs- und Backtrackingschritten durch.\n\n8.2.2.3 Backtracking\n\n\n83\nBeispiel\ntier(hamster)\ntier(tiger)\ntier(fuchs)\ntier(antilope)\ntier(maus)\njagt(tiger,antilope)\njagt(fuchs,maus)\njagt(fuchs,hamster)\nraeuber(X) :- tier(X),jagt(X,_).\n\nDie obere Definition eines Räubers ist sehr allgemein gehalten. Jedes Tier, das jagen kann, ist ein Räuber. Bei der Anfrage an das PROLOG-System\n?- raeuber(Tier).\n\nwürde das System wie folgt vorgehen: Zur Erfüllung des Prädikats raeuber(X) ist es notwendig die Prädikate tier(X) und jagt(X,_) zu erfüllen. Das erste im Programm vorkommende tier-Prädikat ist das tier(hamster). Daher wird nachfolgend geprüft, ob das Prädikat jagt(hamster,_) unifikierbar ist. Da dieses offensichtlich nicht möglich ist und die Unifikation zu einem Fehler führt, wird daraufhin ein Backtracking-Schritt eingeleitet. Das System hat sich zuvor gemerkt, dass bei der Unifikation von tier(X) weitere Lösungen möglich waren. Daher kehrt das PROLOG-System zurück an diese Stelle und wählt die nächste verfügbare Belegung für die Variable X. In diesem Fall wird X mit tiger unifiziert. Da es für den Tiger ein entsprechendes Prädikat jagt(tiger,antilope) gibt, unterbricht das PROLOG-System die Bearbeitung der Anfrage und liefert die gefundene Lösung an den Benutzer.\nTier = tiger ?\n\nMit der Eingabe von ; kann der Benutzer das PROLOG-System zur Suche nach weiteren Lösungen für die aktuelle Abfrage bewegen. Das System legt dabei ebenfalls ein oder mehrere Backtracking-Schritte ein und versucht weitere gültige Variablenbelegungen zu ermitteln. Die Ausgabe für das aktuelle Beispiel könnte dabei wie folgt aussehen.\nTier = tiger ? ;\nTier = fuchs ? ;\nfalse.\n\n8.2.3 Systemprädikate\n\nPROLOG ist eine moderne, sich für praktische Aufgaben eignende Programmiersprache. Neben den grundlegenden Funktionalitäten bietet PROLOG wie auch viele andere Programmiersprachen eine Menge zusätzlicher Steuerungsmechanismen zur Unterstützung des Programmierers bei der Umsetzung von notwendigen und oft wiederkehrenden Aufgaben und Funktionen. Für diesen Zweck bietet PROLOG eine Reihe vordefinierter Systemprädikate, auch Built-In-Prädikate genannt, die jeweils eine\n\nDie vom PROLOG-System angebotene Systemprädikate lassen sich im Allgemeinen in mehrere Kategorien unterscheiden. Diese unterteilen sich in\n\n- Prädikate ohne logische Bedeutung (Die Seiteneffekte sind entscheidend)\n- Testprädikate\n- Prädikate zur Auswertung und Vergleich arithmetischer Ausdrücke\n- Steuerung- und Metaprädikate\n- Prädikate zur Manipulation von Listen\n\n\n<table>\n<thead>\n<tr>\n<th>Befehl</th>\n<th>Erklärung</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>listing</td>\n<td>Auflisten aller bekannten Programmklauseln.</td>\n</tr>\n<tr>\n<td>listing(P)</td>\n<td>Auflisten aller bekannten Programmklauens für die Prozedur P</td>\n</tr>\n<tr>\n<td>read(T)</td>\n<td>Einlesen eines Terms T.</td>\n</tr>\n<tr>\n<td>write(T)</td>\n<td>Ausgabe des Terms T auf die Konsole.</td>\n</tr>\n<tr>\n<td>tab(N)</td>\n<td>Ausgabe von N Leerzeichen.</td>\n</tr>\n<tr>\n<td>nl</td>\n<td>nächste Ausgabe erfolgt in einer neuen Zeile.</td>\n</tr>\n<tr>\n<td>see(F)</td>\n<td>Umschalten des Eingabestroms auf die Datei F.</td>\n</tr>\n<tr>\n<td>seen</td>\n<td>Schließen des aktuellen Eingabestroms. Umschalten auf die (Konsole).</td>\n</tr>\n<tr>\n<td>tell(F)</td>\n<td>Schließen des Ausgabestroms auf die Datei F.</td>\n</tr>\n</tbody>\n</table>\ntold Der aktuelle Ausgabestrom wird geschlossen. Umschalten auf die (Konsole)\n\ntrace, notrace Ein/Ausschalten des -tracing-Mode.\ndebug, nodebug Ein/Ausschalten des -debugging-Mode.\n\n\natom(T) Prüft, ob T ein PROLOG-Atom ist.\natomic(T) Prüft, ob T eine Konstante oder Zahl ist.\nnumber(T) Prüft, ob T eine Zahl ist.\ninteger(T) Prüft, ob T eine ganze Zahl ist.\nvar(T), nonvar(T) Prüft, ob T eine Variable bzw. keine Variable ist.\nT == U, T \\!= U Prüft, ob T und Uidentisch bzw. nicht identisch sind.\nT = U Prüft, ob T und U unifizierbar sind.\n\n\nX =:= Y Ist wahr, wenn der Wert von X gleich dem Wert von Y ist.\nX =\\!= Y Ist wahr, wenn der Wert von X ungleich dem Wert von Y ist.\nX < Y Ist wahr, wenn der Wert von X kleiner als der Wert von Y ist.\nX =< Y Ist wahr, wenn der Wert von X kleiner gleich als der Wert von Y ist.\nX > Y Ist wahr, wenn der Wert von X größer als der Wert von Y ist.\nX =:= Y Ist wahr, wenn der Wert von X größer gleich dem Wert von Y ist.\nsin(X), cos(X)… Liefert jeweils den Wert der gewählten arithmetischen Funktion.\n\n\nconsult(F) \nDie Datei F wird eingelesen und die PROLOG-Datenbank um die im Programm befindlichen Klauseln erweitert.\n\nreconsult(F) \nAnalog zur consult-Klauseln mit identischer Signatur werden dabei aber überschrieben (aktualisiert).\n\nassert(C) \nDie Klausel C wird am Ende des aktuellen Programms (Wissensbasis) hinzugefügt.\n\nretract(C) \nDas erste Vorkommen der Klausel C im Programm (PROLOG-Datenbank) wird gelöscht.\n\nretractall(F) \nAlle Vorkommen der Klausel C im Programm werden gelöscht.\n\nabolish(P,N) \nEine Prozedur P mit der Stelligkeit N wird vollständig aus dem Programm gelöscht.\n\nnot(G) \nIst wahr, wenn das Prädikat G nicht erfüllbar ist.\n\ntrue \nEin Prädikat, das immer erfüllt ist.\n\nfail \nSchlägt immer fehl. Erzwingt ein Backtracking-Schritt.\n\n! \nDas Cut-Prädikat ist immer erfüllt. Verhindert späteres Backtracking.\n\nP ; Q \nOder-Verknüpfung zweiter Prozeduren\n\nWeiterhin bieten die meisten PROLOG-Systeme vordefinierte Systemprädikate für den Umgang mit Listen-Konstrukten. Diese Prädikate können aber auch relativ leicht manuell im eigenen Programm nachimplementiert werden. Die am häufigsten verwendeten Prädikate sind\n\nmember(X,L) \nPrüft, ob X ein Element der Liste L.\n\nappend(L1,L2,L3) \nKonkateniert die Listen L1 und L2 zusammen in der Ergebnisliste L3.\n\nreverse(L1,L2) \nL2 ist die invertierte Liste von L1.\n\nlast(X,L) \nLiefert X als letztes Element der Liste L.\n\n8.2.4 Trace/Boxenmodell\n\nIn PROLOG gibt es eine Möglichkeit, sich die Einzelheiten der Ausführung einer Abfrage näher anzuschauen und somit das Programm auf eventuelle Fehler zu untersuchen. Mit Hilfe des trace-Prädikats kann das PROLOG-System in den sogenannten\n\n\n**CALL** Beim Aufruf einer Klausel wird für diese eine neue Box erstellt und über den CALL-Port betreten. Jede erstellte Box bekommt eine fortlaufend vergebene Nummer zugewiesen. Besteht die aktuelle Klausel aus mehreren Unterzielen, so werden für diese innerhalb der aktuellen Box weitere Boxen angelegt.\n\n**EXIT** Bei der erfolgreichen Bearbeitung der Klausel verlässt das System die Box über den EXIT-Port. Ist die aktuelle Klausel nur ein Teil einer größeren Abfrage, so wird anschließend das nächste Unterziel (Klausel) der Abfrage über den CALL-Port aufgerufen.\n\n**FAIL** Konnte die aktuelle Klausel nicht wahr gemacht werden, so verlässt das System über diesen Ausgang die Box. Bei der darüber liegenden Klausel wird dabei beim Backtracking das REDO-Port betreten, um eine Neuauswertung der darüber liegenden Klausel zu initiieren.\n\n**REDO** Beim Backtracking kommt das System über diesen Port zu seinem früheren Ziel zurück.\n\nDem Programmierer stehen zudem mehrere Möglichkeiten zur Verfügung, die Bearbeitung der aktuellen Klausel zu beeinflussen bzw. zu dirigieren.\n\n**creep-Aktion:** Bei der Wahl dieser Aktion setzt das System die Bearbeitung der Klausel fort, bis das nächste Port-Ereignis registriert wird.\n\n**skip-Aktion:** Die Protokollierung der Ausführung der aktuellen Klausel wird übersprungen.\n\n**retry-Aktion:** Mit dieser Anweisung kann der Programmierer ein Backtracking-Schritt erzwingen. Das PROLOG-System kehrt dabei zurück und versucht die aktuelle Klausel erneut zu erfüllen.\n\n**fail-Aktion:** Mit der *fail*-Aktion kann der Programmierer das Fehlschlagen des aktuellen Ziels erzwingen. Dabei wird das PROLOG-System, sofern es möglich ist, ein Backtracking-Schritt einleiten und die nächste Alternativlösung präsentieren.\n\nAusgehend vom Programm-Beispiel im Abschnitt 8.2.2.3 nachfolgend eine Anfrage im trace-Modus gestartet. Das PROLOG-System erstellt dabei die folgende Ausgabe. An den einzelnen Interaktionspunkten wurde hier stets die *creep*-Aktion gewählt.\n\n?- trace, raeuber(fuchs).\nCall: (8) raeuber(fuchs) ? creep\n8.2.5 Kontrollfluss\n\n\n```\nif_then_else(P,Q,R) :- P, Q. % C1\nif_then_else(P,Q,R) :- not(P), R. % C2\n```\n\nDiese Lösung ist aber nicht sehr effizient, da bei der Bearbeitung der Prozedur auch unnötige Berechnungen durchgeführt werden. Nehmen wir an, dass während der Bearbeitung die erste Klausel (C1) ausgewählt und das erste Prädikat P bereits als wahr ausgewertet wurde. Das Prädikat Q schlägt aber nachfolgend fehl. In diesem Fall würde das PROLOG-System im Rahmen des Backtracking zurückgehen und eine alternative Herleitung für das Prädikat P suchen. Dies ist aber unnötig, da wir schon wissen, dass P bereits bewiesen werden kann. Im anderen Fall, sollte die erste Berechnung von P fehlschlagen, würde das PROLOG-System mit der Bearbeitung der zweiten Klausel der Prozedur if_then_else(P,Q,R) (C2) forfahren. Hier findet aber nochmals die Berechnung von not(P) statt, was ebenfalls überflüssig ist, da P bereits bei der ersten Klausel als falsch ausgewertet wurde.\n\n\n8.2.5.1 Cut-Prädikat\n\n\n```\nif_then_else(P,Q,R) :- P, !, Q. % C1\nif_then_else(P,Q,R) :- R. % C2\n```\n\nDiese Implementierung ist deutlich effizienter. Beim Fehlschlagen des Prädikats Q analog wie im oberen Beispiel findet in diesem Fall kein Backtracking mehr statt. Die Antwort auf die Abfrage würde dabei false sein. Im zweiten Fall, wenn das Prädikat P in der Klausel C1\nfehlschlägt, wird direkt mit der Bearbeitung von R in der Klausel C2 fortgesetzt. Bei dieser Implementierung finden also keine zusätzlichen Berechnungen statt.\n\n\n8.2.5.2 Negation\nDas Systemprädikat not/1 bietet dem Anwender die Möglichkeit zum Auszudrücken der Negationen von Aussagen. Das not-Prädikat darf aber dabei keineswegs als logische Verneinung einer Aussage aufgefasst werden. Die einzig korrekte Interpretation der Aussage not(X) ist die folgende: not(X) ist erfüllt, wenn X fehlschlägt. In PROLOG geht man von der Annahme einer „geschlossenen“ Welt. Das heißt, alles was sich nicht aus dem Programm herleiten lässt, ist automatisch nicht wahr. Doch in der realen Welt trifft diese Annahme nicht immer zu. Bei der Übertragung der Probleme der realen Welt in PROLOG hat man also darauf zu achten, dass bei der Programmentwicklung keine logischen Denkfehler einschleichen und die Benutzung des not-Prädikats im Sinne der Aufgabenstellung stets zum korrekten Ergebnis führt.\n\n8.2.6 Informationen zu Prolog im WWW\nLearn Prolog now!: http://www.learnprolognow.org/\nProlog Programming A first course: http://computing.unn.ac.uk/staff/cgpb4/prologbook/\n\n8.3 Prolog-Hamster-Modell\nDer Zustand und die Befehle der Hamster-Welt werden im Prolog-Hamster-Modell durch entsprechende Fakten und Regeln in einer vordefinierten (und automatisch zur Verfügung stehenden) Datenbasis repräsentiert. Diese hat folgende Gestalt:\n\n%%% Modellierung der Basisbefehe des Java-Hamsters.\n%% Modellierung des Hamsterterritoriums.\n% territory(<anzahlReihen>,<anzahlSpalten>)\n:- dynamic territory(_,_).\n\n%% Modellierung eines Korns im Hamsterterritorium.\n% korn(<reihe>,<spalte>,<anzahl>)\n:- dynamic korn(_,_,_).\n\n%% Modellierung der Mauern im Hamsterterritorium\n% mauer(<reihe>,<spalte>)\n:- dynamic mauer(_,_).\n\n%% Modellierung des Hamsters selbst.\n% hamster(<reihe>,<spalte>,<blickrichtung>,<anzahlKoernerImMaul>)\n:- dynamic hamster(_,_,_,_).\n\n%% Standard-Aktionen des Hamsters.\n\nvor :-\n territory(TReihen,TSpalten),\n hamster(Reihe,Spalte,Blickrichtung,AnzahlKoerner),\n nextPos(Reihe,Spalte,Blickrichtung,ReiheNeu,SpalteNeu),\n ReiheNeu >= 0, ReiheNeu < TReihen,\n SpalteNeu >= 0, SpalteNeu < TSpalten,\n not(mauer(ReiheNeu,SpalteNeu)),\n % Aktualisiere die Prolog-Datenbank:\n retract(hamster(Reihe,Spalte,Blickrichtung,AnzahlKoerner)),\n assert(hamster(ReiheNeu,SpalteNeu,Blickrichtung,AnzahlKoerner)),\n % Rufe vor() beim Hamster auf und warte solange dies ausgeführt wird.\n write('prologhamster:vor'),ttyflush,\n read(Return),\n call(Return),!.\n\nvor :-\n % Rufe vor() beim Hamster auf und warte solange dies ausgeführt wird.\n write('prologhamster:vor'),\n read(Return),\n call(Return),\n false,!.\n\nnextPos(Reihe,Spalte,'NORD',ReiheNeu,Spalte) :-\n ReiheNeu is Reihe - 1, !.\nnextPos(Reihe,Spalte,'WEST',Reihe,SpalteNeu) :-\n SpalteNeu is Spalte - 1, !.\nnextPos(Reihe,Spalte,'SUED',ReiheNeu,Spalte) :-\n ReiheNeu is Reihe + 1, !.\nnextPos(Reihe,Spalte,'OST',Reihe,SpalteNeu) :-\n SpalteNeu is Spalte + 1, !.\nvornFrei :-\n hamster(Reihe, Spalte, Blickrichtung, _),\n territorium(TReihen, TSpalten),\n nextPos(Reihe, Spalte, Blickrichtung, ReiheNeu, SpalteNeu),\n ReiheNeu >= 0, ReiheNeu < TReihen,\n SpalteNeu >= 0, SpalteNeu < TSpalten,\n not(mauer(ReiheNeu, SpalteNeu)),\n write('prologhamster:vornFrei'), ttyflush,\n read(Return),\n call(Return), !.\n\nlinksUm :-\n hamster(Reihe, Spalte, Blickrichtung, AnzahlKoerner),\n dreheHamster(Blickrichtung, BlickrichtungNeu),\n % Aktualisiere die Datenbank:\n retract(hamster(Reihe, Spalte, Blickrichtung, AnzahlKoerner)),\n assert(hamster(Reihe, Spalte, BlickrichtungNeu, AnzahlKoerner)),\n % Rufe linksUm() beim Hamster auf.\n write('prologhamster:linksUm'), ttyflush,\n read(Return),\n call(Return), !.\n\ndreheHamster('NORD', 'WEST').\n\ndreheHamster('WEST', 'SUEO').\n\ndreheHamster('SUEO', 'OST').\n\ndreheHamster('OST', 'NORD').\n\nrechtsUm :-\n linksUm,\n linksUm,\n linksUm, !.\n\nnimm :-\n hamster(Reihe, Spalte, Blickrichtung, AnzahlKoernerImMaul),\n korn(Reihe, Spalte, AnzahlKoerner),\n AnzahlKoerner > 0,\n AnzahlKoernerImMaulNeu is AnzahlKoernerImMaul + 1,\n AnzahlKoernerNeu is AnzahlKoerner - 1,\n % Aktualisiere die Datenbank:\n retract(hamster(Reihe, Spalte, Blickrichtung, AnzahlKoernerImMaul)),\n retract(korn(Reihe, Spalte, AnzahlKoerner)),\n assert(hamster(Reihe, Spalte, Blickrichtung, AnzahlKoernerImMaulNeu)),\n assert(korn(Reihe, Spalte, AnzahlKoernerNeu)),\n % Rufe nimm() beim Hamster auf.\n write('prologhamster:nimm'), ttyflush,\n read(Return),\n call(Return), !.\n\nnimm :-\n % Rufe nimm() beim Hamster auf.\n write('prologhamster:nimm'), ttyflush,\n read(Return),\n call(Return), false, !.\n\ngib :-\n hamster(Reihe, Spalte, Blickrichtung, AnzahlKoernerImMaul),\nkorn(Reihe, Spalte, AnzahlKoerner),\nAnzahlKoernerImMaul > 0,\nAnzahlKoernerImMaulNeu is AnzahlKoernerImMaul - 1,\nAnzahlKoernerNeu is AnzahlKoerner + 1,\n% Aktualisiere die Datenbank:\nretract(hamster(Reihe, Spalte, Blickrichtung, AnzahlKoernerImMaul)),\nretract(korn(Reihe, Spalte, AnzahlKoerner)),\nassert(hamster(Reihe, Spalte, Blickrichtung, AnzahlKoernerImMaulNeu)),\nassert(korn(Reihe, Spalte, AnzahlKoernerNeu)),\n% Rufe gib() beim Hamster auf.\nwrite('prologhamster:gib'), ttyflush,\nread(Return),\ncall(Return),!.\n\n%% falls es noch keine koerner auf dieser Kachel gibt..\ngib :-\n hamster(Reihe, Spalte, Blickrichtung, AnzahlKoernerImMaul),\n AnzahlKoernerImMaul > 0,\n AnzahlKoernerImMaulNeu is AnzahlKoernerImMaul - 1,\n AnzahlKoernerNeu is 1,\n % Aktualisiere die Datenbank:\n retract(hamster(Reihe, Spalte, Blickrichtung, AnzahlKoernerImMaul)),\n assert(hamster(Reihe, Spalte, Blickrichtung, AnzahlKoernerImMaulNeu)),\n assert(korn(Reihe, Spalte, AnzahlKoernerNeu)),\n % Rufe gib() beim Hamster auf.\n write('prologhamster:gib'), ttyflush,\n read(Return),\ncall(Return),!.\n\ngib :-\n % Rufe gib() beim Hamster auf.\n write('prologhamster:gib'), ttyflush,\n read(Return),\ncall(Return),\nfalse,!.\n\nkornDa :-\n hamster(Reihe, Spalte, _, _),\n korn(Reihe, Spalte, AnzahlKoerner),\n AnzahlKoerner > 0,\n write('prologhamster:kornDa'), ttyflush,\n read(Return),\ncall(Return),!.\n\nmaulLeer :-\n hamster(_, _, AnzahlKoernerImMaul),\n AnzahlKoernerImMaul = 0,\n write('prologhamster:maulLeer'), ttyflush,\n read(Return),\ncall(Return),!.\n\n8.4 Prolog-Hamster-Programme\n\nEin Prolog-Hamster-Programm hat immer folgende Gestalt:\n%% Eintrittspunkt des Programms.\nmain :- <ziele>.\n\nmain/1 ist das Prädikat, das beim Ausführen eines Prolog-Hamster-Programms aufgerufen wird.\nIm folgenden Prolog-Hamster-Programm läuft der Hamster bis zur nächsten Wand.\n\n%% Eintrittspunkt des Programms.\nmain :- laufeZurWand.\n\nlaufeZurWand :-\n vornFrei, vor, laufeZurWand, !.\n\nlaufeZurWand.\n\n8.5 Prolog-Konsole\n\n\nDie primäre Aufgabe der PrologKonsole liegt aber an der Fähigkeit, den Programmierer beim Debugging-Prozess der PROLOG-Programme zu unterstützen und diesen Prozess zu visualisieren.\n\nSie können die Prolog-Konsole über den entsprechenden Menü-Item im Menü „Fenster“ öffnen.\n\n8.6 Beispiele\n\nDas folgende Prolog-Hamster-Beispielprogramm zeigt eine Lösung für das Problem, dass der Hamster ein mauerloses Territorium komplett leeren, sprich alle Körner fressen soll. Weitere Beispielprogramme finden Sie in den Beispielprogrammen des Hamster-Simulators.\n%% Eintrittspunkt des Programms.\nmain :- leereTerritorium.\n\n%% zusätzliche nützliche Befehle\nkehrt :-\n linksUm,\n linksUm.\n\nrechtsUm :-\n kehrt,\n linksUm.\n\nlaufeZurWand :-\n vornFrei,\n vor,\n laufeZurWand,\n !.\n\nlaufeZurWand.\n\nlaufeInEcke :-\n laufeZurWand,\n linksUm,\n laufeZurWand,\n linksUm.\n\n%% zusätzliche Testbefehle (ohne Seiteneffekte)\nlinksFrei :-\n linksUm,\n vornFrei,\n rechtsUm,\n !.\n\nlinksFrei :-\n rechtsUm,\n fail.\n\nrechtsFrei :-\n rechtsUm,\n vornFrei,\n linksUm,\n !.\n\nrechtsFrei :-\n linksUm,\n fail.\n\n%% Körner sammeln\nnimmAlle :-\n\n95\nkornDa,\nnimm,\nnimmAlle,\n!.\n\nnimmAlle.\n\n%%% laufen und sammeln\ngraseReiheAb :-\n nimmAlle,\nvornFrei,\nvor,\ngraseReiheAb,\n!.\n\ngraseReiheAb.\n\nleereTerritorium :-\n laufeInEcke,\ngraseAlleReihenAb.\n\nleereTerritorium.\n\ngraseAlleReihenAb :-\ngraseReiheAb,\n kehrt,\n laufeZurWand,\n kehrt,\n linksFrei,\nbegibDichInNaechsteReihe,\n!,\ngraseAlleReihenAb.\n\nbegibDichInNaechsteReihe :-\n linksUm,\nvor,\n rechtsUm.\n9 Python\n\nDie Programmiersprache Python wurde Anfang der 1990er Jahre von Guido van Rossum am Centrum Wiskunde & Informatica (Zentrum für Mathematik und Informatik) in Amsterdam als Nachfolger für die Programmier-Lehrsprache ABC entwickelt und war ursprünglich für das verteilte Betriebssystem Amoeba gedacht. Der Name geht nicht etwa auf die gleichnamige Schlangengattung (Pythons) zurück, sondern bezog sich ursprünglich auf die englische Komikertruppe Monty Python. Trotzdem etablierte sich die Assoziation zur Schlange.\n\n\n9.1 Die Programmiersprache Python\n\nIm Internet finden Sie viele Informationen rund um die Programmiersprache Python. Schauen Sie einfach mal unter folgenden Links nach:\n\n- [http://openbook.galileocomputing.de/python/](http://openbook.galileocomputing.de/python/) (Online-Buch)\n\n9.2 Python-Hamster-Programme\n\nUm mit dem Hamster-Simulator Python-Programme entwickeln und ausführen zu können, muss die Property python auf true gesetzt sein. Standardmäßig ist das nicht der Fall. Öffnen Sie also die Datei hamster.properties und ersetzen Sie dort die Zeile python=false durch die Zeile python=true.\n\nStarten Sie dann den Hamster-Simulator. Wenn Sie ein neues Programm erstellen wollen, wählen Sie in der erscheinenden Dialogbox den Eintrag „Python-Programm“. Im Editor-Bereich erscheint dann ein Feld mit dem Inhalt „if vornFrei(): vor()“. 97\nErsetzen Sie diesen Inhalt durch Ihr Python-Programm und speichern Sie die Datei dann ab. Python-Programme brauchen nicht compiliert zu werden. Nach dem Abspeichern haben Sie direkt die Möglichkeit, das Programm auszuführen. Syntaxfehler werden erst zur Laufzeit angezeigt.\n\nIm Hamster-Simulator lassen sich sowohl imperative als auch objektorientierte Python-Programme entwickeln. Auch gemischte Programme sind möglich. Der (imperative) Hamster kennt (wie üblich) die Befehle\n\nvor()\nlkreisUm()\ngib()\nnimm()\nvornFrei() (-> bool)\nkornDa() (-> bool)\nmaulLeer() (-> bool)\n\nEine vordefinierte Klasse namens Hamster kann für objektorientierte Python-Programme genutzt werden. Die Klasse stellt folgende Methoden zur Verfügung:\n\nvor(self)\nlkreisUm(self)\ngib(self)\nnimm(self)\nvornFrei(self) (-> bool)\nkornDa(self) (-> bool)\nmaulLeer(self) (-> bool)\nschreib(self, string)\nliesZeichenkette(self, string) (-> string)\nliesZahl(self, string) (-> int)\ngetReihe(self) (-> int)\ngetSpalte(self) (-> int)\ngetBlickrichtung(self) (-> int: Hamster.NORD, Hamster.SUED, Hamster.OST, Hamster.WEST)\ngetAnzahlKoerner(self) (-> int)\ngetStandardHamster() (-> Hamster)\n\nDie Klasse definiert 2 Konstruktoren:\n\nHamster(self, reihe, spalte, blickrichtung, anzahlKoerner)\nHamster(self, hamster)\n\n9.2.1 Python-Bibliothek einbinden\n\nWenn Sie Module aus der Standard-Bibliothek von Python nutzen und importieren wollen, müssen Sie zusätzlich folgendes tun:\n\n1. Sie müssen Jython downloaden: http://www.jython.org/\n2. Sie müssen Jython installieren, bspw. ins Verzeichnis „C:\\Program Files\\jython2.5.1“\n\n3. Jetzt gibt es zwei Alternativen:\n a. Entweder verschieben/kopieren Sie dann das Jython-Lib-Verzeichnis „C:\\Program Files\\jython2.5.1\\Lib“ in das Unterverzeichnis \"lib\" des Hamster-Simulator-Ordners (so dass es in \"lib\" ein Unterverzeichnis \"Lib\" gibt)\n b. Oder Sie schreiben die folgende Zeile in die Datei \"hamstersimulator.bat\" (im Hamster-Simulator-Ordner):\n\n```\njava -Dpython.home=\"C:\\Program Files\\jython2.5.1\" -jar hamstersimulator.jar\n```\nund starten den Hamster-Simulator dann durch Doppelklick auf diese Datei \"hamstersimulator.bat\"\n\n### 9.2.2 Eigene Module definieren\n\nSie können auch eigene Module definieren und nutzen. Wenn Sie bspw. einen vordefinierten Hamster-Befehl „rechtsUm“ zur Verfügung stellen wollen, gehen Sie folgendermaßen vor:\n\n1. Legen Sie im Jython-Lib-Verzeichnis bspw. eine Datei mit dem Namen hamstererweiterung.py an. Füllen Sie die Datei mit folgendem Inhalt:\n\n```python\nfrom de.hamster.python.model import PythonHamster\n\nvor = PythonHamster.getStandardHamsterIntern().vor;\nlinksUm = PythonHamster.getStandardHamsterIntern().linksUm;\ngib = PythonHamster.getStandardHamsterIntern().gib;\nnimm = PythonHamster.getStandardHamsterIntern().nimm;\nvornFrei = PythonHamster.getStandardHamsterIntern().vornFrei;\nkornDa = PythonHamster.getStandardHamsterIntern().kornDa;\nmaulLeer = PythonHamster.getStandardHamsterIntern().maulLeer;\n\ndef rechtsUm():\n linksUm()\n linksUm()\n linksUm()\n```\n\n2. Starten Sie dann den Hamster-Simulator neu.\n\n3. Im Hamster-Simulator können Sie nun bspw. folgendes Programm eingeben und ausführen:\n\n```python\nfrom hamstererweiterung import rechtsUm\n\nfor i in range(5):\n vor()\n rechtsUm()\n```\n4. Wenn Sie die definierten Befehle nicht einzeln importieren möchten, müssen Sie den Modulnamen vor die Befehle platzieren, bspw.\n\n import hamstererweiterung\n\n for i in range(5):\n vor()\n hamstererweiterung.rechtsUm()\n\n5. Wenn Sie die Datei \"hamstererweiterung.py\" um neue Befehle ergänzen, scheint es manchmal notwendig zu sein, den Hamster-Simulator neu zu starten, damit dieser auch die neuen Befehle ausführen kann.\n\nEine weitere Möglichkeit eigene Module zu schreiben und zu nutzen, ist folgende:\nGegeben folgende Datei „my.py“:\n\n from de.hamster.python.model import PythonHamster\n\n vor = PythonHamster.getStandardHamsterIntern().vor;\n linksUm = PythonHamster.getStandardHamsterIntern().linksUm;\n gib = PythonHamster.getStandardHamsterIntern().gib;\n nimm = PythonHamster.getStandardHamsterIntern().nimm;\n vornFrei = PythonHamster.getStandardHamsterIntern().vornFrei;\n kornDa = PythonHamster.getStandardHamsterIntern().kornDa;\n maulLeer = PythonHamster.getStandardHamsterIntern().maulLeer;\n\n def rechtsUm():\n linksUm()\n linksUm()\n linksUm()\n\n def zurWand():\n while vornFrei():\n vor()\n\nSei \"Programme\" das Verzeichnis, in dem Sie Ihre Hamster-Python-Programme speichern. Können Sie auch Python-Module dort abspeichern, bspw. die Datei \"my.py\". Anschließend können Sie in Ihren Python-Hamster-Programmen folgendermaßen diese Module nutzen:\n9.3 Python-Beispielprogramme\n\nDie folgenden Unterabschnitte demonstrieren an Beispielen das Schreiben von Python-Hamster-Programmen.\n\n9.3.1 Territorium leeren\n\nDas folgende Python-Programm ist ein einfaches imperatives Beispielprogramm, bei dem der Standard-Hamster ein beliebiges Territorium ohne innere Mauern leert:\n\n```python\n# Aufgabe:\n# der Hamster steht irgendwo in einem beliebigen Territorium\n# ohne innere Mauern; er soll alle Körner fressen\n\ndef kehrt():\n linksUm()\n linksUm()\n\ndef rechtsUm():\n kehrt()\n linksUm()\n\ndef laufeZurueck():\n while vornFrei():\n vor()\n\ndef sammle():\n while kornDa():\n nimm()\n\ndef laufeZurWand():\n while vornFrei():\n vor()\n\ndef laufeInEcke():\n laufeZurWand()\n linksUm()\n laufeZurWand()\n linksUm()\n```\ndef ernteEineReihe():\n sammle()\n while vornFrei():\n vor()\n sammle()\n\ndef ernteEineReiheUndLaufeZurueck():\n ernteEineReihe()\n kehrt()\n laufeZurueck()\n\nlaufeInEcke()\nernteEineReiheUndLaufeZurueck()\nrechtsUm()\nwhile vornFrei():\n vor()\n rechtsUm()\n ernteEineReiheUndLaufeZurueck()\n rechtsUm()\n\n9.3.2 Territorium leeren 2\n\nAuch das folgende Python-Programm ist ein einfaches imperatives Beispielprogramm, bei dem der Standard-Hamster ein beliebiges Territorium ohne innere Mauern leert:\n\n```\n# Aufgabe:\n# der Hamster steht irgendwo in einem beliebigen Territorium\n# ohne innere Mauern; er soll alle Körner fressen\n\n# drehe dich um 180 Grad\ndef kehrt():\n linksUm()\n linksUm()\n\n# drehe dich um 90 Grad nach rechts\ndef rechtsUm():\n kehrt()\n linksUm()\n\n# der Hamster sammelt alle Koerner eines Feldes ein\ndef sammle():\n while kornDa():\n nimm()\n\n# Ueberpruefung, ob sich links vom Hamster\n# eine Mauer befindet\ndef linksFrei():\n linksUm()\n if vornFrei():\n rechtsUm();\n return True\n else:\n rechtsUm()\n return False\n```\n# Überprüfung, ob sich rechts vom Hamster eine\n# Mauer befindet\ndef rechtsFrei():\n rechtsUm()\n if vornFrei():\n linksUm()\n return True\n else:\n linksUm()\n return False\n\n# der Hamster läuft bis zur nächsten Wand\ndef laufeZurWand():\n while vornFrei():\n vor()\n\n# der Hamster läuft in eine Ecke\ndef laufeInEcke():\n laufeZurWand()\n linksUm()\n laufeZurWand()\n linksUm()\n\n# der Hamster soll sich in die nächste Reihe in nördlicher\n# Richtung begeben; vom Hamster aus gesehen, liegt diese Reihe\n# links von ihm\ndef begibDichLinksUmInNaechsteReihe():\n linksUm()\n vor()\n linksUm()\n\n# der Hamster soll sich in die nächste Reihe in nördlicher\n# Richtung begeben; vom Hamster aus gesehen, liegt diese Reihe\n# rechts von ihm\ndef begibDichRechtUmInNaechsteReihe():\n rechtsUm()\n vor()\n rechtsUm()\n\n# Überprüfung, ob in nördlicher Richtung (vom Hamster aus\n# gesehen links) eine weitere nicht mit Mauern besetzte\n# Reihe existiert\ndef weitereReiheLinksVomHamsterExistiert():\n return linksFrei()\n\n# Überprüfung, ob in nördlicher Richtung (vom Hamster aus\n# gesehen rechts) eine weitere nicht mit Mauern besetzte\n# Reihe existiert\ndef weitereReiheRechtsVomHamsterExistiert():\n return rechtsFrei()\n\n# der Hamster soll alle Köerner in einer Reihe einsammeln\ndef ernteEineReihe():\n sammle()\n while vornFrei():\n vor()\nsammle()\n#\n# der Hamster soll alle Körner in einer Reihe einsammeln;\n# er läuft dabei von Westen nach Osten\ndef ernteEineReiheNachOsten():\n ernteEineReihe()\n\n# der Hamster soll alle Körner in einer Reihe einsammeln;\n# er läuft dabei von Osten nach Westen\ndef ernteEineReiheNachWesten():\n ernteEineReihe()\n\n# der Hamster soll einzelne Körnerreihen abgrasen,\n# so lange noch weitere Reihen existieren;\n# er unterscheidet dabei, ob er die Reihen von\n# Osten oder von Westen aus abgrast\nlaufeInEcke()\nernteEineReiheNachOsten()\nwhile weitereReiheLinksVomHamsterExistiert():\n begibDichLinksUmInNaechsteReihe()\n ernteEineReiheNachWesten()\nif weitereReiheRechtsVomHamsterExistiert():\n begibDichRechtsUmInNaechsteReihe()\n ernteEineReiheNachOsten()\nelse:\n kehrt()\n\n9.3.3 Berg erklimmen\n\nIm folgenden imperativen Python-Programm erklimmt der Standard-Hamster einen Berg:\n\n# Aufgabe:\n# der Hamster soll den Gipfel eines vor ihm stehenden\n# Berges erklimmen\n\n# der Hamster soll zum Berg laufen\ndef laufeZumBerg():\n while vornFrei():\n vor()\n\n# der Hamster soll den Berg erklimmen\ndef erklimmeDenBerg():\n while not gipfelErreicht():\n erklimmeEineStufe()\n\n# der Hamster soll eine Stufe erklimmen\ndef erklimmeEineStufe():\n linksUm() # nun schaut der Hamster nach oben\n vor() # der Hamster erklimmt die Mauer\n rechtsUm() # der Hamster wendet sich wieder dem Berg zu\n vor() # der Hamster springt auf den Vorsprung\n\n# der Hamster dreht sich nach rechts um\ndef rechtsUm():\n linksUm()\n linksUm()\n linksUm()\n\n# hat der Hamster den Gipfel erreicht?\ndef gipfelErreicht():\n return vornFrei()\n\n# der Hamster soll zunächst bis zum Berg laufen\n# und dann den Berg erklimmen\nlaufeZumBerg()\nerklimmeDenBerg()\n\n9.3.4 Wettlauf\n\nIm folgenden objektorientierten Python-Programm liefern sich 3 Hamster einen Wettlauf bis zur nächsten Mauer:\n\npaul = Hamster.getStandardHamster()\nwilli = Hamster(paul)\nmaria = Hamster(paul.getReihe()+1, paul.getSpalte(), paul.getBlickrichtung(), 0)\nwhile paul.vornFrei() and willi.vornFrei() and maria.vornFrei():\n paul.vor()\n willi.vor()\n maria.vor()\npaul.schreib(\"Fertig!\")\n\n9.3.5 Objektorientiertes Territorium leeren\n\nIm folgenden Python-Programm werden objektorientierte Konzepte genutzt, um einen Hamster das Territorium leeren zu lassen:\n\n# Ein neu erzeugter Hamster grast das Territorium ab und\n# zählt dabei die gesammelten Koerner\nclass AbgrasHamster(Hamster):\n def __init__(self, reihe, spalte, blickrichtung, anzahlKoerner):\n Hamster.__init__(self, reihe, spalte, blickrichtung, anzahlKoerner)\n self.__Gesammelt = 0\n\n def kehrt(self):\n self.linksUm()\n self.linksUm()\n\n def rechtsUm(self):\n self.kehrt()\n self.linksUm()\n\n def laufeZurueck(self):\n while self.vornFrei():\n self.vor()\ndef sammle(self):\n while self.kornDa():\n self.nimm()\n self.__Gesammelt += 1\n return self.__Gesammelt\n\ndef laufeZurWand(self):\n while self.vornFrei():\n self.vor()\n\ndef laufeInEcke(self):\n self.laufeZurWand()\n self.linksUm()\n self.laufeZurWand()\n self.linksUm()\n\ndef ernteEineReihe(self):\n self.sammle()\n while self.vornFrei():\n self.vor()\n self.sammle()\n\ndef ernteEineReiheUndLaufeZurueck(self):\n self.ernteEineReihe()\n self.kehrt()\n self.laufeZurueck()\n\n# Hauptprogramm\npaul = AbgrasHamster(2, 3, Hamster.WEST, 0)\npaul.laufeInEcke()\npaul.ernteEineReiheUndLaufeZurueck()\npaul.rechtsUm()\nwhile paul.vornFrei():\n paul.vor()\n paul.rechtsUm()\n paul.ernteEineReiheUndLaufeZurueck()\npaul.rechtsUm() \npaul.schreib(\"Gesammelte Koerner = \" + str(paul.gesammelteKoerner()))\n\n9.4 Python-Konsole\n\nAbbildung 9.1: Python-Konsole\n\nHinweis: Die Python-Konsole und Python-Programme arbeiten mit unterschiedlichen Python-Interpretern, d.h. nachdem Sie ein Python-Programm ausgeführt haben, sind unter Umständen durch das Programm angelegte Variablen nicht in der Python-Konsole (und auch nicht in anderen Python-Programmen) verfügbar. Weiterhin ist anzumerken, dass nach der Ausführung eines Python-Programms unter Umständen vorher in der Konsole erzeugte Hamster anschließend nicht mehr zugreifbar sind.\n\n9.5 Implementierung\n\nDie Anbindung von Python an den Hamster-Simulator wurde mit Hilfe von Jython realisiert (http://www.jython.org/). Hier die Lizenzbedingungen:\n\nPYTHON SOFTWARE FOUNDATION LICENSE VERSION 2\n\n1. This LICENSE AGREEMENT is between the Python Software Foundation (\"PSF\"), and the Individual or Organization (\"Licensee\") accessing and otherwise using this software (\"Jython\") in source or binary form and its associated documentation.\n\n2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Jython alone or in any derivative version, provided, however, that PSF's License Agreement and PSF's notice of copyright, i.e., \"Copyright (c) 2007 Python Software Foundation; All Rights Reserved\" are retained in Jython alone or in any derivative version prepared by Licensee.\n3. In the event Licensee prepares a derivative work that is based on or incorporates Jython or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Jython.\n\n4. PSF is making Jython available to Licensee on an \"AS IS\" basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF JYTHON WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF JYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING JYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.\n\n7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party.\n\n8. By copying, installing or otherwise using Jython, Licensee agrees to be bound by the terms and conditions of this License Agreement.\n\nJython 2.0, 2.1 License\n\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n- Neither the name of the Jython Developers nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT\nOF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR\nBUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\nLIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\nNEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n10 Ruby\n\nRuby (engl. für Rubin) ist eine moderne, vielseitige höhere Programmiersprache, die Mitte der Neunziger Jahre von Yukihiro Matsumoto entworfen wurde. Ruby ist interpretiert und objektorientiert, unterstützt aber mehrere weitere Programmierparadigmen (unter anderem Prozedurale und Funktionale Programmierung sowie Nebenläufigkeit), bietet dynamische Typisierung, Reflexion und Automatische Speicherbereinigung.\n\n\n10.1 Die Programmiersprache Ruby\n\nIm Internet finden Sie viele Informationen rund um die Programmiersprache Ruby. Schauen Sie einfach mal unter folgenden Links nach:\n\n\n10.2 Ruby-Hamster-Programme\n\nUm mit dem Hamster-Simulator Ruby-Programme entwickeln und ausführen zu können, muss die Property ruby auf true gesetzt sein. Standardmäßig ist das nicht der Fall. Öffnen Sie also die Datei hamster.properties und ersetzen Sie dort die Zeile ruby=false durch die Zeile ruby=true.\n\nStarten Sie dann den Hamster-Simulator. Wenn Sie ein neues Programm erstellen wollen, wählen Sie in der erscheinenden Dialogbox den Eintrag „Ruby-Programm“. Im Editor-Bereich erscheint dann ein Feld mit dem Inhalt „if vornFrei vor end“. Ersetzen Sie diesen Inhalt durch Ihr Ruby-Programm und speichern Sie die Datei dann ab. Ruby-Programme brauchen nicht compiliert zu werden. Nach dem Abspeichern haben Sie direkt die Möglichkeit, das Programm auszuführen. Syntaxfehler werden erst zur Laufzeit angezeigt.\n\nIm Hamster-Simulator lassen sich sowohl imperative als auch objektorientierte Ruby-Programme entwickeln. Auch gemischte Programme sind möglich. Der (imperative) Hamster kennt (wie üblich) die Befehle\nEine vordefinierte Klasse namens \nH<e>mster kann für objektorientierte \nRuby-Programme genutzt werden. Die Klasse stellt folgende Methoden zur Verfügung:\n\nvor()\nl<e>nksUm()\ngib()\nnimm()\nvornFrei() (-> bool)\nkornDa() (-> bool)\nmaulLeer() (-> bool)\n\nDie Klasse definiert 2 Konstruktoren:\n\nHamster(reihe, spalte, blickrichtung, anzahlKoerner)\nHamster(hamster)\n\n10.3 Ruby-Beispielprogramme\n\nDie folgenden Unterabschnitte demonstrieren an Beispielen das Schreiben von \nRuby-Hamster-Programmen.\n\n10.3.1 Territorium leeren\n\nDas folgende Ruby-Programm ist ein einfaches imperatives Beispielprogramm, bei dem \nder Standard-Hamster ein beliebiges Territorium ohne innere Mauern leert:\n\n```ruby\n# Aufgabe:\n# der Hamster steht irgendwo in einem beliebigen Territorium\n# ohne innere Mauern; er soll alle Körner fressen\n\ndef kehrt\n```\ndef linksUm\n linksUm\nend\n\ndef rechtsUm\n kehrt\n linksUm\nend\n\ndef laufeZurueck\n while vornFrei\n vor\n end\nend\n\ndef sammle\n while kornDa\n nimm\n end\nend\n\ndef laufeZurWand\n while vornFrei\n vor\n end\nend\n\ndef laufeInEcke\n laufeZurWand\n linksUm\n laufeZurWand\n linksUm\nend\n\ndef ernteEineReihe\n sammle\n while vornFrei\n vor\n sammle\n end\nend\n\ndef ernteEineReiheUndLaufeZurueck\n ernteEineReihe\n kehrt\n laufeZurueck\nend\n\n# Hauptprogramm\nlaufeInEcke\nernteEineReiheUndLaufeZurueck\nrechtsUm\nwhile vornFrei\n vor\n rechtsUm\n ernteEineReiheUndLaufeZurueck\n rechtsUm\nend\n10.3.2 Territorium leeren 2\n\nAuch das folgende Ruby-Programm ist ein einfaches imperatives Beispielprogramm, bei dem der Standard-Hamster ein beliebiges Territorium ohne innere Mauern leert:\n\n```ruby\n# Aufgabe:\n# der Hamster steht irgendwo in einem beliebigen Territorium\n# ohne innere Mauern; er soll alle Körner fressen\n\n# drehe dich um 180 Grad\ndef kehrt\n linksUm\n linksUm\nend\n\n# drehe dich um 90 Grad nach rechts\ndef rechtsUm\n kehrt\n linksUm\nend\n\n# der Hamster sammelt alle Körner eines Feldes ein\ndef sammle\n while kornDa\n nimm\n end\nend\n\n# Überprüfung, ob sich links vom Hamster\n# eine Mauer befindet\ndef linksFrei\n linksUm\n if vornFrei\n rechtsUm\n return true\n else\n rechtsUm\n return false\n end\nend\n\n# Überprüfung, ob sich rechts vom Hamster eine\n# Mauer befindet\ndef rechtsFrei\n rechtsUm\n if vornFrei\n linksUm\n return true\n else\n linksUm\n return false\n end\nend\n\n# der Hamster läuft bis zur nächsten Wand\ndef laufeZurWand\nend\n```\n\n113\nwhile vornFrei\n vor\nend\nend\n\n# der Hamster laeuft in eine Ecke\ndef laufeInEcke\n laufeZurWand\n linksUm\n laufeZurWand\n linksUm\nend\n\n# der Hamster soll sich in die naechste Reihe in noerdlicher # Richtung begeben; vom Hamster aus gesehen, liegt diese Reihe # links von ihm\ndef begibDichLinksUmInNaechsteReihe\n linksUm\n vor\n linksUm\nend\n\n# der Hamster soll sich in die naechste Reihe in noerdlicher # Richtung begeben; vom Hamster aus gesehen, liegt diese Reihe # rechts von ihm\ndef begibDichRechtsUmInNaechsteReihe\n rechtsUm\n vor\n rechtsUm\nend\n\n# Uberpruefung, ob in noerdlicher Richtung (vom Hamster aus # gesehen links) eine weitere nicht mit Mauern besetzte # Reihe existiert\ndef weitereReiheLinksVomHamsterExistiert\n return linksFrei\nend\n\n# Uberpruefung, ob in noerdlicher Richtung (vom Hamster aus # gesehen rechts) eine weitere nicht mit Mauern besetzte # Reihe existiert\ndef weitereReiheRechtsVomHamsterExistiert\n return rechtsFrei\nend\n\n# der Hamster soll alle Koerner in einer Reihe einsammeln\ndef ernteEineReihe\n sammle\n while vornFrei\n vor\n sammle\n end\nend\n\n# der Hamster soll alle Koerner in einer Reihe einsammeln; # er laeuft dabei von Westen nach Osten\ndef ernteEineReiheNachOsten\nernteEineReihe\nend\n\n# der Hamster soll alle Koerner in einer Reihe einsammeln;\n# er laeuft dabei von Osten nach Westen\ndef ernteEineReiheNachWesten\n ernteEineReihe\nend\n\n# der Hamster soll einzelne Koernerreihen abgrasen,\n# so lange noch weitere Reihen existieren;\n# er unterscheidet dabei, ob er die Reihen von\n# Osten oder von Westen aus abgrast\nlaufeInEcke\nernteEineReiheNachOsten\nwhile weitereReiheLinksVomHamsterExistiert\n begibDichLinksUmInNaechsteReihe\n ernteEineReiheNachWesten\n if weitereReiheRechtsVomHamsterExistiert\n begibDichRechtsUmInNaechsteReihe\n ernteEineReiheNachOsten\n else\n kehrt\n end\nend\n\n10.3.3 Berg erklimmen\n\nIm folgenden imperativen Ruby-Programm erklimmt der Standard-Hamster einen Berg:\n\n# Aufgabe:\n# der Hamster soll den Gipfel eines vor ihm stehenden\n# Berges erklimmen\n\n# der Hamster soll zum Berg laufen\ndef laufeZumBerg\n while vornFrei\n vor\n end\nend\n\n# der Hamster soll den Berg erklimmen\ndef erklimmeDenBerg\n while not gipfelErreicht\n erklimmeEineStufe\n end\nend\n\n# der Hamster soll eine Stufe erklimmen\ndef erklimmeEineStufe\n linksUm # nun schaut der Hamster nach oben\n vor # der Hamster erklimmt die Mauer\n rechtsUm # der Hamster wendet sich wieder dem Berg zu\n vor # der Hamster springt auf den Vorsprung\nend\n# der Hamster dreht sich nach rechts um\ndef rechtsUm\n linksUm\n linksUm\n linksUm\nend\n\n# hat der Hamster den Gipfel erreicht?\ndef gipfelErreicht\n return vornFrei\nend\n\n# der Hamster soll zunaechst bis zum Berg laufen\n# und dann den Berg erklimmen\nlaufeZumBerg\nerklimeDenBerg\n\n10.3.4 Wettlauf\n\nIm folgenden objektorientierten Ruby-Programm liefern sich 3 Hamster einen Wettlauf bis zur nächsten Mauer:\n\npaul = Hamster.getStandardHamster\nwilli = Hamster.new(paul)\nmaria = Hamster.new(paul.getReihe + 1, paul.getSpalte, paul.getBlickrichtung, 0)\nwhile paul.vornFrei and willi.vornFrei and maria.vornFrei\n paul.vor\n willi.vor\n maria.vor\nend\npaul.schreib(\"Fertig!\")\n\n10.3.5 Objektorientiertes Territorium leeren\n\nIm folgenden Ruby-Programm werden objektorientierte Konzepte genutzt, um einen Hamster das Territorium leeren zu lassen:\n\n# Ein neu erzeugter Hamster grast das Territorium ab und\n# zahlt dabei die gesammelten Koerner\nclass AbgrasHamster < Hamster\n def initialize(reihe, spalte, blickrichtung, anzahlKoerner)\n super(reihe, spalte, blickrichtung, anzahlKoerner)\n @gesammelt = 0\n end\n def kehrt\n linksUm\n linksUm\n end\nend\ndef rechtsUm\n kehrt\n linksUm\nend\n\ndef laufeZurueck\n while vornFrei\n vor\n end\nend\n\ndef sammlle\n while kornDa\n nimm\n @gesammelt += 1\n end\nend\n\ndef laufeZurWand\n while vornFrei\n vor\n end\nend\n\ndef laufeInEcke\n laufeZurWand\n linksUm\n laufeZurWand\n linksUm\nend\n\ndef ernteEineReihe\n sammlle\n while vornFrei\n vor\n sammlle\nend\n\ndef ernteEineReiheUndLaufeZurueck\n ernteEineReihe\n kehrt\n laufeZurueck\nend\n\ndef gesammelteKoerner\n return @gesammelt\nend\nend\n\n# Hauptprogramm\npaul = AbgrasHamster.new(2, 3, Hamster.WEST, 0)\npaul.laufeInEcke\npaul.ernteEineReiheUndLaufeZurueck\npaul.rechtsUm\nwhile paul.vornFrei\n paul.vor\n paul.rechtsUm\n10.4 Ruby-Konsole\n\n\nHinweis: Die Ruby-Konsole und Ruby-Programme arbeiten mit unterschiedlichen Ruby-Interpretern, d.h. nachdem Sie ein Ruby-Programm ausgeführt haben, sind unter Umständen durch das Programm angelegte Variablen nicht in der Ruby-Konsole (und auch nicht in anderen Ruby-Programmen) verfügbar. Weiterhin ist anzumerken, dass nach der Ausführung eines Ruby-Programms unter Umständen vorher in der Konsole erzeugte Hamster anschließend nicht mehr zugreifbar sind.\n10.5 Implementierung\n\n\nJRuby distribuiert einige ruby Module, die unter Ruby Lizenz distribuiert werden:\n\nRuby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>. You can redistribute it and/or modify it under either the terms of the GPL (see the file GPL), or the conditions below:\n\n1. You may make and give away verbatim copies of the source form of the software without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n2. You may modify your copy of the software in any way, provided that you do at least ONE of the following:\n a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or by allowing the author to include your modifications in the software.\n b) use the modified software only within your corporation or organization.\n c) give non-standard binaries non-standard names, with instructions on where to get the original software distribution.\n d) make other distribution arrangements with the author.\n\n3. You may distribute the software in object code or binary form, provided that you do at least ONE of the following:\n a) distribute the binaries and library files of the software, together with instructions (in the manual page or equivalent) on where to get the original distribution.\n b) accompany the distribution with the machine-readable source of the software.\n c) give non-standard binaries non-standard names, with instructions on where to get the original software distribution.\n d) make other distribution arrangements with the author.\n\n4. You may modify and include the part of the software into any other software (possibly commercial). But some files in the distribution are not written by the author, so that they are not under these terms. For the list of those files and their copying conditions, see the file LEGAL.\n\n5. The scripts and library files supplied as input to or produced as output from the software do not automatically fall under the copyright of the software, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this software.\n\n6. THIS SOFTWARE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.\n11 Hamstern mit Scratch\n\n\nAbbildung 11.1: Scratch\n\nAbbildung 11.2: Scratch-Hamster-Simulator\n\n11.1 Überblick\n\nDas Scratch-Hamster-Modell unterstützt folgende Komponenten bzw. Konzepte:\n\n- Die vier Grundbefehle des Hamsters (vor, linksUm, gib und nimm) sind als Anweisungsblöcke vordefiniert.\n- Es lassen sich neue Befehle als Prozeduren definieren, die als neue Anweisungsblöcke repräsentiert werden.\n- Die drei Testbefehle des Hamsters (vornFrei, kornDa und maulLeer) sind als Boolesche-Ausdruck-Blöcke vordefiniert. Weiterhin gibt es die Boolesche-Ausdruck-Blöcke „true“ und „false“.\n- Es lassen sich neue Testbefehle als boolesche Funktionen definieren, die als neue Boolesche-Ausdruck-Blöcke repräsentiert werden.\n- Als Kontrollstrukturen zur Programmsteuerung sind die if-Anweisung, die if-else-Anweisung, die while-Schleife und die do-while-Schleife als spezielle Anweisungsblöcke („falls“, „falls-sonst“, „solange“, „wiederhole-solange“) integriert.\nDiesen können Boolesche-Ausdruck-Blöcke als Bedingungen und Anweisungsblöcke als innere Anweisungen zugeordnet werden.\n\n\n11.2 Voraussetzungen\n\nUm mit dem Hamster-Simulator Scratch-Hamster-Programme entwickeln und ausführen zu können, muss die Property scratch auf true gesetzt sein. Standardmäßig ist das der Fall. Um den Scratch-Modus auszuschalten, öffnen Sie bitte die Datei hamster.properties und ersetzen Sie dort die Zeile scratch=true durch die Zeile scratch=false. Mit Hilfe von Properties lassen sich seit Version 2.8.2 des Hamster-Simulators auch die Beschriftungen der Standard-Blöcke verändern (sie Kapitel 5.1.16).\n\n11.3 Ein erstes kleines Beispiel\n\n\n11.4 Erstellen von Scratch-Programmen\n\n11.4.1 Kategorienauswahl\n\nIn der Kategorienauswahl finden sich die drei Buttons „Anweisungen“, „Boolesche Ausdrücke“ und „Steuerung“. Durch Klick auf einen der Buttons erscheinen entsprechende Blöcke der jeweiligen Kategorie in der Blockpalette.\n\n11.4.2 Blockpalette\n\nIn der Blockpalette werden die Blöcke der in der Kategorienauswahl aktuell ausgewählten Kategorie angezeigt. Diese – genauer gesagt Kopien hiervon – lassen sich per Drag-und-Drop mit der Maus in den Programmbereich ziehen, um Programme zu erstellen. Wählen Sie hierzu den entsprechenden Block, klicken Sie ihn mit der Maus (linke Taste) an, ziehen Sie die Maus bei gedrückter linker Taste in den Programmbereich und lassen Sie die Maustaste los.\n\nFolgende Blöcke werden standardmäßig in der Blockpalette angezeigt (siehe auch die Abbildungen 11.4, 11.5 und 11.6):\n\n- Anweisungsblöcke (Kategorie „Anweisungen“):\n - vor: Repräsentiert den Hamster-Grundbefehl vor.\n - linksUm: Repräsentiert den Hamster-Grundbefehl linksUm.\no nimm: Repräsentiert den Hamster-Grundbefehl nimm.\no gib: Repräsentiert den Hamster-Grundbefehl gib.\no verlasse: Repräsentiert die return-Anweisung zum Verlassen einer Prozedur.\no liefere <boolescher Ausdruck>: Repräsentiert die boolesche-return-Anweisung zum Verlassen einer booleschen Funktion.\no main: Repräsentiert die main-Prozedur.\no Über den Button „Neue Prozedur“ lassen sich neue Prozeduren definieren.\n\nAbbildung 11.4: Blockpalette der Kategorie „Anweisungen“\n\n- Boolesche-Ausdrucks-Blöcke (Kategorie „Boolesche Ausdrücke“):\n o vornFrei: Repräsentiert den Hamster-Testbefehl vornFrei.\n o kornDa: Repräsentiert den Hamster-Testbefehl kornDa.\n o maulLeer: Repräsentiert den Hamster-Testbefehl maulLeer.\n o wahr: Repräsentiert das boolesche Literal „true“.\n o falsch: Repräsentiert das boolesche Literal „false“.\n o <boolescher Ausdruck> und <boolescher Ausdruck>: Repräsentiert den booleschen Und-Operator.\n o <boolescher Ausdruck> oder <boolescher Ausdruck>: Repräsentiert den booleschen Oder-Operator.\n o nicht <boolescher Ausdruck>: Repräsentiert den booleschen Nicht-Operator.\n o Über den Button „Neue Funktion“ lassen sich neue boolesche Funktionen definieren.\nSteuerungsblöcke (Kategorie „Steuerung“):\n\nBei den Steuerungsblöcken handelt sich um spezielle Anweisungsblöcke.\n\n- **falls**: Repräsentiert die if-Anweisung.\n- **falls-sonst**: Repräsentiert die if-else-Anweisung.\n- **solange <boolescher Ausdruck>**: Repräsentiert die while-Schleife.\n- **wiederhole-solange <boolescher Ausdruck>**: Repräsentiert die do-while-Schleife.\n11.4.3 Programmbereich\n\nIm Programmbereich liegen die Scratch-Hamster-Programme. Standardmäßig ist hier die main-Prozedur geöffnet.\n\n\n11.4.4 Anweisungssequenzen\n\n\nAbbildung 11.7: Bilden von Anweisungssequenzen\n\n11.4.5 Programme\n\nScratch-Hamster-Programme starten immer durch Ausführung der main-Prozedur. Ausgeführt wird dabei die Anweisungssequenz, die mit der main-Prozedur verbunden ist. Hierzu besitzt die Prozedur am oberen Rand des Programmbereichs einen Zapfen (den sogenannten Prozedurzapfen). Hier muss man die entsprechende Anweisungssequenz andocken (siehe Abbildung 11.8).\nZwischenbemerkung:\n\nNun sind wir so weit, dass wir ein erstes kleines Scratch-Hamster-Programm selbst erstellen und testen können. Erstellen Sie zum Beispiel ein Programm, in dem sich der Hamster zwei Kacheln nach vorne bewegt, sich dann linksum dreht und wiederum zwei Kacheln nach vorne springt (siehe Abbildung 11.9).\n\n11.4.6 Kontrollstrukturen\n\nDie Blöcke, die die Kontrollstrukturen repräsentieren, lassen sich analog zu den Anweisungsblöcken handhaben. Sie besitzen jedoch als weitere Unterkomponenten einen Bedingungsbereich (grün) und einen Innenbereich (siehe Abbildung 11.10).\nIn den Bedingungsbereich lassen sich beliebige Boolesche-Ausdrucks-Blöcke ziehen, die die Bedingung der entsprechenden Kontrollstruktur repräsentieren. Ein leerer Bedingungsbereich entspricht implizit dem Wert „wahr“. Auch die Boolesche-Ausdruck-Blöcke, die die booleschen Operatoren repräsentieren, enthalten analog zu handhabende Bedingungsbereiche. Damit lassen sich komplexe Bedingungen realisieren.\n\nIn den Innenbereich eines Kontrollstrukturblockes lassen sich wiederum Anweisungsblöcke und Stapel ziehen. Diese entsprechen dabei der true- oder false-Anweisung einer if-Anweisung oder der Iterationsanweisung einer Schleife.\n\n### 11.4.7 Prozeduren und boolesche Funktionen\n\nDas Konzept der Definition neuer Prozeduren und Funktionen existiert im Original-Scratch (leider) nicht. Wir haben versucht, es möglichst harmonisch zu integrieren.\n\n**Definition**\n\n\n**Aufruf**\n\n\n**Handhabung**\n\nDurch Doppelklick auf einen Prozedur- bzw. Funktionsblock in der Blockpalette wird die entsprechende Funktion im Programmbereich geöffnet. Durch Anklicken des entsprechenden Tabs im Programmbereich lässt sich zwischen verschiedenen Prozeduren und Funktionen hin und her wechseln.\n\nZu jeder Prozedur bzw. Funktion existiert ein Popup-Menü, das sich durch Anklicken mit der Maus (rechte Maustaste) über dem entsprechenden Block in der Blockpalette oder\n\n**Besonderheiten**\n\nFehlt am Ende der Ausführung einer booleschen Funktion eine boolesche-return-Anweisung, so wird automatisch der Wert „true“ geliefert. Dasselbe gilt für den Fall der Ausführung einer (normalen) return-Anweisung innerhalb einer booleschen Funktion.\n\nWird innerhalb einer Prozedur eine boolesche-return-Anweisung ausgeführt, wird der gelieferte Wert ignoriert.\n\n**Auslagern von Blöcken**\n\n\nAuch Boolescher-Ausdruck-Blöcke lassen sich in Funktionen auslagern. In die neue Funktion wird dann automatisch eine entsprechende Boolesche-Return-Anweisung integriert.\n\n### 11.5 Ausführen von Scratch-Hamster-Programmen\n\nZum Ausführen von Scratch-Hamster-Programmen dienen die entsprechenden Buttons (Start bzw. Fortführen, Pause und Stopp) der Toolbar. Scratch-Hamster-Programme werden dabei interpretativ ausgeführt, müssen also nicht (und können auch nicht) kompiliert werden. Ein Abspeichern ist vor der Ausführung nicht unbedingt notwendig. Während der Ausführung eines Programms (was man daran erkennt, dass der Stopp-Button enabled (also anklickbar) ist), ist keine Änderung an dem Programm möglich.\n\n11.6 Generieren von Java-Hamster-Programmen\n\n\nEs ist zu beachten, dass bei der Generierung unter Umständen Java-Programme entstehen, die sich nicht compilieren lassen. Hintergrund hierfür ist, dass return-Anweisungen in Scratch anders behandelt werden als in Java. Sie müssen also unter Umständen noch fehlende return-Anweisungen in das generierte Java-Programm integrieren.\n\n11.7 Beispielprogramme\n\nIm Unterordner „scratch“ des Ordners „beispielprogramme“ finden Sie einige Scratch-Hamster-Programme als Beispiele.\n12 Hamstern mit endlichen Automaten\n\n\n12.1 Endliche Automaten\n\n\n12.2 Hamster-Automaten\n\n\nDen Pfeilen zugeordnet sind Beschriftungen, die jeweils aus zwei Teilen bestehen. Der erste Teil ist ein boolescher Ausdruck, in dem die Hamster-Testbefehle benutzt werden können. Der zweite Teil ist eine Sequenz von Hamster-Befehlen.\n\nGenau ein Zustand eines Hamster-Automaten ist als Startzustand ausgezeichnet (zu erkennen an einem eingehenden Pfeil). Bestimmte Zustände können als Endzustände markiert sein (Kreise mit doppelter Umrandung).\n\nWird ein Hamster-Automat ausgeführt, passiert folgendes:\n\n- Genau ein Zustand ist jeweils aktiv. Anfangs ist dies der Startzustand.\n- Es wird überprüft, ob vom aktiven Zustand eine Transition ausgeht, deren boolescher Ausdruck den Wert true liefert. Ist dies der Fall, wird die zugehörige Sequenz von Hamster-Befehlen ausgeführt. Der Zustand, in den die Transition führt, ist anschließend der neue aktive Zustand.\n\nGibt es vom aktiven Zustand ausgehend keine gültige Transition, dann gibt es zwei Fälle:\n\n- Handelt es sich bei dem Zustand um einen Endzustand, dann ist das Programm erfolgreich beendet.\nHandelt es sich beim dem Zustand um keinen Endzustand, dann wird das Programm mit einem Fehler beendet.\n\n\nAbbildung 12.1 zeigt ein Beispiel für einen Hamster-Automaten. Führt man das Programm aus, läuft der Hamster zur nächsten Wand und dreht sich dort um.\n\nAbbildung 12.1: Beispiel Hamster-Automat\n\n\nBei der Ausführung startet das Programm im Startzustand laufeZurNaechstenWand. Es werden die beiden ausgehenden Transitionen überprüft. Steht der Hamster vor einem freien Feld, wird die erste Transition ausgewählt (weil der boolesche Ausdruck vornFrei den Wert true liefert) und der Befehl vor wird ausgeführt. Der nächste aktive Zustand ist\nwiederum der Zustand laufezurNaechstenWand. Steht der Hamster vor einer Wand, wird die zweite Transition ausgewählt und die Befehlssequenz linksUm, linksUm ausgeführt. Der nächste aktive Zustand ist nun der Zustand kehrt. Da vom diesem Zustand keine Transitionen ausgehen, ist das Programm beendet; und zwar erfolgreich, weil der Zustand kehrt ein Endzustand ist.\n\n12.3 Voraussetzungen\n\nUm mit dem Hamster-Simulator Hamster-Automaten entwickeln und ausführen zu können, muss die Property fsm auf true gesetzt sein. Standardmäßig ist das der Fall. Um den Automaten-Modus auszuschalten, öffnen Sie bitte die Datei hamster.properties und ersetzen Sie dort die Zeile fsm=true durch die Zeile fsm=false.\n\n12.4 Erstellen von Hamster-Automaten\n\n\n12.4.1 Zeichnen-Menü\n\nDas Zeichnen-Menü an der linken Seite beinhaltet folgende Funktionalität (von oben nach unten) durch Anklicken des entsprechenden Buttons, wobei immer nur ein Button zur gleichen Zeit aktiv sein kann:\n\n- [Editieren] Durch die vielfältigen Möglichkeiten in diesem Modus wird dieser Punkt im nächsten Abschnitt behandelt.\n- [Zustand erzeugen] Durch Klicken an einen bestimmten Punkt im Programmbereich wird an dieser Stelle der Mittelpunkt des neu erzeugten\nZustands gesetzt. Der Zustand bekommt dabei eine Standardbenennung \\( z+<\\text{Zahl}> \\). Der erste erzeugte Zustand wird als Startzustand definiert.\n\n\nNach Ausführung eines Menüpunktes wird jedes Mal automatisch wieder in den Editieren-Modus gewechselt.\n\n### 12.4.2 Editieren-Modus\n\nIn diesem Modus können Kommentare und Zustände verschoben werden, indem das entsprechende Element mit der Maus angeklickt und per Drag-and-Drop an die gewünschte Stelle gezogen wird.\n\n\nWeiterhin können Zustände und Kommentare umbenannt bzw. der Text geändert werden, indem ein Textfeld durch einen Doppelklick auf das entsprechende Element geöffnet wird. Bei Zuständen ist die Besonderheit, dass Zustände nicht in \\( z + \\text{Zahl} \\) umbenannt werden dürfen, weil es sich um die Standardbenennung der Zustände handelt. Außerdem müssen sich die Namen aller Zustände unterscheiden. Die Namen müssen dabei aus Buchstaben und Ziffern bestehen.\n\nTransitionen können an andere Zielzustände umgelegt werden, indem die Pfeils spitze der Transition auf den gewünschten Zielzustand gezogen wird. Außerdem ist es möglich Transitionen zu biegen. Dazu wird auf den Transitionspfeil doppelgeklickt und der erscheinende rote Punkt so gezogen, bis die Transition die gewünschte Biegung besitzt.\nEine Beschriftung einer Transition kann geändert werden, indem durch einen Doppelklick auf die Beschriftung das Fenster zur Änderung geöffnet wird, welches im folgenden Abschnitt beschrieben ist.\n\nJedes Element besitzt in diesem Modus ein Kontextmenü bzw. Popup-Menü, indem die für das Element möglichen Funktionen aufgeführt werden. Das Kontextmenü wird im Allgemeinen geöffnet, wenn die rechte Maustaste gedrückt wird, während sich die Maus auf dem entsprechenden Element befindet.\n\n\n12.4.3 Definition einer Transition\n\nDas Fenster für die Definition einer Transition ist in zwei Bereiche aufgeteilt, wie Abbildung 12.2 zeigt. Im oberen Bereich kann der boolesche Ausdruck (auch Bedingung oder Input genannt) der Transition, im unteren Bereich die Befehlssequenz (auch Output genannt) festgelegt werden. Die Vorgehensweise in beiden Bereichen ist aber die Gleiche. Im linken Feld des jeweiligen Bereiches befinden sich die zur Auswahl stehenden Elemente. Um ein Element auszuwählen, wird dieses per Drag-and-Drop in das jeweils rechte Feld gezogen. Dort muss es an eine hervorgehobene Stelle innerhalb des grünen bzw. blauen Feldes platziert werden. Diese Stellen werden sichtbar (graue Hervorhebung), sobald die Maus über den entsprechenden Bereich fährt. Während bei der Bedingung genau ein Element ausgewählt wird, in das gegebenenfalls Kinderelemente gezogen werden können, so ist es bei der Befehlssequenz möglich, eine Ausgabeliste zu erstellen, die aus mehreren Elementen bestehen kann.\n\nUm ein Element wieder aus der Auswahl-Liste in den rechten Bereichen zu entfernen, muss der Menüpunkt „löschen“ im Kontextmenü des Elementes ausgewählt werden. Dabei werden gegebenenfalls auch untergeordnete Elemente gelöscht. Das Kontextmenü für ein Element wird dabei dadurch geöffnet, dass der rechte Mausbutton geklickt wird, während sich der Mauszeiger auf dem entsprechenden Element befindet.\n\n\nIm Input-Bereich gibt es außer den Hamster-Testbefehlen und den booleschen Operatoren (und, oder, nicht) noch das Epsilon. Das ist gleichbedeutend zum Wert true. Im Output-Bereich steht das Epsilon für die leere Anweisung (die nichts bewirkt).\n\n12.4.4 Automaten-Menü\n\nDas Automaten-Menü oberhalb des Programmbereiches beinhaltet folgende Funktionalität durch Auswahl des entsprechenden Menüpunktes:\n[Vergrößern] Durch Klicken auf diesen Menüpunkt wird der Graph im Programmbereich um eine Stufe vergrößert.\n\n[Verkleinern] Durch Klicken auf diesen Menüpunkt wird der Graph um eine Stufe verkleinert.\n\n\n12.5 Weitere Funktionen\n\nAusführung: Wie andere Programme auch können Hamster-Automaten gestartet, gestoppt, pausiert und fortgesetzt werden. Während der Ausführung werden die gerade aktiven Elemente rot hervorgehoben. Auch eine schrittweise Ausführung ist möglich (Funktion „Schritt hinein“).\n\nSpeichern/Laden: Hamster-Automaten können (bspw. über das Menü „Datei“) gespeichert und später wieder geladen werden. Im Dateibaum im Editorfenster werden entsprechende Dateien durch das Symbol „gelbes Kästchen mit rotem Punkt“ dargestellt.\n\nDrucken: Hamster-Automaten können (bspw. über das Menü „Datei“) gedruckt werden.\n\n13 Hamstern mit Programmablaufplänen\n\nSeit der Version 2.9 unterstützt der Hamster-Simulator das Hamstern mit Programmablaufplänen (Flowcharts). Herzlichen Dank an Gerrit Apeler, der im Rahmen seiner Bachelorarbeit die Integration dieses Konzeptes in den Hamster-Simulator vorgenommen hat.\n\n13.1 Programmablaufpläne\n\n\n13.2 Hamster-PAPs\n\nAls Elemente enthalten Hamster-PAPs Start/Stop-Elemente, Operationen, Unterprogramme, Verzweigungen, Kommentare und Pfeile.\n\n- **Start-Element:** Jedes Hamster-PAP-Programm und jedes selbst definierte Unterprogramm muss mit einem Start-Element beginnen.\n- **Stop-Element:** Jedes Hamster-PAP-Programm und jedes selbst definierte Unterprogramm muss bei einem Stop-Element enden.\n- **Operationen:** Als vordefinierte Operationen stehen die vier Hamster-Befehle vor, linksUm, gib und nimm zur Verfügung.\n- **Unterprogramme:** Es ist möglich, Unterprogramme zu definieren und im Programm zu verwenden.\n- **Verzweigungen:** Als vordefinierte Verzweigungen stehen die drei Hamster-Testbefehle vornFrei, kornDa und maulLeer zur Verfügung.\n- **Kommentare:** Es ist möglich Kommentare zu definieren und diese mit Elementen zu verbinden.\n- **Pfeile:** Elemente lassen sich untereinander mit Pfeilen verbinden, um somit den Programmfluss zu definieren.\n\nAbbildung 13.1 zeigt beispielhaft einen Hamster-PAP.\n13.3 Voraussetzungen\n\nUm mit dem Hamster-Simulator Hamster-PAPs entwickeln und ausführen zu können, muss die Property `flowchart` auf `true` gesetzt sein. Standardmäßig ist das der Fall. Um den PAP-Modus auszuschalten, öffnen Sie bitte die Datei `hamster.properties` und ersetzen Sie dort die Zeile `flowchart=true` durch die Zeile `flowchart=false`. \n\nAbbildung 13.1: Elemente von Hamster-PAPs\n13.4 Erstellen von Hamster-PAPs\n\n\n13.4.1 Auswahl-Menü\n\nDas Auswahl-Menü an der linken Seite beinhaltet folgende Funktionalität (von oben nach unten):\n\n- [Verzweigung-Element] Mit diesem roten Symbol kann ein Verzweigung-Element, d.h. ein Hamster-Testbefehl, in den Programmbereich gebracht werden.\n\n\n13.4.2 Programmbereich\n\nDer Programmbereich enthält Hamster-PAPs. Oberhalb des Programmbereichs sind für das Hauptprogramm (main) sowie definierter Unterprogramme Tabs angebracht. Durch Anklicken eines Tabs können Sie in den entsprechenden Bereich wechseln.\n13.4.3 Elemente\n\n\n**Operation-Elemente**: Bei der Erzeugung eines Operation-Elementes erscheint nach dem Draggen ein Menü, über das man auswählen kann, welchen Hamster-Befehl die neue Operation repräsentieren soll (vor, linksUm, gib, nimm).\n\n**Verzweigung-Elemente**: Bei der Erzeugung eines Verzweigung-Elementes erscheint nach dem Draggen ein Menü, über das man auswählen kann, welchen Hamster-Testbefehl die neue Operation repräsentieren soll (vornFrei, mauLeer, kornDa).\n\n**Unterprogramm-Elemente**: Bei der Erzeugung eines Unterprogramm-Elementes erscheint nach dem Draggen ein Menü, über das man auswählen kann, ob ein bereits definiertes Unterprogramm aufgerufen werden oder ein neues Unterprogramm definiert werden soll. Im zweiten Fall muss man in einem kleinen erscheinenden Fenster den Namen des neuen Unterprogramms eintippen und anschließend die RETURN-Taste drücken. Im Programmbereich wird dann ein neuer Tab erzeugt und automatisch aktiviert.\n\n**Kommentar-Elemente**: Nach der Erzeugung eines Kommentar-Elementes kann man nach dem Draggen den Kommentartext eingeben und die Eingabe durch Drücken der RETURN-Taste abschließen.\n\n\n13.4.4 Pfeile\n\n\n13.5 Weitere Funktionen\n\n**Ausführung:** Wie andere Programme auch können Hamster-PAPs gestartet, gestoppt, pausiert und fortgesetzt werden. Auch eine schrittweise Ausführung ist möglich (Funktion „Schritt hinein“). Während der schrittweisen Ausführung werden die gerade aktiven Elemente rot hervorgehoben.\n\n**Speichern/Laden:** Hamster-PAPs können (bspw. über das Menü „Datei“) gespeichert und später wieder geladen werden. Im Dateibaum im Editorfenster werden entsprechende Dateien durch das Symbol „gelbes Kästchen mit blauem Punkt“ dargestellt.\n\n**Drucken:** Hamster-Automaten können (bspw. über das Menü „Datei“) gedruckt werden.\n\n**Generieren:** Über das Menü-Item „Generieren“ im Menü „Datei“ lässt sich aus einem Hamster-PAP ein gleichbedeutendes imperatives Java-Hamster-Programm generieren. Die Funktion sollte allerdings nur bei fehlerfreien Hamster-PAPs ausgeführt werden. Ist das Hamster-PAP fehlerhaft, ist nicht definiert, was das generierte Programm tut.\n14 JavaScript\n\nJavaScript (kurz JS) ist eine Skriptsprache, die ursprünglich für dynamisches HTML in Webbrowsern entwickelt wurde, um Benutzerinteraktionen auszuwerten, Inhalte zu verändern, nachzuladen oder zu generieren und so die Möglichkeiten von HTML und CSS zu erweitern. Heute findet JavaScript auch außerhalb von Browsern Anwendung, so etwa auf Servern und in Microcontrollern.\n\nDer als ECMAScript (ECMA 262) standardisierte Sprachkern von JavaScript beschreibt eine dynamisch typisierte, objektorientierte, aber klassenlose Skriptsprache. Sie wird allen objektorientierten Programmierparadigmen unter anderem auf der Basis von Prototypen gerecht. In JavaScript lässt sich objektorientiert und sowohl prozedural als auch funktional programmieren (aus Wikipedia).\n\n14.1 Die Programmiersprache JavaScript\n\nIm Internet finden Sie viele Informationen rund um die Programmiersprache JavaScript. Schauen Sie einfach mal unter folgenden Links nach:\n\n- [http://openbook.rheinwerk-verlag.de/javascript_ajax/](http://openbook.rheinwerk-verlag.de/javascript_ajax/) (Online-Buch)\n\n14.2 JavaScript-Hamster-Programme\n\nUm mit dem Hamster-Simulator JavaScript-Programme entwickeln und ausführen zu können, muss die Property `javascript` auf `true` gesetzt sein. Standardmäßig ist das nicht der Fall. Öffnen Sie also die Datei `hamster.properties` und ersetzen Sie dort die Zeile `javascript=false` durch die Zeile `javascript=true`.\n\nStarten Sie dann den Hamster-Simulator. Wenn Sie ein neues Programm erstellen wollen, wählen Sie in der erscheinenden Dialogbox den Eintrag „JavaScript-Programm“. Im Editor-Bereich erscheint dann ein Feld mit dem Inhalt „if (vornFrei()) vor();“. Ersetzen Sie diesen Inhalt durch Ihr JavaScript-Programm und speichern Sie die Datei dann ab. JavaScript-Programme brauchen nicht compiliert zu werden. Nach dem Abspeichern haben Sie direkt die Möglichkeit, das Programm auszuführen. Syntaxfehler werden erst zur Laufzeit angezeigt.\n\nIm Hamster-Simulator lassen sich sowohl imperative als auch objektorientierte Python-Programme entwickeln. Auch gemischte Programme sind möglich. Der (imperative) Hamster kennt (wie üblich) die Befehle\n\n- `vor();`\n- `linksUm();`\n- `gib();`\n- `nimm();`\n- `vornFrei()` (-> boolean)\nEine vordefinierte Klasse namens `Hamster` kann für objektorientierte JavaScript-Programme genutzt werden. Die Klasse stellt folgende Methoden zur Verfügung:\n\n- `vor()`\n- `linksUm()`\n- `gib()`\n- `nimm()`\n- `vornFrei()` (→ boolean)\n- `kornDa()` (→ boolean)\n- `maulLeer()` (→ boolean)\n- `schreib(String)`\n- `liesZeichenkette(String)` (→ String)\n- `liesZahl(string)` (→ int)\n- `getReihe()` (→ int)\n- `getSpalte()` (→ int)\n- `getBlickrichtung()` (→ int: Hamster.NORD, Hamster.SUED, Hamster.OST, Hamster.WEST)\n- `getAnzahlKoerner()` (→ int)\n- `getStandardHamster()` (→ Hamster)\n\nDie Klasse definiert 2 Konstruktoren:\n\n- `Hamster(reihe, spalte, blickrichtung, anzahlKoerner)`\n- `Hamster(hamster)`\n\nLeider ist es aus implementierungstechnischen Gründen nicht möglich, Hamster-Objekte um zusätzliche Eigenschaften und Methoden zu erweitern. Weiterhin kann die Klasse Hamster leider auch nicht zur Vererbung über Prototypen genutzt werden.\n\nAus diesem Grund wurde eine JavaScript-Klasse JSHamster vordefiniert. JSHamster-Objekte können sowohl erweitert werden als auch kann die Klasse zur Vererbung über Prototypen genutzt werden (siehe Beispiel in Abschnitt 14.3.5).\n\n```javascript\nfunction JSHamster(r, s, b, k) {\n this.hamster = new Hamster(r, s, b, k);\n this.vor = function() {\n this.hamster.vor();\n }\n this.linksUm = function() {\n this.hamster.linksUm();\n }\n this.gib = function() {\n this.hamster.gib();\n }\n this.nimm = function() {\n this.hamster.nimm();\n }\n}\n```\n14.3 JavaScript-Beispielprogramme\n\nDie folgenden Unterabschnitte demonstrieren an Beispielen das Schreiben von JavaScript-Hamster-Programmen.\n\n14.3.1 Territorium leeren\n\nDas folgende JavaScript-Programm ist ein einfaches imperatives Beispielprogramm, bei dem der Standard-Hamster ein beliebiges Territorium ohne innere Mauern leert:\n\n// Aufgabe:\n// der Hamster steht irgendwo in einem beliebigen Territorium\n// ohne innere Mauern; er soll alle Körner fressen\nfunction kehrt() {\n linksUm();\n linksUm();\n}\n\nfunction rechtsUm() {\n kehrt();\n linksUm();\n}\n\nfunction laufeZurueck() {\n while (vornFrei()) {\n vor();\n }\n}\n\nfunction sammle() {\n while (kornDa()) {\n nimm();\n }\n}\n\nfunction laufeZurWand() {\n while (vornFrei()) {\n vor();\n }\n}\n\nfunction laufeInEcke() {\n laufeZurWand();\n linksUm();\n laufeZurWand();\n linksUm();\n}\n\nfunction ernteEineReihe() {\n sammle();\n while (vornFrei()) {\n vor();\n sammle();\n }\n}\n\nfunction ernteEineReiheUndLaufeZurueck() {\n ernteEineReihe();\n kehrt();\n laufeZurueck();\n}\n\nlaufeInEcke();\nernteEineReiheUndLaufeZurueck();\nrechtsUm();\nwhile (vornFrei()) {\n vor();\n rechtsUm();\n ernteEineReiheUndLaufeZurueck();\n rechtsUm();\n}\n14.3.2 Territorium leeren 2\n\nAuch das folgende JavaScript-Programm ist ein einfaches imperatives Beispielprogramm, bei dem der Standard-Hamster ein beliebiges Territorium ohne innere Mauern leert:\n\n```\n// Aufgabe:\n// der Hamster steht irgendwo in einem beliebigen Territorium\n// ohne innere Mauern; er soll alle Körner fressen\n\n// drehe dich um 180 Grad\nfunction kehrt() {\n linksUm();\n linksUm();\n}\n\n// drehe dich um 90 Grad nach rechts\nfunction rechtsUm() {\n kehrt();\n linksUm();\n}\n\n// der Hamster sammelt alle Körner eines Feldes ein\nfunction sammle() {\n while (kornDa()) {\n nimm();\n }\n}\n\n// Uberpruefung, ob sich links vom Hamster\n// eine Mauer befindet\nfunction linksFrei() {\n linksUm();\n if (vornFrei()) {\n rechtsUm();\n return true;\n } else {\n rechtsUm();\n return false;\n }\n}\n\n// Uberpruefung, ob sich rechts vom Hamster eine\n// Mauer befindet\nfunction rechtsFrei() {\n rechtsUm();\n if (vornFrei()) {\n linksUm();\n return true;\n } else {\n linksUm();\n return false;\n }\n}\n```\n// der Hamster laeuft bis zur naechsten Wand\nfunction laufeZurWand() {\n while (vornFrei()) {\n vor();\n }\n}\n\n// der Hamster laeuft in eine Ecke\nfunction laufeInEcke() {\n laufeZurWand();\n linksUm();\n laufeZurWand();\n linksUm();\n}\n\n// der Hamster soll sich in die naechste Reihe in noerdlicher\n// Richtung begeben; vom Hamster aus gesehen, liegt diese Reihe\n// links von ihm\nfunction begibDichLinksUmInNaechsteReihe() {\n linksUm();\n vor();\n linksUm();\n}\n\n// der Hamster soll sich in die naechste Reihe in noerdlicher\n// Richtung begeben; vom Hamster aus gesehen, liegt diese Reihe\n// rechts von ihm\nfunction begibDichRechtsUmInNaechsteReihe() {\n rechtsUm();\n vor();\n rechtsUm();\n}\n\n// Ueberpruefung, ob in noerdlicher Richtung (vom Hamster aus\n// gesehen links) eine weitere nicht mit Mauern besetzte\n// Reihe existiert\nfunction weitereReiheLinksVomHamsterExistiert() {\n return linksFrei();\n}\n\n// Ueberpruefung, ob in noerdlicher Richtung (vom Hamster aus\n// gesehen rechts) eine weitere nicht mit Mauern besetzte\n// Reihe existiert\nfunction weitereReiheRechtsVomHamsterExistiert() {\n return rechtsFrei();\n}\n\n// der Hamster soll alle Koerner in einer Reihe einsammeln\nfunction ernteEineReihe() {\n sammle();\n while (vornFrei()) {\n vor();\n sammle();\n }\n}\n\n// der Hamster soll alle Koerner in einer Reihe einsammeln;\n// er laeuft dabei von Westen nach Osten\ndefunction ernteEineReiheNachOsten() {\nernteEineReihe();\n}\n\n// der Hamster soll alle Koerner in einer Reihe einsammeln;\n// er laeuft dabei von Osten nach Westen\ndefunction ernteEineReiheNachWesten() {\nernteEineReihe();\n}\n\n// der Hamster soll einzelne Koernerreihen abgrasen,\n// so lange noch weitere Reihen existieren;\n// er unterscheidet dabei, ob er die Reihen von\n// Osten oder von Westen aus abgrast\nlaufeInEcke();\nernteEineReiheNachOsten();\nwhile (weitereReiheLinksVomHamsterExistiert()) {\nbegibDichLinksUmInNaechsteReihe();\nernteEineReiheNachWesten();\nif (weitereReiheRechtsVomHamsterExistiert()) {\nbegibDichRechtsUmInNaechsteReihe();\nernteEineReiheNachOsten();\n} else {\n kehrt();\n}\n}\n\n### 14.3.3 Berg erklimmen\n\nIm folgenden imperativen JavaScript-Programm erklimmt der Standard-Hamster einen Berg:\n\n// Aufgabe:\n// der Hamster soll den Gipfel eines vor ihm stehenden\n// Berges erklimmen\n\n// der Hamster soll zum Berg laufen\ndefunction laufeZumBerg() {\nwhile (vornFrei()) {\n vor();\n}\n}\n\n// der Hamster soll den Berg erklimmen\nfunction erklimmeDenBerg() {\nwhile (!gipfelErreicht()) {\nerklimmeEineStufe();\n}\n}\n\n// der Hamster soll eine Stufe erklimmen\nfunction erklimmeEineStufe() {\n linksUm(); // nun schaut der Hamster nach oben\nvor(); // der Hamster erklimmt die Mauer\nrechtsUm(); // der Hamster wendet sich wieder dem Berg zu\nvor(); // der Hamster springt auf den Vorsprung\n}\n\n// der Hamster dreht sich nach rechts um\nfunction rechtsUm() {\n linksUm();\n linksUm();\n linksUm();\n}\n\n// hat der Hamster den Gipfel erreicht?\nfunction gipfelErreicht() {\n return vornFrei();\n}\n\n// der Hamster soll zunächst bis zum Berg laufen\n// und dann den Berg erklimmen\nlaufeZumBerg();\nerklimmeDenBerg();\n\n14.3.4 Wettlauf\n\nIm folgenden objektorientierten JavaScript-Programm liefern sich 3 Hamster einen Wettlauf bis zur nächsten Mauer:\npaul = Hamster.getStandardHamster();\nwilli = new Hamster(paul);\nmaria = new Hamster(paul.getReihe()+1, paul.getSpalte(), Hamster.OST, 0);\nwhile (paul.vornFrei() && willi.vornFrei() && maria.vornFrei()) {\npaul.vor();\nwilli.vor();\nmaria.vor();\n}\npaul.schreib(\"Fertig!\");\n\n14.3.5 Objektorientiertes Territorium leeren\n\nIm folgenden JavaScript-Programm werden objektorientierte Konzepte genutzt, um einen Hamster das Territorium leeren zu lassen:\n\n// Ein neu erzeugter Hamster grast das Territorium ab und\n// zählt dabei die gesammelten Körner\nfunction AbgrasHamster(r, s, b, k) {\n JSHamster.call(this, r, s, b, k);\n\n this.gesammelt = 0;\n this.kehrt = function() {\n this.linksUm();\n this.linksUm();\n }\nAbgrasHamster.prototype = Object.create(JSHamster.prototype);\n\n// Hauptprogramm\n\npaul = new AbgrasHamster(2, 3, Hamster.WEST, 0);\npaul.laufeInEcke();\npaul.ernteEineReiheUndLaufeZurueck();\npaul.rechtsUm();\nwhile (paul.vornFrei()) {\n paul.vor();\n paul.rechtsUm();\n paul.erneuteReiheUndLaufeZurueck();\n paul.rechtsUm();\n}\npaul.schreibt(\"Gesammelte Koerner = \" + paul.gesammelteKoerner());\n15 Noch Fragen?\n\nEigentlich müsste dieses Benutzungshandbuch alle Fragen im Zusammenhang mit dem Hamster-Simulator klären. Wenn Sie trotzdem noch weitere Fragen oder Probleme haben, schreiben Sie mir einfach eine Email: boles@informatik.uni-oldenburg.de"}}},{"rowIdx":263,"cells":{"id":{"kind":"string","value":"c923870b098acffd4525370a7110f51fabba6876"},"text":{"kind":"string","value":"On the execution of high level formal specifications\n\nTimothy Allen Wahls\nIowa State University\n\nFollow this and additional works at: http://lib.dr.iastate.edu/rtd\nPart of the Computer Sciences Commons\n\nRecommended Citation\nhttp://lib.dr.iastate.edu/rtd/10732\n\nThis Dissertation is brought to you for free and open access by Iowa State University Digital Repository. It has been accepted for inclusion in Retrospective Theses and Dissertations by an authorized administrator of Iowa State University Digital Repository. For more information, please contact digirep@iastate.edu.\nINFORMATION TO USERS\n\nThis manuscript has been reproduced from the microfilm master. UMI films the text directly from the original or copy submitted. Thus, some thesis and dissertation copies are in typewriter face, while others may be from any type of computer printer.\n\nThe quality of this reproduction is dependent upon the quality of the copy submitted. Broken or indistinct print, colored or poor quality illustrations and photographs, print bleedthrough, substandard margins, and improper alignment can adversely affect reproduction.\n\nIn the unlikely event that the author did not send UMI a complete manuscript and there are missing pages, these will be noted. Also, if unauthorized copyright material had to be removed, a note will indicate the deletion.\n\nOversize materials (e.g., maps, drawings, charts) are reproduced by sectioning the original, beginning at the upper left-hand corner and continuing from left to right in equal sections with small overlaps. Each original is also photographed in one exposure and is included in reduced form at the back of the book.\n\nPhotographs included in the original manuscript have been reproduced xerographically in this copy. Higher quality 6\" x 9\" black and white photographic prints are available for any photographs or illustrations appearing in this copy for an additional charge. Contact UMI directly to order.\n\nUMI\n\nA Bell & Howell Information Company\n300 North Zeeb Road, Ann Arbor, MI 48106-1346 USA\n313/761-4700 800/521-0600\nOn the execution of high level formal specifications\n\nby\n\nTimothy Allen Wahls\n\nA Dissertation Submitted to the\nGraduate Faculty in Partial Fulfillment of the\nRequirements for the Degree of\nDOCTOR OF PHILOSOPHY\nDepartment: Computer Science\nMajor: Computer Science\n\nApproved:\nSignature was redacted for privacy.\nSignature was redacted for privacy.\nIn Charge of Major Work\nSignature was redacted for privacy.\nFor the Major Department\nSignature was redacted for privacy.\nFor the Graduate College\n\nMembers of the Committee:\nSignature was redacted for privacy.\nSignature was redacted for privacy.\nSignature was redacted for privacy.\n\nIowa State University\nAmes, Iowa\n1995\nTABLE OF CONTENTS\n\nACKNOWLEDGEMENTS ....................................................... v\n\n1. GENERAL INTRODUCTION .............................................. 1\n 1.1 Problem Statement .................................................. 1\n 1.2 Dissertation Organization ........................................... 4\n 1.3 Literature Review .................................................. 5\n 1.3.1 Algorithmic Specifications ..................................... 5\n 1.3.2 Prolog-based Specifications .................................... 9\n 1.3.3 Other Approaches ............................................... 11\n 1.3.4 Summary ....................................................... 13\n\n2. A CASE STUDY OF APPROACHES TO THE FORMAL SPECIFICATION OF ABSTRACT DATA TYPES ................................. 15\n 2.1 Introduction ......................................................... 16\n 2.2 Specifications of ADT Table ......................................... 18\n 2.2.1 VDM ............................................................ 18\n 2.2.2 Z ............................................................... 21\n 2.2.3 SPECS-C++ .................................................... 24\n 2.2.4 Prosper ......................................................... 26\n 2.2.5 Prolog ........................................................ 29\n 2.3 Specifications of ADT BndList ....................................... 30\n 2.3.1 VDM ............................................................ 30\n 2.3.2 Z ............................................................... 33\n 2.3.3 SPECS-C++ .................................................... 35\n 2.3.4 Prosper ......................................................... 37\n 2.3.5 Prolog ........................................................ 38\n4.1 Introduction .................................................. 71\n4.2 Syntax for Executable SPECS-C++ Specifications .......... 75\n4.3 An Algorithm for Executing Assertions ..................... 81\n 4.3.1 Evaluating Pre-conditions .......................... 81\n 4.3.2 Satisfying Post-conditions ......................... 83\n4.4 Limitations of the Execution Technique .................... 90\n4.5 Related Work ............................................... 92\n4.6 Conclusion ................................................ 94\n\n5. APPLICATIONS OF CONTRAINT LOGIC PROGRAMMING\n TECHNIQUES IN EXECUTING FORMAL SPECIFICATIONS 101\n5.1 Introduction ............................................... 101\n5.2 Prolog and CLP Languages ................................ 103\n5.3 Model-based Specification Languages ...................... 104\n5.4 Executing Model-Based Specifications .................... 106\n 5.4.1 Conversion of the Post-condition to Constraints ... 108\n 5.4.2 Solving Constraints into Post-state Values .......... 113\n 5.4.3 Examples ........................................... 120\n 5.4.4 Comments on the Implementation ................... 123\n 5.4.5 Performance ...................................... 124\n 5.4.6 Limitations ....................................... 126\n 5.4.7 Future Work ...................................... 127\n5.5 Comparison of the Execution Technique with CLP .......... 128\n\n6. GENERAL SUMMARY ......................................... 133\n6.1 Discussion of Results .................................... 133\n\nBIBLIOGRAPHY ................................................. 136\nACKNOWLEDGEMENTS\n\nThanks to my parents, Allen and Ellen Wahls, for their continuing support of my academic career. Thanks to my major professors, Albert Baker and Gary Leavens, for encouragement and inspiration. Thanks to my fiancee, Linda Null, for putting up with me while I was writing and grumbling. And a special thanks to IBM Rochester for the fellowship that supported me through much of the research that appears in this dissertation.\n1. GENERAL INTRODUCTION\n\n1.1 Problem Statement\n\nWhile the formal specification of software systems has generated volumes of research and is commonly taught in undergraduate and graduate courses, formal specifications are not widely used in industrial software development. The advantages of formal specifications are clear: they precisely describe the functionality, structure, and interfaces of software systems without involving the programming language details needed to produce an implementation. The specifier works at a higher level of abstraction than the programmer, and so has the opportunity to produce a concise definition of system functionality without worrying about algorithms, efficiency, memory management, and other aspects of implementations that have nothing to do with the functional behavior of the system. Abstracting away these details decreases the likelihood of errors in the specification and allows readers of the specification to perceive the defined functionality without the confusion and verboseness that such details bring. This allows the correct use of an implementation of a formal specification without reading the code of that implementation. Formal specifications also permit the verification of implementations. For safety critical applications, proof that the implementation satisfies the specification may be vital. Thus, the academic interest in formal specifications is not surprising.\n\nOn the other hand, a number of factors have kept formal specifications from wide acceptance in industrial settings. Many software developers are not familiar with the notations used in formal specifications, and training in writing, reading, and implementing specifications is expensive and time consuming. Compounding this problem, programmers often consider implementations to be the only important product of software development, and so often have little enthusiasm for even infor-\nmal specification and documentation. As specifications are written by humans, they often contain errors — specification of unintended and undesirable behavior. These errors can be found by examination of the specification (possibly including unsuccessful attempts to prove desirable properties of the specification), or by producing and testing an implementation of the specification. Examining and proving properties of specifications is difficult and labor intensive, even with the help of software tools, while producing an implementation of an erroneous specification wastes development resources. Additionally, formal specification activities produce little that can be demonstrated to clients as progress toward a completed system, as clients are unlikely to know the specification language and so are unable to read the specification. Unfortunately, this also means that a formal specification usually does not serve as a basis for discussion of whether the specified functionality is in fact the functionality desired by the client. Formal verification of implementations is tedious, error-prone, and labor intensive, so that such verification is rarely done even when a formal specification exists. Formal specifications are of some help in validating implementations, as they are an unambiguous definition of the correct output for any test. However, the tester must manually verify that the result of each test is consistent with the specification, which is again labor intensive and error-prone.\n\nExecutable specifications may be the key to increasing the usefulness and acceptance of formal specifications in industrial settings. Executable specifications can be debugged in much the same way that programs are debugged, as such specifications can easily be tested on a variety of inputs. This allows early and inexpensive detection and correction of errors in the specification. An executable specification is a working prototype of the final system, so that formal specification activities can also be viewed as progress toward a prototype. The prototype thus produced can be demonstrated to the client both as progress toward a final system, and to allow discussion of the desired functionality of the system as compared to the functionality expressed in the specification. A prototype is an excellent way to evaluate this functionality against the informal requirements of a client, as the client can directly determine whether the functionality satisfies the requirements. An executable specification helps in breaking down the barrier between specifiers and others involved in the software development process created by the formality of the specification language. While executable speci-\nfications provide no help in verifying implementations, they can serve as test oracles and so help in the validation of implementations. The behavior of implementations can be tested simply by running the implementation and executable specification on the same data and comparing the results. This allows considerable automation of the testing process and lessens the chance of human error.\n\nMany executable specification languages have been developed, and many different techniques have been used for executing specifications. Some of the relevant research is described in the literature review (Section 1.3). As the literature review will show, existing executable specification languages often force the specifier to work at a low level of abstraction. This occurs because the specifier is forced to provide many of the implementation details in order to produce an executable specification. As an extreme example, some executable specification languages require the specifier to write parts of the specification in a production programming language. More commonly, a formal specification language is restricted to a subset that is algorithmic enough to allow easy execution. In either case, the expressiveness of the specification language is reduced, and the clarity and conciseness of non-executable specifications is compromised by the inclusion of detail needed only for achieving executability. As a specification language becomes more like a programming language, the specifier's task of producing a clear and concise definition of system functionality becomes more and more confounded by the details needed for execution.\n\nThus, executable specifications are desirable, but only if such specifications maintain the characteristics of non-executable specifications. This dissertation describes research into executing specifications written at a higher level of abstraction than that found in existing executable specification languages. The particular focus is on developing an execution technique for model-based specification languages, where model-based means that operations are specified via first order predicate logic pre- and post-conditions written over a fixed set of abstract model types. Typically, such model types include finite sets and sequences, tuples, reals, integers and so on. Although the execution technique was developed in the context of the model-based specification languages DFD-SPECS and SPECS-C++, and the description of the technique in the dissertation uses syntax and examples from these languages, the execution technique is not specific to these languages. The execution technique can\neasily be adapted for any specification language that uses first order predicate logic assertions over a fixed set of model types. All that is required is to add code for handling any additional model types found in these languages. Examples of suitable languages include VDM [Jon90], Z [Hay87, Spi92, Spi88, Spi89], and the myriad dialects and object-oriented offspring of these languages. As VDM and Z are the dominant specification languages in both industrial usage and academia, the execution technique has the potential for much wider use than any interpreter or compiler that is tied closely to a particular language. Thus, the key contribution of the dissertation research is an algorithm for executing assertions over model types.\n\n1.2 Dissertation Organization\n\nThis dissertation is organized as a collection of papers on executing formal, model-based specifications. The papers are preceded by a general introduction and literature review, and followed by a general summary. All references cited in the dissertation (including the collected papers) follow the general summary. The literature review is meant to be self-contained, and so is in part redundant with literature reviews appearing in the included papers. As the collected papers are also self-contained, similar motivational material appears in several of the papers. However, the technical content of each paper is different, as each paper focuses on a different aspect of formal specifications or executing formal specifications.\n\nThe first paper appearing in this dissertation, A Case Study of Approaches to the Formal Specification of Abstract Data Types (Chapter 2), could be considered part of the literature review, as it compares and contrasts the use of model-based, executable, and object-oriented specification languages in specifying ADTs. The second paper, An Approach to the Execution of a Formalized Data Flow Diagram Specification Language (Chapter 3), describes the development of an interpreter for DFD-SPECS, a formalized Data Flow Diagram specification language. During this research, it became clear that this first technique for executing the predicate logic assertions was inadequate for executing some interesting specifications, and that a general technique for executing assertions would be useful for executing any model-based specification language. This realization lead to the research described in the third paper, An\nApproach to the Direct Execution of Model-Based Specifications (Chapter 4). This paper describes the first incarnation of the execution technique and its application in executing SPECS-C++, an interface specification language for specifying C++ classes. Later, this execution technique was applied to DFD-SPECS, resulting in the paper appearing in Chapter 3. Although this version of the execution technique was adequate for executing a large and useful subset of both DFD-SPECS and SPECS-C++, it did not handle underdetermined specifications well, and could not execute incomplete specifications. The author began investigating constraint logic programming languages as a possible means of correcting these deficiencies. This investigation lead to the final paper, Applications of Constraint Logic Programming Techniques in Executing Specifications (Chapter 5), which describes the refinement of the original execution technique using ideas from constraint logic programming. This paper includes a brief summary of the literature on constraint logic programming, and compares the refined execution technique with some of the major constraint logic programming languages.\n\n1.3 Literature Review\n\nThe dominant themes of the executable specification literature are: specification languages that require the specifier to provide the algorithms needed for executing specifications and specification languages that rely on Prolog [CM84] for executability. This section presents examples of both themes, as well as a critical discussion of them. Particular attention is given to work on executing VDM [Jon90] and Z [Hay87, Spi88, Spi89, Spi92] specifications, as these languages are the dominant model-based specification languages in use today and work on executing these languages is directly comparable with our execution technique.\n\n1.3.1 Algorithmic Specifications\n\nAs the name suggests, algorithmic specifications define operations and other parts of software systems by providing specific algorithms with the desired functionality. They are inherently easier to execute than specifications written at a higher level of abstraction, and so a great number of algorithmic specification languages\nhave been developed. This section reviews a sampling of these languages and then provides a critique of algorithmic specifications.\n\nThe aSet specification language [GRW91] with ACTESS modules provides a CASE (Computer Aided Software Engineering) tool for writing executable specifications based on Data Flow Diagrams (DFDs) [You89]. The ACTESS modules are used to define the functionality of bubbles. They are written in a procedural \"Pascal-like\" language, and so this is a clear example of an algorithmic specification language.\n\nThe Prosper specification language [LB89] [BY91] [BY92] [YB92] is designed for prototyping, and particularly for providing an oracle for automated testing of the finished system. Prosper also features an interesting dynamic and dependent type system. Prosper is classified as an algorithmic specification language because operations are specified in a functional \"Lisp-like\" programming language that provides the basis for the execution of Prosper specifications.\n\nPAISley [ZS86] is an executable specification language based on asynchronous processes, where each process is much like a finite state machine. The computations that occur on state transitions are written in a functional programming language that features composition, conditional selection, and tuple formation.\n\nPSDL [BL90] [LVY88] is an enhancement of DFDs for hard real-time specification. The language includes an interesting and elegant type system for flows. It qualifies as an algorithmic specific language because the atomic operations of the specified system must be written in some programming language.\n\nWhile functional programming languages are seldom thought of as specification languages, Harry [Har92a] presents a number of features of functional languages that makes them suitable for producing prototypes. These features include their somewhat declarative nature, preservation of referential transparency (in other words, lack of side effects), strong typing, and resemblance to model-based specification languages. Peyton-Jones [PJ86] adds lazy evaluation, modularity and abstraction, and the possibility of automatic transformation to more efficient programs to this list. Some examples of, and techniques for, such transformations to iterative programs are presented in [FWH92]. This provides a basis for refinement of functional prototypes to more efficient, imperative implementations. Eisenbach and Sadler [ES90a] have combined the observations of Glaser et. al [GHT84] and Fairley [Fai85] to conclude\nthat functional programs can be produced an order of magnitude more quickly than imperative programs, thus adding to their suitability as prototyping languages.\n\nThe *me too* executable specification language [Hen86] is another example of the specification potential of functional languages, as its language constructs are taken from functional languages, notably Miranda [Tur85] and KRC. The development methodology of *me too* is largely taken from VDM. Specifications are executed by embedding them in Lisp.\n\nThe work of Johnson and Sanders [JS90] is also based on functional programming, as they describe a semi-formal technique for translating Z specifications into Lazy ML [AJ88]. Their work includes implementations of Z’s built-in operators, although quantifiers appear to be restricted to ranging over finite lists of boolean values. They emphasize correctness preserving transformations to increase efficiency of prototypes, and the use of lazy evaluation to produce (possibly infinite) lists of solutions.\n\nOne prevalent subfield in algorithmic specifications is work on executing parts of the explicit subset of VDM. Explicit VDM specifications consist of the direct definition of pure functions, as opposed to implicit specifications that use first order predicate logic pre- and post-conditions to specify procedures and functions. Thus, explicit VDM specifications are somewhat similar to function definitions in pure functional programming languages, and researchers have exploited this similarity by using functional programming languages to execute parts of the explicit subset. Combining this with the fact that VDM is one of, if not the, most commonly used formal specification language, it is not surprising that a reasonably large body of work has grown around techniques for executing the explicit subset of VDM.\n\nAn early example of this work is the Meta IV compiler described in [Haß87]. (Meta IV is the formal name of the specification language associated with the Vienna Development Method, or VDM). The compiler described in this work is specialized to compiler generation - compiling VDM specifications of compilers to Pascal. It uses lazy evaluation, and so can handle infinite data structures. Another interesting feature is the use of executable fixed points for evaluating both lazy expressions (as they aren’t directly translatable to Pascal) and simultaneous let expressions.\n\nAnother approach using lazy evaluation is that of [BM93], which provides an in-\nformal algorithm and a semi-automated transformation for translating explicit VDM specifications to Lazy ML [AJ88]. The work includes a Lazy ML implementation of VDM’s data types.\n\nThe IPTES system [AELL92] [LL91] is a methodology and environment for incremental prototyping of embedded systems. The sequential components of the system are specified in a subset of the explicit subset of VDM tailored toward this application. The system includes an interpreter for this subset. One interesting feature of this interpreter is that it allows incomplete specifications – specifications that are nondeterministic or underdetermined. For incomplete specifications, one may adopt a loose semantics, in which the specification determines a set of non-isomorphic models for the specified system. This allows the specifier to delay the choice of a specific model, or simply not limit the specification to one model, as appropriate. See [HJ89] for a discussion of the advantages of loose semantics. The approach taken in the IPTES system is that incomplete specifications are underdetermined, and so the system provides a single model that satisfies the specification. Hence, it does not use a loose semantics.\n\nThe UK’s National Physical Laboratory has also been a major player in this area, as evidenced by its work on translating the explicit subset of VDM to both Miranda [Nor90] [O’N89] (a functional programming language somewhat similar to SML) and Standard ML [O’N92a] [O’N92b]. The contribution is the development of a syntax-directed editor for entering VDM specifications that can also translate the specification entered directly to SML code. The technique can even handle a (small) subset of implicit VDM specifications – those written in an “algorithmic enough” style for the translation to take place. As the editor allows any syntactically correct VDM specification to be entered, the resulting SML code must often be hand edited to account for limitations of the translation technique.\n\nThe EPROL specification language makes a subset of Meta IV executable by compiling it to Lisp. It is part of the EPROS system, which provides tool support for evolutionary and functionality prototyping and for building the user interface to the prototype. EPROL is especially interesting with respect to the execution technique described in the rest of this dissertation in that it also allows the execution of some implicit specifications. Unfortunately, the primary reference on EPROL [HI88]\ndoes not carefully characterize the subset of VDM that EPROL makes executable. However, from the examples presented, it appears that a quantified expression can only be evaluated if it contains no references to post-state values (and so can only be evaluated for its boolean value) and that the only operator that can be used to define post-state values is equality. Set and list comprehensions are used to get around these limitations. Thus, EPROL specifications must provide a level of algorithmic detail similar to that found in modern functional programming languages. See [IWH86, Har92b] for other reviews of EPROL.\n\nIn summary, considerable research has gone into developing executable, algorithmic specification techniques. However, algorithmic techniques as a class are written at an inappropriate level of abstraction for specifications. Ideally, a specification should only define the functionality of a system. Inclusion of other information, such as the algorithms needed to actually produce the specified behavior, serves only to make the task of the specifier more difficult and to make readers of the specification work harder to understand the specified functionality. Thus, there is good reason to investigate techniques for executing non-algorithmic specifications.\n\n1.3.2 Prolog-based Specifications\n\nThis category includes both specification languages whose syntax and semantics are based on Prolog, and also specification languages that provide executability by translating specifications into Prolog.\n\nThe PLEASE development system [TC89] incorporates an executable specification language with a distinctly Prolog-like syntax. Specifications are translated to Prolog for execution. Somewhat similarly, RSF [DFPT90], a language for real-time specification, uses Prolog syntax for expressions denoting both time stamps and values. More could be said about these languages, but their only relevance here is as examples of techniques based on Prolog.\n\nLazarev has advocated translating informal DFDs directly to Prolog [Laz89a] [Laz89b]. This technique cannot be automated, as it starts with an informal specification, but Lazarev provides an informal algorithm for making the translation. The user must also translate (completely by hand) the \"Structured English\" descriptions of bubble functionality to Prolog, as well as declaring the relationships between flows\nFor purposes of this research, the most interesting work that has been done in this area is the use of Prolog for executing and animating Z specifications. West and Eaglestone [WE92] describe an approach called structure simulation for translating a subset of Z into Prolog. This includes rules for translating schemas and several of the schema calculus operators, as well as Prolog implementations of Z set and function operators. However, this approach is limited in that it only supports sets, tuples, and functions represented as sets of tuples. Additionally, only a limited form of existentially quantified expressions and no universally quantified expressions can be handled by their translation technique. Finally, hand editing of the Prolog code resulting from the translation is often required to re-order clauses within the bodies of rules so that they can be executed.\n\nWest and Eaglestone point out two significant ways in which their work differs from most other Z to Prolog approaches:\n\n- They require the user to enter all test case sets as Prolog lists, while most approaches generate test cases from the translation of the schema signature. However, this generation approach produces an exponential number of test cases (in the size of the input), so some control of this process is required. For example, Dick et. al. [DKC90] describe this generate and test approach, and make their Prolog programs more efficient with a number of transformations, including replacing goals with more efficient (but equivalent) goals, and rearranging the order of goals in a rule.\n\n- They use procedural operators (i.e., cut) in their Prolog implementations of Z operators, while most approaches stick to the pure subset of Prolog.\n\nWhile Prolog has been applied in the research cited above, it does have a number of flaws when used as a specification/prototyping language. Languages that incorporate Prolog syntax necessarily expose readers and writers of specifications to that syntax. While Prolog syntax is a representation of a subset of first order predicate logic, it is very different from the syntax used in non-executable specification languages, and restricts the forms that logical assertions in specifications can take. Prolog programs also use relations in place of functions, which often confuses novice\nProlog users. Thus, Prolog is less expressive than first order predicate logic. Additionally, Prolog is not a pure logic programming language. Order of statements matters (as can be seen in West and Eaglestone's work, where hand re-ordering is required), and the language includes non-logical features such as ! (cut), fail, assert, and retract. These features are present largely to increase the efficiency of Prolog programs, and so have little meaning when Prolog programs are interpreted as functional specifications. Even Prolog programs that don't directly use these features (such as direct translations of formal specifications) often use not as logical negation, where not R is usually implemented as R, !, fail. Thus, it is difficult to stay within the logical interpretation of Prolog even when directly translating specifications. Both the loss of expressiveness with Prolog as compared to first order predicate logic and the use of non-logical features make Prolog programs considerably less abstract than non-executable model-based specifications.\n\nAnother serious flaw appears whenever specifications are translated to some programming language (so this charge applies to many of the techniques in the first section as well). When such translation is done, errors in the resulting prototype are reported by whatever the target language is. The translation system can help by generating code that gives helpful error messages, but this is difficult and it seems unlikely that all error conditions can be accounted for. For example, West and Eaglestone make no attempt to give such messages. Thus, the tester must know the target language well enough to determine what the error is, and also know the translation scheme well enough to invert it and find the cause of the error in the original specification. These are clearly nontrivial tasks, and so are burdens on users of specifications that are executed by such a translation.\n\nSo, there are faults with both algorithmic and Prolog-based approaches to executable specification, and good reasons to look for techniques that do not fit into either of these categories. The literature review concludes with a review of two such languages.\n\n1.3.3 Other Approaches\n\nWhile most executable specification languages fit neatly into either the algorithmic or Prolog-based categories, one language found fits equally well into both, and\none fits into neither.\n\nThe OBSERV prototyping language [TY92] models systems as collections of objects. The behavior of objects is modeled by finite state machines, with Prolog used to specify the activities within objects and the transitions between object states. However, the objects also have state variables, and these are modified using a \"Pascal-like\" language with assignment. Hence, OBSERV can be said to fit into both the Prolog-based and algorithmic categories, and so is open to most of the criticisms stated earlier.\n\nThe fase3/C++ language of Kamin and Kraus [KK93, Kra88] is a (mostly) executable interface specification language for C++ classes. The fase3 approach is very similar to that taken in the Larch [GHW85, GHC93] family of specification languages, as it is two-tiered, consisting of the fase3 shared language and the fase3/C++ interface language for C++. The shared language is where most specification occurs, and so where interesting execution occurs as well. Only a few primitive types such as integer, boolean, and so on are built into fase3. More structured types, such as the set, sequence, and tuple types found in model-based specification languages are specified in the shared language using a unique style of algebraic specification that allows any type to be represented as a tuple of functions. As long as these functions remain finite for a particular element of the type, the functions can be represented as \"tables\" (finite sets of tuples), and quantified assertions over that element can be executed. The syntax for quantified assertions is elegant and concise, as the specifier need not supply an explicit bound on the quantified variable, as is required by other executable specification languages that allow explicit quantifiers. Assertions that use observers other than equality to define values are also executable — in fact, the functions that represent an element are exactly the observers of the type as applied to that element.\n\nIn fase3, specifications are executed by first compiling them to an extended $\\lambda$-calculus, and then to an extended form of combinator graph, which is then reduced. This execution strategy can execute many forms of quantified assertions. However, only one kind of fase3 quantified assertion can be evaluated if its body contains refer-\n\n---\n\n1 Observers are functions that, when applied to a value, return some aspect of that value.\nences to the function return value being defined. This kind of assertion is a restricted form of existential quantification that can only be used to find a particular value for the function result that satisfies the body of the quantified assertion. Universally and other existentially quantified assertions cannot refer to the function result. Thus, a large class of quantified assertions that are useful in writing specifications are not executable. The usefulness of errors reported by the reduction algorithm in debugging the specification is also questionable, as the combinator graph is two compilation steps removed from original specification.\n\n1.3.4 Summary\n\nThus, all of the executable specification techniques reviewed suffer from at least one of the following problems:\n\n- operations are specified algorithmically, and so at a low level of abstraction\n- specifiers are forced to use the data types of executable languages like Lisp and Prolog.\n- specifications are executed by translation to some programming language or other formalism, which complicates testing and debugging specifications\n- specifications use Prolog syntax or are executed by translation to Prolog, and so expose the user to Prolog syntax and often to the non-logical features of the language\n\nThe problems associated with these techniques have already been highlighted.\n\nSo, the overall goal of the research described in this dissertation is to develop an execution technique for model-based specification languages that can execute specifications written at a high level of abstraction. The execution technique should not require users of executable specifications to know any programming or specification languages other than the language used for specifications, and it should be capable of reporting useful error messages in the context of the specification. The execution technique also should execute specifications written using the syntax of existing non-executable specification languages, and should allow the specifier to think only\nof the logical interpretation of the specification language while writing executable specifications. The key to meeting these goals is a general algorithm for executing assertions.\n2. A CASE STUDY OF APPROACHES TO THE FORMAL SPECIFICATION OF ABSTRACT DATA TYPES\n\nA paper in preparation for Computing Surveys\n\nTim Wahls, Albert L. Baker, and Gary T. Leavens\n\nAbstract\n\nThis paper compares five formal specification languages on the basis of specifications of the same two abstract data types (ADTs) in each language. The languages included are VDM, Z, SPECS-C++, Prosper, and Prolog. VDM and Z are the \"industry standard\" formal specification languages and so provide a known baseline for comparison. SPECS-C++ is an object-oriented interface specification language, and so represents both the growing number of object-oriented specification languages and interface specification languages. Prosper is an executable specification language wherein the necessary algorithms for execution are given in a functional programming language, and so typifies one approach to executable specifications. Many other executable specification languages either directly incorporate Prolog code in specifications or use Prolog as the engine for execution. The executable subset of SPECS-C++ is also compared with these executable specification languages. The specifications of the ADTs Table and Bounded List allow comparison of both highly practical and more theoretical differences between the specification languages. These comparisons provide a brief introduction to the languages and highlight some of the differences in language features and specification styles that impact reading and writing specifications.\n2.1 Introduction\n\nModel-based specification languages have dominated industrial use of formal methods, as evidenced by the popularity of VDM [Jon90] and Z [Hay87, Spi92, Spi88, Spi89]. Recently, many executable and object-oriented specification languages have been proposed, accompanied by claims that these approaches enhance the role of formal specifications in software development. In this paper, we compare and contrast these approaches by giving specifications of the same abstract data types in languages that represent each approach, and then comparing the difficulties of writing the specifications and the features of the resulting specifications.\n\nThe example ADTs, Table and Bounded List, were chosen because they are small enough to allow complete and at least somewhat realistic specifications to be included in this paper, because they typify the reusable abstraction that can often be cleanly separated from a larger system, and because we believe that they provide a fair basis for comparison. The specifications of ADT Table appear in Section 2.2 and of ADT Bounded List in Section 2.3. To assist readers who are unfamiliar with a particular language, some explanation of relevant language features appears with each specification. These specifications allow the languages to be compared on issues that would arise frequently in day-to-day use of a specification language. The example specifications follow the styles and conventions of each language, while keeping the models (for the model-based languages) and interfaces as similar as possible. When these goals conflict, language conventions are favored. Following these practical comparisons, the languages are compared from a more theoretical standpoint - on issues arising from the design philosophies behind the languages and on the intended applications of the languages.\n\nThe languages compared are VDM, Z, SPECS-C++ [Bak93], Prosper [LB89, LB88, BY91, BY92, YB92], and Prolog [CM84, Coh85]. VDM and Z are included in this comparison as the standard specification languages in use today, with the largest user communities and widest array of tools supporting specification activities.\n\nSPECS-C++ is a recently developed object-oriented specification language which is tailored to specifying the interfaces of C++ [Str91] classes. Class and member function interfaces are given in C++ syntax, and a SPECS-C++ class specification must\nbe implemented by a C++ class with the same interface. The domains of SPECS-C++ are abstract model types similar to those of VDM and Z, except for the exclusion of function and relation types and the inclusion of object types. SPECS-C++ objects are similar to cells in imperative programming languages and locations in denotational semantics. Objects contain values, and the same object can have many names— for example, an object can appear as an element of a set and as an element of a sequence simultaneously. Any change in the contained value is visible from any occurrence of the object. Thus, objects allow uniform detection and specification of mutation and aliasing, which is critical in writing practical specifications of C++ implementations.\n\nThe state of SPECS-C++ class instances is modeled by a tuple of abstract data members. For example, the abstract data members of class BndList (Section 2.3.3) are theList, currCursor, and maxSize. Abstract data members exist only to provide the abstract values of class instances, and so need not be implemented directly. However, for any correct implementation, there will be a mapping from the implementation data members to the abstract data members. In specification inheritance, a derived class inherits all of the abstract data members of its base classes. When a member function from a base class is respecified in a derived class, the base class specification is inherited. Thus, the implementation of the derived class member function must satisfy the base class specification's post-condition whenever the base class specification's pre-condition is satisfied. This kind of inheritance forces subclasses to be behavioral subtypes, and is similar to that found in Larch/C++ [LC93] and Eiffel [Mey90]. Other object-oriented specification languages include dialects of VDM and Z such as Fresco [Wil92], Object-Z [CDD+90] and Z++ [LH92], and the languages featured in [SBC92].\n\nProsper is an executable specification language that relies on functional programming language techniques for its executability. Thus, it has much in common with me too [Hen86], EPROL [HI88, HI86], and SMLVIEW [O'N92a, O'N92b]. However, Prosper uses a powerful dependent type system not shared by any of these other languages. In all of these languages, the algorithms necessary for execution must be written by the specifier in a functional style, although the syntax involved varies from Lisp-like to a subset of VDM. Another variation on this theme is PAISley [ZS86],\nwhich specifies systems via asynchronous processes with a finite set of states. The computations that occur during state changes in PAISley are written in a functional programming language, and so the specification of a system that uses one of the example ADTs would likely include something like the Prosper specification appearing in this paper. Although the comparison will focus on Prosper, many of the comments will also apply to these other languages, and these languages will be referred to as needed in the exposition.\n\nAlthough raw Prolog is sometimes used as a specification language, Prolog is included in this comparison mostly because of the number of specification languages that make use of Prolog syntax or actual Prolog code. PLEASE [TC89], for example, uses a distinctly Prolog-like syntax, and specifications are translated to Prolog for execution in a hybrid Prolog/Ada prototyping environment. In OBSERV [TY92], finite state machines are used to model the changing state of a software system. The activities that occur on a state transition are described by Prolog code, and so a system using one of the example ADTs would likely include a section of Prolog code such as the one given in this paper. Relevant differences between PLEASE, OBSERV, and Prolog are noted in the following comparisons.\n\nThe rest of this paper is organized as follows. Sections 2.2 and 2.3 present the example specifications of ADTs Table and Bounded List, respectively, in each of the five specification languages. Some introductory material is included for readers who may not be familiar with the particular specification languages. Section 2.4 presents practical comparisons of the specification languages based on specifying the example ADTs. Section 2.5 presents more theoretical comparisons of the languages, although the example specifications are still used as illustrations. Section 2.6 summarizes these comparisons.\n\n2.2 Specifications of ADT Table\n\n2.2.1 VDM\n\nVDM uses modules for visibility control. Here, module TABLE is parameterized by RangeType, which is the type of the elements stored in the table. In VDM, $\\mathbb{Z}$ is the type name for integers. Composite types (also called trees) are defined with\nthe :: notation, and are basically tuples. For example, EntryType is the type of tuples with Index and Value fields. In VDM, the natural model for tables would be a map of type Index \\(\\rightarrow\\) RangeType. It is modeled as a set of EntryType here to allow easier comparison with the other specifications of ADT Table, as not all of the languages have map types. Each type definition can have an invariant, provided here by the function inv-Table. The state keyword preceeds the description of the state that the operations of the module use. The initial state of Tables is included here.\n\nThe operation specifications consist of first order predicate logic pre- and post-conditions over the model types. The ext rd and ext wr clauses indicate the external variables that the operation has read and write access to, respectively. There is no requirement that these variables be global in an implementation – they can be thought of as part of the formal parameter list. Variables appearing in the ext wr clause have both a pre- and post-state. In the post-condition, the undecorated variable name denotes the post-state value and the variable name under a harpoon (\\(\\rightarrow\\)) denotes the pre-state value. In the pre-condition, the undecorated name denotes the pre-state value.\n\nmodule TABLE\nparameters types RangeType exports\ntypes\n Table\noperations\n initTable: () \\rightarrow\n AddEntry: Z \\times RangeType \\rightarrow\n RemoveEntry: Z \\rightarrow\n AccessTable: Z \\rightarrow\n ReplaceValue: Z \\times Z \\rightarrow\ndefinitions\n\ntypes\n EntryType::Index: Z\n Value: RangeType\nTable = EntryType-set\ninv inv-Table(T)\nstate\nState of T: Table\n\\[ \\text{init}(\\text{mk-State}(T_0)) \\triangleq T_0 = \\{ \\} \\]\nend;\nfunctions\n\ninv-Table: Table \\rightarrow B\ninv-Table(T) \\triangleq \\forall t \\in T \\cdot \n\\forall s \\in T \\cdot \n\\quad t \\neq s \\Rightarrow \\text{Index}(t) \\neq \\text{Index}(s)\n\noperations\n\nInitTable()\next wr T: Table\npost T = {} \n\nAddEntry(I: \\mathbb{Z}, V: \\text{RangeType})\next wr AddedOk: B, T: Table\npost ((\\exists e \\in T \\cdot \\text{Index}(e) = I) \n\\quad \\land T = \\text{mk-State}(T) \\land \\text{AddedOk} = \\text{false})\n\\vee (((\\exists e \\in T \\cdot \\text{Index}(e) = I) \n\\quad \\land T = \\text{mk-State}(T) \\cup \\text{mk-EntryType}(I, V) \\land \\text{AddedOk} = \\text{true})\n\nRemoveEntry(I: \\mathbb{Z})\next wr T: Table\npost T = T \\setminus \\{e \\in T | \\text{Index}(e) = I\\}\n\nAccessTable(I: \\mathbb{Z})\next rd T: Table\nwr V: \\text{RangeType}, Defined: B\npost ((\\exists e \\in T \\cdot \\text{Index}(e) = I) \n\\quad \\land V = \\text{Value}(e) \\land \\text{Defined} = \\text{true})\n\\vee (((\\exists e \\in T \\cdot \\text{Index}(e) = I) \\land \\text{Defined} = \\text{false})\n\nReplaceValue(I: \\mathbb{Z}, V: \\text{RangeType})\next wr T: Table\nwr ChangedOk: B\n\\[\n\\text{post } ((\\exists e \\in T \\cdot \\text{Index}(e) = I) \\\\\n\\land T = (T - \\{e\\}) \\cup \\{\\text{mk-EntryType}(I, V)\\}) \\\\\n\\land \\text{ChangedOk} = \\text{true}) \\\\\n\\lor ((\\neg \\exists e \\in T \\cdot \\text{Index}(e) = I) \\land \\text{ChangedOk} = \\text{false})\n\\]\n\nend TABLE\n\n2.2.2 Z\n\nIn Z, schemas are used to define types and specify operations. In this example specification, schemas \\text{EntryType} and \\text{Table} define types and schemas \\text{AddEntry}, \\text{RemoveEntry}, \\text{AccessTable}, \\text{ReplaceValue}, and \\text{InitTable} specify the operations on tables. The remaining schemas are used by these operation schemas. There are two forms for schemas: a box (labeled with the schema name) that may be separated into two pieces by a shorter horizontal line, and an equational form that uses \\( = \\) to define a schema name. In the box form, the part above the short horizontal line is the declaration part, and the part below the predicate part.\n\nWhen a schema is used to define a type, the type's model is composed of the variables declared in the declaration, and every element of the type must satisfy the predicate part. In schema \\text{Table}, the variable \\text{theTable} makes up the state of \\text{Tables} and the predicate is used to give the invariant on type \\text{Table}. (In the type of \\text{theTable}, \\( \\mathcal{P} \\) is the powerset operator.) When a schema is used to specify an operation, the declaration gives the variables used in the specification, and the predicate part defines the functionality. When the predicate of a schema specifying an operation has two parts, the first is often the pre-condition and the second the post-condition of the operation. This convention is followed in the example Z schemas.\n\nBy Z convention, undecorated variable names denote pre-state values, while primed (') variables denote post-state values. Variable names ending with a question mark denote inputs (formal parameters), while those ending with an exclamation point denote outputs. For example, in schema \\text{KeyDefined}, \\(? ? \\) is an input and \\text{report!} is an output.\n\nThe schema calculus is used to combine existing schemas in many different ways to form new schemas. Schema \\( \\Delta \\text{Table} \\), which introduces pre- and post-state identifiers\nfor Tables, is included in the declaration part of any schema that change the state of a Table. Similarly, schema $\\Xi$Table, which equates the pre- and post-state values, is included in the declaration of any schema which does not change the state of a Table. Including a schema in the declaration part of another in this way is equivalent to merging the declarations and conjoining the predicates of the two schemas. The other schema calculus operators used in this specification are $\\wedge$ and $\\lor$. The $\\wedge$ operator is similar to inclusion, as $S \\wedge T$ produces a schema with the declarations of $S$ and $T$ merged and the predicates conjoined. The result of $S \\lor T$ is the schema with the declarations of $S$ and $T$ merged and the predicates disjoined. For example, schema AddEntry is built from schemas AddEnt, OK, and KeyDefined by using these operators.\n\nAs in VDM, $\\pi$ has a map type which would have been the natural choice as the model for Table. Except for the use of the schema calculus to split up normal and error conditions, the specification is analogous to the VDM specification of ADT Table.\n\n- **EntryType**\n - Index: $\\mathbb{Z}$\n - Value: RangeType\n\n- **Table**\n - $\\text{theTable}: \\mathcal{P} \\text{EntryType}$\n - $\\forall t : \\text{EntryType} \\; \\exists \\; t \\in \\text{theTable}$\n - $\\forall s : \\text{EntryType} \\; \\exists \\; s \\in \\text{theTable} \\land t \\neq s \\Rightarrow \\; \\text{Index}(t) \\neq \\text{Index}(s)$\n\n- **OK**\n - $\\Xi$Table\n - report!: MESSAGE\n - $\\Rightarrow \\; \\text{report!} = 'Ok'$\n\n- **AddEnt**\n\\[ \\Delta \\text{Table} \\]\n\\[ I?: \\mathcal{Z} \\]\n\\[ V?: \\text{RangeType} \\]\n\n\\[ \\neg \\exists e : \\text{EntryType} \\bullet e \\in \\text{theTable}(T) \\land \\text{Index}(e) = I? \\]\n\\[ \\exists e : \\text{EntryType} \\bullet \\text{Index}(e) = I? \\land \\text{Value}(e) = V? \\]\n\\[ \\land \\text{theTable}(T') = \\text{theTable}(T) \\cup \\{e\\} \\]\n\n---\n\n- KeyDefined\n\n\\[ \\Xi \\text{Table} \\]\n\\[ I?: \\mathcal{Z} \\]\n\\[ \\text{report!}: \\text{MESSAGE} \\]\n\n\\[ \\exists e : \\text{EntryType} \\bullet e \\in \\text{theTable}(T) \\land \\text{Index}(e) = I? \\]\n\\[ \\text{report!} = \\text{\\'Key already defined\\'} \\]\n\n---\n\nAddEntry \\( \\equiv (\\text{AddEnt} \\land \\text{OK}) \\lor \\text{KeyDefined} \\)\n\n- RemoveEntry\n\n\\[ \\Delta \\text{Table} \\]\n\\[ I?: \\mathcal{Z} \\]\n\n\\[ \\text{theTable}(T') = \\text{theTable}(T) - \\{e : \\text{EntryType} \\mid e \\in \\text{theTable}(T) \\land \\text{Index}(e) = I?\\} \\]\n\n---\n\n- AccessTab\n\n\\[ \\Xi \\text{Table} \\]\n\\[ I?: \\mathcal{Z} \\]\n\\[ V!: \\text{RangeType} \\]\n\n\\[ \\exists e : \\text{EntryType} \\bullet e \\in \\text{theTable}(T) \\land \\text{Index}(e) = I? \\]\n\\[ \\exists e : \\text{EntryType} \\bullet e \\in \\text{theTable}(T) \\land \\text{Index}(e) = I? \\land V! = \\text{Value}(e) \\]\n\n---\n\n- KeyNotDefined\n\n\\[ \\Xi \\text{Table} \\]\n\\[ I?: \\mathcal{Z} \\]\n\\[ \\text{report!}: \\text{MESSAGE} \\]\n\\(\\forall e : \\text{EntryType} \\in \\text{theTable}(T) \\land \\text{Index}(e) = I \\Rightarrow \\text{report}! = \\text{'Key not defined'}\\)\n\n\\(\\text{AccessTable} \\triangleq (\\text{AccessTab} \\land \\text{OK}) \\lor \\text{KeyNotDefined}\\)\n\n- \\(\\Delta \\text{Table}\\)\n - \\(I? : \\mathbb{Z}\\)\n - \\(V? : \\text{RangeType}\\)\n - \\(\\exists e : \\text{EntryType} \\in \\text{theTable}(T) \\land \\text{Index}(e) = I\\)\n - \\(\\exists e : \\text{EntryType} \\in \\text{theTable}(T) \\land \\text{Index}(e) = I\\)\n - \\(\\land \\text{theTable}(T') = (\\text{theTable}(T) - \\{e\\})\\)\n - \\(\\cup\\{e : \\text{EntryType} \\mid \\text{Index}(e) = I \\land \\text{Value}(e) = V\\}\\)\n\n\\(\\text{ReplaceValue} \\triangleq (\\text{ReplaceVal} \\land \\text{OK}) \\lor \\text{KeyNotDefined}\\)\n\n- \\(\\Delta \\text{Table}\\)\n - \\(\\Delta \\text{Table}\\)\n - \\(\\text{theTable}(T') = \\{\\}\\)\n\n2.2.3 SPECS-C++\n\nSPECS-C++ specifications are intended to serve as header files for C++ implementations. Hence, the parts of the following specification that are not comments (i.e., not enclosed in the /* */ comment delimiters) are legal C++ code. In particular, the template mechanism of C++ is used to parameterize class specifications by types. The model and invariant for class Table are analogous to those for the VDM and Z versions. The type defined by a class specification is modeled as a tuple of the abstract data members (data members).\n\nIn SPECS-C++, only object types are mutable, and so only objects have pre- and post-state values. Object types end in &. For example, the type of objects containing\nboolean values is bool\\&. An undecorated expression of an object type denotes the pre-state value of the object, while the same expression primed (') denotes the post-state value. As in C++, each member function takes an implicit argument, which in SPECS-C++ is called self, of the object or value type of the class. Thus, in the following member function specifications, self is always of type Table\\& or Table. The name of an abstract data member can be used as a shorthand for the corresponding field of the tuple contained in self, so the Table' is the same as self'.theTable.\n\nMember functions with the same name as the class are constructors, and are used to initialize instances of the class. Member function Table is the only constructor of this class Table. Type void is the return type of pure procedures.\n\ntemplate<class RangeType> class Table {\n /* model\n ** domains\n ** int DomainType\n ** tuple EntryType ( \n ** DomainType Index, \n ** RangeType Value) \n ** data membersA \n ** set of EntryType theTable \n ** invariantA \n ** \\forall (EntryType t) [ \n ** t \\in theTable => \n ** \\forall (EntryType s) [ \n ** s \\in theTable /\\ t != s => \n ** Index(t) != Index(s) \n ** ] \n ** ] \n */\n public:\n Table(); \n /* modifies: self \n ** postA: theTable' = {} \n */\n void AddEntry(DomainType I, RangeType V, bool& AddedOk); \n /* modifies: self, AddedOk \n */\n}\n\\*\\* postA: (\\exists (EntryType e) [ \\\\\n** e \\in theTable /\\ Index(e) = I] \\\\\n** \\ / AddedOk' = false) \\\\\n** \\ / (! (\\exists (EntryType e) [ \\\\\n** e \\in theTable /\\ Index(e) = I]) \\\\\n** / theTable' = theTable \\union \\{(I, V)} \\\\\n** / \\ / AddedOk' = true) \\\\\n*/\n\nvoid RemoveEntry(DomainType I);\n/* modifies: self \n** postA: theTable' = theTable - \\{e | e \\in theTable /\\ Index(e) = I\\} */\n*/\n\nvoid AccessTable(DomainType I, RangeType V, bool& Defined);\n/* modifies: V, Defined \n** postA: (\\exists (EntryType e) [ \\\\\n** e \\in theTable /\\ Index(e) = I /\\ V' = Value(e)] \\\\\n** / \\ / Defined' = true) \\\\\n** / (! (\\exists (EntryType e) [ \\\\\n** e \\in theTable /\\ Index(e) = I]) \\\\\n** / \\ / Defined' = false) \\\\\n*/\n\nvoid ReplaceValue(DomainType I, RangeType V, bool& ChangedOK);\n/* modifies: self, ChangedOK \n** postA: (\\exists (EntryType e) [ \\\\\n** e \\in theTable /\\ Index(e) = I \\\\\n** / theTable' = (theTable - \\{e\\}) \\union \\{(I, V)} \\\\\n** / \\ / ChangedOk' = true) \\\\\n** / (! (\\exists (EntryType e) [ \\\\\n** e \\in theTable /\\ Index(e) = I]) \\\\\n** / \\ / ChangedOk' = false) \\\\\n*/\n\n2.2.4 Prosper\n\nAs in VDM, Prosper uses modules to control what types and operations are exported by a specification. Unlike VDM (or any other language in this survey),\ntypes are first class citizens in the language and can be passed to and returned from functions. Many of the functions specified in this example are parameterized by type. List is a type constructor that takes a type and returns the type of lists of that type. The supertype functions SUM and SUB are used to construct new types. SUM constructs a (possibly infinite) discriminated union of types. Functions \\texttt{Inj} and \\texttt{Proj} are used to inject elements into and project elements from the union, respectively. SUB is used to construct subtypes by specifying a predicate that elements of the subtype must satisfy. For example, only Lists that satisfy the predicate \\texttt{Not Null}? typecheck as the first argument of function Head, where \\texttt{Not Null}? \\texttt{x} is just \\texttt{not(Null? x)}.\n\nAs Prosper is executable, the invariant for ADT Table (as expressed by function \\texttt{IsTableRep}?) is quite different than the invariants for the languages discussed so far, as the previous invariants have been relatively abstract. As Prosper is a pure functional language, there is no notion of pre- and post-state. The notation is LISP-like (with the exception of the type information). Prosper has only a few primitive types, so type List is specified from scratch, and then Table is built on List.\n\n```\nmodule Generic-List\nexport\n List @ TYPE \\rightarrow TYPE;\n Nil @ List('some:TYPE);\n Head @ SUB(Not_Null? @ (List('some:TYPE) boolean)) \\rightarrow 'some;\n Tail @ SUB(Not_Null? @ (List('some:TYPE) boolean)) \\rightarrow List('some);\n Cons @ ('some:TYPE \\times List('some)) \\rightarrow List('some);\n IsIn? @ 'some:TYPE \\rightarrow• List('some) \\rightarrow boolean;\n Null? @ List('some:TYPE) \\rightarrow boolean\n Length @ List('some:TYPE) \\rightarrow integer\n\nfrom\n value List such that List('t)\n is SUM(\\texttt{IsListRep}? 't);\n value \\texttt{IsListRep}? @ TYPE \\rightarrow TYPE \\rightarrow boolean such that \\texttt{IsListRep}? 'a 'b is\n if 'b = single then true\n else if Cartesian? 'b then let 'z \\times 'y be 'b\n in ('z = 'a) and (\\texttt{IsListRep}? 'a 'y)\n else false;\n value Nil is ($ @ single) @ SUM(\\texttt{IsListRep}? ('some:TYPE));\n```\nvalue Head such that Head('x) is first(Proj('x));\nvalue Tail such that Tail ('x:List('t))\n is (Inj (IsListRep? ('t)) (snd(Proj 'x)));\nvalue Cons such that Cons('a, 'b:List('t))\n is (Inj (IsListRep? ('t)) ('a, (Proj 'b)));\nvalue IsIn? such that IsIn? 'Item 'b:List('t) is\n if Null? 'b then false\n else 'Item = first(Proj('b)) or IsIn? 'Item, snd(Proj('b))\nvalue Null? such that Null? 'L is 'L = Nil\nvalue Length such that Length 'L is\n if Null? 'L then 0 @ integer\n else 1 @ integer + Length(Tail 'L)\nend-from\n\nmodule Table\nexport\n Table @ TYPE ^ TYPE;\n InitTable @ Table('vt:TYPE);\n AddEntry @ ('I:integer x 'vt:TYPE x SUB(Not_KeyDefined('I)\n @ Table('vt:TYPE) —>• boolean) —»• Table('vt);\n RemoveEntry @ (integer x Table('vt:TYPE)) —> Table('vt);\n AccessTable @ ('I:integer x SUB(KeyDefined('I) @\n Table('vt:TYPE) —»• boolean) —s- 'vt;\n ReplaceValue @ ('I:integer x 'vt:TYPE x SUB(KeyDefined('I)\n @ Table('vt:TYPE) —> boolean)) —» Table('vt);\nfrom\n value EntryType @ 'vt:TYPE —> TYPE is integer x 'vt;\n value Table such that Table('vt) is SUB(IsTableRep? 'vt);\n value IsTableRep? @ 'vt:TYPE —> List(EntryType('vt)) —>• boolean\n such that IsTableRep 'a 'T is\n if Null? 'T then true\n else if Not_IsIn? Head('T) Tail('T)\n then Not_KeyDefined first(Head('T)) Tail('T)\n and IsTableRep? 'a Tail('T)\n else IsTableRep? 'a Tail('T);\n value KeyDefined @ integer —> Table('vt:TYPE) —> boolean such that\n KeyDefined 'I 'T is\n if Null?('T) then false\n else first(Head('T)) = 'I or KeyDefined 'I Tail('T);\n value InitTable is Nil;\nvalue AddEntry such that AddEntry('I, 'V, 'T) is Cons(('I, 'V), 'T);\nvalue RemoveEntry such that RemoveEntry('I, 'T) is\n if Null?('T) then Nil\n else if first(Head('T)) = 'I then Tail('T)\n else Cons(Head('T), RemoveEntry('I, Tail('T)));\nvalue AccessTable such that AccessTable('I, 'T) is\n if first(Head('T)) = 'I then snd(Head('T))\n else AccessTable('I, Tail('T));\nvalue ReplaceValue such that ReplaceValue('I, 'Z, 'T) is\n if first(Head('T)) = 'I then Cons(('I, 'Z), Tail('T))\n else Cons(Head('T), ReplaceValue('I, 'Z, Tail('T)))\nend-from\n\n2.2.5 Prolog\n\nA Prolog program consists of a set of rules. The part of a rule to the left of\nthe :- is called the head, and the part to the right is the tail. The tail is optional,\nand a rule with no tail is called a fact. Rules define relations, so logically a fact is\njust an assertion that the relation holds for the case given. For example, the first\nrule for keyDefined asserts that the relation keyDefined holds when the first entry\nin the table has the given key. Rules with tails can be thought of as backwards\nlogical implications. For example, the second rule for keyDefined can be interpreted\nas asserting that whenever keyDefined holds for a table, it also holds for the table\nconstructed by adding any entry to that table. Together, these two rules define the\nkeyDefined relation on indices and tables. As Prolog programs define relations, even\nthe operations that are specified as functions or procedures in other languages are\nrelations here. For example, addEntry is defined as a relation between a key and two\ntables, rather than an operation on tables.\n\nIn Prolog, the notation [] is used for constructing lists, and [X|Y] denotes the\nlist with X as its first element and Y as the rest of the list. Prolog programs rely\nheavily on pattern matching. For example, an expression like [X|Y] can be matched\nwith a list to decompose it. An underscore (_) is a wildcard that matches anything.\n\nAs Prolog is an untyped programming language, programs are inherently poly-\nmorphic. Although the invariant for ADT Table is not expressed here, the operations\ndo preserve it. The invariant could be expressed and checked for any Table value.\nkeyDefined(I, [entry(I,_)|_]).\nkeyDefined(I, [_|TheTable]) :- keyDefined(I, TheTable).\n\naddEntry(TheTable, I, V, [entry(I, V)|TheTable]) :-\n not(keyDefined(I, TheTable)).\n\nremoveEntry(_, [], []).\nremoveEntry(I, [entry(I, _)|TheTable], TheTable).\nremoveEntry(I, [entry(X, V)|TheTable], [entry(X, V)|NTable]) :-\n I <> X,\n removeEntry(I, TheTable, NTable).\n\naccessTable(I, [entry(I, V)|_], V).\naccessTable(I, [_|TheTable], V) :-\n keyDefined(I, TheTable),\n accessTable(I, TheTable, V).\n\nreplaceValue(I, V, [entry(I, _)|TheTable], [entry(I, V)|TheTable]).\nreplaceValue(I, V, [entry(X, Y)|TheTable], [entry(X, Y)|NTable]) :-\n keyDefined(I, TheTable),\n I <> X,\n replaceValue(I, V, TheTable, NTable).\n\n2.3 Specifications of ADT BndList\n\n2.3.1 VDM\n\nThis specification uses many of the same features of VDM as the example of Section 2.2.1. One difference is the inclusion of a functions section in the module. This section defines functions that are useful in constructing the operation specifications — the functions are not exported. Function definitions consist of a signature and a direct definition of the function result. Also note that the module does not give a default initial value for BndLists. Instead, the operation InitBndList is provided for initializing them. This approach allows the user to set the maximum size of the BndList when it is initialized.\n\nmodule BNDLIST\nparameters types ItemType\nexports\ntypes\n BndList\noperations\n InitBndList: \\mathcal{N}_1 \\rightarrow\n InitCursor: () \\rightarrow\n AdvanceCursor: () \\rightarrow\n CursorOffEnd: () \\rightarrow B\n CurrentItem: () \\rightarrow ItemType\n InsertFront: ItemType \\rightarrow\n RemoveAllOccurrences: ItemType \\rightarrow\ndefinitions\n types\n BndList::theList: ItemType*\n currCursor: \\mathcal{N}_1\n maxSize: \\mathcal{N}_1\n inv(mk-BndList(theList, currCursor, maxSize)) \\triangleq\n currCursor \\leq \\text{len theList} + 1 \\land \\text{len theList} \\leq \\text{maxSize}\nstate\n State of L: Bndlist\nend;\nfunctions\n OffEnd: BndList \\rightarrow B\n OffEnd(L) \\triangleq (\\text{currCursor}(L) = \\text{len theList}(L) + 1)\n WithItemRemoved: ItemType* \\times ItemType \\rightarrow ItemType*\n WithItemRemoved(LP, Item) \\triangleq\n if LP = []\n then []\n else if \\text{hd}(LP) = Item\n then WithItemRemoved(tl(LP), Item)\n else [\\text{hd}(LP)] \\sim WithItemRemoved(tl(LP), Item)\noperations\nInitBndList(initialMaxSize: \\mathcal{N}_1)\next wr L: BndList\npost theList(L) = [] \\land currCursor(L) = 1 \\land maxSize(L) = initialMaxSize\n\nInitCursor()\nnext wr L: BndList\npost \\text{currCursor}(L) = 1 \\land \\text{theList}(L) = \\text{theList}(L) \\\\\n\\land \\text{maxSize}(L) = \\text{maxSize}(L)\n\nAdvanceCursor()\nnext wr L: BndList\npre \\neg \\text{OffEnd}(L)\npost \\text{currCursor}(L) = \\text{currCursor}(L) + 1 \\land \\text{theList}(L) = \\text{theList}(L) \\\\\n\\land \\text{maxSize}(L) = \\text{maxSize}(L)\n\nCursorOffEnd() b: B\nnext rd L: BndList\npost b = \\text{OffEnd}(L)\n\nCurrentItem() Item: ItemType\nnext rd L: BndList\npre \\neg \\text{OffEnd}(L)\npost Item = \\text{theList}(L)(\\text{currCursor}(L))\n\nInsertFront(Item: ItemType)\nnext wr L: BndList\npre \\text{len \\ theList}(L) < \\text{maxSize}(L)\npost \\text{theList}(L) = [\\text{Item}] \\preceq \\text{theList}(L) \\land \\text{currCursor}(L) = \\text{currCursor}(L) + 1 \\\\\n\\land \\text{maxSize}(L) = \\text{maxSize}(L)\n\nRemoveAllOccurrences(Item: ItemType)\nnext wr L: BndList\npost \\text{theList}(L) = \\text{WithItemRemoved}(\\text{theList}(L), \\text{Item}) \\land \\text{currCursor}(L) = 1 \\\\\n\\land \\text{maxSize}(L) = \\text{maxSize}(L)\n\nend \\text{BNDLIST}\n2.3.2 Z\n\nThe Z features demonstrated in this example specification not appearing in the example of Section 2.2.2 are: including schemas in the predicate part of another schema and the sequence operators $\\|$ and $\\text{rng}$. The inclusion of schema $\\text{OffEnd}$ in the predicate of schema $\\text{AdvanceCursor}$ is equivalent to substituting the predicate of $\\text{OffEnd}$ for the name. In this case the schemas used the same variable names, but the schema calculus provides a renaming operator for cases where different variable names are used. Operator $\\|$ (used in schema $\\text{RemoveAllOccurrences}$) is used to restrict the range of a sequence (i.e. the items contained in the sequence) to a specified set. The result sequence is “squashed” so that no gaps appear in it. The following example illustrates this.\n\n\\[\n[1, 2, 3, 4, 2, 1] \\{1, 3\\} = [1, 3, 1]\n\\]\n\nThe $\\text{rng}$ operator returns the range of its argument sequence as a set, as shown in schema $\\text{RemoveAllOccurrences}$.\n\n- $\\text{BndList}$\n - $\\text{theList}$: seq $\\text{ItemType}$\n - $\\text{currCursor}$: $\\mathbb{N}^+$\n - $\\text{maxSize}$: $\\mathbb{N}^+$\n - $\\text{currCursor} \\leq \\#\\text{theList} + 1 \\land \\#\\text{theList} \\leq \\text{maxSize}$\n\n- $\\text{OffEnd}$\n - $\\text{L}$: $\\text{BndList}$\n - $\\text{currCursor}(\\text{L}) = \\#\\text{theList}(\\text{L}) + 1$\n\n- $\\text{InitBndList}$\n - $\\text{ABndList}$\n - $\\text{initialMaxSize}$?: $\\mathbb{N}^+$\n - $\\text{initialMaxSize} > 0$\n - $\\text{theList}(\\text{L}') = [] \\land \\text{currCursor}(\\text{L}') = 1 \\land \\text{maxSize}(\\text{L}') = \\text{initialMaxSize}$\n- **InitCursor**\n \\[ \\Delta \\text{AbndList} \\]\n - \\( \\text{currCursor}(L') = 1 \\land \\text{theList}(L') = \\text{theList}(L) \\land \\text{maxSize}(L') = \\text{maxSize}(L) \\)\n\n- **AdvanceCursor**\n \\[ \\Delta \\text{AbndList} \\]\n - \\( \\neg \\text{OffEnd} \\)\n - \\( \\text{currCursor}(L') = \\text{currCursor}(L) + 1 \\land \\text{theList}(L') = \\text{theList}(L) \\land \\text{maxSize}(L') = \\text{maxSize}(L) \\)\n\n- **CursorOffEnd**\n \\[ \\Xi \\text{AbndList} \\]\n - \\( \\text{Out!}: \\text{boolean} \\)\n - \\( \\text{Out!} = \\text{OffEnd} \\)\n\n- **CurrentItem**\n \\[ \\Xi \\text{AbndList} \\]\n - \\( \\text{Out!}: \\text{ItemType} \\)\n - \\( \\neg \\text{OffEnd} \\)\n - \\( \\text{Out!} = \\text{theList}(L)(\\text{currCursor}(L)) \\)\n\n- **InsertFront**\n \\[ \\Delta \\text{AbndList} \\]\n - \\( \\text{Item?): \\text{ItemType} \\)\n - \\( \\#\\text{theList}(L) < \\text{maxSize} \\)\n - \\( \\text{theList}(L') = [\\text{Item?}] \\circ \\text{theList}(L) \\land \\text{currCursor}(L') = \\text{currCursor}(L) + 1 \\land \\text{maxSize}(L') = \\text{maxSize}(L) \\)\n- RemoveAllOccurrences\n \\( \\Delta \\text{BndList} \\)\n \\( I \\text{Item?}: \\text{ItemType} \\)\n \\( \\text{theList}(L') = \\text{theList}(L) \\setminus (\\text{rng}(\\text{theList}(L)) \\setminus \\{\\text{Item?}\\}) \\)\n \\( \\land \\text{currCursor}(L') = 1 \\land \\text{maxSize}(L') = \\text{maxSize}(L) \\)\n\n2.3.3 SPECS-C++\n\nThe SPECS-C++ features demonstrated in this specification that do not appear in the specification of Section 2.2.3 include the definition and use of abstract functions and the specification of member functions with non-void return types. Abstract functions are not intended to be implemented. Rather, they are used in the specification of the member functions in much the same way that functions are used by the operation specifications in the VDM specification of ADT Bounded List (Section 2.3.1). Specifications of member functions with non-void return types use the SPECS-C++ keyword \\texttt{result} to refer to the return value. Otherwise, such specifications are the same as any other member function specification.\n\ntemplate<class ItemType> class BndList {\n /* model */\n /** domains */\n /** type ListPart sequence of ItemType */\n /** data members */\n /** ListPart theList */\n /** int currCursor */\n /** int maxSize */\n /** invariant */\n /** 1 \\leq currCursor \\land currCursor \\leq length(theList) + 1 */\n /** \\land length(theList) \\leq maxSize \\land maxSize > 0 */\n /** abstract functions */\n /** define OffEnd(BndList L) as bool s.t. */\n /** OffEnd(L) = (L.currCursor = length(L.theList) + 1) */\n /** define WithItemRemoved(ListPart LP, ItemType Item) as ListPart */\n /** s.t. (LP = <> \\Rightarrow WithItemRemoved(LP, Item) = <>) */\n```\n** /\n** (LP != <> =>\n** (first(LP) = Item => WithItemRemoved(LP, Item) =\n** WithItemRemoved(trailer(LP), Item))\n** (first(LP) != Item => WithItemRemoved(LP, Item) =\n** <first(LP)> || WithItemRemoved(trailer(LP),\n** Item)))\n*/\npublic:\nBndList(int initialMaxSize);\n/* preA: initialMaxSize > 0\n** modifies: self\n** postA: theList' = <> /\n** currCursor' = 1 /\n** maxSize' = initialMaxSize */\nvoid InitCursor();\n/* modifies: self\n** postA: currCursor' = 1 */\nvoid AdvanceCursor();\n/* preA: !OffEnd(self)\n** modifies: self\n** postA: currCursor' = currCursor + 1 */\nbool CursorOffEnd();\n/* PostA: result = OffEnd(self) */\nItemType CurrentItem();\n/* preA: !OffEnd(self)\n** postA: result = index(theList, currCursor) */\nvoid InsertFront(ItemType Item);\n/* preA: length(theList) < maxSize\n** modifies: self\n** postA: theList' = <Item> || theList /\n** currCursor' = currCursor + 1 */\n```\nvoid RemoveAllOccurrences(ItemType Item);\n/* modifies: self */\n** postA: theList' = WithItemRemoved(theList, Item) \\ currCursor' = 1 */\n\n2.3.4 Prosper\n\nThe Prosper specification of ADT Bounded List uses the List type exported by module Generic-List (Section 2.3.4). The main language feature not seen in that previous Prosper specification is the use of an explicit cartesian product type for the representation of type BndList.\n\nmodule BList\nexport\nBndList @ TYPE -> TYPE;\nInitBndList @ integer -> BndList('it:TYPE);\nInitCursor @ BndList('it:TYPE) -> BndList('it);\nAdvanceCursor @ SUB(Not_CursorOfEnd @ BndList('it:TYPE) -> boolean) -> BndList('it);\nCursorOffEnd @ BndList('it:TYPE) -> boolean;\nCurrentItem @ SUB(Not_CursorOffEnd @ BndList('it:TYPE) -> boolean) -> 'it;\nBLength @ BndList('it:TYPE) -> integer;\nInsertFront @ ('it:TYPE) x SUB(ShortList? @ BndList('it) -> boolean) -> BndList('it);\nRemoveAllOccurrences @ ('it:TYPE x BndList('it)) -> BndList('it);\nfrom\nvalue BndList such that BndList('it) is\nSUB(isBndListRep? 'it);\nvalue isBndListRep? @ 'it:TYPE -> (List('it) x integer x integer) -> boolean\nsuch that isBndListRep? 't ('B x 'size x 'maxsize) is\n'size > 0 @ integer and 'size <= Length('B) + 1 @ integer\nand 'maxsize > 0 @ integer and Length('B) <= 'maxsize;\nvalue InitBndList such that InitBndList('initialMaxSize) is\n(Nil, 1 @ integer, 'initialMaxSize);\nvalue InitCursor such that InitCursor('B) is\n(first('B), 1 @ integer, third('B));\nvalue AdvanceCursor such that AdvanceCursor('B) is\n(first('B), snd('B) + 1 @ integer, third('B));\nvalue CursorOffEnd such that CursorOffEnd('B) is\n snd('B) = Length(first('B) + 1 @ integer);\nvalue CurrentItem such that CurrentItem('B) is\n if snd('B) = 1 then Head(first('B))\n else CurrentItem(Tail(first('B)), snd('B) - 1 @ integer, third('B));\nvalue BLength such that BLength('B) is Length(first('B));\nvalue ShortList? @ BndList('it:TYPE) → boolean such that ShortList? 'B is\n BLength('B) < third('B);\nvalue InsertFront such that InsertFront('Item, 'B) is\n (Cons('Item, first('B)), snd('B) + 1 @ integer, third('B));\nvalue WithItemRemoved @ (List('it:TYPE) × 'it) → List('it)\n such that WithItemRemoved('LP, 'Item) is\n if 'LP = Nil then Nil\n else if Head('LP) = 'Item\n then WithItemRemoved(Tail('LP), Item)\n else Cons(Head('LP), WithItemRemoved(Tail('LP), 'Item));\nvalue RemoveAllOccurrences such that RemoveAllOccurrences('Item, 'B) is\n (WithItemRemoved(first('B), 'Item), 1 @ integer, third('B))\nend-from\n\n2.3.5 Prolog\n\nThe Prolog version of ADT Bounded List uses largely the same language features\nas those seen in Section 2.2.5. Here, terms of the form bndlist(L, CurrCursor, MaxSize)\nare used to represent bounded lists. In Prolog terminology, such a term is a tree, and\nbndlist is an (uninterpreted) functor.\n\nlength([], 0).\nlength([_|L], N) :-\n length(L, N1),\n N is N1 + 1.\n\noffEnd(bndlist(TheList, CurrCursor, _)) :-\n length(TheList, Len),\n CurrCursor is Len + 1.\n\nwithItemRemoved([], _, []).\nwithItemRemoved([Item|LP], Item, NLP) :-\n withItemRemoved(LP, Item, NLP).\nwithItemRemoved([X|LP], Item, [X|NLP]) :-\n X <> Item,\n withItemRemoved(LP, Item, NLP).\n\nisInList(bndlist([Item|_], _, _), Item).\nisInList(bndlist([_|LP], CurrCursor, MaxSize), Item) :-\n isInList(bndlist(LP, CurrCursor, MaxSize), Item).\n\ninitCursor(bndlist(TheList, _, MaxSize), bndlist(TheList, 1, MaxSize)).\n\nadvanceCursor(bndlist(TheList, CurrCursor, MaxSize),\n bndlist(TheList, NC, MaxSize)) :-\n not(offEnd(bndlist(TheList, CurrCursor, MaxSize))),\n NC is CurrCursor + 1.\n\ncursorOffEnd(Self) :- offEnd(Self).\n\ncurrentItem(bndlist([Item|_], 1, _), Item).\ncurrentItem(bndlist([X|LP], CurrCursor, MaxSize), Item) :-\n not(offEnd(bndlist([X|LP], CurrCursor, MaxSize))),\n NC is CurrCursor - 1,\n currentItem(bndlist(LP, NC, MaxSize), Item).\n\ninsertFront(bndlist(TheList, CurrCursor, MaxSize), Item,\n bndlist([Item|TheList], NC, MaxSize)) :-\n length(TheList, Len),\n Len < MaxSize,\n NC is CurrCursor + 1.\n\nremoveAllOccurrences(bndlist(TheList, _, MaxSize), Item,\n bndlist(LP, 1, MaxSize)) :-\n withItemRemoved(TheList, Item, LP).\n\n2.4 Practical Comparisons\n\nThis section compares the various specification languages in practical terms, ex\namining issues that would arise in day-to-day use of the languages. The specific issues\nincluded are: handling invalid inputs, support for generic specifications, handling of side effects, framing, support for re-use of specifications, and ease of use.\n\n2.4.1 Handling Invalid Inputs\n\nIn this section we discuss support for specifying what happens when an operation is invoked on invalid or unexpected data. For example, consider calling AddEntry (Section 2.2) with a key that is already defined in the table, or AdvanceCursor (Section 2.3) when the cursor is at the end of the list. In VDM, the specifier basically has two choices: use a strong pre-condition that such input will not satisfy, in which case the result is unspecified, or weaken the pre-condition and handle exceptional conditions in the post-condition, perhaps by setting some error flag. This two alternatives are demonstrated in the example VDM specifications: in module BNDLST (Section 2.3.1), strong pre-conditions are used so that no error handling is needed in the post-conditions, while in module TABLE (Section 2.2.1), all pre-conditions are just true, and exceptional conditions are handled in the post-condition by setting error flags. In SPECS-C++, the same two alternatives are available to the specifier, and the example specifications are analogous to the VDM version in this respect (Sections 2.3.3 and 2.2.3).¹\n\nIn Z, the specifier again has the same options, and the use of explicit pre-conditions is demonstrated in the specification of ADT Bounded List (Section 2.3.2). However, the specifier can also use the schema calculus to separate normal operation from handling invalid inputs (in this case, setting an error flag as in the other specifications), and this alternative is demonstrated in the specification of ADT Table (Section 2.2.2). In the specification of AddEntry, the schema AddEnt gives the pre-condition for normal operation, and specifies the resulting table. The pre-condition of schema KeyDefined is the compliment of AddEnts, and KeyDefined specifies what happens under exceptional circumstances – in this case, that an error is reported. AddEntry is composed from these two schemas, and an additional schema OK that specifies reporting of normal behavior. This is an elegant way of composing specifi-\n\n¹Future plans for SPECS-C++ include adding the ability to specify C++ exceptions as in Larch/C++ [LC93], which will give the specifier another option.\ncations, and gives some hint of the power of the schema calculus.\n\nIn Prosper, no explicit pre-conditions are used. Instead, the dependent type system is used to ensure that if the arguments to the function typecheck, then the function can handle them. For example, in the specification of \\texttt{AdvanceCursor} in module \\texttt{BList} (Section 2.3.4), the type of the \\texttt{BndList} argument is constrained to be only those lists that satisfy the predicate \\texttt{Not.CursorOffEnd}. This corresponds to the pre-condition of the VDM specification of \\texttt{AdvanceCursor}.\n\nProlog has no explicit pre-conditions, but predicates can easily be written with \"guards\" so that the predicates will fail if the corresponding pre-condition is not satisfied. For example, the predicate for \\texttt{accessTable} in the Prolog Table specification (Section 2.2.5) uses predicate \\texttt{keyDefined}, which is equivalent to the corresponding SPECS-C++ pre-condition in class \\texttt{Table} (Section 2.2.3). In PLEASE, separate pre- and post-condition predicates are defined, but for execution are translated into a single Prolog rule with the pre-condition serving as a guard. As OBSERV specifications use raw Prolog code, specifiers would be free to use this pre- and post-condition style. However, it does not seem likely that specifiers would make the mental distinction between pre- and post-condition predicates. The mindset underlying OBSERV seems to be that these parts of specifications are simply Prolog code, and not representations of pre- and post-condition style specifications.\n\n2.4.2 Support for Generic Specifications\n\nGeneric specifications refer to specifications that are parameterized by types, or that allow polymorphism in the specification. For example, is it possible to write a Bounded List specification where the type of the list elements is not known? For all of the languages included here, the answer is yes. However, the techniques used in each language differ, and so are worthy of some discussion.\n\nVDM modules (discussed in Section 2.5.1) can be parameterized by types, and both example specifications (Sections 2.2.1 and 2.3.1) demonstrate this feature. The example Z specifications (Sections 2.2.2 and 2.3.2) simply introduce a new type name and use it consistently in specifying each data type. SPECS-C++ template classes (Sections 2.2.3 and 2.3.3) are similar to VDM modules, as they allow the ADT specifications to be explicitly parameterized by types. Prosper has an even more general\nnotion of type parameters, as types are first class citizens in the language – they can be passed to and returned from functions. All of the example Prosper modules (Sections 2.2.4 and 2.3.4) are parameterized by types. Finally, Prolog (Sections 2.2.5 and 2.3.5) is an untyped programming language, and so is inherently polymorphic.\n\nA crucial deficiency of all of these languages is the lack of any support for specifying characteristics that any actual type substituted for the parameter type must possess. For example, consider specifying ADT Table with the domain type as a parameter (rather than just integer). Clearly, any actual type substituted for this parameter type must allow comparison via equality – otherwise, there is no way to retrieve something from a table by its key. However, none of the languages compared here provide the ability to specify that a parameter type allows such comparisons. Some existing specification languages, for example Larch/C++ and the language described in [EHMO91], do allow specifying such characteristics of parameter types, and research aimed at adding this feature to SPECS-C++ is underway.\n\n2.4.3 Handling of Side Effects\n\nAs most programs written in imperative languages rely on side effects for efficiency, it is appropriate to look at how well the various languages allow specification of side effects. VDM, Z, and SPECS-C++ have a built-in notion of state, and all provide similar mechanisms for referring to the pre- and post-state values of variables, as illustrated in the example specifications. Hence, they are well suited for specifying programs with side effects. The example specifications make only trivial use of SPECS-C++'s object types, and so do not demonstrate the power that they give to the specifier. For example, in SPECS-C++ the BndList template could be instantiated with an object type: BndList<int&> is the type of bounded lists of objects containing integers. Any external mutation of an integer object contained in such a bounded list would be visible through the list. Prosper (and any pure functional programming language) and Prolog have no explicit notion of state. If the specifier wishes to specify state changes, all the operations that change the state must take a \"state\" argument, and return a \"state\" result. Both example specifications in both languages take this approach, thus cluttering up the specification. Even in PLEASE, where there is a notion of pre- and post-state, the predicates that the specifier defines\ntypically take this form. Hence, these languages are not as well suited as the other three for specifying operations with side effects.\n\n2.4.4 Framing\n\nThe framing problem in operation specifications is the difficulty of saying \"and nothing else changes\" [BMR93]; that is, the problem of finding compact and elegant techniques for specifying what parts of the state can change and what parts can't.\n\nVDM has \\texttt{ext rd} and \\texttt{ext wr} clauses, which specify which external variables the specified operation is allowed to read and write, respectively. Thus, the value of a variable can only change from the pre- to the post-state if it is listed in the \\texttt{ext wr} clause. The example specifications (Sections 2.2.1 and 2.3.1) demonstrate the use of these clauses.\n\nBy Z convention, schemas with shape \\( \\Delta \\) are used to define pre- and post-state (primed) variable names for a particular type, and schemas with shape \\( \\Xi \\) are used to specify that these variables are equal. That is, schemas with shape \\( \\Delta \\) are used to introduce pre- and post-state declarations for variables that can change. This schema is then included in any schema that can change the state of these variables. For example, \\( \\Delta \\text{BndList} \\) (Section 2.3.2) is such a schema, and the schema \\texttt{InitBndList} includes this schema. The appropriate schema of shape \\( \\Xi \\) can be included in an operation schema to specify that the included variables do not change value from the pre- to the post-state. Both Z specifications use such a schema. For example, the Z specification of ADT Table (Section 2.2.2) defines such a schema, and includes it in schemas \\texttt{KeyDefined} and \\texttt{KeyNotDefined} to specify that the state of the table does not change under these exceptional circumstances. This makes explicit which schemas can modify the state of elements of what types.\n\nSPECS-C++ provides two aids to framing. The first is the modifies clause, which explicitly states what objects the specified operation is allowed to change. Thus, it is similar to the kind of support for framing provided in VDM and Z. Many of the example SPECS-C++ operation specifications (Sections 2.2.3 and 2.3.3) demonstrate the use of the modifies clause. The second SPECS-C++ aid to framing is the default \"nothing else changes\" semantics, which says that an object does not change its value from pre-state to post-state, unless the specification forces it to. This semantics is\nused in the specification of operation AddEntry in class Table, where the post-state value of the table is not defined when the post-state value of AddedOk is false. The \"nothing else changes\" semantics allows the reader to infer that the state of the table did not change. Note that VDM and Z have no analog to this semantics, so if a specification does not specify a post-state value for a variable that it has \"write access\" to, an implementation is free to give an arbitrary post-state value for it. Hence, all the example VDM and Z specifications provide explicit post-state values for such variables by equating the pre- and post-state values.\n\nBoth Prosper and Prolog are side effect free, and so have no notion of pre- and post-state. However, as previously noted, many of the operations in the example specifications take a state argument, and return a state result, so that state changes are modeled by returning a new state that corresponds to the post-state of the SPECS-C++ specification. Under this modeling of state, Prosper and Prolog have no support for framing. As the notion of state is not built into the language, there is no reason to expect any correspondence between a state argument and a state result other than that explicitly specified. Thus, the specifier must completely specify a state result, even when that result is the same as a state argument.\n\n2.4.5 Support for Re-use of Specifications\n\nAs formal specification is a time consuming and expensive process, it is important that specifications and parts of specifications can easily be re-used. All of the languages studied here allow some form of re-use, but the mechanisms used vary widely. In VDM, pre- and post-conditions and invariants can be used as functions. For example, the pre-condition of operation AdvanceCursor used as a function would have the name pre-AdvanceCursor. Additionally, the types and operations that a module exports can be used in other specifications. In Z, the schema calculus provides many powerful operators for combining existing schemas to produce new ones. The Z specification of ADT Table illustrates the use of the $\\land$ and $\\lor$ operators for combining schemas (Section 2.2.2). Additionally, operators are provided for extracting parts of schemas so that they can be re-used.\n\nSPECS-C++ supplies two mechanisms for specification re-use - specification inheritance and the ability to use member function return values and side effects in\nspecifications. Specification inheritance is unique to SPECS-C++ among the languages studied here, but is similar to the specification inheritance found in some other object-oriented specification languages such as Fresco.\n\nSince Prosper is based on functional programming languages, and Prolog is a programming language, both allow programming language kinds of re-use – functions and predicates that have been defined can be called as often as needed. In Prosper, the types and functions that a module exports can be used in the specification of another module. For example, the module Generic-List (a slightly modified version of the one appearing in [LB88]) is used both in the specification of module Table (Section 2.2.4) and module BList (Section 2.3.4). In both Prolog specifications, some of the predicates are used several times in the specification of other predicates.\n\nAs OBSERV is an object-oriented (more properly, object-based, as inheritance is not supported), it defines objects that can be re-used. Additionally, objects can define types, and these types can be used and re-used as needed. PLEASE packages (which are similar to modules) and the types they define can be re-used in other PLEASE specifications. PAISley apparently provides no support for re-use.\n\n2.4.6 Ease of Use\n\nThis section discusses the human interface of the various languages. A number of issues are pertinent: how difficult the language is to learn, how difficult it is to write clear and concise specifications in the language, and so on.\n\nVDM, Z, and SPECS-C++ all use similar mathematical models (set, sequence, tuple, ...) and similar specification techniques (pre- and post-conditions written in first order predicate logic), and so are quite similar in usability. SPECS-C++ specifications that make sophisticated use of objects can become involved, but as the example specifications show, objects do not complicate specifications that do not need to make explicit use of objects. The schema calculus and various schema shapes add a level of complexity to Z specifications. However, Z does not force any sophisticated use of these features in writing reasonable specifications, so this complexity need not be a burden to novice Z specifiers. For experienced specifiers, use of the schema calculus makes writing specifications less tedious, as existing schemas can easily combined to produce new schemas.\nFor those with some experience in functional programming, Prosper is reasonably easy to use. However, some of the notations used for handling dependent types seem non-intuitive and difficult to learn. The amount of algorithmic information required can also become a burden on the specifier. For example, the definition of \\texttt{IsTableRep?} in module \\texttt{Table} (Section 2.2.4), requires a quite subtle transformation of the invariant for the corresponding ADT Table specification in VDM (Section 2.2.1), as an assertion involving two universal quantifiers must be transformed into a recursive function.\n\nOne initial difficulty in using Prolog is that Prolog programs use relations, rather than functions. For example, many people would most naturally specify or implement \\texttt{removeAllOCCurrences} (Section 2.3.5) as a function, rather than a relation between \\texttt{bndLists}. Note that the other languages specify \\texttt{RemoveAllOCCurrences} as a function. However, a bit of experience with Prolog is usually all that is required to overcome this problem.\n\nA much greater problem in using Prolog is understanding Prolog's non-logical features, such as \\texttt{not}, \\texttt{cut}, \\texttt{fail}, and so on. Both example Prolog specifications use the \\texttt{not} predicate, which is defined in Prolog as \\texttt{not(X) \\equiv X, !, fail}. In other words, \\texttt{not(X)} succeeds when \\texttt{X} fails, which is different than succeeding when \\texttt{X} is false. For example, the query \\texttt{currentltem(B, 3)} (see Section 2.3.5) asking for \\texttt{bndLists} whose cursor points at 3, will either cause an error or return at most one answer depending on the Prolog implementation being used. This occurs because an unbound variable is used inside the argument to \\texttt{not}. Clearly, this can not be explained by the logical interpretation, and so the programmer is forced to fall back on the procedural interpretation. In our experience as learners and teachers of Prolog, the procedural interpretation is much more difficult for humans to understand than the logical interpretation. Unfortunately, non-trivial use of Prolog usually requires understanding the procedural interpretation.\n\nPLEASE avoids the use of the procedural interpretation by excluding the specification of negative information (the usual cause of falling back on the procedural interpretation) from PLEASE specifications. For example, the specifier is not allowed to use \\texttt{not} in specifications, and would have to find another way to specify \\texttt{currentItem} — perhaps by writing an explicit \\texttt{notOffEnd} predicate. Although this does avoid the procedural interpretation, finding clever ways to avoid negation is clearly a burden.\non the specifier.\n\n2.5 Theoretical Comparisons\n\nThis section compares the specification languages in terms of differences arising from the design philosophies behind and the intended usage of the languages. These differences include support for data abstraction, handling of invariants, level of abstraction, and executability.\n\n2.5.1 Support for Data Abstraction in Specifications\n\nThey key to data abstraction is the ability to hide the representation of data types. In the context of formal specifications, this corresponds to hiding the model of an ADT from parts of the specification outside of the ADT. Data abstraction in the specification of ADTs is useful for the same reasons that it is useful in the implementation of ADTs, as it allows the representation of the data type to be changed in the specification of the ADT without affecting parts of the specification outside of the ADT specification. Such a change would be useful, for example, if the specification of additional operations of the ADT would be eased by changing the representation. All of the languages in this study except Z, SPECS-C++, raw Prolog, and PAISley provide some way to use data abstraction in specifications.\n\nVDM specifies data abstraction through modules, which bind together a model and a collection of operations. Import and export lists control what operations and types are visible to the outside world, and what outside operations are used in a module. The model is hidden inside the module. The example VDM specifications are both written as modules (Sections 2.2.1 and 2.3.1).\n\nIn Z, when a schema is used to compose a type, the variables that make up the type and the types of those variables are not hidden from other schemas. For example, any schema that declares a variable of type Table (Section 2.2.2) has access to the to the representation of tables. The schema calculus operator \\ can be used to hide a specified set of the variables the variables of a schema, but there does not seem to be any reasonable way to use this feature to enforce data abstraction in the specification.\nAs SPECS-C++ is an interface specification language, the data abstraction present in implementations can be specified by the class and member protection mechanisms of C++. For example, both public (globally visible) and protected member functions (visible only to derived classes) of a class can be specified. The development methodology associated with SPECS-C++ goes beyond these mechanisms, as it requires that all data members in the implementation of a specification be private, and so inaccessible to clients and derived classes of the implementation. On the other hand, the abstract data members used in specifications are visible throughout the specification. Thus, SPECS-C++ does not support data abstraction in specifications.\n\nIn Prosper, data abstraction is provided by modules with explicit export lists of operators and types visible outside the module. Both of the example Prosper specifications (Sections 2.2.4 and 2.3.4) use this feature. PAISley provides no explicit way to specify data abstraction. This limitation is noted by Zave and Schell [ZS86], and identified as a weakness of the language.\n\nRaw Prolog provides no data abstraction, but both of the Prolog-based languages in this study do. In PLEASE, data abstraction can be specified via packages, which are modeled after Ada packages. As Ada packages are similar to modules as discussed above, the data abstraction provided is similar. Since PLEASE was designed for prototyping Ada implementations, this data abstraction is apparently present in both the specification and implementation. In OBSERV, compound objects composed of collections of other objects can be defined. Such compound objects have a well-defined interface. Additionally, the names of the component objects are not visible in the parts of the specification outside the compound object. Thus, data abstraction is present in the specification.\n\n2.5.2 Invariants\n\nVDM, Z, SPECS-C++, and Prosper each provide the notion of a data invariant as a predicate that members of the specified ADT must satisfy in any state that is observable from outside of the ADT. Prolog does not, so instead the discussion focusses on how PLEASE and OBSERV specify invariants.\n\nIn VDM an invariant can be defined for any type that is declared. For example,\nthe invariant for type Table (Section 2.2.1) says that the same key is not present in two distinct elements of a table. The invariant for type BndList (Section 2.3.1) describes legal relationships among the sub-components that make up the composite value. In Z, when a schema defines a type, the predicate part (the part below the short horizontal line) can be used to define an invariant on that type. This is done in both schemas Table and BndList (Sections 2.2.2 and 2.3.2). Similarly, SPECS-C++ invariants describe the legal states of the abstract data members of a class. Thus, the SPECS-C++ invariants (Sections 2.2.3 and 2.3.3) are similar to the VDM and Z invariants, except that the lack of a type like $N^+$ makes the invariant for class BndList slightly longer.\n\nIn Prosper, invariants are an integral part of the type being specified. For BList, the type operator SUB is used to express the invariant in the definition of type BndList (Section 2.3.4). This is even clearer in modules Generic-List and Table (Section 2.2.4), where the functions IsListRep? and IsTableRep? that express the appropriate invariants are explicitly used as arguments to SUB in the type definitions. This use of the type system for preserving invariants is one of the greatest strengths of Prosper.\n\nPAISley provides no support for specifying invariants. Support for automated consistency checking of declarations, definitions, and applications is provided, but this largely corresponds to the typechecking done by most interpreters and compilers.\n\nIn PLEASE, packages that define data types can also provide an explicit invariant for that type. However, it is unclear whether these invariants are ever executed. OBSERV currently provides no support for invariants, but they are discussed as a possible improvement to the language.\n\n2.5.3 Level of Abstraction\n\nThe non-executable specification languages (VDM, Z, and SPECS-C++) all use pre- and post-condition style specification (although VDM also permits a more explicit style), and use a similar vocabulary in terms of the underlying model. As the pre- and post-conditions are expressed in the first order predicate calculus, such specifications can be quite abstract. The schema calculus of Z provides an additional level of abstraction, as schemas (specifications) can be viewed as building blocks for other specifications.\nAs the execution of Prosper (and many of the executable subsets of VDM) is based on functional programming, it is much more abstract than implementations in a typical imperative programming language would be, and the example specifications show this. However, Prosper (and again the other languages mentioned) does require the specifier to provide algorithms, and so is considerably less abstract than VDM, Z, or SPECS-C++. The example specifications are too short to show this clearly, but the function IsTableRep? (Section 2.2.4) does point the way, as it is considerably less abstract than the corresponding VDM invariant for module Table. This algorithmic information is a burden on the specifier and a potential source of implementation bias.\n\nWhile one could argue that, as Prolog is based on first order predicate logic, the Prolog based languages (PLEASE and OBSERV) are just as abstract as VDM, Z, or SPECS-C++, in practice this is not true. Prolog specifications require the specifier to give enough information for the Prolog interpreter to function, and, as shown in the specification of ADT Table (Section 2.2.5), the level of information required frequently goes beyond the logical interpretation of Prolog. The goal is laudable, but the implementation falls short.\n\n2.5.4 Executability\n\nOf the languages in this study, only VDM, Z, and SPECS-C++ are not directly executable. Work on executing VDM has concentrated on defining executable subsets. In general, either the executable subset is an (algorithmic) subset of explicit specifications [Hen86, RE93, LL91, AELL92], or else implicit specifications are constrained to be written in an “algorithmic enough” style for execution [HI88, HI86, O’N92a, O’N92b]. Work on executing Z seems to have concentrated on translating specifications to Prolog [DKC90, WE92] or to some functional programming language [JS90]. These techniques are limited to the subset of Z that is amenable to fairly direct translation.\n\nThe executable subset of SPECS-C++ [WBL94] is considerably larger than that of any of the subsets of VDM and Z cited, as it includes implicit specifications that use many forms of quantified assertions. Even many quantified assertions with references to post-state values in their bodies can be executed. The SPECS-C++ specifications\nincluded in this study (Sections 2.2.3 and 2.3.3) are both directly executable by the SPECS-C++ execution technique. Thus, executable SPECS-C++ specifications can be written at a much higher level of abstraction than that forced by specification languages such as Prosper that rely on functional programming for executability. The SPECS-C++ execution technique also avoids the problems encountered in Prolog specifications, such as the use of Prolog syntax and the non-logical features of Prolog. Research into using backtracking and constraint satisfaction techniques in executing SPECS-C++ has given the executable subset of SPECS-C++ a level of expressiveness very similar to that of Prolog.\n\n2.6 Conclusion\n\nTable 2.1 summarizes the comparison results for the criteria that showed significant differences. Of particular note is the power of Z's schema calculus, as it makes Z best in terms of specification re-use. Even SPECS-C++'s specification inheritance can not completely match Z's ability to use and extend existing specifications. SPECS-C++ is strongest in language support for framing and specifying side effects. Prosper is best in terms of the handling of invariants, as the invariant is an integral part of the ADT defined, and is automatically checked each time an element of the data type is created.\n\nThe main contribution of this case study is to highlight some of the relative strengths and weaknesses of the included languages (and the approaches to formal specification that they represent) in specifying ADTs. While the criteria used in this comparison are certainly not exhaustive, they do allow a reasonable comparison of the features of these languages. Also included is a brief introduction to the five main languages and examples of typical specifications in these languages. This study should be helpful in choosing a specification language for a particular specification situation, in designing new specification languages, and in teaching and using these specification languages.\nTable 2.1: Comparisons of languages on selected criteria (NA = not applicable)\n\n<table>\n<thead>\n<tr>\n<th>Criteria</th>\n<th>VDM</th>\n<th>Z</th>\n<th>SPECS-C++</th>\n<th>Prosper</th>\n<th>PAISley</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Support for Specifying Side Effects</td>\n<td>yes</td>\n<td>yes</td>\n<td>yes</td>\n<td>no</td>\n<td>no</td>\n</tr>\n<tr>\n<td>Support for Framing</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>- limited access to state</td>\n<td>yes</td>\n<td>yes</td>\n<td>yes</td>\n<td>NA</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>- semantic</td>\n<td>no</td>\n<td>no</td>\n<td>yes</td>\n<td>NA</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>Support for Re-use</td>\n<td>medium</td>\n<td>high</td>\n<td>high</td>\n<td>medium</td>\n<td>low</td>\n</tr>\n<tr>\n<td>Ease of Use</td>\n<td>high</td>\n<td>high</td>\n<td>high</td>\n<td>medium</td>\n<td>medium</td>\n</tr>\n<tr>\n<td>Support for Specifying Data Abstraction</td>\n<td>yes</td>\n<td>no</td>\n<td>no</td>\n<td>yes</td>\n<td>no</td>\n</tr>\n<tr>\n<td>Level of Abstraction</td>\n<td>high</td>\n<td>high</td>\n<td>high</td>\n<td>medium</td>\n<td>medium</td>\n</tr>\n<tr>\n<td>Executability</td>\n<td>low</td>\n<td>low</td>\n<td>medium</td>\n<td>high</td>\n<td>high</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Criteria</th>\n<th>Prolog</th>\n<th>Please</th>\n<th>OBSERV</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Support for Specifying Side Effects</td>\n<td>no</td>\n<td>no</td>\n<td>no</td>\n</tr>\n<tr>\n<td>Support for Framing</td>\n<td>NA</td>\n<td>no</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>- limited access to state</td>\n<td>NA</td>\n<td>no</td>\n<td>NA</td>\n</tr>\n<tr>\n<td>- semantic</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Support for Re-use</td>\n<td>low</td>\n<td>medium</td>\n<td>medium</td>\n</tr>\n<tr>\n<td>Ease of Use</td>\n<td>medium</td>\n<td>medium</td>\n<td>medium</td>\n</tr>\n<tr>\n<td>Support for Specifying Data Abstraction</td>\n<td>no</td>\n<td>yes</td>\n<td>yes</td>\n</tr>\n<tr>\n<td>Level of Abstraction</td>\n<td>medium</td>\n<td>medium</td>\n<td>medium</td>\n</tr>\n<tr>\n<td>Executability</td>\n<td>high</td>\n<td>high</td>\n<td>high</td>\n</tr>\n</tbody>\n</table>\n3. EXECUTING FORMALIZED DATA FLOW DIAGRAM SPECIFICATIONS\n\nA paper in preparation for the Journal of Information Systems\n\nTim Wahls^1, Albert L. Baker, and Gary T. Leavens\n\nAbstract\n\nWhile traditional Data Flow Diagrams (DFDs) are popular, they do not specify software systems precisely or unambiguously. DFD-SPECS is a formalization of DFDs for specifying concurrent software. DFD-SPECS relies on model-based specification of abstract data types, and processes are specified with first order assertions. We provide an interpreter for a subset of DFD-SPECS that includes many quantified assertions. The interpreter helps formalize the semantics of DFD-SPECS, makes possible the validation of specifications, and allows a specification to serve as a prototype for its implementation.\n\nkeywords: Data Flow Diagrams, rapid prototyping, validation of specifications, formal specifications, executable specifications, concurrent systems, formal semantics\n\n^1 Wahls's work is supported in part by a research assistantship provided by the College of Liberal Arts and Sciences, Iowa State University, and in part by a fellowship provided by IBM Rochester. Baker's work was supported in part by a grant from Rockwell International. Leavens's work is supported in part by the National Science Foundation under Grant CCR-9108654.\n\nAuthors' address: Department of Computer Science, 226 Atanasoff Hall, Iowa State University, Ames, Iowa 50011-1040 USA\n\ntelephone: (816) 562-3270\n\nemail: wahls@cs.iastate.edu baker@cs.iastate.edu leavens@cs.iastate.edu\n3.1 Introduction\n\n3.1.1 Data Flow Diagrams\n\nTraditional Data Flow Diagrams (DFDs) are probably the most widely used specification technique in industry today. They are the cornerstone of the software development methodology commonly referred to as \"Structured Analysis\" (SA). Their popularity arises from their graphical representation and hierarchical structure, which allows users with non-technical backgrounds to understand them. Indeed, one of the common uses of DFDs is in explaining the static structure of a system to non-technicians.\n\nTraditional DFDs consist of bubbles and flows. Bubbles are drawn as circles and represent either processes (if the system being specified is concurrent) or procedures. Flows are drawn simply as arrows connecting the bubbles, and show the paths over which data may travel. Hence, a DFD is a directed graph. Flows coming into a bubble are called inflows, and flows leaving, outflows. A bubble reads the information on its inflows, and produces information on its outflows.\n\n3.1.2 Motivation for Formalization of Traditional DFDs\n\nWhile the description above is simplified, it is enough to point out the greatest flaw of traditional DFDs — there is no way to know when a bubble will read its inflows or produce on its outflows, and there is no way to know what a bubble will produce. This is partially explained by the fact that traditional DFDs are intended as static \"road maps\" of how information is transformed in a system, so that there was no notion of actually \"executing\" a DFD. This is clearly insufficient for precisely specifying a real software system.\n\nA number of techniques have been used to combat this problem. In particular, the functionality of a bubble is often expressed in \"Structured English\" [You89]. This has the advantages of informality and some level of understandability by non-technicians, but is too ambiguous to be a good specification technique. Another technique is to include in the DFD the actual code implementing a bubble [GRW91]. While this is a formal specification, it is not an adequate specification technique, as it is too low-level. A third modification to DFDs describes the functionality of bubbles\nwith a finite state machine. This ends up as a notational convenience, for the finite state description is easily transformed into another traditional DFD.\n\nA better technique is embodied in our language DFD-SPECS, a formal specification language based on DFDs. In DFD-SPECS, a set of rules is associated with each bubble. Each rule has three parts: an enabling condition that describes when a bubble may read its inputs, a pre-condition that gives conditions that must be met for the bubble to produce results, and a post-condition, which defines what the bubble outputs to its outflows. The enabling condition resembles the when clause of GCIL [Ler91]. These conditions are written as first order predicate calculus (FOPC) assertions over the values on the inflows and outflows of the bubble. Thus, DFD-SPECS has much in common with VDM [Jon90] and Z [Hay87] [Spi92] [Spi89] in that specification is done using FOPC pre- and post-conditions. DFD-SPECS thus has the formality of these specification techniques, and also the advantage of a graphical notation.\n\nThe traditional advantages of formality include terse, precise, and unbiased descriptions of functionality and the ability to verify properties of specifications. DFD-SPECS shares these advantages with other formal specification languages, and also uses this formality as the basis for executing specifications. Thus, most specifications can serve as prototypes of the final system, providing even those who are unfamiliar with the formal notation used the ability to experiment with and evaluate the specification. Specifications can also be tested and “debugged” in the same way that programs are debugged. This validation of specifications is important in the software development process, because it is usually much more cost effective to correct an error in the specification rather than later in the development process. For large projects, correcting an error in the maintenance phase is typically 100 times more costly than correcting the same error in the specification phase [Boe81].\n\nExecutability for a large subset of DFD-SPECS is provided by an interpreter written in the functional programming language Standard ML [Pau91]. The interpreter also serves as a formal semantics for the executable subset of DFD-SPECS. None of the code for the interpreter is presented in this paper, but is available in [WBL93].\n\nThe rest of this paper is organized as follows. In Section 3.2 we introduce the\nreader to the DFD-SPECS language. In Section 3.3 we briefly describe the technique used for evaluating enabling and pre-conditions, and for producing outflow values from post-conditions. Together, these sections characterize the execution behavior of DFD-SPECS specifications. In Section 3.4 we describe related work on the execution of DFDs and model-based formal specifications. In Section 3.5 we conclude with a description of the problems remaining in formalizing and executing DFD-SPECS.\n\n3.2 Informal Description of DFD-SPECS\n\nThe description of the syntax and semantics of DFD-SPECS in this section follows that of Coleman [Col91].\n\n3.2.1 Syntax of DFD-SPECS\n\nA DFD-SPECS specification consists of a directed graph and an associated textual part. As in traditional DFDs, the nodes of the graph are the bubbles, and the arcs are the flows. Stores are simply flows with multiple origin and destination bubbles [LWBL92]. Each bubble is labeled with its name, and each flow with its name and type. Arcs with a double arrowhead are used for persistent flows, while single arrowheads are used for consumable flows. The difference between these kinds of flows is described in the next section.\n\nThe textual part consists of the data dictionary of types and abstract functions used in the specification, and the specifications of the bubbles (or processes), as described in the following paragraphs and extended BNF grammar. The interpreter uses an abstract syntax that is basically a parse of this concrete syntax.\n\n\\[\n\\text{textual-part} ::= [\\text{data-dictionary}] \\text{process}^*\\]\n\nThe data dictionary defines the types and abstract functions used in the specification. The notation \\(\\text{type-expr}^*\\) refers to union types, i.e. \\(\\text{type intOrReal = int | real;}\\).\n\n\\(^2\\)In this grammar, optional parts are enclosed in square brackets \\([\\,]\\), and the notation \\(\\text{expr}^*\\) means a ; separated list of zero or more \\(\\text{exprs}\\). The \\(\\text{expr}^*\\) and \\(\\text{expr}^+\\) notations have analogous meanings.\ndata-dictionary ::= Data Dictionary : type-decl*[^;] abstract-function*[;]\ntype-decl ::= type var-name = type-expr\ntype-expr ::= int | real | bool | string | signal | set of type-expr | type-expr^* | sequence of type-expr | tuple of (param-decl^*^) | type-name\n\nAbstract functions are functions used only internally to the specification — that is, they can be used in enabling, pre-, and post-conditions, but are not available to users of the specified system. They are used to help in modularizing the specification, and to make it more readable.\n\nabstract-function ::= define absfun-name(param-decl^*) as type-expr\nsuch that FOPC-expr\nparam-decl ::= var-name : type-expr\n\nEach bubble is described by its name, initial state, and set of firing rules. The initial state specifies the initial values on the bubble's outflows. For flows with multiple source bubbles, the values specified must be consistent. The firing rules are the enabling condition, pre-, and post-condition triples discussed previously. In the enabling condition and initial state, the assertion +flow-name is true exactly when information is present on flow flow-name, while -flow-name is true when no information is present. An omitted pre-condition is equivalent to just true.\n\nprocess ::= Process bubble-name : [initial-state] rule*[;]\ninitial-state ::= initially flow-enabled-list [\\ FOPC-expr]\nrule ::= enabled when enabling-condition [requires pre-condition]\nensures post-condition\nenabling-condition ::= true | flow-enabled-list [\\ FOPC-expr]\nflow-enabled-list ::= [flow-enabled-list \\ flow-enabled\nflow-enabled ::= +flow-name | -flow-name\npre-condition ::= FOPC-expr\npost-condition ::= FOPC-expr\n\nThe first order predicate calculus used in DFD-SPECS specifications is augmented with operations on the built-in types. Unprimed flow names refer to the\nvalues on inflows, while primed flow names (') refer to outflow values. For each field of a tuple, DFD-SPECS provides a function with the same name to extract that field from the tuple. The symbol - is used for both arithmetic subtraction and set difference, and | for concatenation of sequences. The index function provides array-like indexing into sequences, header returns all of its argument sequence except the last element, and trailer returns all of its argument sequence except the first element.\n\n\\[ FOPC-expr ::= \\text{true} \\mid \\text{false} \\mid \\text{not} \\ FOPC-expr \\mid FOPC-expr \\land FOPC-expr \\mid FOPC-expr \\lor FOPC-expr \\mid FOPC-expr \\Rightarrow FOPC-expr \\mid \"\\forall\\\" \\text{var-name} : \\text{type-expr} [FOPC-expr] \\mid \"\\exists\\\" \\text{var-name} : \\text{type-expr} [FOPC-expr] \\mid \\{FOPC-expr \\mid FOPC-expr\\} \\mid (FOPC-expr) : \\text{type-expr} \\mid \\text{int-literal} \\mid \\text{real-literal} \\mid \\text{string-literal} \\mid \\text{bool-literal} \\mid \\text{var-name} \\mid \\text{flow-name} \\mid \\text{flow-name}' \\mid \\text{absfun-name}(FOPC-expr*) \\mid \\text{unary-op}(FOPC-expr) \\mid FOPC-expr \\text{binary-op} FOPC-expr \\mid \\{FOPC-expr*\\} \\mid <FOPC-expr*#> \\mid (FOPC-expr*) \\mid \\text{index}(FOPC-expr, FOPC-expr)\n\\]\n\n\\[ \\text{unary-op ::= field-name} \\mid \\text{size} \\mid \\text{first} \\mid \\text{header} \\mid \\text{last} \\mid \\text{trailer} \\mid \\text{length} \\]\n\n\\[ \\text{binary-op ::= +} \\mid = \\mid * \\mid / \\mid \\text{mod} \\mid \\text{union} \\mid \\text{intersection} \\mid | | \\mid = \\mid < \\mid <= \\mid > \\mid >= \\mid \\text{in} \\mid \\text{subset} \\mid \\text{subsetq} \\mid \\text{supset} \\mid \\text{supseteq} \\]\n\nAs an example of a DFD-SPECS specification, consider the specification of a spelling checker in Figures 3.1 and 3.2. Roughly, process \\text{FindWords} takes a document and the dictionary, and produces a dictionary of all the words in the document not appearing in the dictionary. The user of the specified system then supplies the correct spelling of each of these words. Finally, process \\text{CorrectMisspellings} produces the corrected document and updates the dictionary. Flow \\text{Dict: Dictionary} is an example of a store, while \\text{OldDoc: Document} and \\text{Unknown: Dictionary} are just diverging flows.\n\nThis specification has been successfully executed by our interpreter, and is a good illustration of the kinds of specifications that it can handle. For example, the specification makes use of both universal and existential quantification, and outflow values and abstract function results appear inside the bodies of quantified assertions.\nFigure 3.1: The graphical part of the DFD-SPECS specification of a spelling checker.\n\nData Dictionary:\n\ntype Document = sequence of Word;\ntype Word = string;\ntype Dictionary = set of Word;\ntype Disposition = set of WordPair;\ntype WordPair = tuple of (UnknownSpelling: Word, CorrectSpelling: Word)\n\ndefine HasCorrection(w: Word, C: Disposition) as bool such that\n IsKnown(w, C) = \\exists c: WordPair [c \\in C /\\ w = UnknownSpelling(c)];\n\ndefine RightSpelling(w: Word, C: Disposition) as Word such that\n \\exists c: WordPair [c \\in C /\\ w = UnknownSpelling(c)\n /\\ RightSpelling(w, C) = CorrectSpelling(c)]\n\nFigure 3.2: Part 1 of the textual part of the specification of Figure 1.\nProcess In:\n\n\\[\\text{initially } +\\text{OldDoc }\\land +\\text{Dict }\\land \\text{OldDoc} = \\text{\"teh\", \"quick\", \"browne\", \"fox\"} \\land \\text{Dict} = \\text{\"brown\", \"dog\", \"the\", \"fox\", \"red\", \"slow\", \"quick\"}\\]\n\nProcess FindWords:\n\n\\[\\text{initially } -\\text{Unknown}\\]\n\n\\[\\text{enabled when } +\\text{OldDoc }\\land +\\text{Dict}\\]\n\n\\[\\text{ensures } \\text{Unknown}' = \\{\\text{w: Word } \\mid \\text{w }\\in \\text{OldDoc} \\} - \\text{Dict}\\]\n\nProcess User:\n\n\\[\\text{initially } -\\text{Corrections}\\]\n\nProcess CorrectMisspellings:\n\n\\[\\text{initially } -\\text{NewDoc}\\]\n\n\\[\\text{enabled when } +\\text{OldDoc }\\land +\\text{Corrections }\\land +\\text{Dict }\\land +\\text{Unknown}\\]\n\n\\[\\text{requires } \\forall \\text{w: Word } [\\text{w }\\in \\text{Unknown }\\Rightarrow \\text{HasCorrection}(w, \\text{Corrections})]\\]\n\n\\[\\land |\\text{Unknown}| = |\\text{Corrections}|\\]\n\n\\[\\text{ensures } \\forall i: \\text{int } [(1 \\leq i \\leq \\text{length(OldDoc)}\\land \\text{index(OldDoc, i) }\\land \\text{Dict})\\Rightarrow \\text{index}(\\text{NewDoc}', i) = \\text{index}(\\text{OldDoc}, i)]\\]\n\n\\[\\land \\forall i: \\text{int } [(1 \\leq i \\leq \\text{length(OldDoc)}\\land \\text{not (index(OldDoc, i) }\\land \\text{Dict}))\\Rightarrow \\text{index}(\\text{NewDoc}', i) = \\text{RightSpelling(index(OldDoc, i), Corrections)}]\\]\n\n\\[\\land \\text{length(OldDoc')} = \\text{length(OldDoc)}\\]\n\n\\[\\land \\text{Dict'} = \\text{Dict }\\land \\text{union}\\]\n\n\\[\\{\\text{CorrectSpelling(c: WordPair) } \\mid \\text{c }\\in \\text{Corrections}\\}\\]\n\nFigure 3.3: Part 2 of the textual part of the specification of Figure 1.\nAdditionally, the sequence value that process CorrectMisspellings places on flow NewDoc: Document is defined in terms of index positions in the sequence, rather than directly. Section 3.4 contrasts this level of executability with that provided by other executable specification languages.\n\n3.2.2 Informal Semantics of DFD-SPECS\n\nThis informal description of DFD-SPECS semantics as implemented by our interpreter follows the first formalization by Coleman [Col91] and the operational semantics given in Leavens et al. [LWBL92] for traditional DFDs. The key concept is that of firing a bubble. Firing is the process in which a bubble reads its inflows and produces onto its outflows. The semantics of firing gives meaning to the firing rules in DFD-SPECS, which specify the dynamic behaviour of a DFD.\n\nWe model how a bubble fires in two steps. A bubble first reads its input flows, and then writes to its output flows. We say a bubble is working when it has read its input flows but not yet produced output; it is idle otherwise. We consider the transitions between these states to be atomic.\n\nWhat happens when a flow is read depends on the persistency of the flow. When a bubble reads from a consumable flow, the information read is removed from the flow, while reading from a persistent flow does not affect the information it contains. Similarly, writing to a consumable flow adds to the information on the flow, while writing to a persistent one overwrites any information already present. Thus, a persistent flow is like a variable shared between two bubbles which the origin bubble can write and the destination bubble can only read. We treat consumable flows as unbounded FIFO queues. Hence, any information read from a consumable flow is read from the head of the flow’s queue, and any information added to a consumable flow is added at the rear.\n\nFiring occurs as follows. Initially, all the bubbles are idle. The flows may have some initial values placed upon them — the initial state of the diagram. Then the following algorithm is executed:\n\n[^3]The distinction between persistent and consumable flows is closely related to the issue of continuous versus discrete flows found in the traditional DFD literature [Col91] [HP87] [War86].\n1. Find the set of bubbles that may fire. This includes all bubbles in the working state, and any bubble in the idle state that has values on its inflows satisfying the enabling condition of at least one of its firing rules.\n\n2. Choose one of these bubbles to fire.\n\n3. Fire the bubble:\n - If the bubble is idle:\n (a) Choose one of the bubble's rules whose enabling condition is satisfied by the inflow values.\n (b) Read the values referenced by this rule from the inflows. For consumable flows, remove the value. Otherwise, do not change the flow.\n (c) Change the state of the bubble from idle to working.\n - If the bubble is working:\n (a) Check that the pre-condition is satisfied by the values from the inflows. In the interpreter, an exception is raised if the pre-condition isn't satisfied.\n (b) Produce values onto the outflows. These values are defined by the post-condition of the rule chosen when the bubble changed to the working state. For consumable flows, the value is enqueued. For persistent flows, the new value overwrites the flow's contents.\n (c) Change the state of the bubble from working to idle.\n\n4. Repeat the above steps until the set of bubbles allowed to fire in step one is empty.\n\nSo, in the example of the previous section, we start in a state where all bubbles are idle, and flows are initialized to the initial state. The only bubble that can fire is FindWords, because the enabling condition of its rule is satisfied and CorrectMisspellings has no rules with satisfied enabling conditions. Both of the inflows of FindWords are persistent, so they are read but not changed in any way. Finally, FindWords changes state to working.\nContinuing the execution, \\texttt{FindWords} is again the only bubble which may fire. Its rule has no pre-condition, which is equivalent to a pre-condition of just true and so is satisfied. Next, the dictionary of unknown words as defined by the post-condition is written to flow \\texttt{Unknown: Dictionary}. Finally, \\texttt{FindWords} changes state to idle.\n\n### 3.3 Executing Firing Rules\n\nThis section briefly describes the technique used to execute the firing rules. The technique works with FOPC assertions over a fixed set of types (and a fixed set of primitive functions), and so is not dependent on DFDs. In fact, the execution technique has also been used in the execution of a specification language for C++ classes [WBL94]. More details on the execution technique are available in [WBL93], which presents part of the code for the interpreter.\n\nAs can be seen in the previous section, executing DFD-SPECS specifications requires the ability to use FOPC assertions in two distinct ways: to check whether a given set of values satisfies an assertion for testing enabling and pre-conditions, and to construct a set of values that satisfy an assertion for evaluating post-conditions.\n\nChecking assertions is simpler, as all that is required in most cases is the straightforward implementation of logical and DFD-SPECS operators. The only possible complications are quantified assertions and set comprehensions (for example, $\\{x+1 \\mid 1 \\leq x \\leq 5 \\land x \\mod 2 = 0\\}$ is a set comprehension with value \\{3, 5\\}). In the executable subset, quantified variables and the bound variable in set comprehensions are required to range over a finite and explicit domain. For example, each variable bound by a quantifier in the example of Figures 3.1 and 3.2 is forced to range over a finite set of values. Thus, quantified assertions are evaluated by simply iterating over this domain. For set comprehensions, the domain is filtered according to the predicate in the body of the comprehension, and then the result of this filtering is transformed (mapped, in functional programming terminology) according to the function in the head of the comprehension.\n\nFinding values that satisfy post-condition assertions is considerably more complicated. The following algorithm is used to find outflow values that satisfy the post-condition of a firing rule.\n1. Split the post-condition into two parts—the part that can be used in constructing outflow values, and the part that can only be used in checking that the values constructed satisfy the post-condition.\n\n2. Evaluate the constructive parts into a list of constraints on the outflow values.\n\n3. Evaluate the constraints into values for the outflows, and bind the outflow names to the appropriate values in an environment that can be used to check the nonconstructive parts of the post-condition.\n\n4. Check that the nonconstructive parts of the postcondition are satisfied by the values constructed from the constructive parts.\n\nTo evaluate universally quantified assertions into constraints, the body of the assertion is evaluated once for each element of the domain quantified over. All constraints so produced are placed in the list of constraints generated from the postcondition. For existentially quantified assertions, the technique is to first find some element of the domain that satisfies the parts of the body of the assertion that do not refer to outflow values. Then, this element is bound to the quantified variable, and the body is evaluated once more to generate constraints.\n\n3.4 Related Work\n\nThe work related to our research on executing DFD-SPECS falls into two categories: work on formalizing and executing DFDs, and work on executing model-based specifications. In the first category, the work that the authors are aware of requires the specifier to give at least part of the specification in a programming language, and thus the specification advantages of FOPC—abstractness, conciseness, freedom from implementation bias, and the possibility of using theorem proving techniques to prove properties of specifications, are lost. In the second category, existing techniques for executing specifications are not suited to our purposes for various reasons, as detailed with the discussion of these techniques.\n3.4.1 Formalizing and Executing DFDs\n\nPAISley [ZS86] is an executable specification language based on asynchronous processes, which are similar to finite state machines. Thus, PAISley specifications have at least a superficial similarity to DFD-SPECS specifications, with states roughly playing the role of bubbles, and state transitions acting as flows. In PAISley, the computations that occur on state transitions are written in a functional programming language that features composition, conditional selection, and tuple formation.\n\nPSDL [BL90] [LVY88] is an executable enhancement of DFDs for hard real-time specification. The language includes an interesting and elegant type system for flows. However, the atomic operations of the specified system — the operations that implement the functionality of bubbles — must be written in some programming language. Thus, both PAISley and PSDL sacrifice abstraction for executability.\n\n3.4.2 Executing Model-based Specifications\n\nThe EPROL specification language [HI88, HI86] makes a fairly large subset of VDM executable by compiling it to LISP. Even some specifications that use quantifiers are executable. EPROL is part of the EPROS system, which provides tool support for evolutionary and functionality prototyping and for building the user interface to the prototype. The me too specification language [Hen86] executes a subset of VDM that is very similar to that executed by EPROL.\n\nAs VDM is closely related to the part of DFD-SPECS that is used for specifying enabling, pre- and post-conditions, either EPROL or me too could have been used in executing DFD-SPECS. However, neither language can execute assertions of the following three forms. These forms are crucial in writing sufficiently abstract assertions.\n\n- The only operator that can be used to define post-state values\\(^4\\) in EPROL and me too is =. In other words, the expression \\(S' = \\{3\\}\\) is executable, where \\(S'\\) represents the post-state value of the set \\(S\\), but the equivalent\n\n\\(^4\\)In this context, post-state value is a synonym for outflow value — a value defined by the post-condition.\n3 \\in S' \\land |S'| = 1\n\nis not.\n\n- Post-state values of tuple, set, and sequence types cannot be defined \"by parts\", i.e. by describing the result of applying tuple, set, and sequence observers to such post-state values. For example, if rationals are modeled as a tuple consisting of numer and denom fields, then an assertion such as\n\n\\text{numer}(r') = 3 \\land \\text{denom}(r') = 4\n\nis not executable, even though it clearly defines the post-state value of \\( r \\).\n\n- A quantified assertion can only be evaluated if it contains no references to post-state values, and so can only be evaluated for its boolean value. Thus, an expression such as\n\n\\forall x \\ [ x \\in S \\Rightarrow x \\in S' ]\n\\land \\forall y \\ [ y \\in S' \\Rightarrow y \\in S ]\n\nis not executable, even though it is clearly equivalent to \\( S' = S \\), which is executable using any of the techniques described.\n\nAll of the above assertions are executable in DFD-SPECS.\n\nAnother approach to the execution of model-oriented specifications is the fase3 language of Kamin and Kraus [KK93, Kra88]. Only a few primitive types such as integer, boolean, and so on are built into fase3. More structured types, such as the set, sequence, and tuple types of DFD-SPECS are specified using a style of final algebra specification that allows any type to be represented as a tuple of functions. As long as these functions remain finite for a particular element of the type, the functions can be represented as \"tables\" (finite sets of tuples), and quantified assertions over that element can be executed. Unlike quantified assertions in executable DFD-SPECS specifications, the specifier need not supply an explicit bound on the quantified variable. Assertions that use observers to define values are also executable.\nin fact, the functions that represent an element are exactly the observers of the type as applied to that element.\n\nHowever, many quantified assertions that are executable using our technique for DFD-SPECS can not be executed in fase3. In fase3, most quantified assertions with references to the specified function's return value in their bodies are not executable. The only exception is a restricted form of existentially quantified assertions that is used to select an element from the domain quantified over. Thus, for example, the third example of a specification that EPROL cannot execute (given above) is also an example of a specification that is not executable in fase3.\n\nThe execution techniques are quite different. In fase3, specifications are first compiled to an extended λ-calculus, and then to an extended form of combinator graph, which is then reduced. An execution technique of this generality seems to be necessary because the specifier defines the observers of a particular type, rather than the observers being built into the language as in DFD-SPECS. It seems likely that errors reported by the reduction algorithm will not be as useful in debugging specifications as errors reported by a direct interpreter such as the one used for DFD-SPECS, as the combinator graph that the reduction algorithm is working on is several compilation steps removed from the specification that the graph was derived from.\n\n3.5 Conclusion\n\n3.5.1 Contributions\n\nWe wish to emphasize four contributions of this research. Two pertain directly to the specification of DFDs, the third highlights the advantages of having a formal semantics for DFD-SPECS, and the fourth presents the use of executable specifications in software development.\n\nThe first contribution to the specification of DFDs is the particularly simple structure of enabling conditions, as compared to other efforts to capture this idea [Kun91] [Col91]. In our effort to execute and give semantics to enabling conditions, we found that it does not make sense to allow arbitrary logical connectives in the\n\n---\n\n5Note that the return values of fase3 functions are the values that are defined by specifications, and so play the role of outflow values in DFD-SPECS.\nflow-enabled-list portion of the enabling condition (the part consisting of the list of inflows of the bubble tagged with + or -; see the grammar in Section 3.2.1). This realization occurred while automating evaluation of enabling conditions, and so is a result of our effort to execute DFD-SPECS. Consider, for example, an enabling condition (that we do not allow) of the form $+f_1 \\lor +f_2$. This enabling condition is true when a token is present on either flow, or on both. Thus, when the rest of the rule is written, there is no way to know whether or not any individual flow has a token on it, and so no other part of the rule may refer to the value of a token consumed from either flow. The information carried on the flows is lost. So, the only logical connective for the elements of the flow-enabled-list allowed in DFD-SPECS is $\\land$.\n\nThe other contribution to the specification of DFDs is an insight into the nature of firing rules. By adding the notion of firing a bubble, we have raised the questions: “Can a bubble fire concurrently with itself? Can a bubble fire on two distinct rules simultaneously?” In the execution of DFD-SPECS, the answer is no — the semantics we have given prohibits this behavior. When a bubble in the working state fires, it must fire on the rule it was using when the transition to the working state was made, and must produce its output and change state to idle. Work on refinement notions for DFD-SPECS [Ly] has shown that if a bubble is refined to a sub-diagram with several bubbles, the sub-diagram can exhibit behaviors that look like reading more than one input before producing output. We have investigated formal semantics for bubbles firing concurrently with themselves in a forthcoming work [LWBL], and the application of this work to DFD-SPECS would be straightforward.\n\nBy formalizing the DFD model and providing a semantics for DFD-SPECS, we have made the rather “warm and fuzzy” Data Flow Diagram into a solid tool for specifying software systems. Thus, we have all the advantages of traditional formal specification, and at the same time, our model still allows users to do traditional DFDs — simply by building a diagram with bubbles and flows, but no rules, or even simplified rules that don’t capture the entire functionality needed. This informal specification can be directly refined to a formal one — by adding the necessary rules [Ly].\n\nThe final contribution of our work is that most DFD-SPECS specifications are\nexecutable. Thus, the specification is a prototype of the final system, allowing conceptual and requirements errors to be found before the lengthy and expensive process of coding begins. Additionally, the specification can be tested and debugged, allowing errors in the specification can be found and corrected before valuable programmer time is put into implementing the specification. Both these points imply that errors are likely to be discovered earlier than with a traditional software development cycle, resulting in quicker and less expensive production of software.\n\n3.5.2 Directions for further research\n\nWe have formalized and made executable much of the traditional DFD model, but more remains to be done. Some of what follows arises from traditional DFDs, but much of the research is unique to the formal model.\n\n3.5.2.1 Research arising from traditional DFDs An interesting possibility stemming from our research is that of using our formal semantics with traditional CASE tools. In particular, Teamwork™ has already been modified to work with DFD-SPECS specifications. We would like to combine our interpreter with Teamwork to produce a tool that could animate the graphical representation of DFD-SPECS.\n\n3.5.2.2 Research arising from DFD-SPECS The problems we have uncovered in formalizing DFDs are perhaps even more interesting than those found in traditional DFDs. We have extended a static model to a dynamic one, and so face issues that don't even exist in the traditional DFD world.\n\nFor example, we would like to write invariants for DFD-SPECS specifications. An invariant is a logical assertion defining allowable states of the diagram, and so only makes sense in terms of a dynamic model. For example, we might like to require that a certain flow never be empty, or that it never contain more than some fixed number of tokens — consider specifying a bounded buffer producer/consumer system. Since our specifications are now executable, we would now also like to check that the invariant holds at every step in the computation of the diagram. Extending the\nidea of invariants, we may eventually want to use temporal logic [MP92] [Pnu86] to describe liveness and safety properties of DFD-SPECS specifications.\n\nWe would also like to extend the subset of FOPC that can be used in executable DFD-SPECS assertions. We are studying additional techniques for enhancing the interpreter, such as backtracking and running our execution technique multiple times on a single post-condition for finding outflow values that are defined in terms of other outflow values.\n\n3.5.3 Concluding Remarks\n\nThus, it is with high expectations that we approach the next stages of our research. We have successfully demonstrated the executability of a large and powerful subset of DFD-SPECS. With the addition of a parser to translate the concrete syntax of DFD-SPECS to our abstract syntax, our interpreter could become a useful tool in industrial software development settings.\n4. AN APPROACH TO THE DIRECT EXECUTION OF\nMODEL-BASED SPECIFICATIONS\n\nA paper in preparation for the Software Engineering Journal\n\nTim Wahls, Albert L. Baker, and Gary T. Leavens\n\nAbstract\n\nExecutable specification languages may be the key to more widespread use of\nformal methods in software production. However, the expressiveness of executable\nspecification languages is typically much less than that of non-executable specification\nlanguages such as VDM or Z, and so specifiers are forced to work at a lower level\nof abstraction to gain the advantage of executability. Additionally, specifications are\ntypically made executable by translating them to some programming language, so\nmany errors in the specification can only be detected as errors in the resulting code.\nThis paper presents a technique for directly executing model-based specifications\nwritten at a relatively high level of abstraction.\n\n4.1 Introduction\n\nOne barrier preventing formal methods from playing a larger role in industrial\nsoftware development is the fear that the benefits of using formal methods are not\nworth the costs. Executable formal specifications can help in overcoming this fear,\nas an executable specification yields an immediate prototype of the final system.\n\n1Wahls's work is supported by a fellowship provided by IBM Rochester. Leavens's\nwork is supported in part by the National Science Foundation under Grant CCR-\n9108654.\nThose who already use formal specifications also benefit, because executing a specification allows debugging it in the same way that programs are debugged. In addition, executable specifications ease incremental system integration and testing, as the specification (as a prototype) can take the place of parts of the final system that are yet to be implemented.\n\nThus it is not surprising that many executable specification languages have been developed. Unfortunately, these languages almost always force the specifier to work at a much lower level of abstraction than is normally employed in writing specifications in non-executable model-based specification languages, such as VDM [Jon90] and Z [Hay87, Spi88, Spi89, Spi92]. Typically, either the specifier must provide the algorithms needed for executing the specification [LL91, BL90, ZS86, LB89], or execution is based on translating the specification to Prolog [TC89, WE92, DKC90]. In the former case, the specifier is forced to work in an impoverished specification language that is often almost indistinguishable from modern functional programming languages, and the algorithmic information that must be provided is a potential source of implementation bias [Jon90]. If the specification is translated to Prolog, the person using the executable specification is exposed to the inefficiency and non-logical features of Prolog (cut, dependence on order of clauses). Such translations also usually entail poor reporting of errors. These problems are magnified when validating specifications, as specification errors show up in the Prolog code, and the validator must first find the error in the context of the Prolog code, and then find the corresponding error in the specification.\n\nA number of existing executable specification languages/techniques allow the execution of implicit specifications — that is, specifications that do not explicitly provide the necessary algorithms. We first briefly describe several of these languages, and then discuss some of the limitations that these languages share.\n\nThe EPROL specification language [HIS8, HIS86] makes a fairly large subset of VDM executable by compiling specifications to LISP. Even some specifications that use quantifiers are executable. EPROL is part of the EPROS system, which provides tool support for evolutionary and functionality prototyping and for building the user interface to the prototype. Similarly, the me too specification language [Hen86] executes much the same subset of VDM by embedding specifications in LISP.\nThe UK’s National Physical Laboratory has developed a syntax-directed editor for entering VDM specifications with a mode called SMLVIEW [O’N92a, O’N92b] that displays the VDM specification entered compiled into Standard ML (SML) [Pau91] code. The translation scheme is apparently fairly direct, so the VDM specification must be somewhat close to an SML program for this translation to work, and the subset of VDM that can be translated is relatively small. Additionally, some VDM features that are in principle executable, such as set comprehensions\\(^2\\), are not implemented.\n\nAs both EPROL and SMLVIEW involve translation to a programming language, both force the user wishing to validate specifications into the “debug the code, then debug the specification” mode described previously, especially if the generated code fails to compile (as can happen when using SMLVIEW) or causes a run-time error. Any specification error discovered is then reported in the context of the generated code, rather than the context of the specification. As an EPROL specification can be written at a more abstract level than a specification to be executed using SMLVIEW, the distance between the specification and the Lisp code generated is relatively large, and the difficulty of finding the flaw in the specification that caused the error in the generated code may be great. As specifications to be executed using SMLVIEW must be fairly close to the resulting SML code, this “reverse translation” problem is likely to be less serious. However, with SMLVIEW, the user must often hand edit the SML code resulting from the translation to achieve even a syntactically correct SML program. In either case, then, the user is forced into intimate contact with a language that is not directly involved in the software development process – it is neither the specification nor implementation language.\n\nAdditionally, all three of the techniques discussed apparently cannot execute VDM-like assertions of the following three forms:\n\n- The only operator that can be used to define post-state values is =. In other words, the assertion \\(3 \\in S'\\), where \\(S'\\) represents the post-state value of the set \\(S\\), is of no help in building a post-state value for \\(S\\), even though it clearly\n\n\\(^2\\)For example, \\(\\{i + 2 \\mid 1 \\leq i \\leq 5 \\land i \\mod 2 = 0\\}\\) is a set comprehension with value \\(\\{4, 6\\}\\)\ndefines part of that value.\n\n- Post-state values of tuple, set, and sequence types cannot be defined \"by parts\", i.e. by describing the result of applying tuple, set, and sequence observers to such post-state values. For example, if rationals are modeled as a tuple consisting of \\texttt{numer} and \\texttt{denom} fields, then an assertion such as \\texttt{numer(r')} = 3 \\land \\texttt{denom(r')} = 4 is not executable, even though it clearly defines the post-state value of \\texttt{r}.\n\n- A quantified assertion can only be evaluated if it contains no references to post-state values, and so can only be evaluated for its boolean value. Thus, an expression such as \\( \\forall x [x \\in S \\land \\text{odd}(x) \\Rightarrow x \\in S'] \\) can not be used in constructing the value of \\( S' \\), even though it again defines part of that value.\n\nIn the case of \\textit{SMLVIEW}, these limitations can be seen in the description of the subset of VDM that can be executed (see Appendix J of [O'N92a]). Although the authors have been unable to locate any similar characterization of the subset of VDM that EPROL or \\textit{me too} can execute, the example specifications that have been published also exhibit these same limitations.\n\nWe present a technique that makes constructive use of these kinds of assertions in constructing post-state values, and that executes the kinds of assertions that can be executed by EPROL, \\textit{me too}, and \\textit{SMLVIEW} as well. While adding executability of these three features may seem like small progress, they are characteristic (in our experience) of the truly implicit specifications many specifiers, regardless of their expertise and mathematical sophistication, tend to write. Thus, the executability of these features is of key importance in executing specifications. We want executability to be as small a burden on the specifier as possible. Our main goal is to allow the specifier to write purely implicit specifications in a language that is in general not executable, and then execute as much of the specification as is practical. If more executability is needed, then the specification can be refined to an executable form. Thus, specification languages that are designed to be executable are in general not suitable for our purposes, but we do want to ease the trade-off between implicitness and executability as much as we can.\nIn addition, our technique has been implemented as an interpreter for model-based specifications, and so avoids the problems associated with validating a specification when translation to some programming language is used for execution. The technique is described in the context of the specification language SPECS-C++, which is a VDM-like language specialized for specifying C++ [ES90b, Str91] classes. However, our execution technique is not tied to any special feature of SPECS-C++, and so would work as well for VDM specifications as it does for those written in SPECS-C++.\n\nAn informal description of SPECS-C++ is presented in the next section. Our approach to executing SPECS-C++ follows in Section 4.3. Section 4.4 presents an informal characterization of the limitations of our execution technique. Finally, we examine some of the most closely related work in Section 4.5 and speculate about the continued evolution of directly executable, abstract, and formal specifications for C++ classes in the concluding Section 4.6.\n\n### 4.2 Syntax for Executable SPECS-C++ Specifications\n\nThe next two sections summarize our work on direct execution of model-based specifications. We have a literate Standard ML (SML) [Pau91] implementation of an interpreter for a subset of SPECS-C++. This SML implementation should be thought of as a prototype and a demonstration of the feasibility of the execution technique, as it uses an abstract syntax for SPECS-C++ that is too cumbersome for actually writing specifications. Other members of the SPECS-C++ development team are currently working on tools that use the concrete syntax of SPECS-C++ presented in this section. The next section describes the executable subset of SPECS-C++ and the execution technique used in the SML implementation. In the interest of brevity, no SML code is presented, but is available in [WBL94].\n\nA SPECS-C++ specification consists of a set of class specifications and the\n\n---\n\n3 The interpreter is being developed with the aid of the literate programming tool Noweb [Ram91]. Noweb allows a program and the text describing it to be written simultaneously and in the same file, provides a structured way of presenting the code, and makes extracting the code or the descriptive text easy.\ndefinitions of the abstract model types used in those specifications. The primitive abstract types are basically those of VDM: integer, float, char, string, and bool, where float is the type of real numbers. The void type of C++ is included as the return type of pure procedures. More complex types are composed from these basic types: finite sets, sequences, tuples, and alternative (union) types. The map and function types of VDM are not included, but finite maps and functions may be modeled as sets of tuples. All abstract type definitions are visible globally.\n\nClass specifications in SPECS-C++ roughly correspond to modules in VDM. Each class specification defines a type (with the same name as the class) and a set of operations on that type, called public member functions. These public member functions correspond to the exported operations of a VDM module, and are specified using pre- and post-conditions, much like implicit VDM specifications. However, the precise meaning of a class specification is different than the meaning of a VDM module, because SPECS-C++ is an interface specification language [GHW85, GHG+93, Lam89] for C++. That is, a SPECS-C++ specification of a class can only be implemented by a C++ class with the same name, each prototype of a public member function in the specification must appear (with the same name, return type, and arguments) in the implementation as a public member function, and the implementation of each public member function must satisfy the specification given for it in the SPECS-C++ class. For example, consider a SPECS-C++ class OrderedPair (representing ordered pairs of integers) and a member function First that returns the first element of an OrderedPair. (This specification will be presented in full shortly.) The relationship between the specification and the implementation is pictured in Figure 4.1. The interface and the meaning are both part of the specification that must be matched by the implementation.\n\nAs in Larch/Ada [GMP92] and LM3 [Jon92], SPECS-C++ specifications are embedded in implementation code. A SPECS-C++ specification is placed in specially formatted comments within a C++ header file. This automatically makes the interfaces match, and avoids redundancy. Thus, the declaration of the class and the prototypes of the member functions in the specification must be compilable C++ code, and the other parts of the specification (i.e., abstract type declarations, pre- and post-conditions, and so on) are written inside C-style (/* to */) comments, and\nFigure 4.1: The meaning of a SPECS-C++ member function specification. The C++ code must match the specified interface and have a compatible meaning.\nthis style of comment cannot be used otherwise. This separates the C++ clients of\nthe specified class from the C++ code that implements it, so that the implementation\ncan be separately compiled. As the specification is included in the header, the header\ncontains all the information that C++ clients of the class need to know to use the\nclass correctly.\n\nAs an example of a SPECS-C++ specification, consider the specification of the\nclasses OrderedPair (Figure 4.2) and Relation (Figure 4.3), where Relation is\nmodeled as a set of OrderedPairs. Member functions with the class name are con\nstructors, and are typically invoked in client code when class instance declarations\nare executed. Class Int_Set, the return type of RelTo, is not shown here as it is\nuninteresting, but would have to be included for executing this example. The pre\ncondition of the function RelTo specifies that the parameter key must be in the\ndomain of the relation, and the post-condition specifies that the result consists of\nall the integers related to key in the relation. The obvious VDM analog of RelTo’s\npost-condition exhibits two of the kinds of assertions that are not executable under\nthe VDM-based techniques discussed earlier, as references to post-state values ap\npear inside quantified assertions, and the value of result’ is specified using only \\in\n(set membership). However, this post-condition is executable using our approach.\nAs this post-condition is also a non-trivial example of the expressive power of these\nfeatures, the specification of RelTo will be used as a running example in the section\non executing assertions (Section 4.3). A more detailed description of SPECS-C++ is\npresented after this example.\n\nIn SPECS-C++, a class specification consists of the abstract data members, an\ninvariant, a set of abstract function definitions, and a set of public member function\nspecifications. Each of these parts is described below.\n\nIn C++, the data members of a class implement the state of instances of the\nclass – i.e., elements of the type defined by the class. Abstract data members in\nSPECS-C++ differ from the concrete data members of C++ in two important ways:\n\n- abstract data members are used to model the state of instances of the class type\n (and so appear only in the specification), while C++ data members actually\n implement these states. Hence, many different collections of concrete C++\ndata members can implement the specified abstract data members.\nclass OrderedPair {\n/* model */\n** data members */\n** int first */\n** int second */\n** operations */\npublic:\n OrderedPair(int f, int s);\n/* modifies: self */\n** postA: first' = f /\\ second' = s */\n\n int First();\n/* postA: result' = first */\n\n int Second();\n/* postA: result' = second */\n};\n\nFigure 4.2: Specification of class OrderedPair.\nclass Relation {\n /* model */\n ** data members */\n ** set of OrderedPair theRel */\n ** operations */\n\n public:\n\n Relation();\n /* modifies: self */\n ** postA: theRel' = {} */\n\n Insert(OrderedPair elem);\n /* modifies: self */\n ** postA: theRel' = theRel \\ union \\{elem\\} */\n\n ... Int_Set RelTo(int key);\n /* preA: \\exists \\{OrderedPair p\\} [ */\n ** \\(p \\in \\text{theRel}\\) \\(\\land p.First() = key\\)]\n ** postA: \\forall \\{OrderedPair p\\} [ */\n ** \\(p \\in \\text{theRel}\\) \\(\\land p.First() = key \\Rightarrow p.Second() \\in \\text{result'}\\) */\n ** ] \\land */\n ** \\forall (int i) [ */\n ** \\(i \\in \\text{result'}\\) \\Rightarrow */\n ** \\exists \\{OrderedPair p\\} [ */\n ** \\(p \\in \\text{theRel}\\) \\(\\land i = p.Second() \\land key = p.First()\\) ] */\n\nFigure 4.3: Specification of class Relation.\n• abstract data members are visible globally in the specification, while C++ allows various kinds of control over what parts of a program may access concrete data members. The development method used with SPECS-C++ requires that the C++ data members implementing any given abstract data members be private (visible only within the class where they are defined). Thus, class implementations that satisfy a SPECS-C++ specification have only private data members, and all client code access must be through the specified public member functions.\n\nIn our semantics for SPECS-C++, class instances are modeled as tuples composed of the abstract data members, and so are similar to VDM composite types (trees). If a class has no abstract data members, then its type is modeled as the empty tuple. So, for example, instances of class OrderedPair would be modeled as follows:\n\ntuple OrderedPair (int first, int second)\n\nThe invariant in SPECS-C++ is a first order predicate calculus assertion that every class instance must satisfy in every state that can be observed by client code. Invariants may also be written for any specifier-defined abstract type. In our example specifications, any pair of integers is a valid OrderedPair, and any set of OrderedPairs is a valid Relation, and so their invariants are both true, and hence omitted. The invariant for a class should refer only to the abstract data members of the class it belongs to.\n\nAbstract functions allow a first order assertion on the abstract model to be abstracted and parameterized, much like the functions of an ordinary programming language. Abstract functions cannot be invoked in client code. They are just aids in modularizing other assertions in a specification.\n\nThe specification of a member function consists of a C++ function prototype, a pre-condition, a modifies clause, and a post-condition. The function prototype includes a return type, the name of the function, and a parameter list with the types\n\n\\[ \\text{tuple OrderedPair (int first, int second)} \\]\n\nThe invariant in SPECS-C++ is a first order predicate calculus assertion that every class instance must satisfy in every state that can be observed by client code. Invariants may also be written for any specifier-defined abstract type. In our example specifications, any pair of integers is a valid OrderedPair, and any set of OrderedPairs is a valid Relation, and so their invariants are both true, and hence omitted. The invariant for a class should refer only to the abstract data members of the class it belongs to.\n\nAbstract functions allow a first order assertion on the abstract model to be abstracted and parameterized, much like the functions of an ordinary programming language. Abstract functions cannot be invoked in client code. They are just aids in modularizing other assertions in a specification.\n\nThe specification of a member function consists of a C++ function prototype, a pre-condition, a modifies clause, and a post-condition. The function prototype includes a return type, the name of the function, and a parameter list with the types\n\n\\[ \\text{tuple OrderedPair (int first, int second)} \\]\n\nThe invariant in SPECS-C++ is a first order predicate calculus assertion that every class instance must satisfy in every state that can be observed by client code. Invariants may also be written for any specifier-defined abstract type. In our example specifications, any pair of integers is a valid OrderedPair, and any set of OrderedPairs is a valid Relation, and so their invariants are both true, and hence omitted. The invariant for a class should refer only to the abstract data members of the class it belongs to.\n\nAbstract functions allow a first order assertion on the abstract model to be abstracted and parameterized, much like the functions of an ordinary programming language. Abstract functions cannot be invoked in client code. They are just aids in modularizing other assertions in a specification.\n\nThe specification of a member function consists of a C++ function prototype, a pre-condition, a modifies clause, and a post-condition. The function prototype includes a return type, the name of the function, and a parameter list with the types\n\n\\[ \\text{tuple OrderedPair (int first, int second)} \\]\n\nThe invariant in SPECS-C++ is a first order predicate calculus assertion that every class instance must satisfy in every state that can be observed by client code. Invariants may also be written for any specifier-defined abstract type. In our example specifications, any pair of integers is a valid OrderedPair, and any set of OrderedPairs is a valid Relation, and so their invariants are both true, and hence omitted. The invariant for a class should refer only to the abstract data members of the class it belongs to.\n\nAbstract functions allow a first order assertion on the abstract model to be abstracted and parameterized, much like the functions of an ordinary programming language. Abstract functions cannot be invoked in client code. They are just aids in modularizing other assertions in a specification.\n\nThe specification of a member function consists of a C++ function prototype, a pre-condition, a modifies clause, and a post-condition. The function prototype includes a return type, the name of the function, and a parameter list with the types\n\n\\[ \\text{tuple OrderedPair (int first, int second)} \\]\n\nThe invariant in SPECS-C++ is a first order predicate calculus assertion that every class instance must satisfy in every state that can be observed by client code. Invariants may also be written for any specifier-defined abstract type. In our example specifications, any pair of integers is a valid OrderedPair, and any set of OrderedPairs is a valid Relation, and so their invariants are both true, and hence omitted. The invariant for a class should refer only to the abstract data members of the class it belongs to.\n\nAbstract functions allow a first order assertion on the abstract model to be abstracted and parameterized, much like the functions of an ordinary programming language. Abstract functions cannot be invoked in client code. They are just aids in modularizing other assertions in a specification.\n\nThe specification of a member function consists of a C++ function prototype, a pre-condition, a modifies clause, and a post-condition. The function prototype includes a return type, the name of the function, and a parameter list with the types\n\n\\[ \\text{tuple OrderedPair (int first, int second)} \\]\n\nThe invariant in SPECS-C++ is a first order predicate calculus assertion that every class instance must satisfy in every state that can be observed by client code. Invariants may also be written for any specifier-defined abstract type. In our example specifications, any pair of integers is a valid OrderedPair, and any set of OrderedPairs is a valid Relation, and so their invariants are both true, and hence omitted. The invariant for a class should refer only to the abstract data members of the class it belongs to.\n\nAbstract functions allow a first order assertion on the abstract model to be abstracted and parameterized, much like the functions of an ordinary programming language. Abstract functions cannot be invoked in client code. They are just aids in modularizing other assertions in a specification.\n\nThe specification of a member function consists of a C++ function prototype, a pre-condition, a modifies clause, and a post-condition. The function prototype includes a return type, the name of the function, and a parameter list with the types\n\n\\[ \\text{tuple OrderedPair (int first, int second)} \\]\n\nThe invariant in SPECS-C++ is a first order predicate calculus assertion that every class instance must satisfy in every state that can be observed by client code. Invariants may also be written for any specifier-defined abstract type. In our example specifications, any pair of integers is a valid OrderedPair, and any set of OrderedPairs is a valid Relation, and so their invariants are both true, and hence omitted. The invariant for a class should refer only to the abstract data members of the class it belongs to.\n\nAbstract functions allow a first order assertion on the abstract model to be abstracted and parameterized, much like the functions of an ordinary programming language. Abstract functions cannot be invoked in client code. They are just aids in modularizing other assertions in a specification.\n\nThe specification of a member function consists of a C++ function prototype, a pre-condition, a modifies clause, and a post-condition. The function prototype includes a return type, the name of the function, and a parameter list with the types\n\n\\[ \\text{tuple OrderedPair (int first, int second)} \\]\n\nThe invariant in SPECS-C++ is a first order predicate calculus assertion that every class instance must satisfy in every state that can be observed by client code. Invariants may also be written for any specifier-defined abstract type. In our example specifications, any pair of integers is a valid OrderedPair, and any set of OrderedPairs is a valid Relation, and so their invariants are both true, and hence omitted. The invariant for a class should refer only to the abstract data members of the class it belongs to.\n\nAbstract functions allow a first order assertion on the abstract model to be abstracted and parameterized, much like the functions of an ordinary programming language. Abstract functions cannot be invoked in client code. They are just aids in modularizing other assertions in a specification.\n\nThe specification of a member function consists of a C++ function prototype, a pre-condition, a modifies clause, and a post-condition. The function prototype includes a return type, the name of the function, and a parameter list with the types\n\n\\[ \\text{tuple OrderedPair (int first, int second)} \\]\n\nThe invariant in SPECS-C++ is a first order predicate calculus assertion that every class instance must satisfy in every state that can be observed by client code. Invariants may also be written for any specifier-defined abstract type. In our example specifications, any pair of integers is a valid OrderedPair, and any set of OrderedPairs is a valid Relation, and so their invariants are both true, and hence omitted. The invariant for a class should refer only to the abstract data members of the class it belongs to.\n\nAbstract functions allow a first order assertion on the abstract model to be abstracted and parameterized, much like the functions of an ordinary programming language. Abstract functions cannot be invoked in client code. They are just aids in modularizing other assertions in a specification.\n\nThe specification of a member function consists of a C++ function prototype, a pre-condition, a modifies clause, and a post-condition. The function prototype includes a return type, the name of the function, and a parameter list with the types\n\n\\[ \\text{tuple OrderedPair (int first, int second)} \\]\n\nThe invariant in SPECS-C++ is a first order predicate calculus assertion that every class instance must satisfy in every state that can be observed by client code. Invariants may also be written for any specifier-defined abstract type. In our example specifications, any pair of integers is a valid OrderedPair, and any set of OrderedPairs is a valid Relation, and so their invariants are both true, and hence omitted. The invariant for a class should refer only to the abstract data members of the class it belongs to.\n\nAbstract functions allow a first order assertion on the abstract model to be abstracted and parameterized, much like the functions of an ordinary programming language. Abstract functions cannot be invoked in client code. They are just aids in modularizing other assertions in a specification.\n\nThe specification of a member function consists of a C++ function prototype, a pre-condition, a modifies clause, and a post-condition. The function prototype includes a return type, the name of the function, and a parameter list with the types\n\n\\[ \\text{tuple OrderedPair (int first, int second)} \\]\nand names of the formal parameters, exactly as in C++. Member functions always take a formal parameter of the associated class type which is not explicitly listed, the \\textit{default parameter}. In SPECS-C++, this default parameter is always referred to as \\texttt{self}, and is analogous to *this in C++. As a shorthand, the abstract data members of the default parameter can be referred to without mentioning \\texttt{self}, so \\texttt{first} and \\texttt{self.first} are synonyms when specifying the member functions of class \\texttt{OrderedPair}.\n\nThe \\texttt{modifies} clause is a list of the formal parameters, possibly including the default parameter, that the member function is allowed to mutate. The \\texttt{modifies} clause could also be used to advertise mutation of non-local objects, but this is not currently allowed by the SPECS-C++ method. An omitted \\texttt{modifies} clause means that the member function has no side effects.\n\nJust as in VDM, the pre- and post-conditions describe respectively what must be true for the member function to execute correctly, and what will be true after executing the member function. An omitted pre-condition is equivalent to just \\texttt{true}, and means that successful execution of the member function does not depend on the pre-state. We take the total correctness approach, so an implementation is required to terminate in a state that satisfies the post-condition whenever the pre-state satisfies the pre-condition. In the post-condition, the keyword \\texttt{result'} is used to refer to the return value of the member function. To distinguish between the pre-state and post-state values of formal parameters in the post-condition, variable identifiers representing post-state values are primed ('). We include \\texttt{result'} in the set of primed identifiers. Primed identifiers may not appear in a pre-condition.\n\nPre- and post-conditions, abstract functions, and invariants are first order predicate calculus assertions written over SPECS-C++ types. Thus, SPECS-C++ expressions include the literals of the primitive abstract types, the normal mathematical operations on integers and floats, and the standard constructors and observers for sets, sequences, and tuples. Equality is defined in the natural way for each of these types. Sets are constructed by the standard \\{ \\ldots \\} notation, including set comprehensions, i.e. \\{ \\( i + 2 \\mid 1 \\leq i \\leq 10 \\} \\). They are observed by \\texttt{\\in} and \\texttt{\\subseteq}, which are just membership and subset, respectively. Sequences are constructed by \\texttt{\\langle \\ldots \\rangle}, and \\texttt{||} is used for appending of sequences. Given this much notation, the observers\nthat decompose sequences are defined as follows, where \\( s \\) represents a sequence, and \\( e \\) is a sequence element:\n\n\\[\n\\begin{align*}\n\\text{first}(e || s) &= e \\\\\n\\text{last}(s || e) &= e \\\\\n\\text{header}(s || e) &= s \\\\\n\\text{trailer}(e || s) &= s \\\\\n\\text{index}(e || s, i) &= \\text{if } i = 1 \\text{ then } e \\text{ else } \\text{index}(s, i - 1)\n\\end{align*}\n\\]\n\nNote that none of these observers may be applied to empty sequences. The only built-in way to observe tuples is to look at their components, or fields. For each field of every tuple type, SPECS-C++ provides an observer with the same name as the field that returns the associated value. For example, given a declaration:\n\n\\[\n\\text{tuple rational (int num, int denom)}\n\\]\n\nfunctions num: rational \\( \\rightarrow \\) int and denom: rational \\( \\rightarrow \\) int are then available for extracting the components of the tuple.\n\nPredicate calculus assertions are built with the standard boolean connectives: logical and (\\( \\land \\)), or (\\( \\lor \\)), implication (\\( \\Rightarrow \\)), and negation (\\( \\lnot \\)), and the universal (\\( \\forall \\)) and existential (\\( \\exists \\)) quantifiers.\n\nAbstract function references and calls of member functions with non-void return types are also allowed in assertions. Any side effects of the called member function are ignored, so the meaning is that the value\\(^5\\) defined by the body of the abstract function, or respectively the value of result\\(^{*}\\) defined by the post-condition of the member function, is substituted for the call or reference in the assertion. (A syntax and informal semantics for using side effects of member functions in assertions has been developed, but this feature is yet to be formalized.)\n\n\\(^5\\)While the specifications of member functions can in general be nondeterministic, we require abstract functions and member functions that are referenced in pre- or post-conditions to be deterministic. Otherwise, the semantics of assertions becomes problematic. For example, consider the truth value of the assertion \\( \\text{foo}(i) = 3 \\) when \\( \\text{foo}(i) \\) can evaluate to either 2 or 3.\n4.3 An Algorithm for Executing Assertions\n\nOnly public member functions of SPECS-C++ classes can be referenced in client code, so the direct execution of SPECS-C++ (from a client’s perspective) is just the execution of public member function calls.® A call to RelTo would have the form \\( R.\\text{RelTo}(2) \\), where \\( R \\) is an instance of class Relation. Note that the parameters are not C++ values, but rather abstract values corresponding to C++ values. To interpret such a SPECS-C++ public member function call, we use its specification as follows:\n\n1. Check that the actual arguments satisfy the pre-condition of the called member function.\n\n2. Construct post-state values that satisfy the post-condition of the called member function.\n\nIf the post-condition isn’t satisfiable, or if the execution technique isn’t adequate for the given post-condition, then this attempt will fail.\n\n4.3.1 Evaluating Pre-conditions\n\nAs the pre-condition is evaluated in the pre-state of the operation, all the values in the pre-condition assertion are known – they are exactly the actual arguments of the member function. Thus, all that is needed is to apply the definitions of the built-in operators, and the implementation is straightforward. The quantified assertions and set comprehension expressions are the only possible complications.\n\nIn the executable subset of SPECS-C++, universally quantified assertions must be of the form:\n\n\\[\n\\forall (T \\, x) \\; [ \\; (\\text{BP}(x)) \\land P(x) \\Rightarrow Q(x) \\; ]\n\\]\n\nand existentially quantified assertions must be of the form:\n\n\\[\n\\exists (T \\, x) \\; [ \\; (\\text{BP}(x)) \\land P(x) \\Rightarrow Q(x) \\; ]\n\\]\n\n° Invariants could also be executed in order to check that all class instances created or modified by member functions satisfy their respective invariants. However, we have not done so to-date.\n\\exists (T x) [ (BP(x)) \\land P(x) ]\n\nwhere \\( T \\) is the type of the bound variable, and \\( BP(x) \\) is either \\( x \\in E \\) and \\( E \\) is a finite set or sequence, or \\( BP(x) \\) is \\( \\text{low} \\leq x \\leq \\text{high} \\), for some integer valued expressions \\( \\text{low} \\) and \\( \\text{high} \\). We use the term domain of the quantified variable to mean either the predicate \\( BP(x) \\) or the set of values that satisfy that predicate. Which meaning is intended should be clear from context. In the executable subset, this forces quantified variables to range over finite domains. The assertions \\( P(x) \\) and \\( Q(x) \\) are arbitrary assertions of the executable subset (including quantified assertions) that may refer to \\( x \\), and the \\( \\land P(x) \\) portion of both quantifier forms is optional.\n\nA universally quantified assertion such as:\n\n\\( \\forall (\\text{int } x) [(1 \\leq x \\leq 5) \\Rightarrow x < 6] \\)\n\nis evaluated by applying the predicate \\( x < 6 \\) to each of the integers 1 through 5, and logically \"anding\" together each of the results. Thus, evaluating universal quantification corresponds to an and reduction over the domain of the quantified variable. For existential quantifiers, an assertion such as the pre-condition of RelTo:\n\n\\( \\exists (\\text{OrderedPair } p) [(p \\in \\text{theRel}) \\land p.\\text{First()} = \\text{key}] \\)\n\nis evaluated by applying the predicate \\( p.\\text{First()} = \\text{key} \\) to each \\( \\text{OrderedPair} \\) in \\( \\text{theRel} \\), and logically \"oring\" together all of the results - which corresponds to an or reduction. This technique of evaluating quantifiers with reductions is common in the literature [BM93].\n\nIn the executable subset, set comprehensions must be of the form:\n\n\\{F(x) \\mid (BP(x)) \\land P(x)\\}\n\nwhere \\( BP(x) \\) and \\( P(x) \\) are used in precisely the same manner as they were in the definitions of the executable quantified assertions. The term \\( F(x) \\) is an arbitrary term of the executable subset of SPECS-C++. The term \\( F(x) \\) is not required to contain any occurrence of \\( x \\), but will in any interesting case. Given this definition, the evaluation of a set comprehension is basically a filter of the domain, followed by a map. For example, the expression:\n\\{x + 2 \\mid (1 \\leq x \\leq 5) \\land x \\bmod 2 = 0\\}\n\nis evaluated by choosing the integers between 1 and 5 that are even, adding 2 to each, and making a set out of the results.\n\n4.3.2 Satisfying Post-conditions\n\nExecuting a post-condition is more involved. The following steps provide an overview of our algorithm for executing a post-condition:\n\n1. Split the post-condition into constructive and nonconstructive parts. The constructive parts are those which will actually be helpful in constructing post-state values that satisfy the post-condition.\n\n2. Generate a list of constraints from the constructive part. Each constraint defines a post-state value or some part of a post-state value.\n\n3. Solve the constraints to construct the portion of the post-state that differs from the pre-state. The constraints need not determine unique post-state values (and so some \"looseness\" in executable specifications is possible), but this process is deterministic. Thus, calling the same sequence of member functions with the same arguments will always produce the same results.\n\n4. Check the nonconstructive portion of the post-condition by evaluating it in a state where unprimed identifiers have their pre-state values, and primed identifiers (including result') have their post-state values. This state is built from the pre-state and the state constructed in the previous step. If this check fails, then the execution of the post-condition fails.\n\n5. Construct the state that results from the member function call. This state reflects mutations of the actual parameters of the call.\n\nWe are planning to generalize our algorithm by supporting backtracking; if the evaluation fails in step three or step four, the algorithm could go back to step one and make a different split into constructive and non-constructive parts, or to step three and try some of the other possibilities that any looseness in the specification permits.\nWe will discuss the possibilities for backtracking in more detail as the algorithm unfolds.\n\n### 4.3.2.1 Splitting into Constructive and Nonconstructive Parts\n\nThe first step is to split the post-condition into two parts: the part that will be useful in constructing post-state values, and the part that can only be used as a check on post-state values. This splitting is based on the structure of the post-condition. For example, in an assertion of the form $A_1 \\land A_2$, both $A_1$ and $A_2$ must be true for the post-condition to be satisfied, and so each is processed separately.\n\nWith an assertion of the form $A_1 \\lor A_2$, the splitting algorithm tries to determine if either $A_1$ or $A_2$ is necessarily false, just using pre-state values. If either is necessarily false, it discards that argument and continues processing the other. For example, in the post-condition: $(x = 3 \\land x' = 4) \\lor (x \\neq 3 \\land x' = 3)$ (recall that primed variable identifiers represent post-state values), one argument of the $\\lor$ assertion will be false just from pre-state values, and so can be ignored. If neither argument can be determined to be false, then the entire $\\lor$ assertion is nonconstructive, and is evaluated only after the construction of all post-state values. For example, the entire assertion: $x' = 3 \\lor x' = 4$ is nonconstructive. However, when backtracking is added to the interpreter, this case can be handled differently. The interpreter can assume that $x' = 3$ is true, and proceed with the execution. If this assumption results in an unsatisfiable or non-executable post-condition, then the interpreter can backtrack and make the other possible assumption ($x' = 4$). If this assumption fails, then the post-condition must be unsatisfiable or non-executable.\n\nThe first step in evaluating an assertion of the form $A_1 \\Rightarrow A_2$ is to determine whether the antecedent $A_1$ is necessarily true or false, in the same way that the arguments of an $\\lor$ assertion are tested. If $A_1$ must be false, then the entire $\\Rightarrow$ assertion is ignored, as there is no requirement that the consequent $A_2$ holds. If $A_1$ must be true, then $A_2$ must hold, and so is processed recursively. If the truth value of the antecedent cannot be determined just from the pre-state values, then the entire assertion is nonconstructive. Again, the addition of backtracking allows better handling of this case. The two possible assumptions that can be made are that $A_1$ and $A_2$ are both true, or that $A_1$ is false.\nOf the post-condition operators that are not logical connectives, the most important are $=$, $\\in$, and $\\subseteq$. These are the ones that directly contribute to the construction of post-state values. For one of these operators to be constructive, it must be the case that one argument of $=$ and the left argument of both $\\in$ and $\\subseteq$ contain no primed identifiers. This allows the value of that argument to be computed in the pre-state in much the same way that pre-conditions are evaluated. The other argument of $=$, and the right argument of both $\\in$ and $\\subseteq$, must represent a post-state value or part of a post-state value. In other words, it needs to be a primed identifier, or arbitrarily many applications of the built-in tuple and/or sequence observers to a single primed identifier. (The tuple and sequence observers were discussed in Section 4.2.) For example, $x' = 3$, $\\text{elem in theRel'}$, and $\\{3\\} \\subseteq \\text{result'}$ are all constructive, but $\\text{result'} = \\text{self'}$.Second(), $5 \\times x' = 3$, $x' \\in \\{3, 4\\}$ and $\\text{index(S', i')} = 3$ are not. Clearly, \"constructive\" information can be obtained from assertions that are not currently constructive, and so this is an area of ongoing research. In Section 4.4, we discuss an iterative technique for relaxing these restrictions.\n\nOther kinds of relational operators and negated assertions provide some information about post-state values, but are usually of little help in actually constructing them, and so are classified as nonconstructive. For example, $x' < 3$ or $!(x' = 3)$ do give some information about the post-state value of $x$, but both are satisfied by an infinite number of post-state values. One possible extension of the work presented here is to use constraint-satisfaction techniques [Lel88] both for gleaning more information from these kinds of expressions and for generalizing what can represent a post-state value in a constraint.\n\nSet comprehensions, abstract function references, and calls to member functions are constructive if they contain no occurrences of primed identifiers. For a universally quantified assertion to be constructive, the expression for the (finite) domain that the quantified variable ranges over and the assertion $P$ (the rest of the antecedent of the implication) must not contain primed identifiers. Additionally, the assertion $Q$ (the consequent of the implication) must be constructive, using the definition being developed in this section. Otherwise, the universally quantified assertion is nonconstructive. For example, in the post-condition of RelTo:\n\\forall (OrderedPair p) \\[\n(p \\in theRel) \\land p.First() = key \\Rightarrow p.Second() \\in result'\n]\\]\n\nis constructive, as neither the domain of the quantified variable nor the antecedent of the implication contains a primed identifier, and the consequent of the implication is constructive. However,\n\n\\forall (int i) \\[\n(i \\in result') \\Rightarrow \\\\\n\\exists (OrderedPair p) \\[\n(p \\in theRel) \\land i = p.Second() \\land key = p.First()\n]\\]\n\nis not constructive, because result' is the domain of the quantified variable.\n\nExistentially quantified assertions are constructive if the domain of the bound variable contains no primed identifiers, and the rest of the assertion is constructive.\n\n4.3.2.2 Evaluating Constructive Parts into Constraints\n\nTo simplify the construction of post-state values, the constructive part of the post-condition is transformed into a list of constraints on the output values. As one might expect from the last section, these constraints are equality, membership, and subset, and any occurrence of one of these operators is immediately evaluated into a constraint, with the argument that contains no references to post-state values evaluated into a value of one of the abstract types. Note that this transformation is only applied to constructive expressions as defined in the previous section, so an appropriate argument with no references to post-state values is guaranteed to exist. For the same reason, the transformation need deal only with \\(\\land\\) and quantified assertions, and an \\(\\land\\) assertion is handled by simply appending the lists of constraints generated by its two arguments. For example, given the the post-condition \\(\\text{header}(s') = <1, 2> \\land \\text{last}(s') = 3\\), the transformation produces the constraint list \\([\\text{header}(s') = <1, 2>, \\text{last}(s') = 3]\\).\n\nUniversally quantified assertions are transformed to constraints by repeatedly evaluating the body of the assertion with the variable bound by the quantifier bound to each value in the domain, in turn. The resulting lists of constraints are appended into a single list of constraints. So, if (in the post-condition of RelTo) the default\nparameter to RelTo is \\{(1, 2), (2, 2), (2, 3)\\} and the value of key is 2, then\nthe assertion\n\n\\[ p.\\text{First}() = \\text{key} \\Rightarrow p.\\text{Second}() \\in \\text{result'} \\]\n\nis evaluated 3 times, with \\( p \\) bound to \\((1, 2), (2, 2), \\) and \\((2, 3)\\) in turn. The\nresulting constraint list is \\([2 \\in \\text{result'}, 3 \\in \\text{result'}\\].\n\nFor existentially quantified assertions, the technique is to repeatedly evaluate the\nbody of the assertion for its boolean value, where subexpressions involving post-state\nvalues are ignored. This is done with the quantified variable bound to each element\nof the domain, in turn, until the evaluation returns true. Then, the element that\nsatisfies the body is bound to the quantified variable, and the body is evaluated to\ngenerate constraints. So, for example, an assertion such as:\n\n\\[ \\exists (\\text{int } x) \\ [(1 \\leq x \\leq 3) \\land x \\mod 2 = 0 \\land y' = x + 5 ] \\]\n\ncauses the predicate \\( x \\mod 2 = 0 \\) to be evaluated for \\( x \\) equal to 1, 2, and 3. As\nonly 2 satisfies this predicate, the constraint list \\([y' = 7]\\) is generated. If multiple\nelements of the domain satisfy the predicate, the first one that this evaluation tech\nnique finds is used. Note that such an existentially quantified assertion constitutes\nan underdetermined or non-deterministic specification, and that this is the only kind\nof “loose” specification that the execution technique can use constructively in its cur\nrent form. With the addition of backtracking, specifications that are loose because\nof assertions using \\( \\lor \\) and \\( \\Rightarrow \\) as described earlier can also be used constructively.\nThe addition of backtracking will also allow more sophisticated use of existentially\nquantified assertions. Many elements of the domain quantified over can potentially\nsatisfy the parts of the body of the assertion that do not refer to post-state values. In\ncase the original choice of such an element causes the execution of the post-condition\nto fail, backtracking would allow other elements of the domain to be tried.\n\n4.3.2.3 Evaluating Constraints into Values\n\nThe execution algorithm\nnext tries to construct a post-state value for identifiers appearing in the modifies\nclause and for any non-void function result, using the list of constraints constructed\nas described in the previous section. The first step is to check whether the (primed)\nidentifier appears directly in one or more constraints. If so, then there are only two possibilities, assuming that the post-condition used to generate the constraints is satisfiable. Either one or more identical = constraints match, and the (identical) post-state value is directly in each such constraint, or a group of \\texttt{\\textbackslash in} and \\texttt{\\textbackslash subset} constraints match, and so a value of type set needs to be constructed. This is done by unioning together the first arguments of all the constraints that matched. For example, if the list of constraints is \\([2 \\in \\text{result}', 3 \\in \\text{result}']\\), then the post-state value constructed for \\text{result}' is \\{2, 3\\}.\n\nIf the primed identifier doesn't match any constraint and the post-state value under construction is of type tuple or sequence, then the next step is to check the constraint list for applications of built-in tuple or sequence observers, respectively. (Recall that these observers are defined in Section 4.2.) The only non-atomic values in SPECS-C++ are tuples, sequences, and sets, and the only built-in observers of sets (\\texttt{\\textbackslash in} and \\texttt{\\textbackslash subset}) are converted directly into constraints, so tuples and sequences are the only types whose values can be constructed in this way.\n\nThe only built-in way to observe tuples is to look at their components, or fields. Thus, the next step in trying to construct a post-state value of a tuple type is to attempt to match (in the constraints list) the application \\texttt{field(identifier')} for each field of that type of tuple. If this is successful, then the post-state tuple value can easily be constructed.\n\nWhen trying to construct a post-state value of a sequence type, our algorithm constructs applications of the sequence observers to the appropriate primed identifier, and then matches these applications with the constraint list. Each successful match defines a part of the post-state value. For example, if the primed variable of interest is \\texttt{s'} and the constraint list is \\([\\text{header}(s') = <1, 2>, \\text{last}(s') = 3]\\), then two applications match, and the post-state value of \\(<1, 2, 3>\\) can easily be constructed. Clearly, such multiple matches can produce redundant information about the post-state value of a sequence, and this information should be checked for consistency. This has not yet been implemented, but seems straightforward. The other case (some part of the post-state value of a sequence is not defined in the constraint list) is treated next.\n\nIf some part of the post-state value of a sequence or tuple is completely uncon-\nstrained by the constraint list, then there are two possibilities, depending on whether the associated identifier (formal parameter of a tuple or sequence type) is defined (has a value associated with it) in the pre-state. If the identifier is defined in the pre-state, then the \"and nothing else changes\" semantics of SPECS-C++ implies that the unspecified part should be whatever it was in the pre-state value. If the value is being constructed from scratch, then the post-condition didn't provide enough information to construct it, and so the construction fails and reports an error.\n\nPost-state values of union types are constructed by searching the types of the union, and finding the first one to which the value belongs. If none of the type works, then the attempt to construct the post-state value fails. This is another situation in which backtracking could be used to make more specifications executable.\n\nThe steps described in the previous paragraphs are applied in a mutually recursive fashion. Thus, if we had modeled integer relations as a sequences of sets of integers (i.e. each index position in the sequence is related to each of the elements of the set found at that index position), then our algorithm could utilize constraints like $3 \\in \\text{index}(R', \\text{key})$ in constructing a post-state value for $R'$.\n\nIf the post-state value of some identifier appearing in the modifies clause is completely unspecified (i.e. that identifier does not appear in any constraint), then it is handled in the same way as unspecified parts of tuples or sequences – if it is defined in the pre-state, then the post-state value is the same as that of the pre-state value, and if it is not defined in the pre-state, then the construction fails. Note that the result' of the member function being specified is always undefined in the pre-state, and so member functions with non-void return types must always construct a post-state value for result'.\n\n4.3.2.4 Checking the Nonconstructive Parts Next, the parts of the post-condition that were determined to be nonconstructive are checked by evaluating them for their boolean values. This evaluation is done with respect to both the pre- and post-states, as the truth value of the nonconstructive parts may depend on both. Unprimed identifiers have their pre-state values, and primed identifiers (including result') have their post-state values. So, for example, the nonconstructive portion of the post-condition for RelTo:\n\\[\\forall (\\text{int } i) \\ [ \\ (i \\in \\text{result'}) \\Rightarrow \\exists (\\text{OrderedPair } p) \\ [ \\ (p \\in \\text{theRel}) \\land i = p.\\text{Second()} \\land \\text{key} = p.\\text{First()} )] \\]\n\nis evaluated w.r.t a pre-state where theRel is \\{(1, 2), (2, 2), (2, 3)\\}, key is 2, and a post-state where result' is \\{2, 3\\}. The evaluation mechanism is identical to that used for pre-conditions. If this evaluation returns true (as it does for this example), then all is well. Otherwise, the attempt to execute the post-condition fails. This can occur because the post-condition isn’t satisfiable, or because the technique described for finding post-state values failed to find satisfactory ones.\n\n4.3.2.5 Constructing the Result State To complete the execution of a member function call, we need to construct the state that results from the call. This is different from the post-state we have been discussing so far, as this is outside the scope of the member function. Thus, the formal parameters are no longer part of the state, and any side effects of the member function are now reflected in the actual parameters, rather than the formal parameters. Note that any formal parameter that is mutated must appear in the modifies clause of the called function. If the member function that was called has a non-void return type, then the value constructed for result' is just printed, as return values of functions do not affect the state.\n\nAs all state modifications performed by the member function have been made and any return value constructed, execution of the member function call is complete.\n\n4.4 Limitations of the Execution Technique\n\nWhile the work described here makes a large subset of SPECS-C++ executable, not all valid SPECS-C++ specifications can be executed. A post-condition must contain constructive subassertions that define all of the post-state values to be found. The following list of nonconstructive (and so, non-executable) assertions is provided to highlight the limitations of the execution technique.\n\n- Quantified assertions where the domain of the bound variable depends on post-state values, implications where the antecedent refers to post-state values, and\nmultiple occurrences of primed identifiers in the same constraint (in the sense of Section 4.3.2.3). Examples include:\n\n\\[ \\forall (\\text{int } x) \\ [(x \\in (\\text{foo}' \\cup \\{3\\})) \\Rightarrow x \\in \\text{foo}' \\] \n\n\\[ x' = 3 \\Rightarrow y' = 4 \\]\n\n\\[ \\text{index}(S', i') = 3 \\]\n\nAugmenting the execution technique with backtracking would only partially solve these problems. Many more such assertions would be executable by a more incremental approach: find post-state values for all the identifiers possible, and then try again in a state where these primed identifiers are bound to the value found. This corresponds to finding all of the post-state values that depend only on pre-state values, then finding all the post-state values that depend only on pre-state values and those post-state values found in the previous step, and so on until no more post-state values can be found. Note that this scheme is guaranteed to terminate, as at least one post-state value must be found at each step for this iteration to continue.\n\n- Negated assertions and assertions in which any relational operator other than \\(\\_, \\_\\in\\), or \\(\\_\\subset\\) is used to describe the relationship of some value to the post-state value being constructed. Examples of such assertions can be found in Section 4.3.2.1. They limit the possible post-state values that can be constructed. As these limits are checked when the nonconstructive portion of the post-condition is evaluated, the evaluation technique already utilizes such assertions as well as can be expected in the absence of constraint-satisfaction techniques such as those discussed in [Lel88].\n\n- Post-state values used as arguments to abstract function references and member functions calls in post-conditions. Assertions like \\(\\_\\text{someabsfun}(\\text{foo}')\\) do not help in constructing the post-state value for \\text{foo}, at least as far as the work described here is concerned. Note that simply replacing the call or reference by the specification of the associated function will not work. To see this, consider\na post-condition of some member function of class Relation that just mimics\nRelTo on a key of 2, i.e. result' = self.RelTo(2). The post-condition\nof RelTo is a (boolean valued) assertion, so this new post-condition fails to\ntype check. The same problem arises with abstract function references, as an\nabstract functions can also define its return value in the implicit manner typified\nby RelTo. However, this problem does seem reasonably tractable, and so this\nis an area for further research.\n\n4.5 Related Work\n\nThe most closely related work is the fase3/C++ language of Kamin and Kraus\n[KK93, Kra88], as it is a (mostly) executable interface specification language for C++\nclasses. The fase3 approach is very similar to that taken in the Larch [GHW85,\nGHG93] family of specification languages, as it is two-tiered, consisting of the\nfase3 shared language and the bf fase3/C++ interface language for C++.\n\nThe shared language is where most specification occurs, and so where interesting execution\noccurs as well. Only a few primitive types such as integer, boolean, and so on are\nbuilt into fase3. More structured types, such as the set, sequence, and tuple types\nof SPECS-C++ are specified in the shared language using a unique style of algebraic\nspecification that allows any type to be represented as a tuple of functions. As long\nas these functions remain finite for a particular element of the type, the functions can\nbe represented as “tables” (finite sets of tuples), and quantified assertions over that\nelement can be executed. The syntax for quantified assertions is elegant and concise,\nas the specifier need not supply an explicit bound on the quantified variable, as is\nrequired in executable SPECS-C++ specifications. Assertions that use observers to\ndefine values are also executable — in fact, the functions that represent an element\nare exactly the observers of the type as applied to that element.\n\nHowever, many quantified assertions that are executable using our technique for\nSPECS-C++ can not be executed in fase3. Given the natural fase3 shared language\nspecifications of set, sequence, and tuple, the kinds of quantified assertions that have\nno references to post-state7 values that are executable seem quite similar to those\n\n7In fase3, there is no concept of pre- and post-state at the shared level. When\nthat are executable using our technique for SPECS-C++. However, only one kind of fase3 quantified assertion can be evaluated if it contains references to post-state values. This kind of assertion is a restricted form of existential quantification that can only be used to select a particular element from the domain quantified over. Thus, any other kind of quantified assertion can only be evaluated for its boolean value, and so does not provide any interesting way to constrain post-state values. For example, the post-condition of the member function `RelTo` as discussed in the previous section, is not executable using the fase3 execution technique.\n\nThe execution techniques are quite different. In fase3, specifications are first compiled to an extended \\( \\lambda \\)-calculus, and then to an extended form of combinator graph, which is then reduced. An execution technique of this generality seems to be necessary because the specifier defines the observers of a particular type, rather than the observers being built into the language as in SPECS-C++. Because of the compilation phases and complicated reduction phase, the fase3 execution technique seems unlikely to execute specifications as rapidly as our technique for SPECS-C++. We are also unsure of the usefulness of errors reported by the reduction algorithm in debugging the specification that the graph was derived from.\n\nAnother work with some relation to our own is the structural mapping from Object-Z [CDD'90] to C++ of Rafsanjani et. al. [RC93]. This mapping is an informal guideline for producing C++ implementations from Object-Z specifications. Object-Z classes are mapped to C++ classes, operations to virtual member functions, and so on. The mapping is not intended to be an automated translation, so the only tool support provided is a partial implementation of the Object-Z basic types. The work does provide some interesting observations on the relationship between specification inheritance and code inheritance which may be helpful as we work on adding inheritance to our interpreter for SPECS-C++.\n\nwe refer to post-state values in the context of fase3, we are referring to the values returned from shared language functions. These are the values that are defined by specifications, and so play the role of post-state values in SPECS-C++. \n4.6 Conclusion\n\nOne of the strengths of the execution technique described here is that it is relatively efficient (at least with respect to Prolog) and execution times are predictable. The most expensive built-in operators (set intersection, difference, and subset) take $O(n^2)$ time, execution of quantifiers takes time linear in the size of the domain quantified over, and all other built in operations take either linear time (length of sequences, size of sets, etc.) or constant time. Hence, running times can be estimated by inspection of the specification. With the addition of backtracking to the interpreter, some of this predictability would be lost. However, the loss of efficiency would be minimal, as any post-condition that is currently executable would not require backtracking for correct execution by the augmented interpreter.\n\nHowever, this execution technique does lose some aspects of expressiveness as compared to Prolog, even with the addition of backtracking. For example, a classic way of implementing sorting in Prolog is to define predicates “permutation” and “ordered”, and then define a sorted sequence as an ordered permutation of the original. SPECS-C++ is expressive enough to state the specification of a sort this way – the post-condition would look like:\n\n$$\\text{Permutation}(s, s') \\land \\text{Ordered}(s')$$\n\nfor a sequence argument $s$ and appropriate abstract functions Permutation and Ordered. This specification is not executable by the technique described here. On the other hand, executing the Prolog sorting program takes exponential time, and so there is a trade-off between expressiveness and execution time.\n\nAdditionally, our execution technique was designed to take advantage of the ways in which humans usually write specifications. We have found, for example, that people tend to write more constructive specifications (in the sense developed in Section 4.3.2.1), rather than nonconstructive specifications like the one discussed in the previous paragraph. In particular, our technique was developed in the context of a suite of specification examples used for teaching formal methods at both the undergraduate and graduate levels. Almost all of these specifications are executable with only (very) minor modifications, such as placing parenthesis around the domains.\nof variables bound by quantifiers. This provides good evidence that the executable subset of SPECS-C++ is useful in practice.\n\nWe have provided an interpreter for SPECS-C++, rather than using translation to some programming language. Hence, this technique does not require the user to know Standard ML (the language the interpreter is written in), and also can more easily report helpful error messages than techniques using translation.\n\nThe execution technique also demonstrates the use of default frame axioms in an executable specification language. Frame axioms are used to say “and nothing else changes” — that only the state transformations explicitly required by the post-condition actually occur, and no more. The modifies clause is a form of frame axiom, as it explicitly limits the side effects of a member function to only the formals (and corresponding actuals) that occur in the modifies clause. However, additional frame axioms are often required, as member function specifications don’t always completely specify all post-state values. While extra explicit frame axioms can be included in the post-condition, doing so leads to large and unreadable specifications, along with a number of other problems [BMR93]. In SPECS-C++, implicit frame axioms are included in the semantics of the specification language. These frame axioms are also part of the executable subset of SPECS-C++. This is demonstrated in the section on evaluating constraints into post-state values (Section 4.3.2.3). For sets, the default frame axiom is to find a minimal set satisfying the post-condition. To see this, note that nothing is included in a post-state set value unless the post-condition explicitly includes it, in the form of a \\in or \\subset expression. For tuples and sequences, the default frame axiom is that no field or index position changes from the pre-state to the post-state unless the post-condition explicitly specifies that it change.\n\nTwo major extensions of the interpreter are planned. These extensions will add constructs for dealing with SPECS-C++ abstractions of C++ objects and for specification inheritance.\n\nIn C++, “An object is a region of storage” [Str91]. Equivalently, an object may be thought of as a cell in memory, or a value and its address. In SPECS-C++, we are concerned with distinguishing between objects and values because objects can be mutated and aliased, while values cannot. Incorrect usage of mutation and aliasing is a common cause of errors in C++ programs, so it is important to advertise to\nusers of a class (through the specification of the class) exactly where mutation and aliasing can occur. SPECS-C++ borrows the C++ notion of references as a uniform mechanism for creating and handling objects. However, references are not yet part of the executable subset of SPECS-C++.\n\nJust as in C++, in SPECS-C++ inheritance relationships are established through the use of derived classes. The syntax and semantics used are similar to C++, so that a class specified as a derived class inherits the abstract data members and (the specifications of the) member functions of its base (super) class [Lea93]. We plan to add specification inheritance to the SPECS-C++ interpreter, and so to the executable subset of SPECS-C++.\n\nEven in its unfinished state, the SPECS-C++ interpreter can already be used in two important ways. The first is that it provides a formal semantics for a large subset of SPECS-C++. Even if the specifier never wants to execute specifications, this work is useful in that it gives denotational and operational semantics for the executable subset of SPECS-C++, which includes the built-in operators, abstract functions, using member functions in specifications, and (soon) objects and inheritance of specifications. As the SML compiler provides operational semantics for all the constructs in the executable subset, this work has a decided advantage over non-executable descriptions in reference manuals. The SPECS-C++ interpreter is an unambiguous specification of the meaning of the executable subset of SPECS-C++ specifications.\n\nSecondly, this work provides an executable subset of SPECS-C++, and the means to execute specifications written in the subset. Thus, a specification can serve as a prototype of the finished system. Some of the advantages for the specifier and client are [WBL93]:\n\n1. Validating specifications. The specifier can now test and debug a specification in much the same way that a programmer would validate a program. This pushes validation into the specification stage of the software development process.\n\n2. Understanding formal specifications. The client, who is likely to have little or no experience with formal methods, now has a way to understand a formal specification. By experimenting with the prototype, the client can discover\nand report to the specifier erroneous or unexpected results, and missing or incomplete features.\n\nBoth these points imply that requirements and specification errors are likely to be discovered earlier, resulting in less expensive and more reliable software. Additionally, problems that traditional software engineering techniques cope with poorly, such as missing functionality and incomplete requirements documentation, are much more likely to be addressed by an executable specification. Often, the software developer is completely unaware of such problems, and only discovers them after the completed software is delivered to the client. Giving the client a prototype can result in such problems being discovered far earlier.\n\nThus, this research is a contribution to both the theoretical and practical sides of formal methods. On the theoretical side, it demonstrates an executable specification language and execution technique with clear advantages over other approaches. On the practical side, it demonstrates that prototypes generated by executable specifications can be efficient enough for practical use. As such, it represents solid progress in applying formal methods to industrial software production.\n5. APPLICATIONS OF CONTRAINT LOGIC PROGRAMMING TECHNIQUES IN EXECUTING FORMAL SPECIFICATIONS\n\nA paper in preparation for ACM Transactions on Software Engineering and Methodology\n\nTim Wahls,¹ Gary T. Leavens, and Albert L. Baker\n\nAbstract\n\nExecutable specifications may be a key to the industrial acceptance of formal specification techniques, as executability leads to better and more useful specifications. However, executability should not compromise the high level of abstraction typically achieved with model-based specification languages. We investigate the application of techniques from constraint logic programming to the execution of specifications, and show how variants of these techniques can be used to execute very high level specifications.\n\n5.1 Introduction\n\nDespite the strong research interest in the use of formal specification languages in developing software, such languages have made relatively little impact in industrial development settings. The advantages of formal specifications are clear: precise and unambiguous descriptions of software functionality. However, from an industrial viewpoint, specification activities produce little that can be demonstrated to clients as progress toward a finished product, and training software developers in the formal notations involved is an expensive overhead. Additionally, formal specifications are\n\n¹Wahls's work is supported by a fellowship provided by IBM Rochester.\nwritten by humans, and so suffer from \"bugs\" analogous to those that infest programs. An erroneous specification, no matter how precise, is of little value.\n\nHow can such problems be overcome? A partial answer, we believe, lies in executable specifications. An executable specification serves as a functional prototype of the final system, which allows client and developer interaction on system functionality in the earliest stages of development. Currently, this kind of interaction occurs largely after at least partial implementation, often resulting in wasted programming effort. Executable specifications can serve as test oracles, which allow partial automation of the process of testing implementations [GB94]. Executable specifications can also be debugged in much the same way that programs are debugged, resulting in the early detection and correction of errors. This is vital in software development, as the cost of correcting an error in maintenance is typically 100 times greater than the cost of correcting the corresponding error at the specification level [Boe81].\n\nIt is natural to think of the post-conditions of model-based formal specifications as constraints to be satisfied by the post-state. Thus, the execution of such specifications corresponds to a constraint satisfaction problem. However, much of the work in logic and Constraint Logic Programming (CLP) languages is not directly applicable, as the domains involved are different. For example, a common domain in CLP is the rationals or reals, and the constraints to be satisfied are systems of equations and inequalities. While such situations do arise in specifications and can be described in languages such as VDM and Z, specifications over domains such as sets, sequences, tuples, and objects are far more common in industrial software development.\n\nThere is also a basic difference in the kind of answers that are desired between the areas of constraint satisfaction and executable specifications. For example, specifications are usually intended to be implemented in an imperative programming language, and so define mappings from procedure inputs to outputs. Thus, the ability to invert logic programs (or specifications) – i.e., to produce the inputs corresponding to given outputs – is of less interest in executing specifications than it is in logic programming. Additionally, as specifications define the functionality of imperative procedures, the user of an executable specification language usually wants a particular post-state value as an answer, rather than constraints on suitable post-state values.\n\nHowever, some of the techniques used in CLP languages can be of great value\nin executing specifications. The rest of this paper describes the application of CLP-like techniques in executing formal, model-based specifications. In Section 5.2 we provide a brief introduction to Prolog and modern CLP languages such as CLP(\\text{R}) and Prolog III. In Section 5.3 we discuss model-based specification languages and the features of such languages that complicate the application of CLP techniques. In Section 5.4, we describe our technique for executing specifications. Section 5.4.3 provides some example SPECS-C++ specifications and describes their execution. Section 5.4.5 characterizes the run time performance of the algorithm. Section 5.4.6 describes some of the current limits of the execution technique, and Section 5.4.7 outlines future work on lifting these limitations. In Section 5.5 we conclude with a comparison of our technique and logic and constraint logic programming techniques.\n\n5.2 Prolog and CLP Languages\n\nThe best known logic programming language is Prolog [CM84, Col85, Coh85]. Prolog is based on Horn clauses, which represent a subset of first order predicate logic. A Prolog program consists of a finite collection of rules. A query is a list of atomic formulas, and an answer to a query is a substitution of values for the free variables of the query that allow it to be concluded from the rules in the program. The domain of computation is finite trees, where trees are simply terms.\n\nThe basic execution mechanisms of Prolog are unification, refutation (also known as resolution), and backtracking. Unification is the process of finding a substitution for the free variables of two atomic formulas or terms that make the atomic formulas or terms identical. Refutation is the deductive process by which conclusions are drawn from programs. The refutation algorithm often has a choice of rules to apply, so that when a choice of one rule results in the inability to conclude the query, the algorithm can backtrack and try a different rule.\n\nThe best known CLP languages are Prolog III [Col90] and CLP(\\text{R}) [JMSY92]. While the languages have some similarities — for example, both use refutation and backtracking much like Prolog — they are also quite different, both from each other and from Prolog.\n\nIn Prolog III, unification is completely replaced by constraint solving. A con-\nstraint is any atomic formula (including arithmetic equations and inequalities). Rules and queries can include an explicit set of constraints. The answer to a query is a set of constraints on possible answers (in a solved form). As the execution of a Prolog III program progresses, backtracking occurs whenever the current set of constraints becomes unsatisfiable, or when no rule can be applied. The evaluation of a constraint can be explicitly delayed by the user with a \"freeze\" mechanism [Coh90]. The domains over which constraint solving occurs are infinite trees, lists, booleans, reals, characters, and strings.\n\nOn the other hand, CLP(R) uses constraint satisfaction only for the reals, and unification for other computational domains. Constraints consist of arithmetic equations and inequalities, and equality of nonarithmetic terms. Constraints can be used anywhere in the body of a rule. As in Prolog III, answers to queries are simplified sets of constraints. Constraints are not explicitly delayed, but non-linear equations are delayed until sufficient variables are solved to make them linear. The domains of computation are the reals and finite trees (as in Prolog).\n\nWith respect to CLP languages, part of our contribution is the formalization of constraints over specification language domains such as sets, sequences, tuples, and objects, and the introduction of techniques for solving these constraints.\n\n5.3 Model-based Specification Languages\n\nModel-based specification languages describe the functionality of procedures in terms of an underlying mathematical model. The best known examples of these languages are VDM [Jon90] and Z [Hay87, Spi89, Spi92], although many other model-based specification languages have been developed. The model typically includes primitive types such as integers and characters, as well as more structured types such as finite sets, sequences, and tuples. The constants of and functions and relations on the model types provide the vocabulary for writing first order predicate logic pre- and post-conditions. These conditions describe, respectively, sufficient conditions for the specified procedure to execute correctly, and what is guaranteed to be true when the procedure terminates correctly. In other words, the pre-condition describes what must be true of the pre-state (the program state just before the specified procedure\nis called) for the procedure to execute correctly, and the post-condition describes the post-state resulting from the execution of the procedure. Hence, execution of such specifications corresponds to finding post-state values that satisfy the post-condition.\n\nThe execution technique described in the next section was developed in the context of the specification language SPECS-C++ [WBL94], which is a formal and model-based language specialized for specifying the interfaces of C++ classes [Str91]. However, the execution technique is equally applicable to other model-based specification languages, as it depends only on first order assertions over a fixed set of model types. In fact, the addition of C++ specific features only complicates the execution of specifications. These features include classes, objects, and inheritance. Of these, only objects are discussed in this paper.\n\nObject types are used in SPECS-C++ to model aliasing and mutation at the specification level. In this context, an object is a container for a value. Objects are the same as locations in denotational semantics [Sch86]. Mutation occurs when the value held by an object changes from the pre-state to the post-state. Aliasing means that an object can have multiple names, such as an element of a sequence and a field of a tuple. That is, the expressions \\texttt{index(S, 2)} and \\texttt{count(T)}, where \\texttt{S} is a sequence of objects and \\texttt{T} is of a tuple type that has a field \\texttt{count} of an object type, can denote the same object. If the value of this object is changed (mutated), evaluating either of these expressions will return the new value. Specification languages such as VDM and Z allow the specifier to distinguish between pre-state and post-state values, but do not have a complete and uniform theory of objects, and do not allow the detection or specification of aliasing. However, aliasing is characteristic of C++ programs, and the ability to fully specify aliasing is vital in writing practical specifications of C++ classes.\n\nThus, objects (and constraints on objects) are a complication in executing SPECS-C++ that is not found in Prolog III or CLP(R). Other domains in SPECS-C++ that are not typically found in CLP languages include integers, sets, sequences, and tuples. In the case of integers, the cause of this omission is most likely that the truth value of first order predicate logic assertions over integers is undecidable [Kle52]. However, as integers are a domain of SPECS-C++ (and VDM and Z), we want to handle a subset of assertions that explicitly involve integer variables in executing\nspecifications. The other domains of SPECS-C++ can be implemented by trees, and this is likely why they have not been included as separate domains in CLP languages.\n\nAs CLP languages are typically untyped, they can not use type information as such in solving constraints. However, this information can be useful in constructing values that satisfy constraints. For example, knowing that a value has a particular tuple type gives both the number and type of the fields of the tuple. In languages such as SPECS-C++ that use union (alternative) types, type information also allows sensible backtracking when type errors occur.\n\nAnother important difference between SPECS-C++ specifications and CLP programs is that CLP programs consist of rules with a simple structure, while SPECS-C++ specifications use first-order predicate logic syntax (including explicit quantifiers). In the case of Prolog III, the constraints are even explicitly separated from the rest of the program. From an execution standpoint, this means that any attempt to apply CLP techniques to executing specifications must start with some way of extracting constraints from specifications.\n\n5.4 Executing Model-Based Specifications\n\nThe execution of a SPECS-C++ procedure specification is simply the execution of a call to that procedure. Executing the call has two steps.\n\n1. Check that the pre-state and actual arguments satisfy the pre-condition.\n\n2. Construct post-state values that satisfy the post-condition.\n\nEvaluating the pre-condition is relatively easy, as all the values involved are known, and in the executable subset of SPECS-C++, all quantified variables must range over a finite (and explicit) domain. Thus, the pre-condition is simply evaluated for its boolean value. On the other hand, the execution of post-conditions is much more complicated, and it is here that CLP-like techniques are helpful.\n\nA summary of the algorithm for satisfying post-condition assertions is summarized in Figure 5.1. The algorithm is based on iteratively transforming parts of the post-condition into constraints, and then solving those constraints into post-state values. As more (parts of) post-state values become known, parts of the post-condition\nwhile part of the post-condition remains do:\n - generate constraints:\n * transform some parts of the post-condition into constraints, and remove these parts from future consideration\n * directly evaluate some parts of the post-condition, and remove these parts from future consideration\n * delay any remaining parts of the post-condition until future iterations\n - solve constraints:\n * solve any constraints that are currently solvable\n * delay other constraints until future iterations\n\n• solve any remaining constraints\n• apply implicit frame axioms (SPECS-C++ only)\n• return the post-state values found\n\nFigure 5.1: The algorithm for satisfying post-conditions.\nthat refer to those values can be evaluated or transformed into constraints. After all of the post-condition has been transformed into constraints or directly evaluated, the post-state values found are returned. The algorithm is explained in more detail in the following discussion.\n\n5.4.1 Conversion of the Post-condition to Constraints\n\nThe first step in understanding the execution of post-conditions is understanding the observers\\(^2\\) of the built-in model types, as these observers form the basis of constraints. The basic observer of all types is equality (\\(=\\)). The only additional observer of tuples is the field function – i.e. the extraction of a given field from the tuple. For objects, the observers are the postfix functions \\(\\cdot\\) and \\(\\cdot\\), which, respectively, extract the pre- and post-state values of an object. The observers of sets are member, subset, and size (cardinality). Besides the natural length, member, and (1-based) index functions on sequences, SPECS-C++ defines additional sequence functions as follows, where \\(<\\>\\) is sequence constructor notation, and \\(\\|\\) is used for appending sequences:\n\n\\[\n\\begin{align*}\n\\text{first}(\\langle a\\rangle \\| s) & = a \\\\\n\\text{last}(s \\| \\langle c\\rangle) & = c \\\\\n\\text{header}(s \\| \\langle c\\rangle) & = s \\\\\n\\text{trailer}(\\langle a\\rangle \\| s) & = s\n\\end{align*}\n\\]\n\nGiven these definitions, each constraint has one of the following forms:\n\n\\[\n\\begin{align*}\n\\text{val member } lhs \\\\\n\\text{val subset } lhs \\\\\nlhs & = \\text{val} \\\\\n\\text{length}(lhs) & = \\text{val} \\\\\n\\text{size}(lhs) & = \\text{val}\n\\end{align*}\n\\]\n\nwhere \\(\\text{val}\\) is a total value. Total values will be defined precisely in Section 5.4.2, but roughly they are values that are completely known. An \\(lhs\\) is an expression denoting a post-state value or part of a post-state value, and has one of the following forms:\n\n\\(^2\\)Observers are functions that, when applied to a value of the appropriate type, allow one to \"look at\" some aspect of the value.\n\\text{ident} \\\\\n\\text{lhs}' \\\\\n\\text{field(field-name, lhs)} \\\\\n\\text{index(lhs, val)} \\\\\n\\text{first(lhs)} \\\\\n\\text{last(lhs)} \\\\\n\\text{header(lhs)} \\\\\n\\text{trailer(lhs)}\n\nwhere \\text{ident} denotes a variable name, and \\text{field-name} is just the name of a field of some tuple type. Constraints are further restricted by typing (as not every expression of the form given is correctly typed), and by the exclusion of \\text{member} constraints whose \\text{lhs} is of type sequence. Note that the only arithmetic constraints are of the form \\text{x} = \\text{val}, where \\text{val} can be directly evaluated into a number. Thus, the execution technique does minimal numerical constraint solving, and this is an area where existing CLP techniques could be used to advantage.\n\nTo simplify finding post-state values, the post-condition is transformed into a set of constraints. These constraints can then be solved without reference to the structure of the post-condition. To ensure that this process produces post-state values that satisfy the post-condition, this transformation must have the property that if the set of post-state values produced satisfy the constraints, then these post-state values satisfy the post-condition. To show how this property is achieved, we develop the constraint generation algorithm by induction on the structure of post-condition assertions. The basis of this induction is atomic formulas (in the sense of logic programming), which are handled in one of three ways.\n\n- The atomic formula can be converted to a constraint. For this to occur, the atomic formula must have the form of a constraint, except that a term appears where \\text{val} appears in the grammar for constraints. This term can only refer to pre-state values and the known parts of post-state values, so that it can be directly evaluated into a total value. The constraint is generated and this atomic formula need not be processed further.\nvoid abs(int& x);\npre: true\nmodifies: x\npost: \\((x^- \\geq 0 \\land x' = x^-) \\lor (x^- < 0 \\land x' = -x^-)\\)\n\nFigure 5.2: The specification of an absolute value procedure. Type int& is the type of objects containing integers.\n\n- The truth value of the atomic formula can be determined from the values that are currently known. If the atomic formula is true, it need not be processed further. If it is false, backtracking occurs.\n\n- Otherwise, processing of the atomic formula is delayed until after the current set of constraints has been solved into post-state values. Thus, processing of the post-condition is an iterative procedure, and continues until either the entire post-condition has been used up or until no new constraints can be generated.\n\nThe induction steps of constraint generation handle the boolean connectives and universal and existential quantifiers. For example, conjuncts can be considered separately as all must hold for the post-condition to hold. Each disjunct is first checked to see if it is false using a nonstrict evaluation procedure. For example, in the natural specification of an absolute value procedure of Figure 5.2, any pre-state value of x makes one disjunct of the post-condition false, and this disjunct can simply be discarded. (Recall that \\( ^- \\) and \\( ^' \\) are postfix functions for extracting the pre- and post-state values of an object, respectively.) If multiple disjuncts are not false, then one is chosen and a backtrack point is created so that the execution procedure can return and try one of the remaining disjuncts if the current choice fails.\n\nLogical implications are handled similarly, except that the execution procedure tries to determine the truth or falsity of the antecedent first. Specifiers rarely write logical implications whose antecedents refer to post-state values, so this attempt is\nusually successful, and allows easy and efficient processing of implications. If the antecedent can be determined to be true, then it can be discarded and the consequent processed recursively. On the other hand, if the antecedent is false, then the entire implication can be discarded. If no determination can be made, then both the antecedent and consequent are assumed to be true, and a backtrack point is created so that the execution procedure can return and try the assumption that the antecedent is false.\n\nNegated assertions are never transformed into constraints. Instead, they are delayed until sufficient post-state values are known to allow them to be evaluated directly. When this occurs, if the negated assertion is satisfied, then it is discarded and constraint generation proceeds. If it is not satisfied, backtracking occurs. If any delayed assertions remain and no more constraints can be generated (so this holds for atomic formulas as well), then the execution algorithm reports that it can not execute the post-condition.\n\nQuantified assertions can only be evaluated if the domain that the bound variable ranges over is known and finite, and if the body of the quantified assertion can be evaluated either for its boolean value or into constraints. Thus, evaluation of quantified assertions is delayed until this occurs. When a universally quantified assertion is evaluated or transformed into constraints, its body is evaluated once for each element of the domain, with the quantifier variable bound to each element in turn, so that every element of the domain is used in generating constraints. For existentially quantified assertions, the execution technique finds some element of the domain, that, when used as the value of the bound variable, does not make the body of the assertion false. This is checked using the procedure that is used for disjuncts. If multiple elements of the domain satisfy this property, then a backtrack point is created so that each satisfying element can be tried if necessary. Then, constraints are generated from the body of the assertion with the quantifier variable bound to.\n\n---\n\n3 Thus, the bound variable is somewhat like a domain variable in the CLP language CHIP [Van89] in that it ranges over a known and finite domain. However, our use of bound variables is quite different from the use of domain variables in CHIP. Domain variables are still logical variables, and thus are used in unification rather than in generating constraints.\nvoid sort(seqint& si);\n pre: noDups(si) // noDups returns true if sequence has no duplicates\n modifies: si\n post: \\forall int x \\in si \\Rightarrow\n \\exists int i [1 <= i <= length(si) \\& \\&\n index(si', i) = x] \\& \\&\n \\forall int i [2 <= i <= length(si') \\Rightarrow\n index(si', i - 1) < index(si', i)]\\&\\&\n length(si') = length(si)\n\nFigure 5.3: The specification of a sort procedure. Here, seqint is the type of sequences of integers.\n\nthe chosen element of the domain.\n\nFor example, consider the specification of a procedure for sorting sequences of Figure 5.3. The first and third conjuncts can immediately be converted to constraints, but the second can only be evaluated after a post-state value for si has been found. Note that there are many possible constraint sets that can be produced, and so a great deal of backtracking can occur. For example, if the pre-state value of si is <3, 2, 1>, then one possible constraint set is:\n\n\\{index(si', 1) = 3, index(si', 1) = 2, index(si', 1) = 1, length(si') = 3\\}\n\nwhich clearly has no solution. Another possibility is:\n\n\\{index(si', 1) = 3, index(si', 2) = 2, index(si', 3) = 1, length(si') = 3\\}\n\nwhich has a solution, but that solution does not satisfy the second conjunct of the post-condition. In either case, backtracking will occur.\n5.4.2 Solving Constraints into Post-state Values\n\nAfter a set of constraints has been generated from the post-condition, they are solved into partial post-state values. These values are partial because many constraints yield only part of a post-state value. For example, the constraint:\n\n\\[ \\text{index}(s', 3) = 2 \\]\n\ndefines only one index position in the sequence \\( s' \\) and does not constrain the total length of the sequence (other than to set a lower bound of three). Thus, a partial sequence value is a prefix of the total value which can also contain partial values. Thus, partial sequences are similar to improper lists in Prolog III. Partial tuple values are simply tuples with one or more fields containing partial values. Similarly, partial object values are objects containing partial values. Finally, partial set values are simply subsets of the total value. Sets are not allowed to contain partial values because there is no way to refer to a set element that is independent of the value of that element. An element of a sequence can always be retrieved if one knows nothing more about it than its index position, but there is no analogous way to retrieve set elements. Thus, if a partial value is contained in a set, there is no way to use constraints to further define that element.\n\nAs the execution procedure is iterative, on each iteration after the first the procedure may need to evaluate expressions involving partial values. Let \\( \\text{undef} \\) denote the completely undefined (unconstrained) value. Equality checking of partial values uses the following rule: for any value \\( v \\) (including \\( \\text{undef} \\)), the value of \\( v = \\text{undef} \\) is \\( \\text{undef} \\). The evaluation of tuple and object observers is straightforward, as they are allowed to return partial values, and return \\( \\text{undef} \\) when applied to \\( \\text{undef} \\). For example, let \\( (\"first\" \\ 2, \"second\" \\ \\text{undef}) \\) be a tuple with fields \"first\" and \"second\" with the indicated values for each field. Then, the value of \\( \\text{field}(\"first\", (\"first\" \\ 2, \"second\" \\ \\text{undef})) \\) is 2, and the value of \\( \\text{field}(\"second\", (\"first\" \\ 2, \"second\" \\ \\text{undef})) \\) is \\( \\text{undef} \\).\n\nFor partial sets and sequences, the situation is more complex. Let \\( S_{\\text{undef}} \\) denote a set or sequence of unknown size or length, and \\( S_n \\) denote a set or sequence of size or length \\( n \\). For example, \\( \\{1, 3, 5\\}_{10} \\) is a set of size 10 containing \\( \\{1, 3, 5\\} \\) as a subset. Given this notation, the operations on partial set values are summarized...\nin Table 5.1, and the operations on partial sequences in Table 5.2. In the table, the result of dropping the subscript of a partial set value is the defined subset of the partial set considered as a total set value. The result of dropping the subscript of a partial sequence value is the defined prefix of the total sequence value, which can of course still contain partial values. To distinguish these prefix values from total values, the names of SPECS-C++ sequence operators will be italicized when they are applied to prefix values, and \\texttt{app} will be used to denote appending of these values. Cases where one or more arguments are \\texttt{undef} are omitted, as the result is always \\texttt{undef}. In particular, the \\texttt{size (length)} of a partial set (sequence) value is \\texttt{undef} unless it has been defined by a previous \\texttt{size (length)} constraint, as described later in this section. Note that partial values also complicate set difference (denoted by \\texttt{-}), as care must be taken to ensure that any partial set value returned is in fact a subset of any possible total-valued arguments. Thus, if the second argument is partial, the result is always \\texttt{undef}.\n\nThus, the problem of constraint solving in this context comes down to using a constraint to further define a partial value. The \\texttt{lhs} part of the constraint is used to find the appropriate partial value by name, and part of the \\texttt{lhs} may be used to navigate within that partial value find the part of the value that the constraint constrains. The rest of the observers appearing in the \\texttt{lhs} are “used backwards” to help in further defining a partial value. For example, given the constraint \\texttt{field(\"foo\", first(result)) = 3, sequence(tuple(int \"foo\", float \"bar\"))} as the type of \\texttt{result}, and a previous partial value of:\n\\texttt{<undef, (\"foo\" 7, \"bar\" 6.3)>undef}\nfor \\texttt{result}, \\texttt{first} is applied to this partial value, yielding \\texttt{undef}. Next, the inverse of the \\texttt{field} function is used to solve the constraint \\texttt{field(\"foo\", result) = 3} with \\texttt{undef} as the previous partial value for \\texttt{result}. This gives the value:\n\\texttt{(\"foo\" 3, \"bar\" undef)}\nNote that knowing the type of the tuple involved makes inverting the \\texttt{field} function possible. Finally, this value is put back into the original partial value for \\texttt{result}, yielding:\n\\texttt{<(\"foo\" 3, \"bar\" undef), (\"foo\" 7, \"bar\" 6.3)>undef}\nTable 5.1: Some set operations over partial values. Here, * is either undef or a non-negative integer, \\( n \\) is a non-negative integer, and \\( x \\) is not undef.\n\n<table>\n<thead>\n<tr>\n<th>Operation</th>\n<th>Argument</th>\n<th>Argument</th>\n<th>Result</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>size</td>\n<td>( S_{\\text{undef}} )</td>\n<td>( S_n )</td>\n<td>undef</td>\n</tr>\n</tbody>\n</table>\n| member | \\( x \\) | \\( S^* \\) | \\{ true if \\( x \\in S \\) \n| | | | undef otherwise |\n| subset | \\( S_1 \\) | \\( S_2^* \\) | \\{ true if \\( S_1 \\subseteq S_2 \\) \n| | | | undef otherwise |\n| subset | \\( S_1^* \\) | \\( S_2^* \\) | undef |\n| subset | \\( S_1^* \\) | \\( S_2 \\) | \\{ false if \\( \\neg (S_1 \\subseteq S_2) \\) \n| | | | undef otherwise |\n| union | \\( S_1^* \\) | \\( S_2^* \\) | \\( (S_1 \\cup S_2)_{\\text{undef}} \\) |\n| union | \\( S_1 \\) | \\( S_2^* \\) | \\( (S_1 \\cup S_2)_{\\text{undef}} \\) |\n| union | \\( S_1^* \\) | \\( S_2 \\) | \\( (S_1 \\cup S_2)_{\\text{undef}} \\) |\n| intersection | \\( S_1^* \\) | \\( S_2^* \\) | \\( (S_1 \\cap S_2)_{\\text{undef}} \\) |\n| intersection | \\( S_1 \\) | \\( S_2^* \\) | \\( (S_1 \\cap S_2)_{\\text{undef}} \\) |\n| intersection | \\( S_1^* \\) | \\( S_2 \\) | \\( (S_1 \\cap S_2)_{\\text{undef}} \\) |\n| - (set difference) | \\( S_1 \\) | \\( S_2^* \\) | undef |\n| - (set difference) | \\( S_1^* \\) | \\( S_2^* \\) | undef |\n| - (set difference) | \\( S_1^* \\) | \\( S_2 \\) | \\( (S_1 - S_2)_{\\text{undef}} \\) |\nTable 5.2: Some sequence operations over partial values. Here, * is either undef or a non-negative integer, and \\( n, m, \\) and \\( i \\) are non-negative integers. The notation \\( \\text{undef}^l \\) means a comma separated list of \\( \\text{undef} \\)'s of length \\( l \\).\n\n<table>\n<thead>\n<tr>\n<th>Operation</th>\n<th>Argument</th>\n<th>Argument</th>\n<th>Result</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>length</td>\n<td>( S \\text{undef} )</td>\n<td>undefined</td>\n<td>( n )</td>\n</tr>\n<tr>\n<td>length</td>\n<td>( S_n )</td>\n<td>( i )</td>\n<td>\\begin{align*} \\text{undef} & \\quad \\text{if } i > \\text{length}(S) \\ \\text{index}(S, i) & \\quad \\text{otherwise} \\end{align*}</td>\n</tr>\n<tr>\n<td>index</td>\n<td>( S \\text{undef} )</td>\n<td>( i )</td>\n<td>\\begin{align*} \\text{error} & \\quad \\text{if } i > n \\ \\text{undef} & \\quad \\text{if } \\text{length}(S) < i \\leq n \\ \\text{index}(S, i) & \\quad \\text{otherwise} \\end{align*}</td>\n</tr>\n<tr>\n<td>header</td>\n<td>( S \\text{undef} )</td>\n<td></td>\n<td>( \\text{(header}(S)\\text{)} \\text{undef} )</td>\n</tr>\n<tr>\n<td>header</td>\n<td>( S_n )</td>\n<td></td>\n<td>\\begin{align*} \\text{(header}(S)\\text{)}<em>{n-1} & \\quad \\text{if } \\text{length}(S) = n \\ S</em>{n-1} & \\quad \\text{otherwise} \\end{align*}</td>\n</tr>\n<tr>\n<td>first</td>\n<td>( S \\text{undef} )</td>\n<td></td>\n<td>\\begin{align*} \\text{undef} & \\quad \\text{if } \\text{length}(S) = 0 \\ \\text{first}(S) & \\quad \\text{otherwise} \\end{align*}</td>\n</tr>\n<tr>\n<td>first</td>\n<td>( S_n )</td>\n<td></td>\n<td>\\begin{align*} \\text{error} & \\quad \\text{if } n = 0 \\ \\text{undef} & \\quad \\text{if } \\text{length}(S) = 0 \\land n \\neq 0 \\ \\text{first}(S) & \\quad \\text{otherwise} \\end{align*}</td>\n</tr>\n<tr>\n<td>trailer</td>\n<td>( S \\text{undef} )</td>\n<td></td>\n<td>\\begin{align*} \\text{Sundef} & \\quad \\text{if } \\text{length}(S) = 0 \\ \\text{(trailer}(S)\\text{)} \\text{undef} & \\quad \\text{otherwise} \\end{align*}</td>\n</tr>\n<tr>\n<td>trailer</td>\n<td>( S_n )</td>\n<td></td>\n<td>\\begin{align*} \\text{error} & \\quad \\text{if } n = 0 \\ S_{n-1} & \\quad \\text{if } \\text{length}(S) = 0 \\land n \\neq 0 \\ \\text{(trailer}(S)\\text{)}_{n-1} & \\quad \\text{otherwise} \\end{align*}</td>\n</tr>\n<tr>\n<td>last</td>\n<td>( S \\text{undef} )</td>\n<td></td>\n<td>undefined</td>\n</tr>\n<tr>\n<td>last</td>\n<td>( S_n )</td>\n<td></td>\n<td>\\begin{align*} \\text{error} & \\quad \\text{if } n = 0 \\ \\text{last}(S) & \\quad \\text{if } \\text{length}(S) = n \\land n \\neq 0 \\ \\text{undef} & \\quad \\text{otherwise} \\end{align*}</td>\n</tr>\n<tr>\n<td>(</td>\n<td></td>\n<td>)</td>\n<td>( S \\text{undef} )</td>\n</tr>\n<tr>\n<td>(</td>\n<td></td>\n<td>)</td>\n<td>( S \\text{undef} )</td>\n</tr>\n<tr>\n<td>(</td>\n<td></td>\n<td>)</td>\n<td>( S_n )</td>\n</tr>\n<tr>\n<td>(</td>\n<td></td>\n<td>)</td>\n<td>( S_n )</td>\n</tr>\n<tr>\n<td>(</td>\n<td></td>\n<td>)</td>\n<td>( S_n )</td>\n</tr>\n<tr>\n<td>(</td>\n<td></td>\n<td>)</td>\n<td>( S_1 )</td>\n</tr>\n<tr>\n<td>(</td>\n<td></td>\n<td>)</td>\n<td>( S_1 )</td>\n</tr>\n</tbody>\n</table>\nSo, the process of constraint solving can be summarized as follows: starting from the innermost observer in the \\( Ihs \\), apply the observers to the previous partial value (and then to the result of the previous application) until some application yields \\text{undef} \\), a partial set value, or in some cases a partial sequence value. Then, use the inverses of rest of the observers to further define the partial value found in the previous step. Finally, replace the partial value from the first step with this more defined (but still possibly partial) value in the original partial value. The keys to the correctness of this kind of constraint solving are that the (partial) value produced must satisfy the constraint, and that the value produced must also satisfy all previous constraints used to define that value. In order to maintain this second property, the constraint solver can never remove an element from the defined subset of a partial set value, and can never change any defined parts of partial sequence, tuple, and object values. Of course, backtracking can result in this property being violated. However, the property must hold for any successful execution path.\n\nAs the inverses of the observers are not functions, applying these inverses often gives a partial value that represents a (possibly infinite) set of total values. For example, consider the constraint \\( \\text{header}(\\text{result}) = <3> \\) with \\text{undef} as the previous partial value for result. Applying the inverse of header yields \\( <3>^2 \\) as the value of result, which represents the infinite set of sequences of integers of length 2 whose first element is 3. The inverse of \\( \\text{trailer} \\) is analogous. And, of course, the inverse of \\( \\text{index} \\) depends on its integer argument. For example, solving the constraint \\( \\text{index}(\\text{result}, 3) = 4 \\) with \\text{undef} as the previous partial value for \\text{result} gives \\( <\\text{undef}, \\text{undef}, 4>_{\\text{undef}} \\). Figure 5.7 demonstrates the use of the inverses of all three of these observers.\n\nWhile the \\( Ihs \\) is used in the same way for any kind of constraint in constraint solving, the actual (partial) value produced depends on whether the constraint is a length, size, member, subset, or = constraint. (See Section 5.4.1 for a discussion of the kinds of constraints.) The length and size constraints on sequences and sets, respectively, cause the appropriate partial set or sequence value to become total when it grows to the size given in the constraint. Note that sequences can still contain partial values, even when the total size of the sequence is known. Knowing the length of partial sequence values is significant because constraints whose \\( Ihs \\) uses\nlast can not be applied until the length of the constrained sequence is known. For example, a constraint like field(\"ord\", last(seqOrderedPair')) = 3 is delayed until the length of seqOrderedPair' is known. If this length never becomes known, the execution procedure assumes that the current length of the sequence is its total length (unless it has length zero) and attempts to apply any last constraints. If this fails (because the last element of the defined prefix is inconsistent with the constraint), then the execution procedure backtracks and assumes that the total length of the sequence is one greater than its current length. This guarantees that the constraint can be solved (if it has the correct type), because no previous constraints have constrained anything outside the defined prefix of the partial sequence value. Knowing whether a set value is partial or total is important in determining how to solve member and subset constraints on that value, as described next.\n\nThe solving of the member and subset constraints depends on whether they constrain total or partial set values. In the first case, the complete set value is already known, and so the execution technique need only check that the constraint is consistent with that value in the obvious way. Otherwise, the partial set value is further defined by unioning it with the singleton set constructed from the value in the constraint for member constraints, or by unioning it with the set value contained in the constraint for subset constraints. This latter case can cause the partial set value to become larger than the size specified by a previous size constraint, and so backtracking can occur. Since solving either member or subset constraints can cause the defined subset of a partial set value to grow, either can cause this partial set value to become total if its size is known.\n\nAs = constraints directly define (part of a) value, all that need be done is to check that any partial value constructed so far is consistent with the value given by the constraint. For example, if the current (partial) value for $S'$ is $<1, \\text{undef}, 3>$ and the constraint being applied is $S' = <1, 5, 3, 7>$, the partial value and the constraint are consistent, and the value of $S'$ becomes completely known. If this consistency check fails, backtracking occurs.\n\nIn the presence of aliasing, two constraints with completely different lhs's might constrain the same value. To account for this, values contained in objects must be manipulated indirectly, so that any change is visible everywhere that the object\noccurs. For example, suppose that \\( x \\) and \\( y \\) denote the same object. Then the post-condition \\( x' = 3 \\land y' = 4 \\) is unsatisfiable, and the execution technique should report an error. In executing this post-condition, the constraints \\( x' = 3 \\) and \\( y' = 4 \\) are generated. Whichever is solved first gives a total post-state value for the object, and so attempting to solve the second constraint causes an error, as the post-state value proposed for the object is inconsistent with the value it already has.\n\nIf a type error occurs while solving constraints, the execution procedure backtracks on the chance that the use of a union type has created a backtrack point earlier in the execution. For example, given the partial value\n\n\\[\n<(\"fst\" \\ 2, \"snd\" \\ undef), \\ undef>_{5}\n\\]\n\nas the current post-state value for \\( \\text{seqTuple} \\), trying to apply the constraint\n\n\\[\n\\text{field(\"thrd\", index(seqTuple', 4)) = 7}\n\\]\n\ncauses a type error, and backtracking occurs. This backtracking has a chance of succeeding, for example, if \\( \\text{seqTuple'} \\) is of a union type where one type in the union is a tuple type with \"\\( \\text{fst} \\)\" and \"\\( \\text{snd} \\)\" fields, and another type in the union is a tuple type with \"\\( \\text{fst} \\)\", \"\\( \\text{snd} \\)\", and \"\\( \\text{thrd} \\)\" fields. In this case, the first appearance of a constraint on a value of the union type would create a backtrack point that would allow all the types in the union to be tried if necessary.\n\nFinally, if some parts of post-state object, sequence, or tuple values remain undefined after all constraints have been generated and applied, then the frame axioms of SPECS-C++ imply that these parts should be whatever they were in the pre-state. Roughly speaking, frame axioms are used to ensure that no part of the state changes unless it must change to satisfy the post-condition. Thus, when a pre-state value exists and the corresponding post-state value is partial after all constraints have been applied, then the missing parts of the post-state value are \"filled in\" with the corresponding parts of the pre-state value. For sequences, this means that the length of the sequence and the value contained at any index position does not change from the pre- to the post-state unless the post-condition forces change. For tuples, each field does not change from the pre- to the post-state unless forced to. Similarly, the value contained in an object does not change unless mandated by the post-condition.\nint operator++(int& x);\n modifies x\n post: x' = x'' + 1 \\(\\land\\) result = x'\n\nFigure 5.4: The specification of a pre-increment function. The SPECS-C++ keyword result is used to refer to the result of the function.\n\nAfter applying the frame axioms, set and sequence values that are still partial are made total, except that sequences are still allowed to contain partial values. At this point, it may be possible to generate further constraints from the delayed portions of the post-condition, so the execution procedure iterates. The execution algorithm may return partial tuple, sequence, and object values if no corresponding pre-state value exists. As most model-based specification languages do not have implicit frame axioms, this step would be omitted in executing such languages.\n\n5.4.3 Examples\n\nFigure 5.4 shows a specification of the built-in C and C++ prefix increment function. The first conjunct of the post-condition is immediately evaluated into a constraint. Both sides of the = in the second conjunct are unknown, so it is delayed. After the constraint derived from the first conjunct has been solved, the value of x' is known, and so the second conjunct can be evaluated into a constraint, which is then solved to give a value to result.\n\nConsider the specification of a sorting procedure of Figure 5.5. This example is similar to that presented in Figure 5.3, except that this sorting procedure allows duplicates in the sequence to be sorted, and also uses the abstract functions sorted, count, and sameCountAs to modularize and to improve the readability of the specification. In the execution of the post-condition, the first and second conjuncts produce constraints that are solved into a sequence that contains the same elements as the pre-state value of si. The third and fourth conjuncts are then evaluated over that\ndefine sorted(seqint s) as bool s.t.\n sorted(s) = \\forall int i [1 <= i <= length(s) =>\n index(s, i - 1) <= index(s, i)]\n\ndefine count(int i, seqint s) as int s.t.\n (s = <> => count(i, s) = 0)\n \\forall (s != <> =>\n ((first(s) = i => count(i, s) = 1 + count(i, trailer(s)))\n \\forall (first(s) != i => count(i, s) = count(i, trailer(s))))))\n\ndefine sameCountAs(seqint s1, s2) as bool s.t.\n \\forall int x [x member s2 => count(x, s2) = count(x, s1)]\n\nvoid sort(seqint& si);\n modifies: si\n post: \\forall int x [x member si^- =>\n \\exists int i [1 <= i <= length(si^-) \\forall\n index(si', i) = x]]\n \\forall length(si') = length(si^-)\n \\forall sorted(si')\n \\forall sameCountAs(s^-, s')\n\nFigure 5.5: The specification of a sort procedure that can handle duplicates. Here, seqint is again the type of sequences of integers.\nInt_Set RelTo(Relation theRel, int key);\npre: \\exists (OrderedPair p) [ (p \\in theRel) \\& field(\"first\", p) = key]\npost: \\forall (OrderedPair p) [ (p \\in theRel) \\& field(\"first\", p) = key =>\nfield(\"second\", p) \\in result ] \\&\n\\forall (int i)\n(i \\in result) =>\n\\exists (OrderedPair p) [ (p \\in theRel) \\& i = field(\"second\", p) \\&\nkey = field(\"first\", p)]\n\nFigure 5.6: The specification of a \"related to\" function for relations. Relations are modeled as sets of OrderedPairs, and OrderedPairs are tuples with \"first\" and \"second\" fields. Int_Set is the type of sets of integers.\n\nsequence to check that it is a permutation of the pre-state value of si and that it is sorted. If so, then the execution is complete. Otherwise, the execution procedure backtracks and a different sequence is tried. Note that the order of the conjuncts does not matter to the execution procedure, as the calls of sorted and sameCountAs are delayed until a total value for si' has been found.\n\nFigure 5.6 is the specification of a function that returns everything in an integer relation that is related to the integer argument key. The pre-condition specifies that something must be related to key. The first conjunct of the post-condition is immediately evaluated into constraints, and these constraints are solved into a partial value for result. As this value is partial, the second conjunct can not be evaluated, and so no more constraints can be found. Next, the SPECS-C++ frame axioms are applied to the partial value for result. For sets, this just results in the partial value being made total. This allows the second conjunct of the post-condition to be\nseqint constrainseq();\npost: index(header(header(trailer(trailer(result))))), 2) = 3\n\nFigure 5.7: A specification that produces only one constraint on result. Type seqint is the type of sequences of integers.\n\nevaluated, and it is satisfied as the execution procedure does not put any \"extra\" elements into the value of result.\n\nFinally, the example of Figure 5.7 demonstrates the potential complexity of constraints and the amount of information that can be derived from such constraints. The post-condition is in the form of a constraint, and so is immediately evaluated into one. This constraint is solved into the following partial sequence value.\n\n<undef, undef, undef, 3, undef, undef>^Q^jef\n\nNote that the partial sequence value has two trailing undeFs. This represents the knowledge (derived from the constraint) that the total sequence must have a length of at least six, as the lhs could not be applied to any shorter sequence. However, no unnecessary undeFs are added. Whenever the execution technique is able to find a post-state set or sequence value, it always produces the smallest sequence or set value that satisfies both the post-condition and the frame axioms.\n\n5.4.4 Comments on the Implementation\n\nThe execution procedure is currently implemented as an interpreter for SPECS-C++ specifications. The interpreter uses an abstract syntax for SPECS-C++ that is basically a parse tree representation of the concrete syntax presented in the examples. The interpreter consists of 2800 lines of Standard ML [Pau91] code, and was written with the aid of the literate programming tool Noweb [Ram91]. Backtracking is implemented via continuations. As in denotational semantics [Sch86], state is im-\nimplemented via a store that is passed to and returned from all functions that modify the state.\n\n5.4.5 Performance\n\nThe performance of the execution algorithm depends on the structure of the pre- and post-conditions of the operation being executed and on the pre-state values involved. As pre-conditions are just evaluated for their boolean value, all that is involved is evaluating assertions. In executing post-conditions, some parts of the post-condition are just evaluated, while other parts are used in generating constraints. Hence, the time needed for generating and solving constraints must also be considered.\n\nThe time used for directly evaluating assertions is polynomial in the size of the values involved in the assertion, as the algorithms implementing the most expensive of the built-in SPECS-C++ operations (union, intersection, difference, subset) are $O(n^2)$ for sets of size $n$. The time for executing abstract and member function calls in assertions is just the time for evaluating the arguments and the time for evaluating the function body. As the body of a quantified assertion is potentially executed once for each element of the domain quantified over, the execution time is linear in the size of that domain, and polynomial in the number of nested quantifiers. Otherwise, the evaluation is linear in the number of other boolean connectives.\n\nThe time needed generating constraints is largely determined by how much backtracking occurs, and so is exponential in the worst case. (Actually, backtracking can occur both in generating and in solving constraints. The time used in backtracking is included in the time for generating constraints because almost all of the backtrack points, i.e. the points in the execution that can be \"backtracked to\", are created in constraint generation. The only other backtrack points are created in constraint solving for solving constraints over union types and a few forms of constraints on sequences.) Because of backtracking, the time needed for generating constraints is exponential in the number of disjunctions and implications in the post-condition, as well as in the size of the domain of each existentially quantified assertion. As no backtrack points are created in generating constraints from universally quantified assertions, the time needed is just linear in the size of the domain quantified over.\nAs in evaluating assertions, the time for generating constraints is polynomial in the depth of nested quantifiers. Finally, the execution time is linear in the number of other boolean connectives. If, as often happens in executing specifications, no backtracking occurs in generating constraints, then the execution time is just linear in the number of disjuncts and implications, and linear in the size of the domain of existentially quantified assertions.\n\nThe time for solving constraints depends on the number of constraints, the kind of constraint (\\(=, \\text{member}, \\text{subset}, \\ldots\\)), and the structure of the \\(lhs\\) of the constraint, but is polynomial in the number of constraints in the worst case. Redundant constraints impose the overhead of consistency checking with the partial value so far constructed. As the time used for consistency checking is generally less than that for constraint solving, we concentrate on the time for solving constraints. Ignoring for the moment the time cost imposed by the structure of the \\(lhs\\), a \\(=\\) constraint can be solved in constant time, as the value needed is contained directly in the constraint. Assuming that the size of the \\(val\\) part of all subset constraints is bounded by some small constant, the time for solving member and subset constraints is linear in the number of member and subset constraints that constrain the same set value, as the number of these constraints bounds the size of the set produced, and the constraint solver checks for duplicate elements in producing set values. Thus, the total time for solving the \\(n\\) member and subset constraints that constrain a single set value is \\(O(n^2)\\).\n\nThe time cost imposed by the structure of the \\(lhs\\) depends on the number and kind of observers it contains. The most expensive observer is index, as it requires either navigating within the partially defined sequence value, or allocating new index positions for that value. Either operation is directly proportional to the index of the position constrained. If a sequence value is completely constrained by \\(n\\) constraints with index in the \\(lhs\\), then the maximum length of the sequence is \\(n\\). Hence, for a constraint with \\(m\\) observers, the maximum time is \\(O(mn)\\). As there are \\(n\\) constraints, the total maximum time for solving these constraints is \\(O(mn^2)\\). As the number of constraints is typically much greater than the number of observers appearing in any \\(lhs\\), \\(O(n^2)\\) is a fair upper bound. Combining this with the time needed to solve a constraint without considering the structure of the \\(lhs\\), the maximum time for solving\na set of $n$ constraints is $O(n^3)$. Note, however, that this worst case only applies to solving constraints on values that are sequences of sets, as only such values can be specified by `member` constraints with `index` appearing in the `lhs`. For values of other types, the worst case time for constraint solving is $O(n^2)$.\n\nIn general then, for post-conditions that force a great deal of backtracking, this backtracking dominates the total execution time for the algorithm, and the execution time can be as bad as exponential in the larger of either the maximum size of a domain of an existentially quantified assertion or the total number of disjuncts and implications. More typically, the execution of the post-condition will not require significant backtracking, and in that case the execution time is polynomial. The number of constraints generated from a post-condition is (at most) linear in the number of conjuncts, linear in the size of the domains of any universally quantified assertions, and polynomial in the depth of nested universal quantifiers. Thus, for a post-condition with $m$ conjuncts in which the largest domain of a universally quantified assertion is of size $n$ and the maximum depth of universal quantifier nesting is $l$, the number of constraints generated is $O(m + n^l)$. Combining this with the time needed for solving constraints, the maximum time needed for executing a post-condition without backtracking is $O((m + n^l)^3)$. As the time used in generating constraints is proportional to the maximum number of constraints generated, the worst case time for solving constraints dominates the worst case time for generating them, and so bounds the execution time. In practice, the time needed to execute a specification (again, in the case where significant backtracking is not required) rarely approaches this upper bound.\n\n5.4.6 Limitations\n\nThe most significant limitation is the non-executability of quantified assertions in which the bound variable ranges over an unspecified or infinite domain. As evidenced by `fase3` [KK93, Kra88], some progress on executing such assertions is possible, but even in `fase3` these assertions can only be executed if the bound variable implicitly ranges over a finite domain. Similarly, there are no plans to make specifications involving infinite sets and sequences executable. As constraint solving over real valued variables in the sense of CLP($\\mathcal{R}$) [JMSY92] and Prolog III [Col90] does not seem to\nbe very helpful in executing typical model-based specifications, there are no plans to extend the execution technique with more general arithmetic constraint solving. However, further research is planned on removing some of the current limitations of the execution technique. This research is outlined in the next section.\n\n5.4.7 Future Work\n\nSeveral relatively simple extensions of the execution technique would enhance its usefulness. As backtracking is already built into the interpreter, it would not be difficult to return multiple post-state values for the same object (or multiple function results) that satisfy the post-condition. This would be useful for underdetermined or nondeterministic specifications. For example, given the postcondition:\n\n\\[ x' = 3 \\lor x' = 4 \\]\n\nboth 3 and 4 are possible post-state values for \\( x \\), and returning both would be desirable. Another simple extension is the execution of instantiations of generic specifications. Generic specifications are specifications parameterized by types, and instantiation of a generic specification occurs when an actual type is substituted for each parameter type. As the actual parameter type is known at execution time, the execution technique would need only minor changes to execute such specifications.\n\nMore interesting future work centers on the use of partial values in executing specifications. Currently, quantified assertions are only evaluated or used to generate constraints if the domain that the bound variable ranges over completely known—that is, if the domain is not a partial value. However, evaluating a quantified assertion over a partial set or sequence value (i.e. the bound variable is restricted to range over the partial set or sequence) could detect universally quantified assertions that are false, and existentially quantified assertions that are true. Any constraints generated from such an assertion would be valid. However, the assertion would have to be reevaluated for constraints whenever more elements of the domain become known, and so many redundant constraints would be generated. Hence, more research is needed before such an extension to the execution technique is implemented.\nAnother interesting problem is the use of partial values as arguments in abstract or member function calls. One aspect of this problem is the execution of calls of recursive abstract functions where the recursion depends on an actual argument that is a partial value. For example, consider executing the abstract function count from (Figure 5.5) when the length of the sequence argument is not known. The problem is to find a reasonable way to ensure that such a call terminates. On the other hand, abstract function calls with partial valued arguments can also be viewed as constraints on those arguments. For example, a natural post-condition for a sort procedure, where $S$ is an object containing a sequence value, is:\n\n$$\\text{permutation}(S^*, S') \\land \\text{sorted}(S')$$\n\nExecuting this post-condition would require that the call to permutation be used to generate candidate values for $S'$, which does not occur with the current execution technique. The major difficulty is to determine whether an abstract function call with partial-valued arguments should be used for generating constraints (as in the example call to permutation, or whether it should be delayed until the partial valued arguments become total (as in the call to count). In general, this problem is probably undecidable (as it seems to rely on determining whether a function terminates when called with the given arguments), but better use of these calls than that made by the current execution technique should be possible.\n\n### 5.5 Comparison of the Execution Technique with CLP\n\nThe most obvious difference between our execution technique and CLP languages is the lack of constraint solving on the real numbers. While such constraint solving could be added to the interpreter in a fairly orthogonal manner, the utility of doing so is questionable as specifications written in model-based specification languages rarely produce such constraints. On the other hand, our execution technique deals with a richer set of non-arithmetic domains than most CLP languages and provides different constraints that are more suited to specifications over such domains. In particular, member and subset constraints over sets provide a level of expressiveness not found in most CLP languages.\nOur execution technique handles backtracking differently than logic and CLP languages. In such languages, backtracking can occur whenever multiple rules could be applied at some point in program execution, and, given repeated failure, the execution will eventually backtrack to all such rules whether they have a chance of leading to success or not. Our technique explicitly checks that an alternative has a chance of succeeding before creating a \"backtrack point\" that allows backtracking to that alternative. As previously mentioned, this checking is done by evaluating alternatives in a non-strict manner to see if any must be false, just from the values that are already known. We have found that for a large majority of specifications (even specifications written without executability in mind) this approach eliminates any possibilities for backtracking. The specification of an absolute value procedure of Figure 5.2 is typical. Clearly, this leads to more efficient execution.\n\nOur technique shares the concept of delaying constraints with Prolog III and CLP(R), but differs in how constraints are delayed. In Prolog III, constraints are only delayed explicitly (by the programmer), while in our technique, the delaying of constraints is always transparent to the user. CLP(R) also uses implicitly delayed constraints, but the only delayed constraints are nonlinear equations and inequalities. In our technique, delayed constraints consist both of constraints involving last applied to partial sequences of unknown length and of any assertion that can’t be evaluated or converted to constraints until more post-state values are known.\n\nThis is related to the use of logical variables, as it is our avoidance of logical variables that causes some forms of this second kind of delayed constraint. Consider the example of Figure 5.4, and recall that the second conjunct of the post-condition was delayed until the value of x' was known. Given the obvious CLP program analogous to this postcondition with Xpre, Xpost, and Result as logical variables representing the pre- and post-state values of x and the post-state value of result, respectively, a CLP interpreter would produce the following constraint set.\n\n\\{Xpost = Xpre + 1, Result = Xpost\\}\n\nFor any particular value for Xpre, say 3, this would be (iteratively) simplified into the following answer constraint set.\n\n\\{Xpost = 4, Result = 4\\}\nIn fact, whenever logical variables can eventually be bound to actual values, our execution technique produces the effect of logical variables, and the main difference from an execution standpoint is whether iteration occurs while finding constraints or while simplifying them.\n\nGiven this, it is reasonable to ask why we did not use logical variables to represent post-state values in our execution technique. Our avoidance of logical variables is based on the kind of answer that is usually wanted when a specification is executed. For example, one use of an executable specification is to \"fill in\" for the corresponding implementation in the use or testing of code that uses that implementation. This dependent code can not deal with answer constraints or with logical variables contained in the values it receives from the executable specification. However, it can deal with parts of these values being undefined. In C++, for example, this is equivalent to an array with uninitialized index positions, or to a struct with uninitialized fields.\n\nAnother possibility would be to use logical variables inside the execution procedure, and then to replace any logical variables that cannot be substituted out with undef before any values produced are made available to outside code. As previously noted, this substitution process requires the same kinds of iteration that occur in the current execution procedure. Additionally, any implicit constraints found through the use of logical variables — for example, that the first and second index positions of a sequence contain the same logical variable $X$ and so the same value, where no binding for $X$ exists in the associated substitution — would be lost in the replacement of logical variables with undef.\n\nUnlike CLP(ℜ), our execution technique does not use the standard unification algorithm. This is again related to our not using logical variables, as unification is normally used to produce bindings for logical variables. However, our techniques for applying constraints to partial values and for applying the SPECS-C++ frame axioms can be thought of as variants of unification that produce values instead of substitutions.\n\nWhile Prolog and most CLP languages are untyped, SPECS-C++ specifications have explicit type information, and this information can be exploited in constraint solving. In particular, type information is useful in constructing tuples (as the type of the tuple gives the number and type of its fields) and in handling union types.\nsensibly. The existence of union types justifies backtracking on type errors, as the problem may have been caused by using the wrong type from the union. Having the explicit union type limits the amount of backtracking that can occur, as most unions contain only a small number of types. In Prolog III, backtracking occurs when no more rules can be applied, which could be caused by the equivalent of a type error, or simply by unsatisfiability. This type of backtracking has no explicit bound, and so is a potential source of inefficiency.\n\nAnother difference is language syntax. While logic and CLP languages use a rule format that facilitates execution, an execution technique for model-based specification languages must start with the syntax of such languages. In the literature on the execution of model-based specifications, three distinct approaches to dealing with specification language syntax dominate:\n\n1. Restrict the executable subset of the language so that specifications can be directly executed. In particular, this usually means that references to post-state values can not appear in the bodies of quantified assertions, and that only assertions of the form $x' = \\text{val}$ can be used to provide post-state values, where $\\text{val}$ is strictly an expression over pre-state values. This is the most prevalent approach, and examples include EPROL [HI88, HI86], me too [Hen86], SMLVIEW [O'N92a, O'N92b], and the technique used for executing IPTES mini-specifications [RE93, LL91, AELL92].\n\n2. Use Prolog syntax or code in the specification language, and execute specifications via Prolog. Examples include PLEASE [TC89] and OBSERV [TY92].\n\n3. Explicitly translate specifications to Prolog programs. A number of researchers have experimented with this approach [DKC90, WE92], but to the authors' knowledge, no completely automated translator exists.\n\nThus, our approach of deriving constraints from specifications and then applying CLP-like techniques seems to be unique, and to supply a unique combination of syntax that is natural for specifiers and a very high level of executability.\n\nIn conclusion, we have described an execution technique for model-based specification languages with a number of unique and useful features. On the executable specification side, this technique provides:\n• Handling of mutation and aliasing at the (executable) specification level. This permits the writing of practical, \"industrial strength\" specifications of implementations that rely on these features.\n\n• Execution of high level specifications. Such highly abstract specifications would occur early in the software development process, and so the execution of these specifications brings validation activities to the earliest stages of development.\n\nIn the application of CLP techniques, our work demonstrates:\n\n• Checking that backtracking to an alternative would lead to a possibility of success before creating the backtrack point.\n\n• Constraint solving in presence of type information. In particular, we have shown how to use backtracking to deal with union types sensibly.\n\n• Application of CLP techniques to new domains, such as objects, sets, sequences, and tuples.\n\n• Automatic generation of constraints. This is necessary for the practical application of CLP techniques to executing specifications, and may provide a basis for CLP languages with more human-oriented syntax.\n\nThus, our work has practical implications for software development and opens the gateway into a new application arena for constraint logic programming.\n6. GENERAL SUMMARY\n\n6.1 Discussion of Results\n\nAs described in the introduction of this dissertation, the focus of the research described here has been to develop an execution technique capable of executing specifications written at the level of abstraction that typifies non-executable, model-based specifications. The execution technique for model-based specifications largely achieves this goal. The first efforts in developing the execution technique led to a prototype interpreter for DFD-SPECS specifications. The main contributions of this interpreter are a practical operational semantics for formalized data flow diagrams and the first work on executing assertions over model types.\n\nAfter the realizations that a better technique for executing assertions was needed, and that this technique would be directly applicable in executing other model-based specification languages, work began on an interpreter for SPECS-C++. Changing the executed specification language was important in isolating parts of the execution technique that are common to model-based specification languages and parts that are specific to a particular language. Research into executing assertions led to the ability to directly execute quantified assertions, and to the use of quantified for generating constraints on post-state values. Constraint solving was also introduced into the interpreter, but the relationship with modern constraint logic programming techniques was never considered, and so the constraint solving was correspondingly crude. As SPECS-C++ differs from DFD-SPECS in allowing the specification of side effects, the interpreter was extended to execute such specifications. As variables could now change value from the pre-state to the post-state, frame axioms became important. This led to the formalization of the operational semantics of SPECS-C++ frame axioms, and incorporation of this semantics into the interpreter. Although this\ninterpreter can not execute many of the specifications that are executable by the current incarnation of the execution technique, it does have one major advantage over more recent developments: the time required for executing a particular specification is predictable, and can easily be estimated by inspecting the specification.\n\nWhile the interpreter could now execute a large and useful subset of SPECS-C++, it still had a number of deficiencies. Research on the design of SPECS-C++ itself led to the incorporation of an elegant and uniform theory of objects into the language. Because of aliasing among objects, and because objects can contain other objects, the interpreter was not sufficient for executing SPECS-C++ with objects. Additionally, the interpreter dealt poorly with underdetermined (nondeterministic) specifications, and could not execute incomplete specifications. Research into constraint logic programming techniques led to the use of backtracking for dealing with underdetermined specifications, and to the development of a theory of partial values so that incomplete specifications could be executed. Partial values also allowed much more sophisticated constraint solving over SPECS-C++ domains, as constraints could be applied individually and in any order to produce partial values. This refined constraint solving proved to be a natural vehicle for executing specifications involving objects, as a partial value could be contained in an object, and later constraints on objects aliased with that object could easily be used to further define that partial value and could be checked for consistency with the partial value. Thus, the use of techniques inspired by constraint logic programming has greatly enhanced the expressiveness of executable SPECS-C++ specifications. Unfortunately, this additional expressiveness was not achieved without cost, as the use of backtracking has made execution times for specifications harder to predict. On the other hand, the current execution technique does not backtrack when executing any specification that could be executed by the previous interpreter. Thus, the gain in expressiveness has not resulted in a loss of efficiency.\n\nApplying the execution technique in executing DFD-SPECS and SPECS-C++ has allowed the investigation of the executability of existing specifications written in these languages, which is valuable because these specifications were written without executability in mind. The body of specifications in question were developed as examples for the undergraduate and graduate software engineering courses at Iowa State\nUniversity. Typical examples of these specifications include the DFD-SPECS spelling checker specification (Figure 3.1) and the SPECS-C++ specifications of ADTs Table (Section 2.2.3) and Bounded List (Section 2.3.3). Of these, the majority (approximately 70 percent) are executable as written. Almost all of the remaining examples are executable with very minor modifications that do not greatly reduce the level of abstraction present in the specification. The refinement of the execution technique with techniques from constraint logic programming makes even more specifications executable, especially underdetermined and nondeterministic specifications. As the specifications used as examples for students tend to be complete and deterministic, they often do not require the full power of the refined execution technique. However, comparison with specification examples from the literature on specification languages that use logic programming techniques for executability revealed the power and utility of the refined execution technique. Typical examples of these specifications include the sorting examples of Chapter 5 (Figures 5.3 and 5.5).\n\nThus, the current execution technique can execute a large and useful subset of formal, model-based specification languages such as DFD-SPECS and SPECS-C++. As specifications written at a high level of abstraction can be executed, the execution technique provides a way to gain the benefits of executable specifications without losing the benefits of traditional non-executable specifications. Thus, the execution technique should greatly enhance the usefulness of formal specifications in industrial software development settings. The execution technique also introduces constraint solving in new domains, and the use of constraint logic programming techniques in a new application area. Hence, the execution technique has important implications both in practical software development and in applying constraint logic programming to real world problems.\nBIBLIOGRAPHY\n\n\nGary T. Leavens. Inheritance of Interface Specifications (Extended Abstract). Technical Report 93-23, Iowa State University, Department of\nComputer Science, September 1993. Appears in the Workshop on Interface Definition Languages, WIDL '94. Available by anonymous ftp from ftp.cs.iastate.edu or by e-mail from almanac@cs.iastate.edu.\n\n\n"}}},{"rowIdx":264,"cells":{"id":{"kind":"string","value":"99ef5ae11705c0406c4165c01e9a609f4b281fe5"},"text":{"kind":"string","value":"Citation for published version\n\n\nDOI\n\nhttps://doi.org/10.1145/2429069.2429099\n\nLink to record in KAR\n\nhttp://kar.kent.ac.uk/50270/\n\nDocument Version\n\nUNSPECIFIED\n\nCopyright & reuse\n\nContent in the Kent Academic Repository is made available for research purposes. Unless otherwise stated all content is protected by copyright and in the absence of an open licence (eg Creative Commons), permissions for further reuse of content should be sought from the publisher, author or other copyright holder.\n\nVersions of research\n\nThe version in the Kent Academic Repository may differ from the final published version. Users are advised to check http://kar.kent.ac.uk for the status of the paper. Users should always cite the published version of record.\n\nEnquiries\n\nFor any further enquiries regarding the licence status of this document, please contact:\n\nresearchsupport@kent.ac.uk\n\nIf you believe this document infringes copyright then please contact the KAR admin team with the take-down information provided at http://kar.kent.ac.uk/contact.html\nLibrary Abstraction for C/C++ Concurrency\n— extended version —\n\nMark Batty\nUniversity of Cambridge\n\nMike Dodds\nUniversity of York\n\nAlexey Gotsman\nIMDEA Software Institute\n\nAbstract\nWhen constructing complex concurrent systems, abstraction is vital: programmers should be able to reason about concurrent libraries in terms of abstract specifications that hide the implementation details. Relaxed memory models present substantial challenges in this respect, as libraries need not provide sequentially consistent abstractions: to avoid unnecessary synchronisation, they may allow clients to observe relaxed memory effects, and library specifications must capture these.\n\nIn this paper, we propose a criterion for sound library abstraction in the new C11 and C++11 memory model, generalising the standard sequentially consistent notion of linearizability. We prove that our criterion soundly captures all client-library interactions, both through call and return values, and through the subtle synchronisation effects arising from the memory model. To illustrate our approach, we verify implementations against specifications for the lock-free Treiber stack and a producer-consumer queue. Ours is the first approach to compositional reasoning for concurrent C11/C++11 programs.\n\nCategories and Subject Descriptors C11/C++11 programs.\n\nis the first approach to compositional reasoning for concurrent the lock-free Treiber stack and a producer-consumer queue. Ours our approach, we verify implementations against specifications for both through call and return values, and through the subtle syn- tation in the new C11 and C++11 memory model, generalising the tions must capture these.\n\nIn this paper, we propose a criterion for sound library abstraction tion of the C11 model, defining a criterion for library abstraction T echnical challenges. Apart from managing the mere complex- for verification or informal reasoning. Hence, it can be viewed as y complex library code to be replaced by simpler specifications, for verification or informal reasoning. Hence, it can be viewed as giving a proof technique for contextual refinement that avoids con- sidering all possible clients. Our criterion is compositional, mean- ning that a library consisting of several smaller non-interacting li- braries can be abstracted by considering each sub-library separ- ately. When restricted to the SC fragment of C11, our criterion implies classical linearizability (but not vice versa).\n\nThe proposed criterion for library abstraction gives the first sound technique for specifying C11 and C++11 concurrent libraries. To justify its practicality, we have applied it to two typical concurrent algorithms: a non-blocking stack and an array-based queue. To do this, we have adapted the standard linearization point technique to the axiomatic structure of the C11 model. These case studies represent the first step towards verified concurrent libraries for C11 and C++11.\n\nTechnical challenges. Apart from managing the mere complex- is straightforward: there is a total order over reads and writes, and each read returns the value of the most recent write to the location being accessed [14]. However, modern processors and programming languages provide relaxed memory models, where there is no total order of memory actions, and the order of actions observed by a thread may not agree with program order, or with that observed by other threads.\n\nIn this paper, we propose a criterion for library abstraction on the relaxed memory model defined by the new ISO C11 [11] and C++11 [12] standards (henceforth, the ‘C11 model’). We handle the core of the C11 memory model, leaving more esoteric features, such release-consume atomics and fences, as future work (see §9). The C11 model is designed to support common compiler optimisations and efficient compilation to architectures such as x86, Power, ARM and Itanium, which themselves do not guarantee SC. It gives the programmer fine-grained control of relaxed behaviour for individual reads and writes, and is defined by a set of axiomatic constraints, rather than operationally. Both of these properties produce subtle interactions between the client and the library that must be accounted for in abstraction.\n\nOur criterion is an evolution of linearizability [4, 6, 9, 10], a widely-used abstraction criterion for non-relaxed systems. Like linearizability, our approach satisfies the Abstraction Theorem: if one library (a specification) abstracts another (an implementation), then the behaviours of any client using the implementation are contained in the behaviours of the client using the specification. This result allows complex library code to be replaced by simpler specifications, for verification or informal reasoning. Hence, it can be viewed as giving a proof technique for contextual refinement that avoids considering all possible clients. Our criterion is compositional, meaning that a library consisting of several smaller non-interacting libraries can be abstracted by considering each sub-library separately. When restricted to the SC fragment of C11, our criterion implies classical linearizability (but not vice versa).\n\nThe proposed criterion for library abstraction gives the first sound technique for specifying C11 and C++11 concurrent libraries. To justify its practicality, we have applied it two typical concurrent algorithms: a non-blocking stack and an array-based queue. To do this, we have adapted the standard linearization point technique to the axiomatic structure of the C11 model. These case studies represent the first step towards verified concurrent libraries for C11 and C++11.\n\n1. Introduction\nSoftware developers often encapsulate functionality in libraries, and construct complex libraries from simpler ones. The advantage of this is information hiding: the developer need not understand each library’s implementation, but only its more abstract specification. On a sequential system, a library’s internal actions cannot be observed by its client, so its specification can simply be a relation from initial to final states of every library invocation. This does not suffice on a concurrent system, where the invocations can overlap and interact with each other. Hence, a concurrent library’s specification is often given as just another library, but with a simpler (e.g., atomic) implementation; the two libraries are called concrete and abstract, respectively. Validating a specification means showing that the simpler implementation abstracts the more complex one, i.e., reproduces all its client-observable behaviours. Library abstraction has to take into account a variety of ways in which a client and library can interact, including values passed at library calls and returns, the contents of shared data structures and, in this paper, the memory model.\n\nThe memory model of a concurrent system governs what values can be returned when the system reads from shared memory. In a traditional sequentially consistent (SC) system, the memory model\nations between a client and a library. Histories in our work consist of several partial orders on call and return actions. This is in contrast to variants of linearizability, where histories are linear sequences (for this reason, in the following we avoid the term ‘linearizability’).\n\nWe define an abstraction relation on histories as inclusion over partial orders, and lift this relation to give our abstraction criterion for libraries: one library abstracts another if any history of the former can be reproduced in abstracted form by the latter.\n\nSecond, C11 offers the programmer a range of options for concurrently accessing memory, each with different trade-offs between consistency and performance. These choices can subtly affect other memory accesses across the client-library boundary—a particular choice of consistency level inside the library might force or forbid reading certain values in the client, and vice versa. This is an intended feature: it allows C11 libraries to define synchronisation constructs that offer different levels of consistency to clients. We propose a method for constructing histories that captures such client-library interactions uniformly. The Abstraction Theorem certifies that our histories indeed soundly represent all possible interactions.\n\nFinally, some aspects of the C11 model conflict with abstraction. Most problematically, the model permits satisfaction cycles. In satisfaction cycles, the effect of actions executed down a conditional branch is what causes the branch to be taken in the first place. This breaks the straightforward assumption that faults are confined to either client or library code: a misbehaving client can cause misbehaviour in a library, which can in turn cause the original client misbehaviour! For these reasons, we actually define two distinct library abstraction criteria: one for general C11, and one for a for-tinct library abstraction criteria: one for general C11, and one for a client-library interactions uniformly. The Abstraction Theorem certifies that our histories indeed soundly represent all possible interactions.\n\nAs we argue in §9, many of the techniques we developed to address the above challenges should be applicable to other models similar to C11.\n\nStructure. In the first part of the paper, we describe informally how algorithms can be expressed and specified in the C11 memory model (§2), and our abstraction criteria (§3). We then present the model formally (§4 and §5), followed by the criteria (§6) and a method for establishing their requirements (§7). Proofs are given in §C.\n\n2. C11 Concurrency and Library Specification\n\nIn this section we explain the form of our specifications for C11 concurrent libraries, together with a brief introduction to programming in the C11 concurrency model itself. As a running example, we use a version of the non-blocking Treiber stack algorithm [21] implemented using the concurrency primitives in the subset of C11 that we consider. Figure 1a shows its specification, and Figure 1b its implementation, which we have proved to correspond (§7 and §E). For readability, we present examples in a pseudocode instead of the actual C/C++ syntax. Several important features are highlighted in red—these are explained below.\n\nStack specification. As noted in §1, specifications are just alternative library implementations that have the advantage of simplicity, in exchange for inefficiency or nondeterminism. The specification in Figure 1a represents the stack as a sequence abstract data type and provides the three expected methods: *init*, *push* and *pop*. A correct stack implementation should provide the illusion of atomicity of operations to concurrent threads. We specify this by wrapping the bodies of *push* and *pop* in atomic sections, denoted by *atom_sec*. Atomic sections are not part of the standard C11 model—for specification purposes, we have extended the language with a prototype semantics for atomic section (§5). Both *push* and *pop* may non-deterministically diverge, as common stack implementation allow some operations to starve (in concurrency parlance, they are lock-free, but not wait-free). All these are the expected features of a specification on an SC memory model. We now explain the features specific to C11.\n\nThe sequence *S* holding the abstract state is declared atomic. In C11, programs must not have data races on normal variables; any location where races can occur must be explicitly identified as atomic and accessed using the special commands *load*, *store*, and *CAS* (**compar-and-swap**). The latter combines a load and a store into a single operation executed atomically. A CAS takes three arguments: a memory address, an expected value and a new value. The command atomically reads the memory address and, if it contains the expected value, updates it with the new one. Due to our use of atomic sections, the CASes in the specification always succeed. We use CASes here instead of just stores, because, for subtle technical reasons, the latter have a stronger semantics in C11 than our atomic sections (see release sequences in §A).\n\nThe *load* and *store* commands are annotated with a memory order that determines the trade-off between consistency and performance for the memory access; CASes are annotated with two memory orders, as they perform both a load and a store. The choice of memory orders inside a library method can indirectly affect its clients, and thus, a library specification must include them. In the\nThe first thread writes 1 into x and calls push(&x); the second thread pops the address of x from the stack and then reads its contents. In general, a relaxed memory model may allow the second thread to read t before the first thread writes into x. However, in contrast to an SC model, a relaxed model does not allow relaxed reads from other locations, such as the read *a in the client.\n\nTo enable this message-passing idiom, the specification only needs to synchronise from pushes to pops; it need not synchronise from pops to pushes, or from pops to pops. To avoid unnecessary synchronisation, the specification uses the relaxed memory order (RLX). This order is weaker than release-acquire, meaning that the set of values a relaxed load can read from memory is less constrained; additionally, relaxed reads and stores do not synchronise with each other. However, relaxed operations are very cheap, since they compile to basic loads and stores without any additional hardware barrier instructions. Hence, the specification allows implementations that are efficient, yet support the intended use of the stack for message passing. On the other hand, as we show below, it intentionally allows non-SC stack behaviours.\n\n**Stack implementation.** Figure 1b gives our implementation of the Treiber stack. The stack is represented by a heap-allocated linked list of nodes, accessed through a top-of-stack pointer T. Only the latter needs to be atomic, as it is the only point of contention among threads. The push function repeatedly reads from the top pointer T, initialises a newly created node x to point to the value read, and tries to swing T to point to x using a CAS; pop is implemented similarly. For simplicity, we let pop leak memory.\n\nLike the specification, the implementation avoids unnecessary hardware synchronisation by using the relaxed memory order RLX. However, the load of T in pop is annotated ACQ, since the command x = t->next accesses memory based on the value read, and hence, requires it to be up to date.\n\nWhat does it mean for the implementation in Figure 1b to meet the specification in Figure 1a? As well as returning the right values, it must also faithfully implement the correct synchronisation. To understand how this can be formalised, we must therefore explain how synchronisation works in C11’s semantics.\n\n**C11 model structure.** The C11 memory model is defined axiomatically. An execution of a program consists of a set of actions and several partial orders on it. An action describes a memory operation, including the information about the thread that performed it, the address accessed and the values written and/or read. The semantics of a program is given by the set of executions consistent with the program code and satisfying the axioms of the memory model (see Figure 4 for a flavour of these). Here is a program with one of its executions, whose outcome we explain below:\n\n```\nint a, b, x=0;\nx=1;\npush(&x);\n}\nwhile (a==EMPTY);\nb=a;\n```\n\nNote that, in diagrams representing executions, we omit thread identifiers from actions. Several of the most important relations in an execution are:\n\n- **sequenced-before** (sb), a transitive and irreflexive relation ordering actions by the same thread according to their program order.\n- **initialised-before** (ib), ordering initial writes to memory locations before all other actions in the execution. Above we have shown ib by a dotted line dividing the two kinds of actions.\n- **reads-from** (rf), relating reads r to the writes w from which they take their values: w → r.\n- **happens-before** (hb), showing the precedence of actions in the execution. In the fragment of C11 that we consider, it is transitive and irreflexive.\n\nHappens-before is the key relation, and is the closest the C11 model has to the notion of a global time in an SC model: a read must not read any write to the same location related to it in hb other than its immediate predecessor. Thus, for writes w_1 and w_2 and a read r accessing the same location, the following shapes are forbidden:\n\n```\nw_1 \\_{hb} \\leftarrow w_2 \\_{hb} \\rightarrow r\n```\n\nHowever, in contrast to an SC model, hb is partial in C11, and some reads can read from rb-unrelated writes: we might have w → r, but not w \\_{hb} → r.\n\n**Memory orders.** By default, memory reads and writes in C11 are non-atomic (NA). The memory model guarantees that data-race free programs with only non-atomic memory accesses have SC behaviour. A data race occurs when two actions on the same memory location, at least one of which is a write, and at least one of which is a non-atomic access, are unrelated in happens-before, and thus, intuitively, can take place ‘at the same time’.\n\nThe three main atomic memory orders, from least to most restrictive, are relaxed, release-acquire and sequentially consistent.\n\n1. **Aladdin.** This is a specialisation of the additional-synchronises-with relation from the C11 model [1] to programs without dynamic thread creation, to which we restrict ourselves in this paper (see §4).\n2. **Release-consume.** Atomic and fences [1] are left for future work (see §9).\nThe **release-acquire** memory orders allow more relaxed behaviour than SC, while still providing some guarantees. Consider the following execution of the client in the stack in Figure 1a or 1b we have seen above:\n\n**Message passing (MP):**\n\n```c\nint a, b, x=0;\n\nx=1;\npush(&x);\nwhile (a==EMPTY);\ncall push(&x);\nwhile (a==EMPTY);\nret pop(&x);\nrb(&x,1)\n```\n\nHere **rmw (read-modify-write)** is a combined load-store action produced by a CAS. In this case, the ACQ load in pop synchronises with the REL store part of the CAS in push that it reads from. This informal notion of synchronisation we mentioned above is formalised in the memory model by including the corresponding rf edge into **hb**. Then, since sb ∪ ib ⊆ hb and hb is transitive, both writes to x happen before the read. Hence, by (RD), the read from x by the second thread is forced to read from the most recent write, i.e., 1.\n\nIf all the memory order annotations in the Treiber stack were relaxed, the second thread could read 0 from x instead. Furthermore, without release-acquire synchronisation, there would be a data race between the non-atomic write of x in the first thread and the non-atomic read of x in the second.\n\nThe release-acquire memory orders only synchronise between pairs of reads and writes, but do not impose a total order over memory accesses, and therefore allow non-SC behaviour. For example, if we annotate writes in (SB) with REL, and reads with ACQ, then the outcome shown there will still be allowed: each load can read from the initialisation without generating a cycle in hb or violating (RD). We can also get this outcome if we use push and pop operations on two instances of the stack from Figure 1a or 1b instead of load and store. Thus, both the implementation and the specification of the stack allow it to have non-SC behaviour.\n\nTo summarise, very roughly, release-acquire allows writes to be delayed but not reordered, while relaxed allows both. Relaxed actions produce even stranger behaviour, including what we call **satisfaction cycles:**\n\n**Satisfaction cycle (SCL):**\n\n```\nif (a==8)\n sb(&x,0)\n load_rel(&x,0)\n load_rel(&x,0)\n load_rel(&x,0)\n```\n\nHere, each conditional satisfies its guard from a later write in the other thread. This is possible because relaxed reads and writes do not create any happens-before ordering, and thus neither read is constrained by (RD). Unlike relaxed, release-acquire does not allow satisfaction cycles. If the loads and stores in the example were annotated release-acquire, then both rf edges would also be hb edges. This would produce an hb cycle, which is prohibited by the memory model. Satisfaction cycles are known to be a problematic aspect of the C11 model; as we show in this paper, they also create difficulties for library abstraction.\n\n### 3. Library Abstraction Informally\n\n**Histories.** Our approach to abstraction is based on the notion of a history, which concisely records all interactions between the client and the library in a given execution. Clients and libraries can affect one another in several ways in C11. Most straightforwardly, the library can observe the parameters passed by the client at calls, and the client can observe the library’s return values. Therefore, a history includes the set of all call and return actions in the execution. However, clients can also observe synchronisation and other memory-model effects inside a method. These more subtle interactions are recorded by two kinds of partial order: guarantees and denials.\n\nSynchronisation internal to the library can affect the client by forcing reads to read from particular writes. For example, in (MP) from §2, the client is forced to read 1 from x because the push and pop methods synchronise internally in a way that generates an hb ordering between the call to push and the return from pop. If the methods did not hb-synchronise, the client could read from either of the writes to x. The client can thus observe the difference between two library implementations with different internal synchronisation, even if all call and return values are identical. To account for this, the **guarantee** relation in an history of an execution records hb edges between library call and return actions.\n\nEven non-synchronising behaviour inside the library can sometimes be observed by the client. For example, the C11 model requires the existence of a total order mo over all atomic writes to a given location. This order cannot go against hb, but is not included into it, as this would make the model much stronger, and would hinder efficient compilation onto very weak architectures, such as Power and ARM [20]. Now, consider the following:\n\n**Deny (DN):**\n\n```\nstore_rel(&x,1):\nload_acq(&x,0); call lib();\n```\n\nIn this execution, a write internal to the invocation of lib in the second thread is mo-ordered after a write internal to the invocation of lib in the first thread. This forbids the client from reading 0 from x. To see this, suppose the contrary holds. Then the ACQ load synchronises with the REL store of 0, yielding an hb edge. By transitivity with the client sb edges, which are included in hb, we get an hb edge from retlib in the second thread to calllib in the first. Together with the library’s sb edges, this yields an hb edge going against the library-internal mo one, which is prohibited by the memory model. To account for such interactions, the **deny** relations in an history of an execution record hb or other kinds of edges between return and call actions that the client **cannot** enforce due to the structure of the library, e.g., the hb-edge from retlib to calllib above.\n\n**Abstraction in the presence of relaxed atomics.** As we noted in §1, we actually propose two library abstraction criteria: one for the full memory model described in §2, and one for programs without relaxed atomics. We discuss the former first.\n\nTwo library executions with the same history are observationally equivalent to clients, even if the executions are produced by different library implementations. By defining a sound abstraction relation over histories, we can therefore establish abstraction between libraries. To this end, we need to compare the histories of libraries under every client context. Fortunately, we need not examine every possible client: it suffices to consider behaviour under a most general client, whose threads repeatedly invoke library methods in any order and with any parameters. Executions under this client generate all possible histories of the library, and thus represent all client-library interactions (with an important caveat, we also omit some C11 subtleties that are orthogonal to abstraction (see §4).\ndiscussed below). We write \\([\\mathcal{L}]I\\) for the set of executions of the library \\(\\mathcal{L}\\) under the most general client starting from an initial state \\(I\\). Initial states are defined formally in §4, but, informally, record initialisation actions such as the ones shown in (SB). The set \\([\\mathcal{L}]I\\) gives the denotation of the library considered in isolation from its clients, and in this sense, defines a library-local semantics of \\(\\mathcal{L}\\).\n\nThis library-local semantics allows us to define library abstraction. We now quote its definition and formulate the corresponding Abstraction Theorem, introducing some of the concepts used in them only informally. This lets us highlight their most important features that can be discussed independently of the formalities. We fill in the missing details in §6.1, after we have presented the C11 model more fully.\n\nFor the memory model with relaxed atomics, a history contains one guarantee and one deny relation.\n\n**Definition 1.** A history is a triple \\(H = (A, G, D)\\), where \\(A\\) is a set of call and return actions, and \\(G, D \\subseteq A \\times A\\).\n\nLibrary abstraction is defined on pairs of libraries \\(\\mathcal{L}\\) and sets of their initial states \\(I\\). It relies on a function history(·) extracting the history from a given execution of a library, which we lift to sets of executions pointwise. The notation \\([\\mathcal{L}, R]\\) and the notion of safety are explained below.\n\n**Definition 2.** For histories \\((A_1, G_1, D_1)\\) and \\((A_2, G_2, D_2)\\), we let \\((A_1, G_1, D_1) \\subseteq (A_2, G_2, D_2)\\) if \\(A_1 = A_2\\), \\(G_1 = G_2\\) and \\(D_1 \\subseteq D_2\\).\n\nFor safe \\((\\mathcal{L}_1, I_1)\\) and \\((\\mathcal{L}_2, I_2)\\), \\((\\mathcal{L}_1, I_1)\\) is abstracted by \\((\\mathcal{L}_2, I_2)\\), written \\((\\mathcal{L}_1, I_1) \\subseteq (\\mathcal{L}_2, I_2)\\), if for any relation \\(R\\) containing only edges from return actions to call actions, we have\n\n\\[\\forall I_1 \\in I_1, H_1 \\in \\text{history}([\\mathcal{L}_1, R I_1]).\\]\n\n\\[\\exists I_2 \\in I_2, H_2 \\in \\text{history}([\\mathcal{L}_2, R I_2], H_1 \\subseteq H_2).\\]\n\nThe overall shape of the definition is similar to that of linearizability on SC memory models [10]: any behaviour of the concrete library \\(\\mathcal{L}_1\\) relevant to the client has to be reproducible by the abstract library \\(\\mathcal{L}_2\\). However, there are several things to note.\n\nFirst, we allow the execution of the abstract library to deny less than the concrete one, but require it to provide the same guarantee. Intuitively, we can strengthen the deny, because this only allows more client behaviours.\n\nSecond, we do not consider raw executions of the most general client of \\(\\mathcal{L}_1\\) and \\(\\mathcal{L}_2\\), but those whose happens-before relation can be extended with an arbitrary set \\(R\\) of edges between return and call actions without contradicting the axioms of the memory model; \\([\\mathcal{L}_1, R I_1]\\) and \\([\\mathcal{L}_2, R I_2]\\) denote the sets of all such extensions. The set \\(R\\) represents the happens-before edges that can be enforced by the client: such happens-before edges are not generated by the client commands. Such happens-before edges are not generated by the client, because this only allows more client behaviours.\n\nFinally, the abstraction relation is defined only between safe libraries that do not access locations internal to the client and do not have faults, such as data races.\n\nAs we show in §7, the specification of the Treiber stack in Figure 1a abstracts its implementation in Figure 1b.\n\n**Abstraction theorem.** We now formulate a theorem that states the correctness of our library abstraction criterion. We consider programs \\(C(\\mathcal{L})\\) with a single client \\(C\\) and a library \\(\\mathcal{L}\\) (the case of multiple libraries is considered in §6.1). The Abstraction Theorem states that, if we replace the (implementation) library \\(\\mathcal{L}_1\\) in a program \\(C(\\mathcal{L}_1)\\) with another (specification) library \\(\\mathcal{L}_2\\) abstracting \\(\\mathcal{L}_1\\), then the set of client behaviours can only increase. Hence, when reasoning about \\(C(\\mathcal{L}_1)\\), we can soundly replace \\(\\mathcal{L}_1\\) with \\(\\mathcal{L}_2\\) to simplify reasoning.\n\nIn the theorem, \\(\\llbracket C(\\mathcal{L}) \\rrbracket I\\) gives the set of executions of \\(C(\\mathcal{L})\\) from initial states in a set \\(I\\), \\(\\cup\\) combines the initial states of a client and a library, and client(·) selects the parts of executions generated by client commands. We call \\(C(\\mathcal{L}_1)\\), \\(C(\\mathcal{L}_2)\\) non-interfering, if \\(C\\) and \\(\\mathcal{L}_1\\) do not access each others’ internal memory locations in executions of \\(C(\\mathcal{L})\\) from initial states in \\(I\\). The notion of safety for \\(C(\\mathcal{L})\\) is analogous to the one for libraries.\n\n**Theorem 3 (Abstraction).** Assume that \\((\\mathcal{L}_1, I_1), (\\mathcal{L}_2, I_2), (\\llbracket C(\\mathcal{L}_1) \\rrbracket I \\cup I_1, I_2)\\) are safe, \\((\\llbracket C(\\mathcal{L}_1) \\rrbracket I \\cup I_1, I_2)\\) is non-interfering and \\((\\llbracket C(\\mathcal{L}_1) \\rrbracket I \\cup I_1, I_2) \\subseteq (\\llbracket C(\\mathcal{L}_2) \\rrbracket I \\cup I_2).\\) Then \\((\\llbracket C(\\mathcal{L}_1) \\rrbracket I \\cup I_1, I_2)\\) is safe and\n\nclient([\\llbracket C(\\mathcal{L}_1) \\rrbracket I \\cup I_1]) \\subseteq client([\\llbracket C(\\mathcal{L}_2) \\rrbracket I \\cup I_2]).\\)\n\nThe requirement of non-interference is crucial, because it ensures that clients can only observe library behaviour through return values and memory-model effects, rather than by ‘opening the box’ and observing internal states. The drawback of Theorem 3 is that it requires us to establish the non-interference between the client \\(C\\) and the concrete library \\(\\mathcal{L}_1\\), e.g., via a type system or a program logic proof. As we show below, we cannot weaken this condition to allow checking non-interference on the client \\(C\\) using the abstract library \\(\\mathcal{L}_2\\), as is standard in data refinement on SC memory models [7]. This makes the reasoning principle given by the theorem less compositional, since establishing non-interference requires considering the composed behaviour of the client and the concrete library—precisely what library abstraction is intended to avoid! However, this does not kill compositional reasoning completely, as non-interference is often simple to check even globally. We can also soundly check other aspects of safety, such as data-race freedom, on \\(C(\\mathcal{L}_2)\\). Furthermore, as we show in §6.1, the notion of library abstraction given by Definition 2 is compositional for non-interfering libraries. As we now explain, we can get the desired theorem allowing us to check non-interference on \\(C(\\mathcal{L}_2)\\) for the fragment of the language excluding relaxed atomics.\n\n**Abstraction without relaxed atomics.** Restricting ourselves to programs without the relaxed memory order (and augmenting the axiomatic memory model to allow incomplete program runs, as described in §4) allows strengthening our result in three ways:\n\n1. We no longer need to quantify over client happens-before edges \\(R\\), like in Definition 2. Instead, we enrich histories with an additional deny relation, which is easier to deal with in practice than the quantification. Hence, without relaxed atomics, the caveat to the generality of the most general client does not apply.\n\n2. Abstraction on histories can be defined by inclusion on guarantees, rather than by equality.\n\n3. We no longer need to show that the unabstracted program \\(C(\\mathcal{L}_1)\\) is non-interfering. Rather, non-interference is a consequence of the safety of the abstracted program \\(C(\\mathcal{L}_2)\\).\n\nThe first two differences make proofs of library abstraction slightly easier, but are largely incidental otherwise. In particular, quantification over client happens-before edges in Definition 2, although unpleasant, does not make library abstraction proofs drastically more complicated. Requiring the guarantees of the concrete and abstract executions to be equal in this definition just results in more verbose specifications in certain cases. In contrast, the last difference is substantial.\n\n**The price of satisfaction cycles.** For each of the three above differences we have a counterexample showing that Theorem 3 will\nnot hold if we change the corresponding condition to the one required in the case without relaxed atomics. All of these counterexamples involve satisfaction cycles, which can only be produced by relaxed atomics. Our results show that this language feature makes the reasoning principles for C11 programs less compositional. Due to space constraints, here we present only the counterexample for point 3 above: the others are given in §D. In §6.3, we identify the corresponding place in the proof of the Abstraction Theorem for the language without relaxed atomics where we rely on the absence of satisfaction cycles.\n\nConsider the following pair of libraries $L_1$ and $L_2$:\n\n$L_1$: atomic int $x$\nint $m()$\nstoreRLX($x$, 42);\nreturn 42;\nreturn loadRLX($x$);\n\n$L_2$: atomic int $x$\nint $m()$\nstoreRLX($x$, 0);\n\nHere $x$ is a library-internal location. We have $L_1 \\subseteq L_2$, since both method implementations behave exactly the same, assuming that the internal location $x$ is not modified outside the library. Unsafe clients can distinguish between $L_1$ and $L_2$. For example, the client\n\n```\nprint $m()$;\n\\parallel storeRLX($x$, 0);\n```\n\ncan print 0 when using $L_1$, but not $L_2$. However, any non-trivial library behaves erratically when clients corrupt its private data structures, and thus, it is reasonable for abstraction to take into account only well-behaved clients that do not do this. We therefore contend that $L_1$ should be abstracted by $L_2$ according to any sensible abstraction criterion.\n\nThe above misbehaved client violates non-interference when using either $L_1$ or $L_2$. However, we can define a more complicated client $C$ such that $C(L_2)$ is non-interfering, but $C(L_1)$ is not:\n\n```\na=m();\n\\parallel if (a==0)\nstoreRLX($x$, 42);\n\\parallel return loadRLX($x$);\n```\n\nThe execution of $C(L_1)$ given on the right violates non-interference due to a satisfaction cycle: a fault in the client causes the library to misbehave by returning 0 instead of 42, and the effect of this misbehaviour is what causes the client fault in the first place! Since the abstract library $L_2$ is completely resilient to client interference, its method will always return 42, and thus, the satisfaction cycle will not appear and the client will not access the variable $x$. Note that this counterexample is not specific to our notion of library abstraction: any such notion for C11 considering $L_2$ to be a specification for $L_1$ cannot allow checking non-interference using $L_2$.\n\nFor expository reasons, we have given a very simple counterexample. This program would be easy to detect and eliminate, e.g., using a simple type system: one syntactic path in the client is guaranteed to result in the forbidden access to the library’s internal state. However, the same kind of behaviour can occur with dynamically-computed addresses: the client stepping out of bounds of an array overwrites the library state, causing it to misbehave, which in turn causes the original client misbehaviour. For this kind of example, proving non-interference becomes non-trivial.\n\nIt is unclear to us whether satisfaction cycles are observable in practice. They are disallowed by even the weakest C11 target architectures, such as Power and ARM [20], because these architectures respect read-to-write dependencies created by control-flow. It is also clear that the C11 language designers would like to forbid satisfaction cycles: the C++11 standard [11, Section 29.3, Paragraph 11] states that, although (SCL) from §2 is permitted, “implementations should not allow such behaviour”. This apparent contradiction is because certain compiler optimisations, such as common subexpression elimination and hoisting from loops, can potentially create satisfaction cycles (see [15] for discussion). Since avoiding them would require compilers to perform additional analysis and/or limit optimisations, the standard does not disallow satisfaction cycles outright. Our results provide an extra argument that allowing satisfaction cycles is undesirable.\n\n4. C11: Language and Thread-Local Semantics\n\nTo define the C11 model, we use a lightly modified version of its formalisation proposed by Batty et al. [1]. In the interests of simplicity, we consider a simple core language, instead of the full C/C++, and omit some of the features of the memory model. We do not handle two categories of features: those that are orthogonal to abstraction, and more esoteric features that would complicate our results. In the first category we have dynamic memory allocation, dynamic thread creation, blocked CASes and non-atomic initialisation of atomic locations (we also do not present the treatment of locks here, although we handle a bounded number of them in our formal development; see §A). In the second category we have memory fences and release-consume atomics, discussed in §9.\n\nThe semantics of a C11 program is given by a set of executions, generated in two stages. The first stage, described in this section, generates a set of action structures using a sequential thread-local semantics which takes into account only the structure of every thread’s statements, not the semantics of memory operations. In particular, the values of reads are chosen arbitrarily, without regard for writes that have taken place. The second stage, described in §5, filters out the action structures that are inconsistent with the C11 memory model. It does this by constructing additional relations and checking the resulting executions against the axioms of the model.\n\nProgramming language. We assume that the memory consists of locations from $\\mathit{Loc}$ containing values in $\\mathit{Val}$. We assume a function sort : $\\mathit{Loc} \\rightarrow (\\mathit{ATOM}, \\mathit{NA})$, showing whether memory accesses to a given location must be atomic (ATOM) or non-atomic (NA); see §2. The program syntax is as follows:\n\n```\nC ::= \\skip \\mid C_1 ; C_2 \\mid (if $x$) C \\mid \\\\else \\{C\\} \\mid while($x$) C \\mid \\\\atom_{sec} \\\\{ \\\\}\n\\mathit{LC} ::= \\{m = C_m \\mid m \\in M\\}\n\\\\mathit{LC}(C) ::= \\mathit{let} L \\in C_1 ; \\ldots ; || C_n\n```\n\nA program consists of a library $L$ implementing methods $m$ in Method and its client $C$, given by a parallel composition of threads $C_1, \\ldots, C_n$. The commands include skip, an arbitrary set of base commands $c \\in \\mathit{BComm}$ (e.g., atomic and non-atomic loads and stores, and CASes), method calls $m \\in \\mathit{Method}$, sequential composition, branching on the value of a location $x \\in \\mathit{Loc}$ and loops. Our language also includes atomic sections, ensuring that a base command executes atomically. Atomic sections are not part of C/C++, but are used here to express library specifications. We assume that every method called by the client is defined in the library, and we disallow nested method calls.\n\nWe assume that every method accepts a single parameter and returns a single value. Parameters and return values are passed by every thread via distinguished locations in memory, denoted $\\mathit{param}_t, \\mathit{retval}_t \\in \\mathit{Loc}$ for $t = 1..n$, such that $\\mathit{sort}(\\mathit{param}_t) = \\\\mathit{sort}(\\mathit{retval}_t) = \\mathit{NA}$. The rest of memory locations are partitioned into those owned by the client ($\\mathit{CLoc}$) and the library ($\\mathit{LLoc}$):\n\n```\n\\mathit{Loc} = \\mathit{CLoc} \\cup \\mathit{LLoc} \\cup \\{\\mathit{param}_t, \\mathit{retval}_t \\mid t = 1..n\\}\n```\n\nThe property of non-interference introduced in §3 then requires that a library or a client access only the memory locations belonging\nto them (except the ones used for passing parameters and return values). We provide pointers on how we can relax the constraint of static address space partitioning in §9.\n\n**Actions.** Executions are composed of actions, defined as follows:\n\n\\[\n\\begin{align*}\n\\lambda, \\mu &\\in \\text{MemOrd} \\ ::= \\text{NA} \\mid \\text{SC} \\mid \\text{ACQ} \\mid \\text{REL} \\mid \\text{RLX} \\\\\n\\varphi &\\in \\text{Effect} \\ ::= \\text{store}_\\lambda(x, a) \\mid \\text{load}_\\lambda(x, a) \\\\\n&\\quad \\mid \\text{rmw}_\\lambda(x, a, b) \\mid \\text{call}(a) \\mid \\text{ret}(a) \\\\\nu, v, w, q, r &\\in \\text{Act} \\ ::= (e, g, t, \\varphi)\n\\end{align*}\n\\]\n\nHere \\( e \\in \\text{Ald} \\) is a unique action identifier, and \\( \\lambda, \\mu \\) are memory orders (§2) of memory accesses. Every instance of an atomic section occurring in an execution has a unique identifier \\( \\varphi \\in \\text{SectId} \\). Atomic sections only have force when multiple actions have the same section identifier, so actions outside any section are simply assigned a unique identifier each. The domains of the rest of the variables are as follows: \\( t \\in \\{0, \\ldots, n\\}, x \\in \\text{Loc}, a, b \\in \\text{Val} \\). We allow actions by a dummy thread 0 to denote memory initialisation. We only consider actions whose memory orders respect location sorts given by sort, and we do not allow \\( \\text{rmw} \\) actions of sort \\( \\text{NA} \\).\n\nA read-modify-write action \\( (e, g, t, \\text{rmw}_\\lambda(x, a, b)) \\) arises from a successful compare-and-swap command. It corresponds to reading the value \\( a \\) from the location \\( x \\) and atomically overwriting it with the value \\( b \\); \\( \\lambda \\) and \\( \\mu \\) give the memory orders of the read and the write, respectively, and have to be different from NA. The value \\( a \\) in \\( (e, g, t, \\text{call}(a)) \\) or \\( (e, g, t, \\text{ret}(a)) \\) records the parameter \\( \\text{param} \\), or the return value \\( \\text{retval} \\), passed between the library method and its client. We refer to call and return actions as *interface actions*.\n\nFor an action \\( u \\) we write \\( \\text{sec}(u) \\) for its atomic section identifier, and we denote the set of all countable sets of actions by \\( \\mathcal{P}(\\text{Act}) \\). We omit \\( e, g \\) and \\( \\lambda \\) annotations from actions when they are irrelevant. We also write \\( \\_ \\) for an expression whose value is irrelevant. We use \\( (t, \\text{read}_\\lambda(x, a)) \\) to mean any of the following:\n\n\\[\n\\begin{align*}\n(t, \\text{load}_\\lambda(x, a)) &; (t, \\text{rmw}_\\lambda(x, a, a)) \\\\\n(t, \\text{call}_\\lambda(a)) &; (t, \\text{ret}_\\lambda(a))\n\\end{align*}\n\\]\n\nWe use \\( (t, \\text{write}_\\lambda(x, a)) \\) to mean \\( (t, \\text{store}_\\lambda(x, a)) \\) or \\( (t, \\text{rmw}_\\lambda(x, -a)) \\). We call the two classes of actions *read actions* and *write actions*, respectively.\n\n**Thread-local semantics.** The thread-local semantics generates a set of *action structures*—triples \\((A, s, b)\\), where \\( A \\in \\mathcal{P}(\\text{Act}) \\), and \\( s, b \\subseteq A \\times A \\) are the sequenced-before and initialised-before relations introduced in §2. We assume that \\( s, b \\) are transitive and irreflexive and relates actions by the same thread; \\( b \\) relates initialisation actions with thread identifier 0 to the others. We do not require \\( s, b \\) to be a total order: in C/C++, the order of executing certain program constructs is unspecified.\n\nFor a base command \\( c \\in \\text{BComm} \\), we assume a set \\( \\{c\\} ; \\in \\mathcal{P}(\\mathcal{P}(A) \\times \\mathcal{P}(\\mathcal{P}(A))) \\) of all pairs of action sets and \\( s, b \\) relations that \\( c \\) produces when executed by a thread \\( t \\) (the \\( b \\) relations are missing, as they are only relevant for a whole program). Note that base commands may include conditionals and loops, and thus can give rise to an arbitrary number of actions; we give a separate explicit semantics to conditionals and loops only because they are used in the most general client in §6.1. Definitions of \\( \\{c\\} ; \\) for sample base commands \\( c \\) are given in Figure 2. Note that, in the thread-local semantics, a read from memory, such as \\( \\text{load}_\\lambda(y) \\) in the figure, yields an arbitrary value. A CAS command generates an \\( \\text{rmw} \\) action, if successful, and a load, otherwise.\n\nWe define an *initial state* of a program \\( C(L) \\) by a function \\( I \\in (\\text{LLoc} \\cup \\text{CLoc}) \\rightarrow \\text{fin}(\\text{Val} \\times \\text{MemOrd}) \\), giving the initial values of memory locations, together with the memory orders of initial writes to them. We define the set of action structures \\( \\{C(L)\\} ; \\) of a program \\( C(L) \\) in Figure 3. Note that this set of action structures corresponds to complete runs of \\( C(L) \\). The clause for \\( \\text{atom} \\_ \\text{sec}(c) \\) assigns the same atomic section identifier to all actions generated by \\( c \\). The clause for a call to a method \\( m \\) brackets structures generated by its implementation \\( C_m \\) with call and return actions. We have omitted the clause for loops (§B). For simplicity, we assume that the variable in the condition of a branch is always non-atomic.\n\n**Assumptions.** We make several straightforward assumptions about the structures in \\( \\{c\\} ; \\) for \\( c \\in \\text{BComm} \\):\n\n- **Structures in \\( \\{c\\} ; \\)** are finite and contain only load, store and read-modify-write actions by \\( t \\) with unique action identifiers.\n- **For any** \\((A, s, b) \\in \\{c\\} ; \\), \\( s, b \\) is transitive and irreflexive.\n- **Structures in \\( \\{c\\} ; \\)** are insensitive to the choice of action and atomic section identifiers: applying any bijection to such identifiers from a structure in \\( \\{c\\} ; \\) produces another structure in \\( \\{c\\} ; \\).\n- **Atomic sections in every** \\((A, s, b) \\in \\{c\\} ; \\), are contiguous in \\( \\text{sb} \\):\n \\[\n \\forall u, v, q. \\text{sec}(u) = \\text{sec}(v) \\land u \\overset{sb}{\\rightarrow} q \\overset{sb}{\\rightarrow} v \\implies \\text{sec}(q) = \\text{sec}(u).\n \\]\n\nSo as not to obfuscate presentation, we only consider programs \\( C(L) \\) that use \\( \\text{param} \\) and \\( \\text{retval} \\) correctly. We assume that in any action structure of a program, only library actions by \\( t \\text{read param} \\), and write to \\( \\text{retval} \\), and only client actions by \\( t \\text{read retval} \\), and write to \\( \\text{param} \\). We also require that \\( \\text{param} \\) and \\( \\text{retval} \\) be initialised before an access: in any structure \\((A, s, b) \\in \\mathcal{C}(L) \\),\n\n\\[\n\\begin{align*}\n\\forall u &\\in (t, \\text{call} \\_). A \\exists w = (t, \\text{write}(\\text{param} \\_)). w \\overset{sb}{\\rightarrow} u \\\\\n\\forall u &\\in (t, \\text{ret} \\_). A \\exists w = (t, \\text{write}(\\text{retval} \\_)). w \\overset{sb}{\\rightarrow} u.\n\\end{align*}\n\\]\n\n**Additional assumptions without relaxed atomics.** For our result without relaxed atomics (§6.2), we currently require the following additional assumptions:\n\n- The structure set \\( \\{c\\} \\) accounts for \\( c \\) fetching any values from the memory locations it reads (see §B for formalisation).\n- Any structure of a base command \\( c \\) inside an atomic section accesses at most one atomic location. This is sufficient for our purposes, since a library specification usually accesses a single such location containing the abstract state of the library.\n- We modify the standard C11 model by requiring that a program’s semantics include structures corresponding to execution prefixes. In the standard C11 model, all executions are complete (although possibly infinite). We define \\( \\{C_i\\} \\in \\mathcal{T} \\) for a thread \\( C \\) by\n\n\\[\n\\{C}\\_i = \\{(A_p, s_p) \\mid \\exists (A, s) \\in \\{C_i\\} \\}.\n\\]\n\nThis is necessary due to the interaction between our prototype atomic section semantics and the C11 model. It weakens the notion of atomicity: atomic sections at the end of a prefix may be partially executed, and therefore more weakly ordered than their completed counterparts. Eliminating it will require a deeper understanding of the relationship between atomicity and the notion of incomplete program runs. See §6.3 for its use in the proof.\n\n5. **C11: Axiomatic Memory Model**\n\nThe axiomatic portion of the C11 model takes a set of action structures of the program, generated by the thread-local semantics in §4, and filters out those which are inconsistent with the memory model. To formulate it, we enrich action structures with extra relations.\nExecution. The semantics of a program consists of a set of executions, \\( X = \\{ A, sb, ib, rf, sc, mo, sw, hb \\} \\), where \\( A \\in \\mathcal{P}(\\text{Act}) \\) and the rest are relations on \\( A \\):\n\n- \\( sb, ib, rf \\) and \\( hb \\) introduced in §4; \\( rf \\) is such that its reverse is a partial function from read to write actions on the same location and with the same value.\n- **sequentially consistent order** (sc), ordering SC reads from and writes to the same location. The projection of \\( sc \\) to each atomic location is a transitive, irreflexive total order, while writes to distinct locations are unrelated\\(^7\\).\n- **modification order** (mo), ordering writes (but not reads!) to the same atomic (i.e., of the sort ATOM) location. The projection of \\( mo \\) to each atomic location is a transitive, irreflexive total order.\n- **synchronises-with** (sw), defining synchronisation.\n\nWe write \\( r(X) \\) for the component \\( r \\) of the execution \\( X \\).\n\nWe can now define the denotation \\( \\llbracket C(L) \\rrbracket \\) of a program and the notion of safety and non-interference introduced informally in §3. An execution \\( X \\) is **valid**, if it satisfies the validity axioms shown in Figure 4; it is **safe**, if it satisfies the safety axioms in Figure 5, and it is **non-interfering** if it satisfies the NONINTERF axiom from Figure 5. We explain the axioms shown in the rest of this section. Intuitively, validity axioms correspond to properties that are enforced by the runtime, while safety axioms correspond to properties that the programmer must ensure to avoid faults. To simplify the following explanations, Figures 4 and 5 do not show axioms dealing with CASes and locks. To keep the presentation tractable, we have also omitted some corner cases from SWDEF and SCREADS in Figure 4. The missing axioms and cases are given in §5, and our results are established for the memory model including these (the correctness of the stack in Figure 1 actually relies on a corner case in SWDEF).\n\nFor a program \\( C(L) \\) and an initial state \\( I \\), we let \\( \\llbracket C(L) \\rrbracket I \\) be the set of valid executions \\( X \\), whether safe or not, such that \\( \\langle A, sb(X), ib(X) \\rangle \\in \\llbracket C(L) \\rrbracket I \\). We write \\( \\llbracket C(L) \\rrbracket Z \\) for the set of all its \\( Z \\) for some \\( Z \\) of initial states. A program \\( C(L) \\) is safe when run from \\( I \\) if every one of its valid executions is (and similarly for non-interference and sets of initial states). An unsafe program has undefined behaviour.\n\nThe validity axioms define sw and hb directly in terms of the other relations (SWDEF and HBDEF). The \\( hb \\) relation is constructed from the \\( sb \\), ib and sw, and as follows from ACYCLICITY, has to be irreflexive. The \\( / \\) operator in the definition of \\( hb \\) is needed to handle atomic sections; for now the reader should ignore it. The \\( sw \\) relation is derived from \\( sc \\) and \\( rf \\). The \\( rf \\), \\( sc \\) and \\( mo \\) relations are only constrained by the axioms, not defined directly. We explain the validity axioms by first considering a language fragment with non-atomic memory accesses only and then gradually expanding it to include the other memory orders.\n\nNon-atomic memory accesses. The values read by non-atomic reads are constrained by DETREAD and RFNATOMIC. DETREAD requires every read to have an associated \\( rf \\) edge when the location read was previously initialised, i.e., when there is a write to it that happened before the read. Executions with reads from uninitialised locations are valid, but, as we explain below, unsafe. RFNATOMIC requires that a read only reads from the write to the same location immediately preceding it in \\( hb \\); cf. (RD). In the absence of other synchronisation, this means that a thread can read only from its own previous writes or initial values, since by HBDEF, \\( sb \\cup ib \\subseteq hb \\). Threads can establish the necessary synchronisation using atomic operations (which we explain now) or locks (which we elide here; see §5).\n\n**SC atomics.** The strong semantics of SC actions is enforced by organising all SC reads and writes over a single location into a total order \\( sc \\), which cannot form a cycle with \\( hb \\) (ACYCLICITY). According to SCREADS, an SC read can only read from the closest sc-preceding write. Thus, if all memory accesses are annotated as SC in (SB) from §2, the result shown there is forbidden. Indeed, by SCREADS and ACYCLICITY, the store of \\( 1 \\) to \\( y \\) has to follow the load of \\( 0 \\) from \\( y \\) in \\( sc \\), and similarly for \\( x \\). This yields a cycle in \\( sb \\cup sc \\), contradicting ACYCLICITY. Note that the model requires the existence of \\( sc \\), but does not include all of it into \\( hb \\). As a consequence, one cannot use the ordering of, say, two SC reads in \\( sc \\) to constrain the values that can be read according to RFNONATOMIC.\n\nBy SWDEF, an \\( rf \\) edge between an SC write and an SC read generates an sw edge, which is then included into \\( hb \\) by HBDEF. Release-acquire atomics have the same effect, as we now explain.\n\n**Release-acquire atomics.** By SWDEF, an ACQ read synchronises with the REL write it reads from. For example, if in (SCL) we annotated all writes with REL and all reads with ACQ, then the \\( rf \\) edges would be included into \\( hb \\) and the execution would be prohibited by ACYCLICITY.\n\nFor atomics weaker than SC, there is no total order on all operations over a given location analogous to \\( sc \\); this is why (SB) is allowed. Instead, they satisfy a weaker property of coherence: all writes (but not reads) to a single atomic location are organised into a total modification order \\( mo \\), which has to be consistent with \\( hb \\) (HBVSMO). SC writes to the location are also included into \\( mo \\), and in such cases the latter has to be consistent with \\( sc \\) (MOVSACC).\n\nSince reads are not included into \\( mo \\), we do not have an analogue of SCREADS, and thus, a read has more freedom to choose which write it reads from. The only constraints on atomic accesses weaker than SC are given by coherence axioms—COWR, COWR and CORR. For example, COWR says that a read \\( r \\) that happened after a write \\( w_2 \\) cannot read from a write \\( w_1 \\) earlier in \\( mo \\).\n\n**Relaxed atomics.** Like release-acquire atomics, relaxed atomics respect coherence, given by the \\( mo \\) order and the axioms COWR, CORR and CORR. However, \\( rf \\) edges involving them do not generate synchronisation edges sw. The only additional constraint on relaxed reads is given by RFATOMIC, which prohibits reads ‘from the future’, i.e., from writes later in \\( hb \\); cf. (RD). This and the fact that coherence axioms enforce no constraints on actions over distinct locations allows (SCL). If all the loads and stores in (SCL) were to the same location, it would be forbidden by CORW.\n\n**Safety axioms.** The safety axioms in Figure 5 define the conditions under which a program is faulty. DRF constrains pairs of actions over the same location, with at least one write. It requires that such pairs on distinct threads, one of which is a non-atomic access, are related by \\( hb \\), and on the same thread, by \\( sb \\) (recall that in C/C++, the order of executing certain program constructs is unspecified, and thus, \\( sb \\) is partial). SAFEBREAD prohibits reads from uninitialised locations.\n\nThe NONINTERF axiom is not part of the C11 memory model, but formalises the property of non-interference required for our results to hold (§3); it is technically convenient for us to consider it together with the other safety axioms. NONINTERF requires that the library and the client only read from and write to the locations they own, except param \\(_i\\) and retval \\(_j\\) used for communication (§4). The axiom classifies an action as performed by the library or the client depending on its position in \\( sb \\) with respect to calls and returns.\n\n**Atomic sections.** Atomic sections are a widespread idiom for defining library specifications. In an SC memory model, we can\n\n\\(^7\\)In the original C11 model [1], \\( sc \\) is a total order on SC operations over all locations. The formulation here is equivalent to the original one (SC), but more convenient for defining library abstraction.\n\\[(\\text{store}_x(x, \\text{load}_y(y))) t = \\left\\{ ((u, v), \\{ (u, v) \\}) \\mid \\exists u', e_1, e_2, g_1, g_2. e_1 \\neq e_2 \\land g_1 \\neq g_2 \\land u = (e_1, g_1, t, \\text{load}_x(y, a')) \\vee (e_2, g_2, t, \\text{store}_x(x, a')) \\right\\} \\]\n\n\\[(* y = \\text{CAS}_{x, a}(x, a, b)) t = \\left\\{ ((u, v), \\{ (u, v) \\}) \\mid \\exists u, e_1, e_2, g_1, a', e_1 \\neq e_2 \\land g_1 \\neq g_2 \\land a' \\neq a \\land (u = (e_1, g_1, t, \\text{rwv}_{x, a}(x, a, b)) \\vee (e_2, g_2, t, \\text{store}_{2a}(y, 1)) \\vee (u = (e_1, g_1, t, \\text{load}_x(x, a')) \\vee (e_2, g_2, t, \\text{store}_{2a}(y, 0))) \\right\\} \\]\n\n**Figure 2.** Definitions of \\((c)_t\\) for sample base commands. Here \\(x, y \\in \\text{Loc}\\) and \\(a, b \\in \\text{Val}\\) are constants.\n\n\\[\\langle \\text{atom}_\\text{sec} \\rangle \\{ c \\} = \\{ (e, g, t, \\varphi) \\mid (e, w, t, \\varphi) \\in A \\} \\]\n\n\\[\\langle \\text{atom}_\\text{sec} \\rangle \\{ c \\} = \\{ (e, g, t, \\varphi) \\mid (e, w, t, \\varphi) \\in A \\} \\]\n\n**Figure 3.** Thread-local semantics. \\(A \\cup B\\) is the union of the sets of actions \\(A\\) and \\(B\\) with disjoint sets of action and atomic section identifiers.\n\n**Figure 4.** Selected validity axioms of the C11 memory model. Axioms simplified for the purposes of presentation are marked by \\(^s\\).\n\n**Figure 5.** Selected safety axioms of the C11 memory model.\n\n**Figure 6.** Axioms for library (§6.1) and client (§6.3) executions.\ndefine their semantics by simply requiring that no other events are interleaved with actions inside an atomic section. Unfortunately, the relaxed memory model of C11 does not admit such a simple definition. The straightforward solution of imposing a total order on all instances of atomic sections would rule out relaxed specifications that we would like to give, such as theTreiber specification from §2. Hence, we have extended C11 with a prototype notion of atomic sections suitable for its relaxed-memory setting (inspired by the semantics of transactions in [5]). This notion represents only the first step towards a natural specification language for relaxed C11, which is an interesting problem in itself.\n\nThe axioms defining the semantics of atomic sections are HBDEF, ASMO and ASSC in Figure 4 and ATOMAS in Figure 7 (deferred to §A for brevity). They capture the expected properties of atomicity. Thus, in HBDEF, we factor \\(sb\\cup ib\\cup sw\\) over atomic sections using \\(\\sim\\); e.g., if an action \\(u\\) happens-before another action \\(v\\), then \\(u\\) also happens-before any other action from the same atomic section as \\(v\\). ASMO and ASSC require that actions from the same atomic section be contiguous in \\(mo\\) and \\(sc\\). ATOMAS constrains relaxed actions, which do not generate \\(hb\\) edges. ASMO, ASSC and ATOMAS are trivially satisfied when every action has a unique atomic section identifier. Additionally, in this case HBDEF simplifies to \\(hb = (sb\\cup ib\\cup sw)\\), which is how it is defined in standard C11 [1]. Thus, if every action executes in a separate atomic section, our augmented model coincides with standard C11.\n\n6. Library Abstraction in Detail\n\nWe first define formally the concepts used in the definition of library abstraction (Definition 2) and the Abstraction Theorem (Theorem 3) from §3 for the memory model with relaxed atomics. We then show how the Abstraction Theorem can be strengthened for a fragment of the language excluding them (§6.2) and give the proof outlines for both theorems (§6.3).\n\n6.1 Library Abstraction in the Presence of Relaxed Atomics\n\nHistory definition. We formally define the history function, which selects a history in the sense of Definition 2 from a library execution. For an execution \\(X\\), we let\n\n\\[\n\\text{history}(X) = (\\text{interf}(X), \\text{hbL}(X), \\text{scL}(X))\n\\]\n\nand lift history to sets of executions pointwise. Here \\(\\text{interf}(X)\\) is the projection of \\(A(X)\\) to interface (call and return) actions. The \\(\\text{hbL}\\) selector computes the guarantee part of the history. We let \\(\\text{hbL}(X)\\) be the projection of \\((hb(X))\\) to pairs of actions of the form \\((\\ell, \\text{call } \\cdot), (\\cdot, \\text{return } \\cdot)\\) and pairs of calls and returns (in any order) by the same thread. We record only edges of the above form, since it can be shown that any happens-before edge between interface actions in a library execution under its most general client can be obtained as a transitive closure of such edges. Intuitively, call-to-return edges are the ones that represent the synchronisation between library method invocations, as illustrated by (MP) in §2.\n\nThe \\(\\text{scL}\\) selector computes the deny part of the history. We let \\(\\text{scL}(X)\\) be the projection of \\(((hb(X))\\cup sc(X))^+)^-1\\) to pairs of actions of the form \\((\\ell, \\text{return } \\cdot), (\\cdot, \\text{call } \\cdot)\\). This component is needed, since the ACYClicity axiom (Figure 4) mandates that \\(sc\\) cannot form a cycle with \\(hb\\), but does not include \\(sc\\) into \\(hb\\). Thus, when a library relates a call action \\(u\\) to a return action \\(v\\) with \\(hb\\) and \\(sc\\), the client cannot relate \\(v\\) to \\(u\\) with the same relations, as this would invalidate ACYClicity. We add only return-to-call edges into \\(\\text{scL}(X)\\), as these are the edges that represent synchronisation inside the client (similarly how call-to-return edges represent synchronisation inside the library in \\(\\text{hbL}(X)\\)). One might think that the deny component of the history should have included edges recording potential violations of other similar axioms, e.g., HBVSMO, as suggested by (DN). However, in the case of the model with relaxed atomics, we are forced to quantify over client happens-before edges \\(R\\) in Definition 2. As it happens, this makes it unnecessary to consider axioms other than ACYClicity (see the proof of the Theorem 3 in §C). These axioms, however, have to be taken into account in the case without relaxed atomics (§6.2).\n\nLibrary-local semantics. We define the most general client as follows. Take \\(n \\geq 1\\) and let \\(\\{m_1, \\ldots, m_n\\}\\) be the methods implemented by a library \\(L\\). We let\n\n\\[\n\\text{MGC}_n(L) = (L \\in C_{mgc}^n \\ldots \\| C_{mgc}^1),\n\\]\n\nwhere \\(C_{mgc}^i\\) is\n\n\\[\n\\text{while}(\\text{non}\\text{det}(\\cdot)) \\left\\{ \\begin{array}{l}\n\\text{if}(\\text{non}\\text{det}(\\cdot)) \\{m_1\\} \\\\\n\\text{else if}(\\text{non}\\text{det}(\\cdot)) \\{m_2\\} \\ldots \\text{else } \\{m_n\\}\n\\end{array} \\right.\n\\]\n\nHere we use the obvious generalisation of loops and conditionals to branch expressions that yield a non-deterministic value. To allow parameters of methods to be chosen arbitrarily, we replace the axioms \\(\\text{DETREAD}\\) from Figure 4 and \\(\\text{SAFEREAD}\\) from Figure 5 by \\(\\text{DETREAD}_\\text{D}\\) and \\(\\text{SAFEREAD}_\\text{D}\\) from Figure 6, which mandate that reads from param\\(_i\\) lack associated \\(r\\) edges, while nonetheless yielding identical values within a single method call. As part of the proof of the Theorem 3 (§6.3), we show that this client is indeed most general in a certain formal sense (with the caveat concerning the need to extend its executions with client happens-before edges mentioned in §3).\n\nWe note that some libraries require their clients to pass only certain combinations of parameters or issue only certain sequences of method calls. Such contracts could be accommodated in our framework by restricting the most general client appropriately; we do not handle them here so as not to complicate the presentation.\n\nFor an initial library state \\( I \\in L\\text{Loc} \\rightarrow \\text{param}\\), Val \\times MemOrd, a library execution of \\(L\\) from \\(I\\) is an execution from \\([\\text{MGC}_n(L)]\\) \\(I\\) for some \\(n \\geq 1\\). A library execution is valid if it satisfies the validity axioms with \\(\\text{DETREAD}_\\text{D}\\) instead of \\(\\text{DETREAD}\\); it is safe if it satisfies the safety axioms with \\(\\text{SAFEREAD}_\\text{D}\\) instead of \\(\\text{SAFEREAD}\\). We let \\([L]I\\) be the set of all valid library executions of \\(L\\) from \\(I\\) and lift \\([L]\\) to sets of initial states pointwise. We say that a library \\(L\\) is safe when run from \\(I\\) if \\(I\\) is every execution in \\([L]I\\); for a set \\(I\\) of initial states, \\([L, I]\\) is safe if \\(L\\) is safe when run from any \\(I \\in I\\). The notion of a non-interfering library is defined similarly.\n\nExtended executions. In Definition 2, we use library executions whose happens-before relation is extended with extra edges recording constraints enforced by the client. Consider an execution \\(X\\) and a relation \\(R\\) over interface actions from \\(A(X)\\). The extension of \\(X\\) with \\(R\\) is an execution that has the same components as \\(X\\), except the happens-before relation is replaced by \\((hb(X) \\cup R)^+\\). An extension of a library execution with \\(R\\) is admissible when it satisfies the corresponding validity axioms, but with \\(\\text{HBDEF}\\) replaced by \\(\\text{EXT}\\text{HBDEF}: hb = ((sb \\cup ib \\cup sw \\cup R)\\sim)^+\\).\n\nFor an initial library state \\(I\\), we let \\([L, R]I\\) be the set of admissible executions of \\(L\\) from \\(I\\) extended with \\(R\\). This completes the definition of components used in Definition 2.\n\nExecution projections. Finally, we define the client function used in Theorem 3. Consider a valid execution \\(X\\) of \\([L]\\). An action \\(u \\in A\\) is a library action, if it is a call or return action, an action of the form \\((0, \\text{write}(x, \\cdot))\\) for \\(x \\in L\\text{Loc}\\), or if\n\n\\[\n\\exists v. v = (\\ell, \\text{call } \\cdot) \\land v \\xrightarrow{\\text{sh}(X)} u \\land \\\\\n\\neg\\exists q.q = (\\ell, \\text{return } \\cdot) \\land v \\xrightarrow{\\text{sh}(X)} q \\xrightarrow{\\text{sh}(X)} u.\n\\]\n\nAn action \\(u \\in A\\) is a client action, if it is a call or return action, it is an action of the form \\((0, \\text{write}(x, \\cdot))\\) for \\(x \\in L\\text{Loc}\\), or the negation of the above property holds. We define the execution \\(\\text{lib}(X)\\) by\nrestricting the action set to library actions and projecting all the\nrelations in \\( X \\) accordingly. We use a similar projection \\( \\text{client}(X) \\) to\nclient actions and lift client and lib to sets of executions pointwise.\n\n**Properties of library abstraction.** For the fragment of the lan-\nguage with an SC semantics—i.e., allowing only non-atomic mem-\nory accesses and SC actions—Definition 2 implies classical line-\nearizability. This follows from Theorem 3 and the fact that classi-\ncal linearizability is equivalent to observational abstraction on the\nSC memory model [6]. However, the converse is not true: since our\nnotion of library abstraction validates Theorem 3 for clients in the\nfull C11, it distinguishes between SC libraries that classical\nlinearizability would consider equivalent (see \\( \\mathbb{D} \\)).\n\nUsing Theorem 3, we can obtain the expected property that,\nlike the classical notion of linearizability, our notion of library\nabstraction is compositional (with a caveat that non-interference\namong libraries has to be checked globally). Formally, consider\nlibraries \\( L_1, \\ldots, L_k \\) with disjoint sets of declared methods and\nassume the splitting of the library address space into regions be-\nlonging to each library: \\( L_{\\text{loc}} = L_{\\text{loc}} \\cup \\cdots \\cup L_{\\text{loc}}_k \\).\nConsider sets of initial states \\( I_1, \\ldots, I_k \\) such that \\( \\forall j \\in 1..k. I_j \\subseteq I_j \\).\nWe adjust the notion of library safety so that \\( \\text{NONINTERF} \\) for \\( L_1 \\) is checked with respect to locations in \\( L_{\\text{loc}}_1 \\).\nLet \\( (L_{1}, I_{1}), \\ldots (L_{k}, I_{k}) \\) be corresponding library specifications.\nWe define \\( L_1 \\), respectively, \\( L_k \\) as the library implementing all\nmethods of \\( L_1 \\), respectively, \\( L_k \\) and having the set of initial\nstates \\( I_1 \\}, \\ldots, I_k \\), respectively, \\( I'_1 \\), respectively, \\( I'_k \\).\nWe assume that any combination of implementations or specifications of\ndifferent libraries is non-interfering. The following theorem is shown\nby abstracting \\( L_1 \\) to \\( L'_1 \\) one by one using Theorem 3.\n\n**Theorem 4.** If \\( (L_j, I_j) \\subseteq (L'_j, I'_j) \\) for \\( j = 1..k \\), then \\( L \\subseteq L' \\).\n\n### 6.2 Library Abstraction without Relaxed Atomics\n\nWe call an action with at least one RLX annotation relaxed. In this\nsection, we restrict ourselves to programs whose action structures\ndo not have any relaxed actions, and we augment the C11 thread-\nlocal semantics as described in the assumptions of \\( \\mathbb{S} \\). Among other\nthings, these changes allow us to remove the quantification over\nclient happens-before edges \\( R \\) from Definition 2, at the expense of\nincluding an additional deny relation into the history.\n\n**Definition 5.** An extended history is a quadruple \\((A, G, D, D')\\), where\n\\( A \\) is a set of interface actions, and \\( G, D, D' \\subseteq A \\times A \\).\n\nFor an execution \\( X = (A, sb, rb, rf, sc, mo, sw, hb) \\), we let\n\\( \\text{Ehistory} (X) = (\\text{interf}(X), \\text{hb}L(X), \\text{scL}(X), \\text{denyL}(X)) \\),\nwhich we lift to sets of executions pointwise. The selectors \\( \\text{interf}, \\text{hbl} \\), and \\( \\text{scL} \\) are defined as in \\( \\mathbb{S} \\).\n\nThe relation \\( \\text{denyL}(X) \\) is defined similarly to \\( \\text{scL} \\), but whereas\nthe latter records client \\( \\text{hb} \\) and \\( \\text{sc} \\) edges that can violate ACYCLIC-\nitness, the former includes the client \\( \\text{hb} \\) edges that can violate the\naxioms \\( \\text{HBVSMO} \\), \\( \\text{CoWR} \\) and \\( \\text{SCREADS} \\) (Figure 4). We do not\nhave to consider other similar axioms, such as \\( \\text{RFATOMIC} \\), \\( \\text{CoWR} \\)\nand \\( \\text{CoRR} \\) since in any valid execution \\( X \\) without relaxed actions,\nwe have \\( \\text{rf}(X) \\subseteq \\text{hb}(X) \\). Due to this, the \\( \\text{hb} \\) client edges violating,\n\\( \\text{HBVSMO} \\) and \\( \\text{CoWR} \\) and \\( \\text{CoRR} \\) can be covered by the\nsame relations. For the case of \\( \\text{HBVSMO} \\) and \\( \\text{CoWR} \\), \\( \\text{denyL}(X) \\)\nincludes the dashed edges of all possible instantiations of the follow-\nging diagrams:\n\n\\[\n\\text{w}_1 \\xrightarrow{\\text{hb}} \\text{u} \\cdot \\quad \\quad \\cdots \\quad \\quad \\quad \\text{u} \\xrightarrow{\\text{hb}} \\quad \\text{w}_2\n\\]\n\\[\n\\text{w}_1 \\xrightarrow{\\text{mo}} \\text{w}_2\n\\]\n\nwhere \\( u = (\\_, \\text{ret} \\ ) \\) and \\( v = (\\_, \\text{call} \\ ) \\). This records client\n\\( \\text{hb} \\) edges that violate \\( \\text{HBVSMO} \\) or \\( \\text{CoWR} \\) (cf. (DN) in \\( \\mathbb{S} \\)). The\ndiagrams are thus constructed systematically by 'breaking' the\n\\( \\text{hb} \\) edge. For the case of \\( \\text{SCREADS} \\), \\( \\text{denyL}(X) \\) includes edges\ncovering a corner case in this axiom omitted from Figure 4.\n\nThe full version of the axiom and the corresponding deny diagram\nare given in \\( \\mathbb{A} \\).\n\n**Definition 6.** We let \\( (A_1, G_1, D_1, D'_1) \\preceq (A_2, G_2, D_2, D'_2) \\), if\n\\( A_1 \\subseteq A_2 \\), \\( G_1 \\subseteq G_2 \\), \\( D_1 \\subseteq D_2 \\) and \\( D'_2 \\subseteq D'_1 \\).\nFor safe \\( (L_1, I_1) \\) and \\( (L_2, I_2) \\), \\( (L_1, I_1) \\) is abstracted by\n\\( (L_2, I_2) \\), written \\( (L_1, I_1) \\preceq (L_2, I_2) \\), if\n\\[\n\\forall I_1 \\in I_1, H_1 \\in \\text{Ehistory}[[L_1]], I_1 \\subseteq H_2.\n\\]\n\nUnlike in Definition 2, here an abstracted history can guarantee\nfewer happens-before edges to the client: without relaxed atoms,\nremoving edges from happens-before can only permit more client\nbehaviours or make the client unsafe. We note that checking the\ninclusion between the components of the history given by \\( \\text{denyL} \\),\nrequired by Definition 6, is simpler in practice than quantifying\nover client happens-before edges \\( R \\) in Definition 2.\n\nFor executions \\( X \\) and \\( Y \\), we write \\( X \\preceq Y \\) when all their\ncomponents except \\( \\text{hb} \\) are equal, and \\( \\text{hb}(Y) \\subseteq \\text{hb}(X) \\).\n\n**Theorem 7:** (Abstraction without relaxed atoms) Assume that\n\\( (L_1, I_1), (L_2, I_2) \\) and \\( (C(L_2), I) \\) are safe and \\( (L_1, I_1) \\preceq (L_2, I_2) \\). Then \\( (C(L_1), I) \\) is safe and\n\\[\n\\forall X \\in \\text{client}(C(L_1), (I \\supseteq I_2)).\n\\exists Y \\in \\text{client}(C(L_2), (I \\supseteq I_2)). \\quad \\text{X} \\preceq \\text{Y}.\n\\]\n\nUnlike Theorem 3, this one allows the programmer to check non-\ninterference on \\( C(L_2) \\)—i.e., with respect to a library\nspecification—and to conclude that \\( C(L_1) \\) is non-interfering. Since\nthe abstract library can have a smaller guarantee than the con-\ntinue case, the happens-before of the execution \\( C(L_2) \\) may also be\nsmaller than that of the execution \\( C(L_1) \\).\n\nLike the notion of library abstraction from \\( \\mathbb{S} \\), the one pro-\nposed here implies classical linearizability for the SC fragment of\nthe language (but not vice versa) and is compositional \\( \\mathbb{C} \\). How-\never, here the latter property does not require us to check non-\ninterference globally; a composition of several non-interfering\nlibraries is non-interfering.\n\n### 6.3 Proof Outlines\n\n**Client-local semantics.** We start by defining the client-local semantics\nof a client \\( C = C_1 \\mid \\ldots \\mid C_n \\), which is a counterpart of the\nlibrary-local semantics defined in \\( \\mathbb{S} \\). Let \\( M \\) be the set of\nmethods that can be called by \\( C \\). Consider the program\n\\[\nC() = \\{ \\text{let } \\{ m = \\text{skip} \\mid m \\in M \\} \\in C_1 \\mid \\ldots \\mid C_n \\}\n\\]\nwhere every method is implemented by a stub that returns im-\nmmediately after having been called. Moreover, we allow meth-\nods to return arbitrary values by replacing the axioms \\( \\text{DERTREAD} \\)\nfrom Figure 4 and \\( \\text{SAFERead} \\) from Figure 5 by \\( \\text{DERTREAD} \\),\nand \\( \\text{SAFERead} \\), from Figure 6. We call executions of the above pro-\ngram client executions of \\( C \\). A client execution is valid, if it sat-\nsifies the validity axioms with \\( \\text{DERTead} \\), instead of \\( \\text{DERTead} \\); it\nis safe, if it satisfies the safety axioms with \\( \\text{SAFERead} \\), instead of\n\\( \\text{SAFERead} \\). For an initial client state \\( I \\in \\text{CLoc} \\rightarrow \\text{fin} \\)\n(\\( \\text{Val} \\times \\text{MemOrd} \\)), let \\( C[I] \\) be the set of all valid client executions\nof \\( C \\) from \\( I \\); for a set \\( I \\) of initial states we define \\( C[I] \\) as expected.\nThe notion of an extended client execution is similar to the one of\nan extended library execution from \\( \\mathbb{S} \\). For an extended execution\nConsider an execution $X$ of $C(L_1)$ from the initial state $I \\uplus I_1$, where $I \\in \\mathcal{I}$ and $I_1 \\in \\mathcal{I}_1$. We start by decomposing $X$ into a client execution client($X$) and a library execution lib($X$) and showing that\n\n$$\\text{client}(X) \\in \\mathcal{C} \\cap \\text{lib}(\\text{core}(\\text{lib}(X))) \\uplus I;$$\n\n$$\\text{lib}(X) \\in L_1, \\text{hbC} \\in \\text{client}(X)) \\uplus I_1.$$ \n\nThe second inclusion justifies that the most general client of the library defined in §6.1 is indeed most general, as it can reproduce the behaviour of $L_1$ under any client $C$. This comes with the caveat that an execution of the most general client of $L_1$ has to be extended with $\\text{hbL}(\\text{core}(\\text{lib}(X)))$ to obtain $\\text{lib}(X)$, as the library-local semantics does not generate happens-before edges enforced by client synchronisation (and similarly for $\\text{client}(X)$ in the first inclusion). The upper decomposition step relies on $X$ being non-interfering. Using the fact that $\\text{hb}(L_1, 1) \\subseteq (L_2, 2)$, we prove that there exist $I_S \\in L_2$ and $Y \\in L_2, \\text{hbC}(\\text{core}(\\text{client}(X)))$ such that $X$ is smaller than that of $\\text{client}(Y)$. Here we use the quantification of client happens-before edges $R$ in Definition 2 to handle the extension of the library execution with $\\text{hbC}(\\text{core}(\\text{client}(X)))$. We then compose the executions $X$ and $Y$ into the desired execution of $C(L_2)$. This step uses the fact that the deny component of $\\text{history}(Y)$ is smaller than that of $\\text{history}(\\text{lib}(X))$. \n\nProof outline for Theorem 7. Unlike in Theorem 3, here we need to consider the case when an execution $X$ of $C(L_2)$ has actions violating non-interference. In this case, we identify an \"earliest\" faulting action $u$ and construct a valid execution that is a prefix of $X$ ending just before $u$ and is thus non-interfering. This is only possible because, without relaxed atoms, we do not have satisfaction cycles, and because the theorem is stated over an augmented thread-local semantics (§4), with prefix executions added to the semantics. We convert the resulting execution into one of $C(L_2)$ as in the proof of Theorem 3 and conjoin the action the action $u$ to it. This yields an execution of $C(L_2)$ violating non-interference and contradicting the assumption about its safety.\n\nIn the case when $X$ is non-interfering, the proof is similar to that of Theorem 3. Some additional work is needed to deal with the fact that Definition 6 does not have a quantification over client happens-before edges and allows the abstract guarantee to be smaller than the concrete one.\n\n7. Establishing Library Abstraction\n\nIn this section, we discuss the proof process for establishing abstraction between libraries in the sense of Definitions 2 and 6. To reason about programs on the C11 memory model, we use axiomatisations of the action structures generated by them, which give a simple mathematical interface to the program semantics. To prove library safety, required by Definitions 2 and 6, we consider all the execution shapes of the most general client, and check these against the C11 safety axioms. We now explain how we prove the correspondence between the executions of concrete and abstract libraries, using Definition 2 for illustration.\n\nEffect points. Consider an execution $X_1 \\in L_1, R \\uplus I_1$. We construct an execution $X_2 \\in [L_2, R] \\uplus I_2$ whose history witnesses the existential in Definition 2 using an adapted version of the linearization point method for proving lineairizability. The method constructs the abstract execution by calling a method specification at a fixed linearization point in every method invocation of the concrete execution; intuitively, it is at this point that the concrete method \"takes effect\". In our adaptation, we construct $X_2$ by substituting calls to library method implementations in $X_1$ for the corresponding calls to specifications, and choosing appropriate values for reads and different orders between actions. These values and orders are chosen based on the orders over actions we call effect points, picked for each concrete method invocation in $X_1$. Thus, the various partial orders over the effect points in the concrete execution dictate the order of precedence for the effects of method invocations in the abstract execution. In contrast with the original linearization point method, the latter order does not have to be linear. We now explain this technique in more detail on an example.\n\nExample: Treiber stack. We have proved the correctness of the stack in Figure 1b with respect to its specification in Figure 1a according to Definition 2 (full details are given in §E). As effect points in $X_1$, we pick the rmw actions modifying the stack’s top pointer $T$, which correspond to successful CASes (this is the same choice as the that of linearization points when proving the lineairizability of Treiber’s stack on an SC memory model). The order $\\text{m}(X_1)$ over these actions defines a total order over successful push and pop invocations. When substituting invocations of method implementations for invocations of specifications, we use $\\text{m}(X_1)$ to decide $\\text{rf}(X_2)$ and $\\text{m}(X_2)$ for the abstract location $S$. Namely, suppose we have two method invocations $U$ and $V$ in $X_1$, such that the rmw of $U$ is the immediate predecessor to the rmw of $V$ in $\\text{m}(X_1)$. When substituting corresponding invocations of specification methods $U’$ and $V’$, we set up $\\text{rf}(X_2)$ and $\\text{m}(X_2)$ so that the load from $S$ in $V’$ reads from the rmw in $U’$, and $\\text{m}(X_2)$ orders the rmw on $S$ in $U’$ right before the rmw on it in $V’$. Fixing $\\text{rf}(X_2)$ and $\\text{m}(X_2)$ in the abstract execution immediately fixes the values of reads, which finishes the construction of $X_2$.\n\nExample: producer-consumer queue. We have similarly verified a non-blocking producer-consumer queue according to Definition 6 (see §E). The queue is intended for communication between a single producer thread and a single consumer thread and provides three methods: $\\text{init}$, $\\text{enq}$ and $\\text{deq}$. The implementation stores values in a finite cyclic array, while the specification stores them using the abstract data type of a sequence. To ensure that the consumer calling $\\text{deq}$ observes up-to-date values, it must synchronise with the producer calling $\\text{enq}$ using release-acquire atoms.\n\n8. Related Work\n\nRelaxed-memory behaviour has become widespread in real concurrent systems. As a result, some algorithm designers have begun to publish algorithms with memory-model annotations such as fences [2, 16, 17]. However, the corresponding formulations of correctness properties and their proofs are generally informal. While there has been some work on formally verifying programs on weak memory models [13, 19, 22], none has proposed a compositional reasoning method, like we do. Ours is the first approach that formulates the notion of a correct library specification and provides a method for establishing it on C11, or any similarly relaxed model. Our work is an evolution of lineairizability [10], a correctness criterion that has been widely adopted in the concurrent algorithms community. In the SC fragment of C11, our definition of library abstraction implies classical lineairizability. History abstraction in classical lineairizability is defined by lineairization of the partial order over non-overlapping methods invocations, and the guarantee\nportion in our histories can be seen as lifting this to the C11 setting. Classical linearizability has no equivalent to our deny relation; the conflicts between relations that are captured by deny do not occur in an SC setting where all events are totally ordered.\n\nRecent work has formalised the intuition that linearizability corresponds to observational abstraction [6] and has extended it to handle liveness [8], resource-transferring programs [9] and the x86 memory model [4]. The latter work is the closest to this paper; in particular, we borrow the decompose-compose approach in the proof of the Abstraction Theorem (§6.3) from it. However, while its objective is the same as ours—abstraction for relaxed-memory concurrent libraries—the technical challenges and the machinery developed to address them are very different. The x86 memory model can be defined by a small-step operational semantics, which has an underlying total order on abstract machine memory events [18]. Linearizability for x86 is therefore a relatively mild extension to classical linearizability, which simply represents some of these events in (linear) histories. In contrast, C11 constrains relaxed behaviour through partial ordering, controlled by an axiomatic semantics. There are no abstract machine events to linearize, which motivates our novel definition of a history as a set of partial orders and history abstraction as inclusion over them. Furthermore, x86 is a substantially stronger model than C11, with (SB) from §2 being the only significant relaxation [18]. Our approach is the first technique for specifying client-visible effects of relaxations inside libraries on weaker memory models.\n\n9. Conclusion and Future Work\n\nWe have proposed the first sound criterion for library abstraction suitable for the C11 memory model and demonstrated its practicality on two small, but typical, relaxed libraries. Our criterion is certainly complex, but much of this complexity arises from the real-world intricacies of the C11 memory model. In turn, the complexity of the model arises from a multitude of target platforms of C and C++—two of the world’s most widely-used programming languages. Despite this complexity, the criterion allows developers to establish that C11 libraries satisfy simple, reusable specifications that precisely describe the level of consistency guaranteed. This is an essential ingredient for supporting modular development of complex software on relaxed memory models.\n\nIn addition, our approach is the first compositional reasoning technique for an axiomatically defined relaxed memory model, and highlights general principles for abstraction on such models. We have good reason to believe that our techniques can be reused for other memory models, as the conditions for library abstraction fall out naturally from obligations arising when trying to prove the Abstraction Theorem according to the approach in §6.3. In particular, the histories in our approach are constructed uniformly, with deny relations obtained straightforwardly from axioms by ‘breaking’ hb edges (§6.2). In particular, our preliminary investigations show that these techniques can be used to define a notion of library abstraction for an axiomatic formulation of the x86 memory model [18].\n\nOur specifications describe precisely the level of synchronisation provided by the library, although in some cases this makes them more verbose. This is motivated by the fact that libraries on C11 can offer relaxed interfaces to clients, without either giving up all synchronisation guarantees or enforcing sequential consistency. If information about the internal synchronisation used to ensure library correctness were not described in these interfaces, clients would have to duplicate it, thereby decreasing performance. On the other hand, requiring library interfaces to be SC would rule out libraries that use weaker memory orders to achieve efficiency while preserving basic correctness properties, again decreasing performance. Our prototype atomic section semantics represents a first attempt at a syntactic specification idiom for relaxed algorithms, albeit with limitations as described in §4. We leave a more comprehensive treatment of relaxed atomic sections to future work.\n\nOur two formulations of library abstraction (Definitions 2 and 6) and the Abstraction Theorem (Theorems 3 and 7) identify the feature of the current C/C++ memory model that does not allow fully compositional reasoning about libraries. As we argued in §3, this deficiency is not specific to our definition of library abstraction, but would be inherent to any sensible one. We hope that these insights will inform future revisions of the C/C++ memory model.\n\nOur development omits memory fences and release-consume atoms, which are the more advanced features of the C11 memory model. A memory fence is a synchronisation construct that affects many memory actions, rather than just one. Release-consume is a special-purpose memory order which compiles more efficiently to Power and ARM processors. We conjecture that our methods can be used to handle these features. As both of them generate more possible client-library interactions, this will require adding additional relations to histories.\n\nTo concentrate on the core challenges of library abstraction in C11, we assumed that the data structures of the client and its libraries are completely disjoint (§4). We hope to lift this restriction by combining our results with a recent generalisation of classical linearizability allowing transfers of memory ownership [9]. Similarly, a previous generalisation of linearizability to handle liveness properties [8] could be used to strengthen specifications of the kind shown in Figure 1a to guarantee properties such as lock-freedom.\n\nAcknowledgements. We would like to thank Hans Boehm, Richard Bornat, Paul McKenney, Robin Morisset, Madan Musuvathi, Peter Sewell, Jaroslav Ševčík, Hongseok Yang and John Wickerson for helpful comments. We acknowledge funding from EPSRC grants EP/F036345 and EP/H005633.\n\nReferences\n\nA. Additional Definitions for the C11 Model\n\nIn §4–5, we omitted the treatment of locks and CASes from the description of the memory model and simplified some of the axioms, even though the proofs of our theorems do not make such simplifications. Here we provide the missing definitions.\n\nWe handle programs with bounded numbers of locks \\( \\ell \\in \\text{Lock} \\) instead of \\( \\ell \\in \\text{Lock} \\) acquired and released using commands \\( \\text{lock}(\\ell) \\) and \\( \\text{unlock}(\\ell) \\), respectively. We thus extend the set of actions as follows: \\( \\varphi := \\ldots \\land \\text{lock}(\\ell) \\land \\text{lock}(\\ell) \\land \\text{block}(\\ell) \\), where \\( \\ell \\in \\text{Lock} \\). An action \\( (e, g, t, \\text{block}(\\ell)) \\) represents a deadlocked attempt to acquire a lock \\( \\ell \\). We split the set of locks into client and library ones (Lock = \\( \\text{CLock} \\cup \\text{LLock} \\)) and consider only programs where the client and the library use locks from CLock and LLock, respectively.\n\nIn Figure 7, we give the actions structures for lock operations, omitted from Figure 3, and the C11 axioms omitted from Figures 4 and 5. Note that the action structures of a whole program do not include those where a thread executes actions after blocking. To adjust the axioms to the model with locks, we require that the sc relation totally orders actions of the form \\( \\text{lock}(\\ell) \\), \\( \\text{block}(\\ell) \\) or \\( \\text{unlock}(\\ell) \\) for each lock, in addition to SC actions. The axioms ATOMRW and LOCKS define the behaviour of \\( \\text{CLOCK} \\) commands and locks. ATOMAS is an additional axiom for atomic sections, in the spirit of ATOMRW. SWDEF and SCREADS are full versions of the axioms presented in a simplified form in Figure 4. The former adds synchronisation via \\textit{release sequences} [1] (defined by the rs relation), and the latter allows SC reads from non-SC writes. SAFELock is an additional safety axiom, flagging a double unlock or a double lock in the same thread as a fault.\n\nAll the theorems stated in the paper stay valid for this extension of the model. To account for the full version of the SCREADS axiom, we add additional edges to denyL(X). For \\( X = \\{A, \\text{sb}, \\text{ib}, \\text{rf}, \\text{sc}, \\text{mo}, \\text{sw}, \\text{hb}\\} \\). denyL(X) includes the dashed edges of all possible instantiations of the following diagram:\n\n\\[\n\\text{SWDEF. } (\\forall \\ell, r, \\text{sw} \\to r \\land r = (\\text{lock}(\\ell)) \\implies \\exists u. u = (t, \\text{lock}(\\ell)) \\land u \\overset{\\text{sb}}{\\to} v \\land \\neg \\exists q. q = (\\text{(}t\\text{)}) \\land u \\overset{\\text{sc}}{\\to} v) \\land\n\\]\n\n\\[\n(\\forall \\ell, v, t. u = (t, \\text{lock}(\\ell)) \\land u \\overset{\\text{sb}}{\\to} v \\land \\neg \\exists q. q = (\\text{(}t\\text{)}) \\land u \\overset{\\text{sc}}{\\to} v) \\land\n\\]\n\n\\[\n\\text{Additional validity axioms}\n\\]\n\n\\[\n\\text{ATOMAS. } (\\forall \\ell, r, u. u \\overset{\\text{sw}}{\\to} r \\land \\text{sec}(u) = \\text{sec}(r) \\implies \\text{sec}(w) = \\text{sec}(v) \\land r = (\\text{read}(x, \\_)) \\land \\text{sort}(x) = \\text{ATOM} \\implies \\neg (w \\overset{\\text{mv}}{\\to} v) \\land\n\\]\n\n\\[\n(\\forall \\ell, v. u = (\\text{lock}(\\ell)) \\land u \\overset{\\text{sw}}{\\to} v \\implies \\exists q. q = (\\text{unlock}(\\ell)) \\land u \\overset{\\text{sc}}{\\to} q \\overset{\\text{sc}}{\\to} v)\n\\]\n\n\\[\n\\text{Additional safety axiom}\n\\]\n\n\\[\n(\\forall \\ell, v. u = (t, \\text{lock}(\\ell)) \\land u \\overset{\\text{sw}}{\\to} v \\land \\neg \\exists q. q = (\\text{(}t\\text{)}) \\land u \\overset{\\text{sc}}{\\to} v) \\land\n\\]\n\n\\[\n(\\forall \\ell, v. u = (t, \\text{lock}(\\ell)) \\land u \\overset{\\text{sw}}{\\to} v \\land \\neg \\exists q. q = (\\text{(}t\\text{)}) \\land u \\overset{\\text{sc}}{\\to} v)\n\\]\n\n\\[\n\\text{Figure 7. } \\text{Action structures for locks and additional C11 memory model axioms}\n\\]\n\nB. Auxiliary Definitions\n\nNotation. In the following we use interf and other selectors not only on executions, but also on sets of actions and relations over them. We write $I_A$ for the projection of a relation $r$ to a set of actions $A$. We write $X|_A$ for the obvious lifting to executions $X$.\n\nThe formalisation of a restriction on base commands. We formalise the requirement that the set $\\{c\\}$ account for $c$ fetching any values from the memory locations it reads (§4) as follows:\n\n\\[\n\\forall c, t. \\forall (A, sb) \\in \\{c\\}, \\forall A'. \\forall u = (e, g, t, read_{A}(x, a)) \\in A'. A' \\subseteq A \\land (\\exists v \\in A'. u \\xrightarrow{sb} v) \\land \\\\\n(\\forall q \\in A, v \\in A'. q \\xrightarrow{sb} v \\implies q \\in A') \\implies \\\\\n\\exists (A'', sb'') \\in \\{c\\}, \\exists u' = (e, g, t, read_{A'}(x, b)). A'' \\supseteq (A' \\setminus \\{u\\}) \\cup \\{u'\\} \\land \\\\\n\\forall q'' \\in (A'' \\setminus \\{u\\}) \\cup \\{u''\\} \\implies \\\\\n\\exists (A'', sb'') \\cup \\{\\langle q, u'' \\rangle | q \\in A' \\land \\langle q, u \\rangle \\in sb\\} \\land \\\\\n(\\forall q'' \\in A'', v \\in (A'' \\setminus \\{u\\}) \\cup \\{u\\}). q \\xrightarrow{sb} v \\implies \\\\\nq'' \\in ((A' \\setminus \\{u\\}) \\cup \\{u'\\}).\n\\]\n\n(1)\n\nSemantics of loops. The actions structures for loops, omitted from Figure 3, are given in Figure 8.\n\nC11 well-formedness axioms. In Figure 9, we summarise the well-formedness constraints on various relations that we stated in plain text earlier, to make references to them easier that we proved in our proofs.\n\nRelationship to the original C11 formalisation. Consider the memory model without atomic sections, i.e., without the axioms ASMO and ASSC and with HBDEF formulated as follows:\n\n\\[hb = (sb \\cup ib \\cup sw)^{+} \\]\n\nIn the formalisation of this model by Batty et al. [1], the $sc$ relation totally orders SC operations on all locations and locks. Namely, the axioms SCWF and AYCLICLITY are replaced by the following:\n\n- SCWF'. $sc$ is a transitive, irreflexive, total order on all actions of the form $(\\_, lock(\\_), \\_, unlock(\\_), \\_, call \\_, \\_, ret \\_, \\_, chg \\_)$.\n- HBVSSC. $\\neg sc\\mu_v, u, v \\xrightarrow{sc} u \\land v \\xrightarrow{hb} u$.\n- ACYCLICLITY'. $hb$ is irreflexive.\n\nLet $M_1$ be the C11 model with these axioms, and $M_2$, the model adopted in this paper. The following proposition, proved in §C.13, shows that the two are equivalent.\n\nPROPOSITION 8. 1. Every valid execution $X$ in $M_2$ is a corresponding valid execution $X'$ in $M_2$, with $sc(X') \\subseteq sc(X)$, and all other components of the execution the same.\n2. Every valid execution $X'$ in $M_2$ has a corresponding valid execution $X$ in $M_1$, with $sc(X') \\subseteq sc(X)$, and all other components of the execution the same.\n3. Consider a valid execution $X$ in $M_1$, and a valid execution $X'$ in $M_2$, such that $sc(X') \\subseteq sc(X)$, and all other components of the executions are the same. Then $X$ is safe if and only if $X'$ is safe.\n\nC. Proofs of Theorems\n\nC.1 Proof of Theorem 3 (Abstraction)\n\nPROPOSITION 9. If an execution $X$ is safe, then so is its extension with any $R$.\n\nIn particular, extensions of library executions used in Definition 2 are safe.\n\nSince action structures of base commands do not include calls and returns, by the construction in Figure 3, calls and returns in the same thread are totally related by $sb$. This implies\n\nPROPOSITION 10. For any valid execution $X$,\n\n\\[\n\\{ (u, v) \\in interf(hb(X)) | \\\\\n\\text{there exist } u = (t, _, v = (t, _)) \\in interf(sb(X)) \\}\n\\]\n\nThe following lemma states that an execution of a complete program generates two executions in the client-local and library-local semantics.\n\nLEMMA 11 (Decomposition). For any $X \\in \\llbracket C(L_{1}) \\rrbracket (I \\cup I_{1})$ satisfying NONINTERF,\n\n\\[\n\\begin{align*}\nclient(X) \\in [C, \\text{hl}(\\text{core}lib(X)))]I; \\\\\nlib(X) \\in [L_{1}, \\text{hc}(\\text{core}client(X)))]I_{1}.\n\\end{align*}\n\\]\n\nFurthermore,\n\n- $client(X)$ and $lib(X)$ satisfy NONINTERF;\n- if $X$ is unsafe, then so is either $client(X)$ or $lib(X)$; and\n- $\\text{sc}C(client(X)) \\cup \\text{sc}L(lib(X))$ is acyclic.\n\nThe following lemma states that any pair of appropriately extended client and library executions with an acyclic union of deny edges can be combined into a valid execution of the complete program.\n\nLEMMA 12 (Composition). Consider\n\n\\[\n\\begin{align*}\nX \\in [C, \\text{hl}(\\text{core}lib(Y))]I; \\\\\nY \\in [L_{2}, \\text{hc}(\\text{core}X)]I_{2},\n\\end{align*}\n\\]\n\nsuch that\n\n- $A(X) \\cap A(Y) = \\text{interf}(X) = \\text{interf}(Y)$ and otherwise action and atomic section identifiers in $A(X)$ and $A(Y)$ are different;\n- $\\text{interf}(sb(X)) = \\text{interf}(sb(Y))$;\n- $\\text{sc}C(X) \\cup \\text{sc}L(Y)$ is acyclic; and\n- $X$ and $Y$ satisfy NONINTERF.\n\nThen for some $Z \\in [C(L_{2}) \\cup (I \\cup I_{2})$ we have $X = \\text{client}(Z)$ and $Y = \\text{lib}(Z)$. Furthermore, if $X$ is unsafe, then so is $Z$.\n\nProofs of the above lemmas are given in the following sections.\n\nPROOF OF THEOREM 3. Consider $X \\in \\llbracket C(L_{1}) \\rrbracket (I \\cup I_{1})$ for $I \\in I_{1}$ and $I_{1} \\in I_{1}$. Since $X$ satisfies NONINTERF, by Lemma 11, we have that (2), (3) and the other conclusions of this lemma hold. Note that, since $(L_{1}, I_{1})$ is safe by Proposition 9, $lib(X)$ is safe. Hence, if $X$ is unsafe, then so is client$(X)$.\n\nLet $R$ be the projection of $\\text{hc}(\\text{core}client(X))$ to pairs of actions of the form $(\\_, \\text{ret} \\_, \\_, \\text{call} \\_, \\_, \\text{chg} \\_, \\_, \\text{chg} \\_, \\_, \\text{chg} \\_, \\_, \\text{chg} \\_, \\_, \\text{chg} \\_, \\_, \\text{chg} \\_, \\_, \\text{chg} \\_, \\_, \\text{chg} \\_, \\_, \\text{chg} \\_, \\_, \\text{chg} \\_)$. Then by Proposition 10,\n\n\\[\n\\text{hc}(\\text{core}client(X)) \\cup R \\subseteq \\\\\n\\text{interf(sb(client(X)))} \\subseteq \\text{interf(sb(lib(X))}).\n\\]\n\nThus, from (3), we obtain $\\text{lib}(X) \\in [L_{2}, R]I_{2}$. Since $(L_{2}, I_{2}) \\subseteq (L_{2}, I_{2})$, by Definition 2 for some $I_{2} \\in I_{2}$ and $Y \\in [L_{2}, R]I_{2}$, we have\n\n\\[\n\\text{history}(\\text{lib}(X)) = \\text{history}(Y).\n\\]\n\nHence,\n\n\\[\n\\text{interf}(Y) = \\text{interf}(\\text{lib}(X)); \\\\\n\\text{hc}(Y) = \\text{hc}(\\text{lib}(X)); \\\\\n\\text{sc}(Y) = \\text{sc}(\\text{lib}(X)),\n\\]\n\nThen\n\n\\[\n\\text{sc}(client(X)) \\cup \\text{sc}(Y) \\subseteq \\text{sc}(client(X)) \\cup \\text{sc}(\\text{lib}(X)),\n\\]\nLet $hbC(t, v) = (\\bigcup_{i=1}^{k} (\\{u_i\\} \\cup A_i) \\cup \\{u_{k+1}\\})$, $sbC(t, v)$, $\\{u \\in A_i \\cup \\{u_i\\} \\wedge v \\in A_j \\cup \\{u_j\\} \\wedge 1 \\leq i < j \\leq k\\} \\cup \\{u_i, v\\} \\cup \\{v \\in A_i\\} \\cup \\{u, u_{k+1}\\} \\cup \\{u \\in \\bigcup_{i=1}^{k} (\\{u_i\\} \\cup A_i) \\cup \\{u_{k+1}\\}\\} | (A_i, sb) \\in (C)_t \\wedge k \\geq 0 \\wedge (\\forall i. k \\exists u_i = (\\_\\_\\_\\_, t, load_{na}(a, a)) \\land a \\neq 0) \\land u_{k+1} = (\\_\\_\\_\\_, t, load_{na}(x, 0))\\} \\\\\n\\cup \\{\\bigcup_{i=1}^{k} (\\{u_i\\} \\cup A_i) \\cup \\{u\\} \\cup \\{v \\in A_j \\cup \\{u_j\\} \\wedge i < j\\} \\cup \\{(u_i, v) \\land v \\in A_i\\} | (A_i, sb) \\in (C)_t \\wedge (\\forall i. k \\exists u_i = (\\_\\_\\_\\_, t, load_{na}(a, a)) \\land a \\neq 0)\\}\n\nFigure 8. Action structures for loops\n\nand we have obtained from Lemma 11 that this is acyclic. By Proposition 10, we also have\n\n$$\\text{interf}(sb(Y)) = \\text{interf}(sb(lib(X))).$$\n\nThen from $Y \\in \\llbracket L_2, R \\rrbracket I_2$ and (4), we get\n\n$$\\text{interf}(Y) = \\text{interf}(\\text{lib}(X))) = \\text{interf}(\\text{client}(X)).$$\n\nWe have:\n\n$$\\text{interf}(Y) = \\text{interf}(\\text{lib}(X)) = \\text{interf}(\\text{client}(X)).$$\n\nSince action structures of base commands are insensitive to the choice of action and atomic section identifiers (§4), we can assume that $A(\\text{client}(X)) \\cap A(Y) = \\text{interf}(Y)$, and otherwise action and atomic section identifiers in $A(\\text{client}(X))$ and $A(Y)$ are different.\n\nThen from (2) and (5), by Lemma 12 we get that for some $Z \\in [C(L_2)](I \\cup I_2)$ we have $\\text{client}(Z) = \\text{client}(X)$. Furthermore, if $X$ is unsafe, then so is $X$. As before, then by Lemma 12, so is $Z$.\n\nThus the safety of $C(L_2)$ implies that of $C(L_1)$. \\qed\n\nC.2 Proof of Theorem 7 (Abstraction without relaxed atomics)\n\nRecall that here we restrict ourselves to programs whose action structures do not have any relaxed actions, and we prefix-close the set of action structures of every program. We use the following variation on the notion of an execution.\n\nDefinition 13. We call an execution $X$ almost-valid, if:\n\n- $X$ satisfies all the validity axioms except RFNATOMIC and possibly DETREAD;\n- $X$ violates RFNATOMIC solely because of the existence of some number of pairs of actions $u, v \\in A(X)$ accessing locations other than param, or retval, such that $u \\text{ rf}(X) v \\wedge \\neg (u \\text{ hb}(X) v)$;\n- $X$ may violate DETREAD only because DETREAD rules out some of the above edges in $rf(X)$;\n- $hb \\cup rf \\cup sc$ is acyclic.\n\nLet $[C(L)]I$ be the set of almost-valid executions of $C(L)$ from $I$. We define the notions execution extensions, library and client execution derived from the above as expected.\n\nProposition 14 (Absence of causal cycles). For a valid execution $X$ without relaxed actions, $rf(X) \\subseteq hb(X)$, and hence, $hb(X) \\cup rf(X) \\cup sc(X)$ is acyclic.\n\nThen $X$ is almost-valid.\n\nWhen $X$ has an action structure generated as in Figure 3, the inverse of this relation is well-founded; this is also true when $X$ is almost-valid.\n\nNote that the acyclicity guarantee is not valid for almost-valid executions, as the following example shows:\n\n$$\\text{store}_{g0}(\\&x, 8) \\quad \\text{load}_{w7}(\\&y, 7)$$\n\n\\text{store}_{g0}(\\&x, 8) \\quad \\text{load}_{w7}(\\&y, 7)$$\n\n\\quad \\text{store}_{g0}(\\&x, 8)$$\n\nLemma 15 (Prefix construction). Consider $X \\in [C(L)]I$ and $A' \\subseteq A(X)$ such that\n\n$$\\forall u \\in A(X). u = (0, \\_), \\Rightarrow u \\in A' \\wedge$$\n\n$$\\forall v \\in A'. \\forall u \\in A(X). u \\Rightarrow v \\Rightarrow u \\in A'. $$\n\nThen $X \\| A' \\in [C(L)]I$. The above also holds for $L$ instead of $C(L)$. It also holds for almost-valid, rather than valid, executions, provided at least one action violating RFNATOMIC is in $A'$.\n\nProposition 16. For any library execution $X$,\n\n$$\\text{interf}(hb(X)) = (\\text{hb}(L(X)) \\cup \\text{hb}(X)).$$\n\nFor any client execution $X$,\n\n$$\\text{interf}(hb(X)) = (\\text{hb}(C(X)) \\cup \\text{hb}(X)).$$\n\nProposition 17 (Execution reduction). Assume $R' \\subseteq R$ and the extension of a client or library execution $X$ with $R$ is admissible. Then its extension with $R'$ is either admissible or almost-admissible. Furthermore, if the extension of $X$ with $R$ is unsafe, then so is its extension with $R'$.\n\nLemma 18 (Read completion). If $Y \\in [C(L)]I$, then there is an execution $Z \\in [C(L)]I$ that violates DRF. The above also holds for $L$ instead of $C(L)$.\n\nLemma 19 (Appending an action). Let $X \\in [C(L)]I$ and $(A', sb', lb') \\in [C(L)]I$ be such that $X$ satisfies NONINTERF,\n\n$$A' = A(X) \\cup \\{u\\}, \\quad u = (\\_\\_\\_\\_, \\_\\_\\_\\_, \\_\\_\\_\\_), \\quad a \\in \\{\\text{read}, \\text{write}\\},$$\n\n$sb' \\subseteq sb'' \\cup \\{v\\}$.\n\nand $u$ violates NONINTERF in $(A', sb', lb')$. Then there exists $X' \\in [C(L)]I$ such that for some $v = (\\_\\_\\_\\_, a, \\_\\_\\_\\_)$ we have\n\n$$A(X') = A(X) \\cup \\{v\\},$$\n\n$sb(X') = sb(X) \\cup \\{(q, v) \\cup (q, u) \\in sb'\\}.$\nThe above also holds for \\( L \\) instead of \\( C(L) \\).\n\n**Lemma 20** (Execution extension). If the extension of a safe execution \\( X \\in [C]I \\) with \\( R \\) is admissible and safe, and \\( Y \\in [C']I' \\) is a valid and safe execution such that\n\\[ \\text{Ehistory}(X) \\preceq \\text{Ehistory}(Y), \\]\nthen its extension with \\( R \\) is also admissible and safe.\n\nFor an execution \\( X \\), we let \\( \\text{Esc}(C,X) \\) be the projection of \\((\\text{hb}(X) \\cup \\text{sc}(X) \\cup \\text{rf}(X))^+)\\) to pairs of actions of the form \\((\\text{call},.),(\\text{ret},.)\\).\n\n**Proposition 21** (Composition generalisation). Lemma 12 holds when \\( X \\) and \\( Z \\) are almost-admissible, provided \\( \\text{Esc}(C) \\cup \\text{sc}(Y) \\).\n\nProofs of the above lemmas are given in the following sections.\n\n**Proof of Theorem 7.** Let \\( n \\) be the number of threads in \\( C(L) \\). Consider \\( X' \\subseteq [C(L_1)]([I \\sqcup I_1]) \\) for \\( I \\in \\mathcal{I} \\) and \\( I_1 \\in \\mathcal{I}_1 \\). If \\( X' \\) violates \\( \\text{NONINTERF} \\), by Proposition 14, there exists an action \\( v \\in A(X') \\) that violates \\( \\text{NONINTERF} \\) such that there does not exist another action \\( u \\in A(X') \\) violating \\( \\text{NONINTERF} \\) and satisfying\n\\[ u \\xrightarrow{\\text{hb}(X')\\cup\\text{rf}(X')\\cup\\text{sc}(X')^+} v. \\]\nNote that \\( v \\) is not an interface action. Let\n\\[ A' = \\{ u | u = (0,.) \\in A(X') \\} \\cup \\{ u | u \\xrightarrow{\\text{hb}(X')\\cup\\text{rf}(X')\\cup\\text{sc}(X')^+} v \\} \\]\nand \\( X = X'|A' \\). Then by Lemma 15, \\( X \\in [C(L_1)]([I \\sqcup I_1]) \\). Furthermore, by the choice of action \\( v \\), \\( X \\) satisfies \\( \\text{NONINTERF} \\).\n\nLet \\( \\text{sb}'(X') = \\text{sb}(X')|A(X')\\cup{v} \\). Then by Proposition 14,\n\\[ (A(X) \\cup \\{ v \\}, \\text{sb}', \\text{ib}_A|A(X)|u(v)) \\subseteq (C(L_1))([I \\sqcup I_1]), \\]\n\\[ \\text{sb}(X) \\subseteq \\text{sb}', \\text{sb}' \\setminus \\text{sb}(X) \\subseteq (A(X) \\times \\{ v \\}). \\]\n\nIf \\( X' \\) satisfies \\( \\text{NONINTERF} \\), we let \\( X = X' \\).\n\nBy Lemma 11,\n\\[\n\\begin{align*}\n\\text{client}(X) & \\subseteq [C, \\text{hbl}(\\text{core}(\\text{lib}(X))))I; \\\\\n\\text{lib}(X) & \\subseteq [L_1, \\text{hbc}(\\text{core}(\\text{client}(X))))I_1.\n\\end{align*}\n\\]\nand the other conclusions of Lemma 11 hold. Note that, by Proposition 9, \\( \\text{lib}(X) \\) is safe. Hence, if \\( X \\) is unsafe, then so is \\( \\text{client}(X) \\).\n\nFrom (7) and Proposition 17, for some \\( Y_1, \\text{lib}(X) \\) is the admissible extension of \\( Y_1 \\) with \\( \\text{hbc}(\\text{core}(\\text{client}(X))) \\), where either \\( Y_1 \\subseteq [L_1]I_1 \\), or \\( Y_1 \\subseteq [C(L_1)]I_1 \\). However, in the latter case, by Lemma 18, \\( L_1 \\) is unsafe when run from \\( I_1 \\), contradicting the assumptions of the theorem. Thus, \\( Y_1 \\subseteq [L_1]I_1 \\).\n\nConsider the case when \\( X \\neq X' \\) and the action \\( v \\) is a library action. Let \\( A'' = A(Y_1) \\cup \\{ v \\} \\). From \\( \\text{sb}(Y_1) = \\text{sb}(\\text{lib}(X)) \\) and \\( \\text{sb}' \\), we can easily construct \\( \\text{sb}'' \\) such that\n\\[ (A', \\text{sb}', \\text{ib}'' \\in \\langle \\text{mgc}(Y_1), I_1, \\text{sb}(Y_1) \\subseteq \\text{sb}'', \\text{sb}' \\setminus \\text{sb}(Y_1) \\subseteq (A(X) \\times \\{ v \\}). \\]\n\nBy Lemma 19, we can then construct an execution \\( Y_2 \\subseteq [L_1]I_1 \\) that contains \\( v \\). But then this execution violates \\( \\text{NONINTERF} \\), which contradicts the safety of \\( L_1 \\). Hence, the case considered is impossible.\n\nSince \\( [L_1]I_1 \\subseteq [L_2], I_2 \\), for some \\( I_2 \\subseteq [L_2]I_2 \\) we have \\( \\text{Ehistory}(Y_1) \\preceq \\text{Ehistory}(Y_2) \\). Note that by Proposition 10, this implies\n\\[ \\text{interf}(\\text{sb}(Y_1)) = \\text{interf}(\\text{sb}(Y_2)). \\]\n\nBy (7) and Lemma 20, the execution \\( Z \\) obtained by extending \\( Y_2 \\) with \\( \\text{hbc}(\\text{core}(\\text{client}(X))) \\) is admissible and safe. Then\n\\[ Z \\subseteq [L_2, \\text{hbc}(\\text{core}(\\text{client}(X))))I_2, \\]\nand we have obtained from Lemma 11 that this is acyclic. We have:\n\\[ \\text{hb}(Y_1) = \\text{hb}(Y_2) \\subseteq \\text{hbl}(Y_1) = \\text{hbl}(\\text{core}(\\text{lib}(X))). \\]\n\nFrom (6), by Proposition 17, there exists \\( W \\) such that \\( \\text{client}(X) \\subseteq W \\).\n\\[ W \\in [C, \\text{hbl}(\\text{core}(Z))]([I \\sqcup V \\subseteq [C, \\text{hbl}(\\text{core}(Z))]I_1 \\]\nand if \\( \\text{client}(X) \\) is unsafe, then so is \\( W \\).\n\nWe have:\n\\[ \\text{interf}(Z) = \\text{interf}(Y_2) = \\text{interf}(Y_1) = \\text{interf}(\\text{lib}(X)) = \\text{interf}(\\text{client}(X)) = \\text{interf}(W). \\]\n\nSince action structures for base commands are insensitive to the choice of action and atomic section identifiers (§4), we can assume that \\( A(Z) \\cap A(W) = \\text{interf}(Z) \\), and otherwise the action and atomic section identifiers from \\( A(Z) \\) and \\( A(W) \\) are different. By (8), we also have:\n\\[ \\text{interf}(\\text{sb}(Z)) = \\text{interf}(\\text{sb}(Y_2)) = \\text{interf}(\\text{sb}(Y_1)) = \\text{interf}(\\text{lib}(X)) = \\text{interf}(\\text{client}(X)) = \\text{interf}(W). \\]\n\nSince\n\\[ \\text{Esc}(W) \\subseteq \\text{sc}(\\text{client}(X)) \\]\nwe get that\n\\[ \\text{Esc}(W) \\cup \\text{sc}(Z) \\]\nis acyclic.\n\nSince \\( \\text{hbc}(\\text{core}(W)) = \\text{hbc}(\\text{core}(\\text{client}(X))) \\), from (9) we get\n\\[ Z \\subseteq [L_2, \\text{hbc}(\\text{core}(Z))]I_2. \\]\nFrom this and (10), by Proposition 21, for some \\( V \\) we have \\( \\text{client}(X) \\subseteq W = \\text{client}(V) \\).\n\\[ V \\subseteq [C(L_2)]([I \\sqcup I_2) \\sqcup V \\subseteq [C(L_2)]([I \\sqcup I_2). \\]\nFurthermore, if \\( W \\) is unsafe, then so is \\( V \\). However, by Lemma 18, the second disjunct contradicts the safety of \\( C(L_2) \\). Hence, \\( V \\in [C(L_2)]([I \\sqcup I_2). \\]\nFurthermore, if \\( X \\) is unsafe, then so is \\( V \\).\n\nIf \\( X = X' \\), this completes the proof of the theorem.\n\nLet us now return to the case when \\( X \\) was obtained from \\( X' \\) by applying Lemma 15 with respect to the action \\( v \\). Then \\( v \\) is a client action (the case of a library action has already been covered above). Note that \\( \\text{sb}(\\text{client}(V)) = \\text{sb}(\\text{client}(X)) \\). Analogously to how it was done before, we can append \\( v \\) to \\( V \\) using Lemma 19, getting an execution \\( V' \\subseteq [C(L_2)]([I \\sqcup I_2) \\) violating \\( \\text{NONINTERF} \\) and contradicting the safety of \\( C(L_2) \\).\n\n**C.3 Proof of Lemma 11 (Decomposition)**\n\n**Proposition 22**. Consider an execution \\( X \\) a set of actions \\( B \\subseteq A(X) \\). Let \\( X' = X|_B \\). For every one of the following axioms, if \\( X \\) satisfies the axiom, then \\( X' \\) does: \\text{SBFW}, \\text{RFFW}, \\text{SCWF}, \\text{MOWF}, \\text{ATOMRMW}, \\text{ACYCLICITY}, \\text{RFNONATOMIC}, \\text{RFATOMIC}, \\text{HBVSMM}, \\text{MOVS}, \\text{CCOR}, \\text{CCWR}, \\text{covr}, \\text{ASMO}, \\text{ASSC}, \\text{ATOMAS}.\nIt is easy to show that\n\\[\n(A(\\text{client}(X)), \\text{sb}(\\text{client}(X)), \\text{ib}(\\text{client}(X))) \\in (C)_{1} I;\n\\]\n\\[\n(A(\\text{lib}(X)), \\text{sb}(\\text{lib}(X)), \\text{ib}(\\text{lib}(X))) \\in (\\text{MGCA}(L_{1})) I,\n\\]\nwhere \\(n\\) is the number of threads in \\(C(L_{1})\\). It is also easy to check that NONINTERF holds for client(X) and lib(X). We now show that client(X) and lib(X) are admissible. By Proposition 22, we only need to check the validity of LOCKS, SWDEF, SCREADS, EXTHBDEF and DETREAD, or DETREAD, we have:\n\n- LOCKS is valid, because the client and the library access disjoint sets of locks (§A).\n- Since \\(X\\) satisfies NONINTERF, mo(X) edges do not relate actions by different components; and rf(X) edges do not relate actions by different components, except accesses to param, and retval. Besides, clients and the libraries access disjoint sets of locks. Thus, SWDEF and SCREADS are valid.\n- For similar reasons, DETREADC is valid for client(X) and DETREAD, for lib(X).\n\nWe now show that EXTHBDEF holds of client(X) (the case of lib(X) is analogous). Let \\(R = \\text{hbl}(\\text{core}(\\text{lib}(X)))\\). We need to show that\n\\[\n\\text{hb}(\\text{client}(X)) = \\left( \\text{ib}(\\text{client}(X)) \\cup \\text{sb}(\\text{client}(X)) \\cup \\text{sw}(\\text{client}(X)) \\cup R \\right) \\sim^{+}.\n\\]\nWe have:\n\\[\n\\left( \\text{ib}(\\text{client}(X)) \\cup \\text{sb}(\\text{client}(X)) \\cup \\text{sw}(\\text{client}(X)) \\cup R \\right) \\sim^{+} \\subseteq \\left( \\text{ib}(X) \\cup \\text{sb}(X) \\cup \\text{sw}(X) \\cup \\text{hb}(X) \\right) \\sim^{+} \\subseteq \\text{hb}(X).\n\\]\nSince \\(\\text{ib}(\\text{client}(X)), \\text{sb}(\\text{client}(X)), \\text{sw}(\\text{client}(X)) \\) and \\(R\\) relate client actions only, this implies\n\\[\n\\left( \\text{ib}(\\text{client}(X)) \\cup \\text{sb}(\\text{client}(X)) \\cup \\text{sw}(\\text{client}(X)) \\cup R \\right) \\sim^{+} \\subseteq \\text{hb}(\\text{client}(X)).\n\\]\nLet us now show that\n\\[\n\\text{hb}(\\text{client}(X)) \\subseteq \\left( \\text{ib}(\\text{client}(X)) \\cup \\text{sb}(\\text{client}(X)) \\cup \\text{sw}(\\text{client}(X)) \\cup R \\right) \\sim^{+}.\n\\]\nConsider \\((u, v) \\in \\text{hb}(\\text{client}(X))\\). Then \\((u, v) \\in A(\\text{client}(X))\\) and there exists a path from \\(u\\) to \\(v\\), consisting of actions in \\(\\text{ib}(X) \\sim^{+} \\text{sb}(X) \\sim^{+}\\). We only consider then case when the path does not have any edges in \\(\\text{ib}(X) \\sim^{+}\\); the other case is handled trivially. By the construction in Figure 3, we can split \\(\\text{sb}(X) \\sim^{+}\\) edges to make all intermediate interface actions in the program order explicit. Since \\(X\\) satisfies NONINTERF, edges in \\(\\text{sw}(X)\\) do not relate internal actions by different components. Hence, any segment of library actions on the path starts with a call action \\(u'\\) and ends with a return action \\(v'\\). Then \\((u', v') \\in R\\). Thus, every such segment can be replaced by an edge in \\(R\\), yielding a path from \\(u\\) to \\(v\\) with edges from \\(\\text{ib}(\\text{client}(X)) \\sim^{+} \\text{sw}(\\text{client}(X)) \\sim^{+}\\) and \\(R\\). Therefore,\n\\[\n(u, v) \\in \\left( \\text{ib}(\\text{client}(X)) \\cup \\text{sb}(\\text{client}(X)) \\cup \\text{sw}(\\text{client}(X)) \\cup R \\right) \\sim^{+},\n\\]\nas required.\n\nThus, we have shown that\n\\[\n\\text{client}(X) \\in [C, \\text{hb}(\\text{core}(\\text{lib}(X)))) I;\n\\]\n\\[\n\\text{lib}(X) \\in [L_{1}, \\text{hbl}(\\text{core}(\\text{client}(X)))) I.\n\\]\nAssume that\n\\[\n\\text{scC}(\\text{client}(X)) \\cup \\text{scL}(\\text{lib}(X))\n\\]\nhas a cycle. But then this cycle can be converted into one using only edges in \\(\\text{hb}(X)\\) and \\(\\text{sc}(X)\\), contradicting ACYCLICITY. Hence, the above relation is acyclic.\n\nAssume now that \\(X\\) is unsafe, i.e., DRF, SAFEREAD or SAFELOCK is violated. Consider first the case when DRF does not hold for \\(X\\). Since \\(X\\) satisfies NONINTERF, both actions \\(u\\) and \\(v\\) violating DRF have to come from the same component. Hence, either \\(\\text{client}(X)\\) or \\(\\text{lib}(X)\\) is unsafe, as required. The case of SAFELOCK is handled similarly, using the fact that the client and the library access disjoint sets of locks. If SAFEREAD is violated in \\(X\\), then for some action \\(r = (t, \\text{read}(x, a)) \\in A(X)\\), there is no action \\(w\\) such that \\(w \\sim^{+} r\\). Consider the case when \\(r\\) is a client action (the case of a library action is handled similarly). Then there is no action \\(w\\) such that \\(w \\sim^{+} r\\). If \\(x \\neq \\text{retval}_{t}\\), then this violates SAFEREAD. If \\(x = \\text{retval}_{t}\\), then there is no action \\(u = (t, \\text{ret}_{t})\\) such that \\(u \\sim^{+} r\\), for otherwise by DETREAD for \\(X\\), we would have \\(w \\sim^{+} r\\) for some \\(w\\). But then SAFEREAD is violated in \\(X\\).\n\n□\n\nC.4 Proof of Lemma 12 (Composition)\n\nProposition 23. If one of the following axioms is violated in an execution \\(X\\) satisfying NONINTERF and with the action structure generated as in Figure 3, then all the actions involved into the violating configuration come from \\(\\text{client}(X)\\) or \\(\\text{lib}(X)\\): ATOMRMW, RFATOMIC, SCREADS, HBVSMO, MOVSSC, CoWR, CoRW, CoRR, ASMO, ASSC, ATOMAS.\n\nWe show how to construct the required\n\\[\nZ = (A, \\text{sb}, \\text{ib}, rf, sc, mo, sw, hb).\n\\]\nLet\n\\[\nA = A(X) \\cup A(Y);\n\\]\n\\[\n\\text{ib} = \\{(u, v) \\mid \\exists t. u = (t, \\_ \\in A \\land v = (t, \\_ \\in A \\land t \\neq 0)\\};\n\\]\n\\[\n\\text{sb} = (\\text{sb}(X) \\cup \\text{sb}(Y))^{+}; \\quad \\text{mo} = (\\text{mo}(X) \\cup \\text{mo}(Y)).\n\\]\nBy the assumptions of the lemma,\n\\[\nA(X) \\cap A(Y) = \\text{interf}(A(X)) = \\text{interf}(A(Y))\n\\]\nand otherwise action and atomic section identifiers in \\(A(X)\\) and \\(A(Y)\\) are different and\n\\[\n\\text{interf}(\\text{sb}(X)) = \\text{interf}(\\text{sb}(Y)).\n\\]\nThen \\((A, \\text{sb}, \\text{ib},) \\in (C(L_{2}))(I \\cup I_{2})\\), SBWF holds, and since \\(X\\) and \\(Y\\) satisfy NONINTERF, MOWF holds as well. Furthermore, the projections of \\(A, \\text{sb}, \\text{ib}\\) to client, respectively, library actions are \\(A(X), \\text{sb}(X), \\text{ib}(X), \\text{mo}(X), \\text{rf}(X), \\text{ib}(Y), \\text{mo}(Y), \\text{rf}(Y)\\). We let \\(r\\) be \\(rf(X) \\cup \\text{rf}(Y) \\cup R_{t} \\cup R_{e}, \\) where \\(R_{t}\\) contains edges relating library reads from param, to the corresponding client writes, and \\(R_{e}\\), edges relating client reads from retval to the corresponding library writes. We now define \\(R_{e}\\) formally \\((R_{e}\\) can be defined in the same way). For every action \\(r = (t, \\text{read}(\\text{param}_{t}, a)) \\in A(Y), R_{e}\\) contains an edge defined as follows. By DETREAD for \\(Y\\), for some action \\(u \\in A(X)\\) we have\n\\[\n(u, v) = (t, \\text{call } _{(a)}) \\land u \\sim^{+} \\text{ret}_{t} \\land u \\sim^{+} \\text{ib}(Y) \\sim^{+} \\text{sb}(Y) \\sim^{+} v \\sim^{+} \\text{ib}(Y) \\sim^{+} \\text{sb}(Y) \\sim^{+} r.\n\\]\nSince \\(\\text{interf}(A(X)) = \\text{interf}(A(Y))\\), we have \\(u \\in A(X)\\). By the restrictions on accesses to param, and retval, imposed in §4 and DETREAD, for \\(X\\), there exists an action \\(w = (t, \\text{write}(\\text{param}_{t}, a)) \\in X\\) such that \\(w \\sim^{+} u\\). Then the corresponding edge in \\(R_{t}\\) is \\((u, v)\\). RFWF holds for \\(r\\) defined in this way, and its projections to client and library actions are \\(rf(X)\\) and \\(rf(Y)\\).\n\nLet \\(sw = \\text{sw}(X) \\cup \\text{sw}(Y)\\) and \\(hb = (\\text{ib}, \\text{sb}, \\text{sw}) \\sim^{+}\\), so that HBDEF holds by construction. Since \\(X\\) and \\(Y\\) satisfy NONINTERF,\nthe projections of $sw$ to client and library actions are $sw(X)$ and $sw(Y)$. Let $hb_\\sim$, respectively, $hb$ be the projections of $hb$ to client, respectively, library actions. We now show that $hb_\\sim = hb(X)$ (we can show $hb = hb(Y)$ analogously). Let \n\\[ R = hbL((ib(Y) \\cup sb(Y) \\cup sw(Y))/\\sim)^+ = hbL((sb(Y) \\cup sw(Y))/\\sim)^+. \\]\n\nBy $\\text{EXTHBdef}$, we need to show that \n\\[ hb_\\sim = ((ib(X) \\cup sb(X) \\cup sw(X) \\cup R)/\\sim)^+. \\]\n\nWe have: \n\\[ ((ib(X) \\cup sb(X) \\cup sw(X) \\cup R)/\\sim)^+ \\subseteq ((ib(X) \\cup sb(X) \\cup sb(Y) \\cup sw(X) \\cup sw(Y))/\\sim)^+ \\subseteq hb. \\]\n\nSince $ib(X), sb(X), sw(X)$ and $R$ relate only client actions in $A$, this implies \n\\[ ((ib(X) \\cup sb(X) \\cup sw(X) \\cup R)/\\sim)^+ \\subseteq hb_\\sim. \\]\n\nWe now show \n\\[ hb_\\sim \\subseteq ((ib(X) \\cup sb(X) \\cup sw(X) \\cup R)/\\sim)^+. \\]\n\nConsider a path in \n\\[ ((ib(X) \\cup sb(X) \\cup sb(Y) \\cup sw(X) \\cup sw(Y))/\\sim)^+ \\]\n\nbetween two client actions. Like in the proof of Lemma 11 the case when a path has an edge from $ib(X)$ is trivial, and otherwise, any segment of library actions on the path starts with a call and ends with a return. Hence, we can replace every such segment with an edge in $R$, obtaining a path in $(ib(X) \\cup sb(X) \\cup sw(X) \\cup R)/\\sim)^+$, as required.\n\nLet $sc = sc(X) \\cup sc(Y)$. Let us now show that $\\text{ACYCLICITY}$ holds. Assume now that there is a cycle in $hb\\cup sc$ and consider the corresponding cycle with edges from \n\\[ (sb(X)/\\sim) \\cup (sb(Y)/\\sim) \\cup (sw(X)/\\sim) \\cup (sw(Y)/\\sim) \\cup sc(X) \\cup sc(Y) \\]\n\n(it is easy to see that $sb$ edges cannot participate in the cycle). As before, we can split $sb/\\sim$ edges to make all intermediate interface actions in the program order explicit. If all actions on the cycle come from only $X$ or only $Y$, we get a contradiction with $\\text{ACYCLICITY}$. Otherwise, the cycle contains at least two interface actions. Then, every segment of library actions on the cycle starts with a call and ends with a return; conversely, every segment of client actions starts with a return and ends with a call. We can thus convert every one of these segments into an edge from $(scG(X))^{-1}$ or $(scL(Y))^{-1}$ contradicting the assumptions of the lemma. Thus, $\\text{ACYCLICITY}$ holds. The $sc$ relation constructed above also validates $\\text{SCWF}$, and the projections of $sc$ to client and library actions are $sc(X)$ and $sc(Y)$. This and the fact that the client and the library use disjoint sets of locks implies that $\\text{LOCKS}$ holds for $Z$.\n\nAll of the above shows that client$(Z) = X$ and lib$(Z) = Y$.\n\nWe now show that $\\text{SWDEF}$ holds of $Z$. First, take $w$ and $r$ such that $w \\xrightarrow{sc} r$. Then either $w \\xrightarrow{sw(X)} r$ or $w \\xrightarrow{sw(Y)} r$. Since the client and library projections of $sc$, $mo$ and $rf$ coincide with the corresponding relations in $X$ and $Y$, we obtain the judgement on the right-hand side of the equivalence in $\\text{SWDEF}$ for $Z$. Assume now that the judgement holds for $Z$. Then by $\\text{NONINTERF}$ for $X$ and $Y$, all the actions involved come from the same component. Hence, again by $\\text{SWDEF}$ for $X$ and $Y$, we get $w \\xrightarrow{sw} r$.\n\nIf $\\text{RFNONATOMIC}$ is violated in $Z$, then either all actions involved into the violating configuration come from the same component, or $r$ is a read from $\\text{param}_i$ or $\\text{retval}_i$. In the former case, the violating configuration can be reproduced in $X$ or $Y$, contradicting their admissibility. In the latter case, it is easy to check that the axiom holds of $Z$ by construction of $rf$. The validity of $\\text{DETREAD}$ for $Z$ is justified similarly.\n\nBy Proposition 23, any violation of the rest of the axioms has actions coming from a single component. The edges from the relations involved exist in $X$ or $Y$, so we get a violation in one of these executions. Hence, the rest of the axioms are valid for $Z$.\n\nThus, we have shown that $Z \\in [C(L_2)](I \\cup \\varepsilon_2)$. Assume now that $X$ is unsafe, i.e., it violates $\\text{DRF}$, $\\text{SAFEREAD}_c$ or $\\text{SAFELOCK}$. Since client$(Z) = X$ and lib$(Z) = Y$, it is easy to show that in this case $Z$ violates DRF, SAFEREAD or SAFELOCK (in the case of $\\text{SAFELOCK}$ this relies on the fact that the client and the library access disjoint sets of locks).\n\n\\[ \\square \\]\n\nC.5 Proof of Proposition 14 (Absence of causal cycles)\n\nConsider $w \\xrightarrow{rf(X)} r$. If the location accessed is non-atomic, then $\\text{RFNONATOMIC}$ implies that $w \\xrightarrow{hb(X)} r$. If the location is atomic, then $w \\xrightarrow{hb(X)} r$ according to $\\text{SWDEF}$. Then $hb(X) \\cup rf(X) \\cup sc(X) = hb(X) \\cup sc(X)$. This is acyclic by $\\text{ACYCLICITY}$.\n\nWe now show that $(hb(X) \\cup rf(X) \\cup sc(X))^{-1}$ is well-founded (when $X$ is valid or almost valid). Assume there is an infinite chain in this relation. Since a program has finitely many threads, there are infinitely many actions $u_1, u_2, \\ldots$ by the same thread in the chain. Note that for $i$ and $j$ such that $i < j$, we cannot have $u_i \\xrightarrow{sb} u_j$, for this would contradict the acyclicity of $hb(X) \\cup rf(X) \\cup sc(X)$. Since action structures of base commands are finite, by the definition in Figure 3, the above chain contains infinitely many actions related by $sb$ one way or another; according to our previous observation, this has to be a chain in $sb^{-1}$. However, this relation is well-founded, which yields a contradiction.\n\n\\[ \\square \\]\n\nC.6 Proof of Lemma 15 (Prefix construction)\n\nWe only consider the case when $X$ is valid and is an execution of $C(L)$. The cases of an almost-valid execution and an execution of $L$ are handled similarly.\n\nLet $X_p = X|A$. Since $A(X_p)$ is closed under $(sb(X))^{-1}$, we know that $(A(X_p), sb(X_p), ib(X_p)) \\in (C(L))I$.\n\nBy Proposition 22, it is sufficient to check the axioms $\\text{SWDEF}$, $\\text{SCREADS}$, $\\text{LOCKS}$, $\\text{HBDEF}$ and $\\text{DETREAD}$. We have:\n\n- If $r \\in A(X_p)$ and $w \\xrightarrow{rf(X)} r$, then $w \\in A(X_p)$. Furthermore, if $w \\xrightarrow{sc} w'$ in $X$ and $w', w'' \\in A(X_p)$, then $w \\xrightarrow{sc} w''$ in $X_p$. Hence, $\\text{SWDEF}$ holds.\n- If $w \\xrightarrow{hb(X)} w_1$, then $w \\xrightarrow{hb(X)} w_1$. Also, if $w_1 \\xrightarrow{sc} w_2$ and $r \\in A(X_p)$, then $w_2, w_1 \\in A(X_p)$. Hence, $\\text{SCREADS}$ holds.\n- $\\text{LOCKS}$ is valid, since $A(X_p)$ is closed under $(sc(X))^{-1}$.\n- If $u \\xrightarrow{hb(X)} v$ and $v \\in A(X_p)$, then any action on a corresponding path of $(ib(X) \\cup sb(X) \\cup sw(X))/\\sim$ edges from $u$ to $v$ is in $A(X_p)$. Hence, $\\text{HBDEF}$ holds.\n- $\\text{DETREAD}$ holds, because $A(X_p)$ is closed under $(hb(X))^{-1}$ and $(rf(X))^{-1}$.\n\n\\[ \\square \\]\n\nC.7 Proof of Proposition 17 (Execution reduction)\n\nLet $Y$ be the extension of $X$ with $R'$. It is easy to check that, if a validity axiom other than $\\text{RFNONATOMIC}$, $\\text{DETREAD}_c$ or $\\text{DETREAD}_l$ is true of the extension of $X$ with $R$, then it is also true of $Y$, and if a safety axiom is violated in the extension of $X$ with $R$, then so it is in $Y$.\nIf \\textsc{DetRead} or \\textsc{DetReadi} (depending on whether \\(X\\) is a client or a library execution) is violated by a read action, and \\textsc{RFNonAtomic} is not violated by the same action, then we can satisfy \\textsc{DetRead} or \\textsc{DetReadi} by dropping the offending edge from \\(rf(Y)\\). We then get either an admissible or an almost-admissible execution. \\qed\n\n\\section*{C.8 Proof of Lemma 18 (Read completion)}\n\nWe consider only the case when \\(X\\) is an execution of \\(L\\); the case of \\(C(L)\\) is handled similarly.\n\nThere exist actions \\(w, r \\in A(Y)\\), such that \\(w \\xrightarrow{rf(Y)} r\\), but it is not the case that \\(w \\xrightarrow{hb(Y)} r\\). Let us chose the read action \\(r \\in A(Y)\\) violating \\textsc{RFNonAtomic} in this way such that for any other such action \\(r' \\in A(Y)\\) we do not have \\(r' \\xrightarrow{hb(Y) \\cup rf(Y) \\cup sc(Y)^*} r\\). Such an action \\(r\\) exists, since \\(hb(Y) \\cup rf(Y) \\cup sc(Y)\\) is acyclic. Let \\(w\\) be the corresponding action such that \\(w \\xrightarrow{rf(Y)} r\\).\n\nLet \\(A' = \\{ u \\mid u \\xrightarrow{hb(Y) \\cup rf(Y) \\cup sc(Y)^*} \\}\\), and let \\(Y' = Y \\cdot A'\\). Note that \\(w, r \\in A'\\) and no other read action violating \\textsc{RFNonAtomic} or \\textsc{DetReadi} is in \\(A'\\). Also, by Proposition 14, \\(\\neg \\exists u \\in \\text{read}_{\\text{qa}}(x, a)\\).\n\nIf there is no action \\(u' = (\\underline{\\text{write}}(x, _x)) \\in A(Y')\\) such that \\(w \\xrightarrow{hb(Y')} u'\\), then we construct the execution \\(Z\\) from \\(Y'\\) by dropping the offending \\(rf\\) edge \\(w \\xrightarrow{rf(Y)} r\\). The execution \\(Z\\) satisfies \\textsc{DetRead} and \\textsc{RFNonAtomic}, and thus \\(Z \\in \\{L\\}I\\). We also have \\(\\neg (w \\xrightarrow{hb(Z)} r)\\) and \\(\\neg (r \\xrightarrow{hb(Z)} w)\\), which means that \\(Z\\) violates \\textsc{DFR}.\n\nOtherwise, there exists an action \\(u'' = (\\underline{\\text{write}}(x, _b)) \\in A(Y')\\) such that \\(w \\xrightarrow{hb(Y')} u''\\). Let \\(w' = (\\underline{\\text{write}}(x, _a)) \\in A(Z)\\) we do not have \\(w' \\xrightarrow{hb(Y')} u''\\). In this case, we construct \\(Z\\) by replacing the action \\(r\\) with an action \\(r'\\) that reads \\(b\\) instead of \\(a\\) and keeps all relations isomorphic to the original ones, except the \\(rf\\) edge \\(w \\xrightarrow{rf(Y')} r'\\). The resulting execution satisfies \\textsc{DetRead} and \\textsc{RFNonAtomic}. It is easy to check that the validity of the other axioms is not affected, and thus, the execution is valid. According to (1) in \\S B, \\((A(Z), sb(Z), ib(Z), ib(Z)) \\in \\{L\\}I\\). We also have \\(\\neg (w \\xrightarrow{hb(Z)} r')\\) and \\(\\neg (r' \\xrightarrow{hb(Z)} w)\\), which means that \\(Z\\) violates \\textsc{DFR}. \\qed\n\n\\section*{C.9 Proof of Lemma 19 (Appending an action)}\n\nLet \\(X = (A, sb, ib, rf, sc, mo, sw, hb)\\).\n\nWe only consider the case when \\(X\\) is an execution of \\(C(L)\\).\n\nIf needed, we put the action \\(u\\) at the end of the corresponding suborders of \\(mo\\) and \\(sc\\), obtaining \\(mo'\\) and \\(sc'\\).\n\n\\(hb' = (sb' \\cup ib' \\cup sw')^+\\)\n\nand\n\n\\(Y = (A', sb', ib', rf, sc', mo', sw, hb')\\).\n\nThen \\textsc{SCWF}, \\textsc{MOWF}, \\textsc{MOVSSC} and \\textsc{HBDEF} hold of \\(Y\\).\n\nSince there are no outgoing \\(sb'\\) edges out of \\(u\\), the only edges in \\(hb' \\setminus hb\\) are of the form \\((\\underline{\\text{write}}(x, _u))\\). Hence, \\textsc{HBVSMO} and \\textsc{Acylic}.\n\nSince there are no outgoing \\(sc\\), \\(mo\\), \\(hb\\) edges out of \\(u\\), and no \\(rf\\) edges involving \\(u\\), the following axioms hold of \\(Y\\): \\textsc{SWDEF}, \\textsc{AtomRMW}, \\textsc{CoRR}, \\textsc{CoWR}, \\textsc{CoRW}, \\textsc{RFatomic}, \\textsc{RFNonAtomic}, \\textsc{SCreads}. Furthermore, since \\(X\\) satisfies \\textsc{NonInterf} and \\(u\\) violates it, there is no action \\(r\\) in \\(X\\) such that \\(\\text{sec}(u) = \\text{sec}(v)\\) and \\(v\\) accesses the same location as \\(u\\). Hence, \\textsc{ASMO}, \\textsc{ASSC} and \\textsc{ATOMAS} hold.\n\n\\textsc{Locks} holds for \\(Y\\), since it holds for \\(X\\). Finally, \\textsc{SBFW} and \\textsc{RFfw} hold trivially.\n\nThus, \\(Y\\) satisfies all the validity axioms, except possibly \\textsc{DetRead}. Besides, \\(hb(Y) \\cup rf(Y) \\cup sc(Y)\\) is acyclic.\n\nIf \\(u\\) is a store, then \\textsc{DetRead} is satisfied, and \\(Y\\) is the desired execution \\(X'\\). If \\(u\\) accesses a non-atomic location, then \\(Y\\) can be completed to a valid execution like in the proof of Lemma 18.\n\nConsider now the case when \\(u = (\\underline{\\text{write}}(x, _a))\\) such that \\(w \\xrightarrow{hb^d} u\\), then \\(Y\\) satisfies \\textsc{DetRead} and is the desired \\(X'\\).\n\nOtherwise, take the action \\(w = (\\underline{\\text{write}}(x, b))\\) that is the last write to \\(x\\) in \\(mo\\), if \\(u\\) is a load, and the penultimate one, if \\(u\\) is a read-modify-write. If \\(w\\) is annotated with \\(SC\\), by \\textsc{MOVSSC}, it is also the last write to \\(x\\) in \\(sc'\\), except possibly \\(u\\).\n\nLet \\(r\\) be identical to \\(u\\), except it reads \\(b\\) instead of \\(a\\) and \\(A'' = A' \\cup \\{u\\} \\cup \\{r\\}\\). Let \\(X' = (A'', sb'', ib'', rf'', sc'', mo'', sw'', hb'')\\),\n\nwhere \\(sb'\\), \\(ib'\\), \\(sc'\\), \\(mo'\\) are relations isomorphic to \\(sb, ib, sc, mo\\), but with \\(r\\) instead of \\(u\\), \\(rf'' = rf \\cup \\{w, r\\}\\), and \\(sw'' \\text{ and } hb''\\) are computed from the other relations according to \\textsc{SWDEF} and \\textsc{HBDEF}. We have that \\(sw'' \\setminus sw \\subseteq A'' \\times \\{r\\}\\), and hence, \\(hb'' \\setminus hb \\subseteq A'' \\times \\{r\\}\\) and \\textsc{Acyclic} and \\textsc{HBVSMO} hold. By (1) in \\S B, \\((A'', sb'', ib'', sc'') \\in \\{L\\}I\\). Furthermore, \\textsc{DetRead} holds of \\(X'\\).\n\nSince there are no outgoing edges from \\(r\\) in \\(hb'', sc''\\) and \\(mo''\\) are \\textsc{RFatomic}, \\textsc{SCreads} and \\textsc{CoRW} hold of \\(X'\\). By the choice of \\(w\\), we also get that \\textsc{AtomRMW}, \\textsc{CoWR} and \\textsc{CoRR} hold.\n\nSince \\(X\\) satisfies \\textsc{NonInterf} and \\(u\\) violates it, there is no action \\(v\\) in \\(X'\\) such that \\(\\text{sec}(v) = \\text{sec}(\\nu)\\) and \\(\\nu\\) accesses the same location as \\(r\\). Hence, \\textsc{ASMO}, \\textsc{ASSC} and \\textsc{ATOMAS} hold. It is easy to see that the other validity axioms hold of \\(X'\\), and thus, it is the desired execution. \\qed\n\n\\section*{C.10 Proof of Lemma 20 (Execution extension)}\n\nLet \\(Z\\) be the extension of \\(Y\\) with \\(R\\). Then \\textsc{ExtHBDEF} holds of \\(Z\\).\n\nAssume that \\textsc{Acylic} does not hold of \\(Z\\), i.e., \\((sb(Z) \\cup sc(Y))\\) has a cycle. Consider the corresponding cycle of edges in \\((sb(Y) \\cup \\{\\text{sec}(Y)\\}) \\cup \\{\\text{read}(Y)\\} \\cup R \\cup \\{\\text{sc}(Y)\\})\\) (\\(ib(Y)\\) edges cannot participate in it). If the cycle does not involve any edges in \\(R\\), then it also exists in \\(Y\\), contradicting its validity. As usual, we can split \\(sb(Y)\\) into edges to make all intermediate interface actions in the program order explicit. We can also assume that the cycle contains at least two interface actions. We can then convert the cycle into one with edges from \\((\\text{sc}(Y))^{-1} \\cup R \\subseteq (\\text{sec}(Y))^{-1} \\cup R\\) which contradicts the admissibility of \\(X\\) extended with \\(R\\).\n\nFor executions without relaxed actions, \\textsc{RFatomic} follows from \\textsc{Acylic}, and so is valid.\n\nAssume that \\textsc{RFNonAtomic} does not hold of \\(Z\\), i.e., for some \\(w, r\\) and \\(x\\), we have\n\n\\[\\text{sort}(x) = \\text{NA} \\land w \\xrightarrow{rf(Y)} r \\land w = (\\underline{\\text{write}}(x, _a)) \\land r = (\\underline{\\text{read}}(x, _a))\\]\n\nand, additionally, for some \\(w\\) we have\n\n\\[w' = (\\underline{\\text{write}}(x, _a)) \\land w \\xrightarrow{hb(Z)} w' \\xrightarrow{hb(Z)} r.\\]\nThen \\( w \\) and \\( w', w' \\) and \\( r \\), if unordered by \\( hb(Y) \\) would form a race in \\( Y \\), contradicting its safety. Hence, \\( w \\xrightarrow{hb(Y)} w' \\) or \\( w' \\xrightarrow{hb(Y)} r \\), \\( w' \\xrightarrow{hb(Y)} r \\) or \\( r \\xrightarrow{hb(Y)} w' \\). We cannot have \\( w' \\xrightarrow{hb(Y)} w \\) or \\( r \\xrightarrow{hb(Y)} w' \\), as this would give a rise to a cycle in \\( hb(Z) \\). Hence, \n\\[\n\\begin{align*}\n&w \\xrightarrow{hb(Y)} w' \\xrightarrow{rb(Y)} r .\n\\end{align*}\n\\]\nBut this contradicts the validity of RFNonAtomic for \\( Y \\).\n\nSince \\( Y \\) is safe, by SafeREAD, for any read action \\( r \\in A(Y) \\) accessing a location other than \\( param \\), we have \\( \\exists w, w \\xrightarrow{r} r \\). Hence, DETREAD holds for \\( Z \\).\n\nThe only other validity axioms that can be affected by extending \\( hb \\) with \\( R \\) are CREADS, HBvsMO, CORK, CoWR, CoRW. We show that these axioms are valid of \\( Z \\) using the fact that \n\\[\n\\text{deny}(Y) \\subseteq \\text{deny}(X).\n\\]\nWe consider only the case of HBvsMO. The cases of CORK and CREADS are considered similarly, the case of CoWR is covered by that of CoRW, and the case of CoRW, by that of HBvsMO.\n\nAssume that HBvsMO does not hold for \\( Z \\). Then for some \\( w_1 \\) and \\( w_2 \\), we have \\( w_1 \\xrightarrow{hb(Z)} w_2 \\) and \\( w_2 \\xrightarrow{mo(Y)} w_1 \\). Consider the path of edges from \n\\[\n(\\text{ib}(Y) \\sim \\cup \\text{sb}(Y) \\sim \\cup \\text{sw}(Y) \\sim \\cup R)\n\\]\nyielding \\( w_1 \\xrightarrow{hb(Z)} w_2 \\). Let us split \\( \\text{sb}(Z) \\sim \\cup \\) edges to make all intermediate interface actions in the program order explicit. The path must include edges from \\( H \\), for otherwise HBvsMO would be violated in \\( Y \\). Thus, the path includes at least two interface actions. Let \\( u \\) and \\( v \\) be the first, respectively, last interface action on it. Then \\( u \\) is a return, \\( v \\) is a call, and\n\\[\n\\begin{align*}\n&\\xrightarrow{hb(Y)} u \\xrightarrow{hb(Z)} v \\xrightarrow{mo(Y)} u.\n\\end{align*}\n\\]\nHence, \\((u, v) \\in \\text{deny}(Y) \\subseteq \\text{deny}(X)\\), so that \n\\[\n\\begin{align*}\n&\\xrightarrow{hb(X)} u \\xrightarrow{hb(Z)} v \\xrightarrow{mo(X)} u.\n\\end{align*}\n\\]\nAs usual, using the transitivity of \\( hb(Z) \\), we can eliminate non-interface actions on the path connecting \\( u \\) and \\( v \\) in \\( hb(Z) \\), showing that \n\\[\n(u, v) \\in (\\text{interf}(hb(Y)) \\cup R)^+.\n\\]\nThen by Propositions 16,\n\\[\n(u, v) \\in (\\text{ibl}(X) \\cup R)^+ \\subseteq (\\text{hb}(X) \\cup R)^+.\n\\]\nBut this contradicts the admissibility of \\( X \\) extended with \\( R \\).\n\n\\section{C.11 Proof of Proposition 21 (Composition generalisation)}\nThe only non-trivial obligation to show is the acyclicity of \\( \\text{hf}(Z) \\cup \\text{rf}(Z) \\cup \\text{sc}(Z) \\) in the case of almost-valid executions in Lemma 12. Consider the construction of the corresponding relations in this lemma and assume that \\( \\text{hf}(Z) \\cup \\text{rf}(X) \\cup \\text{sc}(Z) \\) has a cycle. It is easy to show that any such cycle can be converted into one in \n\\[\n\\text{hb}(X) \\cup \\text{rf}(X) \\cup \\text{sc}(Z)\n\\]\nor \n\\[\n\\text{EscC}(X) \\cup \\text{sc}(L)\n\\]\ncontradicting the conditions of the proposition. Thus, \\( \\text{hb}(Z) \\cup \\text{rf}(X) \\cup \\text{sc}(Z) \\) is acyclic. By Proposition 14, this implies the acyclicity of \\( \\text{hf}(Z) \\cup \\text{rf}(Z) \\cup \\text{sc}(Z) \\). \\( \\square \\)\n\n\\section{C.12 Proof of Theorem 4 (Compositionality)}\nConsider libraries \\( L_1 \\) and \\( L_2 \\) with the corresponding address spaces \\( L \\subseteq L \\subseteq L \\cup L \\cup L \\cup L \\), and initial states \\( I_1 \\) and \\( I_2 \\), such that \\( \\forall j \\subseteq 1, \\forall I \\subseteq L \\cup L \\cup L \\cup L \\). We write \\( L_1 \\cup L_2 \\) for the library obtained by concatenating their method declarations.\n\nTo simplify presentation, in our development we have assumed that any method called in a program by the client belongs to the library. Our setting and the proof of Theorems 3 and 7 can be simply generalised to allow the client to have its private methods (as before, nested method calls are disallowed).\n\nWe first show Theorem 4 for the case of programs without relaxed atoms.\n\n\\textbf{Lemma 24.} If \\((L_1, I_1)\\) and \\((L_2, I_2)\\) are safe, then so is \\((L_1 \\cup L_2, I_1 \\cup I_2)\\).\n\nThis is easily shown using the techniques from the proof of Theorem 7.\n\n\\textbf{Lemma 25.} If \\((L_2, I_2) \\subseteq (L_2, I_2)\\), and \\((L_1 \\cup L_2, I_1 \\cup I_2)\\) and \\((L_1 \\cup L_2, I_1 \\cup I_2)\\) are safe, then \n\\[\n(L_1 \\cup L_2, I_1 \\cup I_2) \\subseteq (L_1 \\cup L_2, I_1 \\cup I_2).\n\\]\n\nTheorem 4 is obtained by applying Lemma 25 repeatedly to abstract one library after another. Lemma 24 guarantees the safety of composed libraries arising during this construction.\n\nConsider an execution \\( X \\) of \\( L_1 \\cup L_2 \\). We let \\( \\text{ib}(X) \\) be the projection of \\( X \\) to actions of \\( L_1 \\); this excludes calls to and returns from the other library. We let \\( \\text{client}(X) \\) be the projection of \\( X \\) to actions excluding the internal actions by \\( L_1 \\); this includes calls to and returns from both libraries.\n\n\\textbf{Proof of Lemma 25.} Viewing \\( L_1 \\) as a client and \\( L_2 \\) as a library in \\( L_1 \\cup L_2 \\), from the above generalisation of Theorem 7, we obtain \\( \\text{client}(2)[(L_1 \\cup L_2)[(I_1 \\cup I_2) \\subseteq \\text{client}(2)[(L_1 \\cup L_2)[(I_1 \\cup I_2)\\). Consider \\( X_1 \\) \\in \\{L_1 \\cup L_2\\}[I_1 \\cup I_2\\) and a corresponding \\( X_2 \\) \\in \\{L_1 \\cup L_2\\}[I_1 \\cup I_2\\) such that \\( \\text{client}(X_1) \\subseteq \\text{client}(X_2)\\). Then \n\\[\n\\text{interf}(X_1) = \\text{interf}(X_2), \\quad \\text{ib}(X_1) \\subseteq \\text{ib}(X_2), \\quad \\text{sc}(\\text{core}(\\text{ib}(X_1))) \\subseteq \\text{sc}(\\text{core}(\\text{ib}(X_2))), \\quad \\text{deny}(\\text{core}(\\text{ib}(X_1))) \\subseteq \\text{deny}(\\text{core}(\\text{ib}(X_2))) .\n\\]\nWe need to show that \n\\[\n\\text{sc}(X) \\subseteq \\text{sc}(X), \\quad \\text{deny}(X) \\subseteq \\text{deny}(X).\n\\]\nWe only show the former inclusion; the latter is handled similarly.\n\nBy SCW, it is easy to check that for any valid and safe execution \\( X \\),\n\\[\n\\text{sc}(X) = (\\text{sc}(\\text{core}(\\text{ib}(X)))) \\cup \\text{sc}(\\text{core}(\\text{ib}(X))) \\cup \\text{interf}(\\text{sb}(X))^+ .\n\\]\nHence, we only need to show that\n\\[\n\\text{sc}(\\text{core}(\\text{ib}(X))) \\subseteq \\text{sc}(\\text{core}(\\text{ib}(X))).\n\\]\nConsider \\( u, v \\) \\in \\text{sc}(\\text{core}(\\text{ib}(X)))\\). We can trace the construction of \\( X_2 \\) from \\( X_1 \\) in the proof of Theorem 7. In this proof, \\( \\text{ib}(X_2) \\) is constructed by extending an execution \\( Y_2 \\in \\{L_2\\}[I_2\\) . Thus, \n\\[\n(u, v) \\in \\text{sc}(\\text{core}(\\text{ib}(X_2))) = \\text{sc}(\\text{lib}(X_2)).\n\\]\nThe execution \\( Y_2 \\) is obtained from an execution \\( Y_1 \\in \\{L_2\\}[I_2\\) such that \\( \\text{Ehistory}(Y_1) \\subseteq \\text{Ehistory}(Y_2)\\). Thus, \n\\[\n(u, v) \\in \\text{sc}(\\text{lib}(X_2)) \\subseteq \\text{sc}(\\text{lib}(X_1)).\n\\]\nFinally, the execution \\( \\text{lib}(X_1) \\) is obtained by extending \\( Y_1 \\). Hence,\n\\[\n(u, v) \\in \\text{sc}(\\text{lib}(X_1)) = \\text{sc}(\\text{core}(\\text{ib}(X_1)) .\n\\]\nas required.\n\nWe now turn to the case of programs with relaxed atomics. For this case, we assume that the libraries considered in Theorem 4 and all their possible combinations satisfy NONINTERF (unlike above, where this could be checked modularly using Lemma 24).\n\n**Proof of Lemma 25 in the presence of relaxed atomics.**\n\nLet $R$ be a relation containing only edges from return actions to call actions. An appropriate generalisation of Theorem 3 yields\n\n$$client_2([L_1 \\cup L_2, R][I_1 \\cup I_2]) \\subseteq client_2([L_1 \\cup L_2, R][I_1 \\cup I_2]).$$\n\nConsider $X_1 \\in [L_1 \\cup L_2, R][I_1 \\cup I_2]$ and a corresponding $X_2 \\in [L_1 \\cup L_2, R][I_1 \\cup I_2]$ such that $client_2(X_1) = client_2(X_2)$. Then\n\n$$\\text{interf}(X_1) = \\text{interf}(X_2), \\quad \\text{hbL}(X_1) = \\text{hbL}(X_2),$$\n\n$$\\text{scL}(\\text{lib}_1(X_2)) = \\text{scL}(\\text{lib}_1(X_1)).$$\n\nFrom the proof of Theorem 3, we can see that\n\n$$\\text{scL}(\\text{lib}_2(X_2)) \\subseteq \\text{scL}(\\text{lib}_2(X_1)).$$\n\nAll together, these imply\n\n$$\\text{scL}(X_2) \\subseteq \\text{scL}(X_1),$$\n\nas required.\n\n**C.13 Proof of Proposition 8 (Equivalence of Different Model Formulations)**\n\n1. Let us construct $X'$ from $X$ by projecting $\\text{sc}(X)$ per location or lock. Suppose $X'$ is invalid. We consider each of the axioms sensitive to $\\text{sc}(X')$:\n\n - If $\\text{SC}^{\\text{w'}}$ is false, then $\\text{SC}^{\\text{w}}$ could not have been true over $X$, violating our assumptions.\n - If $\\text{ACYCLICITY}$ is false, then there is a cycle in $\\text{sc}(X') \\cup \\text{hb}(X') \\subseteq \\text{sc}(X) \\cup \\text{hb}(X)$. By $\\text{HBVS}^{\\text{SC}}$ for $X$, the $\\text{hb}(X)$ edges in this cycle must all be in $\\text{sc}(X)$, and thus, we have a cycle in $\\text{sc}(X)$, violating $\\text{SC}^{\\text{w}}$ for $X$.\n - If $\\text{SCREADS}$, $\\text{LOCKS}$ or $\\text{MOVS}^{\\text{SC}}$ or $\\text{SWDE}^{\\text{F}}$ is false in $X'$, then it is false in $X$, because the validity of these axioms depends only on actions on the same location.\n\n2. Noting that $\\text{sc}(X') \\cup \\text{hb}(X')$ is acyclic, let $X$ be the execution with $\\text{sc}(X)$ be a total order on $\\text{SC}$ and lock actions including $(\\text{sc}(X') \\cup \\text{hb}(X'))^+$. Then $\\text{SC}^{\\text{w}}$ and $\\text{HBVS}^{\\text{SC}}$ hold by construction. The only other axioms that are sensitive to $\\text{sc}$ are $\\text{SCREADS}$, $\\text{LOCKS}$, $\\text{MOVS}^{\\text{SC}}$ and $\\text{SWDE}^{\\text{F}}$. However, if any of these axioms is false in $X$, then it is false in $X'$, because its validity only depends on actions on the same location.\n\n3. The only safety axiom sensitive to $\\text{sc}$ is $\\text{SAFELOCK}$ and it only depends on $\\text{sc}$ edges between actions on the same location or lock.\n\n**D. Additional counterexamples**\n\nWe now give counterexamples showing that we cannot strengthen Theorem 3 to remove differences 2 and 3 with Theorem 7 noted in §3, and that the classical linearizability does not imply our notion of library abstraction for the SC fragment of the language.\n\n2. **Weakening the guarantee in abstraction is unsound.** Consider the following two libraries:\n\n - $L_1$:\n - ```\n atomic int a;\n store_{\\text{REL}}(\\&a,0);\n void wait() {\n while (!load_{\\text{ACQ}}(\\&a));\n }\n void signal() {\n store_{\\text{REL}}(\\&a,1);\n }\n ```\n - $L_2$:\n - ```\n atomic int a;\n store_{\\text{REL}}(\\&a,0);\n void wait() {\n while (!load_{\\text{ACQ}}(\\&a));\n }\n void signal() {\n store_{\\text{REL}}(\\&a,1);\n }\n ```\n\n The library $L_1$ is abstracted by $L_2$ according to Definition 6. However, the following client $C$ can print 1 when using $L_1$, but not $L_2$:\n\n ```\n atomic int x, y, z;\n int r1 = 0, r2 = 0, r3 = 0;\n store_{\\text{SC}}(\\&x,0); store_{\\text{SC}}(\\&y,0); store_{\\text{SC}}(\\&z,0);\n r3 = \\text{load}_{\\text{RLX}}(\\&z);\n if (r3) {\n r1 = \\text{load}_{\\text{RLX}}(\\&y);\n if (r1) {\n r2 = x;\n if (r2) {\n store_{\\text{RLX}}(\\&z,1);\n print 2;\n }\n }\n }\n ```\n\n The corresponding execution of $C(L_1)$ is:\n\n ![diagram]\n\n Note that this includes a satisfaction cycle. Now, in the program $C(L_2)$, the read from $x$ in the second thread happens only when $r1$ is assigned to 1. By tracing the sequence of assignments, we can check that this will only happen if we read 1 from $x$: in the presence of satisfaction cycles, we can set things up so that a read is only executed if it reads a given value! However, the access to $x$ in the first thread cannot read 1 in $C(L_2)$, since the executions of the program have no $\\text{hb}$ edge from the write to $x$ in the third thread to its read in the second. Hence, $C(L_2)$ is safe and cannot print 1.\n\n3. **Removing quantification over client happens-before edges $R$ (even at the expense of adding the denies from §6.2 and §3) into histories is unsound.** Consider the following library $L_3$ with three methods:\n\n ```\n atomic int x, y, z;\n int r1 = 0, r2 = 0, r3 = 0;\n store_{\\text{SC}}(\\&x,0); store_{\\text{SC}}(\\&y,0); store_{\\text{SC}}(\\&z,0);\n int m1() {\n r3 = \\text{load}_{\\text{RLX}}(\\&z);\n if (r3) {\n r1 = \\text{load}_{\\text{RLX}}(\\&y);\n x = 1;\n }\n }\n ```\n\n ```\n void m2() {\n r1 = \\text{load}_{\\text{RLX}}(\\&y);\n }\n ```\n\n ```\n void m3() {\n if (r1) {\n r2 = x;\n }\n }\n ```\n\n ```\n store_{\\text{RLX}}(\\&y,r3);\n if (r2) {\n store_{\\text{RLX}}(\\&z,1);\n return r2;\n }\n ```\nWe assume that a client of the library must invoke every library method at most once and in a separate thread.\n\nConsider the following client, which is reproduces the key behaviours of the most general client of the library:\n\n\\[\nm_1 \\parallel m_2 \\parallel m_3\n\\]\n\nThis program is safe, despite non-atomic accesses to \\( x \\) in both \\( m_1 \\) and \\( m_2 \\). Like in the example above, the read from \\( x \\) in \\( m_1 \\) happens only when \\( r_1 \\) is assigned to 1, which will happen only if we read 1 from \\( x \\). However, in the above program, the access to \\( x \\) in \\( m_1 \\) cannot read 1, since the executions of the program have no hb edge from the write to \\( x \\) in \\( m_3 \\) to its read in \\( m_1 \\). For the same reason, \\( m_1 \\) always returns 0. Hence, \\( L_1 \\) is safe. It is easy to check that it is abstracted by the following specification \\( L_2 \\), according to Definition 6:\n\n\\[\n\\begin{align*}\n\\text{atomic int } x, y, z; \\\\\n\\text{int } r_1 = 0, r_2 = 0, r_3 = 0; \\\\\n\\text{store}_{\\text{SC}}(x, 0); \\text{store}_{\\text{SC}}(y, 0); \\text{store}_{\\text{SC}}(z, 0);\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\nm_1() \\{ & \\text{void m2() \\{ void m3() \\{ return 0; \\} \\}} \\\\\n& \\} \\\\\n\\}\n\\end{align*}\n\\]\n\nNow consider the following client \\( C \\) that makes \\( m_3 \\) happen before \\( m_1 \\):\n\n\\[\n\\begin{align*}\n\\text{atomic int } a; \\\\\n\\text{int } out = 0; \\\\\n\\text{store}_{\\text{SC}}(\\{a\\}, 0);\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\nm_1() \\{ & \\text{while (!load}_{\\text{ACQ}}(\\{a\\});} \\\\\n& \\text{if (m2())} \\\\\n& \\text{out = 1;} \\\\\n& \\text{print out;}\n\\end{align*}\n\\]\n\nThe program \\( C(L_2) \\) cannot print 1, but \\( C(L_1) \\) can:\n\n\\[\n\\begin{align*}\n\\text{load}_{\\text{ACQ}}(\\{a\\}, 1) \\rightarrow \\text{call m1()} \\rightarrow \\text{load}_{\\text{LC}}(\\{a\\}, 1) \\rightarrow \\text{call m2()} \\rightarrow \\text{load}_{\\text{LC}}(\\{y\\}, 1) \\rightarrow \\text{store}_{\\text{LC}}(\\{y\\}, 1) \\\\\n\\end{align*}\n\\]\n\nHence, in the presence of satisfaction cycles, the most general client is not most general: removing an hb edge enforced by the client can cause the library not to become unsafe, but just to return different values.\n\n**Classical linearizability does not imply library abstraction.**\n\nConsider the following pair of libraries \\( L_1 \\) and \\( L_2 \\):\n\n\\[\n\\begin{align*}\nL_1: & \\text{atomic int } x; \\\\\n& \\text{int } m() \\{ \\text{int } m() \\{ \\text{store}_{\\text{SC}}(\\{x\\}, 0) \\}; \\}\n\\end{align*}\n\\]\n\n\\( L_1 \\) is linearized by \\( L_2 \\) according to the classical definition. However, \\( L_1 \\) is not abstracted by \\( L_2 \\), either according to Definition 2 or Definition 6. This is because, in a history with more than one call to \\( m \\), the component given by \\( \\text{scL} \\) is empty for \\( L_1 \\), but non-empty for \\( L_2 \\). Our notion of abstraction distinguishes between the two libraries, since the presence of SC operations inside a method can prohibit certain relaxations for its clients using weaker memory operations.\n\n**E. Proofs of Example Algorithms**\n\nIn this section, we give proofs of correctness for two algorithms: the lock-free Treiber stack, and a producer-consumer queue.\n\n**E.1 Treiber’s stack**\n\nThe Treiber stack specification and implementation are given in §2.\n\n**E.1.1 Execution Axiomatization**\n\nWe start by giving axiomatisations of the stack specification and implementation. These provide simple mathematical interfaces to the underlying semantics, and make proof simpler. We give the axiomatisations as action structure shapes. These shapes are parameterised with their start and end actions, and their important values, allowing them to be substituted for one another in place. Substitution of specification executions for implementation executions plays an important role in the proof of abstraction below.\n\n**Specification**\n\nA successful push has the following shape:\n\n\\[\nS^{a, j}_{\\text{pushS}, t, i, v} \\triangleq (\\{a, \\ldots b\\}, a \\rightarrow \\ldots \\rightarrow b)\n\\]\n\nwhere\n\n\\[\n\\begin{align*}\n& a: \\text{call(\\text{push}, v)} \\\\\n& \\text{store}_{\\text{NA}}(b, \\text{nondet}) \\\\\n& \\text{load}_{\\text{NA}}(b, 0) \\\\\n& \\text{load}_{\\text{LC}}(\\{S, l\\}) \\\\\n& \\text{store}_{\\text{NA}}(s, l) \\\\\n& \\text{load}_{\\text{NA}}(v, v) \\\\\n& \\text{store}_{\\text{DG}}(s_2, \\text{append}(s_1, v_1)) \\\\\n& \\text{rmw}_{\\text{LC}}(\\{S, s, s_2\\}) \\\\\n& b: \\text{return(\\text{push})}\n\\end{align*}\n\\]\n\nA blocking failed push has the following shape:\n\n\\[\nS^{a, j}_{\\text{pushF}, t, i, v} \\triangleq (\\{a, \\ldots b\\}, a \\rightarrow \\ldots \\rightarrow b)\n\\]\n\nwhere\n\n\\[\n\\begin{align*}\n& a: \\text{call(\\text{push}, v)} \\\\\n& \\text{store}_{\\text{NA}}(b, \\text{nondet}) \\\\\n& \\text{load}_{\\text{NA}}(b, i) \\text{ such that } i \\neq 0 \\\\\n& b: \\text{block}\n\\end{align*}\n\\]\n\nA successful pop has the following shape:\n\n\\[\nS^{a, j}_{\\text{popS}, t, i} \\triangleq (\\{a, \\ldots b\\}, a \\rightarrow \\ldots \\rightarrow b)\n\\]\n\nwhere\n\n\\[\n\\begin{align*}\n& a: \\text{call(\\text{pop})} \\\\\n& \\text{store}_{\\text{NA}}(b, \\text{nondet}) \\\\\n& \\text{load}_{\\text{NA}}(b, 0) \\\\\n& \\text{load}_{\\text{LC}}(\\{S, l\\}) \\\\\n& \\text{load}_{\\text{NA}}(s, l) \\\\\n& \\text{store}_{\\text{DG}}(s_2, \\text{tail}(l')) \\\\\n& \\text{rmw}_{\\text{LC}}(\\{S, s, s_2\\}) \\\\\n& b: \\text{return(\\text{pop}, \\text{head}(s))}\n\\end{align*}\n\\]\n\nA blocking failed pop has the following shape:\n\n\\[\nS^{a, j}_{\\text{popF}, t, i} \\triangleq (\\{a, \\ldots b\\}, a \\rightarrow \\ldots \\rightarrow b)\n\\]\n\nwhere\n\n\\[\n\\begin{align*}\n& a: \\text{call(\\text{pop})} \\\\\n& \\text{store}_{\\text{NA}}(b, \\text{nondet}) \\\\\n& \\text{load}_{\\text{NA}}(b, 0) \\\\\n& b: \\text{block}\n\\end{align*}\n\\]\n\nAn empty failed pop has the following shape\n\n\\[\nS^{a, j}_{\\text{popE}, t, i} \\triangleq (\\{a, \\ldots b\\}, a \\rightarrow \\ldots \\rightarrow b)\n\\]\nwhere\n\n\\[\n\\begin{align*}\na & : \\text{call}(\\text{pop}) \\\\\n\\text{store}_{\\text{NA}}(b, \\text{nondet}) \\\\\n\\text{load}_{\\text{NA}}(b, 0) \\\\\n\\text{load}_{\\text{ACQ}}(\\&S, l) \\\\\n\\text{store}_{\\text{NA}}(s, l) \\\\\n\\text{load}_{\\text{NA}}(s, \\text{empty}) \\\\\nb & : \\text{ret}(\\text{pop}, \\text{EMPTY})\n\\end{align*}\n\\]\n\n**Implementation** We first define the following action structure corresponding to a single failed iteration of the central loop of push:\n\n\\[\nL^{a, b} \\triangleq \\begin{align*}\na & : \\text{load}_{\\text{RLX}}(s, s_t) \\\\\n\\text{store}_{\\text{NA}}(t, s_t) \\\\\n\\text{load}_{\\text{NA}}(x, x_t) \\\\\n\\text{store}_{\\text{NA}}(x_t \\rightarrow \\text{next}, t_i) \\\\\n\\text{load}_{\\text{NA}}(t, t_i) \\\\\n\\text{load}_{\\text{RLX}}(s, s_i) \\\\\n\\text{store}_{\\text{NA}}(b, 0) \\\\\nb & : \\text{load}_{\\text{NA}}(b, 0)\n\\end{align*}\n\\]\n\nWe write \\(L^{a, b}_{n, z}\\) for an action structure consisting of \\(n\\) iterations of \\(L\\), connected end to end (ie, \\(L^{a, b} \\cup L^{b, c} \\cup L^{c, d} \\cup \\ldots \\cup L^{y, z}\\)). We write \\(L^n\\), for an infinite chain.\n\nWe define a successful execution as\n\n\\[\nI^{a, p}_{\\text{pushS}, t, s, v} \\triangleq (\\{a, \\ldots, s\\} \\cup L^n, a \\rightarrow b \\rightarrow x \\rightarrow y \\rightarrow c \\rightarrow \\text{pop})\n\\]\n\nwhere the initial prefix of the action structure is defined as follows:\n\n\\[\n\\begin{align*}\na & : \\text{call}(\\text{push}, v_t) \\\\\n\\text{store}_{\\text{NA}}(t, \\text{next}) \\\\\n\\text{store}_{\\text{NA}}(x, x_t) \\\\\n\\text{load}_{\\text{NA}}(x, x_t) \\\\\nb & : \\text{store}_{\\text{NA}}(x_t \\rightarrow \\text{data}, v_1)\n\\end{align*}\n\\]\n\nand the final, successful iteration of the loop, is defined as follows:\n\n\\[\n\\begin{align*}\nc & : \\text{load}_{\\text{RLX}}(l, l) \\\\\n\\text{store}_{\\text{NA}}(l, l) \\\\\n\\text{load}_{\\text{NA}}(t, t_i) \\\\\n\\text{load}_{\\text{NA}}(x, x_t) \\\\\n\\text{store}_{\\text{NA}}(x_t \\rightarrow \\text{next}, t_i) \\\\\n\\text{load}_{\\text{NA}}(t, t_i) \\\\\n\\text{load}_{\\text{RLX}}(s, s_t) \\\\\n\\text{store}_{\\text{NA}}(b, 1) \\\\\nb & : \\text{load}_{\\text{NA}}(b, 1)\n\\end{align*}\n\\]\n\n\\[\nd : \\text{ret(\\text{push})}\n\\]\n\nWe define an action structure for a failed push as follows:\n\n\\[\nI^{a, p}_{\\text{pushF}, t} \\triangleq (\\{a, \\ldots, s\\} \\cup L^n, a \\rightarrow b \\rightarrow c \\rightarrow \\text{pop})\n\\]\n\nwhere the initial prefix of the action structure is defined as follows (identically to a successful push):\n\n\\[\n\\begin{align*}\na & : \\text{call}(\\text{push}, v_t) \\\\\n\\text{store}_{\\text{NA}}(t, \\text{next}) \\\\\n\\text{store}_{\\text{NA}}(x, x_t) \\\\\n\\text{load}_{\\text{NA}}(x, x_t) \\\\\nb & : \\text{store}_{\\text{NA}}(x_t \\rightarrow \\text{data}, v_1)\n\\end{align*}\n\\]\n\nFor pop a failed loop iteration has the following shape:\n\n\\[\nM^{a, b} \\triangleq \\begin{align*}\na & : \\text{load}_{\\text{ACQ}}(s, s_t) \\\\\n\\text{store}_{\\text{NA}}(t, s_t) \\\\\n\\text{load}_{\\text{NA}}(t, t_i) \\text{ such that } t_i \\neq \\text{NULL} \\\\\n\\text{load}_{\\text{NA}}(t, t_i') \\\\\n\\text{load}_{\\text{NA}}(t \\rightarrow \\text{next}, t_i') \\\\\n\\text{store}_{\\text{NA}}(x, t_i') \\\\\n\\text{load}_{\\text{RLX}}(s, s_t) \\\\\n\\text{load}_{\\text{NA}}(t, t_i''') \\\\\n\\text{store}_{\\text{NA}}(b, 0) \\\\\nb & : \\text{load}_{\\text{NA}}(b, 0)\n\\end{align*}\n\\]\n\nWe write \\(M^{a, b}_{n, z}\\) for an action structure consisting of \\(n\\) iterations of \\(M\\) (ie, \\(M^{a, b} \\cup M^{b, c} \\cup M^{c, d} \\cup \\ldots \\cup M^{y, z}\\)). We write \\(M^n\\) for an infinite chain.\n\nFor a successful pop, we have the following action structure:\n\n\\[\nI^{a, p}_{\\text{popS}, t, s, v} \\triangleq (\\{a, c\\} \\cup M^n, a \\rightarrow q \\rightarrow r \\rightarrow b \\rightarrow c)\n\\]\n\nThe initial action is just the call to pop.\n\n\\[\na : \\text{call}(\\text{pop})\n\\]\n\nThe suffix corresponding to the successful iteration of the main loop is defined as follows:\n\n\\[\n\\begin{align*}\nb & : \\text{load}_{\\text{ACQ}}(s, s_t) \\\\\n\\text{store}_{\\text{NA}}(t, s_t) \\\\\n\\text{load}_{\\text{NA}}(t, t_i) \\text{ such that } t_i \\neq \\text{NULL} \\\\\n\\text{load}_{\\text{NA}}(t, t_i') \\\\\n\\text{load}_{\\text{NA}}(t \\rightarrow \\text{next}, t_i') \\\\\n\\text{store}_{\\text{NA}}(x, t_i') \\\\\n\\text{load}_{\\text{RLX}}(s, s_t) \\\\\n\\text{load}_{\\text{NA}}(t, t_i''') \\\\\n\\text{load}(t_i'''') \\rightarrow \\text{data, } r \\\\\nc & : \\text{ret(\\text{pop}, } r)\n\\end{align*}\n\\]\n\nFor a blocking pop, we have the following action structure:\n\n\\[\nI^{a, b}_{\\text{popF}, t} \\triangleq (\\{a \\cup M^n, a \\rightarrow b \\rightarrow \\text{pop})\n\\]\n\nFor a failed empty pop we have\n\n\\[\nI^{a, p}_{\\text{popF}, t, s, v} \\triangleq (\\{a, c\\} \\cup M^n, a \\rightarrow q \\rightarrow r \\rightarrow b \\rightarrow c)\n\\]\n\nThe suffix corresponding to a failed iteration of the central loop is defined as follows:\n\n\\[\n\\begin{align*}\nb & : \\text{load}_{\\text{ACQ}}(s, s_t) \\\\\n\\text{store}_{\\text{NA}}(t, s_t) \\\\\n\\text{load}_{\\text{NA}}(t, \\text{NULL})\n\\end{align*}\n\\]\n\nc : \\text{ret(\\text{pop}, \\text{EMPTY})}\n\n**E.1.2 Safety**\n\nWe first define a total order \\(<\\) over calls. We choose this total order using modification order over the final rmw event in each successful push and pop. That is \\(I_1 < I_2\\) if for the rmw events \\(a_1 \\in I_1\\) and \\(a_2 \\in I_2\\), \\(a_1 \\xrightarrow{\\text{mod}} a_2\\). For failing empty pop calls, we use the rorder between rmw and acquire-reads. That is, we add such operations at the earliest point in the order such that it reads from no later operations in the order. Blocking push and pop operations have no rmw events, and so can be included anywhere in the order.\n\nLet \\(X_{\\text{imp}}\\) be an arbitrary but fixed execution of the library implementation. Define the following predicate to help with proving safety:\n\n\\[\n\\text{next(\\text{imp})}\n\\]\nQ(c) \\triangleq \\begin{array}{l}\n\\text{Either } c = \\text{null, or} \\\\\n\\text{• } c \\text{ is a location.} \\\\\n\\text{• } c \\to \\text{next and to } c \\to \\text{val are in } \\text{LLoc.} \\\\\n\\text{• There is exactly one write in the execution to } c \\to \\text{next and to } c \\to \\text{val.} \\\\\n\\text{• The write to } c \\to \\text{next has value } n \\text{ for which the predicate } Q(n) \\text{ holds.} \n\\end{array}\n\n\\text{LEMMA 26. Let } v \\text{ be the value observed by any atomic read in } X_{\\text{imp}}. \\text{ Then } Q(v) \\text{ holds in } X_{\\text{imp}}. \n\n\\text{Proof. By induction over } <. \\tag*{\\square}\n\n\\text{LEMMA 27. Any read from } T \\text{ in an implementation } \\text{pop is } hb \\text{ ordered with respect to any } i \\text{-preceding write to } T \\text{ in } \\text{push}. \n\n\\text{Proof. All writes are CASEs. Writes in } \\text{push} \\text{ are annotated release, while reads in } \\text{pop} \\text{ are annotated acquire. The result follows by appeal to the semantics of release sequences.} \\tag*{\\square}\n\n\\text{LEMMA 28. The Treiber implementation } (L_1, I_1) \\text{ is safe over the MGC.} \n\n\\text{Consider the safety axioms that could be violated.} \n\n\\text{NORTH.MIT. By Lemma 26, all locations pointed to in the stack at any point in the algorithm are in } \\text{LLoc. Other locations are method-local, and so straightforward to prove.} \n\n\\text{SAFELOCK. There are no locks in the implementation.} \n\n\\text{SAFE.READ. Follows immediately from the fact that initialisation } hb\\text{-precedes all library calls.} \n\n\\text{DRF. All reads and writes are either atomic or local to the call, aside from reads and writes from the next and val fields of nodes. Writes to these locations are succeeded by a write to } T, \\text{ the head of the list, while reads from this location are preceded by reads from } T. \\text{ All such reads-writes to } T \\text{ are ordered in } hb, \\text{ by Lemma 27. Consequently, any pair consisting of a read and write to the next or val field of a node are also } hb \\text{ related. Each node is written by exactly one action, as nodes are never reused. Therefore, we need not worry about write-write races.} \\tag*{\\square}\n\n\\text{LEMMA 29. The Treiber specification } (L_1, I_1) \\text{ is safe over the MGC.} \n\n\\text{Proof. NORTHEAST/MIT. Satisfied as the algorithm accesses a fixed set of locations. There are no locks, so SAFELOCK does not apply. SAFE.READ follows by the same argument as for the implementation. DRF is satisfied trivially as there are no non-atomic reads or writes.} \\tag*{\\square}\n\n\\text{E.1.3 Abstraction} \n\n\\text{Construc6ng a Specification Execution} \n\n\\text{DEFINITION 30. Let } R \\text{ be some arbitrary return-to-call relation. Let } X_{\\text{imp}} \\in [L_1, R][I_1], \\text{ be an arbitrary, fixed execution of the Treiber stack implementation under the MGC. We construct a corresponding execution } X_{\\text{spec}} \\text{ of the specification as follows.} \n\n\\text{We first construct an action structure } C_{\\text{spec}}. \\text{ Let } X_{\\text{imp}} = (A, sb, ib, rf, sc, mo, sw, hb) \\text{ and let } C_{\\text{imp}} = (A_{\\text{spec}}, ib_{\\text{spec}}) \\text{ be the corresponding action structure. We construct } C_{\\text{spec}} \\text{ by substituting successful implementation push operations with successful specification push operations, blocking implementation pushes with blocking specification pushes, and so on.} \n\n\\text{We use } < \\text{ to construct a function } k \\text{ on actions:} \n\n\\text{• if } I^{a,b} \\text{ is an init call, } k(a) = []; \n\\text{• if } I^{a,b} \\text{ is a successful push of } v, \\text{ and } I^{a',b'} \\text{ is the preceding call, then } k(a) = \\text{append}(k(a'), v). \n\\text{• if } I^{a,b} \\text{ is a successful pop, and } I^{a',b'} \\text{ is the preceding call, then } k(a) = \\text{tail}(v). \n\\text{• otherwise if } I^{a,b} \\text{ is a call and } I^{a',b'} \\text{ is its predecessor, } k(a) = k(a'). \n\n\\text{Starting with } C_{\\text{imp}}, \\text{ we construct the action structure as in the previous proof, by substituting calls. For each successful push, we substitute a specification for an implementation:} \n\nC' = C[S_{\\text{pushS}, t, v}^{x, y} / I^{x, y}, s_{\\text{pushS}, t, v}^{x, y}] \n\n\\text{We do the same things with successful pop and blocking push and pop. The result is an action structure } C_{\\text{spec}}. \n\n\\text{LEMMA 31. } C_{\\text{spec}} \\text{ is an action structure for the Treiber stack specification. That is } C_{\\text{spec}} \\in \\langle L_2 \\rangle I_2. \n\n\\text{Proof. Straightforward from the structure of the MGC.} \\tag*{\\square}\n\n\\text{We now construct the execution } X_{\\text{spec}}. \\text{ We take the action set and } hb \\text{ and } ib \\text{ relations from } C_{\\text{spec}}, \\text{ and construct the rest of the relations as follows:} \n\n\\text{• rf over location } s \\text{ is dictated by } <; \\text{ that is, the call reads from the write in its most recent successful predecessor. All other locations are thread-local and dictated by } sb. \n\\text{• mo over location } s \\text{ is dictated by } <. \n\\text{• sc is empty, as there are no } SC \\text{ actions.} \n\\text{• sw is determined by rf and the SWDEF axiom. Note that release sequences will generate synchronisation.} \n\\text{• hb is determined by the HBDEF axiom.} \n\n\\text{To relate the values observed in the specification execution to the implementation executions } X_{\\text{imp}}, \\text{ we define a predicate } P: \\text{ Act } \\times \\text{ Loc } \\times \\text{ List as the least fixed point of the following recursive definition:} \n\nP(c, x) \\triangleq \\begin{array}{l}\n\\text{Either } c = \\text{null, or} \\\\\n\\text{• } c \\text{ is a location, and } x \\text{ is a list of values.} \\\\\n\\text{• There exists exactly one write to } c \\to \\text{next and to } c \\to \\text{val.} \\\\\n\\text{• The write to } c \\to \\text{val has value } \\text{head}(x), \\text{ and the write to } c \\to \\text{next has value } n \\text{ for which the predicate } P(s, n, \\text{tail}(x)) \\text{ holds.} \n\\end{array}\n\n\\text{LEMMA 32. Let } I^{a,b} \\text{ be a successful push or pop operation, and } S^{a,b} \\text{ the corresponding specification operation. In } I^{a,b} \\text{ pick the final rmw operation (call this } r) \\text{ and in } S^{a,b} \\text{ similarly pick the rmw operation. Let } c \\text{ be the value read in the implementation and let } x \\text{ be the value read in the specification. The two values read in the executions are related by the predicate } P(c, x). \n\n\\text{Proof. Prove the result by induction down the order } >. \\text{ The first operation in the order reads } x = [] \\text{ and } c \\text{ = null from the initialisation, so the property holds trivially.} \n\n\\text{Now consider an arbitrary call. As } < \\text{ has been constructed to follow mo, the rmw } r \\text{ must read from it’s most recent successful } <\\text{-predecessor. By construction, the corresponding specification call must also read from it’s } <\\text{-predecessor. Now case-split on the type of the } <\\text{-preceding successful call: either push or pop.} \n\n\\text{Suppose the preceding successful call is a push. The implementation call pushes a new node onto the stack, while the specification appends the same value onto the list. We only need to show that the}\nnew value written by the rmw satisfies the predicate. The call performs no writes between the initialisation of the new node being pushed onto the stack and the rmw (and so no other inter-thread hb edges). It is easy to see from this and the structure of the thread that the new node satisfies the predicate for the value being pushed onto the stack.\n\nSuppose instead the preceding successful call is a pop. The implementation call simply redirects the top pointer to the next node in the stack. The predicate therefore holds immediately by its inductive structure.\n\n**Lemma 33.** \\(X_{\\text{spec}}\\) is valid.\n\n**Proof.**\n\nSBWF. Trivial by the structure of the substitution.\n\nRFWF. This is satisfied by construction for all reads and writes aside from the return value for a successful pop. For this, we need to show that the value written to the return value is the same as the one read in the client. Lemma 32 shows that the sequence of values readable from the stack in any call corresponds to the values in the specification list. We can therefore conclude that the return value is set correctly.\n\nSCWF and SCReads. Irrelevant, as there are no SCactions.\n\nMOWF. By construction only atomic write actions are ordered in mo.\n\nATOMRmw. By construction, mo follows <, which is dictated by rf.\n\nLocks. Irrelevant, as there are no locks.\n\nBlock. By construction, block actions have no se-successors.\n\nRFAtomic. By construction, hb over the internal actions of library calls must agree with rf: intra-thread rf edges are ordered by sb, while intra-thread hb-ordering must follow <. For rf to disagree with hb, there must be a client return-to-call order in \\(R\\) between two calls which disagrees with <. But any such order that could violate RFAtomic in the specification execution would also violate RFAtomic in \\(X_{\\text{imp}}\\). The result thus follows by contradiction.\n\nAcyclicity and HBVsMO. By the same argument as RFAtomic: violating the axiom in the constructed specification execution would mean that the axiom was violated in the implementation execution, contradicting the assumption.\n\nCoRW, CoWR and CoRR. By construction, reads follow mo, satisfying CoRW. Any execution violating CoWR or CoRR would violate the same axioms in the implementation execution.\n\nRFNonAtomic. Trivial as all non-atomic stores are local to a single call.\n\nDetRead. Satisfied trivially by the construction, and by the presence of the initialisation operation hb-preceding any of the calls.\n\nASMO and ASSC. There are no single atomic sections with multiple mo-related actions, and there are no se-related actions at all.\n\nATOMAS. For the first consequent, both rf and mo are constructed to follow <, which ensures that they conform to the axiom. The second consequent requires that all the reads in an atomic section to the same location read from the same value. This holds by construction for our execution, because all reads follow <. The third consequent is satisfied trivially because each atomic section contains at most one write.\n\n**Lemma 34.** \\(X_{\\text{spec}} \\in [L_2][I_2]\\).\n\n**Proof.** Appeal to Lemmas 31 and 33.\n\n**Inclusion over histories**\n\n**Lemma 35.** \\(\\text{history}(X_{\\text{imp}}) \\subseteq \\text{history}(X_{\\text{spec}})\\)\n\n**Proof.** We need not consider any deny edges, as these are only induced by se orders, which are absent in both \\(X_{\\text{imp}}\\) and \\(X_{\\text{spec}}\\).\n\nFor guarantee edges, we must show that the projections of hb to inter-thread call-to-return and intrathread interface actions are the same for \\(X_{\\text{imp}}\\) and \\(X_{\\text{spec}}\\).\n\nIntrathread hb is trivial: by construction of the \\(X_{\\text{spec}}\\) we have the same sb over calls and returns.\n\nFor inter-thread hb, we need not consider blocking calls, as they do not write and do not have a return action. In successful calls, hb edges are only generated by either reads from \\(S\\) or client dependencies in \\(R\\). Client dependencies are by construction also in \\(X_{\\text{imp}}\\). All successful calls are ordered by mo over their final write to \\(S\\). By the semantics of release sequences, there exists an sw edge from call \\(A\\) to return \\(B\\) if and only if \\(A\\) is a successful push and \\(B\\) is a successful pop such that \\(A < B\\). The same holds for the implementation.\n\nAs failed-on-empty-stack implementation pop calls do not write, they generate no outgoing sw edges, and thus no non-client inter-thread hb edges. The same holds for the specification. They generate an incoming rf edge from the \\(<\\)-preceding successful push or pop operation, and by the semantics of release sequences, a sw edge from all \\(<\\)-preceding successful push operations. (Other sw edges generated by failing reads are subsumed into the sw edges generated by the release sequence). The same is true of the specification pop, by the semantics of release sequences.\n\n**E.2 Producer-Consumer**\n\nIn this section we present a producer-consumer buffer. The library is to be used by a single producer thread to push items into a buffer to be processed by a single consumer thread. The interface in this library has two method calls: \\(\\text{enq()}\\) and \\(\\text{deq()}\\). We provide a specification of the queue, a C/C++11 implementation, and a proof that the implementation linearizes the specification.\n\n**E.2.1 Algorithm**\n\nThe producer-consumer queue is intended for communication between a single producer thread and a single consumer thread. The library has three method calls: \\(\\text{init()}\\), \\(\\text{enq()}\\) and \\(\\text{deq()}\\). Figure 10 gives a specification and implementation.\n\nThe specification and implementation are written in the subset of the language without relaxed atomics. This allows us to use the stronger abstraction theorem. In this setting, values cannot be communicated between threads without synchronising or creating a race. In the producer-consumer example, we do not want the specification to require the creation of happens-before edges from the dequeuing thread to the enqueuing thread. In order to avoid communication in that direction, we make the enqueuing thread unaware of the progress of the dequeuing thread, and allow spurious failure instead.\n\n**Specification.** To help with specification, we assume that locations can store arbitrarily large abstract datatypes – in this case, an unbounded list representing all previously enqueued values. We assume functions \\(\\text{empty\\_list()}\\), \\(\\text{append}(l,m)\\), \\(\\text{length}(l)\\) and \\(\\text{index}(l,i)\\) for manipulating lists. Such unbounded datatypes would of course be impractical to implement, but serve very well as a specification idiom.\n\nTo ensure that the consumer thread observes the most recent version of enqueued objects, the specification generates happens-before edges from the \\(\\text{enq()}\\) that adds a particular item, to the\nThe client must obey a protocol for the specification to be valid: all initialisation must be called from a master thread that happens-before all other threads, calls to enq must be on the same thread and all calls to deq must be on one other thread.\n\nLet $lm(a)$ be a mapping from an action $a$ to the name of the library call that produced them, or the client: in this case: enq, deq or client. Define the protocol as a filter on a set of executions $X$, given the mapping $lm$:\n\n$$s_{.protocol}(X,lm) = \\{ A | A \\in X \\land \\exists t_1,t_2, \\forall a \\in A.\\text{actions.}$$\n\n$$\\text{(}lm(a) = \\text{enq)} \\Rightarrow (a = (t_1, *)) \\land$$\n\n$$\\text{(}lm(a) = \\text{deq)} \\Rightarrow (a = (t_2, *)) \\}$$\n\nApplying this restriction to the most general client gives us a protocol restricted most general client:\n\n$$\\text{MGC}_{pr}(L) = \\{ L \\in C^\\text{enq} \\parallel C^\\text{deq} \\}$$\n\nwhere\n\n$$C^\\text{enq} = (\\text{enq})^* \\quad \\text{and} \\quad C^\\text{deq} = (\\text{deq})^*.$$ \n\nWe use the stronger form of the abstraction theorem that applies only in the absence of relaxed atomicity 6, replacing the MGC with the protocol-restricted most-general-client $\\text{MGC}_{pr}$.\n\n**Theorem 36 (Abstraction).** If: $(L_1, I_1), (L_2, I_2)$ are safe under $\\text{MGC}_{pr}$, and $(L_1, I_1) \\leq (L_2, I_2)$ under $\\text{MGC}_{pr}$, and $C$ satisfies the protocol $pr$, and $(C(L_2), I \\sqcup I_2)$, then $(C(L_1), I \\sqcup I_1)$ is safe and\n\n$$\\forall X \\in \\text{client}(\\{C(L_1)\\}) (I \\sqcup I_1).$$\n\n$$\\exists Y \\in \\text{client}(\\{C(L_2)\\}) (I \\sqcup I_2). \\quad X \\subseteq Y.$$ \n\n### E.2.3 Axiomatisation of action structures\n\n**Specification.** The following action structures correspond to the actions generated by calls to the specification functions. In the specification, we have four sorts of calls to the library: enqueues, both succeeding and failing, and dequeues, both succeeding and failing. Each of the four sorts of calls generates a different execution fragment. A call to $\\text{init}$ generates the following:\n\n$$X_{\\text{enq},t, k, l} =$$\n\n$$(\\{a, \\ldots f\\}, \\{ a \\overset{\\text{enq}}{\\rightarrow} b \\overset{\\text{store}}{\\rightarrow} c \\overset{\\text{deq}}{\\rightarrow} d \\})$$\n\nwhere\n\n$$a = (\\omega, t, \\text{call enq}(k))$$\n$$b = (\\omega, t, \\text{store}_H(b, \\text{nondet})$$\n$$c = (\\omega, t, \\text{load}_A(b, 0))$$\n$$d = (\\omega, t, \\text{load}_ACQ(l, k))$$\n$$e = (\\omega, t, \\text{store}_REl(l, \\text{append}(l, k)))$$\n$$f = (\\omega, t, \\text{ret enq}(1))$$\n\nA successful enq generates the following:\n\n$$X_{\\text{enq},t, k, l} =$$\n\n$$(\\{a, \\ldots f\\}, \\{ a \\overset{\\text{enq}}{\\rightarrow} b \\overset{\\text{store}}{\\rightarrow} c \\overset{\\text{deq}}{\\rightarrow} d \\overset{\\text{deq}}{\\rightarrow} f \\})$$\n\nwhere\n\n$$a = (\\omega, t, \\text{call enq}(k))$$\n$$b = (\\omega, t, \\text{store}_H(b, \\text{nondet})$$\n$$c = (\\omega, t, \\text{load}_A(b, 0))$$\n$$d = (\\omega, t, \\text{load}_ACQ(l, k))$$\n$$e = (\\omega, t, \\text{store}_REl(l, \\text{append}(l, k)))$$\n$$f = (\\omega, t, \\text{ret enq}(1))$$\n\nA failing enq generates the following:\n\\[\nX_{\\text{enq},t,k}^a,d = \\{(a, b, c, d), (a \\xrightarrow{\\text{enq}} b \\xrightarrow{\\text{enq}} c \\xrightarrow{\\text{enq}} d)\\}\n\\]\n\nwhere\n\\[\n\\begin{align*}\n a &= (\\omega, t, \\text{call enq}(k)) \\\\\nb &= (\\omega, t, \\text{storeNA}(b, \\text{nondet}) \\\\\nc &= (\\omega, t, \\text{loadNA}(a, i) \\ \text{such that} \\ i \\neq 0) \\\\\nd &= (\\omega, t, \\text{ret enq}(0))\n\\end{align*}\n\\]\n\nA successful \\text{deq} generates the following:\n\\[\nX_{\\text{deq},t,d,t,v}^{a,f} = \\{(a, b, c, d, e, f), (a \\xrightarrow{\\text{deq}} b \\xrightarrow{\\text{deq}} c \\xrightarrow{\\text{deq}} d \\xrightarrow{\\text{deq}} e \\xrightarrow{\\text{deq}} f)\\}\n\\]\n\nwhere\n\\[\n\\begin{align*}\n a &= (\\omega, t, \\text{call deq}(d)) \\\\\nb &= (\\omega, t, \\text{loadACQ}(l, l_t)) \\\\\nc &= (\\omega, t, \\text{loadACQ}(c, v) \\ \text{such that} \\ v < \\text{length}(l_t)) \\\\\nd &= (\\omega, t, \\text{storeNA}(c, v+1)) \\\\\ne &= (\\omega, t, \\text{ret deq}(\\text{index}(l_t, c)))\n\\end{align*}\n\\]\n\nA failing \\text{deq} generates the following:\n\\[\nX_{\\text{deq},t,d,t,v}^{a,e} = \\{(a, b, c, d, e), (a \\xrightarrow{\\text{deq}} b \\xrightarrow{\\text{deq}} c \\xrightarrow{\\text{deq}} d \\xrightarrow{\\text{deq}} e)\\}\n\\]\n\nwhere\n\\[\n\\begin{align*}\n a &= (\\omega, t, \\text{call deq}(d)) \\\\\nb &= (\\omega, t, \\text{loadACQ}(l, l_t)) \\\\\nc &= (\\omega, t, \\text{loadACQ}(c, v) \\ \text{such that} \\ v < \\text{length}(l_v)) \\\\\nd &= (\\omega, t, \\text{storeNA}(c, v+1)) \\\\\ne &= (\\omega, t, \\text{ret deq}(0))\n\\end{align*}\n\\]\n\nImplementation. The following action structures correspond to the actions generated by calls to the implementation functions, starting with \\text{init}:\n\\[\nX_{\\text{init},t,n}^{a,e} = \\{(a, b, c, d, e, f, g), (a \\xrightarrow{\\text{init}} b \\xrightarrow{\\text{init}} c \\xrightarrow{\\text{init}} d \\xrightarrow{\\text{init}} e)\\}\n\\]\n\nwhere\n\\[\n\\begin{align*}\n a &= (\\omega, t, \\text{call init}(n)) \\\\\nb &= (\\omega, t, \\text{storeNA}(s, n)) \\\\\nc &= (\\omega, t, \\text{storeNA}(b, 0)) \\\\\nd &= (\\omega, t, \\text{storeNA}(f, 0)) \\\\\ne &= (\\omega, t, \\text{ret init}(1))\n\\end{align*}\n\\]\n\nA successful \\text{enq} gives rise to:\n\\[\nX_{\\text{enq},t,k,f_t,b_t,h}^{a,g} = \\{(a, b, c, d, e, f, g), (a \\xrightarrow{\\text{enq}} b \\xrightarrow{\\text{enq}} c \\xrightarrow{\\text{enq}} d \\xrightarrow{\\text{enq}} f \\xrightarrow{\\text{enq}} g)\\}\n\\]\n\nwhere\n\\[\n\\begin{align*}\n a &= (\\omega, t, \\text{call enq}(k)) \\\\\nb &= (\\omega, t, \\text{loadACQ}(f, f_t)) \\\\\nc &= (\\omega, t, \\text{loadACQ}(b, b_t) \\ \text{such that} \\ b_t - s < f_t) \\\\\ne &= (\\omega, t, \\text{storeNA}(a + (b_t \\% s), k)) \\\\\nf &= (\\omega, t, \\text{storeREL}(b, b_t + 1)) \\\\\ng &= (\\omega, t, \\text{ret deq}(1))\n\\end{align*}\n\\]\n\nor the \\text{enq} fails and we have:\n\\[\nX_{\\text{enq},t,k,f_t,b_t,h}^{a,e} = \\{(a, b, c, d, e), (a \\xrightarrow{\\text{enq}} b \\xrightarrow{\\text{enq}} c \\xrightarrow{\\text{deq}} d \\xrightarrow{\\text{deq}} e)\\}\n\\]\n\nwhere\n\\[\n\\begin{align*}\n a &= (\\omega, t, \\text{call enq}(k)) \\\\\nb &= (\\omega, t, \\text{loadACQ}(f, f_t)) \\\\\nc &= (\\omega, t, \\text{loadACQ}(b, b_t) \\ \text{such that} \\ f_t \\leq b_t - s) \\\\\ne &= (\\omega, t, \\text{ret enq}(0))\n\\end{align*}\n\\]\n\nSimilarly, either \\text{deq} is successful, and we have:\n\\[\nX_{\\text{deq},t,d,f_t,b_t,h}^{a,h} = \\{(a, b, c, d, e, f, g, h), (a \\xrightarrow{\\text{deq}} b \\xrightarrow{\\text{deq}} c \\xrightarrow{\\text{deq}} d \\xrightarrow{\\text{deq}} e \\xrightarrow{\\text{deq}} f \\xrightarrow{\\text{deq}} g \\xrightarrow{\\text{deq}} h)\\}\n\\]\n\nwhere\n\\[\n\\begin{align*}\n a &= (\\omega, t, \\text{call deq}(d)) \\\\\nb &= (\\omega, t, \\text{loadACQ}(f, f_t)) \\\\\nc &= (\\omega, t, \\text{loadACQ}(b, b_t) \\ \text{such that} \\ f_t < b_t) \\\\\ne &= (\\omega, t, \\text{loadACQ}(a + (f_t \\% s), v)) \\\\\nf &= (\\omega, t, \\text{storeNA}(k, v)) \\\\\ng &= (\\omega, t, \\text{storeREL}(f, f_t + 1)) \\\\\nh &= (\\omega, t, \\text{ret deq}(k))\n\\end{align*}\n\\]\n\nor the \\text{deq} fails and we have:\n\\[\nX_{\\text{deq},t,d,f_t,b_t,h}^{a,e} = \\{(a, b, c, d, e), (a \\xrightarrow{\\text{deq}} b \\xrightarrow{\\text{deq}} c \\xrightarrow{\\text{deq}} d \\xrightarrow{\\text{deq}} e)\\}\n\\]\n\nwhere\n\\[\n\\begin{align*}\n a &= (\\omega, t, \\text{call deq}(d)) \\\\\nb &= (\\omega, t, \\text{loadACQ}(f, f_t)) \\\\\nc &= (\\omega, t, \\text{loadACQ}(b, b_t) \\ \text{such that} \\ b_t \\leq f_t) \\\\\ne &= (\\omega, t, \\text{ret deq}(0))\n\\end{align*}\n\\]\n\nE.2.4 Implementation and Specification Safety\n\nLet \\((L_2, I_2)\\) be the producer-consumer specification, and \\((L_1, I_1)\\) be the implementation. To apply the abstraction theorem, we must prove the following:\n\n\\textbf{Lemma 37 (Specification Safety).} \\((L_1, I_1)\\) and \\((L_2, I_2)\\) are safe over the MGCpr.\n\nProof: Assume one of them is not. Then there exists an execution, \\(X_2 \\in \\text{MGCpr}(L_2, I_2)\\) or \\(X_1 \\in \\text{MGCpr}(L_1, I_1)\\) such that \\(X_2\\) or \\(X_1\\) has a safety violation. Consider each type of safety violation in turn:\n\n\\textbf{Location disjointness} Recall \\textsc{Noninterfer}: \\[\\forall a, x, t . \\ (a \\in A \\land (a = (t, \\text{write}(x,_1)) \\lor a = (t, \\text{read}(x,_1))) \\land x \\notin \\{\\text{param}_1, \\text{retval}, t \\mid t = 1..n\\}) \\implies ((\\exists b. b = (\\omega, \\text{call}_1) \\land b \\xrightarrow{\\text{enq}} a) \\land \\neg \\exists c. c = (\\omega, \\text{ret}_1 \\land \\text{loadACQ}(b, b_t) \\xrightarrow{\\text{enq}} a) \\iff (x \\in \\text{LLoc}))\\]\n\nFirst note that there are no client actions in the MGCpr, so the read or write, \\(a\\), must originate from a library call. Consequently, there is a sequenced before preceding call action without an intervening return action, so we must show that \\(x \\in \\text{LLoc}\\) for \\(a\\). Observe that in \\(L_1\\) and \\(L_2\\), all accesses are at static global locations, except accesses to statically allocated elements of the task array in the implementation, \\(L_1\\). In the axiomatisation, these accesses, action \\(e\\) in \\text{enq} and \\(e\\) in \\text{deq} use a dynamically calculated address. Both accesses of the array have indices that are calculated modulo.\nthe size of the array, so no accesses can escape its bounds, preserving disjointness.\n\n**Mutex safety** Recall SAFELOCK:\n\n\\[(\\forall b, t, f, b = (t, \\text{unlock}(f))) \\implies \\]\n\n\\[\\exists a. a = (t, \\text{lock}(f)) \\land a \\overset{sh}{\\rightarrow} b \\land a \\overset{sc}{\\rightarrow} b \\land \\]\n\n\\[\\neg \\exists c. c = (\\text{..., } f) \\land a \\overset{sc}{\\rightarrow} c \\overset{sc}{\\rightarrow} b \\land \\]\n\n\\[\\neg \\exists a, b, t, f, a = (t, \\text{lock}(f)) \\land b = (t, \\text{block}(f)) \\land a \\overset{sh}{\\rightarrow} b \\land a \\overset{sc}{\\rightarrow} b \\land \\]\n\n\\[\\neg \\exists c. c = (\\text{..., } f) \\land a \\overset{sc}{\\rightarrow} c \\overset{sc}{\\rightarrow} b.\\]\n\nThere are no mutex actions in the specification or implementation, so both conjuncts of SAFELOCK are true.\n\n**Indeterminate read** Recall SAFEREAD:\n\n\\[\\forall a, \\overline{x}. (a \\in A \\land a = (\\text{..., } \\text{read}(x, _))) \\implies \\exists b, \\overline{r} \\overset{rf}{\\rightarrow} a \\land b = (\\text{..., } \\text{write}(x, _))\\]\n\nThe client performs initialisation of all global variables, and that happens-before all library calls. That combined with DETREAD, ensures there is always a reads-from edge as required.\n\n**Data races** Recall DRF:\n\n\\[\\forall b, a, b, t_1, t_2.\\]\n\n\\[(a, b) \\in A \\land a \\neq b \\land a = (t_1, a(x, _))\\land\\]\n\n\\[b = (t_2, b(x, _)) \\land (a = \\text{write} \\lor b = \\text{write}) \\implies \\]\n\n\\[(t_1 \\neq t_2 \\implies (a \\overset{sh}{\\rightarrow} b \\lor b \\overset{sh}{\\rightarrow} a \\lor \\text{sort}(x) = \\text{ATOM})\\land\\]\n\n\\[(t_1 = t_2 \\implies (a \\overset{sh}{\\rightarrow} b \\lor b \\overset{sh}{\\rightarrow} a)).\\]\n\nSuppose there is a violation of the second conjunct in the implication, then there must be a write and another access of the same location, on the same thread, unrelated by sequenced-before. The race cannot be within one call in either the implementation or the specification, because inspection of the axiomatisation shows all actions are totally ordered by sequenced-before. Consequently, there can be no inter-call unsequenced actions on the same thread because the MGC of totally orders calls by sequenced-before. Consequently, the second conjunct of the implication is not violated.\n\nNow suppose there is a violation of the first conjunct of the implication. Then there must be a write and another access of the same non-atomic location, on different threads, unrelated by happens-before. The specification accesses one non-local non-atomic location, c. It is only accessed by the dequeuing thread, so all accesses are related by sequenced-before, and as a result, happens-before.\n\nThe only non-local non-atomic locations accessed by the implementation are reads of a and accesses of the array, a. The only write of a is in the initialisation, and that happens-before all of the reads.\n\nSuppose there were a race between accesses to the array, there must be an enqueue on one thread and a dequeue on the other such that the value of b read by enq is modulo a is the same as the value of f read by deq modulo a.\n\nLet \\(W_{a+b}(\\text{enq})s\\) be the write of the array and \\(R_{a+b}(\\text{deq})s\\) be the read of the array that might race, let \\(f_{\\text{enq}}\\) and \\(b_{\\text{enq}}\\) be the values of f and b read by enq, and \\(f_{\\text{deq}}\\) and \\(b_{\\text{deq}}\\) be the values read by deq. Noting that the conditional was passed in both calls, brings our knowledge to the following:\n\n1. \\(b_{\\text{enq}}s = f_{\\text{deq}}s\\)\n2. \\(b_{\\text{enq}}s \\neq f_{\\text{enq}}\\)\n3. \\(f_{\\text{deq}} < b_{\\text{deq}}\\)\n\n**Lemma 38.** \\(b_{\\text{enq}} \\leq f_{\\text{deq}} \\implies W_{\\text{enq}}(\\text{enq})s \\overset{bb}{\\rightarrow} R_{\\text{deq}}(\\text{deq})s\\)\n\nWe have both: \\(b_{\\text{enq}} \\leq f_{\\text{deq}}\\) and \\(f_{\\text{deq}} < b_{\\text{deq}}\\), so \\(b_{\\text{enq}} < b_{\\text{deq}}\\). The value of \\(b_{\\text{enq}}\\) is modified only by the increment in each call of enq, therefore, the read of b in deq reads from and synchronises with the write of b in the enq call we are considering or some later call in sequenced-before. Either way, through transitivity of happens-before, we have \\(W_{a+b}(\\text{enq})s \\overset{bb}{\\rightarrow} R_{a+b}(\\text{deq})s\\).\n\n**Lemma 39.** \\(f_{\\text{deq}} < b_{\\text{enq}} \\implies R_{a+b}(\\text{deq})s \\overset{bb}{\\rightarrow} W_{a+b}(\\text{enq})s\\)\n\nWe have both: \\(f_{\\text{deq}} < b_{\\text{enq}}\\) and \\(b_{\\text{enq}} \\neq f_{\\text{deq}}\\), so \\(f_{\\text{deq}} < f_{\\text{enq}}\\). The value of \\(f_{\\text{deq}}\\) is modified only by the increment in each call of deq, therefore, the read of \\(f_{\\text{deq}}\\) in enq reads from and synchronises with the write of \\(f_{\\text{deq}}\\) in the deq call we are considering or some later call in sequenced-before. Either way, through transitivity of happens-before, we have \\(R_{a+b}(\\text{enq})s \\overset{bb}{\\rightarrow} W_{a+b}(\\text{enq})s\\).\n\nThe two lemmas cover all possible read values, so we always have a happens-before edge between potentially racy accesses of the array, and there are no data races.\n\n**E.2.5 Proving Abstraction**\n\nNow we show that \\((\\mathcal{L}_1, \\mathcal{X}_1) \\preceq (\\mathcal{L}_2, \\mathcal{X}_2)\\).\n\n**Constructing a Specification Execution**\n\n**Definition 40.** Let \\(X_{\\text{imp}} \\in \\llbracket \\mathcal{L}_1 \\rrbracket_{\\mathcal{I}_1}\\) be an arbitrary but fixed execution of the producer-consumer implementation. We construct a corresponding execution \\(X_{\\text{spec}}\\) of the specification as follows:\n\nWe first construct an action structure \\(C_{\\text{spec}}\\). Let\n\n\\[X_{\\text{imp}} = (A_i, s_b, i_b, r_f, s_c, m_c, s_w, h_b)\\]\n\nand let \\(C_{\\text{imp}} = (A_i, s_b, i_b)\\) be the corresponding action structure. We construct \\(C_{\\text{spec}}\\) by substituting successful implementation enq operations with successful specification enq operations, failing implementation enq operations with failing specification enq operations, and so on.\n\nWe first define a total order \\(<\\) over calls. We choose this total order such that for any pair of calls \\(f_1, f_2 \\in X_{\\text{Cimpl}}, f_1 < f_2\\) if \\(f_2\\) reads from a store in \\(f_1\\) to \\(f_1\\), either \\(f_1\\) or \\(f_2\\). By construction, the first element in the order must be the single initial call to init.\n\nThis order \\(<\\) is acyclic because reads and writes between threads are release-acquire, meaning that \\(\\leq\\) must be acyclic by the acyclicity of hb.\n\nWe use the order \\(<\\) to construct a function \\(j\\) on actions:\n\n1. if \\(X_{a,b}\\) is an init call, \\(j(a) = [;]\\)\n2. if \\(X_{a,b}\\) is a successful enq for value \\(v\\), and \\(X_{a',b'}\\) is the immediately preceding operation in \\(\\leq\\), then \\(j(a) = \\text{append}(v, j(a'))\\)\n3. otherwise, for all other operations \\(X_{a,b}\\) with immediately preceding operation \\(X_{a',b'}, j(a) = j(a')\\)\n\nThe function \\(j\\) maps from call actions in the implementation, to the contents of the \\(\\ell\\) variable in the specification. Intuitively, it builds the abstract state of the queue.\n\nWe now construct \\(C_{\\text{spec}}\\). We begin with \\(C_{\\text{imp}}\\). For every successful enq operation in the action structure, we substitute the implementation sub-execution for a specification sub-execution:\n\n\\[C' = C[S_{\\text{spec}}^{\\text{enq}}(t, k, j)]/C[S_{\\text{spec}}^{\\text{enq}}(t, k, f)]\\]\n\nNote that here the back pointer \\(b\\) from the implementation gives the value of \\(c\\) in the specification, while the function \\(j\\) gives a value to \\(1\\) in the specification.\n\nWe do the same to failing enq operations, successful and failing deq, and init. As these substitutions commute, we can do them in any order. The result is an action structure \\(C_{\\text{spec}}\\).\n\n**Lemma 41.** \\(C_{\\text{spec}}\\) is an action structure for the producer-consumer specification. That is, \\(C_{\\text{spec}} \\in \\llbracket \\mathcal{L}_2 \\rrbracket_{\\mathcal{I}_2}\\).\n\n**Proof.** We have performed straightforward surgery on the action structure \\(C_{\\text{imp}}\\), replacing enq with enq etc. It is trivial to see\nthat the resulting execution is a action structure for the protocol-\nrestricted MGC. Values have been chosen deliberately to ensure\nconsistency between the resulting executions, but are irrelevant to\nthe correctness of the action structure. □\n\nWe now construct the execution\n\n\\[ X_{\\text{spec}} = (A_s, sb_s, ib_s, rf_s, sc_s, mo_s, sw_s, hb_s). \\]\n\nWe take the action set, happens-before and initialised-before rela-\ntions from \\( C_{\\text{spec}} = (A_s, sb_s, ib_s) \\). Other relations are con-\nstructed as follows:\n\n- All reads and writes for location \\( c \\) are on the same thread, or in\n the initialisation, and so \\( r_f \\) for \\( c \\) simply follows \\( s_b \\) and \\( i_b \\).\n- For location \\( l \\), reads may be on either thread, but writes are all on\n the enqueuing thread. For reads on the same thread, \\( r_f \\) is fol-\n lows \\( s_b \\). For reads between threads, we use the < order as an\n oracle. For any \\( l_{\\text{deq}}^{\\text{b},b,t,k} \\), we find its immediate \\(<\\)-predecessor\n \\( l_{\\text{enq}}^{\\text{b},b,t,k} \\), and generate an \\( r_f \\) from the write to \\( l \\) in the cor-\n responding \\( l_{\\text{enq}}^{\\text{b},b,t,k} \\) to the read in \\( l_{\\text{deq}}^{\\text{b},b,t,k} \\). If \\( l_{\\text{enq}}^{\\text{b},b,t,k} \\) has no\n <\\>-preceding enqueue, we direct the read for \\( l \\) to \\( \\text{init} \\).\n- \\( \\text{mo} \\) is determined by \\( s_b \\), because the locations \\( c \\) and \\( l \\) are each\n modified on a single thread only.\n- \\( \\text{sc} \\) is empty, as there are no SC actions.\n- \\( \\text{sw} \\) is determined by \\( r_f \\) and the SWDEF axiom.\n- \\( \\text{hb} \\) is determined by the HBDEF axiom.\n\nThe following lemma relates the values stored in \\( X_{\\text{imp}} \\) to values in\n\\( X_{\\text{spec}} \\).\n\n**Lemma 42.** Let \\( I^x,y \\) be an \\( \\text{enq} \\) or \\( \\text{deq} \\) call in \\( X_{\\text{imp}} \\) and let \\( S^x,y \\)\nbe the corresponding call in \\( X_{\\text{spec}} \\). Identify in \\( X_{\\text{imp}} \\) the action for\nthe read from \\( b \\), and in \\( X_{\\text{spec}} \\) the action for the read from \\( l \\). These\nactions are related as follows:\n\n- \\( \\text{length}(l) = bt \\).\n- For \\( i \\in [bt \\ldots (bt - f t)] \\), the value of the \\( \\text{hb}\\)-preceding write at\n location \\( a(i - 1) \\) is same as \\( lt[i] \\).\n\n**Proof.** By induction on the order <. Pick a call \\( I^x,y \\) in \\( X_{\\text{imp}} \\)\nand let \\( S^x,y \\) be the corresponding call in \\( X_{\\text{spec}} \\). By construction,\nthe current call must read its value of \\( l \\) from the <\\>-preceding call.\nCase-split on the type of the <\\>-preceding call:\n\n**enqueue.** To see that \\( \\text{length}(l \\pi) = b \\), observe that \\( b \\) is incre-\nmented in this call, and one element is added to the list, increment-\ning its length, so this part of the invariant is preserved.\n\nThe successful \\( \\text{enq} \\) writes the parameter value \\( b \\) to \\( \\text{element} \\) \\( b - 1 \\)\nin the implementation, and the specification appends it to the queue\nas required. The second part of the invariant is preserved.\n\n**dequeue.** In the \\( \\text{deq} \\) case, the implementation increments \\( f \\)\nwhich reduces the number of index values that must be consid-\nered. Neither \\( b \\) nor \\( l \\) in the specification are changed, so the\ninvariant is preserved.\n\n**init.** Trivial. □\n\n**Lemma 43.** \\( X_{\\text{spec}} \\) is valid.\n\n**Proof.** We consider each condition in turn:\n\n**SBWF** \\( s_b \\) is only modified by substituting linear sequences of\nactions for other linear sequences. T\n\n**RFWF** For client actions, the actions and relations are the same,\nand the predicate remains true if reads-from edges are removed. For\nthe library, we have chosen the execution to be consistent.\n\nIt remains to show that the values in the specification calls are\ncorrectly read from associated writes. By the structure of the origi-\nnal execution \\( X_{\\text{imp}} \\), we know that \\( b \\) is incremented in each success-\nful call to \\( \\text{deq} \\). In \\( X_{\\text{spec}} \\), \\( c \\) takes it’s value from the increment in\nthe \\( \\text{hb}\\)-preceding call to \\( \\text{deq} \\). By simple induction, all reads of \\( c \\) have\nvalues that satisfy the axiom.\n\nFor intra-call non-atomic reads, we examine the given values to\nensure that they are consistent. For the call value passed to \\( \\text{enq} \\),\nwe know by construction that the appropriate value will be added\nin the list. For the correctness of return value for \\( \\text{deq} \\), we appeal\nto Lemma 42 to ensure that the value in \\( l \\) read by \\( \\text{deq} \\) corresponds\nto the value read from the array in the concrete implementation.\nOnce again by Lemma 42, we know that \\( \\text{deq} \\) will fail only if the\nimplementation case call could fail.\n\n**SCWF, SCR, HVSSC and MOVSSC** There are no SC\nactions in the implementation or specification.\n\n**MOWF** By construction, all writes to the same location are\nrelated. In \\( X_{\\text{spec}} \\), \\( \\text{mo} \\) is determined \\( s_b \\) the rest of the axiom\nfollows from \\( \\text{SBWF} \\).\n\n**ATOMRMW** There are no read-modify-write actions in the\nimplementation or specification.\n\n**ACyclicity** By assumption, \\( \\text{hb} \\), in the execution \\( X_{\\text{imp}} \\)\ndoes not contain cycles. The constructed execution \\( X_{\\text{spec}} \\) removes\nall \\( \\text{hb}\\)-ordering from the enqueuing to dequencing thread, and adds\nonly \\( \\text{hb}\\)-ordering from the enqueuing to dequencing thread. By\nconstruction, this cannot break irreflexivity.\n\n**LOCKS** There are no locks in the implementation or specification.\n\n**RFATOMIC** All atomic reads of atomic writes automatically sat-\nfify the predicate because in reading, they synchronise. For reads\nof the stores in \\( \\text{init} \\), note that the stores in \\( \\text{init} \\) precede all other\ncalls in happens-before, according to the protocol.\n\n**HBVSMO** \\( \\text{mo} \\) is determined by \\( s_b \\) and \\( \\text{hb} \\) is similarly deter-\nmined by \\( s_b \\) and HBDEF.\n\n**CoRR, CoWR and CoRW** The library actions on the \\( \\text{enq} \\) and\n\\( \\text{deq} \\) threads are totally ordered by sequenced before, precluding\nintra-thread library coherence violations. The only inter-thread edge\nis the read-from edge at \\( l \\), from calls of \\( \\text{enq} \\) to calls of \\( \\text{deq} \\). This\nreads-from edge synchronises, creating a happens-before edge,\nmaking coherence violations impossible.\n\n**RFNonATOMIC and DETREAD** For DETREAD, \\( l \\) is the only\natomic location. All reads in the library are \\( \\text{hb}\\)-preceded by writes\nin the initialisation, which satisfies one direction of the iff. For\nthe other direction, we know by construction that every read of \\( l \\) is \\( r_f\\)-\nrelated to an appropriate write.\n\n**RFNonATOMIC** The only inter-call non-atomic reads in the\nlibrary are those of \\( c \\) in calls to \\( \\text{deq} \\). These are totally ordered by\nsequenced before, and are \\( \\text{hb}\\)-related only to actions on the same\nthread.\n\n**BLOCK** There are no blocking actions in the library.\n\n**Lemma 44.** \\( X_{\\text{spec}} \\in [L_2]I_2 \\).\n\n**Proof.** Appeal to Lemmas 41 and 43. □\n\n**Inclusion over histories**\n\n**Lemma 45.** \\( \\text{hbl}(X_{\\text{spec}}) \\subseteq \\text{hbl}(X_{\\text{imp}}) \\).\nPROOF. All intra-thread happens-before edges over the call and return actions are the same. The only inter-thread happens-before edges created by the specification are a result of \\texttt{deq} calls reading \\texttt{l} from writes of \\texttt{l} in \\texttt{enq} calls. By construction, these edges correspond to reads of \\texttt{b} which synchronise. Therefore all happens-before edges in \\( X_{\\text{spec}} \\) are covered by \\( X_{\\text{imp}} \\), as required.\n\n\\begin{lemma}\n\\hspace{1em} \\text{Lemma 46.} \\hspace{1em} \\text{deny}_L(X_{\\text{spec}}) \\subseteq \\text{deny}_L(X_{\\text{imp}}).\n\\end{lemma}\n\n\\begin{proof}\nConsider each deny part of the history in turn, and show that the edges created by the specification are a subset of the edges created by the implementation:\n\n\\textbf{HBVSMO.} The only modification order edges in the specification are over the writes to \\( l \\). All calls that write \\( l \\) are totally ordered by sequenced-before in both the specification and the implementation, so this part of the deny is covered.\n\n\\textbf{COWR.} By the structure of the specification, any read from a write must \\textit{hb}-preceed that write's \\textit{mo}-successor. Thus the specification generates no deny.\n\n\\textbf{SCREADS.} There are no \\texttt{sc} actions in the specification, so this component of the deny is empty.\n\\end{proof}\n\n\\begin{lemma}\n\\hspace{1em} \\text{Lemma 47.} \\hspace{1em} \\forall H_1 \\in \\text{Ehistory}(X_{\\text{imp}}). \\exists H_2 \\in \\text{Ehistory}(X_{\\text{spec}}). H_2 \\subseteq H_1.\n\\end{lemma}\n\n\\begin{proof}\nBy appeal to the previous two lemmas. The \\texttt{sc} component of the history has no effect, as both the implementation and specification include no \\texttt{sc} orders.\n\\end{proof}"}}},{"rowIdx":265,"cells":{"id":{"kind":"string","value":"da09c77a2e52eef6e6f9a15142fb2ae47eca3555"},"text":{"kind":"string","value":"A model of cooperative threads\n\nCitation for published version:\n\nDigital Object Identifier (DOI):\n10.1145/1480881.1480887\n\nLink:\nLink to publication record in Edinburgh Research Explorer\n\nDocument Version:\nPeer reviewed version\n\nPublished In:\n\nGeneral rights\nCopyright for the publications made accessible via the Edinburgh Research Explorer is retained by the author(s) and / or other copyright owners and it is a condition of accessing these publications that users recognise and abide by the legal requirements associated with these rights.\n\nTake down policy\nThe University of Edinburgh has made every reasonable effort to ensure that Edinburgh Research Explorer content complies with UK legislation. If you believe that the public display of this file breaches copyright please contact openaccess@ed.ac.uk providing details, and we will remove access to the work immediately and investigate your claim.\nA MODEL OF COOPERATIVE THREADS\n\nMARTÍN ABADI AND GORDON D. PLOTKIN\n\nMicrosoft Research, Silicon Valley; University of California, Santa Cruz\ne-mail address: abadi@microsoft.com\n\nMicrosoft Research, Silicon Valley; LFCS, University of Edinburgh\ne-mail address: gdp@inf.ed.ac.uk\n\nAbstract. We develop a model of concurrent imperative programming with threads. We focus on a small imperative language with cooperative threads which execute without interruption until they terminate or explicitly yield control. We define and study a trace-based denotational semantics for this language; this semantics is fully abstract but mathematically elementary. We also give an equational theory for the computational effects that underlie the language, including thread spawning. We then analyze threads in terms of the free algebra monad for this theory.\n\n1. Introduction\n\nIn the realm of sequential programming, semantics, whether operational or denotational, provides a rich understanding of programming constructs and languages, and serves a broad range of purposes. These include, for instance, the study of verification techniques and the reconciliation of effects with functional programming via monads. With notorious difficulties, these two styles of semantics have been explored for concurrent programming, and, by now, a substantial body of work provides various semantic accounts of concurrency. Typically, that work develops semantics for languages with parallel-composition constructs and various communication mechanisms.\n\nSurprisingly, however, that work provides only a limited understanding of threads. It includes several operational semantics of languages with threads, sometimes with operational notions of equivalence, e.g., BMT92, PR97, Jef97, JR05; denotational semantics of those languages seem to be much rarer, and to address message passing rather than shared-memory concurrency, e.g., PHI99, Jef95. Yet threads are in widespread use, often in the context of elaborate shared-memory systems and languages for which a clear semantics would be beneficial.\n\nIn this paper, we investigate a model of concurrent imperative programming with threads. We focus on cooperative threads which execute, without interruption, until they\n\n1998 ACM Subject Classification: D.1.3; Programming Techniques, Concurrent Programming (Parallel programming); F.3.2: Logics and Meanings of Programs, Semantics of Programming Languages.\n\nKey words and phrases: denotational semantics, monad, operational semantics, transaction.\n\nA conference version of this paper has appeared as [AP09].\nCooperative threads appear in several systems, programming models, and languages. Often without much linguistic support, they have a long history in operating systems and databases, e.g., [SQL07]. Cooperative threads also arise in other contexts, such as Internet services and synchronous programming [AHT02, BCZ03, Bou06, Bou07, AZ06]. Most recently, cooperative threads are central in two models for programming with transactions, Automatic Mutual Exclusion (AME) and Transactions with Isolation and Cooperation (TIC) [IB07, SKB07]. AME is one of the main starting points for our research. The intended implementations of AME rely on software transactional memory [ST95] for executing multiple cooperative threads simultaneously. However, concurrent transactions do not appear in the high-level operational semantics of the AME constructs [ABH08]. Thus, cooperative threads and their semantics are of interest independently of the details of possible transactional implementations.\n\nWe define and study three semantics for an imperative language with primitives for spawning threads, yielding control, and blocking execution.\n\n- We obtain an operational semantics by a straightforward adaptation of previous work. In this semantics, we describe the meaning of a whole program in terms of small-step transitions between states in which spawned threads are kept in a thread pool. This semantics serves as a reference point.\n- We also define a more challenging compositional denotational semantics. The meaning of a command is a prefix-closed set of traces. Prefix-closure arises because we are primarily interested in safety properties, that is, in “may” semantics. Each trace is roughly a sequence of transitions, where each transition is a pair of stores, and a store is a mapping from variables to values. We establish adequacy and full-abstraction theorems with respect to the operational semantics. These results require several non-trivial choices in the definition of the denotational semantics.\n- Finally, we define a semantics based on the algebraic theory of effects. More precisely, we give an equational theory for the computational effects that underlie the language, and analyze threads in terms of the free algebra monad for this theory. This definition is more principled and systematic; it explains threads with standard semantic structures, in the context of functional programming. As we show, furthermore, we obtain our denotational semantics as a special case.\n\nSection 2 introduces our language and Section 3 defines its operational semantics. Section 4 develops its denotational semantics. Section 5 presents our adequacy and full-abstraction theorems (Theorems 5.10 and 5.15). Section 6 concerns the algebraic theory of effects and the analysis of the denotational semantics in this monadic setting (Theorem 6.4). Section 7 concludes.\n\n2. The Language\n\nOur language is an extension of a basic imperative language with assignments, sequencing, conditionals, and while loops (IMP [Win93]). Programs are written in terms of a finite set of variables Vars, whose values are natural numbers. In addition to those standard constructs, our language includes:\nA construct for executing a command in an asynchronous thread. Informally, async \\( C \\) forks off the execution of \\( C \\). This execution is asynchronous, and will not happen if the present thread keeps running without ever yielding control, or if the present thread blocks without first yielding control.\n\n- A construct for yielding control. Informally, yield indicates that any pending thread may execute next, as may the current thread.\n\n- A construct for blocking. Informally, block halts the execution of the entire program, even if there are pending threads that could otherwise make progress.\n\nWe define the syntax of the language in Figure 1. We do not detail the constructs on numerical and boolean expressions, which are as usual.\n\nFigure 2 gives an illustrative example. It shows a piece of code that spawns the asynchronous execution of \\( x := 0 \\), then executes \\( x := 1 \\) and yields, then resumes but blocks unless the predicate \\( x = 0 \\) holds, then executes \\( x := 2 \\). The execution of \\( x := 0 \\) may happen once the yield statement is reached. With respect to safety properties, the conditional blocking amounts to waiting for \\( x = 0 \\) to hold. More generally, AME’s \\texttt{blockUntil} \\( b \\) can be written if \\( b \\) then \\texttt{skip} else block.\n\nMore elaborate uses of blocking are possible too, and supported by lower-level semantics and actual transactional implementations [IB07, ABH08]. In those implementations, blocking may cause a roll-back and a later retry at an appropriate time. We regard roll-back as an interesting aspect of some possible implementations, but not as part of the high-level semantics of our language, which is the subject of this work.\n\n\\[\n\\begin{align*}\n b & \\in \\text{BExp} = \\ldots \\\\\n e & \\in \\text{NExp} = \\ldots \\\\\n C, D & \\in \\text{Com} = \\text{skip} \\\\\n & \\quad \\mid x := e \\ (x \\in \\text{Vars}) \\\\\n & \\quad \\mid C;D \\\\\n & \\quad \\mid \\text{if } b \\text{ then } C \\text{ else } D \\\\\n & \\quad \\mid \\text{while } b \\text{ do } C \\\\\n & \\quad \\mid \\text{async } C \\\\\n & \\quad \\mid \\text{yield} \\\\\n & \\quad \\mid \\text{block}\n\\end{align*}\n\\]\nThus, our language is basically a fragment of the AME calculus [ABH08]. It omits higher-order functions and references. It also omits “unprotected sections” for non-cooperative code, particularly legacy code. Non-cooperative code can however be modeled as code with pervasive calls to `yield` (at least with respect to the simple, strong memory models that we use throughout this paper; cf. [GMP06]). See Section 7 for further discussion of possible extensions to our language.\n\n3. Operational Semantics\n\nWe give an operational semantics for our language. Despite some subtleties, this semantics is not meant to be challenging. It is given in terms of small-step transitions between states. Accordingly, we define states, evaluation contexts, and the transition relation.\n\n3.1. States. As described in Figure 3, a state $\\Gamma = (\\sigma, T, C)$ consists of the following components:\n\n- a store $\\sigma$ which is a mapping of the given finite set Vars of variables to a set Value of values, which we take to be the set of natural numbers;\n- a finite sequence of commands $T$ which we call the thread pool;\n- a distinguished active command $C$.\n\nWe write $\\sigma[x \\mapsto n]$ for the store that agrees with $\\sigma$ except at $x$, which is mapped to $n$. We write $\\sigma(b)$ for the boolean denoted by $b$ in $\\sigma$, and $\\sigma(e)$ for the natural number denoted by $e$ in $\\sigma$, similarly. We write $T.T'$ for the concatenation of two thread pools $T$ and $T'$.\n\n3.2. Evaluation Contexts. As usual, a context is an expression with a hole $[\\ ]$, and an evaluation context is a context of a particular kind. Given a context $C$ and an expression $C$, we write $C[C]$ for the result of placing $C$ in the hole in $C$. We use the evaluation contexts defined by the grammar:\n\n$$\\mathcal{E} = [\\ ] | \\mathcal{E}; C$$\n3.3. Steps. A transition $\\Gamma \\rightarrow \\Gamma'$ takes an execution from one state to the next. Figure 4 gives rules that specify the transition relation. According to these rules, when the active command is $\\text{skip}$, a command from the pool becomes the active command. It is then evaluated as such until it produces $\\text{skip}$, yields, or blocks. No other computation is interleaved with this evaluation. Each evaluation step produces a new state, determined by decomposing the active command into an evaluation context and a subexpression that describes a computation step (for instance, a yield or a conditional).\n\nIn all cases at most one rule applies. In two cases, no rule applies. The first is when the active command is $\\text{skip}$ and the pool is empty; this situation corresponds to normal termination. The second is when the active command is $\\text{blocked}$, in the sense that it has the form $E[\\text{block}]$; this situation is an abnormal termination.\n\nWe write $\\Gamma \\xrightarrow{c} \\Gamma'$ when $\\Gamma \\rightarrow \\Gamma'$ via the last rule, and call this a choice transition. We write $\\Gamma \\xrightarrow{a} \\Gamma'$ when $\\Gamma \\rightarrow \\Gamma'$ via the other rules, and call this an active transition. Active transitions are deterministic, i.e., if $\\Gamma \\xrightarrow{a} \\Gamma'$ and $\\Gamma \\xrightarrow{a} \\Gamma''$ then $\\Gamma' = \\Gamma''$.\n\n4. Denotational Semantics\n\nNext we give a compositional denotational semantics for the same language. Here, the meaning of a command is a prefix-closed set of traces, where each trace is roughly a sequence of transitions, and each transition is a pair of stores.\n\nThe use of sequences of transitions goes back at least to Abrahamson’s work [Abr79] and appears in various studies of parallel composition [AP93, HdeBR94, Bro96, Bro02]. However, the treatment of threads requires some new non-trivial choices. For instance, transition sequences, as we define them, include markers to indicate not only normal termination but also the return of the main thread of control. Moreover, although these markers are similar, they are attached to traces in different ways, one inside pairs of stores, the other not. Such details are crucial for adequacy and full abstraction.\nAlso crucial to full abstraction is minimizing the information that the semantics records. More explicit semantics will typically be more transparent, for instance, in detailing that a particular step in a computation causes the spawning of a thread, but will consequently fail to be fully abstract.\n\nSection 4.1 is an informal introduction to some of the details of the semantics. Section 4.2 defines transition sequences and establishes some notation. Sections 4.3 and 4.4 define the interpretations of commands and thread pools, respectively. Section 4.5 discusses semantic equivalences.\n\n4.1. Informal Introduction. As indicated above, the meaning of a command will be a prefix-closed set of traces, where each trace is roughly a sequence of transitions, and each transition is a pair of stores. Safety properties—which pertain to what “may” happen—are closed under prefixing, hence the prefix-closure condition. Intuitively, when the meaning of a command includes a trace \\((\\sigma_1,\\sigma'_1)(\\sigma_2,\\sigma'_2)\\ldots\\), we intend that the command may start executing with store \\(\\sigma_1\\), transform it to \\(\\sigma'_1\\), yield, then resume with store \\(\\sigma_2\\), transform it to \\(\\sigma'_2\\), yield again, and so on.\n\nIn particular, the meaning of block will consist of the empty sequence \\(\\varepsilon\\). The meaning of yield; block will consist of the empty sequence \\(\\varepsilon\\) plus every sequence of the form \\((\\sigma,\\sigma)\\), where \\(\\sigma\\) is any store. Here, the pair \\((\\sigma,\\sigma)\\) is a “stutter” that represents immediate yielding.\n\nIf the meaning of a command \\(C\\) includes \\((\\sigma_1,\\sigma'_1)\\ldots(\\sigma_n,\\sigma'_n)\\) and the meaning of a command \\(D\\) includes \\((\\sigma'_n,\\sigma''_n)\\ldots(\\sigma_m,\\sigma'_m)\\), one might naively expect that the meaning of \\(C;D\\) would contain \\((\\sigma_1,\\sigma'_1)\\ldots(\\sigma_n,\\sigma'_n)\\ldots(\\sigma_m,\\sigma'_m)\\), which is obtained by concatenation plus a simple local composition between \\((\\sigma_n,\\sigma'_n)\\) and \\((\\sigma'_n,\\sigma''_n)\\). Unfortunately, this naive expectation is incorrect. In a trace \\((\\sigma_1,\\sigma'_1)(\\sigma_2,\\sigma'_2)\\ldots\\), some of the pairs may represent steps taken by commands to be executed asynchronously. Those steps need not take place before any further command \\(D\\) starts to execute.\n\nAccordingly, computing the meaning of \\(C;D\\) requires shuffling suffixes of traces in \\(C\\) with traces in \\(D\\). The shuffling represents the interleaving of \\(C\\)’s asynchronous work with \\(D\\)’s work. We introduce a special return marker “Ret” in order to indicate how the traces in \\(C\\) should be parsed for this composition. In particular, when \\(C\\) is of the form \\(C_1;\\text{async} (C_2)\\), any occurrence of “Ret” in the meaning of \\(C_2\\) will not appear in the meaning of \\(C\\). The application of async erases any occurrence of “Ret” from the meaning of \\(C_2\\)—intuitively, because \\(C_2\\) does not return control to its sequential context.\n\nFor example, the meaning of the command\n\\[\nx := n; \\text{yield}; x := n'\n\\]\nwill contain the trace\n\\[\n(\\sigma, \\sigma[x \\mapsto n])(\\sigma', \\sigma'[x \\mapsto n'] \\text{ Ret})\n\\]\nfor every \\(\\sigma\\) and \\(\\sigma'\\). On the other hand, the meaning of the command\n\\[\nx := n; \\text{async } (x := n'); \\text{yield}\n\\]\nwill contain the trace\n\\[\n(\\sigma, \\sigma[x \\mapsto n] \\text{ Ret})(\\sigma', \\sigma'[x \\mapsto n'])\n\\]\nfor every \\(\\sigma\\) and \\(\\sigma'\\). The different positions of the marker Ret correspond to different junction points for any commands to be executed next.\n\nIf the meaning of \\(C\\) contains \\(u(\\sigma_n,\\sigma'_n) \\text{ Ret})u'\\) and the meaning of \\(D\\) contains \\((\\sigma'_n,\\sigma''_n)\\), then the meaning of \\(C;D\\) contains \\(u(\\sigma_n,\\sigma''_n)w\\), where \\(w\\) is a shuffle of \\(u'\\) and \\(v\\). Notice that\nthe marker from \\( u(\\sigma_n, \\sigma'_n \\text{ Ret})u' \\) disappears in this combination. The marker in \\( u(\\sigma_n, \\sigma''_n)w \\), if present, comes from \\( (\\sigma'_n, \\sigma''_n)v \\). An analogous combination applies when the meaning of \\( C \\) contains \\( u(\\sigma_n, \\sigma'_n \\text{ Ret})u' \\) and the meaning of \\( D \\) contains \\( (\\sigma'_n, \\sigma''_n \\text{ Ret})v \\) (a trace that starts with a transition with a marker). Moreover, if the meaning of \\( C \\) contains a trace without any occurrence of the marker \\( \\text{Ret} \\), then this trace is also in the meaning of \\( C ; D \\): the absence of a marker makes it impossible to combine this trace with traces from \\( D \\).\n\nAn additional marker, “Done”, ends traces that represent complete normally terminating executions. Thus, the meaning of \\( \\text{skip} \\) will consist of the empty sequence \\( \\varepsilon \\) and every sequence of the form \\( \\sigma, \\sigma \\text{ Ret} \\) plus every sequence of the form \\( \\sigma, \\sigma \\text{ Ret} \\text{Done} \\). Contrast this with the meaning of \\( \\text{yield; block} \\) given above.\n\nIt is possible for a trace to contain a \\( \\text{Ret} \\) marker but not a \\( \\text{Done} \\) marker. Thus, the meaning of \\( \\text{async } (\\text{block}) \\) will contain the empty sequence \\( \\varepsilon \\) plus every sequence of the form \\( \\sigma, \\sigma \\text{ Ret} \\), but not \\( \\sigma, \\sigma \\text{ Ret} \\text{Done} \\).\n\nMore elaborately, the meaning of the code of Figure 2 will contain all traces of the form\n\n\\[\n(\\sigma, \\sigma[1])(\\sigma[1], \\sigma[0])(\\sigma[0], \\sigma[2] \\text{ Ret})\\text{Done}\n\\]\n\nwhere we write \\( \\sigma[n] \\) as an abbreviation for \\( \\sigma[x \\mapsto n] \\). These traces model normal termination after taking the true branch of the conditional \\( \\text{if } x = 0 \\text{ then } x := 2 \\text{ else block} \\). The meaning will also contain all prefixes of those traces, which model partial executions— including those that take the false branch of the conditional and terminate abnormally.\n\nThe two markers are somewhat similar. However, note that \\( (\\sigma, \\sigma' \\text{ Ret}) \\) is a prefix of \\( (\\sigma, \\sigma' \\text{ Ret})\\text{Done} \\), but \\( (\\sigma, \\sigma') \\) is not a prefix of \\( (\\sigma, \\sigma' \\text{ Ret}) \\). Such differences are essential.\n\n### 4.2. Transitions and Transition Sequences\n\nA plain transition is a pair of stores \\((\\sigma, \\sigma')\\). A return transition is a pair of stores \\((\\sigma, \\sigma' \\text{ Ret})\\) in which the second is adorned with the marker \\( \\text{Ret} \\). A transition is a plain transition or a return transition.\n\nA main-thread transition sequence (hereunder simply: transition sequence) is a finite (possibly empty) sequence, beginning with a sequence of transitions, of which at most one (not necessarily the last) is a return transition, and optionally followed by the marker \\( \\text{Done} \\) if one of the transitions is a return transition. We write \\( TSeq \\) for the set of transition sequences.\n\nA pure transition sequence is a finite sequence of plain transitions, possibly followed by a marker \\( \\text{Done} \\). Note that such a sequence need not be a transition sequence. It is proper if it is not equal to \\( \\text{Done} \\). We write \\( PSeq \\) for the set of pure transition sequences, and \\( PPSeq \\) for the subset of the proper ones.\n\nWe use the following notation:\n\n- We typically let \\( u, v, \\) and \\( w \\) range over transition sequences or pure transition sequences, and let \\( t \\) range over non-empty ones.\n- We write \\( u \\leq_{p} v \\) for the prefix relation between sequences \\( u \\) and \\( v \\) (for both kinds of sequences, pure or not). For example, as mentioned above, we have that \\( (\\sigma, \\sigma' \\text{ Ret}) \\leq_{p} (\\sigma, \\sigma' \\text{ Ret})\\text{Done} \\), but \\( (\\sigma, \\sigma') \\not\\leq_{p} (\\sigma, \\sigma' \\text{ Ret}) \\).\n- A set \\( P \\) is prefix-closed if whenever \\( u \\leq_{p} v \\in P \\) then \\( u \\in P \\). We write \\( P \\downarrow \\) for the least prefix-closed set that contains \\( P \\).\n- For a non-empty sequence of transitions \\( t \\), we write \\( \\text{fst}(t) \\) for the first store of the first transition of \\( t \\).\n- For a transition sequence \\( u \\), we write \\( u^{c} \\) for the pure transition sequence obtained by cleaning \\( u \\), which means removing the \\( \\text{Ret} \\) marker, if present, from \\( u \\).\n4.3. Interpretation of Commands.\n\nPreliminaries. We let Proc be the collection of the non-empty prefix-closed sets of transition sequences, and let Pool be the collection of the non-empty prefix-closed sets of pure transition sequences. Under the subset partial ordering, Proc and Pool are both ω-cpos (i.e., partial orders with sups of increasing sequences) with least element {ε}. We interpret commands as elements of Proc. We use Pool as an auxiliary ω-cpo; below it also serves for the semantics of thread pools. We also let AProc be the sub-ω-cpo of Pool of all non-empty prefix-closed sets of proper pure transition sequences. We think of such sets as modeling asynchronous threads, spawned by an active thread; the difference from Pool is that the latter also contains an element that models the empty thread pool.\n\nWe define a continuous cleaning function\n\n\\( -c : \\text{Proc} \\rightarrow \\text{AProc} \\)\n\nby:\n\n\\[ P^c = \\{ u^c \\mid u \\in P \\} \\]\n\n(Continuous functions are those preserving all sups of increasing sequences.)\n\nWe define the set \\( u \\bowtie v \\) of shuffles of a pure transition sequence \\( u \\) with a sequence \\( v \\), whether a transition sequence or a pure transition sequence, as follows:\n\n- If neither finishes with Done, their set of shuffles is defined as usual for finite sequences.\n- If \\( u \\) does not finish with Done, then a shuffle of \\( u \\) and \\( v \\) Done is a shuffle of \\( u \\) and \\( v \\).\n- If \\( v \\) does not finish with Done, then a shuffle of \\( u \\) Done and \\( v \\) is a shuffle of \\( u \\) and \\( v \\).\n- A shuffle of \\( u \\) Done and \\( v \\) Done is a shuffle of \\( u \\) and \\( v \\) followed by Done.\n\nIf both \\( u \\) and \\( v \\) are pure transition sequences then so is every element of \\( u \\bowtie v \\); if \\( u \\) is a pure transition sequence and \\( v \\) is a transition sequence, then every element of \\( u \\bowtie v \\) is a transition sequence.\n\nLemma 4.1. For any \\( u, v, \\) and \\( w \\) where either:\n\n- all three are pure transition sequences, or\n- \\( u \\) and \\( v \\) are pure transition sequences, and \\( w \\) is a transition sequence\n\nwe have:\n\n\\[ \\bigcup \\{ v' \\bowtie w \\mid v' \\in u \\bowtie v \\} = \\bigcup \\{ u \\bowtie v' \\mid v' \\in v \\bowtie w \\} \\]\nWe define a continuous composition function\n\\[ \\circ : \\text{Proc}^2 \\to \\text{Proc} \\]\nby:\n\\[\nP \\circ Q = \\{ u(\\sigma, \\tau)v \\mid \\exists \\sigma', w, w'. u(\\sigma, \\sigma' \\text{ Ret})w \\in P, \\\\\n(\\sigma', \\tau)w' \\in Q, v \\in w \\triangleright w' \\} \\\\\n\\cup \\{ u \\mid u \\in P \\text{ with no return transition} \\}\n\\]\nComposition is associative with two-sided unit, given by:\n\\[ * = \\{(\\sigma, \\sigma \\text{ Ret})\\text{Done} \\mid \\sigma \\in \\text{Store}\\} \\]\n\nWe also define a continuous delay function\n\\[ d : \\text{Proc} \\to \\text{Proc} \\]\nby:\n\\[\nd(P) = \\{ (\\sigma, \\sigma)u \\mid \\sigma \\in \\text{Store}, u \\in P \\}\\]\n\nThus, \\( d(P) \\) is \\( P \\) preceded by all possible stutters (plus \\( \\varepsilon \\)). Similarly, we define a continuous function\n\\[ \\text{async} : \\text{AProc} \\to \\text{Proc} \\]\nby:\n\\[\n\\text{async}(Q) = \\{ (\\sigma, \\sigma \\text{ Ret})u \\mid \\sigma \\in \\text{Store}, u \\in Q \\}\\]\n\nThus, for \\( P \\in \\text{Proc}, \\text{async}(P^c) \\) differs from \\( d(P) \\) only in the placement of the marker Ret.\n\n4.3.1. Interpretation. The denotational semantics\n\\[ [\\cdot] : \\text{Com} \\longrightarrow \\text{Proc} \\]\nmaps a command to a non-empty prefix-closed set of transition sequences. We define it in Figure 5. There, the interpretation of loops relies on the following approximations:\n\\[\n(\\text{while } b \\text{ do } C)_0 = \\text{block} \\\\\n(\\text{while } b \\text{ do } C)_{i+1} = \\text{if } b \\text{ then } (C;(\\text{while } b \\text{ do } C)_{i}) \\text{ else skip}\n\\]\nThe 0-th approximant corresponds to divergence, which here we identify with blocking.\n\nWe straightforwardly extend the semantics to contexts, so that\n\\[ [C] : \\text{Proc} \\to \\text{Proc} \\]\nis a continuous function on Proc. This function is defined by induction on the form of $C$, with the usual clauses of the definition of $[[\\cdot]]$ plus $[[\\cdot]](P) = P$.\n\n**Proposition 4.2.** $[[C]][[C]] = [[C]][[[C]]]$. Therefore, if $[[C]] \\subseteq [[D]]$ then $[[C]][[C]] \\subseteq [[C]][[D]]$. □\n\n### 4.4. Interpretation of Thread Pools.\n\nAs an auxiliary definition, it is important to have also an interpretation of thread pools as elements of Pool. We develop one in this section.\n\n#### 4.4.1. Preliminaries.\n\nWe define a continuous shuffle operation\n\n$$\\triangledown: (\\text{Pool})^2 \\rightarrow \\text{Pool}$$\n\nat this level by:\n\n$$P \\triangledown Q = \\bigcup_{u \\in P, v \\in Q} u \\triangledown v$$\n\nThe shuffle operation is commutative and associative, with unit $I = \\{\\varepsilon, \\text{Done}\\}$; associativity follows from Lemma 4.1.\n\nWe define the set of right shuffles $u \\triangleright v$ of a pure transition sequence $u$ with a transition sequence $v$ by setting\n\n$$u \\triangleright (\\sigma, \\tau)v = \\{(\\sigma, \\tau)w \\mid w \\in u \\triangledown v\\}$$\n\nand\n\n$$u \\triangleright \\varepsilon = \\{\\varepsilon\\}$$\n\nWe then define\n\n$$\\text{async}: \\text{Pool} \\times \\text{Proc} \\rightarrow \\text{Proc}$$\n\nby:\n\n$$\\text{async}(P, Q) = \\bigcup_{u \\in P, v \\in Q} u \\triangleright v$$\n\nThe use of the notation async for both a unary and a binary operation is a slight abuse, though in line with the algebraic theory of effects: see the discussion in Section 6. In this regard note the equality $\\text{async}(P) \\circ Q = \\text{async}(P, Q)$ (and the equality $[\\text{yield}] \\circ P = d(P)$ points to the corresponding relationship between $d$ and $[\\text{yield}]$).\n\n#### 4.4.2. Interpretation.\n\nWe define the semantics of thread pools by:\n\n$$[[C_1, \\ldots, C_n]] = [[C_1]]^e \\triangledown \\ldots \\triangledown [[C_n]]^e \\quad (n \\geq 0)$$\n\nintending that $[\\varepsilon] = I$. For any thread pool $T$, $\\text{Done} \\in [T]$ iff $T = \\varepsilon$ (because, for all $C$, $\\text{Done} \\notin [[C]]^e$ and, for all $P$ and $Q$, $I \\subseteq P \\triangledown Q$ iff $I \\subseteq P$ and $I \\subseteq Q$). Further, we set $[T, C] = \\text{async}([T], [C])$.\n\n**Lemma 4.3.** For all $P, Q \\in \\text{Pool}$ and $R \\in \\text{Proc}$ we have:\n\n1. $\\text{async}(P \\triangledown Q, R) = \\text{async}(P, \\text{async}(Q, R))$\n2. $\\text{async}(I, R) = R$\n\n**Proof.** For the first part, one shows for all pure transition sequences $u$ and $v$ and transition sequences $w$ that:\n\n$$\\bigcup \\{v' \\triangleright w \\mid v' \\in u \\triangledown v\\} = \\bigcup \\{u \\triangleright v' \\mid v' \\in v \\triangleright w\\}$$\n\nTo this end, one proceeds by cases on $w$, using Lemma 4.1. The second part is obvious. □\n4.5. **Equivalences.** An attractive application of denotational semantics is in proving equivalences and implementation relations between commands. Such denotational proofs tend to be simple calculations. Via adequacy and full-abstraction results (of the kind established in Section 5), one then obtains operational results that would typically be much harder to obtain directly by operational arguments.\n\nAs an example, we note that we have the following equivalence:\n\n\\[\n\\texttt{async } (C; \\texttt{yield } D) = (\\texttt{async } (C; \\texttt{async } D))\n\\]\n\nThis equivalence follows from three facts:\n\n- We have:\n \\[\n \\texttt{[yield } D]^c = \\texttt{[async } (D)]^c = \\{ (\\sigma, u^c) \\mid \\sigma \\in \\text{Store}, u \\in [D] \\};\n \\]\n- whenever \\([D_1]^c = [D_2]^c\\), \\([C; D_1]^c = [C; D_2]^c\\);\n- whenever \\([D_1]^c = [D_2]^c\\), \\([\\texttt{async } (D_1)]^c = [\\texttt{async } (D_2)]^c\\).\n\nThis particular equivalence is interesting for two reasons:\n\n- It models an implementation strategy (in use in AME) where, when executing \\(C; \\texttt{yield } D\\), the \\texttt{yield} causes a new asynchronous thread for \\(D\\) to be added to the thread pool.\n- It illustrates one possible, significant pitfall in more explicit semantics. As discussed above, such a semantics might detail that a particular step in a computation causes the spawning of a thread. More specifically, it might extend transitions with an extra trace component: a triple \\((\\sigma, u, \\tau)\\) might represent a step from \\(\\sigma\\) to \\(\\tau\\) that spawns a thread that contains the trace \\(u\\). With such a semantics, the meanings of \\(\\texttt{async } (C; \\texttt{yield } D)\\) and \\(\\texttt{async } (C; \\texttt{async } D)\\) would be different, since they have different spawning behavior.\n\nMany other useful equivalences hold. For instance, we have:\n\n\\[\n\\texttt{[x := n}; x := n'] = \\texttt{[x := n']}\n\\]\n\ntrivially. For every \\(C\\), we also have:\n\n\\[\n\\texttt{[async } (C); x := n] = \\texttt{[x := n}; \\texttt{async } (C)]\n\\]\n\nand, for every \\(C\\) and \\(D\\), we have:\n\n\\[\n\\texttt{[async } (C); \\texttt{async } (D)] = \\texttt{[async } (D}; \\texttt{async } (C)]\n\\]\n\nAnother important equivalence is:\n\n\\[\n\\texttt{[while } (0 = 0) \\texttt{ do skip] = [block]}\n\\]\n\nThus, the semantics does not distinguish an infinite loop which never yields from immediate blocking. On the other hand, we have:\n\n\\[\n\\texttt{[while } (0 = 0) \\texttt{ do yield] \\neq [block]}\n\\]\n\nThe command \\texttt{while } (0 = 0) \\texttt{ do yield} generates unbounded sequences of stutters \\((\\sigma, \\sigma)\\). Similarly, we have:\n\n\\[\n\\texttt{[yield}; \\texttt{yield] \\neq [yield]}\n\\]\n\nAlternative semantics that would distinguish \\texttt{while } (0 = 0) \\texttt{ do skip} from \\texttt{block} or that would identify \\texttt{while } (0 = 0) \\texttt{ do yield} with \\texttt{block} and \\texttt{yield}; \\texttt{yield} with \\texttt{yield} are viable, however. We briefly discuss those variants and others in Section 7.\nWe leave as subjects for further research the problems of axiomatizing and of deciding equivalence and implementation relations, and the related problem of program verification, perhaps restricted to subsets of the language—even, for example, to the subset with just composition, spawning, and yielding. There is a large literature on axiomatization and decidability in concurrency theory; see, e.g., [AI07] for discussion and further references. Also, recent results on the automatic verification of asynchronous programs appear rather encouraging [JM07, GMR09]; some of their ideas might be applicable in our setting.\n\n4.6. Two Extensions. Trace-based semantics can also be given for variants and enhancements of our basic imperative language. Here we illustrate this point by considering two such enhancements, which illustrate the use of Ret and Done. Section 7 briefly considers other possible language features.\n\n4.6.1. finish. While cleaning maps a transition sequence sequence to a proper pure transition sequence, a marking function maps a proper pure transition sequence to a transition sequence. For a proper pure transition sequence $u$, we define $u^m$ by:\n\n\\[\n\\begin{align*}\n v(\\sigma, \\sigma')^m & = v(\\sigma, \\sigma' \\text{ Ret})^m \\\\\nv^m & = v & \\text{(if } v \\text{ does not contain Done)}\n\\end{align*}\n\\]\n\nThus, $u^m$ includes a marker Ret only if $u$ contains a marker Done (that is, if $u$ corresponds to a terminating execution); the marker Ret is on the last transition of $u^m$, intuitively indicating that control is returned to the sequential context when execution terminates.\n\nMuch as for cleaning, we extend marking to non-empty prefix-closed sets of proper pure transition sequences:\n\n\\[\n-^m : \\text{AProc} \\rightarrow \\text{Proc}\n\\]\n\nUsing this extension, we can define the meaning of a construct finish, inspired by that of the X10 language [CGA05, SJ05]. We set:\n\n\\[\n[\\text{finish } C] = ([C])^m\n\\]\n\nThe intent is that finish $C$ executes $C$ and returns control when all activities spawned by $C$ terminate. For instance, in finish (async ($x := 0$)); $x := 1$, the assignment $x := 1$ will execute only after $x := 0$ is done. In contrast, in async ($x := 0$); $x := 1$, the assignments have the opposite ordering. However, finish (async ($x := 0$)) is not equivalent to $x := 0$, but rather to yield; $x := 0$. Beyond this simple example, finish can be applied to more complex commands, possibly with nested forks, and ensures that all the activities forked terminate before returning control.\n\n4.6.2. Parallel Composition. The definition of parallel composition relies on familiar themes: the use of shuffling, and the decomposition of parallel composition into two cases. The cases correspond to whether the left or the right argument of parallel composition takes the first step.\n\nWe define parallel composition at the level of transition sequences by letting $u || u'$ and $u || u'$ be the least sets that satisfy prefix-closure and the following clauses:\n\n- $w \\in (\\varepsilon || w)$ and $w \\in (w || \\varepsilon)$,\n- $(t || t') \\cup (t' || t) \\subseteq (t || t')$,\n- if $v \\in (w || t')$, then $(\\sigma, \\sigma')v \\in (\\sigma, \\sigma')w || t'$,\n- if $v \\in w \\Rightarrow w'$ then $(\\sigma, \\tau)v \\in (\\sigma, \\text{Ret}w) || (\\sigma', \\tau)w'$.\nExtending this function to\n\\[-\\|\\text{Proc} \\times \\text{Proc} \\rightarrow \\text{Proc}\\]\nwe can define the meaning of a parallel-composition construct:\n\\[[C \\parallel D] = [C] \\parallel [D]\\]\nThe reader may verify that parallel composition, as defined here, has the expected properties, for instance that it is commutative and associative with unit \\text{skip}. It is also worth noting that (under mild assumptions on the available expressions) the binary nondeterministic choice operator \\(\\cup\\) considered in Section 6.1 is definable from parallel composition. The converse also holds, under restricted circumstances: if all occurrences of \\text{yield} in \\(C\\) and \\(D\\) occur inside an \\text{async} then we have:\n\\[[C \\parallel D] = [C; D] \\cup [D; C]\\]\n\n5. Adequacy and Full Abstraction\n\nIn this section we establish that the denotational semantics of Section 4 coincides with the operational semantics of Section 3, and is fully abstract.\n\nThe adequacy theorem (Theorem 5.10), which expresses the coincidence, says that the traces that the denotational semantics predicts are exactly those that can happen operationally. These traces may in general represent the behavior of a command in a context. As a special case, the adequacy theorem applies to runs, which are essentially traces that the command can produce on its own, i.e., with an empty context. This special case is spelled out in Corollary 5.11 which states that the runs that the denotational semantics predicts are exactly those that can happen operationally.\n\nThe full-abstraction theorem (Theorem 5.15) states that two commands \\(C\\) and \\(D\\) have the same set of traces denotationally if, and only if, they produce the same runs in combination with every context. In particular, observing runs, we cannot distinguish \\(C\\) and \\(D\\) in any context. Note that, given Corollary 5.11, we may equivalently speak of runs denotationally or operationally. We comment on other possible notions of observation, and the corresponding full-abstraction results, below.\n\nSection 5.1 defines runs precisely. Sections 5.2 and 5.3 present our adequacy and full-abstraction results, respectively.\n\n5.1. Runs. A pure transition sequence \\textit{generates a run} if, however it can be written as \\(u(\\sigma, \\sigma')(\\sigma'', \\sigma''')v\\), we have \\(\\sigma' = \\sigma''\\). If \\(w = (\\sigma_1, \\sigma_2) \\ldots (\\sigma_{n-1}, \\sigma_n)\\) is such a pure transition sequence, we set \\(\\text{run}(w) = \\sigma_1 \\ldots \\sigma_n\\) and \\(\\text{run}(w\\text{Done}) = \\sigma_1 \\ldots \\sigma_n\\text{Done}\\). A transition sequence \\(u\\) \\textit{generates a run} if \\(u^c\\) does, and then we set \\(\\text{run}(u) = \\text{run}(u^c)\\).\n\nIf a pure transition sequence \\(u\\) generates a run, then it can be easily be recovered from \\(\\text{run}(u)\\): the run \\(\\sigma_1 \\ldots \\sigma_n\\) maps back to\n\\[(\\sigma_1, \\sigma_2) \\ldots (\\sigma_{n-1}, \\sigma_n)\\]\nand the run \\(\\sigma_1 \\ldots \\sigma_n\\text{Done}\\) maps back to\n\\[(\\sigma_1, \\sigma_2) \\ldots (\\sigma_{n-1}, \\sigma_n)\\text{Done}\\]\nSince each non-empty run contains at least two elements, this definition applies when \\( n = 0 \\) and \\( n \\geq 2 \\). We write \\( \\text{runs}(P) \\) for the set of runs generated by (pure) transition sequences in \\( P \\).\n\n5.2. Adequacy.\n\nLemma 5.1. The following equalities hold:\n\n1. \\([E[\\text{block}]]^c = [\\text{block}]^c\\)\n2. \\([\\text{skip}; C]^c = [C]^c\\)\n3. \\([E[\\text{async } D]]^c = \\text{async}([D]^c, [E[\\text{skip}]]^c)\\)\n4. \\([E[\\text{yield}]]^c = \\text{async}([E[\\text{skip}]]^c, [\\text{skip}])^c\\)\n5. For all \\( T \\neq \\varepsilon \\) (equivalently \\( \\text{Done} \\not\\in \\{T\\} \\)),\n \\([T] = \\bigcup \\{[T', T'', C]^c \\mid T = T'.C.T''\\}\\)\n\nProof. The first part is immediate from the semantics of \\text{block} and the definition of composition. The second part holds as \\( \\ast \\) is a unit for composition. The third part follows from the facts that \\( \\text{async}(P) \\circ Q = \\text{async}(P, Q) \\) and that composition is associative with unit \\( \\ast \\).\n\nFor the fourth part, using the third part one sees that it is enough to show that for every \\( E \\) we have:\n\\([E[\\text{yield}]]^c = \\text{async} E[\\text{skip}]^c\\)\n\nAs composition is associative with unit \\( \\ast \\), this is equivalent to showing that, for every \\( C \\) we have:\n\\([\\text{yield}; C]^c = \\text{async}([C]^c)^c\\)\n\nwhich follows immediately, expanding the definitions. The proof of the fifth part is a straightforward verification.\n\nLemma 5.2. If \\( C \\) is blocked then, for all \\( T \\), \\([T, C] = \\{\\varepsilon\\}\\).\n\nProof. We calculate:\n\\[ [T, E[\\text{block}]] = \\text{async}([T], [E[\\text{block}]]) \\]\n\\[ = \\text{async}([T], [\\text{block}]) \\quad \\text{(by Lemma 5.1)} \\]\n\\[ = \\{\\varepsilon\\} \\]\n\nLemma 5.3. \\([T, \\text{skip}] = \\{(\\sigma, \\sigma \\text{ Ret})v \\mid v \\in [T]\\}\\).\n\nProof. Immediate from the definition of \\text{async}.\n\nThe next lemma applies when \\( C \\) is neither \\text{skip} nor blocked.\n\nLemma 5.4. Suppose that \\( \\langle \\sigma, T, C \\rangle \\rightarrow_a \\langle \\sigma', T', C' \\rangle \\). Then, for any \\( \\sigma'', (\\sigma, \\sigma'')v \\in [T, C]^c \\)\n\\iff (\\( \\sigma', \\sigma'' \\))v \\in [T', C']^c.\n\nProof. We divide into cases according to the form of \\( C \\). In the case where \\( C \\) has the form \\( E[\\text{skip}; D] \\) we have \\( \\sigma' = \\sigma, T' = T \\) and \\( C' = E[D] \\). So, by Lemma 5.1 we have \\([T', C'] = [T, C] \\), and we are done.\nIn the case where \\( C \\) instead has the form \\( \\mathcal{E}[\\text{async } D] \\), we have \\( \\sigma' = \\sigma, T' = T.D \\) and \\( C' = \\mathcal{E}[\\text{skip}] \\) and we calculate:\n\n\\[\n[T', C'] = \\left[ T.D, \\mathcal{E}[\\text{skip}] \\right] \\\\\n= \\text{async}(\\left[ T \\right], \\text{async}(\\left[ D \\right]^c, \\left[ \\mathcal{E}[\\text{skip}] \\right]^c)) \\\\\n= \\left[ T, \\mathcal{E}[\\text{async } D] \\right] \\\\\n= \\left[ T, C \\right] \\\\\n\\]\n\n(by Lemma 5.1)\n\nand we are done.\n\nIn the case where \\( C \\) instead has the form \\( \\mathcal{E}[\\text{yield}] \\), we have \\( \\sigma' = \\sigma, T' = T.\\mathcal{E}[\\text{skip}], C' = \\text{skip} \\) and, again using Lemma 5.1, we calculate:\n\n\\[\n[T', C']^c = \\left[ T.\\mathcal{E}[\\text{skip}], \\text{skip} \\right]^c \\\\\n= \\text{async}(\\left[ T \\right], \\text{async}(\\left[ \\mathcal{E}[\\text{skip}] \\right]^c, \\left[ \\text{skip} \\right]^c)) \\\\\n= \\left[ T, \\mathcal{E}[\\text{yield}] \\right]^c \\\\\n= \\left[ T, C \\right]^c \\\\\n\\]\n\nand we are done.\n\nIn the next case, \\( C \\) has the form \\( \\mathcal{E}[x := e] \\), and we have \\( \\sigma' = \\sigma[x \\mapsto \\sigma(e)] \\), \\( T' = T \\) and \\( C' = \\mathcal{E}[\\text{skip}] \\). Here \\( [T, C] = [T, x := e; \\mathcal{E}[\\text{skip}]] \\). So we have that: \\( (\\sigma, \\tau)v \\in [T, C] \\) holds iff \\( (\\sigma', \\tau) \\in [T, \\mathcal{E}[\\text{skip}]] \\).\n\nOtherwise, \\( C \\) has one of the forms \\( \\mathcal{E}[\\text{if } b \\text{ then } C \\text{ else } D] \\) or \\( \\mathcal{E}[\\text{while } b \\text{ do } C] \\) and we proceed much as in the previous case.\n\n**Lemma 5.5.** Suppose that \\( \\langle \\sigma, T, C \\rangle \\rightarrow_a^* \\langle \\sigma', T', \\text{skip} \\rangle \\) with \\( u \\in [T']^c \\). Then \\( (\\sigma, \\sigma')u \\in [T, C]^c \\).\n\n**Proof.** This follows from Lemmas 5.3 and 5.4.\n\nFor the proof of the converse of this lemma, we proceed by an induction on the size of loop-free commands. We then extend to general commands by expressing their semantics in terms of the semantics of their approximations by loop-free commands. The size of a loop-free command is defined by structural recursion:\n\n\\[\n\\text{size}(\\text{skip}) = 1 \\quad \\text{size}(\\text{block}) = 1 \\quad \\text{size}(x := e) = \\text{size}(\\text{async } C) = \\text{size}(\\text{yield}) = 2 \\\\\n\\text{size}(\\text{if } b \\text{ then } C \\text{ else } D) = \\text{size}(C.D) = \\text{size}(C) + \\text{size}(D) \\\\\n\\]\n\nNote that if \\( \\langle \\sigma, T, C \\rangle \\rightarrow_a \\langle \\sigma', T', C' \\rangle \\) and \\( C \\) is loop-free, then so is \\( C' \\) and, further, \\( \\text{size}(C') < \\text{size}(C) \\).\n\nThe approximation relation \\( C \\preceq D \\) between loop-free commands \\( C \\) and general commands \\( D \\) is defined to be the least such relation closed under all non-looping program constructs and such that, for any \\( b, C, D, \\) and \\( i \\geq 0 \\):\n\n\\[\n\\text{block} \\preceq D \\quad C \\preceq D \\quad (\\text{while } b \\text{ do } C_i) \\preceq (\\text{while } b \\text{ do } D) \\\\\n\\]\n\nThis relation is extended to thread pools and contexts in the obvious way: we write \\( T \\preceq T' \\) and \\( C \\preceq C' \\) for these extensions.\n\n**Lemma 5.6.** Suppose that \\( T \\preceq U, C \\preceq D \\), and, further, that \\( \\langle \\sigma, T, C \\rangle \\rightarrow_a \\langle \\sigma', T', C' \\rangle \\). Then, for some \\( U', D' \\) with \\( T' \\preceq U' \\) and \\( C' \\preceq D' \\), \\( \\langle \\sigma, U, D \\rangle \\rightarrow_{a^*} \\langle \\sigma', U', D' \\rangle \\).\n\n**Proof.** One first notes that, for any \\( C, D \\), if \\( \\mathcal{E}[C] \\preceq D \\) then \\( D \\) has the form \\( \\mathcal{E}'[D'] \\) where \\( \\mathcal{E} \\preceq \\mathcal{E}' \\) and \\( C \\preceq D' \\). The proof then divides into cases according to the rule used to show that \\( \\langle \\sigma, T, C \\rangle \\rightarrow_a \\langle \\sigma', T', C' \\rangle \\).\nFor example, suppose we have \\( C = E[\\text{if } b \\text{ then } C_1 \\text{ else } C_2] \\) and \\( \\sigma(b) = \\text{true} \\). We know that \\( D \\) must have the form \\( E'[D'] \\) where \\( E \\preceq E' \\) and \\( (\\text{if } b \\text{ then } C_1 \\text{ else } C_2) \\preceq D' \\). Suppose now that \\( D' \\) has the form \\( \\text{while } b \\text{ do } D'' \\). Then we must have, for some \\( i \\geq 0 \\) that \\( C_1 = C''; (\\text{while } b \\text{ do } C'') \\), where \\( C'' \\preceq D'' \\). But then we observe that\n\n\\[\n\\langle \\sigma, U, D \\rangle \\rightarrow_a \\langle \\sigma, U, E'[\\text{if } b \\text{ then } D''; D' \\text{ else skip}] \\rangle \\rightarrow_a \\langle \\sigma, U, E'[D''; D] \\rangle\n\\]\n\nand the conclusion follows. The other cases are straightforward.\n\nNext we define the approximants \\( C^{(i)} \\) of a command \\( C \\) by induction on \\( i \\) and structural recursion on \\( C \\), beginning with the case where \\( C \\) has one of the forms \\( \\text{skip} \\), \\( \\text{block} \\), \\( x := e \\), or \\( \\text{yield} \\), when \\( C^{(i)} = C \\), and continuing with:\n\n\\[\n(\\text{async } C)^{(i)} = \\text{async } C^{(i)}\n\\]\n\n\\[\n(\\text{if } b \\text{ then } C \\text{ else } D)^{(i)} = \\text{if } b \\text{ then } C^{(i)} \\text{ else } D^{(i)}\n\\]\n\n\\[\n(C; D)^{(i)} = C^{(i)}; D^{(i)}\n\\]\n\n\\[\n(\\text{while } b \\text{ do } C)^{(i)} = (\\text{while } b \\text{ do } C^{(i)});\n\\]\n\nFor any \\( C \\) one shows that \\( C^{(i)} \\preceq C^{(i+1)} \\preceq C \\).\n\n**Lemma 5.7.**\n\n1. If \\( C \\preceq D \\) then \\( [C] \\subseteq [D] \\).\n2. For any command \\( D \\):\n\n\\[\n[D] = \\bigcup_i [D^{(i)}]\n\\]\n\n**Proof.** The first part is evident using the monotonicity of the semantics of the program constructors and the semantic of loops. For the second part, we proceed by structural induction on \\( D \\). All cases are straightforward, using the continuity of the program constructors, except for loops where we calculate:\n\n\\[\n[\\text{while } b \\text{ do } D] = \\bigcup_i [(\\text{while } b \\text{ do } D^{(i)})]\n\\]\n\nWe can now establish the converse of Lemma 5.5.\n\n**Lemma 5.8.** Suppose that \\( (\\sigma, \\sigma')u \\in [T, C]^c \\). Then \\( (\\sigma, T, C) \\rightarrow_a^* (\\sigma', T', \\text{skip}) \\) for some \\( T' \\) with \\( u \\in [T']^c \\).\n\n**Proof.** We begin by proving this for loop-free commands \\( C \\). The proof is by induction on the size of \\( C \\). If \\( C \\) is \\( \\text{skip} \\) we have \\( (\\sigma, T, \\text{skip}) \\rightarrow_a^* (\\sigma, T, \\text{skip}) \\) and the conclusion follows, as, by Lemma 5.3 \\( (\\sigma, \\sigma')u \\in [T, \\text{skip}]^c \\) iff \\( \\sigma' = \\sigma \\) and \\( u \\in [T]^c \\). If \\( C \\) is blocked, the conclusion holds trivially, by Lemma 5.2.\n\nIf \\( C \\) is neither \\( \\text{skip} \\) nor blocked we have \\( (\\sigma, T, C) \\rightarrow_a (\\sigma'', T'', C'') \\) (and then \\( C'' \\) is loop-free and \\( |C''| < |C| \\)). Then, by Lemma 5.4 \\( (\\sigma, \\sigma')u \\in [T, C]^c \\) iff \\( (\\sigma'', \\sigma')u \\in [T'', C'']^c \\) which latter, by the induction hypothesis, implies \\( (\\sigma'', T'', C'') \\rightarrow_a^* \\) some \\( (\\sigma', T', \\text{skip}) \\) with \\( u \\in [T']^c \\) which, in turn, implies \\( (\\sigma, T, C) \\rightarrow_a^* \\) some \\( (\\sigma', T', \\text{skip}) \\) with \\( u \\in [T']^c \\), as desired.\nNext suppose that $(\\sigma, \\sigma') u \\in [T, D]$, where now $D$ is not loop-free. By Lemma 5.7, $(\\sigma, \\sigma') u \\in [T, C]$, for some $C \\leq D$. So, by the above, $\\langle \\sigma, T, C \\rangle \\rightarrow a \\ast$ some $\\langle \\sigma', T', \\text{skip} \\rangle$ with $u \\in [T']$. The desired conclusion follows immediately, using Lemma 5.6.\n\n**Lemma 5.9.**\n\n(1) For any proper non-empty pure transition sequence $u, (\\sigma, \\sigma') u \\in [T, C]$ iff for some $T', C', \\langle \\sigma, T, C \\rangle \\rightarrow a \\ast \\rightarrow_{a}^n \\langle \\sigma', T', C' \\rangle$ with $u \\in [T', C']$.\n\n(2) For any $\\sigma, \\sigma', T, C$, $\\langle \\sigma, \\sigma' \\rangle \\text{Done} \\in [T, C]$ iff $\\langle \\sigma, T, C \\rangle \\rightarrow a \\ast$ some $\\langle \\sigma', T', \\text{skip} \\rangle$, with $u \\in [T']$. In the case where $u$ is proper the conclusion follows from Lemma 5.1.\n\nThe following *Adequacy Theorem* for pure transition sequences is an immediate consequence of Lemmas 5.8 and 5.9.\n\n**Theorem 5.10.**\n\n(1) For $n > 0$, $(\\sigma_1, \\sigma_1') \\ldots (\\sigma_n, \\sigma_n') \\in [T, C]$ iff there are $T_i, C_i, (i = 1, n)$ such that $T_1 = T$, $C_1 = C$, and $\\langle \\sigma_i, T_i, C_i \\rangle \\rightarrow a \\ast \\rightarrow_{a}^n \\langle \\sigma_i', T_{i+1}, C_{i+1} \\rangle$, for $1 \\leq i \\leq n - 1$, and $\\langle \\sigma_n, T_n, C_n \\rangle \\rightarrow a \\ast$ some $\\langle \\sigma_n', T', \\text{skip} \\rangle$.\n\n(2) For $n > 0$, $(\\sigma_1, \\sigma_1') \\ldots (\\sigma_n, \\sigma_n') \\text{Done} \\in [T, C]$ iff there are $T_i, C_i, (i = 1, n)$ such that $T_1 = T$, $C_1 = C$, and $\\langle \\sigma_i, T_i, C_i \\rangle \\rightarrow a \\ast \\rightarrow_{a}^n \\langle \\sigma_i', T_{i+1}, C_{i+1} \\rangle$, for $1 \\leq i \\leq n - 1$, and $\\langle \\sigma_n, T_n, C_n \\rangle \\rightarrow a \\ast$ some $\\langle \\sigma_n', \\varepsilon, \\text{skip} \\rangle$. \n\nAs a corollary we obtain an adequacy theorem for runs:\n\n**Corollary 5.11.**\n\n(1) For $n \\geq 2$, $\\sigma_1 \\ldots \\sigma_n \\in \\text{runs([T, C])}$ iff there are $T_i, C_i, (i = 1, n - 1)$ such that $T_1 = T$, $C_1 = C$, and $\\langle \\sigma_i, T_i, C_i \\rangle \\rightarrow a \\ast \\rightarrow_{a}^n \\langle \\sigma_i', T_{i+1}, C_{i+1} \\rangle$ (1 $\\leq i \\leq n - 2$), and $\\langle \\sigma_{n-1}, T_{n-1}, C_{n-1} \\rangle \\rightarrow a \\ast$ some $\\langle \\sigma_n, T', \\text{skip} \\rangle$.\n\n(2) For $n \\geq 2$, $\\sigma_1 \\ldots \\sigma_n \\text{Done} \\in \\text{runs([T, C])}$ iff there are $T_i, C_i, (i = 1, n - 1)$ such that $T_1 = T$, $C_1 = C$, and $\\langle \\sigma_i, T_i, C_i \\rangle \\rightarrow a \\ast \\rightarrow_{a}^n \\langle \\sigma_i', T_{i+1}, C_{i+1} \\rangle$ (1 $\\leq i \\leq n - 2$), and $\\langle \\sigma_{n-1}, T_{n-1}, C_{n-1} \\rangle \\rightarrow a \\ast$ some $\\langle \\sigma_n, \\varepsilon, \\text{skip} \\rangle$.\n\n### 5.3. Full Abstraction.\n\nThe first lemma in the proof of full abstraction bounds the non-determinism of commands in semantic terms.\n\n**Lemma 5.12.** For all $C, u$, and $\\sigma$, the set $\\{ \\tau | u(\\sigma, \\tau) \\in \\{ C \\} \\}$ is finite.\n\n**Proof.** More generally, we prove that for all $T, C, u = (\\sigma_1, \\tau_1) \\ldots (\\sigma_n, \\tau_n)$, and $\\sigma_n$, the set $\\{ \\tau | u(\\sigma_n, \\tau) \\in [T, C] \\}$ is finite, and similarly that the set $\\{ \\tau | u(\\sigma_n, \\tau) \\in [T] \\}$ is finite. The proof is by induction on $n$. The proof relies on adequacy; a purely semantic proof might be possible but seems harder.\n\n- If $C$ is *skip*, then Lemma 5.3 implies that $\\tau_1$ is $\\sigma_1$ Ret, and $(\\sigma_2, \\tau_2) \\ldots (\\sigma_n, \\tau) \\in [T]$. In case $n = 1$, we are done, with a unique choice for $\\tau_1$. Otherwise, we conclude by induction hypothesis.\n- If $C$ is blocked, then $n = 0$, by Lemma 5.2 so this case is vacuous.\n• If \\( C \\) is neither \\texttt{skip} nor blocked, then Lemma 5.8 implies that \\( \\tau_1 \\) is unique. In case \\( n = 1 \\), we are done, with a unique choice for \\( \\tau_1 \\). Otherwise, Lemma 5.8 also implies that \\((\\sigma_2, \\tau_2) \\ldots (\\sigma_n, \\tau) \\in [T']\\) for a unique \\( T' \\). As in the case of \\texttt{skip}, the desired conclusion follows by induction hypothesis.\n\n• Finally, having established the claim for sequences of length \\( n \\) for sets of the form \\([T, C]\\), we consider sequences of length \\( n \\) in a set of the form \\([T]\\). Suppose that \\( T \\) consists of \\( C_1, \\ldots, C_k \\). A transition sequence \\( v \\) in \\([T]\\) is a shuffle of transition sequences in \\([C_1], \\ldots, [C_k]\\), each of length at most \\( n \\). The finiteness property for \\([T]\\) follows from the fact that there are only finitely many possible ways of decomposing \\( v \\) as a shuffle.\n\n\\[ \\square \\]\n\nIntuitively, Lemma 5.12 is useful because it implies that, at any point, there are certain steps that a command cannot take, and in proofs those steps can be used as unambiguous, visible markers of activity by the context. This lemma is somewhat fragile—it does not hold once one adds to the language either the nondeterministic choice operator considered in Section 6.1 or the parallel composition operator of Section 4.6.2. It follows that neither of these operators is definable in the language. An alternative argument that does not use the lemma relies on fresh variables instead. The fresh variables permit an alternative definition of the desired markers.\n\nFull-abstraction results invariably require some notion of observation. Let us write \\( \\text{obs}(P) \\) for the observations that we make on \\( P \\in \\text{Proc} \\). Equational full abstraction is that \\([C] = [D] \\) if and only if, for every context \\( C \\), we have \\( \\text{obs}([C[C]]) = \\text{obs}([C[D]]) \\). In other words, two commands have the same meaning if and only if they yield the same observations in every context of the language. The stronger inequational full abstraction is that \\([C] \\subseteq [D] \\) if and only if, for every context \\( C \\), we have \\( \\text{obs}([C[C]]) \\subseteq \\text{obs}([C[D]]) \\). The difficult part of this equivalence is usually the implication from right to left: that if, for every context \\( C \\), \\( \\text{obs}([C[C]]) \\subseteq \\text{obs}([C[D]]) \\), then \\([C] \\subseteq [D] \\).\n\nOne possible candidate for \\( \\text{obs}(P) \\) is \\( P^c \\). This notion of observation can be criticized as too fine-grained. Nevertheless, we find it useful to prove full abstraction for this notion of observation, with the following lemma. We first need some auxiliary definitions for its proof, and the lemma that follows. Given two stores \\( \\sigma \\) and \\( \\sigma' \\), we define:\n\n• a boolean expression \\( \\text{check}(\\sigma) \\) as the conjunction of the formulas \\( x = n \\) for every variable \\( x \\), where \\( n \\) is the natural number \\( \\sigma(x) \\) (so \\( \\text{check}(\\sigma) \\) is true in \\( \\sigma \\) and false elsewhere);\n\n• a command \\( \\text{goto}(\\sigma) \\) as the sequence of assignments \\( x := n \\) for every variable \\( x \\), where \\( n \\) is the natural number \\( \\sigma(x) \\);\n\n• a command \\( (\\sigma \\rightsquigarrow \\sigma') \\) as \\( \\text{if} \\ \\text{check}(\\sigma) \\ \\text{then} \\ \\text{goto}(\\sigma') \\ \\text{else} \\ \\text{block} \\);\n\n• a command \\( (\\sigma \\rightsquigarrow \\sigma' \\rightsquigarrow \\sigma'') \\) as \\( (\\sigma \\rightsquigarrow \\sigma') \\text{yield} ; (\\sigma' \\rightsquigarrow \\sigma'') \\text{yield} \\).\n\nThese definitions exploit the fact that the set of variables is finite. However, with more care, analogous definitions could be given otherwise, by focusing on the set of variables relevant to the programs under observation.\n\n**Lemma 5.13.** If \\([C[C]]^c \\subseteq [C[D]]^c \\) for every context \\( C \\), then \\([C] \\subseteq [D] \\).\n\n**Proof.** Letting \\( P = [C] \\) and \\( Q = [D] \\), we assume that \\( P \\not\\subseteq Q \\) and prove that there exists \\( C \\) such that \\([C](P)^c \\not\\subseteq [C](Q)^c \\). For this, choose a sequence \\( w \\) in \\( P \\) but not in \\( Q \\). If \\( w = w^c \\), then we can take \\( C \\) to be \\( \\{ \\} \\). Therefore, for the rest of the proof, we consider the case \\( w \\neq w^c \\).\nIf \\( w \\neq w' \\), then \\( w \\) is of the form \\( u(\\sigma, \\sigma' \\text{ Ret})v \\). We let \\( C = [ ]; (\\sigma' \\leadsto \\sigma'') \\) where \\( \\sigma'' \\) does not appear in \\( u \\) or \\( v \\) and \\( u(\\sigma, \\sigma'') \\notin Q \\) (so, by prefix-closure, \\( u(\\sigma, \\sigma'')v \\notin Q \\)). Such a choice of \\( \\sigma'' \\) is always possible by Lemma \\ref{lem:5.12}. Thus, \\( [C](P) \\) contains \\( u(\\sigma, \\sigma' \\text{ Ret})v \\), and \\( [C](P)^c \\) contains \\( u(\\sigma, \\sigma'')v \\).\n\nSuppose that \\( u(\\sigma, \\sigma'')v \\) is also in \\( [C](Q)^c \\), and that this is because some sequence \\( w' \\) is in \\( [C](Q) \\) and \\( w'^c = u(\\sigma, \\sigma'')v \\). By the definition of the semantics of sequential composition, this could arise in one of the following ways:\n\n- \\( w' = u(\\sigma, \\sigma'' \\text{ Ret})v \\), with \\( w \\in Q \\). This contradicts \\( w \\notin Q \\).\n- \\( w' = u'(\\sigma, \\sigma''')v' \\), and \\( \\sigma'' \\) occurs as the second store of a return transition in either \\( u' \\) or \\( v' \\). This contradicts the requirement that \\( \\sigma'' \\) does not appear in \\( u \\) or \\( v \\).\n- \\( w' = u(\\sigma, \\sigma''')v \\), \\( w' \\in Q \\), and \\( w' \\) does not have a return transition. This contradicts the requirement that \\( u(\\sigma, \\sigma'') \\notin Q \\).\n\n\\( \\square \\)\n\nAnother possible candidate for \\( \\text{obs}(P) \\) is \\( \\text{runs}(P) \\). Runs record more than mere input-output behavior, but much less than entire execution histories. We therefore find them attractive for our purposes. The following lemma connects runs to cleaning.\n\n**Lemma 5.14.** If \\( \\text{runs}([C][C]) \\) \\( \\subseteq \\text{runs}([C][D]) \\) for every context \\( C \\), then \\( [C]^c \\subseteq [D]^c \\).\n\n**Proof.** Letting \\( P = [C] \\) and \\( Q = [D] \\), we assume that \\( P^c \\notin Q^c \\) and prove that there exists \\( C \\) such that \\( \\text{runs}([C](P)) \\not\\subseteq \\text{runs}([C](Q)) \\).\n\nFor this, choose a sequence \\( w \\in P^c \\) but \\( w \\notin Q^c \\), in order to derive a contradiction.\n\nFirst, suppose that \\( w \\) is of the form \\( (\\sigma_1, \\sigma'_1) \\ldots (\\sigma_n, \\sigma'_n) \\), with \\( n > 0 \\). We let \\( C \\) be \\( \\text{async } [ ]; \\text{mesh}(w) \\), where \\( \\text{mesh}(w) \\) is the command\n\n\\[\n\\text{yield}; (\\sigma'_1 \\leadsto \\sigma''_1 \\leadsto \\sigma_2); \\ldots; (\\sigma'_{n-1} \\leadsto \\sigma''_{n-1} \\leadsto \\sigma_n); (\\sigma'_n \\leadsto \\sigma''_n)\n\\]\n\nwhere the stores \\( \\sigma''_i \\) are all different from one another and from all other stores in \\( w \\), and are such that\n\n\\[\n(\\sigma_1, \\sigma'_1) \\ldots (\\sigma_i, \\sigma'_i)(\\sigma'_i, \\sigma''_i) \\notin Q^c\n\\]\n\nand\n\n\\[\n(\\sigma_1, \\sigma'_1) \\ldots (\\sigma_i-1, \\sigma'_{i-1})(\\sigma'_{i-1}, \\sigma_i)(\\sigma_i, \\sigma'_i)(\\sigma'_i, \\sigma''_i) \\notin Q^c\n\\]\n\nSuch a choice of stores \\( \\sigma''_i \\) is always possible by Lemma \\ref{lem:5.12}. Since \\( \\text{mesh}(w) \\) contains the transition sequence:\n\n\\[\n(\\sigma_1, \\sigma_1)(\\sigma'_1, \\sigma''_1)\\ldots(\\sigma''_n, \\sigma_n)(\\sigma'_n, \\sigma''_n \\text{ Ret})\\text{Done}\n\\]\n\nwe obtain that \\( [C](P) \\) contains the transition sequence:\n\n\\[\n(\\sigma_1, \\sigma_1)(\\sigma'_1, \\sigma''_1)(\\sigma'_1, \\sigma''_1)(\\sigma'_2, \\sigma'_2) \\ldots (\\sigma''_n, \\sigma_n)(\\sigma'_n, \\sigma''_n \\text{ Ret})\n\\]\n\nwhich generates the run:\n\n\\[\n\\sigma_1\\sigma_1\\sigma''_1\\sigma''_2\\ldots\\sigma''_{n-1}\\sigma\\sigma''_n\\sigma''_n\n\\]\n\nSuppose that this run is also in \\( \\text{runs}([C](Q)) \\). Therefore, there exists \\( w' \\in Q^c \\) such that\n\n\\[\n(\\sigma_1, \\sigma'_1)(\\sigma'_1, \\sigma''_1)(\\sigma'_2, \\sigma'_2) \\ldots (\\sigma''_n, \\sigma_n)(\\sigma'_n, \\sigma''_n)\\text{Done}\n\\]\n\nis a shuffle of \\( w' \\) with\n\n\\[\n(\\sigma'_1, \\sigma'_1)(\\sigma'_1, \\sigma'_1)(\\sigma'_2, \\sigma'_2) \\ldots (\\sigma'_n, \\sigma'_n)\\text{Done}\n\\]\n\nwhich we call \\( w'' \\), or with a prefix of \\( w'' \\). We analyze the origin of the transitions in the shuffle:\n• The transitions \\((\\sigma_i, \\sigma_i')\\) must all come from \\(w'\\), since each of the transitions in \\(w''\\) contains one of the stores \\(\\sigma_j\\) and, by choice, these are different from \\(\\sigma_i\\) and \\(\\sigma_i'\\).\n\n• Suppose that, up to some \\(i - 1 < n\\), \\(w'\\) starts like \\(w\\), in other words it starts as \\((\\sigma_1, \\sigma_1') \\ldots (\\sigma_{i-1}, \\sigma_{i-1}')\\). Suppose further that, in the shuffle up to this point, each transition \\((\\sigma_j, \\sigma_j')\\) is followed immediately by the corresponding transitions \\((\\sigma_j', \\sigma_j'')(\\sigma_j'', \\sigma_{j+1})\\) from \\(w''\\). We argue that this remains the case up to \\(n\\).\n \n – We consider \\((\\sigma_{i-1}', \\sigma_{i-1}'')\\), the next possible transition in the shuffle. This transition cannot come from \\(w'\\) because, by the choice of \\(\\sigma_{i-1}'\\), we have that\n \n \\[(\\sigma_1, \\sigma_1') \\ldots (\\sigma_{i-1}, \\sigma_{i-1}') (\\sigma_{i-1}', \\sigma_i) \\notin Q^c\\]\n \n So this transition comes from \\(w''\\).\n \n – One step further, in order to derive a contradiction, we suppose that the transition \\((\\sigma_{i-1}', \\sigma_i)\\) comes from \\(w'\\). So \\(w'\\) starts:\n \n \\[(\\sigma_1, \\sigma_1') \\ldots (\\sigma_{i-1}, \\sigma_{i-1}') (\\sigma_{i-1}', \\sigma_i)\\]\n \n and in fact:\n \n \\[(\\sigma_1, \\sigma_1') \\ldots (\\sigma_{i-1}, \\sigma_{i-1}') (\\sigma_{i-1}', \\sigma_i) (\\sigma_i, \\sigma_i')\\]\n \n since, as noted above, the last transition here must come from \\(w'\\). The next transition in the shuffle is \\((\\sigma_i', \\sigma_i'')\\). By the choice of \\(\\sigma_i''\\), we have that\n \n \\[(\\sigma_1, \\sigma_1') \\ldots (\\sigma_{i-1}, \\sigma_{i-1}') (\\sigma_{i-1}', \\sigma_i) (\\sigma_i, \\sigma_i') (\\sigma_i', \\sigma_i'') \\notin Q^c\\]\n \n So the transition \\((\\sigma_i', \\sigma_i'')\\) cannot come from \\(w'\\). Therefore, it must come from \\(w''\\). However, the next available transition in \\(w''\\) is \\((\\sigma_{i-1}'', \\sigma_{i-1})\\), and \\((\\sigma_{i-1}'', \\sigma_{i-1})\\) and \\((\\sigma_{i-1}, \\sigma_i)\\) must be different because \\(\\sigma_{i-1}\\) and \\(\\sigma_i\\) are different, by choice, from \\(\\sigma_i'\\) and \\(\\sigma_i''\\).\n\nThus, the assumption that the transition \\((\\sigma_{i-1}', \\sigma_i)\\) comes from \\(w'\\) leads to a contradiction. This transition must come from \\(w''\\).\n\n• Finally, suppose that, up to \\(n\\), \\(w'\\) starts like \\(w\\), in other words as:\n \n \\[(\\sigma_1, \\sigma_1') \\ldots (\\sigma_n, \\sigma_n')\\]\n \n and that, in the shuffle, each transition \\((\\sigma_j, \\sigma_j')\\) is followed immediately by the corresponding transitions \\((\\sigma_j', \\sigma_j'')(\\sigma_j'', \\sigma_{j+1})\\) from \\(w''\\). By the choice of \\(\\sigma_n''\\), we have that\n \n \\[(\\sigma_1, \\sigma_1') \\ldots (\\sigma_n, \\sigma_n') (\\sigma_n', \\sigma_n'') \\notin Q^c\\]\n \n so \\((\\sigma_n', \\sigma_n'')\\) comes from \\(w''\\), not from \\(w'\\).\n\nIn sum, \\(w' = w\\), and therefore \\(w \\in Q^c\\), contradicting our assumption that \\(w \\notin Q^c\\).\n\nNext, suppose that \\(w\\) is of the form \\((\\sigma_1, \\sigma_1') \\ldots (\\sigma_n, \\sigma_n')\\). Done. With the same \\(C\\), we obtain that \\([C](P)\\) contains the transition sequence:\n\n\\[(\\sigma_1, \\sigma_1)(\\sigma_1, \\sigma_1')(\\sigma_1', \\sigma_1')(\\sigma_1', \\sigma_2)(\\sigma_2, \\sigma_2') \\ldots (\\sigma_n, \\sigma_n')(\\sigma_n, \\sigma_n')(\\sigma_n', \\sigma_n'') \\text{ Ret} \\text{ Done}\\]\n\nwhich generates the run:\n\n\\[\\sigma_1 \\sigma_1 \\sigma_1' \\sigma_1'' \\sigma_2 \\sigma_2' \\ldots \\sigma_n \\sigma_n' \\sigma_n'' \\text{ Done}\\]\n\nSuppose that this run is also in \\(\\text{runs}(C \\subseteq Q)\\). Again, by the choice of \\(\\sigma_n'', \\ldots, \\sigma_n''\\), this can be the case only if \\(w\\) is in \\(Q^c\\). (The argument for the contradiction may actually be simplified in this case, because of the marker Done.)\n\n\\[\\square\\]\nWe obtain the following Full-abstraction Theorem:\n\n**Theorem 5.15.** \\([C] \\subseteq [D]\\) iff, for every context \\(C\\), \\(\\text{runs}([C[C]]) \\subseteq \\text{runs}([C[D]])\\).\n\n**Proof.** The implication from \\([C] \\subseteq [D]\\) is an immediate consequence of the compositionality of the semantics (Proposition 4.2). The converse follows from Lemmas 5.13 and 5.14. \\(\\square\\)\n\nCoarser-grained definitions of \\(\\text{obs}(P)\\) may sometimes be appropriate. For those, we expect that full abstraction will typically require additional closure conditions on \\(P\\), such as closure under suitable forms of stuttering and mumbling, much as in our work and Brookes’s on parallel composition \\([AP93, \\text{Bro96}]\\).\n\n6. Algebra\n\nThe development of the denotational semantics in Section 4 is ad hoc, in that the semantics is not related to any systematic approach. In this section we show how it fits in with the algebraic theory of effects \\([PP02, PP03, HPP06, PP08, PP09]\\).\n\nIn the functional programming approach to imperative languages, commands have unit type, 1. Then, taking the monadic point of view \\([BHM02]\\), they are modeled as elements of \\(T(1)\\) for a suitable monad \\(T\\) on, say, the category of \\(\\omega\\)-cpos and continuous functions. For parallelism one might look for something along the lines of the resumptions monad \\([HP79, CM93, HPP06]\\).\n\nIn the algebraic approach to computational effects \\([PP02, HPP06]\\), one analyses the monads as free algebra monads for a suitable equational or Lawvere theory \\(L\\) (here meaning in the enriched sense, so that inequations are allowed, as are families of operations continuously parameterized over an \\(\\omega\\)-cpo). The operations of the theory (for example a binary choice operation in the case of nondeterminism) are thought of as effect constructors in that they create the effects at hand.\n\nAs discussed in \\([HP79]\\), resumptions are generally not fully abstract when their domain equation is solved in a category of cpos. If, instead, it is solved in a category of semilattices, increased abstraction may be obtained. The situation was analyzed from the algebraic point of view in \\([HPP06]\\). It was shown there that resumptions arise by combining a theory for stores \\([PP02]\\) with one for nondeterminism, one for nontermination, and one for a unary operation \\(d\\) thought of as suspending computation. The difference between solving the equation in a category of semilattices or cpos essentially amounts to whether or not one asks that \\(d\\), and the other operations, commute with nondeterminism.\n\nIn \\([Bro96]\\), Brookes, using an apparently different and mathematically elementary trace-based approach, succeeded in giving a fully abstract semantics for a language of the kind considered in \\([HP79]\\). However, in \\([Jef95]\\), Jeffrey showed that trace-based models of concurrent languages can arise as solutions to domain equations in a category of semilattices, thereby relating the two approaches.\n\nWe propose here to identify the suspension operation \\(d\\) with the operation of the same name introduced in Section 4.3; indeed this identification was the origin of the definition of \\text{yield} given there, and it is natural to further identify \\text{yield} as the generic effect \\([PP03]\\) corresponding to the suspension operation. These identifications are justified by Corollary 6.5 below, and the discussion following it.\n\nIn Section 6.1 we carry out an algebraic analysis of resumptions. We show in Theorem 6.1 that, imposing the commutations with nondeterminism just discussed, they do indeed correspond to a traces model, provided one uses the Hoare or lower powerdomain.\n(This powerdomain is a natural choice as we consider only “may” semantics in this paper, and elements of such powerdomains are Scott closed, so downwards-closed, a natural generalization of our prefix-closedness condition.) The proof makes the link between domain equations and traces.\n\nThe missing ingredient in an algebraic analysis of Proc is then an account of async. In the denotational semantics of any command of the form async C, all Ret marking is lost from the meaning of C, because of the application of the cleaning function, \\(-c\\); further all the sequences in \\([C]^c\\) are proper. We propose to treat async as a generic effect, parameterized by an element of AProc (which will be \\([C]^c\\)).\n\nIn order to give the equations for the async operation it will, as one may expect, be useful to first have an algebraic analysis of AProc; we carry out this analysis in Section 6.2. It turns out, as detailed in Theorem 6.2, that AProc is similar to, but not quite, a resumptions \\(\\omega\\)-cpo. Finally, we analyze processes in Section 6.3, showing, in Theorem 6.4, that a process is a kind of “double-thread”—more precisely, a resumption that returns not only a value but also an element of AProc.\n\n6.1. Resumptions. Our theory \\(L_{\\text{Res}}\\) for resumptions follows [HPP06] but is somewhat modified, as we are interested only in “may” semantics and as we wish to allow infinitely proceeding processes. The theory is a combination of several constituent theories which we now consider successively.\n\nThe Lawvere theory \\(L_S\\) of stores can be presented via a family of unary operations update\\(_{x,n}\\) and a family of “\\(N\\)-ary” operations lookup\\(_x\\) (\\(x \\in \\text{Vars}, n \\in N\\)). (An \\(N\\)-ary operation is a countably infinitary operation whose arguments are indexed by the natural numbers.) For any computation \\(\\gamma\\), update\\(_{x,n}(\\gamma)\\) is read as the computation that first updates \\(x\\) to \\(n\\) and then proceeds as \\(\\gamma\\); for any \\(N\\)-indexed collection \\((\\gamma_n)\\) of computations, lookup\\(_x((\\gamma_n)_n)\\) is read as the computation that proceeds as \\(\\gamma_n\\) if \\(x\\) has value \\(n\\) in the current store.\n\nThe Lawvere theory \\(L_H\\) for nondeterminism is that of the lower (aka Hoare) powerdomain, presented using a binary nondeterministic choice operation \\(\\cup\\); the Lawvere theory \\(L_\\Omega\\) for nontermination is the theory of a least element, presented using a constant \\(\\Omega\\); and the Lawvere theory \\(L_d\\) for suspension is that of a unary operation \\(d\\), with no equations. See [PP02, HPP06] for more details of these theories, including an account of the equations for stores and for Hoare powerdomains.\n\nFor resumptions, continuing to follow [HPP06], we wish the operations of \\(L_S\\) to commute with those of \\(L_H\\) and \\(L_\\Omega\\) (which automatically commute with each other) and it is also natural to have \\(d\\) commute with nondeterministic choice, but not with the operations of \\(L_S\\), as we wish to model interruption points, and not with \\(\\Omega\\), as we want to be able to model infinitely proceeding processes. We therefore define:\n\n\\[\nL_{\\text{Res}} = L_H \\otimes ((L_S \\otimes L_\\Omega) + L_d)\n\\]\n\nand let \\(T_{\\text{Res}}\\) be the associated monad. (For any two theories \\(L\\) and \\(L'\\) presented using disjoint signatures, the theories \\(L + L'\\) and \\(L \\otimes L'\\) can be presented using the union of the signatures of \\(L\\) and \\(L'\\) and, in the former case, by the union of their equations and, in the latter case, by the union of their equations together with additional equations that say that each operation of each theory commutes with each operation of the other.)\n\nWe now give an elementary trace-based picture of \\(T_{\\text{Res}}(P)\\) for sufficiently general \\(\\omega\\)-cpos \\(P\\). Let \\(Q\\) be a partial order. A Q-transition is a pair of states \\((\\sigma, \\sigma' x)\\) in which the\nsecond is marked with an element $x$ of $Q$; we let $\\tau$ range over stores and stores marked with an element of $Q$. A basic $Q$-transition sequence is a non-empty sequence consisting of plain transitions optionally followed by a $Q$-transition. Let $\\leq_Q$ be the least preorder on the set of basic $Q$-transition sequences which contains the prefix relation $\\leq_p$ and is such that, for any $x$, $y$ in $Q$, if $x \\leq y$ then $u(\\sigma, \\sigma'x) \\leq_Q u(\\sigma, \\sigma'y)$. One has that $\\leq_Q$ is a partial order and that $u \\leq_Q v$ holds iff:\n\n- either $u \\leq_p v$\n- or else $\\exists w, x \\leq y. u \\leq_p w(\\sigma, \\sigma'x) \\land v = w(\\sigma, \\sigma'y)$\n\nWe need a few notions concerning ideals in partial orders. An ideal $I$ in a partial order $Q$ is a downwards-closed subset of $Q$; for any subset $X$ of $Q$ we write $X \\downarrow$ for the least ideal including $X$, viz $\\{ x \\in Q \\mid \\exists y \\in X. x \\leq y \\}$; and for any $x \\in Q$ we write $x \\downarrow$ for $\\{ x \\}$. Downwards-closed sets, i.e., ideals, provide a suitable generalization of prefix-closed sets when passing from sequences to general partial orders.\n\nAn ideal $I$ is directed if it is nonempty and any two elements of the ideal have an upper bound in the ideal. An ideal is denumerably generated if $I = X \\downarrow$ for some denumerable $X \\subseteq I$. We write $I^\\omega_\\downarrow(Q)$, respectively $I_\\omega(Q)$, for the collection of all denumerably generated directed ideals of $Q$, respectively all denumerably generated ideals of $Q$, and we partially order them by subset; $I^\\omega_\\downarrow(Q)$ is an $\\omega$-cpo, indeed it is the free such over $Q$; and $I^\\omega(Q)$ is the free $\\omega$-cpo with all finite sups over $Q$: it follows that it is also the free such $\\omega$-cpo over $I^\\downarrow_\\omega(Q)$.\n\nLet $Q$-BTrans be the set of basic $Q$-transition sequences, partially ordered as above. One can view $I_\\omega(Q$-BTrans) as an $L_{\\text{Res}}$-model with the following definitions of the operations, where now we use $l$ to range over Vars:\n\n- $(\\text{update}_{l,n})_{I_\\omega(Q$-BTrans)}(I) = \\{(\\sigma, \\tau)u \\mid (\\sigma[l \\mapsto n], \\tau)u \\in I\\}$\n- $(\\text{lookup}_l)_{I_\\omega(Q$-BTrans)}((I_n)_n) = \\bigcup_n \\{ (\\sigma, \\tau)u \\in I_n \\mid \\sigma(l) = n \\}$\n- $J \\cup I_\\omega(Q$-BTrans) $J = I \\cup J$\n- $\\Omega_{I_\\omega(Q$-BTrans)} = \\emptyset$\n- $d_{I_\\omega(Q$-BTrans)}(I) = \\{ (\\sigma, \\sigma)u \\mid \\sigma \\in \\text{Store}, u \\in I \\} \\cup \\{ (\\sigma, \\sigma)|\\sigma \\in \\text{Store} \\}$\n\n(We skip over the small difference between the notion of an $L_{\\text{Res}}$-model and of an algebra satisfying equations.)\n\nWe write $\\omega$Cpo and $\\omega$SL for, respectively, the category of $\\omega$-cpos and the category of $\\omega$-cpos with all finite sups. For any poset $P$, its lifting $P_\\perp$ is the poset obtained from $P$ by freely adjoining a least element $\\perp$; its elements are $(0, x)$, for $x \\in P$, and $\\perp$, and they are ordered in the evident way. If $P$ has all sups of increasing $\\omega$-chains, i.e., is an $\\omega$-cpos (respectively has finite sups), so does $P_\\perp$. For any object $a$ of any given category, and any set $X$, we write $X \\otimes a$ and $a^X$ for, respectively, the $X$-fold sum and product of $a$ with itself, assuming they exist. The category $\\omega$SL has countable biproducts, given by the usual cartesian product of posets, and it is convenient to identify $X \\otimes L$ with $L^X$, for countable sets $X$.\n\nThe next theorem shows that the algebraic notion of resumptions can indeed be characterized in trace-based terms, specifically as ideals of basic $Q$-transition sequences.\n\n**Theorem 6.1.** Viewed as an $L_{\\text{Res}}$-model, $I_\\omega(Q$-BTrans) is $T_{\\text{Res}}(I^\\downarrow_\\omega(Q))$. The unit\n\n$$(\\eta_{T_{\\text{Res}}})_{I^\\downarrow_\\omega(Q)} : I^\\downarrow_\\omega(Q) \\to I_\\omega(Q$-BTrans)$$\nis given by:\n\n\\[(\\eta_{\\text{Res}})_{\\mathcal{I}_\\omega(Q)}(I) = \\{(\\sigma, x) \\mid \\sigma \\in \\text{Store}, x \\in I\\}\\]\n\nand, for any continuous \\(f : \\mathcal{I}_\\omega(Q) \\rightarrow \\mathcal{I}_\\omega(\\text{R-BTrans})\\), its Kleisli extension\n\n\\[f^\\dagger : \\mathcal{I}_\\omega(\\text{BTrans}) \\rightarrow \\mathcal{I}_\\omega(\\text{R-BTrans})\\]\n\nis given by:\n\n\\[f^\\dagger(I) = \\{u(\\sigma, \\tau)v \\mid \\exists \\sigma', x. \\ u(\\sigma, \\sigma' x, x) \\in I, (\\sigma', \\tau)v \\in f(x)\\}\\]\n\n∪ \\{u \\in I \\mid u \\text{ has no } Q\\text{-transition}\\}\n\n\\[\\text{Proof. } \\text{Models of } L_{\\text{Res}} \\text{ in } \\omega \\text{Cpo correspond to models of } L_S \\text{ in } \\omega \\text{SL together with a morphism } d' : L_{\\perp} \\rightarrow L, \\text{ where } L \\text{ is the carrier of the model. (Such morphisms are equivalent to } \\omega\\text{-continuous maps on } L \\text{ which preserve binary sups, but not necessarily } \\perp. ) \\text{ The carrier } L \\text{ of the model of } L_{\\text{Res}} \\text{ is that of the model of } L_S \\text{ in } \\omega \\text{SL; it is necessarily an } \\omega\\text{-cpo with all finite lbs. The } L_S \\text{ operations on } L \\text{ become those of the model of } L_S \\text{ in } \\omega \\text{SL, and the map } d : L \\rightarrow L \\text{ extends uniquely to a morphism on } L_{\\perp}, \\text{ obtaining the required map } d'. \\text{ This correspondence extends straightforwardly to an equivalence of categories.}\n\nSo, as } \\mathcal{I}_\\omega(Q) \\text{ is the free } \\omega\\text{-cpo with finite sups over the } \\omega\\text{-cpo } \\mathcal{I}_\\omega'(Q), \\text{ we seek the free structure }\n\n\\[(L, (\\text{update}_{l,n})_L, (\\text{lookup}_l)_L, d_L)\\]\n\nover } \\mathcal{I}_\\omega(Q), \\text{ consisting of a model } (L, (\\text{update}_{l,n})_L, (\\text{lookup}_l)_L) \\text{ of } L_S \\text{ in } \\omega \\text{SL and a morphism } d' : L_{\\perp} \\rightarrow L.\n\nBy Theorem 1 of [PP02] the free algebra monad for } L_S \\text{ over } \\omega \\text{SL is } T_S = (S \\otimes -)^S, \\text{ where we abbreviate Store to } S \\text{ (the theorem depends on the set of variables being finite). The definitions of the operations } (\\text{update}_{l,n})_{TS(L)} \\text{ and } (\\text{lookup}_l)_{TS(L)} \\text{ of an algebra } TS(L) \\text{ are given by Proposition 1 of [PP02]: the unit } (\\eta_T)_L \\text{ at } L \\text{ is the canonical map } L \\rightarrow (S \\otimes L)^S.\n\nSo, by Corollary 2 of [HPP06], for any poset } Q, \\text{ } L \\text{ is the solution of the following “domain equation” in } \\omega \\text{SL:}\n\n\\[L \\cong (S \\otimes (L_{\\perp} + \\mathcal{I}_\\omega(Q)))^S\\]\n\n(6.1)\n\nby which we mean the initial } \\omega\\text{-cpo with finite sups } L \\text{ and map }\n\n\\[\\alpha : (S \\otimes (L_{\\perp} + \\mathcal{I}_\\omega(Q)))^S \\rightarrow L\\]\n\n(Such a map is necessarily an isomorphism.)\n\nThe morphism } (\\text{update}_{l,n})_L : L \\rightarrow L \\text{ is }\n\n\\[L \\xrightarrow{\\alpha^{-1}} TS(L_{\\perp} + \\mathcal{I}_\\omega(Q)) \\xrightarrow{(\\text{update}_{l,n})_LTS(L_{\\perp} + \\mathcal{I}_\\omega(Q))} TS(L_{\\perp} + \\mathcal{I}_\\omega(Q)) \\xrightarrow{\\alpha} L\\]\n\nthe morphism } (\\text{lookup}_l)_L : L^N \\rightarrow L \\text{ is }\n\n\\[L^N \\xrightarrow{(\\alpha^{-1})^N} TS(L_{\\perp} + \\mathcal{I}_\\omega(Q))^N \\xrightarrow{(\\text{lookup}_l)_LTS(L_{\\perp} + \\mathcal{I}_\\omega(Q))^N} TS(L_{\\perp} + \\mathcal{I}_\\omega(Q)) \\xrightarrow{\\alpha} L\\]\n\nthe morphism } d'_L : L_{\\perp} \\rightarrow L \\text{ is }\n\n\\[L_{\\perp} \\xrightarrow{\\text{inl}} L_{\\perp} + \\mathcal{I}_\\omega(Q) \\xrightarrow{(\\eta_T)_L(L_{\\perp} + \\mathcal{I}_\\omega(Q))} TS(L_{\\perp} + \\mathcal{I}_\\omega(Q)) \\xrightarrow{\\alpha} L\\]\n\nand at } \\mathcal{I}_\\omega'(Q) \\text{ the unit } \\eta_{\\text{Res}} \\text{ is }\n\n\\[\\mathcal{I}_\\omega'(Q) \\xrightarrow{\\text{inr}} L_{\\perp} + \\mathcal{I}_\\omega(Q) \\xrightarrow{(\\eta_T)_L(L_{\\perp} + \\mathcal{I}_\\omega(Q))} TS(L_{\\perp} + \\mathcal{I}_\\omega(Q)) \\xrightarrow{\\alpha} L\\]\nNow, since countable copowers and powers coincide in $\\omega SL$, Equation (6.1) can be rewritten as:\n\n$$L \\cong S \\otimes (S \\otimes (L_\\perp + I_\\omega(Q)))$$ \\hspace{1cm} (6.2)\n\nAs $I_\\omega : \\text{Pos} \\to \\omega SL$ is a left adjoint, where Pos is the category of posets, it preserves all colimits; $I_\\omega$ also commutes with lifting. So there is an isomorphism:\n\n$$\\beta : I_\\omega(S \\times (S \\times (R_\\perp + Q))) \\cong S \\otimes (S \\otimes (I_\\omega(R)_\\perp + I_\\omega(Q)))$$\n\nfor any poset $R$. So, again using that $I_\\omega$ preserves all colimits, we can solve Equation (6.2) by first solving the equation:\n\n$$R \\cong S \\times (S \\times (R_\\perp + Q))$$\n\nin the category Pos, and then applying $I_\\omega$. To do that, one takes $R$ to be the least set such that\n\n$$R = S \\times (S \\times (R_\\perp + Q))$$\n\nand then imposes the evident inductively defined partial order on it. The solution of Equation (6.2) is then given by taking $L = I_\\omega(R)$ and $\\alpha = \\beta^{-1}$.\n\nWe now have an expression of $L$ as $I_\\omega(R)$, as well as definitions of $(\\text{update}_{l,n})_L$, $(\\text{lookup}_l)_L$, $d_L$, and the unit. So, given the initial discussion above, we see that $L$ forms the free model of $L_{\\text{Res}}$ over $I_\\omega(R)$ with unit:\n\n$$\\eta_{I_\\omega(R)} = \\{ (\\sigma, (\\sigma, \\text{inr}(x))) \\mid x \\in I \\}$$\n\nand with operations:\n\n$$(\\text{update}_{l,n})_L(I) = \\{ (\\sigma, (\\sigma', u)) \\mid (\\sigma[l \\mapsto n], (\\sigma', u)) \\in I \\}$$\n\n$$(\\text{lookup}_l)_L((I_n)_n) = \\{ (\\sigma, (\\sigma', u)) \\in I_n \\mid n \\in \\mathbb{N}, \\sigma(l) = n \\}$$\n\n$I \\cup_L J = I \\cup J$\n\n$\\Omega_L = \\emptyset$\n\n$d_L(I) = \\{ (\\sigma, (\\sigma, \\text{inl}(0, u))) \\mid \\sigma \\in S, u \\in I \\} \\cup \\{ (\\sigma, (\\sigma, \\bot)) \\mid \\sigma \\in S \\}$\n\nThere is an evident isomorphism of partial orders $\\theta_{\\text{Res}} : R \\cong Q\\text{-}B\\text{Trans}$, given recursively by:\n\n$$\\theta_{\\text{Res}}((\\sigma, (\\sigma', \\text{inl}(0, u)))) = (\\sigma, (\\sigma'))$$\n\n$$\\theta_{\\text{Res}}((\\sigma, (\\sigma', \\text{inl}(\\bot)))) = (\\sigma, (\\sigma'))$$\n\n$$\\theta_{\\text{Res}}((\\sigma, (\\sigma', \\text{inr}(x)))) = (\\sigma, (\\sigma'x))$$\n\nThis induces an isomorphism $I_\\omega(R) \\cong I_\\omega(Q\\text{-}B\\text{Trans})$ of $\\omega$-cpos, and so the free such model is also carried by $I_\\omega(Q\\text{-}B\\text{Trans})$. Using this, and the above definitions of the operations and unit for $I_\\omega(R)$, one then verifies that the operations and unit for $I_\\omega(Q\\text{-}B\\text{Trans})$ are as required.\n\nAs regards the formula for the Kleisli extension, that $f^\\dagger(\\eta_{I_\\omega(R)}) = \\eta_{I_\\omega(Q)} = f$ is evident and that the purported extension is a morphism of models of $L_{\\text{Res}}$ is a calculation.\nOne can go further and obtain a closely related, if less elementary, picture of $T_{\\text{Res}}(P)$ for an arbitrary $\\omega$-cpo $P$: one needs a notion of ideal that takes the $\\omega$-sups of $P$ into account.\n\n6.2. Asynchronous Processes. One might hope that $\\text{AProc}$ can be understood as an $\\omega$-cpo of resumptions, and, indeed, basic $\\{$Done$\\}$-transition sequences and proper pure non-empty transition sequences are very similar. Define a map $\\theta_{\\text{AProc}}: \\{$Done$\\}$-BTrans $\\rightarrow$ PPSeq by:\n\n\\[\n\\theta_{\\text{AProc}}(u(\\sigma, \\sigma' \\text{ Done})) = u(\\sigma, \\sigma' \\text{Done})\n\\]\n\n\\[\n\\theta_{\\text{AProc}}(u) = u \\quad \\text{(if $u$ does not contain Done)}\n\\]\n\nUnfortunately, while $\\theta_{\\text{AProc}}$ is a monotonic bijection, it is not an isomorphism of partial orders, as $u(\\sigma, \\sigma') \\leq u(\\sigma, \\sigma' \\text{Done})$ but $u(\\sigma, \\sigma') \\not\\leq u(\\sigma, \\sigma' \\text{Done})$.\n\nThere is a related programming language phenomenon. Denotationally, we have the inclusion:\n\n\\[\n[[\\text{async (yield; block)}]; C] \\subseteq [[\\text{async skip}; C]\n\\]\n\nbut not the inclusion:\n\n\\[\n[yield; block] \\subseteq [\\text{skip}]\n\\]\n\nAs in the proof of the full-abstraction theorem, one can distinguish $[y\\ell e\\ddot{\\text{d}}; \\text{block}]$ from $[\\text{skip}]$ using a sequential context; however, this context is not available when the command is within an async.\n\nTo solve this difficulty we take the theory of asynchronous threads $L_{\\text{AProc}}$ to be $L_{\\text{Res}}$ extended by a new constant $\\text{halt}$ and the equation:\n\n\\[\nd(\\Omega) \\leq \\text{halt}\n\\]\n\nWe can turn $\\text{AProc}$ into a model of $L_{\\text{AProc}}$ by defining operations as follows:\n\n\\[\n(\\text{update}_{l,n})_{\\text{AProc}}(P) = \\{(\\sigma, \\sigma')u \\mid (\\sigma[l \\mapsto n], \\sigma')u \\in P\\} \\cup \\{\\varepsilon\\}\n\\]\n\n\\[\n(\\text{lookup}_n)_{\\text{AProc}}((P_n)_n) = \\bigcup_n \\{(\\sigma, \\sigma')u \\in P_n \\mid \\sigma(l) = n\\} \\cup \\{\\varepsilon\\}\n\\]\n\n\\[\nP \\cup_{\\text{AProc}} Q = P \\cup Q\n\\]\n\n\\[\n\\Omega_{\\text{AProc}} = \\{\\varepsilon\\}\n\\]\n\n\\[\nd_{\\text{AProc}}(P) = \\{(\\sigma, \\sigma)u \\mid \\sigma \\in \\text{Store}, u \\in P\\} \\cup \\{\\varepsilon\\}\n\\]\n\n\\[\n\\text{halt}_{\\text{AProc}} = \\{(\\sigma, \\sigma)\\text{Done} \\mid \\sigma \\in \\text{Store}\\}\\}\n\\]\n\nNote that $\\text{halt}_{\\text{AProc}} = [\\text{skip}]^\\varepsilon$.\n\nWe write $T_{\\text{AProc}}$ for the monad associated to the theory $\\text{AProc}$. The next theorem shows that the variant theory $L_{\\text{AProc}}$ indeed captures $\\text{AProc}$. First we need some notation.\n\n- We define a unary derived operation $a_{l,m,k}$, for $l \\in \\text{Vars}$ and $m, n \\in \\text{Value}$ by:\n\n\\[\na_{l,m,k}(x) \\equiv \\text{def} \\ \\text{lookup}_l((t_{m'})(m'))\n\\]\n\nwhere:\n\n\\[\nt_{m'} \\equiv \\begin{cases} \n\\text{update}_{l,k}(x) & \\text{if } m' = m \\\\\n\\Omega & \\text{otherwise}\n\\end{cases}\n\\]\n\n- We define a unary derived operation $a_{\\sigma, \\sigma'}$, for $\\sigma, \\sigma' \\in \\text{Store}$ by:\n\n\\[\na_{\\sigma, \\sigma'}(x) \\equiv \\text{def} \\ a_{l_1, \\sigma(l_1), \\sigma'(l_1)}(\\ldots a_{l_n, \\sigma(l_n), \\sigma'(l_n)}(x)\\ldots)\n\\]\n\nwhere $l_1, \\ldots, l_n$ is an enumeration of $\\text{Vars}$.\n\n- For every sequence of plain transitions $u = (\\sigma_1, \\sigma'_1) \\ldots (\\sigma_n, \\sigma'_n)$ we define a unary derived operation $a_u$ by:\n\n\\[\na_u(x) \\equiv \\text{def} \\ a_{\\sigma_1, \\sigma'_1}(d(\\ldots a_{\\sigma_n, \\sigma'_n}(d(x))\\ldots))\n\\]\nFor every sequence of plain transitions $u$ and $\\sigma, \\sigma' \\in \\text{Store}$, we define two constants $\\overline{\\eta}$ and $\\overline{u}(\\sigma, \\sigma'):\\text{Done}$ by:\n\n$$\\overline{\\eta} \\equiv_{\\text{def}} a_u(\\Omega) \\quad \\text{and} \\quad \\overline{u}(\\sigma, \\sigma'):\\text{Done} \\equiv_{\\text{def}} a_u(\\text{halt})$$\n\nNote that $\\overline{\\eta}_{\\text{AProc}} = \\overline{\\eta}_{\\text{AProc}}(Q) = u \\downarrow$, where, for example, $\\overline{\\eta}_{\\text{AProc}}$ is the interpretation of $\\overline{\\eta}$ in AProc; further $\\overline{u}(\\sigma, \\sigma'):\\text{Done}_{\\text{AProc}} = u(\\sigma, \\sigma'):\\text{Done} \\downarrow$. Below we may confuse a constant or operation with its interpretation in a specific algebra $A$, e.g., writing $\\overline{\\eta}$ or $a_u$ rather than $\\eta_A$ or $(a_u)_A$, provided that the intended algebra can be understood from the context.\n\n**Theorem 6.2.** AProc is the initial $L_{\\text{AProc}}$-model, i.e., it is $T_{\\text{AProc}}(0)$.\n\n**Proof.** We begin by examining the connection between $\\mathcal{I}_\\omega(\\{\\text{Done}\\})$ and AProc. By Theorem 6.1, $\\mathcal{I}_\\omega(\\{\\text{Done}\\})$ is the free model of $L_{\\text{Res}}$ over $\\{\\text{Done}\\}$. So $f : \\{\\text{Done}\\} \\rightarrow \\text{AProc}$ has a unique extension to a morphism $f^\\dagger : \\mathcal{I}_\\omega(\\{\\text{Done}\\}) \\rightarrow \\text{AProc}$ of $L_{\\text{Res}}$-models, where $f(\\text{Done}) =_{\\text{def}} \\text{halt}_{\\text{AProc}}$. We now show that:\n\n$$f^\\dagger(I) = \\{\\theta_{\\text{AProc}}(u) \\mid u \\in I\\} \\downarrow$$\n\nfrom which it follows that $f^\\dagger$ is onto. It is enough to show that $f^\\dagger(u \\downarrow) = \\theta_{\\text{AProc}}(u) \\downarrow$, which holds as, for any $u$ not containing Done, we calculate that\n\n$$f^\\dagger(u \\downarrow) = f^\\dagger(\\overline{\\eta}_{\\text{AProc}}(\\{\\text{Done}\\})) = (\\overline{\\eta})_{\\text{AProc}} = u \\downarrow = \\theta_{\\text{AProc}}(u) \\downarrow$$\n\nand that\n\n$$f^\\dagger(u(\\sigma, \\sigma' \\text{ Done} \\downarrow)) = f^\\dagger((a_u)_{\\text{AProc}}(\\text{eta}(\\{\\text{Done}\\}))) = (a_u)_{\\text{AProc}}(f^\\dagger(\\eta(\\{\\text{Done}\\})))\n= (a_u)_{\\text{AProc}}(\\text{halt}_{\\text{AProc}}) = u(\\sigma, \\sigma' \\text{ Done} \\downarrow)\n= \\theta_{\\text{AProc}}(u(\\sigma, \\sigma' \\text{ Done} \\downarrow))$$\n\nwhere, in both cases, the second equality holds as $f^\\dagger$ is a morphism of $L_{\\text{Res}}$-models.\n\nLet $L$ be a model of $L_{\\text{AProc}}$. We have to show that there is a unique morphism $h : \\text{AProc} \\rightarrow L$. For uniqueness, let $h, h' \\in \\text{such morphisms. Then both } f^\\dagger \\circ h$ and $f^\\dagger \\circ h'$ are morphisms of $L_{\\text{Res}}$-models from $\\mathcal{I}_\\omega(\\{\\text{Done}\\})$ to $L$, extending the map $\\text{Done} \\mapsto \\text{halt}_L$. So, as there is only one such map, $f^\\dagger \\circ h = f^\\dagger \\circ h'$, and therefore, as $f^\\dagger$ is onto, $h = h'$, as required.\n\nFor existence, define the map $\\theta : \\text{PPSeq} \\rightarrow L$ by: $\\theta(u) = (a_u)_L$. Using the fact that $L$ is a model of AProc, particularly the axiom $d(\\Omega) \\leq \\text{halt}$, one has that $\\theta$ is monotonic. One can then define a continuous map $h : \\text{AProc} \\rightarrow L$ by:\n\n$$h(I) = \\bigvee_{u \\in I} \\theta(u)$$\n\nwith the sup on the right existing as $I$ is denumerable. Let $g$ be the unique morphism of $L_{\\text{Res}}$-models from $\\mathcal{I}_\\omega(\\{\\text{Done}\\})$ to $L$, extending the map $\\text{Done} \\mapsto \\text{halt}_L$.\n\nWe have that $h \\circ f^\\dagger = g$, as, for any $u$ not containing Done, we may calculate that:\n\n$$h(f^\\dagger(u \\downarrow)) = h(u \\downarrow) = \\theta(u) = a_u = g(a_u) = g(u)$$\n\nand that\n\n$$h(f^\\dagger(u(\\sigma, \\sigma' \\text{Done}) \\downarrow)) = h(a_u(\\text{halt})) = h(u(\\sigma, \\sigma')\\text{Done} \\downarrow)\n= \\theta(u(\\sigma, \\sigma')\\text{Done} \\downarrow) = a_u(\\sigma, \\sigma')\\text{Done}\n= g(a_u(\\sigma, \\sigma')\\eta(\\{\\text{Done}\\}))$$\n\n$$g(u(\\sigma, \\sigma'\\text{ Done} \\downarrow))$$\nAs \\( h \\circ f^{\\dagger} = g \\), and \\( f^{\\dagger} \\) and \\( g \\) are morphisms of \\( L_{\\text{Res}} \\) models, and \\( f^{\\dagger} \\) is onto, \\( h \\) is automatically a morphism of \\( L_{\\text{Res}} \\) models. For example, for the preservation of \\( d \\), given \\( I \\in \\text{AProc} \\), choose \\( J \\in I_{\\omega}(\\{\\text{Done}\\}) \\) such that \\( f^{\\dagger}(J) = I \\) and calculate that:\n\n\\[\n\\begin{align*}\n h(d_{\\text{AProc}}(I)) &= h(d_{\\text{AProc}}(f^{\\dagger}(J))) \\\\\n &= h(f^{\\dagger}(d_{I_{\\omega}(\\{\\text{Done}\\})(J)})) \\\\\n &= d_L(g(J)) \\\\\n &= d_L(h(I))\n\\end{align*}\n\\]\n\nFurther, \\( h \\) preserves \\text{halt} as \\( h(\\text{halt}_{\\text{AProc}}) = \\theta(\\text{halt}_{\\text{AProc}}) = \\text{halt}_L \\). We therefore have that \\( h \\) is a morphism of \\( L_{\\text{AProc}} \\)-models, which concludes the proof.\n\nOne can go on and obtain a general view of the monad \\( T_{\\text{AProc}} \\) using a suitable notion of (proper) pure \\( Q \\)-transition sequences. However we omit the details as they are not needed for an account of processes.\n\nThere is another possible proof of Theorem 6.2 along the lines of that of Theorem 6.1. First one notes that to have a model of \\( L_{\\text{AProc}} \\) in \\( \\omega \\text{Cpo} \\) is to have a model of \\( L_{\\text{S}} \\) in \\( \\omega \\text{SL} \\), with carrier \\( L \\), say, together with a morphism \\( d : L_{\\perp} \\to L \\) and an element \\( \\text{halt} \\in L \\) such that \\( d(\\Omega) \\leq \\text{halt} \\). It is not hard to see that to have such a morphism and element is to have a morphism \\( (L + I_{\\omega}(\\{\\text{Done}\\}))_{\\perp} \\to L \\), where \\( 1 \\) is the one-point partial order.\n\nOne then sees that the carrier of the initial such model is given by the solution of the domain equation:\n\n\\[\nL \\cong (S \\otimes (L + I_{\\omega}(\\{\\text{Done}\\}))_{\\perp})^S\n\\]\n\nand that this can be solved by first solving the corresponding equation\n\n\\[\nR \\cong S \\times (S \\times (R + 1)_{\\perp})\n\\]\n\nin \\( \\text{Pos} \\) and then setting \\( L = I_{\\omega}(R) \\). The rest of the proof proceeds as expected.\n\nEqually, there should be an elementary proof of Theorem 6.1 which, like that of Theorem 6.2, makes use of definability. The more conceptual proofs have the advantage of showing, via domain equations, the origins of the two kinds of transition sequences and their ordering.\n\n6.3. Processes. We turn to our algebraic account of Proc. The signature of our theory of processes, \\( L_{\\text{Proc}} \\), is that for \\( L_{\\text{Res}} \\) together with two families of unary operation symbols \\( \\text{async}_P \\) and \\( \\text{yield}_\\text{to}_P \\), where \\( P \\) is in \\( \\text{AProc} \\). The first of these corresponds to the function of the same name defined above, but restricted to asynchronous threads. The second corresponds to a slightly different version of \\( \\text{async} \\) in which the first action is that of the thread spun off, rather than that of the active command. We often find it convenient to write \\( \\text{async}_P \\) and \\( \\text{yield}_\\text{to}_P \\) as, respectively, \\( P \\triangleright t \\) and \\( P \\triangleleft t \\), thinking of them as right and left shuffles.\n\nWe begin with a theory \\( L_{\\text{Spawn}} \\) for \\( \\text{async} \\) and \\( \\text{yield}_\\text{to} \\) which involves the other operations. The first group of equations for \\( L_{\\text{Spawn}} \\) concerns commutation with \\( \\cup \\):\n\n\\[\n\\begin{align*}\n(P \\cup_{\\text{AProc}} P') \\triangleright x &= (P \\triangleright x) \\cup (P' \\triangleright x) \\\\\n(P \\triangleright (x \\cup y)) &= (P \\triangleright x) \\cup (P \\triangleright y) \\\\\n(P \\cup_{\\text{AProc}} P') \\triangleleft x &= (P \\triangleleft x) \\cup (P' \\triangleleft x) \\\\\n(P \\triangleleft (x \\cup y)) &= (P \\triangleleft x) \\cup (P \\triangleleft y)\n\\end{align*}\n\\]\nThe second group of equations concerns the interaction of async with the other operations of $L_{\\text{Proc}}$ (except for $\\prec$):\n\n\\[\n\\begin{align*}\nP \\triangleright \\text{update}_{l,n}(x) &= \\text{update}_{l,n}(P \\triangleright x) \\\\\nP \\triangleright \\text{lookup}_{l}((x_n)_n) &= \\text{lookup}_{l}((P \\triangleright x_n)_n) \\\\\nP \\triangleright \\Omega &= \\Omega \\\\\nP \\triangleright d(x) &= d(P \\bowtie x) \\\\\nP \\triangleright (P' \\triangleright x) &= (P \\bowtie P') \\triangleright x\n\\end{align*}\n\\]\n\nwhere we write $P \\bowtie x$ for the “left action” $(P \\triangleright x) \\cup (P \\prec x)$. The first three state that $P \\triangleright -$ commutes with another operation; the next concerns the interaction of async with suspension and brings in yield$_{to}$; the last reduces two occurrences of async to one. The third, and last, group of equations is for the interaction of yield$_{to}$ with the other operations of $L_{\\text{AProc}}$:\n\n\\[\n\\begin{align*}\n(\\text{update}_{l,n})_{\\text{AProc}}(P) \\prec x &= \\text{update}_{l,n}(P \\prec x) \\\\\n(\\text{lookup}_{l})_{\\text{AProc}}((P_n)_n) \\prec x &= \\text{lookup}_{l}((P_n \\prec x)_n) \\\\\n\\Omega_{\\text{AProc}} \\prec x &= \\Omega \\\\\nd_{\\text{AProc}}(P) \\prec x &= d(P \\bowtie x) \\\\\nhalt_{\\text{AProc}} \\prec x &= d(x)\n\\end{align*}\n\\]\n\nThe first three assert that $- \\prec x$ acts homomorphically with respect to an operation; the next concerns the interaction with suspension; and the last concerns what happens when asynchronous threads halt. Finally we add an inequation:\n\n\\[\n\\Omega_{\\text{AProc}} \\triangleright x \\leq x\n\\]\n\nWe take the equations of $L_{\\text{Proc}}$ to be those of $L_{\\text{Spawn}}$, i.e., the equations are the ones just given for async and yield$_{to}$, together with those of $L_{\\text{Res}}$. One would naturally have expected $L_{\\text{Proc}}$ also to have an equation with left-hand side $P \\triangleright (P' \\prec x)$; indeed, we could have added the equation:\n\n\\[\nP \\triangleright (P' \\prec x) = P' \\prec (P \\bowtie x)\n\\]\n\nHowever this equation is redundant as it can be proved from the others using the algebraic induction principle of “Computational Induction” described in [PP08]. (One proceeds by such an induction on $P'$, with a subinduction on $P$.) The inequation is somewhat inelegant: a possible improvement would be to use Pool instead rather than restricting to asynchronous threads. This would give the possibility of a version of halt, to denote $\\text{Done} \\downarrow$, such that the equations\n\n\\[\nhalt \\triangleright x = \\text{halt} \\prec x = x\n\\]\n\nheld, making the inequation redundant.\n\nLet $T_{\\text{Proc}}$ be the monad associated to the theory Proc. We now aim to give a picture of $T_{\\text{Proc}}(\\mathcal{T}_\\omega(Q))$ like that we gave of $T_{\\text{Res}}(\\mathcal{T}_\\omega(Q))$. Take the partial order $Q$-Trans of the $Q$-transition sequences to be that of the basic $(Q \\times \\text{PSeq})$-transition sequences. Note that one can regard $Q$-transition sequences as elements of a kind of “double thread” in which the first thread returns a value together with a second (asynchronous) thread.\n\nWe show that $Q$-Proc $=_{\\text{def}} \\mathcal{T}_\\omega(Q\\text{-Trans})$ carries the free model of $L_{\\text{Proc}}$ on $\\mathcal{T}_\\omega(Q)$. We view $Q$-Proc as a $L_{\\text{Res}}$-model as in Section 6.1. In order to give async and yield$_{to}$, we first mutually recursively define the incomplete right and left shuffles $u \\triangleright v$ and $u \\prec v$ in $Q$-Proc.\nof a proper pure transition sequence \\( u \\) with a \\( Q \\)-transition sequence \\( v \\), by:\n\n\\[\n\\begin{align*}\n\\uparrow (\\sigma, \\sigma') &= \\{ (\\sigma, \\sigma')u^- \\} \\\\\n\\uparrow (\\sigma, \\sigma'(x, u')) &= \\{ (\\sigma, \\sigma'(x, w)) \\mid w \\in u \\bowtie u' \\} \\\\\n\\uparrow (\\sigma, \\sigma')v &= \\{ (\\sigma, \\sigma')w \\mid w \\in u \\bowtie v \\}\n\\end{align*}\n\\]\n\nwhere, for any pure transition sequence \\( w \\), \\( w^− \\) is \\( w \\) less any occurrence of Done, and writing \\( u \\bowtie v \\) for the incomplete shuffles \\( (u \\bowtie v) \\cup (u \\bowtie v) \\) of \\( u \\) and \\( v \\), and:\n\n\\[\n\\begin{align*}\n\\varepsilon \\bowtie v &= \\emptyset \\\\\n(\\sigma, \\sigma')\\text{Done} \\bowtie v &= \\{ (\\sigma, \\sigma')v \\} \\\\\n(\\sigma, \\sigma')u \\bowtie v &= \\{ (\\sigma, \\sigma')w \\mid w \\in u \\bowtie v \\}\n\\end{align*}\n\\]\n\nwhere, in the last line, \\( u \\) is required to be proper. (Recall that an incomplete shuffle of two sequences is a shuffle of two of their prefixes, equivalently a prefix of a shuffle of them.) Both \\( \\uparrow \\) and \\( \\bowtie \\) are monotonic operations.\n\nThen, for \\( P \\in \\text{AProc} \\) and \\( I \\in \\text{Q-Proc} \\), we put:\n\n\\[\n\\begin{align*}\n(\\text{async}_{\\text{Proc}})P(I) &= \\bigcup_{u \\in P, v \\in I} u \\uparrow v \\\\\n(\\text{yield}_{\\text{to Proc}})P(I) &= \\bigcup_{u \\in P, v \\in I} u \\bowtie v \\cup \\{ u^- \\mid u \\in P, u \\neq \\varepsilon \\}\n\\end{align*}\n\\]\n\nIf \\( I \\) is not empty we have:\n\n\\[\n(\\text{yield}_{\\text{to Proc}})P(I) = \\bigcup_{u \\in P, v \\in I} u \\bowtie v\n\\]\n\nWith these additional operations, \\( Q \\)-Proc is a model of \\( L_{\\text{Proc}} \\).\n\nIn the following we make use of the notation introduced in Section 6.2.\n\n**Lemma 6.3.** For any proper pure transition sequence \\( u \\), the equation \\( u \\downarrow \\bowtie \\Omega = \\overline{u}^- \\) is provable in \\( L_{\\text{Proc}} \\).\n\n**Proof.** The proof is by induction on the length of \\( u \\). In the case where \\( u = \\varepsilon \\), we have \\( u \\downarrow = \\Omega_{\\text{AProc}} \\), and in the equational theory we have \\( \\Omega_{\\text{AProc}} \\bowtie \\Omega = \\Omega \\), as required.\n\nIn the case where \\( u = (\\sigma, \\sigma') \\), we have \\( u \\downarrow = a_{\\sigma, \\sigma'}(d\\Omega_{\\text{AProc}}) \\), and in the equational theory, we have:\n\n\\[\n\\begin{align*}\na_{\\sigma, \\sigma'}(d\\Omega_{\\text{AProc}}) \\bowtie \\Omega &= a_{\\sigma, \\sigma'}(d\\Omega_{\\text{AProc}} \\bowtie \\Omega) \\\\\n&= a_{\\sigma, \\sigma'}(d(\\Omega_{\\text{AProc}} \\bowtie \\Omega) \\cup d(\\Omega_{\\text{AProc}} \\uparrow \\Omega)) \\\\\n&= a_{\\sigma, \\sigma'}(d\\Omega)\n\\end{align*}\n\\]\n\nIn the case where \\( u = (\\sigma, \\sigma')\\text{Done} \\), we have \\( u \\downarrow = a_{\\sigma, \\sigma'}(\\text{halt}) \\), and in the equational theory, we have:\n\n\\[\na_{\\sigma, \\sigma'}(\\text{halt}) \\bowtie \\Omega = a_{\\sigma, \\sigma'}(\\text{halt} \\bowtie \\Omega) = a_{\\sigma, \\sigma'}(d\\Omega)\n\\]\n\nFinally, in the case where \\( u = (\\sigma, \\sigma')v \\), with \\( v \\) a proper pure transition sequence, we have \\( u \\downarrow = a_{\\sigma, \\sigma'}(d(v \\downarrow)) \\), and in the equational theory, we have:\n\n\\[\n\\begin{align*}\na_{\\sigma, \\sigma'}(d(v \\downarrow)) \\bowtie \\Omega &= a_{\\sigma, \\sigma'}(d(v \\downarrow) \\bowtie \\Omega) \\\\\n&= a_{\\sigma, \\sigma'}(d((v \\downarrow) \\bowtie \\Omega) \\cup d((v \\downarrow) \\uparrow \\Omega)) \\\\\n&= a_{\\sigma, \\sigma'}(d((v \\downarrow) \\bowtie \\Omega)) \\\\\n&= a_{\\sigma, \\sigma'}(d(v^-)) \\\\\n&= \\overline{u}^-\n\\end{align*}\n\\]\nusing the induction hypothesis in the next-to-last step.\n\nOur main algebraic theorem characterizes free models of a natural equational theory for resumptions with thread-spawning in terms of a kind of double-thread.\n\n**Theorem 6.4.** Viewed as an $L_{\\text{Proc}}$-model, $\\mathcal{I}_\\omega(Q\\text{-Trans})$ is the free model over $\\mathcal{I}_\\omega^\\uparrow(Q)$. The unit $(\\eta^\\text{Proc})_{\\mathcal{I}_\\omega^\\uparrow(Q)}:\\mathcal{I}_\\omega^\\uparrow(Q) \\to \\mathcal{I}_\\omega(Q\\text{-Trans})$ is given by:\n\n$$(\\eta^\\text{Proc})_{\\mathcal{I}_\\omega^\\uparrow(Q)}(I) = \\{(\\sigma, \\sigma (x, \\text{Done}) \\mid x \\in I) \\downarrow\\}\n$$\n\nand, for any continuous $f: \\mathcal{I}_\\omega^\\uparrow(Q) \\to \\mathcal{I}_\\omega(R\\text{-Trans})$, its Kleisli extension\n\n$$f^\\dagger: \\mathcal{I}_\\omega(Q\\text{-Trans}) \\to \\mathcal{I}_\\omega(R\\text{-Trans})$$\n\nis given by:\n\n$$f^\\dagger(I) = \\{u(\\sigma, \\tau)v \\mid \\exists \\sigma', x. u(\\sigma, \\sigma' (x, \\text{Done})) \\in I,\n\\langle \\sigma', \\tau \\rangle v \\in f(x\\downarrow)\\}\n\\cup \\{u(\\sigma, \\tau)v \\mid \\exists \\sigma', x, w \\neq \\text{Done}. u(\\sigma, \\sigma' (x, w)) \\in I,\n\\langle \\sigma', \\tau \\rangle v \\in w \\downarrow \\triangleright_A f(x\\downarrow)\\}\n\\cup \\{u \\in I \\mid u \\text{ has no } (Q \\times \\text{PSeq}) \\text{ transition}\\}$$\n\n**Proof.** To show that $\\mathcal{I}_\\omega(Q\\text{-Trans})$ is the free algebra over $\\mathcal{I}_\\omega^\\uparrow(Q)$ with unit as above, we must show that for any $L_{\\text{Proc}}$-model $A$ and any continuous function $f: \\mathcal{I}_\\omega^\\uparrow(Q) \\to A$ there is a unique morphism $h: \\mathcal{I}_\\omega(Q\\text{-Trans}) \\to A$ of models of $L_{\\text{Proc}}$ such that the following diagram commutes:\n\nWe begin by showing uniqueness. To that end, fix $A$ and $f$, and let $h$ be a morphism such that the diagram commutes. Define $g: \\mathcal{I}_\\omega^\\uparrow(Q \\times \\text{PSeq}) \\to A$ by putting:\n\n$$g((x, u)\\downarrow) = \\begin{cases} f(x\\downarrow) & \\text{(if } u = \\text{Done)} \\\\ u \\downarrow \\triangleright_A f(x\\downarrow) & \\text{(otherwise)} \\end{cases}$$\n\nThis is a good definition, with monotonicity being established using the inequation for $\\triangleright_A$. We have $f = g\\alpha$ and $(\\eta^\\text{Proc})_{\\mathcal{I}_\\omega^\\uparrow(Q)} = (\\eta^\\text{Res})_{\\mathcal{I}_\\omega^\\uparrow(Q \\times \\text{PSeq})}\\alpha$ where $\\alpha: \\mathcal{I}_\\omega^\\uparrow(Q) \\to \\mathcal{I}_\\omega^\\uparrow(Q \\times \\text{PSeq})$ is defined by setting $\\alpha(x\\downarrow) = (x, \\text{Done})\\downarrow$.\n\nWe then have that the following diagram commutes:\n\n$$\n\\begin{array}{ccc}\n\\mathcal{I}_\\omega^\\uparrow(Q \\times \\text{PSeq}) & \\xrightarrow{g} & A \\\\\n(\\eta^\\text{Res})_{\\mathcal{I}_\\omega^\\uparrow(Q \\times \\text{PSeq})} & \\xrightarrow{h} & A \\\\\n\\mathcal{I}_\\omega((Q \\times \\text{PSeq})\\text{-BTrans}) & \\xrightarrow{\\mathcal{I}_\\omega(Q\\text{-Trans})} & \\mathcal{I}_\\omega^\\uparrow(Q) \\\\\n\\end{array}\n$$\n\n$\\square$\nas we may we calculate, for \\( u = \\text{Done}, \\) that:\n\\[\n\\begin{align*}\n h((\\eta_{\\text{Res}})_{\\downarrow}((x, u) \\downarrow)) &= h(\\eta(x \\downarrow)) \\\\\n &= f(x) \\\\\n &= g((x, u) \\downarrow)\n\\end{align*}\n\\]\nand, for \\( u \\neq \\text{Done}, \\) that:\n\\[\n\\begin{align*}\n h((\\eta_{\\text{Res}})_{\\downarrow}((x, u) \\downarrow)) &= h(\\{(\\sigma, \\sigma(x, u)) \\mid \\sigma \\in \\text{Store}\\} \\downarrow) \\\\\n &= h(u \\uparrow \\triangleright \\{(\\sigma, \\sigma(x, \\text{Done})) \\mid \\sigma \\in \\text{Store}\\} \\downarrow) \\\\\n &= h(u \\uparrow \\triangleright (\\eta_{\\text{Proc}})_{\\downarrow}((x) \\downarrow)) \\\\\n &= u \\uparrow \\triangleright A h((\\eta_{\\text{Proc}})_{\\downarrow}((x) \\downarrow)) \\\\\n &= u \\uparrow \\triangleright A f((x) \\downarrow) \\\\\n &= g((x, u) \\downarrow)\n\\end{align*}\n\\]\n\nThis is enough to show uniqueness, as if \\( h((\\eta_{\\text{Proc}})_{\\downarrow}((x) \\downarrow)) = h'(\\eta_{\\text{Proc}})_{\\downarrow}((x) \\downarrow) = f, \\) for two such morphisms \\( h \\) and \\( h' \\), then \\( h((\\eta_{\\text{Res}})_{\\downarrow}((x) \\downarrow)) = h'(\\eta_{\\text{Res}})_{\\downarrow}((x) \\downarrow) = g, \\) and so \\( h = h' \\), as \\( h \\) and \\( h' \\) are morphisms of models of \\( L_{\\text{Res}} \\) (being morphisms of models of \\( L_{\\text{Proc}} \\)).\n\nFor existence we are again given \\( A \\) and \\( f \\) and wish to construct a suitable \\( h \\). To that end, with \\( g \\) and \\( \\alpha \\) as before, take \\( h \\) to be the \\( T_{\\text{Res}} \\)-extension of \\( g \\). Then we have \\( h((\\eta_{\\text{Proc}})_{\\downarrow}((x) \\downarrow)) = h((\\eta_{\\text{Res}})_{\\downarrow}((x) \\downarrow) = g \\), and so it remains to prove that \\( h \\) preserves async and yield_to.\n\nAs regards the preservation of async, since it is continuous, preserves \\( \\cup \\) in each argument, and is strict in its second argument, it suffices to establish preservation for individual transition sequences. That is, it suffices to show, for all proper pure transition sequences \\( u \\) and all \\( v \\) in \\( Q \\)-Trans, that:\n\\[\nh(u \\uparrow v) = u \\uparrow_A h(v)\n\\]\nwhere here, and below, we omit \\( \\downarrow \\)'s, writing, e.g., \\( u \\) and \\( v \\) rather than \\( u \\downarrow \\) and \\( v \\downarrow \\).\n\nAs regards the preservation of yield_to, since it is continuous and preserves \\( \\cup \\) in each argument, it suffices to show, for all proper pure transition sequences \\( u \\) and all \\( v \\) in \\( Q \\)-Trans that:\n\\[\nh(u \\lessdot v) = u \\lessdot_A h(v)\n\\]\nand:\n\\[\nh(u \\lessdot \\Omega) = u \\lessdot_A h(\\Omega)\n\\]\n\nFor the last of these three equations, as \\( h(\\Omega) = \\Omega \\), using Lemma 6.3, we see that is enough to show that \\( h(\\overline{u}) = \\overline{u} \\), and this holds as \\( h \\) is a homomorphism of models of \\( L_{\\text{Res}} \\).\n\nThe proof of the first two equations is a simultaneous induction on the sum of the lengths of \\( u \\) and \\( v \\), invoking \\( L_{\\text{Proc}} \\) equations on \\( A \\) as necessary. We begin with the first equation. In the first case, we consider \\( v = (\\sigma, \\sigma') \\). Here, on the one hand, we have:\n\\[\nh(u \\uparrow (\\sigma, \\sigma')) = h((\\sigma, \\sigma')u^-) = h((\\sigma, \\sigma')u^-) = (\\sigma, \\sigma')u^{-}\n\\]\nusing the fact that \\( h \\) is a homomorphism for the last equality, and, on the other, we have:\n\\[\nu \\uparrow_A h((\\sigma, \\sigma')) = u \\uparrow_A h(a_{\\sigma,\\sigma'}(d\\Omega)) = u \\uparrow_A (a_{\\sigma,\\sigma'}(d\\Omega)) = a_{\\sigma,\\sigma'}(u \\uparrow_A d\\Omega) = a_{\\sigma,\\sigma'}(d(u \\uparrow_A \\Omega) \\cup d(u \\lessdot_A \\Omega)) = a_{\\sigma,\\sigma'}(d(u^-)) \\text{ (by Lemma 6.3)} = (\\sigma, \\sigma')u^{-}\n\\]\nFor the next case we consider $v = (\\sigma, \\sigma'(x, u'))$. Here, on the one hand we have:\n\n\\[\n\\begin{align*}\n h(u \\triangleright v) &= h\\left(\\{(\\sigma, \\sigma'(x, u'')) \\mid u'' \\in u \\triangleright u'\\} \\right) \\\\\n &= \\bigcup_{u'' \\in u \\triangleright u'} h(\\{(\\sigma, \\sigma'(x, u'')) \\mid u'' \\in u \\triangleright u'\\}) \\\\\n &= \\bigcup_{u'' \\in u \\triangleright u'} a_{\\sigma, \\sigma'}(h((\\eta_{\\text{Res}})_{pq}(Q \\times \\text{PSeq})(x, u''))) \\\\\n &= \\bigcup_{u'' \\in u \\triangleright u'} a_{\\sigma, \\sigma'}(u'' \\triangleright A f(x)) \\\\\n &= a_{\\sigma, \\sigma'}((u \\triangleright u') \\triangleright A f(x))\n\\end{align*}\n\\]\n\nand, on the other hand, we have:\n\n\\[\n\\begin{align*}\n u \\triangleright_A h(v) &= u \\triangleright_A h(a_{\\sigma, \\sigma'}((\\eta_{\\text{Res}})_{pq}(Q \\times \\text{PSeq})(x, u''))) \\\\\n &= a_{\\sigma, \\sigma'}(u \\triangleright A h((\\eta_{\\text{Res}})_{pq}(Q \\times \\text{PSeq})(x, u''))) \\\\\n &= a_{\\sigma, \\sigma'}(u \\triangleright_A (u' \\triangleright A f(x)))\n\\end{align*}\n\\]\n\nFor the last case for the first equation we have $v = (\\sigma, \\sigma')v'$, with $v'$ in $Q$-Trans, and we calculate:\n\n\\[\n\\begin{align*}\n h(u \\triangleright (\\sigma, \\sigma')v') &= a_{\\sigma, \\sigma'}(h(u \\triangleright d(v'))) \\\\\n &= a_{\\sigma, \\sigma'}(a_{\\sigma, \\sigma'}(d(h(v')))) \\\\\n &= a_{\\sigma, \\sigma'}(a_{\\sigma, \\sigma'}(d(u \\triangleright v' \\cup u < v'))) \\\\\n &= a_{\\sigma, \\sigma'}(a_{\\sigma, \\sigma'}(d(u \\triangleright_A h(v')))) \\\\\n &= a_{\\sigma, \\sigma'}(u \\triangleright_A (d(h(v')))) \\\\\n &= u \\triangleright_A h((\\sigma, \\sigma')v')\n\\end{align*}\n\\]\n\napplying the induction hypothesis in the second line.\n\nTurning to the second equation, the first case we consider is where $u = \\varepsilon$, and we have:\n\n\\[\n\\begin{align*}\n h(\\varepsilon < v) &= h(\\Omega < v) = h(\\Omega) = \\Omega = \\Omega <_A h(v) = \\varepsilon <_A h(v)\n\\end{align*}\n\\]\n\nThe second case is where $u = (\\sigma, \\sigma')\\text{Done}$ and we have:\n\n\\[\n\\begin{align*}\n h((\\sigma, \\sigma')\\text{Done} < v) &= h((\\sigma, \\sigma')v) \\\\\n &= a_{\\sigma, \\sigma'}(d(hv)) \\\\\n &= a_{\\sigma, \\sigma'}(\\text{halt} <_A h(v)) \\\\\n &= a_{\\sigma, \\sigma'}(\\text{halt} <_A h(v)) \\\\\n &= (\\sigma, \\sigma')\\text{Done} <_A h(v)\n\\end{align*}\n\\]\n\nThe last case is where $u = (\\sigma, \\sigma')u'$, with $u'$ a proper pure transition sequence, and we have:\n\n\\[\n\\begin{align*}\n h((\\sigma, \\sigma')u' < v) &= h(a_{\\sigma, \\sigma'}(d(u')) < v) \\\\\n &= h(a_{\\sigma, \\sigma'}(d(u' \\triangleright v))) \\\\\n &= a_{\\sigma, \\sigma'}(d(h(u' \\triangleright v))) \\\\\n &= a_{\\sigma, \\sigma'}(d(u' \\triangleright_A h(v))) \\\\\n &= a_{\\sigma, \\sigma'}(d(u')) <_A h(v) = (\\sigma, \\sigma')u' <_A h(v)\n\\end{align*}\n\\]\n\napplying the induction hypothesis to obtain the fourth equality.\n\nFinally, the formula for the Kleisli extension follows from the construction of $h$, using the Kleisli formula of Theorem 6.1.\n\n\\[\\square\\]\n\nAs in the case of resumptions, one can go further and obtain a closely related, if less elementary, picture of $T_{\\text{Proc}}(P)$ for arbitrary $P$.\n\nNote that the proof of Theorem 6.4 is elementary, making use of definability in a similar way to the proof of Theorem 6.2. However, unlike in the cases of Theorems 6.1 and 6.2, we do not know any conceptual proof of Theorem 6.4. The difficulty is that the theory of processes $L_{\\text{Proc}}$, particularly the part concerning $<_A$ and $\\triangleright$, seems somewhat ad hoc, and is not built up in a standard way from simpler theories. There is surely more to be understood here.\n\nNonetheless, with Theorem 6.4 available, we are in a position to give our algebraic account of Proc. There is an isomorphism $\\theta_{\\text{Proc}} : Q\\text{-Trans} \\to T_{\\text{Seq}} \\setminus \\{\\varepsilon\\}$, where $Q = \\{\\text{Ret}\\}$,\nsending \\( u = (\\sigma_1, \\sigma'_1) \\ldots (\\sigma_n, \\sigma'_n) \\) to itself and \\( u(\\sigma, \\sigma' (\\text{Ret}, v)) \\) to \\( u(\\sigma, \\sigma' \\text{Ret}v) \\). One then has an isomorphism of \\( \\omega \\)-cpos \\( \\tilde{\\theta}_{\\text{Proc}} : L_\\omega(Q-\\text{Trans}) \\cong \\text{Proc} \\) given by: \\( \\tilde{\\theta}_{\\text{Proc}}(I) = \\theta_{\\text{Proc}}(I) \\cup \\{ \\varepsilon \\} \\).\n\nIt follows that Proc can be seen as the free model of \\( L_{\\text{Proc}} \\) over the terminal \\( \\omega \\)-cpo \\{Ret\\}, as we now spell out. First, define the set of left shuffles \\( u \\lhd v \\) of a pure transition sequence \\( u \\) with a transition sequence \\( v \\) by setting\n\n\\[\n\\varepsilon \\lhd v = \\{ \\varepsilon \\}\n\\]\n\nand\n\n\\[\n(\\sigma, \\sigma')u \\lhd v = \\{ (\\sigma, \\sigma')w \\mid w \\in u \\Join v \\}\n\\]\n\nThen, we have:\n\n**Corollary 6.5.** Equip Proc with the following operations:\n\n\\[\n\\begin{align*}\n(\\text{update}_{x,n})_{\\text{Proc}}(P) &= \\{(\\sigma, \\tau)u \\mid (\\sigma[x \\mapsto n], \\tau)u \\in P\\} \\cup \\{\\varepsilon\\} \\\\\n(\\text{lookup}_x)_{\\text{Proc}}([P_n]_n) &= \\bigcup_n \\{(\\sigma, \\tau)u \\in P_n \\mid \\sigma(x) = n\\} \\cup \\{\\varepsilon\\} \\\\\nP \\cup_{\\text{Proc}} Q &= P \\cup Q \\\\\n\\Omega_{\\text{Proc}} &= \\{\\varepsilon\\} \\\\\n\\delta_{\\text{Proc}}(P) &= \\{(\\sigma, \\tau)u \\mid \\sigma \\in \\text{Store}, u \\in P\\} \\cup \\{\\varepsilon\\} \\\\\nP \\triangleright_{\\text{Proc}} Q &= \\text{async}(P, Q) \\\\\nP \\triangleleft_{\\text{Proc}} Q &= \\bigcup_{u \\in P, v \\in Q} u \\lhd v\n\\end{align*}\n\\]\n\n(where \\( x \\) ranges over Vars).\n\nThen \\( \\tilde{\\theta}_{\\text{Proc}} : L_\\omega(Q-\\text{Trans}) \\cong \\text{Proc} \\) is an isomorphism of \\( L_{\\text{Proc}} \\)-models, and Proc is the free model of \\( L_{\\text{Proc}} \\) over \\{Ret\\}, with unit \\((\\eta_{\\text{Proc}})_{\\{\\text{Ret}\\}} : \\{\\text{Ret}\\} \\rightarrow \\text{Proc} \\) given by:\n\n\\[\n(\\eta_{\\text{Proc}})_{\\{\\text{Ret}\\}}(\\text{Ret}) = \\{(\\sigma, \\text{Ret}Done) \\mid \\sigma \\in \\text{Store}\\} \\\\\n\\]\n\nThe Kleisli extension of a map \\( f : \\{\\text{Ret}\\} \\rightarrow \\text{Proc} \\) is given by:\n\n\\[\nf^\\dagger(P) = P \\circ f(\\text{Ret})\n\\]\n\n**Proof.** The proof is a calculation using Theorem 6.4. The following equations are useful:\n\n\\[\n\\begin{align*}\n\\tilde{\\theta}_{\\text{Proc}}(u \\triangleright v) &= (u \\triangleright \\theta_{\\text{Proc}}(v)) \\\\\n\\tilde{\\theta}_{\\text{Proc}}(u \\triangleleft v) &= (u \\triangleleft \\theta_{\\text{Proc}}(v))\n\\end{align*}\n\\]\n\nwhere \\( u \\) is a proper pure transition sequence and \\( v \\) is a \\{Ret\\}-transition sequence.\n\nAs we now see, the algebraic view also determines the semantics of our language. This achieves our aim of placing cooperative threads within the algebraic approach to effects, thereby justifying the previous, more ad hoc, account.\n\nFirst, we have that \\([\\text{skip}] = (\\eta_{\\text{Proc}})_{\\{\\text{Ret}\\}}(\\text{Ret})\\) and that \\( P \\circ Q = (\\text{Ret} \\mapsto Q)^\\dagger(P) \\), so the Kleisli structure determines the semantics of \\text{skip} and composition, just as one would expect from the monadic point of view.\n\nNext, the update and lookup operations, together with the assumed primitive natural number and boolean functions, determine the semantics of assignments, conditionals, and while loops. The operations are equivalent to two generic effects, of assignment and reading:\n\n\\[\n:\\equiv : \\text{Vars} \\times \\mathbb{N} \\rightarrow \\text{Proc} \\\\\n\\_! : \\text{Vars} \\rightarrow T_{\\text{Proc}}(\\mathbb{N})\n\\]\n\nOne can use the reading generic effect to give the semantics of numerical expressions as elements of \\( T_{\\text{Proc}}(\\mathbb{N}) \\); with that, one can give the semantics of assignments, using the assignment generic effect, standard monadic means, and \\( \\tilde{\\theta}_{\\text{Proc}} \\). Similarly, one can use the\nreading generic effect to give the semantics of boolean expressions as elements of $T_{\\text{Proc}}(\\mathbb{B})$, where $\\mathbb{B} \\overset{\\text{def}}{=} \\{\\text{true}, \\text{false}\\}$; with that one can give the semantics of conditionals and while loops, again using standard monadic means and $\\theta_{\\text{Proc}}$ (as well as least fixed-points for while loops).\n\nContinuing, the $d$ operation is that of the algebra; and $\\mathbf{block}$ is modeled by $\\Omega_{\\text{Proc}}$. Finally, the semantics of spawning is determined by async together with the cleaning function\n\n$$-c: \\text{Proc} \\rightarrow A\\text{Proc}$$\n\nIt turns out that the latter is also determined by algebraic means. Specifically, one can regard $A\\text{Proc}$ as a model of $L_{\\text{Res}}$ as in Section 6.2 (so we ignore halt) and then extend it to a model of $L_{\\text{Proc}}$ as follows. First for any proper pure transition sequences $u$ and $v$ we define $u \\triangleright v \\in A\\text{Proc}$ inductively on $v$ by:\n\n- $u \\triangleright \\epsilon = \\{\\epsilon\\}$\n- $u \\triangleright (\\sigma, \\sigma')\\text{Done} = \\{(\\sigma, \\sigma')u\\} \\downarrow$\n- $u \\triangleright (\\sigma, \\sigma')v = \\{(\\sigma, \\sigma')w \\mid w \\in u \\triangleright v\\} \\downarrow$\n\nwhere, in the last line, $v$ is required to be proper. Then we put:\n\n$$(\\text{async}_{A\\text{Proc}})P(Q) = \\bigcup_{u \\in P, v \\in Q} u \\triangleright v$$\n\nand $(\\text{yield\\_to}_{A\\text{Proc}})P(Q) = (\\text{async}_{A\\text{Proc}})Q(P)$. With these definitions, $-c$ is the extension of the map $\\text{Ret} \\mapsto \\text{halt}_{A\\text{Proc}}$ to $\\text{Proc}$.\n\nIn the converse direction one can consider adding missing algebraic operations to the language, for example adding $\\cup$ and $\\text{yield\\_to}$ via constructs $C$ or $D$ and $\\text{yield\\_to} C$. The latter construct is to the binary $\\text{yield\\_to}$ as async is to the binary async. It generalizes yield, which is equivalent to yield to skip. Its operational semantics is given by the rule:\n\n$$\\langle \\sigma, T, E[\\text{yield\\_to} C] \\rangle \\rightarrow \\langle \\sigma, T, E[\\text{skip}], C \\rangle$$\n\nOne may debate the programming usefulness of such additional constructs, but they do allow one to express the equations used for the algebraic characterizations at the level of commands. For example, the equation $P \\triangleright d(x) = d(P \\triangleright x)$ becomes:\n\n$$(\\text{async } C); \\text{yield}; D = \\text{yield;}((\\text{async } C); D \\text{ or (yield\\_to } C); D)$$\n\n6.4. Dendriform Algebras and Modules. We have found it useful to employ various forms of shuffle: sometimes we shuffle two things of the same kind with each other, e.g., two pure transition sequences with each other; and sometimes we shuffle two things of different kinds with each other, e.g., a pure transition sequence with a transition sequence.\n\nWe have further found it useful to break down such shuffles into left and right shuffles, e.g., in the case of the left and right shuffles of asynchronous processes with processes; indeed we employ a uniform notation, writing $\\triangleleft, \\triangleright$, and $\\triangleright\\triangleleft$ for left shuffles, right shuffles, and (ordinary) shuffles, respectively. Our algebraic account of threads has further involved a number of equations concerning the interaction of these shuffle operations with each other and with other operations.\n\nShuffle operations and their algebra have been studied in a variety of settings. In particular, Loday’s dendriform algebras \\cite{Lod01, FG08} provide a wide-ranging general notion of\nleft and right shuffling of two things of the same kind with each other. Foissy’s dendriform\nA-modules [Foi07] provide the corresponding notion of action: left or right shuffling a thing\nof one kind with a thing of another kind. We next relate our treatment to these general\nconcepts, thereby placing our various shuffle operations and our equations for them in a\nstandard algebraic context.\n\nLet \\( R \\) be a given commutative semiring (with no requirement for a 0 or a 1). Then\na dendriform dialgebra is an \\( R \\)-module \\( A \\) equipped with two binary bilinear operations \\(<\\)\nand \\(\\triangleright\\) such that, for all \\( x, y, z \\in A \\):\n\n\\[\n(x < y) < z = x < (y \\triangleright z) \\\\\nx \\triangleright (y \\triangleright z) = (x \\triangleright y) \\triangleright z \\\\\n(x \\triangleright y) < z = x \\triangleright (y < z)\n\\]\n\nwhere \\( x \\triangleright y = \\text{def} x < y + y \\triangleright x \\); it is commutative if \\( x < y = y \\triangleright x \\) always holds. Then\n(\\( A,\\triangleright\\)) is a semigroup in the category of \\( R \\)-modules, equivalently \\( \\triangleright\\) is an associative bilinear\noperation; it is commutative if the dialgebra is.\n\nGiven a dendriform algebra \\( A \\), a dendriform \\( A \\)-module is an \\( R \\)-module \\( M \\) equipped\nwith two binary bilinear operations \\(<,\\triangleright\\) : \\( A \\times M \\to M \\) such that, for all \\( a, b \\in A \\) and\n\\( x \\in M \\):\n\n\\[\n(a < b) < x = a < (b \\triangleright x) \\\\\n(a \\triangleright b) < x = a \\triangleright (b < x)\n\\]\n\nwhere \\( \\triangleright\\) : \\( A \\times M \\to M \\) is given by: \\( a \\triangleright x = a < x + a \\triangleright x \\). Then \\( \\triangleright\\) : \\( A \\times M \\to M \\) is a\nbilinear action of \\( (A, \\triangleright) \\) on \\( M \\).\n\nIn all our examples we take \\( R \\) to be the natural two-element semiring over \\( \\mathbb{B} \\); join\nsemilattices with a zero form \\( \\mathbb{B} \\)-modules (setting true \\( x = x \\) and false \\( x = 0 \\)). As a first\nexample, consider the \\( \\mathbb{B} \\)-module of the collection of all languages, i.e., all sets of strings\nover a given alphabet, not containing \\( \\varepsilon \\). This is a commutative dialgebra, taking \\( < \\) to be\nthe left shuffle operation, and \\( \\triangleright \\) to be the right one; \\( \\triangleright\\) is then the usual shuffle operation.\n\nThe semilattice of asynchronous processes \\( \\text{AP roc} \\) forms a commutative dendriform \\( \\mathbb{B}\\)\nalgebra, setting:\n\n\\[\nP \\triangleleft_{\\text{AP roc}} Q = (\\text{yield}_{\\text{AP roc}})P(Q) \\quad P \\triangleright_{\\text{AP roc}} Q = (\\text{async}_{\\text{AP roc}})P(Q)\n\\]\n\nOne then has that \\( Q\\)-Proc forms a dendriform \\( \\text{AP roc} \\)-module, setting:\n\n\\[\nP \\triangleleft_{Q\\text{-Proc}} I = (\\text{yield}_{Q\\text{-Proc}})P(I) \\quad P \\triangleright_{Q\\text{-Proc}} I = (\\text{async}_{Q\\text{-Proc}})P(I)\n\\]\n\nIt follows that \\( \\text{Proc} \\) also forms a dendriform \\( \\text{AP roc} \\)-module, using the definitions of the left\nand right shuffling given in Corollary [6.5]\n\nAlgebraically, the first group of equations for \\( L\\text{Spawn} \\) state the bilinearity of the two\nmodule operations. The second group contains the second of the three module equations. The\nequation\n\n\\[\na \\triangleright (b \\triangleleft x) = b \\triangleleft (a \\triangleright x)\n\\]\n\ngeneralizing one considered above, holds in any module over a commutative dendriform\nalgebra. To account for the other two module equations algebraically one would need an\nalgebraic treatment of the dendriform algebra operations on \\( \\text{AP roc} \\). These operations are\neffect deconstructors rather than effect constructors. An account of unary deconstructors\nhas been given in [PP09], but a satisfactory treatment of binary ones remains to be found; we\ntherefore leave further algebraic treatment to future work.\n7. Conclusion\n\nA priori, the properties and the semantics of threads in general, and of cooperative threads in particular, may not appear obvious. In our opinion, a huge body of incorrect multithreaded software and a relatively small literature both support this point of view. With the belief that mathematical foundations could prove beneficial, the main technical goal of our work is to define and elucidate the semantics of threads. For instance, semantics can serve for validating reasoning principles; our work is only a preliminary, but encouraging, step in this respect.\n\nOur initial motivation was partly practical—we wanted to understand and further the AME programming model and similar ones. We also saw an opportunity to leverage developments in trace-based denotational semantics and in the algebraic theory of effects, and to extend their applicability to threads. As our results demonstrate, the convergence of these three lines of work proved interesting and fruitful.\n\nWe focus on a particular small language with constructs for threads. Several possible extensions may be considered. These include constructs for parallel composition, nondeterministic choice, higher-order functions, and thread-joining. More speculatively, they also include generalized yields, of the kind that arise in the algebraic theory of effects, as discussed in Section 6. Importantly, our monadic treatment of threads indicates how to add higher-order functions to the semantics.\n\nOur results mostly carry over to these extensions. In some cases, small changes or restrictions are required. In particular, the full-abstraction proof with nondeterministic choice would use fresh variables; the one for higher-order functions might require standard limitations on the order of functions, cf. [Jef95]. Thus, our approach seems to be robust, and indeed—as in the case of higher-order functions—helpful in accounting for a range of language features. Further, our algebraic analysis of the thread monad links it to the broader theme of the algebraic treatment of effects. In that regard, as the discussion after Theorem 6.4 indicates, there is clearly still further understanding to be gained.\n\nAnother possible direction for further work is the exploration of alternative semantics. For instance, we could switch from the “may” semantics that we study to “must” semantics. We could also define alternative notions of observation. As suggested in Section 5.3, some of the coarser notions of observation might require closure conditions, such as closure under suitable forms of stuttering and under mumbling. These may correspond to suitable axioms on the suspension operator $d$, as alluded to in [Plo06]: we conjecture that stuttering corresponds to $d(d(x)) \\leq d(x)$ and that mumbling corresponds to $d(x) \\geq x$.\n\nIt would also be interesting to consider finer notions of observation that distinguish blocking from divergence. To this end we could add constructs such as orElse [HMP05] and, in the semantics, treat blocking as a kind of exception. Finally, we could revisit lower-level semantics with explicit optimistic concurrency and roll-backs, of the kind employed in the implementation of AME.\n\nAcknowledgements\n\nWe are grateful to Martín Escardó and Martin Hyland for their helpful comments and suggestions.\nREFERENCES\n\n\n"}}},{"rowIdx":266,"cells":{"id":{"kind":"string","value":"4d45e1ac5f808bc97e6fe6d057dbb2dd6e6fec7e"},"text":{"kind":"string","value":"# TABLE OF CONTENTS\n\n1 Introduction 3 \n1.1 What is Proxmox Backup Server? 3 \n1.2 Architecture 3 \n1.3 Main Features 3 \n1.4 Reasons for Data Backup? 4 \n1.5 Software Stack 4 \n1.6 Getting Help 5 \n1.6.1 Enterprise Support 5 \n1.6.2 Community Support Forum 5 \n1.6.3 Mailing Lists 5 \n1.6.4 Bug Tracker 5 \n1.7 License 5 \n1.8 History 6 \n\n2 Installation 7 \n2.1 System Requirements 7 \n2.1.1 Minimum Server Requirements, for Evaluation 7 \n2.1.2 Recommended Server System Requirements 7 \n2.1.3 Supported Web Browsers for Accessing the Web Interface 8 \n2.2 Debian Package Repositories 8 \n2.2.1 SecureApt 8 \n2.2.2 Proxmox Backup Enterprise Repository 9 \n2.2.3 Proxmox Backup No-Subscription Repository 9 \n2.2.4 Proxmox Backup Test Repository 9 \n2.2.5 Proxmox Backup Client-only Repository 10 \n2.3 Server Installation 10 \n2.3.1 Install Proxmox Backup with the Installer 10 \n2.3.2 Install Proxmox Backup Server on Debian 11 \n2.3.3 Install Proxmox Backup Server on Proxmox VE 11 \n2.4 Client Installation 12 \n2.4.1 Install Proxmox Backup Client on Debian 12 \n\n3 Terminology 13 \n3.1 Backup Content 13 \n3.1.1 Image Archives: <name>.img 13 \n3.1.2 File Archives: <name>.pxar 13 \n3.1.3 Binary Data (BLOBs) 13 \n3.1.4 Catalog File: catalog.pcat1 13 \n3.1.5 The Manifest: index.json 14 \n3.2 Backup Type 14 \n3.3 Backup ID 14 \n3.4 Backup Time 14 \n3.5 Backup Group 14 \n3.6 Backup Snapshot 14\n# Proxmox Backup User Manual\n\n## A Command Syntax\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Title</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A.1</td>\n<td>proxmox-backup-client</td>\n<td>91</td>\n</tr>\n<tr>\n<td>A.1.1</td>\n<td>Catalog Shell Commands</td>\n<td>98</td>\n</tr>\n<tr>\n<td>A.2</td>\n<td>proxmox-backup-manager</td>\n<td>100</td>\n</tr>\n<tr>\n<td>A.3</td>\n<td>proxmox-tape</td>\n<td>113</td>\n</tr>\n<tr>\n<td>A.4</td>\n<td>pmt</td>\n<td>123</td>\n</tr>\n<tr>\n<td>A.5</td>\n<td>pmtx</td>\n<td>126</td>\n</tr>\n<tr>\n<td>A.6</td>\n<td>pxar</td>\n<td>127</td>\n</tr>\n</tbody>\n</table>\n\n## B Configuration Files\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Title</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>B.1</td>\n<td>acl.cfg</td>\n<td>129</td>\n</tr>\n<tr>\n<td>B.1.1</td>\n<td>File Format</td>\n<td>129</td>\n</tr>\n<tr>\n<td>B.1.2</td>\n<td>Roles</td>\n<td>129</td>\n</tr>\n<tr>\n<td>B.2</td>\n<td>datastore.cfg</td>\n<td>130</td>\n</tr>\n<tr>\n<td>B.2.1</td>\n<td>File Format</td>\n<td>130</td>\n</tr>\n<tr>\n<td>B.2.2</td>\n<td>Options</td>\n<td>130</td>\n</tr>\n<tr>\n<td>B.3</td>\n<td>media-pool.cfg</td>\n<td>131</td>\n</tr>\n<tr>\n<td>B.3.1</td>\n<td>File Format</td>\n<td>131</td>\n</tr>\n<tr>\n<td>B.3.2</td>\n<td>Options</td>\n<td>131</td>\n</tr>\n<tr>\n<td>B.4</td>\n<td>tape.cfg</td>\n<td>131</td>\n</tr>\n<tr>\n<td>B.4.1</td>\n<td>File Format</td>\n<td>131</td>\n</tr>\n<tr>\n<td>B.4.2</td>\n<td>Options</td>\n<td>131</td>\n</tr>\n<tr>\n<td>B.5</td>\n<td>tape-job.cfg</td>\n<td>132</td>\n</tr>\n<tr>\n<td>B.5.1</td>\n<td>File Format</td>\n<td>132</td>\n</tr>\n<tr>\n<td>B.5.2</td>\n<td>Options</td>\n<td>132</td>\n</tr>\n<tr>\n<td>B.6</td>\n<td>user.cfg</td>\n<td>133</td>\n</tr>\n<tr>\n<td>B.6.1</td>\n<td>File Format</td>\n<td>133</td>\n</tr>\n<tr>\n<td>B.6.2</td>\n<td>Options</td>\n<td>133</td>\n</tr>\n<tr>\n<td>B.7</td>\n<td>remote.cfg</td>\n<td>134</td>\n</tr>\n<tr>\n<td>B.7.1</td>\n<td>File Format</td>\n<td>134</td>\n</tr>\n<tr>\n<td>B.7.2</td>\n<td>Options</td>\n<td>134</td>\n</tr>\n<tr>\n<td>B.8</td>\n<td>sync.cfg</td>\n<td>134</td>\n</tr>\n<tr>\n<td>B.8.1</td>\n<td>File Format</td>\n<td>134</td>\n</tr>\n<tr>\n<td>B.8.2</td>\n<td>Options</td>\n<td>134</td>\n</tr>\n<tr>\n<td>B.9</td>\n<td>verification.cfg</td>\n<td>135</td>\n</tr>\n<tr>\n<td>B.9.1</td>\n<td>File Format</td>\n<td>135</td>\n</tr>\n<tr>\n<td>B.9.2</td>\n<td>Options</td>\n<td>135</td>\n</tr>\n</tbody>\n</table>\n\n## C File Formats\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Title</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>C.1</td>\n<td>Proxmox File Archive Format (.pxar)</td>\n<td>137</td>\n</tr>\n<tr>\n<td>C.2</td>\n<td>Data Blob Format (.blob)</td>\n<td>137</td>\n</tr>\n<tr>\n<td>C.3</td>\n<td>Fixed Index Format (.fidx)</td>\n<td>138</td>\n</tr>\n<tr>\n<td>C.4</td>\n<td>Dynamic Index Format (.didx)</td>\n<td>138</td>\n</tr>\n</tbody>\n</table>\n\n## D Backup Protocol\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Title</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>D.1</td>\n<td>Backup Protocol API</td>\n<td>139</td>\n</tr>\n<tr>\n<td>D.1.1</td>\n<td>Upload Blobs</td>\n<td>139</td>\n</tr>\n<tr>\n<td>D.1.2</td>\n<td>Upload Chunks</td>\n<td>139</td>\n</tr>\n<tr>\n<td>D.1.3</td>\n<td>Upload Fixed Indexes</td>\n<td>140</td>\n</tr>\n<tr>\n<td>D.1.4</td>\n<td>Upload Dynamic Indexes</td>\n<td>140</td>\n</tr>\n<tr>\n<td>D.1.5</td>\n<td>Finish Backup</td>\n<td>140</td>\n</tr>\n<tr>\n<td>D.2</td>\n<td>Restore/Reader Protocol API</td>\n<td>140</td>\n</tr>\n<tr>\n<td>D.2.1</td>\n<td>Download Blobs</td>\n<td>140</td>\n</tr>\n<tr>\n<td>D.2.2</td>\n<td>Download Chunks</td>\n<td>141</td>\n</tr>\n<tr>\n<td>D.2.3</td>\n<td>Download Index Files</td>\n<td>141</td>\n</tr>\n</tbody>\n</table>\n\n## E Calendar Events\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Title</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>16.8</td>\n<td>Is the backup incremental/deduplicated?</td>\n<td>90</td>\n</tr>\n</tbody>\n</table>\n\n---\n\niv\n1.1 What is Proxmox Backup Server?\n\nProxmox Backup Server is an enterprise-class, client-server backup software package that backs up virtual machines, containers, and physical hosts. It is specially optimized for the Proxmox Virtual Environment platform and allows you to back up your data securely, even between remote sites, providing easy management with a web-based user interface.\n\nIt supports deduplication, compression, and authenticated encryption (AE). Using Rust as the implementation language guarantees high performance, low resource usage, and a safe, high-quality codebase.\n\nProxmox Backup uses state of the art cryptography for both client-server communication and backup content encryption. All client-server communication uses TLS, and backup data can be encrypted on the client-side before sending, making it safer to back up data to targets that are not fully trusted.\n\n1.2 Architecture\n\nProxmox Backup Server uses a client-server model. The server stores the backup data and provides an API to create and manage datastores. With the API, it's also possible to manage disks and other server-side resources.\n\nThe backup client uses this API to access the backed up data. With the command line tool proxmox-backup-client you can create backups and restore data. For QEMU with Proxmox Virtual Environment we deliver an integrated client.\n\nA single backup is allowed to contain several archives. For example, when you backup a virtual machine, each disk is stored as a separate archive inside that backup. The VM configuration itself is stored as an extra file. This way, it's easy to access and restore only important parts of the backup, without the need to scan the whole backup.\n\n1.3 Main Features\n\n- **Support for Proxmox VE** The Proxmox Virtual Environment is fully supported and you can easily backup virtual machines and containers.\n\n- **Performance** The whole software stack is written in Rust, in order to provide high speed and memory efficiency.\n\n- **Deduplication** Periodic backups produce large amounts of duplicate data. The deduplication layer avoids redundancy and minimizes the storage space used.\nIncremental backups Changes between backups are typically low. Reading and sending only the delta reduces the storage and network impact of backups.\n\nData Integrity The built-in SHA-256 checksum algorithm ensures accuracy and consistency in your backups.\n\nRemote Sync It is possible to efficiently synchronize data to remote sites. Only deltas containing new data are transferred.\n\nCompression The ultra-fast Zstandard compression is able to compress several gigabytes of data per second.\n\nEncryption Backups can be encrypted on the client-side, using AES-256 GCM. This authenticated encryption (AE) mode provides very high performance on modern hardware. In addition to client-side encryption, all data is transferred via a secure TLS connection.\n\nWeb interface Manage the Proxmox Backup Server with the integrated, web-based user interface.\n\nOpen Source No secrets. Proxmox Backup Server is free and open-source software. The source code is licensed under AGPL, v3.\n\nNo Limits Proxmox Backup Server has no artificial limits for backup storage or backup clients.\n\nEnterprise Support Proxmox Server Solutions GmbH offers enterprise support in form of Proxmox Backup Server Subscription Plans. Users at every subscription level get access to the Proxmox Backup Enterprise Repository. In addition, with a Basic, Standard or Premium subscription, users have access to the Proxmox Customer Portal.\n\n1.4 Reasons for Data Backup?\n\nThe main purpose of a backup is to protect against data loss. Data loss can be caused by both faulty hardware and human error.\n\nA common mistake is to accidentally delete a file or folder which is still required. Virtualization can even amplify this problem, as deleting a whole virtual machine can be as easy as pressing a single button.\n\nFor administrators, backups can serve as a useful toolkit for temporarily storing data. For example, it is common practice to perform full backups before installing major software updates. If something goes wrong, you can easily restore the previous state.\n\nAnother reason for backups are legal requirements. Some data, especially business records, must be kept in a safe place for several years by law, so that they can be accessed if required.\n\nIn general, data loss is very costly as it can severely damage your business. Therefore, ensure that you perform regular backups and run restore tests.\n\n1.5 Software Stack\n\nProxmox Backup Server consists of multiple components:\n\n- A server-daemon providing, among other things, a RESTful API, super-fast asynchronous tasks, lightweight usage statistic collection, scheduling events, strict separation of privileged and unprivileged execution environments\n\n- A JavaScript management web interface\n\n- A management CLI tool for the server (proxmox-backup-manager)\n• A client CLI tool (proxmox-backup-client) to access the server easily from any Linux amd64 environment\n\nAside from the web interface, most parts of Proxmox Backup Server are written in the Rust programming language.\n\n“The Rust programming language helps you write faster, more reliable software. High-level ergonomics and low-level control are often at odds in programming language design; Rust challenges that conflict. Through balancing powerful technical capacity and a great developer experience, Rust gives you the option to control low-level details (such as memory usage) without all the hassle traditionally associated with such control.”\n\n—The Rust Programming Language\n\n1.6 Getting Help\n\n1.6.1 Enterprise Support\n\nUsers with a Proxmox Backup Server Basic, Standard or Premium Subscription Plan have access to the Proxmox Customer Portal. The customer portal provides support with guaranteed response times from the Proxmox developers. For more information or for volume discounts, please contact office@proxmox.com.\n\n1.6.2 Community Support Forum\n\nWe always encourage our users to discuss and share their knowledge using the Proxmox Community Forum. The forum is moderated by the Proxmox support team. The large user base is spread out all over the world. Needless to say that such a large forum is a great place to get information.\n\n1.6.3 Mailing Lists\n\nProxmox Backup Server is fully open-source and contributions are welcome! Here is the primary communication channel for developers:\n\nMailing list for developers PBS Development List\n\n1.6.4 Bug Tracker\n\nProxmox runs a public bug tracker at https://bugzilla.proxmox.com. If an issue appears, file your report there. An issue can be a bug as well as a request for a new feature or enhancement. The bug tracker helps to keep track of the issue and will send a notification once it has been solved.\n\n1.7 License\n\nCopyright (C) 2019-2021 Proxmox Server Solutions GmbH\n\nThis software is written by Proxmox Server Solutions GmbH <support@proxmox.com>\n\nProxmox Backup Server is free and open source software: you can use it, redistribute it, and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.\n1.8 History\n\nBackup is, and always has been, a central aspect of IT administration. The need to recover from data loss is fundamental and only increases with virtualization.\n\nFor this reason, we’ve been shipping a backup tool with Proxmox VE, from the beginning. This tool is called vzdump and is able to make consistent snapshots of running LXC containers and KVM virtual machines.\n\nHowever, vzdump only allows for full backups. While this is fine for small backups, it becomes a burden for users with large VMs. Both backup duration and storage usage are too high for this case, especially for users who want to keep many backups of the same VMs. To solve these problems, we needed to offer deduplication and incremental backups.\n\nBack in October 2018, development started. We investigated several technologies and frameworks and finally decided to use Rust as the implementation language, in order to provide high speed and memory efficiency. The 2018-edition of Rust seemed promising for our requirements.\n\nIn July 2020, we released the first beta version of Proxmox Backup Server, followed by the first stable version in November 2020. With support for incremental, fully deduplicated backups, Proxmox Backup significantly reduces network load and saves valuable storage space.\nProxmox Backup is split into a server and client part. The server part can either be installed with a graphical installer or on top of Debian from the provided package repository.\n\n2.1 System Requirements\n\nWe recommend using high quality server hardware when running Proxmox Backup in production. To further decrease the impact of a failed host, you can set up periodic, efficient, incremental data-store synchronization from other Proxmox Backup Server instances.\n\n2.1.1 Minimum Server Requirements, for Evaluation\n\nThese minimum requirements are for evaluation purposes only and should not be used in production.\n\n- CPU: 64bit (x86-64 or AMD64), 2+ Cores\n- Memory (RAM): 2 GB RAM\n- Hard drive: more than 8GB of space.\n- Network card (NIC)\n\n2.1.2 Recommended Server System Requirements\n\n- CPU: Modern AMD or Intel 64-bit based CPU, with at least 4 cores\n- Memory: minimum 4 GiB for the OS, filesystem cache and Proxmox Backup Server daemons. Add at least another GiB per TiB storage space.\n- OS storage:\n - 32 GiB, or more, free storage space\n - Use a hardware RAID with battery protected write cache (BBU) or a redundant ZFS setup (ZFS is not compatible with a hardware RAID controller).\n- Backup storage:\n - Use only SSDs, for best results\n - If HDDs are used: Using a metadata cache is highly recommended, for example, add a ZFS special device mirror.\n- Redundant Multi-GBit/s network interface cards (NICs)\n2.1.3 Supported Web Browsers for Accessing the Web Interface\n\nTo access the server’s web-based user interface, we recommend using one of the following browsers:\n\n- Firefox, a release from the current year, or the latest Extended Support Release\n- Chrome, a release from the current year\n- Microsoft’s currently supported version of Edge\n- Safari, a release from the current year\n\n2.2 Debian Package Repositories\n\nAll Debian based systems use APT as a package management tool. The lists of repositories are defined in /etc/apt/sources.list and the .list files found in the /etc/apt/sources.d/ directory. Updates can be installed directly with the apt command line tool, or via the GUI.\n\nAPT sources.list files list one package repository per line, with the most preferred source listed first. Empty lines are ignored and a # character anywhere on a line marks the remainder of that line as a comment. The information available from the configured sources is acquired by apt update.\n\nListing 1: File: /etc/apt/sources.list\n\n```\ndeb http://ftp.debian.org/debian buster main contrib\n# security updates\ndeb http://security.debian.org/debian-security buster/updates main contrib\n```\n\nIn addition, you need a package repository from Proxmox to get Proxmox Backup updates.\n\n2.2.1 SecureApt\n\nThe Release files in the repositories are signed with GnuPG. APT is using these signatures to verify that all packages are from a trusted source.\n\nIf you install Proxmox Backup Server from an official ISO image, the verification key is already installed.\n\nIf you install Proxmox Backup Server on top of Debian, download and install the key with the following commands:\n\n```\n```\n\nVerify the SHA512 checksum afterwards with:\n\n```\n# sha512sum /etc/apt/trusted.gpg.d/proxmox-ve-release-6.x.gpg\n```\n\nThe output should be:\n\n```\nacca6f416917e8e11490a08a1e2842d500b3a5d9f322c6319db0927b2901c3eae23c7f5cd5df6facf2b57399d3cfa52ad7769ebdd75d97\n```\n\nand the md5sum:\n\n```\n# md5sum /etc/apt/trusted.gpg.d/proxmox-ve-release-6.x.gpg\n```\n\nHere, the output should be:\n2.2.2 Proxmox Backup Enterprise Repository\n\nThis is the stable, recommended repository. It is available for all Proxmox Backup subscription users. It contains the most stable packages, and is suitable for production use. The pbs-enterprise repository is enabled by default:\n\n```\nListing 2: File: /etc/apt/sources.list.d/pbs-enterprise.list\ndeb https://enterprise.proxmox.com/debian/pbs buster pbs-enterprise\n```\n\nTo never miss important security fixes, the superuser (root@pam user) is notified via email about new packages as soon as they are available. The change-log and details of each package can be viewed in the GUI (if available).\n\nPlease note that you need a valid subscription key to access this repository. More information regarding subscription levels and pricing can be found at https://www.proxmox.com/en/proxmox-backup-server/pricing\n\nNote: You can disable this repository by commenting out the above line using a # (at the start of the line). This prevents error messages if you do not have a subscription key. Please configure the pbs-no-subscription repository in that case.\n\n2.2.3 Proxmox Backup No-Subscription Repository\n\nAs the name suggests, you do not need a subscription key to access this repository. It can be used for testing and non-production use. It is not recommended to use it on production servers, because these packages are not always heavily tested and validated.\n\nWe recommend to configure this repository in /etc/apt/sources.list.\n\n```\nListing 3: File: /etc/apt/sources.list\ndeb http://ftp.debian.org/debian buster main contrib\ndeb http://ftp.debian.org/debian buster-updates main contrib\n# PBS pbs-no-subscription repository provided by proxmox.com,\n# NOT recommended for production use\ndeb http://download.proxmox.com/debian/pbs buster pbs-no-subscription\n# security updates\ndeb http://security.debian.org/debian-security buster/security main contrib\n```\n\n2.2.4 Proxmox Backup Test Repository\n\nThis repository contains the latest packages and is heavily used by developers to test new features. You can access this repository by adding the following line to /etc/apt/sources.list:\n\n```\nListing 4: sources.list entry for pbstest\ndeb http://download.proxmox.com/debian/pbs buster pbstest\n```\n2.2.5 Proxmox Backup Client-only Repository\n\nIf you want to use the Proxmox Backup Client on systems using a Linux distribution not based on Proxmox projects, you can use the client-only repository. Currently there’s only a client-repository for APT based systems.\n\nAPT-based Proxmox Backup Client Repository\n\nFor modern Linux distributions using apt as package manager, like all Debian and Ubuntu Derivative do, you may be able to use the APT-based repository. This repository is tested with:\n\n- Debian Buster\n- Ubuntu 20.04 LTS\n\nIt may work with older, and should work with more recent released versions.\n\nIn order to configure this repository you need to first setup the Proxmox release key. After that, add the repository URL to the APT sources lists. Edit the file /etc/apt/sources.list.d/pbs-client.list and add the following snippet\n\n```\nListing 5: File: /etc/apt/sources.list\n```\n\n```\ndeb http://download.proxmox.com/debian/pbs-client buster main\n```\n\n2.3 Server Installation\n\nThe backup server stores the actual backed up data and provides a web based GUI for various management tasks such as disk management.\n\n**Note:** You always need a backup server. It is not possible to use Proxmox Backup without the server part.\n\nThe disk image (ISO file) provided by Proxmox includes a complete Debian system (\"buster\" for version 1.x) as well as all necessary packages for the Proxmox Backup server.\n\nThe installer will guide you through the setup process and allow you to partition the local disk(s), apply basic system configurations (e.g. timezone, language, network), and install all required packages. The provided ISO will get you started in just a few minutes, and is the recommended method for new and existing users.\n\nAlternatively, Proxmox Backup server can be installed on top of an existing Debian system.\n\n2.3.1 Install Proxmox Backup with the Installer\n\nDownload the ISO from https://www.proxmox.com/downloads. It includes the following:\n\n- The Proxmox Backup server installer, which partitions the local disk(s) with ext4, xfs or ZFS, and installs the operating system\n- Complete operating system (Debian Linux, 64-bit)\n- Proxmox Linux kernel with ZFS support\n- Complete tool-set to administer backups and all necessary resources\n• Web based management interface\n\n**Note:** During the installation process, the complete server is used by default and all existing data is removed.\n\n### 2.3.2 Install Proxmox Backup Server on Debian\n\nProxmox ships as a set of Debian packages which can be installed on top of a standard Debian installation. After configuring the sysadmin_package_repositories, you need to run:\n\n```bash\n# apt-get update\n# apt-get install proxmox-backup-server\n```\n\nThe commands above keep the current (Debian) kernel and install a minimal set of required packages.\n\nIf you want to install the same set of packages as the installer does, please use the following:\n\n```bash\n# apt-get update\n# apt-get install proxmox-backup\n```\n\nThis will install all required packages, the Proxmox kernel with ZFS support, and a set of common and useful packages.\n\n**Caution:** Installing Proxmox Backup on top of an existing Debian installation looks easy, but it assumes that the base system and local storage have been set up correctly. In general this is not trivial, especially when LVM or ZFS is used. The network configuration is completely up to you as well.\n\n**Note:** You can access the web interface of the Proxmox Backup Server with your web browser, using HTTPS on port 8007. For example at https://<ip-or-dns-name>:8007\n\n### 2.3.3 Install Proxmox Backup Server on Proxmox VE\n\nAfter configuring the sysadmin_package_repositories, you need to run:\n\n```bash\n# apt-get update\n# apt-get install proxmox-backup-server\n```\n\n**Caution:** Installing the backup server directly on the hypervisor is not recommended. It is safer to use a separate physical server to store backups. Should the hypervisor server fail, you can still access the backups.\n\n**Note:** You can access the web interface of the Proxmox Backup Server with your web browser, using HTTPS on port 8007. For example at https://<ip-or-dns-name>:8007\n2.4 Client Installation\n\n2.4.1 Install Proxmox Backup Client on Debian\n\nProxmox ships as a set of Debian packages to be installed on top of a standard Debian installation. After configuring the package_repositories_client_only_apt, you need to run:\n\n```\n# apt-get update\n# apt-get install proxmox-backup-client\n```\n\n**Note:** The client-only repository should be usable by most recent Debian and Ubuntu derivatives.\nCHAPTER\nTHREE\n\nTERMINOLOGY\n\n3.1 Backup Content\n\nWhen doing deduplication, there are different strategies to get optimal results in terms of performance and/or deduplication rates. Depending on the type of data, it can be split into fixed or variable sized chunks. Fixed sized chunking requires minimal CPU power, and is used to backup virtual machine images. Variable sized chunking needs more CPU power, but is essential to get good deduplication rates for file archives.\n\nThe Proxmox Backup Server supports both strategies.\n\n3.1.1 Image Archives: <name>.img\n\nThis is used for virtual machine images and other large binary data. Content is split into fixed-sized chunks.\n\n3.1.2 File Archives: <name>.pxar\n\nA file archive stores a full directory tree. Content is stored using the Proxmox File Archive Format (.pxar), split into variable-sized chunks. The format is optimized to achieve good deduplication rates.\n\n3.1.3 Binary Data (BLOBs)\n\nThis type is used to store smaller (< 16MB) binary data such as configuration files. Larger files should be stored as image archive.\n\nCaution: Please do not store all files as BLOBs. Instead, use the file archive to store whole directory trees.\n\n3.1.4 Catalog File: catalog.pcat1\n\nThe catalog file is an index for file archives. It contains the list of files and is used to speed up search operations.\n3.1.5 The Manifest: index.json\n\nThe manifest contains the list of all backup files, their sizes and checksums. It is used to verify the consistency of a backup.\n\n3.2 Backup Type\n\nThe backup server groups backups by type, where type is one of:\n\n- **vm** This type is used for virtual machines. Typically consists of the virtual machine’s configuration file and an image archive for each disk.\n- **ct** This type is used for containers. Consists of the container’s configuration and a single file archive for the filesystem content.\n- **host** This type is used for backups created from within the backed up machine. Typically this would be a physical host but could also be a virtual machine or container. Such backups may contain file and image archives, there are no restrictions in this regard.\n\n3.3 Backup ID\n\nA unique ID. Usually the virtual machine or container ID. host type backups normally use the hostname.\n\n3.4 Backup Time\n\nThe time when the backup was made.\n\n3.5 Backup Group\n\nThe tuple <type>/<ID> is called a backup group. Such a group may contain one or more backup snapshots.\n\n3.6 Backup Snapshot\n\nThe triplet <type>/<ID>/<time> is called a backup snapshot. It uniquely identifies a specific backup within a datastore.\n\nListing 1: Backup Snapshot Examples\n\n<table>\n<thead>\n<tr>\n<th>Example</th>\n<th>Backup Type</th>\n<th>Date/Time</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>vm/104/2019-10-09T08:01:06Z</td>\n<td>virtual machine</td>\n<td>2019-10-09T08:01:06Z</td>\n</tr>\n</tbody>\n</table>\n\nAs you can see, the time format is RFC3339 with Coordinated Universal Time (UTC, identified by the trailing Z).\nCHAPTER\nFOUR\n\nGRAPHICAL USER INTERFACE\n\nProxmox Backup Server offers an integrated, web-based interface to manage the server. This means that you can carry out all administration tasks through your web browser, and that you don't have to worry about installing extra management tools. The web interface also provides a built-in console, so if you prefer the command line or need some extra control, you have this option.\n\nThe web interface can be accessed via https://youripaddress:8007. The default login is root, and the password is the one specified during the installation process.\n\n4.1 Features\n\n- Simple management interface for Proxmox Backup Server\n- Monitoring of tasks, logs and resource usage\n- Management of users, permissions, datastores, etc.\n- Secure HTML5 console\n- Support for multiple authentication sources\n- Support for multiple languages\n- Based on ExtJS 6.x JavaScript framework\n\n4.2 Login\n\nWhen you connect to the web interface, you will first see the login window. Proxmox Backup Server supports various languages and authentication back ends (Realms), both of which can be selected here.\n\n**Note:** For convenience, you can save the username on the client side, by selecting the “Save User name” checkbox at the bottom of the window.\n4.3 GUI Overview\n\nThe Proxmox Backup Server web interface consists of 3 main sections:\n\n- **Header**: At the top. This shows version information, and contains buttons to view documentation, monitor running tasks, set the language and logout.\n\n- **Sidebar**: On the left. This contains the configuration options for the server.\n\n- **Configuration Panel**: In the center. This contains the control interface for the configuration options in the Sidebar.\n\n4.4 Sidebar\n\nIn the sidebar, on the left side of the page, you can see various items relating to specific management activities.\n\n4.4.1 Dashboard\n\nThe Dashboard shows a summary of activity and resource usage on the server. Specifically, this displays hardware usage, a summary of previous and currently running tasks, and subscription information.\n4.4.2 Configuration\n\nThe Configuration section contains some system configuration options, such as time and network configuration. It also contains the following subsections:\n\n- **Access Control**: Add and manage users, API tokens, and the permissions associated with these items\n- **Remotes**: Add, edit and remove remotes (see Remote)\n- **Subscription**: Upload a subscription key, view subscription status and access a text-based system report.\n\n4.4.3 Administration\n\nThe Administration section contains a top panel, with further administration tasks and information. These are:\n\n- **Server Status**: Provides access to the console, power options, and various resource usage statistics\n- **Services**: Manage and monitor system services\n- **Updates**: An interface for upgrading packages\n- **Syslog**: View log messages from the server\n- **Tasks**: Task history with multiple filter options\nThe administration menu item also contains a disk management subsection:\n\n- **Disks**: View information on available disks\n - **Directory**: Create and view information on ext4 and xfs disks\n - **ZFS**: Create and view information on ZFS disks\n4.4.4 Tape Backup\n\nThe Tape Backup section contains a top panel, managing tape media sets, inventories, drives, changers and the tape backup jobs itself.\n\nIt also contains a subsection per standalone drive and per changer, with a status and management view for those devices.\nThe Datastore section contains interfaces for creating and managing datastores. It contains a button to create a new datastore on the server, as well as a subsection for each datastore on the system, in which you can use the top panel to view:\n\n- **Summary**: Access a range of datastore usage statistics\n- **Content**: Information on the datastore’s backup groups and their respective contents\n- **Prune & GC**: Schedule *pruning* and *garbage collection* operations, and run garbage collection manually\n- **Sync Jobs**: Create, manage and run *Sync Jobs* from remote servers\n- **Verify Jobs**: Create, manage and run *Verification* jobs on the datastore\n5.1 Disk Management\n\nProxmox Backup Server comes with a set of disk utilities, which are accessed using the disk subcommand. This subcommand allows you to initialize disks, create various filesystems, and get information about the disks.\n\nTo view the disks connected to the system, navigate to Administration -> Disks in the web interface or use the list subcommand of disk:\n\n```\n# proxmox-backup-manager disk list\n```\n\n(continues on next page)\nTo initialize a disk with a new GPT, use the initialize subcommand:\n\n```\n# proxmox-backup-manager disk initialize sdX\n```\n\nYou can create an ext4 or xfs filesystem on a disk using `fs create`, or by navigating to **Administration -> Disks -> Directory** in the web interface and creating one from there. The following command creates an ext4 filesystem and passes the `--add-datastore` parameter, in order to automatically create a datastore on the disk (in this case `sdd`). This will create a datastore at the location `/mnt/datastore/store1`:\n\n```\n# proxmox-backup-manager disk fs create store1 --disk sdd --filesystem ext4 --add-datastore\n```\n\nYou can also create a zpool with various raid levels from **Administration -> Disks -> Zpool** in the web interface, or by using `zpool create`. The command below creates a mirrored zpool using two disks (`sdb` & `sdc`) and mounts it under `/mnt/datastore/zpool1`:\n\n```\n# proxmox-backup-manager disk zpool create zpool1 --devices sdb,sdc --raidlevel mirror\n```\n\n**Note:** You can also pass the `--add-datastore` parameter here, to automatically create a datastore from the disk.\n\nYou can use `disk fs list` and `disk zpool list` to keep track of your filesystems and zpools respectively.\n\nProxmox Backup Server uses the package smartmontools. This is a set of tools used to monitor...\nand control the S.M.A.R.T. system for local hard disks. If a disk supports S.M.A.R.T. capability, and you have this enabled, you can display S.M.A.R.T. attributes from the web interface or by using the command:\n\n```\n# proxmox-backup-manager disk smart-attributes sdX\n```\n\n**Note:** This functionality may also be accessed directly through the use of the `smartctl` command, which comes as part of the smartmontools package (see `man smartctl` for more details).\n\n### 5.2 Datastore\n\nA datastore refers to a location at which backups are stored. The current implementation uses a directory inside a standard Unix file system (ext4, xfs or zfs) to store the backup data.\n\nDatastores are identified by a simple ID. You can configure this when setting up the datastore. The configuration information for datastores is stored in the file `/etc/proxmox-backup/datastore.cfg`.\n\n**Note:** The File Layout requires the file system to support at least 65538 subdirectories per directory. That number comes from the $2^{16}$ pre-created chunk namespace directories, and the . and .. default directory entries. This requirement excludes certain filesystems and filesystem configuration from being supported for a datastore. For example, ext3 as a whole or ext4 with the `dir_nlink` feature manually disabled.\n5.2.1 Datastore Configuration\n\nYou can configure multiple datastores. Minimum one datastore needs to be configured. The datastore is identified by a simple name and points to a directory on the filesystem. Each datastore also has associated retention settings of how many backup snapshots for each interval of hourly, daily, weekly, monthly, yearly as well as a time-independent number of backups to keep in that store. Pruning and Removing Backups and garbage collection can also be configured to run periodically based on a configured schedule (see Calendar Events) per datastore.\n\nCreating a Datastore\n\nYou can create a new datastore from the web interface, by clicking Add Datastore in the side menu, under the Datastore section. In the setup window:\n\n- Name refers to the name of the datastore\n- Backing Path is the path to the directory upon which you want to create the datastore\n- GC Schedule refers to the time and intervals at which garbage collection runs\n• *Prune Schedule* refers to the frequency at which pruning takes place\n• *Prune Options* set the amount of backups which you would like to keep (see *Pruning and Removing Backups*).\n• *Comment* can be used to add some contextual information to the datastore.\n\nAlternatively you can create a new datastore from the command line. The following command creates a new datastore called `store1` on `/backup/disk1/store1`\n\n```\n# proxmox-backup-manager datastore create store1 /backup/disk1/store1\n```\n\n**Managing Datastores**\n\nTo list existing datastores from the command line run:\n\n```\n# proxmox-backup-manager datastore list\n```\n\n<table>\n<thead>\n<tr>\n<th>name</th>\n<th>path</th>\n<th>comment</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>store1</td>\n<td>/backup/disk1/store1</td>\n<td>This is my default storage.</td>\n</tr>\n</tbody>\n</table>\n\nYou can change the garbage collection and prune settings of a datastore, by editing the datastore from the GUI or by using the `update` subcommand. For example, the below command changes the garbage collection schedule using the `update` subcommand and prints the properties of the datastore with the `show` subcommand:\n\n```\n# proxmox-backup-manager datastore update store1 --gc-schedule 'Tue 04:27'\n# proxmox-backup-manager datastore show store1\n```\n\n```\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>name</td>\n<td>store1</td>\n</tr>\n<tr>\n<td>path</td>\n<td>/backup/disk1/store1</td>\n</tr>\n<tr>\n<td>comment</td>\n<td>This is my default storage.</td>\n</tr>\n<tr>\n<td>gc-schedule</td>\n<td>Tue 04:27</td>\n</tr>\n<tr>\n<td>keep-last</td>\n<td>7</td>\n</tr>\n<tr>\n<td>prune-schedule</td>\n<td>daily</td>\n</tr>\n</tbody>\n</table>\n```\n\nFinally, it is possible to remove the datastore configuration:\n\n```\n# proxmox-backup-manager datastore remove store1\n```\n\n**Note:** The above command removes only the datastore configuration. It does not delete any data from the underlying directory.\n\n**File Layout**\n\nAfter creating a datastore, the following default layout will appear:\n\n```\n# ls -arlh /backup/disk1/store1\n276493 -rw-r--r-- 1 backup backup 0 Jul 8 12:35 .lock\n276490 drwxr-x--- 1 backup backup 1064960 Jul 8 12:35 .chunks\n```\n.lock is an empty file used for process locking.\n\nThe .chunks directory contains folders, starting from 0000 and taking hexadecimal values until ffff. These directories will store the chunked data after a backup operation has been executed.\n\n```\n# ls -alrh /backup/disk1/store1/.chunks\n545824 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 ffff\n545823 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 fffe\n415621 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 fffd\n415620 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 ffef\n353187 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 ffed\n344995 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 ffec\n144079 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 ffdb\n144078 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 ffda\n144077 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 fffc\n... \n403180 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 000c\n403179 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 000b\n403177 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 000a\n402530 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 0009\n402513 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 0008\n402509 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 0007\n276599 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 0006\n276598 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 0005\n276597 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 0004\n276501 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 0003\n276499 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 0002\n276498 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 0001\n276494 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 0000\n276489 drwxr-x--- 2 backup backup 4.0K Jul 8 12:35 ..\n276490 drwxr-x--- 1 backup backup 1.1M Jul 8 12:35 .\n```\n6.1 User Configuration\n\nProxmox Backup Server supports several authentication realms, and you need to choose the realm when you add a new user. Possible realms are:\n\n- **pam** Linux PAM standard authentication. Use this if you want to authenticate as Linux system user (Users need to exist on the system).\n- **pbs** Proxmox Backup Server realm. This type stores hashed passwords in `/etc/proxmox-backup/shadow.json`.\n\nAfter installation, there is a single user `root@pam`, which corresponds to the Unix superuser. User configuration information is stored in the file `/etc/proxmox-backup/user.cfg`. You can use the `proxmox-backup-manager` command line tool to list or manipulate users:\nThe superuser has full administration rights on everything, so you normally want to add other users with less privileges. You can add a new user with the `user create` subcommand or through the web interface, under the **User Management** tab of **Configuration -> Access Control**. The `create` subcommand lets you specify many options like `--email` or `--password`. You can update or change any user properties using the `update` subcommand later (Edit in the GUI):\n\n```bash\n# proxmox-backup-manager user create john@pbs --email john@example.com\n# proxmox-backup-manager user update john@pbs --firstname John --lastname Smith\n# proxmox-backup-manager user update john@pbs --comment \"An example user.\"\n```\n\nThe resulting user list looks like this:\n\n```\nproxmox-backup-manager user list\n```\n\n### Add: User\n\n<table>\n<thead>\n<tr>\n<th>User name:</th>\n<th>First Name:</th>\n<th>Last Name:</th>\n<th>E-Mail:</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>john</td>\n<td>john</td>\n<td>smith</td>\n<td><a href=\"mailto:john@example.com\">john@example.com</a></td>\n</tr>\n</tbody>\n</table>\n\nNewly created users do not have any permissions. Please read the Access Control section to learn how to set access permissions.\n\nIf you want to disable a user account, you can do that by setting `--enable` to 0\n\n```bash\n# proxmox-backup-manager user update john@pbs --enable 0\n```\n\nOr completely remove the user with:\n\n```bash\n# proxmox-backup-manager user remove john@pbs\n```\n6.2 API Tokens\n\nAny authenticated user can generate API tokens which can in turn be used to configure various clients, instead of directly providing the username and password.\n\nAPI tokens serve two purposes:\n\n1. Easy revocation in case client gets compromised\n2. Limit permissions for each client/token within the users' permission\n\nAn API token consists of two parts: an identifier consisting of the user name, the realm and a tokenname (user@realm!tokenname), and a secret value. Both need to be provided to the client in place of the user ID (user@realm) and the user password, respectively.\n\nThe API token is passed from the client to the server by setting the Authorization HTTP header with method PBSAPIToken to the value TOKENID:TOKENSECRET.\n\nGenerating new tokens can done using proxmox-backup-manager or the GUI:\n\n# proxmox-backup-manager user generate-token john@pbs client1\nResult: {\n\n(continues on next page)\nNote: The displayed secret value needs to be saved, since it cannot be displayed again after generating the API token.\n\nThe user `list-tokens` sub-command can be used to display tokens and their metadata:\n\n```\n# proxmox-backup-manager user list-tokens john@pbs\n\n<table>\n<thead>\n<tr>\n<th>tokenid</th>\n<th>enable</th>\n<th>expire</th>\n<th>comment</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>john@pbs!client1</td>\n<td>1</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n```\n\nSimilarly, the user `delete-token` subcommand can be used to delete a token again.\n\nNewly generated API tokens don’t have any permissions. Please read the next section to learn how to set access permissions.\n\n### 6.3 Access Control\n\nBy default new users and API tokens do not have any permission. Instead you need to specify what is allowed and what is not. You can do this by assigning roles to users/tokens on specific objects like datastores or remotes. The following roles exist:\n\n- **NoAccess** Disable Access - nothing is allowed.\n- **Admin** Can do anything.\n- **Audit** Can view things, but is not allowed to change settings.\n- **DatastoreAdmin** Can do anything on datastores.\n- **DatastoreAudit** Can view datastore settings and list content. But is not allowed to read the actual data.\n- **DatastoreReader** Can inspect datastore content and can do restores.\n- **DatastoreBackup** Can backup and restore owned backups.\n- **DatastorePowerUser** Can backup, restore, and prune owned backups.\n- **RemoteAdmin** Can do anything on remotes.\n- **RemoteAudit** Can view remote settings.\n- **RemoteSyncOperator** Can view remote settings.\n- **RemoteSyncOperator** Can view remote settings.\n\n\nAccess permission information is stored in /etc/proxmox-backup/acl.cfg. The file contains 5 fields, separated using a colon (':') as a delimiter. A typical entry takes the form:\n\nacl:1:/datastore:john@pbs:DatastoreBackup\n\nThe data represented in each field is as follows:\n\n1. acl identifier\n2. A 1 or 0, representing whether propagation is enabled or disabled, respectively\n3. The object on which the permission is set. This can be a specific object (single datastore, remote, etc.) or a top level object, which with propagation enabled, represents all children of the object also.\n4. The user(s)/token(s) for which the permission is set\n5. The role being set\n\nYou can manage permissions via Configuration -> Access Control -> Permissions in the web interface. Likewise, you can use the acl subcommand to manage and monitor user permissions from the command line. For example, the command below will add the user john@pbs as a DatastoreAdmin for the datastore store1, located at /backup/disk1/store1:\n\n```\n# proxmox-backup-manager acl update /datastore/store1 DatastoreAdmin --auth-id john@pbs\n```\n\nYou can list the ACLs of each user/token using the following command:\n\n```\n# proxmox-backup-manager acl list\n```\n\n```\n<table>\n<thead>\n<tr>\n<th>ugid</th>\n<th>path</th>\n<th>propagate</th>\n<th>roleid</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>john@pbs</td>\n<td>/datastore/store1</td>\n<td>1</td>\n<td>DatastoreAdmin</td>\n</tr>\n</tbody>\n</table>\n```\n\nA single user/token can be assigned multiple permission sets for different datastores.\n\n**Note:** Naming convention is important here. For datastores on the host, you must use the convention /datastore/{storename}. For example, to set permissions for a datastore mounted at /mnt/backup/disk4/store2, you would use /datastore/store2 for the path. For remote stores, use the convention /remote/{remote}/{storename}, where {remote} signifies the name of the remote (see Remote below) and {storename} is the name of the datastore on the remote.\n\n### 6.3.1 API Token permissions\n\nAPI token permissions are calculated based on ACLs containing their ID independent of those of their corresponding user. The resulting permission set on a given path is then intersected with that of the corresponding user.\n\nIn practice this means:\n\n1. API tokens require their own ACL entries\n2. API tokens can never do more than their corresponding user\n\n### 6.3.2 Effective permissions\n\nTo calculate and display the effective permission set of a user or API token you can use the proxmox-backup-manager user permission command:\n# proxmox-backup-manager user permissions john@pbs --path /datastore/store1\nPrivileges with (*) have the propagate flag set\nPath: /datastore/store1\n- Datastore.Audit (*)\n- Datastore.Backup (*)\n- Datastore.Modify (*)\n- Datastore.Prune (*)\n- Datastore.Read (*)\n- Datastore.Verify (*)\n\n# proxmox-backup-manager acl update /datastore/store1 DatastoreBackup --auth-id 'john@pbs!client1'\n\n# proxmox-backup-manager user permissions 'john@pbs!client1' --path /datastore/store1\nPrivileges with (*) have the propagate flag set\nPath: /datastore/store1\n- Datastore.Backup (*)\n\n6.4 Two-factor authentication\n\n6.4.1 Introduction\n\nWith simple authentication, only a password (single factor) is required to successfully claim an identity (authenticate), for example, to be able to log in as root@pam on a specific instance of Proxmox Backup Server. In this case, if the password gets stolen or leaked, anybody can use it to log in - even if they should not be allowed to do so.\n\nWith two-factor authentication (TFA), a user is asked for an additional factor to verify their authenticity. Rather than relying on something only the user knows (a password), this extra factor requires something only the user has, for example, a piece of hardware (security key) or a secret saved on the user's smartphone. This prevents a remote user from gaining unauthorized access to an account, as even if they have the password, they will not have access to the physical object (second factor).\n\n6.4.2 Available Second Factors\n\nYou can set up multiple second factors, in order to avoid a situation in which losing your smartphone or security key locks you out of your account permanently.\n\nProxmox Backup Server supports three different two-factor authentication methods:\n\n- **TOTP (Time-based One-Time Password)**. A short code derived from a shared secret and the current time, it changes every 30 seconds.\n\n- **WebAuthn (Web Authentication)**. A general standard for authentication. It is implemented by various security devices, like hardware keys or trusted platform modules (TPM) from a computer or smart phone.\n\n- **Single use Recovery Keys**. A list of keys which should either be printed out and locked in a secure place or saved digitally in an electronic vault. Each key can be used only once. These\nare perfect for ensuring that you are not locked out, even if all of your other second factors are lost or corrupt.\n\n6.4.3 Setup\n\nTOTP\n\nThere is no server setup required. Simply install a TOTP app on your smartphone (for example, FreeOTP) and use the Proxmox Backup Server web-interface to add a TOTP factor.\n\nWebAuthn\n\nFor WebAuthn to work, you need to have two things:\n\n- a trusted HTTPS certificate (for example, by using Let's Encrypt)\n- setup the WebAuthn configuration (see **Configuration -> Authentication** in the Proxmox Backup Server web-interface). This can be auto-filled in most setups.\n\nOnce you have fulfilled both of these requirements, you can add a WebAuthn configuration in the **Access Control** panel.\nRecovery Keys\n\nRecovery key codes do not need any preparation; you can simply create a set of recovery keys in the Access Control panel.\n\n**Note:** There can only be one set of single-use recovery keys per user at any time.\n\n### 6.4.4 TFA and Automated Access\n\nTwo-factor authentication is only implemented for the web-interface. You should use **API Tokens** for all other use cases, especially non-interactive ones (for example, adding a Proxmox Backup Server to Proxmox VE as a storage).\nCHAPTER\nSEVEN\n\nBACKUP CLIENT USAGE\n\nThe command line client is called proxmox-backup-client.\n\n7.1 Backup Repository Locations\n\nThe client uses the following notation to specify a datastore repository on the backup server.\n\n```\n[[username@]server[:port]:]datastore\n```\n\nThe default value for username is root@pam. If no server is specified, the default is the local host (localhost).\n\nYou can specify a port if your backup server is only reachable on a different port (e.g. with NAT and port forwarding).\n\nNote that if the server is an IPv6 address, you have to write it with square brackets (for example, [fe80::01]).\n\nYou can pass the repository with the --repository command line option, or by setting the PBS_REPOSITORY environment variable.\n\nHere some examples of valid repositories and the real values\n\n<table>\n<thead>\n<tr>\n<th>Example</th>\n<th>User</th>\n<th>Host:Port</th>\n<th>Datastore</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>mydatastore</td>\n<td>root@pam</td>\n<td>localhost:8007</td>\n<td>mydatastore</td>\n</tr>\n<tr>\n<td>myhostname:mydatastore</td>\n<td>root@pam</td>\n<td>myhostname:8007</td>\n<td>mydatastore</td>\n</tr>\n<tr>\n<td>user@pbs@myhostname:mydatastore</td>\n<td>user@pbs</td>\n<td>myhostname:8007</td>\n<td>mydatastore</td>\n</tr>\n<tr>\n<td>user@pbs!token@host:store</td>\n<td>user@pbs!token</td>\n<td>myhostname:8007</td>\n<td>mydatastore</td>\n</tr>\n<tr>\n<td>192.168.55.55:1234:mydatastore</td>\n<td>root@pam</td>\n<td>192.168.55.55:1234</td>\n<td>mydatastore</td>\n</tr>\n<tr>\n<td>[ff80::51]:mydatastore</td>\n<td>root@pam</td>\n<td>[ff80::51]:8007</td>\n<td>mydatastore</td>\n</tr>\n<tr>\n<td>[ff80::51]:1234:mydatastore</td>\n<td>root@pam</td>\n<td>[ff80::51]:1234</td>\n<td>mydatastore</td>\n</tr>\n</tbody>\n</table>\n\n7.2 Environment Variables\n\nPBS_REPOSITORY The default backup repository.\nPBS_PASSWORD When set, this value is used for the password required for the backup server. You can also set this to a API token secret.\n\nPBS_ENCRYPTION_PASSWORD When set, this value is used to access the secret encryption key (if protected by password).\n\nPBS_FINGERPRINT When set, this value is used to verify the server certificate (only used if the system CA certificates cannot validate the certificate).\n\n7.3 Output Format\n\nMost commands producing output supports the --output-format parameter. It accepts the following values:\n\n- text Text format (default). Structured data is rendered as a table.\n- json JSON (single line).\n- json-pretty JSON (multiple lines, nicely formatted).\n\nAlso, the following environment variables can modify output behavior:\n\n- PROXMOX_OUTPUT_FORMAT Defines the default output format.\n- PROXMOX_OUTPUT_NO_BORDER If set (to any value), do not render table borders.\n- PROXMOX_OUTPUT_NO_HEADER If set (to any value), do not render table headers.\n\nNote: The text format is designed to be human readable, and not meant to be parsed by automation tools. Please use the json format if you need to process the output.\n\n7.4 Creating Backups\n\nThis section explains how to create a backup from within the machine. This can be a physical host, a virtual machine, or a container. Such backups may contain file and image archives. There are no restrictions in this case.\n\nNote: If you want to backup virtual machines or containers on Proxmox VE, see Proxmox VE Integration.\n\nFor the following example you need to have a backup server set up, working credentials and need to know the repository name. In the following examples we use backup-server:store1.\n\n```\n# proxmox-backup-client backup root.pxar:/ --repository backup-server:store1\nStarting backup: host/elsa/2019-12-03T09:35:01Z\nClient name: elsa\n skip mount point: \"/boot/efi\"\n skip mount point: \"dev\"\n skip mount point: \"/run\"\n skip mount point: \"/sys\"\n Uploaded 12129 chunks in 87 seconds (564 MB/s).\n End Time: 2019-12-03T10:36:29+01:00\n```\n\nThis will prompt you for a password and then uploads a file archive named root.pxar containing all the files in the / directory.\n**Caution:** Please note that the proxmox-backup-client does not automatically include mount points. Instead, you will see a short skip mount point notice for each of them. The idea is to create a separate file archive for each mounted disk. You can explicitly include them using the\n\n```\n--include-dev option (i.e. --include-dev /boot/efi)\n```\n\nYou can use this option multiple times for each mount point that should be included.\n\nThe `--repository` option can get quite long and is used by all commands. You can avoid having to enter this value by setting the environment variable `PBS_REPOSITORY`. Note that if you would like this to remain set over multiple sessions, you should instead add the below line to your `.bashrc` file.\n\n```bash\n# export PBS_REPOSITORY=backup-server:store1\n```\n\nAfter this you can execute all commands without specifying the `--repository` option.\n\nOne single backup is allowed to contain more than one archive. For example, if you want to backup two disks mounted at `/mnt/disk1` and `/mnt/disk2`:\n\n```bash\n# proxmox-backup-client backup disk1.pxar:/mnt/disk1 disk2.pxar:/mnt/disk2\n```\n\nThis creates a backup of both disks.\n\nThe backup command takes a list of backup specifications, which include the archive name on the server, the type of the archive, and the archive source at the client. The format is:\n\n```plaintext\n<archive-name>.<type>:<source-path>\n```\n\nCommon types are `.pxar` for file archives, and `.img` for block device images. To create a backup of a block device run the following command:\n\n```bash\n# proxmox-backup-client backup mydata.img:/dev/mylvm/mydata\n```\n\n### 7.4.1 Excluding files/folders from a backup\n\nSometimes it is desired to exclude certain files or folders from a backup archive. To tell the Proxmox Backup client when and how to ignore files and directories, place a text file called `.pxarexclude` in the filesystem hierarchy. Whenever the backup client encounters such a file in a directory, it interprets each line as glob match patterns for files and directories that are to be excluded from the backup.\n\nThe file must contain a single glob pattern per line. Empty lines are ignored. The same is true for lines starting with `#`, which indicates a comment. A `!` at the beginning of a line reverses the glob match pattern from an exclusion to an explicit inclusion. This makes it possible to exclude all entries in a directory except for a few single files/subdirectories. Lines ending in `/` match only on directories. The directory containing the `.pxarexclude` file is considered to be the root of the given patterns. It is only possible to match files in this directory and its subdirectories. \n\n```\n\\ is used to escape special glob characters. ? matches any single character. * matches any character, including an empty string. ** is used to match subdirectories. It can be used to, for example, exclude all files ending in `.tmp` within the directory or subdirectories with the following pattern `**/\\.*.tmp.\\[.\\[..\\] matches a single character from any of the provided characters within the brackets. ![\\[-9] matches any one single digit.\n```\n\nThe order of the glob match patterns defines whether a file is included or excluded, that is to say later entries override previous ones. This is also true for match patterns encountered deeper down the directory tree, which can override a previous exclusion. Be aware that excluded directories will not be read by the backup client. Thus, a `.pxarexclude` file in an excluded subdirectory will\nhave no effect. `.pxarexclude` files are treated as regular files and will be included in the backup archive.\n\nFor example, consider the following directory structure:\n\n```bash\n# ls -aR folder\nfolder/:\n .. .pxarexclude subfolder0 subfolder1\nfolder/subfolder0/:\n .. file0 file1 file2 file3 .pxarexclude\nfolder/subfolder1/:\n .. file0 file1 file2 file3\n```\n\nThe different `.pxarexclude` files contain the following:\n\n```bash\n# cat folder/.pxarexclude\n/subfolder0/file1\n/subfolder1/*!\n```\n\n```bash\n# cat folder/subfolder0/.pxarexclude\nfile3\n```\n\nThis would exclude `file1` and `file3` in `subfolder0` and all of `subfolder1` except `file2`.\n\nRestoring this backup will result in:\n\n```bash\nls -aR restored\nrestored/:\n .. .pxarexclude subfolder0 subfolder1\nrestored/subfolder0/:\n .. file0 file2 .pxarexclude\nrestored/subfolder1/:\n .. file2\n```\n\n### 7.5 Encryption\n\nProxmox Backup supports client-side encryption with AES-256 in GCM mode. To set this up, you first need to create an encryption key:\n\n```bash\n# proxmox-backup-client key create my-backup.key\nEncryption Key Password: **************\n```\n\nThe key is password protected by default. If you do not need this extra protection, you can also create it without a password:\n\n```bash\n# proxmox-backup-client key create /path/to/my-backup.key --kdf none\n```\n\nHaving created this key, it is now possible to create an encrypted backup, by passing the `--keyfile` parameter, with the path to the key file.\n\n```bash\n# proxmox-backup-client backup etc.pxa:/etc --keyfile /path/to/my-backup.key\nPassword: *********\nEncryption Key Password: **************\n```\n\n**Note:** If you do not specify the name of the backup key, the key will be created in the default location `~/.config/proxmox-backup/encryption-key.json`. `proxmox-backup-client` will also search this location by default, in case the `--keyfile` parameter is not specified.\nYou can avoid entering the passwords by setting the environment variables PBS_PASSWORD and PBS_ENCRYPTION_PASSWORD.\n\n7.5.1 Using a master key to store and recover encryption keys\n\nYou can also use `proxmox-backup-client` key to create an RSA public/private key pair, which can be used to store an encrypted version of the symmetric backup encryption key alongside each backup and recover it later.\n\nTo set up a master key:\n\n1. Create an encryption key for the backup:\n\n ```\n # proxmox-backup-client key create\n creating default key at: \"~/.config/proxmox-backup/encryption-key.json\"\n Encryption Key Password: *********\n ...\n ```\n\n The resulting file will be saved to `~/.config/proxmox-backup/encryption-key.json`.\n\n2. Create an RSA public/private key pair:\n\n ```\n # proxmox-backup-client key create-master-key\n Master Key Password: *********\n ...\n ```\n\n This will create two files in your current directory, `master-public.pem` and `master-private.pem`.\n\n3. Import the newly created `master-public.pem` public certificate, so that `proxmox-backup-client` can find and use it upon backup:\n\n ```\n # proxmox-backup-client key import-master-pubkey /path/to/master-public.pem\n Imported public master key to \"~/config/proxmox-backup/master-public.pem\"\n ```\n\n4. With all these files in place, run a backup job:\n\n ```\n # proxmox-backup-client backup etc.pzar:/etc\n ```\n\n The key will be stored in your backup, under the name `rsa-encrypted.key`.\n\n **Note:** The `--keyfile` parameter can be excluded, if the encryption key is in the default path. If you specified another path upon creation, you must pass the `--keyfile` parameter.\n\n5. To test that everything worked, you can restore the key from the backup:\n\n ```\n # proxmox-backup-client restore /path/to/backup/ rsa-encrypted.key /path/to/target\n ```\n\n **Note:** You should not need an encryption key to extract this file. However, if a key exists at the default location (`~/config/proxmox-backup/encryption-key.json`) the program will prompt you for an encryption key password. Simply moving `encryption-key.json` out of this directory will fix this issue.\n\n6. Then, use the previously generated master key to decrypt the file:\n\n ```\n # proxmox-backup-client key import-with-master-key /path/to/target --master-keyfile /path/to/master-private.pem --encrypted-keyfile /path/to/rsa-encrypted.key\n Master Key Password: *********\n New Password: *********\n Verify Password: *********\n ```\n\n7.5. Encryption\n7. The target file will now contain the encryption key information in plain text. The success of this can be confirmed by passing the resulting json file, with the --keyfile parameter, when decrypting files from the backup.\n\n**Warning:** Without their key, backed up files will be inaccessible. Thus, you should keep keys ordered and in a place that is separate from the contents being backed up. It can happen, for example, that you back up an entire system, using a key on that system. If the system then becomes inaccessible for any reason and needs to be restored, this will not be possible as the encryption key will be lost along with the broken system.\n\nIt is recommended that you keep your master key safe, but easily accessible, in order for quick disaster recovery. For this reason, the best place to store it is in your password manager, where it is immediately recoverable. As a backup to this, you should also save the key to a USB drive and store that in a secure place. This way, it is detached from any system, but is still easy to recover from, in case of emergency. Finally, in preparation for the worst case scenario, you should also consider keeping a paper copy of your master key locked away in a safe place. The paperkey subcommand can be used to create a QR encoded version of your master key. The following command sends the output of the paperkey command to a text file, for easy printing.\n\n```\nproxmox-backup-client key paperkey --output-format text > qrkey.txt\n```\n\n### 7.6 Restoring Data\n\nThe regular creation of backups is a necessary step to avoiding data loss. More importantly, however, is the restoration. It is good practice to perform periodic recovery tests to ensure that you can access the data in case of problems.\n\nFirst, you need to find the snapshot which you want to restore. The snapshot list command provides a list of all the snapshots on the server:\n\n```\n# proxmox-backup-client snapshot list\n\n<table>\n<thead>\n<tr>\n<th>snapshot</th>\n<th>size</th>\n<th>files</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>host/elsa/2019-12-03T09:15:30Z</td>\n<td>51788646825</td>\n<td>root.pxar catalog.pcat1 index.json</td>\n</tr>\n<tr>\n<td>host/elsa/2019-12-03T09:15:35:01Z</td>\n<td>51790622048</td>\n<td>root.pxar catalog.pcat1 index.json</td>\n</tr>\n<tr>\n<td>...</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n```\n\nYou can inspect the catalog to find specific files.\n\n```\n# proxmox-backup-client catalog dump host/elsa/2019-12-03T09:35:01Z\n... \n d \"/root.pxar.didx/etc/cifs-utils\"\n l \"./root.pxar.didx/etc/cifs-utils/idmap-plugin\"\n d \"/root.pxar.didx/etc/console-setup\"\n...\n```\n\nThe restore command lets you restore a single archive from the backup.\n\n```\n# proxmox-backup-client restore host/elsa/2019-12-03T09:35:01Z root.pxar /target/path/\n```\n\nTo get the contents of any archive, you can restore the index.json file in the repository to the target path `\"`. This will dump the contents to the standard output.\n\n```\n# proxmox-backup-client restore host/elsa/2019-12-03T09:35:01Z index.json -\n```\n7.6.1 Interactive Restores\n\nIf you only want to restore a few individual files, it is often easier to use the interactive recovery shell.\n\n```bash\n# proxmox-backup-client catalog shell host/elsa/2019-12-03T09:35:01Z root.pxar\nStarting interactive shell\npxar:/ > ls\nbin boot dev etc home lib lib32 ...\n```\n\nThe interactive recovery shell is a minimal command line interface that utilizes the metadata stored in the catalog to quickly list, navigate and search files in a file archive. To restore files, you can select them individually or match them with a glob pattern.\n\nUsing the catalog for navigation reduces the overhead considerably because only the catalog needs to be downloaded and, optionally, decrypted. The actual chunks are only accessed if the metadata in the catalog is not enough or for the actual restore.\n\nSimilar to common UNIX shells `cd` and `ls` are the commands used to change working directory and list directory contents in the archive. `pwd` shows the full path of the current working directory with respect to the archive root.\n\nBeing able to quickly search the contents of the archive is a commonly needed feature. That's where the catalog is most valuable. For example:\n\n```bash\npxar:/ > find etc/**/*.txt --select\n\"/etc/X11/rgb.txt\"\npxar:/ > list-selected\ntxt/**/*.txt\npxar:/ > restore-selected /target/path\n```\n\nThis will find and print all files ending in `.txt` located in `etc/` or a subdirectory and add the corresponding pattern to the list for subsequent restores. `list-selected` shows these patterns and `restore-selected` finally restores all files in the archive matching the patterns to `/target/path` on the local host. This will scan the whole archive.\n\nThe `restore` command can be used to restore all the files contained within the backup archive. This is most helpful when paired with the `--pattern <glob>` option, as it allows you to restore all files matching a specific pattern. For example, if you wanted to restore configuration files located in `/etc`, you could do the following:\n\n```bash\npxar:/ > restore target/ --pattern etc/**/*.conf\n```\n\nThe above will scan through all the directories below `/etc` and restore all files ending in `.conf`.\n\n7.6.2 Mounting of Archives via FUSE\n\nThe FUSE implementation for the pxar archive allows you to mount a file archive as a read-only filesystem to a mountpoint on your host.\n\n```bash\n# proxmox-backup-client mount host/backup-client/2020-01-29T11:29:22Z root.pxar /mnt/\n# ls /mnt/mountpoint\nbin dev home lib32 libx32 media opt root sbin sys usr\nboot etc lib lib64 lost+found mnt proc run srv tmp var\n```\n\nThis allows you to access the full contents of the archive in a seamless manner.\n\n**Note:** As the FUSE connection needs to fetch and decrypt chunks from the backup server's datastore, this can cause some additional network and CPU load on your host, depending on the oper-\nTo unmount the filesystem use the `umount` command on the mountpoint:\n\n```\n# umount /mnt/mountpoint\n```\n\n### 7.7 Login and Logout\n\nThe client tool prompts you to enter the logon password as soon as you want to access the backup server. The server checks your credentials and responds with a ticket that is valid for two hours. The client tool automatically stores that ticket and uses it for further requests to this server.\n\nYou can also manually trigger this login/logout using the `login` and `logout` commands:\n\n```\n# proxmox-backup-client login\nPassword: **********\n```\n\nTo remove the ticket, issue a logout:\n\n```\n# proxmox-backup-client logout\n```\n\n### 7.8 Changing the Owner of a Backup Group\n\nBy default, the owner of a backup group is the user which was used to originally create that backup group (or in the case of sync jobs, `root@pam`). This means that if a user `mike@pbs` created a backup, another user `john@pbs` can not be used to create backups in that same backup group. In case you want to change the owner of a backup, you can do so with the below command, using a user that has `Datastore.Modify` privileges on the datastore.\n\n```\n# proxmox-backup-client change-owner vm/103 john@pbs\n```\n\nThis can also be done from within the web interface, by navigating to the `Content` section of the datastore that contains the backup group and selecting the user icon under the `Actions` column. Common cases for this could be to change the owner of a sync job from `root@pam`, or to repurpose a backup group.\n\n### 7.9 Pruning and Removing Backups\n\nYou can manually delete a backup snapshot using the `forget` command:\n\n```\n# proxmox-backup-client snapshot forget <snapshot>\n```\n\n**Caution:** This command removes all archives in this backup snapshot. They will be inaccessible and unrecoverable.\n\nAlthough manual removal is sometimes required, the `prune` command is normally used to systematically delete older backups. Prune lets you specify which backup snapshots you want to keep. The following retention options are available:\n\n- `--keep-last <N>` Keep the last `<N>` backup snapshots.\n- `--keep-hourly <N>` Keep backups for the last `<N>` hours. If there is more than one backup for a single hour, only the latest is kept.\n--keep-daily <N> Keep backups for the last <N> days. If there is more than one backup for a single day, only the latest is kept.\n\n--keep-weekly <N> Keep backups for the last <N> weeks. If there is more than one backup for a single week, only the latest is kept.\n\nNote: Weeks start on Monday and end on Sunday. The software uses the ISO week date system and handles weeks at the end of the year correctly.\n\n--keep-monthly <N> Keep backups for the last <N> months. If there is more than one backup for a single month, only the latest is kept.\n\n--keep-yearly <N> Keep backups for the last <N> years. If there is more than one backup for a single year, only the latest is kept.\n\nThe retention options are processed in the order given above. Each option only covers backups within its time period. The next option does not take care of already covered backups. It will only consider older backups.\n\nUnfinished and incomplete backups will be removed by the prune command unless they are newer than the last successful backup. In this case, the last failed backup is retained.\n\n# proxmox-backup-client prune <group> --keep-daily 7 --keep-weekly 4 --keep-monthly 3\n\nYou can use the --dry-run option to test your settings. This only shows the list of existing snapshots and what actions prune would take.\n\n# proxmox-backup-client prune host/elsa --dry-run --keep-daily 1 --keep-weekly 3\n\nNote: Neither the prune command nor the forget command free space in the chunk-store. The chunk-store still contains the data blocks. To free space you need to perform Garbage Collection.\n\n7.10 Garbage Collection\n\nThe prune command removes only the backup index files, not the data from the datastore. This task is left to the garbage collection command. It is recommended to carry out garbage collection on a regular basis.\n\nThe garbage collection works in two phases. In the first phase, all data blocks that are still in use are marked. In the second phase, unused data blocks are removed.\n\nNote: This command needs to read all existing backup index files and touches the complete chunk-store. This can take a long time depending on the number of chunks and the speed of the underlying disks.\n**Note:** The garbage collection will only remove chunks that haven't been used for at least one day (exactly 24h 5m). This grace period is necessary because chunks in use are marked by touching the chunk which updates the atime (access time) property. Filesystems are mounted with the relatime option by default. This results in a better performance by only updating the atime property if the last access has been at least 24 hours ago. The downside is, that touching a chunk within these 24 hours will not always update its atime property.\n\nChunks in the grace period will be logged at the end of the garbage collection task as *Pending removals*.\n\n```\n# proxmox-backup-client garbage-collect\nstarting garbage collection on store store2\nStart GC phase1 (mark used chunks)\nStart GC phase2 (sweep unused chunks)\npercentage done: 1, chunk count: 219\npercentage done: 2, chunk count: 453\n....percentage done: 99, chunk count: 21188\nRemoved bytes: 411368505\nRemoved chunks: 203\nOriginal data bytes: 327160886391\nDisk bytes: 52767414743 (16 %)\nDisk chunks: 21221\nAverage chunk size: 2486565\nTASK OK\n```\n\n### 7.11 Benchmarking\n\nThe backup client also comes with a benchmarking tool. This tool measures various metrics relating to compression and encryption speeds. If a Proxmox Backup repository (remote or local) is specified, the TLS upload speed will get measured too.\n\nYou can run a benchmark using the benchmark subcommand of `proxmox-backup-client`:\n\n```\n# proxmox-backup-client benchmark\nUploaded 1517 chunks in 5 seconds.\nTime per request: 3309 microseconds.\nTLS speed: 1267.41 MB/s\nSHA256 speed: 2066.73 MB/s\nCompression speed: 775.11 MB/s\nDecompress speed: 1233.35 MB/s\nAES256/GCM speed: 3688.27 MB/s\nVerify speed: 783.43 MB/s\n```\n\n```\n+-----------------+-----------------+\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>TLS (maximal backup upload speed)</td>\n<td>1267.41 MB/s (103%)</td>\n</tr>\n<tr>\n<td>SHA256 checksum computation speed</td>\n<td>2066.73 MB/s (102%)</td>\n</tr>\n<tr>\n<td>ZStd level 1 compression speed</td>\n<td>775.11 MB/s (103%)</td>\n</tr>\n<tr>\n<td>ZStd level 1 decompression speed</td>\n<td>1233.35 MB/s (103%)</td>\n</tr>\n<tr>\n<td>Chunk verification speed</td>\n<td>783.43 MB/s (103%)</td>\n</tr>\n<tr>\n<td>AES256 GCM encryption speed</td>\n<td>3688.27 MB/s (101%)</td>\n</tr>\n</tbody>\n</table>\n```\n**Note:** The percentages given in the output table correspond to a comparison against a Ryzen 7 2700X.\n\nYou can also pass the **--output-format** parameter to output stats in **json**, rather than the default table format.\nA Proxmox Backup Server can be integrated into a Proxmox VE setup by adding the former as a storage in a Proxmox VE standalone or cluster setup.\n\nSee also the Proxmox VE Storage - Proxmox Backup Server section of the Proxmox VE Administration Guide for Proxmox VE specific documentation.\n\n8.1 Using the Proxmox VE Web-Interface\n\nProxmox VE has native API and web-interface integration of Proxmox Backup Server since the Proxmox VE 6.3 release.\nA Proxmox Backup Server can be added under Datacenter -> Storage.\n\n8.2 Using the Proxmox VE Command-Line\n\nYou need to define a new storage with type ‘pbs’ on your Proxmox VE node. The following example uses store2 as storage name, and assumes the server address is localhost, and you want to connect as user1@pbs.\n\n```bash\n# pvesm add pbs store2 --server localhost --datastore store2\n# pvesm set store2 --username user1@pbs --password <secret>\n```\n\nNote: If you would rather not pass your password as plain text, you can pass the --password parameter, without any arguments. This will cause the program to prompt you for a password upon entering the command.\n\nIf your backup server uses a self signed certificate, you need to add the certificate fingerprint to the configuration. You can get the fingerprint by running the following command on the backup server:\n\n```bash\n# proxmox-backup-manager cert info | grep Fingerprint\n```\n\nPlease add that fingerprint to your configuration to establish a trust relationship:\n\n```bash\n# pvesm set store2 --fingerprint 64:d3:ff:3a:50:38:53:5a:9b:f7:50:....:ab:fe\n```\n\nAfter that you should be able to see storage status with:\n\n```bash\n# pvesm status --storage store2\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Type</th>\n<th>Status</th>\n<th>Total</th>\n<th>Used</th>\n<th>Available</th>\n<th>%</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>store2</td>\n<td>pbs</td>\n<td>active</td>\n<td>3905190820</td>\n<td>133663816</td>\n<td>256842094</td>\n<td>34.23%</td>\n</tr>\n</tbody>\n</table>\n```\nHaving added the Proxmox Backup Server datastore to Proxmox VE, you can backup VMs and containers in the same way you would for any other storage device within the environment (see Proxmox VE Admin Guide: Backup and Restore.)\n**PXAR COMMAND LINE TOOL**\n\npxar is a command line utility to create and manipulate archives in the Proxmox File Archive Format (.pxar). It is inspired by casync file archive format, which caters to a similar use-case. The .pxar format is adapted to fulfill the specific needs of the Proxmox Backup Server, for example, efficient storage of hardlinks. The format is designed to reduce storage space needed on the server by achieving a high level of deduplication.\n\n### 9.1 Creating an Archive\n\nRun the following command to create an archive of a folder named source:\n\n```bash\n# pxar create archive.pxar /path/to/source\n```\n\nThis will create a new archive called `archive.pxar` with the contents of the source folder.\n\n**Note:** pxar will not overwrite any existing archives. If an archive with the same name is already present in the target folder, the creation will fail.\n\nBy default, pxar will skip certain mountpoints and will not follow device boundaries. This design decision is based on the primary use case of creating archives for backups. It makes sense to not back up the contents of certain temporary or system specific files. To alter this behavior and follow device boundaries, use the `--all-file-systems` flag.\n\nIt is possible to exclude certain files and/or folders from the archive by passing the `--exclude` parameter with gitignore-style match patterns.\n\nFor example, you can exclude all files ending in .txt from the archive by running:\n\n```bash\n# pxar create archive.pxar /path/to/source --exclude '**/*.txt'\n```\n\nBe aware that the shell itself will try to expand all of the glob patterns before invoking pxar. In order to avoid this, all globs have to be quoted correctly.\n\nIt is possible to pass the `--exclude` parameter multiple times, in order to match more than one pattern. This allows you to use more complex file exclusion/inclusion behavior. However, it is recommended to use .pxarexclude files instead for such cases.\n\nFor example you might want to exclude all .txt files except for a specific one from the archive. This is achieved via the negated match pattern, prefixed by !. All the glob patterns are relative to the source directory.\n\n```bash\n# pxar create archive.pxar /path/to/source --exclude '**/*.txt' --exclude '!/folder/file.txt'\n```\n\n**Note:** The order of the glob match patterns matters as later ones override previous ones. Permutations of the same patterns lead to different results.\npxar will store the list of glob match patterns passed as parameters via the command line, in a file called `.pxarexclude-cli` at the root of the archive. If a file with this name is already present in the source folder during archive creation, this file is not included in the archive and the file containing the new patterns is added to the archive instead, the original file is not altered.\n\nA more convenient and persistent way to exclude files from the archive is by placing the glob match patterns in `.pxarexclude` files. It is possible to create and place these files in any directory of the filesystem tree. These files must contain one pattern per line, again later patterns win over previous ones. The patterns control file exclusions of files present within the given directory or further below it in the tree. The behavior is the same as described in Creating Backups.\n\n### 9.2 Extracting an Archive\n\nAn existing archive, `archive.pxar`, is extracted to a target directory with the following command:\n\n```\n# pxar extract archive.pxar /path/to/target\n```\n\nIf no target is provided, the content of the archive is extracted to the current working directory.\n\nIn order to restore only parts of an archive, single files, and/or folders, it is possible to pass the corresponding glob match patterns as additional parameters or to use the patterns stored in a file:\n\n```\n# pxar extract etc.pxar /restore/target/etc --pattern '**/*.conf'\n```\n\nThe above example restores all `.conf` files encountered in any of the sub-folders in the archive `etc.pxar` to the target `/restore/target/etc`. A path to the file containing match patterns can be specified using the `--files-from` parameter.\n\n### 9.3 List the Contents of an Archive\n\nTo display the files and directories contained in an archive `archive.pxar`, run the following command:\n\n```\n# pxar list archive.pxar\n```\n\nThis displays the full path of each file or directory with respect to the archives root.\n\n### 9.4 Mounting an Archive\n\npxar allows you to mount and inspect the contents of an archive via FUSE. In order to mount an archive named `archive.pxar` to the mountpoint `/mnt`, run the command:\n\n```\n# pxar mount archive.pxar /mnt\n```\n\nOnce the archive is mounted, you can access its content under the given mountpoint.\n\n```\n# cd /mnt\n# ls\nbin dev home lib32 libx32 media opt root sbin sys usr\nboot etc lib lib64 lost+found mnt proc run srv tmp var\n```\nCaution: Tape Backup is a technical preview feature, not meant for production use.\n\nProxmox tape backup provides an easy way to store datastore content onto magnetic tapes. This increases data safety because you get:\n\n- an additional copy of the data,\n- on a different media type (tape),\n- to an additional location (you can move tapes off-site)\n\nIn most restore jobs, only data from the last backup job is restored. Restore requests further decline, the older the data gets. Considering this, tape backup may also help to reduce disk usage, because you can safely remove data from disk, once it’s archived on tape. This is especially true if you need to retain data for several years.\nTape backups do not provide random access to the stored data. Instead, you need to restore the data to disk, before you can access it again. Also, if you store your tapes off-site (using some kind of tape vaulting service), you need to bring them back on-site, before you can do any restores. So please consider that restoring from tape can take much longer than restoring from disk.\n\n10.1 Tape Technology Primer\n\nAs of 2021, the only widely available tape technology standard is Linear Tape-Open (LTO). Different vendors offer LTO Ultrium tape drives, auto-loaders, and LTO tape cartridges.\n\nThere are a few vendors that offer proprietary drives with slight advantages in performance and capacity. Nevertheless, they have significant disadvantages:\n\n- proprietary (single vendor)\n- a much higher purchase cost\n\nSo we currently do not test such drives.\n\nIn general, LTO tapes offer the following advantages:\n\n- Durability (30 year lifespan)\n- High Capacity (12 TB)\n- Relatively low cost per TB\n- Cold Media\n- Movable (storable inside vault)\n- Multiple vendors (for both media and drives)\n- Built in AES-GCM Encryption engine\n\nNote that Proxmox Backup Server already stores compressed data, so using the tape compression feature has no advantage.\n\n10.2 Supported Hardware\n\nProxmox Backup Server supports Linear Tape-Open generation 4 (LTO-4) or later.\n\nTape changing is carried out using the SCSI Medium Changer protocol, so all modern tape libraries should work.\n\n**Note:** We use a custom user space tape driver written in Rust. This driver directly communicates with the tape drive using the SCSI generic interface. This may have negative side effects when used with the old Linux kernel tape driver, so you should not use that driver with Proxmox tape backup.\n\n10.2.1 Drive Performance\n\nCurrent LTO-8 tapes provide read/write speeds of up to 360 MB/s. This means, that it still takes a minimum of 9 hours to completely write or read a single tape (even at maximum speed).\n\nThe only way to speed that data rate up is to use more than one drive. That way, you can run several backup jobs in parallel, or run restore jobs while the other dives are used for backups.\n\nAlso consider that you first need to read data from your datastore (disk). However, a single spinning disk is unable to deliver data at this rate. We measured a maximum rate of about 60MB/s\nto 100MB/s in practice, so it takes 33 hours to read the 12TB needed to fill up an LTO-8 tape. If you want to write to your tape at full speed, please make sure that the source datastore is able to deliver that performance (for example, by using SSDs).\n\n10.3 Terminology\n\n**Tape Labels:** are used to uniquely identify a tape. You would normally apply a sticky paper label to the front of the cartridge. We additionally store the label text magnetically on the tape (first file on tape).\n\n**Barcodes:** are a special form of tape labels, which are electronically readable. Most LTO tape robots use an 8 character string encoded as Code 39, as defined in the LTO Ultrium Cartridge Label Specification.\n\nYou can either buy such barcode labels from your cartridge vendor, or print them yourself. You can use our LTO Barcode Generator app, if you would like to print them yourself.\n\n**Note:** Physical labels and the associated adhesive should have an environmental performance to match or exceed the environmental specifications of the cartridge to which it is applied.\n\n**Media Pools:** A media pool is a logical container for tapes. A backup job targets one media pool, so a job only uses tapes from that pool. The pool additionally defines how long a backup job can append data to tapes (allocation policy) and how long you want to keep the data (retention policy).\n\n**Media Set:** A group of continuously written tapes (all from the same media pool).\n\n**Tape drive:** The device used to read and write data to the tape. There are standalone drives, but drives are usually shipped within tape libraries.\n\n**Tape changer:** A device which can change the tapes inside a tape drive (tape robot). They are usually part of a tape library.\n\n**Tape library:** A storage device that contains one or more tape drives, a number of slots to hold tape cartridges, a barcode reader to identify tape cartridges, and an automated method for loading tapes (a robot).\n\nThis is also commonly known as an ‘autoloader’, ‘tape robot’ or ‘tape jukebox’.\n\n**Inventory:** The inventory stores the list of known tapes (with additional status information).\n\n**Catalog:** A media catalog stores information about the media content.\n\n10.4 Tape Quick Start\n\n1. Configure your tape hardware (drives and changers)\n2. Configure one or more media pools\n3. Label your tape cartridges\n4. Start your first tape backup job ...\n10.5 Configuration\n\nPlease note that you can configure anything using the graphical user interface or the command line interface. Both methods result in the same configuration.\n\n10.5.1 Tape changers\n\nTape changers (robots) are part of a Tape Library. They contain a number of slots to hold tape cartridges, a barcode reader to identify tape cartridges and an automated method for loading tapes.\n\nYou can skip this step if you are using a standalone drive.\n\nLinux is able to auto detect these devices, and you can get a list of available devices using:\n\n```\n# proxmox-tape changer scan\n```\n\n<table>\n<thead>\n<tr>\n<th>path</th>\n<th>vendor</th>\n<th>model</th>\n<th>serial</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>/dev/tape/by-id/scsi-CC2C52</td>\n<td>Quantum</td>\n<td>Superloader3</td>\n<td>CC2C52</td>\n</tr>\n</tbody>\n</table>\n\nIn order to use a device with Proxmox Backup Server, you need to create a configuration entry:\n\n```\n# proxmox-tape changer create sl3 --path /dev/tape/by-id/scsi-CC2C52\n```\n\nWhere sl3 is an arbitrary name you can choose.\n\n**Note:** Please use the persistent device path names from inside /dev/tape/by-id/. Names like /dev/sg0 may point to a different device after reboot, and that is not what you want.\nThis operation can also be carried out from the GUI, by navigating to the **Changers** tab of **Tape Backup** and clicking **Add**.\n\nYou can display the final configuration with:\n\n```\n# proxmox-tape changer config sl3\n```\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>name</td>\n<td>sl3</td>\n</tr>\n<tr>\n<td>path</td>\n<td>/dev/tape/by-id/scsi-CC2C52</td>\n</tr>\n</tbody>\n</table>\n\nOr simply list all configured changer devices (as seen in the **Changers** tab of the GUI):\n\n```\n# proxmox-tape changer list\n```\n\n<table>\n<thead>\n<tr>\n<th>name</th>\n<th>path</th>\n<th>vendor</th>\n<th>model</th>\n<th>serial</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>sl3</td>\n<td>/dev/tape/by-id/scsi-CC2C52</td>\n<td>Quantum</td>\n<td>Superloader3</td>\n<td>CC2C52</td>\n</tr>\n</tbody>\n</table>\n\nThe Vendor, Model and Serial number are auto-detected, but only shown if the device is online.\n\nTo test your setup, please query the status of the changer device with:\n\n```\n# proxmox-tape changer status sl3\n```\n\n<table>\n<thead>\n<tr>\n<th>entry-kind</th>\n<th>entry-id</th>\n<th>changer-id</th>\n<th>loaded-slot</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>drive</td>\n<td>0</td>\n<td>vtape1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>slot</td>\n<td>1</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>slot</td>\n<td>2</td>\n<td>vtape2</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>...</td>\n<td>...</td>\n<td></td>\n</tr>\n<tr>\n<td>slot</td>\n<td>16</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTape libraries usually provide some special import/export slots (also called “mail slots”). Tapes inside those slots are accessible from outside, making it easy to add/remove tapes to/from the library. Those tapes are considered to be “offline”, so backup jobs will not use them. Those special slots are auto-detected and marked as an import-export slot in the status command.\n\nIt’s worth noting that some of the smaller tape libraries don’t have such slots. While they have something called a “Mail Slot”, that slot is just a way to grab the tape from the gripper. They are unable to hold media while the robot does other things. They also do not expose that “Mail Slot” over the SCSI interface, so you won’t see them in the status output.\n\nAs a workaround, you can mark some of the normal slots as export slot. The software treats those slots like real import-export slots, and the media inside those slots are considered to be ‘offline’ (not available for backup):\n\n```\n# proxmox-tape changer update sl3 --export-slots 15,16\n```\n\nAfter that, you can see those artificial import-export slots in the status output:\n# proxmox-tape changer status sl3\n\n<table>\n<thead>\n<tr>\n<th>entry-kind</th>\n<th>entry-id</th>\n<th>changer-id</th>\n<th>loaded-slot</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>drive</td>\n<td>0</td>\n<td>vtapel</td>\n<td>1</td>\n</tr>\n<tr>\n<td>import-export</td>\n<td>15</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>import-export</td>\n<td>16</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>slot</td>\n<td>1</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>slot</td>\n<td>2</td>\n<td>vtapel</td>\n<td></td>\n</tr>\n<tr>\n<td>...</td>\n<td>...</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>slot</td>\n<td>14</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n## 10.5.2 Tape drives\n\nLinux is able to auto detect tape drives, and you can get a list of available tape drives using:\n\n```\n# proxmox-tape drive scan\n```\n\n<table>\n<thead>\n<tr>\n<th>path</th>\n<th>vendor</th>\n<th>model</th>\n<th>serial</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>/dev/tape/by-id/scsi-12345-sg</td>\n<td>IBM</td>\n<td>ULT3500-TD4</td>\n<td>12345</td>\n</tr>\n</tbody>\n</table>\nIn order to use that drive with Proxmox, you need to create a configuration entry. This can be done through **Tape Backup -> Drives** in the GUI or by using the command below:\n\n```\n# proxmox-tape drive create mydrive --path /dev/tape/by-id/scsi-12345-sg\n```\n\n**Note:** Please use the persistent device path names from inside /dev/tape/by-id/. Names like /dev/sg0 may point to a different device after reboot, and that is not what you want.\n\nIf you have a tape library, you also need to set the associated changer device:\n\n```\n# proxmox-tape drive update mydrive --changer sl3 --changer-drivenum 0\n```\n\nThe **--changer-drivenum** is only necessary if the tape library includes more than one drive (the changer status command lists all drive numbers).\n\nYou can display the final configuration with:\n\n```\n# proxmox-tape drive config mydrive\n```\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>name</td>\n<td>mydrive</td>\n</tr>\n<tr>\n<td>path</td>\n<td>/dev/tape/by-id/scsi-12345-sg</td>\n</tr>\n<tr>\n<td>changer</td>\n<td>sl3</td>\n</tr>\n</tbody>\n</table>\n\n**Note:** The changer-drivenum value 0 is not stored in the configuration, because it is the default.\n\nTo list all configured drives use:\n\n```\n# proxmox-tape drive list\n```\n\n<table>\n<thead>\n<tr>\n<th>name</th>\n<th>path</th>\n<th>changer</th>\n<th>vendor</th>\n<th>model</th>\n<th>serial</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>mydrive</td>\n<td>/dev/tape/by-id/scsi-12345-sg</td>\n<td>sl3</td>\n<td>IBM</td>\n<td>ULT3580-TD4</td>\n<td>12345</td>\n</tr>\n</tbody>\n</table>\n\nThe Vendor, Model and Serial number are auto detected and only shown if the device is online.\n\nFor testing, you can simply query the drive status with:\n\n```\n# proxmox-tape status --drive mydrive\n```\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>blocksize</td>\n<td>0</td>\n</tr>\n<tr>\n<td>density</td>\n<td>LTO4</td>\n</tr>\n<tr>\n<td>compression</td>\n<td>1</td>\n</tr>\n<tr>\n<td>buffer-mode</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>\nNote: Blocksize should always be 0 (variable block size mode). This is the default anyway.\n\n10.5.3 Media Pools\n\nA media pool is a logical container for tapes. A backup job targets a single media pool, so a job only uses tapes from that pool.\nMedia Set\n\nA media set is a group of continuously written tapes, used to split the larger pool into smaller, restorable units. One or more backup jobs write to a media set, producing an ordered group of tapes. Media sets are identified by a unique ID. That ID and the sequence number are stored on each tape of that set (tape label).\n\nMedia sets are the basic unit for restore tasks. This means that you need every tape in the set to restore the media set contents. Data is fully deduplicated inside a media set.\n\nMedia Set Allocation Policy\n\nThe pool additionally defines how long backup jobs can append data to a media set. The following settings are possible:\n\n- **Try to use the current media set (continue).**\n \n This setting produces one large media set. While this is very space efficient (deduplication, no unused space), it can lead to long restore times, because restore jobs need to read all tapes in the set.\n\n **Note:** Data is fully deduplicated inside a media set. This also means that data is randomly distributed over the tapes in the set. Thus, even if you restore a single VM, data may have to be read from all tapes inside the media set.\n\n Larger media sets are also more error-prone, because a single damaged tape makes the restore fail.\n\nUsage scenario: Mostly used with tape libraries. You manually trigger new set creation by running a backup job with the **--export** option.\n\n **Note:** Retention period starts with the existence of a newer media set.\n\n- **Always create a new media set (always).**\n \n With this setting, each backup job creates a new media set. This is less space efficient, because the media from the last set may not be fully written, leaving the remaining space unused.\n\n The advantage is that this produces media sets of minimal size. Small sets are easier to handle, can be moved more conveniently to an off-site vault, and can be restored much faster.\n\n **Note:** Retention period starts with the creation time of the media set.\n\n- **Create a new set when the specified Calendar Event triggers.**\n \n This allows you to specify points in time by using systemd like Calendar Event specifications (see systemd.time manpage).\n\n For example, the value weekly (or **Mon *-*-* 00:00:00**) will create a new set each week. This balances between space efficiency and media count.\n\n **Note:** Retention period starts when the calendar event triggers.\nAdditionally, the following events may allocate a new media set:\n• Required tape is offline (and you use a tape library).\n• Current set contains damaged or retired tapes.\n• Media pool encryption has changed\n• Database consistency errors, for example, if the inventory does not contain the required media information, or it contains conflicting information (outdated data).\n\nRetention Policy\nDefines how long we want to keep the data.\n• Always overwrite media.\n• Protect data for the duration specified.\n We use systemd like time spans to specify durations, e.g. 2 weeks (see systemd.time manpage).\n• Never overwrite data.\n\nHardware Encryption\nLTO-4 (or later) tape drives support hardware encryption. If you configure the media pool to use encryption, all data written to the tapes is encrypted using the configured key.\nThis way, unauthorized users cannot read data from the media, for example, if you loose a tape while shipping to an offsite location.\n\nNote: If the backup client also encrypts data, data on the tape will be double encrypted.\n\nThe password protected key is stored on each medium, so that it is possible to restore the key using the password. Please make sure to remember the password, in case you need to restore the key.\n\nNote: We use global content namespace, meaning we do not store the source datastore name. Because of this, it is impossible to distinguish store1:/vm/100 from store2:/vm/100. Please use different media pools if the sources are from different namespaces with conflicting names (for example, if the sources are from different Proxmox VE clusters).\n\nTo create a new media pool, add one from Tape Backup -> Media Pools in the GUI, or enter the following command:\n// proxmox-tape pool create <name> --drive <string> [OPTIONS]\n# proxmox-tape pool create daily --drive mydrive\n\nAdditional options can be set later, using the update command:\n\n# proxmox-tape pool update daily --allocation daily --retention 7days\n\nTo list all configured pools use:\n\n# proxmox-tape pool list\n\n<table>\n<thead>\n<tr>\n<th>name</th>\n<th>drive</th>\n<th>allocation</th>\n<th>retention</th>\n<th>template</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>daily</td>\n<td>mydrive</td>\n<td>daily</td>\n<td>7days</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n10.5.4 Tape Backup Jobs\n\nTo automate tape backup, you can configure tape backup jobs which write datastore content to a media pool, based on a specific time schedule. The required settings are:\n\n- **store**: The datastore you want to backup\n- **pool**: The media pool - only tape cartridges from that pool are used.\n- **drive**: The tape drive.\n- **schedule**: Job schedule (see *Calendar Events*)\n\nFor example, to configure a tape backup job for datastore `vmstore1` use:\nThe backup includes all snapshots from a backup group by default. You can set the latest-only flag to include only the latest snapshots:\n\n```bash\n# proxmox-tape backup-job update job2 --latest-only\n```\n\nBackup jobs can use email to send tape request notifications or report errors. You can set the notification user with:\n\n```bash\n# proxmox-tape backup-job update job2 --notify-user root@pam\n```\n\n**Note:** The email address is a property of the user (see User Management).\n\nIt is sometimes useful to eject the tape from the drive after a backup. For a standalone drive, the `eject-media` option ejects the tape, making sure that the following backup cannot use the tape (unless someone manually loads the tape again). For tape libraries, this option unloads the tape to a free slot, which provides better dust protection than inside a drive:\n\n```bash\n# proxmox-tape backup-job update job2 --eject-media\n```\n\n**Note:** For failed jobs, the tape remains in the drive.\n\nFor tape libraries, the `export-media` option moves all tapes from the media set to an export slot, making sure that the following backup cannot use the tapes. An operator can pick up those tapes and move them to a vault.\n\n```bash\n# proxmox-tape backup-job update job2 --export-media\n```\n\n**Note:** The `export-media` option can be used to force the start of a new media set, because tapes from the current set are no longer online.\n\nIt is also possible to run backup jobs manually:\n\n```bash\n# proxmox-tape backup-job run job2\n```\n\nTo remove a job, please use:\n\n```bash\n# proxmox-tape backup-job remove job2\n```\n\nThis same functionality also exists in the GUI, under the **Backup Jobs** tab of **Tape Backup**, where **Local Datastore** relates to the datastore you want to backup and **Media Pool** is the pool to back up to.\n10.6 Administration\n\nMany sub-commands of the proxmox-tape command line tools take a parameter called --drive, which specifies the tape drive you want to work on. For convenience, you can set this in an environment variable:\n\n```bash\n# export PROXMOX_TAPE_DRIVE=mydrive\n```\n\nYou can then omit the --drive parameter from the command. If the drive has an associated changer device, you may also omit the changer parameter from commands that need a changer device, for example:\n\n```bash\n# proxmox-tape changer status\n```\n\nshould display the changer status of the changer device associated with drive mydrive.\n\n10.6.1 Label Tapes\n\nBy default, tape cartridges all look the same, so you need to put a label on them for unique identification. First, put a sticky paper label with some human readable text on the cartridge.\n\nIf you use a Tape Library, you should use an 8 character string encoded as Code 39, as defined in the LTO Ultrium Cartridge Label Specification. You can either buy such barcode labels from your cartridge vendor, or print them yourself. You can use our LTO Barcode Generator app to print them.\n\nNext, you need to write that same label text to the tape, so that the software can uniquely identify the tape too.\n\nFor a standalone drive, manually insert the new tape cartridge into the drive and run:\n\n```bash\n# proxmox-tape label --changer-id <label-text> [--pool <pool-name>]\n```\n\nYou may omit the --pool argument to allow the tape to be used by any pool.\n\n**Note:** For safety reasons, this command fails if the tape contains any data. If you want to overwrite it anyway, erase the tape first.\n\nYou can verify success by reading back the label:\n\n```bash\n# proxmox-tape read-label\n```\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>changer-id</td>\n<td>vtape1</td>\n</tr>\n<tr>\n<td>uuid</td>\n<td>7f42c4dd-9626-4d89-9f2b-c7bc6da7d533</td>\n</tr>\n<tr>\n<td>ctime</td>\n<td>Wed Jan 6 09:07:51 2021</td>\n</tr>\n<tr>\n<td>pool</td>\n<td>daily</td>\n</tr>\n<tr>\n<td>media-set-uuid</td>\n<td>00000000-0000-0000-0000-0000000000000000</td>\n</tr>\n<tr>\n<td>media-set-ctime</td>\n<td>Wed Jan 6 09:07:51 2021</td>\n</tr>\n</tbody>\n</table>\n\n**Note:** The media-set-uuid using all zeros indicates an empty tape (not used by any media set).\n\nIf you have a tape library, apply the sticky barcode label to the tape cartridges first. Then load those empty tapes into the library. You can then label all unlabeled tapes with a single command:\n10.6.2 Run Tape Backups\n\nTo manually run a backup job click Run Now in the GUI or use the command:\n\n```\n# proxmox-tape barcode-label [-pool <pool-name>]\n```\n\nThe following options are available:\n\n- `--eject-media` Eject media upon job completion. It is normally good practice to eject the tape after use. This unmounts the tape from the drive and prevents the tape from getting dusty.\n\n- `--export-media-set` Export media set upon job completion. After a successful backup job, this moves all tapes from the used media set into import-export slots. The operator can then pick up those tapes and move them to a media vault.\n\n10.6.3 Restore from Tape\n\nRestore is done at media-set granularity, so you first need to find out which media set contains the data you want to restore. This information is stored in the media catalog. If you do not have media catalogs, you need to restore them first. Please note that you need the catalog to find your data, but restoring a complete media-set does not need media catalogs.\n\nThe following command lists the media content (from catalog):\n\n```\n# proxmox-tape media content\n```\n\n<table>\n<thead>\n<tr>\n<th>label-text</th>\n<th>pool</th>\n<th>media-set-name</th>\n<th>seq-nr</th>\n<th>snapshot</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n</tr>\n</tbody>\n</table>\n\nA restore job reads the data from the media set and moves it back to data disk (datastore):\n\n```\n// proxmox-tape restore <media-set-uuid> <datastore>\n```\n\n```\n# proxmox-tape restore 9da37a55-aac7-4deb-91c6-482b3b675f30 mystore\n```\nProxmox Backup Server also provides an interface for handling encryption keys on the backup server. Encryption keys can be managed from the Tape Backup -> Encryption Keys section of the GUI or through the `proxmox-tape key` command line tool. To create a new encryption key from the command line:\n\n```\n# proxmox-tape key create --hint \"tape pw 2020\"\n```\n\nTape Encryption Key Password: **********\nVerify Password: **********\n\n```\n...\n```\n\nList existing encryption keys:\n\n```\n# proxmox-tape key list\n\n<table>\n<thead>\n<tr>\n<th>fingerprint</th>\n<th>hint</th>\n</tr>\n</thead>\n</table>\n```\n\nTo show encryption key details:\n\n```\n```\n\n(continues on next page)\nThe `paperkey` subcommand can be used to create a QR encoded version of a tape encryption key. The following command sends the output of the `paperkey` command to a text file, for easy printing:\n\n```\nproxmox-tape key paperkey <fingerprint> --output-format text > qrkey.txt\n```\n\n### Restoring Encryption Keys\n\nYou can restore the encryption key from the tape, using the password used to generate the key. First, load the tape you want to restore into the drive. Then run:\n\n```\n# proxmox-tape key restore\nTape Encryption Key Password: ***********\n```\n\nIf the password is correct, the key will get imported to the database. Further restore jobs automatically use any available key.\n\n### 10.6.7 Tape Cleaning\n\nLTO tape drives require regular cleaning. This is done by loading a cleaning cartridge into the drive, which is a manual task for standalone drives.\n\nFor tape libraries, cleaning cartridges are identified using special labels starting with letters \"CLN\". For example, our tape library has a cleaning cartridge inside slot 3:\n\n```\n# proxmox-tape changer status sl3\n```\n\n<table>\n<thead>\n<tr>\n<th>entry-kind</th>\n<th>entry-id</th>\n<th>changer-id</th>\n<th>loaded-slot</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>drive</td>\n<td>0</td>\n<td>vtape1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>slot</td>\n<td>1</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>slot</td>\n<td>2</td>\n<td>vtape2</td>\n<td></td>\n</tr>\n<tr>\n<td>slot</td>\n<td>3</td>\n<td>CLN001CU</td>\n<td></td>\n</tr>\n<tr>\n<td>...</td>\n<td>...</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTo initiate a cleaning operation simply run:\n\n```\n# proxmox-tape clean\n```\n\nThis command does the following:\n\n- find the cleaning tape (in slot 3)\n- unload the current media from the drive (back to slot 1)\n- load the cleaning tape into the drive\n• run drive cleaning operation\n• unload the cleaning tape (to slot 3)\nMANAGING REMOTES\n\n11.1 Remote\n\nA remote refers to a separate Proxmox Backup Server installation and a user on that installation, from which you can sync datastores to a local datastore with a Sync Job. You can configure remotes in the web interface, under Configuration -> Remotes. Alternatively, you can use the remote subcommand. The configuration information for remotes is stored in the file /etc/proxmox-backup/remote.cfg.\n\nTo add a remote, you need its hostname or IP, a userid and password on the remote, and its certificate fingerprint. To get the fingerprint, use the proxmox-backup-manager cert info command on the remote, or navigate to Dashboard in the remote's web interface and select Show Fingerprint.\n\n```\n# proxmox-backup-manager cert info | grep Fingerprint\n```\n\nUsing the information specified above, you can add a remote from the Remotes configuration panel, or by using the command:\n\n```\n# proxmox-backup-manager remote create pbs2 --host pbs2.mydomain.example --userid sync@pam --password 'SECRET' --fingerprint 64:d3:ff:3a:50:38:53:5a:9b:f7:50:....:ab:fe\n```\n\nUse the list, show, update, remove subcommands of proxmox-backup-manager remote to manage your remotes:\n\n```\n# proxmox-backup-manager remote update pbs2 --host pbs2.example\n# proxmox-backup-manager remote list\n<table>\n<thead>\n<tr>\n<th>name</th>\n<th>host</th>\n<th>userid</th>\n<th>fingerprint</th>\n<th>comment</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>pbs2</td>\n<td>pbs2.example</td>\n<td>sync@pam</td>\n<td>64:d3:ff:3a:50:38:53:5a:9b:f7:50:....:ab:fe</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n```\n\n```\n# proxmox-backup-manager remote remove pbs2\n```\nSync jobs are configured to pull the contents of a datastore on a Remote to a local datastore. You can manage sync jobs in the web interface, from the Sync Jobs tab of the datastore which you’d like to set one up for, or using the proxmox-backup-manager sync-job command. The configuration information for sync jobs is stored at /etc/proxmox-backup/sync.cfg. To create a new sync job, click the add button in the GUI, or use the create subcommand. After creating a sync job, you can either start it manually from the GUI or provide it with a schedule (see Calendar Events) to run regularly.\n\nFor setting up sync jobs, the configuring user needs the following permissions:\n1. Remote.Read on the /remote/{remote}/{remote-store} path\n2. at least Datastore.Backup on the local target datastore (/datastore/{store})\n\nIf the remove-vanished option is set, Datastore.Prune is required on the local datastore as well. If the owner option is not set (defaulting to root@pam) or set to something other than the configuring user, Datastore.Modify is required as well.\n\nNote: A sync job can only sync backup groups that the configured remote’s user/API token can read. If a remote is configured with a user/API token that only has Datastore.Backup privileges, only the limited set of accessible snapshots owned by that user/API token can be synced.\n12.1 Pruning\n\nPrune lets you specify which backup snapshots you want to keep. The following retention options are available:\n\n**keep-last** <N> Keep the last <N> backup snapshots.\n\n**keep-hourly** <N> Keep backups for the last <N> hours. If there is more than one backup for a single hour, only the latest is kept.\n\n**keep-daily** <N> Keep backups for the last <N> days. If there is more than one backup for a single day, only the latest is kept.\n\n**keep-weekly** <N> Keep backups for the last <N> weeks. If there is more than one backup for a single week, only the latest is kept.\n\n**keep-monthly** <N> Keep backups for the last <N> months. If there is more than one backup for a single month, only the latest is kept.\n\n**keep-yearly** <N> Keep backups for the last <N> years. If there is more than one backup for a single year, only the latest is kept.\n\nThe retention options are processed in the order given above. Each option only covers backups within its time period. The next option does not take care of already covered backups. It will only consider older backups.\n\nUnfinished and incomplete backups will be removed by the prune command unless they are newer than the last successful backup. In this case, the last failed backup is retained.\n\n12.1.1 Prune Simulator\n\nYou can use the built-in prune simulator to explore the effect of different retention options with various backup schedules.\n12.1.2 Manual Pruning\n\nTo access pruning functionality for a specific backup group, you can use the prune command line option discussed in *Pruning and Removing Backups*, or navigate to the **Content** tab of the datastore and click the scissors icon in the **Actions** column of the relevant backup group.\n\n12.1.3 Prune Schedules\n\nTo prune on a datastore level, scheduling options can be found under the **Prune & GC** tab of the datastore. Here you can set retention settings and edit the interval at which pruning takes place.\n12.1.4 Retention Settings Example\n\nThe backup frequency and retention of old backups may depend on how often data changes, and how important an older state may be, in a specific work load. When backups act as a company's document archive, there may also be legal requirements for how long backup snapshots must be kept.\n\nFor this example, we assume that you are doing daily backups, have a retention period of 10 years, and the period between backups stored gradually grows.\n\n- **keep-last**: 3 - even if only daily backups, an admin may want to create an extra one just before or after a big upgrade. Setting keep-last ensures this.\n- **keep-hourly**: not set - for daily backups this is not relevant. You cover extra manual backups already, with keep-last.\n- **keep-daily**: 13 - together with keep-last, which covers at least one day, this ensures that you have at least two weeks of backups.\n- **keep-weekly**: 8 - ensures that you have at least two full months of weekly backups.\n- **keep-monthly**: 11 - together with the previous keep settings, this ensures that you have at least a year of monthly backups.\n- **keep-yearly**: 9 - this is for the long term archive. As you covered the current year with the previous options, you would set this to nine for the remaining ones, giving you a total of at least 10 years of coverage.\n\nWe recommend that you use a higher retention period than is minimally required by your environment; you can always reduce it if you find it is unnecessarily high, but you cannot recreate backup snapshots from the past.\n\n12.2 Garbage Collection\n\nYou can monitor and run garbage collection on the Proxmox Backup Server using the garbage-collection subcommand of proxmox-backup-manager. You can use the start sub-command to manually start garbage collection on an entire datastore and the status sub-command to see attributes relating to the garbage collection.\n\nThis functionality can also be accessed in the GUI, by navigating to Prune & GC from the top panel. From here, you can edit the schedule at which garbage collection runs and manually start the operation.\n\n12.3 Verification\n\nProxmox Backup offers various verification options to ensure that backup data is intact. Verification is generally carried out through the creation of verify jobs. These are scheduled tasks that run verification at a given interval (see Calendar Events). With these, you can set whether already verified snapshots are ignored, as well as set a time period, after which verified jobs are checked again. The interface for creating verify jobs can be found under the Verify Jobs tab of the datastore.\n\n12.2. Garbage Collection 73\nNote: It is recommended that you reverify all backups at least monthly, even if a previous verification was successful. This is because physical drives are susceptible to damage over time, which can cause an old, working backup to become corrupted in a process known as bit rot/data degradation. It is good practice to have a regularly recurring (hourly/daily) verification job, which checks new and expired backups, then another weekly/monthly job that will reverify everything. This way, there will be no surprises when it comes to restoring data.\n\nAside from using verify jobs, you can also run verification manually on entire datastores, backup groups, or snapshots. To do this, navigate to the Content tab of the datastore and either click Verify All, or select the V. icon from the Actions column in the table.\n\n12.4 Notifications\n\nProxmox Backup Server can send you notification emails about automatically scheduled verification, garbage-collection and synchronization tasks results.\n\nBy default, notifications are send to the email address configured for the root@pam user. You can set that user for each datastore.\n\nYou can also change the level of notification received per task type, the following options are available:\n\n• Always: send a notification for any scheduled task, independent of the outcome\n• Errors: send a notification for any scheduled task resulting in an error\n• Never: do not send any notification at all\nProxmox Backup is based on the famous Debian Linux distribution. That means that you have access to the whole world of Debian packages, and the base system is well documented. The Debian Administrator's Handbook is available online, and provides a comprehensive introduction to the Debian operating system.\n\nA standard Proxmox Backup installation uses the default repositories from Debian, so you get bug fixes and security updates through that channel. In addition, we provide our own package repository to roll out all Proxmox related packages. This includes updates to some Debian packages when necessary.\n\nWe also deliver a specially optimized Linux kernel, where we enable all required virtualization and container features. That kernel includes drivers for ZFS, and several hardware drivers. For example, we ship Intel network card drivers to support their newest hardware.\n\nThe following sections will concentrate on backup related topics. They either explain things which are different on Proxmox Backup, or tasks which are commonly used on Proxmox Backup. For other topics, please refer to the standard Debian documentation.\n\n13.1 ZFS on Linux\n\nZFS is a combined file system and logical volume manager designed by Sun Microsystems. There is no need to manually compile ZFS modules - all packages are included.\n\nBy using ZFS, it's possible to achieve maximum enterprise features with low budget hardware, but also high performance systems by leveraging SSD caching or even SSD only setups. ZFS can replace cost intense hardware raid cards by moderate CPU and memory load combined with easy management.\n\nGeneral ZFS advantages\n\n- Easy configuration and management with GUI and CLI.\n- Reliable\n- Protection against data corruption\n- Data compression on file system level\n- Snapshots\n- Copy-on-write clone\n- Various raid levels: RAID0, RAID1, RAID10, RAIDZ-1, RAIDZ-2 and RAIDZ-3\n- Can use SSD for cache\n- Self healing\n- Continuous integrity checking\n- Designed for high storage capacities\n• Asynchronous replication over network\n• Open Source\n• Encryption\n\n13.1.1 Hardware\n\nZFS depends heavily on memory, so you need at least 8GB to start. In practice, use as much you can get for your hardware/budget. To prevent data corruption, we recommend the use of high quality ECC RAM.\n\nIf you use a dedicated cache and/or log disk, you should use an enterprise class SSD (e.g. Intel SSD DC S3700 Series). This can increase the overall performance significantly.\n\nIMPORTANT: Do not use ZFS on top of hardware controller which has its own cache management. ZFS needs to directly communicate with disks. An HBA adapter is the way to go, or something like LSI controller flashed in IT mode.\n\n13.1.2 ZFS Administration\n\nThis section gives you some usage examples for common tasks. ZFS itself is really powerful and provides many options. The main commands to manage ZFS are `zfs` and `zpool`. Both commands come with great manual pages, which can be read with:\n\n```bash\n# man zpool\n# man zfs\n```\n\nCreate a new zpool\n\nTo create a new pool, at least one disk is needed. The `ashift` should have the same sector-size (2 power of `ashift`) or larger as the underlying disk.\n\n```bash\n# zpool create -f -o ashift=12 <pool> <device>\n```\n\nCreate a new pool with RAID-0\n\nMinimum 1 disk\n\n```bash\n# zpool create -f -o ashift=12 <pool> <device1> <device2>\n```\n\nCreate a new pool with RAID-1\n\nMinimum 2 disks\n\n```bash\n# zpool create -f -o ashift=12 <pool> mirror <device1> <device2>\n```\n\nCreate a new pool with RAID-10\n\nMinimum 4 disks\n\n```bash\n# zpool create -f -o ashift=12 <pool> mirror <device1> <device2> mirror <device3> <device4>\n```\nCreate a new pool with RAIDZ-1\n\nMinimum 3 disks\n\n```bash\n# zpool create -f -o ashift=12 <pool> raidz1 <device1> <device2> <device3>\n```\n\nCreate a new pool with RAIDZ-2\n\nMinimum 4 disks\n\n```bash\n# zpool create -f -o ashift=12 <pool> raidz2 <device1> <device2> <device3> <device4>\n```\n\nCreate a new pool with cache (L2ARC)\n\nIt is possible to use a dedicated cache drive partition to increase the performance (use SSD). As `<device>` it is possible to use more devices, like it’s shown in “Create a new pool with RAID*”.\n\n```bash\n# zpool create -f -o ashift=12 <pool> cache <cache_device>\n```\n\nCreate a new pool with log (ZIL)\n\nIt is possible to use a dedicated cache drive partition to increase the performance (SSD). As `<device>` it is possible to use more devices, like it’s shown in “Create a new pool with RAID*”.\n\n```bash\n# zpool create -f -o ashift=12 <pool> log <log_device>\n```\n\nAdd cache and log to an existing pool\n\nIf you have a pool without cache and log. First partition the SSD in 2 partition with `parted` or `gdisk`\n\n**Important:** Always use GPT partition tables.\n\nThe maximum size of a log device should be about half the size of physical memory, so this is usually quite small. The rest of the SSD can be used as cache.\n\n```bash\n# zpool add -f <pool> log <device-part1> cache <device-part2>\n```\n\nChanging a failed device\n\n```bash\n# zpool replace -f <pool> <old device> <new device>\n```\n\nChanging a failed bootable device\n\nDepending on how Proxmox Backup was installed it is either using `grub` or `systemd-boot` as boot-loader.\n\nThe first steps of copying the partition table, reissuing GUIDs and replacing the ZFS partition are the same. To make the system bootable from the new disk, different steps are needed which depend on the bootloader in use.\nProxmox Backup Documentation, Release 1.1.2-1\n\nNote: Use the `zpool status -v` command to monitor how far the resilvering process of the new disk has progressed.\n\nWith `systemd-boot`:\n\n```\n# pve-efiboot-tool format <new disk's ESP>\n# pve-efiboot-tool init <new disk's ESP>\n```\n\nNote: ESP stands for EFI System Partition, which is setup as partition #2 on bootable disks setup by the {pve} installer since version 5.4. For details, see xref:sysboot_systemd_boot_setup[Setting up a new partition for use as synced ESP].\n\nWith `grub`:\n\nUsually `grub.cfg` is located in `/boot/grub/grub.cfg`\n\n```\n# grub-install <new disk>\n# grub-mkconfig -o /path/to/grub.cfg\n```\n\nActivate E-Mail Notification\n\nZFS comes with an event daemon, which monitors events generated by the ZFS kernel module. The daemon can also send emails on ZFS events like pool errors. Newer ZFS packages ship the daemon in a separate package, and you can install it using `apt-get`:\n\n```\n# apt-get install zfs-zed\n```\n\nTo activate the daemon it is necessary to edit `/etc/zfs/zed.d/zed.rc` with your favorite editor, and uncomment the `ZED_EMAIL_ADDR` setting:\n\n```\nZED_EMAIL_ADDR=\"root\"\n```\n\nPlease note Proxmox Backup forwards mails to `root` to the email address configured for the root user.\n\nIMPORTANT: The only setting that is required is `ZED_EMAIL_ADDR`. All other settings are optional.\n\nLimit ZFS Memory Usage\n\nIt is good to use at most 50 percent (which is the default) of the system memory for ZFS ARC to prevent performance shortage of the host. Use your preferred editor to change the configuration in `/etc/modprobe.d/zfs.conf` and insert:\n\n```\noptions zfs zfs_arc_max=8589934592\n```\n\nThis example setting limits the usage to 8GB.\n\nImportant: If your root file system is ZFS you must update your initramfs every time this value changes:\nSWAP on ZFS\n\nSwap-space created on a zvol may generate some troubles, like blocking the server or generating a high IO load, often seen when starting a Backup to an external Storage.\n\nWe strongly recommend to use enough memory, so that you normally do not run into low memory situations. Should you need or want to add swap, it is preferred to create a partition on a physical disk and use it as swap device. You can leave some space free for this purpose in the advanced options of the installer. Additionally, you can lower the \\texttt{swappiness} value. A good value for servers is 10:\n\n\\begin{verbatim}\n# sysctl -w vm.swappiness=10\n\\end{verbatim}\n\nTo make the swappiness persistent, open \\texttt{/etc/sysctl.conf} with an editor of your choice and add the following line:\n\n\\begin{verbatim}\nvm.swappiness = 10\n\\end{verbatim}\n\nTable 1: Linux kernel \\texttt{swappiness} parameter values\n\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Strategy</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>\\texttt{vm.swappiness} = 0</td>\n<td>The kernel will swap only to avoid an 'out of memory' condition</td>\n</tr>\n<tr>\n<td>\\texttt{vm.swappiness} = 1</td>\n<td>Minimum amount of swapping without disabling it entirely.</td>\n</tr>\n<tr>\n<td>\\texttt{vm.swappiness} = 10</td>\n<td>Sometimes recommended to improve performance when sufficient memory exists in a system.</td>\n</tr>\n<tr>\n<td>\\texttt{vm.swappiness} = 60</td>\n<td>The default value.</td>\n</tr>\n<tr>\n<td>\\texttt{vm.swappiness} = 100</td>\n<td>The kernel will swap aggressively.</td>\n</tr>\n</tbody>\n</table>\n\nZFS Compression\n\nTo activate compression: .. code-block:: console\n\n\\begin{verbatim}\n# zpool set compression=lz4 <pool>\n\\end{verbatim}\n\nWe recommend using the \\texttt{lz4} algorithm, since it adds very little CPU overhead. Other algorithms such as \\texttt{lzip} and \\texttt{gzip-N} (where \\texttt{N} is an integer 1-9 representing the compression ratio, 1 is fastest and 9 is best compression) are also available. Depending on the algorithm and how compressible the data is, having compression enabled can even increase I/O performance.\n\nYou can disable compression at any time with: .. code-block:: console\n\n\\begin{verbatim}\n# zfs set compression=off <dataset>\n\\end{verbatim}\n\nOnly new blocks will be affected by this change.\n\nZFS Special Device\n\nSince version 0.8.0 ZFS supports \\texttt{special} devices. A \\texttt{special} device in a pool is used to store metadata, deduplication tables, and optionally small file blocks.\n\nA \\texttt{special} device can improve the speed of a pool consisting of slow spinning hard disks with a lot of metadata changes. For example workloads that involve creating, updating or deleting a large\nnumber of files will benefit from the presence of a *special* device. ZFS datasets can also be configured to store whole small files on the *special* device which can further improve the performance. Use fast SSDs for the *special* device.\n\n**Important:** The redundancy of the *special* device should match the one of the pool, since the *special* device is a point of failure for the whole pool.\n\n**Warning:** Adding a *special* device to a pool cannot be undone!\n\nCreate a pool with *special* device and RAID-1:\n\n```bash\n# zpool create -f -o ashift=12 <pool> mirror <device1> <device2> special mirror <device3> ...\n```\n\nAdding a *special* device to an existing pool with RAID-1:\n\n```bash\n# zpool add <pool> special mirror <device1> <device2>\n```\n\nZFS datasets expose the *special_small_blocks*=<size> property. *size* can be 0 to disable storing small file blocks on the *special* device or a power of two in the range between 512B to 128K. After setting the property new file blocks smaller than *size* will be allocated on the *special* device.\n\n**Important:** If the value for *special_small_blocks* is greater than or equal to the *recordsize* (default 128K) of the dataset, all data will be written to the *special* device, so be careful!\n\nSetting the *special_small_blocks* property on a pool will change the default value of that property for all child ZFS datasets (for example all containers in the pool will opt in for small file blocks).\n\nOpt in for all file smaller than 4K-blocks pool-wide:\n\n```bash\n# zfs set special_small_blocks=4K <pool>\n```\n\nOpt in for small file blocks for a single dataset:\n\n```bash\n# zfs set special_small_blocks=4K <pool>/<filesystem>\n```\n\nOpt out from small file blocks for a single dataset:\n\n```bash\n# zfs set special_small_blocks=0 <pool>/<filesystem>\n```\n\n**Troubleshooting**\n\nCorrupted cachefile\n\nIn case of a corrupted ZFS cachefile, some volumes may not be mounted during boot until mounted manually later.\n\nFor each pool, run:\n\n```bash\n# zpool set cachefile=/etc/zfs/zpool.cache POOLNAME\n```\n\nand afterwards update the *initramfs* by running:\n\n```bash\n# update-initramfs -u -k all\n```\n\nand finally reboot your node.\n\nSometimes the ZFS cachefile can get corrupted, and *zfs-import-cache.service* doesn't import the pools that aren't present in the cachefile.\nAnother workaround to this problem is enabling the `zfs-import-scan.service`, which searches and imports pools via device scanning (usually slower).\n\n## 13.2 Service Daemons\n\n### 13.2.1 proxmox-backup-proxy\n\nThis daemon exposes the whole Proxmox Backup Server API on TCP port 8007 using HTTPS. It runs as user `backup` and has very limited permissions. Operation requiring more permissions are forwarded to the local `proxmox-backup` service.\n\n### 13.2.2 proxmox-backup\n\nThis daemon exposes the Proxmox Backup Server management API on `127.0.0.1:82`. It runs as `root` and has permission to do all privileged operations.\n\nNOTE: The daemon listens to a local address only, so you cannot access it from outside. The `proxmox-backup-proxy` daemon exposes the API to the outside world.\nProxmox Backup Server provides both a web interface and a command line tool for network configuration. You can find the configuration options in the web interface under the **Network Interfaces** section of the **Configuration** menu tree item. The command line tool is accessed via the network subcommand. These interfaces allow you to carry out some basic network management tasks, such as adding, configuring, and removing network interfaces.\n\n**Note:** Any changes made to the network configuration are not applied, until you click on **Apply Configuration** or enter the `network reload` command. This allows you to make many changes at once. It also allows you to ensure that your changes are correct before applying them, as making a mistake here can render the server inaccessible over the network.\n\nTo get a list of available interfaces, use the following command:\n\n```bash\n# proxmox-backup-manager network list\n```\n\n<table>\n<thead>\n<tr>\n<th>name</th>\n<th>type</th>\n<th>autostart</th>\n<th>method</th>\n<th>address</th>\n<th>gateway</th>\n<th>ports/slaves</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>bond0</td>\n<td>bond</td>\n<td>1</td>\n<td>static</td>\n<td>x.x.x.x/x</td>\n<td>x.x.x.x</td>\n<td>ens18 ens19</td>\n</tr>\n<tr>\n<td>ens18</td>\n<td>eth</td>\n<td>1</td>\n<td>manual</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>ens19</td>\n<td>eth</td>\n<td>1</td>\n<td>manual</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTo add a new network interface, use the `create` subcommand with the relevant parameters. For example, you may want to set up a bond, for the purpose of network redundancy. The following command shows a template for creating the bond shown in the list above:\n\n```bash\n# proxmox-backup-manager network create bond0 --type bond --bond_mode active-backup --slaves ens18,ens19 --autostart true --cidr x.x.x.x/x --gateway x.x.x.x\n```\n\nYou can make changes to the configuration of a network interface with the `update` subcommand:\n\n```bash\n# proxmox-backup-manager network update bond0 --cidr y.y.y.y/y\n```\n\nYou can also remove a network interface:\nThe pending changes for the network configuration file will appear at the bottom of the web interface. You can also view these changes, by using the command:\n\n```\n# proxmox-backup-manager network changes\n```\n\nIf you would like to cancel all changes at this point, you can either click on the Revert button or use the following command:\n\n```\n# proxmox-backup-manager network revert\n```\n\nIf you are happy with the changes and would like to write them into the configuration file, select Apply Configuration. The corresponding command is:\n\n```\n# proxmox-backup-manager network reload\n```\n\n**Note:** This command and corresponding GUI button rely on the ifreload command, from the package ifupdown2. This package is included within the Proxmox Backup Server installation, however, you may have to install it yourself, if you have installed Proxmox Backup Server on top of Debian or Proxmox VE.\n\nYou can also configure DNS settings, from the DNS section of Configuration or by using the dns subcommand of proxmox-backup-manager.\n15.1 Datastores\n\nA Datastore is the logical place where Backup Snapshots and their chunks are stored. Snapshots consist of a manifest, blobs, dynamic- and fixed-indexes (see Terminology), and are stored in the following directory structure:\n\n\\[\n<\\text{datastore-root}>/<\\text{type}>/<\\text{id}>/<\\text{time}>/\n\\]\n\nThe deduplication of datastores is based on reusing chunks, which are referenced by the indexes in a backup snapshot. This means that multiple indexes can reference the same chunks, reducing the amount of space needed to contain the data (even across backup snapshots).\n\n15.2 Chunks\n\nA chunk is some (possibly encrypted) data with a CRC-32 checksum at the end and a type marker at the beginning. It is identified by the SHA-256 checksum of its content.\n\nTo generate such chunks, backup data is split either into fixed-size or dynamically sized chunks. The same content will be hashed to the same checksum.\n\nThe chunks of a datastore are found in\n\n\\[\n<\\text{datastore-root}>/.\\text{chunks}/\n\\]\n\nThis chunk directory is further subdivided by the first four byte of the chunks checksum, so the chunk with the checksum\n\n\\[\na342e8151cbf439ce65f3df696b54c67a114982cc0aa751f2852c2f7acc19a8b\n\\]\n\nlives in\n\n\\[\n<\\text{datastore-root}>/.\\text{chunks}/a342/\n\\]\n\nThis is done to reduce the number of files per directory, as having many files per directory can be bad for file system performance.\n\nThese chunk directories ('0000'-'ffff') will be preallocated when a datastore is created.\n\n15.2.1 Fixed-sized Chunks\n\nFor block based backups (like VMs), fixed-sized chunks are used. The content (disk image), is split into chunks of the same length (typically 4 MiB).\n\nThis works very well for VM images, since the file system on the guest most often tries to allocate files in contiguous pieces, so new files get new blocks, and changing existing files changes only their own blocks.\nAs an optimization, VMs in Proxmox VE can make use of ‘dirty bitmaps’, which can track the changed blocks of an image. Since these bitmaps are also a representation of the image split into chunks, there is a direct relation between dirty blocks of the image and chunks which need to get uploaded, so only modified chunks of the disk have to be uploaded for a backup.\n\nSince the image is always split into chunks of the same size, unchanged blocks will result in identical checksums for those chunks, so such chunks do not need to be backed up again. This way storage snapshots are not needed to find the changed blocks.\n\nFor consistency, Proxmox VE uses a QEMU internal snapshot mechanism, that does not rely on storage snapshots either.\n\n15.2.2 Dynamically sized Chunks\n\nIf one does not want to backup block-based systems but rather file-based systems, using fixed-sized chunks is not a good idea, since every time a file would change in size, the remaining data gets shifted around and this would result in many chunks changing, reducing the amount of deduplication.\n\nTo improve this, Proxmox Backup Server uses dynamically sized chunks instead. Instead of splitting an image into fixed sizes, it first generates a consistent file archive (pxar) and uses a rolling hash over this on-the-fly generated archive to calculate chunk boundaries.\n\nWe use a variant of Buzhash which is a cyclic polynomial algorithm. It works by continuously calculating a checksum while iterating over the data, and on certain conditions it triggers a hash boundary.\n\nAssuming that most files of the system that is to be backed up have not changed, eventually the algorithm triggers the boundary on the same data as a previous backup, resulting in chunks that can be reused.\n\n15.2.3 Encrypted Chunks\n\nEncrypted chunks are a special case. Both fixed- and dynamically sized chunks can be encrypted, and they are handled in a slightly different manner than normal chunks.\n\nThe hashes of encrypted chunks are calculated not with the actual (encrypted) chunk content, but with the plain-text content concatenated with the encryption key. This way, two chunks of the same data encrypted with different keys generate two different checksums and no collisions occur for multiple encryption keys.\n\nThis is done to speed up the client part of the backup, since it only needs to encrypt chunks that are actually getting uploaded. Chunks that exist already in the previous backup, do not need to be encrypted and uploaded.\n\n15.3 Caveats and Limitations\n\n15.3.1 Notes on hash collisions\n\nEvery hashing algorithm has a chance to produce collisions, meaning two (or more) inputs generate the same checksum. For SHA-256, this chance is negligible. To calculate such a collision, one can use the ideas of the ‘birthday problem’ from probability theory. For big numbers, this is actually infeasible to calculate with regular computers, but there is a good approximation:\n\n\\[ p(n, d) = 1 - e^{-n^2/(2d)} \\]\nWhere \\( n \\) is the number of tries, and \\( d \\) is the number of possibilities. For a concrete example lets assume a large datastore of 1 PiB, and an average chunk size of 4 MiB. That means \\( n = 268435456 \\) tries, and \\( d = 2^{256} \\) possibilities. Inserting those values in the formula from earlier you will see that the probability of a collision in that scenario is:\n\n\\[\n3.1115 \\times 10^{-61}\n\\]\n\nFor context, in a lottery game of guessing 6 out of 45, the chance to correctly guess all 6 numbers is only \\( 1.2277 \\times 10^{-7} \\), that means the chance of a collision is about the same as winning 13 such lotto games in a row.\n\nIn conclusion, it is extremely unlikely that such a collision would occur by accident in a normal datastore.\n\nAdditionally, SHA-256 is prone to length extension attacks, but since there is an upper limit for how big the chunk are, this is not a problem, since a potential attacker cannot arbitrarily add content to the data beyond that limit.\n\n### 15.3.2 File-based Backup\n\nSince dynamically sized chunks (for file-based backups) are created on a custom archive format (pxar) and not over the files directly, there is no relation between files and the chunks. This means that the Proxmox Backup client has to read all files again for every backup, otherwise it would not be possible to generate a consistent independent pxar archive where the original chunks can be reused. Note that there will be still only new or change chunks be uploaded.\n\n### 15.3.3 Verification of encrypted chunks\n\nFor encrypted chunks, only the checksum of the original (plaintext) data is available, making it impossible for the server (without the encryption key), to verify its content against it. Instead only the CRC-32 checksum gets checked.\n16.1 What distribution is Proxmox Backup Server (PBS) based on?\n\nProxmox Backup Server is based on Debian GNU/Linux.\n\n16.2 Which platforms are supported as a backup source (client)?\n\nThe client tool works on most modern Linux systems, meaning you are not limited to Debian-based backups.\n\n16.3 Will Proxmox Backup Server run on a 32-bit processor?\n\nProxmox Backup Server only supports 64-bit CPUs (AMD or Intel). There are no future plans to support 32-bit processors.\n\n16.4 How long will my Proxmox Backup Server version be supported?\n\n<table>\n<thead>\n<tr>\n<th>Proxmox Backup Version</th>\n<th>Debian Version</th>\n<th>First Release</th>\n<th>Debian EOL</th>\n<th>Proxmox EOL</th>\n<th>Backup EOL</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Proxmox Backup 1.x</td>\n<td>Debian (Buster)</td>\n<td>2020-11</td>\n<td>tba</td>\n<td>tba</td>\n<td>tba</td>\n</tr>\n</tbody>\n</table>\n\n16.5 Can I copy or synchronize my datastore to another location?\n\nProxmox Backup Server allows you to copy or synchronize datastores to other locations, through the use of Remotes and Sync Jobs. Remote is the term given to a separate server, which has a datastore that can be synced to a local store. A Sync Job is the process which is used to pull the contents of a datastore from a Remote to a local datastore.\n16.6 Can Proxmox Backup Server verify data integrity of a backup archive?\n\nProxmox Backup Server uses a built-in SHA-256 checksum algorithm, to ensure data integrity. Within each backup, a manifest file (index.json) is created, which contains a list of all the backup files, along with their sizes and checksums. This manifest file is used to verify the integrity of each backup.\n\n16.7 When backing up to remote servers, do I have to trust the remote server?\n\nProxmox Backup Server transfers data via Transport Layer Security (TLS) and additionally supports client-side encryption. This means that data is transferred securely and can be encrypted before it reaches the server. Thus, in the event that an attacker gains access to the server or any point of the network, they will not be able to read the data.\n\nNote: Encryption is not enabled by default. To set up encryption, see the backup client encryption section.\n\n16.8 Is the backup incremental/deduplicated?\n\nWith Proxmox Backup Server, backups are sent incremental and data is deduplicated on the server. This minimizes both the storage consumed and the network impact.\nA.1 proxmox-backup-client\n\nproxmox-backup-client backup {<backupspec>} [OPTIONS]\nCreate (host) backup.\n\n=backupspec>= [<array>] List of backup source specifications (=[<label.ext>::<path>] ...)\nOptional parameters:\n--all-file-systems <boolean> Include all mounted subdirectories.\n--backup-id <string> Backup ID.\n--backup-time <integer> (1547797308 - N) Backup time (Unix epoch.)\n--backup-type vm|ct|host Backup type.\n--chunk-size <integer> (64 - 4096) (default=4096) Chunk size in KB. Must be a power of 2.\n--crypt-mode none|encrypt|sign-only (default=encrypt) Defines whether data is encrypted (using an AEAD cipher), only signed, or neither.\n--entries-max <integer> (default=1048576) Max number of entries to hold in memory.\n--exclude <array> List of paths or patterns for matching files to exclude.\n--include-dev <array> Include mountpoints with same st_dev number (see man fstat) as specified files.\n--keyfd <integer> (0 - N) Pass an encryption key via an already opened file descriptor.\n--keyfile <string> Path to encryption key. All data will be encrypted using this key.\n--master-pubkey-fd <integer> (0 - N) Pass a master public key via an already opened file descriptor.\n--master-pubkey-file <string> Path to master public key. The encryption key used for a backup will be encrypted using this key and appended to the backup.\n--repository <string> Repository URL.\n--skip-lost-and-found <boolean> Skip lost+found directory.\n--verbose <boolean> Verbose output.\n\nproxmox-backup-client benchmark [OPTIONS]\nRun benchmark tests\nOptional parameters:\n--keyfile <string> Path to encryption key. All data will be encrypted using this key.\n--output-format text|json|json-pretty Output format.\n--repository <string> Repository URL.\n--verbose <boolean> Verbose output.\nproxmox-backup-client catalog dump <snapshot> [OPTIONS]\nDump catalog.\n<snapshot> [ <string> ] Snapshot path.\nOptional parameters:\n --keyfd <integer> (0 - N) Pass an encryption key via an already opened file descriptor.\n --keyfile <string> Path to encryption key.\n --repository <string> Repository URL.\nproxmox-backup-client catalog shell <snapshot> <archive-name> [OPTIONS]\nShell to interactively inspect and restore snapshots.\n<snapshot> [ <string> ] Group/Snapshot path.\n<archive-name> [ <string> ] Backup archive name.\nOptional parameters:\n --keyfd <integer> (0 - N) Pass an encryption key via an already opened file descriptor.\n --keyfile <string> Path to encryption key.\n --repository <string> Repository URL.\nproxmox-backup-client change-owner <group> <new-owner> [OPTIONS]\nChange owner of a backup group\n<group> [ <string> ] Backup group.\n<new-owner> [ <string> ] Authentication ID\nOptional parameters:\n --repository <string> Repository URL.\nproxmox-backup-client garbage-collect [OPTIONS]\nStart garbage collection for a specific repository.\nOptional parameters:\n --output-format text|json|json-pretty Output format.\n --repository <string> Repository URL.\nproxmox-backup-client help [{<command>}] [OPTIONS]\nGet help about specified command (or sub-command).\n<command> [ <array> ] Command. This may be a list in order to specify nested sub-commands.\nOptional parameters:\n --verbose <boolean> Verbose help.\nproxmox-backup-client key change-passphrase [path] [OPTIONS]\nChange the encryption key's password.\n\n<path> [string] Key file. Without this the default key's password will be changed.\nOptional parameters:\n--hint <string> Password hint.\n--kdf none|scrypt|pbkdf2 (default=scrypt) Key derivation function for password protected encryption keys.\n\nproxmox-backup-client key create [path] [OPTIONS]\nCreate a new encryption key.\n\n<path> [string] Output file. Without this the key will become the new default encryption key.\nOptional parameters:\n--hint <string> Password hint.\n--kdf none|scrypt|pbkdf2 (default=scrypt) Key derivation function for password protected encryption keys.\n\nproxmox-backup-client key create-master-key\nCreate an RSA public/private key pair used to put an encrypted version of the symmetric backup encryption key onto the backup server along with each backup.\n\nproxmox-backup-client key import-master-pubkey <path>\nImport an RSA public key used to put an encrypted version of the symmetric backup encryption key onto the backup server along with each backup.\nThe imported key will be used as default master key for future invocations by the same local user.\n<path> [string] Path to the PEM formatted RSA public key.\n\nproxmox-backup-client key import-with-master-key [path]\n--encrypted-keyfile <string> --master-keyfile <string> [OPTIONS]\nImport an encrypted backup of an encryption key using a (private) master key.\n\n<path> [string] Output file. Without this the key will become the new default encryption key.\n--encrypted-keyfile <string> RSA-encrypted keyfile to import.\n--master-keyfile <string> (Private) master key to use.\nOptional parameters:\n--hint <string> Password hint.\n--kdf none|scrypt|pbkdf2 (default=scrypt) Key derivation function for password protected encryption keys.\n\nproxmox-backup-client key paperkey [path] [OPTIONS]\nGenerate a printable, human readable text file containing the encryption key.\nThis also includes a scanable QR code for fast key restore.\n<path> [string] Key file. Without this the default key's will be used.\nOptional parameters:\n--output-format text|html Paperkey output format\n--subject <string> Include the specified subject as title text.\n\nproxmox-backup-client key show [<path>] [OPTIONS]\nPrint the encryption key's metadata.\n<path> [string] Key file. Without this the default key's metadata will be shown.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-client key show-master-pubkey [<path>] [OPTIONS]\nList information about master key\n<path> [string] Path to the PEM formatted RSA public key. Default location will be used if not specified.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-client list [OPTIONS]\nList backup groups.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n--repository <string> Repository URL.\n\nproxmox-backup-client login [OPTIONS]\nTry to login. If successful, store ticket.\nOptional parameters:\n--repository <string> Repository URL.\n\nproxmox-backup-client logout [OPTIONS]\nLogout (delete stored ticket).\nOptional parameters:\n--repository <string> Repository URL.\n\nproxmox-backup-client map <snapshot> <archive-name> [OPTIONS]\nMap a drive image from a VM backup to a local loopback device. Use 'unmap' to undo. WARNING: Only do this with trusted backups!\n<snapshot> [string] Group/Snapshot path.\n<archive-name> [string] Backup archive name.\nOptional parameters:\n\n```\n--keyfile <string> Path to encryption key.\n--repository <string> Repository URL.\n--verbose <boolean> (default=false) Verbose output and stay in foreground.\n```\n\nproxmox-backup-client mount <snapshot> <archive-name> <target> [OPTIONS]\nMount pxar archive.\n\n```\n<snapshot> [string] Group/Snapshot path.\n<archive-name> [string] Backup archive name.\n<target> [string] Target directory path.\n```\n\nOptional parameters:\n\n```\n--keyfile <string> Path to encryption key.\n--repository <string> Repository URL.\n--verbose <boolean> (default=false) Verbose output and stay in foreground.\n```\n\nproxmox-backup-client prune <group> [OPTIONS]\nPrune a backup repository.\n\n```\n<group> [string] Backup group.\n```\n\nOptional parameters:\n\n```\n--dry-run <boolean> Just show what prune would do, but do not delete anything.\n--keep-daily <integer> (1 - N) Number of daily backups to keep.\n--keep-hourly <integer> (1 - N) Number of hourly backups to keep.\n--keep-last <integer> (1 - N) Number of backups to keep.\n--keep-monthly <integer> (1 - N) Number of monthly backups to keep.\n--keep-weekly <integer> (1 - N) Number of weekly backups to keep.\n--keep-yearly <integer> (1 - N) Number of yearly backups to keep.\n--output-format text|json|json-pretty Output format.\n--quiet <boolean> Minimal output - only show removals.\n--repository <string> Repository URL.\n```\n\nproxmox-backup-client restore <snapshot> <archive-name> <target> [OPTIONS]\nRestore backup repository.\n\n```\n<snapshot> [string] Group/Snapshot path.\n<archive-name> [string] Backup archive name.\n<target> [string] Target directory path. Use '-' to write to standard output.\n```\n\nWe do not extract '.pxar' archives when writing to standard output.\n\nOptional parameters:\n\n```\n--allow-existing-dirs <boolean> Do not fail if directories already exists.\n```\n\nA.1. proxmox-backup-client\n--crypt-mode none|encrypt|sign-only (default=encrypt) Defines whether data is encrypted (using an AEAD cipher), only signed, or neither.\n\n--keyfd <integer> (0 - N) Pass an encryption key via an already opened file descriptor.\n\n--keyfile <string> Path to encryption key. All data will be encrypted using this key.\n\n--repository <string> Repository URL.\n\nproxmox-backup-client snapshot files <snapshot> [OPTIONS]\nList snapshot files.\n\n<snapshot> [<string>] Snapshot path.\nOptional parameters:\n\n--output-format text|json|json-pretty Output format.\n\n--repository <string> Repository URL.\n\nproxmox-backup-client snapshot forget <snapshot> [OPTIONS]\nForget (remove) backup snapshots.\n\n<snapshot> [<string>] Snapshot path.\nOptional parameters:\n\n--repository <string> Repository URL.\n\nproxmox-backup-client snapshot list [<group>] [OPTIONS]\nList backup snapshots.\n\n<group> [<string>] Backup group.\nOptional parameters:\n\n--output-format text|json|json-pretty Output format.\n\n--repository <string> Repository URL.\n\nproxmox-backup-client snapshot notes show <snapshot> [OPTIONS]\nShow notes\n\n<snapshot> [<string>] Snapshot path.\nOptional parameters:\n\n--output-format text|json|json-pretty Output format.\n\n--repository <string> Repository URL.\n\nproxmox-backup-client snapshot notes update <snapshot> <notes> [OPTIONS]\nUpdate Notes\n\n<snapshot> [<string>] Snapshot path.\n\n<notes> [<string>] The Notes.\nOptional parameters:\n\n--repository <string> Repository URL.\nproxmox-backup-client snapshot upload-log <snapshot> <logfile> [OPTIONS]\nUpload backup log file.\n\n<snapshot> [<string>] Group/Snapshot path.\nlogfile> [<string>] The path to the log file you want to upload.\nOptional parameters:\n--crypt-mode none|encrypt|sign-only (default=encrypt) Defines whether data is encrypted (using an AEAD cipher), only signed, or neither.\n--keyfd <integer> (0 - N) Pass an encryption key via an already opened file descriptor.\n--keyfile <string> Path to encryption key. All data will be encrypted using this key.\n--repository <string> Repository URL.\n\nproxmox-backup-client status [OPTIONS]\nGet repository status.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n--repository <string> Repository URL.\n\nproxmox-backup-client task list [OPTIONS]\nList running server tasks for this repo user\nOptional parameters:\n--all <boolean> Also list stopped tasks.\n--limit <integer> (1 - 1000) (default=50) The maximal number of tasks to list.\n--output-format text|json|json-pretty Output format.\n--repository <string> Repository URL.\n\nproxmox-backup-client task log <upid> [OPTIONS]\nDisplay the task log.\n<upid> [<string>] Unique Process/Task ID.\nOptional parameters:\n--repository <string> Repository URL.\n\nproxmox-backup-client task stop <upid> [OPTIONS]\nTry to stop a specific task.\n<upid> [<string>] Unique Process/Task ID.\nOptional parameters:\n--repository <string> Repository URL.\n\nproxmox-backup-client unmap [<name>]\nUnmap a loop device mapped with ‘map’ and release all resources.\n<name> [<string>] Archive name, path to loopdev (/dev/loopX) or loop device number. Omit to list all current mappings and force cleaning up leftover instances.\n\nproxmox-backup-client version [OPTIONS]\nShow client and optional server version\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n--repository <string> Repository URL.\n\nA.1.1 Catalog Shell Commands\n\nThose command are available when you start an interactive restore shell:\n\nproxmox-backup-client shell <snapshot> <name.pxar>\n\n cd [<path>]\nChange the current working directory to the new directory\n <path> [<string>] target path.\n\n clear-selected\nClear the list of files selected for restore.\n\n deselect <path>\nDeselect an entry for restore.\nThis will return an error if the entry was not found in the list of entries selected for restore.\n <path> [<string>] path to entry to remove from list.\n\n exit\nExit the shell\n\nfind <pattern> [OPTIONS]\nFind entries in the catalog matching the given match pattern.\n <pattern> [string] Match pattern for matching files in the catalog.\nOptional parameters:\n--select <boolean> (default=false) Add matching filenames to list for restore.\n\nhelp [{<command>}] [OPTIONS]\nGet help about specified command (or sub-command).\n <command> [array] Command. This may be a list in order to specify nested sub-commands.\nOptional parameters:\n--verbose <boolean> Verbose help.\nlist-selected [OPTIONS]\nList entries currently selected for restore.\nOptional parameters:\n--patterns <boolean> (default=false) List match patterns instead of the matching files.\n\nls [<path>]\nList the content of working directory or given path.\n<path> [string] target path.\n\npwd\nList the current working directory.\n\nrestore <target> [OPTIONS]\nRestore the sub-archive given by the current working directory to target.\nBy further providing a pattern, the restore can be limited to a narrower subset of this sub-archive.\nIf pattern is not present or empty, the full archive is restored to target.\n<target> [string] target path for restore on local filesystem.\nOptional parameters:\n--pattern <string> match pattern to limit files for restore.\n\nrestore-selected <target>\nRestore the selected entries to the given target path.\nTarget must not exist on the clients filesystem.\n<target> [string] target path for restore on local filesystem.\n\nselect <path>\nSelect an entry for restore.\nThis will return an error if the entry is already present in the list or if an invalid path was provided.\n<path> [string] target path.\n\nstat <path>\nRead the metadata for a given directory entry.\nThis is expensive because the data has to be read from the pxar archive, which means reading over the network.\n<path> [string] target path.\nA.2 proxmox-backup-manager\n\nproxmox-backup-manager acl list [OPTIONS]\nAccess Control list.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager acl update <path> <role> [OPTIONS]\nUpdate Access Control List (ACLs).\n<path> [<string>] Access control path.\nSince privileges are implemented as bitflags, each unique combination of privileges maps to a single, unique u64 value that is used in this enum definition.\nOptional parameters:\n--auth-id <string> Authentication ID\n--delete <boolean> Remove permissions (instead of adding it).\n--digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n--group <string> Group ID\n--propagate <boolean> (default=true) Allow to propagate (inherit) permissions.\n\nproxmox-backup-manager cert info\nDisplay node certificate information.\n\nproxmox-backup-manager cert update [OPTIONS]\nUpdate node certificates and generate all needed files/directories.\nOptional parameters:\n--force <boolean> Force generation of new SSL certificate.\n\nproxmox-backup-manager datastore create <name> <path> [OPTIONS]\nCreate new datastore config.\n$name> [<string>] Datastore name.\n<path> [<string>] Directory name\nOptional parameters:\n--comment <string> Comment (single line).\n--gc-schedule <calendar-event> Run garbage collection job at specified schedule.\n--keep-daily <integer> (1 - N) Number of daily backups to keep.\n--keep-hourly <integer> (1 - N) Number of hourly backups to keep.\n--keep-last <integer> (1 - N) Number of backups to keep.\n--keep-monthly <integer> (1 - N) Number of monthly backups to keep.\n--keep-weekly <integer> (1 - N) Number of weekly backups to keep.\n--keep-yearly <integer> (1 - N) Number of yearly backups to keep.\n--notify [ [gc=<enum>] [,sync=<enum>] [,verify=<enum>]] Datastore notification setting\n--notify-user <string> User ID\n--prune-schedule <calendar-event> Run prune job at specified schedule.\n\nproxmox-backup-manager datastore list [OPTIONS]\nDatastore list.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager datastore remove <name> [OPTIONS]\nRemove a datastore configuration.\n\nOptional parameters:\n--digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n\nproxmox-backup-manager datastore show <name> [OPTIONS]\nShow datastore configuration\n\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager datastore update <name> [OPTIONS]\nUpdate datastore config.\n\nOptional parameters:\n--comment <string> Comment (single line).\n--delete <array> List of properties to delete.\n--digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n--gc-schedule <calendar-event> Run garbage collection job at specified schedule.\n--keep-daily <integer> (1 - N) Number of daily backups to keep.\n--keep-hourly <integer> (1 - N) Number of hourly backups to keep.\n--keep-last <integer> (1 - N) Number of backups to keep.\n--keep-monthly <integer> (1 - N) Number of monthly backups to keep.\n--keep-weekly <integer> (1 - N) Number of weekly backups to keep.\n--keep-yearly <integer> (1 - N) Number of yearly backups to keep.\n--notify [[gc=<enum>] [,sync=<enum>] [,verify=<enum>]] Datastore notification setting\n--notify-user <string> User ID\n--prune-schedule <calendar-event> Run prune job at specified schedule.\n--verify-new <boolean> (default=false) If enabled, all new backups will be verified right after completion.\n\nproxmox-backup-manager disk fs create <name> --disk <string> [OPTIONS]\nCreate a Filesystem on an unused disk. Will be mounted under '/mnt/datastore/<name>'.\n\n<name> [<string>] Datastore name.\n--disk <string> Block device name (/sys/block/<name>).\nOptional parameters:\n--add-datastore <boolean> Configure a datastore using the directory.\n--filesystem ext4|xfs\n\nproxmox-backup-manager disk fs list [OPTIONS]\nList systemd datastore mount units.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager disk initialize <disk> [OPTIONS]\nInitialize empty Disk with GPT\n\n<disk> [<string>] Block device name (/sys/block/<name>).\nOptional parameters:\n--uuid <string> UUID for the GPT table.\n\nproxmox-backup-manager disk list [OPTIONS]\nLocal disk list.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager disk smart-attributes <disk> [OPTIONS]\nShow SMART attributes.\n<disk> [<string>] Block device name (/sys/block/<name>).\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager disk zpool create <name> --devices [<string>, ...] --raidlevel single|mirror|raid10|raidz|raidz2|raidz3 [OPTIONS]\ncreate a zfs pool\n<name> [<string>] Datastore name.\n--devices [<string>, ...] A list of disk names, comma separated.\n--raidlevel single|mirror|raid10|raidz|raidz2|raidz3 The ZFS RAID level to use.\nOptional parameters:\n--add-datastore <boolean> Configure a datastore using the zpool.\n--ashift <integer> (9 - 16) (default=12) Pool sector size exponent.\n--compression gzip|lz4|lzjb|zle|on|off (default=On) The ZFS compression algorithm to use.\n\nproxmox-backup-manager disk zpool list [OPTIONS]\nLocal zfs pools.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\nproxmox-backup-manager dns get [OPTIONS]\nRead DNS settings\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager dns set [OPTIONS]\nUpdate DNS settings.\nOptional parameters:\n--delete <array> List of properties to delete.\n--digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n--dns1 <string> First name server IP address.\n--dns2 <string> Second name server IP address.\n--dns3 <string> Third name server IP address.\n--search <string> Search domain for host-name lookup.\nproxmox-backup-manager garbage-collection start <store> [OPTIONS]\nStart garbage collection for a specific datastore.\n<store> [<string>] Datastore name.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager garbage-collection status <store> [OPTIONS]\nShow garbage collection status for a specific datastore.\n<store> [<string>] Datastore name.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\nproxmox-backup-manager help [{{<command>}}] [OPTIONS]\nGet help about specified command (or sub-command).\n\n<command> [<<array>>] Command. This may be a list in order to specify nested sub-commands.\nOptional parameters:\n--verbose <boolean> Verbose help.\nproxmox-backup-manager network changes\nShow pending configuration changes (diff)\n\nproxmox-backup-manager network create <iface> [OPTIONS]\nCreate network interface configuration.\n\n<iface> [<<string>>] Network interface name.\nOptional parameters:\n--autostart <boolean> Autostart interface.\n--bond-primary <string> Network interface name.\n--bond_mode balance-rr|active-backup|balance-xor|broadcast|802.3ad|balance-tlb|balance-alb\n Linux Bond Mode\n--bond_xmit_hash_policy layer2|layer2+3|layer3+4 Bond Transmit Hash Policy for\n LACP (802.3ad)\n--bridge_ports [<<string>>, ...] A list of network devices, comma separated.\n--bridge_vlan_aware <boolean> Enable bridge vlan support.\n--cidr <string> IPv4 address with netmask (CIDR notation).\n--cidr6 <string> IPv6 address with netmask (CIDR notation).\n--comments <string> Comments (inet, may span multiple lines)\n--comments6 <string> Comments (inet5, may span multiple lines)\n--gateway <string> IPv4 address.\n--gateway6 <string> IPv6 address.\n--method manual|static|dhcp|loopback Interface configuration method\n--method6 manual|static|dhcp|loopback Interface configuration method\n--mtu <integer> (46 - 65535) (default=1500) Maximum Transmission Unit.\n--slaves [<<string>>, ...] A list of network devices, comma separated.\n--type loopback|eth|bridge|bond|vlan|alias|unknown Network interface type\n\nproxmox-backup-manager network list [OPTIONS]\nNetwork device list.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\nproxmox-backup-manager network reload\nReload network configuration (requires ifupdown2).\n\nproxmox-backup-manager network remove <iface> [OPTIONS]\nRemove network interface configuration.\n<iface> [string] Network interface name.\nOptional parameters:\n--digest <string> Prevent changes if current configuration file has different SHA256 digest.\nThis can be used to prevent concurrent modifications.\n\nproxmox-backup-manager network revert\nRevert network configuration (rm /etc/network/interfaces.new).\n\nproxmox-backup-manager network update <iface> [OPTIONS]\nUpdate network interface config.\n<iface> [string] Network interface name.\nOptional parameters:\n--autostart <boolean> Autostart interface.\n--bond-primary <string> Network interface name.\n--bond_mode balance-rr|active-backup|balance-xor|broadcast|802.3ad|balance-tlb|balance-alb\nLinux Bond Mode\n--bond_xmit_hash_policy layer2|layer2+3|layer3+4 Bond Transmit Hash Policy for LACP (802.3ad)\n--bridge_ports [string, ...] A list of network devices, comma separated.\n--bridge_vlan_aware <boolean> Enable bridge vlan support.\n--cidr <string> IPv4 address with netmask (CIDR notation).\n--cidr6 <string> IPv6 address with netmask (CIDR notation).\n--comments <string> Comments (inet, may span multiple lines)\n--comments6 <string> Comments (inet5, may span multiple lines)\n--delete <array> List of properties to delete.\n--digest <string> Prevent changes if current configuration file has different SHA256 digest.\nThis can be used to prevent concurrent modifications.\n--gateway <string> IPv4 address.\n--gateway6 <string> IPv6 address.\n--method manual|static|dhcp|loopback Interface configuration method\n--method6 manual|static|dhcp|loopback Interface configuration method\n--mtu <integer> (46 - 65535) (default=1500) Maximum Transmission Unit.\n--slaves [string, ...] A list of network devices, comma separated.\n--type loopback|eth|bridge|bond|vlan|alias|unknown Network interface type\n\nproxmox-backup-manager pull <remote> <remote-store> <local-store> [OPTIONS]\nSync datastore from another repository\n<remote> [string] Remote ID.\n<remote-store> [string] Datastore name.\n<local-store> [string] Datastore name.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n--remove-vanished <boolean> (default=true) Delete vanished backups. This remove the\n local copy if the remote backup was deleted.\nproxmox-backup-manager remote create <name> --auth-id <string> --host\n <string> --password <string> [OPTIONS]\nCreate new remote.\n<name> [string] Remote ID.\n--auth-id <string> Authentication ID\n--host <string> DNS name or IP address.\n--password <string> Password or auth token for remote host.\nOptional parameters:\n--comment <string> Comment (single line).\n--fingerprint <string> X509 certificate fingerprint (sha256).\n--port <integer> (default=8007) The (optional) port.\n\nproxmox-backup-manager remote list [OPTIONS]\nList configured remotes.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager remote remove <name> [OPTIONS]\nRemove a remote from the configuration file.\n<name> [string] Remote ID.\nOptional parameters:\n--digest <string> Prevent changes if current configuration file has different SHA256 digest.\n This can be used to prevent concurrent modifications.\n\nproxmox-backup-manager remote show <name> [OPTIONS]\nShow remote configuration\n<name> [string] Remote ID.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager remote update <name> [OPTIONS]\nUpdate remote configuration.\n\n<name> [<string>] Remote ID.\nOptional parameters:\n--auth-id <string> Authentication ID\n--comment <string> Comment (single line).\n--delete <array> List of properties to delete.\n--digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n--fingerprint <string> X509 certificate fingerprint (sha256).\n--host <string> DNS name or IP address.\n--password <string> Password or auth token for remote host.\n--port <integer> The (optional) port.\n\nproxmox-backup-manager report\nSystem report\n\nproxmox-backup-manager subscription get [OPTIONS]\nRead subscription info.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager subscription remove\nDelete subscription info.\n\nproxmox-backup-manager subscription set <key>\nSet a subscription key and check it.\n<key> [<string>] Proxmox Backup Server subscription key.\n\nproxmox-backup-manager subscription update [OPTIONS]\nCheck and update subscription status.\nOptional parameters:\n--force <boolean> (default=false) Always connect to server, even if information in cache is up to date.\n\nproxmox-backup-manager sync-job create <id> --remote <string> --remote-store <string> --store <string> [OPTIONS]\nCreate a new sync job.\n<id> [<string>] Job ID.\n--remote <string> Remote ID.\n--remote-store <string> Datastore name.\n--store <string> Datastore name.\n\nOptional parameters:\n--comment <string> Comment (single line).\n--owner <string> Authentication ID\n--remove-vanished <boolean> (default=true) Delete vanished backups. This remove the local copy if the remote backup was deleted.\n--schedule <calendar-event> Run sync job at specified schedule.\n\nproxmox-backup-manager sync-job list [OPTIONS]\nSync job list.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager sync-job remove <id> [OPTIONS]\nRemove a sync job configuration\n<id> [string] Job ID.\nOptional parameters:\n--digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n\nproxmox-backup-manager sync-job show <id> [OPTIONS]\nShow sync job configuration\n<id> [string] Job ID.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager sync-job update <id> [OPTIONS]\nUpdate sync job config.\n<id> [string] Job ID.\nOptional parameters:\n--comment <string> Comment (single line).\n--delete <array> List of properties to delete.\n--digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n--owner <string> Authentication ID\n--remote <string> Remote ID.\n--remote-store <string> Datastore name.\n--remove-vanished <boolean> (default=true) Delete vanished backups. This remove the local copy if the remote backup was deleted.\n\n--schedule <calendar-event> Run sync job at specified schedule.\n\n--store <string> Datastore name.\n\nproxmox-backup-manager task list [OPTIONS]\nList running server tasks.\nOptional parameters:\n--all <boolean> Also list stopped tasks.\n--limit <integer> (1 - 1000) (default=50) The maximal number of tasks to list.\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager task log <upid>\nDisplay the task log.\n<upid> [string] Unique Process/Task ID.\n\nproxmox-backup-manager task stop <upid>\nTry to stop a specific task.\n<upid> [string] Unique Process/Task ID.\n\nproxmox-backup-manager user create <userid> [OPTIONS]\nCreate new user.\n(userid> [string] User ID\nOptional parameters:\n--comment <string> Comment (single line).\n--email <string> E-Mail Address.\n--enable <boolean> (default=true) Enable the account (default). You can set this to '0' to disable the account.\n--expire <integer> (0 - N) (default=0) Account expiration date (seconds since epoch). '0' means no expiration date.\n--firstname <string> First name.\n--lastname <string> Last name.\n--password <string> User Password.\n\nproxmox-backup-manager user delete-token <userid> <tokenname> [OPTIONS]\nDelete a user's API token\n<userid> [string] User ID\n<tokenname> [string] The token ID part of an API token authentication id.\nThis alone does NOT uniquely identify the API token - use a full Authid for such use cases.\nOptional parameters:\n--digest <string> Prevent changes if current configuration file has different SHA256 digest.\nThis can be used to prevent concurrent modifications.\nproxmox-backup-manager user generate-token <userid> <tokenname> [OPTIONS]\nGenerate a new API token with given metadata\n\n.userid> [<string>] User ID\n<tokenname> [<string>] The token ID part of an API token authentication id.\nThis alone does NOT uniquely identify the API token - use a full Authid for such use cases.\n\nOptional parameters:\n--comment <string> Comment (single line).\n--digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n--enable <boolean> (default=true) Enable the account (default). You can set this to '0' to disable the account.\n--expire <integer> (0 - N) (default=0) Account expiration date (seconds since epoch). '0' means no expiration date.\n\nproxmox-backup-manager user list [OPTIONS]\nList configured users.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager user list-tokens <userid> [OPTIONS]\nList tokens associated with user.\n<userid> [<string>] User ID\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager user permissions <auth-id> [OPTIONS]\nList permissions of user/token.\n<auth-id> [<string>] Authentication ID\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n--path <string> Access control path.\n\nproxmox-backup-manager user remove <userid> [OPTIONS]\nRemove a user from the configuration file.\n<userid> [<string>] User ID\nOptional parameters:\n--digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\nproxmox-backup-manager user update <userid> [OPTIONS]\nUpdate user configuration.\n\n<userid> [string] User ID\nOptional parameters:\n--comment <string> Comment (single line).\n--delete <array> List of properties to delete.\n--digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n--email <string> E-Mail Address.\n--enable <boolean> (default=true) Enable the account (default). You can set this to '0' to disable the account.\n--expire <integer> (0 - N) (default=0) Account expiration date (seconds since epoch). '0' means no expiration date.\n--firstname <string> First name.\n--lastname <string> Last name.\n--password <string> User Password.\n\nproxmox-backup-manager verify <store> [OPTIONS]\nVerify backups\n<store> [string] Datastore name.\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager verify-job create <id> --store <string> [OPTIONS]\nCreate a new verification job.\n\n<id> [string] Job ID.\n--store <string> Datastore name.\nOptional parameters:\n--comment <string> Comment (single line).\n--ignore-verified <boolean> (default=true) Do not verify backups that are already verified if their verification is not outdated.\n--outdated-after <integer> (1 - N) Days after that a verification becomes outdated\n--schedule <calendar-event> Run verify job at specified schedule.\n\nproxmox-backup-manager verify-job list [OPTIONS]\nList all verification jobs\nOptional parameters:\n--output-format text|json|json-pretty Output format.\nproxmox-backup-manager verify-job remove <id> [OPTIONS]\nRemove a verification job configuration\n\nOptional parameters:\n- --digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n\nproxmox-backup-manager verify-job show <id> [OPTIONS]\nShow verification job configuration\n\nOptional parameters:\n- --output-format text|json|json-pretty Output format.\n\nproxmox-backup-manager verify-job update <id> [OPTIONS]\nUpdate verification job config.\n\nOptional parameters:\n- --comment <string> Comment (single line).\n- --delete <array> List of properties to delete.\n- --digest <string> Prevent changes if current configuration file has different SHA256 digest. This can be used to prevent concurrent modifications.\n- --ignore-verified <boolean> (default=true) Do not verify backups that are already verified if their verification is not outdated.\n- --outdated-after <integer> (1 - N) Days after that a verification becomes outdated.\n- --schedule <calendar-event> Run verify job at specified schedule.\n- --store <string> Datastore name.\n\nproxmox-backup-manager versions [OPTIONS]\nList package versions for important Proxmox Backup Server packages.\n\nOptional parameters:\n- --output-format text|json|json-pretty Output format.\n- --verbose <boolean> (default=false) Output verbose package information. It is ignored if output-format is specified.\nA.3 proxmox-tape\n\nproxmox-tape backup <store> <pool> [OPTIONS]\nBackup datastore to tape media pool\n\n<store> [{<string>}] Datastore name.\n<pool> [{<string>}] Media pool name.\nOptional parameters:\n --drive <string> Drive Identifier.\n --eject-media <boolean> Eject media upon job completion.\n --export-media-set <boolean> Export media set upon job completion.\n --latest-only <boolean> Backup latest snapshots only.\n --output-format text|json|json-pretty Output format.\n\nproxmox-tape backup-job create <id> --drive <string> --pool <string> --store <string> [OPTIONS]\nCreate a new tape backup job.\n\n<id> [{<string>}] Job ID.\n --drive <string> Drive Identifier.\n --pool <string> Media pool name.\n --store <string> Datastore name.\nOptional parameters:\n --comment <string> Comment (single line).\n --schedule <calendar-event> Run sync job at specified schedule.\n --eject-media <boolean> Eject media upon job completion.\n --export-media-set <boolean> Export media set upon job completion.\n --latest-only <boolean> Backup latest snapshots only.\n --notify-user <string> User ID\n\nproxmox-tape backup-job list [OPTIONS]\nTape backup job list.\nOptional parameters:\n --output-format text|json|json-pretty Output format.\n\nproxmox-tape backup-job remove <id> [OPTIONS]\nRemove a tape backup job configuration\n\n<id> [{<string>}] Job ID.\nOptional parameters:\n --digest <string> Prevent changes if current configuration file has different SHA256 digest.\n This can be used to prevent concurrent modifications.\nproxmox-tape backup-job run <id>\nRun Tape Backup Job\n\nproxmox-tape backup-job show <id> [OPTIONS]\nShow tape backup job configuration\n\nproxmox-tape backup-job update <id> [OPTIONS]\nUpdate the tape backup job\n\nproxmox-tape barcode-label [OPTIONS]\nLabel media with barcodes from changer device\n\nproxmox-tape cartridge-memory [OPTIONS]\nRead Cartridge Memory (Medium auxiliary memory attributes)\n--drive <string> Drive Identifier.\n--output-format [text|json|json-pretty] Output format.\n\nproxmox-tape catalog [OPTIONS]\nScan media and record content\nOptional parameters:\n--drive <string> Drive Identifier.\n--force <boolean> Force overriding existing index.\n--output-format [text|json|json-pretty] Output format.\n--scan <boolean> Re-read the whole tape to reconstruct the catalog instead of restoring saved versions.\n--verbose <boolean> Verbose mode - log all found chunks.\n\nproxmox-tape changer config <name> [OPTIONS]\nGet tape changer configuration\n<name> [string] Tape Changer Identifier.\nOptional parameters:\n--output-format [text|json|json-pretty] Output format.\n\nproxmox-tape changer create <name> --path <string> [OPTIONS]\nCreate a new changer device\n<name> [string] Tape Changer Identifier.\n--path <string> Path to Linux generic SCSI device (e.g. '/dev/sg4')\nOptional parameters:\n--export-slots [integer>, ...] A list of slot numbers, comma separated. Those slots are reserved for Import/Export, i.e. any media in those slots are considered to be 'offline'.\n\nproxmox-tape changer list [OPTIONS]\nList changers\nOptional parameters:\n--output-format [text|json|json-pretty] Output format.\n\nproxmox-tape changer remove <name>\nDelete a tape changer configuration\n<name> [string] Tape Changer Identifier.\n\nproxmox-tape changer scan [OPTIONS]\nScan for SCSI tape changers\nOptional parameters:\n--output-format [text|json|json-pretty] Output format.\nproxmox-tape changer status [\\texttt{<name>}] [OPTIONS]\nGet tape changer status\n\\texttt{<name>} [\\texttt{<string>}] Tape Changer Identifier.\nOptional parameters:\n\\texttt{--cache \\texttt{<boolean>} (default=true)} Use cached value.\n\\texttt{--output-format text|json|json-pretty} Output format.\n\nproxmox-tape changer transfer [\\texttt{<name>}] --from \\texttt{<integer>} (1 - N) --to \\texttt{<integer>} (1 - N)\nTransfers media from one slot to another\n\\texttt{<name>} [\\texttt{<string>}] Tape Changer Identifier.\n\\texttt{--from \\texttt{<integer>} (1 - N)} Source slot number\n\\texttt{--to \\texttt{<integer>} (1 - N)} Destination slot number\n\nproxmox-tape changer update \\texttt{<name>} [OPTIONS]\nUpdate a tape changer configuration\n\\texttt{<name>} [\\texttt{<string>}] Tape Changer Identifier.\nOptional parameters:\n\\texttt{--delete \\texttt{<array>}} List of properties to delete.\n\\texttt{--digest \\texttt{<string>}} Prevent changes if current configuration file has different SHA256 digest.\nThis can be used to prevent concurrent modifications.\n\\texttt{--export-slots \\texttt{<integer>}, ...} A list of slot numbers, comma separated. Those slots are reserved for Import/Export, i.e. any media in those slots are considered to be 'offline'.\n\\texttt{--path \\texttt{<string>}} Path to Linux generic SCSI device (e.g. '/dev/sg4')\n\nproxmox-tape clean [OPTIONS]\nClean drive\nOptional parameters:\n\\texttt{--drive \\texttt{<string>}} Drive Identifier.\n\\texttt{--output-format text|json|json-pretty} Output format.\nproxmox-tape drive config \\texttt{<name>} [OPTIONS]\nGet pool configuration\n\\texttt{<name>} [\\texttt{<string>}] Drive Identifier.\nOptional parameters:\n\\texttt{--output-format text|json|json-pretty} Output format.\n\nproxmox-tape drive create \\texttt{<name>} --path \\texttt{<string>} [OPTIONS]\nCreate a new drive\n<name> [string] Drive Identifier.\n--path <string> The path to a LTO SCSI-generic tape device (i.e. '/dev/sg0')\nOptional parameters:\n--changer <string> Tape Changer Identifier.\n--changer-drivenum <integer> (0 - 8) (default=0) Associated changer drive number\n(required option changer)\n\nproxmox-tape drive list [OPTIONS]\nList drives\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-tape drive remove <name>\nDelete a drive configuration\n<name> [string] Drive Identifier.\n\nproxmox-tape drive scan [OPTIONS]\nScan for drives\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-tape drive update <name> [OPTIONS]\nUpdate a drive configuration\n<name> [string] Drive Identifier.\nOptional parameters:\n--changer <string> Tape Changer Identifier.\n--changer-drivenum <integer> (0 - 8) (default=0) Associated changer drive number\n(required option changer)\n--delete <array> List of properties to delete.\n--digest <string> Prevent changes if current configuration file has different SHA256 digest.\nThis can be used to prevent concurrent modifications.\n--path <string> The path to a LTO SCSI-generic tape device (i.e. '/dev/sg0')\n\nproxmox-tape eject [OPTIONS]\nEject/Unload drive media\nOptional parameters:\n--drive <string> Drive Identifier.\n--output-format text|json|json-pretty Output format.\nproxmox-tape eod [OPTIONS]\nMove to end of media (MTEOM, used to debug)\nOptional parameters:\n--drive <string> Drive Identifier.\n\nproxmox-tape export-media <label-text> [OPTIONS]\nExport media with specified label\n<label-text> [<string>] Media Label/Barcode.\nOptional parameters:\n--drive <string> Drive Identifier.\n\nproxmox-tape format [OPTIONS]\nFormat media\nOptional parameters:\n--drive <string> Drive Identifier.\n--fast <boolean> (default=true) Use fast erase.\n--output-format text|json|json-pretty Output format.\n\nproxmox-tape help [{<command>}] [OPTIONS]\nGet help about specified command (or sub-command).\n<command> [<array>] Command. This may be a list in order to specify nested sub-commands.\nOptional parameters:\n--verbose <boolean> Verbose help.\n\nproxmox-tape inventory [OPTIONS]\nList (and update) media labels (Changer Inventory)\nOptional parameters:\n--drive <string> Drive Identifier.\n--output-format text|json|json-pretty Output format.\n--read-all-labels <boolean> Load all tapes and try read labels (even if already inventoried)\n--read-labels <boolean> Load unknown tapes and try read labels\nproxmox-tape key change-passphrase <fingerprint> [OPTIONS]\nChange the encryption key's password.\n<fingerprint> [<string>] Tape encryption key fingerprint (sha256).\nOptional parameters:\n--hint <string> Password hint.\n--kdf none|scrypt|pbkdf2 (default=scrypt) Key derivation function for password protected encryption keys.\n\nproxmox-tape key create --hint <string> [OPTIONS]\nCreate key (read password from stdin)\n--hint <string> Password restore hint.\nOptional parameters:\n--kdf none|scrypt|pbkdf2 (default=scrypt) Key derivation function for password protected encryption keys.\n\nproxmox-tape key list [OPTIONS]\nList keys\nOptional parameters:\n--output-format text|json|json-pretty Output format.\n\nproxmox-tape key paperkey <fingerprint> [OPTIONS]\nGenerate a printable, human readable text file containing the encryption key.\nThis also includes a scanable QR code for fast key restore.\n<fingerprint> [<string>] Tape encryption key fingerprint (sha256).\nOptional parameters:\n--output-format text|html Paperkey output format\n--subject <string> Include the specified subject as title text.\n\nproxmox-tape key remove <fingerprint> [OPTIONS]\nRemove a encryption key from the database\nPlease note that you can no longer access tapes using this key.\n<fingerprint> [<string>] Tape encryption key fingerprint (sha256).\nOptional parameters:\n--digest <string> Prevent changes if current configuration file has different SHA256 digest.\nThis can be used to prevent concurrent modifications.\n\nproxmox-tape key restore [OPTIONS]\nRestore encryption key from tape (read password from stdin)\nOptional parameters:\n--drive <string> Drive Identifier.\n\nproxmox-tape key show <fingerprint> [OPTIONS]\nPrint the encryption key's metadata.\n<fingerprint> [<string>] Tape encryption key fingerprint (sha256).\nOptional parameters:\n\n```\n--output-format text|json|json-pretty Output format.\n```\n\n```\nproxmox-tape label --label-text <string> [OPTIONS]\n```\nLabel media\n\n```\n--label-text <string> Media Label/Barcode.\n```\nOptional parameters:\n\n```\n--drive <string> Drive Identifier.\n--output-format text|json|json-pretty Output format.\n--pool <string> Media pool name.\n```\n\n```\nproxmox-tape load-media <label-text> [OPTIONS]\n```\nLoad media with specified label\n\n```\n<label-text> [string] Media Label/Barcode.\n```\nOptional parameters:\n\n```\n--drive <string> Drive Identifier.\n--output-format text|json|json-pretty Output format.\n```\n\n```\nproxmox-tape load-media-from-slot <source-slot> [OPTIONS]\n```\nLoad media from the specified slot\n\n```\n<source-slot> [integer] (1 - N) Source slot number.\n```\nOptional parameters:\n\n```\n--drive <string> Drive Identifier.\n```\n\n```\nproxmox-tape media content [OPTIONS]\n```\nList media content\n\n```\n--output-format text|json|json-pretty Output format.\n--backup-id <string> Backup ID.\n--backup-type vm|ct|host Backup type.\n--label-text <string> Media Label/Barcode.\n--media <string> Media Uuid.\n--media-set <string> MediaSet Uuid (We use the all-zero Uuid to reserve an empty media for a specific pool).\n--pool <string> Media pool name.\n```\n\n```\nproxmox-tape media destroy <label-text> [OPTIONS]\n```\nDestroy media (completely remove from database)\n\n```\n<label-text> [string] Media Label/Barcode.\n```\nOptional parameters:\n**--force <boolean>** Force removal (even if media is used in a media set).\n\n**proxmox-tape media list [OPTIONS]**\nList pool media\nOptional parameters:\n\n- **--output-format text|json|json-pretty** Output format.\n- **--pool <string>** Media pool name.\n- **--update-status <boolean> (default=true)** Try to update tape library status (check what tapes are online).\n- **--update-status-changer <string>** Tape Changer Identifier.\n\n**proxmox-tape pool config <name> [OPTIONS]**\nGet media pool configuration\n\n<name> [string] Media pool name.\nOptional parameters:\n\n- **--output-format text|json|json-pretty** Output format.\n\n**proxmox-tape pool create <name> [OPTIONS]**\nCreate a new media pool\n\n<name> [string] Media pool name.\nOptional parameters:\n\n- **--allocation <string>** Media set allocation policy ('continue', 'always', or a calendar event).\n- **--comment <string>** Comment (single line).\n- **--encrypt <string>** Tape encryption key fingerprint (sha256).\n- **--retention <string>** Media retention policy ('overwrite', 'keep', or time span).\n- **--template <string>** Media set naming template (may contain strftime() time format specifications).\n\n**proxmox-tape pool list [OPTIONS]**\nList media pool\nOptional parameters:\n\n- **--output-format text|json|json-pretty** Output format.\n\n**proxmox-tape pool remove <name>**\nDelete a media pool configuration\n\n<name> [string] Media pool name.\n\n**proxmox-tape pool update <name> [OPTIONS]**\nUpdate media pool settings\n\n<name> [string] Media pool name.\nOptional parameters:\n\n--allocation <string> Media set allocation policy ('continue', 'always', or a calendar event).\n--comment <string> Comment (single line).\n--delete <array> List of properties to delete.\n--encrypt <string> Tape encryption key fingerprint (sha256).\n--retention <string> Media retention policy ('overwrite', 'keep', or time span).\n--template <string> Media set naming template (may contain strftime() time format specifications).\n\nproxmox-tape read-label [OPTIONS]\nRead media label\nOptional parameters:\n--drive <string> Drive Identifier.\n--inventorize <boolean> Inventorize media\n--output-format text|json|json-pretty Output format.\n\nproxmox-tape restore <media-set> <store> [OPTIONS]\nRestore data from media-set\n<media-set> [<string>] Media set UUID.\n<store> [[(<source>=)?<target>, ...]] A list of Datastore mappings (or single datastore), comma separated. For example 'a=b,e' maps the source datastore 'a' to target 'b' and all other sources to the default 'e'. If no default is given, only the specified sources are mapped.\nOptional parameters:\n--drive <string> Drive Identifier.\n--notify-user <string> User ID\n--output-format text|json|json-pretty Output format.\n--owner <string> Authentication ID\n\nproxmox-tape rewind [OPTIONS]\nRewind tape\nOptional parameters:\n--drive <string> Drive Identifier.\n--output-format text|json|json-pretty Output format.\n\nproxmox-tape scan [OPTIONS]\nRewind, then read media contents and print debug info\nNote: This reads unless the driver returns an IO Error, so this method is expected to fails when we reach EOT.\nOptional parameters:\n--drive <string> Drive Identifier.\n\nAppendix A. Command Syntax\nproxmox-tape status [OPTIONS]\nGet drive/media status\nOptional parameters:\n --drive <string> Drive Identifier.\n --output-format text|json|json-pretty Output format.\n\nproxmox-tape unload [OPTIONS]\nUnload media via changer\nOptional parameters:\n --drive <string> Drive Identifier.\n --output-format text|json|json-pretty Output format.\n --target-slot <integer> (1 - N) Target slot number. If omitted, defaults to the slot that\nthe drive was loaded from.\n\nproxmox-tape volume-statistics [OPTIONS]\nRead Volume Statistics (SCSI log page 17h)\nOptional parameters:\n --drive <string> Drive Identifier.\n --output-format text|json|json-pretty Output format.\n\nA.4 pmt\n\nAll commands support the following parameters to specify the tape device:\n --device <path> Path to the Linux tape device\n --drive <name> Use drive from Proxmox Backup Server configuration.\n\nCommands which generate output support the --output-format parameter. It accepts the fol-\nlowing values:\n text Text format (default). Human readable.\n json JSON (single line).\n json-pretty JSON (multiple lines, nicely formatted).\n\npmt asf <count>\nPosition the tape at the beginning of the count file (after filemark count)\n<count> [integer> (0 - 2147483647)] File mark position (0 is BOT).\n\npmt bsf <count>\nBackward space count files (position before file mark).\nThe tape is positioned on the last block of the previous file.\n<count> [<integer> (1 - 2147483647)] File mark count.\n\npmt bsfm <count>\nBackward space count files, then forward space one record (position after file mark).\nThis leaves the tape positioned at the first block of the file that is count - 1 files before the current file.\n\n<count> [<integer> (1 - 2147483647)] File mark count.\n\npmt bsr <count>\nBackward space records.\n\n<count> [<integer> (1 - 2147483647)] Record count.\n\npmt cartridge-memory\nRead Cartridge Memory\n\npmt eject\nEject drive media\n\npmt eod\nMove to end of media\n\npmt erase [OPTIONS]\nErase media (from current position)\nOptional parameters:\n--fast <boolean> (default=true) Use fast erase.\n\npmt format [OPTIONS]\nFormat media, single partition\nOptional parameters:\n--fast <boolean> (default=true) Use fast erase.\n\npmt fsf <count>\nForward space count files (position after file mark).\nThe tape is positioned on the first block of the next file.\n\n<count> [<integer> (1 - 2147483647)] File mark count.\n\npmt fsfm <count>\nForward space count files, then backward space one record (position before file mark).\nThis leaves the tape positioned at the last block of the file that is count - 1 files past the current file.\n<count> [<integer> (1 - 2147483647)] File mark count.\n\npmt fsr <count>\nForward space records.\n<count> [<integer> (1 - 2147483647)] Record count.\n\npmt help {{<command>}} [OPTIONS]\nGet help about specified command (or sub-command).\n<command> [<array>] Command. This may be a list in order to specify nested sub-commands.\nOptional parameters:\n--verbose <boolean> Verbous help.\n\npmt load\nLoad media\n\npmt lock\nLock the tape drive door\n\npmt options [OPTIONS]\nSet various drive options\nOptional parameters:\n--blocksize <integer> (0 - 8388608) Set tape drive block_length (0 is variable length).\n--buffer_mode <boolean> Use drive buffer.\n--compression <boolean> Enable/disable compression.\n--defaults <boolean> Set default options\n\npmt rewind\nRewind the tape\n\npmt scan\nScan for existing tape changer devices\n\npmt status\nDrive Status\n\npmt tape-alert-flags\nRead Tape Alert Flags\nProxmox Backup Documentation, Release 1.1.2-1\n\npmt unlock\nUnlock the tape drive door\n\npmt volume-statistics\nVolume Statistics\n\npmt weof [<count>]\nWrite count (default 1) EOF marks at current position.\n<count> [<integer> (1 - 2147483647)] File mark count.\n\nA.5 pmtx\n\npmtx help [{{<command>}}] [OPTIONS]\nGet help about specified command (or sub-command).\n<command> [array] Command. This may be a list in order to specify nested sub-commands. Optional parameters:\n--verbose <boolean> Verbose help.\n\npmtx inquiry\nInquiry\n\npmtx inventory\nInventory\n\npmtx load <slot> [OPTIONS]\nLoad\n<slot> [<integer>] Storage slot number (source). Optional parameters:\n--drivenum <integer> Target drive number (defaults to Drive 0)\n\npmtx scan\nScan for existing tape changer devices\n\npmtx status\nChanger Status\n\npmtx transfer <from> <to>\nTransfer\n<from> [<integer>] Source storage slot number.\n<to> [<integer>] Target storage slot number.\n\npmtx unload [OPTIONS]\nUnload\nOptional parameters:\n--drivenum <integer> Target drive number (defaults to Drive 0)\n--slot <integer> Storage slot number (target). If omitted, defaults to the slot that the drive was loaded from.\n\nA.6 pxar\n\npxar create <archive> <source> [OPTIONS]\nCreate a new .pxar archive.\n<archive> [<string>] Archive name.\n<source> [<string>] Source directory.\nOptional parameters:\n--all-file-systems <boolean> (default=false) Include mounted sudirs.\n--entries-max <integer> (0 - 9223372036854775807) (default=1048576) Max number of entries loaded at once into memory\n--exclude <array> List of paths or pattern matching files to exclude.\n--no-acls <boolean> (default=false) Ignore access control list entries.\n--no-device-nodes <boolean> (default=false) Ignore device nodes.\n--no-fcaps <boolean> (default=false) Ignore file capabilities.\n--no-fifos <boolean> (default=false) Ignore fifos.\n--no-sockets <boolean> (default=false) Ignore sockets.\n--no-xattrs <boolean> (default=false) Ignore extended file attributes.\n--verbose <boolean> (default=false) Verbose output.\n\npxar extract <archive> [<target>] [OPTIONS]\nExtract an archive.\n<archive> [<string>] Archive name.\n<target> [<string>] Target directory\nOptional parameters:\n--allow-existing-dirs <boolean> (default=false) Allows directories to already exist on restore.\n--files-from <string> File containing match pattern for files to restore.\n--no-acls <boolean> (default=false) Ignore access control list entries.\n--no-device-nodes <boolean> (default=false) Ignore device nodes.\nProxmox Backup Documentaধon, Release 1.1.2-1\n\n--no-fcaps <boolean> (default=false) Ignore file capabilities.\n--no-fifos <boolean> (default=false) Ignore fifos.\n--no-sockets <boolean> (default=false) Ignore sockets.\n--no-xattrs <boolean> (default=false) Ignore extended file attributes.\n--pattern <array> List of paths or pattern matching files to restore\n--strict <boolean> (default=false) Stop on errors. Otherwise most errors will simply warn.\n--verbose <boolean> (default=false) Verbose output.\n\npxar help [{<command}>] [OPTIONS]\nGet help about specified command (or sub-command).\n<command> [array] Command. This may be a list in order to specify nested sub-commands.\nOptional parameters:\n--verbose <boolean> Verbose help.\n\npxar list <archive> [OPTIONS]\nList the contents of an archive.\n<archive> [string] Archive name.\nOptional parameters:\n--verbose <boolean> (default=false) Verbose output.\n\npxar mount <archive> <mountpoint> [OPTIONS]\nMount the archive to the provided mountpoint via FUSE.\n<archive> [string] Archive name.\n<mountpoint> [string] Mountpoint for the file system.\nOptional parameters:\n--verbose <boolean> (default=false) Verbose output, running in the foreground (for debugging).\nAll Proxmox Backup Server configuration files resides inside directory \\\\\n/etc/proxmox-backup/.\n\n**B.1 acl.cfg**\n\n**B.1.1 File Format**\n\nThis file contains the access control list for the Proxmox Backup Server API.\nEach line starts with acl:, followed by 4 additional values separated by colons.\n\n- **propagate** Propagate permissions down the hierarchy\n- **path** The object path\n- **User/Token** List of users and token\n- **Role** List of assigned roles\n\nHere is an example list:\n\n```\n acl:/root@pam!test:Admin\n acl:/datastore/store1:user1@pbs:DatastoreAdmin\n```\n\nYou can use the `proxmox-backup-manager acl` command to manipulate this file.\n\n**B.1.2 Roles**\n\nThe following roles exist:\n\n- **Admin** Administrator\n- **Audit** Auditor\n- **NoAccess** Disable Access\n- **DatastoreAdmin** Datastore Administrator\n- **DatastoreReader** Datastore Reader (inspect datastore content and do restores)\n- **DatastoreBackup** Datastore Backup (backup and restore owned backups)\n- **DatastorePowerUser** Datastore PowerUser (backup, restore and prune owned backup)\n- **DatastoreAudit** Datastore Auditor\n- **RemoteAudit** Remote Auditor\n- **RemoteAdmin** Remote Administrator\n- **RemoteSyncOperator** Synchronization Operator\n**B.2 datastore.cfg**\n\n### B.2.1 File Format\n\nThe file contains a list of datastore configuration sections. Each section starts with a header `datastore: <name>`, followed by the datastore configuration options.\n\n```plaintext\ndatastore: <name1>\n path <path1>\n <option1> <value1>\n ...\n\ndatastore: <name2>\n path <path2>\n ...\n```\n\nYou can use the `proxmox-backup-manager datastore` command to manipulate this file.\n\n### B.2.2 Options\n\n*Required properties:*\n\n- **path** [string] Directory name\n\n*Optional properties:*\n\n- **comment** [string] Comment (single line).\n- **gc-schedule** [calendar-event] Run garbage collection job at specified schedule.\n- **keep-daily** [integer] (1 - N) Number of daily backups to keep.\n- **keep-hourly** [integer] (1 - N) Number of hourly backups to keep.\n- **keep-last** [integer] (1 - N) Number of backups to keep.\n- **keep-monthly** [integer] (1 - N) Number of monthly backups to keep.\n- **keep-weekly** [integer] (1 - N) Number of weekly backups to keep.\n- **keep-yearly** [integer] (1 - N) Number of yearly backups to keep.\n- **notify** [[gc=enum] [,sync=enum] [,verify=enum]] Datastore notification setting\n - gc = never|always|error When do we send notifications\n - sync = never|always|error When do we send notifications\n - verify = never|always|error When do we send notifications\n- **notify-user** [string] User ID\n- **prune-schedule** [calendar-event] Run prune job at specified schedule.\n- **verify-new** [boolean] If enabled, all backups will be verified right after completion.\nB.3 media-pool.cfg\n\nB.3.1 File Format\n\nEach entry starts with a header pool: <name>, followed by the media pool configuration options.\n\n```\npool: company1\n allocation always\n retention overwrite\npool: ...\n```\n\nYou can use the proxmox-tape pool command to manipulate this file.\n\nB.3.2 Options\n\nOptional properties:\n\n- **allocation** [<string>] Media set allocation policy ('continue', 'always', or a calendar event).\n- **comment** [<string>] Comment (single line).\n- **encrypt** [<string>] Tape encryption key fingerprint (sha256).\n- **retention** [<string>] Media retention policy ('overwrite', 'keep', or time span).\n- **template** [<string>] Media set naming template (may contain strftime() time format specifications).\n\nB.4 tape.cfg\n\nB.4.1 File Format\n\nEach LTO drive configuration section starts with a header lto: <name>, followed by the drive configuration options.\n\nTape changer configurations starts with changer: <name>, followed by the changer configuration options.\n\n```\nlto: hh8\n changer sl3\n path /dev/tape/by-id/scsi-10WT065325-nst\nchanger: sl3\n export-slots 14,15,16\n path /dev/tape/by-id/scsi-CJ0JBE0059\n```\n\nYou can use the proxmox-tape drive and proxmox-tape changer commands to manipulate this file.\n\n**Note:** The virtual: drive type is experimental and only used for debugging.\n\nB.4.2 Options\n\nSection type 'virtual': Simulate tape drives (only for test and debug)\n\nRequired properties:\n**path** [string] Path to directory\n\n*Optional properties:*\n\n**max-size** [integer] (0 - N) Virtual tape size\n\n**Section type** 'changer': SCSI tape changer\n\n*Required properties:*\n\n**path** [string] Path to Linux generic SCSI device (e.g. '/dev/sg4')\n\n*Optional properties:*\n\n**export-slots** [[integer>, ...]] A list of slot numbers, comma separated. Those slots are reserved for Import/Export, i.e. any media in those slots are considered to be ‘offline’.\n\n**Section type** 'lto': Lto SCSI tape driver\n\n*Required properties:*\n\n**path** [string] The path to a LTO SCSI-generic tape device (i.e. '/dev/sg0')\n\n*Optional properties:*\n\n**changer** [string] Tape Changer Identifier.\n\n**changer-drivenum** [integer] (0 - 8) (default=0) Associated changer drive number (requires option changer)\n\n### B.5 tape-job.cfg\n\n#### B.5.1 File Format\n\nEach entry starts with a header `backup: <name>`, followed by the job configuration options.\n\n```plaintext\nbackup: job1\n drive hh8\n pool p4\n store store3\n schedule daily\nbackup: ...\n```\n\nYou can use the `proxmox-tape backup-job` command to manipulate this file.\n\n#### B.5.2 Options\n\n*Required properties:*\n\n**drive** [string] Drive Identifier.\n\n**pool** [string] Media pool name.\n\n**store** [string] Datastore name.\n\n*Optional properties:*\n\n**comment** [string] Comment (single line).\n\n**schedule** [calendar-event] Run sync job at specified schedule.\n\n**eject-media** [boolean] Eject media upon job completion.\n\n**export-media-set** [boolean] Export media set upon job completion.\n\n**latest-only** [boolean] Backup latest snapshots only.\nB.6 user.cfg\n\nB.6.1 File Format\n\nThis file contains the list of API users and API tokens. Each user configuration section starts with a header user: <name>, followed by the user configuration options.\n\nAPI token configuration starts with a header token: <userid!token_name>, followed by the token configuration. The data used to authenticate tokens is stored in a separate file (token_shadow).\n\n<table>\n<thead>\n<tr>\n<th>user: root@pam</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>comment Superuser</td>\n</tr>\n<tr>\n<td>email <a href=\"mailto:test@example.local\">test@example.local</a></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>token: root@pam!token1</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>comment API test token</td>\n</tr>\n<tr>\n<td>enable true</td>\n</tr>\n<tr>\n<td>expire 0</td>\n</tr>\n</tbody>\n</table>\n\nYou can use the proxmox-backup-manager user command to manipulate this file.\n\nB.6.2 Options\n\nSection type 'user': User properties.\n\nOptional properties:\n\n- comment [string] Comment (single line).\n- email [string] E-Mail Address.\n- enable [boolean] (default=true) Enable the account (default). You can set this to '0' to disable the account.\n- expire [integer] (0 - N) (default=0) Account expiration date (seconds since epoch). '0' means no expiration date.\n- firstname [string] First name.\n- lastname [string] Last name.\n\nSection type 'token': ApiToken properties.\n\nOptional properties:\n\n- comment [string] Comment (single line).\n- enable [boolean] (default=true) Enable the account (default). You can set this to '0' to disable the account.\n- expire [integer] (0 - N) (default=0) Account expiration date (seconds since epoch). '0' means no expiration date.\nB.7 remote.cfg\n\nB.7.1 File Format\n\nThis file contains information used to access remote servers.\nEach entry starts with a header `remote: <name>`, followed by the remote configuration options.\n\n```\nremote: server1\n host server1.local\n auth-id sync@pbs\n ...\nremote: ...\n```\n\nYou can use the `proxmox-backup-manager remote` command to manipulate this file.\n\nB.7.2 Options\n\nRequired properties:\n- **auth-id** `<string>` Authentication ID\n- **host** `<string>` DNS name or IP address.\n- **password** `<string>` Password or auth token for remote host.\n\nOptional properties:\n- **comment** `<string>` Comment (single line).\n- **fingerprint** `<string>` X509 certificate fingerprint (sha256).\n- **port** `<integer>` The (optional) port\n\nB.8 sync.cfg\n\nB.8.1 File Format\n\nEach entry starts with a header `sync: <name>`, followed by the job configuration options.\n\n```\nsync: job1\n store store1\n remote-store store1\n remote lina\nsync: ...\n```\n\nYou can use the `proxmox-backup-manager sync-job` command to manipulate this file.\n\nB.8.2 Options\n\nRequired properties:\n- **remote** `<string>` Remote ID.\n- **remote-store** `<string>` Datastore name.\n- **store** `<string>` Datastore name.\n\nOptional properties:\ncomment [string] Comment (single line).\n\nowner [string] Authentication ID\n\nremove-vanished [boolean (default=true)] Delete vanished backups. This remove the local copy if the remote backup was deleted.\n\nschedule [calendar-event] Run sync job at specified schedule.\n\nB.9 verification.cfg\n\nB.9.1 File Format\n\nEach entry starts with a header verification: <name>, followed by the job configuration options.\n\n```\nverification: verify-store2\n ignore-verified true\n outdated-after 7\n schedule daily\n store store2\nverification: ...\n```\n\nYou can use the proxmox-backup-manager verify-job command to manipulate this file.\n\nB.9.2 Options\n\nRequired properties:\n\nstore [string] Datastore name.\n\nOptional properties:\n\ncomment [string] Comment (single line).\n\nignore-verified [boolean (default=true)] Do not verify backups that are already verified if their verification is not outdated.\n\noutdated-after [integer] (1 - N) Days after that a verification becomes outdated\n\nschedule [calendar-event] Run verify job at specified schedule.\nC.1 Proxmox File Archive Format (.pxar)\n\n```\narchive.pxar ENTRY\n{XATTR}* extended attribute list\n{ACL_USER}* USER ACL entries\n{ACL_GROUP}* GROUP ACL entries\n[ACL_GROUP_OBJ] the ACL_GROUP_OBJ\n[ACL_DEFAULT] the various default ACL fields\n{ACL_DEFAULT_USER}* USER ACL entries\n{ACL_DEFAULT_GROUP}* GROUP ACL entries\n[FCAPS] file capability in Linux disk format\n[QUOTA_PROJECT_ID] the ext4/xfs quota project ID\nPAYLOAD SYMLINK DEVICE {DirectoryEntries}* GOODBYE\nFILENAME ENTRY HARDLINK\n```\n\nC.2 Data Blob Format (.blob)\n\nThe data blob format is used to store small binary data. The magic number decides the exact format:\n\n```\n[66, 171, 56, 7, 190, 131, 112, 161] unencrypted uncompressed\n[49, 185, 88, 66, 111, 182, 163, 127] unencrypted compressed\n[123, 103, 133, 190, 34, 45, 76, 249] encrypted uncompressed\n```\n\nCompression algorithm is zstd. Encryption cipher is AES_256_GCM.\n\nUnencrypted blobs use the following format:\n\n```\nMAGIC: [u8; 8]\nCRC32: [u8; 4]\nData: (max 16MiB)\n```\n\nEncrypted blobs additionally contain a 16 byte IV, followed by a 16 byte Authenticated Encryption (AE) tag, followed by the encrypted data:\nC.3 Fixed Index Format (.fidx)\n\nAll numbers are stored as little-endian.\n\n<table>\n<thead>\n<tr>\n<th>MAGIC: [u8; 8]</th>\n<th>[47, 127, 65, 237, 145, 253, 15, 205]</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>uuid: [u8; 16]</td>\n<td>Unique ID</td>\n</tr>\n<tr>\n<td>ctime: 164,</td>\n<td>Creation Time (epoch)</td>\n</tr>\n<tr>\n<td>index_csum: [u8; 32],</td>\n<td>Sha256 over the index (without header)</td>\n</tr>\n<tr>\n<td>size: u64,</td>\n<td>Image size</td>\n</tr>\n<tr>\n<td>chunk_size:</td>\n<td>Chunk size</td>\n</tr>\n<tr>\n<td>reserved: [u8; 4016],</td>\n<td>overall header size is one page (4096 bytes)</td>\n</tr>\n<tr>\n<td>digest1: [u8; 32]</td>\n<td>first chunk digest</td>\n</tr>\n<tr>\n<td>digest2: [u8; 32]</td>\n<td>next chunk</td>\n</tr>\n<tr>\n<td>...</td>\n<td>next chunk ...</td>\n</tr>\n</tbody>\n</table>\n\nC.4 Dynamic Index Format (.didx)\n\nAll numbers are stored as little-endian.\n\n<table>\n<thead>\n<tr>\n<th>MAGIC: [u8; 8]</th>\n<th>[28, 145, 78, 165, 25, 186, 179, 205]</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>uuid: [u8; 16]</td>\n<td>Unique ID</td>\n</tr>\n<tr>\n<td>ctime: 164,</td>\n<td>Creation Time (epoch)</td>\n</tr>\n<tr>\n<td>index_csum: [u8; 32],</td>\n<td>Sha256 over the index (without header)</td>\n</tr>\n<tr>\n<td>size: u64,</td>\n<td>Image size</td>\n</tr>\n<tr>\n<td>chunk_size:</td>\n<td>Chunk size</td>\n</tr>\n<tr>\n<td>reserved: [u8; 4032],</td>\n<td>Overall header size is one page (4096 bytes)</td>\n</tr>\n<tr>\n<td>offset1: u64</td>\n<td>End of first chunk</td>\n</tr>\n<tr>\n<td>digest1: [u8; 32]</td>\n<td>first chunk digest</td>\n</tr>\n<tr>\n<td>offset2: u64</td>\n<td>End of second chunk</td>\n</tr>\n<tr>\n<td>digest2: [u8; 32]</td>\n<td>second chunk digest</td>\n</tr>\n<tr>\n<td>...</td>\n<td>next chunk offset/digest</td>\n</tr>\n</tbody>\n</table>\nProxmox Backup Server uses a REST based API. While the management interface use normal HTTP, the actual backup and restore interface use HTTP/2 for improved performance. Both HTTP and HTTP/2 are well known standards, so the following section assumes that you are familiar on how to use them.\n\n**D.1 Backup Protocol API**\n\nTo start a new backup, the API call `GET /api2/json/backup` needs to be upgraded to a HTTP/2 connection using `proxmox-backup-protocol-v1` as protocol name:\n\n```\nGET /api2/json/backup HTTP/1.1\nUPGRADE: proxmox-backup-protocol-v1\n```\n\nThe server replies with HTTP 101 Switching Protocol status code, and you can then issue REST commands on that updated HTTP/2 connection.\n\nThe backup protocol allows you to upload three different kind of files:\n\n- Chunks and blobs (binary data)\n- Fixed Indexes (List of chunks with fixed size)\n- Dynamic Indexes (List of chunk with variable size)\n\nThe following section gives a short introduction how to upload such files. Please use the API Viewer for details about available REST commands.\n\n**D.1.1 Upload Blobs**\n\nUploading blobs is done using `POST /blob`. The HTTP body contains the data encoded as `Data Blob`.\n\nThe file name needs to end with `.blob`, and is automatically added to the backup manifest.\n\n**D.1.2 Upload Chunks**\n\nChunks belong to an index, so you first need to open an index (see below). After that, you can upload chunks using `POST /fixed_chunk` and `POST /dynamic_chunk`. The HTTP body contains the chunk data encoded as `Data Blob`. \nD.1.3 Upload Fixed Indexes\n\nFixed indexes are use to store VM image data. The VM image is split into equally sized chunks, which are uploaded individually. The index file simply contains a list to chunk digests.\n\nYou create a fixed index with POST /fixed_index. Then upload chunks with POST /fixed_chunk, and append them to the index with PUT /fixed_index. When finished, you need to close the index using POST /fixed_close.\n\nThe file name needs to end with .fidx, and is automatically added to the backup manifest.\n\nD.1.4 Upload Dynamic Indexes\n\nDynamic indexes are use to store file archive data. The archive data is split into dynamically sized chunks, which are uploaded individually. The index file simply contains a list to chunk digests and offsets.\n\nYou create a dynamic sized index with POST /dynamic_index. Then upload chunks with POST /dynamic_chunk, and append them to the index with PUT /dynamic_index. When finished, you need to close the index using POST /dynamic_close.\n\nThe file name needs to end with .didx, and is automatically added to the backup manifest.\n\nD.1.5 Finish Backup\n\nOnce you have uploaded all data, you need to call POST /finish. This commits all data and ends the backup protocol.\n\nD.2 Restore/Reader Protocol API\n\nTo start a new reader, the API call GET /api2/json/reader needs to be upgraded to a HTTP/2 connection using proxmox-backup-reader-protocol-v1 as protocol name:\n\n```\nGET /api2/json/reader HTTP/1.1\nUPGRADE: proxmox-backup-reader-protocol-v1\n```\n\nThe server replies with HTTP 101 Switching Protocol status code, and you can then issue REST commands on that updated HTTP/2 connection.\n\nThe reader protocol allows you to download three different kind of files:\n\n- Chunks and blobs (binary data)\n- Fixed Indexes (List of chunks with fixed size)\n- Dynamic Indexes (List of chunk with variable size)\n\nThe following section gives a short introduction how to download such files. Please use the API Viewer for details about available REST commands.\n\nD.2.1 Download Blobs\n\nDownloading blobs is done using GET /download. The HTTP body contains the data encoded as Data Blob.\nD.2.2 Download Chunks\n\nDownloading chunks is done using GET /chunk. The HTTP body contains the data encoded as *Data Blob*.\n\nD.2.3 Download Index Files\n\nDownloading index files is done using GET /download. The HTTP body contains the data encoded as *Fixed Index* or *Dynamic Index*. \nE.1 Introduction and Format\n\nCertain tasks, for example pruning and garbage collection, need to be performed on a regular basis. Proxmox Backup Server uses a format inspired by the systemd Time and Date Specification (see systemd.time manpage) called calendar events for its schedules.\n\nCalendar events are expressions to specify one or more points in time. They are mostly compatible with systemd's calendar events.\n\nThe general format is as follows:\n\n```\n[WEAKDAY] [[YEARS-]MONTHS-DAYS] [HOURS:MINUTES[:SECONDS]]\n```\n\nNote that there either has to be at least a weekday, date or time part. If the weekday or date part is omitted, all (week)days are included. If the time part is omitted, the time 00:00:00 is implied. (e.g. '2020-01-01' refers to '2020-01-01 00:00:00')\n\nWeekdays are specified with the abbreviated English version: mon, tue, wed, thu, fri, sat, sun.\n\nEach field can contain multiple values in the following formats:\n\n- comma-separated: e.g., 01,02,03\n- as a range: e.g., 01..10\n- as a repetition: e.g, 05/10 (means starting at 5 every 10)\n- and a combination of the above: e.g., 01,05..10,12/02\n- or a * for every possible value: e.g., *:00\n\nThere are some special values that have specific meaning:\n\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Syntax</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>minutely</td>\n<td><em>.</em>.* 0:00</td>\n</tr>\n<tr>\n<td>hourly</td>\n<td><em>.</em>.* 0:00:00</td>\n</tr>\n<tr>\n<td>daily</td>\n<td><em>.</em>.* 0:00:00:00</td>\n</tr>\n<tr>\n<td>weekly</td>\n<td>mon <em>.</em>.* 0:00:00:00</td>\n</tr>\n<tr>\n<td>monthly</td>\n<td><em>.</em>.-01 0:00:00:00</td>\n</tr>\n<tr>\n<td>yearly or annually</td>\n<td>*-01-01 0:00:00:00</td>\n</tr>\n<tr>\n<td>quarterly</td>\n<td>*-01,04,07,10-01 0:00:00:00</td>\n</tr>\n<tr>\n<td>semiannually or semi-annually</td>\n<td>*-01,07-01 0:00:00:00</td>\n</tr>\n</tbody>\n</table>\n\nHere is a table with some useful examples:\n<table>\n<thead>\n<tr>\n<th>Example</th>\n<th>Alternative</th>\n<th>Explanation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>mon..fin</td>\n<td>mon..fin</td>\n<td>Every working day at 00:00</td>\n</tr>\n<tr>\n<td>sat..sun</td>\n<td>sat..sun</td>\n<td>Only on weekends at 00:00</td>\n</tr>\n<tr>\n<td>mon..fri</td>\n<td>-</td>\n<td>Monday, Wednesday, Friday at 00:00</td>\n</tr>\n<tr>\n<td>12:05</td>\n<td>-</td>\n<td>Every day at 12:05 PM</td>\n</tr>\n<tr>\n<td>*/00/5</td>\n<td>0/1:0/5</td>\n<td>Every five minutes</td>\n</tr>\n<tr>\n<td>mon..wed</td>\n<td>mon..wed</td>\n<td>Monday, Tuesday, Wednesday 30, 40 and 50 minutes after every full hour</td>\n</tr>\n<tr>\n<td>*:30/10</td>\n<td>*:30/10</td>\n<td>Monday, Tuesday, Wednesday at 30, 40 and 50 minutes after every full hour</td>\n</tr>\n<tr>\n<td>mon..fri</td>\n<td>-</td>\n<td>Every working day every 15 minutes between 8 AM and 6 PM and between 10 PM and 11 PM</td>\n</tr>\n<tr>\n<td>12,14,16,18,20,22/2:5</td>\n<td></td>\n<td>Every day starting at 12:05 until 22:05, every 2 hours</td>\n</tr>\n<tr>\n<td><em>/0</em></td>\n<td>0/1:0/1</td>\n<td>Every minute (minimum interval)</td>\n</tr>\n<tr>\n<td>*:05</td>\n<td>-</td>\n<td>On the 5th day of every Month</td>\n</tr>\n<tr>\n<td>Sat *:1..7/15:00</td>\n<td>-</td>\n<td>First Saturday each Month at 15:00</td>\n</tr>\n<tr>\n<td>2015-10-21</td>\n<td>-</td>\n<td>21st October 2015 at 00:00</td>\n</tr>\n</tbody>\n</table>\n\n### E.2 Differences to systemd\n\nNot all features of systemd calendar events are implemented:\n\n- no Unix timestamps (e.g. @12345): instead use date and time to specify a specific point in time\n- no timezone: all schedules use the set timezone on the server\n- no sub-second resolution\n- no reverse day syntax (e.g. 2020-03~01)\n- no repetition of ranges (e.g. 1..10/2)\n\n### E.3 Notes on scheduling\n\nIn Proxmox Backup scheduling for most tasks is done in the proxmox-backup-proxy. This daemon checks all job schedules if they are due every minute. This means that even if calendar events can contain seconds, it will only be checked once a minute.\n\nAlso, all schedules will be checked against the timezone set in the Proxmox Backup server.\nVirtual machine A virtual machine is a program that can execute an entire operating system inside an emulated hardware environment.\n\nContainer A container is an isolated user space. Programs run directly on the host's kernel, but with limited access to the host resources.\n\nDatastore A place to store backups. A directory which contains the backup data. The current implementation is file-system based.\n\nRust Rust is a new, fast and memory-efficient system programming language. It has no runtime or garbage collector. Rust's rich type system and ownership model guarantee memory-safety and thread-safety. I can eliminate many classes of bugs at compile-time.\n\nSphinx Is a tool that makes it easy to create intelligent and beautiful documentation. It was originally created for the documentation of the Python programming language. It has excellent facilities for the documentation of software projects in a range of languages.\n\nreStructuredText Is an easy-to-read, what-you-see-is-what-you-get plaintext markup syntax and parser system.\n\nFUSE Filesystem in Userspace (FUSE) defines an interface which makes it possible to implement a filesystem in userspace as opposed to implementing it in the kernel. The fuse kernel driver handles filesystem requests and sends them to a userspace application.\n\nRemote A remote Proxmox Backup Server installation and credentials for a user on it. You can pull datastores from a remote to a local datastore in order to have redundant backups.\nGNU FREE DOCUMENTATION LICENSE\n\nVersion 1.3, 3 November 2008\n\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\n0. PREAMBLE\n\nThe purpose of this License is to make a manual, textbook, or other functional and useful document \"free\" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.\n\nThis License is a kind of \"copyleft\", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.\n\nWe have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.\n\n1. APPLICABILITY AND DEFINITIONS\n\nThis License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The \"Document\", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as \"you\". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.\n\nA \"Modified Version\" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.\n\nA \"Secondary Section\" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.\n\nThe \"Invariant Sections\" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.\nThe “Cover Texts” are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.\n\nA “Transparent” copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not “Transparent” is called “Opaque”.\n\nExamples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.\n\nThe “Title Page” means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, “Title Page” means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.\n\nThe “publisher” means any person or entity that distributes copies of the Document to the public.\n\nA section “Entitled XYZ” means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as “Acknowledgements”, “Dedication”, “Endorsements”, or “History”). To “Preserve the Title” of such a section when you modify the Document means that it remains a section “Entitled XYZ” according to this definition.\n\nThe Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.\n\n2. VERBATIM COPYING\n\nYou may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.\n\nYou may also lend copies, under the same conditions stated above, and you may publicly display copies.\n\n3. COPYING IN QUANTITY\n\nIf you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.\nIf the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.\n\nIf you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.\n\nIt is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.\n\n4. MODIFICATIONS\n\nYou may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:\n\nA. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.\n\nB. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement.\n\nC. State on the Title page the name of the publisher of the Modified Version, as the publisher.\n\nD. Preserve all the copyright notices of the Document.\n\nE. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.\n\nF. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.\n\nG. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice.\n\nH. Include an unaltered copy of this License.\n\nI. Preserve the section Entitled \"History\", Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled \"History\" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.\n\nJ. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the \"History\" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.\n\nK. For any section Entitled \"Acknowledgements\" or \"Dedications\", Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgments and/or dedications given therein.\nL. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.\n\nM. Delete any section Entitled “Endorsements”. Such a section may not be included in the Modified Version.\n\nN. Do not retitle any existing section to be Entitled “Endorsements” or to conflict in title with any Invariant Section.\n\nO. Preserve any Warranty Disclaimers.\n\nIf the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.\n\nYou may add a section Entitled “Endorsements”, provided it contains nothing but endorsements of your Modified Version by various parties—for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.\n\nYou may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.\n\nThe author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.\n\n5. COMBINING DOCUMENTS\n\nYou may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.\n\nThe combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.\n\nIn the combination, you must combine any sections Entitled \"History\" in the various original documents, forming one section Entitled \"History\"; likewise combine any sections Entitled “Acknowledgements”, and any sections Entitled “Dedications”. You must delete all sections Entitled “Endorsements”.\n\n6. COLLECTIONS OF DOCUMENTS\n\nYou may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.\n\nYou may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.\n\n7. AGGREGATION WITH INDEPENDENT WORKS\n\nA compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an “aggregate” if the\ncopyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.\n\nIf the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.\n\n8. TRANSLATION\n\nTranslation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.\n\nIf a section in the Document is Entitled \"Acknowledgements\", \"Dedications\", or \"History\", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.\n\n9. TERMINATION\n\nYou may not copy, modify, sublicense, or distribute the Document except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, or distribute it is void, and will automatically terminate your rights under this License.\n\nHowever, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.\n\nMoreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.\n\nTermination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, receipt of a copy of some or all of the same material does not give you any rights to use it.\n\n10. FUTURE REVISIONS OF THIS LICENSE\n\nThe Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See https://www.gnu.org/licenses/.\n\nEach version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License \"or any later version\" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. If the Document specifies that a proxy can decide which future versions of this License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Document.\n\n11. RELICENSING\n\n\"Massive Multiauthor Collaboration Site\" (or \"MMC Site\") means any World Wide Web server that publishes copyrightable works and also provides prominent facilities for anybody to edit those\nworks. A public wiki that anybody can edit is an example of such a server. A \"Massive Multi-author Collaboration\" (or \"MMC\") contained in the site means any set of copyrightable works thus published on the MMC site.\n\n\"CC-BY-SA\" means the Creative Commons Attribution-Share Alike 3.0 license published by Creative Commons Corporation, a not-for-profit corporation with a principal place of business in San Francisco, California, as well as future copyleft versions of that license published by that same organization.\n\n\"Incorporate\" means to publish or republish a Document, in whole or in part, as part of another Document.\n\nAn MMC is “eligible for relicensing” if it is licensed under this License, and if all works that were first published under this License somewhere other than this MMC, and subsequently incorporated in whole or in part into the MMC, (1) had no cover texts or invariant sections, and (2) were thus incorporated prior to November 1, 2008.\n\nThe operator of an MMC Site may republish an MMC contained in the site under CC-BY-SA on the same site at any time before August 1, 2009, provided the MMC is eligible for relicensing.\nINDEX\n\nC\nContainer, 145\n\nD\nDatastore, 145\n\nF\nFUSE, 145\n\nR\nRemote, 145\nreStructuredText, 145\nRust, 145\n\nS\nSphinx, 145\n\nV\nVirtual machine, 145"}}},{"rowIdx":267,"cells":{"id":{"kind":"string","value":"65f757a1c763ea1fbe97ba9c6656bd65f6fc2541"},"text":{"kind":"string","value":"Abstract\n\nUnderstanding the behavior of software is important for the existing software to be improved. In this paper, we present a trace slicing technique that is suitable for analyzing complex, textually-large computations in rewriting logic, which is a general framework efficiently implemented in the Maude language that seamlessly unifies a wide variety of logics and models of concurrency. Given a Maude execution trace \\( T \\) and a slicing criterion for the trace (i.e., a piece of information that we want to observe in the final computation state), we traverse \\( T \\) from back to front and the backward dependence of the observed information is incrementally computed at each execution step. At the end of the traversal, a simplified trace slice is obtained by filtering out all the irrelevant data that do not impact on the data of interest. By narrowing the size of the trace, the slicing technique favors better inspection and debugging activities since most tedious and irrelevant inspections that are routinely performed during diagnosis and bug localization can be eliminated automatically.\n\nMoreover, cutting down the execution trace can expose opportunities for further improvement, which we illustrate by means of several examples that we execute by using \\texttt{iJULIENNE}, a trace slicer that implements our conditional slicing technique and is endowed with a trace querying mechanism that increases flexibility and reduction power.\n\n\\textbf{Keywords:} trace slicing, program debugging and comprehension, model checking, rewriting logic\n\n\\textsuperscript{\\textcopyright}This work has been partially supported by the EU (FEDER) and the Spanish MEC project ref. TIN2010-21062-C02-02, and by Generalitat Valenciana ref. PROMETEO2011/052. This work was carried out during the tenure of D. Ballis' ERCIM \"Alain Bensoussan\" Postdoctoral Fellowship. The research leading to these results has received funding from the European Union Seventh Framework Programme (FP7/2007-2013) under grant agreement n. 246016. F. Frechina was supported by FPU-MEC grant AP2010-5681 and D. Romero by FPI-MEC grant BES-2008-004860.\n\nEmail addresses: alpuente@dsic.upv.es (María Alpuente), demis@dimi.uniud.it (Demis Ballis), ffrechina@dsic.upv.es (Francisco Frechina), dromero@dsic.upv.es (Daniel Romero)\n1. Introduction\n\nThe analysis of computation traces plays an important role in many program analysis approaches. Software systems commonly generate large and complex execution traces, whose analysis (or even simple inspection) is extremely time-consuming and, in some cases, unfeasible to perform by hand. Trace slicing is a technique for reducing the size of execution traces by focusing on selected execution aspects, which makes it suitable for trace analysis and monitoring [1] and is also helpful for program debugging, improvement, and understanding [2, 3].\n\nRewriting Logic (RWL) is a logic of change that is particularly suitable for formalizing highly concurrent, complex systems (e.g., biological systems [4] and web systems [5, 6]). RWL is efficiently implemented in the high-speed rewriting language Maude [7]. Roughly speaking, a Maude program consists of a (conditional) term rewriting system (CTRS), together with an equational theory (also possibly conditional) that may include equations and axioms (i.e., algebraic laws such as commutativity, associativity, and unity) so that rewrite steps are applied modulo the equations and algebraic axioms. Rewriting logic-based tools, like the Maude-NPA protocol analyzer, the Maude LTLR model checker, and the Java PathExplorer runtime verification tool (just to mention a few [8]), are used in the analysis and verification of programs and protocols wherein the system states are represented as algebraic entities (elements of an algebraic data type that is specified by the equational theory), while the system computations are modelled via rewrite rules, which describe transitions between states and are performed modulo the equations and axioms. The execution traces produced by these tools are usually very complex and are therefore not amenable to manual inspection. However, not all the information that is in the trace is needed to analyze a given piece of information in a target state. For instance, consider the following rules that define in Maude (a part of) the standard semantics of a simple imperative language: 1) crl <while B do I, St> => <skip, St> if <B, St> => false /\\ isCommand(I), 2) rl <skip, St> => St, and 3) rl <false, St> => false. Then, in the two-step execution trace <while false do X := X + 1, {}> \\rightarrow <skip, {}> \\rightarrow {}, we can observe that the statement X := X + 1 is not relevant to compute the output {}. Therefore, the trace could be simplified by replacing X := X + 1 with a special variable • and by enforcing the logical compatibility condition isCommand(•). This way, we guarantee the correctness of the simplified trace. In other words, any concretization of the simplified trace (which instantiates the variable • and meets the compatibility condition) is a valid trace that still generates the target data that we are observing (in this case, the output {}).\n\nThe basic debugging aid provided by Maude consists of a forward tracing facility that allows the user advance through the program execution, letting the user select the statements being traced. By manually controlling the traceable equations or rules, the displayed trace view can be reduced. However, the user can easily miss the general overview because all rewrite steps that are obtained by applying the equations or rules for the selected function symbols (including all evaluation steps for the conditions of such\nequations/rules) are shown in the output execution trace, whereas the algebraic axiom applications are not recorded in the trace. Thus, the trace is both huge and incomplete, and when the user detects an erroneous intermediate result, it is difficult to determine where the incorrect inference started. Moreover, this trace is either directly displayed or written to a file (in both cases in plain text format) thus being only amenable for user inspection. This is in contrast with the trace slices described below, which are small, automatically generated, and complete (all steps are recorded by default). Moreover, they can be directly displayed or delivered in their meta-level representation and only consist of the information that is strictly needed to deliver the critical part of observed results.\n\nThe backward tracing approach developed in this paper aims to improve program analysis and debugging in rewriting-based programming by helping the user to think backwards –i.e., to deduce the conditions under which a program produces some incorrect output. In conventional programming environments, for such an analysis, the programmer must repeatedly determine which statements in the code impact on the value of a given parameter at a given call, which is usually done manually without any assistance from the debugger. By developing an appropriate notion of antecedents for RWL, our trace slicing technique tracks back reverse dependency and causality along execution traces and then cuts off irrelevant information that does not influence the data observed from the trace. In other words, when execution is stopped at a given computation point (typically, from the location where a fault is manifested), we are able to undo the effect of the last statement executed on the selected data by issuing the step-back facility provided by our slicer (for a given slicing criterion). Thus, by stepwisely reducing the amount of information to be inspected, it is easier for the user to locate errors because many computation steps (and the corresponding program statements involved in the step) can be ignored in the process of locating the program fault area. Moreover, during the trace slice computation, different types of information are computed that are related to the program execution, for example, contributing actions and data and noncontributing ones. After computation of a trace slice, all the noncontributing information is discarded from the trace, and we can even take advantage of the filtered information for the purpose of dynamic program slicing.\n\nContributions. This article offers an up-to-date, comprehensive, and uniform presentation with examples of the backward tracing slicing methodology as developed in [2, 9, 10] and a totally redesigned implementation of our conditional trace slicing technique [11] that we called iJulienne [12].\n\nOur proposal for conditional trace slicing is aimed at endowing the RWL framework with a new instrument that can be used to improve Maude programs, including any RWL-based tool that produces or manipulates RWL computations (e.g., Maude execution traces). The contributions of the paper can be summarized as follows:\n\n1. We describe a novel slicing technique for Maude programs that can be used to drastically reduce complex, textually-large system computations w.r.t. a user-defined\nslicing criterion that selects those data that we want to track back from a given point. The distinguishing features of our technique are as follows:\n\n(a) The system copes with the most prominent RWL features, including algebraic axioms such as associativity, unity, and commutativity.\n\n(b) The system also copes with the rich variety of conditions that occur in Maude theories (i.e., equational conditions $s = t$, matching conditions $p := t$, and rewrite expressions $t \\Rightarrow p$) by taking into account the precise way in which Maude mechanizes the conditional rewriting process so that all such rewrite steps are revisited backwards in an instrumented, fine-grained way.\n\n(c) Unlike previous backward tracing approaches [9, 13], which are based on a costly, dynamic labeling procedure, here a less expensive, incremental technique of matching refinement is used that allows the relevant data to be traced back.\n\n2. We have developed the *iJulienne* system, which is the first slicing-based, incremental trace analysis tool that can be used to analyze execution traces of RWL-based programs and tools. *iJulienne* supersedes and greatly improves the preliminary system presented in [11]. The original algorithm was developed under the assumption that the user examines and slices the entire trace w.r.t. a static slicing criterion, in a non-incremental way. In contrast, the slicing criterion in *iJulienne* can be dynamically changed, which provides the user with a stepwise focus on the information that she wants to observe at any rewrite step. The main features provided by the trace analyzer *iJulienne* are listed below.\n\n(a) *iJulienne* is equipped with an incremental backward trace slicing algorithm that supports incremental refinements of the trace slice and achieves huge reductions in the size of the trace. Starting from a Maude execution trace $T$, a slicing criterion $S$ can be attached to any given state of the trace and the computed trace slice $T^\\bullet$ can be repeatedly refined by applying backward trace slicing w.r.t. increasingly restrictive versions of $S$.\n\n(b) The system supports a cogent form of dynamic program slicing [14] as follows. Given a Maude program $\\mathcal{M}$ and a trace slice $T^\\bullet$ for $\\mathcal{M}$, *iJulienne* is able to infer a fragment of $\\mathcal{M}$ (i.e., the program slice) that is needed to reproduce $T^\\bullet$. This is done by uncovering statement dependence among computationally related parts of the program via backward trace slicing. This feature greatly facilitates the debugging of faulty Maude programs, since the user can generate a sequence of increasingly smaller program slices that gradually shrinks the area that contains the buggy piece of code.\n\n(c) *iJulienne* is endowed with a powerful and intuitive Web user interface that allows the slicing criteria to be easily defined by either highlighting the chosen target symbols or by applying a user-defined filtering pattern. A browsing facility is also provided that enables forward and backward navigation through the trace (and the trace slice) and allows the user to examine all the information that is involved within each state transition (and its corresponding sliced\ncounterpart) for debugging and comprehension purposes. The user interface can be tuned to provide distinct abstract views of the trace that aim at supporting different program comprehension levels. For instance, this includes hiding or displaying the auxiliary transformations that are used by Maude to handle associative and commutative operators.\n\n3. To give the reader a better feeling of the generality and wide application range of our conditional slicing approach, we describe some applications of iJulienne to debugging, analysis and improvement of complex systems (e.g., biological systems, web systems, and protocol specifications).\n\nPlan of the paper. The rest of the paper is organized as follows. Section 2 recalls some fundamental notions of RWL, and Section 3 summarizes the conditional rewriting modulo equational theories defined in Maude. In Section 4 the backward conditional slicing technique is formalized by means of a transition system that traverses the execution traces from back to front, and its formal correctness is stated. Section 5 describes iJulienne, together with some experiments that we have performed with our tool. We also discuss the use of trace slicing to improve program analysis, debugging and comprehension in several application domains. The related work is discussed in Section 7, and Section 8 concludes. The correctness of the proposed backward trace slicing methodology is formally proven in Appendix A.\n\n2. Preliminaries\n\nLet us recall some important notions that are relevant to this work. We assume some basic knowledge of term rewriting [13] and Rewriting Logic [15]. Some familiarity with the Maude language [7] is also required. Maude [16] is a rewriting logic specification and verification system whose operational engine is mainly based on a very efficient implementation of rewriting. A Maude program consists of a composition of modules containing sort and operator declarations, as well as equations relating terms over the operators and universally quantified variables. Maude notation will be introduced “on the fly” as needed in examples.\n\n2.1. The term-language of Maude\n\nWe consider an order-sorted signature $\\Sigma$, with a finite poset of sorts $(S,<)$ that models the usual subsort relation [7]. The connected components of $(S,<)$ are the equivalence classes $[s]$ corresponding to the least equivalence relation $\\equiv<$ containing $. We assume an $S$-sorted family $\\mathcal{V} = \\{\\mathcal{V}_s\\}_{s \\in S}$ of disjoint variable sets. $\\tau(\\Sigma, \\mathcal{V})_s$ and $\\tau(\\Sigma)_s$ are the sets of terms and ground terms of sort $s$, respectively. We write $\\tau(\\Sigma, \\mathcal{V})$ and $\\tau(\\Sigma)$ for the corresponding term algebras. A simple syntactic condition on $(\\Sigma, S, <)$ called preregularity [7] ensures that each (well-formed) term $t$ has always a least-sort possible among all sorts in $S$, which is denoted $ls(t)$. The set of variables that occur in a term $t$ is denoted by $\\text{Var}(t)$. In order to simplify the presentation, we often disregard sorts when no confusion arises.\nA position $w$ in a term $t$ is represented by a sequence of natural numbers that addresses a subterm of $t$ (Λ denotes the empty sequence, i.e., the root position). By notation $w_1.w_2$, we denote the concatenation of positions (sequences) $w_1$ and $w_2$. Positions are ordered by the prefix ordering, that is, given the positions $w_1$ and $w_2$, $w_1 \\leq w_2$ if there exists a position $u$ such that $w_1.u = w_2$. Given a term $t$, we let $\\text{Pos}(t)$ denote the set of positions of $t$. By $t|_w$, we denote the subterm of $t$ at position $w$, and by $t[s]_w$, we denote the result of replacing the subterm $t|_w$ by the term $s$ in $t$.\n\nA substitution $\\sigma$ is a mapping from variables to terms $\\{X_1/t_1, \\ldots, X_n/t_n\\}$ such that $X_i\\sigma = t_i$ for $i = 1, \\ldots, n$ (with $X_i \\neq X_j$ if $i \\neq j$), and $X\\sigma = X$ for all other variables $X$. Given a substitution $\\sigma = \\{X_1/t_1, \\ldots, X_n/t_n\\}$, the domain of $\\sigma$ is the set $\\text{Dom}(\\sigma) = \\{X_1, \\ldots, X_n\\}$. The identity substitution is denoted by $\\{\\}$. The term $t\\sigma$ is the result of applying $\\sigma$ to term $t$. For any substitution $\\sigma$ and set of variables $V$, $\\sigma|_V$ denotes the substitution obtained from $\\sigma$ by restricting its domain to $V$, (i.e., $\\sigma|_V(X) = X\\sigma$ if $X \\in V$, otherwise $\\sigma|_V(X) = X$). Given two terms $s$ and $t$, a substitution $\\sigma$ is a matcher of $t$ in $s$, if $s\\sigma = t$. The term $t$ is an instance of the term $s$, iff there exists a matcher $\\sigma$ of $t$ in $s$. By $\\text{match}_s(t)$, we denote the function that returns a matcher of $t$ in $s$ if such a matcher exists.\n\nWe consider three different kinds of condition that may appear in a conditional Maude theory: an \\textit{equational condition} $t = t'$, with $t, t' \\in \\tau(\\Sigma, V)$; a \\textit{matching condition} is a pair $p := t$ with $p, t \\in \\tau(\\Sigma, V)$; a \\textit{rewrite expression} is a pair $t \\Rightarrow p$, with $p, t \\in \\tau(\\Sigma, V)$. Matching conditions an rewrite expressions are useful for performing a search through a structure without any need to explicitly define a function that does it. This is because substitutions for matching $p$ against $t\\sigma$ need not to be unique since some operators may be matched modulo equational attributes. For instance, considering that list concatenation obeys associativity with identity element \\texttt{nil}, we can define two Maude equations to determine whether an element occurs in a list, as follows:\n\n\\begin{verbatim}\n ceq member(e, lst) = true if (l1, e, l2) := lst .\n eq member(e, lst) = false [owise] .\n\\end{verbatim}\n\nUnlike matching conditions that can only use equations to evaluate the input term $t$, rewrite expressions can apply both equations and rewrite rules for the evaluation.\n\n2.2. Program Equations and Rules\n\nA \\textit{conditional equation} is an expression of the form $\\lambda = \\rho \\text{ if } C$, where $\\lambda, \\rho \\in \\tau(\\Sigma, V)$ (and $ls(\\lambda) \\equiv \\mathcal{L} ls(\\rho)$), and $C$ is a (possibly empty) sequence $c_1 \\land \\ldots \\land c_n$, where each $c_i$ is either an equational condition, or a matching condition. When the condition $C$ is empty, we simply write $\\lambda = \\rho$. A conditional equation $\\lambda = \\rho \\text{ if } c_1 \\land \\ldots \\land c_n$ is \\textit{admissible}, iff (i) \\footnote{A Boolean, equational condition $b = \\text{true}$, with $b \\in \\tau(\\Sigma, V)$ of sort \\texttt{Bool} is simply abbreviated as $b$. A \\textit{Boolean condition} is a conjunction of abbreviated Boolean equational conditions.}\nmod BANK is inc INT .\n sorts Account Msg State Id .\nsubsorts Account Msg < State .\nvar Id Id1 Id2 : Id .\nvar b b1 b2 nb nb1 nb2 M : Int .\nop empty-state : -> State .\nop ac : Id Int -> Account [ctor] .\nops A B C D: Id .\nops credit debit : Id Int -> Msg [ctor] .\nop transfer : Id Id Int -> Msg [ctor] .\n if ac(Id1,b1);debit(Id1,M) => ac(Id1,nb1) /\n ac(Id2,b2);credit(Id2,M) => ac(Id2,nb2) .\netnm\n\nFigure 1: Maude specification of a distributed banking system\n\n\\[ \\forall \\rho \\subseteq \\forall \\lambda \\cup \\bigcup_{i=1}^{n} \\forall \\varphi(c_i), \\text{ and (ii) for each } c_i, \\forall \\varphi(c_i) \\subseteq \\forall \\lambda \\cup \\bigcup_{j=1}^{i-1} \\forall \\varphi(c_j) \\text{ if } c_i \\text{ is an equational condition, and } \\forall \\varphi(e) \\subseteq \\forall \\lambda \\cup \\bigcup_{j=1}^{i-1} \\forall \\varphi(c_j) \\text{ if } c_i \\text{ is a matching condition } p := e. \\]\n\nA conditional rule is an expression of the form \\( \\lambda \\rightarrow \\rho \\text{ if } C \\), where \\( \\lambda, \\rho \\in \\tau(\\Sigma, \\mathcal{V}) \\) (and \\( ls(\\lambda) \\leq ls(\\rho) \\)), and \\( C \\) is a (possibly empty) sequence \\( c_1 \\land \\ldots \\land c_n \\), where each \\( c_i \\) is an equational condition, a matching condition, or a rewrite expression. When the condition \\( C \\) is empty, we simply write \\( \\lambda \\rightarrow \\rho \\). A conditional rule \\( \\lambda \\rightarrow \\rho \\text{ if } c_1 \\land \\ldots \\land c_n \\) is admissible iff it fulfils the exact analogy of the admissibility constraints (i) and (ii) for the equational conditions and the matching conditions, plus the following additional constraint: for each rewrite expression \\( c_i \\) in \\( C \\) of the form \\( e \\Rightarrow p \\), \\( \\forall \\varphi(e) \\subseteq \\forall \\lambda \\cup \\bigcup_{j=1}^{i-1} \\forall \\varphi(c_j) \\). The set of variables that occur in a (conditional) rule/equation \\( r \\) is denoted by \\( \\forall \\varphi(r) \\). Note that admissible equations and rules can contain extra-variables (i.e., variables that appear in the right-hand side or in the condition of a rule/equation but do not occur in the corresponding left-hand side). The admissibility requirements ensure that all the extra-variables of an admissible rule/equation will become instantiated whenever the rule is applied.\n\nAn order-sorted equational theory is a pair \\( E = (\\Sigma, \\Delta \\cup B) \\), where \\( \\Sigma \\) is an order-sorted signature, \\( \\Delta \\) is a collection of (oriented) admissible, conditional equations, and \\( B \\) is a collection of unconditional equational axioms (e.g., associativity, commutativity, and unity) that can be associated with any binary operator of \\( \\Sigma \\). The equational theory \\( E \\) induces a congruence relation on the term algebra \\( T(\\Sigma, \\mathcal{V}) \\), which is denoted by \\( =_E \\). A conditional rewrite theory (or simply, rewrite theory) is a triple \\( \\mathcal{R} = (\\Sigma, \\Delta \\cup B, R) \\), where \\( (\\Sigma, \\Delta \\cup B) \\) is an order-sorted equational theory, and \\( R \\) is a set of admissible conditional rules.\n\nEquational specifications in Maude can be theories in membership equational logic, which may include conditional membership axioms not addressed in this paper.\nExample 2.1\n\nConsider the Maude specification of Figure 1 that encodes a conditional rewrite theory modeling a simple, distributed banking system. Each state of the system is modeled as a multiset (i.e., an associative and commutative list) of elements of the form $e_1; e_2; \\ldots; e_n$. Each element $e_i$ is either (i) a bank account $ac(Id, b)$, where $ac$ is a constructor symbol (denoted by the Maude `ctor` attribute), $Id$ is the owner of the account and $b$ is the account balance; or (ii) a message modeling a debit, credit, or transfer operation. These account operations are implemented via three rewrite rules: namely, the `debit`, `credit`, and `transfer` rules.\n\nNote that the rule `credit` contains the matching condition $nb := b + M$, while in the rule `debit` an equational condition $b \\geq M$ and a matching condition $nb := b - M$ occur. Finally, two rewrite expressions $ac(Id1, b1); debit(Id1, M) \\rightarrow ac(Id1, nb1)$ and $ac(Id2, b2); credit(Id2, M) \\rightarrow ac(Id2, nb2)$ appear in the rule `transfer`.\n\nThe conditional slicing technique formalized in this article is formulated by considering the precise way in which Maude proves the conditional rewriting steps, which we describe in the following section (see Section 5.2 in [7] for more details).\n\n3. Conditional Rewriting Modulo Equational Theories\n\nGiven a conditional rewrite theory $(\\Sigma, E, R)$, with $E = \\Delta \\cup B$, the conditional rewriting modulo $E$ relation (in symbols, $\\rightarrow_{R/E}$) can be defined by lifting the usual conditional rewrite relation on terms \\[ \\rightarrow \\] to the $E$-congruence classes $[t]_E$ on the term algebra $\\tau(\\Sigma, \\nu)$ that are induced by $=_E$ \\[ \\rightarrow \\], that is, $[t]_E$ is the class of all terms that are equal to $t$ modulo $E$. Unfortunately, in general, $\\rightarrow_{R/E}$ is undecidable since a rewrite step $t \\rightarrow_{R/E} t'$ involves searching through the possibly infinite equivalence classes $[t]_E$ and $[t']_E$.\n\nThe Maude interpreter implements conditional rewriting modulo $E$ by means of two much simpler relations, namely $\\rightarrow_{\\Delta, B}$ and $\\rightarrow_{R, B}$, that allow rules and equations to be intermixed in the rewriting process by simply using an algorithm of matching modulo $B$. We define $\\rightarrow_{R, \\Delta, B}$ as $\\rightarrow_{R, B} \\cup \\rightarrow_{\\Delta, B}$. Roughly speaking, the relation $\\rightarrow_{\\Delta, B}$ uses the equations of $\\Delta$ (oriented from left to right) as simplification rules: thus, for any term $t$, by repeatedly applying the equations as simplification rules, we eventually reach a term $t \\downarrow_{\\Delta}$ to which no further equations can be applied. The term $t \\downarrow_{\\Delta}$ is called a canonical form of $t$ w.r.t. $\\Delta$. On the other hand, the relation $\\rightarrow_{R, B}$ implements rewriting with the rules of $R$, which might be non-terminating and non-confluent, whereas $\\Delta$ is required to be terminating and Church-Rosser modulo $B$ in order to guarantee the existence and unicity (modulo $B$) of a canonical form w.r.t. $\\Delta$ for any term $t$.\n\nFormally, $\\rightarrow_{R, B}$ and $\\rightarrow_{\\Delta, B}$ are defined as follows. Given a rewrite rule $r = (\\lambda \\rightarrow \\rho$ if $C) \\in R$ (resp., an equation $e = (\\lambda \\equiv \\rho$ if $C) \\in \\Delta$), a substitution $\\sigma$, a term $t$, and a position $w$ of $t$, $t \\xrightarrow{r, \\sigma, w} R, B t'$ (resp., $t \\xrightarrow{e, \\sigma, w} \\Delta, B t'$) iff $\\lambda \\sigma =_B t|_w$, $t' = t[\\rho \\sigma]|_w$, and $C$ evaluates\nto true w.r.t $\\sigma$. When no confusion arises, we simply write $t \\rightarrow_{R,B} t'$ (resp. $t \\rightarrow_{\\Delta,B} t'$) instead of $t \\stackrel{\\sigma,w}{\\rightarrow}_{R,B} t'$ (resp. $t \\stackrel{e,\\sigma,w}{\\rightarrow}_{\\Delta,B} t'$).\n\nNote that the evaluation of a condition $C$ is typically a recursive process, since it may involve further (conditional) rewrites in order to normalize $C$ to true. Specifically, an equational condition $e$ evaluates to true w.r.t. $\\sigma$ if $e\\sigma \\downarrow_{\\Delta} = B$ true; a matching equation $p := t$ evaluates to true w.r.t. $\\sigma$ if $p\\sigma = B t\\sigma \\downarrow_{\\Delta}$; a rewrite expression $t \\Rightarrow p$ evaluates to true w.r.t. $\\sigma$ if there exists a rewrite sequence $t\\sigma \\rightarrow^{*}_{R,B} u$, such that $u = B p\\sigma$.\n\nAlthough rewrite expressions and matching/equational conditions can be intermixed in any order, we assume that their satisfaction is attempted sequentially from left to right, as in Maude.\n\nUnder appropriate conditions on the rewrite theory, a rewrite step modulo $E$ on a term $t$ can be implemented, without loss of completeness, by applying the following rewrite strategy [19]: (i) reduce $t$ w.r.t. $\\rightarrow_{\\Delta,B}$ until the canonical form $t \\downarrow_{\\Delta}$ is reached; (ii) rewrite $t \\downarrow_{\\Delta}$ w.r.t. $\\rightarrow_{R,B}$.\n\nAn execution trace $T$ in the rewrite theory $(\\Sigma, \\Delta \\cup B, R)$ is a rewrite sequence\n\n$$s_0 \\rightarrow^{*}_{\\Delta,B} s_0 \\downarrow_{\\Delta} \\rightarrow_{R,B} s_1 \\rightarrow^{*}_{\\Delta,B} s_1 \\downarrow_{\\Delta} \\ldots$$\n\nthat interleaves $\\rightarrow_{\\Delta,B}$ rewrite steps and $\\rightarrow_{R,B}$ steps following the strategy mentioned above.\n\nGiven an execution trace $T$, it is always possible to expand $T$ in an instrumented trace $T'$ in which every application of the matching modulo $B$ algorithm is mimicked by the explicit application of a suitable equational axiom, which is also oriented as a rewrite rule [9]. This way, any given instrumented execution trace consists of a sequence of (standard) rewrites using the conditional equations ($\\rightarrow_{\\Delta}$), conditional rules ($\\rightarrow_{R}$), and axioms ($\\rightarrow_{B}$).\n\n**Example 3.1**\n\nConsider the rewrite theory in Example 2.1 together with the following execution trace $T$: $credit(A,2+3);ac(A,10) \\rightarrow_{\\Delta,B} credit(A,5);ac(A,10) \\rightarrow_{R,B} ac(A,15)$. Thus, the corresponding instrumented execution trace is given by expanding the commutative “step” applied to the term $credit(A,5);ac(A,10)$ using the implicit rule $X;Y \\Rightarrow Y;X$ in $B$ that models the commutativity axiom for the (juxtaposition) operator _;_.\n\n$credit(A,2+3);ac(A,10) \\rightarrow_{\\Delta} credit(A,5);ac(A,10) \\rightarrow_{B} ac(A,10);credit(A,5) \\rightarrow_{R} ac(A,15)$\n\n---\n\n\\[3\\] Technically, to properly evaluate a rewrite expression $t \\Rightarrow p$ or a matching condition $p := t$, the term $p$ is required to be a $\\Delta$-pattern —i.e., a term $p$ such that, for every substitution $\\sigma$, if $x\\sigma$ is a canonical form w.r.t. $\\Delta$ for every $x \\in \\text{Dom}(\\sigma)$, then $p\\sigma$ is also a canonical form w.r.t. $\\Delta$. \n\n9\nmod \\text{ M} \\text{ is inc NAT}.\n\\begin{align*}\n\\text{var} & \\text{ X : Nat} . \\\\\n\\text{var} & \\text{ Y : NzNat} . \\\\\n\\text{op} _\\text{mod_} & \\text{ : Nat NzNat -> Nat} . \\\\\n\\text{ceq} & \\text{ X mod Y = X if Y > X} . \\\\\n\\text{ceq} & \\text{ X mod Y = (X - Y) mod Y if Y <= X} .\n\\end{align*}\n\\text{endm}\n\nFigure 2: The _mod_ operator\n\nAlso, typically hidden inside the $B$-matching algorithms, some transformations allow terms that contain operators that obey associative and commutative (AC) axioms to be rewritten by first producing a single representative of their AC congruence class \\cite{9}. For example, consider a binary AC operator $f$ together with the standard lexicographic ordering over symbols. Given the $B$-equivalence $f(b, f(f(b, a), c)) =_B f(f(b, c), f(a, b))$, we can represent it by using the “internal sequence” of transformations $f(b, f(f(b, a), c)) \\rightarrow_{\\text{flat}_B}^* f(a, b, b, c) \\rightarrow_{\\text{unflat}_B}^* f(f(b, c), f(a, b))$, where the first transformation corresponds to a flattening transformation sequence that obtains the AC canonical form, while the second transformation corresponds to the inverse, unflattening one.\n\nIn the sequel, we assume all execution traces are instrumented as explained above. By abuse of notation, we frequently denote the rewrite relations $\\rightarrow_{\\Delta}$, $\\rightarrow_R$, $\\rightarrow_B$ by $\\rightarrow$. Also, we denote the transitive and reflexive (resp. transitive) closure of the relation $\\rightarrow_{\\Delta} \\cup \\rightarrow_R \\cup \\rightarrow_B$ by $\\rightarrow^*$ (resp. $\\rightarrow^+$).\n\n4. Backward Conditional Trace Slicing\n\nA backward trace slicing methodology for RWL was first proposed in \\cite{9} that is only applicable to unconditional RWL theories, and, hence, it cannot be employed when the source program includes conditional equations and/or rules since it would deliver incorrect and/or incomplete trace slices. The following example illustrates why conditions cannot be disregarded by the slicing process.\n\n\\textbf{Example 4.1}\n\nConsider the Maude specification in Figure 2, which computes the remainder of the division of two natural numbers, and the associated execution trace $\\mathcal{T} : 4 \\text{ mod } 5 \\rightarrow 4$. Assume that we are interested in observing the origins of the target symbol $4$ that appears in the final state. If we disregard the condition $Y > X$ of the first conditional equation, the slicing technique of \\cite{9} computes the trace slice $\\mathcal{T}^* : 4 \\text{ mod } \\bullet \\rightarrow 4$, which is not correct since there exist concrete instances of $4 \\text{ mod } \\bullet$ that cannot be rewritten to $4$ using the first rule —e.g., $4 \\text{ mod } 3 \\not\\rightarrow 4$. By contrast, our novel conditional approach not only produces a trace slice, but also delivers a Boolean condition that establishes the valid instantiations of the input term that generate the observed data. In this specific\nIn this section, we formulate our slicing algorithm for conditional RWL computations. The algorithm is formalized by means of a transition system that traverses the execution traces from back to front. The transition system is given by a single inference rule that relies on a backward rewrite step slicing procedure that is based on a substitution refinement.\n\n4.1. Term slices and term slice concretizations\n\nA term slice of a term \\( t \\) is a term abstraction that disregards part of the information in \\( t \\), that is, the irrelevant data in \\( t \\) are simply replaced by special \\( \\bullet \\)-variables of appropriate sort, denoted by \\( \\bullet_i \\), with \\( i = 0, 1, 2, \\ldots \\). More formally, let \\( V^\\bullet \\) be the extension of the \\( S \\)-sorted family \\( V \\) that augments \\( V \\) with \\( \\bullet \\)-variables in the obvious way. A term \\( t^\\bullet \\) is a term slice of the term \\( t \\) iff \\( t \\) is an instance of \\( t^\\bullet \\) and \\( t^\\bullet \\in \\tau(\\Sigma, V^\\bullet) \\). By \\( \\text{Var}^\\bullet(\\exp) \\) we define the set of all \\( \\bullet \\)-variables that occur in the expression \\( \\exp \\).\n\nGiven a term slice \\( t^\\bullet \\), a meaningful position \\( p \\) of \\( t^\\bullet \\) is a position \\( p \\in \\text{Pos}(t^\\bullet) \\) such that \\( t^\\bullet_p \\neq \\bullet_i \\), for all \\( i = 0, 1, \\ldots \\). By \\( \\text{MPos}(t^\\bullet) \\), we denote the set that contains all the meaningful positions of \\( t^\\bullet \\). Symbols that occur at meaningful positions are called meaningful symbols. Let \\( M^\\bullet \\) be a set of \\( \\bullet \\)-variables. By \\( \\text{MPos}(M^\\bullet, t^\\bullet) \\), we define the extension of \\( \\text{MPos}(t^\\bullet) \\) w.r.t. \\( M^\\bullet \\) that we define as follows:\n\n\\[\n\\text{MPos}(M^\\bullet, t^\\bullet) = \\text{MPos}(t^\\bullet) \\cup \\{ p \\in \\text{Pos}(t^\\bullet) \\mid t^\\bullet_p \\in M^\\bullet \\}\n\\]\n\nThe next auxiliary definition formalizes the function \\( \\text{slice}(t, P) \\) that allows a term slice of \\( t \\) to be constructed w.r.t. a set of position \\( P \\) of \\( t \\). The function \\( \\text{slice} \\) relies on the function \\( \\text{fresh}^\\bullet \\) whose invocation returns a (fresh) variable \\( \\bullet_i \\) of appropriate sort, which is distinct from any previously generated variable \\( \\bullet_j \\).\n\n**Definition 4.2** Let \\( t \\in \\tau(\\Sigma, V) \\) be a term, and let \\( P \\) be a set of positions s.t. \\( P \\subseteq \\text{Pos}(t) \\). Then, the function \\( \\text{slice}(t, P) \\) is defined as follows.\n\n\\[\n\\text{slice}(t, P) = \\text{rslice}(t, P, \\Lambda), \\quad \\text{where}\n\\]\n\n\\[\n\\text{rslice}(t, P, p) = \\begin{cases} \n f(\\text{rslice}(t_1, P, p.1), \\ldots, \\text{rslice}(t_n, P, p.n)) & \\text{if } t = f(t_1, \\ldots, t_n) \\text{ and } p \\in \\bar{P} \\\\\n t & \\text{if } t \\in V \\text{ and } p \\in \\bar{P} \\\\\n \\text{fresh}^\\bullet & \\text{otherwise}\n\\end{cases}\n\\]\n\nand \\( \\bar{P} = \\{ u \\mid u \\leq p \\land p \\in P \\} \\) is the prefix closure of \\( P \\).\nRoughly speaking, \\( \\text{slice}(t, P) \\) yields a term slice of \\( t \\) w.r.t. a set of positions \\( P \\) that includes all symbols of \\( t \\) which occur within the paths from the root to any position in \\( P \\), while each maximal subterm \\( t_{|p} \\), with \\( p \\notin P \\), is abstracted by means of a freshly generated \\( \\bullet \\)-variable.\n\n**Example 4.3**\n\nLet \\( t = d(f(g(a, h(b)), c), a) \\) be a term, and let \\( P = \\{1.1, 1.2\\} \\) be a set of positions of \\( t \\). By applying Definition 4.2, we get the term slice \\( t^* = \\text{slice}(t, P) = d(f(g(\\bullet_1, \\bullet_2), c), \\bullet_3) \\) and the set of meaningful positions \\( \\mathcal{MPos}(t^*) = \\{\\Lambda, 1, 1.1, 1.2\\} \\). Let \\( \\mathcal{M^*} = \\{\\bullet_1, \\bullet_3\\} \\). Then, \\( \\mathcal{MPos}(\\mathcal{M^*}, t^*) = \\{\\Lambda, 1, 1.1, 1.2, 1.1.1, 2\\} \\).\n\nNow we show how we particularize a term slice, i.e., we instantiate \\( \\bullet \\)-variables with data that satisfy a given Boolean condition that we call compatibility condition. Term slice concretization is formally defined as follows.\n\n**Definition 4.4 (term slice concretization)** Let \\( t, t' \\in \\tau(\\Sigma, \\mathcal{V}) \\) be two terms. Let \\( t^* \\) be a term slice of \\( t \\) and let \\( B^* \\) be a Boolean condition. We say that \\( t' \\) is a concretization of \\( t^* \\) that is compatible with \\( B^* \\) (in symbols \\( t^* \\propto^{B^*} t' \\)), if (i) there exists a substitution \\( \\sigma \\) such that \\( t^*\\sigma = t' \\), and (ii) \\( B^*\\sigma \\) evaluates to true.\n\n**Example 4.5**\n\nLet \\( t^* = \\bullet_1 + \\bullet_2 + \\bullet_2 \\) and \\( B^* = (\\bullet_1 > 6 \\land \\bullet_2 \\leq 7) \\). Then, \\( 10 + 2 + 2 \\) is a concretization of \\( t^* \\) that is compatible with \\( B^* \\), while \\( 4 + 2 + 2 \\) is not.\n\nIn the following, we formulate a backward trace slicing algorithm that, given an execution trace \\( \\mathcal{T} : s_0 \\rightarrow^* s_n \\) and a term slice \\( s^*_n \\) of \\( s_n \\), generates the sliced counterpart \\( \\mathcal{T}^* : s^*_0 \\rightarrow^* s^*_n \\) of \\( \\mathcal{T} \\) that only encodes the information required to reproduce (the meaningful symbols of) the term slice \\( s^*_n \\). Additionally, the algorithm returns a companion compatibility condition \\( B^* \\) that guarantees the correctness of the generated trace slice.\n\n### 4.2. Backward Slicing for Execution Traces\n\nConsider an execution trace \\( \\mathcal{T} : s_0 \\rightarrow^* s_n \\). A trace slice \\( \\mathcal{T}^* \\) of \\( \\mathcal{T} \\) is defined w.r.t. a slicing criterion for \\( \\mathcal{T} \\) — i.e., a user-defined term slice \\( s^*_n \\) of \\( s_n \\) that only includes those symbols of \\( s_n \\) that we want to observe.\n\nA trace slice is formally defined as follows.\n\n**Definition 4.6 (trace slice)** Let \\( \\mathcal{R} = (\\Sigma, \\Delta \\cup B, R) \\) be a conditional rewrite theory, and let \\( \\mathcal{T} : s_0 \\overset{r_1,\\sigma_1,\\omega_1}{\\rightarrow} s_1 \\overset{r_2,\\sigma_2,\\omega_2}{\\rightarrow} \\ldots \\overset{r_n,\\sigma_n,\\omega_n}{\\rightarrow} s_n \\) be an execution trace in \\( \\mathcal{R} \\). Let \\( s^*_n \\) be a slicing criterion for \\( \\mathcal{T} \\). A trace slice of \\( \\mathcal{T} \\) w.r.t. \\( s^*_n \\) is a pair \\([s^*_0 \\rightarrow s^*_1 \\rightarrow \\ldots \\rightarrow s^*_n; B^*] \\), where \\( s^*_i \\in \\tau(\\Sigma, \\mathcal{V}^*) \\), with \\( i = 0, \\ldots, n - 1 \\), and \\( B^* \\) is a Boolean condition;\nThe following definitions provide two notions of correctness for a trace slice that will be used to prove the correction of the backward trace slicing algorithm described in this section.\n\n**Definition 4.7** Let \\( \\mathcal{R} = (\\Sigma, \\Delta \\cup B, R) \\) be a conditional rewrite theory, and let \\( T : s_0 \\xrightarrow{r_1, \\sigma_1} u_1 \\xrightarrow{r_2, \\sigma_2} u_2 \\xrightarrow{\\ldots} n, \\sigma_n} u_n \\xrightarrow{\\ldots} s_n \\) be an execution trace in \\( \\mathcal{R} \\). Let \\( s^*_n \\) be a slicing criterion for \\( T \\). A trace slice \\([s^*_0 \\rightarrow s^*_1 \\rightarrow \\ldots \\rightarrow s^*_n, B^*]\\) of \\( T \\) w.r.t. \\( s^*_n \\) is weakly correct iff there exists a term \\( s'_0 \\) with \\( s'_0 \\prec B^* s^*_0 \\), and an execution trace \\( s'_0 \\rightarrow s'_1 \\rightarrow \\ldots \\rightarrow s'_n \\) in \\( \\mathcal{R} \\) such that\n\ni) \\( s'_i \\rightarrow s'_{i+1} \\) is either the rewrite step \\( s'_i \\xrightarrow{r_{i+1}, \\sigma'_{i+1}, u_{i+1}} s'_{i+1} \\) or \\( s'_i = s'_{i+1}, i = 0, \\ldots, n-1; \\)\n\nii) \\( s^*_i \\) is a term slice of \\( s'_i \\), for all \\( i = 0, \\ldots, n \\).\n\nDefinition 4.7 provides an existential condition on trace slices. Roughly speaking, it ensures that for some concrete trace \\( T' \\), whose first state \\( s'_0 \\) is a concretization of \\( s^*_0 \\) which is compatible with \\( B^* \\), the rules involved in the sliced steps of \\( T^* \\) can be applied again, at the same positions, in \\( T' \\) and each \\( s^*_i \\) is a term slice of \\( s'_i \\).\n\n**Definition 4.8** Let \\( \\mathcal{R} = (\\Sigma, \\Delta \\cup B, R) \\) be a conditional rewrite theory, and let \\( T : s_0 \\xrightarrow{r_1, \\sigma_1} u_1 \\xrightarrow{r_2, \\sigma_2} u_2 \\xrightarrow{\\ldots} n, \\sigma_n} u_n \\xrightarrow{\\ldots} s_n \\) be an execution trace in \\( \\mathcal{R} \\). Let \\( s^*_n \\) be a slicing criterion for \\( T \\). A trace slice \\([s^*_0 \\rightarrow s^*_1 \\rightarrow \\ldots \\rightarrow s^*_n, B^*]\\) of \\( T \\) w.r.t. \\( s^*_n \\) is strongly correct iff, for every term \\( s'_0 \\) such that \\( s'_0 \\prec B^* s^*_0 \\), there exists an execution trace \\( s'_0 \\rightarrow s'_1 \\rightarrow \\ldots \\rightarrow s'_n \\) in \\( \\mathcal{R} \\) such that\n\ni) \\( s'_i \\rightarrow s'_{i+1} \\) is either the rewrite step \\( s'_i \\xrightarrow{r_{i+1}, \\sigma'_{i+1}, u_{i+1}} s'_{i+1} \\) or \\( s'_i = s'_{i+1}, i = 0, \\ldots, n-1; \\)\n\nii) \\( s^*_i \\) is a term slice of \\( s'_i \\), for all \\( i = 0, \\ldots, n \\).\n\nNote that Definition 4.6 establishes that, for every concretization \\( s'_0 \\) of \\( s^*_0 \\), which is compatible with the Boolean condition \\( B^* \\), there exists a concrete trace \\( T' \\) in which the rules involved in the sliced steps of \\( T^* \\) can be applied again, at the same positions. Besides, each \\( s^*_i \\) is an appropriate term slice of \\( s'_i, i = 0, \\ldots, n \\).\n\n**Example 4.9**\n\nConsider the Maude specification of Example 2.1 together with the following execution trace:\n\n\\[ T : \\text{ac}(A, 30); \\text{debit}(A, 5); \\text{credit}(A, 3) \\xrightarrow{\\text{debit}} \\text{ac}(A, 25); \\text{credit}(B, 3) \\xrightarrow{\\text{credit}} \\text{ac}(A, 28). \\]\n\nLet \\( \\text{ac}(A, \\bullet_1) \\) be a slicing criterion for \\( T \\). Let \\( T^* \\) be as follows:\n\n\\[ \\text{ac}(A, \\bullet_8); \\text{debit}(A, \\bullet_9); \\text{credit}(A, \\bullet_4) \\xrightarrow{\\text{debit}} \\text{ac}(A, \\bullet_3); \\text{credit}(A, \\bullet_4) \\xrightarrow{\\text{credit}} \\text{ac}(A, \\bullet_1) \\]\nThen, the trace slice \\([T^*, \\text{true}]\\) is only weakly correct w.r.t. \\(\\text{ac}(A, \\bullet)\\), whereas the trace slice \\([T^*, \\bullet_8 \\geq \\bullet_9]\\) is strongly correct. Indeed, \\(T^*\\) needs to be coupled with the compatibility condition \\(\\bullet_8 \\geq \\bullet_9\\) to ensure applicability of the debit rule. In other words, an instance \\(s^\\bullet \\sigma\\) of \\(\\text{ac}(A, \\bullet); \\text{debit}(A, \\bullet)\\) can be rewritten by the debit rule only if \\(\\bullet_8 \\sigma \\geq \\bullet_9 \\sigma\\).\n\nInformally, given a slicing criterion \\(s_n^\\bullet\\) for the execution trace \\(T = s_0 \\rightarrow^* s_n\\), at each rewrite step \\(s_{i-1} \\rightarrow s_i, i = n, \\ldots, 1\\), our technique inductively computes the association between the meaningful information of \\(s_i\\) and the meaningful information of \\(s_{i-1}\\). For each such rewrite step, the conditions of the applied rule are recursively processed in order to ascertain the meaningful information of \\(s_{i-1}\\) from \\(s_i\\), together with the accumulated condition \\(B_i^\\bullet\\). The technique proceeds backwards, from the final term \\(s_n\\) to the initial term \\(s_0\\). A simplified trace is obtained where each \\(s_i\\) is replaced by the corresponding term slice \\(s_i^\\bullet\\).\n\nWe define a transition system \\((\\text{Conf}, \\bullet\\rightarrow)\\) \\([20]\\) where \\(\\text{Conf}\\) is a set of configurations and \\(\\bullet\\rightarrow\\) is the transition relation that implements the backward trace slicing algorithm. Configurations are formally defined as follows.\n\n**Definition 4.10** A configuration, written as \\(\\langle T^*, S^\\bullet, B^\\bullet \\rangle\\), consists of three components:\n- the execution trace \\(T^* = s_0 \\rightarrow^* s_n\\) to be sliced;\n- the term slice \\(S^\\bullet\\), that records the computed term slice \\(s_i^\\bullet\\) of \\(s_i\\);\n- a Boolean condition \\(B^\\bullet\\).\n\nThe transition system \\((\\text{Conf}, \\bullet\\rightarrow)\\) is defined as follows.\n\n**Definition 4.11** Let \\(\\mathcal{R} = (\\Sigma, \\Delta \\cup B, R)\\) be a conditional rewrite theory, let \\(T = U \\rightarrow^* W\\) be an execution trace in \\(\\mathcal{R}\\), and let \\(V \\rightarrow W\\) be a rewrite step. Let \\(B^\\bullet_W\\) and \\(B^\\bullet_V\\) be two Boolean conditions, and let \\(W^\\bullet\\) be a term slice of \\(W\\). Given a set \\(\\text{Conf}\\) of configurations, the transition relation \\(\\bullet\\rightarrow \\subseteq \\text{Conf} \\times \\text{Conf}\\) is the smallest relation that satisfies the following rule:\n\n\\[\n(V^\\bullet, B^\\bullet_V) = \\text{slice-step}(V \\rightarrow W, W^\\bullet, B^\\bullet_W) \\\\\n\\langle U \\rightarrow^* V \\rightarrow W, W^\\bullet, B^\\bullet_W \\rangle \\bullet\\rightarrow \\langle U \\rightarrow^* V, V^\\bullet, B^\\bullet_V \\rangle\n\\]\n\nRoughly speaking, the relation \\(\\bullet\\rightarrow\\) transforms a configuration \\(\\langle U \\rightarrow^* V \\rightarrow W, W^\\bullet, B^\\bullet_W \\rangle\\) into a configuration \\(\\langle U \\rightarrow^* V, V^\\bullet, B^\\bullet_V \\rangle\\) by calling the function \\(\\text{slice-step}(V \\rightarrow W, W^\\bullet, B^\\bullet_W)\\) of Section 4.3, which returns a rewrite step slice for \\(V \\rightarrow W\\). More precisely, \\(\\text{slice-step}\\) computes a suitable term slice \\(V^\\bullet\\) of \\(V\\) and a Boolean condition \\(B^\\bullet_V\\) that updates the compatibility condition specified by \\(B^\\bullet_W\\).\n\nThe initial configuration \\(\\langle s_0 \\rightarrow^* s_n, s_n^\\bullet, \\text{true} \\rangle\\) is transformed until a terminal configuration \\(\\langle s_0, s^\\bullet_0, B^\\bullet_0 \\rangle\\) is reached. Then, the computed trace slice is obtained by replacing\neach term \\( s_i \\) by the corresponding term slice \\( s_i^* \\), \\( i = 0, \\ldots, n \\), in the original execution trace \\( s_0 \\rightarrow^* s_n \\). The algorithm additionally returns the accumulated compatibility condition \\( B_0^* \\) attained in the terminal configuration.\n\nMore formally, the backward trace slicing of an execution trace \\( w.r.t. \\) a slicing criterion is implemented by the function \\( \\text{backward-slicing} \\) defined as follows.\n\n**Definition 4.12 (Backward trace slicing algorithm)** Let \\( R = (\\Sigma, \\Delta \\cup B, R) \\) be a conditional rewrite theory, and let \\( T : s_0 \\rightarrow^* s_n \\) be an execution trace in \\( R \\). Let \\( s_n^* \\) be a slicing criterion for \\( T \\). Then, the function \\( \\text{backward-slicing} \\) is computed as follows:\n\n\\[\n\\text{backward-slicing}(s_0 \\rightarrow^* s_n, s_n^*) = [s_0^* \\rightarrow^* s_n^*, B_0^*]\n\\]\n\niff there exists a transition sequence in \\( (\\text{Conf}, \\cdot \\rightarrow) \\)\n\n\\[\n\\langle s_0 \\rightarrow^* s_n, s_n^*, \\text{true}\\rangle \\cdot \\rightarrow \\langle s_0 \\rightarrow^* s_{n-1}, s_{n-1}^*, B_{n-1}^* \\rangle \\cdot \\rightarrow^* \\langle s_0, s_0^*, B_0^* \\rangle\n\\]\n\nIn the following, we formulate the auxiliary procedure for the slicing of conditional rewrite steps.\n\n### 4.3. The function slice-step\n\nThe function \\( \\text{slice-step} \\), which is outlined in Figure 3, takes three parameters as input: a rewrite step \\( \\mu : s \\xrightarrow{r,w} t \\) with \\( r = \\lambda \\rightarrow \\rho \\text{ if } C \\), a term slice \\( t^* \\) of \\( t \\), and a compatibility condition \\( B_{prev}^* \\). It delivers as outcome the term slice \\( s^* \\) and a new\n\n\\[^4\\text{Since equations and axioms are both interpreted as rewrite rules in our formulation, notation }\\lambda \\rightarrow \\rho \\text{ if } C \\text{ is often abused to denote rules as well as (oriented) equations and axioms.}\\]\ncompatibility condition $B^\\bullet$. Within the algorithm slice-step, we use an auxiliary operator $\\langle |, \\sigma_1, \\sigma_2 | \\rangle$ that refines a substitution $\\sigma_1$ with a substitution $\\sigma_2$, where both $\\sigma_1$ and $\\sigma_2$ may contain $\\bullet$-variables. The main idea behind $\\langle |, \\sigma_1, \\sigma_2 | \\rangle$ is that, for the slicing of the step $\\mu$, all variables in the applied rewrite rule $r$ are naively assumed to be initially bound to irrelevant data (that are specified by $\\bullet$-variables), and the bindings are incrementally refined as we (partially) solve the conditions of $r$.\n\n**Definition 4.13 (refinement)** Let $\\sigma_1$ and $\\sigma_2$ be two substitutions. The refinement of $\\sigma_1$ w.r.t. $\\sigma_2$ is defined by the operator $\\langle |, \\sigma_1, \\sigma_2 | \\rangle$ as follows:\n\n$$\\langle |, \\sigma_1, \\sigma_2 | \\rangle = \\sigma_1|_{\\text{Dom}(\\sigma_1)}, \\text{ where}$$\n\n$$x\\sigma = \\begin{cases} x\\sigma_2 & \\text{if } x \\in \\text{Dom}(\\sigma_1) \\cap \\text{Dom}(\\sigma_2) \\\\ x\\sigma_1\\sigma_2 & \\text{if } x \\in \\text{Dom}(\\sigma_1) \\setminus \\text{Dom}(\\sigma_2) \\end{cases}$$\n\nNote that $\\langle |, \\sigma_1, \\sigma_2 | \\rangle$ differs from the (standard) instantiation of $\\sigma_1$ with $\\sigma_2$. We write $\\langle |, \\sigma_1, \\ldots, \\sigma_n | \\rangle$ as a compact denotation for $\\langle |\\langle |\\langle |\\sigma_1, \\sigma_2 | \\rangle, \\ldots, \\sigma_{n−1} | \\rangle, \\sigma_n | \\rangle$. By abuse of notation, we also let $\\langle |\\sigma | \\rangle$ denote the substitution $\\sigma$.\n\n**Example 4.14**\n\nLet $\\sigma_1 = \\{x/\\bullet_1, y/\\bullet_2\\}$ and $\\sigma_2 = \\{x/a, \\bullet_2/g(\\bullet_3), z/5\\}$ be two substitutions. Thus, $\\langle |\\sigma_1, \\sigma_2 | \\rangle = \\{x/a, y/g(\\bullet_3)\\}$.\n\nRoughly speaking, the function slice-step works as follows. When the rewrite step $\\mu$ occurs at a position $w$ that is not a meaningful position of $t^\\bullet$ (in symbols, $w \\notin MPos(t^\\bullet)$), trivially $\\mu$ does not contribute to producing the meaningful symbols of $t^\\bullet$. Therefore, the function returns $s^\\bullet = t^\\bullet$, with the input compatibility condition $B^\\bullet_{\\text{prev}}$.\n\n**Example 4.15**\n\nConsider the Maude specification of Example 2.1 and the following rewrite step $\\mu$: $\\text{ac}(A,30);\\text{debit}(A,5);\\text{credit}(A,3) \\xrightarrow{\\text{debit}} \\text{ac}(A,25);\\text{credit}(A,3)$. Let $\\bullet_1;\\text{credit}(A,3)$ be a term slice of $\\text{ac}(A,25);\\text{credit}(A,3)$. Since the rewrite step $\\mu$ occurs at position $1 \\notin MPos(\\bullet_1;\\text{credit}(A,3))$, the term $\\text{ac}(A,25)$ introduced by $\\mu$ in $\\text{ac}(A,25);\\text{credit}(A,3)$ is completely ignored in $\\bullet_1;\\text{credit}(A,3)$. Hence, the computed term slice for\n\n$$\\text{ac}(A,30);\\text{debit}(A,5);\\text{credit}(A,3)$$\n\nis the very same $\\bullet_1;\\text{credit}(A,3)$.\n\nOn the other hand, when $w \\in MPos(t^\\bullet)$, the computation of $s^\\bullet$ and $B^\\bullet$ involves a more in-depth analysis of the rewrite step, which is based on an inductive refinement process that is obtained by recursively processing the conditions of the applied rule.\nMore specifically, we initially define the substitution \\( \\theta = \\{x/fresh^* \\mid x \\in Var(r)\\} \\) that binds each variable in \\( r \\) to a fresh \\( \\bullet \\)-variable. This corresponds to assuming that all the information in \\( \\mu \\), which is introduced by the substitution \\( \\sigma \\), can be marked as irrelevant. Then, \\( \\theta \\) is incrementally refined using the following two-step procedure.\n\n**Step 1.** We first compute the term slice \\( \\rho^* = slice(\\rho, MPos(Var^*(B^*_w), t_w^*)) \\cap Pos(\\rho) \\) that only records the meaningful symbols of the right-hand side \\( \\rho \\) of the rule \\( r \\) w.r.t. the set of meaningful positions of the term slice \\( t_w^* \\), including the positions of the \\( \\bullet \\)-variables that appear in \\( B^*_w \\), which are essential to correctly track back the compatibility condition computed so far. Then, by matching \\( \\rho^* \\) with \\( t_w^* \\), we generate a matcher \\( match_{\\rho^*}(t_w^*) \\) that extracts the meaningful information from \\( t_w^* \\) that is used to refine \\( \\theta \\). Formally, the computed refinement \\( \\psi^* \\) of \\( \\theta \\) is given by\n\n\\[\n\\psi^* = \\{ \\theta, match_{\\rho^*}(t_w^*) \\}.\n\\]\n\n**Example 4.16**\n\nConsider the rewrite theory in Example 2.1 together with the following rewrite step \\( \\mu_{debit} : ac(A, 30)_1; debit(A, 5) \\rightarrow ac(A, 25) \\) that involves the application (at position \\( w = \\Lambda \\)) of the debit rule whose right-hand side is \\( \\rho_{debit} = ac(Id, nb) \\). Let \\( t^* = ac(A, 1) \\) be a term slice of \\( ac(A, 25) \\) and \\( B^*_w = true \\). Then, the initially ascertained substitution for \\( \\mu \\) is \\( \\theta = \\{ Id/\\bullet_2, b/\\bullet_3, M/\\bullet_4, nb/\\bullet_5 \\} \\) and \\( \\rho^*_{debit} = slice(ac(Id, nb), MPos(\\emptyset, ac(A, 1)) \\cap Pos(ac(Id, nb))) = ac(Id, 6) \\). Finally, the refinement \\( \\psi^*_{debit} \\) of \\( \\theta \\) is given by\n\n\\[\nmatch_{\\rho^*_{debit}}(t_w^*) = match_{ac(Id, 6)}(ac(A, 1)) = \\{ Id/A, \\bullet_6 / \\bullet_1 \\}\n\\]\n\nand\n\n\\[\n\\psi^*_{debit} = \\{ \\theta, match_{\\rho^*_{debit}}(t_w^*) \\} = \\{ Id/A, b/\\bullet_3, M/\\bullet_4, nb/\\bullet_5 \\}.\n\\]\n\nThat is, \\( \\psi^*_{debit} \\) refines \\( \\theta \\) by replacing the uninformed binding \\( Id/\\bullet_2 \\), with \\( Id/A \\).\nStep 2. Let $C\\sigma = c_1\\sigma \\land \\ldots \\land c_n\\sigma$ be the instance of the condition in the rule $r$ that enables the rewrite step $\\mu$. We process each (sub)condition $c_i\\sigma$, $i = 1, \\ldots, n$, in reversed evaluation order, i.e., from $c_n\\sigma$ to $c_1\\sigma$, by using the auxiliary function $\\text{process-condition}$ given in Figure 3 that generates a pair $(\\psi_i, B^*_i)$ such that $\\psi_i$ is used to further refine the partially ascertained substitution $\\{\\psi_p, \\psi_n, \\ldots, \\psi_{i+1}\\}$ that is computed by incrementally analyzing conditions $c_n\\sigma, c_{n-1}\\sigma, \\ldots, c_{i+1}\\sigma$, and $B^*_i$ is a Boolean condition that is derived from the analysis of the condition $c_i$.\n\nWhen the whole $C\\sigma$ has been processed, we get the refinement $\\{\\psi_p, \\psi_n, \\ldots, \\psi_1\\}$, which basically encodes all the instantiations required to construct the term slice $s^*$ from $t^*$. More specifically, $s^*$ is obtained from $t^*$ by replacing the subterm $t^*|_w$ with the left-hand side $\\lambda$ of $r$ instantiated with $\\{\\psi_p, \\psi_n, \\ldots, \\psi_1\\}$. Furthermore, $B^*$ is built by collecting all the Boolean compatibility conditions $B^*_i$ delivered by $\\text{process-condition}$ and instantiating them with the composition of the computed refinements $\\psi_1, \\ldots, \\psi_n$. It is worth noting that $\\text{process-condition}$ handles rewrite expressions, equational conditions, and matching conditions differently. More specifically, the pair $(\\psi_i, B_i)$ that is returned after processing each condition $c_i$ is computed as follows.\n\nMatching conditions. Let $c$ be a matching condition with the form $p := m$ in the condition of rule $r$. During the execution of the step $\\mu : s \\xrightarrow{r,\\sigma,w} t$, recall that $c$ is evaluated as follows: first, $m\\sigma$ is reduced to its canonical form $m\\sigma \\downarrow_\\Delta$, and then the condition $m\\sigma \\downarrow_\\Delta =_B p\\sigma$ is checked. Therefore, the analysis of the matching condition $p := m$ during the slicing process of $\\mu$ implies slicing the (internal) execution trace $T_{\\text{int}} = m\\sigma \\rightarrow^* p\\sigma$, which is done by recursively invoking the function $\\text{backward-slicing}$ for execution trace slicing with respect to the slicing criterion given by slicing the term $p\\sigma$ w.r.t. the meaningful positions of the term slice $p\\theta$ of $p$, where $\\theta$ is a refinement that records the meaningful information computed so far. That is, $[(m\\sigma)^* \\rightarrow^* (p\\sigma)^*, B^*] = \\text{backward-slicing}(m\\sigma \\rightarrow^* p\\sigma, \\text{slice}(p\\sigma, \\mathcal{MP}os(p\\theta)))$. The result delivered by the function $\\text{backward-slicing}$ is a trace slice $(m\\sigma)^* \\rightarrow^* (p\\sigma)^*$ with compatibility condition $B^*$.\n\nIn order to deliver the final outcome for the matching condition $p := m$, we first compute the term slice $m^* = \\text{slice}(m, \\mathcal{MP}os(\\text{Var}^*(B^*), (m\\sigma)^* \\cap \\mathcal{P}os(m)))$. Then, by matching $m^*$ with $(m\\sigma)^*$, the algorithm yields a matcher $\\psi$ that extracts the meaningful information from $(m\\sigma)^*$ that will be used to refine the input substitution $\\theta$. Finally, the pair $(\\psi, B^*)$ is returned.\n\nExample 4.17\n\nConsider the rewrite step $\\mu_{\\text{debit}}$ of Example 4.16 together with the refined substitution $\\theta = \\{\\text{Id}/A, b\\cdot 3, M/\\cdot 4, nb/\\cdot 1\\}$. We process the condition\n\n$$\\text{nb} := b - M$$\nof debit by considering an internal execution trace $T_{int} = 30 - 5 \\rightarrow 25$. By invoking the backward-slicing function with the slicing criterion given by $\\text{slice}(25, M\\text{Pos}(\\bullet_1)) = \\bullet_6$, the resulting trace slice is $[\\bullet_6 \\rightarrow \\bullet_6, \\text{true}]$. Then, the final outcome is given by computing $m^* = \\text{slice}(30 - 5, M\\text{Pos}(\\emptyset, \\bullet_6) \\cap \\text{Pos}(30 - 25)) = \\bullet_7$ and $\\psi = \\text{match}_{\\bullet_7}(\\bullet_6)$, which is the substitution $\\{\\bullet_7/\\bullet_6\\}$.\n\n- **Rewrite expressions.** The case when $c$ is a rewrite expression $m \\Rightarrow p$ is handled similarly to the case of a matching equation $p := m$, with the difference that $m$ can be reduced by using the rules of $R$ in addition to equations and axioms.\n\n- **Equational conditions.** During the execution of the rewrite step $\\mu : s ^{r,s,w} \\rightarrow t$, the instance $e\\sigma$ of an equational condition $e$ in the condition of the rule $r$ is just fulfilled or falsified, but it does not bring any instantiation into the output term $t$. Therefore, when processing $e\\sigma$, no meaningful information to further refine the partially ascertained substitution $\\theta$ must be added. However, the equational condition $e$ must be recorded in order to compute the compatibility condition $B^*$ for the considered conditional rewrite step. In other words, after processing an equational condition $e$, we deliver the tuple $(\\psi, B^*)$, with $\\psi = \\{\\}$ and $B^* = e\\theta$. Note that the condition $e$ is instantiated with the substitution $\\theta$, in order to transfer only the meaningful information of $e\\sigma$, computed so far, in $e$.\n\n**Example 4.18**\n\nConsider the refined substitution given in Example 4.17\n\n$$\\theta = \\{\\text{Id}/\\text{A}, \\text{b}/\\bullet_3, \\text{M}/\\bullet_4, \\text{nb}/\\bullet_1\\}$$\n\ntogether with the rewrite step $\\mu_{\\text{debit}}$ of Example 4.16 that involves the application of the debit rule. After processing the condition $\\text{b} \\geq \\text{M}$ of debit, we deliver $B^* = (\\bullet_3 \\geq \\bullet_4)$.\n\n**4.4. Correctness of Backward Trace Slicing**\n\nGiven an execution trace $T : s_1 \\rightarrow \\ldots s_n$ in a rewrite theory $\\mathcal{R}$ and a slicing criterion $s_n^*$, the call $\\text{backward-slicing}(T, s_n^*)$ always produces a trace slice for $T$ w.r.t. $s_n^*$ that is weakly correct. This result is formalized in the following theorem which establishes the weak correctness of backward trace slicing.\n\n---\n\n5 Note that the trace $30-5\\rightarrow25$ involves an application of the Maude built-in operator “-”. Given a built-in operator $\\text{op}$, in order to handle the reduction $a \\text{ op } b \\rightarrow c$ as an ordinary rewrite step, we add the rule $a \\text{ op } b \\Rightarrow c$ to the considered rewrite theory.\nTheorem 4.19 (weak correctness) Let $\\mathcal{R}$ be a conditional rewrite theory. Let $\\mathcal{T} : s_0 \\rightarrow^{r_1, \\sigma_1^{w_1}} \\ldots \\rightarrow^{r_n, \\sigma_n^{w_n}} s_n$ be an execution trace in the rewrite theory $\\mathcal{R}$, with $n \\geq 0$, and let $s_n^*$ be a slicing criterion for $\\mathcal{T}$. Then, the pair $[s_0^* \\rightarrow \\ldots \\rightarrow s_n^*, B_n^*]$ computed by $\\text{backward-slicing}(\\mathcal{T}, s_n^*)$ is a weakly correct trace slice of $\\mathcal{T}$ w.r.t $s_n^*$.\n\nGiven an arbitrary rewrite theory, the outcome of $\\text{backward-slicing}(\\mathcal{T}, s_n^*)$ might not be a strongly correct trace slice. For instance, when considering a rewrite rule that includes a matching condition $p := m$ or a rewrite expression $m \\Rightarrow p$ such that the evaluation of $m$ depends on the evaluation of some equational condition $e$, it could happen that $e$ is not recorded in $B_n^*$ because the evaluation of $m$ is found to be irrelevant. In this scenario, we would lose the equational condition $e$ that might be essential to enforce the strong correctness of the trace slice. Let us see an example.\n\nExample 4.20\n\nConsider the conditional rewrite theory $\\mathcal{R}$ that contains the following rewrite rules:\n\n$$\n\\begin{align*}\n r_1 & : g(y) \\rightarrow p(z) \\text{ if } z := f(y) \\\\\n r_2 & : f(x) \\rightarrow 5 \\text{ if } x > 1\n\\end{align*}\n$$\n\nand the execution trace $\\mathcal{T} : g(3) \\rightarrow p(5)$. Note that the considered rewrite step implies the evaluation of the matching condition $z := f(y)$ that depends on rule $r_2$ which contains the equational condition $x > 1$.\n\nLet $p(\\bullet_1)$ be a slicing criterion for $\\mathcal{T}$ which considers irrelevant the value computed by the matching condition $z := f(y)$. Then, $\\text{backward-slicing}(\\mathcal{T}, p(\\bullet_1))$ yields the trace slice $[g(\\bullet_2) \\rightarrow p(\\bullet_1), \\text{true}]$, that is not strongly correct. Indeed, there exists the concretization $g(1)$ compatible with $\\text{true}$ that cannot be rewritten to $p(1)$ by using the rule $r_1$.\n\nThe next definition formalizes a class of rewrite theories for which strong correctness of backward trace slicing can be guaranteed, that is, the $\\text{backward-slicing}$ function only computes strongly correct trace slices. Roughly speaking, a rewrite theory satisfies the separation property if and only if it does not contain a mixture of equational conditions, rewrite expressions, and matching conditions. More formally,\n\nDefinition 4.21 A conditional rewrite theory satisfies the separation property iff one of the two following clauses holds:\n\n- all the conditional rewrite rules and equations of $\\mathcal{R}$ only contain equational conditions;\n- all the conditional rewrite rules and equations of $\\mathcal{R}$ only contain matching conditions or rewrite expressions.\n**Theorem 4.22 (strong correctness)** Let $\\mathcal{R}$ be a conditional rewrite theory that satisfies the separation property. Let $T : s_0 \\xrightarrow{r_1,\\sigma_1,w_1} \\cdots \\xrightarrow{r_n,\\sigma_n,w_n} s_n$ be an execution trace in the rewrite theory $\\mathcal{R}$, with $n > 0$, and let $s^*_n$ be a slicing criterion for $T$. Then, the pair $[s^*_0 \\rightarrow \\cdots \\rightarrow s^*_n, B^*_0]$ computed by backward-slicing$(T, s^*_n)$ is a strongly correct trace slice of $T$ w.r.t $s^*_n$.\n\nThe proofs of Theorem 4.19 and Theorem 4.22 can be found in Appendix A.\n\n5. **The iJULIENNE system**\n\nOur trace slicing methodology for conditional RWL computations has been implemented in the slicing-based trace analysis tool iJULIENNE which is available at [21]. The engine of iJULIENNE is written in Maude and consists of about 250 Maude function definitions (approximately 1.5K lines of source code). iJULIENNE is a stand-alone application (which can be invoked as a Maude command or used online through a Java web service) that allows the analysis of general rewrite theories that may contain (conditional) rules and equations, built-in operators, and algebraic axioms. The implementation uses meta-level capabilities and relies on the very efficient Maude system [16]. Actually, the current version of the Maude interpreter can do more than 3 million rewrites per second on state-of-the-art processors, and the Maude compiler can reach up to 15 million rewrites per second. Its user interface is based on the AJAX technology, which allows the Maude engine to be used through the WWW.\n\niJULIENNE generalizes and supersedes previous trace slicing tools such as the trace slicer for unconditional RWL theories described in [9], and the conditional slicer JULIENNE presented in [11].\n\nThe architecture of iJULIENNE, which is depicted in Figure 5, consists of four main modules named **IT-Builder**, **Maude Slicer**, **Query Handler**, and **Pretty-Printer**.\nThe **IT-Builder** is a pre-processor that obtains a suitable, instrumented trace meta-representation where all internal algebraic axiom applications are made explicit.\n\nThe **Maude Slicer** module provides incremental trace slicing and dynamic program slicing facilities. Both of these techniques are developed by using Maude reflection and meta-level functionality. On one hand, the **Trace Slicer** implements a greatly enhanced, incremental extension of the conditional backward trace slicing algorithm of [9, 10] in which the slicing criteria can be repeatedly refined and the corresponding trace slices are automatically obtained by simply discarding the pieces of information affected by the updates. Thanks to incrementality, trace slicing, analysis and debugging times are significantly reduced. On the other hand, the companion **Program Slicer** can be used to discard the program equations and rules that are not responsible for producing the set of target symbols in the observed trace state. Rather than simply glueing together the program equations and rules that are used in the simplified trace, it just delivers a program fragment that is proved to influence the observed result. In other words, not only are the unused program data and rules removed but the data and rules that are used in subcomputations that are irrelevant to the criterion of interest are also removed.\n\nThe way in which the slicing criteria are defined has been greatly improved in **iJulienne**. Besides supporting mouse click events that can select any information piece in the state, a **Query handling** facility is included that allows huge execution traces to be queried by simply providing a filtering pattern (the query) that specifies a set of symbols to monitor and also selects those states that match the pattern. A pattern language with wild cards ? and _ is used to identify (resp. discard) the relevant (resp. irrelevant) data inside the states.\n\nFinally, the **Pretty-Printer** delivers a more readable representation of the trace (transformed back to sort String) that aims to favor better inspection and debugging within the Maude formal environment. Moreover, it provides the user with an advanced view where the irrelevant information can be displayed or hidden, depending on the interest of the user. This can also be done by automatically downgrading the color of those parts of the trace that contain subterms that are rooted by relevant symbols but that only have irrelevant children.\n\n6. **iJulienne at work**\n\nIn general, conventional debugging is an inefficient and time-consuming approach for understanding program behavior, especially when a programmer is interested in observing only those parts of the program execution that relate to the incorrect output. In order to make program debugging and comprehension more efficient, it is important to focus the programmer’s attention on the essential components (actions, states, equations and rules) of the program and their execution. Backward trace slicing provides a means to achieve this by pruning away the unrelated pieces of the computation [22].\nmod BANK_ERR is inc INT .\nsorts Account Msg State Id .\nsubsorts Account Msg < State .\nvar Id Id1 Id2 : Id .\nvar b b1 b2 nb nb1 nb2 M : Int .\nop empty-state : -> State .\nop ac : Id Int -> Account [ctor] .\nops A B C D : Id .\nops credit debit : Id Int -> Msg [ctor] .\nop transfer : Id Id Int -> Msg [ctor] .\ncrl [credit] : credit(Id,M);ac(Id,b) => ac(Id,nb) if nb := b+M .\ncrl [debitERR] : debit(Id,M);ac(Id,b) => ac(Id,nb) if nb := b-M .\ncrl [transfer] : transfer(Id1, Id2,M);ac(Id1,b1);ac(Id2,b2) => ac(Id1,nb1);ac(Id2,nb2)\n if debit(Id1,M);ac(Id1,b1) => ac(Id1,nb1) /\n credit(Id2,M);ac(Id2,b2) => ac(Id2,nb2) .\nendm\n\nFigure 6: Faulty Maude specification of a distributed banking system.\n\n6.1. Debugging Maude programs with iJULIENNE\n\nIn debugging, one is often interested in analyzing a particular execution of a program that exhibits anomalous behavior. However, the execution of Maude programs typically generates large and clumsy traces that are hard to browse and understand even when the programmer is assisted by tracing tools such as the Maude built-in tracing facility. This is because the tracer does not provide any means for identifying the contributing program parts of the program being debugged, and does not allow the programmer to distinguish related computations from unrelated computations. The inspection of these traces for debugging purposes is thus a cumbersome task that very often leads to no conclusion. In this scenario, backward trace slicing can play a meaningful role, since it can automatically reduce the size of the analyzed execution trace keeping track of all and only those symbols that impact on an error or anomaly in the trace.\n\nBasically, the idea is to feed iJULIENNE with an execution trace \\( T \\) that represents a wrong behavior of a given Maude program, together with a slicing criterion that observes an erroneous outcome. The resulting trace slice is typically much smaller than the original one, since it only includes the information that is responsible for the production of the erroneous outcome. Thus, the programmer can easily navigate through the trace slice and repeatedly refine the slicing criteria for program bugs to hunt, as shown in the following examples.\n\nExample 6.1\n\nConsider the Maude program BANK_ERR of Figure 6 which is a faulty mutation of the distributed banking system specified in Figure 1. More precisely, the rule debit has been replaced by the rule debitERR in which we have intentionally omitted the equational condition \\( M \\leq b \\). Roughly speaking, the considered specification always authorizes withdrawals even in the erroneous case when the amount of money to be withdrawn is greater than the account balance.\n\nConsider an execution trace \\( T_{\\text{bank}} \\) in program BANK_ERR that starts in the initial state...\n<table>\n<thead>\n<tr>\n<th>Step</th>\n<th>RuleName</th>\n<th>Execution trace</th>\n<th>Sliced trace</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Start</td>\n<td><code>ac(A,50); ac(B,20); ac(C,20); ac(D,20); credit(A,10); credit(D,40); debit(C,50); debit(D,5); transfer(A,C,15); transfer(A,D,20); transfer(B,C,4)</code></td>\n<td><code>ac(*); ac(*); ac(*); ac(*); credit(*); credit(*); debit(*); debit(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>2</td>\n<td>unfattening</td>\n<td><code>ac(B,20); ac(C,20); ac(D,20); credit(D,40); debit(C,50); debit(D,5); transfer(A,C,15); transfer(A,D,20); transfer(B,C,4); ac(A,50); credit(A,10)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>3</td>\n<td>credit</td>\n<td><code>ac(B,20); ac(C,20); ac(D,20); credit(D,40); debit(C,50); debit(D,5); transfer(A,C,15); transfer(A,D,20); transfer(B,C,4); ac(A,50)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>4-5</td>\n<td>flat-unflat</td>\n<td><code>ac(A,60); ac(B,20); ac(C,20); debit(C,50); debit(D,5); transfer(A,C,15); transfer(A,D,20); transfer(B,C,4); ac(D,20); credit(D,40)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>6</td>\n<td>credit</td>\n<td><code>ac(A,60); ac(B,20); ac(C,20); debit(C,50); debit(D,5); transfer(A,C,15); transfer(A,D,20); transfer(B,C,4); ac(D,60)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>7-8</td>\n<td>flat-unflat</td>\n<td><code>ac(A,60); ac(B,20); ac(D,20); debit(D,5); transfer(A,C,15); transfer(A,D,20); transfer(B,C,4); ac(C,20); debit(C,50)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>9</td>\n<td>debitERR</td>\n<td><code>ac(A,60); ac(B,20); ac(D,60); debit(D,5); transfer(A,C,15); transfer(A,D,20); transfer(B,C,4); ac(C,30)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>10-11</td>\n<td>flat-unflat</td>\n<td><code>ac(A,60); ac(B,20); ac(C,30); transfer(A,C,15); transfer(A,D,20); transfer(B,C,4); ac(C,60); debit(D,5)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>12</td>\n<td>debitERR</td>\n<td><code>ac(A,60); ac(B,20); ac(C,30); transfer(A,C,15); transfer(A,D,20); transfer(B,C,4); ac(D,55)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>13-14</td>\n<td>flat-unflat</td>\n<td><code>ac(A,20); ac(D,55); transfer(A,D,20); transfer(B,C,4); ac(A,60); ac(C,30); transfer(A,C,15)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>15</td>\n<td>transfer</td>\n<td><code>ac(A,20); ac(D,55); transfer(A,D,20); transfer(B,C,4); ac(A,45); ac(C,15)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>16-17</td>\n<td>flat-unflat</td>\n<td><code>ac(A,20); ac(C,15); transfer(B,C,4); ac(A,45); ac(D,55); transfer(A,D,20)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>18</td>\n<td>transfer</td>\n<td><code>ac(A,20); ac(C,15); transfer(B,C,4); ac(A,25); ac(D,75)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>19-20</td>\n<td>flat-unflat</td>\n<td><code>ac(A,25); ac(D,75); ac(C,15); transfer(B,C,4)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>21</td>\n<td>transfer</td>\n<td><code>ac(A,25); ac(D,75); ac(C,11); ac(D,75)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>22</td>\n<td>flattening</td>\n<td><code>ac(A,25); ac(B,16); ac(C,-11); ac(D,75)</code></td>\n<td><code>ac(*); ac(*); ac(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*); transfer(*)</code></td>\n</tr>\n<tr>\n<td>Total size:</td>\n<td>1689</td>\n<td>295</td>\n<td>Reduction: 83%</td>\n</tr>\n</tbody>\n</table>\n\nTable 1: $i$JULIENNE output for the trace $T_{bank}$ w.r.t. the criterion $ac(C,-11)$\n\n```\nac(A,50); ac(B,20); ac(D,20); ac(C,20); transfer(B,C,4); transfer(A,C,15); debit(D,5); credit(A,10); transfer(A,D,20); debit(C,50); credit(D,40)\n```\n\nand ends in the final state\n\n```\nac(A,25); ac(B,16); ac(D,75); ac(C,-11)\n```\n\nWe observe that the final state contains a negative balance for client C, which is a clear symptom of malfunction of the $BANK\\_ERR$ specification, if we assume that balances must be non-negative numbers according to the semantics intended by the programmer. Therefore, we execute $i$JULIENNE on the trace $T_{bank}$ w.r.t. the slicing criterion that observes the term $ac(C,-11)$ in order to determine the cause of such a negative balance. The output delivered by $i$JULIENNE is given in Table 1 and shows the (instrumented)\ninput trace $\\mathcal{T}_{bank}$ in the **Execution Trace** column, the simplified trace $\\mathcal{T}^\\star_{bank}$ in the **Sliced trace** column, the computed compatibility condition, and some other auxiliary data such as the size of the two traces, the reduction rate achieved, and the rules that have been applied in $\\mathcal{T}_{bank}$ and $\\mathcal{T}^\\star_{bank}$.\n\nIt is worth noting that the trace slice $\\mathcal{T}^\\star_{bank}$ greatly simplifies the trace $\\mathcal{T}_{bank}$ by deleting all the bank accounts and account operations that are not related to the client $C$ as well as all the internal flat/unflat rewrite steps, which are needed to implement rewriting modulo associativity and commutativity. In fact, the computed reduction rate is 83%, which clearly shows the drastic pruning that we have obtained.\n\nNow, a quick inspection of $\\mathcal{T}^\\star_{bank}$ allows the existence of a misbehaving account operation to be recognized. Specifically, state 9 in the trace slice $\\mathcal{T}^\\star_{bank}$ has been obtained by reducing the term $\\text{debit}(C, 50)$ by means of the rule $\\text{debitERR}$ even though the current balance of $C$ was only 20. This suggests to us that $\\text{debit}_\\text{ERR}$ might be faulty since it does not conform to its intended semantics, which forbids any withdrawal greater than the current funds available.\n\nThe following example illustrates how debugging activities can be greatly improved by using the incremental trace slicing facility provided by *iJulienne*.\n\n**Example 6.2**\n\nConsider the Maude program **BLOCKS-WORLD** of Figure [7], which is a faulty mutation of one of the most popular planning problems in artificial intelligence. We assume that there are some blocks, placed on a table, that can be moved by means of a robot arm; the goal of the robot arm is to produce one or more vertical stacks of blocks. In our specification, which is shown in the Maude module **BLOCKS-WORLD** of Figure [7], we define a Blocks World system with three different kinds of blocks that are defined by means of the operators $a$, $b$, and $c$ of sort $\\text{Block}$. Different blocks have different sizes that are described by using the unary operator $\\text{size}$. We also consider some operators that formalize block and robot arm properties whose intuitive meanings are given in the accompanying program comments.\n\nThe states of the system are modeled by means of associative and commutative lists of properties of the form $\\text{prop}_1 & \\text{prop}_2 & \\ldots & \\text{prop}_n$, which describe any possible configuration of the blocks on the table as well as the status of the robot arm.\n\nThe system behavior is formalized by four, simple rewrite rules that control the robot arm. Specifically, the $\\text{pickup}$ rule describes how the robot arm grabs a block from the table, while $\\text{putdown}$ rule corresponds to the inverse move. The $\\text{stack}$ and $\\text{unstack}$ rules respectively allow the robot arm to drop one block on top of another block and to remove a block from the top of a stack. Note that the conditional $\\text{stack}$ rule forbids a given block $B_1$ from being piled on a block $B_2$ if the size of $B_1$ is greater than the size of $B_2$.\n\nBarely perceptible, the Maude specification of Figure [7] fails to provide a correct Blocks World implementation. By using the **BLOCKS-WORLD** module, it is indeed possible\nto derive system states that represent erroneous configurations. For instance, the initial state\n\n\\[ s_1 = \\text{empty} \\& \\text{clear}(a) \\& \\text{table}(a) \\& \\text{clear}(b) \\& \\text{table}(b) \\& \\text{clear}(c) \\& \\text{table}(c) \\]\n\ndescribes a simple configuration where the robot arm is empty and there are three blocks \\( a, b, \\) and \\( c \\) on the table. It can be rewritten in 7 steps to the state\n\n\\[ s_f = \\text{empty} \\& \\text{empty} \\& \\text{table}(b) \\& \\text{table}(c) \\& \\text{clear}(a) \\& \\text{clear}(c) \\& \\text{on}(a,b) \\]\n\nwhich clearly indicates a system anomaly since it shows the existence of two empty robot arms!\n\nTo find the cause of this wrong behavior, we feed \\( i\\text{JULIENNE} \\) with the faulty rewrite sequence \\( \\mathcal{T} = s_1 \\rightarrow^* s_f \\), and we initially slice \\( \\mathcal{T} \\) w.r.t. the slicing criterion that observes the two anomalous occurrences of the \\text{empty} property and the stack \\text{on}(a,b) in State \\( s_f \\). This task can be easily performed in \\( i\\text{JULIENNE} \\) by first highlighting the terms that we want to observe in State \\( s_f \\) with the mouse pointer and then starting the slicing process. \\( i\\text{JULIENNE} \\) yields a trace slice that simplifies the original trace by recording only those data that are strictly needed to produce the considered slicing criterion. Also, it automatically computes the corresponding program slice, which consists of the equations defining the \\text{size} operator together with the \\text{pickup} and \\text{stack} rules (see Figure 8). This allows us to deduce that the malfunction is located in one or more rules and equations that are included in the program slice.\n\nThe generated trace slice is then browsed backwards using the \\( i\\text{JULIENNE} \\)'s navigation facility in search of a possible explanation for the wrong behavior. During this\nSlicing-based Trace Analysis of Rewriting Logic Specifications with JULIENNE\nMaría Alpuente, Demis Ballis, Francisco Frechina and Julia Sapiña\n\nAbstract\n\nExamples\n\nDownload\n\nBenchmarks\n\nOnline Trace Analyzer\n\nProgram Slice\n\nYou can mark the relevant data by either: 1) highlighting the symbols in the chosen state, or 2) querying the trace and selecting one of the resulting matching states (the relevant data will be automatically inferred).\n\nPhase, we focus our attention on State 3 (Figure 9), which is inconsistent since it models a robot arm that is holding block a and is empty at the same time. Therefore, we decide to further refine the trace slice by incrementally applying backward trace slicing to State 3 w.r.t. the slicing criterion hold(a). This way we achieve a supplementary reduction of the previous trace slice in which we can easily observe that hold(a) only depends on the clear(a) and table(a) properties (see Figure 10). Furthermore, the computed program slice includes the single pickup rule (see Figure 11). Thus, we can conclude that:\n**Trace Analysis Phase**\n\nYou can mark the relevant data by either: 1) highlighting the symbols in the chosen state, or 2) querying the trace and selecting one of the resulting matching states (the relevant data will be automatically inferred).\n\n\n\n**Program Slice**\n\n```plaintext\nmod BLOCKS-WORLD is inc INT .\nsorts Block Prop State .\nsubsort Prop < State .\nops a b c : -> Block .\nop table : Block -> Prop . *** block is on the table\nop on : Block Block -> Prop . *** block a is on block b\nop clear : Block -> Prop . *** block is clear\nop hold : Block -> Prop . *** robot arm holds the block\nop empty : -> Prop . *** robot arm is empty\nop &_ : State State -> State [assoc comm].\nop sizes : Block -> Nat .\nvars X Y : Block .\neq [sizeA] : size(a) = 1 .\neq [sizeB] : size(b) = 2 .\neq [sizeC] : size(c) = 3 .\nrl [pickup] : clear(X) & table(X) => hold(X) .\nrl [putdown] : hold(X) => empty & clear(X) & table(X) .\nrl [unstack] : empty & clear(X) & on(X,Y) => hold(X) & clear(Y) .\ncrl [stack] : hold(X) & clear(Y) => empty & clear(X) & on(X,Y) if size(X) < size(Y) .\nendm\n```\n\n\n\n1. the malfunction is certainly located in the pickup rule (since the computed program slice only contains that rule);\n2. the pickup rule does not depend on the status of the robot arm (this is witnessed by the fact that hold(a) only relies on the clear(a) and table(a) properties);\n3. by 1 and 2, we can deduce that the pickup rule is incorrect, as it never checks the emptiness of the robot arm before grasping a block.\n\nA possible fix of the detected error consists in including the empty property in the\nleft-hand side of the **pickup** rule, which enforces the robot arm to always be idle before picking up a block. The corrected version of the rule is hence as follows:\n\n\\[\n\\text{rl [pickup]} : \\text{empty} \\& \\text{clear}(X) \\& \\text{table}(X) \\Rightarrow \\text{hold}(X).\n\\]\n\n6.2. **Trace querying with iJulienne**\n\nExecution traces of programs are a helpful source of information for program comprehension. However, they provide such a low-level picture of program execution that users may experience several difficulties in interpreting and analyzing them. Trace querying [23] allows a given execution trace to be analyzed at a higher level of abstraction by selecting only a subtrace of it that the user considers relevant.\n\nTrace querying of Maude execution traces is naturally supported and completely automated by iJulienne. Indeed, execution traces can be simply queried by providing a slicing criterion (in the form of a filtering pattern) that specifies the target symbols the user decides to monitor. Hence, backward trace slicing is performed w.r.t. the considered criterion to compute an abstract view (i.e., the trace slice) of the original execution trace that only includes the information that is strictly required to yield the target symbols under observation. This way, users can focus their attention on the monitored data, which might otherwise be overlooked in the concrete trace.\n\nMoreover, backward trace slicing (strong) correctness provides, for free, a means to understand the program behavior w.r.t. partially-defined inputs since the computed compatibility condition constrains the possible values that non-relevant inputs (modeled by °-variables) might assume. In other words, a trace slice \\( T^* \\) can be thought of as an intensional representation of all the possible concrete traces, which are compatible concretizations of \\( T^* \\), that lead to the production of the monitored target symbols.\n\n**Example 6.3**\n\nThe Maude specification of Figure 12, inspired by a similar one in [24], specifies the operator minmax that takes as input a list of natural numbers \\( L \\) and computes a pair \\((m,M)\\) where \\( m \\) (resp., \\( M \\)) is the minimum (resp., maximum) of \\( L \\).\n\nLet \\( T_{\\text{minmax}} \\) be the execution trace that reduces the input term \\( \\text{minmax}(4;7;0) \\) to the normal form \\( \\text{PAIR}(0,7) \\). Now, assume that we are only interested in analyzing the subtrace that generates 0 in \\( \\text{PAIR}(0,7) \\) —i.e., the minimum of the list \\( 4;7;0 \\).\n\nThus, we can query \\( T_{\\text{minmax}} \\) by specifying the pattern \\( \\text{PAIR}(?,_) \\) that allows us to trace back only the first argument of \\( \\text{PAIR} \\), while the second one is discarded. iJulienne generates the trace slice \\( T^*_{\\text{minmax}} \\), given in Table 2, whose compatibility condition is \\( C^* = \\bullet_1 > 0 \\land \\bullet_3 > 0 \\). The slice \\( T^*_{\\text{minmax}} \\) isolates all and only those function calls in the trace \\( T \\) that must be reduced to yield the minimum of the list \\( 4;7;0 \\). Now, by analyzing the trace slice, it is immediate to see that the operators 2nd and Max do not affect the observed result since they are not used in the trace slice. Also, by the correctness of our\nmod MINMAX is inc INT .\nsorts List Pair .\nsubsorts Nat < List .\nop _ ;_ : List List -> List [ctor assoc] .\nop PAIR : Nat Nat -> Pair .\nop 1st : Pair -> Nat .\nop 2nd : Pair -> Nat .\nop Max : Nat Nat -> Nat .\nop Min : Nat Nat -> Nat .\nop minmax : List -> Pair .\nvar N X Y : Nat .\nvar L : List .\ncrl [Max1] : Max(X,Y) => X if X >= Y .\ncrl [Max2] : Max(X,Y) => Y if X < Y .\ncrl [Min1] : Min(X,Y) => Y if X > Y .\ncrl [Min2] : Min(X,Y) => X if X <= Y .\nrl [1st] : 1st(PAIR(X,Y)) => X .\nrl [2nd] : 2nd(PAIR(X,Y)) => Y .\nrl [minmax1] : minmax(N) => PAIR(N,N) .\nrl [minmax2] : minmax(N ; L) => PAIR(Min(N,1st(minmax(L))) , Max(N,2nd(minmax(L)))) .\nendm\n\nFigure 12: Maude specification of the minmax function\n\n<table>\n<thead>\n<tr>\n<th>Step</th>\n<th>RuleName</th>\n<th>Execution trace</th>\n<th>Sliced trace</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Start</td>\n<td>minmax(4 ; 7 ; 0)</td>\n<td>minmax(4 ; 7 ; 0)</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Unflattening</td>\n<td>minmax(4 ; 7 ; 0)</td>\n<td>minmax(4 ; 7 ; 0)</td>\n</tr>\n<tr>\n<td>3</td>\n<td>minmax2</td>\n<td>PAIR(Min(4,1st(minmax(7 ; 0))),Max(4,2nd(minmax(7 ; 0))))</td>\n<td>PAIR(Min(4,1st(minmax(7 ; 0))),Max(4,2nd(minmax(7 ; 0))))</td>\n</tr>\n<tr>\n<td>4</td>\n<td>minmax2</td>\n<td>PAIR(Min(4,1st(PAIR(Min(7,1st(minmax(0))),Max(7,2nd(minmax(0)))))),Max(4,2nd(minmax(7 ; 0))))</td>\n<td>PAIR(Min(4,1st(PAIR(Min(7,1st(minmax(0))),Max(7,2nd(minmax(0)))))),Max(4,2nd(minmax(7 ; 0))))</td>\n</tr>\n<tr>\n<td>5</td>\n<td>1st</td>\n<td>PAIR(Min(4,Min(7,1st(minmax(0)))),Max(4,2nd(minmax(7 ; 0))))</td>\n<td>PAIR(Min(4,Min(7,1st(minmax(0)))),Max(4,2nd(minmax(7 ; 0))))</td>\n</tr>\n<tr>\n<td>6</td>\n<td>minmax2</td>\n<td>PAIR(Min(4,Min(7,1st(minmax(0)))),Max(4,2nd(PAIR(Min(7,1st(minmax(0)))),Max(7,2nd(minmax(0)))))))</td>\n<td>PAIR(Min(4,Min(7,1st(minmax(0)))),Max(4,2nd(PAIR(Min(7,1st(minmax(0)))),Max(7,2nd(minmax(0)))))))</td>\n</tr>\n<tr>\n<td>7</td>\n<td>2nd</td>\n<td>PAIR(Min(4,Min(7,1st(minmax(0)))),Max(4,Max(7,2nd(minmax(0))))))</td>\n<td>PAIR(Min(4,Min(7,1st(minmax(0)))),Max(4,Max(7,2nd(minmax(0))))))</td>\n</tr>\n<tr>\n<td>8</td>\n<td>minmax1</td>\n<td>PAIR(Min(4,Min(7,1st(PAIR(0,0)))),Max(4,Max(7,2nd(minmax(0))))))</td>\n<td>PAIR(Min(4,Min(7,1st(PAIR(0,0)))),Max(4,Max(7,2nd(minmax(0))))))</td>\n</tr>\n<tr>\n<td>9</td>\n<td>1st</td>\n<td>PAIR(Min(4,Min(7,0)),Max(4,Max(7,2nd(minmax(0))))))</td>\n<td>PAIR(Min(4,Min(7,0)),Max(4,Max(7,2nd(minmax(0))))))</td>\n</tr>\n<tr>\n<td>10</td>\n<td>Min1</td>\n<td>PAIR(Min(4,0),Max(4,Max(7,2nd(minmax(0))))))</td>\n<td>PAIR(Min(4,0),Max(4,Max(7,2nd(minmax(0))))))</td>\n</tr>\n<tr>\n<td>11</td>\n<td>Min1</td>\n<td>PAIR(0,Max(4,Max(7,2nd(minmax(0))))))</td>\n<td>PAIR(0,Max(4,Max(7,2nd(minmax(0))))))</td>\n</tr>\n<tr>\n<td>12</td>\n<td>minmax1</td>\n<td>PAIR(0,Max(4,Max(7,2nd(PAIR(0,0))))))</td>\n<td>PAIR(0,Max(4,Max(7,2nd(PAIR(0,0))))))</td>\n</tr>\n<tr>\n<td>13</td>\n<td>2nd</td>\n<td>PAIR(0,Max(4,Max(7,0))))</td>\n<td>PAIR(0,Max(4,Max(7,0))))</td>\n</tr>\n<tr>\n<td>14</td>\n<td>Max1</td>\n<td>PAIR(0,Max(4,7))</td>\n<td>PAIR(0,Max(4,7))</td>\n</tr>\n<tr>\n<td>15</td>\n<td>Max2</td>\n<td>PAIR(0,7)</td>\n<td>PAIR(0,7)</td>\n</tr>\n</tbody>\n</table>\n\nCompatibility condition: ^1 > 0 and ^3 > 0\n\nTotal size: 679 219\n\nReduction: 67%\n\nTable 2: iJulienne output for the trace $\\tau^*_{\\text{minmax}}$ w.r.t. the criterion PAIR(? ,?)\n\n30\nslicing technique, we can state that for every concrete instance $L_c$ of the partially-defined input $\\bullet_1; \\bullet_3; 0$ that meets the compatibility condition $C^*$, the minimum computed by the call $\\text{minmax}(L_c)$ will be $0$.\n\nThe $\\text{MINMAX}$ program is paradigmatic of a strategy known as introduction of mutual recursion, which separates a single function yielding pairs into the pair of its component functions (slices) \\[25\\]. Thus in a sense, the same effect (trace slicing) could be obtained for this example by slicing the source code in Maude before trace inspection.\n\nIn the following example, the trace querying capabilities of $i\\text{JULIENNE}$ are used to simplify the counter-examples traces provided by Web-TLR \\[5\\], a RWL-based tool that allows real-size web applications to be formally specified and verified by using the built-in Maude model-checker, thus facilitating their analysis. In Web-TLR, a web application is formalized by means of a Maude specification and then checked against a property specified in the $\\text{Linear Temporal Logic of Rewriting}$ (LTLR \\[26\\]), which is a temporal logic specifically designed to model-check rewrite theories. A property is refuted by the LTLR model-checker by issuing a counter-example in the form of a rewrite sequence that reveals some undesired, erroneous behavior. Our example reproduces a typical trace analysis session that operates on the Maude specification of a complex webmail application checked with Web-TLR.\n\n\\textbf{Example 6.4}\n\nConsider the webmail application written in Maude given in \\[5\\] that models both server-side aspects (e.g., web script evaluations, database interactions) and browser-side features (e.g., forward/backward navigation, web page refreshing, window/tab openings). The web application behavior is formalized by using rewrite rules of the form \n\n\\begin{align*}\n\\text{[label]} : \\ & \\text{webState} \\Rightarrow \\text{webState},\n\\end{align*}\n\nwhere $\\text{webState}$ is a triple that we represent with the following operator $\\ || || : (\\text{Browsers} \\times \\text{Message} \\times \\text{Server}) \\rightarrow \\text{webState}$ that can be interpreted as a system shot that captures the current configuration of the active browsers (i.e., the browsers currently using the webmail application) together with the channel through which the browsers and the server communicate via message-passing. An execution trace specifies a sequence of $\\text{webState}$ transitions that represents a possible execution of the webmail application.\n\nThe trace slicing session starts by loading the Maude webmail specification, together with the execution trace to be analyzed, into the $i\\text{JULIENNE}$ trace analyzer. The trace can be directly pasted in the input form or uploaded from a trace file that was written off-line. It can also be dynamically computed by the system (using Maude meta-search capabilities) by introducing the initial and final states of the trace. In Figure 13, we directly fed $i\\text{JULIENNE}$ with an execution trace that represents a counter-example that was automatically generated by the Maude LTLR model-checker. The considered trace consists of 97 states, each of which has about 5,000 characters.\n\nThe aim of our analysis is to extract the navigation path of a possible malicious user $\\text{idA}$ within the web application from the execution trace. This is particularly hard to\n**Execution trace**\n\nEnter the execution trace by providing either: 1) a term of sort Trace (output by Maude), or 2) the first and last state of the trace (to be automatically reconstructed).\n\nMaude term of sort Trace:\n\n```\n[0x0], [0x0], [0x0], [0x0], [0x0], [0x0]), which allows us to select all states inspected.\n```\n\nFigure 13: Loading the webmail execution trace.\n\nperform by hand since the trace is extremely large and system states contain a huge amount of data.\n\nTherefore, we decide to slice the trace with *iJULIENNE* in order to isolate only the web interactions related to user *idA*, getting rid of all the remaining unrelated information. To this end, we define the query $B(idA, \\ldots, \\ldots, \\ldots)$, which allows us to select all states in the trace that contain a browser data structure that is associated with user *idA*. Note that only the third argument of the browser data structure, which corresponds to the web page displayed on the browser, is declared relevant in the query (i.e., it is marked by the card ?). Indeed, we are interested in tracking only the web pages visited by the user *idA*. The remaining information (such as script evaluation, and web interactions with other users) is not pinpointed and, hence, will be systematically removed by the slicing tool which facilitates comprehension. By running the query, *iJULIENNE* computes the outcome shown in Figure 14, which delivers the states that satisfy the query. More concretely, the first 20 states of the trace do match the query, while the remaining 77 states do not include any web interaction with the user *idA* and thus do not need to be inspected.\n\nNow, since we are interested in observing the whole navigation history of user *idA*, we select the last state in the trace that matches the query, namely State 20, and we apply backward trace slicing on that state in order to generate a simplified view of the first 20 states of the trace. Note that the slicing criterion is automatically computed by\nProgram slicing \\cite{22} is the computation of the set of program statements, the program slice, that may affect the values at some point of interest. A program slice consists of all statements that can reach the statement of interest through paths extracted from the original program.\nThese are the states of your Trace Slice:\n- **rl [minmax2]** : minmax(N) => PAIR(N,N).\n- **rl [minmax1]** : minmax(N) => PAIR(N,N).\n- **rl [1st]** : 1st(PAIR(X,Y)) => X.\n- **crl [Min2]** : Min(X,Y) => X if X <= Y.\n- **crl [Max2]** : Max(X,Y) => Y if X < Y.\n- **crl [Max1]** : Max(X,Y) => X if X >= Y.\n\n```plaintext\nvar L : List.\n\nop Min : Nat Nat -> Nat.\n\nop Max : Nat Nat -> Nat.\n\nop 2nd : Pair -> Nat.\n\nop 1st : Pair -> Nat.\n\nop PAIR : Nat Nat -> Pair.\n\nop _;_ : List List -> List [ctor assoc].\n\nsubsorts Nat < List.\n\nsorts List Pair.\n\nmod MINMAX is inc INT.\n\nsorts List Pair.\n\nsubsorts Nat < List.\n\nop PAIR : Nat Nat -> Pair.\n\nop 2nd : Pair -> Nat.\n\nop 1st : Pair -> Nat.\n\nop Max : Nat Nat -> Nat.\n\nop Min : Nat Nat -> Nat.\n\nop List : List -> Pair.\n\nvar X : Y : Nat.\n\nvar X : Y : Nat.\n\nvar L : List.\n\ncrl [Max2] : Max(X,Y) => Y if X < Y.\n\ncrl [Min] : Min(X,Y) => Y if X > Y.\n\ncrl [Min] : Min(X,Y) => Y if X < Y.\n\nrl [last] : list(PAIR(X,Y)) => X.\n\nrl [2nd] : 2nd(PAIR(X,Y)) => Y.\n\nrl [minmax1] : minmax(N) => PAIR(N,N).\n\nrl [minmax2] : minmax(N,L) => PAIR(Min(L,1st(minmax(L))), Max(N,2nd(minmax(L)))).\n\nendm\n```\nof a subset of the statements of the original program, sometimes with the additional constraint that a slice must be a syntactically valid, executable program. Relevant applications of slicing include software maintenance, optimization, program analysis, and information flow control. An important distinction holds between static and dynamic slicing: whereas static slicing is performed with no other information than the source code itself, dynamic program slicing works on a particular execution of the program (i.e., a given execution trace) [14], hence it only reflects the actual dependencies of that execution, resulting in smaller program slices than static ones. Dynamic slicing is usually achieved by dynamic data-flow analysis along the program execution path. Although dynamic program slicing was first introduced to aid in user level debugging to locate sources of errors more easily, applications aimed at improving software quality, reliability, security and performance have also been identified as candidates for using dynamic program slicing.\n\nLet us show how backward trace slicing can support the generation of dynamic program slices by detecting unused program fragments in a given trace slice.\n\nExample 6.5\n\nConsider the trace slice $T_{\\text{minmax}}$ of Example 6.3 for the execution trace\n\n$$\\text{minmax}(4; 7; 0) \\rightarrow^* \\text{PAIR}(0, 7)$$\n\nw.r.t. the query $\\text{PAIR}(?, \\_)$. Since operations $\\text{2nd}$ and $\\text{Max}$ are never used in $T_{\\text{minmax}}$, iJulienne generates a dynamic program slice of the MINMAX Maude module by hiding\n\n- the unneeded operator and variable declarations in the program signature;\n- the rule definitions of the functions $\\text{2nd}$ and $\\text{Max}$;\n- the function calls to $\\text{2nd}$ and $\\text{Max}$ in the right-hand side of the $\\text{minmax2}$ rule.\n\nFigure 16 shows the resulting dynamic program slice.\n\n6.4. Experimental evaluation\n\niJulienne is the first slicing-based, incremental trace analysis tool for Rewriting Logic that greatly reduces the size of the computation traces and can make their analysis feasible even for complex, real-size applications. iJulienne conveys an incremental slicing approach where the user can refine the slicing criteria and then the extra redundancies (i.e., the difference of the slices) are automatically done away with. It is important to note that our trace analyzer does not remove any information that is relevant, independently of the skills of the user. We have experimentally evaluated our tool in several case studies that are available at the iJulienne web site [21] and within the distribution package, which also contains a user guide, the source files of the slicer, and related literature.\n\nTo properly assess the performance and scalability, we have tested iJulienne on several execution traces of increasing complexity. More precisely, we have considered\ntwo execution traces that model two runs of a fault-tolerant client-server communication protocol (FTCP) specified in Maude. Trace slicing has been performed according to two chosen criteria that aim at extracting information related to a specific server and client in a scenario that involves multiple servers and clients, and tracking the response generated by the server according to a given client request.\n\ntwo execution traces generated by Maude-NPA [27], which is an RWL-based analysis tool for cryptographic protocols that takes into account many of the algebraic properties of cryptosystems. These include cancellation of encryption and decryption, Abelian groups (including exclusive-or), exponentiation, and homomorphic encryption. The considered traces model two instances of a well-known man-in-the-middle attack to the Needham-Schroeder network authentication protocol [28]. Specifically, they consist of a sequence of rewrite steps that represents the messages exchanged among three entities: an initiator $A$, a receiver $B$, and an intruder $I$ that imitates $A$ to establish a network session with $B$. The chosen slicing criteria selects the intruder’s actions as well as the intruder’s knowledge at each rewrite step discarding all the remaining session information.\n\ntwo counter-examples produced by model-checking a real-size webmail application specified in Web-TLR. The chosen slicing criteria allow several critical data to be isolated and inspected —e.g., the navigation of a malicious user, the messages exchanged by a specific web browser with the webmail server, and session data of interest (e.g., browser cookies).\n\ntwo execution traces generated by the Pathway Logic Maude implementation. Pathway Logic [29] is a RWL-based approach to modeling biological entities and\nprocesses that formalizes the ordinary models that biologists commonly use to explain biological processes. Roughly speaking, Pathway logic models are Maude executable specifications whose execution traces provide a rewriting-based description of metabolic pathways. The traces that we consider in our experiments model responses to signal stimulation in epithelial-like cells. The chosen criteria allow one to detect cause and effect relations (e.g., the signal responsible for the production of an observed chemical) and select only those chemical reactions that are involved in actions of interest (e.g., protein complexing, phosphorylation).\n\nThe results of our experiments are shown in Table 3. The execution traces for the considered cases consist of sequences of 10–1000 states, each of which contains from 60 to 5000 characters. In all the experiments, not only do the trace slices that we obtained show impressive reduction rates (ranging from ∼85% to ∼95%), but we were also even able to strikingly improve these rates by an average of 8.5% (ranging from ∼97% to ∼99%) by using incremental slicing. In most cases, the delivered trace slices were cleaned enough to be easily analyzed, and we noted an increase in the effectiveness of the analysis processes. Other benchmark programs we have considered are available at the iJULIENNE web site.\n\nWith regard to the time required to perform the analyses, our implementation is rather time efficient; the elapsed times are small even for very complex traces and scale linearly. For example, running the slicer for a 20Kb trace in a Maude specification with about 150 rules and equations—with AC rewrites—took less than 1 second (480,000 rewrites per second on standard hardware, 2.26GHz Intel Core 2 Duo with 4Gb of RAM memory).\n\n7. Related Work\n\nThere are very few approaches that address the problem of tracing rewrite sequences in term rewrite systems [9, 13, 30, 31], and all of them apply to unconditional systems. The techniques in [9, 13, 30] rely on a labeling relation on symbols that allows data content to be traced back within the computation; this is achieved in [31] by formalizing a notion of dynamic dependence among symbols by means of contexts. In [13, 30], non-left linear and collapsing rules are not considered or are dealt with using ad-hoc strategies, while our approach requires no special treatment of such rules. Moreover, the first and only (unconditional) trace slicing technique that supports rules, equations, sorts, and algebraic axioms is [9].\n\nThe technique in [9] computes the reverse dependency among the symbols involved in an execution step by using a procedure (based on [30]) that dynamically labels the calls (terms) involved in the steps. This paper describes a more general slicing technique that copes with conditional rewrite theories and simplifies the formal development in [9] by getting rid of the complex dynamic labeling algorithm that was needed to trace back the origins of the symbols of interest, replacing it with a simple mechanism for\nsubstitution refinement that allows control and data dependencies to be propagated between consecutive rewrite steps. Our technique also avoids manipulating the origins by recording their addressing positions; we simply and explicitly record the origins of the meaningful positions within the computed term slices themselves, without resorting to any other artifact.\n\nWe are not aware of any trace slicer that is comparable to iJulienne for either imperative or declarative languages. To the best of our knowledge, there are just a couple of tools that only slightly relate to ours.\n\nHaSlicer [32] is a prototype of a slicer for functional programs written in Haskell that is used for the identification of possible coherent components from (functional) monolithic legacy code. Both backward and forward dependency slicing are covered by HaSlicer, which is proposed as a support tool for the software architect to manually improve program understanding, and automatically discover software components. The latter is particularly useful as an architecture understanding technique in earlier phases of a re-engineering process.\n\nSpyder [33] is a prototype debugger for C that, thanks to the combination of dynamic program slicing and execution backtracking techniques, is able to automatically step-back, statement by statement, from any desired location in order to determine which statements in the program affect the value of an output variable for a given test case, and to determine the value of a given variable when the control last reached a given program location. In contrast to Spyder and HaSlicer, our technique is based on trace slicing rather than program slicing, and needs much less storage to perform flow-back analysis, as it requires neither the construction of data and control dependency graphs nor the creation of an execution history.\n\nThe Haskell interactive debugger Hat [34] also allows execution traces to be explored backwards, starting from the program output or an error message (computation abort). Similarly to Spyder, this task is carried out by navigating a graph-like, supplementary data structure (redex trail) that records dependencies among function calls. Even if Hat is able to highlight the top-level “parent” function of any expression in the final trace state, it cannot be used to compose a full trace slice. Actually, at every point of the recreated trail, the function arguments are shown in fully evaluated form (the way they would appear at the end of the computation) even though, at the point at which they are shown, they would not yet have necessarily reached that form. A totally different, bytecode trace compression was proposed in [35] to help perform Java program analysis (e.g., dynamic program slicing [36]) over the compact representation.\n\n8. Conclusions\n\nWe have developed a slicing transformation technique for rewriting logic programs that are written and executed in the Maude system. The technique can drastically reduce the size and complexity of the traces under examination, and is useful for execution trace analyses of sophisticated rewrite theories that may include conditional equations,\nequational axioms, and rules. The technique has been implemented in the iJulienne system. iJulienne reveals that the technique does not come at the expense of performance with respect to existing Maude tools. This makes iJulienne attractive for Maude users, especially taking into account that program debugging and trace analysis in Maude is tedious with current state-of-the-art tools. The implementation comprises a front-end consisting of a web graphical user interface and a back-end consisting of a Maude implementation that uses Maude meta-level capabilities. The tool can be tuned to reveal all relevant information (including applied equation/rule, redex position, and matching substitution) for each single rewrite step that is obtained by (recursively) applying a conditional equation, algebraic axiom, or rule, which greatly improves the standard view of execution traces in Maude and their meta-representations. Moreover, it can provide both, a textual representation of the trace and its meta-level representation to be used for further automated analyses, including the incremental algorithm that supports stepwise refinements of the trace slice.\n\nThe Maude system currently supports two different approaches for debugging Maude programs: the internal debugger described in [16] (Chap. 22) and the declarative debugger of [37]. The former is a traditional trace-based debugger that allows the user to define break points in the execution by selecting some operators or statements. When a break point is found, the debugger is entered, and the next rewrite is executed with tracing turned on. The user can also execute another Maude command, which in turn can enter the (fully re-entrant) debugger. For large programs such repeated program executions may be very cumbersome.\n\nThe declarative debugger of Maude is based on Shapiro’s algorithmic debugging technique [38] and allows the debugging of wrong results (erroneous reductions, sort inferences, and rewrites) and incomplete results (not completely reduced normal forms, greater than expected least sorts, and incomplete sets of reachable terms) [37]. The debugging process starts from a computation considered incorrect by the user (typically from the initial term to an unexpected one) and locates a program fragment responsible for that error symptom. Then the debugger builds a debugging tree representing this computation and guides the user through it to find the bug, with several options to build, prune, and traverse the debugging tree. During the process, the system asks questions to an external oracle (generally the user or another program or formal specification) until a so-called buggy node is found, i.e., a node that contains an erroneous result but whose children have all correct results. Since a buggy node produces an erroneous output from correct inputs, it corresponds to an erroneous fragment of code that is pointed out as an error. Typical questions to the user have the form “Is it correct that term $t$ rewrites (or fully reduces) to $t'$?”. As one of the main drawbacks of declarative debugging is the size of the debugging trees and the complexity of the questions to the oracle, the tool allows the debugging trees to be reduced in several ways (e.g., by considering as fully trusted code some statements and even whole modules). Sometimes, the user answers allow the tree to be further pruned and the corresponding questions referring to the nodes of the eliminated subtrees are consequently discarded.\nWe think that our trace slicing technique can provide a complementary source of information to further shorten the declarative debugging process. By not considering some (sub-)computations that were proven by the trace slicer to have no influence on a criterion of interest, we might avoid many unnecessary questions to the user. In order to achieve this, we intend to develop a trace slicing scheme for more sophisticated theories that may include membership axioms and to address the full integration of our tool within the formal tool environment of Maude.\n\nWe also plan to explore other challenging applications of our trace slicing methodology, such as runtime verification [39] which is concerned with monitoring and analysis of system executions. More specifically, we can consider a programming language $\\mathcal{L}$ which is provided with a RWL executable semantics. Then, one can use the semantics as an interpreter to execute $\\mathcal{L}$ programs (given as terms) directly within the semantics of their programming language as in [40], and hence backward trace slicing can be used to analyze such semantics-driven executions w.r.t. a reference specification that monitors critical data. This way, runtime verification might be semantically grounded in our setting, while it is commonly offhacked in more traditional approaches by means of program instrumentation.\n\nAcknowledgement\n\nWe would like to acknowledge the participation of Julia Sapiña in the implementation of iJULIENNE.\n\nReferences\n\n\nAppendix A. Proofs of Theorem 4.19 and Theorem 4.22\n\nThroughout this section, we assume that all execution traces are instrumented, that is, they contain only standard rewrite steps that implement rewriting modulo an equational theory as explained in Section 3. The following definitions are auxiliary. Let \\( t \\) and \\( t' \\) be two terms. We write \\( t \\leq t' \\) to denote that \\( t' \\) is an instance of \\( t \\). We use the notation \\( t[p] \\) to select the symbol rooted at position \\( p \\) of the term \\( t \\). A substitution \\( \\eta \\) is a renaming iff there exists a substitution \\( \\eta^{-1} \\) such that, for every term \\( t \\), \\( t\\eta^{-1} = t\\eta^{-1}\\eta = t \\).\n\nProposition Appendix A.1 Let \\( \\mathcal{R} \\) be a conditional rewrite theory. Let \\( \\mathcal{T} : s_{0} \\xrightarrow{r_{1},\\sigma_{1},w_{1}} \\ldots \\xrightarrow{r_{n},\\sigma_{n},w_{n}} s_{n} \\) be an execution trace in \\( \\mathcal{R} \\), with \\( n \\geq 0 \\), and let \\( s_{n}^* \\) be a slicing criterion for \\( \\mathcal{T} \\). Then, the pair \\( [s_{0} \\rightarrow \\ldots \\rightarrow s_{n}^*, B_{0}^*] \\) computed by backward-slicing(\\( \\mathcal{T}, s_{n}^* \\)) is a trace slice of \\( \\mathcal{T} \\) w.r.t. \\( s_{n}^* \\).\n\nProof. Let \\( \\mathcal{T} : s_{0} \\xrightarrow{r_{1},\\sigma_{1},w_{1}} \\ldots \\xrightarrow{r_{n},\\sigma_{n},w_{n}} s_{n} \\) be an execution trace in the conditional rewrite theory \\( \\mathcal{R} \\), with \\( n \\geq 0 \\), and let \\( s_{n}^* \\) be a slicing criterion for \\( \\mathcal{T} \\). Then,\n\n\\[\n\\text{backward-slicing}(s_{0} \\rightarrow s_{n}; s_{n}^*) = [s_{0} \\rightarrow s_{n}^*, B_{0}^*]\n\\]\n\niff there exists a transition sequence \\( S \\) in \\( (\\text{Conf}, \\bullet \\rightarrow) \\)\n\n\\[\n\\langle s_{0} \\rightarrow s_{n}, s_{n}^*, \\text{true} \\rangle \\bullet \\rightarrow \\langle s_{0} \\rightarrow s_{n-1}, s_{n-1}^*, B_{n-1}^* \\rangle \\bullet \\rightarrow \\langle s_{0}, s_{0}^*, B_{0}^* \\rangle\n\\]\n\n(A.1)\n\nFirst, by the definition of the functions slice-step and process-condition, observe that\n\n\\[\nB_{i}^* = \\text{true} \\land \\bigwedge_{j=0}^{n-1} b_{j}\\Phi_{j} \\quad \\text{for all } i = 0, \\ldots, n - 1\n\\]\n\n(A.2)\n\nwhere, for each \\( j = 0, \\ldots, n - 1 \\), \\( b_{j} \\) is a conjunction of equational conditions that occur in the conditional rewrite theory \\( \\mathcal{R} \\) and \\( \\Phi_{j} \\) is a substitution.\n\nNow, to prove the proposition, simply observe that\n\n1. each \\( s_{i}^*, i = 0, \\ldots, n - 1 \\), is built in the transition\n\n\\[\n\\langle s_{0} \\rightarrow s_{i+1}, s_{i+1}^*, B_{i+1}^* \\rangle \\bullet \\rightarrow \\langle s_{0} \\rightarrow s_{i}, s_{i}^*, B_{i}^* \\rangle\n\\]\n\nby calling the function slice-step on the rewrite step \\( s_{i} \\xrightarrow{r_{i+1},\\sigma_{i+1},w_{i+1}} s_{i+1} \\), the term slice \\( s_{i+1}^* \\), and the Boolean condition \\( B_{i+1}^* \\). Specifically, the call to slice-step generates a term \\( s_{i}^* \\in \\tau(\\Sigma, \\mathcal{V}^*) \\) that is either equal to \\( s_{i+1}^* \\) (See Line 4 of the function slice-step) or derived from \\( s_{i+1}^* \\) by replacing an appropriate subterm of \\( s_{i+1}^* \\) with an instance of the left-hand side of the rule \\( r_{i+1} \\) (See Line 12 of the function slice-step). In both cases, \\( s_{i}^* \\in \\tau(\\Sigma, \\mathcal{V}^*) \\).\n\n2. By \\( A.2 \\), \\( B_{0}^* \\) is the conjunction of Boolean conditions \\( \\text{true} \\land b_{n-1}\\Phi_{n-1} \\land \\ldots \\land b_{0}\\Phi_{0} \\). Hence, \\( B_{0}^* \\) is a Boolean condition.\nTherefore, $[s_n^* \\rightarrow s_n^*, B_0^*]$ is a trace slice of $T$ w.r.t. $S_n$ by Definition 4.6.\n\n**Theorem 4.19 (weak correctness).** Let $\\mathcal{R}$ be a conditional rewrite theory. Let $T : s_0 \\rightarrow^{r_1, \\sigma_1} \\cdots \\rightarrow^{r_n, \\sigma_n} s_n$ be an execution trace in $\\mathcal{R}$, with $n \\geq 0$, and let $s_n^*$ be a slicing criterion for $T$. Then, the pair $[s_0^* \\rightarrow \\cdots \\rightarrow s_n^*, B_0^*]$ computed by backward-slicing($T, s_n^*$) is a weakly correct trace slice of $T$ w.r.t. $s_n^*$.\n\n**Proof.** Let $T : s_0 \\rightarrow^{r_1, \\sigma_1} \\cdots \\rightarrow^{r_n, \\sigma_n} s_n$ be an execution trace in the conditional rewrite theory $\\mathcal{R}$, with $n \\geq 0$, and let $s_n^*$ be a slicing criterion for $T$. Then,\n\n$$\\text{backward-slicing}(s_0 \\rightarrow s_n, s_n^*) = [s_0^* \\rightarrow s_n^*, B_0^*]$$\n\niff there exists a transition sequence $S$ in $(\\text{Conf}, \\rightarrow)$\n\n$$(s_0 \\rightarrow s_{n-1}^*, s_{n-1}^*, \\text{true}) \\rightarrow (s_0 \\rightarrow s_{n-1}, s_{n-1}^*, B_{n-1}) \\rightarrow (s_0, s_n, B_0)$$ (A.3)\n\nBy Proposition [Appendix A.1](#), the outcome $[s_0^* \\rightarrow s_n^*, B_0^*]$ is a trace slice. Therefore, we just need to prove that $[s_0^* \\rightarrow s_n^*, B_0^*]$ is weakly correct, that is, there exists a term $s_i'$ with $s_0^* \\not\\rightarrow^B s_0$, and an execution trace $s_0^* \\rightarrow s_i^* \\rightarrow \\cdots \\rightarrow s_n'$ in $\\mathcal{R}$ such that\n\ni) $s_i' \\rightarrow s_{i+1}'$ is either the rewrite step $s_i' \\rightarrow^{r_i, \\sigma_i} s_{i+1}'$ or $s_i' = s_{i+1}'$, $i = 0, \\ldots, n$;\n\nii) $s_i^*$ is a term slice of $s_i'$, for all $i = 0, \\ldots, n$.\n\nThe proof proceeds by induction on the total number of rewrite steps included in the execution trace $T : s_0 \\rightarrow^{r_1, \\sigma_1} \\cdots \\rightarrow^{r_n, \\sigma_n} s_n$ that we denote by $\\mathcal{N}(T)$. Observe that $\\mathcal{N}(T)$ also includes all the internal rewrites that are needed to prove the validity of the conditions involved in the conditional rewrite steps that occur in $T$.\n\n**$\\mathcal{N}(T) = 0$.** The execution trace $T$ is empty, and hence the theorem vacuously holds.\n\n**$\\mathcal{N}(T) > 0$.** We have a nonempty execution trace $T : s_0 \\rightarrow^{r_1, \\sigma_1} \\cdots \\rightarrow^{r_n, \\sigma_n} s_n$ and a slicing criterion $s_n^*$ to which backward trace slicing is applied. Specifically, by applying backward-slicing($T, s_n^*$), the transition sequence $S$ in [A.3](#) is produced.\n\nWe consider the execution trace $T^{n-1} : s_0 \\rightarrow^{r_1, \\sigma_1} \\cdots \\rightarrow^{r_n, \\sigma_n} s_n$. Since $\\mathcal{N}(T^{n-1}) < \\mathcal{N}(T)$, the inductive hypothesis holds for $T^{n-1}$ and the slicing criterion $s_n^*$. Thus, backward-slicing($s_0 \\rightarrow s_{n-1}, s_{n-1}^*$) = $[s_0^* \\rightarrow s_{n-1}^*, B_0^*]$ and $[s_0^* \\rightarrow s_{n-1}^*, B_0^*]$ is a weakly correct trace slice of $T^{n-1}$ w.r.t. the slicing criterion $s_n^*$.\n\nThen, we consider the rewrite step $s_{n-1} \\rightarrow^{r_n, \\sigma_n} s_n$. By Definition 4.11, the sliced counterpart, $s_{n-1}^* \\rightarrow s_n^*$, of the considered rewrite step, is computed in the first transition of $S$ (that is, $(s_0 \\rightarrow s_{n-1}, s_{n-1}^*, \\text{true}) \\rightarrow (s_0 \\rightarrow s_{n-1}, s_{n-1}^*, B_{n-1})$) by executing slice-step($s_{n-1} \\rightarrow s_n, s_{n-1}^*$, true) which returns the pair $(s_{n-1}^*, B_{n-1})$. We distinguish the two following cases.\nCase $w_n \\notin \\mathcal{MPos}(s_n^\\ast)$. In this case, $\\text{slice-step}(s_{n-1} \\xrightarrow{\\sigma_{n}, w_n} s_n, s_n^\\ast, \\text{true})$ yields the pair $(s_{n-1}^\\ast, B_{n-1}^\\ast)$ such that $s_{n-1}^\\ast = s_n^\\ast$ and $B_{n-1}^\\ast = \\text{true}$. Thus, the trace slice for $\\mathcal{T}$ w.r.t. $s_n$ must be of the form $[s_0^\\ast \\rightarrow^* s_{n-1}^\\ast = s_n^\\ast, B_0^\\ast \\land \\text{true}]$. Since $[s_0^\\ast \\rightarrow^* s_{n-1}^\\ast, B_0^\\ast]$ is a weakly correct trace slice of $\\mathcal{T}^{n-1}$ w.r.t. the slicing criterion $s_{n-1}^\\ast$, there exists a term $s_0'$ with $s_0^\\ast \\Leftrightarrow B_0^\\ast s_0'$, and an execution trace $s_0' \\rightarrow s_1' \\rightarrow \\ldots \\rightarrow s_{n-1}'$ in $R$ such that\n\ni) $s_i' \\rightarrow s_{i+1}'$ is either the rewrite step $s_i' \\xrightarrow{r_{i+1}, \\sigma_{i+1}, w_{i+1}} s_{i+1}'$ or $s_i' = s_{i+1}'$; \n\nii) $s_i^\\ast$ is a term slice of $s_i'$, for all $i = 0, \\ldots, n - 1$.\n\nThen, it also holds that $s_0^\\ast \\Leftrightarrow B_0^\\ast \\land \\text{true} s_0'$. Furthermore, for the execution trace $s_0' \\rightarrow s_1' \\rightarrow \\ldots \\rightarrow s_{n-1}' = s_n'$ in $R$, we have\n\ni) $s_i' \\rightarrow s_{i+1}'$ is either the rewrite step $s_i' \\xrightarrow{r_{i+1}, \\sigma_{i+1}, w_{i+1}} s_{i+1}'$ or $s_i' = s_{i+1}'$; \n\nii) $s_i^\\ast$ is a term slice of $s_i'$, for all $i = 0, \\ldots, n$.\n\nTherefore, $[s_0^\\ast \\rightarrow^* s_{n-1}^\\ast = s_n^\\ast, B_0^\\ast \\land \\text{true}]$ is a weakly correct trace slice of $\\mathcal{T}$ w.r.t. $s_n^\\ast$.\n\nCase $w_n \\in \\mathcal{MPos}(s_n^\\ast)$. Let $r_n$ be the rewrite rule $\\lambda_n \\rightarrow \\rho_n$ if $C_n$. In this case, $\\text{slice-step}(s_{n-1} \\xrightarrow{\\sigma_{n}, w_n} s_n, s_n^\\ast, \\text{true})$ yields the pair $(s_{n-1}^\\ast, B_{n-1}^\\ast)$ such that $s_{n-1}^\\ast = s_n^\\ast[\\lambda_n\\bar{\\phi}]_{w_n}$, for some substitution $\\bar{\\phi}$, and $B_{n-1}^\\ast$ is the conjunction of some equational conditions needed to evaluate the condition $C_n \\sigma_n$ in the rewrite step $s_{n-1} \\xrightarrow{r_n, \\sigma_n, w_n} s_n$. Thus, the trace slice for $\\mathcal{T}$ w.r.t. $s_n^\\ast$ must be of the form $[s_0^\\ast \\rightarrow^* s_n^\\ast[\\lambda\\bar{\\psi}]_{w_n} \\rightarrow s_n^\\ast, B_0^\\ast \\land B_n^\\ast - 1]$, where $B_n^\\ast$ is the compatibility condition computed by slicing the execution trace $\\mathcal{T}^{n-1}$.\n\nNow, we consider the trace slice $[s_0^\\ast \\rightarrow^* s_{n-1}^\\ast = s_n^\\ast, B_0^\\ast]$ which is weakly correct by inductive hypothesis. By Definition 4.7, we know that there exists a term $s_0'$ with $s_0^\\ast \\Leftrightarrow B_0^\\ast s_0'$, and an execution trace $s_0' \\rightarrow s_1' \\rightarrow \\ldots \\rightarrow s_{n-1}'$ in $R$ such that\n\ni) $s_i' \\rightarrow s_{i+1}'$ is either the rewrite step $s_i' \\xrightarrow{r_{i+1}, \\sigma_{i+1}, w_{i+1}} s_{i+1}'$ or $s_i' = s_{i+1}'$; \n\nii) $s_i^\\ast$ is a term slice of $s_i'$, for all $i = 0, \\ldots, n - 1$.\n\nIn particular, we can choose $s_0' = s_0$. This way, all the descendants of $s_0$ will be kept in the execution trace $s_0 = s_0' \\rightarrow s_1' \\rightarrow \\ldots \\rightarrow s_{n-1}'$. Hence, $s_{n-1}'|_{w_n} = s_{n-1}|_{w_n} = \\lambda_n \\sigma_n$. Furthermore, $s_0^\\ast[\\lambda\\bar{\\psi}]_{w_n} = s_0 = s_0'$. Thus, by definition of rewriting, $s_{n-1}' \\xrightarrow{\\sigma_n'}|_{w_n} s_n'$ with $s_{n'|_{w_n}} = \\rho_n \\sigma_n' = \\rho_n \\sigma_n = s_{n'|_{w_n}}$. Also, $s_n^\\ast$ is a term slice of $s_n'$, since $s_n^\\ast$ is a slicing criterion for $\\mathcal{T}$.\n\nTherefore, $[s_0^\\ast \\rightarrow^* s_n^\\ast[\\lambda\\bar{\\psi}]_{w_n} \\rightarrow s_n^\\ast, B_0^\\ast \\land B_n^\\ast - 1]$ is a trace slice for $\\mathcal{T}$ w.r.t. $s_n^\\ast$. \n\n46\nThe next lemmata state some useful properties on the outcome of the slice-step function, that are necessary to prove the strong correctness of backward trace slicing.\n\n**Lemma Appendix A.2** Let \\( r = \\lambda \\rightarrow \\rho \\) if \\( C \\) be a rewrite rule of a conditional rewrite theory \\( \\mathcal{R} \\) that satisfies the separation property and only contains equational conditions. Let \\( T : s \\xrightarrow{r,\\sigma,w} t \\) be a (one-step) execution trace. Let \\( t^* \\) be a term slice of \\( t \\) and \\( B^*_{\\text{prev}} \\) be a Boolean condition. Then, slice-step(\\( T, t^*, B^*_{\\text{prev}} \\)) computes the pair \\( (s^*, B^*) \\) such that, for each term \\( s' \\), with \\( s^* \\propto^{B^*} s' \\),\n\ni) \\( s^* \\) is a term slice of \\( s' \\);\n\nii) there exists a term \\( t' \\) such that \\( s' \\xrightarrow{r',\\sigma',w} t' \\) or \\( s' = t' \\), and \\( t^* \\) is a term slice of \\( t' \\).\n\n**Proof.** Let \\( \\mathcal{R} \\) be a conditional rewrite theory that satisfies the separation property and only contains equational conditions. Let \\( r = \\lambda \\rightarrow \\rho \\) if \\( C \\) be a rewrite rule in \\( \\mathcal{R} \\), hence \\( C \\) is a conjunction of equational conditions \\( c_1 \\wedge \\ldots \\wedge c_m \\). Let \\( T : s \\xrightarrow{r,\\sigma,w} t \\) be a (one-step) execution trace. Let \\( t^* \\) be a term slice of \\( t \\) and \\( B^*_{\\text{prev}} \\) be a Boolean condition. Let \\( (s^*, B^*) \\) be the outcome of slice-step(\\( T, t^*, B^*_{\\text{prev}} \\)). We prove i) and ii) separately.\n\ni) The proof that \\( s^* \\) is a term slice of \\( s' \\) directly derives from the hypothesis of the lemma. In fact, since \\( s^* \\propto^{B^*} s' \\), by Definition 4.4, there exists a substitution \\( \\eta \\) such that \\( s^* \\eta = s' \\). Hence, \\( s' \\) is an instance of the term \\( s^* \\in \\tau(\\Sigma, \\mathcal{V}^*) \\), which implies that \\( s^* \\) is a term slice of \\( s' \\).\n\nii) We distinguish two cases: \\( w \\not\\in \\mathcal{M}\\text{Pos}(t^*) \\) and \\( w \\in \\mathcal{M}\\text{Pos}(t^*) \\).\n\n**Case** \\( w \\not\\in \\mathcal{M}\\text{Pos}(t^*) \\). As \\( w \\) is not a meaningful position of \\( t^* \\), the execution of slice-step(\\( s \\xrightarrow{r,\\sigma,w} t, t^*, B^*_{\\text{prev}} \\)) generates the pair \\( (s^*, B^*) \\) with \\( s^* = t^* \\) and \\( B^* = B^*_{\\text{prev}} \\) (see Lines 1–4 of the slice-step algorithm in Figure 3), which indicates that the rewrite step \\( s \\xrightarrow{r,\\sigma,w} t \\) does not contribute to producing the meaningful symbols of \\( t^* \\).\n\nNow, given an arbitrary term \\( s' \\), such that \\( s^* \\propto^{B^*} s' \\), we have that \\( s^* \\preceq s' \\). Hence, \\( s' = s^* \\eta \\) for some substitution \\( \\eta \\). Since \\( s^* = t^* \\), the following equivalences hold: \\( s' = s^* \\eta = t^* \\eta = t' \\). Therefore, \\( s' = t' \\). Furthermore, \\( t^* \\) is a term slice of \\( t' \\), because \\( s' = t' \\), \\( s^* = t^* \\) and \\( s^* \\) is a term slice of \\( s' \\).\n\n**Case** \\( w \\in \\mathcal{M}\\text{Pos}(t^*) \\). In this case, the else branch of the function slice-step is executed, that is, Lines 6–13. First, note that the execution of Lines 6–8 generates a substitution \\( \\psi_\\rho \\) such that\n\n\\[\n\\rho^* \\psi_\\rho = t^* \\eta \\quad \\text{(A.4)}\n\\]\n\nfor some renaming \\( \\eta \\), and the term slice \\( \\rho^* = \\text{slice}(\\rho, \\mathcal{M}\\text{Pos}(\\text{Var}^*(B^*_{\\text{prev}}), t^*|w \\rangle) \\cap \\text{Pos}(\\rho)) \\) of \\( \\rho \\). Basically, Equation \\( \\text{A.4} \\) holds, since\n\n47\n1. Line 6 yields a substitution \\( \\theta \\) which binds each variable in \\( \\rho \\) to a new, freshly generated \\( \\bullet \\)-variable.\n\n2. By Definition 4.2, Line 7 computes a term slice \\( \\rho^* \\) of \\( \\rho \\) which includes all and only the symbols in \\( \\rho \\) that are meaningful symbols (or \\( \\bullet \\)-variables that appear in \\( B^* \\) of \\( t_w^* \\)).\n\n3. Line 8 computes the substitution \\( \\mu = \\text{match}_\\rho(t_w^*) \\) such that \\( \\rho^* \\mu = t_w^* \\), and — by Definition 4.13 — \\( \\psi_\\rho = \\langle \\theta, \\mu \\rangle \\) updates \\( \\theta \\) with the meaningful information of \\( t_w^* \\) encoded in \\( \\mu \\). Hence, for each position \\( p \\in \\text{Pos}(\\rho^* \\psi_\\rho) \\), we have either \\( \\rho^* \\psi_\\rho[p] = t_w^*[p] \\) and \\( p \\in \\mathcal{M}\\text{Pos}(t_w^*) \\) or \\( \\rho^* \\psi_\\rho[p] = \\bullet_i \\neq \\bullet_j = t_w^*[p] \\) for some \\( \\bullet_i, \\bullet_j \\in \\mathcal{V}^* \\). Thus, by choosing \\( \\eta = \\{ \\bullet_i/\\bullet_j \\mid \\rho_p^* = \\bullet_i, t_w^*[p] = \\bullet_j, p \\in \\text{Pos}(\\rho^*) \\} \\), we get \\( \\rho^* \\psi_\\rho = t_w^* \\eta \\).\n\nNow, Lines 9–11 evaluate the rule condition \\( C = c_1, \\ldots, c_n \\) by invoking the function \\( \\text{process-condition} \\). Specifically, for each \\( c_i \\), \\( \\text{process-condition} \\) generates the refinement \\( \\langle \\psi_\\rho, \\psi_n, \\ldots, \\psi_{i+1} \\rangle \\) of \\( \\psi_\\rho \\). Since each \\( c_i \\) is an equational condition, at the end of the for loop, we obtain the refinement \\( \\langle \\psi_\\rho, \\psi_n, \\ldots, \\psi_1 \\rangle \\) such that each \\( \\psi_i, i = 1, \\ldots, n \\), is the identity substitution \\( \\{ \\} \\). Hence, for each term \\( t \\),\n\n\\[\n\\psi\\rho \\cdot t = t\\langle \\psi_\\rho, \\psi_n, \\ldots, \\psi_1 \\rangle\n\\] \n\n(A.5)\n\nLine 12 constructs the term \\( s^* = (t^*|\\lambda\\psi_\\rho, \\psi_n, \\ldots, \\psi_1|^w) \\), and Line 13 builds the compatibility condition \\( B^* \\). Note that \\( B^* \\) contains a sliced counterpart of every equational condition \\( c_i \\) in \\( c_1 \\land \\ldots \\land c_m \\).\n\nNow, we consider an arbitrary term \\( s' \\), such that \\( s^* \\preceq B^* s' \\). Since \\( s^* \\preceq B^* s' \\), it also holds that \\( s^* \\preceq s' \\). Hence, there exists a substitution \\( \\psi \\) such that \\( s' = (t^*|\\lambda\\psi_\\rho, \\psi_n, \\ldots, \\psi_1|^w) \\). Thus, we can rewrite \\( s' \\) using the rule \\( r \\) at position \\( w \\),\n\n\\[\ns' = t^*\\psi[\\lambda\\psi_\\rho, \\psi_n, \\ldots, \\psi_1|^w] \\xrightarrow{r,\\psi\\rho, \\psi_n, \\ldots, \\psi_1} t^*\\psi[\\rho\\psi_\\rho, \\psi_n, \\ldots, \\psi_1|^w].\n\\]\n\nLet \\( t' \\) be \\( t^*\\psi[\\rho\\psi_\\rho, \\psi_n, \\ldots, \\psi_1|^w] \\). Then, \\( t' = t^*\\psi[\\rho\\psi_\\rho, \\psi_n, \\ldots, \\psi_1|^w] = (t^*|\\rho\\psi_\\rho, \\psi_n, \\ldots, \\psi_1|^w) \\). Hence, \\( t^* \\preceq t' \\) holds as well. Indeed, we have\n\n\\[\nt' = (t^*|\\rho\\psi_\\rho, \\psi_n, \\ldots, \\psi_1|^w) \\psi \\geq (t^*|\\rho\\psi_\\rho, \\psi_n, \\ldots, \\psi_1|^w) \\psi \\quad \\text{(by definition of instance)}\n\\]\n\n\\[\n= t^*|\\rho\\psi_\\rho|^w \\quad \\text{(by A.5)}\n\\]\n\n\\[\n\\geq t^*|\\rho^*\\psi_\\rho|^w \\quad \\text{(as \\( \\rho^* \\preceq \\rho \\) by definition of term slice)}\n\\]\n\n\\[\n= t^*|^w \\quad \\text{(by Equation A.4)}\n\\]\n\n\\[\n\\geq t^* \\quad \\text{(by definition of instance)}\n\\]\n\nFinally, observe that, by choosing\n\n\\[\n\\sigma' = \\langle \\psi_\\rho, \\psi_n, \\ldots, \\psi_1 \\rangle \\psi \\quad \\text{and} \\quad t' = t^*\\psi[\\rho\\psi_\\rho, \\psi_n, \\ldots, \\psi_1|^w]\n\\]\nwe have that \\( s' \\xrightarrow{r,\\sigma',w} t' \\) and \\( t^\\bullet \\) is a term slice of \\( t' \\). Hence, the lemma holds even in the case when \\( w \\notin \\mathcal{MP}os(t^\\bullet) \\).\n\n### Lemma Appendix A.3\n\nLet \\( r = \\lambda \\rightarrow \\rho \\) if \\( C \\) be a rewrite rule of a conditional rewrite theory \\( \\mathcal{R} \\) that satisfies the separation property and only contains matching conditions or rewrite expressions. Let \\( \\mathcal{T} : s \\xrightarrow{r,\\sigma,w} t \\) be a (one-step) execution trace. Let \\( t^\\bullet \\) be a term slice of \\( t \\) and \\( B^\\bullet_{\\text{prev}} \\) be a Boolean condition. Then, \\( \\text{slice-step}(\\mathcal{T}, t^\\bullet, B^\\bullet_{\\text{prev}}) \\) computes the pair \\((s^\\bullet, B^\\bullet)\\) such that, for each term \\( s' \\), with \\( s^\\bullet \\triangleq B^\\bullet \\ s' \\),\n\ni) \\( s^\\bullet \\) is a term slice of \\( s' \\);\n\nii) there exists a term \\( t' \\) such that \\( s' \\xrightarrow{r,\\sigma',w} t' \\) or \\( s' = t' \\), and \\( t^\\bullet \\) is a term slice of \\( t' \\).\n\n**Proof.** The proof is analogous to proof of Lemma Appendix A.2. Basically, the main difference lies in the evaluation of the function \\( \\text{process-condition} \\) (Lines 9–11 of the slice-step function). In this case, each matching condition/rewrite expression \\( c_i \\) is directly encoded in the corresponding computed substitution refinement, while the compatibility condition is left unchanged. More specifically, for each \\( c_i \\), \\( \\text{process-condition} \\) generates the refinement \\( \\langle \\psi_p, \\psi_n \\ldots \\psi_{i+1} \\rangle \\) of \\( \\psi_p \\). Hence, at the end of the \\textbf{for} loop, we obtain the Boolean compatibility condition \\( B^\\bullet = \\text{true} \\), and the refinement \\( \\langle \\psi_p, \\psi_n \\ldots \\psi_1 \\rangle \\) such that, for each term \\( t \\),\n\n\\[\n\\lbrack t \\psi_p \\rbrack \\leq \\lbrack t \\psi_p, \\psi_n \\ldots \\psi_1 \\rbrack.\n\\]\n\n(A.6)\n\nTherefore, by considering an arbitrary term \\( s' \\), such that \\( s^\\bullet \\triangleq \\text{true} \\ s' \\), we have that \\( s^\\bullet \\leq s' \\). Hence, there exists a substitution \\( \\psi \\) such that \\( s' = (t^\\bullet \\psi[\\lambda(\\psi_p, \\psi_n \\ldots \\psi_1)]_w) \\psi = t^\\bullet \\psi[\\lambda(\\psi_p, \\psi_n \\ldots \\psi_1)]_w \\). Thus, we can rewrite \\( s' \\) using the rule \\( r \\) at position \\( w \\),\n\n\\[\ns' = t^\\bullet \\psi[\\lambda(\\psi_p, \\psi_n \\ldots \\psi_1)]_w \\xrightarrow{r,\\lambda(\\psi_p, \\psi_n \\ldots \\psi_1)} t^\\bullet \\psi[\\rho(\\psi_p, \\psi_n \\ldots \\psi_1)]_w.\n\\]\n\nLet \\( t' = t^\\bullet \\psi[\\rho(\\psi_p, \\psi_n \\ldots \\psi_1)]_w \\). Then, \\( t' = (t^\\bullet \\psi[\\rho(\\psi_p, \\psi_n \\ldots \\psi_1)]_w) \\psi = (t^\\bullet \\psi[\\rho(\\psi_p, \\psi_n \\ldots \\psi_1)]_w) \\). Thus, \\( t^\\bullet \\leq t' \\) holds as well. Indeed, we have\n\n\\[\nt' = (t^\\bullet \\psi[\\rho(\\psi_p, \\psi_n \\ldots \\psi_1)]_w) \\psi \\geq (t^\\bullet \\psi[\\rho(\\psi_p, \\psi_n \\ldots \\psi_1)]_w) \\psi \\quad \\text{(by definition of instance)}\n\\]\n\n\\[\n\\geq t^\\bullet \\psi[\\rho \\psi_p]_w \\quad \\text{(by A.6)}\n\\]\n\n\\[\n\\geq t^\\bullet \\psi[\\rho \\psi_p]_w \\quad \\text{(as \\( \\rho^\\bullet \\leq \\rho \\) by definition of term slice)}\n\\]\n\n\\[\n= t^\\bullet \\psi[\\rho \\psi_p]_w \\quad \\text{(by Equation A.4)}\n\\]\n\n\\[\n\\geq t^\\bullet \\psi \\quad \\text{(by definition of instance)}\n\\]\n\nFinally, observe that, by choosing\n\n\\[\n\\sigma' = \\langle \\psi_p, \\psi_n \\ldots \\psi_1 \\rangle \\psi \\quad \\text{and} \\quad t' = t^\\bullet \\psi[\\rho(\\psi_p, \\psi_n \\ldots \\psi_1)]_w\n\\]\n\nwe have that \\( s \\xrightarrow{r,\\sigma',w} t' \\) and \\( t^\\bullet \\) is a term slice of \\( t' \\).\nTheorem 4.22 (strong correctness). Let $\\mathcal{R}$ be a conditional rewrite theory that satisfies the separation property. Let $\\mathcal{T} : s_0 \\rightarrow \\sigma_1^{w_1} \\rightarrow \\ldots \\rightarrow \\sigma_n^{w_n} s_n$ be an execution trace in $\\mathcal{R}$, with $n \\geq 0$, and let $s_n^*$ be a slicing criterion for $\\mathcal{T}$. Then, the pair $[s_0^* \\rightarrow \\ldots \\rightarrow s_n^*, B_0^*]$ computed by backward-slicing($\\mathcal{T}, s_n^*$) is a strongly correct trace slice of $\\mathcal{T}$ w.r.t $s_n^*$.\n\nProof. Let us consider a conditional rewrite theory $\\mathcal{R}$ that satisfies the separation property and only contains equational conditions. The case when $\\mathcal{R}$ is a conditional rewrite theory that satisfies the separation property and only includes matching conditions or rewrite expressions is perfectly similar and requires the application of Lemma A.3 instead of using Lemma A.2.\n\nLet $\\mathcal{T} : s_0 \\rightarrow \\sigma_1^{w_1} \\rightarrow \\ldots \\rightarrow \\sigma_n^{w_n} s_n$ be an execution trace in $\\mathcal{R}$, with $n \\geq 0$, and let $s_n^*$ be a slicing criterion for $\\mathcal{T}$. Then,\n\n$$\\text{backward-slicing}(s_0 \\rightarrow s_n, s_n^*) = [s_0^* \\rightarrow s_n^*, B_0^*]$$\n\niff there exists a transition sequence $\\mathcal{S}$ in $(\\text{Conf}, \\Rightarrow)$\n\n$$(s_0 \\rightarrow s_n, s_n^*, true) \\Rightarrow (s_0 \\rightarrow s_{n-1}, s_{n-1}^*, B_{n-1}^*) \\Rightarrow (s_0, s_0^*, B_0^*) \\quad (A.7)$$\n\nBy Proposition A.1, the outcome $[s_0^* \\rightarrow s_n^*, B_0^*]$ is a trace slice. Therefore, we just need to prove that $[s_0^* \\rightarrow s_n^*, B_0^*]$ is strongly correct, that is, for every term $s_0' \\in S$ such that $s_0^* \\sim B_0^* s_0'$, there exists an execution trace $s_0' \\rightarrow s_1' \\rightarrow \\ldots \\rightarrow s_n'$ in $\\mathcal{R}$ such that\n\ni) $s_i' \\rightarrow s_{i+1}'$ is either the rewrite step $s_i' \\rightarrow \\sigma_{i+1}^{i+1} w_i s_{i+1}'$ or $s_i' = s_{i+1}'$, $i = 0, \\ldots, n - 1$;\n\nii) $s_n'$ is a term slice of $s_n'$, for all $i = 0, \\ldots, n$.\n\nWe proceed by induction on the total number of rewrite steps included in the execution trace $\\mathcal{T} : s_0 \\rightarrow \\sigma_1^{w_1} \\rightarrow \\ldots \\rightarrow \\sigma_n^{w_n} s_n$ that we denote by $\\mathcal{N}(\\mathcal{T})$. Observe that $\\mathcal{N}(\\mathcal{T})$ also includes all the internal rewrites that are needed to prove the validity of the conditions involved in the conditional rewrite steps that occur in $\\mathcal{T}$.\n\n$\\mathcal{N}(\\mathcal{T}) = 0$. In this case the execution trace $\\mathcal{T}$ is empty, and hence the result vacuously holds.\n\n$\\mathcal{N}(\\mathcal{T}) > 0$. We have a nonempty execution trace $\\mathcal{T} : s_0 \\rightarrow \\sigma_1^{w_1} \\rightarrow \\ldots \\rightarrow \\sigma_n^{w_n} s_n$ and a slicing criterion $s_n^*$ to which backward trace slicing is applied. Specifically, by applying backward-slicing($\\mathcal{T}, s_n^*$), the transition sequence $\\mathcal{S}$ in (A.7) is produced.\n\nNow, we consider the execution trace $\\mathcal{T}^{n-1} : s_0 \\rightarrow \\sigma_1^{w_1} \\rightarrow \\ldots \\rightarrow \\sigma_{n-1}^{w_{n-1}} s_{n-1}$. Since $\\mathcal{N}(\\mathcal{T}^{n-1}) < \\mathcal{N}(\\mathcal{T})$, the inductive hypothesis holds for $\\mathcal{T}^{n-1}$ and the slicing criterion $s_{n-1}^*$. Hence, we have that backward-slicing($s_0 \\rightarrow s_{n-1}, s_{n-1}^*$) $= [s_0^* \\rightarrow s_{n-1}^*, B_{n-1}^*]$ and $[s_0^* \\rightarrow s_{n-1}^*, B_{n-1}^*]$ is a trace slice of $\\mathcal{T}^{n-1}$ w.r.t. the slicing criterion $s_{n-1}^*$. \n\n\nTherefore, there exists the transition sequence in \\((\\text{Conf}, \\bullet \\rightarrow)\\)\n\n\\[\n\\langle s_0 \\rightarrow^* s_{n-1}, \\ s_{n-1}^*, \\ \\text{true} \\rangle \\bullet \\rightarrow^* \\langle s_0, \\ s_{n-1}^*, \\ B_{0'}^\\bullet \\rangle\n\\]\n\nwith \\(B_{0'}^\\bullet = \\text{true} \\land b_{n-2} \\Phi_{n-2} \\land \\ldots \\land b_0 \\Phi_0\\), and the following properties hold: for every term \\(s'\\) such that \\(s_0^* \\propto_{B_{0'}^\\bullet} s'\\), there exists an execution trace \\(s_0' \\rightarrow s'_1 \\rightarrow \\ldots \\rightarrow s'_{n-1}\\) in \\(\\mathcal{R}\\) such that\n\n1. \\(s_i' \\rightarrow s_{i+1}'\\) is either the rewrite step \\(s_i' \\xrightarrow{r_{i+1}, \\sigma_{i+1}, w_{i+1}} s_{i+1}'\\) or \\(s_i' = s_{i+1}', i = 0, \\ldots, n - 2\\);\n\n2. \\(s_i^*\\) is a term slice of \\(s_i'\\), for all \\(i = 1, \\ldots, n - 1\\).\n\nFurthermore, by Definition \\([4.11]\\) the first transition of \\(\\mathcal{S}\\) (i.e., \\(\\langle s_0 \\rightarrow^* s_n, \\ s_n^*, \\ \\text{true} \\rangle \\bullet \\rightarrow \\langle s_0 \\rightarrow^* s_{n-1}, \\ s_{n-1}^*, \\ B_{n-1}^\\bullet \\rangle\\)) is generated by executing slice-step\\((s_{n-1} \\rightarrow \\langle s_n, s_n^*, \\ \\text{true} \\rangle)\\) which returns the pair \\((s_{n-1}^*, B_{n-1}^\\bullet)\\). By Lemma [Appendix A.2] we have that for every term \\(s'_{n-1}\\) such that \\(s_{n-1}^* \\propto_{B_{n-1}^\\bullet} s'_{n-1}\\), there exists \\(s_{n-1}' \\rightarrow s'_{n}\\) in \\(\\mathcal{R}\\) such that\n\n1. \\(s_{n-1}^*\\) is a term slice of \\(s'_{n-1}\\);\n\n2. \\(s_{n-1}' \\rightarrow s'_{n}\\) is either the rewrite step \\(s_{n-1}' \\xrightarrow{r_{n-1}, \\sigma_{n-1}, w_{n-1}} s'_{n}\\) or \\(s_{n-1}' = s'_{n}\\) and \\(s_{n}^*\\) is a term slice of \\(s'_{n}\\);\n\nNow observe that \\(B_0^\\bullet = B_0' \\land B_{n-1}^\\bullet\\) which implies that both \\(B_0^\\bullet\\) and \\(B_{n-1}^\\bullet\\) are Boolean conditions which are more restrictive than \\(B_0^\\bullet\\). Consequently, the transition sequence \\(\\mathcal{S}\\) can be reformulated as follows\n\n\\[\n\\langle s_0 \\rightarrow^* s_n, \\ s_n^*, \\ \\text{true} \\rangle \\bullet \\rightarrow \\langle s_0 \\rightarrow^* s_{n-1}, \\ s_{n-1}^*, \\ B_{n-1}^\\bullet \\rangle \\bullet \\rightarrow^* \\langle s_0, \\ s_{n-1}^*, \\ B_{n-1}^\\bullet \\land B_0' \\rangle\n\\]\n\nThus, it also holds that, for every term \\(s'_0\\) such that \\(s_0^* \\propto_{B_{n}^\\bullet} s'_0\\), there exists an execution trace \\(s'_0 \\rightarrow s'_1 \\rightarrow \\ldots \\rightarrow s'_{n}\\) in \\(\\mathcal{R}\\) such that\n\n1. \\(s'_i \\rightarrow s'_{i+1}\\) is either the rewrite step \\(s'_i \\xrightarrow{r_{i+1}, \\sigma_{i+1}, w_{i+1}} s'_{i+1}\\) or \\(s'_i = s'_{i+1}, i = 0, \\ldots, n - 1\\);\n\n2. \\(s_i^*\\) is a term slice of \\(s'_i\\), for all \\(i = 1, \\ldots, n\\)."}}},{"rowIdx":268,"cells":{"id":{"kind":"string","value":"fe1b692762cb8faa7174b26dcd11c1479ab0a083"},"text":{"kind":"string","value":"Semi-Automatic Conceptual Data Modeling Using Entity and Relationship Instance Repositories\n\nA Thesis\nSubmitted to the Faculty\nof\nDrexel University\nby\nOrnsiri Thonggoom\nin partial fulfillment of the requirements for the degree of\nDoctor of Philosophy\nMay 2011\nACKNOWLEDGEMENT\n\nI am indebted to my supervising professor, Dr. Il-Yeol Song, for his guidance throughout the research program, without which this dissertation would never have been completed. His insightful advice and comments have significantly improved this work. I am very grateful for his unwavering help and support for all these years. And I wholeheartedly thank him for never giving up on me.\n\nI would like to thank the Committee Members, Dr. Don Goelman, Dr. Yuan An, Dr. Harry Jiannan Wang, and Dr. Xiaohua Tony Hu, for their valuable advice and helpful comments that contributed to the success of this dissertation. In particular, I would like to thank Dr. Yuan An for his commenting and reviewing my papers. I would also like to thank Dr. Jiexun Jason Li, who participated in my candidacy exam and offered valuable suggestions.\n\nMy success in this program is due largely to the help, friendship and encouragement of many people throughout my graduate career. In particular, Kesarin Phanarangsan has always provided unceasing help and support. Many thanks go to Aunty Ormsin and Uncle Harry Gardiner, Thippaya Chintakovid, and Palakorn Achananuparp for being so generously helpful. My deep appreciation is also extended to Caimei Lu, Ki Jung Li, Namyoun Choi, and all my friends who have made my life here more enjoyable.\n\nFinancial support from the Royal Thai Government throughout my study is gratefully acknowledged.\n\nMost importantly, I would like to thank my family for their unconditional love and support. They have confidence in me more than myself. My mother (Manee\nThonggoom) always loves and supports me in everything. My three sisters (Rattapawn, Puttima, and Piyanuch) unfailingly provide cheering-up every time we talk and help me take care of our mother. Without them, I would never have graduated.\nTable of Contents\n\nLIST OF TABLES .............................................................................................................. v\nLIST of FIGURES ............................................................................................................ vi\nABSTRACT ...................................................................................................................... vii\n\n1. INTRODUCTION ....................................................................................................... 1\n 1.1 Motivations and Problem Statement ................................................................. 1\n 1.2 Research Questions and Objectives .................................................................. 8\n 1.3 Contributions .................................................................................................... 13\n 1.4 Dissertation Organization ................................................................................ 14\n\n2. LITERATURE REVIEW ......................................................................................... 16\n 2.1 Conceptual Data Models .................................................................................. 16\n 2.2 The difficulties in creating conceptual data models ........................................ 19\n 2.3 Techniques used for automating conceptual modeling ................................. 22\n 2.3.1 Linguistic-based .......................................................................................... 23\n 2.3.1.1 Tools, systems, and related work ............................................................ 26\n 2.3.1.2 Strengths and drawbacks ......................................................................... 29\n 2.3.2 Pattern-based ............................................................................................... 29\n 2.3.2.1 Tools, systems, and related work ............................................................ 32\n 2.3.2.2 Strengths and drawbacks ......................................................................... 34\n 2.3.3 Case-based .................................................................................................. 35\n 2.3.3.1 Tools, systems, and related work ............................................................ 35\n 2.3.3.2 Strengths and drawbacks ......................................................................... 36\n 2.3.4 Ontology-based ........................................................................................... 37\n 2.3.4.1 Tools, systems, and related work ............................................................ 39\n 2.3.4.2 Strengths and drawbacks ......................................................................... 40\n 2.3.5 Muti-Techniques-Based .............................................................................. 41\n 2.4 Evaluation Method ........................................................................................... 42\n 2.5 Database Reverse Engineering (DBRE) ............................................................ 44\n 2.6 WordNet ............................................................................................................ 46\n\n3. RESEARCH METHODOLOGY .............................................................................. 50\n 3.1 Developing EIR and RIR ................................................................................. 50\n 3.2 The Six Domain Independent Modeling Rules ................................................. 58\n# Table of Contents\n\n3.3 Developing EIPW (Entity Instance Pattern WordNet) ........................................... 59\n 3.3.1 Overview of EIPW Architecture .................................................................... 60\n 3.3.2 The EIPW Workflow .................................................................................. 62\n\n3.4 Developing HBT (Heuristic-based Technique) ..................................................... 74\n 3.4.1 Overview of HBT Architecture ................................................................... 74\n 3.4.2 The HBT Workflow ................................................................................... 77\n\n4. EMPIRICAL EVALUATION .................................................................................. 83\n 4.1 Experiment Design .......................................................................................... 83\n 4.2 Subjects and Tasks ......................................................................................... 84\n 4.3 Evaluation Metrics .......................................................................................... 85\n 4.4 Empirical Results ............................................................................................ 86\n 4.5 Precision & Recall .......................................................................................... 90\n 4.6 Limitations of the Research .......................................................................... 92\n\n5. CONCLUSION AND FUTURE WORK .................................................................. 94\n\nREFERENCES ........................................................................................................... 97\n\nAppendix A: The user interfaces of EIPW ................................................................. 108\n\nAppendix B: The user interfaces of HBT ................................................................. 118\n\nAppendix C: Experimental Problem Statements .................................................... 130\n\nAppendix D: Pre-Experiment Questionnaires .......................................................... 134\n\nAppendix E: Pre-Experiment Questionnaires .......................................................... 137\n\nCurriculum Vitae ..................................................................................................... 139\nLIST OF TABLES\n\nTable 2.1 Comparing the properties of patterns adapted from (T. Han, 2002) ........................................... 31\nTable 2.2 A summary of conceptual modeling tools or systems ............................................................... 43\nTable 4.1 The Experiment Design ........................................................................................................ 85\nTable 4.2 An ANOVA analysis of modeling quality ............................................................................. 86\nTable 4.3 An ANOVA analysis of modeling quality ............................................................................. 88\nTable 4.4 Tests of between-subjects effects with dependent variable QUALITY SCORE ........... 89\nTable 4.5 Results of the performance of our KBSs ............................................................................. 92\nLIST of FIGURES\n\nFigure 1.1 The database reverse engineering concept ......................................................... 10\nFigure 2.1 The numbers of possible occurring relationships .................................................. 20\nFigure 2.2 Database Reverse Engineering Process (H. Chiang, 1993) ..................................... 45\nFigure 2.3 An example of WordNet hypernym chains ............................................................. 48\nFigure 3.1 An example of an EIP and RIP, respectively ........................................................... 51\nFigure 3.2 The executable DDL schemas .............................................................................. 52\nFigure 3.3 The metadata model of an EIP and an RIP .............................................................. 53\nFigure 3.4 The EIPW architecture ......................................................................................... 62\nFigure 3.5 The EIPW’s user interface of Step 1 ....................................................................... 65\nFigure 3.6 Entity Identification Process in EIPW ................................................................. 70\nFigure 3.7 Relationship Identification Process in EIPW ........................................................ 73\nFigure 3.8 The output of EIPW .............................................................................................. 74\nFigure 3.9 The HBT Architecture ......................................................................................... 76\nFigure 3.10 An example of user interface in HBT ................................................................. 77\nFigure 3.11 Entity Identification Process in HBT ................................................................. 79\nFigure 3.12 The output of HBT ............................................................................................ 82\nFigure 4.1 The framework of empirical experiments .............................................................. 84\nFigure 4.2 The plot of the mean quality scores (%) .............................................................. 87\nFigure 4.3 The plot of the mean quality scores (%) .............................................................. 88\nFigure 4.4 The plot of the mean quality scores (%) .............................................................. 90\nConceptual modeling is the foundation of analysis and design methodologies for the development of information systems. It is challenging because it requires a clear understanding of an application domain and an ability to translate the requirement specifications into a data model. However, novice designers frequently lack experience and have incomplete knowledge about the application being designed. We propose new types of reusable artifacts called Entity Instance Repository (EIR) and Relationship Instance Repository (RIR), which contain ER (Entity-Relationship) modeling patterns from prior designs and serve as knowledge-based repositories for conceptual modeling. We also select six data modeling rules to check whether they are comprehensive enough in creating quality conceptual models. This research aims to develop effective knowledge-based systems (KBSs) with EIR and RIR. Our proposed artifacts are likely to be useful for conceptual designs in the following aspects: (1) they contain knowledge about a domain; (2) automatic generation of EIR and RIR overcomes a major problem of inefficient manual approaches that depend on experienced modeling designers and domain experts; and (3) they are domain-specific and therefore easier to understand and reuse. Two KBSs were developed in this study: Heuristic-Based Technique (HBT) and Entity Instance Pattern WordNet (EIPW). The goals of this study are (1) to find effective\napproaches that can improve the novice designers’ performance in developing conceptual models by integrating pattern-based technique and various modeling techniques, (2) to evaluate whether those selected six modeling rules are effective in HBT, and (3) to validate whether the proposed KBSs are effective in creating quality conceptual models. To assess the potential of the KBSs to benefit practice, empirical testing was conducted on tasks of different sizes. The empirical results indicate that novice designers’ overall performance increased by 30.9~46.0 % when using EIPW, and increased by 33.5~34.9% when using HBT, compared with the cases of no tools.\n1. INTRODUCTION\n\n1.1 Motivations and Problem Statement\n\nConceptual data modeling is the foundation of analysis and design methodologies for the development of information systems. From academic literature, conceptual design is probably the most critical and important process of developing a quality database application because it not only provides a blueprint for the entire system but also determines most of the system functions and structures (Thalheim, 2000). However, it is difficult because it requires a clear understanding of an application domain and an ability to translate requirement specifications into a data model.\n\nThe quality of a conceptual model is measured by the level of accuracy with which it can reflect the real world environment (Dullea, 2003). A good conceptual model has to narrow the gap between real-world concepts and the ability to represent them in a conceptual model. Any errors incurred at this stage could become very costly later after a system has already been implemented. Boehm (Boehm, 1981) reports that the cost difference to correct an error in the early phases of software development as opposed to post-implementation phase is on the order of 1:100. Early in the development of database designs, two qualities, which are performance and storage, have to be measured because of their significant impact on the cost over the life cycle of the database. New hardware technologies have shown that these measurements become less important since their associated costs drop dramatically. However, the database design is the pivotal artifact of\nthe information system. Due to the complexity and size of these systems, the conceptual\ndesign phase of the database has still remained extremely important. It is necessary to\nmake it correct, as a poorly designed conceptual data model can lead to a poor database;\nhence, high costs and poor performance for decades to come.\n\nNatural language (NL) is the common tool for people to describe and communicate\ntheir understanding of the world. It has shown that nearly 90% of all the initial\nrequirement specifications in industrial practice are written in NL (L. Mich, Franch, M.,\nInverardi, P., 2004; Neill, 2003). On the structured representation side, there are many\ndifferent target formalisms for conceptual data models in different domains. For example,\nEntity-Relationship diagram (ERD) is often used for database design, while UML class\ndiagram is often used for object-oriented (OO) software design. However, approaches\n(Batini, 1984; J. Choobineh, Mannino, M., Nunamaker, J., 1988) which skip the NL\nphase by requiring information analysts to write the requirements directly into formal\nrepresentations involve much more human effort in the process and cause communication\ndifficulty with the end users. NL was and will remain the main form of requirements\ndocumentation (Cheng, 2007). Consequently, in our research, conceptual data modeling is\na translating process from NL representations to some kinds of formal representations.\n\nThe difficulties in developing the conceptual data models have been stated in many\npast research studies (Antony, 2002; D. Batra, 2007; D. Batra, Antony, S., 1994; D.\nMoody, 2005). These studies show that conceptual designs especially developed by\nnovice designers, lead to unsatisfactory and inaccurate outcomes. Our survey shows that the difficulties in creating conceptual models are:\n\n1. *Ambiguity in a Requirement Specification*\n\n Most of the inputs in this process are given in NLs which are inherently ambiguous.\n\n2. *Combinatorial Complexity*\n\n In conceptual modeling, a linear increase in the number of entities can result in a combinatorial increase in the number of possible relationships (D. Batra, 2007). With merely 5 entities, the numbers of possible relationships are 20 if cardinality is not considered or could be 80 if cardinality is considered.\n\n3. *Semantic Mismatch*\n\n It represents the inability of novice designers for translating the requirements literally into conceptual modeling structures (D. Batra, 2007). It is also known that not all real-world relationships match to conceptual modeling relationships; some real-world relationships are derivable at the implementation level. In addition, some real-world relationships become indirect, resulting in ambiguous semantics. Indirect relationships without direct relationships cause semantic ambiguities.\n\n4. *Inexperience and Incomplete Knowledge of Novice Designers*\n\n Novice designers frequently lack experience and have incomplete knowledge about the application being designed. Even expert designers could fail to obtain a\nquality conceptual model due to their lack of domain knowledge, unless they have a clear perception of a requirement specification (N. Kim, Lee, S., Moon, S., 2008). Concepts that are not explicitly expressed in a requirement are often very difficult to model. Expertise in domain knowledge to identify the hidden entities and relationships is therefore needed (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004).\n\n5. **Scattered Modeling Rules**\n\nThere is no complete set of rules/heuristics that help developing conceptual data models. Also, there is always trade off in design so that not all rules/heuristics can work together because some rules/heuristics are conflicting. These conflicting rules may provide wrong advice.\n\nCurrently, there are several commercial graphical CASE tools for automatically converting a conceptual data model into a logical model and into a physical implementation. Most of them offer forward engineering processes, and some of them also reverse engineering processes as well. However, there is still no commercial tool available for translating NL requirement specifications into conceptual data models. At present, a fully automated conceptual modeling approach seems impossible due to the inherent ambiguities in NL, context-dependent nature of modeling, and incompleteness of domain knowledge. It is desirable to develop a semi-automatic process which would be much more economical than an entirely manual modeling process. Therefore, many researchers have proposed knowledge-based systems (KBSs) and tools to support the\ndesigners in developing conceptual models (Antony, 2002; J. Choobineh, Lo, A., 2004; Du, 2008; Harmain, 2003; N. Omar, 2004; Ovemyer, 2001; S. Purao, 1998; S. Purao, Storey, V., Han, T., 2003). One of the limitations of the proposed tools is that such tools do not solve the problems that novice designers are inexperienced and have incomplete knowledge. In addition, they do not address the semantic mismatch issue.\n\nAn ontology can be a source of domain knowledge and designers can use the ontology to get initial domain knowledge. However, developing an extensive and usable domain ontology is labor-intensive and time-consuming (Sugumaran, 2006). Currently, several research projects are considering emerging approaches that try to reuse as much knowledge included in existing large scale ontologies as possible. However, they are general knowledge resources and are not created only specific for conceptual modeling applications. So far there are no good user interfaces or effective APIs to make the process effective and usable (Conesa, 2010). Obviously, domain ontologies are more usable than large scale ontologies.\n\nMost conceptual designs are usually created from scratch, although a similar design might have previously been created. And in many organizations there are a large number of database designs that have been already developed over many years. Reuse of already existing resources and solutions has become a strategy for cost reduction and efficient improvement in the information system development process. Currently, building a library of reusable artifacts involves explication of human developer’s knowledge, which is major obstacle in facilitating reuse of knowledge (Ba, 2001; T. Han, Purao, S., Storey,\nIt requires effort from experts to identify elements with potential reuse, and then convert these into reuse elements. One solution to reduce efforts and time of human experts comes from extracting artifacts from prior designs. If this could be conducted for various application domains, then it would assist in creating the practically reusable libraries.\n\nIn this research, we explore knowledge-based and pattern-based approaches that help novice designers develop quality conceptual data models. Our methodology also includes database reverse engineering concepts. We propose new types of reusable artifacts that contain knowledge about an application domain, called the entity instance repository (EIR) and the relationship instance repository (RIR), which are repositories of entity instance patterns (EIPs) and relationship instance patterns (RIPs), respectively. An EIP is a pattern of a single entity and its properties. An RIP is a binary relationship with cardinality constraints between two entities. The EIP and RIP can be automatically extracted from prior relational database schemas. Our proposed artifacts are useful for conceptual designs in the following aspects: (1) they contain knowledge about a domain; (2) automatic generation of EIR and RIR overcomes a major problem of inefficient manual approaches; and (3) they are domain-specific and therefore easier to understand and reuse.\n\nTypically, a rule-based approach (P. Chen, 1983; Harmain, 2003; Hartmann, 2007; N. Omar, Hanna, P., Mc Kevitt, P., 2004) is a popular technique for conceptual modeling because it could lead designers with known heuristics. However, this approach\ndoes not provide an optimal solution to many sophisticated requirements because most of the proposed rules/heuristics were built based on syntax of some specific NLs. These rules cannot overcome the inherent ambiguities of NLs. For instance, entities can be extracted from nouns in English sentences to produce a list of entities. However, the correspondences between entities are not completely perfect since nouns are also used to refer to many concepts that are not usually represented as entities in conceptual models. In general, rules/heuristics are often useful, but sometimes they may lead to cognitive error called bias (D. Batra, 2007; D. Batra, Antony, S., 1994; Parson, 2004). To overcome these errors, we should have a small but sufficient set of rules to create quality conceptual models and make them easy to understand. In this research, we select six data modeling rules termed as the six domain independent modeling rules that are considered a minimum set of rules to teach novice designers in creating quality conceptual models. We evaluate the usefulness of this set of rules by developing a KBS named heuristic-based technique (HBT) that applies these rules to the creation of conceptual data models.\n\nTwo knowledge-based systems were developed in this study: HBT and EIPW (Entity Instance Pattern WordNet). The tasks of our KBSs are divided into two subtasks: entity identification and relationship identification. The entity identification processes of our KBSs are different, but the relationship identification process in them is the same. The architectures of each KBS will be presented in later sections. The goals of this study are as follows: (1) to find effective approaches that can improve the novice designers’ performance in developing conceptual models by integrating pattern-based technique and\nvarious modeling techniques, (2) to evaluate whether those selected six modeling rules are effective, and (3) to validate whether the proposed KBSs are effective in creating quality data models.\n\n1.2 Research Questions and Objectives\n\nThis research seeks to address the following questions.\n\n*Question 1: Can we automatically create EIR and RIR from the prior relational database schemas?*\n\nMost of the proposed reusable artifacts used for conceptual data models are developed based on a manual approach that is time-consuming and skill-intensive for expert designers. Reusable artifacts for conceptual data models are typically represented in the form of patterns that can be instantiated and combined in different ways to produce concrete design (Blaha, 2010; Castano, 1998; Coad, 1995; Fowler, 1997; T. Han, Purao, S., Storey, V., 2008). The widely used approach to build such patterns is called domain engineering. A purpose of domain engineering is to create patterns that embody a generic solution to common problems within a specific domain by following a series of predefined steps such as domain analysis, domain design, and domain implementation (Sherif, 2002). With this approach, designers must have very clear knowledge about the specific domain and must identify the boundaries of what objects to be included and what degree they should be abstracted. Therefore, this approach does not seem to be a practically efficient approach because it takes time and effort to develop reusable\nartifacts. That is a significant drawback of the existing approach that we attempt to address in this research.\n\nIn this research, we propose an automatic methodology for creating EIR and RIR, which are the repositories of EIPs and RIPs, respectively. Our methodology includes database reverse engineering concepts. The database reverse engineering approach can provide a solution to the problem as stated previously. It is defined as shown in Figure 1.1, in this research, as the process of examining existing database design schemas to:\n\n1. Identify database’s elements (e.g. entities, attributes, etc.) and their interrelationships.\n\n2. Determine domain semantics which are not explicitly represented in an application system. Domain semantics are information about the application domain, which should be captured during the requirements specification phase of database design.\nThe outputs of this database reverse engineering process are transformed into the instance patterns, which are EIPs and RIPs, and can be reused as a source of architecture components for developing conceptual models.\n\nThe first objective to address the question above is:\n\n**Objective 1: Developing an automated methodology based on database reverse engineering concept to create the EIR and RIR as new types of reusable artifacts for conceptual model designs.**\n\nThe next step of the study is to investigate how EIR and RIR can assist or improve conceptual data modeling. Thus, the next question is:\n**Question 2: Can we use EIR and RIR for semi/automatically developing conceptual data models?**\n\nAvailable commercial graphical CASE tools can help in documenting and analyzing the output of analysis and design. However, they do not provide any support in conceptual data modeling—especially during a stage of identifying the entities, attributes, and relationships, which represent the problem domain. Therefore, many researchers have proposed knowledge-based systems (KBSs) or tools to support the designers in modeling conceptual models. One of the limitations of proposed tools or KBS is that such tools have no domain knowledge or semantic analysis capacity incorporated into them. Therefore, these tools cannot solve the incomplete knowledge of designers and the semantic mismatch issue.\n\nIn this research, we explore knowledge-based and pattern-based approaches that help designers develop quality conceptual data models. One of our goals in this study is to provide designers with instance patterns that contain knowledge about an application domain in which the designers are interested. The KBS with EIR and RIR called EIPW (Entity Instance Pattern WordNet) will be developed. The second objective to address this question above is:\n\n**Objective2: Developing a KBS called EIPW with EIR and RIR that contain domain semantics regarding an application domain.**\nThe following step of this study is to examine whether our proposed EIPW will provide quality conceptual data models and will thus be attractive to the designers. The research question is:\n\n**Question 3:** Can the EIPW with EIR and RIR create quality conceptual data models?\n\nSince our proposed EIR and RIR are automatically extracted from existing relational database schemas, the quality of the KBS with EIR and RIR depends on the scope and correctness of the existing designs. Our research starts creating EIR and RIR based on the library of DDL (Data Definition Language) schemas created by (Silverston, 2001). Later, the instance patterns in EIR and RIR are also extended with case studies. In order to make EIPW more efficient, it is also integrated with other modeling techniques. Although there are several KBSs or tools proposed to assist the designers during conceptual data modeling phase, the efficiency of these systems has not been tested empirically which is a drawback of current research (D. Moody, 2005; Simsion, 2007).\n\n**Objective 3:** Evaluating the usefulness of the EIPW by a human subject experiment.\n\n**Question 4:** Are six domain independent modeling rules sufficient to develop quality conceptual model?\n\nOur survey shows that one of the difficulties in creating conceptual models is the scattered modeling rules. There is no complete set of rules that helps in developing conceptual models. In addition, there are trade-offs in design so that not all rules can work together because some rules are conflicting. We have selected the six domain\nindependent modeling rules based on teaching experiences of over 20 years by one of the committees of this study. These six rules are considered a minimal set of rules to teach novice designers in creating quality conceptual models. These rules are not based on the syntax of any NLs and thus are domain independent. This means that these rules can be applied to a wide range of applications and domains. In this research, we would like to discover if the six rules are indeed useful. We evaluate the usefulness of these rules by developing a KBS named heuristic-based technique (HBT) that employs these six rules for creating conceptual data models.\n\nObjective 4: Developing the knowledge-based system (KBS) named HBT and evaluating the usefulness with human subjects.\n\n1.3 Contributions\n\nIn summary, the contributions of this research are:\n\n1. Proposed an automated methodology for creating EIR and RIR as new types of reusable repositories that contain knowledge about an application domain. The EIR and RIR leverage knowledge from existing designs and serve as knowledge-based repositories for conceptual data modeling by reducing the amount of work on the part of experts.\n\n2. Demonstrated that EIR and RIR are useful for conceptual designs in the following aspects:\n\n 1) They contain knowledge about a domain;\n2) Automatic generation of EIR and RIR overcomes inefficient manual approaches that depend on experienced modeling designers and domain experts;\n\n3) They are domain-specific and therefore easier to understand and reuse.\n\n3. Evaluated the six domain independent modeling rules as a set of rules that are comprehensive enough to create quality conceptual models.\n\n4. Designed and developed two knowledge-based data modeling tools called HBT and EIPW. HBT incorporates the six domain independent modeling rules, entity categories, and relationship instance repository. EIPW incorporates entity instance repository, entity categories, relationship instance repository, and WordNet. They minimize the cognitive load on designers and ensure that the conceptual models are correct. HBT can serve as a learning tool as well as provide a smooth head-start for novices.\n\n5. Evaluated and demonstrated the utility of the KBSs by human subject experiment.\n\n1.4 Dissertation Organization\n\nThis dissertation proposal is organized into five chapters. This chapter is an introductory chapter. It lays out research problems expected to be addressed by the proposed research, and gives an overview of our research questions, as well as contributions of the work. Chapter 2 provides a literature review, comprising four major areas. The first area is conceptual data model and discussion of current problems in the\nfield. The second area is techniques of automating conceptual modeling. The tools, systems, frameworks and related work on each technique are surveyed. The third area is database reverse engineering concepts. The fourth area is WordNet as a knowledge-based system for supporting our research methodologies. Chapter 3 describes the research methodologies and research procedures in detail. Chapter 4 presents statistical analysis and empirical results. Chapter 5 summarizes the finding of the study and suggests future work.\n2. LITERATURE REVIEW\n\nFollowing the research goals outlined in Chapter 1, this chapter provides a literature review, comprising four major areas. The first area discusses the conceptual data model and current problems in the field. The second area focuses on techniques of automating conceptual modeling. The tools, systems, frameworks and related work on each technique are surveyed. The third area looks at database reverse engineering concepts. The fourth area presents WordNet as a reference system for supporting our research methodologies.\n\n2.1 Conceptual Data Models\n\nConceptual data modeling is the foundation of analysis and design methodologies for the development of information systems. For many years, some researchers have proposed varied conceptual modeling formalisms such as Entity-Relationship (ER) modeling (P. Chen, 1976), derivatives of ER model such as IDEF1X, Oracle CASE notation, and IE, Natural/Nijssen Language Information Analysis Method (NIAM), the Extended Entity Relationship (EER) model, Object Role Modeling (ORM), Object-Oriented (OO) modeling, Unified Modeling Language (UML), EXPRESS, RM-ODP, and others. Thalheim (Thalheim, 2000) estimates that the total numbers of proposed derivatives of ER model are 80. Comparisons of these data modeling formalisms in terms of quality of data models, quality of design time preference, time task performance, and so forth are shown in studies by Kim and March (Y. Kim, March, S., 1995) and Neill\nOf the aforementioned modeling formalisms, EXPRESS, RM-OMP, and UML have been formally designated as standards.\n\nAmong the different conceptual modeling formalisms, ER models and UML models are the most widely used in practice (L. Mich, Franch, M., Inverardi, P., 2004). The ER model original proposed Chen (P. Chen, 1976) has been widely used in structured analysis and conceptual modeling. The ER approach is easy to understand, powerful enough to model real-world problems and readily translated into a database schema (Elmasri, 2004). The ER model consists of a collection of entities, relationships between entities and attributes describing entities and relationships. Many extensions or revisions of ER model have been proposed and utilized in different applications (Gogolla, 1991; Teorey, 1986) such as EER (Extended ER model or Enhanced ER model). The UML is another important conceptual data modeling approach, especially in software engineering. The UML is the standard modeling language for the analysis and design of software. Unlike the ER modeling approach that provides only one type of diagram (ERD), UML 2.2 provides 14 types of diagrams. It is difficult to translate NL requirement specifications to all 14 UML diagrams. Mostly the correspondence between natural language (NL) components and class diagram has been examined in previous research.\n\nA major innovated conceptual modeling formalism is the use of established ontologies as theoretical bases for developing, comparing, and improving data models (Simsion, 2007). Bunge’s ontology (Bunge, 1979) has been the most widely used for\nanalyzing conceptual data models (Bodart, 2001; Y. Wand, Storey, V.C., Weber, R., 1999; Y. Wand, Weber, R., 1993, 1995). This ontology has also been adapted by Weber and Wand called Bunge-Wand-Weber (BWW) (Y. Wand, Weber, R., 1988) into a theory of representation that is closer to terminology of the Information Systems community. Some researchers (Milton, 2004) employ Chisholm’s ontology (Chisholm, 1996). Both Bunge and Chisholm postulate an objective reality independent of human perceptions. OntoClean (Guarino, 2004) is developed based on philosophical notions for evaluating taxonomical structures. Integration between different ontologies has also been used by different researchers but for different purposes.\n\nNatural language (NL) is the common tool for people to describe things and communicate. Reports (L. Mich, Franch, M., Inverardi, P., 2004; Neill, 2003) show that nearly 90% of all the requirements in industrial practice are written in NL. Methods that skip the NL understanding phase and that require human analyst to write the requirements directly into formal representations. However, there are at least three limitations for this translation (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004): 1) NL is ambiguous. An effective and accurate analysis is difficult. Therefore, techniques and rules for modeling are required; 2) The same semantic can be represented in different ways. Therefore, ways of handling these style variations are necessary; and 3) Concepts that are not explicitly expressed in a requirement specification are often difficult to model. Expertise in domain knowledge to discover the hidden entities is therefore needed.\n2.2 The difficulties in creating conceptual data models\n\nThe difficulties in creating conceptual data models have been documented in past research studies (Antony, 2002; D. Batra, 2007; Currim, 2008; Dey, 1999; Liao, 2000; D. Moody, 2004; Shoval, 1997). In spite of its importance, research evidences show that conceptual data modeling is not done well, and it should be improved in both training and education (Simsion, 2007). Researchers (D. Batra, Antony, S., 1994; Currim, 2008; Simsion, 2007) have studied the conceptual data modeling design process employed by novice designers to gain an understanding of errors causing factors. These factors are important in building tools and techniques that can prevent the errors and enhance the quality of information systems. The factors are:\n\n1. Combinatorial Complexity\n\nPrevious research from a complete survey (Topi, 2002) shows that novice designers have more difficulty in modeling relationships than entities. Batra and Anthony (D. Batra, 2007; D. Batra, Antony, S., 1994) examine designer performance in modeling open-ended exercises and find that the novice designers not only have difficulty in modeling relationships such as unary and ternary, but also have the difficulty in modeling all kinds of relationships including binary relationships. One of the reasons comes from the fact that given a set of entities, there are potentially a very large number of possible relationships. As the number of entities increases, the number of possible relationships increases at a combinatorial rate as shown in Figure 2.1. What are the rules that allow a designer to choose the right set of relationships in the ER model? And how does the\ndesigner know whether all the correct relationships between the entities are identified and which relationships are incorrect? Most relationships can be derived from others, so the problem in modeling relationships is selecting a minimum set that captures the semantics effectively and can be used to derive the others. For the right identification of relationship constructs, the following criteria should at least be met: (1) all semantics in the application should not be lost, (2) all relationship constructs should not be redundant relationships, (3) and the degree of relationship should be minimal.\n\n\n\nFigure 2.1 The numbers of possible occurring relationships\n\n2. *Scattered Modeling Rules*\n\nThere is no complete set of heuristics/rules that help in developing quality data models. In general, heuristics/rules are often useful, but sometimes they may lead to cognitive errors called biases (D. Batra, Antony, S., 1994; Parson, 2004). Furthermore,\nthere is always trade off in design so that not all the rules can work together because some rules are conflicting. These conflicting rules may provide inaccurate advice.\n\n3. **Semantic Mismatch**\n\nTranslating the requirement specification literally into database structures causes literal translation errors (D. Batra, 2007). For instance, a sentence stating that “an order records a sale of products to customers” may include an erroneous relationship between customer and product. It shows that not all real-world relationships map to database relationships; some real-world relationships are derivable at the database level. In addition, some real-world relationships become indirect, resulting in ambiguous semantics. Indirect relationships without direct relationships are wrong.\n\n4. **Inexperience of novice designers and incomplete knowledge of designers**\n\nNovice designers have limited knowledge and skills, while expert designers often draw from their past experiences. Even an expert designer might fail to create a quality conceptual model due to their lack of domain knowledge, unless he or she has a clear perception of requirement specifications (N. Kim, Lee, S., Moon, S., 2008). Expertise in domain knowledge to identify the hidden entities is therefore needed. The important issues are how the novice designers can be trained efficiently and how domain knowledge can be transferred to the designers.\n\n5. **Multiple solutions**\n\nIn conceptual design, there is neither a single answer nor an algorithm for creating the best answer. Moody and Shanks (D. Moody, Shanks, G., 1994) also state that one of\nthe common problem encountered in design is the large number of alternative designs that can be created for a particular problem. Therefore, they propose a six-element framework to evaluate the quality of conceptual data models (D. L. Moody, 1998). Their frameworks are composed of completeness, simplicity, flexibility, understandability, integration, and implementability. Later this framework is refined, and empirically tested in (D. L. Moody, Shanks, G.G., 2003).\n\n### 2.3 Techniques used for automating conceptual modeling\n\nIn the past few years, the field of conceptual data models has spawned numerous techniques for the identification of entities, attributes and their relationships. However, these techniques rely heavily on manual processes and experiences of designers. Currently, there are several commercial graphical CASE tools for automatically converting a conceptual data model into a logical model and into physical implementations such as ERWin, Rational Rose, Visio, Oracle Designer, Dia, etc. Most of them offer forward engineering processes, and some of them reverse engineering processes as well. However, there is still no commercial tool available for translating NL requirement specifications into conceptual data models. At present, a fully automated conceptual modeling approach seems impossible due to the inherent ambiguities in NL, context-dependent nature of modeling, and incompleteness of domain knowledge. It is desirable to develop a semi-automatic process which would be much more economical than an entirely manual modeling process.\nThis section presents the board scope of techniques used for automatically developing conceptual models. There are at least five categories of techniques used for automatically generating conceptual models design from NL requirement specifications. They are linguistic-based, pattern-based, case-based, ontology-based, and multi-techniques-based.\n\n### 2.3.1 Linguistic-based\n\nNatural language processing (NLP) and linguistic theories are used as a means for designing more user-oriented information and communication systems because NL is a common tool for people to describe and communicate their understanding of the world (Castro, 2009; Métais, 2002). Chen (P. Chen, 1983) proposes eleven rules for translating English sentence structures into ER diagram’s structure. Since Chen’s initial proposal, many studies (Hartmann, 2007; P. Johannesson, Kalman, K., 1989; N. Omar, Hanna, P., Mc Kevitt, P., 2004; Ovemyer, 2001) have tried to refine and extend on this approach. However, these rules are still not complete and fully accurate. Although entities can be identified by nouns in a requirements specification, the correspondence between entities and nouns does not completely match because nouns not only refer to entities but also to attributes and other concepts. Entities can also be identified from verb phrases and hidden requirements (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004). Most recently, Hartmann and Link (Hartmann, 2007) modify Chen’s eleven rules for the translation from English sentence structures and EER elements in which they re-organize and extend those rules in twelve heuristics. However, even these heuristics are not complete.\nTherefore, this technique can only serve as a basis for a manual or semi-automatic process of transforming an English specification into ER model. Furthermore, most of the proposed rules are built based on syntax of some specific NLs. These rules cannot overcome the inherent ambiguities of NLs. In addition, most of the languages in this world are very different and, therefore, these kinds of rules can not apply worldwide.\n\nIn order to solve the inherent problems of NL and to succeed the machine translation, some studies put constraints on the input by restricting either the vocabulary or the sentence structures (Ambriola & Gervasi, 2006; Osborne & MacNish, 1996; Tjoa, 1993). With these restrictions, simple linguistic processing such as tagging and chunking can achieve reasonably good results. These also improve the tractability of many difficult problems in NLP such as ambiguity and unknown words. However, the use of controlled languages has some limitations. It can not apply to existing requirement documents. Furthermore, they are not natural and place burdens on the requirements writers. Several formal specification languages such as Z, Object-Z, VDM, B, and OCL have been also proposed for formal model-based specification. They are very expressive but require knowledge to write a correct formalization. However, they lack completely supporting tools and the use of these tools needs deep knowledge of them in order to write them efficiently. Moreover, these languages have been designed for some specific applications, and their use for different purposes may become awkward and difficult. Other researchers propose dialogue tools that help elicit the NL requirement specification (Buchholz, 1995; N. Kim, Lee, S., Moon, S., 2008). The main disadvantages of these tools are that they\nrequire more interventions by users and it is difficult to use them for large scale batch processing.\n\nTheory of classification and categories has been applied to conceptual data modeling (Larman, 2004; I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004). Categories are characterized by the properties shared by their members whereas entities could be classified unambiguously according to their common attributes. It is a widely-used technique in identifying entities and classes. In addition, class categories can be used to spot the missing entities or classes. Also, there are some hidden entities or classes that are not explicitly stated in the requirement documents but can be discovered by applying class categories to domain knowledge (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004).\n\nThe trend in this technique orients towards the collaboration with huge linguistic dictionaries (Fellbaum, 1998; Miyoshi, 1996) and common sense ontologies (Lenat, 1995). Sometime computers are not skillful because they lack basic knowledge that is obvious for humans. Researchers have long sought to grab this basic knowledge for years. Linguistic dictionaries not only provide semantic links between concepts such as synonym, antonym, hypernym/hypernym (is-a), and meronym/holonym (part-of) but also syntactical and morphological information. A detailed discussion of relationship types is stated in (V.C. Storey, 1993b). WordNet is the best known linguistic dictionary used for conceptual modeling because it is available and it extends to other languages such as European languages, Spanish, Chinese, and so forth. However, the main drawback of\nWordNet is that it does not contain many other important semantic relationships (i.e., no relationship between dish and spoon). Therefore, WordNet++, the extension of WordNet, containing special types of relationships that are not available in WordNet, is proposed in (Dehne, 2001).\n\n### 2.3.1.1 Tools, systems, and related work\n\nMost of the tools or systems proposed for developing conceptual models follow this technique. They apply NLP to extract the model’s constructs from requirements specifications or dialogue sessions with a designer for creating conceptual data models (Buchholz, 1995; Burg, 1998; Du, 2008; Eick & Lockemann, 1985; Harmain, 2003; Meziane & Vadera, 2004; L. Mich & Garigliano, 1999; N. Omar, Hanna, P., Mc Kevitt, P., 2004; V.C. Storey, 1993a; Tjoa, 1993; F. S. C. Tseng, Chen, A.L.P., Yang, W., 1992). Most of these are involved in extending Chen’s original approach. A review of some proposed tools or systems can be found in (Du, 2008). Our paper will present only the recent ones.\n\nLIDA (Ovemyer, 2001) is a semi-automatic text analyzing tool that allows designers to produce class diagrams. It tags parts-of-speech and follows Chen’s eleven rules where there is an association of nouns with classes, relationships with verbs and attributes with adjectives and prepositional phrases. However, in requirement specifications, class can also be identified from verbs and hidden requirements (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004).\nCIRCLE (Ambriola & Gervasi, 2006) is a web-based comprehensive environment for aiding in NL requirements gathering, elicitation, selection, and validation. A human generated glossary and minimal domain descriptions are added to the original requirements. The actual recognition is performed by a number of MAS (Model, Action, and Substitution) rules. A detailed case study of a fictitious missile control system is provided and various stages of requirements analysis are covered.\n\nCOLOR-X (Burg, 1998) is based on WordNet. Its main goal is to facilitate the process of generating conceptual modeling. COLOR-X uses linguistic concepts that are similar to Chen’s rules for creating system models that reflect both static and dynamic aspects of the referred system. For example, it relates concepts (constructs) stated in WordNet to OO constructs in which object must be identified from nouns and relationship must be identified from verbs. Later (Dehne, 2001), they revise the method by using WordNet++ instead.\n\nCM-Builder (Harmain, 2003) is a NL-based CASE tool aimed to supporting the conceptual analysis stage of software development in an OO framework. This tool use NLP to analyze the requirement specifications and develop initial UML class diagrams. CM-Builder can work either automatically or interactively with the user. This tool converts all nouns into candidate classes and verbs into relationships. For every candidate class, the frequency in a requirement specification is counted before items are selected. The most frequent candidates are the most likely classes. Attributes are identified from heuristics such as possessive relationships and the use of verb phrase like “to have”.\n\nHowever, this tool has some limitations in its linguistic analysis because NL is ambiguous, fuzzy, and redundant.\n\nER-Converter (N. Omar, 2004) is a rule-based system. The rules are associated with weights according to the confidence level at which the event is true. The weights assigned to each rule are based on intuition. For example, “If a noun occurs before the verb ‘has/have’, it may indicate an entity type.” With a weight of 0.7, which means that 70% of the time this rule will create the correct result (because not all nouns before the verb ‘has/have’ are entity types). User interventions are required when the calculated weights are low in the processing.\n\nACDM (Du, 2008) is an automated multi-component system. The system is a fully integrated composite of existing, publicly available components including a parser (Link Parser), a lexical filter (WordNet) and a semantic filter (Google web corpus search facilities). After parsing, it uses extended Chen’s rules to identify ERD’s elements. The main limitation of this system is that the input has to be controlled language requirement specification.\n\nTseng and Chen (F. Tseng, Chen, C., 2008) propose a translation scheme for transforming NL queries into relational algebra through the class diagram notations. Based on a logical form developed by extending the UML class diagram notations, a transformation model is presented to support the automatic transformation of natural language queries into relational algebra by employing appropriate NLP techniques and OO analysis methods. The proposed logical form has the advantage that it can be mapped\nfrom NL constructs by referring to the conceptual schema modeled by class diagrams, and can be efficiently transformed into relational algebra for query execution.\n\n### 2.3.1.2 Strengths and drawbacks\n\nThe domain independence is the strength of this approach. However, the strength of this technique is also its weakness because tools or systems proposed have no domain knowledge incorporated in them. This technique does not provide an optimal solution to many sophisticated requirement specifications because of the nature problems of NL.\n\n### 2.3.2 Pattern-based\n\nThe important role of patterns in design is recognized in Alexander’s book (Alexander, 1979) on architecture and urban planning. It suggests that designers should produce and use patterns rather than solving problems from the first principle. Now patterns have been well established as a technique for reusing solutions of recurrent problems in the software development process. Pattern reuse provides many benefits such as higher productivity, software quality improvement, and reduction of time and cost for software development. Design patterns have been proven very useful in speeding up the design process through reuse, and in improving the overall quality of systems. Integrating patterns into conceptual design is challenging. Thalheim (Thalheim, 2000) also supports pattern-based modeling in his extensions to the ER model. The recognition of patterns in the context of conceptual data modeling is based on works by Coad et al. (Coad, 1995), Hay (Hay, 1996), and Fowler (Fowler, 1997). Like architects, they create a library of\nproven structure components, and provide some examples of adapting generic models to suit particular requirements. Empirical research shows that experts reuse patterns while novices do not (Chaiyasut, 1994). The process in pattern reuse can be divided into three tasks: retrieval, adaptation, and integration (Anthony, 2009). Retrieval involves choosing patterns that may be relevant to a particular problem. After a pattern is chosen, it must be adapted or instantiated to fit the specific problem. Finally, it needs to be integrated with other patterns to form a complete model in the form of a conceptual data model. Several authors have proposed various kinds of patterns (Coad, 1995; Fayad, 1997; Fowler, 1997; Gamma, 1995; Hay, 1996; P. Johannesson & Wohed, 1999; Johnson, 1988; Pree, 1994; Silverston, 2001; Szyperski, 1998). For the latest one, Blaha (Blaha, 2010) proposes several types of data modeling patterns: Universal antipatterns are the patterns that we should avoid for all applications; Archetypes are the common modeling patterns occurring across different applications; Canonical patterns are corresponding to meta models of modeling formalisms. However, their utility to conceptual modeling varies greatly. Finally, he presents methods for mapping his patterns to relational schema for database design. Three criteria (T. Han, Purao, S., Storey, V., 2008) can be used to examine these patterns. First, usability specifies the ease where an artifact can support retrieval (search and adaptation of the artifact for the current design) and assembly (integration of reusable artifact with other parts of design). Second, reusefulness is measured by the artifact’s granularity and abstractness (domain independence). Third,\nefficiency is measured by the effort necessary to create the artifacts. Table 2.1 summarizes the quality of each pattern based on the aforesaid criteria.\n\n<table>\n<thead>\n<tr>\n<th>Patterns</th>\n<th>Usability</th>\n<th>Reusefulness</th>\n<th>Efficiency</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Ease of retrieval</td>\n<td>Ease of assembly</td>\n<td>granularity</td>\n</tr>\n<tr>\n<td>Domain Models (Prieto-Diaz, 1987)</td>\n<td>high</td>\n<td>N.A.</td>\n<td>coarse</td>\n</tr>\n<tr>\n<td>Analysis Patterns (Coad, 1995)</td>\n<td>medium</td>\n<td>medium</td>\n<td>small</td>\n</tr>\n<tr>\n<td>Analysis Patterns (Hay, 1996)</td>\n<td>medium</td>\n<td>medium</td>\n<td>medium</td>\n</tr>\n<tr>\n<td>Analysis Patterns (Fowler, 1997)</td>\n<td>medium</td>\n<td>medium</td>\n<td>medium</td>\n</tr>\n<tr>\n<td>Analysis Patterns (D. Batra, 2005)</td>\n<td>medium</td>\n<td>medium</td>\n<td>medium</td>\n</tr>\n<tr>\n<td>Data Modeling Patterns (Blaha, 2010)</td>\n<td>medium</td>\n<td>medium</td>\n<td>small</td>\n</tr>\n<tr>\n<td>Framework (Fayad, 1997)</td>\n<td>medium</td>\n<td>medium</td>\n<td>coarse</td>\n</tr>\n<tr>\n<td>Semantic analysis Patterns (Fernandez, 2000)</td>\n<td>high</td>\n<td>medium</td>\n<td>coarse</td>\n</tr>\n<tr>\n<td>Components (Szyperski, 1998)</td>\n<td>low</td>\n<td>medium</td>\n<td>fine</td>\n</tr>\n<tr>\n<td>Domain Fragment (T. Han, Purao, S., Storey, V., 2008)</td>\n<td>high</td>\n<td>medium</td>\n<td>coarse</td>\n</tr>\n</tbody>\n</table>\n\nFrom the comparison table, the design and construction of prior reusable artifacts are labor-intensive and require a lot of time and effort from expert designers. It is shown that the third criterion, efficiency, is the most daunting obstacle to successful reuse.\nRecently, there are packaged data models (or model components) available, which can be purchased and after suitable customization, assembled into full-scale data models. These generic data models are designed to be used by organizations within specific industries. Well-known examples of packaged data models are provided by (Silverston, 2001) and (Kimball, 2002). In summary, the use of packaged data models yield two major advantages to an organization (Hoffer, 2004):\n\n1) Reducing the implementation times and cost.\n The time required to design and implement a large data model can be reduced by weeks or months by using this approach.\n\n2) Providing quality models.\n Packaged data models are created and tested by knowledgeable developers based on their experience with many industries and organizations. They tend to represent best practice data modeling technique.\n\n However, packaged data models cannot replace sound database analysis and design. Skilled analysts and designers are still needed to determine database requirements and to select, modify, and integrate any packaged systems that are used.\n\n2.3.2.1 Tools, systems, and related work\n\nThe traditional way of using patterns is to leave the decision of how to adapt or instantiate a pattern entirely up to the person designing the schema. Recently, analysis pattern repositories have been the most popular and employed in conceptual modeling\ntools or systems. Analysis pattern repository is a group of generic objects with stereotypical properties and relations in a domain neutral manner (D. Batra, 2005). To make use of patterns from a repository, the designer must be able to match a task description with a candidate pattern. According to Structure-Mapping theory (Gentner, 1998), there are three ways comparisons can be made. They are (a) Literal comparison, (b) Abstraction, and (c) Analogy. To reuse analysis patterns, Fernandez and Yuan (Fernandez, 2000) propose an approach that involves looking for semantic analysis patterns that match requirements exactly while trying to specialize analogous or abstract patterns that may apply. However, there are not many proposed conceptual modeling tools or systems using this technique.\n\nAPSARA (S. Purao, 1998) is a KBS (knowledge-based system), which automated analysis patterns to create OO conceptual design. It firstly uses NLP to parse the requirement specifications into significant keywords, and eventually objects. Based on the objects identified, analysis patterns are retrieved from the pattern repository, then instantiated and synthesized into a conceptual model. In its pattern repository, thirty analysis patterns by Coad (Coad, 1995). Later, this KBS is improved by incorporating learning mechanisms, which provide the designer with additional support by suggesting specific patterns that might apply (S. Purao, Storey, V., Han, T., 2003). The limitation of this approach is that analysis patterns are so abstract that mismatches to patterns are fairly common. Novice designers seem to have inability to reason with analogy (Anthony, 2009).\nModeling Wizard Tool (Wohed, 2000) is a dialogue tool for selecting the appropriate patterns. Various versions of patterns are stored. The appropriate one is selected step by step according to the answers given to the questions such as “Does the booking consist of one object or may it consist of several objects?” This tool requires much more on user intervention, and it is hard to use it for large scale batch processing.\n\n### 2.3.2.2 Strengths and drawbacks\n\nPatterns have proven very useful in speeding up the design process through reuse, and in improving the overall quality of systems by promoting the use of designs that have been proven superior in many applications. The advantage of reusable patterns aims not only to reuse schema compounds but also to reuse relationships between objects. However, building a repository of patterns involves explication of human developers’ knowledge, which is a major obstacle in facilitating reuse of knowledge. To develop pattern repository, designer must have very clear knowledge about the specific domain and must identify the boundaries of what objects to include and what degree they should be abstracted. It takes a lot of time and effort to create pattern repository. Currently, most of the proposed reusable pattern repositories used for conceptual data models is developed based on a manual approach that is time-consuming and skill-intensive for expert designers. Furthermore, most of the proposed tools in this technique use analysis patterns which require manual matching.\nOne solution to reduce the effort and time of human experts comes from extracting the pattern artifacts from existing designs (T. Han, Purao, S., Storey, V., 2008). If this could be done for various application domains, then it would assist in creating the practically reusable pattern artifacts. These patterns are also easier to understand and reuse because they are domain-specific.\n\n### 2.3.3 Case-based\n\nCase-based reasoning is a technology used to develop a KBS known as the case-based system. The basic idea is, given the description of a new problem, retrieving from a case base a similar problem and adapting the retrieval to get the solution. Retrieval mechanisms for reusable artifacts intensively require NLP techniques. And indexing techniques could speed up the retrieval of artifacts. Ambrosio et al. (Ambrosio, Métais, & Meunier, 1995) provide a mechanism for flexible queries. Flexible querying is obtained by the automatic modification of the query statements through the relaxation of query conditions in order to recover concepts within a certain semantic distance according to the semantic relations, i.e. synonyms, hypernym, meronym, and similarity.\n\n### 2.3.3.1 Tools, systems, and related work\n\nVery few have used case-based reasoning where cases of conceptual models are stored, indexed, and used for future design. We can find only three KBSs that use this technique, which are CSBR (V. C. Storey, Chiang, R., Goldstein, R., Dey, D.,\nSundaresan, S., 1997), DES-DS (Paek, 1996), and CABSYDD (J. Choobineh, Lo, A., 2004). A comparison between these KBSs can be found in (J. Choobineh, Lo, A., 2004).\n\nCABSYDD [64] is a case base reasoning system for database schema design. It comprises of two components: a CBR system and a module that will derive conceptual design from first principles. The case indexing used is similar to that used by (Paek, 1996) in which each schema design is hierarchically organized by business area. The hierarchy is organized by categorizing cases using a four tiered structure (sector, subsector, industry group, and department) based on the North American Industry Classification System (NAICS). Case representation included schemas expressed by EER models, textual identifiers for the business area classification, and a textual case description. Matching is performed by calculating the case with the highest matching index score. If no matching cases exist, the system invokes the module to create a new schema design from first principles.\n\n2.3.3.2 Strengths and drawbacks\n\nThis technique involves storing conceptual models of a large number of applications and providing a key word mechanism that enable users to search for a conceptual model that is a candidate solution for a problem statement. It takes advantage of reusing the previous design. The limitations in this technique are that if any adjustment is required in the conceptual model, it has to resort to the generic data modeling approach. Moreover, adjustments are always required in order to be appropriate for the\nparticular requirement specification. The major disadvantage of this technique is that developing the conceptual model libraries and indexing mechanism are very expensive.\n\n### 2.3.4 Ontology-based\n\nOntologies have been proposed as an important way to represent real world knowledge and, at some level, to support interoperability (Soares & Fonseca, 2007). Research on creating and using ontologies has been motivated by the Semantic Web and knowledge reuse. Ontology can range in expressivity from a taxonomy (a parent-child structure), to a thesaurus, to a domain model, to a logical theory (very general, consistent and meaningful knowledge), etc. Some papers point out some similarities and differences between ontologies and conceptual data models (El-Ghalayini, 2006; Fonseca, 2007). According to Fonseca (Fonseca, 2007), two criteria that differentiate ontologies from conceptual data models are (1) the objective of modeling and (2) objects to model. Embley (Embley, 2004) suggests that ontology is the key for solving the semantic problems of information systems.\n\nIn the conceptual modeling field, many researchers employ ontology for evaluating, improving or developing the conceptual modeling formalisms. Storey (V. C. STOREY, 2005) proposes an ontology to classify the verb phrases of relationships based on research in linguistics and semantic data models. Wand et al. (Y. Wand, Storey, V.C., Weber, R., 1999) propose rules as a theory of constructing the relationships in conceptual modeling practice. Evermann and Wand (Evermann, 2001) examine the mapping\nbetween ontological elements and UML elements and propose guidelines on how to use UML elements to model real-world systems in particular. Purao and Storey (S. Purao, Storey, V. C., 2005) propose a multilayered ontology for classifying relationships by using data abstractions and by separating domain-dependent and domain-independent aspects of the relationship constructs.\n\nHowever, the major advantage of using ontology for conceptual modeling is the reusability of knowledge repository. This can be developed into two levels: domain ontology and large scale or upper level ontology. Domain ontology (Conesa, 2010) represents concepts, relationships between concepts, and inference rules for a particular domain. The most well-known domain ontologies are the DAML ontologies (www.daml.org), which are created particularly for Semantic Web and contained a repository of more than 200 ontologies. Several tools for creating and querying domain ontologies are available such as Protégé, OWL, SPARQL, etc. Detail comparison of each tool is shown in (Corcho, 2003). Instead of developing individual ontologies, there has been interest in creating upper level or large scale ontology. Upper level ontology (Conesa, 2010) represents general concepts that are the same across all domains and always consist of a hierarchy of entities and rules that describe those general entities which do not belong to a specific problem domain. Examples of upper level ontologies are Cyc, ResearchCyc, BFO (Basic Formal Ontology), DOLCE, SUMO, geneontology, etc. For review and comparison of upper level ontologies see (Mascardi, 2007). The potential usefulness of upper level ontologies lies in the fact that they are domain\nindependent. However, it is difficult to integrate them and make them truly useful. A major problem with existing upper level ontologies is the lack of good user interface and a good API. For example, Cyc is not an ontology of word sense like WordNet. As a result, there is no comprehensive mapping of Cyc concepts into words of NL (Conesa, 2007). Without adequate tool support, it is difficult to work with them. Obviously, domain ontologies are more usable than large scale ontologies (Conesa, 2010).\n\n2.3.4.1 Tools, systems, and related work\n\nOntologies have been considered as important components in many applications. Some generic ontologies such as WordNet and Cyc are available, but most applications require a specific domain ontology to describe concepts and relations in the domain. This approach holds the potential of promoting information reused. Currently, several projects are considering the emerging approaches that attempt to reuse as much as possible of the knowledge included in existing ontologies.\n\nNL-OOPS (L. Mich, Garigliano, R., 2002) is an NL-based system. It is based on LOLITA (Large scale Object-based Language Interactor, Translator and Analyser) NLP system, which includes all the functions for analysis of NL: morphology, parsing (1500-rules grammar), semantic and pragmatic analysis, inference, and generation. The knowledge base of the system consists of SemNet, which is a large graph that holds knowledge that can be accessed and expanded using NL input and has been merged with WordNet. Thus LOLITA is among the largest implemented NLP systems. Documents in\nEnglish are analyzed by LOLITA and their content is stored in its knowledge base, adding new nodes to its semantic network. NL-OOPS prototype implements an algorithm for the extraction of classes and associations from the semantic network of LOLITA. NL-OOPS’s interface consists of three frames. The first one contains the text being analyzed and the second frame gives a partial representation of the SemNet structures used by LOLITA for the analysis of the document. After running the modeling module, the third frame gives a class model.\n\nOMDDE (Sugumaran, 2006) uses a domain ontology to represent the domain knowledge in order to assist database designer. OMDDE is a prototype that demonstrates the possibility of using an ontology as the domain knowledge. The prototype can assist Database designers to design a conceptual model from scratch and also evaluate the existing conceptual database model. The prototype uses an auction domain ontology as the knowledge domain to identify the entities and relationships for the conceptual model. The prototype also suggests terms and highlight missing constructs. Furthermore, it expands the relationship element to include four types of domain relationships: prerequisite, mutually inclusive, mutually exclusive, and temporal.\n\n2.3.4.2 **Strengths and drawbacks**\n\nOntology can be the source of domain knowledge and designers can use ontology to get initial domain knowledge. Corcho and his colleagues (Corcho, 2003) suggest that a strategy for developing ontologies would be to reuse large scale or upper level ontologies\nto create domain ontologies or knowledge bases. The same upper level ontology can be used for developing many knowledge bases or ontologies, which share the same skeleton. Extensions of the skeleton should make at the low level by adding domain-specific subconcepts.\n\nHowever, ontology development is fundamentally difficult. For example, Cyc takes more than 20 years and 900 people to develop a large scale common sense knowledge base. Even for a specific domain, developing intensive domain ontology requires labor intensive and time-consuming. Automatic ontology development is difficult work because of the lack of structured knowledge base or domain thesaurus. While many ontology tools such as OntoEdit, Ontolingua, and Protégé are available to aid the development of ontologies, ontology constructions still need human effort. Most studies of ontology development and application assume manual process.\n\n### 2.3.5 Muti-Techniques-Based\n\nFrom our survey, most tools or systems for conceptual design require users’ involvement during the process. And no single technique works best all the time because each technique has some limitations. Ideally, various techniques should be integrated together for a design process. For example, Song et al. (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004) have proposed a TCM (Taxonomic Class Modeling) methodology used for object-oriented analysis in business applications. This method integrates several class modeling techniques under one framework. Their framework integrates the noun\nanalysis method, class categories, English structures, check lists, and modeling rules.\n\nThonggoom and colleagues (Thonggoom, 2011) propose EIPW (Entity Instance Pattern\nWordNet), which is a knowledge-based database modeling tool. It integrates pattern-\nbased technique and various modeling techniques. This tool shows how domain\nknowledge stored in the instance patterns can be used together with other modeling\ntechniques.\n\n2.4 Evaluation Method\n\nEvaluation acts as a significant after-stage in all surveyed techniques. Although\nthere are several systems or tools proposed to assist the designers during conceptual\nmodeling phase as shown in Table 2.2, the efficiency of these systems has not been tested\nempirically which is a drawback of current research (D. Moody, 2005; Simsion, 2007).\nAlso, in this field, there are no universal standard guidelines for measuring the\nperformance of the proposed tools or systems. Some researchers use individual grading\nframeworks for the evaluation, while some use recall and precision as the measurements\nfor evaluation. Even though they use the same method for the measurement, the\nconditions of measurements are very different. Since there is no standard evaluation of\nNL-based tools available, it is difficult to compare the performances between and among\nthe tools.\n<table>\n<thead>\n<tr>\n<th>Input</th>\n<th>Output</th>\n<th>Techniques used</th>\n<th>User Intervention</th>\n<th>Lexical Knowledge</th>\n<th>Domain Knowledge</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ACDM (2008)</td>\n<td>Controlled NL text</td>\n<td>ER model</td>\n<td>Linguistic Rules, Lexical Filter</td>\n<td>Can be automatic or semi-automatic</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>APSARA (2003)</td>\n<td>NL text</td>\n<td>ER model</td>\n<td>Analysis Patterns, Learning Concepts</td>\n<td>Yes</td>\n<td>No</td>\n</tr>\n<tr>\n<td>CABSYYDD (2004)</td>\n<td>NL text</td>\n<td>EER model</td>\n<td>Case-based Reasoning</td>\n<td>Yes</td>\n<td>No</td>\n</tr>\n<tr>\n<td>CIRCLE (2006)</td>\n<td>NL text</td>\n<td>View model, Validated requirement</td>\n<td>Linguistic Rules, Requirement Validation</td>\n<td>Yes</td>\n<td>No</td>\n</tr>\n<tr>\n<td>CM-Builder (2003)</td>\n<td>NL text</td>\n<td>Class diagram</td>\n<td>Linguistic Rules, Frequency Analysis</td>\n<td>Can be automatic or semi-automatic</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>Color-X (1998)</td>\n<td>NL text</td>\n<td>OO constructs</td>\n<td>Linguistic Rules, Paraphrase Dialog</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>EIPW (2011)</td>\n<td>NL text</td>\n<td>EER model</td>\n<td>Instance Patterns, Entity Categories, Modeling Rules</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>ER-Converter (N. Omar, 2004)</td>\n<td>NL text</td>\n<td>ER model</td>\n<td>Linguistic rules</td>\n<td>Can be automatic or semi-automatic</td>\n<td>No</td>\n</tr>\n<tr>\n<td>LIDA (Ovemyer, 2001)</td>\n<td>NL text</td>\n<td>Class diagram</td>\n<td>Linguistic rules</td>\n<td>Yes</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Modeling Wizard Tool (2000)</td>\n<td>NL text</td>\n<td>EER model</td>\n<td>Analysis Patterns, Dialog Sessions</td>\n<td>Yes</td>\n<td>No</td>\n</tr>\n<tr>\n<td>NL-OOPS (2002)</td>\n<td>NL text</td>\n<td>Object model, Revised requirement</td>\n<td>Linguistic Rules</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>OMDDE (2008)</td>\n<td>NL text</td>\n<td>ER model</td>\n<td>Domain Ontology</td>\n<td>Yes</td>\n<td>No</td>\n</tr>\n<tr>\n<td>TCM (2004)</td>\n<td>NL text</td>\n<td>Class diagram</td>\n<td>Noun Analysis, Class Categories, Modeling Rules</td>\n<td>Yes</td>\n<td>No</td>\n</tr>\n</tbody>\n</table>\n2.5 Database Reverse Engineering (DBRE)\n\nDBRE is another relevant area of our research. Typically, the database design process can be defined as a sequence of schema transformations that convert the user requirements into an executable schema expressed by the DDL (data definition language) of the target DBMS (H. Chiang, 1993). The entire process can be written as a function:\n\n\\[ \\text{DDL schema} = \\text{Database Design} \\]\n\nOn the other hand, database reverse engineering (DBRE) is the reverse of the task of database design. According to Chiang et al. (R. Chiang, Barron, T., Storey, V., 1994), DBRE is the process of recovering such a conceptual data model by examining an existing database system to identify the database’s elements and their interrelationships. It aims at extracting a conceptual data model from a relational database schema. The entire process can be written as a function:\n\n\\[ \\text{Conceptual schema} = \\text{DBRE (DDL schema, data instances)} \\]\n\nMethods of DBRE have been proposed since 1980s. Dumpala and Arora (Dumpala, 1981) were the first to focus on DBRE field. Fahrner and Vossen (Fahrner, 1995) provide a survey of various methods to reverse schema transformations from the relational schema into the ER model according to five characteristics. These characteristics are: (1) the various extensions of the ER model, (2) transformation prerequisites, (3) the principle transformation method, (4) properties of transformation methods, and (5) user interaction requirements. Most of the DBRE methods we have reviewed are informal. In particular, they depend on various rules/heuristics to generate\nelements in a conceptual model from available sources and do not formally specify the quality of the results. DBRE is also difficult to automate and requires human intervention. Since the sources do not contain sufficient semantic information, the conceptual models created by DBRE methods are often closely tied to the existing database schemas and so may become just the graphical representations of the actual logical and physical implementations of the databases. The methodology proposed by Chiang (H. Chiang, 1993) divides the reverse engineering process into six phases: (1) Initialization, (2) Decomposition, (3) Classification, (4) Generalization, (5) Identification, and (6) Refinement & Enhancement. Figure 2.2 shows all these phases and the functions of each phase.\n\nFigure 2.2 Database Reverse Engineering Process (H. Chiang, 1993)\nIn our research, we employ the DBRE methodology proposed by Chiang (H. Chiang, 1993) for automatically developing the proposed reusable pattern repositories.\n\n2.6 WordNet\n\nWordNet (Fellbaum, 1998) is an online lexical reference system. It was created and improved at Princeton University since 1985. It groups words into a set of synonyms called synset, and maintains the various semantic relationships between these synonym sets. The latest version of WordNet is 3.0, which contains about 155,000 words organized in over 117,000. The semantic relationships between synsets are IS-A (hypernym/hyponym), Part-of (meronym/holonym), synonym, and antonym. The IS-A relationship is the most fundamental by producing a taxonomic hierarchy of synsets.\n\nWordNet has analyzed large corpora and gathered statistics on the senses in which words are used. For example, the synonym sets for each sense are ranked by frequency. WordNet aims to build a combination of a dictionary and a thesaurus, and to support automatic text analysis and artificial intelligence applications. Due to ambiguities in NL, words may have several meanings (homonyms) and many concepts can be represented by two or more words (synonyms). WordNet has been used as a reference tool to disambiguate nouns in automated conceptual data modeling (Du, 2008). Although entities can be identified by nouns in a problem statement, the correspondence between entities and nouns is not completely matching because nouns do not only refer to entities but also to attributes and other concepts. In fact, it is difficult to automatically identify which\nnouns should be entities and which should not. Such distinctions depend heavily on context and human ability to apply their own knowledge.\n\nIn the conceptual data modeling field, WordNet can be used as a source of reusable knowledge to ensure that the designing models are correct. Métais (Métais, 2002) investigates the use of NLP techniques in the design phase of information systems. In summary, the possible usages of WordNet applying in automated conceptual modeling process are:\n\n- To differentiate between entities and non-entities. The top noun categories and the hypernym chains in WordNet can be used as a general standard to distinguish attributes from entities (Du, 2008). Three top level category groups are defined as follows:\n 1) strong-entity: “group”, “physical object”, “physical entity”, “thing”\n 2) mid-entity: “substance”, “event”, “communication”, “physical process”\n 3) weak-entity: “cognition”, “attribute”, “measure”, “constituent”, “language unit”\n\nIf the hypernym chain of a noun phrase reaches to one of the categories in the strong-entity group, it means that this noun has a high potential to be a candidate entity. On the other hand, if the hypernym chain of the term reaches to one of the categories in the weak-entity group, it means that this noun has a low potential to be a candidate entity.\nFor example, the WordNet hypernym chains of the word “customer” as shown in Figure 2.3 are consumer => user => person => organism => living thing => object, while specific nouns that more usually indicative of entity will link to synsets such as “object and physical entity.\n\n\n\nFigure 2.3 An example of WordNet hypernym chains\n\nTo disambiguate the meaning of noun or verb by examining synonyms. For instance, E-R generator (Gomez, 1999) employs WordNet for word sense\ndisambiguation in their conceptual data modeling system. An interface is used to access WordNet and displays the ontological categories for a given word. When word ambiguity happens, the system asks the user to choose the proper category in the current context.\n\n- To discover some hidden relationships through WordNet. The hypernym chains in WordNet can be used to identify the inheritance and aggregation relationships.\n- To identify hidden attributes. In CM-Builder (Harmain, 2003), it uses WordNet to assist users in determining the meaning and the context of words, and to identify hidden attributes that may get from adjectives.\n3. RESEARCH METHODOLOGY\n\nThis Chapter presents four methodologies to answer the research questions stated in Chapter 1 during the course of our work:\n\n3.1 Developing EIR and RIR as new types of reusable pattern artifacts for conceptual model designs.\n\n3.2 Proposing six domain independent modeling rules.\n\n3.3 Developing EIPW with EIR and RIR that contain domain semantics regarding an application domain.\n\n3.4 Developing HBT with six domain independent modeling rules and RIR.\n\nIn our research, we use the ER model originally developed by Chen (P. Chen, 1976) as our representation because it has been widely used in conceptual modeling field -- powerful to real-world problems and readily translated into a database schema (Teorey, 1986).\n\n3.1 Developing EIR and RIR\n\nThis section presents our automatic methodology for creating Entity Instance Repository (EIR) and (RIR), which are the repositories of Entity Instance Patterns (EIPs) and Relationship Instance Patterns (RIPs), respectively. EIR and RIR contain ER modeling patterns from prior designs and serve as knowledge-based repositories for conceptual modeling. An EIP is a pattern of a single entity and its properties. An RIP is a binary relationship with cardinality constraints between two entities. Examples of these\nare shown in Figure 3.1. We propose a method based on database reverse engineering concepts (R. Chiang, Barron, T., Storey, V., 1994) to automatically extract EIPs and RIPs from relational schemas. This methodology employs three assumptions about the characteristics of the input schemas for database reverse engineering processes:\n\n1. Relational schemas: An input is a DDL (Data Definition Language) schema that contains data instances of an application domain.\n\n2. 3NF relations: There are no non-3NF relations in the input relational schemas. It would simplify the extraction process by dealing with the relations, each of which primarily corresponds to one entity type or one relationship type, rather than corresponding to more than one entity type or a mixture of entity and relationship types.\n\n3. Proper primary keys (PK) and foreign keys (FK): Proper PKs and Fks are specified in input DDL schemas.\n\nFigure 3.1 An example of an EIP and RIP, respectively\nThe method for creating EIR and RIR consists of the following three main steps:\n\nINPUT: DDL schemas\n\nOUTPUT: EIR and RIR\n\n1) **Obtaining information about the executable schemas (DDL schemas)**\n\nIn order to reverse engineer existing database schemas, the information about the executable schemas must be available. These existing schemas (DDL schemas) have to provide at least relation names, attribute names, and PKs as seen in Figure 3.2.\n\n```\nCREATE TABLE CUSTOMER {\n CUSTOMER_ID VARCHAR(5) NOT NULL,\n NAME VARCHAR(30) NOT NULL,\n ADDRESS VARCHAR(50) NOT NULL,\n POSTAL_CODE CHAR(5) NOT NULL,\n PRIMARY KEY(CUSTOMER_ID);\n}\n\nCREATE TABLE ORDER {\n ORDER_ID VARCHAR(5) NOT NULL,\n ORDER_DATE DATE NOT NULL,\n CUSTOMER_ID VARCHAR(5) NOT NULL,\n PRIMARY KEY(ORDER_ID),\n FOREIGN KEY(CUSTOMER_ID) REFERENCES CUSTOMER(CUSTOMER_ID);\n}\n```\n\nFigure 3.2 The executable DDL schemas\n\nIn our research, we use a library of logical data models (executable schemas or DDL schemas) created by Silverston (Silverston, 2001) originally containing 464 relations and 1859 attributes as our first input. Later, the lists of EIR and RIR are extended by case studies.\n(2) Extracting EIP’s elements\n\nWe extract the EIP’s elements from input DDL schemas by storing a relation name as an entity_name and an attribute as an attribute_name in EIR. The metadata model of EIP and RIP is shown in Figure 3.3.\n\n(3) Extracting RIP’s elements\n\nWe extract the RIR’s elements by identifying relationships between extracted entities obtained from Step (2) above. Most of the ER (Entity-Relationship) methods used in textbooks or CASE tools can be classified as either binary models or n-ary models (I.-Y. Song, Evans, M., Park, E., 1995). There is an argument about the inclusion of binary or n-ary relationships in conceptual models (Hitchman, 2003). A central argument comes from the ability of n-ary modeling to reflect the true semantics of any given situation, whereas a binary model provides the simplest structures for a requirement specification’s logical design. In database design, the binary relationship\nmodel is equivalently represented in a relational database management system. Many researchers suggest that all of the relationship representations in the conceptual model should be binary. For example, Rambaugh et al. (Rumbaugh, 1991) suggest that higher order relationships are more complicated to draw, implement, and understand than binary relationships, thus should be avoided if possible. In most cases, binary relationships are sufficient enough to represent the problem domain. Comprehensive analysis of binary relationships and ternary relationship is shown in (I.-Y. Song, Jones, T., 1993). Therefore, in this research, we only specify the maximum cardinality constraints for binary models. Because of the limited semantic expressiveness of DDL schemas, the minimum cardinality cannot be automatically identified. Using a fully automated process, we can identify five relationship types:\n\n3.1 \\( 1: N \\) for relationships identified by FK\n3.2 \\( 1: N \\) for relationships identified by partial keys\n3.3 \\( N: M \\) for relationships identified by relationship relations\n3.4 Is-a relationships\n3.5 Recursive relationships\n\nSubsequently, these binary relationships are stored in RIR. The reverse engineering rules used in this step are created by inverting the schema transformation rules based on the EER (Extended Entity-Relationship) (Elmasri, 2004). These transformation rules are described as following:\n3.1 1: N for relationships identified by FK\n\nIF: the PK of a relation \\( T_1 \\) is shown as a FK of another relation \\( T_2 \\),\n\nTHEN: there is a 1: N relationship between \\( T_1 \\) and \\( T_2 \\).\n\nConsider these two relations:\n\n\\[\nT_1 (K_{11}, a_{11}, a_{12}, a_{13}, \\ldots, a_{1i})\n\\]\n\n\\[\nT_2 (K_{2}, a_{21}, a_{22}, a_{23}, \\ldots, a_{2i}, K_{11}^*)\n\\]\n\nwhere \\( T_1 \\) represents a relation, \\( a_{ij} \\) represents an attribute in a relation, PK is underlined, and FK is followed by a star symbol. If \\( T_2.K_{11}^* \\) is a FK that comes from \\( T_1 \\), then there is a 1: N relationship between \\( T_1 \\) and \\( T_2 \\).\n\nEx. Consider these entities, EMPLOYEE and DEPARTMENT.\n\nDEPARTMENT (DNAME, DNUMBER, MGRSSN*, MGRSTARTDATE)\n\nEMPLOYEE (FNAME, LNAME, SSN, ADDRESS, SEX, SALARY, SUPERSSN, DNO*)\n\nThe PK, DNUMBER, of an entity DNUMBER, appears as a FK of entity EMPLOYEE. Then there is a 1:N binary relationship between entity DEPARTMENT and entity EMPLOYEE.\n\n3.2 1: N for relationships identified by partial keys\n\nIF: the PK of a relation \\( T_1 \\) appears as a composite PK of another relation \\( T_2 \\) and the PK of relation \\( T_1 \\) is the FK of table \\( T_2 \\) as well,\n\nTHEN: \\( T_1 \\) is a strong entity.\n\n\\( T_2 \\) is a weak entity.\n\nAnd there is a 1: N relationship between \\( T_1 \\) and \\( T_2 \\).\nConsider these two relations:\n\n\\[ T_1 (K_1, a_{11}, a_{12}, a_{13}, \\ldots, a_{1i}) \\]\n\\[ T_2 (K_1^*, K_2, a_{21}, a_{22}, a_{23}, \\ldots, a_{2i}) \\]\n\nT₂ has a composite PK of \\((K_1, K_2)\\) and only \\(K_1\\) is a FK of table \\(T_2\\), and \\(K_1\\) is a PK of \\(T_1\\). So, \\(T_1\\) is a strong entity, \\(T_2\\) is a weak entity, and there is a 1: N relationship between \\(T_1\\) and \\(T_2\\).\n\nEx. Consider these entities, EMPLOYEE and DEPENDENT.\n\nEMPLOYEE (FNAME, LNAME, SSN, ADDRESS, SEX, SALARY, SUPERSSN, DNO*)\n\nDEPENDENT (ESSN*, DEPENDENT_NAME, SEX, BDATE, RELATIONSHIP)\n\nIn this case, entity relations DEPENDENT has a composite PK of \\((ESSN, DEPENDENT\\_NAME)\\), and only ESSN is a FK. Therefore, there is a 1: N relationship between entity EMPLOYEE and entity DEPENDENT.\n\n### 3.3 N: M for relationships identified by relationship relations\n\nConsider these two relations:\n\n\\[ T_1 (K_1, a_{11}, a_{12}, a_{13}, \\ldots, a_{1i}) \\]\n\\[ T_2 (K_2, a_{21}, a_{22}, a_{23}, \\ldots, a_{2i}) \\]\n\\[ T_3 (K_2^*, K_1^*, a_k) \\]\n\n**IF:** \\(T_3\\) has a composite primary key of \\((K_2, K_1)\\), when consisting of FKs from the other two different tables \\(T_1\\) and \\(T_2\\),\n\n**THEN:** there is a M : N relationship between \\(T_1\\) and \\(T_2\\).\n\nEx. EMPLOYEE (FNAME, LNAME, SSN, ADDRESS, SALARY, SUPERSSN, DNO*)\nWORKS_ON (SSN*, PNO*, HOURS)\n\nPROJECT (PNAME, PNO, PLOCATION, DNUM*)\n\nEntity WORK_ON has a composite primary key of (ESSN, PNO), when consists of FKS from the entity EMPLOYEE and entity DEPARTMENT. So, there is an M: N relationship between entity EMPLOYEE and entity PROJECT.\n\n3.4 Is-a Relationship\n\n**IF:** two strong entities, T₁ and T₂, have the same PK and T₂ has a key being both PK and FK,\n\n**THEN:** T₂ has “Is-a” relationship with T₁ (T₂ Is-a T₁).\n\nConsider these two relations:\n\n\\[\nT₁ (K₁, a₁₁, a₁₂, a₁₃, \\ldots, a₁ᵢ)\n\\]\n\n\\[\nT₂ (K₁*, a₂₁, a₂₂, a₂₃, \\ldots, a₂ᵢ)\n\\]\n\nEx. EMPLOYEE(FNAME, LNAME, SSN, ADDRESS, SALARY, SUPERSSN, DNO*)\n\nMANAGER (SSN*, RANK, PROMOTION_DATE, DEPTNO)\n\nIn this case, the relations, EMPLOYEE and MANAGER, have the same PK (SSN), and MANAGER has SSN as being both PK and FK. This suggests that there is an “Is-a” relationship exists from relation MANAGER and relation EMPLOYEE.\n\n3.5 Recursive Relationship\n\n**IF:** T₁ has a FK that references the PK of its own table (T₁),\n\n**THEN:** T₁ has recursive relationship.\n\nConsider this relation:\n\\[ T_1(K_l, a_{i1}, a_{i2*}, a_{i3*}, \\ldots, a_{i3}) \\]\n\nEx. EMPLOYEE (FNAME, LNAME, SSN, ADDRESS, SEX, SALARY, SUPERSSN*, DNO*)\n\nIn this case, each Employee occurrence contains two social security numbers (SSN), one identify the employee, the other being the SSN of the employee’s supervisor.\n\n### 3.2 The Six Domain Independent Modeling Rules\n\nThis section presents our selected six modeling rules termed as the six domain independent modeling rules. Our survey shows that one of the difficulties in creating conceptual models is the scattered modeling rules. There is no complete set of rules that help developing conceptual models. In general, rules/heuristics are useful but sometimes they may lead to cognitive errors called bias (D. Batra, 2007; Parson, 2004). There is always trade off in design so that not all rules can work together because some rules are conflicting. We have selected the six domain independent modeling rules based on teaching experiences of over 20 years by one of the committee members of this dissertation. These six rules are considered as a minimal set of rules to teach novice designers in creating quality conceptual models. These six rules are not based on the syntax of any NLs and thus are domain independent. This means that these rules can be applied to a wide range of applications and domains. In this research, we would like to experiment whether the six rules are indeed useful. The six domain independent modeling rules are:\n\n**R1: The ID (Identifier) Rule**\nIF a concept (noun or verb) needs to have a unique identifier, THEN it can be an entity.\n\n**R2: The MA (Multiple Attribute) Rule**\n\nIF a concept has multiple attributes, THEN it can be an entity.\n\n**R3: The MVA (Multi-Valued Attribute) Rule**\n\nIF a concept has multi-values, THEN it can be an entity.\n\n**R4: The TDA (Time-dependent attributes) Rule**\n\nIF a concept has time-dependent attributes or needs to keep track of history of values, THEN it can be an entity.\n\n**R5: The SC (Single Concept) Rule**\n\nA good entity should represent one and only one concept.\n\n**R6: The DI (Domain Importance) Rule**\n\nIF a concept is important in its own right within the problem domain whether it has one or multiple attributes, THEN it can be an entity.\n\n### 3.3 Developing EIPW (Entity Instance Pattern WordNet)\n\nIn this research, we explore knowledge-based and pattern-based approaches that help database designers develop quality conceptual data models. We propose new types of reusable pattern artifacts, called the entity instance repository (EIR) and the relationship instance repository (RIR), which are repositories of entity instance patterns (EIPs) and relationship instance patterns (RIPs), respectively. In the previous section, EIR and RIR have been created as the reusable pattern repositories containing knowledge\nabout an application domain. This section discusses how these patterns are implemented in KBS called EIPW (Entity Instance Pattern WordNet).\n\n### 3.3.1 Overview of EIPW Architecture\n\nThe architecture of EIPW is shown in Figure 3.4. A prototype of EIPW has been developed by using JAVA Applet. Firstly, the system passes a NL requirement specification as an input to do the part of speech tagging (POS) in order to list all of the possible candidate entities. We use a well-known open source called LingPipe ([http://alias-i.com/lingpipe](http://alias-i.com/lingpipe)) to perform POS. In EIPW, the entity list can be identified based on noun phrases and hidden requirements. During the post-parsing analysis, a noun phrase belonging to any of a *discard noun set* will be excluded as a candidate entity. The discard noun set are created based on the history of words discarded by designers and the class elimination rules (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004). The discard noun set is domain independent.\n\nIn the entity identification module, there are three activities performed:\n\n1. The first activity is to identify the entity list based on EIR. WordNet is also used to ensure that the synonyms of EIR’s entities are not missed out while preparing the lists of entities.\n2. The second activity is to identify the entities that are not detected by EIR by applying the top noun categories and hypernym chains in WordNet (Du, 2008).\n3. The third activity is to identify the hidden entities by applying entity categories. Our entity categories are adopted from the class categories defined by Song et al. (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004).\n\nRelationships between entity lists are generated by considering the application domain semantics inherent in the RIR. The modeling rules are used to ensure that all of the relationships are identified. The lists of EIR and RIR are extended by case studies. WordNet is also used to ensure that the synonyms of EIR’s entities and RIR’s entities are missed out while preparing the list of candidate entities and preparing the list of relationships, respectively.\n3.3.2 The EIPW Workflow\n\nThis section shows the detailed workflow of EIPW and its use for generating ER models. EIPW can be mainly divided into two subtasks: entity identification and relationship identification.\n(1) **Entity Identification**\n\nThe actual step-by-step activities of our methodology outlined in Figure 3.6 are the form of an activity diagram in the UML. In Figure 3.6, the three swimlanes perform the following activities:\n\n- The middle swimlane: The aim of these swimlane activities is to identify entities based on EIR.\n- The rightmost swimlane: The aim of these swimlane activities is to identify entities that are not detected by EIR by applying the top noun categories and hypernym chains in WordNet.\n- The leftmost swimlane: The aim of these swimlane activities is to identify hidden entities that are not explicitly stated in the requirements but are necessary for the conceptual modeling by applying entity categories. Entities categories are used as a tip for identifying entities.\n\nThe details of the activities in Figure 3.6 are presented below.\n\n**Activities of Middle Swimlane of Figure 3.6**\n\n- Begin with a requirement and remove the partial explanation statements\n \n This process starts by reading a text file containing a requirements specification of an application written in English. Explanation statements in a requirements specification aim to help human readers to understand the requirements better but they are harmful for automated requirement analysis (Du, 2008). For example, in “A new video store intends to offer rentals (and sales) of entertainment material to\nthe wider public.” the explanation part inside the parenthesis is redundant and not necessary to transform it into ERD representation. Heuristic rules based on parenthesis and some words (e.g. such as) will be used to remove the explanation statement.\n\n- **Step 1: Get noun phrases**\n\nPart of speech tagging (POS) is used to assign each word in an input sentence its proper part of speech such as noun phrases and verb phrases in order to reflect the word’s syntactic categories. The POS tags provide a useful abstraction of words whereby candidate entities can be identified from either noun phrases (P. Chen, 1983) or verb phrases (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004). In this research, we use an open source call LingPipe for POS tagging to get the entire noun phrases appearing in the requirement specification. Figure 3.5 shows the user interface of Step 1 that lists all the noun phrases appearing in the requirement specification.\n### Step 2: Test discard noun set\n\nTo facilitate the post-parsing analysis, a noun phrase belonging to any of the discard noun set will be excluded as a candidate entity. The discard noun set is created based on the history of words discarded by designers and the class elimination (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004) to provide intelligent suggestion for better parsing the requirement. The discard noun set is domain independent. Some examples of discard noun set are number, ID, information, database, track, record, system, etc.\n\n### Step 3: Identify entities based on EIR\nAfter the initial set of possible candidate entities is identified from Step 2, each term is compared to the entity names in the EIR. If a noun phrase matches an entity name in EIR, then it becomes a candidate entity (E1).\n\n- **Step 4: Apply WordNet Synonym**\n\nOut of these entity names, identify synonyms of a noun phrase from WordNet. If the synonyms of a noun phrase match the entity name in EIR, then the noun phrase also becomes a candidate entity (E1).\n\n**Activities of RightMost Swimlane of Figure 3.6**\n\n- **Step 1: Apply top noun categories and hypernym chains in WordNet**\n\nThe top noun categories and hypernym chains in WordNet are used to perform entity categorizations. The entity categories can help us identify entities from non-identifiable noun phrases from the MiddleMost Swimlane. These entity categories can be divided into two groups and defined as follows:\n\n - **Potential-Entity Group**: group, physical object, physical entity, thing, transaction.\n \n - **Non-Entity Group**: cognition, attribute, value, measure, constituent, language_unit, feeling.\n\n If the hypernym chain of a noun phrase reaches to one of the categories in the “Potential-Entity” group, the system will label this term as a candidate entity (E2) and insert it to the EIR to expand the list of EIP. On the other hand, if the\nhypernym chain of a term reaches to one of the categories in the “Non-Entity”\ngroup, the system will delete this noun phrase.\n\nIf the hypernym chain of a term does not belong to either group, the system\nwill ask the user to make judgments regarding this term. If the user labels it as a\ncandidate entity (E2), then insert it to the EIR, else delete this noun phrase.\n\nActivities of Left Most Swimlane of Figure 3.6\n\nIn this swimlane, the system asks the user to identify the hidden entities by applying\ndomain knowledge to entity categories. Our entity categories in business applications\nadopt the class categories defined by Song et al. (I.-Y. Song, Yano. K., Trujillo, J., Lujan-\nMora, S., 2004). They are as follows:\n\n1. Roles of People\n They represent role of humans who perform some important function.\n Ex. Student, Employee, Customer.\n\n2. Places\n They represent locations where important business activities are occurred.\n Ex. Warehouse, Brach, Store.\n\n3. Physical Things\n They represent tangible objects that are import in business activities.\n Ex. Product, Machine, Device, Book\n\n4. Organization\n They represent important business units.\n Ex. Department, Team\n\n5. Events (Transactions)\nThey represent important activities that need to record some data with the time the event occurred.\nEx. Order, Promotion, Payment\n\n6. *Transaction Line Items*\n They represent an element of a transaction.\n Ex. Order-Line-Item, Purchase-Line-Item, Rental-Line-Item\n\n7. *Concepts with properties*\n They represent intangible ideas used to keep track of business activities.\n Ex. Project, Account, Complaint\n\n8. *Specification*\n They represent a description of other items that need to be distinguished from one another.\n Ex. Video-Title, Flight-Plan. For example, each video tape has a different barcode.\n\n9. *Interaction*\n They represent an association between two entities, where the association has meaningful attributes. An example of this entity is Reservation between Passenger and Flight entities.\n\n10. *Rules/Policies/Reference/Look up*\n They represent important business rules.\n Ex. Rental-Policy, Shipping Method\n\n11. *Containers of other things*\n They represent entities that will contain other entities.\n Ex. Shelf, Catalog, Pick List, Bin\n\n12. *Things in a container*\n They represent entities that will be contained in another entity.\n Ex. Order-Line-Item, Passenger, Video-Title in a catalog.\n• **Step 1: Apply domain knowledge to entity categories (user intervention)**\n\nFor each entity category, check whether all the entities representing the entity category are already captured. Otherwise create a new candidate entity (E3) based on the entity categories.\n\nA set of entities identified from our methodology is a union of the entities identified from the three swimlanes. That is: \\{Entities\\} = \\{E1\\} \\cup \\{E2\\} \\cup \\{E3\\}\n(2) **Relationship Identification**\n\nAfter the entity list has been identified in the entity identification process, Relationships between entities are generated by considering the application domain.\nsemantics inherent in the RIR. This repository is used to identify occurring relationships within an application domain and to generate the relationships between entities. The flowcharts for the relationship identification process are shown in Figure 3.7. The processing task requires several activities in order to determine the relationships between the entities. In figure 3.7, there are two swimlanes performing the following activities.\n\n- **The left swimlane**: The goal of these swimlane activities is to identify relationships (r) between candidate entities based on RIR.\n\n- **The right swimlane**: The goal of these swimlane activities is to ask the users to identify the relationships, which are not detected by the RIR, by applying Need-to-Remember Rule (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S. , 2004).\n\nThe details of the activities in Figure 3.6 are discussed below.\n\n**Activities of left swimlane of Figure 3.7**\n\n- Begin with the candidate entity list obtained from entity identification process.\n\n- Step 1: Delete duplicate entities.\n \n This Step is conducted through WordNet synonyms.\n\n- Step 2: Assign all possible relationships (rij) between the candidate entities.\n\n- Step 3: Match the possible relationships (rij) with RIR.\n \n If rij match the relationships in RIR, add rij into Relationship set (R).\n\n- Step 4: Apply WordNet Synonym\n \n Out of the matching, identify synonyms of entity names from WordNet. If the synonyms of rij match the relationship in RIR, add rij in R.\nActivities of right swimlane of Figure 3.7\n\n- Begin with the possible relationships that are not detected by RIR from left swimlane.\n\n- **Step 5: Apply Need-to-Know rule (user intervention)**\n\n If a relationship represents an association that does not have to be remembered between two entities, then delete this relationship.\n\n- **Step 6: Assign the multiplicity (user intervention)**\n\n Assign the multiplicity to each relationship obtained from Step 5.\n\nThe ER model is created by combining a set of relationships \\((R)\\) identified from the two swimlanes. Figure 3.8 shows the output of EIPW.\nFigure 3.7 Relationship Identification Process in EIPW\n3.4 Developing HBT (Heuristic-based Technique)\n\nIn this research, we select six domain independent modeling rules that are comprehensive enough in creating conceptual models. We evaluate the usefulness of these rules by developing HBT that applies these rules to the creation of conceptual data models. The knowledge implemented in the system is based on the six domain independent modeling rule. The six domain rules are used to ensure whether the initial candidate entity lists should be included or excluded in the data model.\n\n3.4.1 Overview of HBT Architecture\n\nThe system modules are shown in Figure 3.9. A prototype of HBT was developed by JAVA applet. First, the system takes a NL requirement specification as an input to a\npreprocessing module. The main functionality of the preprocessing module is to do the POS in order to list all of the possible candidate entities. In HBT, the entity list can be identified based on noun phrases, verb phrases, and hidden requirements. During the post-parsing analysis, a noun phrase and a verb phrase belonging to any of a discard noun set and a discard verb set, respectively, will be excluded as a candidate entity. The discard noun set and the discard verb set are created based on the history of words discarded by designers and the class elimination rules (I.-Y. Song, Yano, K., Trujillo, J., Lujan-Mora, S., 2004). The discard noun set and the discard verb set are domain independent. Most of the other modules’ functions in HBT are very similar to those in EIPW. Also, the user interfaces of HBT are also similar to those in the HBT as shown in Figure 3.10. The only difference is in the entity identification module. In this module, there are three activities performed:\n\n1. The first activity is to identify the entity list based on noun phrases by using the six domain independent modeling rules, which are the ID, MA, MVA, TDA, SC, and DI rules.\n\n2. The second activity is to identify the entity list based on verb phrases by using two rules out of six domain independent modeling rules, which are the ID and MA rules.\n3. The third activity is to identify hidden entities that are not explicitly stated in the requirements but are necessary for the conceptual modeling by applying entity categories.\n\nFigure 3.9 The HBT Architecture\n3.4.2 The HBT Workflow\n\nThis section presents the detailed workflow of HBT. HBT incorporates the six domain independent modeling rules, entity categories, and relationship instance repository. HBT’s process can be divided into two subtasks: entity identification and relationship identification. In entity identification process, the six domain independent modeling rules are used to ensure whether the initial candidate entity lists should be included or excluded in the data model. The relationship identification process of HBT is the same as that used in EIPW.\n1) **Entity Identification**\n\nThe step-by-step activities of our methodology outlined in Figure 3.11 are in the form of an activity diagram in the UML. The processing task requires several steps to be carried out in order to achieve the candidate entities from the NL input. In Figure 3.11, there are three swimlanes to perform the following activities:\n\n- The middle swimlane: The aim of these swimlane activities is to identify entities based from the concepts that are explicitly stated as noun phrases in the requirements.\n\n- The rightmost swimlane: The aim of these swimlane activities is to identify entities based from the concepts that are explicitly stated as verb phrases in the requirements.\n\n- The leftmost swimlane: The aim of these swimlane activities is to identify hidden entities that are not explicitly stated in the requirements but are necessary for the conceptual modeling. We identify those hidden entities by applying domain knowledge to entity categories.\nFigure 3.11 Entity Identification Process in HBT\nActivities of Middle Swimlane of Figure 3.11\n\n- Begin with a requirements specification and remove the partial explanation statement.\n\n- Step 1: Get noun phrases\n \n Get the entire noun phrases from a requirement specification by using POS technique.\n\n- Step 2: Test discard noun set\n \n To facilitate the post-parsing analysis, noun phrases belong to any of the discard noun set will be deleted.\n\n- Step 3: Apply the ID (Identifier) Rule\n \n If a noun phrase needs to have a unique identifier, then it is a candidate entity (E1).\n\n- Step 4: Apply the MA (Multiple Attributes) Rule\n \n If a noun phrase has multiple attributes, then it is a candidate entity (E1).\n\n- Step 5: Apply the MVA (Multi-Value Attribute) Rule\n \n If a noun phrase has multi-values, then it is a candidate entity (E1).\n\n- Step 6: Apply the TDA (Time-dependent attributes) Rule\n \n If a noun phrase has time-dependent attributes or needs to keep track of history of values, then it is a candidate entity (E1).\n\n- Step 7: Apply the SC (Single Concept) Rule\n \n A good entity should represent one and only one concept (E1).\n- **Step 8: Apply the DI (Domain Importance) Rule**\n\n If a noun phrase is important in its own right within the problem domain whether it has one or multiple attributes, then it is a candidate entity (E1).\n\n**Activities of Rightmost Swimlane of Figure 3.11**\n\n- **Step 1: Get verb phrases**\n\n We use POS technique to get all the verb phrases from the requirement specification.\n\n- **Step 2: Test the discard verb set**\n\n To facilitate the post-parsing analysis, verb phrases belong to any of the discard verb set will be deleted. The examples of verb phrases in discard verb set are: automate, become, concern, etc.\n\n- **Step 3: Apply ID (Identifier) Rule**\n\n If the concept represented by a verb phrase needs to have a unique identifier, then it is a candidate entity (E2). Song et al. (I.-Y. Song, Yano. K., Trujillo, J., Lujan-Mora, S., 2004) term this candidate entity a Transformed Entity.\n\n- **Step 4: Apply MA (Multiple Attribute) Rule**\n\n If the concept represented by a verb phrase has multiple attributes, then it is a candidate entity (E2).\nActivities of Left Swimlane of Figure 3.11\n\nIn this swimlane, the system asks the user to identify the hidden entities by applying domain knowledge to entity categories. These entity categories are the same as that used in the EIPW.\n\n- **Step 1: Apply domain knowledge to entity categories**\n\n For each entity category, check whether all the entities representing the entity category are already captured. Otherwise create a new entity based on the entity category.\n\n A set of entities (E) identified from our methodology is a union of the entities gotten from the three swimlanes. The relationship identification process of HBT is the same as that used in EIPW. The output of HBT is shown in Figure 3.12.\n\n\n\n**Figure 3.12 The output of HBT**\n4. **EMPIRICAL EVALUATION**\n\nIn this research, we have proposed methods for improving the process of conceptual modeling design. We have implemented two knowledge-based data modeling tools: EIPW and HBT. EIPW incorporates entity instance repository, entity categories, relationship instance repository, and WordNet. HBT incorporates the six domain independent rules, entity categories, and relationship instance repository.\n\nIn this Chapter, we evaluated the quality of outputs generated by EIPW and HBT by using ANOVA technique. Because the quality of the ER models is of interest, the following hypotheses are tested:\n\n*H1: Novice designers using EIPW will create conceptual models with better quality compared to the models generated without using any tools.*\n\n*H2: Novice designers using HBT will create conceptual models with higher scores compared to the models generated without using any tools.*\n\n*H3: There is no significant difference between the two KBSs regarding the quality of the conceptual models.*\n\n4.1 **Experiment Design**\n\nThe experimental framework is shown in Figure 4.1. The two independent variables are the systems and the task sizes. In conceptual modeling, a linear increase in the number of entities can result in a combinatorial increase in the number of possible relationships (D. Batra, 2007). As the task size increases, so do the numbers of decisions\nrequired in the modeling process. Therefore, our experiment design incorporates two levels of the task size to provide some sensitivity for this factor. The medium task size has 9 entities and 9 relationships, while the moderate task size has 14 entities and 14 relationships. The dependent variable is the quality scores of the ER models.\n\nFigure 4.1 The framework of empirical experiments\n\n4.2 Subjects and Tasks\n\nThere were 41 subjects. All of the subjects were students in the iSchool at Drexel University and did not work in conceptual modeling field before. Therefore, we concluded that all of our subjects were novice designers. Twenty-one were undergraduates and twenty were graduate students. Forty-one subjects were divided into four groups as shown in Table 4.1. Each subject worked on four problem statements: one medium size and one moderate size problem statements with the aid of our KBS, and one\nmedium size and one moderate size problem statements with no tool. The problem \n\nstatements are in the e-commerce domain. The subjects could take time as long as they \nwanted to create conceptual models based on the given problem statements.\n\nTable 4.1 The Experiment Design\n\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Num of subject</th>\n<th>Problem1</th>\n<th>Problem2</th>\n<th>Problem3</th>\n<th>Problem4</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>11</td>\n<td>No tool</td>\n<td>No tool</td>\n<td>Using EIPW</td>\n<td>Using EIPW</td>\n</tr>\n<tr>\n<td>2</td>\n<td>10</td>\n<td>Using EIPW</td>\n<td>Using EIPW</td>\n<td>No tool</td>\n<td>No tool</td>\n</tr>\n<tr>\n<td>3</td>\n<td>10</td>\n<td>No tool</td>\n<td>No tool</td>\n<td>Using HBT</td>\n<td>Using HBT</td>\n</tr>\n<tr>\n<td>4</td>\n<td>10</td>\n<td>Using HBT</td>\n<td>Using HBT</td>\n<td>No tool</td>\n<td>No tool</td>\n</tr>\n</tbody>\n</table>\n\n4.3 Evaluation Metrics\n\n1. Evaluating experimental data\n\nThe quality of the conceptual data models created by the novice designers is \njudged by a third party.\n\n2. Grading criteria\n\nThe quality of an ER model is evaluated by a scoring schema that specifies how \nto grade the ER model on each facet (entities and relationships). In this research \nwe adopt the scoring scheme proposed by Du (Du, 2008). It focuses on the correct \nidentification of appropriate entities and relationships based on the given problem \nstatements.\n\nEntity\n- Add 2 points for each correct entity stated in the problem statement.\n- No penalty for very likely entity but not stated in the problem statement.\n- Deduct 1 point for each wrong entity.\n- Deduct 1 point for each missing entity.\nRelationship\n- Add 2 points for each relationship that is correctly attached to the corresponding entities.\n- Deduct 1 point for each missing relationship.\n- Deduct 1 point for each a redundant relationship or a derivable relationship.\n- Deduct 1 point for each wrong relationship.\n - Showed as an indirect relationship without a direct relationship.\n- Deduct 1 point for each incorrect degree of relationship.\n- Deduct 0.5 point for each an incorrect cardinality.\n\n4.4 Empirical Results\n\nTest of Hypothesis 1: EIPW\n\nA 2x2 within-subjects analysis of variance was performed on quality scores as a function of EIPW (with, no tool) and task size (medium, moderate) as shown in Table 4.2.\n\n<table>\n<thead>\n<tr>\n<th>QUALITY SCORE</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>System (EIPW, no tool)</td>\n</tr>\n<tr>\n<td>Task Size (medium, moderate)</td>\n</tr>\n<tr>\n<td>System x Task Size</td>\n</tr>\n</tbody>\n</table>\n\nNote: Significant Level < 0.05\nFrom the calculated means shown in Figure 8, the conceptual models created by EIPW are better than those created by no tool cases for both task sizes. In Table 4.2, the results show that the main effect of system (with EIPW, no tool) is significant (p < 0.00). Therefore, this result supports our hypothesis (H1) that the EIPW helps novice designers create better conceptual models than they do without it. There is no significant main effect for task size (p < 0.111). It shows that the effect of System x Task Size is not significant (p < 0.310), which means there is no interaction between the system and the task size. We conclude that EIPW improves the novices’ performance by 30.9% for the medium task size and 46.0% for the moderate task size.\nTest of Hypothesis 2: HBT\n\nA 2x2 within-subjects analysis of variance was performed on quality scores as a function of HBT (with, no tool) and task size (medium, moderate) as shown in Table 4.3.\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>QUALITY SCORE</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>System (HBT, no tool)</td>\n<td>$F(1,19) = 25.69, p < 0.000$</td>\n</tr>\n<tr>\n<td>Task Size (medium, moderate)</td>\n<td>$F(1,19) = 6.925, p < 0.016$</td>\n</tr>\n<tr>\n<td>System x Task Size</td>\n<td>$F(1,19) = 0.132, p < 0.720$</td>\n</tr>\n</tbody>\n</table>\n\nNote: Significant Level < 0.05\n\nFigure 4.3 The plot of the mean quality scores (%)\n\nFrom the calculated means shown in Figure 4.3, the conceptual models created by the HBT are better than those created by no tool cases for both task sizes. In Table 4.3, the\nresults show that the main effect of **system** (with HBT, no tool) is significant (p < 0.00). Therefore, this results support our hypothesis (H2) that the HBT helps novice designers create better conceptual models than they do without it. There is significant main effect for **task size** (p < 0.016). However, it shows that the effect of **System x Task Size** is not significant (p < 0.720), which means there is no interaction between the system and the task size. We conclude that HBT improves the novices’ performance by 34.9% for the medium task size and 33.5% for the moderate task size.\n\n**Test of Hypothesis 3: EIPW & HBT**\n\nA 2x2 mixed model design with **system** as between-subject and **task size** as within-subject factors was used. The two independent variables are **system** (with EIPW, with HBT) and the **task size** (medium, moderate). The dependent variable is the **quality score**. Since the aspects of within-subject factor are not used for analyzing this hypothesis, only the test of between-subject analysis is shown in Table 4.4.\n\n<table>\n<thead>\n<tr>\n<th>QUALITY SCORE</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>System (EIPW, HBT)</td>\n<td>F(1,39) = 0.004, p < 0.948</td>\n</tr>\n</tbody>\n</table>\n\nNote: Significant Level < 0.05\nIn Table 4.4, the main effect of system is not significant (p < 0.948). So, this result supports our hypothesis (H3) that there is no significant difference between the two KBSs regarding the quality of the conceptual models. However, the mean scores of EIPW and HBT suggest that EIPW is better than HBT when the task size is moderate. On the other hand, HBT is slightly better than EIPW when the task size is smaller. This results show that the six domain independent modeling rules are effective in the small to medium task sizes.\n\n4.5 Precision & Recall\n\nEven though recall and precision (van Rijsbergen, 1979) are always used for evaluating information retrieval systems and also widely used in evaluating information extraction systems, Harmain and Gaizaukas (Harmain, 2003) first introduced precision\nRecall measures the completeness of the results developed by the system. The relevant information developed by the systems is compared with that developed by human analysts or answer key. The formula for calculating recall is:\n\n\\[\n\\text{Recall} = \\frac{N_{\\text{correct}}}{N_{\\text{key}}} \\quad [\\text{Harmain & Gaizauskas, 2003}]\n\\]\n\nWhere \\( N_{\\text{correct}} \\) is the number of correct responses made by the system, and \\( N_{\\text{key}} \\) is the number of information elements in the answer key.\n\nPrecision measures the accuracy of the system (i.e. how much of the information produced by the system is correct). The formula for calculating precision is:\n\n\\[\n\\text{Precision} = \\frac{N_{\\text{correct}}}{N_{\\text{correct}} + N_{\\text{incorrect}}} \\quad [\\text{Harmain & Gaizauskas, 2003}]\n\\]\n\nWhere \\( N_{\\text{correct}} \\) is as above, and \\( N_{\\text{incorrect}} \\) is the incorrect responses made by the system.\n\nThe results of Recall and Precision of the performance of our proposed KBSs are shown in Table 4.5.\nTable 4.5 Results of the performance of our KBSs\n\n<table>\n<thead>\n<tr>\n<th>Tools or Systems</th>\n<th>Recall</th>\n<th>Precision</th>\n<th>F-measure</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>No tool</td>\n<td>56%</td>\n<td>74%</td>\n<td>64%</td>\n</tr>\n<tr>\n<td>EIPW</td>\n<td>79%</td>\n<td>93%</td>\n<td>85%</td>\n</tr>\n<tr>\n<td>HBT</td>\n<td>84%</td>\n<td>94%</td>\n<td>89%</td>\n</tr>\n</tbody>\n</table>\n\nF-measure is the weighted average of the precision and recall.\n\nIt is questionable and inconsistent to use precision and recall to evaluate the performance of conceptual modeling tools or systems because there is no universal standard evaluation requirement corpus available. However, Table 4.5 provides the overall performance of our tools.\n\nSince there is no standard evaluation of NL-based tools available, we cannot compare our tools with the previous tools or systems. However, Harmain & Gaizauskas (Harmain, 2003) claimed that other language processing technologies such as information retrieval systems, information extraction systems, and machine translation systems have found commercial applications with % precision and % recall well below this level (73% recall and 66% precision).\n\n### 4.6 Limitations of the Research\n\nThe overall system performance has been evaluated in the previous chapter. In this section, the limitations of some of the system components are discussed.\n1. This study has, so far, been carried out on one domain only, but it provides a theoretical background for research on other domains as well.\n\n2. One characteristic of our KBSs is to integrate multiple modules and resources for the purpose of automating the process of conceptual data modeling. Some of the modules are designed for these KBSs while other are adopted from open source third party packages. Each component has some limitations.\n - The natural language processing (NLP) technique such as part of speech tagging (POS) technique cannot completely identify all of the information in the requirement specification. For example, the compound noun with hyphen cannot be identified as the whole one noun. However, the overall performance of the POS is quite effective and the % accuracy is 96.4.\n - The use of a general lexical knowledge resource, top noun categories and hypernym chains in WordNet, for automated entity identification process is novel and quite attractive. However, the top noun categories and hypernym chains in WordNet cannot perform entity categories completely because WordNet is a general knowledge resource and is not developed specifically for conceptual data modeling applications.\n\n3. Outputs from the KBSs are individual relationships, not a combined ER diagram.\n\n4. The evaluation of the completeness of the KBSs should be performed in many different categories. For example, empirical work either by using the systems in a number of real cases or by letting number of experts use and evaluate the tools.\n5. CONCLUSION AND FUTURE WORK\n\nTypically, conceptual data modeling has been considered as a creative activity, where human designers are indispensable. In this research, we have proposed methods that can improve the novice designers’ performance and reduce the dependence on domain experts during the conceptual design process. Much research has been conducted in developing methodologies and guidelines to help the designers in conceptual database design. However, it would be useful if a designer has knowledge about an application domain in the form of repository of application-specific knowledge. Currently, building a repository of reusable artifacts involves explication of human developers’ knowledge, which is a major obstacle in facilitating reuse of knowledge. To solve this problem, we proposed new types of reusable artifacts, called entity instance repository (EIR) and Relationship Instance Repository (RIR), which are repositories of Entity Instance Patterns (EIPs) and Relationship Instance Patterns (RIPs), respectively. These patterns can suggest what terms should appear in an application domain and how they are related to each terms. Our proposed artifacts are likely to be useful for conceptual designs in the following aspects: (1) they contain knowledge about a domain; (2) automatic generation of EIR and RIR overcomes a major problem of inefficient manual approaches that depend on experienced modeling designers and domain experts; and (3) they are domain-specific and therefore easier to understand and reuse. In this study, we provided a\ndefinition of the artifacts, and proposed the methodology for automatically generating repositories of domain artifacts.\n\nWe have implemented two knowledge-based data modeling tools: HBT and EIPW. HBT incorporates the six domain independent modeling rules, entity categories, and relationship instance repository. EIPW incorporates entity instance repository, entity categories, relationship instance repository, and WordNet. This step is an initial step to show how domain knowledge stored in the instance patterns can be used together with other modeling techniques.\n\nThe empirical results indicate that novice designers’ performance increased by 30.9~46% when using EIPW, while the performance increased by 33.5~34.9 when using HBT, compared with the cases of no tools. The EIPW with EIR and RIR clearly helps the novice designers in creating better quality conceptual models. These results also imply that the use of EIR and RIR in EIPW is effective by providing us with a library of reusable patterns and by automating the process of finding the most appropriate one for certain situation. In addition, the results of HBT experiments show that the six domain independent modeling rules in HBT are effective in developing the quality conceptual models. They minimize the cognitive load on novices and ensure that the conceptual models are correct. This study shows that the six domain independent rules can be taught in a beginning database modeling class, and HBT can serve as a learning tool. It provides a smooth head-start to novices. In addition, RIR used in relationship identification process in both KBSs can ease the identification of relationships and solve the errors in\nconceptual models caused by the semantic mismatch in which not all real-world relationships can match the conceptual relationships.\n\nThe study has, so far, been carried out with one domain only, but it provides a theoretical background for research on other domains as well. However, it is necessary for the future research to advance the KBSs for supporting not only one but several different domains. Future work is to include more modeling rules required for automatic detection of modeling errors such as fan trap and chasm trap occurring in the conceptual data modeling process. We want to test the usability of the KBSs for different domains and subjects. The evaluation of the completeness of the KBSs have to be done by empirical work either by using the KBSs in a number of real cases or by letting a number of experts use and evaluate the KBS. We also plan to make both KBSs’ interface modules to import the output schema into an ER diagram or a class diagram in graphical CASE tools. In addition, future research will consider the cognitive processes involved and mental representations in conceptual modeling design process. Cognitive science is a very useful reference discipline for gaining a deep understanding why people do things in a particular way (Siau, 1999).\nREFERENCES\n\n\nAppendix A: The user interfaces of EIPW\n\nInitial Step: Begin with copy and paste a requirement specification in the text box.\n\nFigure A.1 A Screenshot of Initial Step in EIPW\nStep 1: Get all the noun phrases from the requirement specification by applying POS.\n\nFigure A.2 A Screenshot of Step 1 in EIPW\nStep2: Test the discard noun set for facilitating the post-parsing analysis.\n\nFigure A.3 A Screenshot of Step 2 in EIPW\nStep 3: Identify entities based on EIR (Entity Instance Repository). And out of the entity names in EIR, identify synonyms from WordNet.\n\nFigure A.4 A Screenshot of Step 3 in EIPW\nStep 4: Identify entities based on top noun categories and hypernym chains in WordNet.\n\n1. Click the \"Apply Hypernym Chains in WordNet\" button.\n2. Then, the noun phrases that can be identified as \"Entity\" or \"Non-Entity\" based on the hypernym chains in WordNet will be shown in Table 1.\n3. For remaining noun phrases that cannot be identified by WordNet, choose whether to model it as \"entity\" or \"non-entity\" in the second column of Table 2.\n4. Move on to the next page by clicking the \"Next Step>>\" button.\n\n@Click on each noun phrase to show the sentences where it is used.\n\nTable 1:\n\n<table>\n<thead>\n<tr>\n<th>Noun Phrases</th>\n<th>Entities</th>\n<th>Non-Entities</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>return item</td>\n<td>☑ entity</td>\n<td>☑ non-entity</td>\n</tr>\n<tr>\n<td>time</td>\n<td>☐ entity</td>\n<td>☑ non-entity</td>\n</tr>\n<tr>\n<td>web site</td>\n<td>☐ entity</td>\n<td>☑ non-entity</td>\n</tr>\n</tbody>\n</table>\n\nTable 2:\n\n<table>\n<thead>\n<tr>\n<th>Non-Identifiable Noun Phrases</th>\n<th>Entity or Non-Entity?</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>return item</td>\n<td>✓ entity ☑ non-entity</td>\n</tr>\n<tr>\n<td>time</td>\n<td>☑ entity ☑ non-entity</td>\n</tr>\n<tr>\n<td>web site</td>\n<td>☑ entity ☑ non-entity</td>\n</tr>\n</tbody>\n</table>\n\nShow the sentences where a noun phrase is used:\n1. For each return item, we keep track of return date, and total return price.\n\nFigure A.5 Screenshot of Step 4 in EIPW\nStep 5: Identify entities based on top noun categories and hyponym chains in WordNet.\n\nFigure A.6 A Screenshot of Step 4 in EIPW\nStep 6: identify relationships based on RIR (Relationship Instance Repository).\n\nFigure A.7 A Screenshot of Step 6 in EIPW\nStep 7: Identify relationships, which are not detected by RIR, by applying a modeling rule.\n\nThis step requires the user to identify the relationships that are not detected by the RIR (Relationship Instance Repository).\n\n1. We keep only Need-to-Remember Relationships as follows:\n\n/* The Need-to-Remember Rule */\nIf a semantic connection between the two entities need to know each other for some duration\nTHEN this connection represents the need-to-remember relationship.\n\ne.g. X and Y know each other (Ex. LOAN and BORROWER)\ne.g. X is recorded in Y (Ex. ORDER and ORDERLINE)\ne.g. For each X, there is a (set of) Y (Ex. TITLE and ITEM)\n\n2. For each relationship in the table on the right side, choose whether to \"Remember\" it or not based on the aforementioned rule.\n\n3. The relationships that the user does not choose as \"Remember\" will be removed by default.\n\n@Click on each Entity1 in the table to show the sentences where it is used. This can be helpful in identifying the appropriate relationship.\n\nFigure A.8 A Screenshot of Step 7 in EIPW\nStep 8: Assign the multiplicity to each relationship obtained from previous Step.\n\nFigure A.9 A Screenshot of Step 8 in EIPW\nStep 9: Show an output of EIPW.\n\nFigure A.10 An output of EIPW\nAppendix B: The user interfaces of HBT\n\nInitial Step: Begin with copy and paste a requirement specification in the text box.\n\nFigure B.1 A Screenshot of Initial Step in HBT\nStep 1: Get all the noun phrases from the requirement specification by applying POS.\n\nFigure B.2 A Screenshot of Step 1 in HBT\nStep 2: Test the discard noun set for facilitating the post-parsing analysis.\n\n**Figure B.3 A Screenshot of Step 2 in HBT**\nStep 3: Identify the entities from noun phrases based on six domain independent modeling rules.\n\n1. Please read the 6 Domain-Independent-Modeling Rules.\n\n /* R1: Identifier Rule */\n IF a noun phrase needs a unique identifier, THEN it is an entity.\n /* R2: Multiple Attribute Rule */\n IF a noun phrase has multiple attributes, THEN it is an entity.\n /* R3: Multi-valued Attribute Rule */\n IF a noun phrase has multi-values, THEN it is an entity.\n /* R4: Time-dependent Attribute Rule */\n IF a noun phrase has time-dependent attributes or keeps track of a history of values, THEN it is an entity.\n e.g. Login, Price History\n /* R5: Single Concept Rule */\n IF a class represents one and only concept, THEN it is an entity.\n /* R6: Domain Importance Rule */\n IF a noun phrase is important in its own right within the problem domain whether it has one or multiple attributes, THEN it is an entity.\n\n2. Based on the 6 rules above, identify whether each noun phrase in the table on the right side is an entity.\n\n3. Move on to the next page by clicking the “Next Step>>” button.\n\n @Click on each noun phrase in the table to show the sentences where it is used. This can be helpful in identifying the appropriate entities.\n\nFigure B.4 A Screenshot of Step 3 in HBT\nStep 4: Get all the verb phrases from the requirement specification by applying POS.\n\nFigure B.5 A Screenshot of Step 4 in HBT\nStep 5: Test the discard verb set for facilitating the post-parsing analysis.\n\nFigure B.6 A Screenshot of Step 5 in HBT\nStep 6: Identify the entities from verb phrases based on modeling rules.\n\n1. Please read the Identification & Multiple Attribute Rules.\n\n /* R1: The Identification Rule */\n IF the concept represented by a verb requires a unique identifier, THEN model it as an entity.\n\n /* R2: The Multiple Attribute Rule */\n IF the concept represented by a verb has multiple attributes, THEN model it as an entity.\n\n2. Double-click the second column in the table on the right side and choose to model each verb as either “Entity” or “Non-Entity” by applying the aforementioned rules.\n\n3. For each verb identified as a “Entity”, double-click the “From Verb to Noun” column to convert the verb into the appropriate noun form.\n\n4. Move on to the next page by clicking the “Next Step>>” button.\n\nClick on each verb to show the sentences where it is used. This can be helpful in identifying the appropriate noun form.\n\nFigure B.7 A Screenshot of Step 6 in HBT\nStep 7: Identify the entities based on entity categories.\n\n**Figure B.8** A Screenshot of Step 7 in HBT\nStep 8: identify relationships based on RIR (Relationship Instance Repository).\n\n1. Examine the retrieved patterns shown in the table on the right side. Then, delete any patterns that are not related to the problem statement.\n\n Ex. [customer] 1:N [order]\n\n This relationship pattern is read as follow:\n (1) Each [customer] is associated with M:N [order].\n (2) Each [order] is associated with ONE [customer].\n\n2. To delete, select a pattern and click the \"DELETE RELATIONSHIP PATTERN\" button.\n\n3. Move on to the next page by clicking the \"Next Step>>\" button.\n\n Click on each entity above to show the sentences where it is used.\n\nFigure B.9 A Screenshot of Step 8 in HBT\nStep 9: Identify relationships, which are not detected by RIR, by applying a modeling rule.\n\nFigure B. 10 A Screenshot of Step 9 in HBT\nStep 10: Assign the multiplicity to each relationship obtained from previous Step.\n\n1. For each relationship, double-click the cell in the “Multiplicity?” column and choose the appropriate multiplicity type.\n\n2. To identify the appropriate multiplicity type, refer to the one-way relationship pattern in the box at the top right corner.\n\nE.g.\n\n2.1 Each [customer] is associated with __ Exactly One __ [order].\n2.2 Each [customer] is associated with __ Zero Or One __ [order].\n2.3 Each [customer] is associated with __ Zero Or Many __ [order].\n2.4 Each [customer] is associated with __ One Or Many __ [order].\n\n3. Click the “Next Step>>” button to print and show the result.\n\nFigure B.11 A Screenshot of Step 10 in HBT\nStep 11: Show an output of HBT\n\nFigure B.12 An output of HB\nAppendix C: Experimental Problem Statements\n\nProblem 1 (Moderate Task Size)\n\nAssume a simplified mail order system for a company in an e-commerce environment of selling various products for children. The web site requires a customer to have a login account in order to gain access. The company also wants to record the login history in order to track the time and IP address given to access the web site. Each customer may place one or more order. The following information about each order needs to be recorded are order date, credit authorization status. For each order item, we keep track of order date, unit price, quantity, and the total order price including the shipping charge. Customers may return order items that they are not satisfied. For each return item, we keep track of return date, and total return price. Each order give rise to one invoice and the customer can make a payment by using credit card (CC), where we keep track of credit card types (Visa, MasterCard, AMEX), CC number, name on the CC, and expiration date. The company also wants to record the price history of each product. There are several shipment methods (such as one-day express, two-day priority, or regular surface mail) and each customer can choose one shipment and numbers of delivery dates. Assume the shipping charge is a straightforward percentage of the total order price plus extra charge depending on the shipping method. Shipping address is the same as the customer address.\nProblem 2 (Medium Task Size)\n\nThe company wants to create a database to keep track of all employees and projects assigned. Projects are distinguished by project numbers, the customers to which the project belongs, a project start date, a project end date, and estimated. In the project plan, the manager of the project must determine the tasks that will be performed to take the project from beginning to the end. Each task has a task ID, a task description, the task’s starting and ending dates, and the number of employees required completing the task. Employees are assigned to specific tasks scheduled by the manager. The hour’s employees working are kept in a work log entry containing a record of the actual hours worked by an employee on a given assignment. The work log is a weekly form that the employee fills out at the end of each month. The work log also contains the date (the last workday of the month), assignment ID, the total hours worked up to the end of that month, and the number of the bill to which the work-log entry is charged. Obviously, each work log entry can be related to only one bill. The company has pooled all of its employees by region, and from this pool, employees are assigned to a specific task.\n\nProblem 3 (Moderate Task Size)\n\nTemporary Employment Corporation (TEC) places the temporary workers in companies. TEC has a file of candidates who are willing to work. If the candidate has worked before, that candidate has a specific job history (Naturally, no job history exists if the candidate has never worked). Each time the candidate works, one additional job history record is created. Each candidate has earned several qualifications. TEC offers\ncourses to help candidates improve their qualifications. Every course develops one specific qualification. Some qualifications have multiple courses that develop that qualification. Some courses require specific qualifications as prerequisites. A course can have several prerequisites. Courses are taught during the training sessions with specialists in the field. A training session is the presentation of a single course and is scheduled in a particular room at a specific time slot. Candidates can register and pay a fee to attend a training session. TEC also has a list of companies that request temporaries. Each time a company requests a temporary employee, TEC makes an entry in the Open Position folder. That folder contains an opening number, a company name, required qualifications, a starting date, an anticipated ending date, and hourly pay. Each opening position requires only one specific or main qualification. When a candidate matches the qualification, the placement is assigned, and an entry is made in the Placement Record folder. That folder contains a placement date, a placement number, the total hours worked, etc. In addition, an entry is made in the job history for the candidate. A placement can be filled by many candidates, and a candidate can fill many placements.\n\n**Problem 4 (Medium Task Size)**\n\nA company wishes to create a database to control its inventory, which consists of many products divided into a number of product categories (i.e. clothing, shoes, bags, and accessories). The purchase department makes a purchase order when a product has to be reordered from the suppliers. The name of the employee who processes the purchase order is record. Each purchase line item records the purchase ID, product received, cost,\nand any wastage. The reorder guideline provides information on how to best reorder products. The same products are stored in the same warehouse, where the company have several different warehouses located in different cities. The different tax rates are used in different states. The sales tax is not applied to every purchase order, but only occurs in those states in which the merchant is required by the state to collect taxes on products sold in the state. Normally, the sales tax determination could be based on the location of the supplier.\nAppendix D: Pre-Experiment Questionnaires\n\nThis questionnaire is part of an analysis of a research work in the area of conceptual modeling. Your answers will be kept confidential. Thank you for your cooperation.\n\n1. Gender (circle your selection): Male / Female\n\n\n4. In order to participate in this study, you must have some experiences with Entity-Relationship (ER) models for database design. Please indicate the type of experience you have with the ER modeling.\n\n □ Developing ER models for database design classes some years ago.\n\n □ Developing small ER models for class assignments or class project recently.\n\n □ Extensive using ER models for database design.\n\n □ Expert knowledge of using ER models for database design.\n\n5. Level of difficulty in database topic:\n\n<table>\n<thead>\n<tr>\n<th>Very Difficult</th>\n<th>Very Easy</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Entity-Relationship Modeling</td>\n<td>□</td>\n</tr>\n<tr>\n<td>Normalization</td>\n<td>□</td>\n</tr>\n<tr>\n<td>The Relational Model</td>\n<td>□</td>\n</tr>\n</tbody>\n</table>\n6. Do you understand the concepts about entity, relationship, and attribute in ER model?\n\n- Very clear\n- Very unclear\n\n<table>\n<thead>\n<tr>\n<th>Entity</th>\n<th>Relationship</th>\n<th>Attribute</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n7. How do you determine entities and relationships in ER modeling?\n\n- ☐ Scanning the sentences in problem statement for nouns and verbs.\n- ☐ Visualizing the scenario\n- ☐ Guessing\n- ☐ Others Please specify: _________________________________\n\n8. Have you created the ER model based on a given problem statement?\n\n- ☐ Every time\n- ☐ Never\n\n9. Have you used any diagramming tools to help you in creating an ER model?\n\n- ☐ Yes If yes, please name: _________________________________\n- ☐ No\n10. Do the diagramming tools help in improving your skills in the ER modeling?\n\n☐ Yes\n\n☐ No\nAppendix E: Pre-Experiment Questionnaires\n\nPlease answer the questions about the experiment you just finished. Your answers will be kept confidential.\n\n11. How difficult is the problem statements?\n\nPlease rate in the scale below\n\n<table>\n<thead>\n<tr>\n<th>Very difficult</th>\n<th>very easy</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Problem 1</td>\n<td></td>\n</tr>\n<tr>\n<td>Problem 2</td>\n<td></td>\n</tr>\n<tr>\n<td>Problem 3</td>\n<td></td>\n</tr>\n<tr>\n<td>Problem 4</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n12. How confident do you feel about modeling the ERD (Entity-Relationship Diagram) to the problem statements?\n\n- [ ] Extremely confident\n- [ ] Somewhat confident\n- [ ] Neither confident or distrustful\n- [ ] Somewhat not confident\n- [ ] Not confident\n13. In your opinion, rate the overall helpfulness of our modeling tool for developing ER models.\n\n- [ ] Very helpful\n- [ ] Somewhat helpful\n- [ ] A little helpful\n- [ ] Not at all helpful\n\n14. In your opinion, rate the impact of our tool on how easy to use and user-friendly.\n\n- [ ] Not at all\n- [ ] Not very easy to use\n- [ ] Somewhat easy to use and user friendly\n- [ ] Very easy to use and user friendly\n\n15. What are the main advantages of using our tool?\n\n16. Identify areas where you believe that the conceptual data modeling tools could be improved. Please explain your improvement.\nCurriculum Vitae\n\nThe author was born in Bangkok, Thailand on September 7, 1974. She attended Chulalongkorn University from 1991 to 1995, and graduated with a Bachelor of Science. Later, she attended Rochester Institute of Technology from 1997 to 1999, and graduated with a Master of Science.\n\nShe came to Drexel University in the Fall of 2005 and began her Ph.D program in the College of Information Science and Technology, with a scholarship from the Royal Thai government. She pursued her research in automated conceptual data modeling under the supervision of Professor Il-Yeol Song."}}},{"rowIdx":269,"cells":{"id":{"kind":"string","value":"cbf37dfc6010a258a6b5a33c5aed205e77cd9ddc"},"text":{"kind":"string","value":"\nDownloaded from:\n\nUsage Guidelines:\nPlease refer to usage guidelines at contact lib-eprints@bbk.ac.uk. or alternatively\nAutomatically Proving Termination and Memory Safety for Programs with Pointer Arithmetic\n\nThomas Ströder · Jürgen Giesl · Marc Brockschmidt · Florian Frohn · Carsten Fuhs · Jera Hensel · Peter Schneider-Kamp · Cornelius Aschermann\n\nAbstract While automated verification of imperative programs has been studied intensively, proving termination of programs with explicit pointer arithmetic fully automatically was still an open problem. To close this gap, we introduce a novel abstract domain that can track allocated memory in detail. We use it to automatically construct a symbolic execution graph that over-approximates all possible runs of a program and that can be used to prove memory safety. This graph is then transformed into an integer transition system, whose termination can be proved by standard techniques. We implemented this approach in the automated termination prover AProVE and demonstrate its capability of analyzing C programs with pointer arithmetic that existing tools cannot handle.\n\nKeywords LLVM · C programs · Termination · Memory Safety · Symbolic Execution\n\n1 Introduction\n\nConsider the following standard C implementation of strlen [62,72], computing the length of the string at the pointer \\texttt{str}. In C, strings are usually represented as a pointer \\texttt{str} to the heap, where all following memory cells up to the first one that contains the value 0 are allocated memory and form the value of the string.\n\n\\begin{verbatim}\nint strlen(char* str) { char* s = str; while(*s) s++; return s-str; }\n\\end{verbatim}\n\nTo analyze algorithms on such data, one has to handle the interplay between addresses and the values they point to. In C, a violation of memory safety (e.g., dereferencing \\texttt{NULL}, accessing an array outside its bounds, etc.) leads to undefined behavior, which may also\ninclude non-termination. Thus, to prove termination of C programs with low-level memory access, one must also ensure memory safety. The \\texttt{strlen} algorithm is memory safe and terminates, because there is some address \\texttt{end} \\geq \\texttt{str} (an integer property of \\texttt{end} and \\texttt{str}) such that \\texttt{*end} is 0 (a pointer property of \\texttt{end}) and all addresses \\texttt{str} \\leq \\texttt{s} \\leq \\texttt{end} are allocated. Other typical programs with pointer arithmetic operate on arrays (which are just sequences of memory cells in C). In this paper, we present a novel approach to prove memory safety and termination of algorithms on integers and pointers automatically. Our abstract domain is tailored to track both integer properties which relate allocated memory addresses with each other, as well as pointer properties about the data stored at such addresses.\n\nTo avoid handling the intricacies of C, we analyze programs in the platform-independent intermediate representation (IR) of the LLVM compilation framework [51, 53]. Our approach works in three steps: First, a symbolic execution graph is created that represents an over-approximation of all possible program runs. We present our abstract domain based on separation logic [61] in Sect. 2 and the automated generation of such graphs in Sect. 3. In Sect. 4 we show the correctness of our construction. In this first step from LLVM to the symbolic execution graph, we handle all issues related to memory, and in particular we prove memory safety of our input program. In Sect. 5, we describe the second step of our approach, in which we generate an integer transition system (ITS) from the symbolic execution graph, encoding the essential information needed to show termination. In the last step, existing techniques for integer programs are used to prove termination of the resulting ITS. In Sect. 6, we compare our approach with related work and show that our implementation in the termination prover AProVE proves memory safety and termination of typical pointer algorithms that could not be handled by other tools before.\n\nA preliminary version of parts of this paper was published in [67]. The present paper extends [67] by the following new contributions:\n\n- We lift the restriction of analyzing only programs with exactly one function to non-recursive programs with several functions.\n- We show how to consider alignment information in the abstract domain. In [67], we just assumed a 1 byte data alignment for all types.\n- In [67], we only handled memory allocation using the LLVM instruction \\texttt{alloca}. In this paper, we extend our abstract domain and our symbolic execution rules to handle the external functions \\texttt{malloc} and \\texttt{free}. This allows us to model memory safety more precisely. Up to now, we could only prove absence of accesses to unallocated memory, whereas now, we can also show that \\texttt{free} is only called for addresses that have been returned by \\texttt{malloc} and that have not been released already. Note that if memory is not released by the end of the program, then we do not consider this as a violation of memory safety, because it does not lead to undefined behavior.\n- We added more symbolic execution rules for LLVM instructions, and give a detailed overview of our limitations in Sect. 6.\n- To represent all possible program runs by a finite symbolic execution graph, it is crucial to merge abstract program states that visit the same program position. We have substantially improved the merging heuristic of [67] in order to also analyze programs where termination or memory safety depend on invariants relating different areas of allocated memory. Such reasoning is required for programs like the \\texttt{strcpy} function from the standard C library. Our symbolic execution can now handle such programs automatically, whereas [67] fails to prove memory safety (and hence also termination).\n- We prove the soundness of our approach w.r.t. the formal LLVM semantics from [73], and provide all proofs in the paper.\n2 Abstract Domain for Symbolic Execution\n\nIn this section, we introduce concrete LLVM states and abstract states that represent sets of concrete states. These states will be needed for symbolic execution in Sect. 3.\n\nTo simplify the presentation, we restrict ourselves to types of the form \\( \\text{in} \\) (for \\( n \\)-bit integers), \\( \\text{in}^\\star \\) (for pointers to values of type \\( \\text{in} \\)), \\( \\text{in}^\\star\\star \\), \\( \\text{in}^\\star\\star\\star \\), etc. Like many other approaches to termination analysis, we disregard integer overflows and assume that variables are only instantiated with signed integers appropriate for their type.\n\nWe consider the function from Sect. 1. In the corresponding LLVM code, \\( \\text{str} \\) has the type \\( \\text{i}8^\\star \\), since it is a pointer to the string’s first character (of type \\( \\text{i}8 \\)). The program is split into the basic blocks entry, loop, and done. We will explain this LLVM code in detail when constructing the symbolic execution graph in Sect. 3.\n\nAn LLVM state consists of a call stack, a knowledge base with information about the values of symbolic variables, and two sets which describe memory allocations and the contents of memory. The call stack is a sequence of stack frames, where each stack frame contains information local to its corresponding function. In particular, a stack frame contains the current program position which is represented by a pair \\((b, j)\\). Here, \\( b \\) is the name of the current basic block and \\( j \\) is the index of the next instruction. So if \\( \\text{Blks} \\) is the set of all basic blocks, then the set of program positions is \\( \\text{Pos} = \\text{Blks} \\times \\mathbb{N} \\). To ease the formalization, we assume that different functions do not have basic blocks with the same names. Moreover, a stack frame also contains information on the current values of the local program variables. We represent an assignment to the local variables \\( \\mathcal{V}_P \\) (e.g., \\( \\mathcal{V}_P = \\{ \\text{str}, \\text{c0}, \\ldots \\} \\)) in the \\( i \\)-th stack frame as a partial function \\( \\mathcal{L}_i: \\mathcal{V}_P \\rightarrow \\mathcal{V}_{sym} \\) (where \\( \\rightarrow \\) denotes partial functions). We use an infinite set of symbolic variables \\( \\mathcal{V}_{sym} \\) with \\( \\mathcal{V}_{sym} \\cap \\mathcal{V}_P = \\{ \\} \\) instead of concrete integers. In this way, our states can represent not only concrete execution states, where all symbolic variables \\( v \\in \\mathcal{V}_{sym} \\) are constrained to a concrete fixed number in \\( \\mathbb{Z} \\), but also abstract states, where \\( v \\) can stand for several possible values. Such states will be needed for symbolic execution. To ease the generalization of states in Sect. 3.3, we require that all \\( \\mathcal{L}_i \\) occurring in a call stack are injective and have pairwise disjoint ranges. Let \\( \\mathcal{V}_{sym}(\\mathcal{L}_i) \\subseteq \\mathcal{V}_{sym} \\) be the set of all symbolic variables \\( v \\) where there exists some \\( x \\in \\mathcal{V}_P \\) with \\( \\mathcal{L}_i(x) = v \\).\n\nIn addition to the values of local variables, each stack frame also contains an allocation list \\( \\mathcal{A}_L \\). This list contains expressions of the form \\( [v_1, v_2] \\) for \\( v_1, v_2 \\in \\mathcal{V}_{sym} \\), which indicate that \\( v_1 \\leq v_2 \\) and that all addresses between \\( v_1 \\) and \\( v_2 \\) have been allocated by an \\texttt{alloca} instruction. This information is stored in the stack frames, as memory allocated by \\texttt{alloca} in a function is automatically released when the control flow returns from that function.\n\nA program position, a variable assignment and an allocation list form a stack frame \\( \\mathcal{F} \\), and we represent call stacks as sequences \\( [\\mathcal{F}_1, \\ldots, \\mathcal{F}_n] \\) of such stack frames, where the \\( i \\)-th stack frame has the form \\( \\mathcal{F}_i = (p_i, \\mathcal{L}_i, A_L) \\). The topmost frame is \\( \\mathcal{F}_1 \\), and we use \"\\( \\cdot \\)\" to decompose call stacks, i.e., \\( [\\mathcal{F}_1, \\ldots, \\mathcal{F}_n] = \\mathcal{F}_1 \\cdot [\\mathcal{F}_2, \\ldots, \\mathcal{F}_n] \\). A new stack frame is inserted after decomposing a stack.\n\n\\begin{verbatim}\ndefine i32 @strlen(i8* str) {\n entry: 0: c0 = load i8* str\n 1: c0zero = icmp eq i8 c0, 0\n 2: br i1 c0zero, label done, label loop\n loop: 0: olds = phi i8* [str,entry],[s,loop]\n 1: a = getelementptr i8* olds, i32 1\n 2: c = load i8* a\n 3: czero = icmp eq i8 c, 0\n 4: br i1 czero, label done, label loop\ndone: 0: sfin = phi i8* [str,entry],[s,loop]\n 1: sfinint = ptrtoint i8* sfin to i32\n 2: strint = ptrtoint i8* str to i32\n 3: size = sub i32 sfinint, strint\n 4: ret i32 size\n}\n\\end{verbatim}\n\n\\footnote{This LLVM program corresponds to the code obtained from \\texttt{strlen} with the Clang compiler [23]. To ease readability, we wrote variables without \"\\( \\cdot \\)\" in front (i.e., we wrote \\texttt{\"str\"} instead of \\texttt{\"\\%str\"} as in proper LLVM) and added line numbers.}\nis added in front of the sequence whenever a function is called, and removed when control\nreturns from it. For any call stack $CS = [FR_1, \\ldots, FR_n]$ where each stack frame $FR_i$ uses\nthe partial function $LV_i$ for the local variables, let $V_{sym}(CS)$ consist of $V_{sym}(LV_1) \\cup \\ldots \\cup\nV_{sym}(LV_n)$ and of all symbolic variables occurring in $AL_1, \\ldots$ or $AL_n$.\n\nThe second component of our LLVM states is the knowledge base $KB \\subseteq QF_JA(V_{sym})$, a\nset of quantifier-free first-order formulas that express integer arithmetic properties of $V_{sym}$.\nFor concrete states, the knowledge base constrains $V_{sym}(CS)$ in such a way that their values\nare uniquely determined, whereas for abstract states several values are possible.\n\nMany of the rules for symbolic execution in Sect. 3 have conditions where one has to\ncheck validity of formulas obtained from the knowledge base of the current state. In principle,\nany SMT solver can be used for this check. Most of these formulas only use linear integer\narithmetic, but for programs with non-linear expressions (like $x \\cdot y$), the resulting formulas\ncan also contain non-linear arithmetic. As validity is not decidable for non-linear integer\narithmetic, the power of the SMT solver influences the power of our analysis, since symbolic\nexecution rules can only be applied if the proof for their applicability conditions succeeds.\n\nThe third component is the global allocation list $AL$. It is used to model memory allocated\nby malloc, where allocated parts of the memory are again represented by expressions of the form\n$v_1, v_2$. In contrast to malloc, memory allocated by malloc needs to be released\nexplicitly by the programmer. In this paper, we assume that reading from memory locations\nthat are currently allocated but not initialized, yields an arbitrary fixed value. To remove this\nassumption, a structure similar to $AL$ could be used to track initialized memory regions.\n\nAs the fourth and final component, $PT$ is a set of “points-to” atoms $v_1 \\rightarrow_{ty} v_2$ where\n$v_1, v_2 \\in V_{sym}$ and $ty$ is an LLVM type. This means that the value $v_2$ of type $ty$ is stored\nat the address $v_1$. Let $size(ty)$ be the number of bytes required for values of type $ty$ (e.g.,\nsize(18) = 1 and size(132) = 4). As each memory cell stores one byte, $v_1 \\rightarrow_{ty} v_2$ means\nthat $v_2$ is stored in the four cells at the addresses $v_1, \\ldots, v_1 + 3$. The size of a pointer type\n$ty*$ is determined by the data layout string in the beginning of an LLVM program. On 64-bit\nmachine architectures, we usually have $size(ty*) = 8$, and on 32-bit architectures we usually\nhave $size(ty*) = 4$. In the following let us consider some fixed value for $size(ty*)$.\n\nFinally, to model possible violations of memory safety, we introduce a special error state\n$ERR$. In particular, this state is reached when accessing non-allocated memory. The following\ndefinition introduces our notion of (possibly abstract) LLVM states formally.\n\nDefinition 1 (LLVM States) LLVM states have the form $(CS, KB, AL, PT)$ where $CS \\in\n(PoSM \\times (V_{PT} \\rightarrow V_{sym}) \\times \\{[v_1, v_2] \\mid v_1, v_2 \\in V_{sym}\\})^\\ast$, $KB \\subseteq QF_JA(V_{sym})$, $AL \\subseteq \\{[v_1, v_2] \\mid\nv_1, v_2 \\in V_{sym}\\}$, and $PT \\subseteq \\{v_1 \\rightarrow_{ty} v_2 \\mid v_1, v_2 \\in V_{sym}, ty$ is an LLVM type$\\}$. Additionally,\nthere is a state $ERR$ for possible memory safety violations. For a state $a = (CS, KB, AL, PT)$,\nlet $V_{sym}(a)$ consist of $V_{sym}(CS)$ and of all symbolic variables occurring in $KB, AL,$ or $PT$.\n\nIn a call stack $CS = [(p_1, LV_1, AL_1), \\ldots, (p_n, LV_n, AL_n)]$, we often identify the mapping\n$LV_i$ with the set of equations $\\{x_i = LV_i(x) \\mid x \\in V_{PT}, LV_i(x)$ is defined$\\}$ and extend $LV_i$ to\na function from $V_{PT} \\cup Z$ to $V_{sym} \\cup Z$ by defining $LV_i(n) = n$ for all $n \\in Z$.\nWe also often identify $CS$ with the set of equations $\\{x_i = LV_i(x) \\mid x \\in V_{PT}, LV_i(x)$ is defined$\\}$.\nLet $V_{PT}^A = \\{x_i \\mid x \\in V_{PT}, i \\in [n]\\}$ be the set of all these indexed variables that we use to represent\nstack frames. Moreover, we write $AL^*$ for the union of the global allocation list with the allocation\nlists in the individual stack frames, i.e., $AL^* = AL \\cup AL_1 \\cup \\ldots \\cup AL_n$. Thus, $AL^*$\nrepresents all currently allocated memory (by alloc or malloc) in the current state. We\nsay that a state $(CS, KB, AL, PT)$ is well formed iff for every “points-to” information $v \\rightarrow_{ty}\nw \\in PT$, there is an allocated area $[v_1, v_2]$ in $AL^*$ such that $= KB \\Rightarrow v_1 \\leq v \\wedge v \\leq v_2$. So $PT$\nonly contains information about addresses that are known to be allocated.\nAs an example, consider the following abstract state for our strlen program:\n\n\\[\n\\langle \\text{entry}, 0, \\text{str} = \\text{malloc}, \\{ z = 0 \\}, \\{ v_{\\text{end}} \\rightarrow i8 z \\} \\rangle\n\\]\n\nIt represents states at the beginning of the entry block, where \\( CS = [[\\text{entry}, 0], L_{i8}, \\{ z = 0 \\}, \\{ v_{\\text{end}} \\rightarrow i8 z \\}] \\) with \\( L_{i8}(\\text{str}) = \\text{malloc} \\) and no memory was allocated by alloca. Due to an earlier call of \\text{malloc}, the memory cells between \\( L_{i8}(\\text{str}) = \\text{malloc} \\) and \\( v_{\\text{end}} \\) are allocated on the heap, and the value at the address \\( v_{\\text{end}} = z \\) (where the knowledge base is \\( \\{ z = 0 \\} \\)).\n\nTo define the semantics of abstract states \\( a \\), we introduce the formulas \\( \\langle a \\rangle_{SL} \\) and \\( \\langle a \\rangle_{FO} \\). Here, \\( \\langle a \\rangle_{SL} \\) is a formula from a fragment of separation logic [61] that defines which concrete states are represented by \\( a \\). The first-order formula \\( \\langle a \\rangle_{FO} \\) is a weakened version of \\( \\langle a \\rangle_{SL} \\), used for the automation of our approach. We use it to construct symbolic execution graphs, as it allows us to apply standard SMT solving [59] for all reasoning. We also use \\( \\langle a \\rangle_{FO} \\) for the subsequent generation of integer transition systems from symbolic execution graphs.\n\nThe formula \\( \\langle a \\rangle_{FO} \\) contains \\( KB \\), and in addition, it expresses that the pairs \\( [v_1, v_2] \\) in allocation lists represent disjoint intervals. Moreover, two values at the same address must be equal and two addresses must be different if they point to different values in \\( PT \\). Finally, all addresses are positive numbers.\n\n**Definition 2 (Representing States by FO Formulas)** The set \\( \\langle a \\rangle_{FO} \\) is the smallest set with\n\n\\[\n\\langle a \\rangle_{FO} = KB \\cup \\{ 1 \\leq v_1 \\land v_1 \\leq v_2 \\mid [v_1, v_2] \\in AL^* \\} \\cup \\\\\n\\{ v_2 < v_1 \\lor v_2 < v_1 \\mid [v_1, v_2], [w_1, w_2] \\in AL^*, (v_1, v_2) \\neq (w_1, w_2) \\} \\cup \\\\\n\\{ v_2 = w_2 \\mid \\{ v_1 \\rightarrow_{ty} v_2, (v_1 \\hookrightarrow_{ty} w_2) \\in PT \\text{ and } \\models \\langle a \\rangle_{FO} \\Rightarrow v_1 = w_1 \\} \\cup \\\\\n\\{ v_1 \\neq w_1 \\mid (v_1 \\hookrightarrow_{ty} v_2), (w_1 \\hookrightarrow_{ty} w_2) \\in PT \\text{ and } \\models \\langle a \\rangle_{FO} \\Rightarrow v_2 \\neq w_2 \\} \\cup \\\\\n\\{ v_1 > 0 \\mid (v_1 \\hookrightarrow_{ty} v_2) \\in PT \\}.\n\\]\n\nNow we formally define \"concrete states\" as abstract states of a particular form. A concrete state \\( c \\) uniquely describes the call stack and the contents of the memory. So we require that \\( \\langle c \\rangle_{FO} \\) is satisfiable to ensure that \\( c \\) actually can represent something, and that \\( b \\) can have unique values for the contents of all allocated addresses. Here, we represent memory data byte-wise, and since LLVM represents values in two’s complement, each byte stores a value from \\([-2^7, 2^7 - 1]\\). This byte-wise representation of the memory enforces a uniform representation of concrete states, and thus \\( c \\) we allow only statements of the form \\( w_1 \\hookrightarrow_{i8} w_2 \\) in \\( PT \\) for concrete states. Moreover, this restriction ensures that concrete states are really legal states. (Otherwise, we would have to check whether two statements \\( w_1 \\hookrightarrow_{ty} w_2 \\) and \\( w_1 \\hookrightarrow_{ty} w_3 \\) with \\( ty_1 \\neq ty_3 \\) in the same state are compatible or whether they contradict each other.) Finally, \\( d \\) all occurring symbolic variables must have unique values.\n\n**Definition 3 (Concrete States)** Let \\( c = (CS, KB, AL, PT) \\) be an LLVM state. We call \\( c \\) a concrete state iff \\( c \\) is well formed and all of the following conditions hold:\n\n(a) \\( \\langle c \\rangle_{FO} \\) is satisfiable,\n\n(b) for all \\([v_1, v_2] \\in AL^*\\) and for all integers \\( n \\) with \\( \\models \\langle c \\rangle_{FO} \\Rightarrow v_1 \\leq n \\land n \\leq v_2 \\), there exists \\( (w_1 \\hookrightarrow_{i8} w_2) \\in PT \\) for some \\( w_1, w_2 \\in V_{\\text{sym}} \\) such that \\( \\models \\langle c \\rangle_{FO} \\Rightarrow w_1 = n \\) and \\( \\models \\langle c \\rangle_{FO} \\Rightarrow w_2 = k \\) for some \\( k \\in [-2^7, 2^7 - 1] \\),\n\n(c) there is no \\( w_1 \\hookrightarrow_{ty} w_2 \\) in \\( PT \\) for \\( ty \\neq i8 \\),\n\n(d) for all \\( v \\in V_{\\text{sym}}(c) \\) there exists an \\( n \\in \\mathbb{Z} \\) such that \\( \\models \\langle c \\rangle_{FO} \\Rightarrow v = n \\).\n\nMoreover, ERR is also a concrete state.\n\nA state \\( a \\neq ERR \\) always stands for a memory-safe state where exactly the addresses in \\( AL^* \\) are allocated. Let \\( \\rightarrow_{\\text{LLVM}} \\) be LLVM’s evaluation relation on concrete states, i.e., \\( c \\rightarrow_{\\text{LLVM}} \\tau \\) holds iff \\( c \\) evaluates to \\( \\tau \\) by executing one LLVM instruction. Similarly, \\( c \\rightarrow_{\\text{LLVM}} ERR \\)\nmeans that the evaluation step performs an operation that may lead to undefined behavior. An LLVM program is memory safe for \\( c \\neq \\text{ERR} \\) iff there is no evaluation \\( c \\rightarrow^*_{\\text{LLVM}} \\text{ERR} \\), where \\( \\rightarrow^*_{\\text{LLVM}} \\) is the transitive closure of \\( \\rightarrow_{\\text{LLVM}} \\).\n\nAs mentioned, in addition to \\( \\langle a \\rangle_{\\text{FO}} \\), we also introduce a separation logic formula \\( \\langle a \\rangle_{\\text{SL}} \\) for every state \\( a \\). We consider a fragment of separation logic which extends first-order logic by a predicate symbol “\\( \\rightarrow \\)” for “points-to” information and by the connective “\\( \\ast \\)” for separating conjunction. As usual, \\( \\phi_1 \\ast \\phi_2 \\) means that \\( \\phi_1 \\) and \\( \\phi_2 \\) hold for disjoint parts of the memory.\n\nThe semantics of separation logic can then be defined using interpretations of the form \\( (as, \\text{mem}) \\) which represent the values of the program variables and the heap. The (partial) assignment function \\( as : \\mathcal{V}_{\\text{PT}} \\rightarrow \\mathbb{Z} \\) is used to describe the values of the program variables (more precisely, as operates on variables of the form \\( x_i \\) to represent the variable \\( x \\in \\mathcal{V}_{\\text{PT}} \\) occurring in the \\( i \\)-th stack frame). Moreover, a partial function \\( \\text{mem} : \\mathbb{N}_{>0} \\rightarrow \\{ 0, \\ldots, 2^8 - 1 \\} \\) with finite domain describes the memory contents at allocated addresses (as unsigned bytes).\n\nTo deal with symbolic variables in formulas, we use instantiations. Let \\( \\mathcal{T}(\\mathcal{V}_{\\text{sym}}) \\) be the set of all arithmetic terms containing only variables from \\( \\mathcal{V}_{\\text{sym}} \\). Any function \\( \\sigma : \\mathcal{V}_{\\text{sym}} \\rightarrow \\mathcal{T}(\\mathcal{V}_{\\text{sym}}) \\) is called an instantiation. Thus, \\( \\sigma \\) does not instantiate \\( \\mathcal{V}_{\\text{PT}} \\). Instantiations are extended to formulas in the usual way, i.e., \\( \\sigma(\\varphi) \\) instantiates every free occurrence of \\( v \\in \\mathcal{V}_{\\text{sym}} \\) in \\( \\varphi \\) by \\( \\sigma(v) \\). An instantiation is called concrete iff \\( \\sigma(v) \\in \\mathbb{Z} \\) for all \\( v \\in \\mathcal{V}_{\\text{sym}} \\).\n\n**Definition 4 (Semantics of Separation Logic)** Let \\( \\mathcal{V}_{\\text{PT}} \\) be a set of points-to information. Let \\( \\mathcal{V}_{\\text{sym}} \\) be the set of all arithmetic terms containing only variables from \\( \\mathcal{V}_{\\text{sym}} \\). We define \\( \\langle a \\rangle_{\\text{SL}} \\) for formulas \\( \\varphi \\) that may contain symbolic variables from \\( \\mathcal{V}_{\\text{sym}} \\) (this is needed for Sect. 3). As usual, all free variables \\( v_1, \\ldots, v_n \\) in \\( \\varphi \\) are implicitly universally quantified, i.e., \\( \\varphi \\mid \\mathcal{V}_{\\text{sym}} \\) if \\( \\varphi \\mid \\mathcal{V}_{\\text{sym}} \\). The semantics of arithmetic operations and predicates as well as of first-order connectives and quantifiers are as usual.\n\nIn particular, we define \\( \\langle a \\rangle_{\\text{SL}} \\) for formulas \\( \\varphi \\) that may contain symbolic variables from \\( \\mathcal{V}_{\\text{sym}} \\) (this is needed for Sect. 3). As usual, all free variables \\( v_1, \\ldots, v_n \\) in \\( \\varphi \\) are implicitly universally quantified, i.e., \\( \\varphi \\mid \\mathcal{V}_{\\text{sym}} \\) if \\( \\varphi \\mid \\mathcal{V}_{\\text{sym}} \\). The semantics of arithmetic operations and predicates as well as of first-order connectives and quantifiers are as usual.\n\nWe still have to define the semantics of \\( \\langle a \\rangle_{\\text{SL}} \\) for formulas \\( \\varphi \\) that may contain symbolic variables from \\( \\mathcal{V}_{\\text{sym}} \\) (this is needed for Sect. 3). As usual, all free variables \\( v_1, \\ldots, v_n \\) in \\( \\varphi \\) are implicitly universally quantified, i.e., \\( \\varphi \\mid \\mathcal{V}_{\\text{sym}} \\) if \\( \\varphi \\mid \\mathcal{V}_{\\text{sym}} \\). The semantics of arithmetic operations and predicates as well as of first-order connectives and quantifiers are as usual.\n\nTo formalize the semantics of an abstract state \\( a \\), i.e., to define which concrete states are represented by \\( a \\), we now define \\( \\langle a \\rangle_{\\text{SL}} \\). In \\( \\langle a \\rangle_{\\text{SL}} \\), we combine the elements of \\( \\mathcal{AL} \\) with the separating conjunction “\\( \\ast \\)” to express that different allocated memory blocks are disjoint. We have to include an additional separated conjunct \\( \\text{true} \\) to represent further allocations that we do not know of. In contrast, the elements of \\( \\mathcal{PT} \\) are combined by the ordinary conjunction “\\( \\land \\)”.\n\n**Definition 5 (Representing States by SL Formulas)** For \\( v_1, v_2 \\in \\mathcal{V}_{\\text{sym}} \\), let \\( \\langle [v_1, v_2] \\rangle_{\\text{SL}} = \\)\n\n\\[ ^{2} \\text{We use “\\( \\rightarrow \\)” instead of “\\( \\rightarrow^* \\)” in separation logic, since \\( \\text{mem} \\mid n_1 \\rightarrow n_2 \\) would imply that \\( \\text{mem}(n) \\) is undefined for all \\( n \\neq n_1 \\). This would be inconvenient in our formalization, since \\( \\mathcal{PT} \\) usually only contains information about a part of the allocated memory.} \\]\n\nThomas Ströder et al.\n1 \\leq v_1 \\land v_1 \\leq v_2 \\land (\\forall x : y. (v_1 \\leq x \\leq v_2) \\Rightarrow (x \\leftrightarrow y)).\n\nReflecting two's complement representation, for any LLVM type \\( ty \\), we define \\( (v_1 \\leftrightarrow_{sl} v_2)_{SL} = v_1 > 0 \\land (v_1 \\leftrightarrow_{sl} ty(v_2))_{SL} \\land (v_2 \\geq 0 \\Rightarrow v_3 = v_2) \\land (v_2 < 0 \\Rightarrow v_3 = v_2 + 2^8.\\text{size}(ty)) \\), where \\( v_3 \\in V_{sym} \\) is fresh. We assume a little-endian data layout (where the least significant byte is stored in the lowest address). Here, we let \\( (v_1 \\leftrightarrow_{v_0} v_3)_{SL} = true \\) and \\( (v_1 \\leftrightarrow_{v_1} v_3)_{SL} = (v_1 \\leftrightarrow (v_3 \\mod 2^8)) \\land ((v_1 + 1) \\leftrightarrow v_3 \\div 2^8)_{SL} \\).\n\nLet \\( a = (CS, KB, AL, PT) \\) be an abstract state. It is represented in separation logic by \\( \\langle a \\rangle_{SL} = CS \\land KB \\land (true \\ast (*_{\\varphi \\in AL} (\\varphi))_{SL}) \\land (\\bigwedge_{\\varphi \\in PT} (\\varphi))_{SL} \\).\n\nClearly, we have \\( \\models \\langle a \\rangle_{SL} \\Rightarrow \\langle a \\rangle_{FO} \\) for any abstract state \\( a \\). So \\( \\langle a \\rangle_{FO} \\) only contains first-order information that holds in every concrete state represented by \\( a \\).\n\nNow we can define which concrete states are represented by an abstract state. Note that due to Def. 3, we can extract an interpretation \\((as', \\text{mem'})\\) from every concrete state \\( c \\neq \\text{ERR} \\). Then we define that a (well-formed) abstract state \\( a \\) represents all those concrete states \\( c \\) where \\((as', \\text{mem'})\\) is a model of some (concrete) instantiation of \\( a \\).\n\n**Definition 6 (Representing Concrete by Abstract States)** Let \\( c = (CS', KB', AL', PT') \\) be a concrete state where \\( CS' \\) uses the functions \\( LV_1, \\ldots, LV_n \\). For every \\( x \\in V_P \\) where \\( LV_1^{x}(x) \\) is defined, let \\( a_s'(x) = n \\) for the number \\( n \\in \\mathbb{Z} \\) with \\( \\models (c)_{FO} \\Rightarrow LV_1^{x}(x) = n \\).\n\nFor \\( n \\in \\mathbb{N}_{\\geq 0} \\), the function \\( \\text{mem'}(n) \\) is defined iff there exists a \\( w_1 \\leftrightarrow_{\\text{sl}} w_2 \\in PT' \\) such that \\( \\models (c)_{FO} \\Rightarrow w_1 = n \\). Let \\( \\models (c)_{FO} \\Rightarrow w_2 = k \\) for \\( k \\in [-2^7, 2^7 - 1] \\). Then we have \\( \\text{mem'}(n) = k \\) if \\( k \\geq 0 \\) and \\( \\text{mem'}(n) = k + 2^8 \\) if \\( k < 0 \\).\n\nWe say that an abstract state \\( a = (\\{(p_1, LV_1^{p_1}, AL_1^{p_1}), \\ldots, (p_n, LV_n^{p_n}, AL_n^{p_n})\\}, KB', AL', PT') \\) represents a concrete state \\( c = (\\{(p_1, LV_1^{p_1}, AL_1^{p_1}), \\ldots, (p_n, LV_n^{p_n}, AL_n^{p_n})\\}, KB, AL', PT') \\) iff \\( a \\) is well formed and \\((as', \\text{mem'})\\) is a model of \\( \\sigma(a)_{SL} \\) for some concrete instantiation \\( \\sigma \\) of the symbolic variables. The only state that represents the error state \\( \\text{ERR} \\) is \\( \\text{ERR} \\) itself.\n\nSo the abstract state \\((\\dagger)\\) from the strl\\(_n\\) program represents all concrete states \\( c = (\\{(\\text{entry}, 0), LV_1, \\{\\}\\}, KB, AL, PT) \\) where \\( \\text{mem'} \\) stores a string at the address \\( \\text{as'}(\\text{strl}) \\).\n\n### 3 From LLVM to Symbolic Execution Graphs\n\nWe now show how to automatically generate a symbolic execution graph that over-approximates all possible executions of a given program. For this, we present symbolic execution rules for some of the most important LLVM instructions. We start with the rules for the LLVM instructions in our strl\\(_n\\) example in Sect. 3.1. In Sect. 3.2, we present rules for a more advanced example including memory allocation and function calls.\n\nWhile there already exist approaches for symbolic execution of C or LLVM (e.g., in the tools KLEE [18] and Ufo [1]), our new abstract domain is particularly suitable for tracking explicit information about memory allocations and the contents of memory, allowing a fully\n\n---\n\n5 A corresponding representation could also be defined for big-endian layout. This layout information is necessary to decide which concrete states are represented by abstract states, but it is not used when constructing symbolic execution graphs (i.e., our remaining approach is independent of such layout information).\n\n4 We identify sets of first-order formulas \\( \\{\\varphi_1, \\ldots, \\varphi_q\\} \\) with their conjunction \\( \\varphi_1 \\land \\ldots \\land \\varphi_q \\). Thus, \\( CS \\) is identified with the set resp. with the conjunction of the equations \\( \\bigcup_{i \\in \\mathbb{Z}} (x_i = LV_i(x)) \\mid x \\in V_P, LV_i(x) \\) is defined \\). Moreover, we wrote \\( (true \\ast (*_{\\varphi \\in AL} (\\varphi))_{SL}) \\) to ensure that this part of the formula is \\( true \\) if \\( AL' = \\varnothing \\).\n\n5 The reason is that then there is an address \\( \\text{end} \\in \\mathbb{N}_{\\geq 0} \\) with \\( \\text{end} \\geq \\text{as'}(\\text{strl}) \\) such that \\( \\text{mem'}(\\text{end}) = 0 \\) and \\( \\text{mem'} \\) is defined for all numbers between \\( \\text{as'}(\\text{strl}) \\) and \\( \\text{end} \\). Hence if \\( a \\) is the state in \\((\\dagger)\\), then \\( \\text{mem'}(a) = \\text{mem'}(\\text{strl}) \\) holds for any instantiation \\( \\sigma \\) with \\( \\sigma(a_{\\text{strl}}) = \\text{as'}(\\text{strl}) \\), \\( \\sigma(\\text{end}) = \\text{end} \\), and \\( \\sigma(\\text{a}) = 0 \\).\nautomated analysis of programs with direct memory access and pointer arithmetic. Most other existing tools cannot successfully analyze termination of such programs fully automatically without the specification of invariants by the user. In particular, we also have rules for refining and generalizing abstract states. This is needed to obtain finite symbolic execution graphs that represent all possible executions. We present our algorithm to generalize states in Sect. 3.3.\n\n### 3.1 Basic Symbolic Execution Rules\n\nOur analysis starts with the set of initial states that one wants to analyze for termination, e.g., all states where $$\\sigma$$ points to a string. So in our example, we start with the abstract state $$(\\uparrow)$$. Fig. 1 depicts the symbolic execution graph for $$\\sigma$$. Here, we omitted the component $$AL = \\{[u_{\\sigma \\tau}, v_{\\text{end}}]\\}$$ for the global allocation list, which stays the same in all states in this example. We also abbreviated parts of $$CS, KB, \\text{and } PT$$ by “...”. Instead of $$v_{\\text{end}} \\mapsto_{\\text{LB}} z$$ and $$z = 0$$, we directly wrote $$v_{\\text{end}} \\mapsto 0$$, etc.\n\nThe function $$\\sigma$$ starts with loading the character at address $$\\sigma$$ to $$c_0$$. Let $$p : \\text{ins}$$ denote that $$\\text{ins}$$ is the instruction at position $$p$$. Our first rule handles the case $$p : \\text{load ty* ad}$$, i.e., the value of type $$\\text{ty}$$ at the address $$\\text{ad}$$ is assigned to the variable $$x$$. In our rules, let $$a$$ always denote the state before the execution step (i.e., above the horizontal line of the rule). Moreover, we write $$\\langle a \\rangle$$ instead of $$\\langle a \\rangle_FO$$. As each memory cell stores one byte, in the $$\\text{load}$$-rule we first have to check whether the addresses $$\\text{ad}, \\ldots, \\text{ad + size(\\text{ty}) - 1}$$ are allocated, i.e., whether there is a $$\\langle v_1, v_2 \\rangle \\in AL$$ such that $$\\langle a \\rangle \\Rightarrow (v_1 \\leq LV_1(\\text{ad}) \\land LV_1(\\text{ad}) + \\text{size(\\text{ty})} - 1 \\leq v_2)$$ is valid. Then, we reach a new state where the previous position $$p = (b, i)$$ is updated to the position $$p^+ = (b, i + 1)$$ of the next instruction in the same basic block, and we set $$LV_1(x) = w$$ for a fresh $$w \\in V_{\\text{sym}}$$. Here we write $$LV_1[x := w]$$ for the function where $$(LV_1[x := w])(x) = w$$ and for $$y \\neq x$$, we have $$(LV_1[x := w])(y) = LV_1(y)$$. Moreover, we add $$LV_1(\\text{ad}) \\mapsto_{\\text{ty}} w$$ to $$PT$$. Thus, if $$PT$$ already contained a formula $$LV_1(\\text{ad}) \\mapsto_{\\text{ty}} u$$, then $$\\langle a \\rangle$$ implies $$w = u$$. We used this rule to obtain $$B$$ from $$A$$ in Fig. 1.\n\nIn memory access instructions like $$\\text{load}$$, one can also specify an optional alignment $$\\text{al}$$ which indicates that the respective addresses are divisible by $$\\text{al}$$. This alignment information is generated by the LLVM code emitter (e.g., by the compiler from C to LLVM). It is a hint to the code generator (which transforms LLVM code into machine code) that the address will be at the specified alignment. The code generator may use this information for optimizations.\n\nNote in the rules that $$LV_1$$ is a partial function, i.e., $$LV_1$$ may not be defined for all $$x \\in V_P$$. But according to [53], in well-formed LLVM programs all uses of a variable are dominated by its definition. So $$LV_1(x)$$ is always defined when we read from $$x$$ during symbolic execution.\n\n```\n\\text{load from allocated memory} (p : \"x = load ty* ad [, align al]\" with x, ad \\in V_P, al \\in \\mathbb{N})\n\\begin{align*}\n(p, LV_1, \\langle eyelid, CS, \\text{al}, PT \\rangle) \\quad & \\text{if } \\langle p^+, LV_1[x := w], \\langle eyelid, CS, \\text{al}, PT \\rangle \\cup \\{LV_1(\\text{ad}) \\mapsto_{\\text{ty}} w\\} \\rangle \\\\\n\\text{• there is } \\langle v_1, v_2 \\rangle \\in AL \\quad & \\text{with } \\vdash (a) \\Rightarrow (v_1 \\leq LV_1(\\text{ad}) \\land LV_1(\\text{ad}) + \\text{size(\\text{ty})} - 1 \\leq v_2), \\\\\n\\text{• } \\vdash (a) \\Rightarrow (LV_1(\\text{ad}) \\mod \\text{al} = 0), \\text{if an alignment \\text{al} \\geq 1 is specified}, \\\\\n\\text{• w \\in V_{\\text{sym}} is fresh}\n\\end{align*}\n```\n\nIn a similar way, we formulate a rule for instructions that $$\\text{store}$$ a value at some address in the memory. The instruction \"$$\\text{store ty t, ty* ad}$$\" stores the value $$t$$ of type $$\\text{ty}$$ at the address $$\\text{ad}$$. Again, we check whether $$LV_1(\\text{ad}), \\ldots, LV_1(\\text{ad}) + \\text{size(\\text{ty})} - 1$$ are addresses in an allocated part of the memory. The information that $$\\text{ad}$$ now points to $$t$$ is added to the set $$PT$$. All other information in $$PT$$ that is not influenced by this change is kept.\\(^6\\)\n\n\\(^6\\) For any terms, \"$$\\langle t_1, t_2 \\rangle \\perp \\langle \\overline{t}, \\overline{t} \\rangle\" is a shorthand for $$t_2 < \\overline{t} \\lor \\overline{t} < t_1.$$\nFig. 1 Symbolic execution graph for strlen\n\nstore to allocated memory ($p$:*store ty $t$, ty* ad [], align all*), $t \\in V_{P} \\cup Z$, ad $\\in V_{P} \\cup 0$\n\n$$((p, LV_{1}, AL_{1}) \\cdot CS, KB, AL, PT)$$\n\nif\n\n- there is $[w_{1}, w_{2}] \\in AL$ with $\\models (a) \\Rightarrow (v_{1} \\leq LV_{1}(ad) \\land LV_{1}(ad)+size(ty)-1 \\leq v_{2})$\n- $PT = \\{(w_{1} \\rightarrow_{sy} w_{2}) \\in PT | \\models (a) \\Rightarrow (LV_{1}(ad), LV_{1}(ad)+size(ty)-1 \\leq w_{1} \\lor w_{1} + size(sy)-1))$\n- $\\models (a) \\Rightarrow (LV_{1}(ad) \\mod al = 0)$, if an alignment $al \\geq 1$ is specified.\n- $w \\in V_{sym}$ is fresh\n\nIf load or store accesses a non-allocated address or if the address does not correspond to the specified alignment, then memory safety is violated and we reach the ERR state.\n\nload or store on unallocated memory ($p$:*load ty* ad [], align all*), $x, ad \\in V_{P}$ and $al \\in N$, or $p$:*store ty* ad [], align all*), $x, ad \\in V_{P}$ and $al \\in N$\n\n$$((p, LV_{1}, AL_{1}) \\cdot CS, KB, AL, PT)$$\n\nif\n\nthere is no $[v_{1}, v_{2}] \\in AL$ with $\\models (a) \\Rightarrow (v_{1} \\leq LV_{1}(ad) \\land LV_{1}(ad)+size(ty)-1 \\leq v_{2})$\n\nload or store with unsafe alignment ($p$:*load ty* ad, align all*), $x, ad \\in V_{P}$ and $al \\in N_{\\leq 0}$, or $p$:*store ty* ad, align all*), $x, ad \\in V_{P}$ and $al \\in N_{\\leq 0}$\n\n$$((p, LV_{1}, AL_{1}) \\cdot CS, KB, AL, PT)$$\n\nif $\\not\\models (a) \\Rightarrow (LV_{1}(ad) \\mod al = 0)$\n\nThe instructions icmp and br in strlen’s entry block check if the first character c0 is 0. In that case, we have reached the end of the string and jump to the block done. Thus, we now introduce rules for integer comparison. For “$x = icmp eq ty t_{1}, t_{2}$”, we check\nif the state contains enough information to decide whether the values \\( t_1 \\) and \\( t_2 \\) of type \\( 2\\) are equal. In that case, the value 1 resp. 0 (i.e., true resp. false) is assigned to \\( x \\).\n\n\\[\n\\text{icmp eq}(p:\\text{\"x = icmp eq ty t_1, t_2\" with } x \\in \\mathcal{V}_p \\text{ and } t_1, t_2 \\in \\mathcal{V}_p \\cup \\mathbb{Z})\n\\]\n\n\\[\n((p, \\mathcal{L}V_1, \\mathcal{A}L_1)\\cdot \\mathcal{C}S, \\mathcal{K}B, \\mathcal{A}L, \\mathcal{P}T)\n\\]\n\n\\[\n\\text{if } \\models \\langle a \\rangle \\Rightarrow (\\mathcal{L}V_1(t_1) = \\mathcal{L}V_1(t_2))\n\\]\n\n\\[\n\\text{and } w \\in \\mathcal{V}_{\\text{sys}} \\text{ is fresh}\n\\]\n\n\\[\n((p, \\mathcal{L}V_1[x := w], \\mathcal{A}L_1)\\cdot \\mathcal{C}S, \\mathcal{K}B \\cup \\{w = 1\\}, \\mathcal{A}L, \\mathcal{P}T)\n\\]\n\n\\[\n\\text{if } \\models \\langle a \\rangle \\Rightarrow (\\mathcal{L}V_1(t_1) \\neq \\mathcal{L}V_1(t_2))\n\\]\n\n\\[\n\\text{and } w \\in \\mathcal{V}_{\\text{sys}} \\text{ is fresh}\n\\]\n\nOther integer comparisons (for \\(<, \\leq, \\ldots \\)) are handled analogously. Note that LLVM always represents integers in two’s complement, as does the knowledge base in our states. However, some instructions explicitly consider values in an unsigned way, and this needs to be reflected in our evaluation rules. As an example, suppose that \\( \\models \\langle a \\rangle \\Rightarrow v = -2^7 \\land w = 2^7 - 1 \\). Then signed comparison yields \\( v < w \\), but unsigned comparison yields \\( v > w \\), because \\( v \\) is stored as \\( 10000000 \\), whereas \\( w \\) is stored as \\( 01111111 \\). So for an unsigned comparison, we check whether the two values to be compared are either both positive or both negative, i.e., have the same sign. In this case, the comparison on the unsigned interpretation coincides with the signed comparison. For different signs, negative numbers (like \\( v = -2^7 \\)) are always greater than positive ones (like \\( w = 2^7 - 1 \\)). As an example, the following rule illustrates the affirmative case (\\( w = 1 \\)) of unsigned less-or-equal (ule).\n\n\\[\n\\text{icmp ule}(p:\\text{\"x = icmp ule ty t_1, t_2\" with } x \\in \\mathcal{V}_p \\text{ and } t_1, t_2 \\in \\mathcal{V}_p \\cup \\mathbb{Z})\n\\]\n\n\\[\n((p, \\mathcal{L}V_1, \\mathcal{A}L_1)\\cdot \\mathcal{C}S, \\mathcal{K}B, \\mathcal{A}L, \\mathcal{P}T)\n\\]\n\n\\[\n((p, \\mathcal{L}V_1[x := w], \\mathcal{A}L_1)\\cdot \\mathcal{C}S, \\mathcal{K}B \\cup \\{w = 1\\}, \\mathcal{A}L, \\mathcal{P}T)\n\\]\n\n\\[\n\\text{if } \\models \\langle a \\rangle \\Rightarrow (\\mathcal{L}V_1(t_1) \\leq \\mathcal{L}V_1(t_2)) \\land (\\text{sgn}(\\mathcal{L}V_1(t_1)) = \\text{sgn}(\\mathcal{L}V_1(t_2))) \\lor (\\mathcal{L}V_1(t_1) \\geq 0) \\land (\\mathcal{L}V_1(t_2) < 0)\n\\]\n\n\\[\n\\text{and } w \\in \\mathcal{V}_{\\text{sys}} \\text{ is fresh}\n\\]\n\nThe rules for \\text{icmp} are only applicable if \\( \\mathcal{K}B \\) contains enough information to evaluate the respective condition. Otherwise, a case analysis needs to be performed, i.e., one has to refine the abstract state by extending its knowledge base. This is done by the following rule, which transforms an abstract state into two new ones.\\(^7\\)\n\n\\[\n\\text{refining abstract states}(p:\\text{\"x = icmp eq ty t_1, t_2\", } x \\in \\mathcal{V}_p, t_1, t_2 \\in \\mathcal{V}_p \\cup \\mathbb{Z})\n\\]\n\n\\[\n((p, \\mathcal{L}V_1, \\mathcal{A}L_1)\\cdot \\mathcal{C}S, \\mathcal{K}B, \\mathcal{A}L, \\mathcal{P}T)\n\\]\n\n\\[\n((p, \\mathcal{L}V_1, \\mathcal{A}L_1)\\cdot \\mathcal{C}S, \\mathcal{K}B \\cup \\{\\phi\\}, \\mathcal{A}L, \\mathcal{P}T) \\mid ((p, \\mathcal{L}V_1, \\mathcal{A}L_1)\\cdot \\mathcal{C}S, \\mathcal{K}B \\cup \\{\\neg \\phi\\}, \\mathcal{A}L, \\mathcal{P}T)\n\\]\n\n\\[\n\\text{if } \\not\\models \\langle a \\rangle \\Rightarrow \\phi \\text{ and } \\not\\models \\langle a \\rangle \\Rightarrow \\neg \\phi \\text{ and } \\phi \\text{ is } \\mathcal{L}V_1(t_1) = \\mathcal{L}V_1(t_2)\n\\]\n\nIn state \\( B \\) of Fig. 1, we evaluate “\\( \\text{c0zero = icmp eq i8 c0, 0} \\)” i.e., we check if the first character \\( c0 \\) of the string \\( \\text{str} \\) is 0. Since this cannot be inferred from \\( B \\)’s knowledge base, we refine \\( B \\) to the successor states \\( C \\) and \\( D \\) and call the edges from \\( B \\) to \\( C \\) and \\( D \\) refinement edges. In \\( D \\), we have \\( c0 = v_1 \\text{ and } v_1 \\neq 0 \\). Thus, the \\text{icmp}-rule yields \\( E \\) where \\( \\text{c0zero} = v_2 \\) and \\( v_2 = 0 \\). We do not display the successors of \\( C \\) that lead to a program end.\n\nThe next instruction in our example is “\\text{br i1 c0zero, label done, label loop}”, a conditional jump (or branch) to another block. Let us first consider a similar, but simpler case. The instruction “\\text{br label bnext}” means that the execution has to continue with the first instruction in the block \\( bnext \\). When execution moves from one block to another, in the\n\n\\(^7\\) Analogous refinement rules can also be used for other conditional LLVM instructions, e.g., conditional jumps with \\text{br} or other cases of \\text{icmp}.\nnew target block one first evaluates the phi instructions that may be present at its beginning. These instructions are needed due to the static single assignment form of LLVM and initialize the variables in the target block depending on from which block we are entering the target block. Such phi instructions may only occur at the beginning of a block, i.e., every block starts with a (possibly empty) sequence of phi instructions. A phi instruction has the form “x = phi ty [t1, b1], . . . , [tn, bn],” meaning that if the previous block was bj, then the value tj is assigned to x. All t1, . . . , tn must have type ty. A peculiarity of phi instructions is that all phi instructions in the same block are executed atomically together. So all local variables occurring in t1, . . . , tn still have the values that they had before entering the new target block.\n\nTo handle phi instructions in combination with the br instruction at the end of the previous block, we introduce an auxiliary function firstNonPhi. For any block b, firstNonPhi(b) is the index of the first non-phi instruction in b. Moreover, we define the function computePhi to implement the parallel execution of all phi statements “xj = phi tyj [tj1, b1], . . . , [tjn, bn],” . . . “xm = phi tym [tm1, bm1], . . . , [tmm, bmm],” at the start of the block bnext. Its arguments are the current values LV of the local variables, the current block bj, and the target block bnext, and it returns a pair (LV′, KBphi), where LV′ reflects the updated local variables and KBphi contains information on the new symbolic variables introduced in LV′:\n\n\\[\n\\text{computePhi}(LV, b, bnext) = (LV'[x := w^1, . . . , x := w^m], \\{ w^1 = LV(t^1), . . . , w^m = LV(t^m) \\}),\n\\]\n\nwhere w1, . . . , wm ∈ Vsym are fresh. Now we can define a rule that allows us to perform an unconditional jump with br to a block bnext and that executes bnext’s phi instructions.\n\nFor conditional branches “br i1 t, label b1, label b2”, one has to check whether the current state contains enough information to conclude that t is 1 (i.e., true) or 0 (i.e., false). Then the evaluation continues after the phi instructions of block b1 resp. b2.\n\nWith the br instruction, one now jumps to the loop block in State F. Note that we simplified the equalities resulting from computePhi in F, to avoid renaming in the presentation.\n\nThe strlen function traverses the string using a pointer s, and the loop terminates when s eventually reaches the last memory cell of the string (containing 0). Then one jumps to doend, converts the pointers s and strlen to integers, and returns their difference. To perform the required pointer arithmetic, “bd = getelementptr ty*, ad, in t” increases ad by the size of t elements of type ty (i.e., by size(ty) · t) and assigns this address to bd.\\(^8\\)\n\n\\(^8\\) Since we do not consider struct data structures in this paper, we disregard getelementptr instructions with more than two parameters. Note that getelementptr instructions with just two parameters suffice for several levels of de-referencing (where memory has to be accessed after each getelementptr instruction).\nwhich may therefore violate memory safety and affect the termination behavior.\n\nThus, we update 0 computed from these given alignments. Allocating LLVM types in the header of the interface (of the target machine and operating system). The code emitter writes information\n\nIn contrast to x, moreover, the address of the first memory cell in the newly allocated block is assigned to v for fresh symbolic variables. AL is allocated (i.e., the allocation list holds because s is in an allocated part of the memory (i.e., that ustr ≤ v_end and ustr ≠ v_end (as ustr ↦ v1, v_end ↦ 0 ∈ PT and v1 ≠ 0 ∈ KB)). Finally, we check whether c is 0. We again perform a refinement which yields the states I and J. State J corresponds to the case c ≠ 0 and thus, we obtain czero = 0 in K.\n\nFinally, we present rules for the instructions ptrtoint and sub that are used in the block done of the strlen example. The ptrtoint instruction simply converts pointers to integers and is needed to perform subsequent arithmetic operations on them (e.g., to subtract one address from another in the strlen algorithm). In a similar way, we also have rules to handle other LLVM instructions for casting between pointers and different types of integers.\n\n3.2 Advanced Symbolic Execution Rules\n\nNow we also present rules that allow allocation of memory, function calls, and manipulation of larger memory chunks. We start with a rule for the alloc statement. The instruction “x = alloc ty, in t” allocates memory for t elements of the type ty Here, x is an identifier from V_p of type ty* and t is either an identifier or a natural number. Thus, a new interval is allocated (i.e., the allocation list AL of the current stack frame is extended by [v1, v2] for fresh symbolic variables v1, v2) and KB is extended by v2 = v1 + size (ty) · LV (t) − 1. Moreover, the address of the first memory cell in the newly allocated block is assigned to x. Thus, we update LV by x = v1. Again, the code emitter may have added an alignment a1. In contrast to load and store, it is not designed as a hint for the code generator but as a requirement that the result of the allocation must be at least a1-aligned. If no alignment is specified or a1 = 0, one uses the alignment align (ty) specified by the ABI (application binary interface) of the target machine and operating system. The code emitter writes information on the ABI alignment of pointers and the most common integer, vector, and floating point types in the header of the LLVM program. For all remaining types, the ABI alignment is computed from these given alignments. Allocating 0 bytes results in undefined behavior, which may therefore violate memory safety and affect the termination behavior.\n\\[\\text{alloca}(p: \"x = \\text{alloca ty, in } t \\ [\\ , \\ \\text{align } al\\) with } x \\in V_p, t \\in \\mathbb{V}_p \\cup \\mathbb{Z}, \\text{ and } al \\in \\mathbb{N})\\]\n\\[\n\\begin{align*}\n&((p, LV_1, AL_1) \\cdot CS, KB, AL, PT) \\\\\n&\\quad \\text{if } \\not\\models (a) \\Rightarrow (LV_1(t) > 0) \\\\\n&ERR\n\\end{align*}\n\\]\n\n\\[\\begin{align*}\n&((p', LV_1[x := v_1]_1, AL_1 \\cup \\{[v_1, v_2]\\}) \\cdot CS, KB' \\cup \\{v_2 = v_1 + \\text{size}(ty) \\cdot LV_1(t) - 1\\}, AL, PT) \\\\\n&\\begin{align*}\n&\\quad \\bullet \\text{ we have } \\models (a) \\Rightarrow (LV_1(t) > 0), \\\\\n&\\quad \\bullet \\text{ } KB' = KB \\cup \\{v_1 \\mod e = 0\\}, \\text{ where } e = al, \\text{ if } a1 \\geq 1 \\text{ is specified, or else } e = \\text{align}(ty), \\\\\n&\\quad \\bullet v_1, v_2 \\in V_{\\text{free}} \\text{ are fresh}\n\\end{align*}\n\\end{align*}\\]\n\nNote that \\text{alloca} is used to allocate memory on the stack, whereas \\text{malloc} and \\text{free} allocate and release memory on the heap. The latest versions of LLVM do not have built-in \\text{malloc} or \\text{free} instructions anymore, but one has to call them as external functions (provided by the standard C library). For LLVM programs that call \\text{malloc} or \\text{free}, we use the following two inference rules. The rule for \\text{malloc} mainly differs from the rule for \\text{alloca} by placing the newly allocated memory region into the global allocation list instead of the allocation list of the current stack frame. Here, \\text{\"x = call i8* \\text{malloc}(in } t\\)\" allocates } t \\text{ bytes and the address of the first memory cell in this block is assigned to } x. Depending on the processor architecture of the target machine, the allocated memory is 8-byte or 16-byte aligned. Our rule for \\text{malloc} currently does not take into account that \\text{malloc} may also return \\text{NULL} without allocating any memory. However, we could easily support this by introducing a corresponding second successor state for this possible outcome.\n\n\\[\\text{malloc}(p: \"x = \\text{call i8* \\text{malloc(in } t\\) with } x \\in V_p \\text{ and } t \\in V_p \\cup \\mathbb{Z})\\]\n\\[\n\\begin{align*}\n&((p, LV_1, AL_1) \\cdot CS, KB, AL, PT) \\\\\n&\\quad \\text{if } \\models (a) \\Rightarrow (LV_1(t) > 0) \\\\\n&\\begin{align*}\n&\\quad \\bullet \\text{ we have } \\models (a) \\Rightarrow (LV_1(t) > 0), \\\\\n&\\quad \\bullet \\text{ } KB' = KB \\cup \\{v_1 \\mod e = 0\\}, \\text{ where } e = 8 \\text{ for 32-bit platforms and } c = 16 \\text{ for 64-bit platforms}, \\\\\n&\\quad \\bullet v_1, v_2 \\in V_{\\text{free}} \\text{ are fresh}\n\\end{align*}\n\\end{align*}\\]\n\nLLVM does not explicitly distinguish between the heap and stack, but applies the same memory model for both (using \\text{load} and \\text{store}). However, memory acquired by \\text{alloca} is automatically released at the end of the function in which it was allocated, while memory acquired by \\text{malloc} has to be released explicitly by calling \\text{free}. The instruction \\text{\\texttt{call void } \\texttt{\\texttt{free}(i8* t)}\" releases the allocated memory block starting at the address } t. Moreover, it deletes those entries from } PT \\text{ which are known to correspond to this memory block. Calling } \\text{free} \\text{ on } \\text{NULL} \\text{ does not change the state. If } \\text{free} \\text{ is called with an address that is neither the beginning of an allocated memory block in the global allocation list (of memory allocated by } \\text{malloc}) \\text{ nor } \\text{NULL}, \\text{ then memory safety is violated and we reach the state } ERR.\\]\n\n\\[\\text{free}(p: \\text{\\texttt{call void } \\texttt{\\texttt{free}(i8* t)}\" with } t \\in \\mathbb{V}_p \\cup \\mathbb{Z})\\]\n\\[\n\\begin{align*}\n&((p, LV_1, AL_1) \\cdot CS, KB, AL, PT) \\\\\n&\\quad \\text{if } \\models (a) \\Rightarrow (LV_1(t) = v_1), \\\\\n&\\quad \\bullet v_1, v_2 \\in V_{\\text{free}} \\\\\n&\\quad \\bullet PT' \\text{ results from } PT \\text{ by removing all } v \\leftarrow w \\text{ where } \\models (a) \\Rightarrow v_1 \\leq v \\land v \\leq v_2\n\\end{align*}\n\\]\n\n\\[\\begin{align*}\n&((p, LV_1, AL_1) \\cdot CS, KB, AL, PT) \\\\\n&\\quad \\text{if } \\models (a) \\Rightarrow (LV_1(t) = 0) \\\\\n&ERR\n\\end{align*}\\]\n\n\\[\\begin{align*}\n&((p, LV_1, AL_1) \\cdot CS, KB, AL, PT) \\\\\n&\\quad \\text{if } \\not\\models (a) \\Rightarrow (LV_1(t) = 0), \\\\\n&\\quad \\bullet \\text{ there is no } [v_1, v_2] \\in AL \\text{ with } \\models (a) \\Rightarrow (LV_1(t) = v_1)\n\\end{align*}\\]\nTo illustrate the rules for allocating and releasing memory, assume that we call the function `strlen` within a main function with a pointer to a memory area allocated by `malloc`. The symbolic execution graph for the corresponding LLVM program is depicted in Fig. 2. The first instruction is `icmp slt`, which checks if the function argument `i` in signed interpretation is less than `1 (slt)`. Since in state $A'$, we do not have any information on `i`, we refine $A'$ to the states $B'$ and $C'$. $C'$ is then evaluated to $D'$, where the result of the comparison is assigned to `ineg`. Depending on the value of `ineg`, the select instruction assigns `1` or `i` to the variable `bytes`. In $F'$, the call of `malloc` has been evaluated: the entry $[\\text{v}_{\\text{ad}}, \\text{v}_{\\text{ad}_1}]$ is added to the global allocation list and in the knowledge base we keep the relationship between the start address `v_{ad}` and the end address `v_{ad_1}`. In $M'$, the allocated memory area is released again, leading to an empty global allocation list and an empty list $PT$ at the end of the program. The transition from $I'$ to $J'$ corresponds to a call of the function `strlen` and the transition from $K'$ to $L'$ corresponds to a return from this function.\n\nThe symbolic execution rules for the `select` instruction are analogous to the rules for `icmp`. The instructions `call` and `ret` for calling and returning from a function are needed when going beyond intraprocedural analysis. The rule for `call` pushes a new frame on the call stack whose position is the entry point of the called function and the argument values are assigned to its parameters. When the `ret` instruction is encountered, the top frame is popped from the stack again. For reasons of space, we only present the rules for non-void functions.\ncall(p: “x = call ty $function(ty_1, t_1, \\ldots, ty_n, t_n)” with $x \\in V^p, t_1, \\ldots, t_n \\in V^p \\cup Z$)\n\n\\[\n\\begin{array}{l}\n((p, \\text{LV}_1, \\text{AL}_1) : \\text{CS}, \\text{KB}, \\text{AL}, \\text{PT})\n\\end{array}\n\\]\n\nif\n\nfunction.entry is the entry block of function\n\nfunction is declared as function($ty_1, \\ldots, ty_n, u_n$).\n\n\\(w_1, \\ldots, w_n \\in V_{sym}\\) are fresh.\n\n\\(\\text{LV}(u_1) = w_1, \\ldots, \\text{LV}(u_n) = w_n\\), and \\(\\text{LV}(x)\\) is undefined for all $x \\in V^p \\setminus \\{u_1, \\ldots, u_n\\}$\n\n\\(\\text{KB} = \\text{KB} \\cup \\{w = \\text{LV}(t_{i_1}), \\ldots, w = \\text{LV}(t_{i_n})\\}\\)\n\n3.3 Generalizing Abstract States\n\nIn the strlen example and its graph in Fig. 1, after reaching $K$, one unfolds the loop once more until one reaches a state $\\bar{K}$ at position (loop, 4) again, analogous to the first iteration. To obtain finite symbolic execution graphs, we generalize our states whenever an evaluation visits a program position $(b, j)$ twice and the domains of the local variable mappings $\\text{LV}_j$ in the two states are the same. Thus, we have to find a state that is more general than $K = [(\\{p, \\text{LV}_1, \\emptyset\\}, \\text{KB}^K, \\text{AL}, \\text{PT}^K)]$ and $\\bar{K} = [(\\{p, \\text{LV}_1, \\emptyset\\}, \\bar{\\text{KB}}^K, \\text{AL}, \\bar{\\text{PT}}^K)]$. For readability, we again write “$\\rightarrow_\\text{IB}^K$” instead of “$\\rightarrow_\\text{IB}^\\text{IB}$”.\n\nThen $p = ($loop, 4$), AL = [(u_{str}, v_{end})], and\n\n\\[\n\\begin{align*}\n\\text{LV}_1^K &= \\{s_{\\text{str}} \\leftarrow u_{\\text{str}}, c_1 \\leftarrow v_5, s_1 \\leftarrow v_4, \\text{olds}_1 \\leftarrow v_3, \\ldots\\} \\\\\n\\text{PT}_1^K &= \\{u_{\\text{str}} \\leftarrow v_1, v_4 \\leftarrow v_5, v_{\\text{end}} \\leftarrow z\\} \\\\\n\\text{KB}_1^K &= \\{v_3 \\neq v_4, v_4 \\leftarrow v_3 + 1, v_3 = u_{\\text{ptr}}, v_1 \\neq 0, z = 0, \\ldots\\} \\\\\n\\bar{\\text{KB}}_1^K &= \\{v_3 \\neq v_4, v_3 \\leftarrow v_3 + 1, v_4 = v_3 + 1, v_3 = u_{\\text{ptr}}, v_1 \\neq 0, z = 0, \\ldots\\}\n\\end{align*}\n\\]\n\nOur aim is to construct a new state $L$ that is more general than $K$ and $\\bar{K}$, but contains enough information for the remaining proof. We now present our heuristic for merging states that is used in our implementation.\n\nTo merge $K$ and $\\bar{K}$, we keep those constraints of $K$ that also hold in $\\bar{K}$. To this end, we proceed in two steps. First, we create a new state $L = [(\\{p, \\text{LV}_1, \\emptyset\\}, \\text{KB}^L, \\text{AL}^L, \\text{PT}^L)]$ using fresh symbolic variables $v_2$ for all $x \\in V^p$ where $\\text{LV}_1^K$ and $\\text{LV}_1^K$ are defined. This yields\n\n\\[\n\\text{LV}_1^L = \\{s_{\\text{str}} = v_{\\text{str}}, c_1 = v_c, s_1 = v_s, \\text{olds}_1 = v_{\\text{olds}}, \\ldots\\}\n\\]\n\nWe then create mappings $\\mu_K$ (resp. $\\mu_\\bar{K}$) from $L$’s symbolic variables to their counterparts in $K$ (resp. $\\bar{K}$), i.e., $\\mu_K(v_2) = \\text{LV}_1^K(x)$ if $\\text{LV}_1^K(x)$ is defined. In our example, $\\mu_K(v_{\\text{str}}) = u_{\\text{str}}, \\mu_K(v_2) = v_2, \\mu_\\bar{K}(v_{\\text{ptr}}) = v_3, \\mu_\\bar{K}(v_2) = v_3, \\mu_\\bar{K}(v_{\\text{ptr}}) = v_3, \\mu_\\bar{K}(v_{\\text{ptr}}) = v_3$. By injectivity of $\\text{LV}_1^K$, we can also define a pseudo-inverse of $\\mu_K$ that maps $K$’s variables to $L$ by setting $\\mu_K^{-1}(\\text{LV}_1^K(x)) = v_2$ if $\\text{LV}_1^K(x)$ is defined and $\\mu_K^{-1}(v) = v$ for all other $v \\in V_{sym}$ ($\\mu_\\bar{K}^{-1}$ is analogous). So symbolic variables in $K$ and $\\bar{K}$ corresponding to the\nsame program variable are mapped to the same symbolic variable by $\\mu^{-1}_K$ and $\\mu^{-1}_{\\overline{K}}$.\n\nIn a second step, we use the mappings $\\mu^{-1}_K$ and $\\mu^{-1}_{\\overline{K}}$ to check which constraints of $K$ also hold in $\\overline{K}$. So we set $AL^L = \\mu^{-1}_K(AL) \\cap \\mu^{-1}_{\\overline{K}}(AL) = \\{ [v_{str}, v_{end}] \\}$ and\n\n$PT^L = \\mu^{-1}_K(PT^K) \\cap \\mu^{-1}_{\\overline{K}}(PT^K) = \\{ v_{vstr} \\rightarrow v_1, v_a \\rightarrow v_c, v_{vend} \\rightarrow z \\} \\cap \\{ v_{vstr} \\rightarrow v_1, v_4 \\rightarrow v_5, v_6 \\rightarrow v_c, v_{vend} \\rightarrow z \\} = \\{ v_{vstr} \\rightarrow v_1, v_a \\rightarrow v_c, v_{vend} \\rightarrow z \\}.$\n\nHere, $v_1$ is not changed by $\\mu^{-1}_K$ and $\\mu^{-1}_{\\overline{K}}$ because it is not assigned to a program variable.\n\nIt remains to construct $KB^L$. Essentially, we would like to take the intersection of those formulas that are implied by the knowledge bases of $K$ and $\\overline{K}$. So in principle, we would like to define the knowledge base of the new merged state $L$ as follows:\n\n$KB^L = \\{ \\varphi \\mid \\models K^{-1}(K) \\Rightarrow \\varphi \\text{ and } \\models K^{-1}(\\overline{K}) \\Rightarrow \\varphi \\} \\quad (1)$\n\nHowever, with this definition $KB^L$ would be an infinite set of formulas, which is not suitable for automation. Thus, we restrict the definition of $KB^L$ to a finite subset of (1) that can be automatically generated from the knowledge bases of the states $K$ and $\\overline{K}$. This restriction is only a heuristic and has no impact on the correctness, since it would already be correct to include all formulas of (1) in the knowledge base of the generalized state.\n\nOur heuristic for the restriction of (1) considers $K$’s knowledge base and extends it by certain additional formulas. This leads to a finite set $\\langle K \\rangle$. For these finitely many formulas we then check whether they are also implied by $\\langle \\overline{K} \\rangle$ (when renaming variables appropriately).\n\nMore precisely, we have $v_3 = u_{vstr}$ (“olds = str”) in $\\langle K \\rangle$, but $v_3 = v_4, v_4 = v_3 + 1, v_3 = u_{vstr}$ (“olds = str + 1”) in $\\langle \\overline{K} \\rangle$. To keep as much information as possible, we rewrite equations to inequations before performing the generalization. So let $\\langle K \\rangle$ result from extending $\\langle \\overline{K} \\rangle$ by $t_1 \\geq t_2$ and $t_1 \\leq t_2$ for any equation $t_1 = t_2 \\in \\langle \\overline{K} \\rangle$. In our example, we obtain $v_3 \\geq u_{vstr}$ in $\\langle \\overline{K} \\rangle$ (“olds = str”). Moreover, for any $t_1 \\neq t_2 \\in \\langle K \\rangle$, we check whether $\\langle K \\rangle$ implies $t_1 > t_2$ or $t_1 < t_2$, and add the respective inequation to $\\langle \\overline{K} \\rangle$. In this way, one can express sequences of inequations $t_1 \\neq t_2, t_1 + 1 \\neq t_2, \\ldots, t_1 + n \\neq t_2$ (where $t_1 \\leq t_2$) by a single inequation $t_1 + n < t_2$, which is needed for suitable generalizations afterwards. We use this to derive $v_4 < v_{end} \\in \\langle \\overline{K} \\rangle$ (“v < v_{end}”) from $v_4 = v_3 + 1, v_3 = u_{vstr}, u_{vstr} \\leq v_{end}, u_{vstr} \\neq v_{end}, v_4 \\neq v_{end} \\in \\langle K \\rangle$.\n\nWe then let $KB^L$ consist of all formulas $\\varphi$ from $\\langle K \\rangle$ that are also implied by $\\langle \\overline{K} \\rangle$, again translating variable names using $\\mu^{-1}_K$ and $\\mu^{-1}_{\\overline{K}}$. Thus, we have\n\n$\\langle K \\rangle = \\{ v_3 \\neq 0, v_4 = v_3 + 1, v_3 = u_{vstr}, v_3 \\leq u_{vstr}, v_4 < v_{end}, \\ldots \\} \\quad \\mu^{-1}_K(\\langle K \\rangle) = \\{ v_c \\neq 0, v_a = v_{olds} + 1, v_{olds} = u_{vstr}, v_{olds} \\geq v_{str}, v_a < v_{end}, \\ldots \\}$\n\n$\\langle \\overline{K} \\rangle = \\{ v_3 \\neq 0, v_4 = v_{olds} + 1, v_{olds} = u_{vstr}, v_{olds} = v_4, v_4 = v_3 + 1, v_3 = u_{vstr}, v_a < v_{end}, \\ldots \\} \\quad KB^L = \\{ v_4 \\neq 0, v_a = v_{olds} + 1, v_{olds} \\geq v_{str}, v_a < v_{end}, \\ldots \\}.$\n\nIn Fig. 1, we do not show the second loop unfolding from $K$ to $\\overline{K}$, and directly draw a generalization edge with a dashed arrow from $K$ to $L$. Such an edge expresses that all concrete states represented by $K$ are also represented by the more general state $L$. Semantically, a state $a'$ is a generalization of a state $a$ iff $\\models (a)_{L} \\Rightarrow \\mu((a')_{L})$ for some instantiation $\\mu$.\n\nIn the stricten example, we continue symbolic execution in state $L$. Similar to the execution from $F$ to $K$, after 5 steps another state $N$ at position (loop, 4) is reached. In Fig. 1, the dotted arrows from $L$ to $M$ and from $M$ to $N$ abbreviate several evaluation steps. As $L$ is again a generalization of $N$ using an instantiation $\\mu$ with $\\mu(v_c) = w_c, \\mu(v_a) = w_a$, and $\\mu(v_{olds}) = w_{olds}$, we draw a generalization edge from $N$ to $L$. The construction of a symbolic execution graph is finished as soon as all leaves have only one stack frame, which is at a\nret instruction. We call a non-empty symbolic execution graph with this property complete. In particular, a complete symbolic execution graph cannot contain an ERR state.\n\nThe approach presented so far is sufficient to prove memory safety (and together with the techniques in Sect. 5 also termination) of the strlen function, cf. Sect. 4 and 5. Up to now, when merging states we make relations between symbolic variables explicit (by adding inequations between symbolic variables). Then, these inequations are retained in the merged state if they are present in both states to be merged. In other words, these inequations restrict the state space of the represented concrete states and we want to keep as many restrictions as possible during merging in order to obtain a more precise abstraction. In some cases, however, it is also important to make relations between differences of symbolic variables explicit (e.g., about the distance between addresses). So in addition to inequations like \\( v_1 \\geq v_2 \\) or \\( v_1 > v_2 \\) in \\( \\langle K \\rangle \\), we may also add equations like \\( v_1 - v_2 = w_1 - w_2 \\) for symbolic variables \\( v_1, v_2, w_1, w_2 \\). By making these equations explicit, they can also be retained when merging states.\n\nSo far, relations established and preserved by instructions within a “loop” (i.e., a path through the program leading from some program position back to the same position) are usually retained by our merging heuristic. For example, the instruction \\( s = \\text{getelementptr} \\ i8* \\ \\text{olds}, \\ i32 \\ 1 \\) within the block \\( \\text{loop} \\) leads to the relation \\( v_4 = v_3 + 1 \\) in \\( K \\) and to the relation \\( v_4 = v_3 + 1 \\) in \\( K \\), where \\( v_4 \\) and \\( v_3 \\) correspond to the program variable \\( s \\) and \\( v_3 \\) corresponds to the program variable \\( \\text{olds} \\). Thus, the relation \\( v_5 = \\text{olds} + 1 \\) is also contained in the merged state \\( L \\) for the corresponding “merged” symbolic variables \\( v_5 \\) and \\( \\text{olds} \\).\n\nHowever, relations established before a loop may be generalized or removed during merging. As example, the instruction \\( \\text{olds} = \\phi i8* [\\text{str}, \\text{entry}], [s, \\text{loop}] \\) assigns the value of \\( \\text{str} \\) to the variable \\( \\text{olds} \\) when the block \\( \\text{loop} \\) is entered for the first time. So in the state \\( K \\), we had the relation \\( v_3 = u_{\\text{str}} \\) where the symbolic variables \\( v_3 \\) and \\( u_{\\text{str}} \\) correspond to the program variables \\( \\text{olds} \\) and \\( \\text{str} \\). Since in \\( K \\), the value of \\( \\text{olds} \\) has been increased by 1, this is generalized to the inequation \\( v_{\\text{olds}} \\geq v_{\\text{str}} \\) in the merged state \\( L \\). So by merging states, we lose the information on the exact distance between \\( \\text{olds} \\) and its initial value \\( \\text{str} \\).\n\nOf course, we need to abstract to obtain a finite representation of all evaluations. However, we might want to keep the knowledge that two distances between different symbolic variables are the same. This knowledge is necessary for a successful analysis of the strcpy function on the right (cf. [62, 72]). This function copies the string at the source address \\( s2 \\) to the destination address \\( s1 \\). The while loop of the function terminates as soon as the value 0 is reached in the source string.\n\nTo ease readability, we do not depict the full symbolic execution graph. Instead, Fig. 3 shows a graphical illustration of some key program states in the execution of strcpy. The\nDefinition 7 (Merging States) Let \\( a = ([p_1, LV_1^a, AL_1^a], ..., (p_n, LV_n^a, AL_n^a)], KB^a, AL^a, PT^a) \\), \\( b = ([p_1, LV_1^b, AL_1^b], ..., (p_n, LV_n^b, AL_n^b)], KB^b, AL^b, PT^b) \\) be abstract states. Moreover, for all \\( i \\in \\{1, ..., n\\} \\), let the domains of \\( LV_i^a \\) and \\( LV_i^b \\) coincide. Then \\( c = (CS^c, KB^c, AL^c, PT^c) \\) with \\( CS^c = ([p_1, LV_1^c, AL_1^c], ..., (p_n, LV_n^c, AL_n^c)] \\) results from merging the states \\( a \\) and \\( b \\) if\n\n- \\( LV_i^c = \\{ x_i = v_i^c \\mid x \\in V_P \\text{ where } LV_i^a(x) \\text{ is defined} \\} \\) for all \\( 1 \\leq i \\leq n \\) and fresh pairwise different symbolic variables \\( v_1^c, ..., v_n^c \\). Moreover, we define \\( \\mu_a(v_i^c) = LV_i^a(x) \\) and \\( \\mu_b(v_i^c) = LV_i^b(x) \\) for all \\( x \\in V_P \\) where \\( LV_i^a(x) \\) is defined, and we let \\( \\mu_a \\) and \\( \\mu_b \\) be the identity on all remaining variables from \\( V_{sym} \\).\n\n- \\( PT^c = \\mu_a^{-1}(PT^a) \\cap \\mu_b^{-1}(PT^b), AL^c = \\mu_a^{-1}(AL^a) \\cap \\mu_b^{-1}(AL^b), \\) and \\( AL_i^c = \\mu_a^{-1}(AL_i^a) \\cap \\mu_b^{-1}(AL_i^b) \\) for all \\( 1 \\leq i \\leq n \\). Here, the “inverse” of \\( \\mu_a \\) is defined as \\( \\mu_a^{-1}(v) = v_i^c \\) if \\( v = LV_i^a(x) \\) and \\( \\mu_a^{-1}(v) = v \\) for all other \\( v \\in V_{sym} \\) (\\( \\mu_b^{-1} \\) is defined analogously).\n\n- \\( BB^c = \\{ \\phi \\in \\mu_a^{-1}(\\langle a \\rangle) \\mid \\models \\mu_b^{-1}(\\langle b \\rangle) \\Rightarrow \\phi \\} \\), where \\( \\langle a \\rangle \\) is the smallest set such that\n\n - \\( \\{ a \\} \\subseteq \\langle a \\rangle \\)\n - \\( t_1 = t_2 \\in \\langle a \\rangle \\Rightarrow t_1 \\geq t_2, t_1 \\leq t_2 \\in \\langle a \\rangle \\)\n - \\( \\{ a \\} \\subseteq \\langle a \\rangle \\Rightarrow \\{ a \\} \\Rightarrow t_1 > t_2 \\Rightarrow t_1 > t_2 \\in \\langle a \\rangle \\)\n - \\( \\{ a, b, c \\} \\subseteq \\langle a \\rangle \\Rightarrow \\{ a \\} \\Rightarrow \\{ a \\} \\Rightarrow t_1 < t_2 \\Rightarrow t_1 < t_2 \\in \\langle a \\rangle \\)\n - \\( \\{ a, b, c \\} \\subseteq \\langle a \\rangle \\Rightarrow \\{ a \\} \\Rightarrow v_1 - v_2 = k_1 \\cdot k_2 \\land v_3 - v_4 = k_2 \\Rightarrow v_1 - v_2 = k_1 \\cdot (v_3 - v_4) \\in \\langle a \\rangle \\)\n\n for all \\( k_1, k_2 \\in \\mathbb{N} \\) with \\( k_1 > 0 \\) and all \\( v_1, v_2, v_3, v_4 \\in V_{sym}(a) \\) with \\( (v_1, v_2) \\neq (v_3, v_4) \\).\n\nNote that \\( \\langle a \\rangle \\) may contain arbitrary formulas from \\( QFJA(V_{sym}) \\) since \\( a \\subseteq \\langle a \\rangle \\). Moreover, the terms \\( t_1, t_2 \\in \\langle a \\rangle \\) are arbitrary (possibly non-linear) arithmetic terms. So our definition for \\( \\langle a \\rangle \\) is beyond those classes of formulas that are typically used in abstract interpretation (i.e., beyond octagons [57] and even polyhedra [29]). This is crucial for the success of our approach, since the conditions of programs often contain formulas that are not in these\nrestricted classes. Indeed, our definition of \\(\\langle a \\rangle\\) was very successful in our implementation.\n\nWe now define a rule to compute generalization edges automatically. Recall that semantically, a state \\(a'\\) is a generalization of a state \\(a\\) if \\(\\models \\langle a \\rangle_{SL} \\Rightarrow \\mu(\\langle a' \\rangle_{SL})\\) for some instantiation \\(\\mu\\). To automate our procedure, we define a weaker relationship between \\(a\\) and \\(a'\\). We say that \\(a' = (CS', KB', AL', PT')\\) is a generalization of \\(a = (CS, KB, AL, PT)\\) with the instantiation \\(\\mu\\) whenever the conditions (b) – (f) of the following rule are satisfied. Again, let \\(a\\) denote the state before the generalization step (i.e., above the horizontal line of the rule) and let \\(a'\\) be the state resulting from the generalization (i.e., below the line).\n\n\\[\n\\text{generalization with } \\mu\n\\]\n\n\\[\n((|p_1, LV_1', AL_1|, \\ldots, (p_n, LV_n', AL_n|), KB, AL, PT)\n\\]\n\n\\[\n\\left((|p_1, LV_1', AL_1'|, \\ldots, (p_n, LV_n', AL_n'|), KB', AL', PT')\\right)\n\\]\n\nif\n\n- (a) \\(a\\) has an incoming evaluation edge,\\(^9\\)\n- (b) \\(LV_i\\) and \\(LV_i'\\) have the same domain and \\(LV_i'(x) = \\mu(LV_i'(x))\\) for all \\(1 \\leq i \\leq n\\) and all \\(x \\in V\\) where \\(LV_i\\) and \\(LV_i'\\) are defined.\n- (c) \\(\\models (a) \\Rightarrow \\mu(KB')\\).\n- (d) if \\(v_1, v_2 \\in AL'\\), then \\([\\mu(v_1), \\mu(v_2)] \\in AL\\).\n- (e) if \\(v_1, v_2 \\in AL'\\), then \\([\\mu(v_1), \\mu(v_2)] \\in AL\\) (for all \\(1 \\leq i \\leq n\\)),\n- (f) if \\(v_1 \\rightarrow_{\\gamma_1} v_2 \\in PT'\\), then \\((\\mu(v_1) \\rightarrow_{\\gamma_1} \\mu(v_2)) \\in PT\\)\n\nThe above rule does not refer to the merging of states in Def. 7, but it introduces a general form of “generalizations”. The correctness of this rule is obvious, as it clearly implies \\(\\models \\langle a \\rangle_{SL} \\Rightarrow \\mu(\\langle a' \\rangle_{SL})\\). Condition (a) is needed to avoid cycles of refinement and generalization steps in the symbolic execution graph, which would not correspond to any computation.\n\nOf course, many approaches are possible to compute such generalizations. Thm. 8 shows that the merging heuristic from Def. 7 satisfies the conditions of the generalization rule. So if a state \\(c\\) results from merging \\(a\\) and \\(b\\), then \\(c\\) is indeed a generalization of both \\(a\\) and \\(b\\).\n\nThm. 8 also shows that if one uses the merging heuristic for generalizations, then the construction of symbolic execution graphs always terminates when applying the following strategy:\n\n(1) If \\(b\\) is the next state to evaluate symbolically and there is a path from some state \\(a\\) to \\(b\\), where \\(a\\) and \\(b\\) are at the same program position, the domains of all functions \\(LV\\) in \\(a\\) are equal to the domains of the corresponding functions \\(LV\\) in \\(b\\), \\(b\\) has an incoming evaluation edge, and \\(a\\) has no incoming refinement edge, then:\n\n(1a) If \\(a\\) is a generalization of \\(b\\) (i.e., the corresponding conditions of the generalization rule are satisfied), then we draw a generalization edge from \\(b\\) to \\(a\\). Here, any SMT solver can be used to prove Condition (c) of the “generalization” rule.\n\n(1b) Otherwise, remove \\(a\\)’s children, and add a generalization edge from \\(a\\) to the merging \\(c\\) of \\(a\\) and \\(b\\). If \\(a\\) already had an incoming generalization edge from some state \\(q\\), then remove \\(a\\) and add a generalization edge from \\(q\\) to \\(c\\) instead.\n\n(2) Otherwise, just evaluate \\(b\\) symbolically as usual, applying refinements when needed.\n\n**Theorem 8 (Soundness and Termination of Merging)** Let \\(c\\) result from merging the states \\(a\\) and \\(b\\) as in Def. 7. Then \\(c\\) is a generalization of \\(a\\) and \\(b\\) with the instantiations \\(\\mu_a\\) and \\(\\mu_b\\), respectively. Moreover, if \\(a\\) is not already a generalization of \\(b\\), and \\(n\\) is the height of the call stacks in \\(a\\), \\(b\\), and \\(c\\), then \\(|\\langle c \\rangle| + (\\sum_{i \\leq j < n} |AL_i'|) + |AL'| + |PT'| < |\\langle a \\rangle| + (\\sum_{i \\leq j < n} |AL_i'|) + |AL'| + |PT'|\\). Here, for any conjunction \\(\\varphi\\), let \\(|\\varphi|\\) denote the number of its conjuncts. Thus, the above strategy to construct symbolic execution graphs always terminates.\n\n**Proof** To show that \\(c\\) is a generalization of \\(a\\) and \\(b\\) with the instantiations \\(\\mu_a\\) and \\(\\mu_b\\), we have\n\n\\(^9\\) Evaluation edges are edges that are not refinement or generalization edges.\nto prove that the conditions (b) – (f) of the generalization rule are satisfied. By definition, \n\\(LV^i_\\varphi(x) = \\mu_i(LV^i_\\varphi(x))\\) and \\(LV^0_\\varphi(x) = \\mu_0(LV^1_\\varphi(x))\\) for all \\(1 \\leq i \\leq n\\) and all \\(x \\in V_\\varphi\\), which proves (b). Moreover, for \\([v_1, v_2] \\in AL^\\varphi\\), we have \\([v_1, v_2] \\in \\mu_i(\\mu_0(AL^\\varphi))\\) and \\([v_1, v_2] \\in \\mu_i(AL^\\varphi)\\). This implies \\([\\mu_i(v_1), \\mu_i(v_2)] \\in AL^\\varphi\\) and \\([\\mu_0(v_1), \\mu_0(v_2)] \\in AL^\\varphi\\), which proves (d). Condition (e) on \\(AL^\\varphi\\) and condition (f) on \\(PT^\\varphi\\) can be proved in a similar way.\n\nIt remains to prove (c). As \\(KB^\\varphi \\subseteq \\mu_1^{-1}(\\langle a \\rangle)\\), we have \\(\\langle \\varphi \\rangle \\models \\mu_1(\\langle a \\rangle)\\) and therefore also \\(\\models \\langle a \\rangle \\Rightarrow \\mu_1(\\langle a \\rangle)\\). Moreover, as \\(\\models \\mu_1^{-1}(\\langle b \\rangle) \\Rightarrow \\varphi\\) holds for all \\(\\varphi \\in KB^\\varphi\\), we also obtain \\(\\models \\langle b \\rangle \\Rightarrow \\mu_2(\\langle b \\rangle)\\). Note that we even have \\(\\models \\langle a \\rangle \\Rightarrow \\mu_0(\\langle c \\rangle)\\) and \\(\\models \\langle b \\rangle \\Rightarrow \\mu_0(\\langle c \\rangle)\\).\n\nFinally, we show that \\(\\langle c \\rangle \\models (\\sum_{1 \\leq i \\leq n} |AL^\\varphi_i|) + |AL^\\varphi| + |PT^\\varphi| < |\\langle a \\rangle| + (\\sum_{1 \\leq i \\leq n} |AL^\\varphi_i|) + |AL^\\varphi| + |PT^\\varphi|\\) if \\(a\\) is not a generalization of \\(b\\).\n\nWe first show that \\(\\langle c \\rangle \\models (\\langle a \\rangle)\\). The reason is that whenever there is a \\(t_1 \\neq t_2 \\in \\langle c \\rangle\\), then \\(t_1 \\neq t_2 \\in \\mu_1^{-1}(\\langle a \\rangle)\\) and thus also \\(t_1 \\geq t_2, t_2 \\leq t_2 \\in \\mu_1^{-1}(\\langle a \\rangle)\\). As \\(\\models \\mu_1^{-1}(\\langle b \\rangle) \\Rightarrow t_1 \\geq t_2\\) also implies \\(\\models \\mu_1^{-1}(\\langle b \\rangle) \\Rightarrow t_1 \\geq t_2\\) and \\(\\models \\mu_1^{-1}(\\langle b \\rangle) \\Rightarrow t_2 \\leq t_2\\), we also have \\(t_1 \\geq t_2, t_2 \\leq t_2 \\in \\langle c \\rangle\\). Moreover, suppose that \\(t_1 \\neq t_2 \\in \\langle c \\rangle\\) and \\(\\models \\langle c \\rangle \\Rightarrow t_1 \\geq t_2\\). This implies \\(\\models \\mu_1^{-1}(\\langle a \\rangle) \\Rightarrow t_1 > t_2\\) (i.e., \\(t_1 > t_2 \\in \\mu_1^{-1}(\\langle a \\rangle)\\)) and \\(\\models \\mu_1^{-1}(\\langle b \\rangle) \\Rightarrow t_1 > t_2\\). Hence, we also obtain \\(t_1 > t_2 \\in \\langle c \\rangle\\).\n\nThe case where \\(t_1 \\neq t_2 \\in \\langle c \\rangle\\) and \\(\\models \\langle c \\rangle \\Rightarrow t_1 \\geq t_2\\) is analogous. Finally, consider the case that \\(\\models \\langle c \\rangle \\Rightarrow v_1 - v_2 = k_1 \\cdot k_2 \\land v_3 - v_4 = k_3\\) holds for some \\(k_1, k_2, k_3 \\in \\mathbb{N}\\) and \\(v_1, v_2, v_3, v_4 \\in V_{sym}(c)\\) with \\(v_1, v_2 \\neq (v_3, v_4)\\). Since \\(\\models \\langle a \\rangle \\Rightarrow \\mu_0(\\langle c \\rangle)\\), we also have \\(\\models \\mu_0(v_1 - v_2 = k_1 \\cdot (v_1 - v_4) \\in \\langle a \\rangle, i.e., (v_1 - v_2 = k_1 \\cdot (v_1 - v_4) \\in \\mu_0^{-1}(\\langle a \\rangle)\\). Moreover, due to \\(\\models \\langle b \\rangle \\Rightarrow \\mu_0(\\langle c \\rangle)\\) we have \\(\\models \\mu_0^{-1}(\\langle b \\rangle) \\Rightarrow v_1 - v_2 = k_1 \\cdot (v_1 - v_4)\\). This implies \\(v_1 - v_2 = k_1 \\cdot (v_1 - v_4) \\in KB^\\varphi \\subseteq \\langle c \\rangle\\).\n\nNext note that \\(\\langle c \\rangle \\models KB^\\varphi\\). Again the reason is that for any \\(\\varphi \\in \\langle c \\rangle\\) we have \\(\\varphi \\in \\mu_0^{-1}(\\langle c \\rangle)\\) and \\(\\models \\mu_0^{-1}(\\langle b \\rangle) \\Rightarrow \\varphi\\). Thus, we only have to show that \\(\\mbox{KB}^\\varphi = \\left(\\sum_{1 \\leq i \\leq n} |AL^\\varphi_i|\\right) + |AL^\\varphi| + |PT^\\varphi| < |\\langle a \\rangle| + \\left(\\sum_{1 \\leq i \\leq n} |AL^\\varphi_i|\\right) + |AL^\\varphi| + |PT^\\varphi|\\). From the definition, it is obvious that we always have \\(|KB^\\varphi| \\leq |\\langle a \\rangle|, |AL^\\varphi| \\leq |AL^\\varphi|, |AL^\\varphi| \\leq |AL^\\varphi|\\) for all \\(1 \\leq i \\leq n\\) and \\(|PT^\\varphi| \\leq |PT^\\varphi|\\).\n\nHence, it suffices to show that \\(|KB^\\varphi| = |\\langle a \\rangle|, |AL^\\varphi| = |AL^\\varphi|, |AL^\\varphi| = |AL^\\varphi|\\) for all \\(1 \\leq i \\leq n\\) and \\(|PT^\\varphi| = |PT^\\varphi|\\), then \\(a\\) would be a generalization of \\(b\\) with the instantiation \\(\\mu_0 \\circ \\mu_1^{-1}\\). To see this, note that we have \\(LV^i_\\varphi(x) = \\mu_0(LV^i_\\varphi(x)) = \\mu_0(\\mu_0^{-1}(LV^i_\\varphi(x)))\\), i.e., condition (b) of the generalization rule is satisfied. Clearly, \\(|AL^\\varphi| = |AL^\\varphi|\\) means that \\(\\mu_1^{-1}(AL^\\varphi) = \\mu_1^{-1}(AL^\\varphi)\\). Thus, if \\([v_1, v_2] \\in AL^\\varphi\\), then \\(\\mu_1^{-1}(v_1), \\mu_1^{-1}(v_2) \\in \\mu_1^{-1}(AL^\\varphi) = \\mu_0(\\mu_0^{-1}(AL^\\varphi))\\) and hence, \\(\\mu_0(\\mu_1^{-1}(v_1)), \\mu_0(\\mu_1^{-1}(v_2)) \\in AL^\\varphi\\), which shows condition (d). Conditions (e) and (f) follow from \\(AL^\\varphi = |AL^\\varphi|\\) resp. \\(|PT^\\varphi| = |PT^\\varphi|\\) for similar reasons. Finally, \\(|KB^\\varphi| = |\\langle a \\rangle|\\) means that for all \\(\\varphi \\in \\mu_0^{-1}(\\langle a \\rangle)\\), we have \\(\\models \\mu_0^{-1}(\\langle b \\rangle) \\Rightarrow \\varphi\\). Let \\(\\psi \\in \\mu_0(\\mu_0^{-1}(KB^\\varphi))\\). Then we have \\(\\models \\mu_0^{-1}(\\psi) \\in \\mu_0^{-1}(KB^\\varphi) \\subseteq \\mu_0^{-1}(\\langle a \\rangle)\\). Hence, we can infer \\(\\models \\mu_0^{-1}(\\langle b \\rangle) \\Rightarrow \\mu_0^{-1}(\\psi)\\), which implies \\(\\models \\langle b \\rangle \\Rightarrow \\psi\\), cf. condition (c).\n\n\\[\\square\\]\n\n4 Correctness of Symbolic Execution\n\nWe now prove the correctness of our approach in Sect. 2 and 3, i.e., that our symbolic execution graphs represent an over-approximation of all concrete program runs. We proceed in two stages, as depicted graphically in Fig. 4. This proof structure is inspired by the correctness proof of our termination technique for Java w.r.t. a suitable formal semantics [11]. First, we relate the formal definition of the LLVM semantics from the Velvm project [73] to our semantics \\(\\rightarrow_{LLVM}\\) of LLVM from Sect. 2 and 3 that we use for program analysis. Here, \\(\\rightarrow_{LLVM}\\) is defined by applying our symbolic execution rules of Sect. 3 to concrete states. Only for rules that deal with memory access (via load, store, alloca, or malloc), our symbolic execution rules have to be adapted slightly. This is necessary since the concrete rules essentially have to implement an LLVM interpreter. For example, in a concrete state we know the size of an allocated memory block in \\(AL^*\\) (say, \\(n\\) bytes). Thus, the concrete rules put \\(n\\) entries for this block into \\(PT\\) to track the contents of all currently allocated memory. In\nour abstract rules, the size of an allocated memory block may be unknown, and thus, we do not know how many \\( \\rightarrow_{\\text{LLVM}} \\)-entries to add to \\( PT \\). Hence, we can only represent a part of the memory contents in \\( PT \\). Similarly, our symbolic execution can abstract information when a \\texttt{store} operation partially overwrites a multi-byte value. However, for the concrete semantics \\( \\rightarrow_{\\text{LLVM}} \\), we need to keep track of each allocated byte of memory. See [3] for the four cases where our rules for the abstract semantics need to be adapted for the concrete semantics.\n\n\\texttt{Vellvm} is a formalization of \\( \\text{LLVM} \\) in the Coq [7] theorem prover. In this subsection, we only regard programs over the fragment supported by our rules. While \\texttt{Vellvm}'s non-deterministic semantics \\( \\text{LLVM}_D \\) returns \\texttt{undef} (which we currently do not support) for a \\texttt{load} from uninitialized allocated memory, its deterministic semantics \\( \\text{LLVM}_D \\) returns the value 0. Thus, we use the semantics \\( \\text{LLVM}_D \\) and denote its transition relation by \\( \\rightarrow_{\\text{Vellvm}} \\).\n\nFor our proof, we define a relation \\( \\text{TRANS} \\) between \\texttt{Vellvm} states and concrete states in our representation. Thm. 9 will state that for every evaluation step \\( v_1 \\rightarrow_{\\text{Vellvm}} v_2 \\) with \\( \\text{TRANS}(v_1, c_1) \\), there is a \\( c_2 \\) with \\( \\text{TRANS}(v_2, c_2) \\) such that \\( c_1 \\rightarrow_{\\text{LLVM}} c_2 \\) holds. Moreover, if \\texttt{Vellvm}'s execution gets stuck in a state \\( v \\) (i.e., if the next instruction to execute would violate memory safety, denoted \\( \\text{Stuck}(v) \\)) and \\( \\text{TRANS}(v, c) \\), then we have \\( c \\rightarrow_{\\text{LLVM}} \\text{ERR} \\). So the idea is that we can “replay” any \\texttt{Vellvm} execution as an execution on our concrete states. In a second step, we relate symbolic execution on abstract states to evaluation on concrete states. Thm. 10 states that if some concrete state \\( c_1 \\) is represented by a state \\( a_1 \\) in a symbolic execution graph (denoted by “\\( \\text{repr} \\)\" in Fig. 4) and \\( c_1 \\rightarrow_{\\text{LLVM}} c_2 \\), then the graph contains a path from \\( a_1 \\) to a state \\( a_2 \\) in the symbolic execution graph such that \\( a_2 \\) represents \\( c_2 \\).\n\nTogether, Thm. 9 and Thm. 10 show that symbolic execution graphs simulate \\texttt{Vellvm} execution, and hence, they imply the soundness of our technique for analyzing memory safety w.r.t. the \\texttt{Vellvm} semantics of \\( \\text{LLVM} \\): Suppose that there is an \\( \\text{LLVM} \\)-computation \\( v_1 \\rightarrow_{\\text{Vellvm}} v_2 \\rightarrow_{\\text{Vellvm}} \\cdots \\rightarrow_{\\text{Vellvm}} v_n \\) with \\( \\text{Stuck}(v_n) \\) and \\( v_1 \\) is represented in the symbolic execution graph (i.e., there is a state \\( a_1 \\) in the graph with \\( \\text{TRANS}(v_1, c_1) \\) and \\( c_1 \\) is represented by \\( a_1 \\)). Then by Thm. 9 there is a symbolic evaluation \\( c_1 \\rightarrow_{\\text{LLVM}} c_2 \\rightarrow_{\\text{LLVM}} \\cdots \\rightarrow_{\\text{LLVM}} c_n \\rightarrow_{\\text{LLVM}} \\text{ERR} \\), where \\( \\text{TRANS}(v_i, c_i) \\) holds for all \\( i \\). Hence, Thm. 10 implies that the symbolic execution graph also contains a path from the state \\( a_1 \\) to an \\text{ERR} node.\n\nThm. 9 and 10 can also be used as a basis for the certification of termination proofs for \\( \\text{LLVM} \\). Several certifiers were developed to check the soundness of automatically generated termination proofs for \\textit{term rewrite systems} [8, 25, 69]. The correctness of these certifiers has been formally proved using Coq [7] or Isabelle/HOL [60]. To certify termination proofs for \\( \\text{LLVM} \\), one could build upon \\texttt{Vellvm} by formalizing and proving the soundness of our symbolic execution (Thm. 9 and 10) within Coq or Isabelle. Building on that, one could then formalize our approach to generate integer transition systems from the symbolic execution graph (Thm. 13 in Sect. 5) and one would also have to formalize the techniques used to prove termination of these ITSs. Steps in this direction are currently investigated within the certifier \\texttt{GeVA} [69], which can already be directly coupled with AP\\textsc{rove} [38, Sect. 3].\n\n\\footnote{This step corresponds to other work for machine-checked abstract interpreters [9, 17, 46].}\nVellvm’s representation of (concrete) program states is similar to our Def. 3. The main difference is that Vellvm does not use symbolic variables since its program states are not designed for symbolic execution. This was also our main reason for developing a new representation for program states. We now express Vellvm’s representation in our terminology.\n\n**Vellvm States.** A Vellvm state has the form \\((M, \\Sigma)\\) for a memory state \\(M\\) and a list of stack frames \\(\\Sigma\\) which is analogous to our call stack \\(CS\\). In a stack frame \\(\\Sigma = (\\text{fid}, b, \\overline{\\text{tmn}}, \\Delta, \\alpha)\\), \\(\\text{fid}\\) is the id of the current function, \\(b\\) is the label of the current basic block, \\(\\overline{\\text{tmn}}\\) are the remaining instructions to be executed in the current block, with \\(\\text{tmn}\\) as the terminator of the block (its last command). Together, these components correspond to our position \\(p = (b, j)\\) in the program where the command sequence \\(\\overline{\\text{tmn}}\\) begins in block \\(b\\) at line \\(j\\). Recall that we assume block labels to be different across different functions. Thus, we do not need to represent \\(\\text{fid}\\) explicitly in our states. The component \\(\\Delta\\) keeps track of the values of the local variables of the block and corresponds to our functions \\(LV\\). The final component \\(\\alpha\\) (roughly) corresponds to our lists \\(AL\\), and keeps track of the memory blocks allocated by the current stack frame that are released automatically when the current function returns.\n\nVellvm does not use absolute memory addresses, but pairs of a memory-block identifier (a number which is increased in each allocation) and an offset in that block. We say that a block identifier is valid if the corresponding memory block has been allocated and not yet released. In a Vellvm memory state \\(M = (N, B, C)\\), \\(N\\) denotes the number of the next fresh memory block to allocate, \\(B\\) is a partial map from valid block identifiers to the size of the blocks (like our entries \\([v_1, v_2] \\in AL^*\\) with size \\(v_2 - v_1 + 1\\), and \\(C\\) is a partial map from pairs of a valid block identifier and an offset in that block to values (similar to our \\(PT\\)).\n\nVellvm represents values in three ways. For integers, \\(\\text{mb}(sz, \\text{byte})\\) represents the memory content \\(\\text{byte}\\) and the bit-width \\(sz\\) of the overall integer (but not the position in the integer that this byte corresponds to). We represent similar information in \\(PT\\). For uninitialized memory cells, the pseudo-value \\(\\text{muninit}\\) is used, which stands for the value 0 in the semantics \\(\\text{LLVM}_D\\).\n\nFor pointers, Vellvm uses \\(\\text{mptr}(blk, ofs, idxs)\\), where the block \\(blk\\) and offset \\(ofs\\) characterize the pointer’s target, and the index \\(idxs\\) indicates which of the bytes of the pointer is represented.\n\n**Translation \\texttt{TRANS}**. We now define a translation relation \\texttt{TRANS} between Vellvm states and concrete states. The reason why \\texttt{TRANS} is a relation instead of a function is that in contrast to us, Vellvm represents blocks of memory by their size and an identifier number but without absolute addresses. So for a Vellvm state \\(v\\), we want to describe all concrete states (cf. Def. 3) \\(c = (CS, KB, AL, PT)\\) where \\texttt{TRANS}(\\(v, c\\)) holds.\n\nConsider a Vellvm memory state \\(M = (N, B, C)\\). To assign start and end addresses for its memory blocks, we relate \\(M\\) to any memory allocation \\(AL^*\\) of blocks of the same sizes. So we require \\(AL^* = \\{ [v_{blk}, w_{blk}] | B(\\text{blk}) \\text{ is defined} \\}\\) with \\(\\implies KB \\Rightarrow w_{blk} - v_{blk} = B(\\text{blk}) - 1\\) where \\(v_{blk}\\) and \\(w_{blk}\\) are pairwise different symbolic variables for all \\(\\text{blk}\\) where \\(B(\\text{blk})\\) is defined.\n\nTo handle actual memory contents, we consider the values of \\(C(\\text{blk}, ofs)\\) and introduce fresh symbolic variables such that \\(PT = \\{ x_{(blk, ofs)} | \\text{C(blk, ofs) is defined} \\}\\). The value for the address \\(x_{(blk, ofs)}\\) is obtained by adding \\(ofs\\) to the corresponding symbolic variable \\(v_{blk}\\) for the start of the block \\(blk\\). So we require \\(\\implies KB \\Rightarrow x_{(blk, ofs)} = v_{blk} + ofs\\) whenever \\(C(\\text{blk}, ofs)\\) is defined. Moreover, \\(KB\\) must contain knowledge about the values stored in memory. If \\(C(\\text{blk}, ofs) = \\text{muninit}\\), then \\(y_{(blk, ofs)} = 0\\) according to the deterministic semantics \\(\\text{LLVM}_D\\). If \\(C(\\text{blk}, ofs) = \\text{mb}(sz, byte)\\), we require \\(\\implies KB \\Rightarrow y_{(blk, ofs)} = \\text{byte}\\). Here, we assume that \\(byte\\) is already represented as a signed integer from \\([-2^{j}, 2^{j} - 1]\\). Similarly, if \\(C(\\text{blk}, ofs) = \\text{mptr}(blk', ofs', idxs)\\), then \\(KB\\) must contain the knowledge that \\(y_{(blk, ofs)}\\) is the \\(idxs\\)’s byte of the value forming the address \\(v_{blk'} + ofs'\\) (this byte is obtained as in Def. 5).\nFinally, we relate Vellvm’s call stack \\( \\Sigma = [f_r_1, \\ldots, f_r_n] \\) with \\( f_r_i = (\\text{fid}_i, \\text{b}_i, c_i^\\tau, \\text{tmn}_i, \\Delta_i, \\alpha_i) \\) to a call stack \\( CS = [(p_1, LV_1, AL_1), \\ldots, (p_n, LV_n, AL_n)] \\) for our concrete state. For any \\( 1 \\leq i \\leq n \\), let \\( p_i = (b, j_i) \\), where \\( j_i \\) is the position in the block \\( b_i \\) where the command sequence “\\( c_i^\\tau, \\text{tmn}_i \\)” begins. Moreover, \\( LV_i(x) \\) is defined iff \\( \\Delta_i(x) \\) is defined. In this case, \\( LV_i(x) \\) is a fresh symbolic variable with \\( \\models KB \\Rightarrow LV_i(x) = \\Delta_i(x) \\). To determine \\( AL_1, \\ldots, AL_n, \\) and \\( AL \\), we define \\( AL_i = \\{ [v_{blk}, w_{blk}] \\mid blk \\in \\alpha_i \\} \\) for \\( 1 \\leq i \\leq n \\) and \\( AL = AL_i \\cup \\bigcup_{1 \\leq i \\leq n} AL_i \\).\n\n**Evaluation Rules.** We now show that our evaluation \\( \\rightarrow_{\\text{Vellvm}} \\) simulates \\( \\rightarrow_{\\text{Vellvm}} \\). For reasons of space, we only demonstrate this for one Vellvm evaluation rule from [73], adapted to our notation. In the following rule for \\( \\text{br} \\), \\( \\text{eval}(\\Delta, t) \\) evaluates \\( t \\) according to \\( \\Delta \\). Vellvm uses an operation findblock to obtain the block \\( b_i \\) with the instructions \\( \\phi_i \\cdot \\text{cmd}_1 \\cdot \\text{tmn}_1 \\). Here, \\( \\phi_i \\) are the \\( \\phi \\) instructions of the block \\( b_i \\). This operation is implicit in our rules. Similar to our \\( \\text{br} \\) rules, compute\\( \\phi_i \\cdot \\text{cmd}_1 \\cdot \\text{tmn}_1 \\) yields a new mapping \\( \\Delta' \\) for the local variables according to the \\( \\phi \\) instructions \\( \\phi_i \\) in the target block \\( b_i \\).\n\n\\[\n\\begin{align*}\n\\text{br}\\_true\\_tmn: \\text{br} \\ i1 \\ t, \\text{label} \\ b_1, \\text{label} \\ b_2 & \\text{ with } t \\in \\mathcal{V}_P \\cup \\{0,1\\} \\text{ and } b_1, b_2 \\in \\text{Blks} \\\\\n& \\quad M, (\\text{fid}_i, b_i, [\\cdot, \\text{tmn}_i, \\Delta, \\alpha]) \\cdot \\Sigma \\rightarrow M, (\\text{fid}_i, b_i, \\text{cmd}^\\tau_1, \\text{tmn}_1, \\phi_i \\cdot \\text{cmd}_1 \\cdot \\text{tmn}_1, \\Delta', \\alpha) \\cdot \\Sigma \\\\\n& \\quad \\text{if } \\phi_i \\cdot \\text{cmd}_1 \\cdot \\text{tmn}_1 \\end{align*}\n\\]\n\nThm. 9 shows that our evaluation rules on concrete states correspond to evaluation w.r.t. Vellvm. As mentioned, here we only consider the LLVM fragment handled by our rules and in addition, we assume that a load operation for a type \\( \\text{in} \\) with \\( n \\mod 8 \\neq 0 \\) is only performed for values that were written by a store of type \\( \\text{in} \\). Similarly, we assume that values written by a store operation for a type \\( \\text{in} \\) with \\( n \\mod 8 \\neq 0 \\) will only be read by a load of the same type. The reason is that for simplicity, our concrete states do not keep track of the type with which a store operation was performed. Therefore, we cannot distinguish whether a later load of, e.g., an \\( 120 \\) value should yield the contents of the memory cell or an unknown value. Our abstract domain over-estimates such incompatible reads by an unknown value.\n\n**Theorem 9 (Simulating Vellvm by Evaluation of Concrete States)** Let \\( \\mathcal{P} \\) be an LLVM program. For all Vellvm states, \\( v \\rightarrow_{\\text{Vellvm}} \\tau \\) implies that for any concrete state \\( c \\) with \\( \\text{trans}(v,c) \\) there exists a concrete state \\( \\tau' \\) with \\( \\text{trans}(\\tau, \\tau') \\) such that \\( c \\rightarrow_{\\text{LLVM}} \\tau' \\). Moreover, if \\( \\text{Stack}(v) \\) holds, then \\( \\text{trans}(v,c) \\) implies \\( c \\rightarrow_{\\text{LLVM}} \\text{ERR} \\).\n\n**Proof** We show the simulation of Vellvm’s rule \\( \\text{br}\\_true\\_tmn \\) by our corresponding rule. The other cases are analogous. Let \\( v = (M, (\\text{fid}_i, b_i, [\\cdot, \\text{tmn}_i, \\Delta, \\alpha]) \\cdot \\Sigma) \\) and \\( \\tau = (M, (\\text{fid}_i, b_i, \\text{cmd}^\\tau_1, \\text{tmn}_1, \\phi_i \\cdot \\text{cmd}_1 \\cdot \\text{tmn}_1, \\Delta', \\alpha) \\cdot \\Sigma) \\) such that \\( v \\rightarrow_{\\text{Vellvm}} \\tau \\) holds by the rule \\( \\text{br}\\_true\\_tmn \\). Assume that we have \\( \\text{trans}(v,c) \\) for \\( c = ((b, j_i), LV_1, AL_1) \\cdot CS, KB, AL, PT \\). As \\( \\text{br}\\_true \\) is applicable to \\( v \\), we know \\( \\text{eval}(\\Delta, t) = 1 \\) and hence \\( t = 1 \\) or \\( t \\in \\mathcal{V}_P \\) with \\( \\Delta(t) = 1 \\), implying \\( \\models (c) \\Rightarrow LV_1(t) = 1 \\). Thus, we can apply our rule for “\\( \\text{br} \\ i1 \\ t, \\text{label} \\ b_1, \\text{label} \\ b_2 \\)” to \\( c \\) and obtain \\( c \\rightarrow_{\\text{LLVM}} \\tau \\) for a state \\( \\tau = ((b_1, j_1), LV_1', AL_1) \\cdot CS, KB \\cup KB_{\\phi_1}, AL, PT \\) with \\( (LV_1', KB_{\\phi_1}) = \\text{computePhi}(LV_1, b_1, j_1) \\) and \\( j_1 = \\text{firstNonPhi}(b_1) \\).\n\nIt remains to prove that \\( \\text{trans}(\\tau, \\tau') \\) holds. Note that \\( (b_1, j_1) \\) with \\( j_1 = \\text{firstNonPhi}(b_1) \\) corresponds exactly to the position where “\\( \\text{cmd}^\\tau_1, \\text{tmn}_1 \\)” begins in \\( b_1 \\). Moreover, the components of \\( AL' \\), \\( PT \\), and \\( M \\) do not change in the steps \\( c \\rightarrow_{\\text{LLVM}} \\tau \\) and \\( v \\rightarrow_{\\text{Vellvm}} \\tau \\). The computations for the \\( \\phi_1 \\) instructions are analogous in both settings, i.e., from \\( \\models (c) \\Rightarrow LV_1(t) = \\Delta(x) \\) we get \\( \\models (\\tau') \\Rightarrow LV_1'(t) = \\Delta'(x) \\) for all \\( x \\), where \\( \\Delta' = \\text{computePhi}(\\Delta, b_1, j_1) \\). \\( \\square \\)\nWe now show that evaluation of concrete states with $\\rightarrow_{\\text{LLVM}}$ can be simulated by symbolic execution of abstract states. Together with Thm. 9, this proves that our symbolic execution correctly simulates LLVM according to the semantics of Vellvm, cf. Fig. 4.\n\n**Theorem 10 (Simulating Evaluation of Concrete States by Abstract States)** Let $\\mathcal{P}$ be an LLVM program with a complete symbolic execution graph $\\mathcal{G}$. Let $c$ be a concrete state that is represented by some abstract state $a$ in $\\mathcal{G}$. Then $c \\rightarrow_{\\text{LLVM}} \\tau$ implies that there is a path from $a$ to an abstract state $\\overline{a}$ in $\\mathcal{G}$ such that $\\tau$ is represented by $\\overline{a}$.\n\n**Proof** Let $c \\rightarrow_{\\text{LLVM}} \\tau$, where $c$ is represented by a state $a$ in the graph $\\mathcal{G}$, i.e., $(\\text{as}, \\text{mem}) \\models \\sigma((a)_{\\text{SL}})$ for some concrete instantiation $\\sigma$. Then $\\tau$ is also represented by a state in $\\mathcal{G}$:\n\n(a) If $a$ has an outgoing evaluation edge to $\\sigma$, then $(\\text{as}, \\text{mem}) \\models \\overline{\\sigma}((\\overline{a})_{\\text{SL}})$ for a concrete instantiation $\\overline{\\sigma}$ with $\\overline{\\sigma}(v) = \\sigma(v)$ for all $v \\in \\mathcal{V}_{\\text{sym}}(a)$. This is trivial for all rules except those for load, store, alloca, and malloc, since the same rules are applied to the concrete and abstract states (note that the evaluation rules are non-overlapping). The proof for the slightly adapted concrete rules for the four instructions above can be found at [3].\n\n(b) If $a$’s outgoing edges are refinement edges, then one of its successors $\\tilde{a}$ has an evaluation edge to another abstract state $\\overline{a}$, where $(\\text{as}, \\text{mem}) \\models \\overline{\\sigma}(\\overline{a})_{\\text{SL}}$ for a concrete instantiation $\\overline{\\sigma}$ with $\\overline{\\sigma}(v) = \\sigma(v)$ for all $v \\in \\mathcal{V}_{\\text{sym}}(a)$.\n\n(c) If $a$’s outgoing edge is a generalization edge to a state $\\tilde{a}$ with some instantiation $\\mu$, and $\\tilde{a}$ has an evaluation edge to another abstract state $\\overline{a}$, then $(\\text{as}, \\text{mem}) \\models \\overline{\\sigma}(\\overline{a})_{\\text{SL}}$ for a concrete instantiation $\\overline{\\sigma}$ with $\\overline{\\sigma}(v) = \\sigma(\\mu(v))$ for all $v \\in \\mathcal{V}_{\\text{sym}}(\\tilde{a})$.\n\n(d) Otherwise, there is a generalization edge from $a$ to a state $\\tilde{a}$ with some instantiation $\\mu$, a refinement edge from $\\tilde{a}$ to some $\\tilde{\\tilde{a}}$, and an evaluation edge from $\\tilde{\\tilde{a}}$ to some $\\overline{a}$, where $(\\text{as}, \\text{mem}) \\models \\overline{\\sigma}(\\overline{a})_{\\text{SL}}$ for a concrete instantiation $\\overline{\\sigma}$ with $\\overline{\\sigma}(v) = \\sigma(\\mu(v))$ for all $v \\in \\mathcal{V}_{\\text{sym}}(\\tilde{\\tilde{a}})$. □\n\nRecall that a complete symbolic execution graph must not contain the state $\\text{ERR}$. Thus, all concrete states represented by the abstract states in the graph are memory safe.\n\n**Corollary 11 (Memory Safety of LLVM Programs)** Let $\\mathcal{P}$ be a program with a complete symbolic execution graph $\\mathcal{G}$. Then $\\mathcal{P}$ is memory safe for all states represented by $\\mathcal{G}$.\n\n**Proof** If a concrete state $c$ is represented by an abstract state $a$ in the graph $\\mathcal{G}$ where $\\text{TRANS}(v, c)$ and $\\text{Stack}(v)$ for some Vellvm state $v$, then by Thm. 9 we have $c \\rightarrow_{\\text{LLVM}} \\text{ERR}$. By Thm. 10, $c \\rightarrow_{\\text{LLVM}} \\text{ERR}$ implies that there is an edge from $a$ to $\\text{ERR}$ in $\\mathcal{G}$. However, this contradicts the prerequisite that $\\mathcal{G}$ is complete and therefore does not contain $\\text{ERR}$. □\n\n## 5 From Symbolic Execution Graphs to Integer Transition Systems\n\nFinally, we extract an integer transition system from the symbolic execution graph and use existing tools to prove its termination. The extraction step essentially restricts the information in abstract states to the integer constraints on symbolic variables. This conversion of memory-based arguments into integer arguments often suffices for the termination proof. The reason for considering only $\\mathcal{V}_{\\text{sym}}$ instead of $\\mathcal{V}_{\\mathcal{P}}$ is that since the mappings $L_{\\mathcal{P}}$ are injective, the variables $\\mathcal{V}_{\\mathcal{P}}$ are completely represented by symbolic variables and the conditions in the abstract states (which are crucial for termination) only concern symbolic variables.\n\nFor example, termination of $\\text{strlen}$ is proved by showing that $n$ is increased as long as it is smaller than $v_{\\text{end}}$, the end of the input string. In Fig. 1, this is explicit as the invariant $v_{i} < v_{\\text{end}}$ holds in all states represented by $L$. Each loop iteration increases the value of $v_{i}$.\n\nFormally, LTSs are graphs whose nodes are abstract states and whose edges are transitions. Let $\\mathcal{V} \\subseteq \\mathcal{V}_{\\text{sym}}$ be the finite set of all symbolic variables in states of the symbolic execution graph. A transition is a tuple $(a, \\text{CON}, \\overline{a})$ where $a, \\overline{a}$ are abstract states and the condition\nCON \\subseteq QFJA(\\mathcal{V} \\cup \\mathcal{V'}) is a set of pure quantifier-free formulas over \\mathcal{V} \\cup \\mathcal{V}'. Here, \\mathcal{V}' = \\{v' \\mid v \\in \\mathcal{V}\\} represents the variable values after the transition. An ITS state \\langle a, \\sigma \\rangle consists of an abstract state a and a concrete instantiation \\sigma : \\mathcal{V} \\rightarrow \\mathbb{Z}. For any such \\sigma, let \\sigma' : \\mathcal{V}' \\rightarrow \\mathbb{Z} with \\sigma'(v') = \\sigma(v). Given an ITS \\mathcal{I}, \\langle a, \\sigma \\rangle evaluates to \\langle \\sigma, \\sigma' \\rangle (denoted \"\\langle a, \\sigma \\rangle \\rightarrow_{\\mathcal{I}} \\langle \\sigma, \\sigma' \\rangle\") iff \\mathcal{I} has a transition \\langle a, \\text{CON}, \\sigma \\rangle with \\models (\\sigma \\cup \\sigma')(v) \\models \\text{CON}. Here, we have (\\sigma \\cup \\sigma')(v) = \\sigma(v) and (\\sigma \\cup \\sigma')(v') = \\sigma'(v') = \\sigma(v) for all v \\in \\mathcal{V}. An ITS \\mathcal{I} is terminating iff \\rightarrow_{\\mathcal{I}} is well-founded.\\(^{11}\\)\n\nWe convert symbolic execution graphs to ITSs by transforming every edge into a transition. If there is a generalization edge from a to \\sigma with an instantiation \\mu, then the new value of any v \\in \\mathcal{V}_{\\text{sym}}(\\sigma) in \\sigma is \\mu(v). Hence, we create the transition \\langle a, (a) \\cup \\{v = \\mu(v) \\mid v \\in \\mathcal{V}_{\\text{sym}}(\\sigma)\\}, \\sigma \\rangle.\\(^{12}\\) So for the edge from N to L in Fig. 1, we obtain the condition \\{w_a = w_{old} + 1, w_{old} = v_{end}, v'_{\\text{addr}} = v_{\\text{str}}, v_{end} = v_{\\text{end}}, v'_c = w_c, v'_a = w_a, \\ldots\\}. This can be simplified to \\{v_a < v_{\\text{end}}, v_{\\text{end}} = v_{\\text{end}}, v'_a = v_a + 1, \\ldots\\}\n\nAn evaluation or refinement edge from a to \\sigma does not change the variables of \\mathcal{V}_{\\text{sym}}(a).\n\nThus, we construct the transition \\langle a, (a) \\cup \\{v' = v \\mid v \\in \\mathcal{V}_{\\text{sym}}(a)\\}, \\sigma \\rangle.\n\nSo in the ITS resulting from Fig. 1, the condition of the transition from A to B is \\{v'_{\\text{end}} = v_{\\text{end}}, u'_{\\text{addr}} = u_{\\text{addr}}\\}. The condition for the transition from B to D is the same, but extended by v'_{1} = v_{1}. Hence, in the transition from A to B, the value of v_{1} can change arbitrarily (since v_{1} \\notin \\mathcal{V}_{\\text{sym}}(A)), but in the transition from B to D, it must remain the same.\n\nDefinition 12 (ITS from Symbolic Execution Graph) For a symbolic execution graph \\mathcal{G}, the corresponding integer transition system \\mathcal{I}_G has one transition for each edge in \\mathcal{G}:\n\n- If the edge from a to \\sigma is not a generalization edge, then \\mathcal{I}_G has a transition from a to \\sigma with the condition \\langle a \\cup \\{v' = v \\mid v \\in \\mathcal{V}_{\\text{sym}}(a)\\}, \\sigma \\rangle.\n\n- If there is a generalization edge from a to \\sigma with the instantiation \\mu, then \\mathcal{I}_G has a transition from a to \\sigma with the condition \\langle a \\cup \\{v = \\mu(v) \\mid v \\in \\mathcal{V}_{\\text{sym}}(\\sigma)\\}, \\sigma \\rangle.\n\nFrom the non-generalization edges on the path from L to N in Fig. 1, we obtain transitions whose conditions contain v'_{\\text{end}} = v_{\\text{end}} and v'_{a} = v_{a}. So v_{a} is increased by 1 in the transition from N to L and it remains the same in all other transitions of the graph’s only cycle. Since the transition from N to L is only executed as long as v_{a} < v_{\\text{end}} holds (where v_{\\text{end}} is not changed by any transition), termination of the resulting ITS can easily be proved automatically.\n\nThm. 13 states the soundness of our approach for termination. If there is an infinite LLVM-computation v_{1} \\rightarrow_{\\text{Vellvm}} v_{2} \\rightarrow_{\\text{Vellvm}} \\ldots and v_{1} is represented in the symbolic execution graph (i.e., there exists some c_{1} with \\text{TRANS}(v_{1}, c_{1}) that is represented by a_{1}), then Thm. 9 and 10 imply that there is a corresponding infinite path in the graph starting with the node a_{1}. We now show that then the ITS resulting from the graph is not terminating.\n\nTheorem 13 (Termination of LLVM Programs) Let \\mathcal{P} be an LLVM program with a complete symbolic execution graph \\mathcal{G}. If \\mathcal{I}_G is terminating, then \\mathcal{P} is also terminating for all LLVM states represented by the states in \\mathcal{G}.\n\nProof Let \\langle a \\rightarrow_{\\text{LLVM}} \\sigma \\rangle, where \\mathcal{G} contains an abstract state a with \\langle a, \\text{mem} \\rangle \\models \\sigma(a)_{\\text{SL}} for some concrete instantiation \\sigma. In the proof of Thm. 10, we showed that there is an abstract state \\sigma in \\mathcal{G} and a concrete instantiation \\sigma' with \\langle a, \\text{mem} \\rangle \\models \\sigma(a)_{\\text{SL}}. To prove Thm. 13, it suffices to show \\langle a, \\sigma \\rangle \\rightarrow_{\\mathcal{I}_G} \\langle \\sigma, \\sigma' \\rangle. By Thm. 9, then termination of \\mathcal{I}_G also implies that there is no infinite LLVM evaluation according to the semantics of Vellvm.\n\n(a) If a has an evaluation edge to \\sigma, then \\sigma(v) = \\sigma(v) for all v \\in \\mathcal{V}_{\\text{sym}}(a). We show that\n\n\\(^{11}\\) For programs starting in states represented by an abstract state a_{0}, it would suffice to prove termination of all \\rightarrow_{\\mathcal{I}}-evaluations starting in ITS states of the form \\langle a_{0}, \\sigma \\rangle.\n\n\\(^{12}\\) In the transition, we do not impose the additional constraints of \\sigma on the post-variables \\mathcal{V}', since they are checked anyway in the next transition which starts in \\sigma.\\}\nthen \\((a, \\sigma) \\rightarrow_{I_G} (\\overline{a}, \\overline{\\sigma})\\). Note that \\(I_G\\) has a transition \\((a, \\sigma) \\cup \\{ v' = v \\mid v \\in \\mathcal{I}_{\\mathcal{Sym}}(a) \\}, \\overline{\\sigma}\\), so it suffices to show that \\((\\sigma \\cup \\overline{\\sigma})\\) satisfies the condition of this transition. We have \\((a', \\text{mem'}') \\models \\sigma((a)_SL)\\), and hence \\((a', \\text{mem'}') \\models \\sigma((a))\\). Since \\(\\sigma\\) is concrete (i.e., \\(\\sigma((a))\\) does not contain variables), this implies \\(\\models \\sigma((a))\\) and thus, \\((\\sigma \\cup \\overline{\\sigma})\\) \\((a)\\).\n\nMoreover, for all \\(v \\in \\mathcal{I}_{\\mathcal{Sym}}(a)\\), we have \\((\\sigma \\cup \\overline{\\sigma})(v) = \\overline{\\sigma}(v) = \\overline{\\sigma}(v) = \\sigma(v) = (\\sigma \\cup \\overline{\\sigma})(v)\\).\n\n(b) If the path from \\(a\\) to \\(\\overline{\\sigma}\\) consists of a refinement and a subsequent evaluation edge, then \\(\\overline{\\sigma}(v) = \\sigma(v)\\) for all \\(v \\in \\mathcal{I}_{\\mathcal{Sym}}(a)\\). We show that then we have \\((a, \\sigma) \\rightarrow_{I_G} (\\overline{a}, \\overline{\\sigma})\\). To see this, note that in \\(a\\)'s two successors, the knowledge base is extended by \\(\\varphi\\) and \\(\\neg \\varphi\\) for some formula \\(\\varphi\\), respectively. If \\(\\models \\sigma(\\varphi)\\), then let \\(\\overline{a}\\) be the successor with the knowledge base \\(KB = KB \\cup \\{ \\varphi \\}\\). Otherwise, let \\(\\overline{a}\\) be the successor with the knowledge base \\(KB = KB \\cup \\{ \\neg \\varphi \\}\\). So in both cases, we have \\(\\models \\sigma(KB)\\) and thus, \\((a', \\text{mem'}') \\models \\sigma((\\overline{a})_SL)\\).\n\nHence, \\((\\overline{a}, \\sigma) \\rightarrow_{I_G} (\\overline{a}, \\overline{\\sigma})\\) can be shown as in (a). As \\(I_G\\) has a transition \\((a, \\sigma) \\cup \\{ v = v \\mid v \\in \\mathcal{I}_{\\mathcal{Sym}}(a) \\}, \\overline{\\sigma}\\), we can show \\((a, \\sigma) \\rightarrow_{I_G} (\\overline{a}, \\sigma)\\) as in (a).\n\n(c) Let \\(a\\) have a generalization edge to \\(\\overline{a}\\) with instantiation \\(\\mu\\) and an evaluation edge from \\(\\overline{a}\\) to \\(\\overline{\\sigma}\\) with \\(\\overline{\\sigma}(v) = \\sigma(\\mu(v))\\) for all \\(v \\in \\mathcal{I}_{\\mathcal{Sym}}(\\overline{a})\\). We show \\((a, \\sigma) \\rightarrow_{I_G} (\\overline{a}, \\sigma \\circ \\mu) \\rightarrow_{I_G} (\\overline{a}, \\overline{\\sigma})\\).\n\nWe first prove \\((a, \\sigma) \\rightarrow_{I_G} (\\overline{a}, \\sigma \\circ \\mu)\\). Due to the edge from \\(a\\) to \\(\\overline{a}\\), \\(I_G\\) has the transition \\((a, \\sigma) \\cup \\{ v = \\mu(v) \\mid v \\in \\mathcal{I}_{\\mathcal{Sym}}(\\overline{a}) \\}, \\overline{\\sigma}\\), and we show that \\((\\sigma \\cup \\sigma \\circ \\mu')\\) satisfies the condition of this transition. We have \\((a', \\text{mem'}') \\models \\sigma((\\overline{a})_SL)\\), and hence \\((a', \\text{mem'}') \\models \\sigma((a))\\), from which \\(\\models \\sigma((a))\\) follows and finally \\(\\models (\\sigma \\cup (\\sigma \\circ \\mu'))((a))\\). Moreover, for all \\(v \\in \\mathcal{I}_{\\mathcal{Sym}}(\\overline{a})\\), we have \\((\\sigma \\cup (\\sigma \\circ \\mu'))(v) = (\\sigma \\circ \\mu')(v) = \\sigma(\\mu(v)) = (\\sigma \\cup (\\sigma \\circ \\mu'))(\\mu(v))\\).\n\nNow we show \\((\\overline{a}, \\sigma \\circ \\mu) \\rightarrow_{I_G} (\\overline{a}, \\overline{\\sigma})\\). As there is a generalization edge from \\(a\\) to \\(\\overline{a}\\) with the instantiation \\(\\mu\\), we know that \\(\\models (a)_SL \\Rightarrow \\mu((\\overline{a})_SL)\\). Thus, \\((a', \\text{mem'}') \\models \\sigma((\\overline{a})_SL)\\) implies \\((a', \\text{mem'}') \\models (\\sigma \\circ \\mu)((\\overline{a})_SL)\\).\n\nHence, \\((a, \\sigma \\circ \\mu) \\rightarrow_{I_G} (\\overline{a}, \\overline{\\sigma})\\) follows as in (a).\n\n(d) Finally, let \\(a\\) have a generalization edge to \\(\\overline{a}\\) with the instantiation \\(\\mu\\), and there is a path consisting of a refinement and an evaluation edge from \\(a\\) to \\(\\overline{\\sigma}\\), where \\(\\overline{\\sigma}(v) = \\sigma(\\mu(v))\\) for all \\(v \\in \\mathcal{I}_{\\mathcal{Sym}}(\\overline{a})\\). We show that then \\((a, \\sigma) \\rightarrow_{I_G} (\\overline{a}, \\sigma \\circ \\mu) \\rightarrow_{I_G} (\\overline{a}, \\overline{\\sigma})\\). Here, \\((a, \\sigma) \\rightarrow_{I_G} (\\overline{a}, \\sigma \\circ \\mu) \\rightarrow_{I_G} (\\overline{a}, \\overline{\\sigma})\\) follows as in (c), and \\((\\overline{a}, \\sigma \\circ \\mu) \\rightarrow_{I_G} (\\overline{a}, \\overline{\\sigma})\\) can be proved as in (b).\n\n6 Limitations, Related Work, Experiments, and Conclusion\n\nWe have developed a new approach to prove memory safety and termination of C (resp. LLVM) programs with explicit pointer arithmetic and memory access. It relies on a representation of abstract program states which allows an easy automation of the rules for symbolic execution (by using standard SMT solving to check the first-order conditions of these rules). Moreover, this representation is suitable for generalizing abstract states and for generating integer transition systems. In this way, LLVM programs are translated fully automatically into ITSSs amenable to automated termination analysis.\n\nLimitations and Future Work. To simplify the formalization of our approach, we have not discussed global variables, which our implementation supports. In line with most other techniques, we currently do not handle the case that calls to malloc may fail, and we also assume that reading from uninitialized (but allocated) heap locations is safe and yields an arbitrary value. Our method could easily be adapted to lift these limitations. Furthermore, in this paper we disregard integer overflows and treat all integer types except int as the infinite set \\(\\mathbb{Z}\\). An extension of our approach to bounded integers can be found in [44].\n\nIn the paper, we only gave rules for a subset of all LLVM instructions. Our implementation handles several more instructions, but there exist instructions (or cases of instructions) where our implementation does not yet contain suitable rules for symbolic execution. In particular, our abstract domain currently does not handle \\texttt{undefined} values, floating point values, or vectors,\nand consequently, all corresponding instructions are unsupported.\\footnote{The instructions supported by our implementation are \\texttt{icmp(eq,ne,sgt,sge,slt,sle,ugt,uge,ult,ule)}, \\texttt{add,sub,mul,div,rem,urem, and, or, xor, shl, ashr, lshr, call, br, bitcast, ptrtoint, trunc, sext,zext, getelementptr} (with at most 2 parameters), \\texttt{select,phi,ret,alloca,load, and store}.\n\nWhen encountering an instruction that cannot be handled, the symbolic execution can still continue by removing all potentially affected knowledge. The same holds if one cannot prove all conditions of a symbolic execution rule. It often suffices to remove all information about the value that is computed by the instruction, e.g., for floating point operations.\n\nIn this paper, we did not treat recursive programs and we also did not present any method to prove that an LLVM program is \\textit{not} memory safe or does \\textit{not} terminate. However, we are working on extending our approach accordingly and our implementation already contains some support for recursion and non-termination by adapting our approaches for recursion and non-termination of Java programs\\cite{12,13}. Another direction for further work could be to embed our analysis into a \\textit{Counter-Example-Guided Abstraction Refinement (CEGAR)} loop \\cite{24} to disprove termination or memory safety, and to automatically refine the abstraction.\n\nFinally, we cannot yet analyze C programs using inductive data structures defined via \\texttt{\"struct\"}. However, in the future, we want to adapt our corresponding technique for termination analysis of Java programs\\cite{11,12,14,63}. Instead of ITSs, here one generates integer term rewrite systems\\cite{35,37} from the symbolic execution graph, where data objects are transformed into \\textit{terms} to represent them in a precise way.\n\nMoreover, we would like to improve the scalability of our approach by a compositional treatment of LLVM functions. There are several tools based on separation logic which support local modular reasoning for shape analysis and the verification of memory safety, e.g.,\\cite{19–21}. Moreover, compositional approaches for termination analysis were developed in\\cite{22,28,70}, based on\\cite{65}. Combining such approaches with the byte-precise handling of explicit low-level pointer arithmetic for termination analysis will be the subject of further work.\n\n\\textbf{Related Work and Experimental Evaluation.} There exist numerous other methods and tools for termination analysis of imperative programs (e.g., \\texttt{2LS}\\cite{22}, \\texttt{ARMC}\\cite{64}, \\texttt{ARTMC}\\cite{41,45}, \\texttt{COSTA}\\cite{2}, \\texttt{CppInv}\\cite{50}, \\texttt{Ctrl}\\cite{47,48}, \\texttt{Cyclist}\\cite{16}, \\texttt{FuncTion}\\cite{32}, \\texttt{HipTNT+}\\cite{52}, \\texttt{Juggernaut}\\cite{30}, \\texttt{Julia}\\cite{66}, \\texttt{KITTeL}\\cite{35}, \\texttt{L2CA}\\cite{10}, \\texttt{LoopFrog}\\cite{70}, \\texttt{SeaHorn}\\cite{71}, \\texttt{Sonar}\\cite{5,4}, \\texttt{TAN}\\cite{49}, \\texttt{Terminator}\\cite{26–28}, \\texttt{Termite}\\cite{39}, \\texttt{TRex}\\cite{42}, \\texttt{T2}\\cite{15}, \\texttt{Ultimate}\\cite{43}, \\ldots). Until very recently, most other approaches did not handle the heap at all, or supported dynamic data structures by an abstraction to integers (e.g., to represent sizes or lengths) or to terms (representing finite unravelings). In particular, most tools failed when the control flow depends on explicit pointer arithmetic and on detailed information about the contents of addresses. While our approach was inspired by our previous work on termination of Java, in the current paper we extend these techniques to prove termination and memory safety of programs with explicit pointer arithmetic. This requires a fundamentally new approach, as pointer arithmetic cannot be expressed in the Java-based techniques of\\cite{11,12,14,63}.\n\nWe implemented our technique in the termination prover AProVE\\cite{38,68}, which uses the SMT solvers \\texttt{Yices}\\cite{34} and \\texttt{Z3}\\cite{31} in the back-end. AProVE participated very successfully in the \\textit{International Competition on Software Verification (SV-COMP)}\\footnote{http://sv-comp.sosy-lab.org/} at TACAS and in the \\textit{International Termination Competition (TermComp)},\\footnote{http://termination-portal.org/wiki/Termination_Competition} both of which feature categories for termination of C programs since 2014.\n\nTo evaluate AProVE empirically, we compare its performance with other tools on all 631 programs from the \\textit{Termination} category of \\textit{SV-COMP} 2016. For termination of low-level C programs, one also has to ensure their memory safety. Approaches for proving memory...\nsafety of programs with pointer arithmetic were proposed in [19,40], for example. However, while there exist several tools to prove memory safety of C programs, many of them do not handle explicit byte-accurate pointer arithmetic (e.g., Thor [55,56] or SLayer [6]) or require the user to provide the needed loop invariants (as in the Jessie plug-in of Frama-C [58]). In contrast, our approach can prove memory safety of such algorithms automatically.\n\nMore precisely, for the 631 programs in our collection, AProVE shows memory safety for 547 examples. In contrast, the most powerful tool for verifying memory safety at SV-COMP 2016 (Predator [33]) proves memory safety for 431 examples (see [3] for details). However, this comparison is not very meaningful, since Predator considers bounded integers, whereas AProVE assumes integers to be unbounded. Thus, the resulting notions of memory safety are incomparable. Moreover, there exist several tools to disprove memory safety (e.g., Predator, CPAchecker [54], and LLBMC [36]). In contrast, AProVE can only prove, but not disprove memory safety, since our symbolic execution graph over-approximates all possible program runs. So the occurrence of ERR in our graph does not imply that the program is really unsafe.\n\nTo evaluate the power of our approach for proving termination, we compared AProVE to the most powerful other tools (Ultimate and SeaHorn) from the Termination category of SV-COMP 2016, and to HipTNT+. (AProVE, Ultimate, and HipTNT+ were the most powerful tools in the C category of TermComp 2015 and in the Termination category of SV-COMP 2015.) In addition, we included the tool KITTeL in our evaluation, which operates on LLVM as well. Recall that in the present paper, we only introduced techniques to prove (but not to disprove) termination of programs. Therefore, to evaluate the contributions of the present paper, we excluded those C programs from our evaluation that are known to be non-terminating. This resulted in 498 programs.16\n\nOn the side, we show the performance of the tools for a time limit of 900 seconds per example. For AProVE, Ultimate, and SeaHorn, we used the results of SV-COMP 2016. The other tools were run on an Intel Xeon with 4 cores clocked at 2.33 GHz each and 16 GB of RAM. “YES” gives the number of examples where termination could be proved, “MAYBE” states how often the tool could not find a proof within 900 seconds, and “Runtime” is the average time in seconds for those examples where the tool proved termination. The table shows that in these experiments, AProVE is the most powerful tool for proving termination of C programs. On the other hand, since AProVE constructs symbolic execution graphs to prove memory safety and to infer suitable invariants needed for termination proofs, its runtime is often higher. For details on the experiments and to access our implementation in AProVE via a web interface, we refer to [3].\n\nAcknowledgements We are grateful to the developers of the other tools for termination or memory safety [33,35,43,52,71] for their help with the experiments.\n\nReferences\n\n\n16 As mentioned above, we also started implementing support for non-termination in AProVE. When running the tools on all 631 C examples, AProVE proves termination for 409 and non-termination for 91 examples. Ultimate shows termination for 392 and non-termination for 111 programs. Finally, HipTNT+ proves termination in 312 and non-termination in 107 cases. Again, the detailed results can be found at [3].\n\n\n"}}},{"rowIdx":270,"cells":{"id":{"kind":"string","value":"9dc9cd841645fca8670c0d68f88aeb8c1da03fe7"},"text":{"kind":"string","value":"# CONTENTS\n\n1 Introduction\n 1.1 Contributing .......................................................... 1\n 1.2 How to run the client .............................................. 2\n 1.3 Understanding the client in more depth ....................... 2\n\n2 What is a Certificate?\n 2.1 Certificates and Lineages ........................................ 3\n\n3 Get Certbot\n 3.1 System Requirements ................................................ 5\n 3.2 Installation ............................................................ 6\n 3.3 Snap (Recommended) .................................................. 6\n 3.4 Alternative 1: Docker ................................................ 6\n 3.5 Alternative 2: Pip ...................................................... 7\n 3.6 Alternative 3: Third Party Distributions ....................... 7\n 3.7 Certbot-Auto [Deprecated] .......................................... 7\n\n4 User Guide\n 4.1 Certbot Commands .................................................... 10\n 4.2 Getting certificates (and choosing plugins) .................... 10\n 4.3 Managing certificates ............................................... 16\n 4.4 Where are my certificates? ........................................ 24\n 4.5 Pre and Post Validation Hooks .................................... 25\n 4.6 Changing the ACME Server ......................................... 28\n 4.7 Lock Files .............................................................. 28\n 4.8 Configuration file ...................................................... 28\n 4.9 Log Rotation ........................................................... 29\n 4.10 Certbot command-line options ................................... 30\n 4.11 Getting help .......................................................... 44\n\n5 Developer Guide\n 5.1 Getting Started ....................................................... 46\n 5.2 Code components and layout ....................................... 49\n 5.3 Coding style ........................................................... 51\n 5.4 Use certbot.compat.os instead of os .............................. 52\n 5.5 Mypy type annotations .............................................. 52\n 5.6 Submitting a pull request .......................................... 52\n 5.7 Asking for help ....................................................... 53\n 5.8 Building the Certbot and DNS plugin snaps ................... 53\n 5.9 Updating the documentation ...................................... 53\nCHAPTER ONE\n\nINTRODUCTION\n\nNote: To get started quickly, use the interactive installation guide.\n\nCertbot is part of EFF’s effort to encrypt the entire Internet. Secure communication over the Web relies on HTTPS, which requires the use of a digital certificate that lets browsers verify the identity of web servers (e.g., is that really google.com?). Web servers obtain their certificates from trusted third parties called certificate authorities (CAs). Certbot is an easy-to-use client that fetches a certificate from Let’s Encrypt—an open certificate authority launched by the EFF, Mozilla, and others—and deploys it to a web server.\n\nAnyone who has gone through the trouble of setting up a secure website knows what a hassle getting and maintaining a certificate is. Certbot and Let’s Encrypt can automate away the pain and let you turn on and manage HTTPS with simple commands. Using Certbot and Let’s Encrypt is free, so there’s no need to arrange payment.\n\nHow you use Certbot depends on the configuration of your web server. The best way to get started is to use our interactive guide. It generates instructions based on your configuration settings. In most cases, you’ll need root or administrator access to your web server to run Certbot.\n\nCertbot is meant to be run directly on your web server, not on your personal computer. If you’re using a hosted service and don’t have direct access to your web server, you might not be able to use Certbot. Check with your hosting provider for documentation about uploading certificates or using certificates issued by Let’s Encrypt.\n\nCertbot is a fully-featured, extensible client for the Let’s Encrypt CA (or any other CA that speaks the ACME protocol) that can automate the tasks of obtaining certificates and configuring web servers to use them. This client runs on Unix-based operating systems.\n\nTo see the changes made to Certbot between versions please refer to our changelog.\n\n1.1 Contributing\n\nIf you’d like to contribute to this project please read Developer Guide.\n\nThis project is governed by EFF’s Public Projects Code of Conduct.\n1.2 How to run the client\n\nThe easiest way to install and run Certbot is by visiting certbot.eff.org, where you can find the correct instructions for many web server and OS combinations. For more information, see Get Certbot.\n\n1.3 Understanding the client in more depth\n\nTo understand what the client is doing in detail, it’s important to understand the way it uses plugins. Please see the explanation of plugins in the User Guide.\n\n1.3.1 Links\n\nDocumentation: https://certbot.eff.org/docs\nSoftware project: https://github.com/certbot/certbot\nNotes for developers: https://certbot.eff.org/docs/contributing.html\nMain Website: https://certbot.eff.org\nLet’s Encrypt Website: https://letsencrypt.org\nCommunity: https://community.letsencrypt.org\nACME spec: RFC 8555\nACME working area in github (archived): https://github.com/ietf-wg-acme/acme\n\n1.3.2 System Requirements\n\nSee https://certbot.eff.org/docs/install.html#system-requirements.\nWHAT IS A CERTIFICATE?\n\nA public key or digital certificate (formerly called an SSL certificate) uses a public key and a private key to enable secure communication between a client program (web browser, email client, etc.) and a server over an encrypted SSL (secure socket layer) or TLS (transport layer security) connection. The certificate is used both to encrypt the initial stage of communication (secure key exchange) and to identify the server. The certificate includes information about the key, information about the server identity, and the digital signature of the certificate issuer. If the issuer is trusted by the software that initiates the communication, and the signature is valid, then the key can be used to communicate securely with the server identified by the certificate. Using a certificate is a good way to prevent “man-in-the-middle” attacks, in which someone in between you and the server you think you are talking to is able to insert their own (harmful) content.\n\nYou can use Certbot to easily obtain and configure a free certificate from Let’s Encrypt, a joint project of EFF, Mozilla, and many other sponsors.\n\n2.1 Certificates and Lineages\n\nCertbot introduces the concept of a lineage, which is a collection of all the versions of a certificate plus Certbot configuration information maintained for that certificate from renewal to renewal. Whenever you renew a certificate, Certbot keeps the same configuration unless you explicitly change it, for example by adding or removing domains. If you add domains, you can either add them to an existing lineage or create a new one.\n\nSee also: Re-creating and Updating Existing Certificates\nGET CERTBOT\n\nTable of Contents\n\n• System Requirements\n• Installation\n• Snap (Recommended)\n• Alternative 1: Docker\n• Alternative 2: Pip\n• Alternative 3: Third Party Distributions\n• Certbot-Auto [Deprecated]\n\n3.1 System Requirements\n\n• Linux, macOS, BSD and Windows\n• Recommended root access on Linux/BSD/Required Administrator access on Windows\n• Port 80 Open\n\nNote: Certbot is most useful when run with root privileges, because it is then able to automatically configure TLS/SSL for Apache and nginx.\n\nCertbot is meant to be run directly on a web server, normally by a system administrator. In most cases, running Certbot on your personal computer is not a useful option. The instructions below relate to installing and running Certbot on a server.\n3.2 Installation\n\nUnless you have very specific requirements, we kindly suggest that you use the installation instructions for your system found at https://certbot.eff.org/instructions.\n\n3.3 Snap (Recommended)\n\nOur instructions are the same across all systems that use Snap. You can find instructions for installing Certbot through Snap can be found at https://certbot.eff.org/instructions by selecting your server software and then choosing “snapd” in the “System” dropdown menu.\n\nMost modern Linux distributions (basically any that use systemd) can install Certbot packaged as a snap. Snaps are available for x86_64, ARMv7 and ARMv8 architectures. The Certbot snap provides an easy way to ensure you have the latest version of Certbot with features like automated certificate renewal preconfigured.\n\nIf you unable to use snaps, you can use an alternate method for installing certbot.\n\n3.4 Alternative 1: Docker\n\nDocker is an amazingly simple and quick way to obtain a certificate. However, this mode of operation is unable to install certificates or configure your webserver, because our installer plugins cannot reach your webserver from inside the Docker container.\n\nMost users should use the instructions at certbot.eff.org. You should only use Docker if you are sure you know what you are doing and have a good reason to do so.\n\nYou should definitely read the Where are my certificates? section, in order to know how to manage the certificates manually. Our ciphersuites page provides some information about recommended ciphersuites. If none of these make much sense to you, you should definitely use the installation method recommended for your system at certbot.eff.org, which enables you to use installer plugins that cover both of those hard topics.\n\nIf you’re still not convinced and have decided to use this method, from the server that the domain you’re requesting a certificate for resolves to, install Docker, then issue a command like the one found below. If you are using Certbot with the Standalone plugin, you will need to make the port it uses accessible from outside of the container by including something like -p 80:80 or -p 443:443 on the command line before certbot/certbot.\n\n```\nsudo docker run -it --rm --name certbot \\\n -v \"/etc/letsencrypt:/etc/letsencrypt\" \\\n -v \"/var/lib/letsencrypt:/var/lib/letsencrypt\" \\\n certbot/certbot certonly\n```\n\nRunning Certbot with the certonly command will obtain a certificate and place it in the directory /etc/letsencrypt/live on your system. Because Certonly cannot install the certificate from within Docker, you must install the certificate manually according to the procedure recommended by the provider of your webserver.\n\nThere are also Docker images for each of Certbot’s DNS plugins available at https://hub.docker.com/u/certbot which automate doing domain validation over DNS for popular providers. To use one, just replace certbot/certbot in the command above with the name of the image you want to use. For example, to use Certbot’s plugin for Amazon Route 53, you’d use certbot/dns-route53. You may also need to add flags to Certbot and/or mount additional directories to provide access to your DNS API credentials as specified in the DNS plugin documentation.\n\nFor more information about the layout of the /etc/letsencrypt directory, see Where are my certificates?.\n3.5 Alternative 2: Pip\n\nInstalling Certbot through pip is only supported on a best effort basis and when using a virtual environment. Instructions for installing Certbot through pip can be found at https://certbot.eff.org/instructions by selecting your server software and then choosing “pip” in the “System” dropdown menu.\n\n3.6 Alternative 3: Third Party Distributions\n\nThird party distributions exist for other specific needs. They often are maintained by these parties outside of Certbot and tend to rapidly fall out of date on LTS-style distributions.\n\n3.7 Certbot-Auto [Deprecated]\n\nWe used to have a shell script named certbot-auto to help people install Certbot on UNIX operating systems, however, this script is no longer supported.\n\nPlease remove certbot-auto. To do so, you need to do three things:\n\n1. If you added a cron job or systemd timer to automatically run certbot-auto to renew your certificates, you should delete it. If you did this by following our instructions, you can delete the entry added to /etc/crontab by running a command like sudo sed -i '/certbot-auto/d' /etc/crontab.\n\n2. Delete the certbot-auto script. If you placed it in /usr/local/bin like we recommended, you can delete it by running sudo rm /usr/local/bin/certbot-auto.\n\n3. Delete the Certbot installation created by certbot-auto by running sudo rm -rf /opt/eff.org.\nTable of Contents\n\n• Certbot Commands\n\n• Getting certificates (and choosing plugins)\n – Apache\n – Webroot\n – Nginx\n – Standalone\n – DNS Plugins\n – Manual\n – Combining plugins\n – Third-party plugins\n\n• Managing certificates\n – Re-creating and Updating Existing Certificates\n – Changing a Certificate’s Domains\n – Using ECDSA keys\n * Changing existing certificates from RSA to ECDSA\n * Obtaining ECDSA certificates in addition to RSA certificates\n – Revoking certificates\n * Revoking by account key or certificate private key\n – Deleting certificates\n * Safely deleting certificates\n – Renewing certificates\n – Modifying the Renewal Configuration of Existing Certificates\n – Automated Renewals\n * Setting up automated renewal\n\n• Where are my certificates?\n4.1 Certbot Commands\n\nCertbot uses a number of different commands (also referred to as “subcommands”) to request specific actions such as obtaining, renewing, or revoking certificates. The most important and commonly-used commands will be discussed throughout this document; an exhaustive list also appears near the end of the document.\n\nThe certbot script on your web server might be named letsencrypt if your system uses an older package. Throughout the docs, whenever you see certbot, swap in the correct name as needed.\n\n4.2 Getting certificates (and choosing plugins)\n\nCertbot helps you achieve two tasks:\n\n1. Obtaining a certificate: automatically performing the required authentication steps to prove that you control the domain(s), saving the certificate to /etc/letsencrypt/live/ and renewing it on a regular schedule.\n\n2. Optionally, installing that certificate to supported web servers (like Apache or nginx) and other kinds of servers. This is done by automatically modifying the configuration of your server in order to use the certificate.\n\nTo obtain a certificate and also install it, use the certbot run command (or certbot, which is the same).\n\nTo just obtain the certificate without installing it anywhere, the certbot certonly (“certificate only”) command can be used.\n\nSome example ways to use Certbot:\n\n```bash\n# Obtain and install a certificate:\ncertbot\n\n# Obtain a certificate but don't install it:\ncertbot certonly\n\n# You may specify multiple domains with -d and obtain and # install different certificates by running Certbot multiple times:\ncertbot certonly -d example.com -d www.example.com\ncertbot certonly -d app.example.com -d api.example.com\n```\n\nTo perform these tasks, Certbot will ask you to choose from a selection of authenticator and installer plugins. The appropriate choice of plugins will depend on what kind of server software you are running and plan to use your certificates with.\n**Authenticators** are plugins which automatically perform the required steps to prove that you control the domain names you’re trying to request a certificate for. An authenticator is always required to obtain a certificate.\n\n**Installers** are plugins which can automatically modify your web server’s configuration to serve your website over HTTPS, using the certificates obtained by Certbot. An installer is only required if you want Certbot to install the certificate to your web server.\n\nSome plugins are both authenticators and installers and it is possible to specify a distinct *combination* of authenticator and plugin.\n<table>\n<thead>\n<tr>\n<th>Plugin</th>\n<th>Auth</th>\n<th>Inst</th>\n<th>Notes</th>\n<th>Challenge types (and port)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>apache</td>\n<td>Y</td>\n<td>Y</td>\n<td>Automates obtaining and installing a certificate with Apache.</td>\n<td>http-01 (80)</td>\n</tr>\n<tr>\n<td>nginx</td>\n<td>Y</td>\n<td>Y</td>\n<td>Automates obtaining and installing a certificate with Nginx.</td>\n<td>http-01 (80)</td>\n</tr>\n<tr>\n<td>webroot</td>\n<td>Y</td>\n<td>N</td>\n<td>Obtains a certificate by writing to the webroot directory of an already running webserver.</td>\n<td>http-01 (80)</td>\n</tr>\n<tr>\n<td>standalone</td>\n<td>Y</td>\n<td>N</td>\n<td>Uses a “standalone” webserver to obtain a certificate. Requires port 80 to be available. This is useful on systems with no webserver, or when direct integration with the local webserver is not supported or not desired.</td>\n<td>http-01 (80)</td>\n</tr>\n<tr>\n<td>DNS plugins</td>\n<td>Y</td>\n<td>N</td>\n<td>This category of plugins automates obtaining a certificate by modifying DNS records to prove you have control over a domain. Doing domain validation in this way is the only way to obtain wildcard certificates from Let’s Encrypt.</td>\n<td>dns-01 (53)</td>\n</tr>\n</tbody>\n</table>\nUnder the hood, plugins use one of several ACME protocol challenges to prove you control a domain. The options are http-01 (which uses port 80) and dns-01 (requiring configuration of a DNS server on port 53, though that's often not the same machine as your webserver). A few plugins support more than one challenge type, in which case you can choose one with --preferred-challenges.\n\nThere are also many third-party-plugins available. Below we describe in more detail the circumstances in which each plugin can be used, and how to use it.\n\n### 4.2.1 Apache\n\nThe Apache plugin currently supports modern OSes based on Debian, Fedora, SUSE, Gentoo, CentOS and Darwin. This automates both obtaining and installing certificates on an Apache webserver. To specify this plugin on the command line, simply include --apache.\n\n### 4.2.2 Webroot\n\nIf you're running a local webserver for which you have the ability to modify the content being served, and you'd prefer not to stop the webserver during the certificate issuance process, you can use the webroot plugin to obtain a certificate by including certonly and --webroot on the command line. In addition, you'll need to specify --webroot-path or -w with the top-level directory (\"web root\") containing the files served by your webserver. For example, --webroot-path /var/www/html or --webroot-path /usr/share/nginx/html are two common webroot paths.\n\nIf you're getting a certificate for many domains at once, the plugin needs to know where each domain's files are served from, which could potentially be a separate directory for each domain. When requesting a certificate for multiple domains, each domain will use the most recently specified --webroot-path. So, for instance,\n\n```\ncertbot certonly --webroot -w /var/www/example -d www.example.com -d example.com -w /var/...other -d other.example.net -d another.other.example.net\n```\n\nwould obtain a single certificate for all of those names, using the /var/www/example webroot directory for the first two, and /var/www/other for the second two.\n\nThe webroot plugin works by creating a temporary file for each of your requested domains in ${webroot-path}/.well-known/acme-challenge. Then the Let's Encrypt validation server makes HTTP requests to validate that the DNS for each requested domain resolves to the server running certbot. An example request made to your web server would look like:\n\n```\n66.133.109.36 - - [05/Jan/2016:20:11:24 -0500] \"GET /.well-known/acme-challenge/HGr8U1IeTW4kY_Z6U1yaakz0kyQgPr_7ArllgtZE8SX HTTP/1.1\" 200 87 \"-\" \"Mozilla/5.0compatible; Let's Encrypt validation server; +https://www.letsencrypt.org\"\n```\n\nNote that to use the webroot plugin, your server must be configured to serve files from hidden directories. If ./well-known/acme-challenge is treated specially by your webserver configuration, you might need to modify the configuration to ensure that files inside ./well-known/acme-challenge are served by the webserver.\n\nUnder Windows, Certbot will generate a web.config file, if one does not already exist, in ./well-known/acme-challenge in order to let IIS serve the challenge files even if they do not have an extension.\n\n---\n\n4.2. Getting certificates (and choosing plugins) 13\n4.2.3 Nginx\n\nThe Nginx plugin should work for most configurations. We recommend backing up Nginx configurations before using it (though you can also revert changes to configurations with `certbot --nginx rollback`). You can use it by providing the `--nginx` flag on the commandline.\n\n```\ncertbot --nginx\n```\n\n4.2.4 Standalone\n\nUse standalone mode to obtain a certificate if you don’t want to use (or don’t currently have) existing server software. The standalone plugin does not rely on any other server software running on the machine where you obtain the certificate.\n\nTo obtain a certificate using a “standalone” webserver, you can use the standalone plugin by including `certonly` and `--standalone` on the command line. This plugin needs to bind to port 80 in order to perform domain validation, so you may need to stop your existing webserver.\n\nIt must still be possible for your machine to accept inbound connections from the Internet on the specified port using each requested domain name.\n\nBy default, Certbot first attempts to bind to the port for all interfaces using IPv6 and then bind to that port using IPv4; Certbot continues so long as at least one bind succeeds. On most Linux systems, IPv4 traffic will be routed to the bound IPv6 port and the failure during the second bind is expected.\n\nUse `--<challenge-type>-address` to explicitly tell Certbot which interface (and protocol) to bind.\n\n4.2.5 DNS Plugins\n\nIf you’d like to obtain a wildcard certificate from Let’s Encrypt or run `certbot` on a machine other than your target webserver, you can use one of Certbot’s DNS plugins.\n\nThese plugins are not included in a default Certbot installation and must be installed separately. They are available in many OS package managers, as Docker images, and as snaps. Visit [https://certbot.eff.org](https://certbot.eff.org) to learn the best way to use the DNS plugins on your system.\n\nOnce installed, you can find documentation on how to use each plugin at:\n\n- `certbot-dns-cloudflare`\n- `certbot-dns-cloudxns`\n- `certbot-dns-digitalocean`\n- `certbot-dns-dnssimple`\n- `certbot-dns-dnsmadeeasy`\n- `certbot-dns-gehirn`\n- `certbot-dns-google`\n- `certbot-dns-linode`\n- `certbot-dns-luadns`\n- `certbot-dns-nsone`\n- `certbot-dns-ovh`\n- `certbot-dns-rfc2136`\n• certbot-dns-route53\n• certbot-dns-sakuracloud\n\n4.2.6 Manual\n\nIf you’d like to obtain a certificate running certbot on a machine other than your target webserver or perform the steps for domain validation yourself, you can use the manual plugin. While hidden from the UI, you can use the plugin to obtain a certificate by specifying certonly and --manual on the command line. This requires you to copy and paste commands into another terminal session, which may be on a different computer.\n\nThe manual plugin can use either the http or the dns challenge. You can use the --preferred-challenges option to choose the challenge of your preference.\n\nThe http challenge will ask you to place a file with a specific name and specific content in the /.well-known/acme-challenge/ directory directly in the top-level directory (“web root”) containing the files served by your webserver. In essence it’s the same as the webroot plugin, but not automated.\n\nWhen using the dns challenge, certbot will ask you to place a TXT DNS record with specific contents under the domain name consisting of the hostname for which you want a certificate issued, prepended by _acme-challenge.\n\nFor example, for the domain example.com, a zone file entry would look like:\n\n```text\n_acme-challenge.example.com. 300 IN TXT \"gfj9Xq...Rg85nM\"\n```\n\nRenewal with the manual plugin\n\nCertificates created using --manual do not support automatic renewal unless combined with an authentication hook script via --manual-auth-hook to automatically set up the required HTTP and/or TXT challenges.\n\nIf you can use one of the other plugins which support autorenewal to create your certificate, doing so is highly recommended.\n\nTo manually renew a certificate using --manual without hooks, repeat the same certbot --manual command you used to create the certificate originally. As this will require you to copy and paste new HTTP files or DNS TXT records, the command cannot be automated with a cron job.\n\n4.2.7 Combining plugins\n\nSometimes you may want to specify a combination of distinct authenticator and installer plugins. To do so, specify the authenticator plugin with --authenticator or -a and the installer plugin with --installer or -i.\n\nFor instance, you could create a certificate using the webroot plugin for authentication and the apache plugin for installation.\n\n```bash\ncertbot run -a webroot -i apache -w /var/www/html -d example.com\n```\n\nOr you could create a certificate using the manual plugin for authentication and the nginx plugin for installation. (Note that this certificate cannot be renewed automatically.)\n\n```bash\ncertbot run -a manual -i nginx -d example.com\n```\n4.2.8 Third-party plugins\n\nThere are also a number of third-party plugins for the client, provided by other developers. Many are beta/experimental, but some are already in widespread use:\n\n<table>\n<thead>\n<tr>\n<th>Plugin</th>\n<th>Auth</th>\n<th>Inst</th>\n<th>Notes</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>haproxy</td>\n<td>Y</td>\n<td>Y</td>\n<td>Integration with the HAProxy load balancer</td>\n</tr>\n<tr>\n<td>s3front</td>\n<td>Y</td>\n<td>Y</td>\n<td>Integration with Amazon CloudFront distribution of S3 buckets</td>\n</tr>\n<tr>\n<td>gandi</td>\n<td>Y</td>\n<td>N</td>\n<td>Obtain certificates via the Gandi LiveDNS API</td>\n</tr>\n<tr>\n<td>varnish</td>\n<td>Y</td>\n<td>N</td>\n<td>Obtain certificates via a Varnish server</td>\n</tr>\n<tr>\n<td>external-auth</td>\n<td>Y</td>\n<td>Y</td>\n<td>A plugin for convenient scripting</td>\n</tr>\n<tr>\n<td>pritunl</td>\n<td>N</td>\n<td>Y</td>\n<td>Install certificates in pritunl distributed OpenVPN servers</td>\n</tr>\n<tr>\n<td>proxmox</td>\n<td>N</td>\n<td>Y</td>\n<td>Install certificates in Proxmox Virtualization servers</td>\n</tr>\n<tr>\n<td>dns-standalone</td>\n<td>Y</td>\n<td>N</td>\n<td>Obtain certificates via an integrated DNS server</td>\n</tr>\n<tr>\n<td>dns-ispconfig</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication using ISPConfig as DNS server</td>\n</tr>\n<tr>\n<td>dns-clouddns</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication using CloudDNS API</td>\n</tr>\n<tr>\n<td>dns-lightsail</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication using Amazon Lightsail DNS API</td>\n</tr>\n<tr>\n<td>dns-inwx</td>\n<td>Y</td>\n<td>Y</td>\n<td>DNS Authentication for INWX through the XML API</td>\n</tr>\n<tr>\n<td>dns-azure</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication using Azure DNS</td>\n</tr>\n<tr>\n<td>dns-godaddy</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication using Godaddy DNS</td>\n</tr>\n<tr>\n<td>dns-yandexcloud</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication using Yandex Cloud DNS</td>\n</tr>\n<tr>\n<td>dns-bunny</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication using BunnyDNS</td>\n</tr>\n<tr>\n<td>njalla</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication for njalla</td>\n</tr>\n<tr>\n<td>DuckDNS</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication for DuckDNS</td>\n</tr>\n<tr>\n<td>Porkbun</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication for Porkbun</td>\n</tr>\n<tr>\n<td>Infomaniak</td>\n<td>Y</td>\n<td>N</td>\n<td>DNS Authentication using Infomaniak Domains API</td>\n</tr>\n</tbody>\n</table>\n\nIf you’re interested, you can also write your own plugin.\n\n4.3 Managing certificates\n\nTo view a list of the certificates Certbot knows about, run the certificates subcommand:\n\ncertbot certificates\n\nThis returns information in the following format:\n\nFound the following certificates:\nCertificate Name: example.com\n Domains: example.com, www.example.com\n Expiry Date: 2017-02-19 19:53:00-00:00 (VALID: 30 days)\n Certificate Path: /etc/letsencrypt/live/example.com/fullchain.pem\n Key Type: RSA\n Private Key Path: /etc/letsencrypt/live/example.com/privkey.pem\n\nCertificate Name shows the name of the certificate. Pass this name using the --cert-name flag to specify a particular certificate for the run, certonly, certificates, renew, and delete commands. Example:\n\ncertbot certonly --cert-name example.com\n4.3.1 Re-creating and Updating Existing Certificates\n\nYou can use `certonly` or `run` subcommands to request the creation of a single new certificate even if you already have an existing certificate with some of the same domain names.\n\nIf a certificate is requested with `run` or `certonly` specifying a certificate name that already exists, Certbot updates the existing certificate. Otherwise a new certificate is created and assigned the specified name.\n\nThe `--force-renewal`, `--duplicate`, and `--expand` options control Certbot's behavior when re-creating a certificate with the same name as an existing certificate. If you don't specify a requested behavior, Certbot may ask you what you intended.\n\n`--force-renewal` tells Certbot to request a new certificate with the same domains as an existing certificate. Each domain must be explicitly specified via `-d`. If successful, this certificate is saved alongside the earlier one and symbolic links (the “live” reference) will be updated to point to the new certificate. This is a valid method of renewing a specific individual certificate.\n\n`--duplicate` tells Certbot to create a separate, unrelated certificate with the same domains as an existing certificate. This certificate is saved completely separately from the prior one. Most users will not need to issue this command in normal circumstances.\n\n`--expand` tells Certbot to update an existing certificate with a new certificate that contains all of the old domains and one or more additional new domains. With the `--expand` option, use the `-d` option to specify all existing domains and one or more new domains.\n\nExample:\n\n```\ncertbot --expand -d existing.com,example.com,newdomain.com\n```\n\nIf you prefer, you can specify the domains individually like this:\n\n```\ncertbot --expand -d existing.com -d example.com -d newdomain.com\n```\n\nConsider using `--cert-name` instead of `--expand`, as it gives more control over which certificate is modified and it lets you remove domains as well as adding them.\n\n`--allow-subset-of-names` tells Certbot to continue with certificate generation if only some of the specified domain authorizations can be obtained. This may be useful if some domains specified in a certificate no longer point at this system.\n\nWhenever you obtain a new certificate in any of these ways, the new certificate exists alongside any previously obtained certificates, whether or not the previous certificates have expired. The generation of a new certificate counts against several rate limits that are intended to prevent abuse of the ACME protocol, as described here.\n\n4.3.2 Changing a Certificate's Domains\n\nThe `--cert-name` flag can also be used to modify the domains a certificate contains, by specifying new domains using the `-d` or `--domains` flag. If certificate `example.com` previously contained `example.com` and `www.example.com`, it can be modified to only contain `example.com` by specifying only `example.com` with the `-d` or `--domains` flag.\n\nExample:\n\n```\ncertbot certonly --cert-name example.com -d example.com\n```\n\nThe same format can be used to expand the set of domains a certificate contains, or to replace that set entirely:\n\n```\ncertbot certonly --cert-name example.com -d example.org,www.example.org\n```\n4.3.3 Using ECDSA keys\n\nAs of version 1.10, Certbot supports two types of private key algorithms: rsa and ecdsa. The type of key used by Certbot can be controlled through the --key-type option. You can also use the --elliptic-curve option to control the curve used in ECDSA certificates.\n\n**Warning:** If you obtain certificates using ECDSA keys, you should be careful not to downgrade your Certbot installation since ECDSA keys are not supported by older versions of Certbot. Downgrades like this are possible if you switch from something like the snaps or pip to packages provided by your operating system which often lag behind.\n\n**Changing existing certificates from RSA to ECDSA**\n\nUnless you are aware that you need to support very old HTTPS clients that are not supported by most sites, you can safely just transition your site to use ECDSA keys instead of RSA keys. To accomplish this if you have existing certificates managed by Certbot, you may freely change the certificate to a new private key.\n\nIf you want to use ECDSA keys for all certificates in the future, you can simply add the following line to Certbot's configuration file\n\n```\nkey-type = ecdsa\n```\n\nAfter this option is set, newly obtained certificates will use ECDSA keys. This includes certificates managed by Certbot that previously used RSA keys.\n\nIf you want to change a single certificate to use ECDSA keys, you’ll need to issue a new Certbot command setting --key-type ecdsa on the command line like\n\n```\ncertbot renew --key-type ecdsa --cert-name example.com --force-renewal\n```\n\n**Obtaining ECDSA certificates in addition to RSA certificates**\n\nWhen Certbot configures the certificates it obtains with Apache or Nginx, all HTTPS clients that we try to support can use certificates with ECDSA keys. If, however, you are aware of having a specific need to support very old TLS clients, you may want to obtain both ECDSA and RSA certificates for the same domains. Certbot can only configure Apache or Nginx to use a single certificate, however, you could manually configure your software to use the different certificates depending on your needs.\n\nWhen obtaining both ECDSA and RSA certificates for the same domains with Certbot, we recommend using the --cert-name option to give your certificates names so that you can easily identify them. For instance, you may want to append “ecdsa” to the name of your ECDSA certificate by using a command like\n\n```\ncertbot certonly --key-type ecdsa --cert-name example.com-ecdsa\n```\n4.3.4 Revoking certificates\n\nIf you need to revoke a certificate, use the `revoke` subcommand to do so.\n\nA certificate may be revoked by providing its name (see `certbot certificates`) or by providing its path directly:\n\n```\ncertbot revoke --cert-name example.com\n```\n```\ncertbot revoke --cert-path /etc/letsencrypt/live/example.com/cert.pem\n```\n\nIf the certificate being revoked was obtained via the `--staging`, `--test-cert` or a non-default `--server` flag, that flag must be passed to the `revoke` subcommand.\n\n**Note:** After revocation, Certbot will (by default) ask whether you want to delete the certificate. Unless deleted, Certbot will try to renew revoked certificates the next time `certbot renew` runs.\n\nYou can also specify the reason for revoking your certificate by using the `reason` flag. Reasons include unspecified which is the default, as well as `keycompromise`, `affiliationchanged`, `superseded`, and `cessationofoperation`:\n\n```\ncertbot revoke --cert-name example.com --reason keycompromise\n```\n\n**Revoking by account key or certificate private key**\n\nBy default, Certbot will try revoke the certificate using your ACME account key. If the certificate was created from the same ACME account, the revocation will be successful.\n\nIf you instead have the corresponding private key file to the certificate you wish to revoke, use `--key-path` to perform the revocation from any ACME account:\n\n```\ncertbot revoke --cert-path /etc/letsencrypt/live/example.com/cert.pem --key-path /etc/letsencrypt/live/example.com/privkey.pem\n```\n\n4.3.5 Deleting certificates\n\nIf you need to delete a certificate, use the `delete` subcommand.\n\n**Note:** Read this and the `Safely deleting certificates` sections carefully. This is an irreversible operation and must be done with care.\n\nCertbot does not automatically revoke a certificate before deleting it. If you’re no longer using a certificate and don’t plan to use it anywhere else, you may want to follow the instructions in `Revoking certificates` instead. Generally, there’s no need to revoke a certificate if its private key has not been compromised, but you may still receive expiration emails from Let’s Encrypt unless you revoke.\n\n**Note:** Do not manually delete certificate files from inside `/etc/letsencrypt/`. Always use the `delete` subcommand.\n\nA certificate may be deleted by providing its name with `--cert-name`. You may find its name using `certbot certificates`.\nOtherwise, you will be prompted to choose one or more certificates to delete:\n\n```bash\ncertbot delete --cert-name example.com\n# or to choose from a list:\ncertbot delete\n```\n\n## Safely deleting certificates\n\nDeleting a certificate without following the proper steps can result in a non-functioning server. To safely delete a certificate, follow all the steps below to make sure that references to a certificate are removed from the configuration of any installed server software (Apache, nginx, Postfix, etc) *before* deleting the certificate.\n\nTo explain further, when installing a certificate, Certbot modifies Apache or nginx’s configuration to load the certificate and its private key from the `/etc/letsencrypt/live/` directory. Before deleting a certificate, it is necessary to undo that modification, by removing any references to the certificate from the webserver’s configuration files.\n\nFollow these steps to safely delete a certificate:\n\n1. Find all references to the certificate (substitute `example.com` in the command for the name of the certificate you wish to delete):\n\n ```bash\n sudo bash -c 'grep -R live/example.com /etc/{nginx,httpd,apache2}'\n ```\n\n If there are no references found, skip directly to Step 4.\n\n If some references are found, they will look something like:\n\n ```\n /etc/apache2/sites-available/000-default-le-ssl.conf:SSLCertificateFile /etc/letsencrypt/live/example.com/fullchain.pem\n /etc/apache2/sites-available/000-default-le-ssl.conf:SSLCertificateKeyFile /etc/letsencrypt/live/example.com/privkey.pem\n ```\n\n2. You will need a self-signed certificate to replace the certificate you are deleting. The following command will generate one for you, saving the certificate at `/etc/letsencrypt/self-signed-cert.pem` and its private key at `/etc/letsencrypt/self-signed-privkey.pem`:\n\n ```bash\n sudo openssl req -nodes -batch -x509 -newkey rsa:2048 -keyout /etc/letsencrypt/self-signed-privkey.pem -out /etc/letsencrypt/self-signed-cert.pem -days 356\n ```\n\n3. For each reference found in Step 1, open the file in a text editor and replace the reference to the existing certificate with a reference to the self-signed certificate.\n\n Continuing from the previous example, you would open `/etc/apache2/sites-available/000-default-le-ssl.conf` in a text editor and modify the two matching lines of text to instead say:\n\n ```\n SSLCertificateFile /etc/letsencrypt/self-signed-cert.pem\n SSLCertificateKeyFile /etc/letsencrypt/self-signed-privkey.pem\n ```\n\n4. It is now safe to delete the certificate. Do so by running:\n\n ```bash\n sudo certbot delete --cert-name example.com\n ```\n4.3.6 Renewing certificates\n\n**Note:** Let’s Encrypt CA issues short-lived certificates (90 days). Make sure you renew the certificates at least once in 3 months.\n\nSee also:\n\nMost Certbot installations come with automatic renewal out of the box. See *Automated Renewals* for more details.\n\nSee also:\n\nUsers of the *Manual* plugin should note that --manual certificates will not renew automatically, unless combined with authentication hook scripts. See *Renewal with the manual plugin*.\n\nAs of version 0.10.0, Certbot supports a *renew* action to check all installed certificates for impending expiry and attempt to renew them. The simplest form is simply\n\ncertbot renew\n\nThis command attempts to renew any previously-obtained certificates that expire in less than 30 days. The same plugin and options that were used at the time the certificate was originally issued will be used for the renewal attempt, unless you specify other plugins or options. Unlike *certonly*, *renew* acts on multiple certificates and always takes into account whether each one is near expiry. Because of this, *renew* is suitable (and designed) for automated use, to allow your system to automatically renew each certificate when appropriate. Since *renew* only renews certificates that are near expiry it can be run as frequently as you want - since it will usually take no action.\n\nThe *renew* command includes hooks for running commands or scripts before or after a certificate is renewed. For example, if you have a single certificate obtained using the *standalone* plugin, you might need to stop the webserver before renewing so standalone can bind to the necessary ports, and then restart it after the plugin is finished. Example:\n\ncertbot renew --pre-hook \"service nginx stop\" --post-hook \"service nginx start\"\n\nIf a hook exits with a non-zero exit code, the error will be printed to *stderr* but renewal will be attempted anyway. A failing hook doesn’t directly cause Certbot to exit with a non-zero exit code, but since Certbot exits with a non-zero exit code when renewals fail, a failed hook causing renewal failures will indirectly result in a non-zero exit code. Hooks will only be run if a certificate is due for renewal, so you can run the above command frequently without unnecessarily stopping your webserver.\n\nWhen Certbot detects that a certificate is due for renewal, --pre-hook and --post-hook hooks run before and after each attempt to renew it. If you want your hook to run only after a successful renewal, use --deploy-hook in a command like this.\n\ncertbot renew --deploy-hook /path/to/deploy-hook-script\n\nYou can also specify hooks by placing files in subdirectories of Certbot’s configuration directory. Assuming your configuration directory is `/etc/letsencrypt`, any executable files found in `/etc/letsencrypt/renewal-hooks/pre`, `/etc/letsencrypt/renewal-hooks/deploy`, and `/etc/letsencrypt/renewal-hooks/post` will be run as pre, deploy, and post hooks respectively when any certificate is renewed with the *renew* subcommand. These hooks are run in alphabetical order and are not run for other subcommands. (The order the hooks are run is determined by the byte value of the characters in their filenames and is not dependent on your locale.)\n\nHooks specified in the command line, *configuration file*, or *renewal configuration files* are run as usual after running all hooks in these directories. One minor exception to this is if a hook specified elsewhere is simply the path to an executable file in the hook directory of the same type (e.g. your pre-hook is the path to an executable in `/etc/letsencrypt/renewal-hooks/pre`), the file is not run a second time. You can stop Certbot from automatically running executables found in these directories by including --no-directory-hooks on the command line.\n\nMore information about hooks can be found by running `certbot --help renew`.\n\n4.3. Managing certificates 21\nIf you’re sure that this command executes successfully without human intervention, you can add the command to `crontab` (since certificates are only renewed when they’re determined to be near expiry, the command can run on a regular basis, like every week or every day). In that case, you are likely to want to use the `-q` or `--quiet` quiet flag to silence all output except errors.\n\nIf you are manually renewing all of your certificates, the `--force-renewal` flag may be helpful; it causes the expiration time of the certificate(s) to be ignored when considering renewal, and attempts to renew each and every installed certificate regardless of its age. (This form is not appropriate to run daily because each certificate will be renewed every day, which will quickly run into the certificate authority rate limit.)\n\nNote that options provided to `certbot renew` will apply to every certificate for which renewal is attempted; for example, `certbot renew --rsa-key-size 4096` would try to replace every near-expiry certificate with an equivalent certificate using a 4096-bit RSA public key. If a certificate is successfully renewed using specified options, those options will be saved and used for future renewals of that certificate.\n\nAn alternative form that provides for more fine-grained control over the renewal process (while renewing specified certificates one at a time), is `certbot certonly` with the complete set of subject domains of a specific certificate specified via `-d` flags. You may also want to include the `-n` or `--noninteractive` flag to prevent blocking on user input (which is useful when running the command from cron).\n\n```\ncertbot certonly -n -d example.com -d www.example.com\n```\n\nAll of the domains covered by the certificate must be specified in this case in order to renew and replace the old certificate rather than obtaining a new one; don’t forget any `www.` domains! Specifying a subset of the domains creates a new, separate certificate containing only those domains, rather than replacing the original certificate. When run with a set of domains corresponding to an existing certificate, the `certonly` command attempts to renew that specific certificate.\n\nPlease note that the CA will send notification emails to the address you provide if you do not renew certificates that are about to expire.\n\nCertbot is working hard to improve the renewal process, and we apologize for any inconvenience you encounter in integrating these commands into your individual environment.\n\n---\n\n**4.3.7 Modifying the Renewal Configuration of Existing Certificates**\n\nWhen creating a certificate, Certbot will keep track of all of the relevant options chosen by the user. At renewal time, Certbot will remember these options and apply them once again.\n\nSometimes, you may encounter the need to change some of these options for future certificate renewals. To achieve this, you will need to perform the following steps:\n\n1. Perform a **dry run renewal** with the amended options on the command line. This allows you to confirm that the change is valid and will result in successful future renewals.\n\n2. If the dry run is successful, perform a **live renewal** of the certificate. This will persist the change for future renewals. If the certificate is not yet due to expire, you will need to force a renewal using `--force-renewal`.\n\n**Note:** Rate limits from the certificate authority may prevent you from performing multiple renewals in a short period of time. It is strongly recommended to perform the second step only once, when you have decided on what options should change.\nAs a practical example, if you were using the `webroot` authenticator and had relocated your website to another directory, you would need to change the `--webroot-path` to the new directory. Following the above advice:\n\n1. Perform a `dry-run renewal` of the individual certificate with the amended options:\n\n```bash\ncertbot renew --cert-name example.com --webroot-path /path/to/new/location --dry-run\n```\n\n2. If the dry-run was successful, make the change permanent by performing a `live renewal` of the certificate with the amended options, including `--force-renewal`:\n\n```bash\ncertbot renew --cert-name example.com --webroot-path /path/to/new/location --force-renewal\n```\n\n`--cert-name` selects the particular certificate to be modified. Without this option, all certificates will be selected.\n\n`--webroot-path` is the option intended to be changed. All other previously selected options will be kept the same and do not need to be included in the command.\n\nFor advanced certificate management tasks, it is also possible to manually modify the certificate’s renewal configuration file, but this is discouraged since it can easily break Certbot’s ability to renew your certificates. These renewal configuration files are located at `/etc/letsencrypt/renewal/CERTNAME.conf`. If you choose to modify the renewal configuration file we advise you to make a backup of the file beforehand and test its validity with the `certbot renew --dry-run` command.\n\n**Warning:** Manually modifying files under `/etc/letsencrypt/renewal/` can damage them if done improperly and we do not recommend doing so.\n\n### 4.3.8 Automated Renewals\n\nMost Certbot installations come with automatic renewals preconfigured. This is done by means of a scheduled task which runs `certbot renew` periodically.\n\nIf you are unsure whether you need to configure automated renewal:\n\n1. Review the instructions for your system and installation method at [https://certbot.eff.org/instructions](https://certbot.eff.org/instructions). They will describe how to set up a scheduled task, if necessary. If no step is listed, your system comes with automated renewal pre-installed, and you should not need to take any additional actions.\n\n2. On Linux and BSD, you can check to see if your installation method has pre-installed a timer for you. To do so, look for the `certbot renew` command in either your system’s crontab (typically `/etc/crontab` or `/etc/cron.*/*`) or systemd timers (`systemctl list-timers`).\n\n3. If you’re still not sure, you can configure automated renewal manually by following the steps in the next section. Certbot has been carefully engineered to handle the case where both manual automated renewal and pre-installed automated renewal are set up.\nSetting up automated renewal\n\nIf you think you may need to set up automated renewal, follow these instructions to set up a scheduled task to automatically renew your certificates in the background. If you are unsure whether your system has a pre-installed scheduled task for Certbot, it is safe to follow these instructions to create one.\n\n**Note:** If you’re using Windows, these instructions are not necessary as Certbot on Windows comes with a scheduled task for automated renewal pre-installed.\n\nIf you are using macOS and installed Certbot using Homebrew, follow the instructions at [https://certbot.eff.org/instructions](https://certbot.eff.org/instructions) to set up automated renewal. The instructions below are not applicable on macOS.\n\nRun the following line, which will add a cron job to `/etc/crontab`:\n\n```\nSLEEPTIME=$(awk 'BEGIN{srand(); print int(rand()*(3600+1))}'); echo \"0 0,12 * * * root → sleep $SLEEPTIME && certbot renew -q\" | sudo tee -a /etc/crontab > /dev/null\n```\n\nIf you needed to stop your webserver to run Certbot, you’ll want to add `pre` and `post` hooks to stop and start your webserver automatically. For example, if your webserver is HAProxy, run the following commands to create the hook files in the appropriate directory:\n\n```\nsudo sh -c 'printf \n#!/bin/sh\nservice haproxy stop\n\" > /etc/letsencrypt/renewal-hooks/pre/haproxy.sh\ndsuo sh -c 'printf \n#!/bin/sh\nservice haproxy start\n\" > /etc/letsencrypt/renewal-hooks/post/haproxy.sh\ndsuo chmod 755 /etc/letsencrypt/renewal-hooks/pre/haproxy.sh\ndsuo chmod 755 /etc/letsencrypt/renewal-hooks/post/haproxy.sh\n```\n\nCongratulations, Certbot will now automatically renew your certificates in the background.\n\nIf you are interested in learning more about how Certbot renews your certificates, see the **Renewing certificates** section above.\n\n### 4.4 Where are my certificates?\n\nAll generated keys and issued certificates can be found in `/etc/letsencrypt/live/$domain`, where `$domain` is the certificate name (see the note below). Rather than copying, please point your (web) server configuration directly to those files (or create symlinks). During the renewal, `/etc/letsencrypt/live` is updated with the latest necessary files.\n\n**Note:** The certificate name `$domain` used in the path `/etc/letsencrypt/live/$domain` follows this convention:\n\n- it is the name given to `--cert-name`,\n- if `--cert-name` is not set by the user it is the first domain given to `--domains`,\n- if the first domain is a wildcard domain (eg. `*.example.com`) the certificate name will be `example.com`,\n- if a name collision would occur with a certificate already named `example.com`, the new certificate name will be constructed using a numerical sequence as `example.com-001`.\n\nFor historical reasons, the containing directories are created with permissions of `0700` meaning that certificates are accessible only to servers that run as the root user. **If you will never downgrade to an older version of Certbot**, then you can safely fix this using `chmod 0755 /etc/letsencrypt/{live,archive}`.\nFor servers that drop root privileges before attempting to read the private key file, you will also need to use chgrp and chmod 0640 to allow the server to read /etc/letsencrypt/live/$domain/privkey.pem.\n\nNote: /etc/letsencrypt/archive and /etc/letsencrypt/keys contain all previous keys and certificates, while /etc/letsencrypt/live symlinks to the latest versions.\n\nThe following files are available:\n\n**privkey.pem** Private key for the certificate.\n\n**Warning:** This *must be kept secret at all times!* Never share it with anyone, including Certbot developers. You cannot put it into a safe, however - your server still needs to access this file in order for SSL/TLS to work.\n\nNote: As of Certbot version 0.29.0, private keys for new certificate default to 0660. Any changes to the group mode or group owner (gid) of this file will be preserved on renewals.\n\nThis is what Apache needs for SSLCertificateKeyFile, and Nginx for ssl_certificate_key.\n\n**fullchain.pem** All certificates, including server certificate (aka leaf certificate or end-entity certificate). The server certificate is the first one in this file, followed by any intermediates.\n\nThis is what Apache >= 2.4.8 needs for SSLCertificateFile, and what Nginx needs for ssl_certificate.\n\n**cert.pem** and **chain.pem (less common)** cert.pem contains the server certificate by itself, and chain.pem contains the additional intermediate certificate or certificates that web browsers will need in order to validate the server certificate. If you provide one of these files to your web server, you must provide both of them, or some browsers will show “This Connection is Untrusted” errors for your site, some of the time.\n\nApache < 2.4.8 needs these for SSLCertificateFile, and SSLCertificateChainFile, respectively.\n\nIf you're using OCSP stapling with Nginx >= 1.3.7, chain.pem should be provided as the ssl_trusted_certificate to validate OCSP responses.\n\nNote: All files are PEM-encoded. If you need other format, such as DER or PFX, then you could convert using openssl. You can automate that with --deploy-hook if you’re using automatic renewal.\n\n### 4.5 Pre and Post Validation Hooks\n\nCertbot allows for the specification of pre and post validation hooks when run in manual mode. The flags to specify these scripts are --manual-auth-hook and --manual-cleanup-hook respectively and can be used as follows:\n\n```\n```\n\nThis will run the authenticator.sh script, attempt the validation, and then run the cleanup.sh script. Additionally certbot will pass relevant environment variables to these scripts:\n\n- **CERTBOT_DOMAIN**: The domain being authenticated\n- **CERTBOT_VALIDATION**: The validation string\n- **CERTBOT_TOKEN**: Resource name part of the HTTP-01 challenge (HTTP-01 only)\n- **CERTBOT_REMAINING_CHALLENGES**: Number of challenges remaining after the current challenge\n- **CERTBOT_ALL_DOMAINS**: A comma-separated list of all domains challenged for the current certificate\n\nAdditionally for cleanup:\n- **CERTBOT_AUTH_OUTPUT**: Whatever the auth script wrote to stdout\n\nExample usage for HTTP-01:\n\n```\ncertbot certonly --manual --preferred-challenges=http --manual-auth-hook /path/to/http/...\nauthenticator.sh --manual-cleanup-hook /path/to/http/cleanup.sh -d secure.example.com\n```\n\n```\n#!/bin/bash\necho $CERTBOT_VALIDATION > /var/www/htdocs/.well-known/acme-challenge/$CERTBOT_TOKEN\n```\n\n```\n#!/bin/bash\nrm -f /var/www/htdocs/.well-known/acme-challenge/$CERTBOT_TOKEN\n```\n\nExample usage for DNS-01 (Cloudflare API v4) (for example purposes only, do not use as-is)\n\n```\ncertbot certonly --manual --preferred-challenges=dns --manual-auth-hook /path/to/dns/...\nauthenticator.sh --manual-cleanup-hook /path/to/dns/cleanup.sh -d secure.example.com\n```\n\n```\n#!/bin/bash\n\n# Get your API key from https://www.cloudflare.com/a/account/my-account\nAPI_KEY=\"your-api-key\"\nEMAIL=\"your.email@example.com\"\n\n# Strip only the top domain to get the zone id\nDOMAIN=$(expr match \"$CERTBOT_DOMAIN\" '.*\\.(.*)..*')\n\n# Get the Cloudflare zone id\nZONE_EXTRA_PARAMS=\"status=active&page=1&per_page=20&order=status&direction=desc&match=all\"\nZONE_ID=$(curl -s -X GET \"https://api.cloudflare.com/client/v4/zones?name=$DOMAIN&$ZONE_EXTRA_PARAMS\" -H \"X-Auth-Email: $EMAIL\" -H \"X-Auth-Key: $API_KEY\" -H \"Content-Type: application/json\" | python -c \"import sys,json;print(json.load(sys.stdin)['result'][0]['id'])\")\n\n# Create TXT record\nCREATE_DOMAIN=\"_acme-challenge.$CERTBOT_DOMAIN\"\nRECORD_ID=$(curl -s -X POST \"https://api.cloudflare.com/client/v4/zones/$ZONE_ID/dns_records\" -H \"X-Auth-Email: $EMAIL\" -H \"X-Auth-Key: $API_KEY\" -H \"Content-Type: application/json\" --data \"\\nname=$CREATE_DOMAIN\\ntype=txt\\ncontent=\"$CERTBOT_VALIDATION\"\")\n```\n\n(continues on next page)\n--data '{\"type\": \"TXT\", \"name\": \"$CREATE_DOMAIN\", \"content\": \"$CERTBOT_VALIDATION\", \"ttl\": 120}'}\n|\npython -c \"import sys, json; print(json.load(sys.stdin)['result']['id'])\"\n\n# Save info for cleanup\nif [ ! -d /tmp/CERTBOT_$CERTBOT_DOMAIN ]; then\n mkdir -m 0700 /tmp/CERTBOT_$CERTBOT_DOMAIN\nfi\n\n# Get your API key from https://www.cloudflare.com/a/account/my-account\nAPI_KEY=\"your-api-key\"\nEMAIL=\"your.email@example.com\"\n\nif [ -f /tmp/CERTBOT_$CERTBOT_DOMAIN/ZONE_ID ]; then\n ZONE_ID=$(cat /tmp/CERTBOT_$CERTBOT_DOMAIN/ZONE_ID)\n rm -f /tmp/CERTBOT_$CERTBOT_DOMAIN/ZONE_ID\nfi\n\nif [ -f /tmp/CERTBOT_$CERTBOT_DOMAIN/RECORD_ID ]; then\n RECORD_ID=$(cat /tmp/CERTBOT_$CERTBOT_DOMAIN/RECORD_ID)\n rm -f /tmp/CERTBOT_$CERTBOT_DOMAIN/RECORD_ID\nfi\n\n# Remove the challenge TXT record from the zone\nif [ -n \"$(ZONE_ID)\" ]; then\n if [ -n \"$(RECORD_ID)\" ]; then\n curl -s -X DELETE \"https://api.cloudflare.com/client/v4/zones/$ZONE_ID/dns_records/$RECORD_ID\" \\\n -H \"X-Auth-Email: $EMAIL\" \\\n -H \"X-Auth-Key: $API_KEY\" \\\n -H \"Content-Type: application/json\"\n fi\nfi\n4.6 Changing the ACME Server\n\nBy default, Certbot uses Let’s Encrypt’s production server at https://acme-v02.api.letsencrypt.org/directory. You can tell Certbot to use a different CA by providing --server on the command line or in a configuration file with the URL of the server’s ACME directory. For example, if you would like to use Let’s Encrypt’s staging server, you would add --server https://acme-staging-v02.api.letsencrypt.org/directory to the command line.\n\nIf Certbot does not trust the SSL certificate used by the ACME server, you can use the REQUESTS_CA_BUNDLE environment variable to override the root certificates trusted by Certbot. Certbot uses the requests library, which does not use the operating system trusted root store.\n\nIf you use --server to specify an ACME CA that implements the standardized version of the spec, you may be able to obtain a certificate for a wildcard domain. Some CAs (such as Let’s Encrypt) require that domain validation for wildcard domains must be done through modifications to DNS records which means that the dns-01 challenge type must be used. To see a list of Certbot plugins that support this challenge type and how to use them, see plugins.\n\n4.7 Lock Files\n\nWhen processing a validation Certbot writes a number of lock files on your system to prevent multiple instances from overwriting each other’s changes. This means that by default two instances of Certbot will not be able to run in parallel.\n\nSince the directories used by Certbot are configurable, Certbot will write a lock file for all of the directories it uses. This include Certbot’s --work-dir, --logs-dir, and --config-dir. By default these are /var/lib/letsencrypt, /var/log/letsencrypt, and /etc/letsencrypt respectively. Additionally if you are using Certbot with Apache or nginx it will lock the configuration folder for that program, which are typically also in the /etc directory.\n\nNote that these lock files will only prevent other instances of Certbot from using those directories, not other processes. If you’d like to run multiple instances of Certbot simultaneously you should specify different directories as the --work-dir, --logs-dir, and --config-dir for each instance of Certbot that you would like to run.\n\n4.8 Configuration file\n\nCertbot accepts a global configuration file that applies its options to all invocations of Certbot. Certificate specific configuration choices should be set in the .conf files that can be found in /etc/letsencrypt/renewal.\n\nBy default no cli.ini file is created (though it may exist already if you installed Certbot via a package manager, for instance). After creating one it is possible to specify the location of this configuration file with certbot --config cli.ini (or shorter -c cli.ini). An example configuration file is shown below:\n\n```\n# This is an example of the kind of things you can do in a configuration file.\n# All flags used by the client can be configured here. Run Certbot with\n# \"--help\" to learn more about the available options.\n#\n# Note that these options apply automatically to all use of Certbot for\n# obtaining or renewing certificates, so options specific to a single\n# certificate on a system with several certificates should not be placed\n# here.\n\n# Use ECC for the private key\nkey-type = ecdsa\nelliptic-curve = secp384r1\n```\n(continues on next page)\n# Use a 4096 bit RSA key instead of 2048\nrsa-key-size = 4096\n\n# Uncomment and update to register with the specified e-mail address\n# email = foo@example.com\n\n# Uncomment to use the standalone authenticator on port 443\n# authenticator = standalone\n\n# Uncomment to use the webroot authenticator. Replace webroot-path with the\n# path to the public_html / webroot folder being served by your web server.\n# authenticator = webroot\n# webroot-path = /usr/share/nginx/html\n\n# Uncomment to automatically agree to the terms of service of the ACME server\n# agree-tos = true\n\n# An example of using an alternate ACME server that uses EAB credentials\n# server = https://acme.sectigo.com/v2/InCommonRSAOV\n# eab-kid = somestringofstuffwithoutquotes\n# eab-hmac-key = yaddayaddahexhexnotquoted\n\nBy default, the following locations are searched:\n\n- /etc/letsencrypt/cli.ini\n- $XDG_CONFIG_HOME/letsencrypt/cli.ini (or ~/.config/letsencrypt/cli.ini if\n $XDG_CONFIG_HOME is not set).\n\nSince this configuration file applies to all invocations of certbot it is incorrect to list domains in it. Listing domains in cli.ini may prevent renewal from working. Additionally due to how arguments in cli.ini are parsed, options which wish to not be set should not be listed. Options set to false will instead be read as being set to true by older versions of Certbot, since they have been listed in the config file.\n\n### 4.9 Log Rotation\n\nBy default certbot stores status logs in /var/log/letsencrypt. By default certbot will begin rotating logs once there are 1000 logs in the log directory. Meaning that once 1000 files are in /var/log/letsencrypt Certbot will delete the oldest one to make room for new logs. The number of subsequent logs can be changed by passing the desired number to the command line flag --max-log-backups. Setting this flag to 0 disables log rotation entirely, causing certbot to always append to the same log file.\n\n**Note:** Some distributions, including Debian and Ubuntu, disable certbot's internal log rotation in favor of a more traditional logrotate script. If you are using a distribution's packages and want to alter the log rotation, check /etc/logrotate.d/ for a certbot rotation script.\n4.10 Certbot command-line options\n\nCertbot supports a lot of command line options. Here's the full list, from `certbot --help all`:\n\n```\nusage:\ncertbot [SUBCOMMAND] [options] [-d DOMAIN] [-d DOMAIN] ...\n\nCertbot can obtain and install HTTPS/TLS/SSL certificates. By default, it will attempt to use a webserver both for obtaining and installing the certificate. The most common SUBCOMMANDS and flags are:\n\nobtain, install, and renew certificates:\n (default) run Obtain & install a certificate in your current webserver\n certonly Obtain or renew a certificate, but do not install it\n renew Renew all previously obtained certificates that are near expiry\n enhance Add security enhancements to your existing configuration\n -d DOMAINS Comma-separated list of domains to obtain a certificate for\n\n --apache Use the Apache plugin for authentication & installation\n --standalone Run a standalone webserver for authentication\n --nginx Use the Nginx plugin for authentication & installation\n --webroot Place files in a server's webroot folder for authentication\n --manual Obtain certificates interactively, or using shell script hooks\n -n Run non-interactively\n --test-cert Obtain a test certificate from a staging server\n --dry-run Test \"renew\" or \"certonly\" without saving any certificates to disk\n\nmanage certificates:\n certificates Display information about certificates you have from Certbot\n revoke Revoke a certificate (supply --cert-name or --cert-path)\n delete Delete a certificate (supply --cert-name)\n\nmanage your account:\n register Create an ACME account\n unregister Deactivate an ACME account\n update_account Update an ACME account\n show_account Display account details\n --agree-tos Agree to the ACME server's Subscriber Agreement\n -m EMAIL Email address for important account notifications\n\noptions:\n -h, --help show this help message and exit\n -c CONFIG_FILE, --config CONFIG_FILE\n path to config file (default: /etc/letsencrypt/cli.ini\n and ~/.config/letsencrypt/cli.ini)\n -v, --verbose This flag can be used multiple times to incrementally\n increase the verbosity of output, e.g. -vvv. (default: 0)\n --max-log-backups MAX_LOG_BACKUPS\n Specifies the maximum number of backup logs that\n should be kept by Certbot's built in log rotation.\n Setting this flag to 0 disables log rotation entirely,\n\n(continues on next page)\n```\ncausing Certbot to always append to the same log file.\n(default: 1000)\n\n-n, --non-interactive, --noninteractive\nRun without ever asking for user input. This may require additional command line flags; the client will try to explain which ones are required if it finds one missing (default: False)\n\n--force-interactive\nForce Certbot to be interactive even if it detects it's not being run in a terminal. This flag cannot be used with the renew subcommand. (default: False)\n\n-d DOMAIN, --domains DOMAIN, --domain DOMAIN\nDomain names to apply. For multiple domains you can use multiple -d flags or enter a comma separated list of domains as a parameter. The first domain provided will be the subject CN of the certificate, and all domains will be Subject Alternative Names on the certificate. The first domain will also be used in some software user interfaces and as the file paths for the certificate and related material unless otherwise specified or you already have a certificate with the same name. In the case of a name collision it will append a number like 0001 to the file path name.\n(default: Ask)\n\n--eab-kid EAB_KID\nKey Identifier for External Account Binding (default: None)\n\n--eab-hmac-key EAB_HMAC_KEY\nHMAC key for External Account Binding (default: None)\n\n--cert-name CERTNAME\nCertificate name to apply. This name is used by Certbot for housekeeping and in file paths; it doesn't affect the content of the certificate itself. To see certificate names, run 'certbot certificates'. When creating a new certificate, specifies the new certificate's name. (default: the first provided domain or the name of an existing certificate on your system for the same domains)\n\n--dry-run\nPerform a test run of the client, obtaining test (invalid) certificates but not saving them to disk. This can currently only be used with the 'certonly' and 'renew' subcommands. Note: Although --dry-run tries to avoid making any persistent changes on a system, it is not completely side-effect free: if used with webserver authenticator plugins like apache and nginx, it makes and then reverts temporary config changes in order to obtain test certificates, and reloads webservers to deploy and then roll back those changes. It also calls --pre-hook and --post-hook commands if they are defined because they may be necessary to accurately simulate renewal. --deploy-hook commands are not called. (default: False)\n\n--debug-challenges\nAfter setting up challenges, wait for user input before submitting to CA. When used in combination with the `-v` option, the challenge URLs or FQDNs and their\nCertbot Documentation, Release 1.31.0\n\n---\n\n**expected return values are shown. (default: False)**\n\n--preferred-chain PREFERRED_CHAIN\nSet the preferred certificate chain. If the CA offers multiple certificate chains, prefer the chain whose topmost certificate was issued from this Subject Common Name. If no match, the default offered chain will be used. (default: None)\n\n--preferred-challenges PREF_CHALLS\nA sorted, comma delimited list of the preferred challenge to use during authorization with the most preferred challenge listed first (Eg, \"dns\" or \"http,dns\"). Not all plugins support all challenges. See https://certbot.eff.org/docs/using.html#plugins for details. ACME Challenges are versioned, but if you pick \"http\" rather than \"http-01\", Certbot will select the latest version automatically. (default: [])\n\n--issuance-timeout ISSUANCE_TIMEOUT\nThis option specifies how long (in seconds) Certbot will wait for the server to issue a certificate. (default: 90)\n\n--user-agent USER_AGENT\nSet a custom user agent string for the client. User agent strings allow the CA to collect high level statistics about success rates by OS, plugin and use case, and to know when to deprecate support for past Python versions and flags. If you wish to hide this information from the Let's Encrypt server, set this to \"\". (default: CertbotACMEClient/1.31.0 (certbot; OS_NAME OS_VERSION) Authenticator/XXX Installer/YYY (SUBCOMMAND; flags: FLAGS) Py/major.minor.patchlevel). The flags encoded in the user agent are: --duplicate, --force-renew, --allow-subset-of-names, -n, and whether any hooks are set.\n\n--user-agent-comment USER_AGENT_COMMENT\nAdd a comment to the default user agent string. May be used when repackaging Certbot or calling it from another tool to allow additional statistical data to be collected. Ignored if --user-agent is set. (Example: Foo-Wrapper/1.0) (default: None)\n\n### automation:\nFlags for automating execution & other tweaks\n\n--keep-until-expiring, --keep, --reinstall\nIf the requested certificate matches an existing certificate, always keep the existing one until it is due for renewal (for the 'run' subcommand this means reinstall the existing certificate). (default: Ask)\n\n--expand\nIf an existing certificate is a strict subset of the requested names, always expand and replace it with the additional names. (default: Ask)\n\n--version\nshow program's version number and exit\n\n(continues on next page)\n--force-renewal, --renew-by-default\n\nIf a certificate already exists for the requested domains, renew it now, regardless of whether it is near expiry. (Often --keep-until-expiring is more appropriate). Also implies --expand. (default: False)\n\n--renew-with-new-domains\n\nIf a certificate already exists for the requested certificate name but does not match the requested domains, renew it now, regardless of whether it is near expiry. (default: False)\n\n--reuse-key\n\nWhen renewing, use the same private key as the existing certificate. (default: False)\n\n--no-reuse-key\n\nWhen renewing, do not use the same private key as the existing certificate. Not reusing private keys is the default behavior of Certbot. This option may be used to unset --reuse-key on an existing certificate. (default: False)\n\n--new-key\n\nWhen renewing or replacing a certificate, generate a new private key, even if --reuse-key is set on the existing certificate. Combining --new-key and --reuse-key will result in the private key being replaced and then reused in future renewals. (default: False)\n\n--allow-subset-of-names\n\nWhen performing domain validation, do not consider it a failure if authorizations can not be obtained for a strict subset of the requested domains. This may be useful for allowing renewals for multiple domains to succeed even if some domains no longer point at this system. This option cannot be used with --csr. (default: False)\n\n--agree-tos\n\nAgree to the ACME Subscriber Agreement (default: Ask)\n\n--duplicate\n\nAllow making a certificate lineage that duplicates an existing one (both can be renewed in parallel). (default: False)\n\n-q, --quiet\n\nSilence all output except errors. Useful for automation via cron. Implies --non-interactive. (default: False)\n\nsecurity:\n\nSecurity parameters & server settings\n\n--rsa-key-size N\n\nSize of the RSA key. (default: 2048)\n\n--key-type {rsa,ecdsa}\n\nType of generated private key. Only *ONE* per invocation can be provided at this time. (default: rsa)\n\n--elliptic-curve N\n\nThe SECG elliptic curve name to use. Please see RFC 8446 for supported values. (default: secp256r1)\n\n--must-staple\n\nAdds the OCSP Must-Staple extension to the certificate. Autoconfigures OCSP Stapling for supported setups (Apache version >= 2.3.3). (default: False)\n<table>\n<thead>\n<tr>\n<th>Flag</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>--redirect</td>\n<td>Automatically redirect all HTTP traffic to HTTPS for the newly authenticated vhost. (default: redirect enabled for install and run, disabled for enhance)</td>\n</tr>\n<tr>\n<td>--no-redirect</td>\n<td>Do not automatically redirect all HTTP traffic to HTTPS for the newly authenticated vhost. (default: redirect enabled for install and run, disabled for enhance)</td>\n</tr>\n<tr>\n<td>--hsts</td>\n<td>Add the Strict-Transport-Security header to every HTTP response. Forcing browser to always use SSL for the domain. Defends against SSL Stripping. (default: None)</td>\n</tr>\n<tr>\n<td>--uir</td>\n<td>Add the "Content-Security-Policy: upgrade-insecure-requests" header to every HTTP response. Forcing the browser to use https:// for every http:// resource. (default: None)</td>\n</tr>\n<tr>\n<td>--staple-ocsp</td>\n<td>Enables OCSP Stapling. A valid OCSP response is stapled to the certificate that the server offers during TLS. (default: None)</td>\n</tr>\n<tr>\n<td>--strict-permissions</td>\n<td>Require that all configuration files are owned by the current user; only needed if your config is somewhere unsafe like /tmp/ (default: False)</td>\n</tr>\n<tr>\n<td>--auto-hsts</td>\n<td>Gradually increasing max-age value for HTTP Strict Transport Security security header (default: False)</td>\n</tr>\n</tbody>\n</table>\n\n**testing:**\n\nThe following flags are meant for testing and integration purposes only.\n\n<table>\n<thead>\n<tr>\n<th>Flag</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>--test-cert, --staging</td>\n<td>Use the staging server to obtain or revoke test (invalid) certificates; equivalent to --server <a href=\"https://acme-staging-v02.api.letsencrypt.org/directory\">https://acme-staging-v02.api.letsencrypt.org/directory</a> (default: False)</td>\n</tr>\n<tr>\n<td>--debug</td>\n<td>Show tracebacks in case of errors (default: False)</td>\n</tr>\n<tr>\n<td>--no-verify-ssl</td>\n<td>Disable verification of the ACME server's certificate. The root certificates trusted by Certbot can be overridden by setting the REQUESTS_CA_BUNDLE environment variable. (default: False)</td>\n</tr>\n<tr>\n<td>--http-01-port HTTP01_PORT</td>\n<td>Port used in the http-01 challenge. This only affects the port Certbot listens on. A conforming ACME server will still attempt to connect on port 80. (default: 80)</td>\n</tr>\n<tr>\n<td>--http-01-address HTTP01_ADDRESS</td>\n<td>The address the server listens to during http-01 challenge. (default: )</td>\n</tr>\n<tr>\n<td>--https-port HTTPS_PORT</td>\n<td>Port used to serve HTTPS. This affects which port Nginx will listen on after a LE certificate is installed. (default: 443)</td>\n</tr>\n<tr>\n<td>--break-my-certs</td>\n<td>Be willing to replace or renew valid certificates with invalid (testing/staging) certificates (default: False)</td>\n</tr>\n</tbody>\n</table>\npaths:\nFlags for changing execution paths & servers\n\n--cert-path CERT_PATH\nPath to where certificate is saved (with certonly --csr), installed from, or revoked (default: None)\n\n--key-path KEY_PATH\nPath to private key for certificate installation or revocation (if account key is missing) (default: None)\n\n--fullchain-path FULLCHAIN_PATH\nAccompanying path to a full certificate chain (certificate plus chain). (default: None)\n\n--chain-path CHAIN_PATH\nAccompanying path to a certificate chain. (default: None)\n\n--config-dir CONFIG_DIR\nConfiguration directory. (default: /etc/letsencrypt)\n\n--work-dir WORK_DIR\nWorking directory. (default: /var/lib/letsencrypt)\n\n--logs-dir LOGS_DIR\nLogs directory. (default: /var/log/letsencrypt)\n\n--server SERVER\nACME Directory Resource URI. (default: https://acme-v02.api.letsencrypt.org/directory)\n\nmanage:\nVarious subcommands and flags are available for managing your certificates:\n\ncertificates\nList certificates managed by Certbot\n\ndelete\nClean up all files related to a certificate\n\nrenew\nRenew all certificates (or one specified with --cert-name)\n\nrevoke\nRevoke a certificate specified with --cert-path or --cert-name\n\nupdate_symlinks\nRecreate symlinks in your /etc/letsencrypt/live/ directory\n\nrun:\nOptions for obtaining & installing certificates\n\ncertonly:\nOptions for modifying how a certificate is obtained\n\n--csr CSR\nPath to a Certificate Signing Request (CSR) in DER or PEM format. Currently --csr only works with the 'certonly' subcommand. (default: None)\n\nrenew:\nThe 'renew' subcommand will attempt to renew any certificates previously obtained if they are close to expiry, and print a summary of the results. By default, 'renew' will reuse the plugins and options used to obtain or most recently renew each certificate. You can test whether future renewals will succeed with '--dry-run'. Individual certificates can be renewed with the '--cert-name' option. Hooks are available to run commands before and after renewal; see https://certbot.eff.org/docs/using.html#renewal for\nmore information on these.\n\n--pre-hook PRE_HOOK Command to be run in a shell before obtaining any certificates. Intended primarily for renewal, where it can be used to temporarily shut down a webserver that might conflict with the standalone plugin. This will only be called if a certificate is actually to be obtained/renewed. When renewing several certificates that have identical pre-hooks, only the first will be executed. (default: None)\n\n--post-hook POST_HOOK Command to be run in a shell after attempting to obtain/renew certificates. Can be used to deploy renewed certificates, or to restart any servers that were stopped by --pre-hook. This is only run if an attempt was made to obtain/renew a certificate. If multiple renewed certificates have identical post-hooks, only one will be run. (default: None)\n\n--deploy-hook DEPLOY_HOOK Command to be run in a shell once for each successfully issued certificate. For this command, the shell variable $RENEWED_LINEAGE will point to the config live subdirectory (for example, \"/etc/letsencrypt/live/example.com\") containing the new certificates and keys; the shell variable $RENEWED_DOMAINS will contain a space-delimited list of renewed certificate domains (for example, \"example.com www.example.com\") (default: None)\n\n--disable-hook-validation Ordinarily the commands specified for --pre-hook/--post-hook/--deploy-hook will be checked for validity, to see if the programs being run are in the $PATH, so that mistakes can be caught early, even when the hooks aren't being run just yet. The validation is rather simplistic and fails if you use more advanced shell constructs, so you can use this switch to disable it. (default: False)\n\n--no-directory-hooks Disable running executables found in Certbot's hook directories during renewal. (default: False)\n\n--disable-renew-updates Disable automatic updates to your server configuration that would otherwise be done by the selected installer plugin, and triggered when the user executes \"certbot renew\", regardless of if the certificate is renewed. This setting does not apply to important TLS configuration updates. (default: False)\n\n--no-autorenew Disable auto renewal of certificates. (default: False)\n\ncertificates:\n List certificates managed by Certbot\n\ndelete:\nOptions for deleting a certificate\n\nrevoke:\nOptions for revocation of certificates\n\n--reason {unspecified,keycompromise,affiliationchanged,superseded,cessationofoperation}\nSpecify reason for revoking certificate. (default: unspecified)\n\n--delete-after-revoke\nDelete certificates after revoking them, along with all previous and later versions of those certificates. (default: None)\n\n--no-delete-after-revoke\nDo not delete certificates after revoking them. This option should be used with caution because the 'renew' subcommand will attempt to renew undeleted revoked certificates. (default: None)\n\nregister:\nOptions for account registration\n\n--register-unsafely-without-email\nSpecifying this flag enables registering an account with no email address. This is strongly discouraged, because you will be unable to receive notice about impending expiration or revocation of your certificates or problems with your Certbot installation that will lead to failure to renew. (default: False)\n\n-m EMAIL, --email EMAIL\nEmail used for registration and recovery contact. Use comma to register multiple emails, ex: u1@example.com,u2@example.com. (default: Ask).\n\n--eff-email\nShare your e-mail address with EFF (default: None)\n\n--no-eff-email\nDon't share your e-mail address with EFF (default: None)\n\nupdate_account:\nOptions for account modification\n\nunregister:\nOptions for account deactivation.\n\n--account ACCOUNT_ID Account ID to use (default: None)\n\ninstall:\nOptions for modifying how a certificate is deployed\n\nrollback:\nOptions for rolling back server configuration changes\n\n--checkpoints N Revert configuration N number of checkpoints.\nplugins:\nOptions for the \"plugins\" subcommand\n\n--init Initialize plugins. (default: False)\n--prepare Initialize and prepare plugins. (default: False)\n--authenticators Limit to authenticator plugins only. (default: None)\n--installers Limit to installer plugins only. (default: None)\n\nupdate_symlinks:\nRecreates certificate and key symlinks in /etc/letsencrypt/live, if you\nchanged them by hand or edited a renewal configuration file\n\nenhance:\nHelps to harden the TLS configuration by adding security enhancements to\nalready existing configuration.\n\nshow_account:\nOptions useful for the \"show_account\" subcommand:\n\nplugins:\nPlugin Selection: Certbot client supports an extensible plugins\narchitecture. See 'certbot plugins' for a list of all installed plugins\nand their names. You can force a particular plugin by setting options\nprovided below. Running --help <plugin_name> will list flags specific to\nthat plugin.\n\n--configurator CONFIGURATOR\nName of the plugin that is both an authenticator and\nan installer. Should not be used together with\n--authenticator or --installer. (default: Ask)\n-a AUTHENTICATOR, --authenticator AUTHENTICATOR\nAuthenticator plugin name. (default: None)\n-i INSTALLER, --installer INSTALLER\nInstaller plugin name (also used to find domains).\n (default: None)\n--apache Obtain and install certificates using Apache (default: False)\n--nginx Obtain and install certificates using Nginx (default: False)\n--standalone Obtain certificates using a \"standalone\" webserver.\n (default: False)\n--manual Provide laborious manual instructions for obtaining a\ncertificate (default: False)\n--webroot Obtain certificates by placing files in a webroot\ndirectory. (default: False)\n--dns-cloudflare Obtain certificates using a DNS TXT record (if you are\n using Cloudflare for DNS). (default: False)\n--dns-cloudxns Obtain certificates using a DNS TXT record (if you are\n using CloudXNS for DNS). (default: False)\n--dns-digitalocean Obtain certificates using a DNS TXT record (if you are\n\n(continues on next page)\nusing DigitalOcean for DNS). (default: False)\n\n--dns-dnsimple\nObtain certificates using a DNS TXT record (if you are using DNSimple for DNS). (default: False)\n\n--dns-dnsmadeeasy\nObtain certificates using a DNS TXT record (if you are using DNS Made Easy for DNS). (default: False)\n\n--dns-gehirn\nObtain certificates using a DNS TXT record (if you are using Gehirn Infrastructure Service for DNS). (default: False)\n\n--dns-google\nObtain certificates using a DNS TXT record (if you are using Google Cloud DNS). (default: False)\n\n--dns-linode\nObtain certificates using a DNS TXT record (if you are using Linode for DNS). (default: False)\n\n--dns-luadns\nObtain certificates using a DNS TXT record (if you are using LuaDNS for DNS). (default: False)\n\n--dns-nsone\nObtain certificates using a DNS TXT record (if you are using NS1 for DNS). (default: False)\n\n--dns-ovh\nObtain certificates using a DNS TXT record (if you are using OVH for DNS). (default: False)\n\n--dns-rfc2136\nObtain certificates using a DNS TXT record (if you are using BIND for DNS). (default: False)\n\n--dns-route53\nObtain certificates using a DNS TXT record (if you are using Route53 for DNS). (default: False)\n\n--dns-sakuracloud\nObtain certificates using a DNS TXT record (if you are using Sakura Cloud for DNS). (default: False)\n\napache:\nApache Web Server plugin (Please note that the default values of the Apache plugin options change depending on the operating system Certbot is run on.)\n\n--apache-enmod APACHE_ENMOD\nPath to the Apache 'a2enmod' binary (default: None)\n\n--apache-dismod APACHE_DISMOD\nPath to the Apache 'a2dismod' binary (default: None)\n\n--apache-le-vhost-ext APACHE_LE_VHOST_EXT\nSSL vhost configuration extension (default: -le-ssl.conf)\n\n--apache-server-root APACHE_SERVER_ROOT\nApache server root directory (default: /etc/apache2)\n\n--apache-vhost-root APACHE_VHOST_ROOT\nApache server VirtualHost configuration root (default: None)\n\n--apache-logs-root APACHE_LOGS_ROOT\nApache server logs directory (default: /var/log/apache2)\n\n--apache-challenge-location APACHE_CHALLENGE_LOCATION\nDirectory path for challenge configuration (default: /etc/apache2)\n\n--apache-handle-modules APACHE_HANDLE_MODULES\nLet installer handle enabling required modules for you (Only Ubuntu/Debian currently) (default: False)\n\n--apache-handle-sites APACHE_HANDLE_SITES\n\n(continues on next page)\nLet installer handle enabling sites for you (Only Ubuntu/Debian currently) (default: False)\n\n--apache-ctl APACHE_CTL\nFull path to Apache control script (default: apache2ctl)\n\n--apache-bin APACHE_BIN\nFull path to apache2/httpd binary (default: None)\n\ndns-cloudflare:\nObtain certificates using a DNS TXT record (if you are using Cloudflare for DNS).\n\n--dns-cloudflare-propagation-seconds DNS_CLOUDFLARE_PROPAGATION_SECONDS\nThe number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 10)\n\n--dns-cloudflare-credentials DNS_CLOUDFLARE_CREDENTIALS\nCloudflare credentials INI file. (default: None)\n\ndns-cloudxns:\nObtain certificates using a DNS TXT record (if you are using CloudXNS for DNS).\n\n--dns-cloudxns-propagation-seconds DNS_CLOUDXNS_PROPAGATION_SECONDS\nThe number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 30)\n\n--dns-cloudxns-credentials DNS_CLOUDXNS_CREDENTIALS\nCloudXNS credentials INI file. (default: None)\n\ndns-digitalocean:\nObtain certificates using a DNS TXT record (if you are using DigitalOcean for DNS).\n\n--dns-digitalocean-propagation-seconds DNS_DIGITALOCEAN_PROPAGATION_SECONDS\nThe number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 10)\n\n--dns-digitalocean-credentials DNS_DIGITALOCEAN_CREDENTIALS\nDigitalOcean credentials INI file. (default: None)\n\ndns-dnsimple:\nObtain certificates using a DNS TXT record (if you are using DNSimple for DNS).\n\n--dns-dnsimple-propagation-seconds DNS_DNSIMPLE_PROPAGATION_SECONDS\nThe number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 30)\n\n--dns-dnsimple-credentials DNS_DNSIMPLE_CREDENTIALS\nDNSimple credentials INI file. (default: None)\nCertbot Documentation, Release 1.31.0\n\n(dns-dnsmadeeasy:\n Obtain certificates using a DNS TXT record (if you are using DNS Made Easy for DNS).\n\n --dns-dnsmadeeasy-propagation-seconds DNS_DNSMADEEASY_PROPAGATION_SECONDS\n The number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 60)\n\n --dns-dnsmadeeasy-credentials DNS_DNSMADEEASY_CREDENTIALS\n DNS Made Easy credentials INI file. (default: None)\n\ndns/gehirn:\n Obtain certificates using a DNS TXT record (if you are using Gehirn Infrastructure Service for DNS).\n\n --dns-gehirn-propagation-seconds DNS_GEHIRN_PROPAGATION_SECONDS\n The number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 30)\n\n --dns-gehirn-credentials DNS_GEHIRN_CREDENTIALS\n Gehirn Infrastructure Service credentials file. (default: None)\n\ndns/google:\n Obtain certificates using a DNS TXT record (if you are using Google Cloud DNS for DNS).\n\n --dns-google-propagation-seconds DNS_GOOGLE_PROPAGATION_SECONDS\n The number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 60)\n\n --dns-google-credentials DNS_GOOGLE_CREDENTIALS\n Path to Google Cloud DNS service account JSON file. (See https://developers.google.com/identity/protocols/OAuth2ServiceAccount#creatinganaccount for information about creating a service account and https://cloud.google.com/dns/access-control#permissions_and_roles for information about the required permissions.) (default: None)\n\ndns/linode:\n Obtain certificates using a DNS TXT record (if you are using Linode for DNS).\n\n --dns-linode-propagation-seconds DNS_LINODE_PROPAGATION_SECONDS\n The number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 120)\n\n --dns-linode-credentials DNS_LINODE_CREDENTIALS\n Linode credentials INI file. (default: None)\n\ndns-luadns:\n\n(continues on next page)\nObtain certificates using a DNS TXT record (if you are using LuaDNS for DNS).\n\n--dns-luadns-propagation-seconds DNS_LUADNS_PROPAGATION_SECONDS\n The number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 30)\n--dns-luadns-credentials DNS_LUADNS_CREDENTIALS\n LuaDNS credentials INI file. (default: None)\n\ndns-nsone:\nObtain certificates using a DNS TXT record (if you are using NS1 for DNS).\n\n--dns-nsone-propagation-seconds DNS_NSONE_PROPAGATION_SECONDS\n The number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 30)\n--dns-nsone-credentials DNS_NSONE_CREDENTIALS\n NS1 credentials file. (default: None)\n\ndns-ovh:\nObtain certificates using a DNS TXT record (if you are using OVH for DNS).\n\n--dns-ovh-propagation-seconds DNS_OVH_PROPAGATION_SECONDS\n The number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 120)\n--dns-ovh-credentials DNS_OVH_CREDENTIALS\n OVH credentials INI file. (default: None)\n\ndns-rfc2136:\nObtain certificates using a DNS TXT record (if you are using BIND for DNS).\n\n--dns-rfc2136-propagation-seconds DNS_RFC2136_PROPAGATION_SECONDS\n The number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 60)\n--dns-rfc2136-credentials DNS_RFC2136_CREDENTIALS\n RFC 2136 credentials INI file. (default: None)\n\ndns-route53:\nObtain certificates using a DNS TXT record (if you are using AWS Route53 for DNS).\n\n--dns-route53-propagation-seconds DNS_ROUTE53_PROPAGATION_SECONDS\n The number of seconds to wait for DNS to propagate before asking the ACME server to verify the DNS record. (default: 10)\n\ndns-sakuracloud:\nObtain certificates using a DNS TXT record (if you are using Sakura Cloud...\nfor DNS).\n\n--dns-sakuracloud-propagation-seconds DNS_SAKURACLOUD_PROPAGATION_SECONDS\n The number of seconds to wait for DNS to propagate\n before asking the ACME server to verify the DNS\n record. (default: 90)\n\n--dns-sakuracloud-credentials DNS_SAKURACLOUD_CREDENTIALS\n Sakura Cloud credentials file. (default: None)\n\nmanual:\nAuthenticate through manual configuration or custom shell scripts. When\nusing shell scripts, an authenticator script must be provided. The\nenvironment variables available to this script depend on the type of\nchallenge. $CERTBOT_DOMAIN will always contain the domain being\nauthenticated. For HTTP-01 and DNS-01, $CERTBOT_VALIDATION is the\nvalidation string, and $CERTBOT_TOKEN is the filename of the resource\nrequested when performing an HTTP-01 challenge. An additional cleanup\nscript can also be provided and can use the additional variable\n$CERTBOT_AUTH_OUTPUT which contains the stdout output from the auth\nscript. For both authenticator and cleanup script, on HTTP-01 and DNS-01\nchallenges, $CERTBOT_REMAINING_CHALLENGES will be equal to the number of\nchallenges that remain after the current one, and $CERTBOT_ALL_DOMAINS\ncontains a comma-separated list of all domains that are challenged for the\ncurrent certificate.\n\n--manual-auth-hook MANUAL_AUTH_HOOK\n Path or command to execute for the authentication\n script (default: None)\n\n--manual-cleanup-hook MANUAL_CLEANUP_HOOK\n Path or command to execute for the cleanup script\n (default: None)\n\nnginx:\n Nginx Web Server plugin\n\n--nginx-server-root NGINX_SERVER_ROOT\n Nginx server root directory. (default: /etc/nginx or\n /usr/local/etc/nginx)\n\n--nginx-ctl NGINX_CTL\n Path to the 'nginx' binary, used for 'configtest' and\n retrieving nginx version number. (default: nginx)\n\n--nginx-sleep-seconds NGINX_SLEEP_SECONDS\n Number of seconds to wait for nginx configuration\n changes to apply when reloading. (default: 1)\n\nnull:\n Null Installer\n\nstandalone:\n Spin up a temporary webserver\n\nwebroot:\nPlace files in webroot directory\n\n--webroot-path WEBROOT_PATH, -w WEBROOT_PATH\n\npublic_html / webroot path. This can be specified\nmultiple times to handle different domains; each\ndomain will have the webroot path that preceded it.\nFor instance:\n\n```\n-w /var/www/example -d example.com\n-w /var/www/thing -d www.example.com\n-w /var/www/thing -d thing.net\n-w /var/www/thing -d m.thing.net\n```\n\n(default: Ask)\n\n--webroot-map WEBROOT_MAP\n\nJSON dictionary mapping domains to webroot paths; this\nimplies -d for each entry. You may need to escape this\nfrom your shell. E.g.: --webroot-map\n\n```\n{\"eg1.is,m.eg1.is\": \"/www/eg1/\", \"eg2.is\": \"/www/eg2\"}\n```\n\nThis option is merged with, but takes precedence over,\n-w / -d entries. At present, if you put webroot-map in\na config file, it needs to be on a single line, like:\n\n```\nwebroot-map = \n{\"example.com\": \"/var/www\"}. (default: \n{})\n```\n\n4.11 Getting help\n\nIf you’re having problems, we recommend posting on the Let’s Encrypt Community Forum.\n\nIf you find a bug in the software, please do report it in our issue tracker. Remember to give us as much information as possible:\n\n- copy and paste exact command line used and the output (though mind that the latter might include some personally identifiable information, including your email and domains)\n- copy and paste logs from /var/log/letsencrypt (though mind they also might contain personally identifiable information)\n- copy and paste certbot --version output\n- your operating system, including specific version\n- specify which installation method you’ve chosen\nTable of Contents\n\n• Getting Started\n – Running a local copy of the client\n – Find issues to work on\n – Testing\n * Running automated unit tests\n * Running automated integration tests\n * Running manual integration tests\n * Running tests in CI\n\n• Code components and layout\n – Plugin-architecture\n – Authenticators\n – Installer\n – Installer Development\n – Writing your own plugin\n * Writing your own plugin snap\n\n• Coding style\n• Use certbot.compat.os instead of os\n\n• Mypy type annotations\n• Submitting a pull request\n\n• Asking for help\n\n• Building the Certbot and DNS plugin snaps\n\n• Updating the documentation\n\n• Certbot’s dependencies\n – Updating dependency versions\n\n• Running the client with Docker\n5.1 Getting Started\n\nCertbot has the same system requirements when set up for development. While the section below will help you install Certbot and its dependencies, Certbot needs to be run on a UNIX-like OS so if you're using Windows, you'll need to set up a (virtual) machine running an OS such as Linux and continue with these instructions on that UNIX-like OS.\n\n5.1.1 Running a local copy of the client\n\nRunning the client in developer mode from your local tree is a little different than running Certbot as a user. To get set up, clone our git repository by running:\n\n```\n$ git clone https://github.com/certbot/certbot\n```\n\nIf you're running on a UNIX-like OS, you can run the following commands to install dependencies and set up a virtual environment where you can run Certbot.\n\nInstall and configure the OS system dependencies required to run Certbot.\n\n```\n# For APT-based distributions (e.g. Debian, Ubuntu ...)\nsudo apt update\nsudo apt install python3-dev python3-venv gcc libaugeas0 libssl-dev \\\n libffi-dev ca-certificates openssl\n# For RPM-based distributions (e.g. Fedora, CentOS ...)\n# NB1: old distributions will use yum instead of dnf\n# NB2: RHEL-based distributions use python3X-devel instead of python3-devel (e.g. python36-devel)\nsudo dnf install python3-devel gcc augeas-libs openssl-devel libffi-devel \\\n redhat-rpm-config ca-certificates openssl\n# For macOS installations with Homebrew already installed and configured\n# NB: If you also run 'brew install python' you don't need the ~/lib\ndirectory created below, however, Certbot's Apache plugin won't work\nif you use Python installed from other sources such as pyenv or the\nversion provided by Apple.\nbrew install augeas\nmkdir ~/lib\nln -s $(brew --prefix)/lib/libaugeas* ~/lib\n```\n\nSet up the Python virtual environment that will host your Certbot local instance.\n\n```\n$ cd certbot\n$ python tools/venv.py\n```\n\n**Note:** You may need to repeat this when Certbot's dependencies change or when a new plugin is introduced.\n\nYou can now run the copy of Certbot from git either by executing `venv/bin/certbot`, or by activating the virtual environment. You can do the latter by running:\n\n```\n$ source venv/bin/activate\n```\n\nAfter running this command, `certbot` and development tools like `ipdb3`, `ipython`, `pytest`, and `tox` are available in the shell where you ran the command. These tools are installed in the virtual environment and are kept separate from your global Python installation. This works by setting environment variables so the right executables are found and\nPython can pull in the versions of various packages needed by Certbot. More information can be found in the virtualenv docs.\n\n## 5.1.2 Find issues to work on\n\nYou can find the open issues in the [github issue tracker](https://github.com/certbot/certbot/issues). Comparatively easy ones are marked good first issue. If you’re starting work on something, post a comment to let others know and seek feedback on your plan where appropriate.\n\nOnce you’ve got a working branch, you can open a pull request. All changes in your pull request must have thorough unit test coverage, pass our tests, and be compliant with the coding style.\n\n## 5.1.3 Testing\n\nYou can test your code in several ways:\n\n- running the **automated unit** tests,\n- running the **automated integration** tests\n- running an **ad hoc manual integration** test\n\n---\n\n**Note:** Running integration tests does not currently work on macOS. See [https://github.com/certbot/certbot/issues/6959](https://github.com/certbot/certbot/issues/6959). In the meantime, we recommend developers on macOS open a PR to run integration tests.\n\n### Running automated unit tests\n\nWhen you are working in a file `foo.py`, there should also be a file `foo_test.py` either in the same directory as `foo.py` or in the `tests` subdirectory (if there isn’t, make one). While you are working on your code and tests, run `python foo_test.py` to run the relevant tests.\n\nFor debugging, we recommend putting `import ipdb; ipdb.set_trace()` statements inside the source code.\n\nOnce you are done with your code changes, and the tests in `foo_test.py` pass, run all of the unit tests for Certbot and check for coverage with `tox -e py3-cover`. You should then check for code style with `tox -e lint` (all files) or `pylint --rcfile=.pylintrc path/to/file.py` (single file at a time).\n\nOnce all of the above is successful, you may run the full test suite using `tox --skip-missing-interpreters`. We recommend running the commands above first, because running all tests like this is very slow, and the large amount of output can make it hard to find specific failures when they happen.\n\n---\n\n**Warning:** The full test suite may attempt to modify your system’s Apache config if your user has sudo permissions, so it should not be run on a production Apache server.\n\n---\n\n5.1. Getting Started\n\n47\nRunning automated integration tests\n\nGenerally it is sufficient to open a pull request and let Github and Azure Pipelines run integration tests for you. However, you may want to run them locally before submitting your pull request. You need Docker and docker-compose installed and working.\n\nThe tox environment integration will setup Pebble, the Let’s Encrypt ACME CA server for integration testing, then launch the Certbot integration tests.\n\nWith a user allowed to access your local Docker daemon, run:\n\n```\ntox -e integration\n```\n\nTests will be run using pytest. A test report and a code coverage report will be displayed at the end of the integration tests execution.\n\nRunning manual integration tests\n\nYou can also manually execute Certbot against a local instance of the Pebble ACME server. This is useful to verify that the modifications done to the code make Certbot behave as expected.\n\nTo do so you need:\n\n• Docker installed, and a user with access to the Docker client,\n• an available local copy of Certbot.\n\nThe virtual environment set up with python tools/venv.py contains two CLI tools that can be used once the virtual environment is activated:\n\n```\nrun_acme_server\n```\n\n• Starts a local instance of Pebble and runs in the foreground printing its logs.\n• Press CTRL+C to stop this instance.\n• This instance is configured to validate challenges against certbot executed locally.\n\nNote: Some options are available to tweak the local ACME server. You can execute run_acme_server --help to see the inline help of the run_acme_server tool.\n\n```\ncertbot_test [ARGS...]\n```\n\n• Execute certbot with the provided arguments and other arguments useful for testing purposes, such as: verbose output, full tracebacks in case Certbot crashes, etc.\n• Execution is preconfigured to interact with the Pebble CA started with run_acme_server.\n• Any arguments can be passed as they would be to Certbot (eg. certbot_test certonly -d test.example.com).\n\nHere is a typical workflow to verify that Certbot successfully issued a certificate using an HTTP-01 challenge on a machine with Python 3:\n\n```\npython tools/venv.py\nsource venv/bin/activate\nrun_acme_server &\n```\n\n(continues on next page)\nRunning tests in CI\n\nCertbot uses Azure Pipelines to run continuous integration tests. If you are using our Azure setup, a branch whose name starts with test- will run all tests on that branch.\n\n5.2 Code components and layout\n\nThe following components of the Certbot repository are distributed to users:\n\n- **acme**: contains all protocol specific code\n- **certbot**: main client code\n- **certbot-apache** and **certbot-nginx**: client code to configure specific web servers\n- **certbot-dns-**: client code to configure DNS providers\n- **windows installer**: Installs Certbot on Windows and is built using the files in windows-installer/\n\n5.2.1 Plugin-architecture\n\nCertbot has a plugin architecture to facilitate support for different webservers, other TLS servers, and operating systems. The interfaces available for plugins to implement are defined in interfaces.py and plugins/common.py.\n\nThe main two plugin interfaces are **Authenticator**, which implements various ways of proving domain control to a certificate authority, and **Installer**, which configures a server to use a certificate once it is issued. Some plugins, like the built-in Apache and Nginx plugins, implement both interfaces and perform both tasks. Others, like the built-in Standalone authenticator, implement just one interface.\n\n5.2.2 Authenticators\n\nAuthenticators are plugins that prove control of a domain name by solving a challenge provided by the ACME server. ACME currently defines several types of challenges: HTTP, TLS-ALPN, and DNS, represented by classes in acme.challenges. An authenticator plugin should implement support for at least one challenge type.\n\nAn Authenticator indicates which challenges it supports by implementing get_chall_pref(domain) to return a sorted list of challenge types in preference order.\n\nAn Authenticator must also implement perform(achalls), which “performs” a list of challenges by, for instance, provisioning a file on an HTTP server, or setting a TXT record in DNS. Once all challenges have succeeded or failed, Certbot will call the plugin’s cleanup(achalls) method to remove any files or DNS records that were needed only during authentication.\n5.2.3 Installer\n\nInstallers plugins exist to actually setup the certificate in a server, possibly tweak the security configuration to make it more correct and secure (Fix some mixed content problems, turn on HSTS, redirect to HTTPS, etc). Installer plugins tell the main client about their abilities to do the latter via the \\texttt{supported_enhancements()} call. We currently have two Installers in the tree, the \\texttt{ApacheConfigurator} and the \\texttt{NginxConfigurator}. External projects have made some progress toward support for IIS, Icecast and Plesk.\n\nInstallers and Authenticators will oftentimes be the same class/object (because for instance both tasks can be performed by a webserver like nginx) though this is not always the case (the standalone plugin is an authenticator that listens on port 80, but it cannot install certificates; a postfix plugin would be an installer but not an authenticator).\n\nInstallers and Authenticators are kept separate because it should be possible to use the \\texttt{StandaloneAuthenticator} (it sets up its own Python server to perform challenges) with a program that cannot solve challenges itself (Such as MTA installers).\n\n5.2.4 Installer Development\n\nThere are a few existing classes that may be beneficial while developing a new developer\\texttt{Installer}. Installers aimed to reconfigure UNIX servers may use Augeas for configuration parsing and can inherit from \\texttt{AugeasConfigurator} class to handle much of the interface. Installers that are unable to use Augeas may still find the \\texttt{Reverter} class helpful in handling configuration checkpoints and rollback.\n\n5.2.5 Writing your own plugin\n\n\\textbf{Note:} The Certbot team is not currently accepting any new plugins because we want to rethink our approach to the challenge and resolve some issues like \\#6464, \\#6503, and \\#6504 first.\n\nIn the meantime, you're welcome to release it as a third-party plugin. See \\texttt{certbot-dns-ispconfig} for one example of that.\n\nCertbot client supports dynamic discovery of plugins through the \\texttt{setuptools} entry points using the \\texttt{certbot.plugins} group. This way you can, for example, create a custom implementation of \\texttt{Authenticator} or the \\texttt{Installer} without having to merge it with the core upstream source code. An example is provided in \\texttt{examples/plugins/} directory.\n\nWhile developing, you can install your plugin into a Certbot development virtualenv like this:\n\n```\n. venv/bin/activate\npip install -e examples/plugins/\ncertbot_test plugins\n```\n\nYour plugin should show up in the output of the last command. If not, it was not installed properly.\n\nOnce you’ve finished your plugin and published it, you can have your users install it system-wide with \\texttt{pip install}. Note that this will only work for users who have Certbot installed from OS packages or via pip.\nWriting your own plugin snap\n\nIf you'd like your plugin to be used alongside the Certbot snap, you will also have to publish your plugin as a snap. Plugin snaps are regular confined snaps, but normally do not provide any “apps” themselves. Plugin snaps export loadable Python modules to the Certbot snap.\n\nWhen the Certbot snap runs, it will use its version of Python and prefer Python modules contained in its own snap over modules contained in external snaps. This means that your snap doesn't have to contain things like an extra copy of Python, Certbot, or their dependencies, but also that if you need a different version of a dependency than is already installed in the Certbot snap, the Certbot snap will have to be updated.\n\nCertbot plugin snaps expose their Python modules to the Certbot snap via a snap content interface where certbot-1 is the value for the content attribute. The Certbot snap only uses this to find the names of connected plugin snaps and it expects to find the Python modules to be loaded under lib/python3.8/site-packages/ in the plugin snap. This location is the default when using the core20 base snap and the python snapcraft plugin.\n\nThe Certbot snap also provides a separate content interface which you can use to get metadata about the Certbot snap using the content identifier metadata-1.\n\nThe script used to generate the snapcraft.yaml files for our own externally snapped plugins can be found at https://github.com/certbot/certbot/blob/master/tools/snap/generate_dnsplugins_snapcraft.sh.\n\nFor more information on building externally snapped plugins, see the section on Building the Certbot and DNS plugin snaps.\n\nOnce you have created your own snap, if you have the snap file locally, it can be installed for use with Certbot by running:\n\n```\nsnap install --classic certbot\nsnap set certbot trust-plugin-with-root=ok\nsnap install --dangerous your-snap-filename.snap\nsudo snap connect certbot:plugin your-snap-name\nsudo /snap/bin/certbot plugins\n```\n\nIf everything worked, the last command should list your plugin in the list of plugins found by Certbot. Once your snap is published to the snap store, it will be installable through the name of the snap on the snap store without the --dangerous flag. If you are also using Certbot's metadata interface, you can run sudo snap connect your-snap-name:your-plug-name-for-metadata certbot:certbot-metadata to connect your snap to it.\n\n5.3 Coding style\n\nPlease:\n\n1. Be consistent with the rest of the code.\n3. Follow the Google Python Style Guide, with the exception that we use Sphinx-style documentation:\n\n```python\ndef foo(arg):\n \"\"\"Short description.\n\n :param int arg: Some number.\n :returns: Argument\n :rtype: int\n```\n\n(continues on next page)\n4. Remember to use pylint.\n\n5. You may consider installing a plugin for editorconfig in your editor to prevent some linting warnings.\n\n6. Please avoid unittest.assertTrue or unittest.assertFalse when possible, and use assertEqual or more specific assert. They give better messages when it’s failing, and are generally more correct.\n\n5.4 Use certbot.compat.os instead of os\n\nPython’s standard library os module lacks full support for several Windows security features about file permissions (eg. DACLs). However several files handled by Certbot (eg. private keys) need strongly restricted access on both Linux and Windows.\n\nTo help with this, the certbot.compat.os module wraps the standard os module, and forbids usage of methods that lack support for these Windows security features.\n\nAs a developer, when working on Certbot or its plugins, you must use certbot.compat.os in every place you would need os (eg. from certbot.compat import os instead of import os). Otherwise the tests will fail when your PR is submitted.\n\n5.5 Mypy type annotations\n\nCertbot uses the mypy static type checker. Python 3 natively supports official type annotations, which can then be tested for consistency using mypy. Mypy does some type checks even without type annotations; we can find bugs in Certbot even without a fully annotated codebase.\n\nZulip wrote a great guide to using mypy. It’s useful, but you don’t have to read the whole thing to start contributing to Certbot.\n\nTo run mypy on Certbot, use tox -e mypy on a machine that has Python 3 installed.\n\nAlso note that OpenSSL, which we rely on, has type definitions for crypto but not SSL. We use both. Those imports should look like this:\n\n```python\nfrom OpenSSL import crypto\nfrom OpenSSL import SSL\n```\n\n5.6 Submitting a pull request\n\nSteps:\n\n0. We recommend you talk with us in a GitHub issue or Mattermost before writing a pull request to ensure the changes you’re making is something we have the time and interest to review.\n\n1. Write your code! When doing this, you should add mypy type annotations for any functions you add or modify. You can check that you’ve done this correctly by running tox -e mypy on a machine that has Python 3 installed.\n2. Make sure your environment is set up properly and that you’re in your virtualenv. You can do this by following the instructions in the *Getting Started* section.\n\n3. Run `tox -e lint` to check for pylint errors. Fix any errors.\n\n4. Run `tox --skip-missing-interpreters` to run the entire test suite including coverage. The `--skip-missing-interpreters` argument ignores missing versions of Python needed for running the tests. Fix any errors.\n\n5. If any documentation should be added or updated as part of the changes you have made, please include the documentation changes in your PR.\n\n6. Submit the PR. Once your PR is open, please do not force push to the branch containing your pull request to squash or amend commits. We use *squash merges* on PRs and rewriting commits makes changes harder to track between reviews.\n\n7. Did your tests pass on Azure Pipelines? If they didn’t, fix any errors.\n\n### 5.7 Asking for help\n\nIf you have any questions while working on a Certbot issue, don’t hesitate to ask for help! You can do this in the Certbot channel in EFF’s Mattermost instance for its open source projects as described below.\n\nYou can get involved with several of EFF’s software projects such as Certbot at the [EFF Open Source Contributor Chat Platform](https://github.com/certbot/certbot/tree/master/tools/snap). By signing up for the EFF Open Source Contributor Chat Platform, you consent to share your personal information with the Electronic Frontier Foundation, which is the operator and data controller for this platform. The channels will be available both to EFF, and to other users of EFFOSCCP, who may use or disclose information in these channels outside of EFFOSCCP. EFF will use your information, according to the [Privacy Policy](https://github.com/certbot/certbot/tree/master/tools/snap), to further the mission of EFF, including hosting and moderating the discussions on this platform.\n\nUse of EFFOSCCP is subject to the [EFF Code of Conduct](https://github.com/certbot/certbot/tree/master/tools/snap). When investigating an alleged Code of Conduct violation, EFF may review discussion channels or direct messages.\n\n### 5.8 Building the Certbot and DNS plugin snaps\n\nInstructions for how to manually build and run the Certbot snap and the externally snapped DNS plugins that the Certbot project supplies are located in the README file at [https://github.com/certbot/certbot/tree/master/tools/snap](https://github.com/certbot/certbot/tree/master/tools/snap).\n\n### 5.9 Updating the documentation\n\nMany of the packages in the Certbot repository have documentation in a *docs/* directory. This directory is located under the top level directory for the package. For instance, Certbot’s documentation is under *certbot/docs*.\n\nTo build the documentation of a package, make sure you have followed the instructions to set up a *local copy* of Certbot including activating the virtual environment. After that, cd to the docs directory you want to build and run the command:\n\n```make clean html```\n\nThis would generate the HTML documentation in `_build/html` in your current *docs/* directory.\n5.10 Certbot’s dependencies\n\nWe attempt to pin all of Certbot’s dependencies whenever we can for reliability and consistency. Some of the places we have Certbot’s dependencies pinned include our snaps, Docker images, Windows installer, CI, and our development environments.\n\nIn most cases, the file where dependency versions are specified is `tools/requirements.txt`. There are two exceptions to this. The first is our “oldest” tests where `tools/oldest_constraints.txt` is used instead. The purpose of the “oldest” tests is to ensure Certbot continues to work with the oldest versions of our dependencies which we claim to support. The oldest versions of the dependencies we support should also be declared in our setup.py files to communicate this information to our users.\n\nThe second exception to using `tools/requirements.txt` is in our unpinned tests. As of writing this, there is one test we run nightly in CI where we leave Certbot’s dependencies unpinned. The thinking behind this test is to help us learn about breaking changes in our dependencies so that we can respond accordingly.\n\nThe choices of whether Certbot’s dependencies are pinned and what file is used if they are should be automatically handled for you most of the time by Certbot’s tooling. The way it works though is `tools/pip_install.py` (which many of our other tools build on) checks for the presence of environment variables. If `CERTBOT_NO_PIN` is set to 1, Certbot’s dependencies will not be pinned. If that variable is not set and `CERTBOT_OLDEST` is set to 1, `tools/oldest_constraints.txt` will be used as constraints for `pip`. Otherwise, `tools/requirements.txt` is used as constraints.\n\n5.10.1 Updating dependency versions\n\ntools/requirements.txt and tools/oldest_constraints.txt can be updated using `tools/pinning/current/repin.sh` and `tools/pinning/oldest/repin.sh` respectively. This works by using poetry to generate pinnings based on a Poetry project defined by the `pyproject.toml` file in the same directory as the script. In many cases, you can just run the script to generate updated dependencies, however, if you need to pin back packages or unpin packages that were previously restricted to an older version, you will need to modify the `pyproject.toml` file. The syntax used by this file is described at https://python-poetry.org/docs/pyproject/ and how dependencies are specified in this file is further described at https://python-poetry.org/docs/dependency-specification/.\n\nIf you want to learn more about the design used here, see `tools/pinning/DESIGN.md` in the Certbot repo.\n\n5.11 Running the client with Docker\n\nYou can use Docker Compose to quickly set up an environment for running and testing Certbot. To install Docker Compose, follow the instructions at https://docs.docker.com/compose/install/.\n\nNote: Linux users can simply run `pip install docker-compose` to get Docker Compose after installing Docker Engine and activating your shell as described in the Getting Started section.\n\nNow you can develop on your host machine, but run Certbot and test your changes in Docker. When using `docker-compose` make sure you are inside your clone of the Certbot repository. As an example, you can run the following command to check for linting errors:\n\n```\ndocker-compose run --rm --service-ports development bash -c 'tox -e lint'\n```\n\nYou can also leave a terminal open running a shell in the Docker container and modify Certbot code in another window. The Certbot repo on your host machine is mounted inside of the container so any changes you make immediately take effect. To do this, run:\nNow running the check for linting errors described above is as easy as:\n\ntox -e lint\n6.1 Releases\n\nWe release packages and upload them to PyPI (wheels and source tarballs).\n\n- https://pypi.python.org/pypi/acme\n- https://pypi.python.org/pypi/certbot\n- https://pypi.python.org/pypi/certbot-apache\n- https://pypi.python.org/pypi/certbot-nginx\n- https://pypi.python.org/pypi/certbot-dns-cloudflare\n- https://pypi.python.org/pypi/certbot-dns-cloudxns\n- https://pypi.python.org/pypi/certbot-dns-digitalocean\n- https://pypi.python.org/pypi/certbot-dns-dnsmadeeasy\n- https://pypi.python.org/pypi/certbot-dns-dnsgoogle\n- https://pypi.python.org/pypi/certbot-dns-linode\n- https://pypi.python.org/pypi/certbot-dns-luadns\n- https://pypi.python.org/pypi/certbot-dns-nsone\n- https://pypi.python.org/pypi/certbot-dns-ovh\n- https://pypi.python.org/pypi/certbot-dns-rfc2136\n- https://pypi.python.org/pypi/certbot-dns-route53\n\nThe following scripts are used in the process:\n\n\nWe use git tags to identify releases, using Semantic Versioning. For example: v0.11.1.\n\nSince version 1.21.0, our packages are cryptographically signed by one of four PGP keys:\n\n- BF6BCFC89E90747B9A680FD7B6029E8500F7DB16\n- 86379B4F0AF371B50CD9E5FF3402831161D1D280\n- 20F201346BF8F3F455A73F9A780CC99432A28621\n- F2871B4152AE13C49519111F447BF683AA3B26C3\nThese keys can be found on major key servers and at https://dl.eff.org/certbot.pub.\n\nReleases before 1.21.0 were signed by the PGP key A2CFB51FA275A7286234E7B24D17C995CD9775F2 which can still be found on major key servers.\n\n### 6.2 Notes for package maintainers\n\n0. Please use our tagged releases, not master!\n\n1. Do not package `certbot-compatibility-test` as it’s only used internally.\n\n2. To run tests on our packages, you should use pytest by running the command `python -m pytest`. Running `pytest` directly may not work because `PYTHONPATH` is not handled the same way and local modules may not be found by the test runner.\n\n3. If you’d like to include automated renewal in your package:\n - `certbot renew -q` should be added to crontab or systemd timer.\n - A random per-machine time offset should be included to avoid having a large number of your clients hit Let’s Encrypt’s servers simultaneously.\n - `--preconfigured-renewal` should be included on the CLI or in `cli.ini` for all invocations of Certbot, so that it can adjust its interactive output regarding automated renewal (Certbot >= 1.9.0).\n\n4. `jws` is an internal script for `acme` module and it doesn’t have to be packaged - it’s mostly for debugging: you can use it as `echo foo | jws sign | jws verify`.\n\n5. Do get in touch with us. We are happy to make any changes that will make packaging easier. If you need to apply some patches don’t do it downstream - make a PR here.\nAll Certbot components including acme, Certbot, and non-third party plugins follow Semantic Versioning both for its Python API and for the application itself. This means that we will not change behavior in a backwards incompatible way except in a new major version of the project.\n\n**Note:** None of this applies to the behavior of Certbot distribution mechanisms such as our snaps or OS packages whose behavior may change at any time. Semantic versioning only applies to the common Certbot components that are installed by various distribution methods.\n\nFor Certbot as an application, the command line interface and non-interactive behavior can be considered stable with two exceptions. The first is that no aspects of Certbot’s console or log output should be considered stable and it may change at any time. The second is that Certbot’s behavior should only be considered stable with certain files but not all. Files with which users should expect Certbot to maintain its current behavior with are:\n\n- `/etc/letsencrypt/live/$domain/{cert,chain,fullchain,privkey}.pem`, where $domain is the certificate name (see *Where are my certificates?* for more details)\n- CLI configuration files\n- Hook directories in `/etc/letsencrypt/renewal-hooks`\n\nCertbot’s behavior with other files may change at any point.\n\nAnother area where Certbot should not be considered stable is its behavior when not run in non-interactive mode which also may change at any point.\n\nIn general, if we’re making a change that we expect will break some users, we will bump the major version and will have warned about it in a prior release when possible. For our Python API, we will issue warnings using Python’s warning module. For application level changes, we will print and log warning messages.\nCHAPTER\nEIGHT\n\nRESOURCES\n\nDocumentation: https://certbot.eff.org/docs\nSoftware project: https://github.com/certbot/certbot\nNotes for developers: https://certbot.eff.org/docs/contributing.html\nMain Website: https://certbot.eff.org\nLet’s Encrypt Website: https://letsencrypt.org\nCommunity: https://community.letsencrypt.org\nACME spec: RFC 8555\nACME working area in github (archived): https://github.com/ietf-wg-acme/acme\n9.1 certbot package\n\nCertbot client.\n\n9.1.1 Subpackages\n\ncertbot.compat package\n\nCompatibility layer to run certbot both on Linux and Windows.\n\nThis package contains all logic that needs to be implemented specifically for Linux and for Windows. Then the rest of\n\ncertbot code relies on this module to be platform agnostic.\n\nSubmodules\n\ncertbot.compat.filesystem module\n\nCompat module to handle files security on Windows and Linux\n\ncertbot.compat.filesystem.chmod(file_path: str, mode: int) → None\n\nApply a POSIX mode on given file_path:\n\n• for Linux, the POSIX mode will be directly applied using chmod,\n• for Windows, the POSIX mode will be translated into a Windows DACL that make sense for Certbot context,\n and applied to the file using kernel calls.\n\nThe definition of the Windows DACL that correspond to a POSIX mode, in the context of Certbot, is explained at\nhttps://github.com/certbot/certbot/issues/6356 and is implemented by the method\n_generate_windows_flags().\n\nParameters\n\n• file_path (str) – Path of the file\n• mode (int) – POSIX mode to apply\n\ncertbot.compat.filesystem.umask(mask: int) → int\n\nSet the current numeric umask and return the previous umask. On Linux, the built-in umask method is used. On\n\nWindows, our Certbot-side implementation is used.\n\nParameters mask (int) – The user file-creation mode mask to apply.\nReturn type int\n\nReturns The previous umask value.\n\ncertbot.compat.filesystem.copy_ownership_and_apply_mode(src: str, dst: str, mode: int, copy_user: bool, copy_group: bool) → None\n\nCopy ownership (user and optionally group on Linux) from the source to the destination, then apply given mode in compatible way for Linux and Windows. This replaces the os.chown command.\n\nParameters\n\n- **src** (str) – Path of the source file\n- **dst** (str) – Path of the destination file\n- **mode** (int) – Permission mode to apply on the destination file\n- **copy_user** (bool) – Copy user if True\n- **copy_group** (bool) – Copy group if True on Linux (has no effect on Windows)\n\ncertbot.compat.filesystem.copy_ownership_and_mode(src: str, dst: str, copy_user: bool = True, copy_group: bool = True) → None\n\nCopy ownership (user and optionally group on Linux) and mode/DACL from the source to the destination.\n\nParameters\n\n- **src** (str) – Path of the source file\n- **dst** (str) – Path of the destination file\n- **copy_user** (bool) – Copy user if True\n- **copy_group** (bool) – Copy group if True on Linux (has no effect on Windows)\n\ncertbot.compat.filesystem.check_mode(file_path: str, mode: int) → bool\n\nCheck if the given mode matches the permissions of the given file. On Linux, will make a direct comparison, on Windows, mode will be compared against the security model.\n\nParameters\n\n- **file_path** (str) – Path of the file\n- **mode** (int) – POSIX mode to test\n\nReturn type bool\n\nReturns True if the POSIX mode matches the file permissions\n\ncertbot.compat.filesystem.check_owner(file_path: str) → bool\n\nCheck if given file is owned by current user.\n\nParameters **file_path** (str) – File path to check\n\nReturn type bool\n\nReturns True if given file is owned by current user, False otherwise.\n\ncertbot.compat.filesystem.check_permissions(file_path: str, mode: int) → bool\n\nCheck if given file has the given mode and is owned by current user.\n\nParameters\n\n- **file_path** (str) – File path to check\n- **mode** (int) – POSIX mode to check\n\nReturn type bool\nReturns True if file has correct mode and owner, False otherwise.\n\n```\ncertbot.compat.filesystem.open(file_path: str, flags: int, mode: int = 511) → int\n```\nWrapper of original os.open function, that will ensure on Windows that given mode is correctly applied.\n\n**Parameters**\n\n- **file_path (str)** – The file path to open\n- **flags (int)** – Flags to apply on file while opened\n- **mode (int)** – POSIX mode to apply on file when opened, Python defaults will be applied if None\n\n**Returns** the file descriptor to the opened file\n\n**Return type** int\n\n**Raise** OSError(errno.EEXIST) if the file already exists and os.O_CREAT & os.O_EXCL are set, OSError(errno.EACCES) on Windows if the file already exists and is a directory, and os.O_CREAT is set.\n\n```\ncertbot.compat.filesystem.makedirs(file_path: str, mode: int = 511) → None\n```\nRewrite of original os.makedirs function, that will ensure on Windows that given mode is correctly applied.\n\n**Parameters**\n\n- **file_path (str)** – The file path to open\n- **mode (int)** – POSIX mode to apply on leaf directory when created, Python defaults will be applied if None\n\n```\ncertbot.compat.filesystem.mkdir(file_path: str, mode: int = 511) → None\n```\nRewrite of original os.mkdir function, that will ensure on Windows that given mode is correctly applied.\n\n**Parameters**\n\n- **file_path (str)** – The file path to open\n- **mode (int)** – POSIX mode to apply on directory when created, Python defaults will be applied if None\n\n```\ncertbot.compat.filesystem.replace(src: str, dst: str) → None\n```\nRename a file to a destination path and handles situations where the destination exists.\n\n**Parameters**\n\n- **src (str)** – The current file path.\n- **dst (str)** – The new file path.\n\n```\ncertbot.compat.filesystem.realpath(file_path: str) → str\n```\nFind the real path for the given path. This method resolves symlinks, including recursive symlinks, and is protected against symlinks that creates an infinite loop.\n\n**Parameters** **file_path (str)** – The path to resolve\n\n**Returns** The real path for the given path\n\n**Return type** str\n\n```\ncertbot.compat.filesystem.readlink(link_path: str) → str\n```\nReturn a string representing the path to which the symbolic link points.\n\n**Parameters** **link_path (str)** – The symlink path to resolve\n\n**Returns** The path the symlink points to\nReturns str\nRaise ValueError if a long path (260+ characters) is encountered on Windows.\n\ncertbot.compat.filesystem.is_executable(path: str) → bool\nIs path an executable file?\n\nParameters path (str) – path to test\n\nReturns True if path is an executable file\n\nReturn type bool\n\ncertbot.compat.filesystem.has_world_permissions(path: str) → bool\nCheck if everybody/world has any right (read/write/execute) on a file given its path.\n\nParameters path (str) – path to test\n\nReturns True if everybody/world has any right to the file\n\nReturn type bool\n\ncertbot.compat.filesystem.compute_private_key_mode(old_key: str, base_mode: int) → int\nCalculate the POSIX mode to apply to a private key given the previous private key.\n\nParameters\n• old_key (str) – path to the previous private key\n• base_mode (int) – the minimum modes to apply to a private key\n\nReturns the POSIX mode to apply\n\nReturn type int\n\ncertbot.compat.filesystem.has_same_ownership(path1: str, path2: str) → bool\nReturn True if the ownership of two files given their respective path is the same. On Windows, ownership is checked against owner only, since files do not have a group owner.\n\nParameters\n• path1 (str) – path to the first file\n• path2 (str) – path to the second file\n\nReturns True if both files have the same ownership, False otherwise\n\nReturn type bool\n\ncertbot.compat.filesystem.has_min_permissions(path: str, min_mode: int) → bool\nCheck if a file given its path has at least the permissions defined by the given minimal mode. On Windows, group permissions are ignored since files do not have a group owner.\n\nParameters\n• path (str) – path to the file to check\n• min_mode (int) – the minimal permissions expected\n\nReturns True if the file matches the minimal permissions expectations, False otherwise\n\nReturn type bool\ncertbot.compat.misc module\n\nThis compat module handles various platform specific calls that do not fall into one particular category.\n\ncertbot.compat.misc.raise_for_non_administrative_windows_rights() \\(\\rightarrow\\) None\nOn Windows, raise if current shell does not have the administrative rights. Do nothing on Linux.\n\nRaises errors.Error – If the current shell does not have administrative rights on Windows.\n\ncertbot.compat.misc.prepare_virtual_console() \\(\\rightarrow\\) None\nOn Windows, ensure that Console Virtual Terminal Sequences are enabled.\n\ncertbot.compat.misc.readline_with_timeout(timeout: float, prompt: Optional[str]) \\(\\rightarrow\\) str\nRead user input to return the first line entered, or raise after specified timeout.\n\nParameters\n\n• timeout (float) – The timeout in seconds given to the user.\n\n• prompt (str) – The prompt message to display to the user.\n\nReturns The first line entered by the user.\n\nReturn type str\n\ncertbot.compat.misc.get_default_folder(folder_type: str) \\(\\rightarrow\\) str\nReturn the relevant default folder for the current OS\n\nParameters folder_type (str) – The type of folder to retrieve (config, work or logs)\n\nReturns The relevant default folder.\n\nReturn type str\n\ncertbot.compat.misc.underscores_for_unsupported_characters_in_path(path: str) \\(\\rightarrow\\) str\nReplace unsupported characters in path for current OS by underscores.\n\n:param str path: the path to normalize\n:return: the normalized path\n:type: str\n\ncertbot.compat.misc.execute_command_status(cmd_name: str, shell_cmd: str, env: Optional[dict] = None) \\(\\rightarrow\\) Tuple[int, str, str]\nRun a command:\n\n• on Linux command will be run by the standard shell selected with subprocess.run(shell=True)\n\n• on Windows command will be run in a Powershell shell\n\nThis differs from execute_command: it returns the exit code, and does not log the result and output of the command.\n\nParameters\n\n• cmd_name (str) – the user facing name of the hook being run\n\n• shell_cmd (str) – shell command to execute\n\n• env (dict) – environ to pass into subprocess.run\n\nReturns tuple (int returncode, str stderr, str stdout)\n\ncertbot.compat.misc.execute_command(cmd_name: str, shell_cmd: str, env: Optional[dict] = None) \\(\\rightarrow\\) Tuple[str, str]\nRun a command:\n• on Linux command will be run by the standard shell selected with subprocess.run(shell=True)\n• on Windows command will be run in a Powershell shell\n\nThis differs from execute_command: it returns the exit code, and does not log the result and output of the command.\n\nParameters\n• `cmd_name (str)` – the user facing name of the hook being run\n• `shell_cmd (str)` – shell command to execute\n• `env (dict)` – environ to pass into subprocess.run\n\nReturns tuple (str stderr, str stdout)\n\n`certbot.compat.os module`\n\nThis compat modules is a wrapper of the core os module that forbids usage of specific operations (e.g. chown, chmod, getuid) that would be harmful to the Windows file security model of Certbot. This module is intended to replace standard os module throughout certbot projects (except acme).\n\nThis module has the same API as the os module in the Python standard library except for the functions defined below.\n\n```python\nisort:skip_file\ncertbot.compat.os.access(*unused_args, **unused_kwargs)\n Method os.access() is forbidden\n\ncertbot.compat.os.chmod(*unused_args, **unused_kwargs)\n Method os.chmod() is forbidden\n\ncertbot.compat.os.chown(*unused_args, **unused_kwargs)\n Method os.chown() is forbidden\n\ncertbot.compat.os.fstat(*unused_args, **unused_kwargs)\n Method os.stat() is forbidden\n\ncertbot.compat.os.makedirs(*unused_args, **unused_kwargs)\n Method os.makedirs() is forbidden\n\ncertbot.compat.os.open(*unused_args, **unused_kwargs)\n Method os.open() is forbidden\n\ncertbot.compat.os.rename(*unused_args, **unused_kwargs)\n Method os.rename() is forbidden\n\ncertbot.compat.os.replace(*unused_args, **unused_kwargs)\n Method os.replace() is forbidden\n\ncertbot.compat.os.stat(*unused_args, **unused_kwargs)\n Method os.stat() is forbidden\n\ncertbot.compat.os.umask(*unused_args, **unused_kwargs)\n Method os.chmod() is forbidden\n\ncertbot.compat.os.mkdirs(*unused_args, **unused_kwargs)\n Method os.mkdirs() is forbidden\n```\ncertbot.display package\n\nCertbot display utilities.\n\nSubmodules\n\ncertbot.display.ops module\n\nContains UI methods for LE user operations.\n\n```\ncertbot.display.ops.get_email(invalid: bool = False, optional: bool = True) -> str\n```\n\nPrompt for valid email address.\n\n**Parameters**\n\n- `invalid (bool)` – True if an invalid address was provided by the user\n- `optional (bool)` – True if the user can use --register-unsafely-without-email to avoid providing an e-mail\n\n**Returns** e-mail address\n\n**Return type** str\n\n**Raises** errors.Error – if the user cancels\n\n```\ncertbot.display.ops.choose_account(accounts: List[certbot._internal.account.Account]) -> Optional[certbot._internal.account.Account]\n```\n\nChoose an account.\n\n**Parameters** `accounts (list)` – Containing at least one Account\n\n```\ncertbot.display.ops.choose_values(values: List[str], question: Optional[str] = None) -> List[str]\n```\n\nDisplay screen to let user pick one or multiple values from the provided list.\n\n**Parameters**\n\n- `values (list)` – Values to select from\n- `question (str)` – Question to ask to user while choosing values\n\n**Returns** List of selected values\n\n**Return type** list\n\n```\ncertbot.display.ops.choose_names(installer: Optional[certbot.interfaces.Installer], question: Optional[str] = None) -> List[str]\n```\n\nDisplay screen to select domains to validate.\n\n**Parameters**\n\n- `installer (certbot.interfaces.Installer)` – An installer object\n- `question (str)` – Overriding default question to ask the user if asked to choose from domain names.\n\n**Returns** List of selected names\n\n**Return type** list of str\n\n```\ncertbot.display.ops.get_valid_domains(domains: Iterable[str]) -> List[str]\n```\n\nHelper method for choose_names that implements basic checks on domain names\nCertbot Documentation, Release 1.31.0\n\nParameters **domains** *(list)* – Domain names to validate\n\nReturns List of valid domains\n\nReturn type **list**\n\ncertbot.display.ops.*success_installation*(domains: List[str]) → None\nDisplay a box confirming the installation of HTTPS.\n\nParameters **domains** *(list)* – domain names which were enabled\n\ncertbot.display.ops.*success_renewal*(unused_domains: List[str]) → None\nDisplay a box confirming the renewal of an existing certificate.\n\nParameters **domains** *(list)* – domain names which were renewed\n\ncertbot.display.ops.*success_revocation*(cert_path: str) → None\nDisplay a message confirming a certificate has been revoked.\n\nParameters **cert_path** *(list)* – path to certificate which was revoked.\n\ncertbot.display.ops.*report_executed_command*(command_name: str, returncode: int, stdout: str, stderr: str) → None\nDisplay a message describing the success or failure of an executed process (e.g. hook).\n\nParameters\n • **command_name** *(str)* – Human-readable description of the executed command\n • **returncode** *(int)* – The exit code of the executed command\n • **stdout** *(str)* – The stdout output of the executed command\n • **stderr** *(str)* – The stderr output of the executed command\n\ncertbot.display.ops.*validated_input*(validator: Callable[[str], Any], *args: Any, **kwargs: Any) → Tuple[str, str]\nLike *input_text*, but with validation.\n\nParameters\n • **validator** *(callable)* – A method which will be called on the supplied input. If the method raises an errors.Error, its text will be displayed and the user will be re-prompted.\n • **args** *(list)* – Arguments to be passed to *input_text*.\n • **kwargs** *(dict)* – Arguments to be passed to *input_text*.\n\nReturns as *input_text*\n\nReturn type **tuple**\n\ncertbot.display.ops.*validated_directory*(validator: Callable[[str], Any], *args: Any, **kwargs: Any) → Tuple[str, str]\nLike *directory_select*, but with validation.\n\nParameters\n • **validator** *(callable)* – A method which will be called on the supplied input. If the method raises an errors.Error, its text will be displayed and the user will be re-prompted.\n • **args** *(list)* – Arguments to be passed to *directory_select*.\n • **kwargs** *(dict)* – Arguments to be passed to *directory_select*.\n\nReturns as *directory_select*\nReturn type: tuple\n\ncertbot.display.util module\n\nInternal class delegating to a module, and displaying warnings when attributes related to deprecated attributes in the certbot.display.util module.\n\ncertbot.display.util.OK = 'ok'\nDisplay exit code indicating user acceptance.\n\ncertbot.display.util.CANCEL = 'cancel'\nDisplay exit code for a user canceling the display.\n\ncertbot.display.util.HELP = 'help'\nDisplay exit code when for when the user requests more help. (UNUSED)\n\ncertbot.display.util.ESC = 'esc'\nDisplay exit code when the user hits Escape (UNUSED)\n\ncertbot.display.util.notify(msg: str) → None\nDisplay a basic status message.\n\nParameters:\n- msg (str) – message to display\n\ncertbot.display.util.notification(message: str, pause: bool = True, wrap: bool = True, force_interactive: bool = False, decorate: bool = True) → None\nDisplays a notification and waits for user acceptance.\n\nParameters:\n- message (str) – Message to display\n- pause (bool) – Whether or not the program should pause for the user’s confirmation\n- wrap (bool) – Whether or not the application should wrap text\n- force_interactive (bool) – True if it’s safe to prompt the user because it won’t cause any workflow regressions\n- decorate (bool) – Whether to surround the message with a decorated frame\n\nDisplay a menu.\n\nParameters:\n- message (str) – title of menu\n- choices (list of tuples (tag, item) or list of descriptions (tags will be enumerated)) – Menu lines, len must be > 0\n- default – default value to return, if interaction is not possible\n- cli_flag (str) – option used to set this value with the CLI\n- force_interactive (bool) – True if it’s safe to prompt the user because it won’t cause any workflow regressions\n\nReturns: tuple of (code, index) where code - str display exit code index - int index of the user’s selection\n\nReturn type: tuple\n\nAccept input from the user.\n\n**Parameters**\n\n- **message (str)** – message to display to the user\n- **default** – default value to return, if interaction is not possible\n- **cli_flag (str)** – option used to set this value with the CLI\n- **force_interactive (bool)** – True if it’s safe to prompt the user because it won’t cause any workflow regressions\n\n**Returns** tuple of (code, input) where code - str display exit code input - str of the user’s input\n\n**Return type** tuple\n\n\nQuery the user with a yes/no question.\n\nYes and No label must begin with different letters, and must contain at least one letter each.\n\n**Parameters**\n\n- **message (str)** – question for the user\n- **yes_label (str)** – Label of the “Yes” parameter\n- **no_label (str)** – Label of the “No” parameter\n- **default** – default value to return, if interaction is not possible\n- **cli_flag (str)** – option used to set this value with the CLI\n- **force_interactive (bool)** – True if it’s safe to prompt the user because it won’t cause any workflow regressions\n\n**Returns** True for “Yes”, False for “No”\n\n**Return type** bool\n\n\nDisplay a checklist.\n\n**Parameters**\n\n- **message (str)** – Message to display to user\n- **tags (list)** – str tags to select, len(tags) > 0\n- **default** – default value to return, if interaction is not possible\n- **cli_flag (str)** – option used to set this value with the CLI\n- **force_interactive (bool)** – True if it’s safe to prompt the user because it won’t cause any workflow regressions\n\n**Returns** tuple of (code, tags) where code - str display exit code tags - list of selected tags\n\n**Return type** tuple\n\nDisplay a directory selection screen.\n\nParameters\n\n- **message** (str) – prompt to give the user\n- **default** – default value to return, if interaction is not possible\n- **cli_flag** (str) – option used to set this value with the CLI\n- **force_interactive** (bool) – True if it’s safe to prompt the user because it won’t cause any workflow regressions\n\nReturns\ntuple of the form (code, string) where code - display exit code string - input entered by the user\n\ncertbot.display.util.assert_valid_call(prompt: str, default: str, cli_flag: str, force_interactive: bool) → None\n\nVerify that provided arguments is a valid display call.\n\nParameters\n\n- **prompt** (str) – prompt for the user\n- **default** – default answer to prompt\n- **cli_flag** (str) – command line option for setting an answer to this question\n- **force_interactive** (bool) – if interactivity is forced\n\ncertbot.plugins package\n\nCertbot plugins.\n\nSubmodules\n\ncertbot.plugins.common module\n\nPlugin common functions.\n\ncertbot.plugins.common.option_namespace(name: str) → str\n\nArgumentParser options namespace (prefix of all options).\n\ncertbot.plugins.common.dest_namespace(name: str) → str\n\nArgumentParser dest namespace (prefix of all destinations).\n\nclass certbot.plugins.common.Plugin(config: certbot.configuration.NamespaceConfig, name: str)\n\nBases: certbot.interfaces.Plugin\n\nGeneric plugin.\n\nabstract classmethod add_parser_arguments(add: Callable[..., None]) → None\n\nAdd plugin arguments to the CLI argument parser.\n\nParameters\n\n- **add** (callable) – Function that proxies calls to argparse.ArgumentParser.add_argument prepending options with unique plugin name prefix.\nclassmethod inject_parser_options(parser: argparse.ArgumentParser, name: str) → None\n\nInject parser options.\n\nSee inject_parser_options for docs.\n\nproperty option_namespace: str\n\nArgumentParser options namespace (prefix of all options).\n\noption_name(name: str) → str\n\nOption name (include plugin namespace).\n\nproperty dest_namespace: str\n\nArgumentParser dest namespace (prefix of all destinations).\n\ndest(var: str) → str\n\nFind a destination for given variable var.\n\nconf(var: str) → Any\n\nFind a configuration value for variable var.\n\nauth_hint(failed_achalls: List[certbot.achallenges.AnnotatedChallenge]) → str\n\nHuman-readable string to help the user troubleshoot the authenticator.\n\nShown to the user if one or more of the attempted challenges were not a success.\n\nShould describe, in simple language, what the authenticator tried to do, what went wrong and what the user should try as their “next steps”.\n\nTODO: auth_hint belongs in Authenticator but can’t be added until the next major version of Certbot. For now, it lives in .Plugin and auth_handler will only call it on authenticators that subclass .Plugin. For now, inherit from Plugin to implement and/or override the method.\n\nParameters failed_achalls (list) – List of one or more failed challenges (achallenges.AnnotatedChallenge subclasses).\n\nRtype str\n\nclass certbot.plugins.common.Installer(*args: Any, **kwargs: Any)\n\nBases: certbot.interfaces.Installer, certbot.plugins.common.Plugin\n\nAn installer base class with reverter and ssl_dhparam methods defined.\n\nInstaller plugins do not have to inherit from this class.\n\nadd_to_checkpoint(save_files: Set[str], save_notes: str, temporary: bool = False) → None\n\nAdd files to a checkpoint.\n\nParameters\n\n• save_files (set) – set of filepaths to save\n\n• save_notes (str) – notes about changes during the save\n\n• temporary (bool) – True if the files should be added to a temporary checkpoint rather than a permanent one. This is usually used for changes that will soon be reverted.\n\nRaises errors.PluginError – when unable to add to checkpoint\n\nfinalize_checkpoint(title: str) → None\n\nTimestamp and save changes made through the reverter.\n\nParameters title (str) – Title describing checkpoint\n\nRaises errors.PluginError – when an error occurs\nrecovery_routine() → None\n Revert all previously modified files.\n Reverts all modified files that have not been saved as a checkpoint\n Raises errors.PluginError – If unable to recover the configuration\n\nrevert_temporary_config() → None\n Rollback temporary checkpoint.\n Raises errors.PluginError – when unable to revert config\n\nrollback_checkpoints(rollback: int = 1) → None\n Rollback saved checkpoints.\n Parameters rollback (int) – Number of checkpoints to revert\n Raises errors.PluginError – If there is a problem with the input or the function is unable to correctly revert the configuration\n\nproperty ssl_dhparams: str\n Full absolute path to ssl_dhparams file.\n\nproperty updated_ssl_dhparams_digest: str\n Full absolute path to digest of updated ssl_dhparams file.\n\ninstall_ssl_dhparams() → None\n Copy Certbot's ssl_dhparams file into the system's config dir if required.\n\nclass certbot.plugins.common.Configurator(*args: Any, **kwargs: Any)\n Bases: certbot.plugins.common.Installer, certbot.interfaces.Authenticator\n A plugin that extends certbot.plugins.common.Installer and implements certbot.interfaces.Authenticator\n\nclass certbot.plugins.common.Addr(tup: Tuple[str, str], ipv6: bool = False)\n Bases: object\n Represents an virtual host address.\n Parameters\n • addr (str) – addr part of vhost address\n • port (str) – port number or *, or \"\"\n classmethod fromstring(str_addr: str) → Optional[certbot.plugins.common.GenericAddr]\n Initialize Addr from string.\n\nnormalized_tuple() → Tuple[str, str]\n Normalized representation of addr/port tuple\n\nget_addr() → str\n Return addr part of Addr object.\n\nget_port() → str\n Return port.\n\nget_addr_obj(port: str) → certbot.plugins.common.GenericAddr\n Return new address object with same addr and new port.\n\nget_ipv6_exploded() → str\n Return IPv6 in normalized form\n\nclass certbot.plugins.common.ChallengePerformer(configurator: certbot.plugins.common.Configurator)\n Bases: object\n\n9.1. certbot package\nAbstract base for challenge performers.\n\nVariables\n\n- `configurator` – Authenticator and installer plugin\n- `achalls` (list of `KeyAuthorizationAnnotatedChallenge`) – Annotated challenges\n- `indices` (list of int) – Holds the indices of challenges from a larger array so the user of the class doesn’t have to.\n\n```python\nadd_chall(achall: certbot.achallenges.KeyAuthorizationAnnotatedChallenge, idx: Optional[int] = None) → None\n```\n\nStore challenge to be performed when `perform()` is called.\n\nParameters\n\n- `achall` (`KeyAuthorizationAnnotatedChallenge`) – Annotated challenge.\n- `idx` (int) – index to challenge in a larger array\n\n```python\nperform() → List[acme.challenges.KeyAuthorizationChallengeResponse]\n```\n\nPerform all added challenges.\n\nReturns\n\nchallenge responses\n\nReturn type\n\nlist of `acme.challenges.KeyAuthorizationChallengeResponse`\n\n```python\ncertbot.plugins.common.install_version_controlled_file(dest_path: str, digest_path: str, src_path: str, all_hashes: Iterable[str]) → None\n```\n\nCopy a file into an active location (likely the system’s config dir) if required.\n\nParameters\n\n- `dest_path` (str) – destination path for version controlled file\n- `digest_path` (str) – path to save a digest of the file in\n- `src_path` (str) – path to version controlled file found in distribution\n- `all_hashes` (list) – hashes of every released version of the file\n\n```python\ncertbot.plugins.common.dir_setup(test_dir: str, pkg: str) → Tuple[str, str, str]\n```\n\nSetup the directories necessary for the configurator.\n\n## certbot.plugins.dns_common module\n\nCommon code for DNS Authenticator Plugins.\n\n```python\nclass certbot.plugins.dns_common.DNSAuthenticator(config: certbot.configuration.NamespaceConfig, name: str)\n```\n\nBases: `certbot.plugins.common.Plugin, certbot.interfaces.Authenticator`\n\nBase class for DNS Authenticators\n\n```python\nclassmethod add_parser_arguments(add: Callable[[…], None], default_propagation_seconds: int = 10) → None\n```\n\nAdd plugin arguments to the CLI argument parser.\n\nParameters\n\n- `add` (callable) – Function that proxies calls to `argparse.ArgumentParser.add_argument` prepending options with unique plugin name prefix.\n\n```python\nauth_hint(failed_achalls: List[certbot.achallenges.AnnotatedChallenge]) → str\n```\n\nSee `certbot.plugins.common.Plugin.auth_hint`. \n\n---\n\nChapter 9. API Documentation\nget_chall_pref(unused_domain: str) → Iterable[Type[acme.challenges.Challenge]]\nReturn collections.Iterable of challenge preferences.\n\nParameters domain (str) – Domain for which challenge preferences are sought.\n\nReturns collections.Iterable of challenge types (subclasses of acme.challenges.Challenge) with the most preferred challenges first. If a type is not specified, it means the Authenticator cannot perform the challenge.\n\nReturn type collections.Iterable\n\nprepare() → None\nPrepare the plugin.\nFinish up any additional initialization.\n\nRaises\n\n- PluginError – when full initialization cannot be completed.\n- MisconfigurationError – when full initialization cannot be completed. Plugin will be displayed on a list of available plugins.\n- NoInstallationError – when the necessary programs/files cannot be located. Plugin will NOT be displayed on a list of available plugins.\n- NotSupportedError – when the installation is recognized, but the version is not currently supported.\n\nmore_info() → str\nHuman-readable string to help the user.\nShould describe the steps taken and any relevant info to help the user decide which plugin to use.\n\nRtype str\n\nperform(achalls: List[certbot.achallenges.AnnotatedChallenge]) → List[acme.challenges.ChallengeResponse]\nPerform the given challenge.\n\nParameters achalls (list) – Non-empty (guaranteed) list of AnnotatedChallenge instances, such that it contains types found within get_chall_pref() only.\n\nReturns list of ACME ChallengeResponse instances corresponding to each provided Challenge.\n\nReturn type collections.List of acme.challenges.ChallengeResponse, where responses are required to be returned in the same order as corresponding input challenges\n\nRaises PluginError – If some or all challenges cannot be performed\n\ncleanup(achalls: List[certbot.achallenges.AnnotatedChallenge]) → None\nRevert changes and shutdown after challenges complete.\n\nParameters achalls (list) – Non-empty (guaranteed) list of AnnotatedChallenge instances, a subset of those previously passed to perform().\n\nRaises PluginError – if original configuration cannot be restored\n\nclass certbot.plugins.dns_common.CredentialsConfiguration(filename: str, mapper: Callable[[str], str] = <function CredentialsConfiguration.<lambda>>)\n\nBases: object\nRepresents a user-supplied field which stores API credentials.\n\n**require** *(required_variables: Mapping[str, str]) → None*\nEnsures that the supplied set of variables are all present in the file.\n\n**Parameters**\n\n- **required_variables** *(dict)* — Map of variable which must be present to error to display.\n\n**Raises**\n\n- **errors.PluginError** — If one or more are missing.\n\n**conf**(var: str) → str\nFind a configuration value for variable var, as transformed by mapper.\n\n**Parameters**\n\n- **var** *(str)* — The variable to get.\n\n**Returns**\n\nThe value of the variable.\n\n**Return type**\n\nstr\n\ncertbot.plugins.dns_common.validate_file(filename: str) → None\nEnsure that the specified file exists.\n\ncertbot.plugins.dns_common.validate_file_permissions(filename: str) → None\nEnsure that the specified file exists and warn about unsafe permissions.\n\ncertbot.plugins.dns_common.base_domain_name_guesses(domain: str) → List[str]\nReturn a list of progressively less-specific domain names.\n\nOne of these will probably be the domain name known to the DNS provider.\n\n**Example**\n\n```python\n>>> base_domain_name_guesses('foo.bar.baz.example.com')\n['foo.bar.baz.example.com', 'bar.baz.example.com', 'baz.example.com', 'example.com', 'com']\n```\n\n**Parameters**\n\n- **domain** *(str)* — The domain for which to return guesses.\n\n**Returns**\n\nThe a list of less specific domain names.\n\n**Return type**\n\nlist\n\ncertbot.plugins.dns_common_lexicon module\n\nCommon code for DNS Authenticator Plugins built on Lexicon.\n\nclass certbot.plugins.dns_common_lexicon.LexiconClient\nBases: object\nEncapsulates all communication with a DNS provider via Lexicon.\n\n**add_txt_record**(domain: str, record_name: str, record_content: str) → None\nAdd a TXT record using the supplied information.\n\n**Parameters**\n\n- **domain** *(str)* — The domain to use to look up the managed zone.\n- **record_name** *(str)* — The record name (typically beginning with ‘_acme-challenge.’).\n- **record_content** *(str)* — The record content (typically the challenge validation).\n\n**Raises**\n\n- **errors.PluginError** — if an error occurs communicating with the DNS Provider API\ndel_txt_record(domain: str, record_name: str, record_content: str) → None\nDelete a TXT record using the supplied information.\n\nParameters\n\n• domain (str) – The domain to use to look up the managed zone.\n• record_name (str) – The record name (typically beginning with `_acme-challenge.`).\n• record_content (str) – The record content (typically the challenge validation).\n\nRaises errors.PluginError – if an error occurs communicating with the DNS Provider API\n\ncertbot.plugins.dns_common_lexicon.build_lexicon_config(lexicon_provider_name: str, lexicon_options: Mapping[str, Any], provider_options: Mapping[str, Any]) → Union[None, Dict[str, Any]]\nConvenient function to build a Lexicon 2.x/3.x config object.\n\n:param str lexicon_provider_name: the name of the lexicon provider to use\n:param dict lexicon_options: options specific to lexicon\n:param dict provider_options: options specific to provider\n:rtype: ConfigurationResolver or dict\n\ncertbot.plugins.dns_test_common module\n\nBase test class for DNS authenticators.\n\nclass certbot.plugins.dns_test_common.BaseAuthenticatorTest\nBases: object\n\nA base test class to reduce duplication between test code for DNS Authenticator Plugins.\n\nAssumes:\n\n• That subclasses also subclass unittest.TestCase\n• That the authenticator is stored as self.auth\n\nachall = KeyAuthorizationAnnotatedChallenge(challb=DNS01(token=b'17817c66b60ce2e4012dfad92657527a'), domain='example.com', account_key=JWKRSA(key=<ComparableRSAKey(<cryptography.hazmat.backends.openssl.rsa._RSAPrivateKey object>)>))\n\ntest_more_info() → None\ntest_get_chall_pref() → None\ntest_parser_arguments() → None\n\ncertbot.plugins.dns_test_common.write(values: Mapping[str, Any], path: str) → None\nWrite the specified values to a config file.\n\nParameters\n\n• values (dict) – A map of values to write.\n• path (str) – Where to write the values.\ncertbot.plugins.dns_test_common_lexicon module\n\nBase test class for DNS authenticators built on Lexicon.\n\nclass certbot.plugins.dns_test_common_lexicon.BaseLexiconAuthenticatorTest\n Bases: certbot.plugins.dns_test_common.BaseAuthenticatorTest\n test_perform(unused_mock_get_utility: Any) → None\n test_cleanup() → None\n\nclass certbot.plugins.dns_test_common_lexicon.BaseLexiconClientTest\n Bases: object\n DOMAIN_NOT_FOUND = Exception('No domain found')\n GENERIC_ERROR\n alias of requests.exceptions.RequestException\n LOGIN_ERROR = HTTPError('400 Client Error: ...')\n UNKNOWN_LOGIN_ERROR = HTTPError('500 Surprise! Error: ...')\n record_prefix = '_acme-challenge'\n record_name = '_acme-challenge.example.com'\n record_content = 'bar'\n test_add_txt_record() → None\n test_add_txt_record_try_twice_to_find_domain() → None\n test_add_txt_record_fail_to_find_domain() → None\n test_add_txt_record_fail_to_authenticate() → None\n test_add_txt_record_fail_to_authenticate_with_unknown_error() → None\n test_add_txt_record_error_finding_domain() → None\n test_add_txt_record_error_adding_record() → None\n test_del_txt_record() → None\n test_del_txt_record_fail_to_find_domain() → None\n test_del_txt_record_fail_to_authenticate() → None\n test_del_txt_record_fail_to_authenticate_with_unknown_error() → None\n test_del_txt_record_error_finding_domain() → None\n test_del_txt_record_error_deleting_record() → None\n**certbot.plugins.enhancements module**\n\nNew interface style Certbot enhancements\n\n```python\ncertbot.plugins.enhancements.ENHANCEMENTS = ['redirect', 'ensure-http-header', 'ocsp-stapling']\n```\n\nList of possible `certbot.interfaces.Installer` enhancements.\n\nList of expected options parameters: - redirect: None - ensure-http-header: name of header (i.e. Strict-Transport-Security) - ocsp-stapling: certificate chain file path\n\n```python\ncertbot.plugins.enhancements.enabled_enhancements(config: certbot.configuration.NamespaceConfig) → Generator[Dict[str, Any], None, None]\n```\n\nGenerator to yield the enabled new style enhancements.\n\n**Parameters**\n- `config` (`certbot.configuration.NamespaceConfig`) – Configuration.\n\n```python\ncertbot.plugins.enhancements.are_requested(config: certbot.configuration.NamespaceConfig) → bool\n```\n\nChecks if one or more of the requested enhancements are those of the new enhancement interfaces.\n\n**Parameters**\n- `config` (`certbot.configuration.NamespaceConfig`) – Configuration.\n\n```python\ncertbot.plugins.enhancements.are_supported(config: certbot.configuration.NamespaceConfig, installer: Optional[certbot.interfaces.Installer]) → bool\n```\n\nChecks that all of the requested enhancements are supported by the installer.\n\n**Parameters**\n- `config` (`certbot.configuration.NamespaceConfig`) – Configuration.\n- `installer` (`interfaces.Installer`) – Installer object\n\n**Returns**\n- If all the requested enhancements are supported by the installer\n\n**Return type**\n- `bool`\n\n```python\ncertbot.plugins.enhancements.enable(lineage: Optional[certbot.interfaces.RenewableCert], domains: Iterable[str], installer: Optional[certbot.interfaces.Installer], config: certbot.configuration.NamespaceConfig) → None\n```\n\nRun enable method for each requested enhancement that is supported.\n\n**Parameters**\n- `lineage` (`certbot.interfaces.RenewableCert`) – Certificate lineage object\n- `domains` (`str`) – List of domains in certificate to enhance\n- `installer` (`interfaces.Installer`) – Installer object\n- `config` (`certbot.configuration.NamespaceConfig`) – Configuration.\n\n```python\ncertbot.plugins.enhancements.populate_cli(add: Callable[..., None]) → None\n```\n\nPopulates the command line flags for `certbot._internal.cli.HelpfulParser`\n\n**Parameters**\n- `add` (`func`) – Add function of `certbot._internal.cli.HelpfulParser`\n\n---\n\n**class certbot.plugins.enhancements.AutoHSTSEnhancement**\n\n**Bases:** `object`\n\nEnhancement interface that installer plugins can implement in order to provide functionality that configures the software to have a ‘Strict-Transport-Security’ with initially low max-age value that will increase over time.\n\nThe plugins implementing new style enhancements are responsible of handling the saving of configuration checkpoints as well as calling possible restarts of managed software themselves. For `update_autohsts` method, the installer may have to call `prepare()` to finalize the plugin initialization.\n**Methods:**\n\n`enable_autohsts` is called when the header is initially installed using a low max-age value.\n\n`update_autohsts` is called every time Certbot is run using ‘renew’ verb. The max-age value should be increased over time using this method.\n\n`deploy_autohsts` is called for every lineage that has had its certificate renewed. A long HSTS max-age value should be set here, as we should be confident that the user is able to automatically renew their certificates.\n\n```python\nabstract update_autohsts(lineage: certbot.interfaces.RenewableCert, *args: Any, **kwargs: Any) → None\n```\n\nGets called for each lineage every time Certbot is run with ‘renew’ verb. Implementation of this method should increase the max-age value.\n\n**Parameters**\n\n- **lineage** *(certbot.interfaces.RenewableCert)* – Certificate lineage object\n\n**Note:** `prepare()` method inherited from `interfaces.Plugin` might need to be called manually within implementation of this interface method to finalize the plugin initialization.\n\n```python\nabstract deploy_autohsts(lineage: certbot.interfaces.RenewableCert, *args: Any, **kwargs: Any) → None\n```\n\nGets called for a lineage when its certificate is successfully renewed. Long max-age value should be set in implementation of this method.\n\n**Parameters**\n\n- **lineage** *(certbot.interfaces.RenewableCert)* – Certificate lineage object\n\n```python\nabstract enable_autohsts(lineage: Optional[certbot.interfaces.RenewableCert], domains: Iterable[str], *args: Any, **kwargs: Any) → None\n```\n\nEnables the AutoHSTS enhancement, installing Strict-Transport-Security header with a low initial value to be increased over the subsequent runs of Certbot renew.\n\n**Parameters**\n\n- **lineage** *(certbot.interfaces.RenewableCert)* – Certificate lineage object\n- **domains** *(list of str)* – List of domains in certificate to enhance\n\n### certbot.plugins.storage module\n\nPlugin storage class.\n\n```python\nclass certbot.plugins.storage.PluginStorage(config: certbot.configuration.NamespaceConfig, classkey: str)\n```\n\n**Bases:** `object`\n\nClass implementing storage functionality for plugins\n\n```python\nsave() → None\n```\n\nSaves PluginStorage content to disk\n\n**Raises** `errors.PluginStorageError` – when unable to serialize the data or write it to the filesystem\n\n```python\nput(key: str, value: Any) → None\n```\n\nPut configuration value to PluginStorage\n\n**Parameters**\n\n- **key** *(str)* – Key to store the value to\n- **value** – Data to store\n**fetch**(*key: str*) → Any\nGet configuration value from PluginStorage\n\n**Parameters**\n*key* (*str*) – Key to get value from the storage\n\n**Raises**\n*KeyError* – If the key doesn’t exist in the storage\n\n**certbot.plugins.util module**\nPlugin utilities.\n\n**certbot.plugins.util.get_prefixes**(*path: str*) → List[str]\nRetrieves all possible path prefixes of a path, in descending order of length. For instance:\n\n- (Linux) /a/b/c returns ['/a/b/c', '/a/b', '/a', '/']\n- (Windows) C:abc returns ['C:abc', 'C:ab', 'C:a', 'C:']\n\n**Parameters**\n*path* (*str*) – the path to break into prefixes\n\n**Returns**\nall possible path prefixes of given path in descending order\n\n**Return type**\nlist of str\n\n**certbot.plugins.util.path_surgery**(*cmd: str*) → bool\nAttempt to perform PATH surgery to find cmd\n\nMitigates https://github.com/certbot/certbot/issues/1833\n\n**Parameters**\n*cmd* (*str*) – the command that is being searched for in the PATH\n\n**Returns**\nTrue if the operation succeeded, False otherwise\n\n**certbot.tests package**\nUtilities for running Certbot tests\n\n**Submodules**\n\n**certbot.tests.acme_util module**\nACME utilities for testing.\n\n**certbot.tests.acme_util.gen_combos**(*challbs: Iterable[acme.messages.ChallengeBody]*) → Tuple[Tuple[int], ...]\nGenerate natural combinations for challbs.\n\n**certbot.tests.acme_util.chall_to_challb**(*chall: acme.challenges.Challenge, status: acme.messages.Status*) → acme.messages.ChallengeBody\nReturn ChallengeBody from Challenge.\n\nGenerate an authorization resource.\n\n**Parameters**\n• **authz_status** (acme.messages.Status) – Status object \n• **challs** (list) – Challenge objects \n• **statuses** (list) – status of each challenge object \n• **combos** (bool) – Whether or not to add combinations\n\n**certbot.tests.util module**\n\nTest utilities.\n\nclass certbot.tests.util.DummyInstaller(*args: Any, **kwargs: Any) \nBases: certbot.plugins.common.Installer\n\nDummy installer plugin for test purpose.\n\n get_all_names() → Iterable[str] \n Returns all names that may be authenticated. \n \n Return type collections.Iterable of str\n\ndeploy_cert(domain: str, cert_path: str, key_path: str, chain_path: str, fullchain_path: str) → None \nDeploy certificate.\n\n Parameters\n\n • **domain** (str) – domain to deploy certificate file \n • **cert_path** (str) – absolute path to the certificate file \n • **key_path** (str) – absolute path to the private key file \n • **chain_path** (str) – absolute path to the certificate chain file \n • **fullchain_path** (str) – absolute path to the certificate fullchain file (cert plus chain) \n\n Raises **PluginError** – when cert cannot be deployed\n\n enhance(domain: str, enhancement: str, options: Optional[Union[List[str], str]] = None) → None \nPerform a configuration enhancement.\n\n Parameters\n\n • **domain** (str) – domain for which to provide enhancement \n • **enhancement** (str) – An enhancement as defined in **ENHANCEMENTS** \n • **options** – Flexible options parameter for enhancement. Check documentation of **ENHANCEMENTS** for expected options for each enhancement. \n\n Raises **PluginError** – If Enhancement is not supported, or if an error occurs during the enhancement.\n\n supported_enhancements() → List[str] \nReturns a collections.Iterable of supported enhancements.\n\n Returns supported enhancements which should be a subset of **ENHANCEMENTS**\n\n Return type collections.Iterable of str\n\n save(title: Optional[str] = None, temporary: bool = False) → None \nSaves all changes to the configuration files.\n\nBoth title and temporary are needed because a save may be intended to be permanent, but the save is not ready to be a full checkpoint.\nIt is assumed that at most one checkpoint is finalized by this method. Additionally, if an exception is raised, it is assumed a new checkpoint was not finalized.\n\n**Parameters**\n\n- **title** *(str)* – The title of the save. If a title is given, the configuration will be saved as a new checkpoint and put in a timestamped directory. `title` has no effect if `temporary` is true.\n\n- **temporary** *(bool)* – Indicates whether the changes made will be quickly reversed in the future (challenges)\n\n**Raises** `PluginError` – when save is unsuccessful\n\n```python\ndef config_test() -> None:\n Make sure the configuration is valid.\n```\n\n** Raises** `MisconfigurationError` – when the config is not in a usable state\n\n```python\ndef restart() -> None:\n Restart or refresh the server content.\n```\n\n** Raises** `PluginError` – when server cannot be restarted\n\n```python\ndef classmethod add_parser_arguments(add: Callable[..., None]) -> None:\n Add plugin arguments to the CLI argument parser.\n```\n\n**Parameters** `add` *(callable)* – Function that proxies calls to `argparse.ArgumentParser.add_argument` prepping options with unique plugin name prefix.\n\n```python\ndef prepare() -> None:\n Prepare the plugin.\n```\n\n** Raises**\n\n- `PluginError` – when full initialization cannot be completed.\n\n- `MisconfigurationError` – when full initialization cannot be completed. Plugin will be displayed on a list of available plugins.\n\n- `NoInstallationError` – when the necessary programs/files cannot be located. Plugin will NOT be displayed on a list of available plugins.\n\n- `NotSupportedError` – when the installation is recognized, but the version is not currently supported.\n\n```python\ndef more_info() -> str:\n Human-readable string to help the user.\n```\n\nShould describe the steps taken and any relevant info to help the user decide which plugin to use.\n\n**Rtype** `str`\ncertbot.tests.util.load_comparable_csr(*names: str) → josepy.util.ComparableX509\nLoad ComparableX509 certificate request.\n\ncertbot.tests.util.load_rsa_private_key(*names: str) → josepy.util.ComparableRSAKey\nLoad RSA private key.\n\ncertbot.tests.util.load_pyopenssl_private_key(*names: str) → OpenSSL.crypto.PKey\nLoad pyOpenSSL private key.\n\ncertbot.tests.util.make_lineage(config_dir: str, testfile: str, ec: bool = False) → str\nCreates a lineage defined by testfile.\n\nThis creates the archive, live, and renewal directories if necessary and creates a simple lineage.\n\nParameters\n\n- **config_dir** (str) – path to the configuration directory\n- **testfile** (str) – configuration file to base the lineage on\n- **ec** (bool) – True if we generate the lineage with an ECDSA key\n\nReturns\n\npath to the renewal conf file for the created lineage\n\nReturn type\n\nstr\n\ncertbot.tests.util.patch_get_utility(target: str = 'zope.component.getUtility') → mock.MagicMock\nDeprecated, patch certbot.display.util directly or use patch_display_util instead.\n\nParameters\n\n- **target** (str) – path to patch\n\nReturns\n\nmock zope.component.getUtility\n\nReturn type\n\nmock.MagicMock\n\ncertbot.tests.util.patch_get_utility_with_stdout(target: str = 'zope.component.getUtility', stdout: Optional[IO] = None) → mock.MagicMock\nDeprecated, patch certbot.display.util directly or use patch_display_util_with_stdout instead.\n\nParameters\n\n- **target** (str) – path to patch\n- **stdout** (object) – object to write standard output to; it is expected to have a write method\n\nReturns\n\nmock zope.component.getUtility\n\nReturn type\n\nmock.MagicMock\n\ncertbot.tests.util.patch_display_util() → mock.MagicMock\nPatch certbot.display.util to use a special mock display utility.\n\nThe mock display utility works like a regular mock object, except it also also asserts that methods are called with valid arguments.\n\nThe mock created by this patch mocks out Certbot internals so this can be used like the old patch_get_utility function. That is, the mock object will be called by the certbot.display.util functions and the mock returned by that call will be used as the display utility. This was done to simplify the transition from zope.component and mocking certbot.display.util functions directly in test code should be preferred over using this function in the future.\n\nSee https://github.com/certbot/certbot/issues/8948\n\nReturns\n\npatch on the function used internally by certbot.display.util to get a display utility instance\n\nReturn type\n\nmock.MagicMock\nPatch certbot.display.util to use a special mock display utility.\n\nThe mock display utility works like a regular mock object, except it also asserts that methods are called with valid arguments.\n\nThe mock created by this patch mocks out Certbot internals so this can be used like the old patch_get_utility function. That is, the mock object will be called by the certbot.display.util functions and the mock returned by that call will be used as the display utility. This was done to simplify the transition from zope.component and mocking certbot.display.util functions directly in test code should be preferred over using this function in the future.\n\nSee https://github.com/certbot/certbot/issues/8948\n\nThe message argument passed to the display utility methods is passed to stdout’s write method.\n\nParameters\n\n- **message**: object\n\nReturns\n\n- patch on the function used internally by certbot.display.util to get a display utility instance\n\nReturn type\n\nmock.MagicMock\n\nclass certbot.tests.util.FreezableMock\n\nBases: object\n\nMock object with the ability to freeze attributes.\n\nThis class works like a regular mock.MagicMock object, except attributes and behavior set before the object is frozen cannot be changed during tests.\n\nIf a func argument is provided to the constructor, this function is called first when an instance of FreezableMock is called, followed by the usual behavior defined by MagicMock. The return value of func is ignored.\n\nfreeze() → None\n\nFreeze object preventing further changes.\n\nclass certbot.tests.util.TempDirTestCase\n\nBases: unittest.case.TestCase\n\nBase test class which sets up and tears down a temporary directory\n\nsetUp() → None\n\nExecute before test\n\ntearDown() → None\n\nExecute after test\n\nclass certbot.tests.util.ConfigTestCase\n\nBases: certbot.tests.util.TempDirTestCase\n\nTest class which sets up a NamespaceConfig object.\n\nsetUp() → None\n\nExecute before test\n\ncertbot.tests.util.lock_and_call(callback: Callable[..., Any], path_to_lock: str) → None\n\nGrab a lock on path_to_lock from a foreign process then execute the callback.\n\n:param callback: object to call after acquiring the lock\n:param str path_to_lock: path to file or directory to lock\n\ncertbot.tests.util.skip_on_windows(reason: str) → Callable[[Callable[..., Any]], Callable[..., Any]]\n\nDecorator to skip permanently a test on Windows. A reason is required.\ncertbot.tests.util.temp_join(path: str) → str\n\nReturn the given path joined to the tempdir path for the current platform Eg.: ‘cert’ => /tmp/cert (Linux) or ‘C:UserscurrentuserAppDataTempcert’ (Windows)\n\n### 9.1.2 Submodules\n\n**certbot.achallenges module**\n\nClient annotated ACME challenges.\n\nPlease use names such as achall to distinguish from variables “of type” `acme.challenges.Challenge` (denoted by chall) and `ChallengeBody` (denoted by challb):\n\n```python\nfrom acme import challenges\nfrom acme import messages\nfrom certbot import achallenges\n\nchall = challenges.DNS(token='foo')\nchallb = messages.ChallengeBody(chall=chall)\nachall = achallenges.DNS(chall=challb, domain='example.com')\n```\n\nNote, that all annotated challenges act as a proxy objects:\n\n```python\nachall.token == challb.token\n```\n\n```python\nclass certbot.achallenges.AnnotatedChallenge(**kwargs: Any)\n Bases: josepy.util.ImmutableMap\n Client annotated challenge.\n Wraps around server provided challenge and annotates with data useful for the client.\n \n Variables challb – Wrapped ChallengeBody.\n\n challb\nclass certbot.achallenges.KeyAuthorizationAnnotatedChallenge(**kwargs: Any)\n Bases: certbot.achallenges.AnnotatedChallenge\n Client annotated KeyAuthorizationChallenge challenge.\n \n response_and_validation(*args: Any, **kwargs: Any) → Any\n Generate response and validation.\n\n challb\n domain\n account_key\nclass certbot.achallenges.DNS(**kwargs: Any)\n Bases: certbot.achallenges.AnnotatedChallenge\n Client annotated “dns” ACME challenge.\n \n acme_type\n alias of acme.challenges.DNS\n\n challb\n domain\n```\ncertbot.crypto_util module\n\nCertbot client crypto utility functions.\n\n**certbot.crypto_util.generate_key**\n\n\\[\n\\text{generate_key}(key\\_size: \\text{int}, \\text{key\\_dir: \\text{str}, \\text{key\\_type: \\text{str = 'rsa', elliptic\\_curve: \\text{str = 'secp256r1', keyname: \\text{str = 'key-certbot.pem', strict\\_permissions: \\text{bool = True}} \\to \\text{certbot.util.Key}}}\n\\]\n\nInitializes and saves a privkey.\n\nInits key and saves it in PEM format on the filesystem.\n\n**Note:** keyname is the attempted filename, it may be different if a file already exists at the path.\n\n**Parameters**\n\n- **key_size** (**int**) – key size in bits if key size is rsa.\n- **key_dir** (**str**) – Key save directory.\n- **key_type** (**str**) – Key Type [rsa, ecdsa]\n- **elliptic_curve** (**str**) – Name of the elliptic curve if key type is ecdsa.\n- **keyname** (**str**) – Filename of key\n- **strict_permissions** (**bool**) – If true and key_dir exists, an exception is raised if the directory doesn’t have 0700 permissions or isn’t owned by the current user.\n\n**Returns** Key\n\n**Return type** *certbot.util.Key*\n\n** Raises ** ValueException – If unable to generate the key given key_size.\n\n**certbot.crypto_util.init_save_key**\n\n\\[\n\\text{init_save_key}(key\\_size: \\text{int, key\\_dir: \\text{str, key\\_type: \\text{str = 'rsa', elliptic\\_curve: \\text{str = 'secp256r1', keyname: \\text{str = 'key-certbot.pem'}} \\to \\text{certbot.util.Key}}}\n\\]\n\nInitializes and saves a privkey.\n\nInits key and saves it in PEM format on the filesystem.\n\n**Note:** keyname is the attempted filename, it may be different if a file already exists at the path.\n\n**Deprecated since version 1.16.0:** Use **generate_key()** instead.\n\n**Parameters**\n\n- **key_size** (**int**) – key size in bits if key size is rsa.\n- **key_dir** (**str**) – Key save directory.\n- **key_type** (**str**) – Key Type [rsa, ecdsa]\n- **elliptic_curve** (**str**) – Name of the elliptic curve if key type is ecdsa.\n- **keyname** (**str**) – Filename of key\n\n**Returns** Key\n\n**Return type** *certbot.util.Key*\n\n** Raises ** ValueException – If unable to generate the key given key_size.\n**Certbot Documentation, Release 1.31.0**\n\n```python\ncertbot.crypto_util.generate_csr(privkey: certbot.util.Key, names: Union[List[str], Set[str]], path: str, must_staple: bool = False, strict_permissions: bool = True) → certbot.util.CSR\n```\n\nInitialize a CSR with the given private key.\n\n**Parameters**\n\n- `privkey` *(certbot.util.Key)* – Key to include in the CSR\n- `names` *(set)* – `str` names to include in the CSR\n- `path` *(str)* – Certificate save directory.\n- `must_staple` *(bool)* – If true, include the TLS Feature extension “OCSP Must-Staple”\n- `strict_permissions` *(bool)* – If true and path exists, an exception is raised if the directory doesn’t have 0755 permissions or isn’t owned by the current user.\n\n**Returns** CSR\n\n**Return type** `certbot.util.CSR`\n\n```python\ncertbot.crypto_util.init_save_csr(privkey: certbot.util.Key, names: Set[str], path: str) → certbot.util.CSR\n```\n\nInitialize a CSR with the given private key.\n\n**Deprecation**\n\n*Deprecated since version 1.16.0:* Use `generate_csr()` instead.\n\n**Parameters**\n\n- `privkey` *(certbot.util.Key)* – Key to include in the CSR\n- `names` *(set)* – `str` names to include in the CSR\n- `path` *(str)* – Certificate save directory.\n\n**Returns** CSR\n\n**Return type** `certbot.util.CSR`\n\n```python\ncertbot.crypto_util.valid_csr(csr: bytes) → bool\n```\n\nValidate CSR.\n\nCheck if `csr` is a valid CSR for the given domains.\n\n**Parameters**\n\n- `csr` *(bytes)* – CSR in PEM.\n\n**Returns** Validity of CSR.\n\n**Return type** `bool`\n\n```python\ncertbot.crypto_util.csr_matches_pubkey(csr: bytes, privkey: bytes) → bool\n```\n\nDoes private key correspond to the subject public key in the CSR?\n\n**Parameters**\n\n- `csr` *(bytes)* – CSR in PEM.\n- `privkey` *(bytes)* – Private key file contents (PEM)\n\n**Returns** Correspondence of private key to CSR subject public key.\n\n**Return type** `bool`\n\n```python\ncertbot.crypto_util.import_csr_file(csrfile: str, data: bytes) → Tuple[int, certbot.util.CSR, List[str]]\n```\n\nImport a CSR file, which can be either PEM or DER.\n\n**Parameters**\n\n- `csrfile` *(str)* – CSR filename\n- **data** *(bytes)* – contents of the CSR file\n\n**Returns** *(crypto.FILETYPE_PEM, util.CSR object representing the CSR, list of domains requested in the CSR)*\n\n**Return type** *tuple*\n\n```python\ncertbot.crypto_util.make_key(bits: int = 1024, key_type: str = 'rsa', elliptic_curve: Optional[str] = None) → bytes\n```\n\nGenerate PEM encoded RSA|EC key.\n\n**Parameters**\n\n- **bits** *(int)* – Number of bits if key_type=rsa. At least 1024 for RSA.\n- **key_type** *(str)* – The type of key to generate, but be rsa or ecdsa\n- **elliptic_curve** *(str)* – The elliptic curve to use.\n\n**Returns** new RSA or ECDSA key in PEM form with specified number of bits or of type ec_curve when key_type ecdsa is used.\n\n**Return type** *str*\n\n```python\ncertbot.crypto_util.valid_privkey(privkey: str) → bool\n```\n\nIs valid RSA private key?\n\n**Parameters** *privkey* *(str)* – Private key file contents in PEM\n\n**Returns** Validity of private key.\n\n**Return type** *bool*\n\n```python\ncertbot.crypto_util.verify_renewable_cert(renewable_cert: certbot.interfaces.RenewableCert) → None\n```\n\nFor checking that your certs were not corrupted on disk.\n\n**Several things are checked:**\n\n1. Signature verification for the cert.\n2. That fullchain matches cert and chain when concatenated.\n3. Check that the private key matches the certificate.\n\n**Parameters** *renewable_cert* *(certbot.interfaces.RenewableCert)* – cert to verify\n\n**Raises** *errors.Error* – If verification fails.\n\n```python\ncertbot.crypto_util.verify_renewable_cert_sig(renewable_cert: certbot.interfaces.RenewableCert) → None\n```\n\nVerifies the signature of a RenewableCert object.\n\n**Parameters** *renewable_cert* *(certbot.interfaces.RenewableCert)* – cert to verify\n\n**Raises** *errors.Error* – If signature verification fails.\n\nCheck the signature of a payload.\n\nParameters\n\n- **public_key** (RSAPublicKey/EllipticCurvePublicKey) – the public_key to check signature\n- **signature** (bytes) – the signature bytes\n- **payload** (bytes) – the payload bytes\n- **signature_hash_algorithm** (hashes.HashAlgorithm) – algorithm used to hash the payload\n\nRaises\n\n- **InvalidSignature** – If signature verification fails.\n- **errors.Error** – If public key type is not supported\n\ncertbot.crypto_util.verify_cert_matches_priv_key(cert_path: str, key_path: str) → None\n\nVerifies that the private key and cert match.\n\nParameters\n\n- **cert_path** (str) – path to a cert in PEM format\n- **key_path** (str) – path to a private key file\n\nRaises **errors.Error** – If they don’t match.\n\ncertbot.crypto_util.verify_fullchain(renewable_cert: certbot.interfaces.RenewableCert) → None\n\nVerifies that fullchain is indeed cert concatenated with chain.\n\nParameters **renewable_cert** (certbot.interfaces.RenewableCert) – cert to verify\n\nRaises **errors.Error** – If cert and chain do not combine to fullchain.\n\ncertbot.crypto_util.pyopenssl_load_certificate(data: bytes) → Tuple[OpenSSL.crypto.X509, int]\n\nLoad PEM/DER certificate.\n\nRaises **errors.Error** –\n\ncertbot.crypto_util.get_sans_from_cert(cert: bytes, typ: int = 1) → List[str]\n\nGet a list of Subject Alternative Names from a certificate.\n\nParameters\n\n- **cert** (str) – Certificate (encoded).\n- **typ** – crypto.FILETYPE_PEM or crypto.FILETYPE_ASN1\n\nReturns A list of Subject Alternative Names.\n\nReturn type list\ncertbot.crypto_util.get_names_from_cert(cert: bytes, typ: int = 1) → List[str]\nGet a list of domains from a cert, including the CN if it is set.\n\nParameters\n • cert (str) – Certificate (encoded).\n • typ – crypto.FILETYPE_PEM or crypto.FILETYPE_ASN1\n\nReturns A list of domain names.\nReturn type list\ncertbot.crypto_util.get_names_from_req(csr: bytes, typ: int = 1) → List[str]\nGet a list of domains from a CSR, including the CN if it is set.\n\nParameters\n • csr (str) – CSR (encoded).\n • typ – crypto.FILETYPE_PEM or crypto.FILETYPE_ASN1\n\nReturns A list of domain names.\nReturn type list\ncertbot.crypto_util.dump_pyopenssl_chain(chain: Union[List[OpenSSL.crypto.X509], List[josepy.util.ComparableX509]], filetype: int = 1) → bytes\nDump certificate chain into a bundle.\n\nParameters chain (list) – List of crypto.X509 (or wrapped in josepy.util.ComparableX509).\n\ncertbot.crypto_util.notBefore(cert_path: str) → datetime.datetime\nWhen does the cert at cert_path start being valid?\n\nParameters cert_path (str) – path to a cert in PEM format\n\nReturns the notBefore value from the cert at cert_path\nReturn type datetime.datetime\ncertbot.crypto_util.notAfter(cert_path: str) → datetime.datetime\nWhen does the cert at cert_path stop being valid?\n\nParameters cert_path (str) – path to a cert in PEM format\n\nReturns the notAfter value from the cert at cert_path\nReturn type datetime.datetime\ncertbot.crypto_util.sha256sum(filename: str) → str\nCompute a sha256sum of a file.\n\nNB: In given file, platform specific newlines characters will be converted into their equivalent unicode counterparts before calculating the hash.\n\nParameters filename (str) – path to the file whose hash will be computed\n\nReturns sha256 digest of the file in hexadecimal\nReturn type str\ncertbot.crypto_util.cert_and_chain_from_fullchain(fullchain_pem: str) → Tuple[str, str]\nSplit fullchain_pem into cert_pem and chain_pem\n\nParameters fullchain_pem (str) – concatenated cert + chain\nReturns tuple of string cert_pem and chain_pem\n\nReturn type tuple\n\nRaises errors.Error – If there are less than 2 certificates in the chain.\n\ncertbot.crypto_util.get_serial_from_cert(cert_path: str) → int\nRetrieve the serial number of a certificate from certificate path\n\nParameters cert_path (str) – path to a cert in PEM format\n\nReturns serial number of the certificate\n\nReturn type int\n\ncertbot.crypto_util.find_chain_with_issuer(fullchains: List[str], issuer_cn: str, warn_on_no_match: bool = False) → str\nChooses the first certificate chain from fullchains whose topmost intermediate has an Issuer Common Name matching issuer_cn (in other words the first chain which chains to a root whose name matches issuer_cn).\n\nParameters\n • fullchains (list of str) – The list of fullchains in PEM chain format.\n • issuer_cn (str) – The exact Subject Common Name to match against any issuer in the certificate chain.\n\nReturns The best-matching fullchain, PEM-encoded, or the first if none match.\n\nReturn type str\n\ncertbot.errors module\n\nCertbot client errors.\n\nexception certbot.errors.Error\n Bases: Exception\n Generic Certbot client error.\n\nexception certbot.errors.AccountStorageError\n Bases: certbot.errors.Error\n Generic AccountStorage error.\n\nexception certbot.errors.AccountNotFound\n Bases: certbot.errors.AccountStorageError\n Account not found error.\n\nexception certbot.errors.ReverterError\n Bases: certbot.errors.Error\n Certbot Reverter error.\n\nexception certbot.errors.SubprocessError\n Bases: certbot.errors.Error\n Subprocess handling error.\n\nexception certbot.errors.CertStorageError\n Bases: certbot.errors.Error\n Generic CertStorage error.\nexception certbot.errors.HookCommandNotFound\n Bases: certbot.errors.Error\n Failed to find a hook command in the PATH.\n\nexception certbot.errors.SignalExit\n Bases: certbot.errors.Error\n A Unix signal was received while in the ErrorHandler context manager.\n\nexception certbot.errors.OverlappingMatchFound\n Bases: certbot.errors.Error\n Multiple lineages matched what should have been a unique result.\n\nexception certbot.errors.LockError\n Bases: certbot.errors.Error\n File locking error.\n\nexception certbot.errors.AuthorizationError\n Bases: certbot.errors.Error\n Authorization error.\n\nexception certbot.errors.FailedChallenges(failed_achalls: Set[AnnotatedChallenge])\n Bases: certbot.errors.AuthorizationError\n Failed challenges error.\n \n Variables failed_achalls (set) – Failed AnnotatedChallenge instances.\n\nexception certbot.errors.PluginError\n Bases: certbot.errors.Error\n Certbot Plugin error.\n\nexception certbot.errors.PluginEnhancementAlreadyPresent\n Bases: certbot.errors.Error\n Enhancement was already set\n\nexception certbot.errors.PluginSelectionError\n Bases: certbot.errors.Error\n A problem with plugin/configurator selection or setup\n\nexception certbot.errors.NoInstallationError\n Bases: certbot.errors.PluginError\n Certbot No Installation error.\n\nexception certbot.errors.MisconfigurationError\n Bases: certbot.errors.PluginError\n Certbot Misconfiguration error.\n\nexception certbot.errors.NotSupportedException\n Bases: certbot.errors.PluginError\n Certbot Plugin function not supported error.\n\nexception certbot.errors.PluginStorageError\n Bases: certbot.errors.PluginError\n Certbot Plugin Storage error.\nexception certbot.errors.StandaloneBindError\n Bases: certbot.errors.Error\n Standalone plugin bind error.\n\ndefinition of ConfigurationError\n Bases: certbot.errors.Error\n Configuration sanity error.\n\ndefinition of MissingCommandLineFlag\n Bases: certbot.errors.Error\n A command line argument was missing in noninteractive usage\n\ncertbot.interfaces module\n Internal class delegating to a module, and displaying warnings when attributes related to Zope interfaces are accessed.\n\nclass certbot.interfaces.AccountStorage\n Bases: object\n Accounts storage interface.\n \n abstract find_all() -> List[Account]\n Find all accounts.\n Returns All found accounts.\n Return type list\n \n abstract load(account_id: str) -> Account\n Load an account by its id.\n Raises\n • AccountNotFound – if account could not be found\n • AccountStorageError – if account could not be loaded\n Returns The account loaded\n Return type Account\n \n abstract save(account: Account, client: acme.client.ClientBase) -> None\n Save account.\n Raises AccountStorageError – if account could not be saved\n\nclass certbot.interfaces.Plugin\n Bases: object\n Certbot plugin.\n \n Objects providing this interface will be called without satisfying any entry point “extras” (extra dependencies) you might have defined for your plugin, e.g (excerpt from setup.py script):\n\n setup(\n ...\n entry_points={\n 'certbot.plugins': [\n 'name=example_project.plugin[plugin_deps]',\n \n(continues on next page)\nTherefore, make sure such objects are importable and usable without extras. This is necessary, because CLI does the following operations (in order):\n\n- loads an entry point,\n- calls \\texttt{inject.parser.options},\n- requires an entry point,\n- creates plugin instance (\\texttt{\\_\\_call\\_\\_}).\n\n\\textbf{description:} \\texttt{str} = \\texttt{NotImplemented} \nShort plugin description\n\n\\textbf{name:} \\texttt{str} = \\texttt{NotImplemented} \nUnique name of the plugin\n\n\\textbf{abstract prepare()} \\to \\texttt{None} \nPrepare the plugin. Finish up any additional initialization.\n\n\\textbf{Raises}\n\n- \\texttt{PluginError} – when full initialization cannot be completed.\n- \\texttt{MisconfigurationError} – when full initialization cannot be completed. Plugin will be displayed on a list of available plugins.\n- \\texttt{NoInstallationError} – when the necessary programs/files cannot be located. Plugin will NOT be displayed on a list of available plugins.\n- \\texttt{NotSupportedError} – when the installation is recognized, but the version is not currently supported.\n\n\\textbf{abstract more_info()} \\to \\texttt{str} \nHuman-readable string to help the user. Should describe the steps taken and any relevant info to help the user decide which plugin to use.\n\n\\textbf{Rtype} \\texttt{str} \n\\textbf{abstract classmethod inject.parser.options}(\\texttt{parser: argpparse.ArgumentParser, name: str}) \\to \\texttt{None} \nInject argument parser options (flags).\n\n1. Be nice and prepend all options and destinations with \\texttt{option_namespace} and \\texttt{dest_namespace}.\n2. Inject options (flags) only. Positional arguments are not allowed, as this would break the CLI.\n\n\\textbf{Parameters}\n\n- \\texttt{parser} (\\texttt{ArgumentParser}) – (Almost) top-level CLI parser.\n- \\texttt{name} (\\texttt{str}) – Unique plugin name.\nclass certbot.interfaces.Authenticator(config: Optional[certbot.configuration.NamespaceConfig], name: str)\n\nBases: certbot.interfaces.Plugin\n\nGeneric Certbot Authenticator.\n\nClass represents all possible tools processes that have the ability to perform challenges and attain a certificate.\n\nabstract get_chall_pref(domain: str) → Iterable[Type[acme.challenges.Challenge]]\n\nReturn collections.Iterable of challenge preferences.\n\nParameters domain (str) – Domain for which challenge preferences are sought.\n\nReturns collections.Iterable of challenge types (subclasses of acme.challenges.Challenge) with the most preferred challenges first. If a type is not specified, it means the Authenticator cannot perform the challenge.\n\nReturn type collections.Iterable\n\nabstract perform(achalls: List[certbot.achallenges.AnnotatedChallenge]) → List[acme.challenges.ChallengeResponse]\n\nPerform the given challenge.\n\nParameters achalls (list) – Non-empty (guaranteed) list of AnnotatedChallenge instances, such that it contains types found within get_chall_pref() only.\n\nReturns list of ACME ChallengeResponse instances corresponding to each provided Challenge.\n\nReturn type collections.List of acme.challenges.ChallengeResponse, where responses are required to be returned in the same order as corresponding input challenges\n\nRaises PluginError – If some or all challenges cannot be performed\n\nabstract cleanup(achalls: List[certbot.achallenges.AnnotatedChallenge]) → None\n\nRevert changes and shutdown after challenges complete.\n\nThis method should be able to revert all changes made by perform, even if perform exited abnormally.\n\nParameters achalls (list) – Non-empty (guaranteed) list of AnnotatedChallenge instances, a subset of those previously passed to perform().\n\nRaises PluginError – if original configuration cannot be restored\n\nclass certbot.interfaces.Installer(config: Optional[certbot.configuration.NamespaceConfig], name: str)\n\nBases: certbot.interfaces.Plugin\n\nGeneric Certbot Installer Interface.\n\nRepresents any server that an X509 certificate can be placed.\n\nIt is assumed that save() is the only method that finalizes a checkpoint. This is important to ensure that checkpoints are restored in a consistent manner if requested by the user or in case of an error.\n\nUsing certbot.reverter.Reverter to implement checkpoints, rollback, and recovery can dramatically simplify plugin development.\n\nabstract get_all_names() → Iterable[str]\n\nReturns all names that may be authenticated.\n\nReturn type collections.Iterable of str\n\nabstract deploy_cert(domain: str, cert_path: str, key_path: str, chain_path: str, fullchain_path: str) → None\n\nDeploy certificate.\nParameters\n\n- `domain (str) – domain to deploy certificate file`\n- `cert_path (str) – absolute path to the certificate file`\n- `key_path (str) – absolute path to the private key file`\n- `chain_path (str) – absolute path to the certificate chain file`\n- `fullchain_path (str) – absolute path to the certificate fullchain file (cert plus chain)`\n\nRaises `PluginError` – when cert cannot be deployed\n\nabstract `enhance`(<domain: str, enhancement: str, options: Optional[Union[List[str], str]] = None) → None\nPerform a configuration enhancement.\n\nParameters\n\n- `domain (str) – domain for which to provide enhancement`\n- `enhancement (str) – An enhancement as defined in ENHANCEMENTS`\n- `options – Flexible options parameter for enhancement. Check documentation of ENHANCEMENTS for expected options for each enhancement.`\n\nRaises `PluginError` – If Enhancement is not supported, or if an error occurs during the enhancement.\n\nabstract `supported_enhancements`() → List[str]\nReturns a collections.Iterable of supported enhancements.\n\nReturns supported enhancements which should be a subset of ENHANCEMENTS\n\nReturns type collections.Iterable of str\n\nabstract `save`(title: Optional[str] = None, temporary: bool = False) → None\nSaves all changes to the configuration files.\n\nBoth title and temporary are needed because a save may be intended to be permanent, but the save is not ready to be a full checkpoint.\n\nIt is assumed that at most one checkpoint is finalized by this method. Additionally, if an exception is raised, it is assumed a new checkpoint was not finalized.\n\nParameters\n\n- `title (str) – The title of the save. If a title is given, the configuration will be saved as a new checkpoint and put in a timestamped directory. title has no effect if temporary is true.`\n- `temporary (bool) – Indicates whether the changes made will be quickly reversed in the future (challenges)`\n\nRaises `PluginError` – when save is unsuccessful\n\nabstract `rollback_checkpoints`(rollback: int = 1) → None\nRevert rollback number of configuration checkpoints.\n\nRaises `PluginError` – when configuration cannot be fully reverted\n\nabstract `recovery_routine`() → None\nRevert configuration to most recent finalized checkpoint.\n\nRemove all changes (temporary and permanent) that have not been finalized. This is useful to protect against crashes and other execution interruptions.\nRaises `errors.PluginError` – If unable to recover the configuration\n\n```python\nclass RenewableCert\n Bases: object\n Interface to a certificate lineage.\n \n abstract property cert_path: str\n Path to the certificate file.\n \n Return type: str\n \n abstract property key_path: str\n Path to the private key file.\n \n Return type: str\n \n abstract property chain_path: str\n Path to the certificate chain file.\n \n Return type: str\n \n abstract property fullchain_path: str\n Path to the full chain file.\n \n The full chain is the certificate file plus the chain file.\n \n Return type: str\n \n abstract property lineagename: str\n Name given to the certificate lineage.\n \n Return type: str\n \n abstract names() → List[str]\n What are the subject names of this certificate?\n \n Returns: the subject names\n \n Return type: list of str\n \n Raises CertStorageError – if could not find cert file.\n```\nabstract generic_updates(lineage: certbot.interfaces.RenewableCert, *args: Any, **kwargs: Any) → None\nPerform any update types defined by the installer.\n\nIf an installer is a subclass of the class containing this method, this function will always be called when “certbot renew” is run. If the update defined by the installer should be run conditionally, the installer needs to handle checking the conditions itself.\n\nThis method is called once for each lineage.\n\nParameters lineage (RenewableCert) – Certificate lineage object\n\nclass certbot.interfaces.RenewDeployer\nBases: object\n\nInterface for update types run when a lineage is renewed\n\nThis class allows plugins to perform types of updates that need to run at lineage renewal that Certbot hasn’t defined (yet).\n\nTo make use of this interface, the installer should implement the interface methods, and interfaces.RenewDeployer.register(InstallerClass) should be called from the installer code.\n\nabstract renew_deploy(lineage: certbot.interfaces.RenewableCert, *args: Any, **kwargs: Any) → None\nPerform updates defined by installer when a certificate has been renewed\n\nIf an installer is a subclass of the class containing this method, this function will always be called when a certificate has been renewed by running “certbot renew”. For example if a plugin needs to copy a certificate over, or change configuration based on the new certificate.\n\nThis method is called once for each lineage renewed\n\nParameters lineage (RenewableCert) – Certificate lineage object\n\ncertbot.main module\n\nCertbot main public entry point.\n\ncertbot.main.main(cli_args: Optional[List[str]] = None) → Optional[Union[str, int]]\nRun Certbot.\n\nParameters cli_args (list of str) – command line to Certbot, defaults to sys.argv[1:]\n\nReturns value for sys.exit about the exit status of Certbot\n\nReturn type str or int or None\n\ncertbot.ocsp package\n\nTools for checking certificate revocation.\n\nclass certbot.ocsp.RevocationChecker(enforce_openssl_binary_usage: bool = False)\nBases: object\n\nThis class figures out OCSP checking on this system, and performs it.\n\nocsp_revoked(cert: certbot.interfaces.RenewableCert) → bool\nGet revoked status for a particular cert version.\n\nParameters cert (interfaces.RenewableCert) – Certificate object\n\nReturns True if revoked; False if valid or the check failed or cert is expired.\nReturn type bool\n\nocsp_revoked_by_paths(cert_path: str, chain_path: str, timeout: int = 10) → bool\nPerforms the OCSP revocation check\n\nParameters\n- cert_path (str) – Certificate filepath\n- chain_path (str) – Certificate chain\n- timeout (int) – Timeout (in seconds) for the OCSP query\n\nReturns True if revoked; False if valid or the check failed or cert is expired.\n\nReturn type bool\n\ncertbot.reverter module\n\nReverter class saves configuration checkpoints and allows for recovery.\n\nclass certbot.reverter.Reverter(config: certbot.configuration.NamespaceConfig)\nBases: object\n\nReverter Class - save and revert configuration checkpoints.\n\nThis class can be used by the plugins, especially Installers, to undo changes made to the user’s system. Modifications to files and commands to do undo actions taken by the plugin should be registered with this class before the action is taken.\n\nOnce a change has been registered with this class, there are three states the change can be in. First, the change can be a temporary change. This should be used for changes that will soon be reverted, such as config changes for the purpose of solving a challenge. Changes are added to this state through calls to add_to_temp_checkpoint() and reverted when revert_temporary_config() or recovery_routine() is called.\n\nThe second state a change can be in is in progress. These changes are not temporary, however, they also have not been finalized in a checkpoint. A change must become in progress before it can be finalized. Changes are added to this state through calls to add_to_checkpoint() and reverted when recovery_routine() is called.\n\nThe last state a change can be in is finalized in a checkpoint. A change is put into this state by first becoming an in progress change and then calling finalize_checkpoint(). Changes in this state can be reverted through calls to rollback_checkpoints().\n\nAs a final note, creating new files and registering undo commands are handled specially and use the methods register_file_creation() and register_undo_command() respectively. Both of these methods can be used to create either temporary or in progress changes.\n\n---\n\n**Note:** Consider moving everything over to CSV format.\n\nParameters config (certbot.configuration.NamespaceConfig) – Configuration.\n\nrevert_temporary_config() → None\nReload users original configuration files after a temporary save.\n\nThis function should reinstall the users original configuration files for all saves with temporary=True\n\nRaises ReverterError – when unable to revert config\n\nrollback_checkpoints(rollback: int = 1) → None\nRevert ‘rollback’ number of configuration checkpoints.\nParameters **rollback** (*int*) – Number of checkpoints to reverse. A str num will be cast to an integer. So “2” is also acceptable.\n\n**Raises** **ReverterError** – if there is a problem with the input or if the function is unable to correctly revert the configuration checkpoints\n\n### add_to_temp_checkpoint(*save_files: Set[str], save_notes: str*) → None\nAdd files to temporary checkpoint.\n\n**Parameters**\n\n- **save_files** (*set*) – set of filepaths to save\n- **save_notes** (*str*) – notes about changes during the save\n\n### add_to_checkpoint(*save_files: Set[str], save_notes: str*) → None\nAdd files to a permanent checkpoint.\n\n**Parameters**\n\n- **save_files** (*set*) – set of filepaths to save\n- **save_notes** (*str*) – notes about changes during the save\n\n### register_file_creation(*temporary: bool, *files: str*) → None\nRegister the creation of all files during certbot execution.\n\nCall this method before writing to the file to make sure that the file will be cleaned up if the program exits unexpectedly. (Before a save occurs)\n\n**Parameters**\n\n- **temporary** (*bool*) – If the file creation registry is for a temp or permanent save.\n- ***files** – file paths (str) to be registered\n\n**Raises** **certbot.errors.ReverterError** – If call does not contain necessary parameters or if the file creation is unable to be registered.\n\n### register_undo_command(*temporary: bool, command: Iterable[str]*) → None\nRegister a command to be run to undo actions taken.\n\n**Warning:** This function does not enforce order of operations in terms of file modification vs. command registration. All undo commands are run first before all normal files are reverted to their previous state. If you need to maintain strict order, you may create checkpoints before and after the command registration. This function may be improved in the future based on demand.\n\n**Parameters**\n\n- **temporary** (*bool*) – Whether the command should be saved in the IN_PROGRESS or TEMPORARY checkpoints.\n- **command** (*list of str*) – Command to be run.\n\n### recovery_routine() → None\nRevert configuration to most recent finalized checkpoint.\n\nRemove all changes (temporary and permanent) that have not been finalized. This is useful to protect against crashes and other execution interruptions.\n\n**Raises** **errors.ReverterError** – If unable to recover the configuration\nfinalize_checkpoint(title: str) → None\n\nFinalize the checkpoint.\n\nTimestamps and permanently saves all changes made through the use of add_to_checkpoint() and register_file_creation()\n\nParameters title (str) – Title describing checkpoint\n\nRaises certbot.errors.ReverterError – when the checkpoint is not able to be finalized.\n\ncertbot.util module\n\nUtilities for all Certbot.\n\nclass certbot.util.Key(file, pem)\n\nBases: tuple\n\nproperty file\nAlias for field number 0\n\nproperty pem\nAlias for field number 1\n\nclass certbot.util.CSR(file, data, form)\n\nBases: tuple\n\nproperty data\nAlias for field number 1\n\nproperty file\nAlias for field number 0\n\nproperty form\nAlias for field number 2\n\ncertbot.util.env_no_snap_for_external_calls() → Dict[str, str]\n\nWhen Certbot is run inside a Snap, certain environment variables are modified. But Certbot sometimes calls out to external programs, since it uses classic confinement. When we do that, we must modify the env to remove our modifications so it will use the system’s libraries, since they may be incompatible with the versions of libraries included in the Snap. For example, apachectl, Nginx, and anything run from inside a hook should call this function and pass the results into the env argument of subprocess.Popen.\n\nReturns A modified copy of os.environ ready to pass to Popen\n\nReturn type dict\n\ncertbot.util.run_script(params: List[str], log: Callable[[str], None] = <bound method Logger.error of <Logger certbot.util (WARNING)>>) → Tuple[str, str]\n\nRun the script with the given params.\n\nParameters\n\n• params (list) – List of parameters to pass to subprocess.run\n\n• log (callable) – Logger method to use for errors\n\ncertbot.util.exe_exists(exe: str) → bool\n\nDetermine whether path/name refers to an executable.\n\nParameters exe (str) – Executable path or name\n\nReturns If exe is a valid executable\n\nReturn type bool\ncertbot.util.lock_dir_until_exit(dir_path: str) → None\nLock the directory at dir_path until program exit.\n\nParameters\n\n- **dir_path** (str) – path to directory\n\nRaises\n\n- **errors.LockError** – if the lock is held by another process\n\ncertbot.util.set_up_core_dir(directory: str, mode: int, strict: bool) → None\nEnsure directory exists with proper permissions and is locked.\n\nParameters\n\n- **directory** (str) – Path to a directory.\n- **mode** (int) – Directory mode.\n- **strict** (bool) – require directory to be owned by current user\n\nRaises\n\n- **errors.LockError** – if the directory cannot be locked\n- **errors.Error** – if the directory cannot be made or verified\n\ncertbot.util.make_or_verify_dir(directory: str, mode: int = 493, strict: bool = False) → None\nMake sure directory exists with proper permissions.\n\nParameters\n\n- **directory** (str) – Path to a directory.\n- **mode** (int) – Directory mode.\n- **strict** (bool) – require directory to be owned by current user\n\nRaises\n\n- **errors.LockError** – if a directory already exists, but has wrong permissions or owner\n- **OSError** – if invalid or inaccessible file names and paths, or other arguments that have the correct type, but are not accepted by the operating system.\n\ncertbot.util.safe_open(path: str, mode: str = 'w', chmod: Optional[int] = None) → IO\nSafely open a file.\n\nParameters\n\n- **path** (str) – Path to a file.\n- **mode** (str) – Same as mode for open.\n- **chmod** (int) – Same as mode for filesystem.open, uses Python defaults if None.\n\ncertbot.util.unique_file(path: str, chmod: int = 511, mode: str = 'w') → Tuple[IO, str]\nSafely finds a unique file.\n\nParameters\n\n- **path** (str) – path/ filename.ext\n- **chmod** (int) – File mode\n- **mode** (str) – Open mode\n\nReturns\ntuple of file object and file name\n\ncertbot.util.unique_lineage_name(path: str, filename: str, chmod: int = 420, mode: str = 'w') → Tuple[IO, str]\nSafely finds a unique file using lineage convention.\nParameters\n\n- **path** *(str)* – directory path\n- **filename** *(str)* – proposed filename\n- **chmod** *(int)* – file mode\n- **mode** *(str)* – open mode\n\n**Returns** tuple of file object and file name (which may be modified from the requested one by appending digits to ensure uniqueness)\n\n**Raises** OSError – if writing files fails for an unanticipated reason, such as a full disk or a lack of permission to write to specified location.\n\ncertbot.util.safely_remove(path: str) → None\nRemove a file that may not exist.\n\n**Parameters**\n\n- **path** *(str)*\n\n**Returns**\n\n- None\n\n**Raises**\n\n- None\n\ncertbot.util.get_filtered_names(all_names: Set[str]) → Set[str]\nRemoves names that aren’t considered valid by Let’s Encrypt.\n\n**Parameters**\n\n- **all_names** *(set)* – all names found in the configuration\n\n**Returns**\n\n- all found names that are considered valid by LE\n\n**Return type** set\n\ncertbot.util.get_os_info() → Tuple[str, str]\nGet OS name and version\n\n**Returns**\n\n- (os_name, os_version)\n\n**Return type** tuple of str\n\ncertbot.util.get_os_info_ua() → str\nGet OS name and version string for User Agent\n\n**Returns**\n\n- os_ua\n\n**Return type** str\n\ncertbot.util.get_systemd_os_like() → List[str]\nGet a list of strings that indicate the distribution likeness to other distributions.\n\n**Returns**\n\n- List of distribution acronyms\n\n**Return type** list of str\n\ncertbot.util.get_var_from_file(varname: str, filepath: str = '/etc/os-release') → str\nGet single value from a file formatted like systemd /etc/os-release\n\n**Parameters**\n\n- **varname** *(str)* – Name of variable to fetch\n- **filepath** *(str)* – File path of os-release file\n\n**Returns**\n\n- requested value\n\n**Return type** str\n\ncertbot.util.get_python_os_info(pretty: bool = False) → Tuple[str, str]\nGet Operating System type/distribution and major version using python platform module\n\n**Parameters**\n\n- **pretty** *(bool)* – If the returned OS name should be in longer (pretty) form\n\n**Returns**\n\n- (os_name, os_version)\nReturn type tuple of str\ncertbot.util.safe_email(email: str) → bool\nScrub email address before using it.\nclass certbot.util.DeprecatedArgumentAction(option_strings, dest, nargs=None, const=None,\ndefault=None, type=None, choices=None, required=False, help=None, metavar=None)\nBases: argparse.Action\nAction to log a warning when an argument is used.\ncertbot.util.add_deprecated_argument(add_argument: Callable[..., None], argument_name: str, nargs:\\nUnion[str, int]) → None\nAdds a deprecated argument with the name argument_name.\nDeprecated arguments are not shown in the help. If they are used on the command line, a warning is shown\nstating that the argument is deprecated and no other action is taken.\nParameters\n• add_argument (callable) – Function that adds arguments to an argument parser/group.\n• argument_name (str) – Name of deprecated argument.\n• nargs – Value for nargs when adding the argument to argparse.\ncertbot.util.enforce_le_validity(domain: str) → str\nChecks that Let's Encrypt will consider domain to be valid.\nParameters domain (str) – FQDN to check\nReturns The domain cast to str, with ASCII-only contents\nReturn type str\nRaises ConfigurationError – for invalid domains and cases where Let's Encrypt currently will\nnot issue certificates\ncertbot.util.enforce_domain_sanity(domain: Union[str, bytes]) → str\nMethod which validates domain value and errors out if the requirements are not met.\nParameters domain (str or bytes) – Domain to check\nRaises ConfigurationError – for invalid domains and cases where Let’s Encrypt currently will\nnot issue certificates\nReturns The domain cast to str, with ASCII-only contents\nReturn type str\ncertbot.util.is_ipaddress(address: str) → bool\nIs given address string form of IP(v4 or v6) address?\nParameters address (str) – address to check\nReturns True if address is valid IP address, otherwise return False.\nReturn type bool\ncertbot.util.is_wildcard_domain(domain: Union[str, bytes]) → bool\nIs domain a wildcard domain?\nParameters domain (bytes or str) – domain to check\nReturns True if domain is a wildcard, otherwise, False\nReturn type bool\ncertbot.util.get_strict_version(normalized: str) → distutils.version.StrictVersion\nConverts a normalized version to a strict version.\n\nParameters normalized (str) – normalized version string\n\nReturns An equivalent strict version\n\nReturn type distutils.version.StrictVersion\ncertbot.util.is_staging(srv: str) → bool\nDetermine whether a given ACME server is a known test / staging server.\n\nParameters srv (str) – the URI for the ACME server\n\nReturns True iff srv is a known test / staging server\n\nRtype bool\ncertbot.util.atexit_register(func: Callable, *args: Any, **kwargs: Any) → None\nSets func to be called before the program exits.\n\nSpecial care is taken to ensure func is only called when the process that first imports this module exits rather than any child processes.\n\nParameters func (function) – function to be called in case of an error\ncertbot.util.parse_loose_version(version_string: str) → List[Union[int, str]]\nParses a version string into its components.\n\nThis code and the returned tuple is based on the now deprecated distutils.version.LooseVersion class from the Python standard library. Two LooseVersion classes and two lists as returned by this function should compare in the same way. See https://github.com/python/cpython/blob/v3.10.0/Lib/distutils/version.py#L205-L347.\n\nParameters version_string (str) – version string\n\nReturns list of parsed version string components\n\nReturn type list\nINDICES AND TABLES\n\n- genindex\n- modindex\n- search\nC\n\ncertbot, 63\n\ncertbot.achallenges, 88\n\ncertbot.compat, 63\n\ncertbot.compat.filesystem, 63\n\ncertbot.compat.misc, 67\n\ncertbot.compat.os, 68\n\ncertbot.crypto_util, 89\n\ncertbot.display, 69\n\ncertbot.display.ops, 69\n\ncertbot.display.util, 71\n\ncertbot.errors, 94\n\ncertbot.interfaces, 96\n\ncertbot.main, 101\n\ncertbot.ocsp, 101\n\ncertbot.plugins, 73\n\ncertbot.plugins.common, 73\n\ncertbot.plugins.dns_common, 76\n\ncertbot.plugins.dns_common_lexicon, 78\n\ncertbot.plugins.dns_test_common, 79\n\ncertbot.plugins.dns_test_common_lexicon, 80\n\ncertbot.plugins.enhancements, 81\n\ncertbot.plugins.storage, 82\n\ncertbot.plugins.util, 83\n\ncertbot.reverter, 102\n\ncertbot.tests, 83\n\ncertbot.tests.acme_util, 83\n\ncertbot.tests.util, 84\n\ncertbot.util, 104\nINDEX\n\nA\naccess() (in module certbot.compat.os), 68\naccount_key (certbot.achallenges.KeyAuthorizationAnnotatedChallenge attribute), 88\nAccountNotFound, 94\nAccountStorage (class in certbot.interfaces), 96\nAccountStorageError, 94\nachall (certbot.plugins.dns_test_common.BaseAuthenticatorTest attribute), 79\nacme_type (certbot.achallenges.DNS attribute), 88\nadd_chall() (certbot.plugins.common.ChallengePerformer method), 76\nadd Deprecated_argument() (in module certbot.util), 107\nadd_parser_arguments() (certbot.plugins.common.Plugin class method), 73\nadd_parser_arguments() (certbot.plugins.dns_common.DNAuthenticator class method), 76\nadd_parser_arguments() (certbot.tests.util.DummyInstaller class method), 85\nadd_to_checkpoint() (certbot.plugins.common.Installer method), 74\nadd_to_checkpoint() (certbot.reverter.Reverter method), 103\nadd_to_temp_checkpoint() (certbot.reverter.Reverter method), 103\nadd_txt_record() (certbot.plugins.dns_common_lexicon.LexiconClient method), 78\nAddr (class in certbot.plugins.common), 75\nAnnotatedChallenge (class in certbot.achallenges), 88\nare_requested() (in module certbot.plugins.enhancements), 81\nare_supported() (in module certbot.plugins.enhancements), 81\nassert_valid_call() (in module certbot.display.util), 73\natexit_register() (in module certbot.util), 108\nauth_hint() (certbot.plugins.common.Plugin method), 74\nauth_hint() (certbot.plugins.dns_common.DNAuthenticator method), 76\nAuthenticator (class in certbot.interfaces), 97\nAuthorizationError, 95\nAutoHSTSEnhancement (class in certbot.plugins.enhancements), 81\n\nB\nbase_domain_name_guesses() (in module certbot.plugins.dns_common), 78\nBaseAuthenticatorTest (class in certbot.plugins.dns_test_common), 79\nBaseLexiconAuthenticatorTest (class in certbot.plugins.dns_test_common_lexicon), 80\nBaseLexiconClientTest (class in certbot.plugins.dns_test_common_lexicon), 80\nbuild_lexicon_config() (in module certbot.plugins.dns_common_lexicon), 79\n\nC\nCANCEL (in module certbot.display.util), 71\ncert_and_chain_from_fullchain() (in module certbot.crypto_util), 93\ncert_path (certbot.interfaces.RenewableCert property), 100\ncertbot module, 63\ncertbot.achallenges module, 88\ncertbot.compat module, 63\ncertbot.compat.filesystem module, 63\ncertbot.compat.misc module, 67\ncertbot.compat.os module, 68\ncertbot.crypto_util module, 89\ncertbot.display module, 69\nget_systemd_os_like() (in module certbot.util), 106\nget_valid_domains() (in module certbot.display.ops), 69\nget_var_from_file() (in module certbot.util), 106\nhas_min_permissions() (in module certbot.compat.filesystem), 66\nhas_same_ownership() (in module certbot.compat.filesystem), 66\nhas_world_permissions() (in module certbot.compat.filesystem), 66\nHELP (in module certbot.display.util), 71\nHookCommandNotFound, 94\nimport_csr_file() (in module certbot.crypto_util), 90\ninit_save_csr() (in module certbot.crypto_util), 90\ninit_save_key() (in module certbot.crypto_util), 89\ninject_parser_options() (certbot.interfaces.Plugin class method), 97\ninject_parser_options() (certbot.plugins.common.Plugin class method), 73\ninput_text() (in module certbot.display.util), 71\ninstall_ssl_dhparams() (certbot.plugins.common.Installer method), 75\ninstall_version_controlled_file() (in module certbot.plugins.common), 76\nInstaller (class in certbot.interfaces), 98\nInstaller (class in certbot.plugins.common), 74\nis_executable() (in module certbot.compat.filesystem), 66\nis_ipaddress() (in module certbot.util), 107\nis_staging() (in module certbot.util), 108\nisWildcardDomain() (in module certbot.util), 107\nKey (class in certbot.util), 104\nkey_path (certbot.interfaces.RenewableCert property), 100\nKeyAuthorizationAnnotatedChallenge (class in certbot.achallenges), 88\nLexiconClient (class in certbot.plugins.dns_common_lexicon), 78\nlineagename (certbot.interfaces.RenewableCert property), 100\nload() (certbot.interfaces.AccountStorage method), 96\nload_cert() (in module certbot.tests.util), 85\nload_comparable_csr() (in module certbot.tests.util), 85\nload_csr() (in module certbot.tests.util), 85\nload_pyopenssl_private_key() (in module certbot.tests.util), 86\nload_rsa_private_key() (in module certbot.tests.util), 86\nload_vector() (in module certbot.tests.util), 85\nlock_and_call() (in module certbot.tests.util), 87\nlock_dir_until_exit() (in module certbot.util), 104\nLockError, 95\nLOGIN_ERROR (certbot.plugins.dns_test_common_lexicon.BaseLexiconClientTest attribute), 80\nmain() (in module certbot.main), 101\nmake_key() (in module certbot.crypto_util), 91\nmake_lineage() (in module certbot.tests.util), 86\nmake_or_verify_dir() (in module certbot.util), 105\nmakedirs() (in module certbot.compat.filesystem), 65\nmakedirs() (in module certbot.compat.os), 68\nmenu() (in module certbot.display.util), 71\nMisconfigurationError, 95\nMissingCommandLineFlag, 96\nmkdir() (in module certbot.compat.filesystem), 65\nmkdir() (in module certbot.compat.os), 68\nmodule\ncertbot, 63\ncertbot.achallenges, 88\ncertbot.compat, 63\ncertbot.compat.filesystem, 63\ncertbot.compat.misc, 67\ncertbot.compat.os, 68\ncertbot.crypto_util, 89\ncertbot.display, 69\ncertbot.display.ops, 69\ncertbot.display.util, 71\ncertbot.errors, 94\ncertbot.interfaces, 96\ncertbot.main, 101\ncertbot.ocsp, 101\ncertbot.plugins, 73\ncertbot.plugins.common, 73\ncertbot.plugins.dns_common, 76\ncertbot.plugins.dns_common_lexicon, 78\ncertbot.plugins.dns_test_common, 79\ncertbot.plugins.dns_test_common_lexicon, 80\ncertbot.plugins.enhancements, 81\ncertbot.plugins.storage, 82\ncertbot.plugins.util, 83\ncertbot.reverter, 102\ncertbot.tests, 83\ncertbot.tests.acme_util, 83\ncertbot.tests.util, 84\ncertbot.util, 104\nU\n\numask() (in module certbot.compat.filesystem), 63\numask() (in module certbot.compat.os), 68\nunderscores_for_unsupported_characters_in_path() (in module certbot.compat.misc), 67\nunique_file() (in module certbot.util), 105\nunique_lineage_name() (in module certbot.util), 105\nUNKNOWN_LOGIN_ERROR (certbot.plugins.dns_test_common_lexicon.BaseLexiconClientTest attribute), 80\nupdate_autohsts() (certbot.plugins.enhancements.AutoHSTSEnhancement method), 82\nupdated_ssl_dhparams_digest (certbot.plugins.common.Installer property), 75\n\nV\n\nvalid_csr() (in module certbot.crypto_util), 90\nvalid_privkey() (in module certbot.crypto_util), 91\nvalidate_file() (in module certbot.plugins.dns_common), 78\nvalidate_file_permissions() (in module certbot.plugins.dns_common), 78\nvalidated_directory() (in module certbot.display.ops), 70\nvalidated_input() (in module certbot.display.ops), 70\nvector_path() (in module certbot.tests.util), 85\nverify_cert_matches_priv_key() (in module certbot.crypto_util), 92\nverify_fullchain() (in module certbot.crypto_util), 92\nverify_renewable_cert() (in module certbot.crypto_util), 91\nverify_renewable_cert_sig() (in module certbot.crypto_util), 91\nverify_signed_payload() (in module certbot.crypto_util), 91\n\nW\n\nwrite() (in module certbot.plugins.dns_test_common), 79\n\nY\n\nyesno() (in module certbot.display.util), 72"}}},{"rowIdx":271,"cells":{"id":{"kind":"string","value":"1a6b5938d0cccfe9e139311fa2b459f565d8d828"},"text":{"kind":"string","value":"Automated Test Case Generation as a Many-Objective Optimisation Problem with Dynamic Selection of the Targets\n\nAnnibale Panichella∗, Fitsum Meshesha Kifetew†, Paolo Tonella†\n∗SnT - University of Luxembourg, Luxembourg\n†Fondazione Bruno Kessler, Trento, Italy\nannibale.panichella@uni.lu, kifetew@fbk.eu, tonella@fbk.eu\n\nAbstract—\nThe test case generation is intrinsically a multi-objective problem, since the goal is covering multiple test targets (e.g., branches). Existing search-based approaches either consider one target at a time or aggregate all targets into a single fitness function (whole-suite approach). Multi and many-objective optimisation algorithms (MOAs) have never been applied to this problem, because existing algorithms do not scale to the number of coverage objectives that are typically found in real-world software. In addition, the final goal for MOAs is to find alternative trade-off solutions in the objective space, while in test generation the interesting solutions are only those test cases covering one or more uncovered targets.\n\nIn this paper, we present DynaMOSA (Dynamic Many-Objective Sorting Algorithm), a novel many-objective solver specifically designed to address the test case generation problem in the context of coverage testing. DynaMOSA extends our previous many-objective technique MOSA (Many-Objective Sorting Algorithm) with dynamic selection of the coverage targets based on the control dependency hierarchy. Such extension makes the approach more effective and efficient in case of limited search budget.\n\nWe carried out an empirical study on 346 Java classes using three coverage criteria (i.e., statement, branch, and strong mutation coverage) to assess the performance of DynaMOSA with respect to the whole-suite approach (WS), its archive-based variant (WSA) and MOSA. The results show that DynaMOSA outperforms WSA in 28% of the classes for branch coverage (+8% more coverage on average) and in 27% of the classes for mutation coverage (+11% more killed mutants on average). It outperforms WS in 51% of the classes for statement coverage, leading to +11% more coverage on average. Moreover, DynaMOSA outperforms its predecessor MOSA for all the three coverage criteria in 19% of the classes with +8% more code coverage on average.\n\nIndex Terms—Evolutionary Testing; Many-Objective Optimisation; Automatic Test Case Generation\n\n1 INTRODUCTION\n\nAutomated structural test case generation aims at producing a set of test cases that maximises coverage of the test goals in the software under test according to the selected adequacy testing criterion (e.g., branch coverage). Search-based test case generators use meta-heuristic optimisation algorithms, such as genetic algorithms (GA), to produce new test cases from the previously generated (initially, random) ones, so as to reduce and eventually nullify their distance from each of the yet uncovered targets [52], [37]. The search for a test sequence and for test input data that bring the test execution closer to the current coverage target is guided by a fitness function, which quantifies the distance between the execution trace of a test case and the coverage target. The actual computation of such a distance depends on the type of coverage criterion under consideration. For instance, for branch coverage, the distance is based on the number of control dependencies that separate the execution trace from the target (approach level) and on the variable values evaluated at the conditional expression where the execution diverges from the target (branch distance).\n\nIn traditional evolutionary testing, to cover all targets a meta-heuristic algorithm is applied multiple times, each time with a different target, until all targets are covered or the total search budget is consumed. The final test suite is thus composed of all the test cases that cover one or more targets, including those that accidentally cover previously uncovered targets (collateral coverage).\n\nSearching for one target at a time is problematic in several respects. First of all, targets may require higher or lower search effort depending on how difficult it is to produce test cases that cover them. Hence, uniformly distributing the search budget across all targets might be largely sub-optimal. Even worse, the presence of unfeasible targets wastes entirely the search time devoted to their coverage. The whole-suite (WS) approach [17], [3] to test case generation is a recent attempt to address these issues. WS optimises entire test suites, not just individual test cases, and makes use of a single fitness value that aggregates the fitness values measured for the test cases contained in a test suite, so as to take into consideration all coverage targets simultaneously. In fact, each test case in a test suite is associated with the target closest to its execution trace. The sum over all test cases of such minimum distances from the targets provides the overall, test-suite-level fitness. The additive combination of multiple targets into a single, scalar objective function is known as sum scalarization in\nthe theory of optimisation [11]. The aim is to apply single-objective algorithms, like GA, to an intrinsically multi-objective problem.\n\nWhile being more effective than targeting one target at a time, the WS approach suffers all the well-known problems of sum scalarization in many-objective optimisation, among which the inefficient convergence occurring in the non-convex regions of the search space [11]. On the other hand, there are single-objective problem instances on which many-objective algorithms have been shown to be much more convenient than the single-objective approach. In fact, reformulating a complex single-objective problem as a many-objective problem defined on multiple but simpler objectives can reduce the probability that the search remains trapped in local optima, eventually leading to faster convergence [30], [21]. However, there are two main challenges to address when applying many-objective optimisation to test case generation: (i) none of the available multi or many-objective solvers can scale to the number of objectives (targets) typically found in coverage testing [3]; and (ii) multi and many-objective solvers are designed to increase the diversity of the solutions, not just to fully achieve each objective individually (reducing to zero its distance from the target), as required in test case generation [33].\n\nTo overcome the aforementioned limitations, in our previous work [42] we introduced MOSA (Many-Objective Sorting Algorithm), a many-objective GA tailored to the test case generation problem. MOSA has three main features: (i) it uses a novel preference criterion instead of ranking the solutions based on their Pareto optimality; (ii) it focuses the search only on the yet uncovered coverage targets; (iii) it saves all test cases satisfying one or more previously uncovered targets into an archive, which contains the final test suite when the search ends.\n\nRecently, Rojas et al. [48] developed the Whole Suite with Archive approach (WSA), a hybrid strategy that incorportes some of MOSA’s routines inside the traditional WS approach. While WSA still applies the sum scalarization and works at the test suite level, it incorporates an archive strategy which operates at the test case level. Moreover, it also focuses the search only on the yet to cover targets. From an empirical point of view, WSA has been proved to be statistically superior to WS and to the one-target at a time approaches. However, from a theoretical point of view, it does not evolve test suites anymore since the final test suite given to developers is artificially synthesised by taking those test cases stored in the archive rather than returning the best individual (i.e., test suite) from the last generation of GAs [48]. Rojas et al. [48] arose the following still unanswered questions: (1) To what extent do the benefits of MOSA stem from the many-objective reformulation of the problem or from the use of the archiving mechanism? (2) How does MOSA performs compared to WSA since both of them implement an archiving strategy?\n\nIn this paper, we provide an in-depth analysis of many-objective approaches to test case generation, thus, answering the aforementioned open questions. First, we present DynaMOSA (Many-Objective Sorting Algorithm with Dynamic target selection) which extends MOSA with the capability to dynamically focus the search on a subset of the yet uncovered targets, based on the control dependency hierarchy. Thus, uncovered targets that are reachable from other uncovered targets positioned higher in the hierarchy are removed from the current vector of objectives. They are reinserted in the objective vector dynamically, when their parents are covered. Since DynaMOSA optimises a subset of the objectives considered by MOSA using the same many-objective algorithm and preference criterion, DynaMOSA is ensured to be equally or more efficient than MOSA.\n\nSecond, we conduct a large empirical study involving 346 Java classes sampled from four different datasets [18], [53], [49], [42] and considering three well-known test adequacy criteria: statement coverage, branch coverage and mutation coverage. We find that DynaMOSA achieves significantly higher coverage than WSA in a large number of classes (27% and 28% for branch and mutation coverage respectively) with an average increment, for classes where statistically significant differences were observed, of +8% for branch coverage and +11% for mutation coverage. It also produces higher statement coverage than WSA in 51% of the classes, for which we observe +11% of covered statements on average. As predicted by the theory, DynaMOSA also improves MOSA for all the three criteria. This happens in 19% of the classes with an average coverage improvement of 8%.\n\nThis paper extends our previous work [42] with the following novel contributions:\n\n1) DynaMOSA: a novel algorithm for dynamic target selection, which is theoretically proven as subsuming MOSA.\n2) Larger scale experiments: one order of magnitude more classes are considered in the new experiments.\n3) Empirical comparison of DynaMOSA with MOSA and WSA to provide support to the usage of many-objective solvers in addition to the archiving strategy, which is implemented in all the three approaches.\n4) Empirical assessment of the selected algorithms with respect to different testing criteria, i.e., branch coverage, statement coverage and strong mutation coverage.\n5) Direct comparison with Pareto dominance ranking based algorithms, i.e., NSGA-II enriched with an archiving strategy.\n6) Empirical assessment of our novel preference criterion, to understand if the higher effectiveness of DynaMOSA is due to the preference criterion alone or to its combination with dominance ranking.\n\nThe remainder of this paper is organised as follows. Section 2 presents the reformulation of the test case generation problem as a many-objective problem. Section 3 presents the many-objective test generator MOSA, followed by its extension, DynaMOSA, with dynamic selection of the coverage targets. Section 4 presents the description of the experiments we conducted for the evaluation of the proposed algorithm. Section 5 reports the results obtained from the experiments, while Sections 6 and 7 provide additional empirical analyses and discuss the threats to validity.\n\n1. For statement coverage, we consider WS as baseline since no implementation of WSA is available.\nrespectively. Section 8 summarises the research works most closely related to ours. Section 9 draws conclusions and identifies possible directions for future work.\n\n## 2 Problem Formulation\n\nThis section presents our many-objective reformulation of the structural coverage problem. First the single-objective formulation used in the whole-suite approach [17] is described, followed by our many-objective reformulation, highlighting its main differences and peculiarities.\n\n### 2.1 Single Objective Formulation\n\nIn the whole-suite approach, a candidate solution is a test suite consisting of a variable number of individual test cases, where each test case is a sequence of method calls of variable length. The fitness function measures how close the candidate test suite is to satisfy all coverage targets (aka, test goals). It is computed with respect to full coverage (e.g., full branch coverage), as the sum of the individual distances to all coverage targets (e.g., branches) in the program under test. More formally, the problem of finding a test suite that satisfies all test targets has been defined as follows:\n\n**Problem 2.1:** Let \\( U = \\{u_1, \\ldots, u_k\\} \\) be the set of structural test targets of the program under test. Find a test suite \\( T = \\{t_1, \\ldots, t_n\\} \\) that minimises the fitness function:\n\n\\[\n\\min f_U(T) = \\sum_{u \\in U} d(u, T)\n\\]\n\nwhere \\( d(u, T) \\) denotes the minimal distance for the target \\( u \\) according to a specific distance function.\n\nIn general, the function to minimise \\( d \\) is such that \\( d(u, T) = 0 \\) if and only if the target goal is covered when a test suite \\( T \\) is executed. The difference between the various coverage criteria affects the specific distance function \\( d \\) used to express how distant the execution traces are from covering the test targets in \\( U \\) when all test cases in \\( T \\) are executed.\n\nIn Branch Coverage, the test targets to cover are the conditional statement branches in the class under test. Therefore, Problem 2.1 can be instantiated as finding a test suite that covers all branches, using as function \\( d \\) the traditional branch distance [37] for each individual branch to be covered. More formally [17]:\n\n**Problem 2.2:** Let \\( B = \\{b_1, \\ldots, b_k\\} \\) be the set of branches in a class. Find a test suite \\( T = \\{t_1, \\ldots, t_n\\} \\) that covers all the feasible branches, i.e., one that minimises the following fitness function:\n\n\\[\n\\min f_B(T) = |M| - |M_T| + \\sum_{b \\in B} d(b, T)\n\\]\n\nwhere \\( |M| \\) is the total number of methods, \\( |M_T| \\) is the number of executed methods by all test cases in \\( T \\); \\( B_S \\) is the set of branches that hold a direct control dependency on the statements in \\( S \\); and \\( d(b, T) \\) denotes the minimal normalised branch distance for branch \\( b \\in B_S \\).\n\nIn Strong Mutation Coverage, the test targets to cover are mutants, i.e., variants of the original class obtained by injecting artificial modifications (mimicking real faults) into them. Therefore, the optimal test suite is the one which is able to cover (kill, in the mutation analysis jargon) all mutants. A test case strongly kills a mutant if and only if the observable object state or the method return values differ between original and mutated class under test. Such a condition is usually checked by means of automatically generated assertions, which assert the equality of method return values and object state with respect to those observed when the original class is tested. Hence, such assertions fail when evaluated on the mutant if a different return value or object state is produced. An effective fitness function \\( f \\) for strong mutation coverage can be defined based on the notions of infection and propagation. The execution state of a mutated class instance is regarded as infected if it differs from the execution state of the original class when compared immediately after the mutated statement. This ensures that the mutant is producing some immediate effect on the class attributes or method variables, but it does not ensure that such an effect will propagate to an externally observable difference. Infection propagation accounts for the possibility of observing a different state between mutant and original class in the statements that follow the mutated one along the execution trace. The corresponding formal definition is the following [19]:\n\nnormalized branch distance \\( d(b, t) \\) for each branch \\( b \\in B \\) is defined as [17]:\n\n\\[\nd(b, t) = \\begin{cases} 0 & \\text{if } b \\text{ has been covered} \\\\ \\frac{D_{\\min}(t \\in T, b)}{D_{\\min}(t \\in T, b) + 1} & \\text{if the predicate has been executed at least twice} \\\\ 1 & \\text{otherwise} \\end{cases}\n\\]\n\nwhere \\( D_{\\min}(t \\in T, b) \\) is the minimal non-normalised branch distance, computed according to any of the available branch distance computation schemes [37]; minimality here refers to the possibility that the predicate controlling a branch is executed multiple times within a test case or by different test cases. The minimum is taken across all such executions.\n\nIn **Statement Coverage**, the optimal test suite is the one that executes all statements in the code. To reach a given statement \\( s \\), it is sufficient to execute a branch on which such a statement is directly control dependent. Thus, the distance function \\( d \\) for a statement \\( s \\) can be measured using the branch distances for the branches to be executed in order to reach \\( s \\). More specifically, the problem is [17]:\n\n**Problem 2.3:** Let \\( S = \\{s_1, \\ldots, s_k\\} \\) be the set of statements in a class. Find a test suite \\( T = \\{t_1, \\ldots, t_n\\} \\) that covers all the feasible statements, i.e., one that minimises the following fitness function:\n\n\\[\n\\min f_S(T) = |M| - |M_T| + \\sum_{b \\in B_S} d(b, T)\n\\]\n\nwhere \\( |M| \\) is the total number of methods, \\( |M_T| \\) is the number of executed methods by all test cases in \\( T \\); \\( B_S \\) is the set of branches that hold a direct control dependency on the statements in \\( S \\); and \\( d(b, T) \\) denotes the minimal normalised branch distance for branch \\( b \\in B_S \\).\nProblem 2.4: Let $M = \\{m_1, \\ldots, m_k\\}$ be the set of mutants for a class. Find a test suite $T = \\{t_1, \\ldots, t_n\\}$ that kills all mutants, i.e., one that minimises the following fitness function:\n\n$$\n\\min f_M(T) = f_{B_M}(T) + \\sum_{m \\in M} (d_i(m, T) + d_p(m, T))\n$$\n\nwhere $f_{B_M}(T)$ is the whole-suite fitness function for all branches in $T$ holding a direct control dependency on a mutant in $M$; $d_i$ estimates the distance toward a state infection; and $d_p$ denotes the propagation distance.\n\nFrom an optimisation point of view, in the whole-suite approach the fitness function $f$ considers all the targets at the same time and aggregates all corresponding distances into a unique fitness function by summing up the contributions from the individual target distances, i.e., the minimum distance from each individual target. In other words, multiple search targets are conflated into a single search target by means of an aggregated fitness function. Using this kind of approach, often named scalarization [11], a problem which involves multiple targets is transformed into a traditional single-objective, scalar one, thus allowing for the application of single-objective meta-heuristics such as standard GA.\n\n2.2 Many-Objective Formulation\n\nIn this paper, we reformulate the coverage criteria for test case generation as many-objective optimisation problems, where the objectives to be optimised are the individual distances from all the test targets in the class under test.\n\nMore formally, in this paper we consider the following reformulation:\n\nProblem 2.5: Let $U = \\{u_1, \\ldots, u_k\\}$ be the set of test targets to cover. Find a set of non-dominated test cases $T = \\{t_1, \\ldots, t_n\\}$ that minimise the fitness functions for all test targets $u_1, \\ldots, u_k$, i.e., minimising the following $k$ objectives:\n\n$$\n\\begin{align*}\n\\min f_1(t) &= d(u_1, t) \\\\\n& \\vdots \\\\\n\\min f_k(t) &= d(u_k, t)\n\\end{align*}\n$$\n\nwhere each $d(u_i, t)$ denotes the distance of test case $t$ from covering the test target $u_i$. Vector $(f_1, \\ldots, f_k)$ is also named a fitness vector.\n\nAccording to this new generic reformulation, branch coverage, statement coverage and strong mutation coverage can be reformulated as follows:\n\nProblem 2.6: Let $B = \\{b_1, \\ldots, b_k\\}$ be the set of branches of a class. Find a set of non-dominated test cases $T = \\{t_1, \\ldots, t_n\\}$ that minimises the fitness functions for all branches $b_1, \\ldots, b_k$, i.e., minimising the following $k$ objectives:\n\n$$\n\\begin{align*}\n\\min f_1(t) &= al(b_1, t) + d(b_1, t) \\\\\n& \\vdots \\\\\n\\min f_k(t) &= al(b_k, t) + d(b_k, t)\n\\end{align*}\n$$\n\nwhere each $d(b_j, t)$ denotes the normalised branch distance for the branch, executed by $t$, which is closest to $b_j$ (i.e., which is at minimum number of control dependencies from $b_j$), while $al(b_j, t)$ is the corresponding approach level (i.e., the number of control dependencies between the closest executed branch and $b_j$).\n\nProblem 2.7: Let $S = \\{s_1, \\ldots, s_k\\}$ be the set of statements in a class. Find a set of non-dominated test cases $T = \\{t_1, \\ldots, t_n\\}$ that minimises the fitness functions for all statements $s_1, \\ldots, s_k$, i.e., minimising the following $k$ objectives:\n\n$$\n\\begin{align*}\n\\min f_1(t) &= al(s_1, t) + d(b(s_1), t) \\\\\n& \\vdots \\\\\n\\min f_k(t) &= al(s_k, t) + d(b(s_k), t)\n\\end{align*}\n$$\n\nwhere each $d(b(s_j), t)$ denotes the normalised branch distance of test case $t$ for the branch closest to $b(s_j)$, the branch that directly controls the execution of statement $s_j$, while $al(s_j, t)$ is the corresponding approach level.\n\nProblem 2.8: Let $M = \\{m_1, \\ldots, m_k\\}$ be the set of mutants for a class. Find a set of non-dominated test cases $T = \\{t_1, \\ldots, t_n\\}$ that minimises the fitness functions for all mutants $m_1, \\ldots, m_k$, i.e., minimising the following $k$ objectives:\n\n$$\n\\begin{align*}\n\\min f_1(t) &= al(m_1, t) + d(b(m_1), t) + d_i(m_1, t) + d_p(m_1, t) \\\\\n& \\vdots \\\\\n\\min f_k(t) &= al(m_k, t) + d(b(m_k), t) + d_i(m_k, t) + d_p(m_k, t)\n\\end{align*}\n$$\n\nwhere $d(b(m_j), t)$ and $al(m_j, t)$ denote the normalised branch distance and the approach level of test case $t$ for mutant $m_j$ respectively; $d_i(m_j, t)$ is the distance from state infection, while $d_p(m_j, t)$ measures the propagation distance.\n\nIn this formulation, a candidate solution is a test case, not a test suite, which is scored by a single objective vector containing the distances from all yet uncovered test targets. Hence, the fitness is a vector of $k$ values, instead of a single aggregate score. In many-objective optimisation, candidate solutions are evaluated in terms of Pareto dominance and Pareto optimality [11]:\n\nDefinition 1: A test case $x$ dominates another test case $y$ (also written $x \\prec y$) if and only if the values of the objective function vector satisfy the following conditions:\n\n$$\n\\forall i \\in \\{1, \\ldots, k\\} \\quad f_i(x) \\leq f_i(y) \\\\\n\\text{and} \\\\\n\\exists j \\in \\{1, \\ldots, k\\} \\text{ such that } f_j(x) < f_j(y)\n$$\n\nConceptually, the definition above indicates that $x$ is preferred to (dominates) $y$ if and only if $x$ is strictly better on one or more objectives and it is not worse for the remaining objectives. For example, in branch coverage $x$ is preferred to (dominates) $y$ if and only if $x$ has a lower branch distance + approach level for one or more branches and it is not worse for the remaining branches.\n\nFigure 1 provides a graphical interpretation of Pareto dominance for a simple case with two test targets to cover, i.e., the problem is bi-objective. All test cases in the grey rectangle ($A$ and $C$) are dominated by $D$, because $D$ is better for both the two objectives $f_1$ and $f_2$. On the other hand, the test case $D$ does not dominate $B$ because it is closer to cover $f_1$ than $B$, but it is worse than $B$ on the other test target, $f_2$. Moreover, $D$ does not dominate $E$ because it is worse for the test target $f_1$. Similarly, the test case $B$ does not dominate $D$ and $E$ but it dominates $A$. Thus, $B$, $D$, and $E$ are non-dominated by any other test case, while $A$ and\nthese non-dominated by any other possible test case: \\( f(C) \\) covers the target are dominated by either \\( C \\) or \\( B \\). The test case \\( B \\) satisfies (covers) the target \\( f_2 \\), thus, it is a candidate to be included in the final test suite.\n\nAmong all possible test cases, the optimal test cases are those non-dominated by any other possible test case:\n\n**Definition 2:** A test case \\( x^* \\) is Pareto optimal if and only if it is not dominated by any other test case in the space of all possible test cases (feasible region).\n\nSingle-objective optimisation problems have typically one solution (or multiple solutions with the same optimal fitness value). On the other hand, solving a multi-objective problem may lead to a set of Pareto-optimal test cases (with different fitness vectors), which, when evaluated, correspond to trade-offs in the objective space. While in many-objective optimisation it may be useful to consider all the trade-offs in the objective space, especially if the number of objectives is small, in the context of coverage testing we are interested in finding only the test cases that contribute to maximising the total coverage by covering previously uncovered test targets, i.e., test cases having one or more objective scores equal to zero: \\( f_i(t) = 0 \\), as test \\( B \\) in Figure 1. These are the test cases that intersect any of the \\( m \\) Cartesian axes of the vector space where fitness vectors are defined. Such test cases are candidates for inclusion in the final test suite and represent a specific sub-set of the Pareto optimal solutions.\n\n### 3 Algorithm\n\nSearch algorithms aimed at optimising more than three objectives have been widely investigated for classical numerical optimisation problems. A comprehensive survey of such algorithms can be found in a recent paper by Li et al. [34]. The following subsections provide a discussion of the most relevant related works on many-objective optimisation and highlight how our novel many-objective algorithm overcomes their limitations in the context of many-objective structural coverage. In particular, Section 3.1 provides an overview on traditional many-objective algorithms, while Section 3.2 presents the many-objective algorithms that we have developed for solving the many-objective reformulation of structural coverage criteria.\n\n#### 3.1 Existing Many-Objective Algorithms\n\nMulti-objective algorithms, such as the Non-dominated Sorting Genetic Algorithm II (NSGA-II) [13] and the improved Strength Pareto Evolutionary Algorithm (SPEA2) [63], have been successfully applied within the software engineering community to solve problems with two or three objectives, including software refactoring, test case prioritisation, etc. However, such classical multi-objective evolutionary algorithms present scalability issues because they are not effective in solving optimisation problems with more than three-objectives [34].\n\nTo overcome their limitations, a number of many-objective algorithms have been recently proposed in the evolutionary computation community, which modify multi-objective solvers to increase the selection pressure. According to Li et al. [34], existing many-objective solvers can be categorised into seven classes: relaxed dominance based, diversity-based, aggregation-based, indicator-based, reference set based, preference-based, and dimensionality reduction approaches. For example, Laumanns et al. [33] proposed the usage of \\( \\epsilon \\)-dominance (\\( \\epsilon \\)-MOEA), which is a relaxed version of the classical dominance relation that enlarges the region of the search space dominated by each solution, so as to increase the likelihood for some solutions to be dominated by others [34]. Although this approach is helpful in obtaining a good approximation of an exponentially large Pareto front in polynomial time, it presents drawbacks and in some cases it can slow down the optimisation process significantly [27].\n\nYang et al. [58] introduced a Grid-based Evolutionary Algorithm (GrEA) that divides the search space into hyper-boxes of a given size and uses the concepts of grid dominance and grid distance to improve diversity among individuals by determining their mutual relationship in a grid environment. Zitzler and Künzli [62] proposed the usage of the hypervolume indicator instead of Pareto dominance when selecting the best solutions to form the next generation. Even if the new algorithm, named IBEA (Indicator Based Evolutionary Algorithm), was able to outperform NSGA-II and SPEA2, the computation cost associated with the exact calculation of the hypervolume indicator in a high-dimensional space (i.e., with more than five objectives) is too expensive, making it unfeasible with hundreds of objectives as in the case of structural test coverage (e.g., in mutation coverage a class/program may have hundreds of mutants).\n\nZhang and Li [61] proposed a Decomposition based Multi-objective Evolutionary Algorithm (MOEA/D), which decomposes a single many-objective problem into many single-objective sub-problems by employing a series of weighting vectors. Specifically, each sub-problem is obtained by using a specific weighting vector that aggregates different objectives using a weighted-sum approach. Different weighting vectors assign different importance (weights) to objectives, thus, delimiting the searching direction of these aggregation-based algorithms. However, the selection of weighting vectors is still an open problem especially for problems with a very large number of objectives [34].\nDi Pierro et al. [14] used a preference order-approach (POGA) as an optimality criterion in the ranking phase of NSGA-II. This criterion considers the concept of efficiency of order in subsets of objectives and provides a higher selection pressure towards the Pareto front than Pareto dominance-based algorithms.\n\nDeb and Jain [12] proposed NSGA-III, an improved version of the classical NSGA-II algorithm, where the crowding distance is replaced with a reference-set based niche-preservation strategy. It results in a new Pareto ranking/sorting based algorithm that produces well-spread and diversified solutions.\n\nYuan et al. [59] developed θ-NSGA-III, which enriches the non-dominated sorting scheme with the concepts of θ-dominance to rank solutions in the environmental selection phase, so as to ensure both convergence and diversity.\n\nAll the many-objective algorithms mentioned above have been investigated mostly for numerical optimisation problems with less than 15 objectives. Moreover, they are designed to produce a rich set of optimal trade-offs between different optimisation goals, by considering both proximity to the real Pareto optimal set and diversity between the obtained trade-offs [33]. As explained in Section 2.2, this is not the case of structural coverage for test case generation. The interesting solutions for this problem are test cases having one or more objective scores equal to zero (i.e., $f_i(t) = 0$). Trade-offs between objectives scores are useful just for maintaining diversity during the optimisation process. Hence, there are two main peculiarities that have to be considered in many-objective structural coverage as compared to more traditional many-objective problems. First, not all non-dominated test cases have a practical utility since they represent trade-offs between objectives. Instead, in structural coverage the search has to focus on a specific sub-set of the non-dominated solutions: those solutions (test cases) that satisfy one or more coverage targets. Second, for a given level of structural coverage, shorter test cases (i.e., test cases with a lower number of statements) are preferred to reduce the oracle cost [6], [17] and to avoid the bloat phenomenon [17].\n\n### 3.2 The Proposed Many-Objective Algorithms\n\nPrevious research in many-objective optimisation [55], [34] has shown that many-objective problems are particularly challenging because of the dominance resistance phenomenon, i.e., most of the solutions are incomparable since the proportion of non-dominated solutions increases exponentially with the number of objectives. As a consequence, it is not possible to assign a preference among individuals for selection purposes and the search process becomes equivalent to a random one [55]. Thus, problem/domain specific knowledge is needed to impose an order of preference over test cases that are non-dominated according to the traditional non-dominance relation. For test case generation, this means focusing the search effort on those test cases that are closer to one or more uncovered targets (e.g., branches) of the program. To this aim, we propose the following preference criterion in order to impose an order of preference among non-dominated test cases:\n\n**Definition 3:** Given a coverage target $u_i$, a test case $x$ is preferred over another test case $y$ (also written $x \\prec_{u_i} y$) if and only if the values of the objective function for $u_i$ satisfy the following condition:\n\n$$f_i(x) < f_i(y) \\text{ OR } f_i(x) = f_i(y) \\wedge \\text{size}(x) < \\text{size}(y)$$\n\nwhere $f_i(x)$ denotes the objective score of test case $x$ for coverage target $u_i$ (see Section 2), and $\\text{size}$ measures the test case length (number of statements). The best test case for a given coverage target $u_i$ is the one preferred over all the others for such target ($x_{best} \\prec_{u_i} y, \\forall y \\in T$). The set of best test cases across all uncovered targets ($\\{x \\mid \\exists i : x \\prec_{u_i} y, \\forall y \\in T\\}$) defines a subset of the Pareto front that is given priority over the other non-dominated test cases in our algorithms. When there are multiple test cases with the same minimum fitness value for a given coverage target $u_i$, we use the test case length (number of statements) as a secondary preference criterion. We opted for this secondary criterion since generated tests require human effort to check the candidate assertions (oracle problems). Therefore, minimising the test cases is a valuable (secondary) objective to achieve [6], [17] since smaller tests involve a lower number of method calls (and corresponding covered paths) to manually analyse.\n\nOur preference criterion provides a way to distinguish between test cases in a set of non-dominated ones, i.e., in a set where test cases are incomparable according to the traditional non-dominance relation, and it increases the selection pressure by giving higher priority to the best test cases with respect to the currently uncovered targets. Since none of the existing many-objective algorithms considers this preference ordering, which is a peculiarity of test case generation, in this paper we define our novel many-objective GA by incorporating the proposed preference criterion in the main loop of NSGA-II, a widely known Pareto efficient multi-objective genetic algorithm designed by Deb et al. [13].\n\nIn a nutshell, NSGA-II starts with an initial set of random solutions (random test cases), also called chromosomes, which represents a random sample of the search space (line 3 of Algorithm 1). The population then evolves through a series of generations to find better test cases. To produce the next generation, NSGA-II first creates new test cases,\ncalled offsprings, by combining parts from two selected test cases (parents) in the current generation using the crossover operator and randomly modifying test cases using the mutation operator (function GENERATE-OFFSPRING, at line 5 of Algorithm 1). Parents are selected according to a selection operator, which uses Pareto optimality to give higher chance of reproduction to non-dominated (fittest) test cases in the current population. The crowding distance is used in order to make a decision about which test cases to select: non-dominated test cases that are far away from the rest of the population have higher probability of being selected (lines 10-15 of Algorithm 1). Furthermore, NSGA-II uses the FAST-NONDOMINATED-SORT algorithm to preserve the test cases forming the current Pareto frontier in the next generation (elitism). After some generations, NSGA-II converges to “stable” test cases, which represent the Pareto-optimal solutions to the problem.\n\nThe next sections describe in detail our proposed many-objective algorithms starting from NSGA-II, first describing the MOSA algorithm followed by its extension, DynaMOSA.\n\n3.2.1 MOSA: a Many Objective Sorting Algorithm\n\nMOSA (Many Objective Sorting Algorithm) replaces the traditional non-dominated sorting with a new ranking algorithm based on our preference criterion. As shown in Algorithm 2, MOSA shares the initial steps of NSGA-II: it starts with an initial set of randomly generated test cases that forms the initial population (line 3 of Algorithm 2); then, it creates new test cases using crossover and mutation (function GENERATE-OFFSPRING, at line 6 of Algorithm 2).\n\nSelection. Differently from NSGA-II, in MOSA the selection is performed by considering both the non-dominance relation and the proposed preference criterion (function PREFERENCE-SORTING, at line 9 of Algorithm 2). In particular, the PREFERENCE-SORTING function, whose pseudo-code is provided in Algorithm 3, determines the test case with the lowest objective score (e.g., branch distance + approach level for branch coverage) for each uncovered target \\( u_i \\in U \\), i.e., the test case that is closest to cover \\( u_i \\) (lines 2-6 of Algorithm 3). All these test cases are assigned rank 0 (i.e., they are inserted into the first non-dominated front \\( F_0 \\)), so as to give them a higher chance of surviving in to the next generation (elitism). The remaining test cases (those not assigned to the first rank) are then ranked according to the traditional non-dominated sorting algorithm used by NSGA-II [13], starting with a rank equal to 1 and so on (line 11-15 of Algorithm 3). To speed-up the ranking procedure, the traditional non-dominated sorting algorithm is applied only when the number of test cases in \\( F_0 \\) is smaller than the population size \\( M \\) (condition in line 8). Instead, when the condition \\( |F_0| > M \\) is satisfied, the PREFERENCE-SORTING function returns only two fronts: the first front (rank 0) with all test cases selected by our preference criterion; and the front with rank 1 that contains all remaining test cases in \\( T \\), i.e., \\( F_1 = T − F_0 \\).\n\nDominance. It is important to notice that the routine FAST-NONDOMINATED-SORT assigns the ranks to the remaining test cases by considering only the non-dominance relation for the uncovered targets, i.e., by focusing the search toward the interesting sub-region of the remaining search space. Such non-dominance relation is computed by a specific dominance comparator which iterates over all the uncovered targets when deciding whether two test cases \\( t_1 \\) and \\( t_2 \\) do not dominate each other or whether one (e.g., \\( t_1 \\)) dominates the other (e.g., \\( t_2 \\)). While the original dominance comparator defined by Deb et al. [13] iterates over all the objectives (targets), in MOSA we use the dominance comparator depicted in Algorithm 4. Such a comparator iterates only over the uncovered targets (loop condition in line 4 of Algorithm 4). Moreover, as soon as it finds two uncovered targets for which two test cases \\( t_1 \\) and \\( t_2 \\) do not dominate each other (lines 11-12 Algorithm 4), the iteration is terminated without analysing further uncovered targets.\n\nCrowding distance. Once a rank is assigned to all candidate test cases, the crowding distance is used to give higher probability of being selected to some test cases in the same front. As measure for the crowding distance, we use the sub-vector dominance assignment proposed by Köppen et al. [31] for many-objective optimisation problems. Specifically, the loop at line 12 in Algorithm 2 and the following lines 16 and 17 add as many test cases as possible to the next generation, according to their assigned ranks, until reaching\n\n---\n\n### Algorithm 2: MOSA\n\n**Input:**\n- \\( U = \\{u_1, \\ldots, u_m\\} \\) the set of coverage targets of a program.\n- Population size \\( M \\)\n\n**Result:** A test suite \\( T \\)\n\n```\nbegin\n1. t ← 0 // current generation\n2. \\( P_t \\) ← RANDOM-POPULATION(\\( M \\))\n3. archive ← UPDATE-ARCHIVE(\\( P_t \\), 0)\n4. while not (search_budget_consumed) do\n5. \\( Q_t \\) ← GENERATE-OFFSPRING(\\( P_t \\))\n6. archive ← UPDATE-ARCHIVE(\\( Q_t \\), archive)\n7. \\( R_t \\) ← \\( P_t \\) ∪ \\( Q_t \\)\n8. \\( P_{t+1} \\) ← PREFERENCE-SORTING(\\( R_t \\))\n9. \\( d \\) ← 0\n10. while \\( |P_{t+1}| + |P_d| \\leq M \\) do\n11. \\( P_{t+1} \\) ← \\( P_{t+1} \\) ∪ \\( P_d \\)\n12. \\( d \\) ← \\( d + 1 \\)\n13. Sort(\\( P_d \\)) // according to the crowding distance\n14. \\( P_{t+1} \\) ← \\( P_{t+1} \\) ∪ \\( P_d [1 : (M - |P_{t+1}|)] \\)\n15. \\( t \\) ← \\( t + 1 \\)\n16. archive ← archive\nend\n```\n\n### Algorithm 3: PREFERENCE-SORTING\n\n**Input:**\n- A set of candidate test cases \\( T \\)\n- Population size \\( M \\)\n\n**Result:** Non-dominated ranking assignment \\( F \\)\n\n```\nbegin\n1. \\( F_0 \\) / first non-dominated front\n2. for \\( u_i \\in U \\) and \\( u_i \\) is uncovered do\n3. \\( t_{best} \\) ← test case in \\( T \\) with minimum objective score for \\( u_i \\)\n4. \\( F_0 \\) ← \\( F_0 \\) ∪ \\( \\{t_{best}\\} \\)\n5. \\( T \\) ← \\( T \\) ∪ \\( F_0 \\)\n6. if \\( |F_0| > M \\) then\n7. \\( P_1 \\) ← \\( T \\)\n8. else\n9. for \\( u_i \\in U \\) \\( u_i \\) is uncovered do\n10. \\( F_0 \\) ← FAST-NONDOMINATED-SORT(\\( T\\), \\( \\{u \\in U^*\\}\\))\n11. \\( d \\) ← 0 // first front in \\( F \\)\n12. for All non-dominated fronts in \\( F \\) do\n13. \\( F_d+1 \\) ← \\( F_d \\)\n```\nAlgorithm 4: DOMINANCE-COMPARATOR\n\nInput:\nTwo test cases to compare $t_1$ and $t_2$\n$U = \\{u_1, \\ldots, u_m\\}$ the set of coverage targets of a program.\n\n1 begin\n2 dominates1 ← false\n3 dominates2 ← false\n4 for $u_i \\in U$ and $u_i$ is uncovered do\n5 $f_1^i$ ← values of $u_i$ for $t_1$\n6 $f_2^i$ ← values of $u_i$ for $t_2$\n7 if $f_1^i < f_2^i$ then\n8 dominates1 ← true\n9 if $f_1^i > f_2^i$ then\n10 dominates2 ← true\n11 if dominates1 == true & dominates2 == true then\n12 break\n13 if dominates1 == dominates2 then\n14 // $t_1$ and $t_2$ do not dominate each other\n15 else\n16 if dominates1 == true then\n17 // $t_1$ dominates $t_2$\n18 else\n19 // $t_2$ dominates $t_1$\n20 return $A$\n\nAlgorithm 5: UPDATE-ARCHIVE\n\nInput:\nA set of candidate test cases $T$\nAn archive $A$\n\nResult: An updated archive $A$\n\n1 begin\n2 for $u_i \\in U$ do\n3 $t_{best} ← \\varnothing$\n4 best_length ← $\\infty$\n5 if $u_i$ already covered then\n6 $t_{best} ←$ test case in $A$ covering $u_i$\n7 best_length ← number of statements in $t_{best}$\n8 for $t_j \\in T$ do\n9 score ← objective score of $t_j$ for target $u_i$\n10 length ← number of statements in $t_j$\n11 if score == 0 and length $\\leq$ best_length then\n12 replace $t_{best}$ with $t_j$ in $A$\n13 $t_{best} ← t_j$\n14 best_length ← length\n15 return $A$\n\nthe population size. The algorithm first selects the non-dominated test cases from the first front ($F_1$); if the number of selected test cases is lower than the population size $M$, the loop selects more test cases from the second front ($F_2$), and so on. The loop stops when adding test cases from current front $F_d$ exceeds the population size $M$. At end of the loop (lines 16-17), when the number of selected test cases is lower than the population size $M$, the algorithm selects the remaining test cases from the current front $F_d$ according to the descending order of crowding distance.\n\nArchiving. As a further peculiarity with respect to other many-objective algorithms, MOSA uses a second population, called archive, to keep track of the best test cases that cover targets of the program under test. Specifically, whenever new test cases are generated (either at the beginning of search or when creating offsprings) MOSA stores those tests that satisfy previously uncovered targets in the archive as candidate test cases to form the final test suite (line 4 and 7 of Algorithm 2). To this aim, function UPDATE-ARCHIVE (reported in Algorithm 5 for completeness) updates the set of test cases stored in the archive with the new generated test cases. This function considers both the covered targets and the length of test cases when updating the archive; for each covered target $u_i$ it stores the shortest test case covering $u_i$ in the archive.\n\nIn summary, generation by generation MOSA focuses the search towards the uncovered targets of the program under test (both PREFERENCE-SORTING and FAST-NONDOMINATED-SORT routines analyse the objective scores of the candidate test cases considering the uncovered targets only); it also stores the shortest covering test cases in an external data structure (i.e., the archive) to form the final test suite. Finally, since MOSA uses the crowding distance when selecting the test cases, it promotes diversity, which represents a key factor to avoid premature convergence toward sub-optimal regions of the search space [28].\n\n3.2.2 Graphical Interpretation\n\nLet us consider the simple program shown in Figure 2-a. Let us assume that the coverage criterion is branch coverage and that the uncovered targets are the true branches of statements 1 and 3, whose branch predicates are $(a == b)$ and $(b == c)$ respectively. According to the proposed many-objective formulation, the corresponding problem has two residual optimisation objectives, which are $f_1 = al(b_1) + d(b_1) = abs(a - b)$ and $f_2 = al(b_2) + d(b_2) = abs(b - c)$. Hence, any test case produced at a given generation $g$ corresponds to some point in a two-dimensional objective space as shown in Figure 2-b and 2-c. Unless both $a$ and $b$ are equal, the objective function $f_1$ computed using the combination of approach level and branch distance is greater than zero. Similarly, function $f_2$ is greater than zero unless $b$ and $c$ are equal.\n\nLet us consider the scenario reported in Figure 2-b where no test case is able to cover the two uncovered branches (i.e., in all cases $f_1 > 0$ and $f_2 > 0$). If we use the traditional non-dominance relation between test cases, all test cases corresponding to the black points in Figure 2-b are non-dominated and form the first non-dominated front $F_0$. Therefore, all such test cases have the same probability of being selected to form the next generation, even if test case $A$ is the closest to the Cartesian axis $f_2$ (i.e., closest to cover branch $b_2$) and test case $B$ is the closest to the Cartesian axis $f_1$ (branch $b_1$). Since there is no preference among test cases in $F_0$, it might happen that $A$ and/or $B$ are not kept for the next generation, while other, less useful test cases in $F_0$ are preserved. This scenario is quite common in many-objective optimisation, where the number of non-dominated solutions increases exponentially with the number of objectives [55]. However, from the branch coverage point of view the two test cases $A$ and $B$ are better (fitter) than all other test cases, because they are the closest to covering each of the two uncovered branches.\n\nOur novel preference criterion gives a higher priority to test cases $A$ and $B$ with respect to all other test cases, guaranteeing their survival in the next generation. In particular, using the new ranking algorithm proposed in this paper (see Algorithm 3), the first non-dominated front $F_0$ will contain only test cases $A$ and $B$ (see Figure 2-c), while all other test cases will be assigned to other, successive fronts. Whenever there are multiple test cases that are closest to one axis,\nassociated with a given uncovered branch, the preference criterion provides a further strategy to impose an order to the non-dominated test cases by assigning rank 0 to the shortest test case only.\n\n3.2.3 DynaMOSA: Dynamic Selection of the Optimisation Targets\n\nOne main limitation in MOSA is that it considers all coverage targets as independent objectives to optimise since the first generation. However, there exist structural dependencies among targets that should be considered when deciding which targets/objectives to optimise. For example, some targets can be satisfied if and only if other related targets are already covered.\n\nTo better explain this concept, let us consider the example in Figure 3. The four branches to be covered, b₁, b₂, b₃, b₄, are not independent from each other. In fact, coverage of b₂, b₃ can be achieved only after b₁ has been covered, since the former targets are under the control of the latter. In other words, there is a control dependency between b₁ and b₂, b₃, which means that the execution of b₂, b₃ depends on the outcome of the condition at node 2, which in turn is evaluated only once target b₁ is covered. If no test case covers b₁, the ranking in MOSA is determined by the fitness function $f_1 = d(b₁)$. When tests are evaluated for the two dependent branches b₂ and b₃, the respective fitness functions will be equal to $f_1 + 1$, since the only difference from coverage of b₁ consists of a higher approach level (in this case, +1), while the branch distance $d$ is the same. Since the values of $f₂$ and $f₃$ are just shifted by a constant amount (the approach level) with respect to $f_1$, the test case ranking is the same as the one obtained when considering $f_1$ alone. This means that taking into account objectives $f₂$, $f₃$ during preference sorting is useless, since they do not contribute to the final ranking.\n\nThe example illustrated above shows that coverage targets can be organised into a priority hierarchy based on the following concepts in standard flow analysis:\n\n**Definition 4** (Dominator): A statement $s₁$ dominates another statement $s₂$ if every execution path to $s₂$ passes through $s₁$.\n\n**Definition 5** (Post-dominator): A statement $s₁$ post-dominates another statement $s₂$ if every execution path from $s₂$ to the exit point (return statement) passes through $s₁$.\n\n**Definition 6** (Control dependency): There is a control dependency between program statement $s₁$ and program statement $s₂$.\niff: (1) \\( s_2 \\) is not a postdominator of \\( s_1 \\) and (2) there exists a path in the control flow graph between \\( s_1 \\) and \\( s_2 \\) whose nodes are postdominated by \\( s_2 \\).\n\nCondition (1) in the definition of control dependency ensures that \\( s_2 \\) is not necessarily executed after \\( s_1 \\). Condition (2) ensures that once a specific path is taken between \\( s_1 \\) and \\( s_2 \\), the execution of \\( s_2 \\) becomes inevitable. Hence, \\( s_1 \\) is a decision point whose outcome determines the inevitable execution of \\( s_2 \\).\n\n**Definition 7** (Control dependency graph): The graph \\( G = (N, E, s) \\), consisting of nodes \\( n \\in N \\) that represent program statements and edges \\( e \\in E \\subseteq N \\times N \\) that represent control dependencies between program statements, is called control dependency graph. Node \\( s \\in N \\) represents the entry node, which is connected to all nodes that are not under the control dependency of another node.\n\nThe definition of control dependency given above can be easily extended from program statements to arbitrary coverage targets. For instance, given two branches to be covered, \\( b_1, b_2 \\), we say \\( b_1 \\) holds a control dependency on \\( b_2 \\) if \\( b_1 \\) is postdominated by a statement \\( s_1 \\) which holds a control dependency on a node \\( s_2 \\) that postdominates \\( b_2 \\).\n\nIn DynaMOSA, the control dependency graph is used to derive which targets are independent from any others (targets that are free of control dependencies) and which ones can be covered only after satisfying previous targets in the graph. The difference between DynaMOSA and MOSA are illustrated in Algorithms 6. At the beginning the search process, DynaMOSA selects as initial set of objectives only those targets that are free of control dependencies (line 2). Once the initial population of random test cases is generated (line 4), the current set of targets \\( U^* \\) is updated using the routine UPDATE-TARGETS highlighted in Algorithm 7. This routine is also called at each iteration in order to update the current set of targets \\( U^* \\) to consider at each generation depending on the results of the execution of the offspring (line 10 in Algorithms 6). Therefore, fitness evaluation (line 8), preference sorting (line 12), and crowding distance (line 16) are computed only considering the targets in \\( U^* \\subseteq U \\).\n\nThe routine UPDATE-TARGET is responsible for dynamically updating the set of selected targets \\( U^* \\) so as to include any uncovered targets that are control dependent on the newly covered target. It iterates over all targets in \\( U^* \\subseteq U \\) (loop in lines 2-6 of Algorithm 7) and in case of newly covered targets (condition in line 3) it visits the control flow graph to find all control dependent targets. Indeed, Algorithm 7 uses a standard graph visit algorithm, which stops its visit whenever an uncovered target is encountered (lines 7-13). In such a case, the encountered target is added to the set of targets \\( U^* \\), to be considered by DynaMOSA in the next generation. If the encountered target is covered, the visit continues recursively until the first uncovered target is found or all targets have been already visited (lines 9-11). This ensures that only the first uncovered target, encountered after visiting a covered target, is added to \\( U^* \\). All following uncovered targets are just ignored, since the graph visit stops.\n\n2. For simplicity, we only consider the case of targets associated with graph edges, but the same algorithm works if targets are associated with nodes.\n\n---\n\n**Algorithm 6: DynaMOSA**\n\n**Input:**\n- \\( U = \\{u_1, \\ldots, u_m\\} \\) the set of coverage targets of a program.\n- Population size \\( M \\)\n- \\( G = (N, E, s) \\): control dependency graph of the program\n- \\( \\phi : E \\rightarrow U^* \\): partial map between edges and targets\n\n**Result:** A test suite \\( T \\)\n\n1. **begin**\n2. \\( U^* \\leftarrow \\text{targets in } U \\text{ with not control dependencies} \\)\n3. \\( t \\leftarrow 0 \\) // current generation\n4. \\( P_t \\leftarrow \\text{RANDOM-POPULATION}(M) \\)\n5. \\( \\text{archive} \\leftarrow \\text{UPDATE-ARCHIVE}(P_t, \\emptyset) \\)\n6. \\( U^* \\leftarrow \\text{UPDATE-TARGETS}(U^*, G, \\phi) \\)\n7. **while** not (search_budget_consumed) **do**\n8. \\( Q_t \\leftarrow \\text{GENERATE-OFFSPRING}(P_t) \\)\n9. \\( \\text{archive} \\leftarrow \\text{UPDATE-ARCHIVE}(Q_t, \\text{archive}) \\)\n10. \\( U^* \\leftarrow \\text{UPDATE-TARGETS}(U^*, G, \\phi) \\)\n11. \\( R_t \\leftarrow P_t \\cup Q_t \\)\n12. \\( P_{t+1} \\leftarrow \\text{PREFERENCE-SORTING}(R_t, U^*) \\)\n13. \\( P_{t+1} \\leftarrow \\emptyset \\)\n14. \\( d \\leftarrow 0 \\)\n15. **while** \\( |P_{t+1}| + |F_d| \\leq M \\) **do**\n16. \\( F_{d} \\leftarrow \\text{CROWDING-DISTANCE-ASSIGNMENT}(F_{d}, U^*) \\)\n17. \\( P_{t+1} \\leftarrow P_{t+1} \\cup F_{d} \\)\n18. \\( d \\leftarrow d + 1 \\)\n19. \\( \\text{Sort}(F_{d}) \\) // according to the crowding distance\n20. \\( P_{t+1} \\leftarrow P_{t+1} \\cup F_{d[1 : (M - |P_{t+1}| + 1)]} \\)\n21. \\( t \\leftarrow t + 1 \\)\n22. **T \\leftarrow archive**\n\n---\n\n**Algorithm 7: UPDATE-TARGETS**\n\n**Input:**\n- \\( G = (N, E, s) \\): control dependency graph of the program\n- \\( U^* \\subseteq U \\): current set of targets\n- \\( \\phi : E \\rightarrow U^* \\): partial map between edges and targets\n\n**Result:**\n- \\( U^* \\): updated set of targets to optimise\n\n1. **begin**\n2. **for** \\( u \\in U^* \\) **do**\n3. \\( \\text{if } u \\text{ is covered then} \\)\n4. \\( U^* \\leftarrow U^* \\setminus \\{u\\} \\)\n5. \\( \\text{visit}(e_u) \\)\n6. **end for**\n\n7. **Function** \\( \\text{visit}(e_u \\in E) \\)\n8. **for** each unvisited \\( e_u \\in E \\) control dependent on \\( e_u \\) **do**\n9. \\( \\text{if } \\phi(e_u) \\text{ is not covered then} \\)\n10. \\( U^* \\leftarrow U^* \\cup \\{\\phi(e_u)\\} \\)\n11. **set** \\( e_u \\text{ as visited} \\)\n12. **else**\n13. \\( \\text{visit}(e_u) \\)\n14. **end if**\n15. **end for**\n\nIn this way, the ranking performed by MOSA remains unchanged (a formal proof of this is provided below), while convergence to the final test suite is achieved faster, since the number of objectives to be optimised concurrently is kept smaller. Intuitively, the ranking of MOSA is unaffected by the exclusion of targets that are controlled by uncovered targets because such excluded targets induce a ranking of the test cases which is identical to the one induced by the controlling nodes.\n\nThere are two main conditions that must be satisfied to justify the dynamic selection of the targets produced by the execution of Algorithm 6:\n\n1. Since at each generation, the set \\( U^* \\) used by DynaMOSA contains all targets with minimum approach level, for each remaining target \\( u_i \\) in \\( U - U^* \\) there should exist a target \\( u^* \\in U^* \\) such that \\( f(u_i) = f(u^*) + K. \\)\n2) The computation cost of the routine UPDATE-TARGETS in Algorithm 7 should be negligible if compared to cost of computing preference sorting and crowding distance for all the uncovered targets.\n\nThe first condition is ensured by Theorem 1, presented in the following. The second is not ensured theoretically, but it was found empirically to hold in practice.\n\nDynaMOSA generates test cases with minimum distance from $U^*$, the set of uncovered targets directly reachable through a control dependency edge of one or more test case execution trace. On the other hand, MOSA generates test cases with minimum distance from the full set of uncovered targets, $U$. The two minimisation processes are equivalent if and only if the test cases at minimum distance from the elements of $U^*$ are also the test cases at minimum distance from $U$. The following Theorem provides a theoretical justification for the dynamic selection of a subset of the targets produced by the execution of Algorithm 7, by proving that the two sets of test cases optimised respectively by MOSA ($T_{\\text{min}}$) and DynaMOSA ($T_0$) are the same.\n\n**Theorem 1:** Let $U$ be the set of all uncovered targets; $T_{\\text{min}}$ the set of test cases with minimum approach level from $U$ and $T_0$ the test cases with approach level zero; $U^*$ be the set of uncovered targets at approach level zero from one or more test cases $t \\in T_0$, then the two sets of test cases $T_{\\text{min}}$ and $T_0$ are the same, i.e., $T_{\\text{min}} = T_0$.\n\n**Proof:** Since the approach level is always greater than or equal to zero, the approach level of the elements of $T_0$ is ensured to be minimum. Hence, $T_0 \\subseteq T_{\\text{min}}$. Let us now prove by contradiction that there cannot exist any uncovered target $u$ associated with a test case $t$ whose approach level from $u$ is strictly greater than zero, such that $t$ does not belong to $T_0$. Let us consider the shortest path from the execution trace of $t$ to $u$ in the control dependency graph. The first node $u'$ in such path belongs to $U^*$, since it is an uncovered target, and it has approach level zero from the trace of $t$. Indeed, it is an uncovered target because otherwise the test case $t'$ that covers it would have an execution trace closer to $u$ than $t$. Since it satisfies the relation approach level$(t, u') = 0$, test case $t$ must be an element of $T_0$. Hence, $T_{\\text{min}}$ cannot contain any test case not in $T_0$ and the equality $T_{\\text{min}} = T_0$ must hold.\n\nSince the same set of test cases are at minimum distance from either $U$ or $U^*$, the test case selection performed by MOSA, based on the distance of test cases from $U$, is algorithmically equivalent to the test case selection performed by DynaMOSA, based on the distance of test cases from $U^*$.\n\nThe fact that DynaMOSA iterates over a lower number of targets ($U^* \\subseteq U$) with respect to MOSA has direct consequences on the computational cost of each single generation. In fact, in each generation the two many-objective algorithms share two routines: the PREFERENCE-SORTING and the CROWDING-DISTANCE-ASSIGNMENT routines, as shown in Algorithms 2 and 6. For the fronts following the first one, the routine PREFERENCE-SORTING relies on the traditional FAST-NON-DOMINATED-SORT by Deb et al. [13], which has an overall computation complexity of $O(M^2 \\times N)$ where $M$ is the size of the population and $N$ is the number of objectives. Thus, for MOSA the cost of such routine is $O(M^2 \\times |U|)$ where $U$ is the set of uncovered targets in a given generation. For DynaMOSA, the computational cost is reduced to $O(M^2 \\times |U^*|)$ with $U^* \\subseteq U$ being the set of uncovered targets with minimum approach level. For trivial classes where all targets have no structural dependencies (i.e., classes with only branchless methods), the cost of PREFERENCE-SORTING will be the same since $U^* = U$. However, for non-trivial classes we would expect $U^* \\subset U$ leading to a reduced computational complexity.\n\nA similar analysis can be performed for the other shared routine, i.e., CROWDING-DISTANCE-ASSIGNMENT. According to Köppen et al. [31], the cost of such a routine when using the sub-vector dominance assignment is $O(M^2 \\times N)$ where $M$ is the size of the population while $N$ is the number of objectives. Therefore, for MOSA the cost of such routine is $O(M^2 \\times |U|)$ where $U$ is the set of uncovered targets in a given generation; while for DynaMOSA it is $O(M^2 \\times |U^*|)$. For non-trivial classes, DynaMOSA will iterate over a lower number of targets as long as the condition $U^* \\subset U$ holds.\n\nMoreover, MOSA requires to compute the fitness scores (e.g., approach level and branch distances in branch coverage) for all uncovered targets $U$ and for each newly generated test case. In particular, for each test case MOEA requires to compute the distances between execution traces and all targets in $U$. Instead, DynaMOSA focuses only on coverage targets with minimum approach levels, thus, requiring to compute the fitness scores for $U^* \\subseteq U$ only.\n\nThe additional operations of DynaMOSA with respect to MOSA are the construction of the intra-procedural control dependency graph and its visit for target selection. The cost for intra-procedural control dependency graph construction is paid just once for all test case generation iterations and the computation of the graph can be carried out offline, before running the algorithm. The visit of the control dependency graph for coverage target selection can be performed very efficiently (for structured programs the graph is a tree). As a consequence, the saving in the computation of PREFERENCE-SORTING, CROWDING-DISTANCE-ASSIGNMENT and fitness scores performed by DynaMOSA vs. MOSA is expected to dominate the overall execution time of the two algorithms, while the visit of the control dependency graph performed by DynaMOSA is expected to introduce a negligible overhead. This was confirmed by our experiments. In fact, in our experiments the intra-procedural control dependency graphs of the methods under test and their visit consumed a negligible amount of execution time in comparison with the time taken by the extra computations performed by MOSA.\n\n## 4 Empirical Evaluation\n\nThis section details the empirical study we carried out to evaluate the proposed many-objective test case generation algorithms with respect to three testing criteria: (i) branch coverage, (ii) statement coverage, and (iii) strong-mutation coverage.\n\n### 4.1 Subjects\n\nThe context of our study is a random selection of classes from four test benchmarks: (i) the SFI10 corpus [18]; (ii) the SBST tool contest 2015 [53]; (iii) the SBST tool contest 2016 [49]; and (iv) the benchmark used in our previous conference paper [42].\nThe SF110 benchmark is a corpus of Java classes composed of a representative sample of 100 projects from the SourceForge.net repository, augmented with 10 of the most popular projects in the repository, for a total of 23,886 classes. We selected this benchmark since it has been widely used in the literature to assess test case generation tools [18], [51], [48]. However, Shamshiri et al. [51] showed that the vast majority of classes in the FS110 corpus are trivial to cover fully, even with random search algorithms. In fact, they observed that most of the classes in this corpus do not require the usage of evolutionary algorithms. Hence, for our evaluation we selected only non-trivial classes from this benchmark. To this aim, we first computed the McCabe's cyclomatic complexity [36] for each method in FS110 by means of the extended CKJM library. The McCabe's cyclomatic complexity of a method is defined as the number of independent paths in the control flow graph and can be shown (for structured programs) to be equal to the number of branches plus one. We found that 56% of the classes in SF110 are trivial, combining only methods with cyclomatic complexity equal to 1. These branchless methods can be fully covered by a simple method call. Therefore, we pruned this benchmark by removing all classes whose methods have a cyclomatic complexity lower than five. This filtering resulted in a smaller benchmark composed of 96 projects and 23% of classes from the original SF110 corpus. Among those 96 projects, 18 projects contain only a single non-trivial class after our filter. For our experiment, we randomly sampled 2 classes from each of the 78 projects containing multiple non-trivial classes, and we selected the available non-trivial classes from each of the remaining 18 projects. In addition, we randomly sampled two further classes for each of the most popular projects (11 projects), and one additional class for each of the eight larger projects in the repository. This resulted in 204 non-trivial classes.\n\nFrom the latest two editions of the SBST unit test tool contests [53], [49] we selected 97 subjects: 46 classes from the third edition [53] and 51 classes from the fourth edition [49] of the contest. From the original set of classes in the two competitions, we removed all duplicate classes belonging to different versions of the same library since we would not expect any relevant difference over different versions in terms of branch, statement, or mutation coverage. We selected these two benchmarks because they contain Java classes with different characteristics and belonging to different application domains. In addition, they have been recently used to assess the performance of different test generation techniques.\n\nOur last benchmark is the one used in our previous conference paper [42], from which we consider all classes used in our previous empirical study. While the original dataset includes 64 classes, in the present study we report the results for 45 classes, since 19 classes are shared with the SF110 corpus and with the latest SBST unit test tool contest [49].\n\nIn total, the selected 346 Java classes have 360,941 statements, 61,553 branches, and 117,816 mutants that are considered as coverage targets in our experiment. Table 1 reports the characteristics of the selected classes, grouped by project. Specifically, it reports the number of classes selected for each project as well as minimum, average (mean), and maximum number of statements, branches and mutants contained in\nthose classes. The number of branches in each class ranges between 2 (a class from the SBST contest) and 7,939, while the number of statements ranges between 14 and 16,624; the number of mutants ranges between 0 and 1,086 (EvoSuite was unable to inject any mutant into two of the selected classes; however, we kept them for the other two coverage criteria). It is worth noticing that, according to the survey by Li et al. [34], existing many-objective algorithms can deal with up to 50 objectives, while in our study most selected classes contain hundreds and thousands of objectives (e.g., mutants to kill). This confirms the need for designing new many-objective algorithms suitable for test case generation given the very high number of coverage targets as compared to the number of objectives (≤ 50) encountered in traditional many- and multi-objective problems.\n\n4.2 Research Questions\nThe empirical evaluation aims at answering the following research questions:\n\n- RQ1: How does DynaMOSA perform compared to alternative approaches on branch coverage?\n- RQ2: How does DynaMOSA perform compared to alternative approaches on statement coverage?\n- RQ3: How does DynaMOSA perform compared to alternative approaches on strong mutation coverage?\n\nThe three research questions above aim at evaluating the benefits introduced by the many-objective reformulation of testing criteria—branch, statement and mutation—and to what extent the proposed DynaMOSA algorithm is able to cover more test targets (effectiveness) when compared to alternative approaches for test generation problems. When no difference is detected in the number of covered test targets, we analyse to what extent the proposed approach is able to reach higher code coverage when considering different search time intervals (efficiency).\n\nTo evaluate the internal functioning of our new sorting algorithm (Algorithm 3), which combines both our preference criterion and Pareto-based ranking, we formulate the following additional research question:\n\n- RQ4 (internal assessment): How do preference criterion and Pareto dominance affect the effectiveness of DynaMOSA?\n\nIn answering this research question, we consider the two sub-questions below:\n\n- RQ4.1: What is the effectiveness of DynaMOSA’s Pareto-based ranking alone, when applied without the preference criterion?\n- RQ4.2: What is the effectiveness of DynaMOSA’s preference criterion alone, when applied without Pareto-based dominance ranking?\n\n4.3 Baseline Selection\nTo answer our first three research questions, we selected the following approaches for comparison with DynaMOSA:\n\n- Many-objective sorting algorithm (MOSA). It is the many-objective solver we developed in our previous paper [42] for branch coverage. While in our previous paper we used MOSA only for branch coverage criterion, in this paper (see section 3.2) we have described how this algorithm can be also used for other criteria. Therefore, we use MOSA as baseline for the first three research questions.\n\n- Whole Suite approach with Archive (WSA). It is an extension of the more traditional whole suite approach recently proposed by Rojas et al. [48] and implemented in EvoSuite. In particular, WSA is a hybrid approach that implements some routines of our MOSA algorithm along with the original whole suite approach. First, WSA uses an archive to store test cases that cover one or more coverage targets (e.g., branches) [48]. Such an archive operator works at test case level and not at test suite level, which is the usual granularity of the whole suite approach. Second, WSA focuses the search on uncovered coverage targets only, which is also one of the core properties we developed in MOSA (and DynaMOSA too). Finally, the final test suite is not represented by the best individual (candidate suite) from the last generation of GA, but it is artificially synthesised by taking those test cases stored in the archive and that come from different suites. While WSA has been shown to outperform both standard WS and one-target approaches, it departs from the original WS principle of test suite evolution [48]. For our study, we could use WSA as baseline only for RQ1 and RQ3 because no archive strategy has been implemented in EvoSuite for statement coverage.\n\n- Traditional Whole Suite approach (WS). This is the traditional, pure whole suite approach without any archive strategy [17]. Thus, the final test suite provided to developers is the best individual (candidate suite) from the last generation of the genetic algorithm. We used WS as baseline only for RQ2 since for statement coverage no WSA variant is available in EvoSuite. While WS could be used as additional baseline also for RQ1 and RQ3, we discarded this scenario since Rojas et al. [48] already showed the superiority of WSA over WS for branch coverage.\n\nMOSA is a natural baseline to compare with, in order to investigate the benefits achieved when dynamically reducing the number of objectives to be optimised at each generation. This comparison allows us also to empirically validate our discussion on the computational cost of DynaMOSA vs. MOSA reported in Section 3. WSA is the main baseline, because it has been shown to outperform standard WS and the single-target approach. Since WSA is a hybrid solution that incorporates the archiving core routines of MOSA (and DynaMOSA), such comparison allows us to understand to what extent benefits in effectiveness or efficiency stem from our many-objective reformulation and not from our archiving mechanism. It is also worth noticing that WSA won the last SBST tool contest (edition 2016) against other tools, such as JTexPert [50] (evolutionary), T3 [45] (random testing). Finally, DynaMOSA, MOSA, WS and WSA are implemented in the same tool (i.e., EvoSuite) avoiding possible confounding factors [48] due to the usage of different\ntools with different implementation choices (e.g., different libraries to build the control flow graph).\n\nTo address our last research question (RQ$_3$), we selected the following algorithms to compare against DynaMOSA:\n\n- DynaMOSA with Pareto ranking alone (DynaMOSA$_{Pareto}$). This variant of DynaMOSA uses only the Pareto ranking to assign test cases to different non-dominated fronts, without using our preference criterion to further increase the selection pressure (see Algorithm 3). Therefore, this variant corresponds to the traditional NSGA-II algorithm, enriched with the archive strategy and with a dynamic selection of coverage targets. DynaMOSA$_{Pareto}$ is used as a baseline to answer RQ$_{1,1}$.\n\n- DynaMOSA with preference criterion alone (DynaMOSA$_{Pref}$). This variant of DynaMOSA uses our preference criterion without applying the Pareto ranking algorithm to build the other non-dominated fronts. Therefore, at each generation it creates only two fronts: the first containing all best test cases selected according to preference criterion, while all the remaining tests are assigned to the second front (see Algorithm 3). This variant also uses an archive to keep track of test cases as soon as they reach uncovered targets (see Algorithm 2). DynaMOSA$_{Pref}$ is used as a baseline to answer RQ$_{1,2}$.\n\n4.4 Prototype Tool\n\nWe have implemented our many-objective algorithms MOSA and DynaMOSA in a prototype tool that extends the EvoSuite test data generation framework [17], [48]. In particular, we implemented the two many-objective GAs as described in Section 3 within EvoSuite version 1.0.3, downloaded from GitHub on May 15th, 2016. All other details (e.g., encoding schema, genetic operators, etc.) are those implemented in EvoSuite [17], [48]. According to the encoding schema available in EvoSuite for test cases, a test case is a statement sequence $t = \\langle s_1, s_2, \\ldots, s_n \\rangle$ of length $n$. Each statement has a type belonging to one of five kinds of statements: (i) primitive statement, (ii) constructor statement, (iii) field statement, (iv) method statement and (v) assignment statement. Note that the representation has variable size, i.e., the number of statements $n$ in each test can vary during the GA search. Test cases are evolved through the application of selection, crossover and mutation operators. Pairs of test cases (parents) are selected using tournament selection according to their non-dominance ranks. Parents are recombined using the single-point crossover, which generates offsprings by exchanging statements between the two parent test cases. Finally, test cases are mutated using uniform mutation, which randomly removes, changes or inserts statements in a given test case. Since our many-objective algorithm uses Pareto-based ranking, we implemented the tournament selection operator based on dominance ranking and crowding distance as defined in NSGA-II (see Algorithm 2).\n\nThe tool, along with a replication package, is available for download here: http://selab.fbk.eu/kifetew/mosa.html.\n\n4.5 Parameter setting\n\nThere are several parameters that control the performance of the algorithms being evaluated. We adopted the default parameter values used by EvoSuite [17], as it has been empirically shown [2] that the default values, which are also commonly used in the literature, give reasonably acceptable results. Thus, here we only report a few of the important search parameters and their values:\n\n- **Population size**: we use the default population size in EvoSuite, which is set to 50 individuals.\n- **Crossover**: we use the default crossover operator in EvoSuite, which is single-point crossover with crossover probability set to 0.75 [17].\n- **Mutation**: test cases are mutated by adding, deleting, changing statements using uniform mutation with mutation probability equal to $1/\\text{size}$, where size is the number of statements contained in the test case to mutate [17].\n- **Selection**: we use the tournament selection available in EvoSuite, with default tournament size equal to 10.\n- **Search Timeout**: the search stops when the maximum search budget ($\\text{max\\_time}$) is reached or if 100% coverage is achieved before consuming the total allocated time. We set $\\text{max\\_time}$ to five minutes for branch and statement coverage, while we increased the search timeout up to eight minutes for strong mutation coverage. We used a larger budget for strong mutation coverage because of the additional overhead required by this criterion to re-execute each test case against the target mutants.\n\nIt is important to notice that WSA, MOSA and DynaMOSA work at two different granularity levels: WSA evolves test suites while MOSA and DynaMOSA evolve test cases. Therefore, in our many-objective algorithms the number of individuals (i.e., test cases) is always the same (50 test cases). Differently, in WSA each individual is a test suite which usually contains a variable number of test cases. The population is composed of 50 test suites, where each suite can have a variable number of test cases that can be added, deleted or modified at each generation. The crossover operator also works at two different levels of granularity: the single point crossover in MOSA and DynaMOSA creates two offsprings by recombining statements from the two parent test cases; in WSA suite offsprings are generated by recombining test cases composing the two parent suites. For WS and WSA the winner of the tournament selection is the test suite with the smaller (fitter) whole-suite fitness function, while in MOSA and DynaMOSA the winner is the test case with the lowest non-dominance rank or with the largest crowding distance for test cases having the same non-dominance rank.\n\n4.6 Experimental Protocol\n\nFor each class, and for each coverage criterion (statement, branch, mutation), each search strategy (WSA, MOSA, DynaMOSA) is executed and the resulting coverage is recorded. The three coverage criteria are implemented as fitness functions in EvoSuite and are used as guidance for the search algorithms. For strong mutation, EvoSuite uses its own mutation engine that generates mutated versions\nof the code under test, which correspond to the adequacy targets (mutants to kill). In each execution, an overall time limit is imposed so that the run of an algorithm on a class is bounded with respect to time. Hence, the search stops when either full coverage is reached or the total allocated time is elapsed. To allow reliable detection of statistical differences between the strategies, each run is repeated 10 times. Consequently, we performed a total of 3 (search strategies) × 3 (coverage criteria) × 346 (classes) × 10 (repetitions) = 31,140 test generator executions.\n\nTo answer RQ1, RQ2, and RQ3, in terms of effectiveness, we measure the percentage of covered branches, statements, and the percentage of killed mutants:\n\n\\[\n\\text{branch\\_cov} = \\frac{\\text{#covered branches}}{\\text{#total branches to be covered}}\n\\]\n\n\\[\n\\text{statement\\_cov} = \\frac{\\text{#covered statements}}{\\text{#total statements to be covered}}\n\\]\n\n\\[\n\\text{mutation\\_cov} = \\frac{\\text{#covered branches}}{\\text{#total mutants to be killed}}\n\\]\n\nTo measure the aforementioned metrics, we rely on the internal engine of EvoSuite [48], which performs some post-processing by re-executing the test suites obtained at the end of the search process. During post-processing, EvoSuite removes those statements that do not contribute to the final coverage from each test case. It also removes redundant test cases from the final test suite. After this minimisation process, the final test suite is re-executed to collect its final coverage metric. We execute the three selected algorithms separately for each single coverage criterion, thus obtaining the corresponding coverage score after the post-processing.\n\nWe also statistically analyse the results, to check whether the differences between two different algorithms are statistically significant or not. To this aim we used the non-parametric Wilcoxon test [8] with a p-value threshold of 0.05. Significant p-values indicate that the null hypothesis can be rejected in favour of the alternative hypothesis, i.e., that one of the algorithms reaches a significantly higher coverage. Besides testing the null hypothesis, we used the Vargha-Delaney (\\(\\hat{A}_{12}\\)) statistic [54] to measure the effect size, i.e., the magnitude of the difference between the coverage scores achieved by two different algorithms. The Vargha-Delaney (\\(\\hat{A}_{12}\\)) statistic is equal to 0.50 if the two compared algorithms are equivalent, \\(\\hat{A}_{12} \\neq 0.50\\) otherwise. In our case, an \\(\\hat{A}_{12} > 0.50\\) indicates that DynaMOSA reaches a higher coverage than the alternative algorithm, while \\(\\hat{A}_{12} < 0.50\\) indicates that the alternative algorithm is better than DynaMOSA.\n\nTo quantify the efficiency of the compared algorithms, we analyse their capability of reaching higher code coverage at different points in time. While the effectiveness measures the algorithm performance only at the end of the allocated time (i.e., after five or eight minutes), we want also to analyse how algorithms perform during the search. A simple way to perform such a comparison consists of plotting the percentage of branches, statements or mutants killed by each algorithm at predefined time intervals during the search process. Such a convergence graph allows us to compare two or more search algorithms, showing the percentage of covered test goals at the same point in time. To this aim, we collected the coverage achieved after intervals of 20 seconds for each independent run, resulting in 16 coverage points for each run (25 points for strong mutation coverage). To summarise the efficiency of the experimented algorithms using a single scalar value, we computed the overall convergence rate as the area under the curve delimited by the convergence graph. More formally, let \\(P_A = \\{p_0, \\ldots, p_n\\}\\) be the set of points in time considered for a given algorithm \\(A\\). Let \\(cov(p_i)\\) be the percentage of targets covered by \\(A\\) at time \\(p_i\\). Let \\(I\\) be the time elapsed between two consecutive points \\(p_i\\) and \\(p_{i+1}\\). The Area-Under-Curve (AUC) enclosed by these points is computed using the trapezoidal rule:\n\n\\[\nAUC(P_A) = \\frac{\\sum_{i=0}^{h-1} [cov(p_i) + cov(p_{i+1})] \\times I}{2 \\times \\text{TotalRunningTime}} \\times 100\n\\]\n\nSuch metric takes values in \\([0 : 100]\\). Higher AUC values are preferable because they indicate that the algorithm is faster in achieving higher levels of code coverage.\n\nIt is important to remark that we consider efficiency only for classes where we do not observe a significant difference in terms of effectiveness, i.e., branch coverage, statement coverage or mutation coverage. In other words, the efficiency performance metric is considered for comparison only in cases where the algorithms under analysis achieve the same coverage level. This is because focusing only on efficiency without considering effectiveness is not meaningful (low coverage can be easily achieved very efficiently). As done for effectiveness, we measure the statistical significance of differences in efficiency using the non-parametric Wilcoxon test [8] with a \\(p\\)-value threshold of 0.05, and the Vargha-Delaney (\\(\\hat{A}_{12}\\)) statistic [54] to measure the effect size. In this case, significant \\(p\\)-values indicate that one of the two algorithms being compared converges quicker than the other to the final coverage. \\(\\hat{A}_{12} > 0.50\\) indicates that DynaMOSA converged to the final coverage more quickly than the alternative algorithm, while \\(\\hat{A}_{12} < 0.50\\) indicates that DynaMOSA was less efficient than the alternative algorithm, e.g., MOSA).\n\nFor the internal assessment (RQ4), we investigate the effectiveness of DynaMOSA against two of its variants: (i) a first variant, namely DynaMOSA\\_Rank, which uses only the Pareto-based dominance ranking; and (ii) a second variant, namely DynaMOSA\\_Pref, which uses our preference criterion alone. For DynaMOSA and for both DynaMOSA variants we use an archive to store test cases as soon as they cover any yet uncovered target. Therefore, any difference in efficiency can be attributed only to the different ranking strategies used by DynaMOSA or by its variants. To save space, the comparison is reported only for branch coverage, since consistent results are obtained for statement and strong mutation coverage.\n\nGiven the large number of classes considered in the experiments, we cannot report all \\(p\\)-values and Vargha-Delaney \\(\\hat{A}_{12}\\) scores measured for each class. Therefore, for each project in our sample we report the number of times (number of classes) the comparison is statistically significant at level 0.05, as well as the corresponding number of times (percentage) the Vargha-Delaney (\\(\\hat{A}_{12}\\)) statistic is greater or lower than 0.50. Results at class level are available in our replication package for the interested readers.\n5 Results\n\nThis section discusses the results of our study with the aim of answering the research questions formulated in Section 4. In the following, when comparing two different algorithms we will refer to difference in code coverage as the arithmetic difference between the two corresponding percentage coverage scores.\n\n5.1 RQ1: How does DynaMOSA perform compared to alternative approaches on branch coverage?\n\nTable 2 summarises the results achieved by WSA, MOSA, and DynaMOSA for branch coverage. In particular, it reports the percentage of classes in each project where the effect size (\\( \\tilde{A}_{12} \\)) is statistically greater/lowerr than 0.50. In the following, we will refer to 335 classes only since in 11 classes in our sample EvoSuite crashed for some internal errors.\n\nFrom Table 2 we can observe that DynaMOSA is significantly better than WSA in 93 classes out of 335, corresponding to 28% of classes in our sample. The improvement achieved in branch coverage using DynaMOSA, for classes where statistically significant differences were observed, ranges between 1% and 67%, with an average improvement of 8%. On the other hand, we observe that WSA is significantly better than DynaMOSA in 10 classes only, while no statistically significant difference is observed in the remaining 232 cases. Looking at the results at project level, we find that in 43% of the projects DynaMOSA achieved higher branch coverage than WSA on at least one class in the project.\n\nFor example, if we consider class ControlFlowAnalysis extracted from the compiler project, we can observe that WSA covers 184 branches (on average) while DynaMOSA covers 287 (+25%) branches (on average) using the same search budget. For larger classes, differences are even larger. For example, for class JavaParserTokenManager extracted from the project jmcaw, WSA covers 994 branches (on average) against 1,157 (+10%) branches covered (on average) by DynaMOSA using the same search budget. Project jmcaw is particularly interesting since it contains the largest classes in our sample (two of the five selected classes have more than 1,500 branches). This project DynaMOSA is significantly better than WSA in 75% of the selected classes with \\( \\tilde{A}_{12} = 1 \\) in all cases.\n\nOnly in a few cases WSA is significantly better than DynaMOSA (10 classes out of 335), with an average difference, over classes with significant differences, of 3% in terms of branch coverage. The class with the highest difference is JSJshop extracted from the project shop. For this class, WSA is able to cover 93 branches (on average) against 46 branches covered by DynaMOSA. After manual investigation, we discovered that such a negative result is due to test cases discarded because of the usage of test case length (size) as secondary selection criterion in our preference criterion. In order to verify this conjecture, we ran DynaMOSA with the test size as secondary criterion disabled. The obtained results show that DynaMOSA covers on average 95 branches (+1.75%), with an effect size equal to 0.83 and \\( p \\)-value = 0.01. Therefore, we conclude that test case size as secondary preference criterion can have sometimes negative effects on the final coverage. Thus, an adaptive version of the secondary preference criterion (e.g., disabling size when there is no improvement of branch\n\n### Table 2\n\n<table>\n<thead>\n<tr>\n<th>Project Name</th>\n<th>Classes</th>\n<th>Branch Coverage</th>\n<th>WSA MOSA</th>\n<th>DynaMOSA MOSA</th>\n<th>DynaMOSA vs WSA</th>\n<th>DynaMOSA vs MOSA</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n</tr>\n<tr>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n</tr>\n<tr>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n</tr>\n<tr>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n</tr>\n<tr>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n</tr>\n</tbody>\n</table>\n\n- \\( \\tilde{A}_{12} \\) is the effect size.\n- \\( p \\)-value is the significance level.\n\nNo cases DynaMOSA significantly worse than WSA -- 12(3.6%) No cases DynaMOSA significantly better than WSA -- 44(13.2%) No cases DynaMOSA significantly worse than MOSA -- 11(3.3%)\ndistance for some generations) might be beneficial.\n\nFor the 232 classes on which there is no statistically significant difference in branch coverage between WSA and DynaMOSA, we compare the two search strategies along the efficiency metric. The results of this comparison are summarised in Table 3. The table reports the median AUC metric for WSA and DynaMOSA as well as the results of the effect size (\\(\\hat{A}_{12}\\)) aggregated by project. From the comparison, we observe that in 27 classes out of 232, DynaMOSA has a statistically significantly higher AUC metric compared to WSA, which means that the former would reach higher branch coverage if given a shorter search time. The average improvement for the AUC metric is 3%. The minimum improvement, 0.1%, occurs for class Title (from project wikipedia), and the maximum, 17%, for DynamicSelectModel (from project wheeletoolbox). On the other hand, WSA turned out to be more efficient than DynaMOSA in 13 classes out of 232. However, for these classes the differences in terms of AUC scores are very small, being <0.1% on average.\n\nLet us now consider the comparison between DynaMOSA and MOSA. Results for branch coverage are reported in Table 2. We can observe that in the majority of the cases there is no statistically significant difference between the two many-objective algorithms according to the Wilcoxon test. In total, in 64 classes out of 335 (19%) DynaMOSA achieved significantly higher branch coverage, while in only one class (<1%) MOSA turned out to be better than DynaMOSA. Looking at the magnitude of the differences, we notice that in those cases where DynaMOSA achieved higher branch coverage, the improvements range between 1% and 71%, with an average increase of 7%. The largest improvement is obtained for JTablePanel (jtable project), for which DynaMOSA covers 21 branches (91%) while MOSA covers only 3 branches (13%). For the single class where MOSA outperformed DynaMOSA, namely ServerGameModel from left-bomberman, the difference in terms of branch coverage is 4%. We observe that this class is very peculiar: it contains 128 branches and it is very expensive in execution time. Indeed, both DynaMOSA and MOSA could only execute less than 5 generations of their evolutionary algorithm (on average) within the five minutes of search budget.\n\nIn terms of efficiency, DynaMOSA and MOSA are statistically equivalent in the majority of those classes where there is no statistically significant difference on branch coverage. Indeed, as reported in Table 4 in only 12 classes out of 273 DynaMOSA yielded a statistically significantly higher AUC metric as compared to MOSA. More specifically, we observe that on these classes DynaMOSA produces +5% of branch coverage on average when considering a search budget lower than five minutes, which is the total search time set for branch coverage. The minimum improvement of 0.2% is yielded for class Conversion (from the apache commons library), and the maximum of 29% is achieved for ExploitAssigns (from project compiler). On the other hand, MOSA turned out to be more efficient than DynaMOSA in only one class, namely TimePeriodValues from free-chart, where the difference in terms of AUC is equal to just 0.21%.\n\nFigure 4 shows an example of (average) branch coverage achieved over time by MOSA, DynaMOSA and WSA on SortingTableModel, a class for which we did not find any statistically significant difference in terms of efficiency or effectiveness for the three experimented approaches. From Figure 4, we can observe that in the first 20 seconds DynaMOSA is particularly efficient compared to the other alternatives. In less than 10 seconds, it reaches 96% of branch coverage. MOSA required almost 30 seconds to reach the same branch coverage, while WSA had the worst branch coverage scores within this initial time window. This result is very unexpected considering that WSA benefits from a larger population size (50 test suites with more than one test case each) with respect to DynaMOSA and MOSA (50 initial test cases in total). After consuming 60 seconds, all the three approaches reach the maximum branch coverage, which is 98% for this class. As a consequence, we did not detect any statistically significant difference in the final efficiency among DynaMOSA, MOSA and WS, but a substantial difference can be observed in the first 20 seconds (i.e., before we collect the first coverage point when computing the AUC.\n\n### Table 3\n\n<table>\n<thead>\n<tr>\n<th>Project Name</th>\n<th>Classes</th>\n<th>Efficiency MOSA</th>\n<th>AUC Statistics</th>\n<th>(\\hat{A}_{12})</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>checkstyle</td>\n<td>4</td>\n<td>82.55</td>\n<td>71.37</td>\n<td>70.52</td>\n</tr>\n<tr>\n<td>classviewer</td>\n<td>3</td>\n<td>58.98</td>\n<td>57.33</td>\n<td>33.33</td>\n</tr>\n<tr>\n<td>commons-lang</td>\n<td>10</td>\n<td>92.19</td>\n<td>92.34</td>\n<td>20.00</td>\n</tr>\n<tr>\n<td>commons-math</td>\n<td>11</td>\n<td>76.69</td>\n<td>75.63</td>\n<td>9.09</td>\n</tr>\n<tr>\n<td>dischat</td>\n<td>2</td>\n<td>29.85</td>\n<td>29.01</td>\n<td>50.00</td>\n</tr>\n<tr>\n<td>dvdb-homevideo</td>\n<td>3</td>\n<td>11.13</td>\n<td>11.15</td>\n<td>33.33</td>\n</tr>\n<tr>\n<td>firebird</td>\n<td>2</td>\n<td>93.49</td>\n<td>93.52</td>\n<td>50.00</td>\n</tr>\n<tr>\n<td>ggrep</td>\n<td>1</td>\n<td>55.42</td>\n<td>55.51</td>\n<td>100.00</td>\n</tr>\n<tr>\n<td>guava</td>\n<td>6</td>\n<td>72.78</td>\n<td>71.77</td>\n<td>16.67</td>\n</tr>\n<tr>\n<td>heal</td>\n<td>2</td>\n<td>92.13</td>\n<td>91.16</td>\n<td>50.00</td>\n</tr>\n<tr>\n<td>hip bomberman</td>\n<td>1</td>\n<td>96.03</td>\n<td>95.54</td>\n<td>100.00</td>\n</tr>\n<tr>\n<td>javabuildback</td>\n<td>2</td>\n<td>72.81</td>\n<td>69.78</td>\n<td>16.67</td>\n</tr>\n<tr>\n<td>javanil</td>\n<td>6</td>\n<td>81.24</td>\n<td>81.24</td>\n<td>16.67</td>\n</tr>\n<tr>\n<td>jdbcl</td>\n<td>1</td>\n<td>97.72</td>\n<td>97.50</td>\n<td>100.00</td>\n</tr>\n<tr>\n<td>jdom</td>\n<td>4</td>\n<td>82.37</td>\n<td>82.29</td>\n<td>25.00</td>\n</tr>\n<tr>\n<td>jfree-chart</td>\n<td>5</td>\n<td>75.31</td>\n<td>74.50</td>\n<td>40.00</td>\n</tr>\n<tr>\n<td>jhardballmoves</td>\n<td>2</td>\n<td>21.15</td>\n<td>21.25</td>\n<td>-</td>\n</tr>\n<tr>\n<td>joda</td>\n<td>8</td>\n<td>80.11</td>\n<td>79.50</td>\n<td>37.50</td>\n</tr>\n<tr>\n<td>jsecurity</td>\n<td>2</td>\n<td>69.31</td>\n<td>68.80</td>\n<td>50.00</td>\n</tr>\n<tr>\n<td>joss</td>\n<td>2</td>\n<td>69.19</td>\n<td>70.83</td>\n<td>-</td>\n</tr>\n<tr>\n<td>newsgribber</td>\n<td>2</td>\n<td>22.21</td>\n<td>22.35</td>\n<td>50.00</td>\n</tr>\n<tr>\n<td>noom</td>\n<td>2</td>\n<td>88.81</td>\n<td>87.47</td>\n<td>50.00</td>\n</tr>\n<tr>\n<td>objectexplorer</td>\n<td>2</td>\n<td>50.96</td>\n<td>48.74</td>\n<td>50.00</td>\n</tr>\n<tr>\n<td>testplayer</td>\n<td>2</td>\n<td>78.00</td>\n<td>85.89</td>\n<td>-</td>\n</tr>\n<tr>\n<td>tweeterid</td>\n<td>5</td>\n<td>98.21</td>\n<td>98.36</td>\n<td>20.00</td>\n</tr>\n<tr>\n<td>weka</td>\n<td>3</td>\n<td>62.82</td>\n<td>64.01</td>\n<td>33.33</td>\n</tr>\n<tr>\n<td>wheelwebtool</td>\n<td>2</td>\n<td>97.27</td>\n<td>98.46</td>\n<td>100.00</td>\n</tr>\n<tr>\n<td>wikipedia</td>\n<td>1</td>\n<td>94.76</td>\n<td>94.74</td>\n<td>100.00</td>\n</tr>\n<tr>\n<td>xisenele</td>\n<td>1</td>\n<td>68.15</td>\n<td>67.46</td>\n<td>100.00</td>\n</tr>\n</tbody>\n</table>\n\nMean: 74.84 ± 27.58\n\nNo cases DynaMOSA significantly better than WSA: 22 (11.79%)\nNo cases DynaMOSA significantly worse than WSA: 13 (5.65%)\n\n### Table 4\n\n<table>\n<thead>\n<tr>\n<th>Project Name</th>\n<th>N. Classes</th>\n<th>Efficiency MOSA</th>\n<th>AUC Statistics</th>\n<th>(\\hat{A}_{12})</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>bill</td>\n<td>1</td>\n<td>19.91</td>\n<td>18.72</td>\n<td>10.00</td>\n</tr>\n<tr>\n<td>commons-lang</td>\n<td>10</td>\n<td>95.18</td>\n<td>96.05</td>\n<td>20.00</td>\n</tr>\n<tr>\n<td>commons-math</td>\n<td>13</td>\n<td>66.51</td>\n<td>65.77</td>\n<td>7.69</td>\n</tr>\n<tr>\n<td>compiler</td>\n<td>5</td>\n<td>32.24</td>\n<td>28.62</td>\n<td>20.00</td>\n</tr>\n<tr>\n<td>diffi</td>\n<td>2</td>\n<td>93.54</td>\n<td>92.52</td>\n<td>50.00</td>\n</tr>\n<tr>\n<td>ggrep</td>\n<td>1</td>\n<td>55.42</td>\n<td>55.51</td>\n<td>100.00</td>\n</tr>\n<tr>\n<td>geo-google</td>\n<td>2</td>\n<td>91.61</td>\n<td>89.63</td>\n<td>50.00</td>\n</tr>\n<tr>\n<td>free-chart</td>\n<td>8</td>\n<td>87.76</td>\n<td>87.20</td>\n<td>-</td>\n</tr>\n<tr>\n<td>jprof</td>\n<td>4</td>\n<td>73.24</td>\n<td>72.27</td>\n<td>25.00</td>\n</tr>\n<tr>\n<td>quickserver</td>\n<td>4</td>\n<td>74.82</td>\n<td>70.46</td>\n<td>33.33</td>\n</tr>\n<tr>\n<td>twitterid</td>\n<td>6</td>\n<td>91.25</td>\n<td>91.22</td>\n<td>16.67</td>\n</tr>\n<tr>\n<td>wheelwebtool</td>\n<td>3</td>\n<td>82.88</td>\n<td>79.23</td>\n<td>33.33</td>\n</tr>\n</tbody>\n</table>\n\nMean: 74.84 ± 27.58\n\nNo cases DynaMOSA significantly better than MOSA: 12 (4.51%)\nNo cases DynaMOSA significantly worse than MOSA: 1 (0.38%)\nmetric). Hence, the results in Figure 4 show that when a very limited search budget is given to the search (<20-30s), DynaMOASA reaches higher coverage much more quickly than the other two alternatives. We obtained consistent results for the other classes in our study for which we did not find any significant difference in the final effectiveness and efficiency: DynaMOASA has always the steepest coverage increase in the initial time window.\n\nIn summary, we can conclude that DynaMOASA achieves higher or equal branch coverage as compared to both WSA and MOSA. Moreover, DynaMOASA converges to such coverage more quickly especially when limited time is given to the search. Finally, our many-objective reformulation provides further benefits to branch coverage as compared to the usage of the archive strategy, since it outperforms WSA, which extends WS with the archive strategy.\n\n5.2 RQ2: How does DynaMOASA perform compared to alternative approaches on statement coverage?\n\nTable 5 reports the statement coverage achieved by WS, MOSA, and DynaMOASA for the classes in our experiment, grouped by project. Table 5 also reports the percentage of classes in each project where the effect size ($\\hat{A}_{12}$) is statistically greater or lower than 0.50. Since in 7 classes in our sample EvoSuite crashed for some internal errors, in the following we will refer to 339 classes only for which EvoSuite could generate tests.\n\nFor statement coverage, we can notice that DynaMOASA is significantly better than WS on 173 classes out of 339 (51%), while WS is significantly better in only 5 cases (< 2%). In the remaining 160 classes, no statistically significant difference is observed according to the Wilcoxon test. At project level, we find that in 65% of the projects DynaMOASA achieves significantly higher coverage than WS on at least one class in the project. Overall, the usage of DynaMOASA leads to an increase in statement coverage equal to 11% on average, over classes where significant differences were observed. The largest improvement is obtained for class TwitterImpl selected from project twitter4j, where\n\nTable 5 Mean statement coverage achieved for each project. We report the percentage of classes with $\\hat{A}_{12} < 0.50$ or $\\hat{A}_{12} > 0.50$ where $p$-value $\\leq 0.05$\n\n<table>\n<thead>\n<tr>\n<th>Project Name</th>\n<th>Classes</th>\n<th>Statement Coverage</th>\n<th>% Better</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>WS</td>\n<td>MOSA</td>\n<td>DynaMOASA</td>\n<td>MOSA Better</td>\n</tr>\n<tr>\n<td>Project 1</td>\n<td>339</td>\n<td>173</td>\n<td>51%</td>\n</tr>\n<tr>\n<td>Project 2</td>\n<td>339</td>\n<td>173</td>\n<td>51%</td>\n</tr>\n<tr>\n<td>Project 3</td>\n<td>339</td>\n<td>173</td>\n<td>51%</td>\n</tr>\n</tbody>\n</table>\n\n...\n<table>\n<thead>\n<tr>\n<th>Project Name</th>\n<th>N. Classes</th>\n<th>Efficiency</th>\n<th>A12 $\\neq 0.50$</th>\n<th>Efficiency</th>\n<th>A12 $\\neq 0.50$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>apr</td>\n<td>2</td>\n<td>54.92</td>\n<td>34.34</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>apbsmem</td>\n<td>2</td>\n<td>71.41</td>\n<td>71.40</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>at-noboot2-j</td>\n<td>1</td>\n<td>74.89</td>\n<td>73.38</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>bagpipes</td>\n<td>2</td>\n<td>84.54</td>\n<td>83.85</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>calendarcount</td>\n<td>1</td>\n<td>100.00</td>\n<td>98.95</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>checkstyle</td>\n<td>2</td>\n<td>94.57</td>\n<td>92.57</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>commons-lang</td>\n<td>2</td>\n<td>96.24</td>\n<td>96.22</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>commons-math</td>\n<td>12</td>\n<td>76.93</td>\n<td>75.37</td>\n<td>58.33</td>\n<td></td>\n</tr>\n<tr>\n<td>compiler</td>\n<td>3</td>\n<td>34.15</td>\n<td>29.40</td>\n<td>94.57</td>\n<td>94.57</td>\n</tr>\n<tr>\n<td>dvl-homevideo</td>\n<td>2</td>\n<td>19.19</td>\n<td>20.20</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>estj</td>\n<td>2</td>\n<td>96.32</td>\n<td>95.99</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>fixsuite</td>\n<td>1</td>\n<td>50.04</td>\n<td>49.75</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>gapgrip</td>\n<td>1</td>\n<td>38.80</td>\n<td>36.51</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>guava</td>\n<td>7</td>\n<td>87.89</td>\n<td>88.54</td>\n<td>14.29</td>\n<td>12.49</td>\n</tr>\n<tr>\n<td>hft-bomberman</td>\n<td>1</td>\n<td>91.77</td>\n<td>74.36</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>ifs-framework</td>\n<td>1</td>\n<td>69.17</td>\n<td>67.55</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>javaml</td>\n<td>7</td>\n<td>88.33</td>\n<td>88.24</td>\n<td>71.43</td>\n<td></td>\n</tr>\n<tr>\n<td>jd</td>\n<td>3</td>\n<td>98.97</td>\n<td>98.41</td>\n<td>66.67</td>\n<td></td>\n</tr>\n<tr>\n<td>jhandballmoves</td>\n<td>2</td>\n<td>23.92</td>\n<td>23.74</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>jigger</td>\n<td>2</td>\n<td>91.24</td>\n<td>91.31</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>jmca</td>\n<td>1</td>\n<td>13.16</td>\n<td>11.97</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>jsecurity</td>\n<td>1</td>\n<td>67.15</td>\n<td>67.12</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>lagoon</td>\n<td>1</td>\n<td>23.83</td>\n<td>23.54</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>liferay</td>\n<td>1</td>\n<td>100.00</td>\n<td>99.88</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>litch</td>\n<td>1</td>\n<td>100.00</td>\n<td>95.79</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>lotus</td>\n<td>2</td>\n<td>86.83</td>\n<td>88.11</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>netweaver</td>\n<td>2</td>\n<td>96.43</td>\n<td>95.74</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>nutanetcore</td>\n<td>2</td>\n<td>50.16</td>\n<td>51.73</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>objectexplorer</td>\n<td>1</td>\n<td>52.84</td>\n<td>49.25</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>quickserver</td>\n<td>2</td>\n<td>97.49</td>\n<td>96.92</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>scribe</td>\n<td>6</td>\n<td>99.64</td>\n<td>99.69</td>\n<td>16.67</td>\n<td></td>\n</tr>\n<tr>\n<td>shop</td>\n<td>4</td>\n<td>54.74</td>\n<td>52.70</td>\n<td>50.00</td>\n<td></td>\n</tr>\n<tr>\n<td>squirrel-sql</td>\n<td>2</td>\n<td>67.04</td>\n<td>63.11</td>\n<td>100.00</td>\n<td></td>\n</tr>\n<tr>\n<td>summia</td>\n<td>3</td>\n<td>33.87</td>\n<td>32.08</td>\n<td>33.33</td>\n<td></td>\n</tr>\n<tr>\n<td>trove</td>\n<td>4</td>\n<td>84.75</td>\n<td>83.80</td>\n<td>75.00</td>\n<td></td>\n</tr>\n<tr>\n<td>wikipedia</td>\n<td>2</td>\n<td>89.16</td>\n<td>88.67</td>\n<td>50.00</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nMean: $79.09$, $89.33$\n\nNo. cases DynaMOSA significantly better than WS: 40 (12.5%)\nNo. cases DynaMOSA significantly worse than WS: 46 (15.97%)\nWSA turned out to be statistically significantly better on 22 that DynaMOSA can achieve high mutation scores even on WSA kills only one mutant on average. This result shows total number strong mutants to kill is equal to 21. On this 0.30% and 69% respectively. The class with largest improve- c - - - - dcparseargs 1 - - - - jtailgui 2 25.91 27.23 28.30 41.09 41.58 41.58 59.73 70.98 72.23 58.63 56.12 56.83 20.00 - 20.00 20.08 - 20.08 30.35 29.76 31.21 42.86 4.76 52.38 4.76 commons-primitives 1 - - 50.00 - - nutzenportfolio 2 - - 50.00 - - openjms 2 21.43 22.86 22.86 100.00 - - - xmlenc 2 100.00 - - - - jdom 5 78.85 76.92 76.92 43.75 43.75 43.75 - - - - imsmart 1 - - 100.00 - - javabullboard 2 14.90 15.81 16.51 50.00 - - 50.00 jdom 5 22.36 21.68 21.68 78.85 76.92 76.92 43.75 43.75 43.75 - - - - celwars2009 2 0.61 0.61 0.61 17.79 20.61 27.39 50.00 - - - - battlecry 2 45.08 40.08 45.63 14.29 14.29 14.29 - - - - tullibee 2 3.38 0.00 0.00 0.00 0.00 0.00 - - - - javathena 4 22.02 22.50 25.50 7.69 5.13 5.13 46.43 46.43 46.43 - - - - summa 4 100.00 - 50.00 - - - - checkstyle 5 10.74 8.74 7.10 68.07 78.40 70.58 - - - - lavalamp 1 24.15 24.07 24.26 21.43 22.86 22.86 0.00 0.00 0.00 21.05 21.38 21.71 - - - - jhandballmoves 2 17.17 19.95 19.69 18.81 16.77 14.06 46.15 - 84.62 - - - - jopenchart 2 88.52 85.25 88.52 8.48 7.88 5.47 16.17 14.28 15.19 100.00 - - - - weka 3 10.79 10.56 9.28 10.79 10.56 9.28 - - - - commons-primitives 1 - - 50.00 - - commons-lang 14 35.02 29.62 37.62 42.20 39.70 42.05 35.54 27.65 27.21 22.98 25.75 34.68 Table 8 Mean strong mutation coverage achieved for each project. Table 8 Mean strong mutation coverage achieved for each project. TABLE 8 Mean strong mutation coverage achieved for each project. 5.3 RQ3: How does DynaMOSA perform compared to alternative approaches on strong mutation coverage? Results on the strong mutation coverage are reported in Table 8, grouped by software projects. For 34 classes, we could not obtain the mutation coverage score because of internal EvoSuite crashes. Therefore, in the following we refer to 312 classes only. Results show that DynaMOSA statistically significantly outperforms WSA in 85 out of 312 classes (27%), which corresponds to 41% of the projects in our study. The average improvement, over classes where significant differences were observed, in mutation score achieved by DynaMOSA is 11%, with minimum and maximum improvement of 0.30% and 69% respectively. The class with largest improve- ment is TableMeta, from project schemaspy, for which the total number strong mutants to kill is equal to 21. On this class, DynaMOSA kills on average 15 mutants (71%) while WSA kills only one mutant on average. This result shows that DynaMOSA can achieve high mutation scores even on small classes (i.e., classes with a small number of mutants). WSA turned out to be statistically significantly better on 22 classes (7%), corresponding to the 16% of the projects in our sample. However, in this case the average difference in strong mutation coverage is just 5%. For the remaining 205 classes in our study, no statistically significant difference was found for mutation coverage. For these classes, we compared DynaMOSA and WSA in\nterms of efficiency, using the AUC metric. The results of this comparison are summarised in Table 9, grouped by project. We observe that in 64 classes (31%) DynaMOSA reaches a statistically significant higher AUC score than WSA, with an average improvement of 8%, and minimum improvement of 1% for Region (templateit project) and maximum of 78% for SimpleKeyListerHelper (caloriount project). Vice versa, WSA is better than DynaMOSA on 11 classes (5%), with an average AUC difference of 6%. It is important to notice that on these 11 cases, the difference in efficiency is mainly due to the test prioritisation performed by WSA: WSA prioritises the test cases in a test suite according to their execution time before re-running them on each infected mutant. Hence, mutants that are killed by quicker tests in a test suite do not need to be evaluated again on the other more expensive tests in the same test suite. This strategy can be particularly relevant in the case of the strong mutation coverage, as every mutant requires the re-execution of the test suite. Differently, in DynaMOSA (and MOSA) all test cases (offsprings) are evaluated, without applying any prioritisation strategy. Hence, there is room for improvement of DynaMOSA when using it with the strong mutation coverage. In fact, we could also prioritise the offspring test cases by execution time.\n\nLet us now consider the comparison between DynaMOSA and MOSA. Results are similar to those obtained for branch and statement coverage. As reported in Table 8, DynaMOSA achieved significantly higher mutation score in 82 classes (26%) against 6 classes (2%) on which MOSA yields statistically significantly higher scores. In those classes where DynaMOSA turned out to be better, the improvements in terms of mutation score range between 0.51% and 79%, being 12% on average. In those few cases (2%) where MOSA yields higher mutation score, the average increase is 7%, with minimum of 1% for class BrentOptimizer (from apache commons math) and maximum of 23% for class Verse (from project biblesstudy).\n\nThe largest improvement achieved by DynaMOSA is 79%, and it is obtained for class AuswertungGrafik from project nutzenportfolio, whose total number of mutants is 131. On this class, DynaMOSA is able to kill 103 mutants compared to 34 mutants killed by MOSA on average. The explanation for such large difference is due to (i) the number of objectives evaluated at each generation, and (ii) the heavy evaluation cost of each mutant for such a class. Indeed, with MOSA all 131 mutants are evaluated since the first generation, even if not all mutants are within control of covered branches. Differently, DynaMOSA exploits the control dependencies between test targets and selects less mutants by execution time.\n\nIn terms of efficiency, DynaMOSA and MOSA are statistically equivalent in the majority of the classes where there is no statistically significant difference in the number of killed mutants. Indeed, as reported in Table 10, in only 18 classes out of 224 DynaMOSA yielded a significantly higher AUC score in 82 classes (26%) against 6 classes (2%) on which MOSA yields statistically significantly higher scores. In those classes where DynaMOSA turned out to be better, the improvements in terms of mutation score range between 0.51% and 79%, being 12% on average. In those few cases (2%) where MOSA yields higher mutation score, the average increase is 7%, with minimum of 1% for class BrentOptimizer (from apache commons math) and maximum of 23% for class Verse (from project biblesstudy).\nIn summary, DynaMOSA kills more or the same number of mutants as compared to WSA and MOSA. Moreover, for classes with no improvement in mutation score DynaMOSA converges more quickly.\n\n5.4 RQ4: How do preference criterion and Pareto dominance affect the effectiveness of DynaMOSA?\n\nOur approach is designed to improve the selection pressure by giving higher priority to the test cases that are close to reach uncovered targets. Specifically, selection is based on a new sorting algorithm (Algorithm 3), which combines two key ingredients: (i) traditional Pareto-based ranking and (ii) our novel preference criterion. Table 11 reports the results achieved on branch coverage by three variants of DynaMOSA: (i) a first variant, namely DynaMOSAFull, which uses only Pareto-based ranking; (ii) a second variant, namely DynaMOSAPref, which uses only our preference criterion; and (iii) full DynaMOSA, which combines both Pareto-based ranking and preference criterion (DynaMOSAfull). In all three variants, we use an archive to keep track of test cases as soon as they reach uncovered targets (see Algorithm 5). Therefore, any difference in the final branch coverage can be interpreted as the effect of the different selection strategies used by the DynaMOSA variants.\n\nFrom the comparison, we observe that DynaMOSAfull outperforms DynaMOSA\\text{Full} in 172 classes out of 335 (51%) with an average difference in branch coverage of 14% and maximum difference of 91% (for class TableMeta from the project schemaply). In 46% of the projects there is at least one class for which DynaMOSA\\text{Full} outperforms DynaMOSA\\text{Rank}. Since DynaMOSA\\text{Rank} uses only Pareto-based ranking, the achieved results show that the usage of the preference criterion has a strong impact on the effectiveness of our many-objective algorithm.\n\nThere are only four classes in which DynaMOSA\\text{Rank} has significantly higher branch coverage scores, namely ScopeUtils from checkstyle, CacheBuilderSpec from guava, InternalChatFrame from dsachat, and ReflectionSearch from beamline. However, for these classes we note that the difference is small (<5% on average) especially if compared to the average improvement that can be obtained by using our preference criterion, i.e., by using DynaMOSA\\text{Full}. The explanation for these few exceptional classes is that the statistically significant differences are due to the usage of test case length (size) as secondary selection criterion in our preference criterion. Indeed, in DynaMOSA\\text{Full} by disabling the test size criterion, the average branch coverage (over 10 independent runs) for ReflectionSearch is 73.20%, becoming statistically indistinguishable from DynaMOSA\\text{Rank} (p-value = 0.92 and \\( \\hat{\\alpha}_2 = 0.52 \\)).\n\nThe results of the comparison between Dyna-MOSA\\text{Full} and DynaMOSA\\text{Pref} are mixed: in the majority of classes (302 out of 335 classes) there is no statistically significant difference between these two variants of DynaMOSA. This means that the preference criterion is the most critical ingredient in our many-objective algorithm, since it achieves the same branch coverage (and sometimes higher coverage) even if it is not combined with Pareto-based ranking. In 39 classes (12%) DynaMOSA\\text{Full} outperforms DynaMOSA\\text{Pref}, with an average difference in branch coverage of 14% and maximum difference of 85% for class SchurTransformer from the apache commons math. In the remaining 14 classes (4%), the usage of preference criterion alone (DynaMOSA\\text{Pref}) leads to statistically higher branch coverage if compared to its combination with the traditional non-dominance ranking (DynaMOSA\\text{Full}).\n\nWe notice that DynaMOSA\\text{Pref} is significantly better for extremely large classes, i.e., classes with hundreds or thousands of branches. Vice versa, DynaMOSA\\text{Full} achieves better coverage for relatively small/medium size classes. In fact, the mean size of classes for which DynaMOSA\\text{Pref}\nturned out to be significantly better than DynaMOSAFull is 247 branches. On the other hand, the mean size of classes for which DynaMOSAFull outperforms DynaMOSARef is 177.\n\nThe explanation for such findings could be that Pareto-based ranking computes the non-dominance ranks using the Fast-Non-Dominated-Sort algorithm, whose computational complexity is $O(M^2 \\times N)$, where $M$ is the population size and $N$ is the number of uncovered test targets. When the number of targets becomes too large (the order of thousands), DynaMOSAFull spends too much time in computing the non-dominance ranks rather than in evolving the test cases. Hence, potentially better coverage scores may be achieved by developing an adaptive strategy which enables or disables Pareto-based ranking based on the number of uncovered branches considered as objectives.\n\nIn summary, our preference criterion is a critical component of DynaMOSA, necessary to improve the selective pressure when dealing with many objectives (RQ4). Indeed, Pareto-based ranking (even with the archive) is not sufficient to deal with hundreds of objectives, as is the case of test case generation.\n\n### 6 Additional Analyses\n\nIn this section, we analyse qualitatively some examples and discuss co-factors that could have played an important role in the performance of the experimented algorithms. Even though these analyses are not directly related to the research questions of the study described in Sections 4-5, they helped us understand the conditions in which DynaMOSA outperforms the alternative algorithms.\n\n#### 6.1 Qualitative analysis\n\nFigure 6 shows an example of a branch covered by DynaMOSA but not by WSA for the class MatrixUtils extracted from the Apache commons math library, i.e., the false branch of line 137 of method createRealMatrix. The related branch condition checks the size of the input matrix data and returns an object of class Array2DRowRealMatrix or of class BlockRealMatrix depending on the outcome of the branch condition. In particular, below $2^{12}$ elements (i.e., 4096 elements or $64 \\times 64$ for a square matrix) an Array2DRowRealMatrix instance is built since it can store up to 32kB array. Above this threshold a BlockRealMatrix instance is built. At the end of the search process, the final test suite obtained by WSA has a whole suite fitness $f = 21.50$. Within the final test suite, the test case closest to cover the considered target is shown in Figure 6-b. It is a test case with branch distance $d = 0.9998$, for the branch under analysis.\n\nThis test case executes method createRealMatrix giving it as input an array with $1 \\times 6 = 6$ elements (<< 4096). However, by analysing all the test cases generated by WSA during the search process we found that TC1 is not the closest test case to the false branch of line 137 across all generations. For example, at some generation WSA generated a test case TC2 with a lower branch distance $d = 0.9997$ that is reported in Figure 6-c. As we can see, TC2 also executes the lines 131-136, hence being equivalent to TC1 in terms of coverage. However, in TC1 the method createRealMatrix is called by using as input an array with $50 \\times 50 = 2500$ elements, thus, such a test case is much closer to satisfy the condition $\\text{data.length} * \\text{data[0].length} > 4096$ that lead to cover the false branch of line 137. However, TC2 was generated within a candidate test suite with a poor whole suite fitness $f = 98.37$, which happened to be the worst candidate test suite in its generation. Thus, in the next generation this test suite is not selected to form the next generation and the promising test case TC2 is lost. By manual investigation we verified that this scenario is quite common, especially for classes with a large number of targets to cover. As we can see from this example, the whole suite fitness is really useful in increasing the global number of covered goals, but when aggregating the branch distances of uncovered branches, the individual contribution of single promising test cases may remain unexploited.\n\nUnlike WSA, DynaMOSA selects the best test case (instead of the best test suite) within the current population for each uncovered branch. Therefore, in a similar scenario it would place TC2 in the first non-dominated front $F_0$ according to the proposed preference criterion. Thus, generation by generation test case TC2 will remain in front $F_0$ until it is replaced by a new test case that is closer to covering the target branch. Over few generations, DynaMOSA covers the false branch of line 137, while WSA does not, even after 10 minutes of search budget.\n\n#### 6.2 Co-factors analysis for DynaMOSA vs. WSA\n\nFigure 7 plots the relation among McCabe’s cyclomatic complexity, number of coverage targets, and Vargha-Delaney $\\bar{A}_{12}$ scores achieved for those classes with statistically significant differences between DynaMOSA and WSA. Basically,\nthe figure reports three $x$-$y$ scatter plots with circles to express a third dimension: each circle represents a class in our study, whose $x$ coordinate is the $\\hat{A}_{12}$ score achieved when comparing DynaMOSA against WSA, the $y$ coordinate is its McCabe’s cyclomatic complexity score, while the radius of the circle is proportional to the number of coverage targets. We compute the McCabe’s cyclomatic complexity score of each class as the sum of the complexity scores of its methods. Each coverage criterion —i.e., branch, statement and strong mutation — is reported in a different graph.\n\nFor branch coverage (Fig. 7-a), classes with $\\hat{A}_{12}<0.50$ (i.e., with WSA outperforming DynaMOSA) have low cyclomatic complexity (average <51) and contain only few branches to cover (average <85). Vice versa, classes with $\\hat{A}_{12}>0.50$ (i.e., with DynaMOSA outperforming WSA) have a more variable complexity, ranging between 4 and 1,244, and number of branches varying between 17 and 7,938. Therefore, on this coverage criterion we observe a general trend for DynaMOSA to reach higher branch coverage ($\\hat{A}_{12}>0.50$) regardless of class size and complexity.\n\nFor statement coverage (Fig. 7-b), $\\hat{A}_{12}>0.50$ scores are achieved mainly for classes with more than 500 statements, which represent 75% of the classes for which DynaMOSA achieves significantly higher statement coverage. For cyclomatic complexity, there is more variability since it ranges between 5 and 1,244. Only few circles (classes) fall on the left of the $\\hat{A}_{12} = 0.50$ point. For those few cases, the average complexity is 20 while the total number of statements to cover is 404 on average.\n\nFinally, for strong mutation coverage, the results are mixed: classes with both $\\hat{A}_{12}<0.50$ and $\\hat{A}_{12}>0.50$ show variable complexity ($y$ coordinate) as well as a variable number of mutants to kill (circle’s radius). Indeed, Figure 7-c reports large circles on the left of point $\\hat{A}_{12}=0.50$ indicating that there are classes with a large number of mutants for which WSA achieves better strong mutation scores. It is important to notice that for this criterion WSA prioritises the test cases to be run according to their execution time, while DynaMOSA does not do that. For classes with an extremely high number of mutants, this strategy helps in reducing the time consumed in each generation, thus, allowing the algorithm to spend more effort evolving the test suites. However, there are many more circles on the right of point $\\hat{A}_{12}=0.50$, indicating that DynaMOSA outperforms WSA in many more cases even without using any prioritising strategy based on test case execution time.\n\nTo provide statistical support to the observations made above, we used a two-way permutation test [4] to verify whether any interaction between the $\\hat{A}_{12}$ statistics, cyclomatic complexity and number of targets is statistically significant or not. The two-way permutation test is a non-parametric test equivalent to the two-way Analysis of Variance (ANOVA), thus, it does not make any assumption on data distributions. For this test, we use the implementation available in the lmPerm package for R. It uses an iterative procedure to compute the $p$-values, thus, it can produce different results over multiple runs when few iterations are used. For this reason, we set the number of iterations to $10^8$.\n\nThe two-way permutation test shows that the $\\hat{A}_{12}$ scores are significantly influenced by cyclomatic complexity and number of targets for branch coverage ($p$-values $\\in \\{0.04, 0.02\\}$), as well as by their combination ($p$-value=0.02). Therefore, on this criterion DynaMOSA improves branch coverage over WSA especially for classes with high number of branches and/or high computational complexity. For statement coverage, the permutation test reveals a significant interaction between $\\hat{A}_{12}$ scores and cyclomatic complexity combined with number of targets ($p$-value=0.02). However, the two factors taken alone do not significantly interact with the $\\hat{A}_{12}$ scores ($p$-values $\\in \\{0.24, 1.00\\}$). Therefore, DynaMOSA provides better coverage scores (with $\\hat{A}_{12}>0.50$) especially for classes with high cyclomatic complexity and/or with large number of mutants/statements to be covered. For strong mutation coverage, the two-way permutation test shows that the $\\hat{A}_{12}$ scores are not significantly influenced by cyclomatic com-\n\n\nplexity and number of targets for branch coverage (p-values $\\in \\{0.98, 0.35\\}$), neither by their combination (p-value=0.75).\n\n6.3 Co-factors analysis for DynaMOSA vs. MOSA\n\nFigure 8 reports the results of the interaction between McCabe’s cyclomatic complexity (y axis), number of coverage targets (circle’s radius), and Vargha-Delaney $\\hat{A}_{12}$ scores (x axis) for those classes with statistically significant differences between DynaMOSA and MOSA. For branch coverage (Figure 8-a), classes with $\\hat{A}_{12}>0.50$ show a variable number of branches that ranges between 21 and 2,373, and a variable cyclomatic complexity ranging between 4 and 679. Vice versa, for the single class with $\\hat{A}_{12}<0.50$ the corresponding circle has a small size (low number of branches) and low complexity scores. Therefore, for branch coverage DynaMOSA reaches higher coverage, with respect to MOSA, independently of the considered factors.\n\nFor statement coverage (Figure 8-b), $\\hat{A}_{12}<0.50$ scores are achieved for classes with complexity ranging between 16 and 63, while the corresponding number of statements ranges between 152 and 1,436. However, these two factors have higher values for classes with $\\hat{A}_{12}>0.50$. Indeed, for such classes the complexity values range between 10 and 775, while the number of statements to cover ranges between 179 and 7,809. Hence, for this criterion DynaMOSA tends to outperform MOSA for classes with both high complexity and large size.\n\nFor strong mutation, most of the classes in Figure 8-c have low complexity when $\\hat{A}_{12}<0.50$ while for $\\hat{A}_{12}>0.50$ we observe a larger variability in terms of complexity. There is an extreme class on the right of the line $\\hat{A}_{12} = 0.50$ with a very large complexity (755) for which DynaMOSA is more effective than MOSA. For what concerns the number of mutants (radius of circles), we do not observe any relevant differences between the data points on the left and on the right sides of line $\\hat{A}_{12} = 0.50$. Thus, we do not observe any influence of the number of mutants to kill on the $\\hat{A}_{12}$ statistics.\n\nTo test the statistical significance of the interactions reported above, we used a two-way permutation test [4]. According to this test, for branch coverage, $\\hat{A}_{12}$ scores obtained from the comparison between DynaMOSA and MOSA are not significantly influenced by cyclomatic complexity and by number of branches to cover (p-values $\\in \\{0.73, 0.16\\}$), and neither from their combination (p-value=0.13). Similarly, for statement coverage the permutation test reveals no interaction between $\\hat{A}_{12}$ statistics and both cyclomatic complexity (p-value=0.14) and number of statements (p-value=1.00). Moreover, there is no significant interaction between their combination and $\\hat{A}_{12}$ scores (p-value=0.29). For strong mutation, only cyclomatic complexity has a marginal interaction with $\\hat{A}_{12}$ statistics (p-value=0.07) while there is no significant influence for the number of mutants (p-value=1.00) as well as for its combination with cyclomatic complexity (p-value=0.92). Hence, DynaMOSA outperforms MOSA independently of size and complexity of the class under test for all three coverage criteria considered in this study.\n\n7 Threats to Validity\n\nThreats to construct validity regard the relation between theory and experimentation. The comparison among different search algorithms is based on performance metrics that are widely adopted in the literature: structural coverage, strong mutation scores, and running time. In the context of test case generation, these metrics give reasonable estimation of the effectiveness (coverage metrics) and efficiency (running time) of the test case generation techniques.\n\nThreats to internal validity regard factors that could influence our results. To deal with the inherent randomness of GA, we repeated each execution 10 times and reported average performance together with rigorous statistical analysis to support our findings. Another potential threat arises from GA parameters. We used default parameter values.\nsuggested in related literature since they have been shown to give reasonably acceptable results as compared to fine-tuned settings [2]. All experimented algorithms are implemented in the same tool, thus, they share the same implementation for the genetic operators. This avoids potential confounding effects due to usage of different tools with different operator implementations.\n\nThreats to conclusion validity stem from the relationship between the treatment and the outcome. In analysing the results of our experiments, we have used appropriate statistical tests coupled with enough repetitions of the experiments to enable the statistical tests. In particular, we have used the two-tailed Wilcoxon test and the two-way permutation test, two non-parametric tests that do not make any assumption on the data distributions being compared. We also use the Vargha-Delaney effect size statistics for estimating the magnitude of the observed difference. We drew conclusions only when results were statistically significant according to these tests.\n\nThreats to external validity affect the generalisation of our results. We carried out experiments on 346 Java classes randomly taken from 116 open-source projects belonging to four different datasets [18], [53], [49], [42]. These software projects have been used in many previous works on test case generation (e.g., [2], [19]). Moreover, in order to increase the generalisability of our findings, we evaluated all the algorithms with respect to three different, widely used, coverage criteria, i.e., branch coverage, statement coverage and strong mutation coverage.\n\n8 Related Work\n\nThe application of search algorithms for test data and test case generation has been the subject of increasing research efforts. As a result, several techniques [5], [26], [24], [46], [56] and tools [6], [9], [40], [35], [7], [29], [57], [60], [43] have been proposed in the literature.\n\nSearch-based approaches. Existing works on search-based test generation rely on the single objective formulation of the problem, as discussed in Section 2. In the literature, two variants of the single objective formulation can be found: (i) targeting one branch at a time [1], [20], [26], [37], and (ii) targeting all branches at once (whole-suite approach) [3], [17], [19]. The first variant (i.e., targeting one branch at a time) has been shown to be inferior to the whole-suite approach [3], [17], [19]. The first variant is still targeted individually) and the second objective is the first objective is branch coverage (each coverage target is still targeted individually) and the second objective is the number of collateral targets that are accidentally covered. Ferrer et al. [16] proposed a multi-objective approach that considers two conflicting objectives: coverage (to be maximised) and oracle cost (to be minimised). They also used the targeting one branch at a time approach for the branch coverage criterion, i.e., their approach selects one branch at a time and then runs GA to find the test case with minimum oracle cost that covers such a branch. Pinto and Vergilio [44] considered three different objectives when generating test cases: structural coverage criteria (targeting one branch at a time approach), ability to reveal faults, and execution time. Oster and Saglietti [39] considered two objectives to optimise: branch coverage (to be maximised) and number of test cases required to reach the maximum coverage (to be minimised). Lakhotia et al. [32] experimented bi-objective approaches, considering as objectives branch coverage and dynamic memory consumption for both real and synthetic programs. Even if they called this bi-objective formulation as multi-objective branch coverage, they still represent branch coverage as a single objective function, by considering one branch at a time. According to McMinn [38], there are several other potential non-coverage objectives that could be added to test case generation tools, such as minimising the oracle cost, maximising the test case diversity to increase the likelihood to expose more faults, etc.\n\nIt is important to notice that all previous multi-objective approaches for evolutionary test data generation used the targeting one branch at a time strategy [37]. The branch distance of a single targeted branch is one objective, considered with additional non-coverage objectives. From all these studies, there is no evidence that the usage of additional (non-coverage) objectives provides benefits in terms of coverage with respect to the traditional single-objective approach based on branch coverage alone. As reported by Ferrer et al. [16] the usage of such additional objectives can be even harmful for the final structural coverage. It is also important to highlight that the number of objectives considered in these studies remains limited to a relatively small number, being always ≤ 3.\n\nMulti-objective approaches. Although in the related literature there are previous works applying multi-objective approaches in evolutionary test data generation, they all considered structural coverage as a single objective, while other, domain-specific objectives have been added as further objectives the tester would like to achieve [1], [22], such as memory consumption [32], execution time [44], test suite size [39], etc. For example, Harman et al. [23] proposed a search-based multi-objective approach in which the first objective is branch coverage (each coverage target is still targeted individually) and the second objective is the number of collateral targets that are accidentally covered. Ferrer et al. [16] proposed a multi-objective approach that considers two conflicting objectives: coverage (to be maximised) and oracle cost (to be minimised). They also used the targeting one branch at a time approach for the branch coverage criterion, i.e., their approach selects one branch at a time and then runs GA to find the test case with minimum oracle cost that covers such a branch. Pinto and Vergilio [44] considered three different objectives when generating test cases: structural coverage criteria (targeting one branch at a time approach), ability to reveal faults, and execution time. Oster and Saglietti [39] considered two objectives to optimise: branch coverage (to be maximised) and number of test cases required to reach the maximum coverage (to be minimised). Lakhotia et al. [32] experimented bi-objective approaches, considering as objectives branch coverage and dynamic memory consumption for both real and synthetic programs. Even if they called this bi-objective formulation as multi-objective branch coverage, they still represent branch coverage as a single objective function, by considering one branch at a time. According to McMinn [38], there are several other potential non-coverage objectives that could be added to test case generation tools, such as minimising the oracle cost, maximising the test case diversity to increase the likelihood to expose more faults, etc.\n\nIt is important to notice that all previous multi-objective approaches for evolutionary test data generation used the targeting one branch at a time strategy [37]. The branch distance of a single targeted branch is one objective, considered with additional non-coverage objectives. From all these studies, there is no evidence that the usage of additional (non-coverage) objectives provides benefits in terms of coverage with respect to the traditional single-objective approach based on branch coverage alone. As reported by Ferrer et al. [16] the usage of such additional objectives can be even harmful for the final structural coverage. It is also important to highlight that the number of objectives considered in these studies remains limited to a relatively small number, being always ≤ 3.\n\nNon-evolutionary approaches. Other than evolutionary approaches, other techniques have been proposed in the literature for test case and test data generation, such as dynamic symbolic execution [7], [29], [57], [60] and random testing [10], [35], [40], [41]. Dynamic symbolic execution techniques encode all constraints that should be satisfied to execute a particular path in a specific formula to be solved using constraint solvers. A solution to such a formula consists of method sequences and test data allowing to cover the corresponding path in the program [29]. Although symbolic execution has been widely applied in the liter-\nthere are several challenges to address for real-world programs [15], such as: path explosion, complexity constraints, dependencies to external libraries, and paths related to exceptions. Eler et al. [15] performed a large-scale study on the SF110 corpus to identify factors that negatively impact symbolic execution techniques for object-oriented software. They observed that less than 10% of Java methods in SF110 have only integer or floating-point data types. Therefore, most of constraints to solve are related to complex data types (e.g., objects) posing several challenges to constraint solvers [15]. Moreover, handling calls to external libraries limits the applicability of symbolic execution for real-world software projects [15].\n\nDirect comparison between evolutionary testing and random testing has been the subject of investigation of several researchers (e.g., [56], [25], [53], [49]) in the last decade. Most of these studies have shown that evolutionary testing outperforms random testing [56], [25], [49], which usually fails to cover hard-to-reach branches that require a quite sophisticated search [25]. For example, Fraser and Arcuri [18] conducted a large empirical study on open source projects (the SF110 corpus) and industrial projects and compared EvoSuite with Randoop [41], a popular random testing tool for Java. Their results showed that GAs (whole suite approach) lead to a large improvement over random testing [18], despite the presence of a large number of classes in SF110 that are trivial to cover. Similar results have been obtained by Shamshiri et al. [51]. On the SF110 corpus they compared the whole suite approach with a random search algorithm implemented in the same tool, i.e., EvoSuite. However, they observed that most of classes in SF110 are so trivial to cover that random search could generate test cases without much relative disadvantage for such a dataset.\n\nRecently, Ma et al. [35] introduced an improved version of random testing, namely guided random testing (GRT). GRT extracts constants from the software under test via lightweight static analysis and reuses such knowledge to seed the generation process. Empirical results [35], [53] have shown GRT is able to reach competitive (and sometimes higher) coverage than the pure whole-suite approach in implemented EvoSuite. However, no empirical comparison has been performed between GRT and a more recent version of EvoSuite implementing WSA (archive-based whole suite approach), which won the latest SBST tool contest [49].\n\nWhereas a systematic comparison of evolutionary testing (e.g., WSA, DynaMOSA) with other techniques (e.g., GRT, Randoop, etc.) would be an interesting analysis to perform, it escapes the scope of this paper. In fact, the main goal of this paper is to determine a proper formulation of the test case generation problem in the context of evolutionary testing. As a consequence, we have presented a new many-objective solver for evolutionary-based techniques. Further investigations and comparisons with different categories of techniques are part of our future work agenda.\n\nOur paper. Although other existing techniques already target all branches/statements at the same time (e.g., WSA [48], GRT [35], etc.), none of them consider such coverage targets as explicit objectives to optimise. In this paper, we regard coverage itself as a many-objective problem, since the goal is to minimise simultaneously the distances between the test cases and the uncovered structural targets in the class under test. In our previous ICST 2015 paper [42] we provided a first reformulation of branch coverage as a many-objective problem. In this paper, we refine the target selection mechanism and we dynamically add yet uncovered targets that are under direct control dependency of a covered condition. This allows us to reduce the number of objectives simultaneously active during test case evolution, which further increases the effectiveness and efficiency of the proposed approach. Such extension is especially useful when the number of targets is very high, as in mutation testing or when dealing with classes that have high cyclomatic complexity/size.\n\nOur empirical results provide also evidence that attempting all coverage targets at the same time is not equivalent to applying a many-objective solver. In fact, all algorithms investigated in our paper already attempt all coverage targets at the same time: WSA and WS consider such targets as components of a test-suite level single function to optimise; MOSA and DynaMOSA (and its variants) use such targets as independent objectives. Our results show that there exists a statistically significant difference in code coverage among the aforementioned algorithms. In particular, we found that the usage a many-objective strategy to select the candidate tests during the search process plays a paramount role on both effectiveness and efficiency in test case generation (see RQ4 on the role of the preference criterion).\n\n9 Conclusions and Future Work\n\nWe have reformulated the test case generation problem as a many-objective optimisation problem, where different coverage targets are considered as different objectives to be optimised. Our novel many-objective genetic algorithm, DynaMOSA, exploits the peculiarities of coverage testing with respect to traditional many-objective problems to overcome scalability issues when dealing with hundreds of objectives (coverage targets). In particular, (i) it includes a new preference criterion that gives higher priority to a subset of Pareto optimal solutions (test cases), hence increasing the selective pressure; (ii) it dynamically focuses the search on a subset of the yet uncovered targets, based on the control dependency hierarchy.\n\nOur empirical study, conducted on 346 Java classes extracted from 117 java projects belonging to four different datasets, shows that the proposed algorithm, DynaMOSA, yields strong, statistically significant improvements for coverage with respect to its predecessor, MOSA, and the whole-suite approach. Specifically, the improvements can be summarised as follows: coverage is significantly higher with respect to WSA in 28% of the classes for branch and 27% strong mutation; for these classes, DynaMOSA leads to +8% and +11% more coverage respectively. The comparison with WS shows a significant improvement for statement coverage in 51% of classes, for which the average improvement is 11%. Finally, DynaMOSA outperforms its predecessor MOSA in 12% of the classes with an average coverage improvement of 8%. Consistent results have been obtained across all three coverage criteria —i.e., branch coverage, statement coverage and strong mutation coverage. On classes with no improvement in coverage, DynaMOSA\nconverges more quickly, especially when limited time is given to the search. Therefore, we conclude that many-objective algorithms can be applied to test case generation, but they need to be suitably customised to deal with the hundreds and thousands of targets/objectives that are typical of test case generation.\n\nGiven the results reported in this paper, there are a few potential directions for future works. First of all, we intend to incorporate also non-coverage criteria within our many-objective algorithm, such as execution time [44] and memory consumption [32]. We also plan to further improve our preference criterion by developing adaptive strategies to enable/disable the test size (secondary non-coverage criterion) to avoid genetic drift, to enable/disable Pareto-based ranking and to activate the upper bound strategy when the number of uncovered targets/objectives is extremely high.\n\nRecent research endeavours have resulted in improved variants of random testing techniques (e.g., [35]) which have been shown to be effective alternatives for test data generation, as opposed to being mere baselines for comparing other techniques. However, such effectiveness needs to be investigated with respect to the nature of the program under test, in particular, when the program under test exhibits complex structures. In future work, we plan to design a comprehensive experimental evaluation for investigating the comparative pros and cons of random testing techniques with respect to our DynaMOSA.\n\nFinally, we plan to investigate the performance of our many-objective algorithm when combining multiple coverage criteria at the same time compared to the scalarization strategy used by Rojas et al [47] for WS and WSA.\n\nAcknowledgement\n\nThis work is partially supported by the National Research Fund, Luxembourg FNR/P10/03.\n\nReferences\n\n\n\n\nAnnibale Panichella received the PhD in Software Engineering from the University of Salerno in 2014 with the thesis entitled “Search-based software maintenance and testing”. From March 2014 to December 2014 he was a post-doctoral researcher for the Security & Trust research unit at Fondazione Bruno Kessler in Trento (Italy). From January 2015 to September 2016, he was a post-doctoral researcher in the Software Engineering Research Group (SERG) at Delft University of Technology (TU Delft) in Netherlands. Currently, he is a Research Associate in the Interdisciplinary Centre for Security, Reliability and Trust (SnT) at the University of Luxembourg. His research interests include security testing, evolutionary testing, search-based software engineering, textural analysis, and empirical software engineering. He serves and has served as program committee member of various international conference (e.g., ICSE, GECCO, ICST and ICP) and as reviewer for various international journals (e.g., TSE, TOSEM, TEVC, EMSE, STVR) in the fields of software engineering and evolutionary computation.\n\n\nFitsum Meshesha Kifetew received his BSc and MSc degrees in Computer Science from Addis Ababa University, Ethiopia in 2003 and 2005 respectively. From 2005 to 2009 he worked as a lecturer at the Addis Ababa University. In 2009 he joined the Software Engineering unit at Fondazione Bruno Kessler (FBK) in Trento, Italy as a software engineer. In 2011 he started studying at the University of Trento towards a PhD degree, sponsored by FBK and in 2015 he obtained the PhD degree after defending his thesis “Evolutionary Test Case Generation via Many Objective Optimization and Stochastic Grammars”. He is currently a postdoctoral researcher in the Software Engineering unit at FBK. His research focuses on applying search-based techniques to software engineering problems, such as test case generation and requirements prioritization. He served as program committee member of the Symposium on Search-Based Software Engineering (SSBSE) and as reviewer for various journals (TSE, STVR, IST, JSS).\n\nPaolo Tonella is head of the Software Engineering Research Unit at Fondazione Bruno Kessler (FBK), in Trento, Italy. He is also Honorary Professor at University College London (UCL). He received his PhD degree in Software Engineering from the University of Padova, in 1999, with the thesis “Code Analysis in Support to Software Maintenance”. In 2011 he was awarded the ICSE 2001 MIP (Most Influential Paper) award, for his paper: “Analysis and Testing of Web Applications”. He is the author of “Reverse Engineering of Object Oriented Code”, Springer, 2005, and of “Evolutionary Testing of Classes”; ISSTA 2004. Paolo Tonella was Program Chair of ICSM 2011 and ICPC 2007; General Chair of ISSTA 2010 and ICSM 2012. He is associate editor of TSE and he is in the editorial board of EMSE and JSEP. His current research interests include code analysis, web testing, search based test case generation and the test oracle problem."}}},{"rowIdx":272,"cells":{"id":{"kind":"string","value":"4b34d5cfefb6c737a31c47b32a7e14c249e3850f"},"text":{"kind":"string","value":"Thesis\n\nALGOL-M\nAn Implementation of a High-level Block Structured Language for a Microprocessor-based Computer System\n\nby\nJohn P. Flynn\nand\nMark S. Moranville\n\nSeptember 1977\n\nThesis Advisor:\nG. A. Kildall\n\nApproved for public release; distribution unlimited.\nALGOL-M\nAn Implementation of a High-level Block Structured Language for a Microprocessor-based Computer System\n\nJohn P. Flynn\nMark S. Moranville\n\nNaval Postgraduate School\nMonterey, California 93940\n\nApproved for public release; distribution unlimited\n\nThe design and implementation of the ALGOL-M programming language for use on a microprocessor-based system is described. The implementation is comprised of two subsystems, a compiler...\nwhich generates code for a hypothetical zero-address machine and a run-time monitor which executes this code. The system was implemented in PL/M to run on an 8080 microcomputer in a diskette-based environment with at least 20K bytes of user storage.\nApproved for public release; distribution unlimited\n\nALGOL-M\nAn Implementation of a\nHigh-level Block Structured Language\nfor a Microprocessor-Based Computer System\n\nby\n\nJohn P. Flynn\nLieutenant Commander, United States Navy\nB.S., United States Naval Academy, 1965\n\nand\n\nMark S. Moranville\nLieutenant, United States Navy\nB.S., Oregon State University, 1972\n\nSubmitted in partial fulfillment of the\nrequirements for the degree of\n\nMASTER OF SCIENCE IN COMPUTER SCIENCE\n\nfrom the\n\nNAVAL POSTGRADUATE SCHOOL\nSEPTEMBER, 1977\n\nAuthors:\n\nJohn P. Flynn\nMark Moranville\n\nApproved by:\n\nRay A. Kibler\nThesis Advisor\n\nStephen J. Zelko\nSecond Reader\n\nChairman, Department of Computer Science\n\nDean of Information and Policy Sciences\nABSTRACT\n\nThe design and implementation of the ALGOL-M programming language for use on a microprocessor-based system is described. The implementation is comprised of two subsystems, a compiler which generates code for a hypothetical zero-address machine and a run-time monitor which executes this code. The system was implemented in PL/M to run on an 8080 microcomputer in a diskette-based environment with at least 20K bytes of user storage.\n# TABLE OF CONTENTS\n\n## I. INTRODUCTION\n\nA. HISTORY OF ALGOL\n\nB. MICROCOMPUTER SOFTWARE\n\nC. OBJECTIVES OF ALGOL-M\n\n## II. ALGOL-M LANGUAGE DESCRIPTION\n\nA. FEATURES OF THE ALGOL-M LANGUAGE\n 1. Type Declarations\n 2. Arithmetic Processing\n 3. Control Structures\n 4. Input/Output\n 5. Disk Access\n\n## III. IMPLEMENTATION\n\nA. COMPILER IMPLEMENTATION\n 1. Compiler Organization\n 2. Scanner\n 3. Symbol Table\n 4. Parser\n 5. Code Generation\n\nB. INTERPRETER IMPLEMENTATION\n 1. Building the ALGOL-M Pseudo Machine\n 2. Overview of the Interpreter\n 3. Allocation of Storage Space\n a. Integers\n b. Decimals\nc. Strings.................................................. 31\n\nd. Arrays.................................................. 34\n\n4. Storage and Retrieval of Variables............. 36\n\n5. Arithmetic Operations.............................. 37\n\nb. String Operations................................. 38\n\n7. Subroutines........................................... 39\n\na. Invocation............................................. 39\n\nd. Storage Allocation................................. 39\n\nc. Parameter Mapping.................................. 41\n\nd. Function Return Value............................. 41\n\ne. External Functions................................. 44\n\nf. Forward References................................. 44\n\ng. Built-in Functions................................. 44\n\n6. Input-Output........................................... 45\n\n9. ALGOL-M Pseudo Operators......................... 46\n\na. Description of Interpreter Variables... 46\n\nb. Literal Data References.......................... 47\n\nc. Allocation Operators.............................. 48\n\nd. Arithmetic Operators............................. 49\n\ne. String Operators.................................. 52\n\nf. Stack Operators.................................. 53\n\ng. Array Operators.................................. 54\n\nh. Program Control Operators....................... 55\n\ni. Store Operators.................................. 55\n\nj. Input/Output Operators........................... 56\n\nk. Subroutine Operators............................ 59\n\nIV. CONCLUSIONS............................................ 61\nV. RECOMMENDATIONS ........................................... 63\n\nAPPENDIX A - BENCHMARK PROGRAMS ...................... 64\n\nAPPENDIX B - COMPILER ERROR MESSAGES ................. 67\n\nAPPENDIX C - INTERPRETER ERROR MESSAGES .............. 69\n\nAPPENDIX D - ALGOL-M LANGUAGE MANUAL ............... 70\n\nAPPENDIX E - ALGOL-M LANGUAGE STRUCTURE ............ 108\n\nALGOL-M PROGRAM LISTINGS .................................. 120\n\nLIST OF REFERENCES ......................................... 186\n\nINITIAL DISTRIBUTION LIST ................................. 188\nI. INTRODUCTION\n\nA. HISTORY OF ALGOL\n\nThe definition of the algorithmic language (ALGOL-60) was the result of the work of a committee of distinguished computer scientists and was originally published in 1960. The purpose of the developers of ALGOL-60 was the establishment of a universal computer language specifically designed to allow for the formal and efficient program representation of algorithms. Additional versions and extensions of ALGOL-60 such as ALGOL-68 (115) and ALGOL-W (116) have been developed and have found acceptance primarily in the academic communities and in Europe. The language ALGOL-E (10) is also based on ALGOL-60 and was developed as part of a complete system designed for teaching programming language concepts.\n\nB. MICROCOMPUTER SOFTWARE\n\nThe rapid development of microcomputer hardware since 1975 has generally resulted in a considerable lag in the corresponding development of compatible software, particularly that of high level languages. The Intel 8080 microprocessor is one of the few microprocessors which has endured long enough to permit software development to advance beyond the assembly language level. High level\nLanguages which have been developed for 8080 based systems by students at the Naval Postgraduate School include a macro assembler (ML-80) \\(^{(12)}\\), a \\textsc{BASIC} compiler/interpreter (RASIC-F) \\(^{(6)}\\), and a \\textsc{FORTRAN} compiler/interpreter (MICRO-COBOL) \\(^{(2)}\\). The majority of high level languages currently available for microcomputer based systems are extensions of the original Dartmouth \\textsc{BASIC} and, although they allow for a reasonable level of programming sophistication, they are encumbered by the inherent limitations of the \\textsc{BASIC} language constructs.\n\n\\section{Objective of \\textsc{ALGOL-4}}\n\nThe major objective of this project was to develop a dynamic, block-structured, recursive high level language which would provide adequate programming power and flexibility for applications programming using microcomputer based systems. \\textsc{ALGOL} constructs were chosen because of their simplicity and power and because it was possible to write the grammar in LALR\\(^1\\) form for use with available compiler-compiler generated parse tables \\(^{(14)}\\). \\textsc{ALGOL-4} was developed to run on 8080 based microcomputer systems because of the availability of a high level system development language (PL/M) \\(^{(8)}\\) which produces \\textsc{RUR} object code and which could be run on the \\textsc{Vava} Postgraduate School's IBM 360. The availability of an 8080 based disk operating system (CP/M) \\(^{(13)}\\) simulator on the IBM 360 was also a strong factor in the choice of \\textsc{RUR} microprocessor and \\textsc{CP/M}\noperating system.\nII. ALGOL-M LANGUAGE DESCRIPTION\n\nA. FEATURES OF THE ALGOL-M LANGUAGE\n\nAlthough ALGOL-M was modeled after ALGOL-60, no attempt was made to make it a formal subset of ALGOL-60. This was done intentionally in order to provide a language which would be best suited to the needs of applications programmers using microcomputer systems. However, the basic structure of ALGOL-M is similar enough to ALGOL-60 to allow simple conversion of programs from one language to the other. This was considered particularly important in view of the fact that the standard publication language is ALGOL-60. Therefore, there exists a large source of applications programs and library procedures which can be simply converted to execute under ALGOL-M.\n\n1. Type Declarations\n\nALGOL-M supports three types of variables: integers, decimals, and strings. Integers may be any value between \\(-10,384\\) and \\(+10,384\\). Decimals may be declared with up to 18 digits of precision and strings may be declared as long as 255 characters. The default precision for decimals is ten digits and the default length for strings is ten characters. Decimal and string variable lengths may be integer variables which can be assigned actual values at run-time.\n\nAnother form of declaration in ALGOL-M is the array\ndeclaration. Arrays may have up to 255 dimensions with each dimension ranging from -16,384 to +16,384. The maximum 8080 microprocessor address space of 64k bytes limits practical array sizes to something smaller than the maximum. Dimension bounds may be integer variables with the actual values assigned at run-time. Arrays may be of type integer, decimal or string.\n\n2. Arithmetic Processing\n\nInteger and binary coded decimal arithmetic are supported under ALGOL-M. Integers may be used in decimal expressions and will be converted to decimals at run-time. The integer and decimal comparisons of less-than (<), greater-than (>), equal-to (=), not-equal-to (<>), less-than-or-equal-to (<=), and greater-than-or-equal-to (>=) are provided. Additionally, the logical operators AND, OR, and NOT are available.\n\n3. Control Structures\n\nALGOL-M control structures consist of BEGIN, END, FOR, IF THEN, IF THEN ELSF, WHILE, CASE and GOTO constructs. Function and procedure calls are also used as control structures. ALGOL-M is a block structured language with a block normally bracketed by a BEGIN and an END. Blocks may be nested within other blocks to nine levels. Variables which are declared within a block can only be referenced within that block or a block nested within that block. Once program control proceeds outside of a block in which a variable has been declared, the variable may not be\nreferenced and, in fact, run-time storage space for that variable no longer exists.\n\nFunctions, when called, return an integer, decimal or string value depending on the type of the function. Procedures do not return a value when called. Both functions and procedures may have zero or more parameters which are call by value and both may be called recursively. Additionally, functions and procedures may be referenced before they are declared.\n\n4. Input/Output\n\nThe ALGOL-M WRITE statement causes output to the console on a new line. The desired output is specified in a write list which is enclosed in parentheses. String constants may be used in a write list and are characterized by being enclosed in quotation marks. Any combination of integer, decimal and string variables or expressions may also be used in a write list. A WRITEON statement is also available which is essentially the same as the WRITE statement except that output continues on the same line as the output from a previous WRITE or WRITEON statement. When a total of 80 characters have been written to the console, a new line is started automatically. A TAB option may also be used in the write list which causes the following item in the write list to be spaced to the right by a specified amount.\n\nConsole input is accomplished by the READ statement followed by a read list of any combination of integer,\ndecimal and string variables enclosed in parentheses. If embedded blanks are desired in the input for a string variable, the console input must be enclosed in quotation marks. A READ statement will result in a halt in program execution at run-time until the input values are typed at the console and a carriage return is sent. If the values typed at the console match the read list in number and type, program execution continues. If an error as to number or type of variables from the console occurs, program execution is again halted until values are re-entered on the console.\n\n5. Disk Access\n\nALGOL-M programs may read data from, or write data to, one or more disk files which may be located on one or more disk drives. When file input or output is desired, the appropriate READ or WRITE statement is modified by placing a filename identifier immediately after READ or WRITE. The actual name of the file may be assigned to the file name identifier when the program is written or it may be assigned at run-time. Various disk drives are referenced by the letters A through Z. A specific drive may be specified by prefixing the actual file name with the desired drive letter followed by a colon. Additionally, if random file access is desired, the file name identifier may be followed by an integer constant, variable or expression enclosed in parentheses. This integer value specifies the record within the file which is to be used for input/output.\n\nPrior to the use of a file name identifier in a READ\nor WRITE statement, the file name identifier must appear in a file declaration statement. The file name identifier can only be referenced within the same block (or a lower block) as the file declaration. Files are normally treated as unblocked sequential files. However, if blocked files are desired, the record length may optionally be specified in parentheses after the file name identifier in the file declaration statement.\nIII. IMPLEMENTATION\n\nA. COMPILER IMPLEMENTATION\n\n1. Compiler Organization\n\nThe compiler was designed to read source language statements from a diskette and to produce an intermediate language file with optional source listing at the console. A two pass approach was used to facilitate the implementation of GOTO statements, forward subroutines, and control statements. Pass one builds the symbol table and saves all branch locations for resolution during pass two. Pass one also computes the size of the program reference table (PRT) and writes this information out to the intermediate file. Pass two resolves all forward references and emits code to the intermediate file on disk.\n\n2. Scanner\n\nThe scanner analyses the source program and sends a sequence of tokens to the parser. In addition, the scanner provides a listing of the source file (if requested), ignores remarks, and sets the compiler toggles. Analysis of the first non-blank character in the input file determines the general class of the next token. The rest of the token is then scanned as it is placed into the accumulator (ACCUM). The first byte of ACCUM contains the length of the token. In the case of constants that exceed the size of\nACCIUIM (32 bytes) a continuation flag is set. This permits the scanner and parser to continue as necessary to accept the entire constant.\n\nWhen the scanner recognizes an identifier it searches the vocabulary table (VOCAB) to determine if the identifier is a reserved word. If found, the token number associated with the reserved word's position in the VOCAB table is returned. The reserved word COMMENT is a special case since it is not part of the grammar and is handled entirely by the scanner. The VOCAB table is one of the tables provided by the LALR(1) parse table generator[141].\n\nConstants are passed unconverted from the scanner through the parser to the intermediate file. Although this procedure does not allow constant checking during compile time, it does save space in the compiler. The conversion routines must be in the run-time system for console input and their duplication in the compiler was not considered necessary.\n\n3. Symbol Table\n\nThe symbol table stores attributes of program and compiler generated entities such as identifiers, procedures, and labels. The symbol table is constructed during pass one and the stored information is used by the compiler during pass two to verify that the program is semantically correct and to assist in code generation. Access to the symbol table is accomplished through various subroutines which operate on the symbol table through the use of based global\nvariables.\n\nThe symbol table is modeled after the BASIC-E symbol table (6). It is an unordered linear list of entries which grows toward the top of memory. Individual entries are accessed via a chained hash addressing technique as illustrated in Figure 1. Each location in the hash table heads a linked list whose printnames all evaluate to the same hash address. If there is a zero in the hash table then there are no entries for that particular hash value. During references to the symbol table, the global variable PRINTNAME contains the address of a variable which contains the length of the variable name followed by the name itself. The variable SYMHASH contains the sum of the ASCII characters that make up the variable name, modulo 64. Entries which hash to the same value are chained so that the latest entry is the first one on the chain. They are, however, stored in the symbol table in the order in which they appear in the program.\n\nEach entry in the symbol table contains the following information:\n\n- length of printname: 1 byte\n- collision field: 2 bytes\n- printname: variable length\n- type: 1 byte\n- address: 2 bytes\n- block level: 1 byte\n- subtype: 1 byte\nSYMBOL TABLE STRUCTURE\n\nSYMBOL TABLE\n\nHASH ARRAY\n\n28 0 0 18\n\n28 0 0 18\n\nA B C\n\nCOLLISION FIELD\n\nTWO ENTRIES WITH SAME HASH VALUES\n\nFIGURE 1\nThe address field indicates the identifier's position in the PPI unless the identifier is a label. For labels, it indicates the label's position in the code area. For subroutines, there are two extra symbol table entries: a parameter field which indicates the number of parameters associated with the subroutine (1 byte), and another address field which indicates the position of the subroutine in the code area.\n\nSince ALGOL-M is completely block structured, there is a block number associated with each identifier in the symbol table. A \"previous block level stack\" was designed in order to retain the symbol table for debugging purposes during run-time. Each active block is used as an index into this stack which contains all blocks to which the active block is subordinate. When a block is deactivated (i.e., the corresponding block end is encountered), the block number is removed from the previous block stack and therefore any identifiers associated with that block become inaccessible.\n\nTwo different lookup routines were designed to facilitate symbol table lookup. The first is FULLSLOOKUP which searches the current block and all outer blocks for an identifier. The second is NORMALSLOOKUP which simply checks the current block level. In most cases, FULLSLOOKUP is used to determine if an identifier being used has been declared and NORMALSLOOKUP is used to determine if an identifier being declared has been previously declared in the same block level.\n4. Parser\n\nThe LALR parser is a derivative of the I-bar parsing technique. It receives tokens from the scanner and analyzes them to determine if they are part of the AlOL-LR grammar. When the parser accepts a token, one of the following actions will be taken. It may save the token and continue to accept tokens in the lookahead state, or it may recognize the right part of one of the valid productions and apply the production state (cause a reduction to take place). Finally, the parser may determine that the tokens received do not form a valid right part for a production in the grammar and cause a syntax error to be printed.\n\nWhen an error is detected RECOVER is called and the parser backs up a state with an attempt to continue parsing from that state. If this fails, it continues to back up until the end of the currently pending reduction is reached. At that point the bad token is bypassed and an attempt to parse the following token is made until an acceptable token is found.\n\nThe major data structures in the parser are the LALR(1) parse tables and the parse stacks. The parse stacks consist of a state stack and six auxiliary stacks. These auxiliary stacks are parallel to the parse stack and are used to store information needed during code generation. The information stored in these stacks includes variable types, subtypes, and variable addresses.\n5. Code Generation\n\nThe parser not only verifies the syntax of source statements, but also controls code generation by associating semantic actions with reductions. When a reduction takes place, the procedure SYNTHESIZE is called with the production number as a parameter. SYNTHESIZE copies the needed semantic information from the parse stacks into simple variables (to avoid extensive subscripting) and performs the appropriate semantic action. This is accomplished by the use of a large case statement with the production number as a key. The syntax of the language, along with the semantic actions taken, is listed in Appendix E.\n\n4. INTERPRETER IMPLEMENTATION\n\n1. Building the ALGOL-M Pseudo Machine\n\nThe ALGOL-M pseudo machine, as shown in Figure 2, is a software emulation of a stack-oriented CPU with an instruction set which is particularly well suited for execution of ALGOL-M programs. The ALGOL-M interpreter is loaded at address 100 hex (as are all executable programs under the CP/M operating system) and proceeds to read the ALGOL-M intermediate code from disk, constructing the pseudo machine beginning at the first free memory location. The ALGOL-M intermediate code is read into a buffer in 128 byte segments. The first two bytes of the intermediate code represent an integer value equal to the number of bytes\nto be used for the program reference table (PRT). Each PRT location is two bytes in length and is used to contain information relative to ALGOL-M program identifiers, arrays, and subroutines.\n\nThe remaining intermediate code is manipulated in accordance with the algorithm shown in Figure 3 in order to construct the pseudo machine code area.\n\n2. Overview of the Interpreter\n\nThe ALGOL-M interpreter uses the pseudo machine code area as input data. Each pseudo machine operator is equated to an integer value which is evaluated in order to provide the correct entry point into a large case statement in the interpreter. Each entry in the case statement contains the necessary code to cause proper run-time execution of the specific ALGOL-M pseudo instruction. The case statement is executed continually until the ALGOL-M program has been completed, at which time control is passed back to the operating system. A run-time stack is used to facilitate the execution of ALGOL-M pseudo instructions. The stack can be viewed as being two bytes wide and expanding or contracting above the ALGOL-M machine code area as necessary. The top item on the stack is addressed by the variable $\\text{PA}$, while the next-to-top item is addressed by $\\text{PB}$. The contents of the two bytes on top of the stack are referenced by the variable $\\text{AHA}$ while the two byte contents of the next-to-top stack position are referenced by the variable $\\text{ARB}$. The low order byte\nALGOL-M MACHINE\nMEMORY ORGANIZATION\n\nFIGURE 2\nGET NEXT BYTE FROM INT FILE\n\n>=128\n\nSTORE BYTE PLUS NEXT BYTE IN ALGOL-M PSEUDO MACHINE CODE AREA\n\n\"INT\"\n\nSTORE BYTE IN CODE AREA, READ IN ASCII NUMBERS UNTIL BINARY ZERO, CONVERT TO TWO BYTE INTERNAL FORM, STORE IN CODE AREA\n\n\"STR\"\n\nSTORE BYTE IN CODE AREA, READ IN ASCII CHARACTERS UNTIL BINARY ZERO, CONVERT TO INTERNAL FORM, STORE IN CODE AREA\n\n\"DEC\"\n\nSTORE BYTE IN CODE AREA, READ IN ASCII DIGITS AND DECIMAL POINT UNTIL BINARY ZERO, CONVERT TO INTERNAL FORM, STORE IN CODE AREA\n\nSTORE IN CODE AREA\n\n\"BRS\" \"RRC\"\n\nREAD IN NEXT TWO BYTES, ADD VALUE OF THESE TO CODE BASE, STORE IN CODE AREA\n\n\"IM1\"\n\nREAD IN NEXT BYTE, STORE IN CODE AREA\n\n\"IM2\"\n\nREAD IN NEXT TWO BYTES, STORE IN CODE AREA\n\nFIGURE 3\n\n25\ncontents of the top and next-to-top stack locations are referenced by the variables PRA and RRA respectively. The various stack variables are depicted in Figure 4.\n\n3. Allocation of Storage Space\n\nRun-time storage space is required for the values associated with ALGOL-M program identifiers which have been declared as integer, decimal, or string values, and for information needed to process arrays and subroutines. A sequential number is assigned to each new identifier as it is recognized by the compiler. This number is used to reference the PRT at run-time in order to store or retrieve the value associated with each identifier.\n\na. Integers\n\nInteger values range from $-10,324$ to $+16,384$ and are stored directly in the two bytes allocated in the PRT for integer identifiers. A maximum length of two bytes for integer values was chosen because the resulting range of possible integer values was considered adequate for the primary use of integers as program control counters, such as array subscripts and loop boundaries. Additionally, two-byte values were the most convenient size to work with in the implementation language PL/M [81]. The high order bit of the integer representation is the sign bit, with zero indicating a positive value and one indicating a negative value. The second bit of the integer representation is always zero in order to permit\nALGOL-M STACK\nVARIABLES\n\nFIGURE 4\ndifferentiation between integers and other types on the stack. The ALGOL-M internal form for addresses is also a two byte value.\n\nb. Decimals\n\nDecimal values up to 18 digits in length are permitted in the ALGOL-M language. Each decimal identifier is associated with a unique PRT entry. The value stored in the two byte PRT entry represents the runtime address of the location on the ALGOL-M stack where the actual decimal value is stored. The format for decimal storage is shown in Figure 6.\n\nThe next-to-last byte of the allocated space for decimal identifiers contains the number of bytes used for storage of that value. This value is a function of the size declared for the decimal by the programmer and may be delayed until runtime. A maximum of 18 digits of precision may be declared with the default precision being ten digits. The first byte of the decimal storage area contains a value representing the number of bytes used to hold the actual packed digits. This value may be less than the number of bytes which could be stored in the allocated area. In order to save storage space, the decimal values are packed two digits per byte of storage space.\n\nALGOL-M is a block structured language based upon a stack model for execution. Thus, it allows efficient allocation of storage for decimal identifiers. A block is normally bracketed by the ALGOL-M keywords\nBEGIN\nINTEGER A,B;\nA := 3;\nB := -2;\nEND\n\nSIGN BIT\n\n| 0 0 0 0 0 0 1 1 | 0 0 0 0 0 0 0 0 | +3 |\n\nLOW ORDER BYTE HIGH ORDER BYTE\n\nSIGN BIT\n\n| 0 0 0 0 0 0 1 0 | 1 0 0 0 0 0 0 0 | -2 |\n\nINTEGER STORAGE\n\nFIGURE 5\n\n29\nBEGIN\nDECIMAL(12) X;\nX := 123456.78;\nEND\n\n<table>\n<thead>\n<tr>\n<th>OFFSET TO BOTTOM OF DECIMAL STORAGE</th>\n<th>SIGN (+)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>8</td>\n<td>1</td>\n</tr>\n<tr>\n<td>56</td>\n<td>78</td>\n</tr>\n<tr>\n<td>12</td>\n<td>34</td>\n</tr>\n<tr>\n<td>4</td>\n<td>2</td>\n</tr>\n</tbody>\n</table>\n\nSTACK\n\nDECIMAL STORAGE\n\nFIGURE 6\nBEGIN and END. Blocks may be embedded within a higher level block as shown in Figure 7. Identifiers which are declared in a given block are considered local to that block and global to any lower level block and therefore may be referenced from those blocks. However, once execution of an ALGOL-M program proceeds beyond a given block, the identifiers declared within that block may no longer be referenced and, in fact, the storage allocated for those identifiers is removed from the ALGOL-M machine stack.\n\nc. Strings\n\nStrings of ASCII characters up to 255 bytes in length are permitted in ALGOL-M. In the same manner as used for decimal storage, the string identifier is associated with a unique PRT entry. The corresponding PRT entry contains the address of the actual string storage space on the ALGOL-M stack. The format for string storage is shown in Figure 8. The next-to-last byte of the allocated storage space for a string identifier contains the value of the number of bytes actually allocated by the programmer up to a maximum of 255 bytes. The first byte of the allocated string storage area contains the value of the actual number of ASCII characters stored in the allocated area. The concept of storage allocation as related to block levels is the same as described for decimal identifiers.\nBLOCK LEVEL 0 \\textbf{BEGIN} \\\\\n\\textbf{BEGIN} \\text{DECIMAL} A,B,C; \\\\\n\\text{STRING} X,Y,Z; \\\\\n\\textbf{BEGIN} \\text{DECIMAL} C,D,E; \\\\\n\\text{END} \\text{BLOCK LEVEL 2} \\rightarrow \\text{END}; \\\\\n\\text{END} \\text{BLOCK LEVEL 1} \\rightarrow \\text{END}; \\\\\n\\text{END} \\text{BLOCK LEVEL 0} \\rightarrow \\text{END}; \\\\\n\n\\begin{figure}\n\\centering\n\\includegraphics[width=0.7\\textwidth]{figure7.png}\n\\caption{Block Levels and Stack Storage}\n\\end{figure}\n\n32\nBEGIN\nSTRING(9) TESTWORD;\nTESTWORD := \"HELLO\";\nEND\n\n<table>\n<thead>\n<tr>\n<th>OFFSET TO BOTTOM OF STRING STORAGE</th>\n<th>10</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>"L"</td>\n<td>"O"</td>\n</tr>\n<tr>\n<td>"E"</td>\n<td>"L"</td>\n</tr>\n</tbody>\n</table>\n| ACTUAL NUMBER OF CHARACTERS STORED | 5 | \"H\"\n\nSTACK\n\nSTRING STORAGE\n\nFIGURE 8\nd. Arrays\n\nALGOL-M arrays may be of type integer, decimal, or string. Arrays may consist of up to 255 dimensions with each dimension containing up to 16,384 elements. The upper and lower bounds of each dimension may consist of any positive integers, variables, or arithmetic expressions. Each array name is associated with a unique PRT entry. The PRT entry contains the address pointer to the actual array storage area on the ALGOL-M machine stack. The first part of the array storage area on the stack consists of the displacement vector and other information which is necessary to calculate the address of any specific array element at run-time. The format for array storage is shown in Figure 9. The allocated storage area for each array element is exactly like that used for integers, decimals, or strings which are declared as single identifiers. The algorithm used for calculating the displacement vector is expressed as:\n\n$$D_i = \\begin{cases} \\text{IF } i = n \\text{ THEN } 1, \\text{ OTHERWISE } \\\\ (U_{i+1} - L_{i+1} + 1) \\cdot D_{i+1} \\end{cases}$$\n\nwhere \\( N \\) is the number of dimensions, \\( I \\) is the respective dimension, and \\( U \\) is the upper bound and \\( L \\) is the lower bound of a dimension.\n\nThe offset vector, \\( V \\), is calculated by:\n\n$$V = - \\sum_{i=1}^{N} L_i D_i$$\n\nThe offset vector represents the correction necessary for non-zero-origin subscripts. This approach to locating elements in dynamically declared arrays is essentially the same as that used in ALGOL-F [10].\nSTACK\n\nACTUAL STORAGE AREA FOR ARRAY ELEMENTS\n\nTOP ADDRESS FOR ARRAY STORAGE\n\nV SIZE\n\nD1\n\nN D_{n-1}\n\nPRT ENTRY FOR ARRAY NAME\n\nARRAY STORAGE ON THE STACK\n\nFIGURE 9\n4. Storage and Retrieval of Variables\n\nOnce allocation of storage for variables has been completed at run-time, storage and retrieval of actual values is relatively simple. A check is first made to insure that the number of bytes to be stored is less than or equal to the storage space allocated for a given variable. In the case of strings, if the destination storage space is not large enough to hold the entire string, as many characters as possible are stored and a run-time warning message is issued advising that string overflow has occurred. For decimal storage, if the total number of packed digits to be stored is larger than the available storage space, non-significant digits are deleted until the decimal value can be stored. If a significant digit must be deleted in order to store a decimal value, an error message is generated and the stored decimal value is arbitrarily set to 1.0 to allow continuation of program execution.\n\nArray elements are stored exactly as the corresponding single element variables. However, the data located at the beginning of each array storage area (refer to Figure 9) is used to calculate the actual location of a specific array element. This is accomplished by initializing the offset variable to the value of the rightmost subscripted value. This value is then added to the product of the next rightmost subscripted value and the n-1 displacement vector value. This procedure is continued until the left-most subscripted value has been used in\nthe calculation. Next the offset vector, \\( v \\), plus one, is subtracted from the offset variable and the result is multiplied by the size of the area allocated to each array element. The result of this calculation is the total offset, in bytes, from the beginning of the storage area for the array to the specific array element in question. A check is made to insure the calculated total offset is not greater than the offset which would result in access to the last array element. An error message is generated by the interpreter if a subscripted variable is referenced with subscripts that are not within the declared array dimensions.\n\n5. Arithmetic Operations\n\nArithmetic operations for integer variables are straightforward because the implementation language, PL/M \\( (R) \\), provides all of the necessary two byte arithmetic operations. Therefore, the two integer values which are to be added, subtracted, multiplied, or divided are placed one above the other on the stack and the appropriate routine performs the necessary arithmetic operation, replacing the original two integer values with the result of that operation. The resulting value is then available to store into the space allocated for an integer variable or to be used as one of the integer values for continued arithmetic operations.\n\nDecimal arithmetic is accomplished by manipulating packed decimal strings, each of which is loaded in a ten\nyte register (two digits per byte). The result of the\ndecimal arithmetic operation is stored in a third\nregister. Decimal values are also stored in the packed\ndecimal form, shown in Figure 6. Decimal strings are only\nunpacked when and if they are written to disk or console\nat run-time. Decimal addition is accomplished by\nadding the two registers, subtraction is done using\nnines complement arithmetic, multiplication is done\nthrough a shift and add algorithm, and division by a shift\nand subtract method. After the decimal arithmetic\noperation is completed, the result is placed on the top of\nthe stack in preparation for a decimal store operation or\nuse as a new value in a continuing algebraic expression.\n\n6. String Operations\n\nThe ALGOL-M compiler is designed to handle strings\nup to 255 characters in length. The concatenation operator\nallows two or more strings to be combined to produce a new\nstring consisting of all the characters contained in\nthe original strings. The process of concatenation takes\nplace on the stack with strings being combined\nrepeatedly as necessary for multiple concatenations.\nThe resulting string is then available for storage in\nthe space allocated to a string identifier. If the result\nof concatenation produces a string which is longer than\nthe allocated storage space, the string is truncated as\nnecessary and an error message is issued by the interpreter.\n7. Subroutines\n\nThere are two types of subroutines in ALGOL-H: functions and procedures. The only difference between the two is that a function returns a value to the top of the stack while a procedure does not. Subroutines are fully recursive and can be called prior to their declaration.\n\na. Invocation\n\nA subroutine can be invoked with zero or more actual parameters. The actual parameters consist of integer, decimal, or string expressions which are evaluated and passed to the subroutine via the execution stack. In addition to parameter values, the only other information needed to call a procedure is the procedure address in the code area. The actual format of the stack at the point of a subroutine call is indicated in Figure 10.\n\nb. Storage Allocation\n\nStorage for variables and parameters declared within a subroutine is allocated on the stack at run-time. The actual parameters and the subroutine call information is also stored on the execution stack. To allow subroutine call by value and to save memory, it was necessary to move the actual parameter values and subroutine call information off the stack prior to allocating storage for the formal parameters and local variables. This was accomplished by moving them to the top of available memory. Storage can then be allocated for the formal parameters on top of the\nSTACK CONFIGURATION FOR PRO OPERATOR\n\nBEFORE\n\n AFTER\n\n<TOP OF MEMORY\n\n<RETURN ADDR\n\n<ADDR OF SUBR IN CODE AREA\n\n<1st PARM TYPE\n\n<PARAMETER\n\n<2nd PARM TYPE\n\n<PARAMETER\n\n<1st PARM TYPE\n\n<PARAMETER\n\n<2nd PARM TYPE\n\n<PARAMETER\n\nFIGURE 10\nstack in the normal manner. This move was accomplished through the SAV operator as illustrated in Figure 11. The SAV operator also checks to determine if the call is a recursive call and if so, saves the procedure control block (PCB) on top of the stack. The PCB is similar in structure to that of ALGOL-E10. Although this procedure slows down the execution speed of the interpreter, it was considered more important to save memory space. Storing subroutine values on the stack as indicated above simplifies the reallocation of memory at the end of the subroutine. This is accomplished by simply removing elements from the stack down to the appropriate level.\n\nc. Parameter Mapping\n\nParameter mapping is done through the use of the SV2 operator as illustrated in Figure 12. The operator copies the actual parameter information at the top of memory into the area allocated on top of the stack. The PCR which keeps track of subroutine variables is then set with pointers to the current parameter values.\n\nd. Function Return Value\n\nIncluded with the allocated area for parameters and local variables, there is an additional allocated area for the return value of functions. The function name is treated as a simple variable within the function and the return value is assigned to it. This value is copied to the top of the stack when the function returns.\nSTACK CONFIGURATION FOR\nSAV OPERATOR\n\nSTACK BEORE\n\nPRT\n\nLOCAL VARIABLES\n\nFORMAL\n\nPARAMETER\n\nPOINTERS\n\n<ALLOCATION\n\n<LENGTH (FOR FUNC)\n\n<SAVED BLOCK\n\n<POINTER\n\n<PTR FOR RETURN\n\nVALUE\n\nAFTER\n\nTOP OF MEMORY\n\nRETURN ADDRESS\n\nACTUAL PARM COUNT\n\n1st PARM TYPE\n\nPARAMETER\n\nCALL INFORMATION (MOVED OFF\n\nSTACK) AREA USED TO SAVE\n\nPCB FOR RECURSIVE CALLS\n\nFIGURE 11\n\n42\nSTACK CONFIGURATION FOR SV2 OPERATOR\n\nFIGURE 12\n\nSTACK\n\n<TOP OF MEMORY\n<RETURN ADDR\n<PARM COUNT\n<1st PARM TYPE\n<PARAMETER\n<2nd PARM TYPE\n<PARAMETER\n\nTHIS DATA IS COPIED INTO THE AlLOCATED AREA\n\nALLOCATED AREA\n\nPRT\n\nPCB\ne. External Functions\n\nThe ALGOL-M grammar supports external function declarations and, although they have not been implemented, their design has been considered. External functions are conceived to be ALGOL-M intermediate files which could be declared and called from other ALGOL-M programs. The intermediate code for these files would be read from disk by the compiler and integrated into the program intermediate code as if the external subroutine had in fact been a normal program subroutine. The grammar would require modification in order to allow a subroutine to be compiled by itself.\n\nf. Forward References\n\nForward subroutine references are supported by simply treating all undeclared identifiers as forward subroutine references during pass one of the compiler. If on pass two these references have not been resolved, then an undeclared variable error is generated by the compiler.\n\ng. Built-in Functions\n\nThere are currently no built-in functions in ALGOL-M. However, their implementation has been considered. To implement built-in functions, a simple modification to the symbol table structure would be needed, allowing the built-in function names to be entered in the symbol table when it is initialized. There would be an operator associated with each function name in the symbol table which would indicate the run-time action to\nbe taken. This operator would be emitted each time the built-in function was referenced.\n\n8. Input-Output\n\nTwo basic types of input-output (I/O) are implemented in the ALGOL-M language: console and disk. Console I/O refers to the device which is being used to provide commands to the system, typically a cathode-ray tube terminal or a teletype. Input is accomplished via ALGOL-M program READ statements and output via WRITE or WRITEON statements. Integer and decimal values, including signs and decimal points, are converted from their internal representation into ASCII characters which are provided to an operating system print routine for console output. String variables and constants are stored in the ALGOL-M pseudo-machine as ASCII strings and are sent character by character to the system print routine. Console input is accomplished via an operating system routine which reads one full console line into an ALGOL-M buffer. The interpreter examines the buffer and converts the ASCII characters in the buffer into the appropriate ALGOL-M internal decimal, integer or string format. The input value is then stored in the space allocated for its variable name.\n\nThe ALGOL-M READ or WRITE statement for disk I/O contains the name of the disk file to be used and optionally, specifies the disk drive containing that file. The default drive is the currently logged drive [4].\nadditional option is that any specific record on the file may also be specified in the ALGOL-M READ or WRITE statement. A file declaration statement is used to associate file identifier names with a specific entry in the ALGOL-M PRT. At run-time, space is allocated on the ALGOL-M stack for file control block (FCB) information necessary to interface file operations with the operating system. In addition to the FCB, space is also allocated for a 128-byte I/O buffer for each declared file. The routines to convert packed decimal and integer numbers from internal form to ASCII form, and vice-versa, which are used for writing to and reading from disk files are the same as those used for console I/O. Any number of files may be open simultaneously and, as with all run-time storage, the space allocated on the stack for file operations is recovered when the block is exited.\n\n9. ALGOL-M Pseudo Operators\n\na. Description of Interpreter Variables\n\nThe top item on the ALGOL-M stack is addressed by the variable RA while the next-to-top item on the stack is addressed by the variable RB. The value contained in the first two bytes addressed by RA and RB are referenced by the variables APA and APB respectively. The contents of the low-order byte of AR and ARB is referenced by the variable BPA or BRB respectively. The structure of the stack is shown in Figure 4. Decimal and string values may be represented on the stack by an address which yields the\nactual storage area for the value, or by the actual value itself stored as one of the items on the stack. When a decimal or string value is stored on the stack, it is referred to as a temporary value. Temporary values are stored on the stack in preparation for storage into the area allocated to a specific identifier, or for use as a value in the evaluation of an expression.\n\nThe ALGOL-M compiler generates various pseudo operators which were chosen to allow effective run-time execution of the ALGOL-M pseudo machine. Following is a list of the pseudo operators and a brief description of the action taken at run-time when each operator is encountered in the ALGOL-M code area.\n\nb. Literal Data References\n\nAn initial check is made of each one byte operator in the code area in order to determine if the high order bit of that byte is set to one. If the high order bit is set then the least significant 14 bits of that byte and the following byte are automatically added to the address of the beginning of the program reference table and placed on top of the stack. A check is then made of the second bit of the original byte and if it also is set to one the PRT address now on top of the stack is replaced by the contents of the two bytes pointed to by that address. These are referred to as LIT and LITLOC operators.\n\nINT: (integer). The following two byte integer value is placed on the stack.\nSTR: (string). The program counter is incremented past the following string constant and the address of the next-to-last byte of the string constant is placed on the stack.\n\nDECT: (decimal). The program counter is incremented past the following decimal constant and the address of the next-to-last byte of the decimal is placed on the stack. The next-to-last byte of the decimal constant contains the offset to the first byte of the constant which in turn contains the value of the number of bytes in which actual decimal digits are stored.\n\nIM1: (load a one byte integer). The value of the following byte is converted to a two byte value and placed on the stack.\n\nIM2: (load a two byte integer). The following two byte value is placed on the stack in reverse order.\n\nc. Allocation Operators\n\nALD: (allocate decimal). Storage for a decimal variable is allocated on the stack and the address of the allocated area is placed in the PRT entry for the specific decimal variable.\n\nALS: (allocate string). Storage for a string variable is allocated on the stack and the address of the allocated area is placed in the PRT entry for the specific string variable.\n\nATD: (allocate intermediate decimal). The same action is taken as in ALD except the declared decimal length\nis left on top of the stack in preparation for the next allocation which is expected to immediately follow in the code area. This operator is used when several decimal identifiers are declared in a single declaration statement.\n\nAIS: (allocate intermediate string). The same action is taken as in the AID operator with the exception that string allocation is used.\n\nd. Arithmetic Operators\n\nADD: (add integer). The integer values of the top two items on the stack are replaced by their integer sum.\n\nADD: (add decimal). The decimal value of the top item on the stack is loaded into decimal arithmetic register zero, and the value of the second item on the stack is loaded into decimal arithmetic register one. The two arithmetic registers are added with the result placed in register two. The original decimal values on the stack are replaced by the result of the arithmetic operation.\n\nSBI: (subtract integer). The second integer value on the stack is subtracted from the integer value on top of the stack, both values are removed from the stack and the result of the operation is placed on top of the stack.\n\nSRD: (subtract decimal). The same action is taken as in the ADD operator except the second item is subtracted from the top item on the stack.\n\nMPI: (multiply integer). The same action is taken as in the SBI operator except the top two items are\nmultiplied.\n\nMPD: (multiply decimal). The same action is taken as in the ADD operator except the top two items are multiplied.\n\nDVI: (divide integer). The same action is taken as in the SRI operator except the top item is divided by the second item.\n\nDVD: (divide decimal). The same action is taken as in the ADD operator except the top item is divided by the second item.\n\nNEG: (negative). The sign of the decimal or integer on top of the stack is changed.\n\nCTI: (convert integer). The integer on top of the stack is replaced by its decimal equivalent.\n\nCT2: (convert integer). The same action is taken as with CTI except the integer which is the second item on the stack is converted to a decimal.\n\nLSS: (integer less than). The integer value (ARB) is compared with the integer value (ARA). Both values are removed from the stack. If ARB was less than ARA, the value one is placed on the stack, otherwise the value zero is placed on the stack.\n\nDLSS: (decimal less than). The decimal on top of the stack is compared to the decimal which is the second item on the stack. If the value on top of the stack is less than the second value on the stack, both values are removed from the stack and replaced by the value one, otherwise they are replaced by the value zero.\nGTR: (integer greater than). The same action is taken as in the LSS operator except a one is placed on the stack if ARB is greater than ARA.\n\nDGTR: (decimal greater than). The same action is taken as in the DLSS operator except a one is placed on the stack if the second decimal item is greater than the top decimal item.\n\nEQL: (integer equal to). The same action is taken as in the GTR operator except a one is placed on the stack if ARB is equal to ARA.\n\nDEQL: (decimal equal to). The same action is taken as in the DGTR operator except a one is placed on the stack if the second decimal item is equal to the top decimal item.\n\nNEQ: (integer not equal to). The same action is taken as in the EQL operator except a one is placed on the stack if ARB is not equal to ARA.\n\nDNEQ: (decimal not equal to). The same action is taken as in the DEQL operator except a one is placed on the stack if the second decimal item is not equal to the top decimal item.\n\nGEU: (integer greater than or equal to). The same action is taken as in the NEQ operator except a one is placed on the stack if ARB is greater than or equal to ARA.\n\nDGEO: (decimal greater than or equal to). The same action is taken as in the DNEQ operator except a one is placed on the stack if the second decimal item is greater than or equal to the top decimal item.\nLEQ: (integer less than or equal to). The same action is taken as in the GEQ operator except a one is placed on the stack if ARB is less than or equal to ARA.\n\nDLEQ: (decimal less than or equal to). The same action is taken as in the DGEQ operator except a one is placed on the stack if the second decimal value is less than or equal to the top decimal value.\n\nNOT: (boolean not). This operator changes the result of any previous boolean operator by complementing the value of the one or zero which was placed on the stack by the previous operation.\n\nAND: (boolean and). This operator checks the top two values left on the stack by any two previous boolean operations. If both values are one then both values are replaced with a one; otherwise both values are replaced with a zero.\n\nOR: (boolean or). This operator checks the top two values left on the stack by any two previous boolean operations. If either value is a one then both values are replaced by a one; otherwise they are replaced by a zero.\n\ne. String Operators\n\nCAT: (concatenate). The two strings on top of the stack are combined to produce a new string consisting of the characters of the second string followed by the characters of the first string. The two original strings are popped from the stack and replaced by the resulting concatenated string.\nSLSS: (string less than). The same action is taken as in the DLSS operator except that a character by character string comparison is made using the ASCII character collating sequence.\n\nSGTR: (string greater than). The same action is taken as in the DGTR operator except a string comparison is made.\n\nSFGL: (string equal to). The same action is taken as in the NEQL operator except a string comparison is made.\n\nSNEQ: (string not equal to). The same action is taken as in the DNEQ operator except a string comparison is made.\n\nSGEQ: (string greater than or equal to). The same action is taken as with DGEQ except a string comparison is made.\n\nSLEQ: (string less than or equal to). The same action is taken as with DLEQ except a string comparison is made.\n\nf. Stack Operators\n\nACH: (exchange). The value of the top two bytes on the stack (ARA) is exchanged with the value of the next-to-top two bytes on the stack (ARB).\n\nPOP: (pop the stack). The stack pointer (RA) is moved to the position of the stackpointer (RB) and Pb is moved to point to the next item below its current position on the stack.\nLOD: (load). The address value on the stack (ARA) is replaced by the two bytes pointed to by that address.\n\nDCB: (decrement block by more than one level): The stack pointer (RA) is decremented to the address stored in the block level table and the index to the clock level table is decreased by the value stored in the next two bytes in the code area. The stack pointer (RA) is moved below RA to the top of the second item on the stack.\n\nBLI: (clock level increment). The index to the block level array is increased by one and the address of the top item on the stack is stored in the block level array.\n\nDLI: (clock level decrement). The index to the block level array is decreased by one and the value of the stack pointer (RA) is changed to the address stored in the block level array.\n\nSPR: (subtract stack values). This operator is used to subtract the second value on the stack from the top value on the stack using unsigned sixteen bit arithmetic. The two values are replaced by the result of the subtraction.\n\ng. Array Operators\n\nRAW: (allocate array storage). The number of array dimensions, the upper and lower bounds of each dimension, and the array type (integer, decimal, or string) are used to calculate the array displacement vector which is stored on the stack prior to allocation of storage for the\nactual array elements.\n\n**SUB**: (calculate the offset to a specific array element). The array subscript is used in conjunction with the displacement vector information stored at the beginning of the array storage area to calculate the address of the specific array element being referenced by the subscripted variable.\n\n**n. Program Control Operators**\n\n**bRS**: (branch absolute). The program counter is changed to an address one less than the address represented by the following two bytes in the code area.\n\n**bPC**: (branch conditional). If the value on top of the stack is zero, the program counter is changed as in **bRS**; otherwise the program continues with the next operator in the code area.\n\n**BRA**: (computed branch absolute). The program counter is changed relative to the start of the code area by the value on top of the stack.\n\n**XIT**: (exit the interpreter). XIT caused return of control to the operating system.\n\n**i. Store Operators**\n\n**STI**: (store integer intermediate). The integer value which is the second item on the stack is stored in the PRI address which is the top item on the stack. The PRI address is then removed from the stack.\n\n**SDI**: (store decimal intermediate). The same action is taken as with **STI** except a decimal value is stored.\nin the allocated area pointed to by the address on top of\nthe stack.\n\n**SSI:** (store string intermediate). The same\naction is taken as in the SDI operator except a string value\nis stored.\n\n**SID:** (store integer destruct). The same action\nis taken as in the SII operator except both the PRT address\nand the integer value are removed from the stack.\n\n**SDU:** (store decimal destruct). The same action\nis taken as in the SID operator except the pointer to the\ndecimal allocated area and the decimal value are removed\nfrom the stack.\n\n**SSD:** (store string destruct). The same action\nis taken as in the SSD operator except the pointer to the\nstring allocated area and the string value are removed from\nthe stack.\n\nj. Input/Output Operators\n\n**DMP:** (dum). DMP signifies the end of writing a\nline to the console. A carriage return and line feed are\noutput to the console via the operating system.\n\n**WIC:** (write integer to console). The integer\nvalue on top of the stack is converted to ASCII characters\nand printed on the console.\n\n**ADC:** (write decimal to console). The decimal\nvalue on top of the stack is converted to ASCII characters\nand printed on the console.\n\n**ASC:** (write string to console). The ASCII\nstring value on top of the stack is printed on the console.\n\nWID: (write integer to disk). The integer value on top of the stack is converted to ASCII characters and stored in the disk buffer allocated for the file name specified in the source WRITE statement.\n\nWDD: (write decimal to disk). The decimal value on top of the stack is converted to ASCII characters and stored in the disk buffer allocated for the file name specified in the source WRITE statement.\n\nWSU: (write string to disk). The ASCII string characters on top of the stack are stored in the disk buffer allocated for the file name specified in the source WRITE statement.\n\nRCI: (read console integer). The console read buffer is scanned for the ASCII representation of an integer which is converted into internal form and placed on top of the stack.\n\nRCD: (read console decimal). The console read buffer is scanned for the ASCII representation of a decimal value which is converted into internal form and placed on top of the stack.\n\nRCS: (read console string). The console read buffer is scanned for an ASCII string or for any series of characters delimited by quotation marks which is placed on top of the stack.\n\nRFI: (read disk integer). The disk buffer allocated to the file name appearing in the source language READ statement is scanned for the ASCII representation of an\ninteger which is converted to internal form and stored on top of the stack.\n\nRDD: (read disk decimal). The same action is taken as in the RDI operator except a decimal value is placed on top of the stack.\n\nRDS: (read disk string). The same action is taken as in the RDI operator except a string value is placed on top of the stack.\n\nRCN: (load console buffer). The current line on the console is dumped into the console read buffer and the current program counter is stored in preparation for the possibility of a console error and the subsequent need to recover for repeated console input.\n\nECR: (error in console read). If characters remain in the console read buffer after all console read operations have been completed, an error condition exists and the program counter is reset to the start of the console read routine allowing the console input to be entered again as necessary.\n\nUPN: (disk open). The address on top of the stack points to the allocated area for the file control block and disk buffer associated with the disk file name specified in the source language file declaration statement. The file name which is stored in the file control block is passed to the operating system which in turn opens that specific file for disk input/output.\n\nCLS: (disk close). The file name located in the file control block pointed to by the address of the top of\nthe stack is passed to the operating system which in turn closes that specific file to input/output.\n\nRDB: (ready sequential block). The interpreter input/output routines are initialized to operate with the file control block and disk buffer area pointed to by the address on top of the stack. The address of the code to be executed upon reaching the end of a file is also initialized.\n\nRDF: (ready random block). The same action is taken as with RDB with the addition that the specific record of the disk file is also taken from the top of the stack and the file control block is set up to conduct input/output from or to that specific record.\n\nEDR: (end of record for read). At the end of a read statement the remainder of the record is skipped.\n\nENW: (end of record for write). At the end of a write statement the remainder of the record is filled with blanks and a line terminator is appended to the end of the record.\n\nk. Subroutine Operators\n\nPRU: (subroutine call). The two bytes of code following the PRU operator represent the address of the subroutine in the code area. This operator saves the return address at the top of memory, positions the stack pointer at the top of the first actual parameter (see Figure 10 for parameter format) and branches to the first statement in the subroutine.\nSAV: (save actual parameters). The SAV operator expects the stack format illustrated in Figure 11. It copies the actual parameters to the top of memory and checks the PCB for a recursive call and if so it copies the PCR onto the top of the stack.\n\nSV2: (copy actual parameters into formal parameters). The SV2 operator copies the actual parameters at the top of memory into allocated area for the formal parameters on top of the stack.\n\nUNS: (unsafe parameters). The UNS operator checks the PCB to see if it is the end of a recursive call. If this is the case, UNS restores the PCB from the previous call. UNS also returns the value associated with the name of the subroutine to the top of the stack. In the case of procedures the returned value is zero.\n\nRTN: (return). The RTN operator changes the value of the program counter to the value of the return address.\nIV. CONCLUSIONS\n\nThis project has resulted in the construction of a high-level, block-structured, applications oriented compiler for micro-computers with 20k bytes of memory or more. When compared to a fully dynamic scheme, the stack storage allocation and retrieval scheme presented here appears to enhance program execution speed, reduce memory requirements, and simplify compiler implementation.\n\nTiming tests with several benchmark programs have been conducted. These test programs were obtained from REFLI and have been run with several versions of the BASIC programming language. The results (expressed as execution time in seconds) are summarized as follows:\n\n<table>\n<thead>\n<tr>\n<th>BENCHMARK NUMBER</th>\n<th>1</th>\n<th>2</th>\n<th>3</th>\n<th>4</th>\n<th>5</th>\n<th>6</th>\n<th>7</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ALGOL-M</td>\n<td>1.8</td>\n<td>1.3</td>\n<td>3.5</td>\n<td>7.3</td>\n<td>9.1</td>\n<td>14.2</td>\n<td>16.4</td>\n</tr>\n<tr>\n<td>INTEGER BASIC</td>\n<td>1.3</td>\n<td>3.1</td>\n<td>7.2</td>\n<td>7.2</td>\n<td>8.8</td>\n<td>18.5</td>\n<td>28.0</td>\n</tr>\n<tr>\n<td>STANDARD BASIC</td>\n<td>1.7</td>\n<td>7.5</td>\n<td>20.9</td>\n<td>20.9</td>\n<td>22.1</td>\n<td>36.2</td>\n<td>51.8</td>\n</tr>\n</tbody>\n</table>\n\nListings of the seven benchmark programs are contained in Appendix A. The reason ALGOL-M appears slower in the first benchmark is that the grammar requires at least one executable statement in FOR loops when compared to BASIC which has FOR loops which can do nothing. The resulting ALGOL-M program executes 1000 extra assignment statements which the BASIC programs did not. Otherwise, the results\nclearly indicate that the ALGOL-M language is not only well-structured but also executes rapidly in comparison with the very best BASIC interpreters. It is believed that the major reason that the ALGOL-M versions performed so well is the fact that the language supports integer arithmetic as opposed to most BASIC implementations which convert all constants and variables to floating point format. This allows ALGOL-M loop control counters to be incremented extremely rapidly. Comparisons for decimal calculations have not been done, and thus no conclusions can be drawn concerning relative speeds of calculation-dependent programs.\nV. RECOMMENDATIONS\n\nThere are several areas that could be enhanced in this implementation of ALGOL-M. Formatted I/O although defined in the grammar has not been implemented. The I/O definition is very similar to that of COBOL and implementation of this should not be too difficult. File I/O is implemented, but not tested. Debugging facilities in the run-time monitor are not currently implemented. However, the system is designed to provide the following information at run-time: the line number of the currently executing line and the value of each variable as it is altered.\n\nThe current version of ALGOL-M is designed to run on a system with at least 20k bytes of memory. A smaller system could be designed to run on a 16k system. This would involve deleting some of the more complicated sections of code such as dynamic arrays and recursive subroutines. The other features of the language which are not implemented are relatively minor, and are indicated in the program listings.\nAPPENDIX A - BENCHMARK PROGRAMS\n\nBenchmark Program 1\n\n300 PRINT \"START\"\n400 FOR K=1 TO 1000\n500 NEXT K\n700 PRINT \"END\"\n800 END\n\nBEGIN\nINTEGER A,K;\nWRITE(\"START\");\nFOR K:=1 STEP 1 TO 1000 DO\nA:=0;\nWRITE(\"END\");\nEND\n\nBenchmark Program 2\n\n300 PRINT \"START\"\n400 K=0\n500 K=K+1\n600 IF K<1000 THEN 500\n700 PRINT \"END\"\n800 END\n\nBEGIN\nINTEGER K;\nWRITE(\"START\");\nK:=0;\nWHILE K < 1000 DO\nK:=K+1;\nWRITE(\"END\");\nEND\n\nBenchmark Program 3\n\n300 PRINT \"START\"\n400 K=0\n500 K=K+1\n600 A:=K/K*K+K-K\n610 IF K<1000 THEN 500\n700 PRINT \"END\"\n800 END\n\nBEGIN\nINTEGER A,K;\nWRITE(\"START\");\nK:=0;\nWHILE K<1000 DO\nBEGIN\nK:=K+1;\nA:=K/K*K+K-K;\nEND;\nWRITE(\"END\");\nEND\nbenchmark Program 4\n\n300 PRINT \"START\"\n400 K=0\n500 K:=K+1\n510 A:=K/2*3+4-5\n600 IF K<1000 THEN 500\n700 PRINT \"END\"\n800 END\n\nbenchmark Program 5\n\n300 PRINT \"START\"\n400 K=0\n500 K:=K+1\n510 A:=K/2*3+4-5\n520 GOSUB 820\n600 IF K<1000 THEN 500\n700 PRINT \"END\"\n800 END\n\nBEGIN\nINTEGER A,K;\nWRITE(\"START\");\nK:=0;\nWHILE K<1000 DO\nBEGIN\nK:=K+1;\nA:=K/2*3+4-5;\nEND;\nWRITE(\"END\");\nEND\n\nBEGIN\nINTEGER A,K;\nPROCEDURE DUMOTHING;\nA:=0;\nWRITE(\"START\");\nK:=0;\nWHILE K<1000 DO\nBEGIN\nK:=K+1;\nA:=K/2*3+4-5;\nDUMOTHING;\nEND;\nWRITE(\"END\");\nEND\nBenchmark Program 6\n\n300 PRINT \"START\"\n400 K=0\n430 DIM M(5)\n500 K=K+1;\n510 A=K/2*3+4-5\n520 GOSUB 820\n530 FOR L=1 TO 5\n540 NEXT L\n600 IF K<1000 THEN 500\n700 PRINT \"END\"\n800 END\n\nBEGIN\nINTEGER A,K,L;\nINTEGER ARRAY M(1:5);\nPROCEDURE DONOTHING:\nBEGIN\nA:=0;\nEND;\nWRITE(\"START\");\nK:=0;\nWHILE K<1000 DO\nBEGIN\nK:=K+1;\nA:=K/2*3+4-5;\nDONOTHING;\nFOR L:=1 STEP 1 UNTIL 5 DO\nA:=0;\nEND;\nWRITE(\"END\");\nEND\n\nBenchmark Program 7\n\n300 PRINT \"START\"\n400 K=0\n430 DIM M(5)\n500 K=K+1;\n510 A=K/2*3+4-5\n520 GOSUB 820\n530 FOR L=1 TO 5\n535 M(L)=A\n540 NEXT L\n600 IF K<1000 THEN 500\n700 PRINT \"END\"\n800 END\n820 RETURN\n\nBEGIN\nINTEGER A,K,L;\nINTEGER ARRAY M(1:5);\nPROCEDURE DONOTHING:\nBEGIN\nA:=0;\nEND;\nWRITE(\"START\");\nK:=0;\nWHILE K<1000 DO\nBEGIN\nK:=K+1;\nA:=K/2*3+4-5;\nDONOTHING;\nFOR L:=1 STEP 1 UNTIL 5 DO\nM(L):=A;\nEND;\nWRITE(\"END\");\nEND\n## APPENDIX B - COMPILER ERROR MESSAGES\n\n<table>\n<thead>\n<tr>\n<th>Code</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>AS</td>\n<td>Function/Procedure on left hand side of assignment statement.</td>\n</tr>\n<tr>\n<td>BP</td>\n<td>Incorrect bound pair subtype (must be integer).</td>\n</tr>\n<tr>\n<td>DE</td>\n<td>Disk error; no corrective action can be taken in the program.</td>\n</tr>\n<tr>\n<td>DD</td>\n<td>Doubly declared identifier, label, variable etc.</td>\n</tr>\n<tr>\n<td>IC</td>\n<td>Invalid special character.</td>\n</tr>\n<tr>\n<td>ID</td>\n<td>Subtypes incompatible (decimal values can not be assigned to integer variables).</td>\n</tr>\n<tr>\n<td>IO</td>\n<td>Integer overflow.</td>\n</tr>\n<tr>\n<td>IT</td>\n<td>Identifier is not declared as a simple variable or function.</td>\n</tr>\n<tr>\n<td>NG</td>\n<td>No ALG file found.</td>\n</tr>\n<tr>\n<td>NI</td>\n<td>Subtype is not integer.</td>\n</tr>\n<tr>\n<td>NP</td>\n<td>No applicable production exists.</td>\n</tr>\n<tr>\n<td>NS</td>\n<td>Subtype is not string.</td>\n</tr>\n<tr>\n<td>PC</td>\n<td>Undeclared parameter.</td>\n</tr>\n<tr>\n<td>SO</td>\n<td>Stack overflow.</td>\n</tr>\n<tr>\n<td>SI</td>\n<td>Array subscript is not of subtype integer.</td>\n</tr>\n<tr>\n<td>TD</td>\n<td>Subtype has to be integer or decimal.</td>\n</tr>\n<tr>\n<td>TM</td>\n<td>Subtypes do not match or are incompatible.</td>\n</tr>\n<tr>\n<td>TO</td>\n<td>Symbol table overflow.</td>\n</tr>\n<tr>\n<td>US</td>\n<td>Undeclared subscripted variable.</td>\n</tr>\n<tr>\n<td>UD</td>\n<td>Undeclared identifier.</td>\n</tr>\n<tr>\n<td>UF</td>\n<td>Undeclared file/function.</td>\n</tr>\n<tr>\n<td>UP</td>\n<td>Undeclared procedure.</td>\n</tr>\n</tbody>\n</table>\nVarc table overflow. Possibly caused by too many long identifiers.\nAPPENDIX C - INTERPRETER ERROR MESSAGES\n\nERROR MESSAGES\n\nAR Array subscript out of bounds.\nAZ Attempt to allocate null decimal or string, default to 10 digits/characters.\nCE Disk file close error.\nDC Disk file create error.\nDW Disk file write error.\nD7 Division by zero, result set to 1.0.\nEF Disk end of file, no action specified.\nIO Integer overflow.\nNI No TNT file found or directory.\nUV Overflow during decimal multiply.\nRE Attempt to read past end of record on blocked file.\nRU Attempt to random access a non-blocked file.\nSL Significant digits lost during decimal store, value set to 1.0.\n\nWARNING MESSAGES\n\nII Invalid Console Input\nIL Non-significant digit lost during decimal store.\nSM Characters lost during string store.\nThis section describes the various elements of the ALgOL-M language. The format of the element will be shown, followed by a description and examples of use. The following notation is used:\n\nBraces () indicate an optional entry.\nA vertical bar | indicates alternate choices, one of which must appear.\nEllipses \"...\" indicate that the preceding item may be optionally repeated.\nReserved words are indicated by capital letters.\nReserved words and other special symbols must appear as shown.\nItems appearing in small letters are elements of the language which are defined and explained elsewhere in the language manual.\nELEMENT:\n\narithmetic expression\n\nFORMAT:\n\ninteger:decimal\n\nvariable\n\n(() arithmetic expression binary operator arithmetic expression ())\n\n(() unary operator arithmetic expression ()),\n\nDESCRIPTION:\n\nOperators in ALCOL-M have an implied precedence which is used to determine the manner in which operators and operands are grouped. A-R/C causes the result of R divided by C to be subtracted from A. In this case R is considered to be \"bound\" to the \"/\" operator instead of the \"-\" operator which causes the division to be performed first. The implied precedence binds operands to the adjacent operator of highest precedence. The implied precedence of operators is as follows:\nParentheses can be used to override the implied precedence in the same way as they are used in ordinary algebra. Thus the expression $(A-B)/C$ will cause $b$ to be subtracted from $A$ and the result divided by $C$.\n\n**EXAMPLE:**\n\n$$ (Y + Y) \\times (Z + Y + X) \\times ? $$\n\n$$ x + y + z \\times x \\times y \\times z / 5.456 + 1 $$\nARRAY declaration\n\nELEMENT:\n\nARRAY declaration\n\nFORMAT:\n\nINTEGER;DECIMAL;STRING ((expression)) ARRAY\nidentifier ... bound pair list (,identifier)\n\nDESCRIPTION:\n\nThe array declaration dynamically allocates storage for arrays. The optional integer expression indicates the length of each array element. For strings, the maximum length is 255 characters and for decimals the maximum length is 19 digits. Integer lengths are not specified since storage adequate to represent all integer values between -10,384 and +10,384 is automatically allocated. Arrays are not automatically initialized to zero.\n\nEXAMPLE:\n\nINTEGER ARRAY x[0:5,0:5];\nDECIMAL(10) ARRAY x,y[0:5,5:10];\nSTRING ARRAY WORDS[y+3:12];\nassignment statement\n\nELEMENT:\nassignment statement\n\nFORMAT:\n\nvariable := (variable :=) ... expression\n\nDESCRIPTION:\nThe expression is evaluated and stored into the variable. The types of permissible assignments are indicated by the following table:\n\n<table>\n<thead>\n<tr>\n<th>expression</th>\n<th>integer</th>\n<th>decimal</th>\n<th>string</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>integer</td>\n<td>yes</td>\n<td>no</td>\n<td>no</td>\n</tr>\n<tr>\n<td>variable</td>\n<td>yes</td>\n<td>yes</td>\n<td>no</td>\n</tr>\n<tr>\n<td>decimal</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>string</td>\n<td>no</td>\n<td>no</td>\n<td>yes</td>\n</tr>\n</tbody>\n</table>\n\nMultiple assignments are allowed with the expression being assigned to all of the listed variables.\n\nEXAMPLE:\n\nx := y + z;\n\nELEMENr:\nbalanced statement\n\nFORMAT:\n\n(label definition) simple statement\n\n(label definition) IF boolean expression THEN balanced statement ELSE balanced statement\n\nDESCRIPTION:\n\nIf the boolean expression is true, the balanced statement to the left of the ELSE is executed. If the boolean expression is false, the balanced statement to the right of the ELSE is executed.\n\nEXAMPLE:\n\nIF A < R THEN A := 1 ELSE A := 2;\n\nIF R = C THEN\nBEGIN\n WRITE(R);\n R := R + 1;\nEND\nELSE\nBEGIN\n WRITE(C);\n C := C + 1;\nEND;\n\nPROGRAMMING NOTE:\n\nA semicolon is not allowed after the statement.\nimmediately preceding an ELSE.\nELEMENT:\n\nblock\n\nFORMAT:\n\nBEGIN (declaration; ...) statement; ... END;\n\nDESCRIPTION:\n\nThe block is the foundation of the ALGOL-W language. Each time a new block is entered new variables may be declared. These variables are unique in the sense that a variable \\( x \\) declared in two different blocks represents two different variables. All storage within a block is dynamic and allocated when the block is entered and de-allocated when the block is departed. A block can be used anywhere a simple statement can be used.\n\nEXAMPLE:\n\n```\nBEGIN\n X := 1;\n Y := 2;\nEND;\n\nIF X = Y THEN\n BEGIN\n Y := 5;\n Y := 4;\n END;\n```\n\nPROGRAMMING NOTE:\nDeclarations may not appear in case blocks. The final END, which matches the initial program BEGIN, is not followed by a semicolon.\nboolean expression\n\nELEMENT:\n\nboolean expression\n\nFORMAT:\n\nNOT boolean expression\n\nboolean expression OR boolean expression\n\nboolean expression AND boolean expression\n\n{{ expression =!<;>;>=!<=;<> expression }}\n\nDESCRIPTION:\n\nInteger-integer, decimal-integer, decimal-decimal, integer-decimal, and string-string comparisons are allowed in ALGOL-M. For integer-decimal and decimal-integer comparisons the integer value is converted to a decimal value prior to comparison. The result of a comparison of numerical values is based on the size of the numbers. The result of a comparison of string values depends on a character-by-character comparison where the first instance of a non-equal character establishes the boolean result. The collating sequence of the ASCII character set is used for string comparisons. Generally, numbers are followed by upper case letters which are followed by lower case letters.\n\nEXAMPLE:\n\\[x > y \\text{ or } y < z;\\]\n\\[(x = y) \\text{ and } (y = 7 \\text{ or } z = 10);\\]\n\\[\\text{if not } x = 1 \\text{ then write(\"HELLO\");}\\]\nbound pair list\n\nELEMENT:\n\nbound pair list\n\nFORMAT:\n\n(expression : expression{,expression : expression} ...)\n\nDESCRIPTION:\n\nExpressions in the bound pair list must be of type integer and greater than or equal to zero. There can be no more than 255 dimensions.\n\nEXAMPLE:\n\n(1:7,0:5)\n(3:6,0:v)\n(v*3:z,1:12)\nCASE statement\n\nELEMENT:\n\nCASE statement\n\nFORMAT:\n\nCASE expression OF\n\nBEGIN\n\nstatement; ...\n\nEND;\n\nDESCRIPTION:\n\nThe CASE statement allows the programmer to choose one of several statements to be executed. The statement chosen depends on the value of the integer expression. The first statement is executed if the expression evaluates to zero. If the value of the expression is greater than the number of statements in the case block, the resulting action is undefined.\n\nEXAMPLE:\n\nCASE X + Y OF\n\nBEGIN\n\nWRITE(\"CASE 0\");\n\nWRITE(\"CASE 1\");\n\nEND;\nCLOSE statement\n\nELEMENT:\n\nCLOSE statement\n\nFORMAT:\n\nCLOSE identifier (identifier) ...\n\nDESCRIPTION:\n\nThis statement allows the programmer to explicitly close the file specified. Closing a file results in the file being rewound (i.e., if it is reopened the file begins at the first record). Any number of files may be open at any one time. All files are implicitly closed at the end of the program.\n\nEXAMPLE:\n\nCLOSE FILE1, FILE2;\nconstant\n\nELEMENT:\n\nconstant\n\nFORMAT:\n\ninteger|decimal|string\n\nDESCRIPTION:\n\nA constant may be either an integer, decimal, or string constant. Integer constants are numbers with no decimal point ranging from -15,364 to +10,384. Decimal constants are numbers with a decimal point and may not exceed 18 digits in length. String constants may be composed of any combination of alphanumeric and special characters and may be up to 255 characters in length. Strings entered from the console or disk may be either enclosed in quotation marks or delimited with blanks. Strings used as constants in the program must be enclosed in quotation marks.\n\nEXAMPLE:\n\n10\n10.5678\n\"EXAMPLE ONE\"\nELEMENT:\n\ndeclaration\n\nDESCRIPTION:\n\nSee FILE declaration, ARRAY declaration, simple declaration, procedure declaration, and function declaration.\nELEMENT:\n\nexpression\n\nFORMAT:\n\nboolean expression!arithmetic expression\n\nDESCRIPTION:\n\nSee arithmetic expression and boolean expression.\nFILE declaration\n\nEXAMPLE:\n\nFILE TAPE1, TAPE2(128);\nFOR statement\n\nELEMENT:\n\nFOR statement\n\nFORMAT:\n\n(label definition) FOR assignment statement\n*(STEP expression) UNTIL expression DO simple statement\n\nDESCRIPTION:\n\nExecution of all statements within the simple statement are repeated until the indexing variable is greater than or equal to the value of the UNTIL expression. The indexing variable is incremented by the amount specified in the STEP expression and must be incremented by a positive amount. The UNTIL and STEP expressions are evaluated on each loop. If the optional STEP expression is omitted, a default value of one is used.\n\nEXAMPLE:\n\nFOR I := 1 STEP 1 UNTIL 10 DO\n X := Y;\n\nFOR INDEX := X + Y UNTIL X + Y DO\n BEGIN\n A := A + R;\n WRITE(A);\n END;\nFUNCTIONS\n\nFUNCTIONS may appear as primary elements in arithmetic or boolean expressions. Parameter passing is by value. Functions may be called recursively with no limit to the number of recursive calls allowed.\n\nEXAMPLE:\n\nx := RAND;\ny := SUM(5.0);\nc := FUNC * RND(2);\nA function declaration may or may not include parameters. If parameters are included they must be declared before the simple statement which represents the body of the function. Parameters are passed by value and may be of type integer, decimal, or string. Functions return a value to the point of call. The value to be returned is assigned to the function name (which is used as a simple variable within the function) prior to the end of the function. Functions may be called recursively with no limit set as to the number of recursive calls which can be made. Variables may be declared within functions and are considered local to the function.\n\n**Example:**\n\n```plaintext\nINTEGER FUNCTION VALUF(Y);\n```\nINTEGER X;\nBEGIN\nX := (X * 5) + (Y * 2);\nVALUE := X;\nEND;\nGOTO statement\n\nELEMENT:\n\nGOTO statement\n\nFORMAT:\n\nlabel definition GOTO identifier;integer\nlabel definition GOTO identifier;integer\n\nDESCRIPTION:\n\nExecution continues at the statement labeled with the identifier or integer following the GOTO or GO TO statement.\n\nEXAMPLE:\n\nNEXT: GO TO 100;\n100: GOTO NEXT;\n\nPROGRAMMING NOTE:\n\nGOTO statements can only be used to branch within the current block or to an outer block.\nELEMENT:\n\nidentifier\n\nFORMAT:\n\nletter (letter|number) ...\n\nDESCRIPTION:\n\nIdentifiers begin with a letter and are continued with any alphanumeric characters. Although identifiers up to 255 characters may be used, only the first 31 characters are actually used to distinguish the identifiers.\n\nEXAMPLE:\n\nA\n\nNAME\n\nCOUNTER1\nIF statement\n\nELEMENT:\n\nIF statement\n\nDESCRIPTION:\n\nSee balanced statement or unbalanced statement.\nLabel definitions are optional on all balanced or unbalanced statements.\nprocedure call\n\nELEMENT:\n procedure call\n\nFORMAT:\n identifier ((expression ,expression) ...))\n\nDESCRIPTION:\n\nProcedures can be called with or without parameters. Parameter passing is by value. Procedures can be called recursively with no limit set as to the number of recursive calls.\n\nEXAMPLE:\n\n COMPUTE;\n COMPARE(\"AAA\", WORD);\n COUNT(1, 2, 3);\nprocedure declaration\n\nELEMENT:\n\nprocedure declaration\n\nFORMAT:\n\nPROCEDURE identifier ((identifier (,identifier) ...))\n{declaration; ...} simple statement\n\nDESCRIPTION:\n\nA procedure declaration may or may not include parameters. If parameters are included they must be declared before the simple statement which represents the body of the procedure. Parameters are passed by value and may be of type integer, decimal or string. Procedures do not return a value to the point of call. Procedures can be called recursively. Procedures are considered separate blocks within which local variables may be declared.\n\nEXAMPLE:\n\nPROCEDURE OUTPUT;\nWRITE (\"HELLO\");\n\nPROCEDURE COMPARE(X,Y);\nINTEGER X,Y;\nBEGIN\nWRITE(\"THE LARGEST INTEGER IS \");\nIF X > Y THEN\nWRITE(X);\nELSE\nWRITE(Y);\nEND;\nREAD statement\n\nELEMENT:\n\nREAD statement\n\nFORMAT:\n\nREAD (variable (,variable) ...) (ONENDFILE block)\n\nDESCRIPTION:\n\nIf the form of the READ statement is READ(), then the input device is the console. Otherwise a file action must be specified and the input device is the disk. A READ statement reads one or more variables at a time. The optional ONENDFILE section indicates action to be taken when the end of the specified file is reached.\n\nEXAMPLE:\n\nREAD(WURDONE, X, VALUE2);\nREAD FILE3 (WURDONE, X, VALUE2);\n\nPROGRAMMING NOTE:\n\nThe ONENDFILE section is currently not implemented.\nreserved word list\n\nELEMENT:\n\nreserved word list\n\nFORMAT:\n\nletter (letter) ...\n\nDESCRIPTION:\n\nThe following words are reserved by ALGOL-M and may not be used as identifiers:\n\nAND ARRAY BEGIN CASE\nCLOSE DECIMAL DO ELSE\nEND EXTERNAL FILE FUNCTION\nGO GOTO IF INITIAL\nINTEGER NOT OF ONENDFILE\nOR PIC PROCEDURE READ\nSTEP STRING TAB THEN\nTO UNTIL WHILE WRITE\n\nReserved words must be preceded and followed by either a special character or a space. Spaces may not be embedded within reserved words.\nsimple statement\n\nELEMENT:\n\n simple statement\n\nFORMAT:\n\n block; assignment statement; for statement;\n case statement; close statement; goto statement;\n while statement; read statement; write statement;\n procedure call; identifier\n\nDESCRIPTION:\n\n All ALGOL-M statements are free form and must be\n separated by semicolons.\nsimple declaration\n\nELEMENT:\n\nsimple declaration\n\nFORMAT:\n\nINTEGER!DECIMAL!STRING ((identifier!integer))\nidentifier (,identifier) ...\n\nDESCRIPTION:\n\nSimple integer variables may be any value between \n-16,384 and +16,384. Simple decimal variables can be \nspecified as any length from one to 10 digits with a \ndefault length of 10 digits. Simple string variables \ncan be specified as any length from one to 255 \ncharacters with a default length of 10 characters.\n\nEXAMPLE:\n\nINTEGER x;\nDECIMAL(15) x,y;\nSTRING(33) WORDONE, WORDTWO, WORDTHREE;\nELEMENT:\n\nspecial characters\n\nDESCRIPTION:\n\nThe following special characters are used by ALGOL-M:\n\n( open parenthesis\n) close parenthesis\n* asterisk\n+ plus\n- minus\n: colon\n; semicolon\n< less-than\n> greater-than\n= equal\n, comma\n[ open bracket\n] close bracket\n:= assigned equal\n** exponentiation\n% percentage\n\nAny special character in the ASCII character set may appear in a string. Special characters, other than those listed above, will cause an error condition if used outside of a string.\nTAB expression\n\nELEMENT:\n\nTAB expression\n\nFORMAT:\n\nTAB expression\n\nDESCRIPTION:\n\nTAB is optionally used in a WRITE statement to cause spacing on the output line. The amount of spacing is specified by the integer expression following TAB.\n\nEXAMPLE:\n\nWRITE(\"NEXT NAME\", TAB 5, NAME[I]);\nunbalanced statement\n\nELEMENT:\nunbalanced statement\n\nFORMAT:\n(label definition) IF boolean expression THEN statement\n(label definition) IF boolean expression THEN balanced statement ELSE unbalanced statement\n\nDESCRIPTION:\nUnlike the balanced statement that will always have a balanced statement on either side of the ELSE in an IF THEN ELSE structure, an unbalanced statement may not even include the ELSE portion of the statement.\n\nEXAMPLE:\nIF S > Y THEN WRITE(X);\nIF X < Y THEN\n IF Z > Y THEN\n WRITE(Z)\n ELSE\n WRITE(X);\n\nPROGRAMMING NOTE:\nA semicolon is not allowed after the statement immediately preceding an ELSE.\nELEMENT:\n\nvariable\n\nFORMAT:\n\nidentifier ([bound pair list])\n\nDESCRIPTION:\n\nA variable in ALGOL-M may be simple or subscripted and of type INTEGER, DECIMAL, or STRING.\n\nEXAMPLE:\n\nX\nVALUE[2]\nZ[1, X * Y]\nWHILE statement\n\nELEMENT:\n\nWHILE statement\n\nFORMAT:\n\nWHILE boolean expression DO simple statement\n\nDESCRIPTION:\n\nWHILE statements continue executing the simple statement following the DO for as long as the boolean expression is true.\n\nEXAMPLE:\n\nWHILE I > 0 DO\n I := I - 1;\n\nWHILE X > 5 AND Y <> A DO\n BEGIN\n X := Y / 3;\n WRITE(X);\n END;\n\nEND;\nWRITE statement\n\nELEMENT:\n\nWRITE statement\n\nFORMAT:\n\nWRITE:WRITED (file option)\n\n(expression|tab expression|pic definition|string\n\n(expression|tab expression|pic definition|string) ...)\n\nDESCRIPTION:\n\nThe WRITE option indicates the output will start printing on a new line, while the WRITEDE option will continue printing on the same line. If the form of the statement is WRITE() or WRITEDE(), the output device is the console. Otherwise, a file option must be specified and the output device is the disk.\n\nEXAMPLE:\n\nWRITE(x);\nWRITE(\"THE NUMBER IS\", x + y);\nWRITE(\"ANSWER\", IAD s, x * y);\n\nPROGRAMMING NOTE:\n\nThe PIC definition is not currently implemented.\nAPPENDIX E ALGOL-M LANGUAGE STRUCTURE\n\nIn the following sections, the syntax of the language will be listed in BNF notation followed by the semantic actions (offset with asterisks) associated with that production. The description will be given in terms of compiler data structures and the ALGOL-M machine code generated. Items enclosed in brackets and separated by slants are alternative semantic actions. N/A indicates no action. This notation is similar to that used in REF 6 and REF 10.\n\n1 <program> ::= <block> '='\n **<block>; x?T; (eof indicator)\n\n2 <block> ::= <block head> <block end>\n **<block head>; <block end>\n\n3 <block head> ::= <block head> <declaration> ;\n **<block head>; <declaration>\n\n4 ; <begin>\n **<block>\n\n5 <begin> ::= begin\n **ALT\n\n6 <block end> ::= <block body> ; end\n **RLD\n\n7 <block body> ::= <statement>\n **<statement>\n\n8 <block body> ; <statement>\n **<block body> ; <statement>\n\n9 <declaration> ::= <file declaration>\n **<file declaration>\n\n10\n10 ; <simple declaration>\n *<simple declaration>\n\n11 ; <simple declaration> <initial option>\n *<simple declaration>; <initial option>\n\n12 ; <array declaration>\n *<array declaration>\n\n13 ; <array declaration> <initial option>\n *<array declaration>; <initial option>\n\n14 ; <subprogram declaration>\n *<subprogram declaration>\n\n15 ; <external declaration>\n *(Not implemented)\n\n16 <simple declaration> ::= <declaration head>\n <identifier>\n *<declaration head>; LIT (identifier address)\n *[ALD/ALS/ N/A for integers]\n\n17 <initial option> ::= <initial head> <constant> )\n *<initial head>; <constant>\n\n18 <initial head> ::= initial ( N/A\n\n19 ; <initial head> <constant>,\n *<initial head>; <constant>\n\n20 <declaration head> ::= <declaration type>\n *<declaration type>\n\n21 ; <declaration head> <identifier>\n\n22 <declaration type> ::= string\n *TMI (string default size);\n\n23 ; string <size option>\n *<size option>\n\n24 ; integer\n N/A\n\n25 ; decimal\n *TMI (decimal default size);\n26 *<size option> \n : decimal <size option>\n\n27 <size option> ::= ( <variable> ) \n *LITLOAD (variable address);\n\n28 : ( <integer> ) \n *<integer>\n\n29 <statement> ::= <balanced statement> \n *<balanced statement>\n\n30 : <unbalanced statement> \n *<unbalanced statement>\n\n31 <balanced statement> ::= <simple statement> \n *<simple statement>\n\n32 : !<if clause> <true part> else \n <balanced statement> \n *<if clause>; <true part>; <balanced statement>\n\n33 : !<label definition> \n <balanced statement> \n *<label definition>; <balanced statement>\n\n34 <unbalanced statement> ::= <if clause> <statement> \n *<if clause>; <statement>\n\n35 : !<if clause> <true part> \n36 else <unbalanced statement> \n *<if clause>; <true part>; <unbalanced statement>\n\n37 <true part> ::= <balanced statement> \n *<balanced statement>; BRS (address of end of \n *current statement)\n\n38 <label definition> ::= <identifier> : \n N/A\n\n39 : <integer> : \n N/A\n\n40 <simple statement> ::= <block> \n *<block>\n41 *<assignment statement>*\n ; <assignment statement>\n42 *<for statement>*\n ; <for statement>\n43 *<while statement>*\n ; <while statement>\n44 *<read statement>*\n ; <read statement>\n45 *<write statement>*\n ; <write statement>\n46 *<case statement>*\n ; <case statement>\n47 *<go to statement>*\n ; <go to statement>\n48 *<close statement>*\n ; <close statement>\n49 *<procedure call>*\n ; <procedure call>\n50 *<identifier>*\n ; <identifier>\n51 *<assignment statement>* ::= <left part> <expression>\n *<left part>*; <expression>; ([LII/LII])\n52 ; <left part>\n52 *<assignment statement>*\n *<left part>*; <assignment statement>\n53 *<left part>* ::= <variable> ::= \n *<variable>*; ([LII/LIILOAD])\n54 *<expression>* ::= <arithmetic expression>\n *<arithmetic expression>*\n55 ; <if expression> <expression>\n N/A\n56 *<arithmetic expression>* ::= <term>\n *<term>*\n57 ; <arithmetic expression> +\n57 \\texttt{\\textless term\\textgreater ; \\textless arithmetic expression\\textgreater ; \\textless term\\textgreater ; [ADT/ADD]}\n\n58 \\texttt{\\textless arithmetic expression\\textgreater - \\textless term\\textgreater ; \\textless arithmetic expression\\textgreater ; \\textless term\\textgreater ; [SBI/SBN]}\n\n59 \\texttt{\\textless arithmetic expression\\textgreater ! \\textless term\\textgreater ; \\textless arithmetic expression\\textgreater ; \\textless term\\textgreater ; [CAT]}\n\n60 \\texttt{\\textless term\\textgreater ; \\texttt{NEG} \\textless term\\textgreater ; \\texttt{+ term\\textgreater ;}}\n\n61 \\texttt{\\textless term\\textgreater ; \\texttt{:= primary\\textgreater ;}}\n\n62 \\texttt{\\textless primary\\textgreater ; \\texttt{\\textless primary\\textgreater ; \\textless primary\\textgreater ; \\texttt{mul primary\\textgreater ; \\texttt{div primary\\textgreater ;}}}\n\n63 \\texttt{\\textless term\\textgreater ; \\texttt{\\textless primary\\textgreater ; \\texttt{\\textless primary\\textgreater ; \\texttt{mul primary\\textgreater ; \\texttt{div primary\\textgreater ;}}}\n\n64 \\texttt{\\textless term\\textgreater ; \\texttt{\\textless primary\\textgreater ; \\texttt{\\textless primary\\textgreater ; \\texttt{mul primary\\textgreater ; \\texttt{div primary\\textgreater ;}}}\n\n65 \\texttt{\\textless primary\\textgreater ; \\texttt{\\textless primary\\textgreater ; \\texttt{\\textless primary\\textgreater ; \\texttt{mul primary\\textgreater ; \\texttt{div primary\\textgreater ;}}}\n\n66 \\texttt{\\textless primary\\textgreater ; \\texttt{\\textless primary\\textgreater ; \\texttt{\\textless primary\\textgreater ; \\texttt{mul primary\\textgreater ; \\texttt{div primary\\textgreater ;}}}\n\n67 \\texttt{\\textless primary\\textgreater ; \\texttt{:= variable\\textgreater ; \\texttt{LITLOAD \\{address of simple variable\\}/ N/A for \\texttt{subscripted variables/ IM2 (subroutine \\texttt{address in code area); PRU\\}\n\n68 \\texttt{\\textless constant\\textgreater ;}}\n\n69 \\texttt{\\textless procedure call\\textgreater ;}\n\n70 \\texttt{\\textless assignment statement\\textgreater ;}\n\n71 \\texttt{\\textless expression\\textgreater ;}\n\n72 \\texttt{\\textless constant\\textgreater ; \\texttt{:= integer\\textgreater ; \\texttt{INT\\{constant\\};}}\n73 ; <decimal> \n *DEC; (constant)\n74 ; <string> \n *STR; (constant)\n75 <variable> ::= <identifier> \n N/A\n76 ; <subscripted variable> \n *<subscripted variable>\n77 <file declaration> ::= <file head> <file name> \n *(not implemented)\n78 <file head> ::= file \n *(not implemented)\n79 ; <file head> <file name> , \n *(not implemented)\n80 <file name> ::= <string> <length option> \n *(not implemented)\n81 ; <string> \n *(not implemented)\n82 ; <identifier> <length option> \n *(not implemented)\n83 ; <identifier> \n *(not implemented)\n84 <length option> ::= { <identifier> } \n *(not implemented)\n85 ; { <integer> } \n *(not implemented)\n86 <array declaration> ::= <array list> \n86 <bound pair list> \n *<array list>; <bound pair list>; \n *LIT (# of arrays(m)); LIT (type of \n *array); \n *followed by: \n (1) LIT (array location) \n (2) m=m-1 if m=0 then halt else step(1)\n87 \\texttt{<array list>} ::= \\texttt{<array head> <identifier>} \\\\\n \\hspace{1em} \\times \\texttt{<array head>}\n\n88 \\texttt{<array head>} ::= \\texttt{<declaration type> array} \\\\\n \\hspace{1em} \\times \\texttt{<declaration type>}\n\n89 \\texttt{; \\texttt{<array head> <identifier>},} \\\\\n \\hspace{1em} \\times \\texttt{<array head>}\n\n90 \\texttt{<bound pair list>} ::= \\texttt{<bound pair head>} \\\\\n \\hspace{1em} \\times \\texttt{<bound pair> } \\\\\n \\hspace{1em} \\times \\texttt{<bound pair head>; <bound pair>}\n\n91 \\texttt{<bound pair head>} ::= \\{ \\\\\n \\hspace{1em} \\times \\texttt{N/A}\n\n92 \\texttt{; \\texttt{<bound pair head> <bound pair>},} \\\\\n \\hspace{1em} \\times \\texttt{<bound pair head>}\n\n93 \\texttt{<bound pair>} ::= \\texttt{<expression> : <expression>} \\\\\n \\hspace{1em} \\times \\texttt{<expression> ; <expression>}\n\n94 \\texttt{<subscripted variable>} ::= \\texttt{<subscript head>} \\\\\n \\hspace{1em} \\times \\texttt{<subscript head> ; <expression>;} \\\\\n \\hspace{1em} \\times \\texttt{LITLOAD <array address>; SUB}\n\n95 \\texttt{<subscript head>} ::= \\texttt{<identifier> \\{} \\\\\n \\hspace{1em} \\times \\texttt{N/A}\n\n96 \\texttt{; \\texttt{<subscript head> <expression>},} \\\\\n \\hspace{1em} \\times \\texttt{<subscript head> ; <expression>}\n\n97 \\texttt{<go to statement>} ::= \\texttt{<go to> <identifier>} \\\\\n \\hspace{1em} \\times \\texttt{DCB (\\# of blocks to decrement)/NOP;NOP} \\\\\n \\hspace{1em} \\times \\texttt{followed by RHS (branch address)}\n\n98 \\texttt{; \\texttt{<go to> <integer>}} \\\\\n \\hspace{1em} \\times \\texttt{DCB (\\# of blocks to decrement)/NOP;NOP} \\\\\n \\hspace{1em} \\times \\texttt{followed by RHS (branch address)}\n\n99 \\texttt{<go to>} ::= \\texttt{go to} \\\\\n \\hspace{1em} \\times \\texttt{N/A}\n\n100 \\texttt{; goto} \\\\\n \\hspace{1em} \\times \\texttt{N/A}\n\n101 \\texttt{<read statement>} ::= \\texttt{<read head> <variable> )} \\\\\n \\hspace{1em} \\times \\texttt{<read head>; LIT/LITLOAD (address of variable)}; \\\\\n \\hspace{1em} \\times \\texttt{PDT/PCT; STD/SDD/SSD} \\\\\n \\hspace{1em} \\times \\texttt{if console I/O then FCP}\n102 \\text{<read head> ::= read (}\n \\text{*RCN}\n\\text{)}\n103 \\text{! read file option (}\n \\text{*(not implemented)}\n\\text{)}\n104 \\text{! <read head> <variable>,}\n \\text{<read head>;} \\text{ same as production 101}\n105 \\text{<write statement> ::= <write head> <expression> )}\n \\text{<write head>; <expression>; [WIC/WDC/WS/WID}\n \\text{*WUN/WID]}\n106 \\text{! <write head> <tab expression> )}\n \\text{*(not implemented)}\n107 \\text{! <write head> <pic definition> )}\n \\text{*(not implemented)}\n108 \\text{<write head> ::= write (}\n \\text{*DMP}\n\\text{)}\n109 \\text{! write file option (}\n \\text{*(not implemented)}\n\\text{)}\n110 \\text{! writeon (}\n \\text{N/A}\n\\text{)}\n111 \\text{! writeon file option (}\n \\text{*(not implemented)}\n\\text{)}\n112 \\text{! <write head> <expression>,}\n \\text{<write head>; <expression>; [LIT/LITLOAD]}\n113 \\text{! <write head> <tab expression>,}\n \\text{*(not implemented)}\n114 \\text{! <write head> <pic definition>,}\n \\text{*(not implemented)}\n115 \\text{file option ::= <identifier>}\n \\text{N/A}\n116 \\text{! <identifier> <rec option>}\n \\text{N/A}\n117 \\text{! <string>}\n \\text{N/A}\n118 \\text{! <string> <rec option>}\n \\text{N/A}\n119 \\text{<rec option> ::= , <identifier>}\n \\text{N/A}\n120 ; , <integer>\nN/A\n\n121 <pic definition> ::= <pic head> <pic list> )\n*(not implemented)\n\n122 <pic head> ::= pic <string>\n*(not implemented)\n\n123 ; pic <identifier>\n*(not implemented)\n\n124 <pic list> ::= ( <expression> \n*(not implemented)\n\n125 ; <pic list> , <expression> \n*(not implemented)\n\n126 <tab expression> ::= tab <expression> \n*(not implemented)\n\n127 <if clause> ::= if <boolean expression> then\n*<boolean expression> ; RSC (branch address)\n\n128 <if expression> ::= <if clause> <expression> else\n*(not implemented)\n\n129 <boolean expression> ::= <boolean term> \n*<boolean term>\n\n130 ; <boolean expression> or\n130 <boolean term>\n*<boolean expression> ; <boolean term> ; RUR\n\n131 <boolean term> ::= <boolean primary> \n*<boolean primary>\n\n132 ; not <boolean primary>\n*<boolean primary> ; NOTO\n\n133 ; <boolean term> and\n133 <boolean primary> \n*<boolean term> ; <boolean primary> ANDO\n\n134 <boolean primary> ::= <logical expression>\n*<logical expression>\n\n135 ; ( <boolean expression> )\n*<boolean expression>\n\n136 <logical expression> ::= <expression> <relation> \n136 <expression> \n*<expression> ; <expression> ; [string, integer, \nor decimal relational operator]\n137 \\(<relation> ::= \\sim\\)\nN/A\n\n138 \\(\\sim <\\)\nN/A\n\n139 \\(\\sim >\\)\nN/A\n\n140 \\(\\sim <\\comp>\\)\nN/A\n\n141 \\(<\\comp> ::= < >\\)\nN/A\n\n142 \\(\\sim < =\\)\nN/A\n\n143 \\(\\sim > =\\)\nN/A\n\n144 \\(<\\text{while statement}> ::= <\\text{while clause}> <\\text{do statement}>\\)\n*<while clause>; <do statement>; BRS\n*{branch location}\n\n145 \\(<\\text{while clause}> ::= <\\text{while} <\\text{boolean expression}>\\)\n*<boolean expression>; RSC {branch address}\n\n146 \\(<\\text{while}> ::= \\text{while}\\)\nN/A\n\n147 \\(<\\text{for statement}> ::= <\\text{for clause}> <\\text{step expression}>\\)\n<for clause>; <step expression>; <until clause>; <do statement>; RRS {branch address}\n\n148 \\(<\\text{for clause}> ::= \\text{for} <\\text{assignment statement}>\\)\n*<assignment statement>; RRS (branch address); RRS (branch address); LIT (counter variable); LITLOAD (counter variable)\n\n149 \\(<\\text{step expression}> ::= \\text{step} <\\text{expression}>\\)\n*<expression>; AOT; STD; LITLOAD (counter variable)\n\n150 \\(<\\text{until clause}> ::= <\\text{until non-term} <\\text{expression}>\\)\n*<until non-term>; <expression>; LEO; BSC\n*(branch address)\n\n151 \\(<\\text{until non-term}> ::= \\text{until}\\)\n*{1,1} {one}; AOT; STD; LITLOAD (counter variable)\nN/A if there is a step expression\n\n152 \\(<\\text{do statement}> ::= \\text{do} <\\text{simple statement}>\\)\n*<simple statement>\n153 <close statement> ::= close <identifier>\n* (not implemented)\n154 \\[ <close statement> , <identifier>\n* (not implemented)\n155 <subprogram declaration> ::= <subprogram heading>\\\\\n155 <simple statement>\\\\\n*<subprogram heading> ; <simple statement> ; LIT\\\\\n*{subroutine PRT address} ; UNS ; RTN ; LIT(SBP) ;\\\\\n*LIT 0 ; SID ;\n156 <subprogram heading> ::= <function heading>\n*<function heading>\n157 \\( <procedure heading>\\\\\n*<procedure heading>\n158 <function heading> ::= <paramless function>\\\\\n*<paramless function>\n159 \\( <function & params> ; SV2\\]\n160 <procedure heading> ::= <paramless proc>\\\\\n*<paramless proc>\n161 \\( <proc & params> ; SV2\\]\n162 <paramless function> ::= <declaration type>\\\\\n162 function <identifier> ;\n163 <function & params> ::= <function head>\\\\\n163 <identifier> ) ;\n164 \\( <function & params>\\\\\n164 <declaration> ;\n*<function params> ; <declaration> ;\n165 <function head> ::= <declaration type> function\\\\\n165 <identifier> (\\\\\n*<declaration type>\n166 \\( <function head> <identifier> ,\n*<function head>\n167 <paramless proc> ::= procedure <identifier> ;\\\\\n*IM1 (parameter count) ; IM1 (local variable &\\\\\n*parameter offset) ; LIT (base of PCR) ; SAV ; BLI\\\\\n*if this is a non-integer function then\\\\\n*LITLOAD (length of return value) ;\\\\\n*LIT (PRT address of function) ; [ALD/ALS]\n<proc & params> ::= <procedure head> <identifier> ) ;\n *<procedure head>; same as production 167\n\n<procedure call> ::= <call heading> <expression> )\n *<call heading>; <expression>; IM2\n *(address of subroutine in code area); RNO\n\n<call heading> ::= <identifier> ( N/A\n\n<call heading> ::= <identifier> )\n *<expression>\n\n< declaration> ::= <declaration type> external\n\n<case statement> ::= <case heading> <case block>\n *<case heading>; <case block>\n *(do n times(n=number of statements in case block) BRS (address of case statement(n))\n\n<case heading> ::= case <expression> of\n *<expression>; LIT {3}; WP1; IM2\n *(address of end of case block); S6R; BFA\n\n<case block> ::= begin <case block body> ; end N/A\n\n<case block body> ::= <statement>\n *<statement>; BRS (address of end of case block)\n\n<case block body> ::= <statement>\n *same as production 182\n100h: /*load point for compiler*/\n\nDECLARE false literally '0',\ntrue literally '1',\nlit literally '\"',\nstartbdos address initial(5h),\nmax based startbdos address,\nboot lit '0',\nstacksize lit '48',\nintsize lit '128',\ndcl lit 'declare',\nproc lit 'procedure',\nfileof lit '1',\nfile lit '20',\nidentitize lit '32',\naddr lit 'address',\nforever lit 'while true',\nvarsize lit '100',\nindexsize lit 'address',\nstatebitize lit 'address',\nmaxoncount lit '23',\nerr lit '3',\nif lit '0',\nstringdelim lit '22h',\nquestionmark lit '3fh',\ntab lit '09h',\ncolin lit '3ah',\ncomment lit '9',\nconbuffsize lit '82',\neolchar lit '0dh',\nhashtblsize lit '64',\nsourcecssize lit '128',\nhashmask lit '63',\nconchar lit '5ch',\neoffiller lit '1fh',\npercent lit '25h',\n\ndeclare maxrno literally '132',\nmaxlno literally '190',\nmaxpush count /\nmaxstate count /\nstart state /\nnumber of productions /\nsemicolon /\ncolon /\nstring /\ndecimal /\ninteger /\nprocedure /\nidentifiers /\nterminals /\n\nDECLARE block address initial(5h),\nsourcebuff based block sourcecssize) byte,\nsourceptr byte initial(sourcecssize),\nbuffer byte initial(55),\nerrorcount address initial 0,\nlinebuff conbuffsize) byte,\nlineptr byte initial(0).\nWhen the following global variables are used by the scanner\n\n```c\ndeclare token byte; /* type of token just scanned */\nhashcode byte; /* has value of current token */\nnextchar byte; /* current character from geteliar */\naccurimize byte; /* indicates accum was full, still more */\n```\nmon1: procedure (f, a);\n declare f byte,\n a address;\n go to bdos;\nend mon1;\n\nmon2: procedure (f, a) byte;\n declare f byte, a address;\n go to bdos;\nend mon2;\n\nmon3: procedure;\n /* used to return to the system */\n goto boot;\nend mon3;\n\nmove: procedure (a, b, l);\n /* moves from a to b for l bytes (l < 255) */\n declare (a, b) address,\n (a based a, d based b, 1) byte;\n do while (l := l - 1) <> 255;\n d := b := b + 1;\n a := a + 1;\n end;\nend move;\n\nfill: procedure (a, char, n);\n /* move char to a n times */\n declare a addr. (char, n, dest based a) byte;\n do while (n := n - 1) <> 255;\n dest := char;\n a := a + 1;\n end;\nend fill;\n\nread: procedure;\n declare toggle (3) byte;\n toggle := 1;\n call monl (10, toggle);\nend read;\n\nprintchar: procedure (char);\n declare char byte;\n call monl (23, char);\nend printchar;\n\nprint: procedure (a);\n declare a address;\n call monl (9, a);\nend print;\n\ndiskerr: procedure;\n call print (. 'de $' );\n goto boot;\nend diskerr;\n\nopen@sourcefile: procedure;\n call move (. 'alg'. rfchaddr + 16);\n rfch(32) := @;\n if mon2 (15, rfchaddr) = 253 then do;\n call print (. 'ns $' );\n go to boot;\n end;\nend open@sourcefile;\n\nclose@sourcefile: procedure;\n /* close a file */\n if mon2 (16, rfch) = 253 then\ncall diskerr;\nend close@int@file;\n\nsetup@int@file: procedure;\n/* set up int file as new file */\nif mothfile then /* only make file if this toggle is off */\nreturn;\ncall move(.rfcb,.wfcb,9);\nwfcb(32)=0;\ncall coml(19,.wfcb);\nif mon2(22,.wfcb) = 255 then\ncall diskerr;\nend setup@int@file;\n\nrewind@source@file: proc;\n/* cp/m does not require any action prior to reopen */\nreturn;\nend rewind@source@file;\n\nread@source@file: proc byte;\ndeclare cnt byte;\nif(dnt:= mon2(rfile.rfcbaddr)) > fileeof then\ncall diskerr;\nreturn cnt;\nend read@source@file;\n\nwrite@int@file: procedure;\nif mothfile then\nreturn;\ncall monl(26,.diskoutbuff);\nif mon2(21,.wfcb) <> 0 then\ncall diskerr;\ncall nmonl(26,.0h);\n/* reset dma address */\nend write@int@file;\n\ncrlf: procedure;\ncall printchar(cr);\ncall printchar(lf);\nend crlf;\n\nprintdec: procedure(value);\ndeclare value address, l byte, count byte;\ndeclare decl(4) address initial(1000,100,10,1);\ndeclare flag byte;\nflag = false;\ncount = 30h;\ndo i = 0 to 3;\ndo while value >= decl(i):\nvalue = value - decl(i);\nflag = true;\ncount = count + 1;\nend;\nif flag or (i = 3) then\ncall printchar(count); else\ncall printchar(' '); end;\ncall printchar(' ');\nend: printdec;\n\nprint@prod: proc;\ncall print('. prod = '); call print@dec(production);\ncall crlf;\nend print@prod;\n\nprint@token: proc;\ncall print('. token = '); call print@dec(token);\ncall crlf;\nend print@token.\nemit: proc(objcode);\n declare objcode byte;\n if (buffptr < buffptr+1) > intrecsize then /* write to disk */\n do:\n call writeintfile:\n buffptr:=0;\n end;\n diskoutbuff(buffptr)=objcde;\n end emit;\nend clear@line@buff:\n\nlistline: procedure (length);\n declare (length+1) byte;\n call printdec(linen0);\n call printdec(prevGtnex~l);\n call printchar(' ');\n do 1 = 0 to length;\n call printchar(linebuff+1));\n end;\n call crlf;\nend listline;\n\n/* the following variables are used by the parser */\ndeclare listprod byte initial(false),\n lowertoupper byte initial(true),\n listsource byte initial(false),\n debugin byte initial(false),\n errset byte initial(false),\n compiling byte,\n codesize address, /* used to count size of code area */\n prtek address initial(0xffeh), /* used to count size of prtek */\n /x variables used during for loop code generation */\n forcount byte initial(0),\n randomfile byte,\n fileio byte initial(false);\n\ngetchar: procedure byte;\n declare addof data ('eof', enolchar, 1); /* add to end if left off */\n nextsourcechar: procedure byte;\n return sourcebuff(sourceptr);\nend nextsourcechar;\n\ncheckfile: procedure byte;\n do forever;\n if (sourceptr<sourceptr+1) > sourcebuffsize then\n do:\n sourceptr:=0;\n if (readsourcefile=fileof then\n return true;\n end;\n if (nextchar>nextsourcechar) < if then\n return false;\n end;\nend checkfile;\n\nif checkfile or (nextchar = nofillchar) then\n do: /* eof reached */\n call move(.addof, chloc, 5):\nsourceptr = 0;\nnextchar = next$source$char;\nend:\nlinebuff(lineptr) = lineptr + 2; nextchar = nextchar;\nif nextchar = eolchar then\ndo:\nline = line + 1;\nif listsource then\ncall list(line(lineptr - 1));\nlineptr = 0;\ncall clear(linebuff);\nend;\nif nextchar = tab then\nnextchar = ' ';\nreturn nextchar;\nend getchar:\n\ngetnoblank: procedure;\ndo while((getchar = ' ') or (nextchar = eolfiller));\nend:\nend getnoblank:\n\ntitle: procedure;\ncall print (. 'algol-m vers 1.0');\ncall crlf;\nend title:\n\nprint$error$: procedure;\ncall printdec(errorcount);\ncall printchar('');\ncall print (. 'error(s) detected');\ncall crlf;\nend print$error$:\n\nerror: procedure(errorcode);\ndeclare errorcode address.\n 1 byte;\nerrorcount = errorcount + 1;\ncall print (. 'err $');\ncall printdec(errorcount);\ncall print (. 'error $');\ncall printchar('');\ncall printchar(high(errorcode));\ncall printchar(low(errorcode));\ncall crlf;\ncall printprod;\nif token = eofc then\ndo:\ncall print$error$;\ncall mon3;\nend:\nend error:\n\ninitialize$scanner$: procedure:\ndeclare count byte;\ncall open(sourcefile);\nline, lineptr = 0;\ncall clear(linebuff);\nsourceptr = 128;\ncall getnoblank;\ndo while nextchar = ' ';\ncall get$noblank$;\nif count := (nextchar and $3fh) = 'a' (< 4 then\ndo case count;\nend;\nif pass then listsouce = true;\nlistprod $true$;\nnoinput $true$;\nlisttoken $true$;\ndebugin $true$;\nend;\nend of case x.\ncall get$noblank$;\n\n126\nend:\nend initialize scanner:\n\nscannerr: procedure:\nputinaccum: procedure:\nif not cont then do:\naccum(accum := accum + 1) = nextchar;\nhashcode = (hashcode + nextchar) and hashmask;\nif accum = 31 then cont = true;\nend:\nend putinaccum:\nputandget: procedure:\ncall putinaccum;\ncall getnolobank:\nend putandget:\nputandchar: procedure:\ncall putinaccum;\nnextchar = getchar:\nend putandchar:\nnumeric: procedure byte:\nreturn(nextchar = '0') <= 9;\nend numeric:\nlowercase: procedure byte:\nreturn (nextchar = 61h) and (nextchar <= 7ah);\nend lowercase;\ndecimalpt: proc byte:\nreturn nextchar = '1';\nend decimalpt;\nconvtouppepr: proc:\nif lowercase and lowercase then\nnextchar = nextchar and 5fh;\nend convtouppepr:\nletter: procedure byte:\ncall convtouppepr;\nreturn ((nextchar = 'a') <= 25) or lowercase;\nend letter:\nalpha: procedure byte:\nreturn numeric or letter or decimalpt;\nend alpha:\nspoolnumeric: procedure:\ndo while numeric:\ncall putandchar:\nend:\nend spoolnumeric:\n\nsetupnextcall: procedure:\nif nextchar = ' ' then a\ngetnolobank:\ncont = false;\nend setupnextcall:\n\nlookup: procedure byte:\ndeclare maxring lit '9';\ndeclare vocab data(0., '<', '(', '+', '5bd.7ch. 'x' ')', ':', '-', '/', ' ', '\n', ',', 'do', 'go', 'if', 'of', 'or', 'to', 'eof', 'end', '\n', 'end', 'for', 'not', 'pic', 'tab', 'case', 'else', 'file', 'goto', 'end', '\n', 'step', 'then', 'array', 'begin', 'close', 'until', 'while', 'write', '\n', 'string', 'decimal', 'initial', 'integer', 'writeon', '\n', 'comment', 'external', 'function', 'procedure');\ndeclare vloc data(0.1,16.32,53.81.111.117,152.168,177);\ndeclare vnum data(0.1,16.24.31.38.45.53.54);\ndeclare count data(0.14.7,6.5,0.4,1.9);\ndeclare ptr address. (field based ptr) (9) byte;\ndeclare i byte;\n\ncompare: procedure byte:\ndeclare i byte:\n i = 0;\ndo while (field(i) = accum(i := i + 1)) and i <= accum;\nend:\nreturn (i > accum);\nend compare:\n\nif accum > maxwring then\n return false;\nptr=vloc(accum)+.vocab;\ndo i=vnum(accum) to (vnum(accum)+count(accum))\n if compare then\n do:\n if i=50 then\n token=comment:\n else\n token=:\n return true:\n end:\n ptr=ptr+ accum:\n end:\n return false;\nend lookup:\n\n/*\n scanner main code */\n/*\n do forever:\n accum. hashcode, token = 0;\ndo while nextchar=sochchar:\n call getmoblank:\nend:\nif(nextchar = stringdelim) or cont then\n do: /* found string */\n token = string:\n cont = false:\n do forever:\n do while getchar <> stringdelim:\n call putinaccum:\n if cont then return;\n end:\n call getnoblank:\n if nextchar <> stringdelim then\n return:\n call putinaccum:\n end: /* of do forever */\nend: /* of recognizing a string */\nelse if numeric or decimalpt then\n do: /* have digit */\n token = integer:\n do while nextchar='0': /*elim leading zeros*/\n nextchar=:\n end:\n call spoolnumeric;\n if decimalpt then\n\ndo: \n token=decimal; \n call putandchar; \n call spoolnumeric; \n end; \n if accum@ then \n hashcode, accum(accum : x) = '0'; \n call setup@next@call; \n return; \n end; \nelse if letter then \n do: \n /% have a letter /% \n do while alphanumeric: \n call putandchar; \n end; \n if not lookup then \n do: \n token = identifier; \n call setup@next@call; \n return; \n end; \n else /% is a rw but if comment skip /% \n if token = comment then \n do: \n do while nextchar <> ';': \n nextchar = getchar; \n end: \n call get@no@blank; \n end: \n else \n do: \n call setup@next@call; \n return; \n end; \n end; \nelse \n do: \n /% special character /% \n if nextchar = 25h then \n do: \n nextchar = getchar; \n do while nextchar <> 25h: \n nextchar = getchar; \n end; \n call get@no@blank; \n end: \n else \n do: \n if nextchar = ' ' then \n do: \n call putandchar; \n if nextchar = 'w' then \n call putandget; \n end; \n end: \n else if nextchar = 'x' then \n do: \n call putandchar; \n if nextchar = 'x' then \n call putandget; \n end; \n end: \n else call putandget; \n end: \n end; \n else call putandget; \n end; \n end; \nelse if nextchar = 'w' then \n do: \n call putandchar; \n if nextchar = 'w' then \n call putandget; \n end; \nelse call putandget; \n end; \nelse call putandget; \n if not lookup then \n call error('w'); \n call setup@next@call; \n return; \nend; \nend: \nelse \n do: \n /% of recognizing special char /% \n end; \nelse \n do forever \nend scanner; \nend of scanner.\n/* procedures for synthesizer*/\ninitialize@sym tbl:proc:\n if pass 1 then\ndo:\n /* fill hashtable with 0's */\n call fill hashtable(0,shbl(hash tbl size,2));\n shbl = .memory;\n end:\n/* initialize pointer to top of symbol table*/\nshbl top = max - 2;\nend initialize@sym tbl:\n\nsetaddrptr:proc(offset):\n /* set ptr for addr reference*/\n declare offset byte:\n setaddrptr = base + ptr + offset /*position for addr reference*/\nend setaddrptr:\n\nsetblk@level:proc(level):\n declare level byte:\n call setaddrptr(6);\n byteptr = level;\nend setblk@level:\n\ngethash:proc byte:\n declare hash byte,\n 1 byte:\n hash = 0:\n aptraddr = base + 2:\n do i = 1 to ptr:\n hash = (hash + byteptr(1)) and hashmask:\n end:\n return hash:\nend gethash:\n\nnextentry:proc:\n base = base + ptr + 8:\nend nextentry:\n\nsetlink:proc:\n aptraddr = base + 1:\nend setlink:\n\nhash tbl@off sym hash:proc address:\n return hashtable(sym hash):\nend hash tbl@off sym hash:\n\nlimits:proc(count):\n /* check to see if additional shbl will overflow limits of\n memory. if so then punt else return */\n declare count byte: /*size being added is count */\n if shbltop <= (shbl + count) then\ndo:\n call error('to'):\n call mon3:\n end:\nend limits:\n\nsetaddr:proc(loc):\n /* set the address field and resolved bit*/\n declare loc address:\n call setaddrptr(4):\n addptr = loc:\nend setaddr:\n\nlookup@current @shbl:proc(chk@shbl byte:\n declare chk@shbl byte:\n len byte:\n a based printname byte:\nbases $hmvhtb$\n\nI do while base <> 0:\n call setaddrptr(6):\n if bytепtr < chkSblk then\n return false:\n if bytепtr = chkSblk then\n do:\n if (len:ptr) = n then\n do while (ptr(len + 2) = m(len)):\n if (len + len - 1) = 0 then\n return true:\n end:\n end:\n end:\n call setlink:\n base = addrptr:\nend:\nreturn false:\nend lookup@current$blk:\n\nlookup: proc byte:\n declare test$blk byte:\n test$index byte:\n test$index = prev$index+1:\n test$blk = blk$level:\n do while (test$index = test$index - 1) <> 255:\n if lookup@current$blk(test$blk) then\n return true:\n else:\n return false:\n end:\n return false:\nend lookup:\n\nenter: proc:\n / enter token reference by printname and symhash\n into next available location in the symbol table.\n set base to beginning of this entry and increment\n sbtbl. also check for symbol table full. */\n declare l byte:\n l based printname byte:\n call listadd(l:=n+8):\n base = sbtbl: /*base for new entry */\n call move(printname + l,sbtl + 3,(ptr := n)):\n call setaddrptr(3): /*set resolve bit to 0x*/\n bytепtr = 0:\n call setlink:\n addrptr = hash$tbl$off$symhash:\n hash$tbl$off$symhash = base:\n call set$lk$level(blk$level): s\n sbtl = sbtl + 1:\nend enter:\n\ngetlen: proc byte: /*return length of the p/n */\n return ptr:\nend getlen:\n\ngettype: proc byte: /*returns type of variable*/\n call setaddrptr(3):\n return bytепtr:\nend gettype:\n\nsetsubtype: proc(stype): /*enter the subtype in $sbl$*/\n declare s type byte:\n call setaddrptr(7):\n bytепtr:=stype:\nend setsubtype:\n\ngetparm: proc byte:\n call setaddrptr(10):\n return bytепtr:\nend getparm:\n\ngetsubtype: proc byte: /*return the subtype*/\n call setaddrptr(7):\nreturn byteptr;\nend getsubtype;\nsettype:proc (type); /* set typefield = type */\ndeclare type byte;\ncall setaddrptr (3);\nbyteptr = type;\nend settype;\n\ngetaddr: proc address;\ncall setaddrptr(4);\nreturn addrptr;\nend getaddr;\ndo;\n/* block for parser */\n\n/* pneumonics for ALGOL-M machine */\ndeclare nop lit '0', str lit '1', int lit '2', xch lit '3'.\nlod lit '4', dbh lit '5', dmp lit '6', xit lit '7'.\nadd lit '8', als lit '9', alit '10', xim lit '11'.\nsub lit '12', subd lit '13', subb lit '14', subb lit '15'.\nmp lit '16', mpd lit '17', dvi lit '18', dvb lit '19'.\ndneg lit '20', neg lit '21', c1 lit '22', c2 lit '23', c3 lit '24'.\ndcl lit '25', pop lit '26', call lit '27', call lit '28'.\n\nbrc lit '34', bar lit '35', lss lit '36', diss lit '37'.\nalso lit '38', str lit '39', dgr lit '40', segr lit '41'.\neql lit '42', deq lit '43', seq lit '44', seq lit '45'.\ndg lit '46', sgleq lit '47', geq lit '48', dgeq lit '49'.\nsgeq lit '50', leg lit '51', sleq lit '52', seql lit '53'.\ninot lit '54', dnot lit '55', snot lit '56', smdl lit '57'.\ndand lit '58', sand lit '59', lor lit '60', dor lit '61'.\nsor lit '62', wic lit '63', wic lit '64', wsc lit '65'.\nwid lit '66', wdd lit '67', wdd lit '68', smr lit '69'.\nbra lit '70', row lit '71', sub lit '72', rcl lit '73'.\nrcd lit '74', ren lit '75', rdi lit '76', rdd lit '77'.\nrds lit '78', renlit '79', erc lit '80', slt lit '81'.\nsdi lit '82', smd lit '83', sid lit '84', smd lit '85'.\nadd lit '86', opn lit '87', csq lit '88', rdb lit '89'.\nrdf lit '90', edr lit '91', edw lit '92', pro lit '93'.\nmwv lit '94', sw2 lit '95', uns lit '96', rtn lit '97'.\n\ndeclare state size;\nstatesize, statestack(2) statesize;\nhash(2) statesize byte;\nsymbol(2) statesize address;\nerror(2) statesize address;\nvartype(2) statesize byte;\ntype(2) statesize byte;\nstate(2) statesize byte;\nvar(2) statesize byte;\nvarindex byte;\n(sp, mp, appl, molook) byte;\nonstack(maxoncount) byte;\nclass byte initial(2);\nclass byte initial(23);\nclass byte;\nstrsiz byte initial(10);\ndecsize byte initial(10);\na byte;\nnum byte initial(10);\nsaveparm address;\nsaveparm based saveparm byte;\nfpcount byte;\nprobsame address;\nproc@type byte;\n(ptest, l) byte;\nproc byte initial(10);\ntype temp byte;\nflag byte;\nlpcount byte;\nident address;\ninitialize: procedure:\ncodeword, onstack, cable = 0:\nprev$index = 255:\nblks$cut = 0:\nblks$level[z0]\nend initialize: synthesize:\n\nsynthesize: proc:\n\n/* ****** synthesize local declarations ****** */\n\ndeclare s$ivar lit '0hh'.\ns$ivar lit '99'.\npro lit '93'.\nex$nproc lit '03'.\nb$nfunc lit '06'.\nconst lit '06'.\nlab lit '09'.\ninteger lit '08'.\nstr lit '1'.\nfile lit '0ch'.\nfunc lit '0dh'.\np$arm lit '10h'.\n\ndeclare (typ$sp, typ$emp, typ$emp1) byte.\n(b, temp) byte.\n(stype$sp, stype$mp, stype$mp1) byte.\n(hash$mp, hash$mp, hash$mp1) byte.\n(s$iloc$sp, s$iloc$mp, s$iloc$mp1) address.\n(s$iloc$sp, s$iloc$sp) address:\n\n/* ****** code generation proc's ****** */\n\n/* ****** code generation proc's ****** */\n\n/* ****** code generation proc's ****** */\n\n/* ****** code generation proc's ****** */\n\ncopy: procedure:\ntype$sp = type$sp;\ntyp$emp1 = type$mp1;\ntyp$emp = type$mp;\nstype$sp = stype$sp;\nstype$emp1 = stype$mp1;\nstype$emp = stype$mp;\nsymloc$sp = symloc$sp;\nsymloc$mp1 = symloc$mp1;\nsymloc$mp = symloc$mp;\nhash$mp = hash$mp;\nhash$mp1 = hash$mp1;\nhash$sp = hash$sp;\ns$iloc$sp = s$iloc$sp;\ns$iloc$mp = s$iloc$mp;\nend copy:\n\nsetsymloc$sp: procedure(a):\ndeclare s address;\nsymloc$sp = a;\nend setsymloc$sp:\n\nsetsymloc$mp: procedure(a):\ndeclare s address;\nsymloc$mp = a;\nend setsymloc$mp:\n\nsettype$sp: procedure(b):\ndeclare b byte;\ntype$sp = b;\nend settype$sp:\nsettypeprop: procedure(b);\ndeclare b byte;\ntype(sp) = b;\nend settypeprop;\n\nsettypeprop: procedure(b);\ndeclare b byte;\ntype(mp) = b;\nend settypeprop;\n\nsettypeprop: procedure(b);\ndeclare b byte;\ntype(mp) = b;\nend settypeprop;\n\nsetshmp: procedure(b);\ndeclare b byte;\nhash(mp) = b;\nend setshmp;\n\nsetshmp: procedure(b);\ndeclare b byte;\nhash(mp) = b;\nend setshmp;\n\nsetrlocomp: procedure(a);\ndeclare a address;\nsetloc(sp) = a;\nend setrlocomp;\n\nsetrlocomp: proc(a);\ndeclare a byte;\nsetloc(mp) = a;\nend setrlocomp;\n\ngetrloc: proc byte;\ncall = taddrptr(8);\nreturn addptr;\nend getrloc;\n\ngenerate: proc(objcode):\n/*writes generated code and counts size of code area.*/\ndeclare objcode byte;\ncodesize = codesize + 1;\nif not pass1 then\ncall emit(objcode);\nend generate;\n\ngenintiv: proc(a):\ndeclare a byte;\ncall generate(int1);\ncall generate(a);\nend genintiv;\n\nincr@blk$level: proc:\nprev@blk$level(prev$index := prev$index+1) = blk$level;\nblk$level = blk$cnt + 1;\nblk$cnt = blk$cnt+1;\ncall generate(bll);\nend incr@blk$level;\n\ndecr@blk$level: proc:\nblk$level = prev@blk$level(prev$index);\nprev$index = prev$index-1;\ncall generate(bll);\nend decr@blk$level;\n\ncalc@var: procedure(b) address;\ndeclare b byte;\nreturn var(b) + .varc;\nend calc@var;\nsetlookup: procedure(a); \ndeclare a byte;\nprintname = value(a);\nsymhash = label(a);\nend setlookup;\n\nlookuponly: procedure(a) byte;\ndeclare a byte;\ncall setlookup(a);\nif lookup¤t(b1k(b1k#level)) then\n return true;\nbase&flag := true;\nreturn false;\nend lookuponly:\n\nfulllookup: proc(a) byte;\ndeclare a byte;\ncall setlookup(a);\nif lookup then\n return true;\nreturn false;\nend fulllookup:\n\nnormallookup: procedure(a) byte;\ndeclare a byte;\nif lookuponly(a) then\n return true;\ncall enter;\nreturn false;\nend normallookup:\n\ncountprt: proc address;\n/* counts the size of the prt */\nreturn println(pret := pret + 2);\nend countprt:\n\ngenexpr: proc(a);\n/* writes two bytes of object code on disk for literals */\ndeclare a address;\ncall generate(high(a));\ncall generate(low(a));\nend genexpr:\n\nliterals: proc(a);\ndeclare a address;\ncall genexpr or $0000h;\nend literals:\n\nsetname: proc;\nprintname := aliasing;\nsymhash := table and hashmask;\nend setname:\n\nenter$compiler$label: proc(b);\ndeclare b byte;\nif pass1 then\n do:\n call setname;\ncall enter;\n call *inaddr(codesize + b);\n end:\nend enter$compiler$label:\n\nset$compiler$label: proc;\ndeclare x byte;\nstable := stable + 1;\ncall setname;\nif pass2 then\n x = lookup;\nend set$compiler$label;\n\ncompiler$label: proc:\ncall set$compiler$label:\ncall gentwo(getaddr):\nend compiler$label:\n\nset$center: proc(a):\n declare (a,b) byte:\n call settypep(clable):\ncall compiler$label:\ncall gentwo(getaddr):\ncall compiler$label:\nend set$center:\n\nbranch$clause: proc(a):\n declare a byte:\n call generate(a):\n call compiler$label:\ncall settypep(clable):\nend branch$clause:\n\nprocess$case$label: proc(a):\n declare (a,b,x) byte:\n b=clable:\n clable=a:\n call generate(brs):\ncall setname:\nif pass$2 then\n x=lookup:\ncall gentwo(getaddr):\ncall compiler$label:\nend process$case$label:\n\ncase$state: proc:\n call process$case$label(type=mp-2):\n x=x+1:\n clable=clable+1:\ncall compiler$label:\nend case$state:\n\nlit$load: proc(a):\n declare a address:\n call gentwo(a or 0c00h):\nend lit$load:\n\nstep$gen: proc:\n call generate(adj):\n call generate(add):\n call compiler$label:\ncall lit$load(adjident):\nend step$gen:\n\nchk$typ: proc(a): /* check mpop to see if they are both decimal */\ndeclare a byte: /* both integer, one of each, or neither */\nif (stypemp=Int) and (styps$int) then\ncall generate(a):\nelse\n if (stypemp=dec) and (styps$dec) then\n call generate(a):\n call generate(adj):\n else\n if (stypemp=dec) and (styps$int) then\ndo:\n else\n if (stypemp=Int) and (styps$int) then\ndo:\n else\n if typemp fun or pass$2 then\ncall error('mf');\n\nend chktyp1;\n\nchktyp2: proc byte;\nif stypesp (<) stypemp then\n do;\n call error('mm');\n return false;\n end;\n return true;\nend chktyp2;\n\nchktyp3: proc byte;\ncall setstypemp(stypesp);\nif (stypesp=Int) or (stypesp=Dec) then\n return true;\ncall error('mf');\nreturn false;\nend chktyp3;\n\nchktyp4: proc byte;\nif (stypesp<>Int) then\n return true;\ncall error('mn');\nreturn false;\nend chktyp4;\n\nchktyp5: proc byte;\nif (stypesp<>Int) then\n return true;\ncall error('mf');\nreturn false;\nend chktyp5;\n\nchktyp6: proc;\nif pass2 then\n do;\n if (stypesp=Int) and (stypesp=Dec) then\n call error('id');\n else if (stypesp<>Int) then\n return false;\n end;\n end;\nend: end chktyp6;\n\ngencst: proc(subtype);\ndeclare (i, subtype) byte;\ngen@accum: proc;\nif pass2 then\n do i=1 to accum;\n call emit(accump(i));\n end;\nend gen@accum;\ncall generate(subtype);\ncall setstypemp(const);\ncall setstypemp(subtype);\nif subtype=Int then\n if accum<>0 then\n call error('lo');\ncall gen@accum;\nif pass2 then\n call emit(0);\ncodesize=codesize+2;\nend;\nelse\ndo forever;\n if subtype=Str then\n do i=1 to accum;\n call generate(accump(i));\n end;\n else\ndo;\n call gen@accum;\ncodesize=codesize+accum(i)/2;\nend;\nif cont then\ncall scanner:\nelse\ndo:\n if subtype = dec then\ncall gen two(0);\n else\ncodesize = codesize + 2;\ncall generate(0);\nreturn;\nend:\nend gencon;\n\nprocessstore: proc(a):\ndeclare a byte:\nif chktyp5 then\ncall generate(a+2);\nelse\ncall chktype(a);\nend processstore:\n\ngen$loc: proc(a,b):\ndeclare a byte,\nb address:\nif a = int then\ncall literal(b);\nelse\ncall literal(b);\nend gen$loc:\n\nget$field: proc:\ngen$read: proc(s):\ndeclare a byte:\nif stypempi = int then\ndo:\ncall generate(a):\ncall generate(s):;\nend:\nelse\n if stypempi = dec then\ndo:\ncall generate(a+1):\ncall generate(sadd);\nend:\nelse\ndo:\ncall generate(a+2):\ncall generate(sadd);\nend:\nend gen$read:\ncall gen$loc(stypempi,symlocmpl):\nif filelo then\ncall gen$read(rd):\nelse\ncall gen$read(rc):\nend get$field:\n\nput$field: proc(s):\ndeclare a byte:\nif filelo then\n a = 3:\n if stypempi = int then\ndo:\n if typempi = subvar then\ncall generate(lod):\ncall generate($n):\nend:\nelse\n if stypempi = dec then\ncall generate(a+1):\nelse\ncall generate(a+2):\nend put$field:\nprocess proc: proc(a): declare a byte; call settypeemp(a); if pass2 then do: call seterroremp(srlcemp:geterrloc); call settypeemp(getsubtype); parmbase=base+ptr+1; end; end process proc:\n\nprocess ident: proc(a) byte; declare a byte; if fulllookup(a) then return gettype; else if pass2 then do: call error('ud'); return false; end; else return func; end process ident:\n\nprocess array: proc(a); declare (a,b) byte; if ((b=processident(a)) subvar) and pass2 then do: if b<>0 then call error('ln'); end; else do: call settypeemp(getsubtype); call setsymlocemp(symlocemp:getaddr); call settypeemp(subvar); end; end process array:\n\nprocess ident dcl: proc(a,b,c); dcl(a,b,c) byte; pnum=pnum+1; if not normallookup(a) then do: call settype(b); if subvar then call setaddr(conntptr); call setsubtype(c); end; else if pass1 then do: if gettype=parm then do: call settype(b); call setsubtype(c): ptest=ptest-1; end; else call error('dd'); end; end process ident dcl:\n\nprocess sav: proc; call genint@('pcount'); call genint@('pnum+31*2); call literal(symlocemp); call generate(sav); call generate(b11); if procstypefunc then do: if stypeemp(func) int then\ndo:\ncall lit load(symlocmp+4):\ncall literal (symlocmp):\nif stypelscmp=doc then\n call generate(sid):\nelse\n call generate(ais):\nend:\nend proc$parm:\n\ncheck$parm: proc(a):\ndeclare a byte:\n b address:\nif pass2 then\n do:\n b=base:\n base+para base:\n if a 'get subtype then\n call error('pm'):\n para base+base+ptr+8:\n base+:\n end:\n call generate(imj):\ncall generate(a):\nend check$parm:\n\nproc$pro: proc:\ncall generate(im2):\ncall gen$two(snilcmp):\ncall generate(pro):\nend proc$pro:\n\nprocess$proc$decl: proc(a,b,c):\ndeclare (a,b,c) byte:\ncall process$ident$decl(a,b,c):\nplist; count=0:\ncall get$symlocmp(symlocmp:=get addr):\nif pass1 then\n prct=prct+4:\nif (proc$type:=b) = func then\n do:\n call literal(symlocmp+4):\ncall generate(xch):\ncall generate(sid):\n end:\ncall branch$clause(hrs):\nif pass1 then\n do:\ncall set$addrptr(b):\n addrptr+codesize:\n stb1=stb1+3:\nsavparm=stb1+1:\n end:\ncall incr$blk$level:\nend process$proc$decl:\n\nprocess$var: proc(a):\ndeclare (a,b) byte:\nif (b = process$ident(a)) = simvar then\n do:\n call set$symlocmp(symlocmp:=get addr):\ncall set$typesimvar:\ncall set$typesimvar (get subtype):\n end:\nelse\n if b!=func then\n call process$proc$func:\nelse\n if b>0 then\n call error('ip'):\nend process$var:\nprocess$simvar$decl: proc(a, b);\ndeclare (a, b) byte;\ncall process$simident$decl(a, simvar, stypemp);\nif stypemp = int then\n do:\n call literal(getaddr);\n if stypemp = dec then\n call generate(b);\n else\n call generate(b+1);\n end;\nend process$simvar$decl;\n\nprocess$label: proc;\nif pass1 then\n do:\n if full$lookup(mp) then\n call error('dd');\n else\n do:\n call enter;\n call setaddr(cod$size);\n call settype(lab);\n call setblk$level(blk$level);\n end;\n end;\nend process$label;\n\nresolve$label: proc;\ndeclare (chk$blk, tindex) byte;\nif pass2 then\n do:\n if ((not full$lookup(sp)) or (getype <> lab)) then\n call error('ul');\n else\n do:\n call enter;\n call setaddr(cod$size);\n call settype(lab);\n call setblk$level(blk$level);\n end;\n end;\n end;\nelse\n call gen$two(nop);\nend resolve$label;\n\nprocess$array$decl: proc(a);\ndeclare a byte;\ncall process$simident$decl(a, subvar, stypemp);\narr$loc(arr$num) = getaddr;\narr$num = arr$num + 1;\nend process$array$decl;\n\nclose$file: proc(a);\ndeclare a byte;\nif process$simident(a) then /* not implemented */\nelse call error('at');\nend close$file;\n\nassign$stmt: proc;\ncall chktyp;\nif (tpcount = tpcount-$1) then /* test multiple assign stmt */\ncall process$store($1);\nelse\ncall processstore(sld):\nend assignstmt:\n\n/* execution of synthesize begins here------*/\n\nif listprod then\n call print$prod:\ncall copy:\ndo case production: /* call to synthesize handles one prod */\n\n/*case 0 not used*/:\n\n/* 1 <program> ::= <block> _- _\nif pass1 then\ndo:\npass1 := false:\n if errorcount > 0 then\ndo:\ncall print$error:\ncall mon3:\n end:\ncall rewind$source$file:\ncall gentwo(codesize+1); /* plus one to include the xit */\ncall gentwo(countprt):\n end:\nelse\ndo:\ncall print$error:\ncall generate(xit):\ncall writeInt$file:\ncall closeInt$file:\ncall mon3:\n end:\n/* 2 <block> ::= <block head> <block end>\n*/\n\n/* 3 <block head> ::= <block head> <declaration> ;\n*/\n\n/* 4 <begin> ::= begin\n call incr$blk$level:\n*/\n\n/* 5 <block end> ::= <block body> ; end\ncall decr$blk$level:\n*/\n\n/* 7 <block body> ::= <statement>\n*/\n\n/* 8 <block body> ::= <block body> ; <statement>\n*/\n\n/* 9 <declaration> ::= <file declaration>\n*/\n\n/* 10 <simple declaration>\n*/\n\n/* 11 <simple declaration> <initial option>\n*/\n\n/* 12 <array declaration>\n*/\n\n/* 13 <array declaration> <initial option>\n*/\n\n/* 14 <subprogram declaration>\n*/\n\n/* 15 <external declaration>\n*/\n(simple declaration) ::= (declaration head) (identifier)\n\ncall process$simvar$decl(sp.aid);\n\n(initial option) ::= (initial head) (constant)\n\n(initial head) ::= initial (constant)\n\n(declaration head) ::= (declaration type)\n\n(declaration type) ::= string\ndo:\ncall settypesp(str);\ncall gen$intv(str*size);\nend:\n\n(string size option)\ndo:\ncall settypesp(str);\nend:\n\n(integer)\ncall settypesp(int);\n\n(decimal size option)\ndo:\ncall settypesp(dec);\ncall gen$intv(dec*size);\nend:\n\ndecimal\n\ncall settypesp(dec);\n\n(size option) ::= (variable)\nif settypesp(int) then\ncall litload(symblocmpl);\nelse\ncall error(\"si\");\n\n(integer)\ndo:\ncall move(calcvarc(mppl), accum7);\ncall gen$cont;\nend:\n\n(balanced statement)\n\n(unbalanced statement)\n\n(balanced statement) ::= (simple statement)\n\n(if clause) <true part> else <balanced statement>\n\n(label definition)\n\n(balanced statement)\n\n(unbalanced statement) ::= (if clause) <statement>'\ncall set$enter(tempsl); \n\n(balanced statement)\n\n(unbalanced statement) ::= (if clause) <true part>\ncall set$enter(tempsl); \n\n(balanced statement)\n\n(unbalanced statement) ::= (if clause) <true part> else <unbalanced statement>\ncall set$enter(tempsl); \n\n(label definition)\n\n(unbalanced statement)\n\n(true part) ::= <balanced statement>\ndo:\ncall branch$clause(brp)\ncall set$enter(typepsl-1));\nend:\n\n(label definition) ::= <identifier>\ncall process$label;\n\ncall process$label;\n/* 40 simple statement ::= (block) */\n/* 41 | (assignment statement) */\n/* 42 | (for statement) */\n/* 43 | (while statement) */\n/* 44 | (read statement) */\n/* 45 | (write statement) */\n/* 46 | (case statement) */\n/* 47 | (go to statement) */\n/* 48 | (case statement) */\n/* 49 call generate(pop): */\n/* 50 | (identifier) */\n/* do; */\n/* if ((process#ident(sp) <= pro) and pass2) then */\n/* call error(\"nf\"): */\n/* call process#proc(pro); */\n/* call proc#pro; */\n/* call generate(pop): */\n/* end; */\n/* 51 (assignment statement) ::= (left part) (expression) */\n/* call assignStmt: */\n/* 52 | (left part) */\n/* 53 | (assignment statement) */\n/* do; */\n/* if typemp<subvar then */\n/* call gen$loc(stypem#symlocmp): */\n/* ipcount=ipcount+1: */\n/* end; */\n/* 54 (expression) ::= (arithmetic expression) */\n/* | if expression (expression) */\n/* 55 | (arithmetic expression) ::= (term) */\n/* 56 | (term) */\n/* 57 | (arithmetic expression) ::= <term> */\n/* 58 | (primary) */\n/* 59 call chktmpl(sdi): */\n/* 60 call chktmpl(sbi): */\n/* if chktyp3 then */\n/* call generate(neg): */\n/* if chktyp3 then */\n/* call generate(not): */\n/* if chktyp3 then */\n/* | (term) ::= (primary) */\n/* 61 | (term) ::= (primary) */\n/* 62 call chktmpl(mpi): */\n/* 63 call chktmpl(dvi): */\n/* 64 call chktmpl(lpi): */\n/* 65 call chktmpl(expr): */\n/* 66 | (primary) ::= (primary element) */\n/* 67 | (primary element) ::= (variable) */\n/* if typemp<subvar then */\n/* call litt$loc(stypem#symlocmp): */\nIf typesp() subvar then\n call proc@pro:\n (constant)\n/x 68\n (procedure call)\n/x 69\n (assignment statement)\n/x 70\n call set@typep(stypep:=stypep):\n/x 71\ndo:\n call set@typep(stypep):\n call set@typep(stypep):\nend:\n/x 72\n (constant) := (integer)\n call gencon(int):\n/x 73\n (decimal) := (string)\n call gencon(str):\n/x 74\n (variable) := (identifier)\n call process$var(sp):\n/x 75\n (subscripted variable)\n/x 76\n (file declaration) := (file head) <file name>\n/x 77\n (file head) := file\n/x 78\n (file head) := file\n/x 79\n (file name) := (string) <length option>\n/x 80\n (string)\n/x 81\n (identifier) <length option>\n/x 82\n call process$ident$dc(mp,filel.0):\n/x 83\n (identifier)\n call process$ident$dc(sp,filel.0):\n/x 84\n (length option) := (identifier)\n if process$ident$mp then:\n/x 85\n (integer) 3\n/call gencon(int):\n/x 86\n (array declaration) := (array list) <bound pair list>\n/x 87\ndo:\n call gen$int$av(arr$dim):\n call gen$int$av(arr$num):\n call gen$int$av(stypep):\n call generate(row):\n do while (arr$num := arr$num-1) > 255;\n call literal(arr$loc(arr$num)):\nend:\n/x 88\n (array list) := (array head) <identifier>\n call process$array$dc(sp):\n/x 89\n (array head) := (declaration type) array\n arr$num:=0:\n/x 90\n (array head) <identifier>\n call process$array$dc(mp):\n/x 91\n (bound pair list) := (bound pair head) <bound pair> 0\n/x 92\n (bound pair head) := '\n arr$dim:=0:\n/x 93\n arr$dim:=arr$dim+1:\n/x 94\n (bound pair head) <bound pair> 0\n/x 95\n (expression) <expression>\n if (stypep(:int) or (stypep(:int)) then\n call error(\"bp\"):\n/x 96\n (expression) 0\n/x 97\ndo:\n if stypep(:int then\n call error(\"<int\"):\n call literal(stypep):\ncall generate(subt):\nend:\n/* 93 <subscript head> ::= <identifier> */\ncall processArray(tmp):\n/* 96 <subscript head> <expression> */\nif stypeemp int then\n call error(\"int\"): /* 97 'go to statement' ::= <go to> <identifier> */\ncall resolveLabel:\n/* 98 <go to> <integer> */\ncall resolveLabel:\n/* 99 'go to' ::= <go to> */\n/* 100 'goto' */\n/* 101 'read statement' ::= <read head> <variable> */\ndo:\ncall getFeld:\n if filelo then\n filelo=false:\n end:\nelse\n call generate(ecn):\nend:\n/* 102 'read head' ::= read (*/\ncall generate(ecn):\n/* 103 'read <file option> */\n: /* 104 'read head' <variable> */\ncall getFeld:\n/* 105 'write statement' ::= <write head> <expression> */\ncall putFeld(wlc):\n/* 106 'write head' <tab expression> */\n/* 107 'write head' <pic definition> */\n/* 108 'write head' ::= write (*/\ncall generate(dmp):\n/* 109 'write <file option> */\n: /* 110 'writeon (*/\n: /* 111 'writeon <file option> */\n: /* 112 'writeon head' <expression> */\ncall putFeld(wlc):\n/* 113 'write head' <tab expression> */\n/* 114 'write head' <pic definition> */\n/* 115 'file option' ::= <identifier> */\nif process$Identemp $filel then:\n /* 116 'identifier' */\nif process$Identemp $filel then:\n else call error(\"if\"): /* 117 'string' */\nelse /* 118 'string' */\n : /* 119 'rec option' ::= 'identifier' */\n if ((process$Identemp $sимвar) and (getSubtype = int)) then:\n else call error (\"int\"): /* 120 'integer' */\ncall gencon(int):\n/* 121 'pic definition' ::= <pic head> <pic list> */\n/* 122 'pic head' ::= <pic string> */\n/* 123 'pic string' */\nif (process$Identemp $sимвar and getSubtype = string) then:\nelse call error(\"string\"): /* 124 'string' */\nif (process$Identemp $sимвar and getSubtype = string) then:\nelse call error(\"string\"): /* 124 'string' */\n/*\n124 <pic list> ::= <expression>\n125 |\n126 <tab expression> ::= <tab <expression>]\n127 <if clause> ::= if <boolean expression> then\n128 call branchclause(brc);\n129 <if expression> ::= <if clause> <expression> else\n130 <boolean expression> ::= <boolean expression> or\n131 <boolean expression>\n132 call chktyp(bor);\n133 <boolean term> ::= <boolean primary>\n134 if chktyp3 then\n135 call generate(nolo);\n136 <boolean term> and\n137 <boolean primary>\n138 call chktyp(ando);\n139 <boolean primary> ::= <logical expression>\n140 if (<boolean expression> )\n141 call settypep(stypep1):\n142 <logical expression> ::= <expression> <relation>\n143 if (stypep2a) and (stypep2a) then\n144 call generate(typer3+2):\n145 else\n146 call chktyp(typer3);\n147 <relation> ::= =\n148 call settypep(eq1);\n149 <true expression>\n150 call settypep(eq2);\n151 call settypep(eq3);\n152 <comp> ::= <>\n153 call settypep(neq):\n154 =\n155 call settypep(eq):\n156 !=\n157 call settypep(neq):\n158 <while statement> ::= <while clause> <do statement>\n159 do:\n160 call generate(brc);\n161 call gen@two(symlocmp);\n162 call setenter(typer3):\n163 end:\n164 <while clause> ::= <while> <boolean expression>\n165 call branchclause(brc);\n166 <while> ::= while\n167 call setsymlocmp(codesize):\n168 <for statement> ::= <for clause> <step expression>\n169 <until clause> <do statement>\n170 do:\n171 call generate(brc):\n172 call gen@two(symlocmp);\n173 call setenter(typer3+1));\n174 end:\n175 <for clause> ::= for assignment statement\n176 do:\n177 if (stypep'stvar') or (stypep'int) then\n178 call error('ni');\n179 call generate(brc);\n180 call compiler@label;\n181 call setsymlocmp(codesize);\n182 call literal(symlocmp);\n183 call literal(label: symlocmp):\n184 call literal(loca: symlocmp):\n185 */\n/x 149 do:\nstep expression ::= step (expression)\nend:\ndo:\nif stepflag = true:\ncall error(\"nil\");\nstepflag = false:\ncall stepgen;\nend:\n/* 150 until clause ::= until non-term (expression)\ndo:\ncall generate(sleq);\ncall branchclause(last);\nend:\n/* 131 until non-term ::= until\nif not stepflag then\ndo:\ncall generate(intv(1));\ncall stepgen;\nend:\nelse\nstepflag = false:\n/* 152 do statement ::= do simple statement\n/* 153 close statement ::= close identifier\ncall closefile(sp):\n/* 154 close statement, identifier\ncall closefile(slp):\n/* 155 subprogram declaration ::= (subprogram heading)\n/* 156 (simple statement)\ndo:\ncall literal(symlocmp):\ncall generate(uns):\ncall generate(rtn):\ncall declbkllevel:\ncall setenter(symemp):\ncall literal(symlocnum-2):\ncall genintv(0):\ncall generate(sid):\nmnum, mcount = 0:\nif flag = false:\nend:\n/* 157 (function heading)\n/* 158 procedure heading, Proc>\n/* 159 function & param\n/* 160 (paramless proc)\n/* 161 (proc & param\n/* 162 paramless function ::= (declaration type) function\n/* 163 function & param\n/* 164 function head\n/* 165 declaration\n/* 166\ncall generate(i=2);\ncall gen@io(getaddr-4); \ncall generate(bra):\ncall generate(bir):\ncall enter@compiler$shb-1(0):\nif0:\nend:\n/* 181 <case block> ::= begin (case block body) end */\n/* 182 (case block body) ::= (statement) */\nend:\n/* 183 (case block body) ::= (statement) */\nend of case statement/\nend synthesize:\n\n/recovery error routine\nmodule:\n noconflict: proc (estate: byte):\n declare estate state(size: (i,j,k) index:size:)\n k = j * index2(estate) - 1;\n do i = j to k;\n if read(i) = token then return true:\n end:\n return false:\n end noconflict:\n recover: proc (state: size:)\n declare state stack: byte: state stack: size:;\n do forever:\n sp = sp - 1;\n do while (sp < 255):\n if noconflict(state: stack: sp) then\n if state will read token then\n if sp <> sp then sp = sp - 1:\n return state:\n end:\n sp = sp - 1:\n end:\n end:\n end:\n call scanner:\n end:\n end recover:\n\nmodule: parser routines\nmodule:\n do: /*block for declaration of*/\n declare (i,j,k) index:size: index byte:\n initialize: procedure:\n call title:\n call initialize@scanner:\n call initialize@synthesizer:\n end initialize:\n\ngetin1: procedure index:size: \nreturn index1(state:\nend getin1:\n\ngetin2: procedure index:size: \nreturn index2(state:\nend getin2:\nincsp: procedure;\n if (sp := sp + 1) = length(states) then\n call error('too');\nend incsp:\n\nlookahead: procedure;\n if nolook then\n do:\n call scanner;\n nolook = false;\n if listtoken then\n call print$token;\n end:\n end lookahead:\n\nset$var$1: procedure(i:\n declare 1 byte;\n set varc: and increment varindex x/\n varc(varindex)$i:\n if(varindex: varindex$1) > length(varc) then\n call error('var');\n end set$var$1:\n\n/* initialize for input - output operations */\ncall move$rch..wch.999: /* put filename in write fcb */\ncall setup$int$filename: /* create an output file for code generated */\ncall initialize:\n\ndo forever:\n do while pass1 or pass2:\n /* initialize variables */\n compiling: nolook: true: state=starts:\n sp:255:\n varindex: var: 0:\n do while compiling:\n if sta$=maxno then /* read state */\n do:\n call incsp: st$:states(sp)=state;\n i=get$11: call lookahead:\n j=i+get$12-1:\n do i = 1 to j:\n if read(token) then /* save token */\n do: var(sp)=varindex:\n /* copy to proper position */\n do index := 0 to accum:\n call set$var$1(accum(index));\n end:\n hash(sp)=hashcode:\n /* save relative table location */\n state=starts; end:\n end:\n else\n if i: then\n do:\n call error('sp');\n if(state < recover10 then compiling: false:\n end:\n end:\n else\n if state=maxno then /* apply production */\n do:\n sp:=sp-get$11: set$11:\n production = state-maxno:\n call synthetize:\n sp:=sp-get$11:\n varindex=starts:\n end:\n end:\n end:\nend:\nj = statestack(en);\n do while k = apply1(i) <> 0 and j <> k:\n j = j+1;\n end;\n if state = apply2(i) = 0 then compiling = false:\n end; else\n if state = maxino then \"lookahead state */\ndo:\n s = getini; call lookahead:\n do while k = look1(i) = 0 and token (1) k:\n t = t+1;\n end;\n state = look2(1):\n end; else\n/* push state */\ndo; call incsp:\n statestack(sp) = sp+2;\n state = getini; end;\n /* of while compiling */\nend; /*of while pass1 or pass2*/\nlistsource = false;\nlistprod = false;\nlisttoken = false;\ncall initialize;\npass2 = true;\nend; /*of do forever*/\nend; /*of block for parser */\nend; /*of block for declarations*/\noef\n190h: /*load point for interp program*/\n\ndeclare /*global literals*/\n lit literally 'literally'.\n true lit '1'\n false lit '0'\n forever lit 'while true'.\n cr lit '0dh'\n if lit '0ah'.\n\ndeclare /*op codes for algol-n machine instructions*/\n decl lit '25'.\n str lit '1'.\n int lit '2'.\n db lit '3'.\n bci lit '4'.\n boc lit '5'.\n iml lit '27'.\n im2 lit '28'.\n\ndeclare /*interface points for c/r/m and interp*/\n bdos lit '05h'.\n hoot lit '0h'.\n diskbuff loc lit '80h'.\n fc bloc lit '5ch'.\n diskbuffend lit '100h'.\n bdosbegin address initial(000h).\n buf address initial(diskbuffend).\n filename address initial(fcbloc).\n fnp based filename byte.\n\ndeclare /*build variables*/\n prtbase address.\n prt$addr address.\n prt$entry based prt$addr address.\n codebase address.\n codeptr address.\n stackbase address.\n curchar byte.\n switch byte initial(false).\n bld$flag byte.\n b based codeptr byte.\n a based codeptr address.\n templ address.\n t1 based templ byte.\n temp2 address.\n t2 based temp2 byte.\n\n/* declarations for interpreter */\n\ndeclare contz lit '0ah'.\n quote lit '22h'.\n what lit '63'.\n\ndeclare eolchar lit '0dh'.\n eoffiller lit '0ah'.\n intsize lit '128h'.\n disksize lit '128h'.\n stringdelim lit '22h'.\n conbuffsize lit '80h'.\n consote lit '0h'.\n usstock lit '48h'.\n max$shk$level lit '10h'.\n negative lit '0'.\n positive lit '1'.\n\ndeclare ea address.\n rb address.\n rc address.\nc based rc byte.\ntwobyteoperand based rc address.\nsb address.\nst address.\nbr based ra byte.\nara based ra address.\nrb based rb byte.\nmpn address.\nmed address.\ndeclare inputbuffer byte initial(conbuffsize).\nbufspace(conbuffsize) byte.\ninputindex byte.\nconbuffptr address.\ncon@char based conbuffptr byte.\ninputptr address.\ninput@char based inputptr byte.\numread byte.\nprintbufflength lit '71'.\nprintbufferloc lit '80h'.\ntabpos1 lit '142'.\ntabpos2 lit '156'.\ntabpos3 lit '170'.\ntabpos4 lit '184'.\nprintbuffer address initial(printbufferloc).\nprintpos based printbuffer byte.\nprintbuffend lit '067h'.\nrereadaddr address.\ninputtype byte.\nfield@length byte.\nsign byte.\ndeclare fieldaddr address.\nfbp address.\npacked address.\nbuffsend address.\nrecord@pointer address.\nbuffer address.\nnexttick@char based record@pointer byte.\nreg@length lit.\nblocksize lit.\nerror@flag byte.\nbk(max@blocksize) address.\nbyte@written address.\nfirstfield byte.\neofnode address.\neofrb address.\ndeclare (r0,r1,r2) (11)\n(sign0,sign1,sign2) byte.\ndecep0,decpt1,decpt2 byte.\ncte address.\nno@shift byte.\nbase address.\nb@byte based base byte.\nb@addr based base address.\nhold address.\nh@byte based hold byte.\nh@addr based hold address.\nptr@one address.\nptr@two address.\np@one based ptr@one byte.\np@two based ptr@two byte.\nstacktop address.\nret@addr based stacktop address.\npcb@ptr address.\npcl@value based pcl@ptr address.\ncounter byte.\nmov@nt address.\nret@value address.\n\n/*cp/m interface routines*/\n\nmon1: procedure(function, parameter):\n declare function byte,\n parameter address;\n goto bdoe;\nend mon1;\n\nmon2: procedure(function, parameter) byte:\n declare function byte,\n parameter address;\n goto bdoe;\nend mon2;\n\nmon3: procedure:\n goto boot;\nend mon3;\n\nprintchar: procedure(char):\n declare char byte;\n call mon2(char);\nend printchar;\n\nprint: procedure(buffer):\n declare buffer address;\n call mon1(buffer);\nend print;\n\ncrlf: procedure:\n call printchar(cr);\n call printchar(lf);\nend crlf;\n\n/* procedures for build */\n\nopenintofile: procedure:\n fnp(9) = 'a':\n fnp(10) = 't':\n fnp(11) = 'l':\n fnp(32) = 0:\n if mon2(15, filename) = 255 then\n do:\n call printchar('at\n call crlf;\n call mon3;\n end:\n end openintofile:\n\nreadintofile: procedure byte:\n return mon2(20, filename):\nend readintofile:\n\n/*global procedures*/\n\ninbuf: procedure:\n if (buff := buff+1) = diskbuff then\n do:\n buff = diskbuff;\nIf read<int>file \\( < \\) 0 then\n\nchar = 7fh;\nend\nend inclbuf;\n\nstorechar<inc>procedure:\n b = char;\n codeptr = codeptr+1;\nend storechar<inc>:\n\nnextchar<procedure byte>:\n call inclbuf;\n return curchar := char;\nend nextchar<procedure byte>:\n\nget<two>bytes<procedure>:\n h(i) = nextchar;\n b = nextchar;\nend get<two>bytes<procedure>:\n\ninc<codeptr>two<procedure>:\n codeptr = codeptr + 1 + 1;\nend inc<codeptr>two<procedure>:\n\ngetparm<procedure address>:\n return shl(double(nextchar),8) + nextchar;\nend getparm<procedure>:\n\npack<decimal>procedure(loc<one>, loc<two>):\n declare switch byte,\n loc<one> address,\n loc<two> address;\n pack<procedure>:\n if (switch := not switch) then\n p<two> = shl(p<one>-30h,4); /* odd */\n else\n do:\n p<two> = p<two> or (p<one>-30h); /* even */\n p<two> = p<two> + 1;\n end:\n end pack:\n\n ptr<one> = loc<one>;\n ptr<two> = loc<two>;\n switch = false;\n temp1 = ptr<two>;\n p<two> = 0;\n ptr<two> = ptr<two> + 1;\n temp2 = ptr<two>;\n p<two> = 0;\n ptr1<two> = ptr<two> + 1;\n do while p<one> <> 0:\n if (p<one> = '0') and (p<one> = '9') then do:\n call pack;\n ti = ti + 1;\n end:\n else\n if p<one> = '.' then do:\n 12 = ti; /* left offset to decpt */\n else\n do:\n error$flag = true;\n return;\n end:\n if (ptr<one> := ptr<one>+11 = diskbuffend) and hidd$flag then do:\n p<one> = diskbuffend;\n if read<int>file \\( < \\) 0 then do:\n p<one>(2) = 7fh;\n return;\nend:\nend:\n\nif switch then\ndo:\nt1 = t1 + 1;\np1two = p1two + 1;\nend:\nt2 = ti - t2; /* right offset to fetch */\nt1 = ti / 2;\np1two = t1 + 2;\np1two = p1two * 1;\np1two = positive; /* this field used for design */\nend pack\n/* procedures for interp */\n\nreadchar: procedure byte:\nreturn mon2(1,0):\nend readchar:\n\nread: procedure(a):\ndeclare a address:\ncall mon1(10,a):\nend read:\n\nopen: procedure byte:\nreturn mon2(16, file addr):\nend open:\n\nclose: procedure byte:\nreturn mon2(16, file addr):\nend close:\n\ndiskread: procedure byte:\nreturn mon2(20, file addr):\nend diskread:\n\ndiskwrite: procedure byte:\nreturn mon2(21, file addr):\nend diskwrite:\n\nmake: procedure byte:\nreturn mon2(22, file addr):\nend make:\n\ndelete: procedure:\nreturn mon2(22, file addr):\nend delete:\n\nsetdata: procedure:\ncall mon1(19, file addr):\nend setdata:\n\nselect: procedure(drive):\ndeclare drive byte:\ncall mon1(14, drive):\nend select:\n\nmask: procedure(location) address:\ndeclare location address,\n1 based location address:\nreturn mon 1 and 0bfff:\nend mask:\n\ncheckIntSign: procedure value byte:\ndeclare value address:\nif not high value:\nreturn negative:\nelse\nreturn positive:\nend checkIntSign:\ncheckSint: procedure(stack$loc): byte;\ndeclare stack$loc address;\nif not (rol(high(stack$loc),2)) then return true;\nelse return false;\nend checkSint;\n\ncheck$temp: procedure(stack$loc): byte;\ndeclare stack$loc address;\nif (rol(high(stack$loc),1)) then and\n(rol(high(stack$loc),2)) then return true;\nelse return false;\nend check$temp;\n\nsetUp$neg: procedure;\nif not checkSint(sign(ara)) then\nara = ara or 4000h;\nif not checkSint(sign(arb)) then\narb = arb or 4000h;\nend setUp$neg;\n\ncheck$neg: procedure;\nif not checkSint(sign(arb)) then\narb = arb and #bffh;\nend check$neg;\n\npop$stack: procedure;\ndeclare num byte;\nra = rb;\nif check$temp(arb) then\nrb = rb - (bit-2);\nelse rb = rb - 2;\nend pop$stack;\n\npush$stack: procedure(num);\ndeclare num byte;\nrba = ra;\nra = ra + num;\nend push$stack;\n\nmove: procedure(source,dest,count);\ndeclare source address;\ndest address;\ncount byte;\nschar based source byte;\ndchar based dest byte;\ndo while(count := 1;\n\ndchar = schar;\nsource = source - 1;\ndest = dest + 1;\nend;\nend move;\n\nfill: procedure(dest,char,n):\n\"fill locations starting at dest with char for n bytes.\"\ndeclare dest address;\nchar byte;\nd based dest byte;\ndo while (n := n-1) \": #0ffh;\nd = char;\ndest = dest + 1;\nend;\nend fill;\n\nerror$neg: procedure(msg):\ndeclare msg address;\ncall print$char(\" \");\ncall print$char(high(msg));\ncall print$char(low(msg));\ncall print$char(low(msg));\nend error$neg;\nwarning: procedure (warncode); \n declare warncode address;\n call crlf;\n call print( 'warning $' );\n call error$msg(warncode);\nend warning;\n\nerror: procedure (errcode);\n declare errcode address;\n call crlf;\n error$flag = true;\n call print( 'error $' );\n call error$msg(errcode);\nend error;\n\n/* file processing routines for use with cp/m */\n-initialize$disk$buffer: procedure;\n call fill$buffer.fill$(20);\nend initialize$disk$buffer;\n\nbuffer$status$byte: procedure byte;\n return fch(33);\nend buffer$status$byte;\n\nset$buffer$status$byte: procedure(byte);\n declare status byte;\n fch(33) = status;\nend set$buffer$status$byte;\n\nwrite$mark: procedure byte;\n return buffer$status$byte;\nend write$mark;\n\nset$write$mark: procedure;\n call set$buffer$status$byte(buffer$status$byte or 01h);\nend set$write$mark;\n\nclear$write$mark: procedure;\n call set$buffer$status$byte(buffer$status$byte and 0feh);\nend clear$write$mark;\n\nactive$buffer: procedure byte;\n return shr( buffer$status$byte, 1 );\nend active$buffer;\n\nset$buffer$inactive: procedure;\n call set$buffer$status$byte(buffer$status$byte and 0fdh);\nend set$buffer$inactive;\n\nset$buffer$active: procedure;\n call set$buffer$status$byte(buffer$status$byte or 02h);\nend set$buffer$active;\n\nset$random$mode: procedure;\n call set$buffer$status$byte(buffer$status$byte or 00h);\nend set$random$mode;\n\nrandom$mode: procedure byte;\n return rol(buffer$status$byte, 1 );\nend random$mode;\n\ndisk$eof: procedure;\n if eof$addr = 0 then\n call error(\"eof\");\n re = eof$addr + 1;\n ra = eof$ra;\n rb = eof$rb;\n goto eof$exit;\nend disk$eof;\nfill@filebuffer:procedure:\nif diskread = 0 then\n do:\n call set@buffer@active:\n return:\n end:\nif not random@mode then\n do:\n call disk@eof:\n return:\n end:\ncall initialize@diskbuffer:\ncall set@buffer@active:\nreturn:\nend fill@filebuffer:\nwrite@disk@ifreq:procedure:\nif write@mark then\n do:\n if diskwrite <> 0 then\n call error('dw'):\n call clear@write@mark:\n if random@mode then\n call set@buffer@inactive:\n else:\n call initialize@diskbuffer:\n end:\n record@pointer := buffer:\n end write@disk@ifreq:\natSend@diskbuffer:procedure byte:\n return (record@pointer := record@pointer + 1) := buffer:\n end atSend@diskbuffer:\nvar@block@size:procedure byte:\n return blocksize <> 0:\n end var@block@size:\nstore@rec@ptr:procedure:\n fcbadd(12) := record@pointer:\n end store@rec@ptr:\nwrite@@byte:procedure(char):\ndeclare char byte:\nif var@block@size and (bytes@written := bytes@written + 1) > blocksize then\n call error('er'):\n if atSend@diskbuffer then\n call write@disk@ifreq:\n if not active@buffer and random@mode then\n do:\n call fill@file@buffer:\n fcb(32) = fcb(32) - 1; /* reset record no */\n end:\n nextdiskchar := char:\n call set@write@mark:\n end write@@byte:\nset@file@addr:procedure:\n prt@addr := mask(19):\n file@addr := prt@entry:\n sof@addr := fcbadd(19):\n call pop@stack:\n end set@file@addr:\nset@file@pointers:procedure:\n buffer@end := (buffer := file@addr + 30) + disk@size:\n record@pointer := fcbadd(17):\n blocksize := fcbadd(14):\n call set@index:\n end set@file@pointers:\nsetup@file@entry:procedure,\nif open = 255 then\ndo:\n if make = 255 then\n call error(\"me\");\nend:\nend setupfileextent;\n\ndiskopen: procedure;\ndeclare (filename, buff, blksize) address,\n (i, j) byte,\n char based buff byte;\nincj: procedure byte;\n return (j := j + 1);\nend incj;\n\nprintaddr = mask(ra);\ncall popstack;\nblksize = ara;\ncall popstack;\nbuff = mask(ra);\ncall popstack;\nbuff = buff - char;\nfileaddr, ptrentry = ra;\nbuffer = ra + 0;\ncall fill((filename = ra + 1),\",\", 11);\nif char(2) = ':' then\ndo:\n bra = (char(1) and $ff) - 1;\n l = char - 2;\n buff = buff + 2;\nend:\nelse\n l = char;\nif l > 12 then\n l = 12;\n buff = buff + 1;\n j = 255;\ndo while (char(incl) <> \".\") and (j < 8):\nend;\ncall move (buff, filename, j);\nif l > incl then\ncall move (.char(j), filename=8, l-j);\ncall setupfileextent:\nara(19) = 0;\nara(18) = ra + 256;\nara(17) = blksize;\nra = ra + 168;\nend diskopen;\n\nsetoffstack: procedure:\n enra = ra;\n eoffb = rb;\nend setoffstack;\n\nsetupdisklo: procedure:\ncall set(fileaddr);\ncall set(file pointers);\nbyteswritten = 0;\nfirstfield = true;\nend setupdisklo;\n\nrandomsetup: procedure;\ndeclare bytecount address,\n record address,\n extent byte;\nif not varblocksize then\n call error(\"run\");\narra = ara - 1;\ncall setrandommode;\ncall setbufferinactive;\ncall write disksize;\nbytecount = blocksize * ara;\nrecordpointer = (bytecount + 1) / buffer - 1:\ncall store@rec@ptr;\nrecord = shr(bytecount,7);\nextent = shr(record,7);\nif extent > fcb(12) then\ndo:\n if close = 255 then\n call error('ce');\n fcb(12) = extent;\n call set@file@extent;\n end;\n fcb(32) = low(record) and 7fh;\ncall pop@stack;\nend random@setup;\n\nget@disk@char: procedure byte;\nif attend@disk@buffer then\ndo:\n call write@disk@ifree;\n call fill@file@buffer;\n end:\nif not active@buffer then\n call fill@file@buffer;\nif next@disk@char = eof@ll then\n call disk@eof;\nreturn next@disk@char;\nend get@disk@char:\n\ndisk@close: procedure;\ncall set@file@pointers;\ncall write@disk@ifree;\nprint@addr = mask(link);\nif close = 255 then\n call error('ce');\nprint@entry = 0;\nend disk@close:\nclear@print@buff: procedure;\ncall fill((printbuffer := printbufferloc),',',72);\nend clear@print@buff:\ndump@print@buff: procedure:\ndeclare temp address;\n char @based temp byte;\ntemp = printbuffer;\ndo while char = ' ';\ntemp = temp - 1;\nend:\ncall chr;\ndo printbuffer := printbufferloc to temp;\ncall printchar(printpos);\nend:\ncall clear@print@buff;\nend dump@print@buff:\nload@print@buff: procedure(chr):\ndeclare char @byte;\nprintpos := char;\nif (printbuffer := printbuffer +1)\n printbuffer := 0 then\n call dump@print@buff;\nend load@print@buff:\noutput: procedure(dest, char):\ndeclare dest @byte;\n char @byte;\nif dest = console then\ncall print@char(chr):\n \" to console \";\nelse\ncall write@byte(chr):\n \" to disk \";\nend output:\nwrite@byte: procedure(source, dest):\n\nDeclare source address.\nnum byte,\nnum digits byte,\nchar byte,\nindex byte,\ndest byte,\ncount byte;\nstoreOne: procedure;\nif (switch := not switch) then\n do:\n char = shr(hbyte,4) or '0';\n else\n call output(dest, char);\n end;\nelse\n do:\n call output(dest, hbyte and 0fh or '0');\n hold = hold - 1;\n end;\n count = count + 1;\nend storeOne;\n\nhold = source;\nsign = hbyte(1);\nif sign or 00h then\n call output(dest, ' ');\nelse call output(dest, '-');\ncount = 0;\nhold = hold - hbyte;\nnumdigits = hbyte * 2;\nhold = hold + 1;\num = numdigits - hbyte;\nswitch = false;\nhold = hold + 1;\ndo index = 1 to numdigits+1:\n if count = num then\n do:\n call output(dest, ' ');\n count = 100;\n end;\n else\n call storeOne;\n end;\nend writeStr;\n\nwriteStr: procedure(hold, dest):\ndeclare hold address,\nh based hold byte,\ndest byte,\nindex byte;\nhold = hold - h;\ndo index = 1 to h:\ncall output(dest, h, index));\nend;\nend writeStr;\n\nwriteInt: procedure(value, dest):\ndeclare value address, i byte, count byte;\ndeclare declint(5) address initial(1000), (100, 100, 10, 1);\ndeclare (flag, dest) byte;\nsign = checkIntSign(value):\nif sign = negative then\n do:\n value = -value and 0ffh; /* mask off next to left bit */\ncall output(dest, '-');\n end;\nelse call output(dest, ' '):\n flag = false;\ndo l = 0 to 4:\ncount = 30h:\ndo while value = 0:\n value = value - dec(l);\n do:\n if flag then\n call output(dest, ' ');\n value = value - dec(l);\n else:\n call output(dest, ' ');\n end;\ncount = count + 1;\n end:\ncall output(dest, ' ');\nend writeInt;\nflag := true;\ncount := count + 1;\nend:\nif flag or (1 := 4) then\ncall output(dest, count);\nelse\ncall output(dest, 1);\nend;\nend write4int;\n\nwrite4to4disk: procedure (type);\n/* type 0-integer, type 1-decimal, type 2-string */\ndeclare type byte;\nif type = 0 then\ncall write4int(ara, l);\nif type = 1 then\ncall write4int(ara, l);\nif not firstfield then /* separate fields with commas */\ncall write4byte(\", \");\nelse firstfield := false;\nif type = 2 then\ndo:\ncall write4byte(quote); /* strings put in quotes */\ncall write4str(ara, l);\ncall write4byte(quote); /* add trailing quotes */\nend;\ncall pop4stack;\nend write4to4disk;\n\nconcatenate: procedure;\ndeclare (size1, size2, tsize) byte;\ntemp1 := mask(ra);\ncall pop4stack;\nif not check4(temp(ara)) then\ndo:\ntemp2 := mask(ra);\ntemp2 := temp2 * t2;\ntsize2 := t2 + 1;\ncall move(temp2, ra, size2);\nend;\nelse\ndo:\ntsize2 := bra;\nra := ra - bra;\nend;\ntemp1 := temp1 - t1;\ntsize := t1;\ncall move(temp1 + 1, ra + size2, size1);\ntsize := size1 + size2;\nbra := tsize - 1;\nra := ra + tsize;\nbra := tsize;\nbra(i) := 0:\n/* set temp bits */\nend concatenate;\n\nconvert4to4int: procedure (loc, size) address;\ndeclare decint(5) address, initial (i1000, i000, 100, 10, 1),\nloc address,\nhold address,\nh based hold byte,\nnum address,\n(i1, j, size) byte;\nnum := 0;\nj := 3;\nhold := loc + size - 1;\nif size < 3 then\ncall error(\"too\");\nelse\ndo i := 1 to size:\n\nnum = num + (h - 30) * decimal(y + z - 1);\nhold = hold - 1;\nend;\nif num <= 10233 then\nreturn num;\nelse\nerror('io');\nend;\nend convert$to$stat:\n\nones$left$:\nprocedure:\ndeclare ctr byte;\nif shrink$byte.(ctr:4) = 0 then\ndo:\ndo ctr = 1 to 9;\nshr$byte(ctr) = shr$byte(ctr).4 or shr$byte(ctr + 1).4\nend:\nend:\nelse no$shift = true;\nend ones$left:\n\nones$right$:\nprocedure:\ndeclare ctr byte;\nctr = 11;\ndo index = 1 to 9;\nctr = ctr - 1;\nshr$byte(ctr) = shr$byte(ctr).4 or shr$byte(ctr + 1).4\nend:\nend ones$right:\n\nshift$right$:\nprocedure(count);\ndeclare count, ctr byte;\ndo ctr = 1 to count;\ncall one$right$;\nend;\nend shift$right$:\n\nshift$left$:\nprocedure(count):\ndeclare count byte;\nno$shift$ = false;\ndo ctr = 1 to count;\ncall one$left$;\nif no$shift$ then\nreturn;\nend;\nend shift$left$:\n\nleading$zeros$:\nprocedure(addr byte):\ndeclare count byte,\nctr byte,\naddr address:\ncount = 0;\nbase = addr;\ndo ctr = 1 to 9;\nif (shr$byte(ctr) and 0fh) = 0 then\nreturn count;\nend:\nend:\nif base = 0 then\ndo:\ncall error('dz');\nshr$byte(9) = 10h;\ndepth = 1;\nreturn 16;\nend;\nreturn count;\nend leading$zeros$:\n\nright$greater$:\nprocedure byte:\ndeclar: (i. ctr) byte;\ndo ctr = 1 to 9;\n if ri ctr) > 128 then (99h - ri ctr)) then\n return true;\n if ri ctr) < 1 then\n return false;\nend:\nelfflag = true:\nreturn true:\nend ri greater:\nalign: procedure:\n declart (x, y) byte:\nrightop: procedure (addr);\n declare addr address:\n if no shift then\n do:\n base = addr:\n call shift right(y := x - ctr);\n end:\n end rightop:\ny = 0;\n if decp0 > decptl then\n do:\n base = .rl;\n call shift left(x := decp0 - decpt1);\n decptl = decpt1 + ctr - 1;\n call rightop (.rl);\n decpt0 = decpt0 - y;\n end:\n else\n do:\n base = .rl;\n call shift left(x := decptl - decp0);\n decp0 = decp0 + ctr - 1;\n call rightop (.rl);\n decptl = decptl - y;\n end:\n end align:\naddor: procedure (second, dest);\n declare (second, dest) address, (index, cy, a, b, l) byte:\n hold = second:\n base = dest:\n cy = 0:\n ctr = 10;\ndo index = 1 to 11:\n a = ri ctr);\n b = hbyte (ctr);\n i = dec (a + cy);\n cy = carried and 1;\n i = dec (1 + b);\n cy = (cy or carry) and 1;\n hbyte (ctr) = i;\n ctr = ctr - 1;\nend:\nif cy then\n do:\n ctr = 10;\ndo index = 1 to 11:\n i = hbyte (ctr);\n i = dec (1 + cy);\n cy = carried and 1;\n hbyte (ctr) = i;\n ctr = ctr - 1;\nend:\nend addor:\ncompliment: procedure (numb);\n declare numb byte:\ndo case numb:\n hold = .r0;\n hold = .r1;\n hold = .r2;\nend;\nif sign0(numb) then sign0(numb) = negative:\nelse sign0(numb) = positive:\ndo ctr = 0 to 10:\n h$byte(ctr) = 99h - h$byte(ctr);\nend;\neend compliment;\nright$justify:procedure(numb):\ndeclare (numb,i) byte:\ndo case numb:\n base = .r0;\n base = .r1;\n base = .r2;\nend:\nl = 0:\ndo while (((i:=l+2) < dec$byte(numb)) and (h$byte(9)=0)):\ncall shift$right(2):\nend:\ndept0(numb) = decpt0(numb) - (l-2):\nend right$justify;\nset$mul$div:procedure:\nnoshift = false:\nif (sign0 and sign1) or\n (not sign0 and not sign1) then\nsign2 = positive:\nelse sign2 = negative:\ncall fill (.r2,0,10):\nend set$mul$div;\nadd$series:procedure(count):\ndeclare (i,count) byte:\ndo i = 1 to count:\ncall add$series(.r2,.r2):\nend;\ned add$series:\nmultiply:procedure(value):\ndeclare value byte:\nif value \":\" 0 then\ndo:\n if noshift then\n call error('ov');\n call add$series(value):\nend:\nbases = .r0:\ncall ones$left;\nend multiply:\ndivide:procedure:\ndeclare (i,j,k,x,1z0,1zl) byte:\ncall set$mul$div;\nif flag then false:\nif (1z0 \"= leading$zeros(.r0))\n (1zl \"= leading$zeros(.r1)) then\ndo:\n if 1z0 > 1zl then\n do:\n base = .r0;\n call shift$left(i:=(z0-1zl):\n decpt0 = decpt0 + i:\n x = 1zl:\n end:\nelse\ndo:\n base = .r1:\n call shift$left(i:=(z0-1z0):\nend;\ndecpt2 = decpt1 + 1;\n x = 1x0;\nend;\nelse x = 1x1;\n decpt2 = 19 - x + decpt1 - decpt0;\ncall compliment(0);\ndo l = x to 19:\nj = 0;\ndo while l is greater and sflag:\ncall addreg(r1,rl):\nj = J + 1;\nif sflag = true then sflag = false;\nk = shr(I,1);\nif I then\n r2(k) = r2(k) or j:\nelse r2(k) = r2(k) or shl(j,4):\nbase = .r0;\ncall one@right;\nend:\ndivide:\ncheckresult: procedure:\nif r2 = $99h then\ndo:\ncall compliment(2):\nsign2 = sign2 xor 1:\nend;\nelse\ndo:\nif r2 <> 0 then\ncall error('ov');\nif not sflag then\nsign2 = positive:\nend:\ndecr checkresult:\nchecksign: procedure:\nsflag = false;\nif sign0 and sign1 then\ndo:\nsign2 = positive;\nreturn;\nend:\nsign2 = negative;\nif not sign0 and not sign1 then\ndo:\nsflag = true;\nreturn;\nend:\nif sign0 then call compliment(1);\nelse call compliment(0);\ndecr checksign:\nadd: procedure:\ncall checksign:\ncall addreg(r1,r2):\ncall checkresult:\ndecpt2 = decpt0;\nend add:\ncpy@reg2@on@stack: procedure:\ndeclare count byte;\n 1 byte:\ncall right@justify(2):\ncall pop@stack:\ncount = 0;\nbase = .r2;\nl = 16 - (decpt2+1)/2;\ndo while (l is byte = 0 and count < 1):\n base = base + 1;\n count = count + 1;\n\nend;\nrs = rb + 2;\nbrs(0) = (count = 10 - count);\nbrs(1) = decSp(2);\ncall move(base, ra + 2, count);\nbrs(count + 2) = count + 2;\nbrs (count + 3) = sign2 or 000; // set sign and temp bits r\nrs = ra + count + 2;\nend\n\nload$reg: procedure(source, reg$num);\ndeclare source address.\nreg$num byte.\ncount byte;\nhold = source;\nif not check temp(h$addr) then\nhold = mask(hold);\nsign0(reg$num) = h$byte(1);\nhold = hold - h$byte;\ncount = h$byte;\ndo case reg$num:\nbase = .r0;\nbase = .r1;\nbase = .r2;\nend:\ncall fill(base, 0, 11);\nhold = hold + 1;\ndeSp(0)(reg$num) = h$byte;\nhold = hold + 1;\ncall move(hold, base + 10 - count, count);\nend load$reg:\n\nsetSup$regs: procedure;\nnoShift = false;\ncall load$reg(rs, 0);\ncall load$reg(rb, 1);\ncall right$justify(0);\ncall right$justify(1);\nend setSup$regs:\n\nstep$ins$cnt: procedure(num);\ndeclare num byte.\nrc = reg + num;\nend step$ins$cnt:\n\nbranch$absolute: procedure;\ncall step$ins$cnt(1);\nrc = two$byte operand - 1;\nend branch$absolute:\n\ng$code$addr: procedure(offset address);\ndeclare offset address;\nreturn codebase + offset;\nend g$code$addr:\n\ng$ptr$addr: procedure(offset address);\ndeclare offset address;\nreturn ptr$base + offset;\nend g$ptr$addr:\n\nload: procedure(addr);\ndeclare addr address.\nptr$addr = mask(addr);\nptr$entry;\nend load:\n\nstore$dec: procedure(source, dest);\ndeclare (source, dest, dest$entry)\n(adj$to, avail$to, h$byte) byte,\na based source address.\nd based dest address.\ndecr byte.\nsign based dest & sign byte:\nif check@temp(s) then\ntempl = source;\nelse templ = mask(source);\ntemp2 = mask(dest);\navailsto = t2 - 2;\ndest@sign = temp2 + 1;\nt2(1) = t1(1) and 0th // mask off temp bits\nsource = (templ * templ - 1);\ndest = temp2 - t2;\navailsto = t1;\ndecpt = t1(1);\nsigbytes = ((availsito + 2 - decpt) + 1) / 2;\nif availsito <= availsto then\ndo:\ncall fill(dest, 00h, t2);\ncall move(source, dest, t1+2);\nend:\nelse if sigbytes < availsto then\ndo:\ncall move(source, dest, t2);\nt2 = dest;\nt2 = availsto;\nt2(1) = (availsto - sigbytes) * 2;\nif decpt then\nt2(1) = t2(1) + 1;\ncall warning('11');\nend:\nelse\ndo:\nhold = dest;\nhradr = 0101h;\nhr@byte(2) = 10h;\nsign = positive;\ncall error('11');\nend:\nend store@dec:\nstore@int: procedure(dest, value);\ndeclare (dest, value) address;\nprnt@adr = mask(dest);\nprnt@entry = value;\nend store@int;\nstore@str: procedure(source, dest);\ndeclare (dest, source) addresses.\nda based source address.\nd based dest address:\nif check@temp(s) then\ntempl = source;\nelse templ = mask(source);\ntemp2 = mask(dest);\ndest = temp2 - t2;\nsource = templ - t1;\nif t1 <= t2 then\ndo:\ncall fill(dest, 20h, t2);\ncall move(source, dest, t1);\nend:\nelse\ndo:\ncall move(source, dest, t1);\ncall warning('so');\nend:\nend store@str:\nallocate@str: procedure:\nif brs = 0 then\ndo:\ncall error('az');\nbrs = 10;\nend\n call push#stack(brn:=brn+1);\n brn = brb;\nend allocate#str;\n\nallocate$loc:procedure:\ndeclare store byte;\n if brn = 0 then\ndo:\n call error('az');\n brn = 9;\n end:\n ctr = brn;\n store = (brn+1)/2+2;\n call push#stack(store);\n brn = store;\n ars = ars or 0100h;\nend allocate$loc;\n\nset$up$allocation:procedure:\n pushd ir = mask(ra);\n call pop$stack;\nend set$up$allocation;\n\nfind$orb:procedure:\n if check$temp(ars) then\n rb = ra - (brn + 2);\n else rb = ra - 2;\nend find$orb;\n\nsave$pchb:procedure:\n if move$cnt = 0 then\n return;\n call push#stack(2);\n call move(pchptr,ra,move$cnt);\n pch$value(1) := ra;\n ra = ra + move$cnt;\n ars = move$cnt;\nend save$pchb;\n\nunsave:procedure:\n call move({expl:=ra-ars,hold,ars})\n ra = {expl}\nend unsave;\n\ncalc$row:procedure:\ndeclare (index,num,v,size:type) byte,\n (numarrays,numdim,allocation,counts) byte,\n d (10) byte;\n type = brn: .x 1-int.2-dec.3-str */\ncall pop$stack;\n numarrays = brn;\ncall pop$stack;\n numdim = brn;\ncall pop$stack;\n v := 0;\n isize = 1:\n d(numdim) := 1;\n if numdim = 1 then\ndo:\n isize = isize + brb + 1;\n v := brb;\n call pop$stack;\n call pop$stack;\nend:\nelse\n do index = 1 to num$dim:\n = numdim - index;\n isize = isize + num := brn - brb + 1:\n d(index) := num := d(index+1);\n v := v + brb := d(index+1);\n call push$stack;\n call pop$stack;\nend:\n\nif type = int then\n call push-stack(2);\nelse\n alloc-len = bra;\ndo count = 1 to num-arrays:\n call step-insent(1):\n bra = c(1);\n bra(1) = c and 3fh;\n prt-addr = arr + ptr-base:\n ptr-entry = ra or 4000h: /* set addr bits */\n bra = num-dim:\n if num-dim <> 1 then\n do index = 1 to num-dim - 1:\n ra = ra + 1;\n bra = alloc-len;\n end:\n end:\n ra = ra + 1;\n bra = 0;\n bra = alloc-len;\n if type = int then\n do:\n bra = 2;\n ra = ra + 1;\n hold = ra;\n ra = ra + absise * 2;\n h-addr = ra;\n end;\n else\n if type = decI then\n do:\n bra = (bra+1)/2 + 4;\n ra = (hold := ra+1) + 2;\n bra = alloc-len;\n do index = 1 to absise:\n call allocate-dec:\n call push-stack(2):\n bra = c(tr; /* reset to allocated length */\n end:\n call pop-stack:\n h-addr = ra;\n end:\n else\n if type = str then\n do:\n bra = bra + 3;\n ra = (hold := ra+1) + 2;\n bra = alloc-len;\n do index = 1 to absise:\n call allocate-str:\n call push-stack(2);\n arr = arr;\n end:\n call pop-stack:\n h-addr = ra;\n end:\n end:\n end:\n call step-insent(1):\nend counts;\nend calc-row:\n\ncalc-row: procedure:\ndeclare array-addr address:\nlocation address:\nabs-byte based array-str byte:\nabs-addr based array-addr address:\n(1 num-dim) byte:\noffset address:\narray-addr = mask(rn):\ncall pop-stack:\noffset = arr:\nnum-dim = abs-byte:\ndo 1 = 2 to numaddr;\ncall pop@stack;\narrayaddr = arrayaddr + 1;\noffset = arr * a$byte + offset;\nend;\narrayaddr = arrayaddr + 1;\noffset = (offset - a$byte + 1) = a$byte();\narrayaddr = arrayaddr + 2;\nif (location = arrayaddr + offset) a$addr then\ncall error('ab');\nend calc@sub;\n\ndecrement@blk: procedure(num);\ndeclare num byte;\nra = blk$level = blk@level - num + 1);\ncall find@rb;\nend decrement@blk;\n\nadd@int: procedure(int1, int2) address;\ndeclare (int1, int2) address;\nreturn int1 + int2;\nend add@int;\n\nsub@int: procedure(int1, int2) address;\ndeclare (int1, int2) address;\nreturn int1 - int2;\nend sub@int;\n\nmul@int: procedure(int1, int2) address;\ndeclare (int1, int2) address;\nreturn int1 * int2;\nend mul@int;\n\ndiv@int: procedure(int1, int2) address;\ndeclare (int1, int2) address;\nreturn int1 / int2;\nend div@int;\n\nexit@interp: procedure;\ncall crlf;\ncall mon3;\nend exit@interp;\n\nconsole@read: procedure;\ncall crlf;\ncall printfchar('-');\ncall printfchar('');\ncall printfchar('');\ncall read(), inputbuffer);\nif buff$space(1) = cntz then\ncall exit@interp;\nnumRead = buff$space;\nconbuffptr = buff$space;\nbuff$space(buff$space+1) = eolchar;\nend console@read;\n\nmore@con@input: procedure byte;\nreturn conbuffptr < buff$space( num$read);\nend more@con@input;\n\nconsole@input$err: procedure;\nre = readdr; /* reset program counter */\ncall warning ('11');\ngoto error@exit; /* return to outer level */\nend console@input$err;\n\nget@con@char: procedure byte;\nconbuffptr = conbuffptr + 1;\nreturn con@char;\nend get@con@char;\nnext@input@char: procedure byte:\n if input$type = 0 then /* read from disk */\n /* do forever:\n if (buffer$space (input$index) := get disk$char) = if then\n do:\n if var$blocksize then\n call error'(set'\n end:\n else\n return next@disk$char:\n end\n if input$type = 1 then /* input from console */\n return get$console$char:\n end\n next@input$char:\nget$field: procedure:\n declare hold byte, delim byte;\n field$length = 0;\n do while (hold := next@input$char) = ' ':\n end:\n if input$type = 0 then\n input$ptr = buffer$space:\n if input$type = 1 then\n input$ptr = console$buffer$ptr:\n if hold <> quote then\n delim = ' ':\n else:\n delim = quote:\n hold = next@input$char:\n end:\n do while (hold <> delim) and (hold <> eof$char):\n field$length = field$length + 1:\n hold = next@input$char:\n end:\n end get$field:\nget$int$field: procedure:\n declare sign byte:\n call get$field:\n if input$char = '-' then\n do:\n sign = 1:\n input$ptr = input$ptr + 1:\n field$length = field$length - 1:\n end:\n else\n if input$char = '+' then\n do:\n sign = 0:\n input$ptr = input$ptr + 1:\n field$length = field$length - 1:\n end:\n else\n sign = 0:\n call push$stack(2):\n are = convert$to$int(input$ptr,field$length):\n if error$flag then\n call console$input$error:\n if sign then\n are = -are and 0xff#h: /* set neg bit and conv to neg int */\n end\n get$int$field:\n end\nget$str$field: procedure:\n call get$field:\n con$char = field$length + 1:\n input$ptr = console$buffer$ptr + con$char:\n input$char = field$length:\n call push$stack(2):\n are = console$buffer$ptr or 4000#h:\n end get$str$field:\nget#dec#field: procedure:\ncall get#field:\ncall push#stack(2):\ncond#char = 0; /* set binary 0 as end of dec */\nif input#char = '0' then\ndo:\n sign = 1;\n input#ptr = input#ptr + 1;\nend:\nelse\nif input#char = '=' then\ndo:\n sign = 0;\n input#ptr = input#ptr + 1;\nend:\nelse\n sign = 1;\ncall pack#decimal(input#ptr, rm);\nif error#flag then\ncall console#input#error:\n rm = ptr两点 = 1;\n brs(i) = sign or 0@8h; /* set sign and temp bits */\nend get#dec#field:\ninitialize#execute: procedure:\nstack-top=3050h:\nmed, rc = code#base:\nopr = pr#base:\nstr, sb = stack#base:\nrm = (rb := sb) + 2:\nbegin#flag := false:\nend initialize#execute:\n/* set up machine */\ncall print(\"algol-m interpreter-vers 1.08\");\ncall crlf:\ncall open#int#file:\nbegin#flag := true:\ncall incbuf; call incbuf; /* skip codesize */\npr#base = .memory:\ncode#base = get#parm + pr#base:\ncode#ptr = code#base:\n/* load machine */\ndo while next#char <> 7fh:\n if curchar = 128 then\ndo:\ncall sto#char#inc:\ncall incbuf:\ncall sto#char#inc:\nend:\nelse\n if curchar = str then\ndo:\ncall sto#char#inc:\n incr = code#ptr:\n char = 0; /* set initial length to zero */\ncall sto#char#inc:\ndo while next#char = 0:\ncall sto#char#inc:\nt = t + 1;\nend:\nchar = t + 1:\ncall sto#char#inc:\nchar = 0; /* must set str length an odd quantity */\ncall sto#char#inc:\nend:\nelse\n if curchar = int then\ndo:\ncall sto#char#inc:\nhold = buff + 4:\nfieldlength = 0;\ndo while nextchar <> 0:\n fieldlength = fieldlength + 1;\nend;\nd = convert(Stoint(hold, fieldlength);\ncodeptr = codeptr + 2;\nend;\nelse\n if curchar = dell then\ndo;\ncall stochar$inc;\ncall incbuf;\ncall pack$decimal(buff, codeptr);\ncodeptr = codeptr + 2;\nbuff = ptr$one + 2;\nend;\nelse\n do:\ncall stochar$inc;\n if (curchar = brs' or 'curchar = bsc) then\ndo;\ncall get$two$byte$es;\n a = a + codebase;\ncall inc$codeptr$two;\nend;\nelse\n if (curchar = i1) or (curchar = deb) then\ndo;\ncall incbuf;\ncall stochar$inc;\nend;\nelse\n if curchar = im2 then\ndo;\ncall incbuf;\ncall stochar$inc;\ncall incbuf;\ncall stochar$inc;\ncall incbuf;\ncall stochar$inc;\nend;\nend;\nend;\nstackbase = codeptr;\n\nexecute: procedure:\ndo forever:\n if rol(c.1) then /* must be lit or lit+lit */\ndo:\ncall push$stack(2);\nbrs = c(1); /* load in reverse order */\nbrs(1) = c and 3fl; /* mask bits 10 */\narm = ptr(arm + ptr$base) or 4000h; /* set @i addr bits */\nif rol(c.2) then call load$main:\ncall step$ins$nent(1);\nend:\nelse\n do case c:\n/* @ case @ not used*/\n/* @ lit */\ndo:\ncall push$stack(2);\ncall step$ins$nent(1);\nrc = rc + c + 1;\narm = rc or 4000h;\ncall step$ins$nent(1);\nend:\n/* 2 int */\ndo;\ncall push@stack(2);\ncall step@instcnt(1);\nara = two@byte@opnand;\ncall step@instcnt(1);\nend;\n\n/* 3 xch */\ndo;\nhold = ara;\nara = arb;\n arb = hold;\nend;\n\n/* 4 lod */\ncall load(ra);\n\n/* 5 dch */\ndo;\ncall step@instcnt(1);\ncall decrement@bkcr;\nend;\n\n/* 6 dmp */\ncall cr1f;\n\n/* 7 xit */\nreturn;\n\n/* 8 ald */\ndo;\ncall set@up@alloc;\ncall allocate@dec;\nprt$entry=ra or 4000h;\nend;\n\n/* 9 ald */\ndo;\ncall set@up@alloc;\ncall allocate@str;\nprt$entry=ra or 4000h;\nend;\n\n/* 10 ald */\ndo;\ncall set@up@alloc;\ncall allocate@str;\nprt$entry=ra or 4000h;\ncall push@stack(2);\nbra = str;\nend;\n\n/* 11 ald */\ndo;\ncall set@up@alloc;\ncall allocate@str;\nprt$entry=ra or 4000h;\ncall push@stack(2);\nara = arb;\nend;\n\n/* 12 ald */\ndo;\ncall set@up@neg;\narb = add$int(arb,ara);\ncall check$neg;\ncall pop@stack;\nend;\n\n/* 13 add */\ndo;\ncall setSupRegs: /* puts values of top two items in reg0 and reg1 respectively */\ncall align;\ncall add;\ncall cpyReg2SonStack;\nend;\n\n/*14 sbi x*/\ndo:\ncall setSupNeg:\n arb = subInt(arb,arn);\ncall checkNeg;\ncall popStack;\nend;\n\n/*15 sbd x*/\ndo:\ncall setSupRegs: /* puts values of top two items in reg0 and reg1 respectively */\ncall align;\ncall compliment(0);\nif sign0 then sign0 = negative;\nelse sign0 = positive;\ncall add;\ncall cpyReg2SonStack;\nend;\n\n/*16 mp1 x*/\ndo:\ncall setSupNeg:\n arb = multInt(arb,arn);\ncall checkNeg;\ncall popStack;\nend;\n\n/*17 mpd x*/\ndo:\ncall setSupRegs: /* puts values of top two items in reg0 and reg1 respectively */\ndeclare (1, index) byte;\ncall setMulDiv;\n decPt2 = decPt0 + decPt1;\ni = 10;\ndo index = 1 to 10;\n call multiply(r1(i) = i and 0fh);\n call multiply(shrl(r1(i),4)));\nend:\ncall cpyReg2SonStack;\nend;\n\n/*18 dji x*/\ndo:\ncall setSupNeg:\n arb = divInt(arb,arn);\ncall checkNeg;\ncall popStack;\nend;\n\n/*19 djd x*/\ndo:\ncall setSupRegs: /* puts values of top two items in reg0 and reg1 respectively */\ncall divide;\ncall cpyReg2SonStack;\nend;\n\n/ *20 x*/\n/* not used x*/\n\n/ *21 x*/\n/* not used x*/\n\n170\n/*22 neg */\ndo:\nif check#int(ars) then\nars = ~ars and 0h\nelse if check#temp(ars) then\nars = ars xor 0100; /*change sign bit*/\nelse\ndot\nhold = mask(ars);\nhr#addr = h#addr xor 0100h.\nend:\n\n/*23 call */\n/* not implemented */\n\n/*24 cl2 */\n/* not implemented */\n\n/*25 decl */\ndo:\ncall push#stack(2):\ncall step#ins#cnt(1):\nrec = rec + c + 2;\nars = rec or 4000h:\ncall step#ins#cnt(1):\nend:\n\n/*26 pop */\ncall pop#stack:\n\n/*27 im1 */\ndo:\ncall push#stack(2):\ncall step#ins#cnt(1):\nars = c1:\nend:\n\n/*28 im2 */\ndo:\ncall push#stack(2):\ncall step#ins#cnt(1):\nbr = c(1); /*load in reverse*/\nbr(1) = c1:\ncall step#ins#cnt(1):\nend:\n\n/*29 */\n/* not used */\n\n/*30 */\n/* not used */\n\n/*31 cat */\ncall concatenate:\n\n/*32 bli */\nhik #hik#level + 1 = ran:\n\n/*33 bid */\ncall decrement #hik(1):\n\n/*34 brz */\ncall branch#absolute:\n\n/*35 bsc */\nif brz = 0 then\ncall branch#absolute;\nelse\n do:\n call stepsinsent(2);\n call popstack:\n end;\n/*36 lsw */\n do:\n if brb < bra then\n brb=1;\n else brb=0;\n call popstack:\n end;\n/*37 lsw */\n/* not implemented */\n/*38 lsw */\n/* not implemented */\n/*39 str */\n do:\n if brb > bra then\n brb=1;\n else brb=0;\n call popstack:\n end;\n/*40 dgtr */\n/* not implemented */\n/*41 sgtr */\n/* not implemented */\n/*42 eq1 */\n do:\n if brb = bra then\n brb=1;\n else brb=0;\n call popstack:\n end;\n/*43 dsql */\n/* not implemented */\n/*44 sq1 */\n/* not implemented */\n/*45 neg */\n do:\n if brb <> bra then\n brb=1;\n else brb=0;\n call popstack:\n end;\n/*46 dneg */\n/* not implemented */\n/*47 deq */\n/* not implemented */\n/*48 geq */\n do:\n if brb > bra then\n brb=1;\n else brb=0;\n call popstack:\n end;\n/*49 dgeq */\n/* not implemented */\n/*50 ageq */\n/* not implemented */\n/* St. log */\ndo;\n if brb < bra then\n brb = 1;\n else brb = 0;\n call pop@stack;\nend;\n/* not Implemented */\n/* u-aleq */\n/* not Implemented */\nif bra = 0 then\n bra = 1;\nelse bra = 0;\nend;\n/* not Implemented */\n/* not Implemented */\n/* not Implemented */\ndo;\n if (bras=0) or (brb=0) then\n brb=1;\n else brb=0;\n call pop@stack;\nend;\n/* not Implemented */\n/* not Implemented */\n/* not Implemented */\ndo;\n if (bras=0) and (brb=0) then\n brb=1;\n else brb=0;\n call pop@stack;\nend;\n/* not Implemented */\n/* not Implemented */\ndcall write@int(ars,0);\ncall pop@stack;\nend;\n/* wdc */\ndcall write@temp(ars) then\ncall write@dec(ra,0);\nelse\ncall write@dec(mask(rn),0);\ncall pop@stack;\nend;\n/* wdc */\ndcall write@temp(ars) then\ncall write@email(ars,0);\nelse\ncall write@email(mask(ra),0);\ncall pop@stack:\nend;\n/*66 wid z/\ncall write@to@disk(0):\n/*67 wid z/\ncall write@to@disk(1):\n/*68 wid z/\ncall write@to@disk(2):\n/*69 sbr z/\ndo:\n arb = ara = arb;\ncall pop@stack;\nend;\n/*70 bra z/\ndo:\n rc = codebase + ara;\ncall pop@stack;\nend;\n/*71 row z/\ncall calc@row:\n/*72 sub z/\ncall calc@sub:\n/*73 rec z/\ncall get@int@field:\n/*74 rec z/\ncall get@dec@field:\n/*75 rec z/\ncall get@str@field:\n/*76 rdi z/\ndo:\n inputtype = 0;\ncall get@int@field:\nend;\n/*77 rdd z/\ndo:\n inputtype = 0;\ncall get@dec@field:\nend;\n/*78 rds z/\ndo:\n inputtype = 0;\ncall get@str@field:\nend;\n/*79 rem z/\ndo:\n inputtype = 1;\n rc = addr = rc;\ncall console@read;\nend;\n/*80 scr z/\nif more@con@input then\n call console@input@error;\n/*81 stil z/\ndo:\n call store@int(rb, arr);\n rb = rb - 2;\nend;\ncall store#dec(ra, rb); \nr\nrb = rb - 2;\nend;\n\ncall store#str(ra, rb); \nr\nrb = rb - 2;\nend;\n\ncall store#int(rb, ara); \ncall pop#stack;\n\ncall pop#stack;\nend;\n\ncall store#dec(ra, rb); \ncall pop#stack;\n\ncall pop#stack;\nend;\n\ncall store#str(ra, rb); \ncall pop#stack;\n\ncall pop#stack;\nend;\n\ncall disk#open;\n\ncall disk#close;\n\ncall pop#stack;\nend;\n\nrdb =\n\nready sequential block x/\ndo:\ncall setup#disk#10;\n\ncall set#of#stack;\nend;\n\nready random block x/\ndo:\ncall setup#disk#10;\n\ncall random#setup;\n\ncall set#of#stack;\nend;\n\nend of record for read x/\nadvances to next line feed x/\nif var#block#size then\n do while get#disk#char () if;\n end:\ncall store#rec#ptr;\nend;\n\nend of record for write x/\ndo;\nif var#block#size then\ndo while byteswritten < (blocksize - 2);\ncall writeaabyte(' ');\nend;\ncall writeaabyte(cr);\ncall writeaabyte(lf);\ncall storearecsptr;\nend;\n/*93 pro.x/\ndo:\nstack = stacktop - 2;\nretaddr = rec;\nrc = area + codebase;\ncall pop@stack;\nend;\n/*94 sav.x/\ndo:\ndeclare (lm, num) byte;\npcbptr = mask(ra);\ncall pop@stack;\nmovcnt = area;\ncall pop@stack;\nif area <> 0 then\ndo:\nhold = ra;\ncounter = 2 * area + 1;\ndo l = 1 to counter:\ncall pop@stack;\nend;\nnm = hold - ra:\nif (temp := stacktop - num) <> ra then\ncall error('mo');\ncall movcra+2,temp1,num);\ncall fill(temp1-2,0h,2);\nend;\nelse\ncall pop@stack;\nblk = blklevel+1 = ra;\nif pcbAvalue(l) = 0 then\npcbAvalue(l) = 1;\nelse\ncall sav@pcb;\nend;\n/*95 sav2 x/\ndo:\ndeclare 1 byte,\nparm@count address;\ntad1 = ra;\ntad2 = rb;\ntad3 = stacktop - 2;\nrba = ra - 2;\nparm@count = area;\ncall pop@stack;\npcbptr = pcbptr + 4 + parm@count * 2;\ndo l = 1 to parm@count:\ntestvalue = area;\ncall pop@stack;\nif testvalue = int then\n\ncall store@int(pcbptr, area);\nelse\nif testvalue = deci then\n\ncall store@deci(ra, pcbptr);\nelse\n\ncall store@str(ra, pcbptr);\ncall pop@stack;\npcbptr = pcbptr - 2;\nend;\nrm = tad1;\nrb = tad2;\ntad3 = 0;\nend\n/*96 uns */\ndo:\n haddr = mask(rs);\n ret$value = haddr;\n call decrement$hlk(1);\n if haddr(1) = 1 then\n call unsave;\n else\n haddr(1) = 0;\n call decrement$hlk(1);\n call push$stack(2);\n if check$int(ret$value) then\n ara = ret$value;\n else\n do:\n templ = mask(ret$value);\n call move(templ = tl.ru, tl+2);\n ra = ra + tl;\n bra(1) = bra(1) or 0e0h;\n end;\n end:\nend:\n/*97 rtn */\ndo:\n rc = ret$addr;\n stacktop = stacktop + 2;\nend:\n/*end case*/\ncall step$line$cnt(1);\nerror$flag = false:\nend: /* if do for ever */\nend execute;\nmainline:\ncall crlf:\ncall initialize$execute;\neofexit: /* on end of file of current disk file come here */\nerror$exit: /* regroup on console input error */\ncall execute:\ncall exit$interp:\neof\n\nLIST OF REFERENCES\n\n\n13. Strutvnski, Kathryn B. Information on the CP/M Interface Simulator, internally distributed technical note.\n\n\n<table>\n<thead>\n<tr>\n<th>No.</th>\n<th>Copies</th>\n<th>Name and Details</th>\n</tr>\n</thead>\n</table>\n| 1. | 2 | Defense Documentation Center \n Cameron Station \n Alexandria, Virginia 22314 |\n| 2. | 2 | Library, Code O212 \n Naval Postgraduate School \n Monterey, California 93940 |\n| 3. | 4 | Department Chairman, Code 52 \n Department of Computer Science \n Naval Postgraduate School \n Monterey, California 93940 |\n| 4. | 1 | Assoc Professor Barry A. Kildall, Code 52Kn \n Department of Computer Science \n Naval Postgraduate School \n Monterey, California 93940 |\n| 5. | 1 | LCDR Stephen T. Holl, USN, Code 52H1 \n Department of Computer Science \n Naval Postgraduate School \n Monterey, California 93940 |\n| 6. | 2 | Microcomputer Laboratory, Code 52ec \n Department of Computer Science \n Naval Postgraduate School \n Monterey, California 93940 |\n| 7. | 1 | LCDR John P. Flynn, USN \n Fleet Air Reconnaissance Squadron One \n NAS Agana, Guam \n FPO San Francisco 96601 |\n| 8. | 1 | LT Mark S. Moranville, USN \n 19109 Creekside Place \n Salinas, California 93908 |"}}},{"rowIdx":273,"cells":{"id":{"kind":"string","value":"c8f51bdab4117540b799e1d34b68f9612fbdcb10"},"text":{"kind":"string","value":"Welcome to the Course\n\nHi! Welcome to CSC280. I’m glad you’re taking it, and (although I realize it is a B.S. requirement and—worse still!—it covers what certainly is the most abstract material in our undergraduate core), I hope that you’ll be glad you took it!\n\nAfter all, most of you are computer science majors, and this course is about getting a firm, rigorous handle on what it means to be a computer of a given type, i.e., we will try to capture what it means to be a model of computation. And we will see how to prove that models have, or lack, the ability to accept certain problems.\nIndeed, computer science—and the challenges computer scientists (and real world programmers) face—is to a surprisingly large extent about hard or easy problems are. (My life is particularly much about that; I’m a complexity theorist!\\(\\Psi\\)) Here are some examples (by the end of the course we’ll know the answers to the red ones as well as anyone on Earth, although that is a trick claim in the third case):\\(\\Psi\\)\n\n- Can a machine with finite memory recognize the palindromes?\n- Is \\(\\{ww \\mid w \\in \\{0, 1\\}^*\\}\\) a context-free language?\n- Can we in polynomial time tell whether a given Boolean formula is satisfiable?\n- Does there exist a Turing machine that, given as input another Turing machine \\(B\\), decides whether \\(B\\) accepts at least one string?\nQuestions of the difficulty of problems are everywhere. They touch all aspects of our life and our profession, from helping us build compilers to telling us why perfect compiler optimization is impossible; from (and this is my own work’s current focus) helping us protect elections from manipulative attacks to helping us mount those attacks; from scheduling things well, to building small computer circuits, to searching for patterns, to securely encoding messages.\n\nAnd as CS people, to better understand problems, and see their commonalities, we group them into classes, typically based on the type/amount/power of computation that suffices to solve the problems.\nWelcome to the Course, cont’d\n\nAs you might imagine, there is a huge array of classes by now, capturing all sorts of approaches to computation and all sorts of models of computation—ranging from DNA-based computing to quantum computing to probabilistic computing to unambiguous computing to nondeterministic computing to things so strange that they should be drawn as giant green animals with three heads in Dr. Seuss books.\n\nEven experts don’t know all the models. But in this course, we’ll learn how to formalize and study some of the most beautiful and important models and classes.\nIn particular, we’ll intensely study the regular languages (and their machine model, finite automata—both deterministic and nondeterministic), the context-free languages (and their machine model, pushdown automata), and the recursive and recursively enumerable languages (and their machine models, respectively, total Turing machines and Turing machines). We’ll even learn a bit about P and NP—deterministic and nondeterministic polynomial time. (If you are the first to prove that the classes P and NP differ, or that they collapse, you’ll win a million dollars. Let’s see your English course cough up that kind of incentive!)\nWelcome to the Course, cont’d\n\nProving that a problem is not contained in a class is can be hugely challenging. You typically have to show that every single one of the infinite number of computers/programs/automata modeling the class doesn’t solve the problem. Since infinity is sort of big, this could take your lifetime and more, unless you have the right tools, knowledge, and skills.\n\nSo where are you going to get those tools, knowledge, and skill?\nSurprise—you’re there! CSC280! Here, we’ll learn about tools to let us prove that problems are not in various classes, and tools and approaches that let us prove that problems are in various classes, and we’ll get hands-on practice using them. Some of the tools look like tools (e.g., the so-called pumping lemmas), but many are simply about understanding the machine models for a class, so we can show something is in the class by building the machine (i.e., “program”) that by its existence puts the problem into the class.\nWelcome to the Course, cont’d\n\nSo buckle up, get ready for a demanding course, but with luck also one where you are challenged, have some fun, and get a real feel for how to prove that problems are, or are not, in some of the most important classes. (And if you really like doing this, keep in mind that CSC286/CSC486 is in effect a continuation of course, and among other things it will intensely study such resource-bounded classes as P, NP, and the polynomial hierarchy—triple yummy!)\n\nOr, to come back to where we started:\n\nWelcome to CSC 280!\n\nCheers,\nLane\nIt is always important to give credit where credit is due. Mitsunori Ogihara was a professor here for a long time, and even chaired our department for eight years and coauthored a complexity book with me, before the sunshine and alligators lured him to Florida’s University of Miami. His slides are by far the best I know of for this course, and even after leaving he very kindly agreed to let us at UR use them. (Of course, if something is an obvious insertion from me, such as all the slides so far, it would be wrong to blame Mitsu. Also, over the years that I’ve used them, I’ve edited/modified many of the slides, and so even problems in things that are not obvious insertions-by-me could well be due to me.)—Cheers, Lane\nChapter 0: Fundamental Concepts\n\nFundamental Concepts\nWhat Is Computation?\n\nComputation is a systematic way of obtaining an answer to a problem\n\nThe systematic nature of computation allows the use of computing devices for actual computation\n\nThe abstraction of devices of the “same kind” is a model\n\n- “Is this model ‘different’ from that model?”\n- “Can we solve this problem in that model?”\nProblem Classes\n\n“Computation model” + “Concept of Solving Problems (Typically Already Built into the Model’s Definitions Through the Notion of Acceptance of Inputs)” = “Class of Problems (Namely, Those Accepted by Some Machine of that Model)”\n\n- “Is this model different from that model?” can in a certain sense of “different” be addressed via “Is class $A$ equal to class $B$?”\n\n- “Can we solve this problem in that model?” can be understood by getting a handle on “Exactly what is class $A$?... Is this problem in $A$?”\nClass Overview: Classes of Computation\n\nThe Universe of Languages\n\nThe Recursively Enumerable Languages\n\nThe Recursive Languages\n\nThe Context-free Languages\n\nThe Regular Languages\n(and Now on We Go to…) Fundamental Concepts\nSets\n\n- \\( a \\in S \\): \\( a \\) is an element of \\( S \\); \\( a \\) is a member of \\( S \\).\n \n **Example** \\( 1 \\in \\{1, 2, 3\\} \\).\n\n- \\( S \\subseteq T \\): \\( S \\) is a subset of \\( T \\); \\( S \\) is contained in \\( T \\). This means that every member of \\( S \\) is a member of \\( T \\).\n \n **Example** \\( \\{1, 2\\} \\subseteq \\{1, 2, 3\\}, \\ {1, 2} \\subseteq \\{1, 2\\}, \\text{ and } \\{1, 4\\} \\not\\subseteq \\{1, 2, 3\\} \\).\n\n- \\( S \\subset T \\): \\( S \\) is a proper subset of \\( T \\); \\( S \\) is properly contained in \\( T \\). This means that \\( S \\neq T \\) and \\( S \\subseteq T \\).\n \n **Example** \\( \\{1, 2\\} \\subset \\{1, 2, 3\\} \\) and \\( \\{1, 2\\} \\not\\subset \\{1, 2\\} \\).\n\n- \\( \\emptyset \\) is the empty set, the set without elements.\n\n- \\( 2^S \\) is a power set of \\( S \\); i.e., the set of all subsets of \\( S \\).\nSet Operations\n\n- \\( S \\cap T \\): the **intersection** of \\( S \\) and \\( T \\); the set of all common members between \\( S \\) and \\( T \\).\n\n **Example** \\( \\{1, 2, 3\\} \\cap \\{1, 2, 4\\} = \\{1, 2\\} \\).\n\n- \\( S \\cup T \\): the **union** of \\( S \\) and \\( T \\); the set of all members of \\( S \\) or \\( T \\).\n\n **Example** \\( \\{1, 2, 3\\} \\cup \\{1, 2, 4\\} = \\{1, 2, 3, 4\\} \\).\n\n- \\( S \\setminus T \\): the **set difference** of \\( S \\) and \\( T \\); i.e., the set consisting of all members of \\( S \\) that are nonmembers of \\( T \\).\n\n **Example** \\( \\{1, 2, 3\\} \\setminus \\{1, 2, 4\\} = \\{3\\} \\).\n\n- If \\( T \\subseteq S \\) (or even if not), we write \\( S - T \\) to mean \\( S \\setminus T \\).\n\n **Example** \\( \\{1, 2, 3\\} - \\{1, 2\\} = \\{3\\} \\).\n\n- \\( S \\triangle T \\): the **disjoint union** of \\( S \\) and \\( T \\). \\( S \\triangle T = (S \\setminus T) \\cup (T \\setminus S) \\).\n\n **Example** \\( \\{1, 2, 3\\} \\triangle \\{1, 2, 4\\} = \\{3, 4\\} \\).\nSet Operations (cont’d)\n\n- \\(S \\times T\\): the **Cartesian product** of \\(S\\) and \\(T\\); i.e., \\(\\{(a, b) \\mid a \\in S\\) and \\(b \\in T\\}\\).\n\n **Example** \\(\\{a, b, c\\} \\times \\{1, 2\\} = \\{(a, 1), (a, 2), (b, 1), (b, 2), (c, 1), (c, 2)\\}\\).\n\n- \\(\\|S\\|\\): the **cardinality** of the set \\(S\\); i.e., the number of elements in \\(S\\).\n\n **Example** \\(\\|\\{a, b, c\\}\\| = 3\\).\n\n- Quite often \\(|·|\\) is used for the cardinality. (But it is wiser to reserve it for “length of” strings and so on.)\nAlphabet, Strings, Languages, etc.\n\n- An **alphabet** is any finite set, whose members are called **symbols**.\n\n- A **string (or word) over an alphabet** is a sequence of symbols from the alphabet written one after another.\n \n **Example** \\(aba\\) is a word over an alphabet \\(\\{a, b\\}\\)\n\n- The **length** of a word \\(w\\), denoted by \\(|w|\\), is the number of symbols in it.\n \n **Example** If \\(w = aba\\), then \\(|w| = 3\\).\n\n- The **empty string** or **null string**, denoted by \\(\\epsilon\\), is the string with no symbols in it.\nA string \\( z \\) is a substring of \\( w \\) if \\( z \\) appears consecutively within \\( w \\).\n\n**Example** Let \\( z = 001111010 \\). Then 1111 is a substring of \\( z \\) while 11111 is not.\n\n- The **concatenation** of strings \\( x \\) and \\( y \\) is the string constructed by appending \\( y \\) after \\( x \\).\n **Example** The concatenation of \\( a = 000 \\) and \\( b = 111 \\) is 000111.\n\n- A **language** is a collection of strings.\n- A **class** is a collection of languages.\nAlphabet, Strings, Languages, etc. (cont’d)\n\n• For an alphabet $\\Sigma$, $\\Sigma^*$ is the set of all strings over $\\Sigma$.\n• The complement of a language is the collection of all nonmembers; for a language $L$ over an alphabet $\\Sigma$, its complement is $\\Sigma^* - L$ and is denoted by $L^c$ or $\\overline{L}$.\n\nExample If $\\Sigma = \\{a, b\\}$ and $L$ is the set of all strings over $\\Sigma$ having an even number of $a$’s, then $\\overline{L}$ is the set of all strings over $\\Sigma$ having an odd number of $a$’s.\nAlphabet, Strings, Languages, etc. (cont’d)\n\n• If $\\Sigma$ is a single-letter alphabet with $a$ as its unique symbol, we often write $a^*$ for $\\Sigma^*$.\n\n• For a language $L$, $L^*$ is the set of all strings constructed by concatenating any strings from $L$ in any order. That is, $L^* = \\{\\epsilon\\} \\cup \\{x_1 \\cdots x_m \\mid m \\geq 1, x_1, \\ldots, x_m \\in L\\}$.\n\nExample $\\{a, ab\\}^*$ is the set of all strings $w$ over $a$ and $b$ such that either $w$ is empty or ($w$ begins with an $a$ and has no $bb$ as a substring).\nA **Boolean variable** takes on one of 0 (FALSE) and 1 (TRUE). The **negation** of $x$, denoted by $\\overline{x}$ or $\\neg x$, is $1 - x$.\n\nWe will be using six **binary Boolean operators**:\n\n<table>\n<thead>\n<tr>\n<th>$(x, y)$</th>\n<th>(0, 0)</th>\n<th>(0, 1)</th>\n<th>(1, 0)</th>\n<th>(1, 1)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$\\land$</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>$\\lor$</td>\n<td>0</td>\n<td>1</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>$\\rightarrow$</td>\n<td>1</td>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>$\\leftarrow$</td>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>$\\leftrightarrow$</td>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>$\\oplus$</td>\n<td>0</td>\n<td>1</td>\n<td>1</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\nBoolean Logic (cont’d)\n\nA **predicate** is a **function** whose **range** is \\{ TRUE, FALSE \\}. A **relation** is a predicate whose number of arguments is fixed to a constant.\n\n**Properties of binary relation** $R$ **over domain** $D$.\n\n- **Reflexive**: For all $x \\in D$, $xRx$.\n- **Symmetric**: For all $x, y \\in D$, $xRy \\leftrightarrow yRx$.\n- **Transitive**: For all $x, y, z \\in D$, $(xRy \\land yRz) \\rightarrow xRz$.\n\nAn **equivalence relation** is a binary relation that is reflexive, symmetric, and transitive.\nProof by Induction\n\nA method for proving a statement $P$. Divide the statement $P$ into cases $P(n), n = a, a + 1, a + 2, \\ldots$ For the base case, prove $P(a)$. For the induction step, assume that $P(n)$ is true for all values of $n \\leq k$ and show that $P(k + 1)$ holds.\nGraphs\n\nA **graph** consists of **nodes (vertices)** and **edges**. A **path** is a sequence of edges (or a sequence of nodes) that connects from a node to another. A **tree** is a **connected, undirected graph** without **cycles**.\nChapter 1, Part 1\n\nRegular Languages\nFinite Automata\n\nA finite automaton is a system for processing any finite sequence of symbols, where the symbols are chosen from a finite set of symbols.\n\nThe goal is to determine whether the sequence has a certain property by simply reading the symbols of the sequence from the beginning to the end.\nAn Illustrating Example of Finite Automata\n\nA coin exchanger takes nickels or dimes and delivers quarters. It takes coins one at a time. When the deposited amount reaches or goes beyond 25 cents it delivers a quarter. There is no “change” button and any change is carried over as a deposit.\n\nFor example, if the deposit is currently 20 cents, upon receiving a dime, the machine delivers a quarter and the deposit becomes 5 cents.\nQuestion\n\nIf you have a bag full of nickels and dimes and use this machine to change for quarters, do you break even?\n### Relationship Between Deposit and Coin Inserted\n\nThe deposit amount in cents is one of 0, 5, 10, 15, and 20. Upon receiving a coin, the deposit changes as follows:\n\n<table>\n<thead>\n<tr>\n<th>Current Deposit</th>\n<th>Coin Inserted</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Nickel</td>\n</tr>\n<tr>\n<td>0</td>\n<td>5</td>\n</tr>\n<tr>\n<td>5</td>\n<td>10</td>\n</tr>\n<tr>\n<td>10</td>\n<td>15</td>\n</tr>\n<tr>\n<td>15</td>\n<td>20</td>\n</tr>\n<tr>\n<td>20</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\nLet $N$ stand for “nickel” and $D$ for “dime”. For $a \\in \\{0, 5, 10, 15, 20\\}$, let $q_a$ represent the status in which the deposit is $a$ cents.\nFinite Automata\n\nA finite automaton is a 5-tuple \\((Q, \\Sigma, \\delta, q_0, F)\\), where\n\n1. \\(Q\\) is a finite set called the states,\n2. \\(\\Sigma\\) is a finite set called the alphabet,\n3. \\(\\delta : Q \\times \\Sigma \\rightarrow Q\\) is the transition function,\n4. \\(q_0 \\in Q\\) is the initial state, and\n5. \\(F \\subseteq Q\\) is the set of accepting states or the set of final states.\n\nLet \\(M = (Q, \\Sigma, \\delta, q_0, F)\\) be an FA. A string \\(w = w_1 \\cdots w_n\\) is accepted by \\(M\\) if there exists a sequence \\((p_0, \\ldots, p_n)\\) of states in \\(Q\\) such that \\(p_0 = q_0, p_n \\in F\\), and for every \\(i, 1 \\leq i \\leq n\\), \\(\\delta(p_{i-1}, w_i) = p_i\\).\nThe Language Decided by a Finite Automaton\n\nThe language decided by $M$, denoted $L(M)$, is the language over $\\Sigma$ such that\n\n(*) for every string $w$ over $\\Sigma$, $w \\in L(M) \\iff M$ accepts $w$. \nAn FA for the Coin Changer\n\nLet $\\Sigma = \\{N, D\\}$.\n\nLet $Q = \\{q_0, q_5, q_{10}, q_{15}, q_{20}\\}$.\n\nThe transition function is:\n\n<table>\n<thead>\n<tr>\n<th>state</th>\n<th>$N$</th>\n<th>$D$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$q_0$</td>\n<td>$q_5$</td>\n<td>$q_{10}$</td>\n</tr>\n<tr>\n<td>$q_5$</td>\n<td>$q_{10}$</td>\n<td>$q_{15}$</td>\n</tr>\n<tr>\n<td>$q_{10}$</td>\n<td>$q_{15}$</td>\n<td>$q_{20}$</td>\n</tr>\n<tr>\n<td>$q_{15}$</td>\n<td>$q_{20}$</td>\n<td>$q_0$</td>\n</tr>\n<tr>\n<td>$q_{20}$</td>\n<td>$q_0$</td>\n<td>$q_5$</td>\n</tr>\n</tbody>\n</table>\n\n$F = \\{q_0\\}$.\n\nOur FA accepts $NNND$ and $DDDDD$ but not $NNN$. \nThe Coin Changer As a Finite Automaton\nRegular Languages\n\nThe regular languages is the class of languages accepted by finite automata.\nExample 1\n\nAn FA that accepts the strings over 0 and 1 with either (an even number of 0s and an even number of 1s) or (an odd number of 0s and an odd number of 1s)\n\nDrawing rules:\n- The initial state has an incoming edge from outside.\n- Accept states are represented with double circles.\n- Every node has one outgoing edge for each symbol.\nExample 2\n\nAn FA that accepts the set of all words over \\( \\{a, b\\} \\) having odd length\nExample 3\n\nAn FA that accepts the set of all words over \\(\\{a, b\\}\\) containing \\(ababb\\) as a substring.\nExample 4\n\nAn FA that accepts the set of all words over \\( \\{a, b\\} \\) containing at least three \\( a \\)'s and at least two \\( b \\)'s\nExample 4\n\nAn FA that accepts the set of all words over \\( \\{a, b\\} \\) containing at least three \\( a \\)'s and at least two \\( b \\)'s\n\n“At least two \\( b \\)'s” and “at least three \\( a \\)'s”\nExample 4\n\nAn FA that accepts the set of all words over \\( \\{a, b\\} \\) containing at least three \\( a \\)'s and at least two \\( b \\)'s\nExample 5\n\nAn FA that accepts the set of all words over \\( \\{a, b\\} \\) containing either as least three \\( a \\)'s or at least two \\( b \\)'s\nExample 5\n\nAn FA that accepts the set of all words over \\( \\{a, b\\} \\) containing either as least three \\( a \\)'s or at least two \\( b \\)'s\nNondeterministic Finite Automata\nFundamental set operations\n\nLet \\( A \\) and \\( B \\) be two languages. In addition to union and intersection, we consider the following set operations:\n\n- **Concatenation** of \\( A \\) and \\( B \\), \\( A \\circ B \\), is \\( \\{xy \\mid x \\in A \\text{ and } y \\in B\\} \\).\n\n- **Star** of \\( A \\), \\( A^* \\), is \\( \\{x_1x_2\\cdots x_k \\mid k \\geq 0 \\text{ and } x_1, \\ldots, x_k \\in A\\} \\).\n \n (Note: For each set \\( A \\), \\( \\epsilon \\in A^* \\). In particular, and many find this surprising and counterintuitive, \\( \\emptyset^* = \\{\\epsilon\\} \\). One way to view this is that the concatenation of zero strings from any set—even if the set is \\( \\emptyset \\)—is taken to be \\( \\{\\epsilon\\} \\).)\n\n- **Complement** of \\( A \\), \\( \\overline{A} \\), is \\( \\Sigma^* - A \\), i.e., \\( \\{w \\mid w \\in \\Sigma^* \\land w \\notin A\\} \\).\n**Fundamental set operations**\n\nLet $A$ and $B$ be two languages. In addition to union and intersection, we consider the following set operations:\n\n- **Concatenation** of $A$ and $B$, $A \\circ B$, is $\\{xy \\mid x \\in A \\text{ and } y \\in B\\}$.\n\n- **Star** of $A$, $A^*$, is $\\{x_1x_2\\cdots x_k \\mid k \\geq 0 \\text{ and } x_1, \\ldots, x_k \\in A\\}$. (Note: For each set $A$, $\\epsilon \\in A^*$. In particular, and many find this surprising and counterintuitive, $\\emptyset^* = \\{\\epsilon\\}$. One way to view this is that the concatenation of zero strings from any set—even if the set is $\\emptyset$—is taken to be $\\{\\epsilon\\}$.)\n\n- **Complement** of $A$, $\\overline{A}$, is $\\Sigma^* - A$, i.e., $\\{w \\mid w \\in \\Sigma^* \\land w \\not\\in A\\}$.\n\nWe will prove that the regular languages are closed under union, intersection, concatenation, star, and complement; i.e., that if $A$ and $B$ are regular, then $A \\cup B$, $A \\cap B$, $A \\circ B$, $A^*$, and $\\overline{A}$ are each regular.\nNondeterministic Finite Automata\n\nThe **nondeterministic finite automaton** is a variant of finite automaton with two characteristics:\n\n- **$\\epsilon$-transition**: state transition can be made *without reading a symbol*;\n- **nondeterminism**: zero or more than one possible value may exist for state transition.\nAn Example Nondeterministic Finite Automaton\n\nAn NFA that accepts all strings over \\( \\{0, 1\\} \\) that contain a 1 either at the third position from the end or at the second position from the end.\n\n- There are two edges labeled 1 coming out of \\( q_1 \\).\n- There are no edges coming out of \\( q_4 \\).\n- The edge from \\( q_2 \\) is labeled with \\( \\varepsilon \\), in addition to 0 and 1.\nWhat the Diagram Says\n\n- If the node you are in has an outgoing edge labeled $\\epsilon$, you may choose to follow it (even if there are still symbols waiting to be read).\n\n- When you choose to read the next symbol,\n - IF the node you are in has one or more outgoing edges labeled with the symbol, you nondeterministically choose one of them and cross it ELSE (if there are no outgoing edges with that symbol) our current computation path dies.\n\nThe above is informal; see the formal definitions to come for what is really going on in nondeterministic finite automata.\nA **nondeterministic finite automaton** is a 5-tuple $N = (Q, \\Sigma, \\delta, q_0, F)$, where $\\delta$ is a mapping of $Q \\times \\Sigma_\\epsilon$ to $2^Q$ (alternatively, written $\\mathcal{P}(Q)$), and $\\Sigma_\\epsilon = \\Sigma \\cup \\{\\epsilon\\}$.\n\nFor each $p \\in Q$ and each $a \\in \\Sigma_\\epsilon$, $\\delta(s, a) = R$ means:\n\n“**upon reading an $a$ the automaton $N$ may transition from state $s$ to any state in $R$.”**\n\nFor $\\epsilon$ in particular, $\\delta(s, \\epsilon) = R$ means:\n\n“**without reading a symbol the automaton $N$ may transition from state $s$ to any state in $R$.”**\nAcceptance by Nondeterministic Finite Automata\n\n$N$ accepts a word $w = w_1 \\cdots w_n, w_1, \\ldots, w_n \\in \\Sigma$ if: there exist $(p_0, \\ldots, p_m), p_0, \\ldots, p_m \\in Q$ and $y_1, \\ldots, y_m \\in \\Sigma_\\epsilon$ such that\n\n- $w = y_1 \\cdots y_m$,\n- $p_0 = q_0$,\n- $p_m \\in F$, and\n- for every $i$, $1 \\leq i \\leq m$, $p_i \\in \\delta(p_{i-1}, y_i)$. \nTransition Function for the Previous Example\n\n\\[\n\\begin{array}{c|ccc}\n\\text{state} & 0 & 1 & \\epsilon \\\\\n\\hline\nq_1 & \\{q_1\\} & \\{q_1, q_2\\} & \\emptyset \\\\\nq_2 & \\{q_3\\} & \\{q_3\\} & \\{q_3\\} \\\\\nq_3 & \\{q_4\\} & \\{q_4\\} & \\emptyset \\\\\nq_4 & \\emptyset & \\emptyset & \\emptyset \\\\\n\\end{array}\n\\]\nTransition Function for the Previous Example\n\nThis NFA accepts $y = 11$ with respect to state sequence $(q_1, q_2, q_3, q_4)$ and decomposition $y = 1\\epsilon 1$. \n\n<table>\n<thead>\n<tr>\n<th>state</th>\n<th>symbol</th>\n<th>(0)</th>\n<th>(1)</th>\n<th>(\\epsilon)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$q_1$</td>\n<td></td>\n<td>${q_1}$</td>\n<td>${q_1, q_2}$</td>\n<td>$\\emptyset$</td>\n</tr>\n<tr>\n<td>$q_2$</td>\n<td></td>\n<td>${q_3}$</td>\n<td>${q_3}$</td>\n<td>${q_3}$</td>\n</tr>\n<tr>\n<td>$q_3$</td>\n<td></td>\n<td>${q_4}$</td>\n<td>${q_4}$</td>\n<td>$\\emptyset$</td>\n</tr>\n<tr>\n<td>$q_4$</td>\n<td></td>\n<td>$\\emptyset$</td>\n<td>$\\emptyset$</td>\n<td>$\\emptyset$</td>\n</tr>\n</tbody>\n</table>\nNondeterministic Choices\n\nNondeterministic computation can be thought of as a self-reproducing agent traveling in the state space.\n\n1. At the start of computation the agent is in the initial state.\nNondeterministic Choices\n\nNondeterministic computation can be thought of as a self-reproducing agent traveling in the state space.\n\n1. At the start of computation the agent is in the initial state.\nNondeterministic Choices\n\n2. Both before and after receiving an input symbol, the agent follows each $\\epsilon$-labeled outgoing edge (or edge-chain) by producing its own clones and sending them along each edge (or edge-chain). The original remains in the current location.\n\n(Warning and reminder: Despite the informal text above, the formal definition actually uses multiple $\\epsilon$’s to run through chains of $\\epsilon$’s, one at a time.)\nNondeterministic Choices\n\n2. Both before and after receiving an input symbol, the agent follows each $\\epsilon$-labeled outgoing edge (or edge-chain) by producing its own clones and sending them along each edge (or edge-chain). The original remains in the current location.\nNondeterministic Choices\n\n3. On receiving an input symbol, say \\( a \\),\n \n (a) If there is only one \\( a \\)-labeled outgoing edge, the agent follows the edge.\n \n (b) If there is no \\( a \\)-labeled outgoing edge, the agent evaporates.\nNondeterministic Choices\n\n3. On receiving an input symbol, say $a$,\n (a) If there is only one $a$-labeled outgoing edge, the agent follows the edge.\n (b) If there is no $a$-labeled outgoing edge, the agent evaporates.\n\nI am gone.\n3. On receiving an input symbol, say $a$,\n (c) If there are $k \\geq 2$ $a$-labeled outgoing edges, the agent produces $k - 1$ clones, make them cross $k - 1$ of the edges, and cross the remaining one by himself.\nNondeterministic Choices\n\n3. On receiving an input symbol, say \\( a \\),\n (c) If there are \\( k \\geq 2 \\) \\( a \\)-labeled outgoing edges, the agent produces \\( k - 1 \\) clones, make them cross \\( k - 1 \\) of the edges, and cross the remaining one by himself.\nNondeterministic Choices\n\n4. When two agents collide in a state, they merge themselves into one.\nNondeterministic Choices\n\n4. When two agents collide in a state, they merge themselves into one.\nWhy Use NFA?\n\nFor some languages construction is much easier.\n\nBelow is a DFA that accepts the same language by remembering the last three symbols.\nComparison\n\nDFA\n\nNFA\nExample 1\n\nAn NFA for the language of all strings over \\( \\{a, b, c\\} \\) that end with one of \\( ab, bc, \\) and \\( ca. \\)\nExample 1\n\nAn NFA for the language of all strings over \\{a, b, c\\} that end with one of ab, bc, and ca.\nA DFA Version of the Same Language\nExample 2\n\nAn NFA for the language of all strings over \\( \\{0, 1\\} \\) that end with one of 0110, 010, and 00.\nExample 2\n\nAn NFA for the language of all strings over \\{0, 1\\} that end with one of 0110, 010, and 00.\nExample 3\n\nAn NFA for the language of all strings over \\(\\{a, b, c\\}\\) for which one of (the number of occurrences of \\(a\\)), (the number of occurrences of \\(b\\)), and (the number of occurrences of \\(c\\)) is a multiple of 3.\nExample 3\n\nAn NFA for the language of all strings over \\{a, b, c\\} for which one of (the number of occurrences of a), (the number of occurrences of b), and (the number of occurrences of c) is a multiple of 3.\nExample 4\n\nAn NFA for the language of all strings over \\( \\{a, b\\} \\) that contain \\( ababb \\).\nExample 4\n\nAn NFA for the language of all strings over \\( \\{a, b\\} \\) that contain \\textit{ababb}. \n\n![NFA Diagram]\nThe FA Model Versus NFA Model\n\nThe NFA simplifies computational design, but the use of nondeterministic selections and $\\epsilon$-transitions makes it look very different from FA.\n\nIs that really so?\nThe FA Model Versus NFA Model\n\nThe NFA simplifies computational design, but the use of nondeterministic selections and $\\epsilon$-transitions makes it look very different from FA.\n\nIs that really so?\n\nNo, the FA model is equivalent to the NFA model. That is, every language accepted by an DFA is accepted by an NFA, vice versa.\n\nObviously, we have:\n\nTheorem. Every FA is already an NFA.\n\nWe will show:\n\nTheorem. Every NFA can be converted to an equivalent FA.\nProof\n\nThe principle is that just before the first symbol is received and after each symbol is read, there will be at most one agent in any state.\nProof\n\nThe principle is that just before the first symbol is received and after each symbol is read, there will be at most one agent in any state.\n\nWe will thus consider the \"set of all states an agent can be in.\"\nProof (cont’d)\n\nLet \\( N = (Q, \\Sigma, \\delta, q_0, F) \\) be an NFA.\n\nWe will construct a DFA \\( M = (S, \\Sigma, \\gamma, s_0, G) \\).\n\n- The state set \\( S \\) is \\( \\mathcal{P}(Q) \\).\n- The initial state \\( s_0 \\) is the set consisting of \\( q_0 \\) and all the states reachable from \\( q_0 \\) by following only \\( \\epsilon \\) transitions.\n- The final state set \\( G \\) is \\( \\{ A \\in S \\mid A \\cap F \\neq \\emptyset \\} \\); i.e., the set of all subsets of \\( Q \\) containing an element of \\( F \\).\n**Transition Function**\n\nThe transition function $\\gamma$ is defined as follows:\n\nFor each $A \\in S$ and for each $b \\in \\Sigma$, $\\gamma(A, b) = \\bigcup_{p \\in A} \\delta(p, \\epsilon^* b \\epsilon^*)$, the collection of all states $r$ that can be reached from a state $p$ in $A$ by following\n\n- any number of $\\epsilon$-arrows,\n- a $b$-arrow, and then\n- any number of $\\epsilon$-arrows.\n\nFor all $w$ over $\\Sigma$, $w$ is accepted by $N$ if and only if the new DFA transitions from $s_0$ to a state in $G$ on input $w$. \nExample\n\nAn NFA that recognizes the language consisting of all strings over \\{0, 1\\} that contain a 1 at either the third to last position or the second to last position.\n\n![NFA Diagram]\n\n\\[0, 1\\to q_1 \\xrightarrow{1} q_2 \\xrightarrow{0, 1, \\varepsilon} q_3 \\xrightarrow{0, 1} q_4\\]\nConversion to DFA\n\nThe state set consists of: $\\emptyset$, \\{q_1\\}, \\{q_2\\}, \\{q_3\\}, \\{q_4\\}, \\{q_1, q_2\\}, \\{q_1, q_3\\}, \\{q_1, q_4\\}, \\{q_2, q_3\\}, \\{q_2, q_4\\}, \\{q_3, q_4\\}, \\{q_1, q_2, q_3\\}, \\{q_1, q_2, q_4\\}, \\{q_1, q_3, q_4\\}, \\{q_2, q_3, q_4\\}, \\{q_1, q_2, q_3, q_4\\}.\n\n$F$ consists of: \\{q_4\\}, \\{q_1, q_4\\}, \\{q_2, q_4\\}, \\{q_3, q_4\\}, \\{q_1, q_2, q_4\\}, \\{q_1, q_3, q_4\\}, \\{q_2, q_3, q_4\\}, \\{q_1, q_2, q_3, q_4\\}.\n\nThe initial state is \\{q_1\\}.\nThe other states are unreachable from the initial state.\nA Greedy Conversion Algorithm\n\nStep 1 For each state \\( p \\in Q \\) and for each symbol \\( a \\in \\Sigma \\), compute the set \\( R(p, a) \\) of all states that can be reached from state \\( p \\) by:\n\n(a) any number of \\( \\epsilon \\) transitions,\n(b) one transition labeled by \\( a \\), and then\n(c) any number of \\( \\epsilon \\) transitions.\n\nStep 2 Initialize the state collection \\( S \\) as \\( \\{p_0\\} \\), where \\( p_0 \\) is the set of all states that can be reached from \\( q_0 \\) by following any number of \\( \\epsilon \\) transitions.\n\nStep 3 While \\( S \\) contains a state with no outgoing edges, select an arbitrary member, say \\( r \\), of \\( S \\), and do the following:\n\n• For each symbol \\( a \\), compute the state \\( r_a \\) as \\( \\bigcup_{q \\in r} R(q, a) \\), add \\( r_a \\) to \\( S \\) if \\( r_a \\) is not already in it, and then draw an arc from \\( r \\) to \\( r_a \\).\nAlgorithm Execution Example\n\nUse the previous NFA.\n### Step 1\n\n<table>\n<thead>\n<tr>\n<th>state</th>\n<th>0</th>\n<th>1</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$q_1$</td>\n<td>$q_1$</td>\n<td>$q_1$, $q_2$, $q_3$</td>\n</tr>\n<tr>\n<td>$q_2$</td>\n<td>$q_3$, $q_4$</td>\n<td>$q_3$, $q_4$</td>\n</tr>\n<tr>\n<td>$q_3$</td>\n<td>$q_4$</td>\n<td>$q_4$</td>\n</tr>\n<tr>\n<td>$q_4$</td>\n<td>$\\emptyset$</td>\n<td>$\\emptyset$</td>\n</tr>\n</tbody>\n</table>\n\n### Step 2\n\nInitially $S = \\{ \\{q_1\\} \\}$. \nStep 3\n\n\\{q_1\\} on 0 changes the state to \\{q_1\\}\n\\{q_1\\} on 1 changes the state to \\{q_1, q_2, q_3\\}. New!\n\\{q_1, q_2, q_3\\} on 0 changes the state to \\{q_1, q_3, q_4\\}. New!\n\\{q_1, q_2, q_3\\} on 1 changes the state to \\{q_1, q_2, q_3, q_4\\}. New!\n\\{q_1, q_3, q_4\\} on 0 changes the state to \\{q_1, q_4\\}. New!\n\\{q_1, q_2, q_3\\} on 1 changes the state to \\{q_1, q_2, q_3, q_4\\}.\n\\{q_1, q_2, q_3, q_4\\} on 0 changes the state to \\{q_1, q_3, q_4\\}.\n\\{q_1, q_2, q_3, q_4\\} on 1 changes the state to \\{q_1, q_2, q_3, q_4\\}.\n\\{q_1, q_4\\} on 0 changes the state to \\{q_13\\}.\n\\{q_1, q_4\\} on 1 changes the state to \\{q_1, q_2, q_3\\}. \nRegular Expression\n\nThe regular expressions are equivalent to the finite automata.\nAn expression $R$ is a regular expression if $R$ is\n\n1. $a$ for some $a$ in some alphabet $\\Sigma$,\n2. $\\epsilon$,\n3. $\\emptyset$,\n4. $(R_1 \\cup R_2)$ for some regular expressions $R_1$ and $R_2$,\n5. $(R_1 \\circ R_2)$ for some regular expressions $R_1$ and $R_2$, or\n6. $(R_1)^*$ for some regular expression $R_1$.\n\nWhen the meaning is clear from the context, $(\\cdot)$ and $\\circ$ can be removed from the expression.\nThe Language Represented by a Regular Expression\n\nFor a regular expression $R$, $L(R)$ denotes the language $R$ expresses.\n\n1. For each $a \\in \\Sigma$, $L(a) = \\{a\\}$.\n2. $L(\\epsilon) = \\{\\epsilon\\}$\n3. $L(\\emptyset) = \\emptyset$.\n4. $L(R_1 \\cup R_2) = L(R_1) \\cup L(R_2)$.\n5. $L(R_1 \\circ R_2) = L(R_1) \\circ L(R_2) = \\{uv \\mid u \\in R_1 \\text{ and } v \\in R_2\\}$.\n6. $L(R_1^*) = \\{\\epsilon\\} \\cup \\{u_1 \\cdots u_k \\mid u_1, \\ldots, u_k \\in R_1\\}$. \nRegular Expression Examples\n\n- \\( L(a) = \\{a\\} \\) (for a single-element regular expression, you may simply write the element)\n\n- \\( L(abab \\cup bc) = \\{abab, bc\\} \\)\n\n- \\( L((abab \\cup abc)^*) = \\{\\epsilon\\} \\cup \\{w_1 \\cdots w_k \\mid k \\geq 1 \\text{ and } w_1, \\cdots, w_k \\in \\{abab, abc\\}\\} \\).\n\n- \\( L((abab \\cup abc)^* \\cup c^* \\cup abc(abca)^*) = \\{\\epsilon\\} \\cup \\{w_1 \\cdots w_k \\mid k \\geq 1 \\text{ and } w_1, \\cdots, w_k \\in \\{abab, abc\\}\\} \\)\n\\( \\cup \\{w \\mid w \\text{ is a repetition of } c's\\} \\)\n\\( \\cup \\{abc, abcabca, abcabcaabca, \\cdots\\} \\).\nFinite Automata ≡ Regular Expression\n\nTheorem. The regular languages are precisely those that are expressed by regular expressions.\n\nWe show:\n\n- Each language expressed by a regular expression can be recognized by a finite automata.\n- Regular languages can be expressed as regular expressions.\nRegular expressions’ languages can be recognized by FAs\n\nBy induction\n\nBase Cases\n\n1. $a$ for some $a$ in some alphabet $\\Sigma$,\n2. $\\epsilon$,\n3. $\\emptyset$,\n\nInduction\n\n4. $(R_1 \\cup R_2)$ for some regular expressions $R_1$ and $R_2$,\n5. $(R_1 \\circ R_2)$ for some regular expressions $R_1$ and $R_2$, or\n6. $(R_1)^*$ for some regular expression $R_1$. \nProof\n\nThe Base Case\n\nThe following are all regular:\n\n- any set consisting only of a single letter,\n- the set consisting only of the empty string,\n- the empty set.\nThe Induction Step\n\nWe have only to show the following:\n\nIf $L_1$ is accepted by an FA $N_1 = (Q_1, \\Sigma, \\delta_1, p_1, F_1)$ and $L_2$ is accepted by an FA $N_2 = (Q_2, \\Sigma, \\delta_2, p_2, F_2)$ (here $Q_1$ and $Q_2$ are disjoint; thus, clearly $F_1$ and $F_2$ are also disjoint), then there are NFA for $L_1 \\cup L_2$, $L_1 \\circ L_2$, and $L_1^*$. \n**Union**\n\nThe new NFA has an \\( \\varepsilon \\)-arrow from its initial state \\( p_0 \\) to \\( p_1 \\) and to \\( p_2 \\).\nIts final state set is \\( F_1 \\cup F_2 \\).\nConcatenation\n\nThe state set of the new NFA is the union of the state sets of $N_1$ and $N_2$.\nThe initial state is $p_1$.\nThere is an $\\varepsilon$-arrow from each $s \\in F_1$ to $p_2$.\nThe final state set $F_0$ is $F_2$. \n\n\nIntroduce a new initial state $p_0$.\nAdd an $\\epsilon$-arrow from $p_0$ to $p_1$.\nAdd an $\\epsilon$-arrow from each $s \\in F_1$ to $p_0$.\nThe final state set is $\\{p_0\\}$.\nRegular languages can be expressed as regular expressions.\n\nA **general nondeterministic finite automaton (GNFA)** is a kind of NFA such that:\n\n- There is a unique start state and is a unique accept state.\n- Every pair of nodes is connected by an arrow in each direction, each labeled with a regular expression. Exceptions are:\n - The start state has no incoming edges.\n - The accept state has no outgoing edges.\n\nThe language accepted by the GNFA is the union of all $L(R)$ such that $R$ is the regular expression constructed by concatenating all the regular expressions appearing on the path from the start state to the accept state in the order they appear.\nAn Example of GNFA\n\nHere the dashed arrows represent arrows with $\\emptyset$ as the label.\n\n(Quite a few dotted arrows aren’t drawn here (and on the coming slides) but really should be. For example, there should be dotted arrows from the far left state to each of the 3 rightmost states, and 4 more backward dotted arrows along the upper and lower segments. GNFAs are painful to draw in full correctly!)\nAnd our woes are not over yet. Is there some problem in this drawing? I claim that two of the edges have illegal labels. Can you spot those two? And what should those labels be replaced with (remember, labels should be regular expressions, and “a, b” is not a regular expression)? (The rest of this example still uses “a, b,” but each such use is a formal error! So please do as we say, not as we (incorrectly) do (here)!)\nProof Plan\n\n1. Show that any NFA can be converted to an equivalent GNFA.\n2. Show that any GNFA can be converted to an equivalent regular expression.\nFrom an NFA to a GNFA\n\nGiven an NFA $N$, construct a GNFA $G$ as follows:\n\n1. Add a special start state $q_{\\text{start}}$ and connect it to the initial state of $N$ with $\\epsilon$ as the label. Connect $q_{\\text{start}}$ to each remaining state with $\\emptyset$ as the label.\nFrom an NFA to a GNFA\n\nGiven an NFA $N$, construct a GNFA $G$ as follows:\n\n1. Add a special start state $q_{\\text{start}}$ and connect it to the initial state of $N$ with $\\epsilon$ as the label. Connect $q_{\\text{start}}$ to each remaining state with $\\emptyset$ as the label.\n\n2. Add a special accept state $q_{\\text{accept}}$ and connect to it from each final state of $N$ with $\\epsilon$ as the label. Connect from each of the remaining state of $N$ to $q_{\\text{accept}}$ with $\\emptyset$ as the label.\nFrom an NFA to a GNFA\n\nGiven an NFA $N$, construct a GNFA $G$ as follows:\n\n1. Add a special start state $q_{start}$ and connect it to the initial state of $N$ with $\\epsilon$ as the label. Connect $q_{start}$ to each remaining state with $\\emptyset$ as the label.\n\n2. Add a special accept state $q_{accept}$ and connect to it from each final state of $N$ with $\\epsilon$ as the label. Connect from each of the remaining state of $N$ to $q_{accept}$ with $\\emptyset$ as the label.\n\n3. Add an arrow with $\\emptyset$ as the label wherever necessary.\n(Aside: What is missing here? Hint: We need to know the start state of this NFA?)\nBefore and After\n\n(Can you see why $q_{start}$ does not need to have a “this is the start state” arrow?)\n\n(Dashed-arrow self-loops labeled with $\\emptyset$ are, except for gray states, there (but not drawn), here and in the rest of Ch. 1, Pt. 3; and various other dotted-arrow omissions exist as mentioned earlier.)\nWhat Have We Done?\n\nWe have constructed our initial GNFA $G$ so that:\n\n(I) For each word $w$ in $L(N)$, there is a path $[u_0, \\ldots, u_m]$ in $G$ from $q_{\\text{start}}$ to $q_{\\text{accept}}$ such that\n\n(a) $w$ is decomposed as $w_1w_2\\cdots w_m$;\n\n(b) for all $i$, $1 \\leq i \\leq m$, $w_i$ is a member of the language represented by the regular expression of the arrow $(u_{i-1}, u_i)$. \nWhat Have We Done?\n\nWe have constructed our initial GNFA $G$ so that:\n\n(I) For each word $w$ in $L(N)$, there is a path $[u_0, \\ldots, u_m]$ in $G$ from $q_{start}$ to $q_{accept}$ such that\n (a) $w$ is decomposed as $w_1w_2\\cdots w_m$;\n (b) for all $i$, $1 \\leq i \\leq m$, $w_i$ is a member of the language represented by the regular expression of the arrow $(u_{i-1}, u_i)$.\n\n(II) For each word $w$ that can be decomposed as in the above, $w$ is a member of $L(N)$. \nConvert a GNFA to a Regular Expression\n\nWe will remove intermediate nodes one after the other while preserving the two properties.\n\nRepeat the following until there is no state left other than the start state and the accept state.\n\n• Select an arbitrary intermediate state $s$.\n• Produce from the current GNFA an equivalent GNFA by:\n • For each arrow $(p, q)$ such that $p, q \\neq s$, replace its label with the label corresponding to the paths $[p, q], [p, s, q], [p, s, s, q], [p, s, s, s, q], \\ldots$ \\hspace{1cm} (The cases where $p = q$ are quite important, and should not be forgotten; that is a very easy, common mistake to make; I make it often!)\n • Remove $s$ and all edges attached to it.\nThe Procedure\n\nLet $G$ be the current GNFA. Replace $G$ with a new GNFA $G'$ constructed from $G$ as follows:\n\n- $G'$ has all states of $G$ except for $s$.\n- For each pair $(p, q)$ of states, $p, q \\neq s$, label the arrow $(p, q)$ of $G'$ by $u \\cup xy^*z$, where\n - $u$ is the label of $(p, q)$ in $G$,\n - $x$ is the label of $(p, s)$ in $G$,\n - $y$ is the label of $(s, s)$ in $G$,\n - $z$ is the label of $(s, q)$ in $G$,\n - Side note: since $A\\emptyset = \\emptyset A = \\emptyset$ and $\\emptyset^* = \\{\\epsilon\\}$, exactly the right things happen even for things with $\\emptyset$ labels; also, we use the just-mentioned equalities to simplify labels on the fly.\n\nThe two properties (I) and (II) are preserved.\nState Elimination\n\nbecomes\n\nbecomes\nState Elimination\n\nbecomes\n\nbecomes\nState Elimination\n\nbecomes\nState Elimination\n\nbecomes\nState Elimination\n\nbecomes\n\nCSC280, Chapter 1, Part 3 © 2012 Mitsunori Ogihara. Edits/updates by Lane A. Hemaspaandra, 20{13,14,17}. 29\nState Elimination\n\nbecomes\n\n\\[ aa\\{a,b\\}^* \\cup bb\\{a,b\\}^* \\]\nState Elimination\n\nbecomes\n\n\\[ aa(a,b)^* \\cup bb(a,b)^* \\]\nState Elimination\n\nbecomes\n\nThe conversion has been completed.\nThe Regular Expression Is Not Necessarily Unique\n\nNote that the regular expression is dependent on the order in which the states are eliminated and thus may not be unique.\nClosure Properties of Regular Languages\n\n**Theorem.** The regular languages are closed under complement, union, intersection, concatenation, and star.\n\n**Proof** The closure properties under union, concatenation, and star follow from the fact that the regular languages are those that are expressible with regular expressions.\n\nFor complement, note that the complement of a language accepted by a DFA \\((Q, \\Sigma, \\delta, p_0, F)\\) is accepted by a DFA \\((Q, \\Sigma, \\delta, p_0, Q \\setminus F)\\).\n\nFor intersection, use DeMorgan’s Law.\nNonregular Languages\n\n*How can we show that a language is not regular?*\nThe Pumping Lemma\n\n**Theorem.** (Pumping Lemma) Let $L$ be an arbitrary regular language. Then there exists a positive integer $p$ with the following property:\n\nGiven an arbitrary member $w$ of $L$ having length at least $p$ (i.e., $|w| \\geq p$), $w$ can be divided into three parts, $w = xyz$, such that\n\n- $|y| \\geq 1$ (the middle part is nonempty),\n- $|xy| \\leq p$ (the first two parts together have length at most $p$), and\n- for each $i \\geq 0$, $xy^iz \\in L$ (removing or repeating the middle part produces members of $L$).\nProof of the Pumping Lemma\n\nLet \\( L \\) be an arbitrary regular language. Then there is an FA, say \\( M \\), that decides \\( L \\). Let \\( p \\) be the number of states of \\( M \\).\n\nLet \\( w \\) be an arbitrary member of \\( L \\) having length \\( n \\) with \\( n \\geq p \\). (If \\( L \\) has no strings of length greater or equal to \\( n \\), then the theorem is clearly satisfied and we are done.)\n\nLet \\( q_0, q_1, \\ldots, q_n \\) be the states that \\( M \\) on input \\( w \\). That is, for each \\( i \\), after reading the first \\( i \\) symbols of \\( w \\), \\( M \\) is at \\( q_i \\).\n\nClearly, \\( q_0 \\) is the initial state of \\( M \\). Also, because \\( w \\in L \\), \\( q_n \\) is a final state of \\( M \\).\nThe Pigeonhole Principle\n\nWe are placing a number of pigeons in a number of holes.\n\nIf there are more pigeons than there are holes, at least one hole must host more than one pigeon.\nThe Pigeonhole Principle\n\nWe are placing a number of pigeons in a number of holes.\n\nIf there are more pigeons than there are holes, at least one hole should host more than one pigeon.\n\nConsider $q_0, \\ldots, q_p$ (the first $p + 1$ states that $M$ goes through on input $w$). By the pigeonhole principle, there exist $c$ and $d$, $0 \\leq c < d \\leq p$, such that $q_c = q_d$.\n\nPick an arbitrary such pair $(c, d)$. \nProof of the Pumping Lemma (cont’d)\n\nLet $x = w_1 \\cdots w_c$, $y = w_{c+1} \\cdots w_d$, and $z = w_{d+1} \\cdots w_n$. Then\n\n- $|y| \\geq 1$,\n- $|xy| \\leq p$,\n- $M$ transitions from $q_0$ to $q_c$ on $x$,\n- $M$ transitions from $q_c$ to $q_c$ on $y$,\n- $M$ transitions from $q_c$ to $q_n$ on $z$.\n\nThus, for every $i \\geq 0$, $M$ transitions from $q_0$ to $q_n$ on $xy^i z$, and so $xy^i z$ is a member of $L$. \n\nApplication of the Pumping Lemma\n\nExample 1: \\( B = \\{0^n1^n \\mid n \\geq 0\\} \\) is not regular.\nApplication of the Pumping Lemma\n\nExample 1: \\( B = \\{0^n1^n \\mid n \\geq 0\\} \\) is not regular.\n\nProof Assume that \\( B \\) is regular. Let \\( p \\) be a constant from the pumping lemma for \\( B \\). Let \\( w = 0^p1^p \\).\nApplication of the Pumping Lemma\n\nExample 1: \\( B = \\{0^n1^n \\mid n \\geq 0\\} \\) is not regular.\n\nProof Assume that \\( B \\) is regular. Let \\( p \\) be a constant from the pumping lemma for \\( B \\). Let \\( w = 0^p1^p \\).\n\nThen \\( w \\) is in \\( B \\) so it can be divided into \\( w = xyz \\) such that\n\n- \\( |y| \\geq 1 \\),\n- \\( |xy| \\leq p \\), and\n- for each \\( i \\geq 0 \\), \\( xy^i z \\in B \\).\nApplication of the Pumping Lemma\n\n**Example 1:** \\( B = \\{0^n1^n \\mid n \\geq 0\\} \\) is not regular.\n\n**Proof** Assume that \\( B \\) is regular. Let \\( p \\) be a constant from the pumping lemma for \\( B \\). Let \\( w = 0^p1^p \\).\n\nThen \\( w \\) is in \\( B \\) so it can be divided into \\( w = xyz \\) such that\n\n- \\( |y| \\geq 1 \\),\n- \\( |xy| \\leq p \\), and\n- for each \\( i \\geq 0 \\), \\( xy^iz \\in B \\).\n\nSince \\( |xy| \\leq p \\), both \\( x \\) and \\( y \\) consist solely of 0s. The word \\( xyyz \\) (the \\( i = 2 \\) case) has more 0s than 1s, and thus, not in \\( B \\). However, by the pumping lemma, \\( xyyz \\in B \\), a contradiction. Hence, \\( B \\) is not regular.\nI think \"0^n1^n\" is regular...\nI think \"0\\text{n}1\\text{n}\\\" is regular...\n\nYou're wrong, and here's why. Assuming it's regular, how many states do you need to build an FA for it?\nIllustrating Conversation\n\nWell, it must be large, but I think it should be less than a trillion...\nIllustrating Conversation\n\nWell, it must be large, but I think it should be less than a trillion...\n\nLet $p$ be the number and $w=0^p1^p$. The Pumping Lemma divides this into $xyz$. What is $y$?\nIllustrating Conversation\n\nWell, $y = 0^k$ for some positive $k$...\nIllustrating Conversation\n\nWell, \\( y = 0^k \\) for some positive \\( k \\)...\n\nThen \\( xz \\) must be a member, but it has fewer 0s than 1s, so it can’t be. We thus have a contradiction.\nIllustrating Conversation\n\nIt's not too late.\n\nOh, I was so naive. I should have taken CSC280...\nExample 2\n\n\\( C = \\{ w \\mid w \\in \\{0,1\\}^* \\text{ and has an equal number of 0s and 1s } \\} \\) is not regular.\nExample 2\n\n\\[ C = \\{ w \\mid w \\in \\{0, 1\\}^* \\text{ and has an equal number of 0s and 1s} \\} \\text{ is not regular.} \\]\n\n**Proof** Assume, to the contrary, that \\( C \\) is regular. Let \\( p \\) be the constant from the pumping lemma for \\( C \\).\nExample 2\n\n$C = \\{ w \\mid w \\in \\{0,1\\}^* \\text{ and has an equal number of 0s and 1s } \\}$ is not regular.\n\n**Proof** Assume, to the contrary, that $C$ is regular. Let $p$ be the constant from the pumping lemma for $C$.\n\nLet $w = 0^p1^p$. Then $w = xyz$ such that $|xy| \\leq p$, $|y| \\geq 1$, and for every $i \\geq 0$, $xy^iz \\in C$. \n**Example 2**\n\n\\[ C = \\{ w \\mid w \\in \\{0, 1\\}^* \\text{ and has an equal number of 0s and 1s} \\} \\text{ is not regular.} \\]\n\n**Proof** Assume, to the contrary, that \\( C \\) is regular. Let \\( p \\) be the constant from the pumping lemma for \\( C \\).\n\nLet \\( w = 0^p1^p \\). Then \\( w = xyz \\) such that \\( |xy| \\leq p \\), \\( |y| \\geq 1 \\), and for every \\( i \\geq 0 \\), \\( xy^iz \\in C \\).\n\nLet \\( w' = xz \\). Then \\( w' \\in C \\) but \\( w' \\) has fewer 0s than 1s.\nExample 3\n\nThe language $F = \\{vv \\mid v \\in \\{0, 1\\}^*\\}$ is not regular ($F$ is the language of all even length strings over $\\{0, 1\\}$ whose first half is identical to the second half).\n\nProof Assume, to the contrary, that $F$ is regular. Let $p$ be a constant for which the pumping lemma holds for $F$. \nExample 3\n\nThe language $F = \\{ vv \\mid v \\in \\{0, 1\\}^* \\}$ is not regular ($F$ is the language of all even length strings over $\\{0, 1\\}$ whose first half is identical to the second half).\n\nProof Assume, to the contrary, that $F$ is regular. Let $p$ be a constant for which the pumping lemma holds for $F$.\n\nLet $w = 0^p1^p0^p1^p$. Then, $w$ is divided into $w = xyz$ such that $|y| \\geq 1$, $|xy| \\leq p$, and $(\\forall i \\geq 0)[xy^iz \\in F]$. Here $y \\in 0^+$ since $w$ begins with $0^p$. \nExample 3\n\nThe language $F = \\{vv \\mid v \\in \\{0, 1\\}^*\\}$ is not regular ($F$ is the language of all even length strings over $\\{0, 1\\}$ whose first half is identical to the second half).\n\n**Proof** Assume, to the contrary, that $F$ is regular. Let $p$ be a constant for which the pumping lemma holds for $F$.\n\nLet $w = 0^p1^p0^p1^p$. Then, $w$ is divided into $w = xyz$ such that $|y| > 0$, $|xy| \\leq p$, and $(\\forall i \\geq 0)[xy^iz \\in F]$. Here $y \\in 0^+$ since $w$ begins with $0^p$.\n\nPick $i = 0$, we have $0^q1^p0^p1^p \\in F$, where $q < p$. This word cannot be decomposed as $uu$. This is a contradiction.\nExample 4\n\n\\[ D = \\{1^{n^2} \\mid n \\geq 0\\} \\text{ is not regular.} \\]\nExample 4\n\n\\[ D = \\{1^{n^2} \\mid n \\geq 0\\} \\] is not regular.\n\n**Proof** Assume, to the contrary, that \\( D \\) is regular. Let \\( p \\) be a constant for which the pumping lemma holds for \\( D \\).\nExample 4\n\n\\[ D = \\{1^{n^2} \\mid n \\geq 0\\} \\text{ is not regular.} \\]\n\n**Proof** Assume, to the contrary, that \\( D \\) is regular. Let \\( p \\) be a constant for which the pumping lemma holds for \\( D \\).\n\nLet \\( w = 1^{p^2} \\). Then \\( w = xyz \\) for some \\( x, y, z \\) such that \\( |y| \\geq 1 \\), \\( |xy| \\leq p \\), and \\( (\\forall i \\geq 0)[xy^i z \\in D] \\).\n**Example 4**\n\n\\[ D = \\{1^{n^2} \\mid n \\geq 0\\} \\text{ is not regular.} \\]\n\n**Proof** Assume, to the contrary, that \\( D \\) is regular. Let \\( p \\) be a constant for which the pumping lemma holds for \\( D \\).\n\nLet \\( w = 1^{p^2} \\). Then \\( w = xyz \\) for some \\( x, y, z \\) such that \\( |y| \\geq 1 \\), \\( |xy| \\leq p \\), and \\( (\\forall i \\geq 0)[xy^i z \\in D] \\).\n\nLet \\( l = |y| \\). Then \\( 1 \\leq l \\leq p \\). By plugging in \\( i = 2 \\), we have \\( 1^{p^2 + l} \\in D \\), but \\( p^2 + l \\leq p^2 + p < (p + 1)^2 \\), a contradiction. \\( \\square \\)\nExample 5\n\n\\[ E = \\{0^i1^j \\mid i > j\\} \\] is not regular.\nExample 5\n\n\\[ E = \\{0^i1^j \\mid i > j\\} \\] is not regular.\n\n**Proof** Assume, to the contrary, that \\( E \\) is regular. Let \\( p \\) be a constant for which the pumping lemma holds for \\( E \\).\nExample 5\n\n$E = \\{0^i1^j \\mid i > j\\}$ is not regular.\n\nProof Assume, to the contrary, that $E$ is regular. Let $p$ be a constant for which the pumping lemma holds for $E$.\n\nLet $w = 0^p1^{p-1}$. Then $w = xyz$ for some $x, y, z$ such that $|y| \\geq 1$, $|xy| \\leq p$, and $(\\forall i \\geq 0)[xy^iz \\in E]$. Here $y \\in 0^+$ since the first $p$ symbols of $w$ are all 0.\nExample 5\n\n$E = \\{0^i1^j \\mid i > j\\}$ is not regular.\n\n**Proof** Assume, to the contrary, that $E$ is regular. Let $p$ be a constant for which the pumping lemma holds for $E$.\n\nLet $w = 0^p1^{p-1}$. Then $w = xyz$ for some $x, y, z$ such that $|y| \\geq 1$, $|xy| \\leq p$, and $(\\forall i \\geq 0)[xy^iz \\in E]$. Here $y \\in 0^+$ since the first $p$ symbols of $w$ are all 0.\n\nWith $i = 0$, we have $0^q1^{p-1} \\in E$, where $q \\leq p - 1$, a contradiction.\n\n\\[\\square\\]\nChapter 2, Part 1\n\nContext-free Languages\nA context-free grammar is a 4-tuple \\( G = (V, \\Sigma, R, S) \\). Here\n\n1. \\( V \\) is the set of variables (or nonterminals),\n2. \\( \\Sigma \\) is the set of terminals,\n3. \\( R \\) is the set of substitution rules (or production rules), each of which is of the form\n\n\\[\nA \\rightarrow w,\n\\]\n\nfor some nonterminal \\( A \\) and some word \\( w \\) over \\( V \\cup \\Sigma \\); and\n4. \\( S \\) is a nonterminal called the start symbol.\n**Substitution**\n\nGiven a word $x \\in (V \\cup \\Sigma)^*$ of the form $yAz$ and a rule $A \\rightarrow w$, $x$ can be turned into $ywz$ by substituting the $A$ with $w$.\n\nNote\n\n- If $A$ does not appear in $x$, the rule has no effect on $x$.\n- If there are multiple rules for substituting $A$, then you nondeterminististically choose the one you apply.\n- If there are multiple occurrences of $A$, then you nondeterminististically choose the one and the rule is applied.\nWe write $u \\Rightarrow v$ to mean that $v$ can be produced from $u$ by applying in sequence production rules; that is, if there is a sequence $[u_0, \\ldots, u_m]$ of strings over $V \\cup \\Sigma$ and there is a sequence $[r_1, \\ldots, r_m]$ of rules $R$ such that\n\n- $u_0 = u$ and $u_m = v$;\n- for each $i$, $1 \\leq i \\leq m$, $u_i$ can be obtained from $u_{i-1}$ by applying $r_i$.\n\nWe say that $G$ produces $w \\in \\Sigma^*$ if $S \\Rightarrow w$, i.e., $w$ can be obtained from $S$ by derivation.\nA **parse tree** (or **derivation tree**) is a tree that depicts the process of derivation.\n\nSince each derivation step substitutes one nonterminal, the series of substitutions can be visualized using a tree.\nExample\n\nThe strings over $\\Sigma = \\{a, b\\}$ consisting of an equal number of a’s and b’s.\nExample: A Tempting but Incorrect Grammar for This!\n\nThe strings over $\\Sigma = \\{a, b\\}$ consisting of an equal number of a’s and b’s.\n\n$V = \\{S\\}$ and the derivation rules are\n\n$S \\rightarrow \\epsilon | abS | baS | aSb | bSa | S'ab | S'ba$.\n\nAre all the strings this generates good?\n\nDoes this generate all strings in the set? Can you find a counterexample?\nExample: A Tempting but Incorrect Grammar for This!\n\nThe strings over $\\Sigma = \\{a, b\\}$ consisting of an equal number of $a$’s and $b$’s.\n\n$V = \\{S\\}$ and the derivation rules are\n\n$S \\rightarrow \\epsilon \\mid abS \\mid baS \\mid aSb \\mid bSa \\mid S_{ab} \\mid S_{ba}$.\n\nAre all the strings this generates good? Yes!\n\nDoes this generate all strings in the set? Can you find a counterexample? Here is one:\n\nCan this grammar ever yield a string that starts and ends in $a$? Yes it can! Oops—but let’s not give up! So, can this grammar ever yield a string that starts and ends in $aa$, such as $aabbbbaa$? No! Why? What could the first rule be?!? None work!\nExample: Two Good Grammars\n\nThe strings over $\\Sigma = \\{a, b\\}$ consisting of an equal number of a’s and b’s.\n\nGrammar 1 that works for this:\n$V = \\{S\\}$ and the derivation rules are $S \\rightarrow \\epsilon \\mid aSbS \\mid bSaS$.\n\nGrammar 2 that works for this:\n$V = \\{S\\}$ and the derivation rules are $S \\rightarrow \\epsilon \\mid aSb \\mid bSa \\mid SS$. \nExample\n\nThe strings over $\\Sigma = \\{a, b\\}$ consisting of an equal number of a’s and b’s.\n$V = \\{S\\}$ and the derivation rules are $S \\rightarrow \\epsilon \\mid aSbS \\mid bSaS$.\n\n$abab$ is derived as follows (this is an example using Grammar 1):\n\n$$S \\Rightarrow aSbS \\Rightarrow abSaSbS \\Rightarrow abSabS \\Rightarrow ababS \\Rightarrow abab.$$\nWhy Does the Grammar 2 Work?\n\nGrammar 2: $V = \\{S\\}$ and the derivation rules are\n\n$$S \\rightarrow \\epsilon \\mid aSa \\mid bSb \\mid SS.$$ \n\nEverything grammar 2 generates has the same number of a’s and b’s.\n\nConsider any nonempty (even-length) string of a’s and b’s with the same number of a’s and b’s. If it is $\\epsilon$, clearly this grammar gives it. If it is $a \\ldots b$ or $b \\ldots a$, strip the inside thanks to the $aSb$ or $bSa$ productions, and inductively we’re done. If it is $a \\ldots a$ (and $b \\ldots b$ is analogous), then there must be (why?) some break-up of the string into two nonempty parts (e.g., breaking $aabbabbbba$ into $aabb \\cdot abbbabbbba$) that each have the same number of a’s and b’s, and so thanks to the SS production inductively (twice, on those smaller strings) we’re again done.\nWhy Does the Grammar 1 Work?\n\nLet $L$ be the language. For each word over $\\{a, b\\}$, let $d(w)$ be the number of $a$’s in $w$ minus the number of $b$’s in $w$. We observe:\n\n- For all $w$, $w \\in L$ if and only if $d(w) = 0$.\n- $d(\\varepsilon) = 0$; $d(a) = 1$; $d(b) = -1$.\n- For all $u$ and $v$, $d(uv) = d(u) + d(v)$.\n\nSo, if $w \\in L$ and if $w_1 = a$, there exists some $k \\geq 2$ such that $d(w_1 \\cdots w_k) = 0$ and $d(w_1 \\cdots w_{k-1}) = d(w_1) = 1$. This implies that $d(w_2 \\cdots w_{k-1}) = d(w_{k+1} \\cdots w_n) = 0$.\n\nThis gives $S \\rightarrow aSbS$. By exchanging the role between $a$ and $b$, we have $S \\rightarrow bSaS$. \nAmbiguity and Leftmost Derivation\n\nIt looks like there are many different ways to produce the same word $w \\in L(G)$ for a grammar $G$. \nAmbiguity and Leftmost Derivation\n\nIt looks like there are many different ways to produce the same word $w \\in L(G)$ for a grammar $G$.\n\nOf course, this is true because when multiple nonterminals appear on an intermediate word, the order in which the nonterminals are chosen for substitution doesn’t affect the word produced.\nAmbiguity and Leftmost Derivation\n\nIt looks like there are many different ways to produce the same word \\( w \\in L(G) \\) for a grammar \\( G \\).\n\nOf course, this is true because when multiple nonterminals appear on an intermediate word, the order in which the nonterminals are chosen for substitution doesn’t affect the word produced.\n\nBut what if you force the order to be always from left to right, will there still be multiple ways to derive the target word?\nLeftmost Derivation\n\nA **leftmost derivation** is the derivation in which each production rule is applied to the leftmost nonterminal at the moment.\nA leftmost derivation is the derivation in which each production rule is applied to the leftmost nonterminal at the moment. For $abab$ in the previous example,\n\n$$S \\Rightarrow aS'bS \\Rightarrow abS'aS'bS \\Rightarrow abaS'bS \\Rightarrow ababS \\Rightarrow abab$$\n\nis a leftmost derivation,\n**Leftmost Derivation**\n\nA **leftmost derivation** is the derivation in which each production rule is applied to the leftmost nonterminal at the moment. For $abab$ in the previous example,\n\n$$S \\Rightarrow aS'bS \\Rightarrow abS'aS'bS \\Rightarrow abaS'bS \\Rightarrow ababS \\Rightarrow abab$$\n\nis a leftmost derivation, while\n\n$$S \\Rightarrow aS'bS \\Rightarrow aS'baS'bS \\Rightarrow aS'babS \\Rightarrow aS'bab \\Rightarrow abab$$\n\nisn’t one.\nAmbiguity and Leftmost Derivation\n\nA context-free grammar is **unambiguous** if it has a unique leftmost derivation for every word it generates. Otherwise, the grammar is **ambiguous**.\n\nThere is a context-free language that is **inherently ambiguous** — every grammar that produces the language is ambiguous.\nChomsky Normal Form\n\nA context-free grammar $G = (V, \\Sigma, R, S)$ is in Chomsky normal form if each rule in $R$ is of the following form:\n\n- $S \\rightarrow \\epsilon$ (note that $S$ is the start symbol).\n- $A \\rightarrow BC$ for some $A \\in V$ and $B, C \\in V - \\{S\\}$ and\n- $A \\rightarrow a$ for some $a \\in \\Sigma$. \n\nChomsky Normal Form\n\nA context-free grammar $G = (V, \\Sigma, R, S)$ is in **Chomsky normal form** if each rule in $R$ is of the following form:\n\n- $S \\rightarrow \\epsilon$ (note that $S$ is the start symbol).\n- $A \\rightarrow BC$ for some $A \\in V$ and $B, C \\in V - \\{S\\}$ and\n- $A \\rightarrow a$ for some $a \\in \\Sigma$.\n\n**Theorem.** Each context-free language is generated by a Chomsky normal form grammar.\nConverting an Arbitrary CFG to a CNF Grammar\n\nLet $G = (V, \\Sigma, R, S)$ be an arbitrary CFG and let $L = L(G)$.\n\nWe will convert this to a CNF grammar $G' = (V', \\Sigma, R', S_0)$. \nConversion Policy\n\nWe perform the following steps in order:\n\n1. Do away with rules of the form $A \\rightarrow \\epsilon$.\n This rule is permitted for only $A = S_0$ only in the case where $\\epsilon \\in L$.\n\n2. Do away with rules of the form $A \\rightarrow B$ where $B$ is a variable.\n\n3. Do away with rules of the form $A \\rightarrow w$ where either $w$ is having length 2 and contains a terminal or $w$ is having length $\\geq 3$. \nStep 1: Rules of the form $A \\rightarrow \\epsilon$\n\nWe need to eliminate all rules of the form $A \\rightarrow \\epsilon$.\n\nWe say that a variable $A$ of $G$ is **nullable** if $A \\Rightarrow \\epsilon$. \nFinding All “Nullable” Variables\n\nWe find all “nullable” variables using the following greedy algorithm:\n\n- Initialize a set $U$ as the collection of all variables $A$ such that $A \\rightarrow \\epsilon$ is a valid production rule.\n- While there is a rule of the form $B \\rightarrow A_1 \\cdots A_k$ such that $B \\notin U$ and $A_1, \\ldots, A_k \\in U$, select such a $B$ add it to $U$. \nDoes $\\epsilon$ Belong to $L(G)$?\n\nAfter $U$ has been computed, whether $\\epsilon \\in L(G)$ can be tested by checking whether $S \\in U$ because:\n\n$$S \\in U \\iff \\epsilon \\in L(G).$$\n\nIf $S \\in U$, we will add $S_0 \\rightarrow \\epsilon$ at the end.\n\nFrom this point on we will assume that $\\epsilon \\notin L(G)$. \nRemovable of $A \\rightarrow \\epsilon$\n\n- Initialize $V'$ with the set $V$.\n- Add to $R'$ all the rules in $R$ of the form $B \\rightarrow y$ such that $y$ is nonempty, is not equal to $B$, and has no nullable variables.\n- Add $S_0$ to $V'$ and rule $S_0 \\rightarrow S$ to $R'$.\nRemovable of $A \\rightarrow \\epsilon$\n\nFor each rule of the form $B \\rightarrow y$ in $R$ such that a nullable variable appears in $y$ do the following:\n\n- Create all rules produced from $B \\rightarrow y$ by selecting, independently at each position in $y$ where the letter is a nullable variable, whether to keep the variable in place or replace it with $\\epsilon$.\n\n- Add all the rules thus created (which includes the original $B \\rightarrow y$) to $R'$, except for $B \\rightarrow \\epsilon$ and $B \\rightarrow B$ if such a rule is at all created.\nRemovable of $A \\rightarrow B$\n\nWhile $R'$ contains a rule of the form $A \\rightarrow B$ such that $B \\in V$, pick such a rule $r$ and do the following:\n\n- Remove $r$ from $R'$.\n- For each rule $B \\rightarrow w$ in $R'$, add $A \\rightarrow w$ to $R'$ if $w \\neq A$. \nCurrent Situation\n\nEach rule in $R'$ is one of the following forms:\n\n- $A \\rightarrow b$ for some $b \\in \\Sigma$.\n- $A \\rightarrow w$ for some $w \\in (V \\cup \\Sigma)^*$ having length $\\geq 2$. \nNormalization Part 1\n\nFor each terminal $d$\n\n- add a new variable $D$,\n- add a new rule $D \\rightarrow d$, and\n- for each rule $A \\rightarrow u$ such that $|u| \\geq 2$ and $d$ appears in $u$, replace each occurrence of $d$ with a $D$. \nNormalization Part 2\n\nFor each rule $A \\rightarrow w_1 \\ldots w_m$ such that $m \\geq 3$, do the following:\n\n- Add a new variable $X$.\n- Replace $A \\rightarrow w$ by two rules: $A \\rightarrow w_1X$ and $X \\rightarrow w_2 \\ldots w_m$. \n**Example**\n\n\\[ V = \\{S\\}, \\Sigma = \\{a, b\\}, \\text{ and } R \\text{ consists of } S \\rightarrow \\epsilon \\mid aSbS \\mid bSaS \\]\n\n**Step 1** Add \\( S_0 \\rightarrow S \\mid \\epsilon \\).\n\n**Step 2** Eliminate \\( S \\rightarrow \\epsilon \\). The rules are\n\n\\[\nS_0 \\rightarrow S \\mid \\epsilon,\n\\]\n\n\\[\nS \\rightarrow ab \\mid abS \\mid aSbS \\mid aSb \\mid ba \\mid baS \\mid bSaS \\mid bSa.\n\\]\n\n**STEP 3** Eliminate \\( S_0 \\rightarrow S \\) and add\n\n\\[\nS_0 \\rightarrow ab \\mid abS \\mid aSbS \\mid aSb \\mid ba \\mid baS \\mid bSaS \\mid bSa\n\\]\nThe rules are\n\n\\[ S_0 \\rightarrow \\epsilon, \\quad A \\rightarrow a, \\quad B \\rightarrow b, \\]\n\\[ S_0 \\rightarrow AB \\mid AX_1 \\mid AX_2 \\mid AX_3 \\mid BA \\mid BY_1 \\mid BY_2 \\mid BY_3, \\]\n\\[ S \\rightarrow AB \\mid AX_1 \\mid AX_2 \\mid AX_3 \\mid BA \\mid BY_1 \\mid BY_2 \\mid BY_3, \\]\n\\[ X_1 \\rightarrow BS, \\quad X_2 \\rightarrow SX_4, \\]\n\\[ X_3 \\rightarrow SB, \\quad X_4 \\rightarrow BS, \\]\n\\[ Y_1 \\rightarrow AS, \\quad Y_2 \\rightarrow SY_4, \\]\n\\[ Y_3 \\rightarrow SA, \\quad Y_4 \\rightarrow AS. \\]\n\nHere we are using the same variables \\( X_1, \\ldots, X_4 \\) and \\( Y_1, \\ldots, Y_3 \\) for \\( S_0 \\) and \\( S \\).\nPushdown Automata\n\nThe machine model for the context-free language.\nPushdown Automata\n\nA pushdown automaton is an NFA with a last-in, first-out storage device called stack.\nPushdown Automata\n\nA pushdown automaton is an NFA with a last-in, first-out storage device called stack.\n\nA pushdown automaton is a 6-tuple \\((Q, \\Sigma, \\Gamma, \\delta, q_0, F)\\) where\n\n1. \\(Q\\) is a finite set of states,\n2. \\(\\Sigma\\) is a finite input alphabet,\n3. \\(\\Gamma\\) is a finite stack alphabet,\n4. \\(\\delta : Q \\times \\Sigma \\epsilon \\times \\Gamma \\epsilon \\rightarrow \\mathcal{P}(Q \\times \\Gamma \\epsilon)\\) is the transition,\n5. \\(q_0 \\in Q\\) is the start state, and\n6. \\(F \\subseteq Q\\) is the set of accept states,\n\nwhere \\(\\Sigma \\epsilon = \\Sigma \\cup \\{\\epsilon\\}\\) and \\(\\Gamma \\epsilon = \\Gamma \\cup \\{\\epsilon\\}\\).\nRepresent the contents of the stack by taking the letters from top to bottom and putting them from left to right. Here the stack has the word \\textit{tstst} (see: \\textit{t} is at the top of the stack in the picture, and so is leftmost in \\textit{tstst}).\n(A) If not the entire input has been read, it may choose to read the next letter.\n - If either the entire input has already been read or it decides not to read the next letter, the input letter is considered to be $\\varepsilon$. \n\nComputation by Pushdown Automata\n\n(B) It may choose to read the top letter of the stack.\n - If the stack is already empty, then the computation stops there without accepting.\n - If it decides not to read the stack, the stack letter is considered to be $\\epsilon$. \nComputation by Pushdown Automata\n\n(C) Depending on the current state, the input letter, and the stack letter, it **nondeterministically decides the next state** and **a letter to be placed on the stack**, with a possible option of not placing a letter, in which case the letter is considered to be $\\epsilon$. \nTransition Function of a PDA\n\n- The input: $Q \\times \\Sigma \\epsilon \\times \\Gamma \\epsilon$.\n- The output: $2Q \\times \\Gamma \\epsilon$. \nAcceptance of Pushdown Automata\n\nA pushdown automaton $M$ accepts an input $w$ if $M$ arrives at an accept state at some time after reading all the input letters.\n\nA computation path of $M$ on input $w$ halts without accepting if there is no applicable next move.\n\nIf the current state is $q$, the next input letter is $a$, and the top stack letter is $b$, there are four possible courses of action:\n\n1. a move in $\\delta(q, \\epsilon, \\epsilon)$\n2. a move in $\\delta(q, \\epsilon, b)$\n3. a move in $\\delta(q, a, \\epsilon)$\n4. a move in $\\delta(q, a, b)$\nAcceptance of Pushdown Automata\n\nA pushdown automaton $M$ accepts an input $w$ if $M$ arrives at an accept state at some time after reading all the input letters.\n\nA computation path of $M$ on input $w$ halts without accepting if there is no applicable next move.\n\nIf the current state is $q$, the next input letter is $a$, and the top stack letter is $b$, there are four possible courses of action:\n\n1. a move in $\\delta(q, \\epsilon, \\epsilon)$\n2. a move in $\\delta(q, \\epsilon, b)$ – impossible if stack is empty\n3. a move in $\\delta(q, a, \\epsilon)$ – impossible if no input letter is left\n4. a move in $\\delta(q, a, b)$ – impossible if no input letter is left or stack is empty\nAcceptance by a Pushdown Automaton\n\nFormally, $M$ accepts $w \\in \\Sigma^*$ if there exist\n\n- $r_0, \\ldots, r_m \\in Q$ (states), $w_1, \\ldots, w_m \\in \\Sigma^\\epsilon$ (input letters),\n- $a_1, \\ldots, a_m \\in \\Gamma^\\epsilon$ (stack letters read),\n- $b_1, \\ldots, b_m \\in \\Gamma^\\epsilon$ (stack letters written),\n- $s_1, \\ldots, s_m \\in \\Gamma^*$ (stack word before pop),\n- $t_1, \\ldots, t_m \\in \\Gamma^*$ (stack word after pop),\n\nsuch that:\n\n1. $r_0 = q_0$, $r_m \\in F$ (start with $q_0$ and accept),\n2. $w = w_1 \\cdots w_m$ (the input decomposition),\n3. $a_1 = s_1 = t_1 = \\epsilon$ (start with empty stack),\n4. for all $i, 1 \\leq i \\leq m - 1$, $s_i = a_i t_i$ and $s_{i+1} = b_i t_i$ (preservation of stack content other than top),\n5. for all $i, 1 \\leq i \\leq m$, $(r_i, b_i) \\in \\delta(r_{i-1}, w_i, a_i)$ (respecting the transition function).\nDiagram\n\nInput \\[ \\cdots \\; w_i \\; w_{i+1} \\]\n\n\\[ \\delta(r_{i-1}, w_i, a_i) \\ni (r_i, b_i) \\]\n\nState \\[ r_0 \\; \\cdots \\; r_{i-1} \\; r_i \\; \\cdots \\; r_m \\]\n\nStack\n\n\\[\n\\begin{array}{c}\n\\begin{array}{c}\n a_i \\\\\n t_i \\\\\n s_i\n\\end{array}\n\\end{array}\n\\quad\n\\begin{array}{c}\n\\begin{array}{c}\n b_i \\\\\n t_i \\\\\n s_{i+1}\n\\end{array}\n\\end{array}\n\\]\nExample 1\n\nA PDA for $L = \\{0^n1^n | n \\geq 0\\}$.\n\nFor example, 000111 is a member, 0011 is a member, but 00110011 is not.\nExample 1\n\nIdea\n\nUsing stack keep a tally of the leading 0s. Compare the number against the number of trailing 1s.\nExample 1\n\nAlgorithm\n\n1. May accept immediately.\n2. Place a special symbol $ on the stack to mark the bottom.\n3. Read input symbols without popping from stack. If the symbol is a 0, put a 0 onto stack; otherwise, stop.\n4. Guess the start of 1s and begin simultaneously reading input and popping from stack.\n If either the input symbol is not a 1 or the stack symbol popped is not a 0, stop.\n Any time during this, stop reading the input and then\n • verify that the top of stack is $ and accept.\nHow This Method Works\n\n• $0^n1^n$ for some $n \\geq 1$: Will accept.\n• $\\epsilon$: Will accept by choosing to verify $\\$$ immediately after place it on the top.\nHow This Method Works\n\n- $0^n1^n$ for some $n \\geq 1$: Will accept.\n- $\\epsilon$: Will accept by choosing to verify $\\$$ immediately after place it on the top.\n- $1y$ for some $y \\in \\{0, 1\\}^*$: Will either pop the $\\$$ on reading the first 1 or enter accept without reading any input letter.\n- $0^n1^{n+k}$ for some $n, k \\geq 1$: Will either pop the $\\$$ on reading the first 1 or enter accept without finishing to read the input.\n- $0^n1^{n-k}$ for some $n, k \\geq 1$: Verification for $\\$$ will fail.\n**Transition Function**\n\n\\[ \\Gamma = \\{0, 1, \\$\\}, \\quad Q = \\{q_1, q_2, q_3, q_4\\}, \\quad F = \\{q_1, q_4\\}, \\quad q_1 \\text{ is the initial state} \\]\n\n<table>\n<thead>\n<tr>\n<th>Input:</th>\n<th>0</th>\n<th>1</th>\n<th>(\\epsilon)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Stack:</td>\n<td>(0/$)</td>\n<td>(\\epsilon)</td>\n<td>(0)</td>\n</tr>\n<tr>\n<td>(q_1)</td>\n<td>{(q_2, 0)}</td>\n<td>{(q_3, \\epsilon)}</td>\n<td>{(q_4, \\epsilon)}</td>\n</tr>\n<tr>\n<td>(q_2)</td>\n<td>{(q_2, 0)}</td>\n<td>{(q_3, \\epsilon)}</td>\n<td>{(q_4, \\epsilon)}</td>\n</tr>\n<tr>\n<td>(q_3)</td>\n<td>{(q_2, 0)}</td>\n<td>{(q_3, \\epsilon)}</td>\n<td>{(q_4, \\epsilon)}</td>\n</tr>\n</tbody>\n</table>\nExample 1\n\nLet \\((q, u, v), q \\in Q, u \\in \\Sigma^*, v \\in \\Gamma^*,\\) denote the configuration where the state is \\(q\\), the remaining input is \\(u\\), and the stack word is \\(v\\).\n\n000111 is accepted by the following path:\n\n\\[(q_1, 000111, \\epsilon) \\Rightarrow (q_2, 000111, \\$) \\Rightarrow (q_2, 00111, 0\\$) \\Rightarrow (q_2, 0111, 00\\$) \\Rightarrow (q_2, 111, 000\\$) \\Rightarrow (q_3, 11, 00\\$) \\Rightarrow (q_3, 1, 0\\$) \\Rightarrow (q_3, \\epsilon, \\$) \\Rightarrow (q_4, \\epsilon, \\epsilon).\\]\nExample 2\n\n\\[ L = \\{ u \\in \\{0, 1\\}^* \\mid u \\text{ has the same number of } 0\\text{s as } 1\\text{s} \\}. \\]\n\nFor example, 011100 is a member, 10010101 is a member, and 00010 is a nonmember.\nExample 2\n\n\\[ L = \\{ u \\in \\{0, 1\\}^* \\mid u \\text{ has the same number of } 0\\text{s as } 1\\text{s } \\} . \\]\n\nIdea\n\nUsing stack maintain a \\textit{tally of the difference between the number of } 0\\text{s and the number of } 1\\text{s that have been read so far}. Use a tally of 0s if there have been more 0s than 1s and a tally of 1s if there have been more 1s than 0s.\n\nCompare the first letter of the tally and an input letter. If one is a 0 and the other is a 1, they cancel out; otherwise, increase the tally.\nExample 2\n\n$L = \\{ u \\in \\{0, 1\\}^* | u \\text{ has the same number of 0s as 1s } \\}$. \n\n$Q = \\{ q_0, q_1, q_2, q_3, q_4 \\}$, $q_4$:final, $q_0$:initial \n\nNo permissible actions in $q_4$ \n\n$\\Gamma = \\{0, 1, \\$\\}$\n\n<table>\n<thead>\n<tr>\n<th>State</th>\n<th>Input</th>\n<th>Stack</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n<td>0</td>\n</tr>\n<tr>\n<td>$q_0$</td>\n<td>$\\epsilon$</td>\n<td>(q₂, 0)</td>\n</tr>\n<tr>\n<td>$q_1$</td>\n<td>0</td>\n<td>(q₂, 0)</td>\n</tr>\n<tr>\n<td></td>\n<td>1</td>\n<td>(q₁, $\\epsilon$)</td>\n</tr>\n<tr>\n<td></td>\n<td>$\\epsilon$</td>\n<td>(q₄, $\\epsilon$)</td>\n</tr>\n<tr>\n<td>$q_2$</td>\n<td>$\\epsilon$</td>\n<td></td>\n</tr>\n<tr>\n<td>$q_3$</td>\n<td>$\\epsilon$</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nHere { and } are omitted.\nBut wait! There is a one-character flaw in this machine drawing (here and also on the next slide). Can you spot it? (Hint: It has to do with the arrow from $q_1$ to $q_2$; compare the labels on that arrow to the ones on the arrow from $q_1$ to $q_3$; is there a problem regarding the topmost “/0” on that arrow to $q_2$?)\nExample: \\((q_0, 011100, \\epsilon) \\Rightarrow (q_1, 011100, \\$) \\Rightarrow (q_2, 11100, \\$) \\Rightarrow (q_1, 11100, 0\\$) \\Rightarrow (q_1, 1100, \\$) \\Rightarrow (q_3, 100, \\$) \\Rightarrow (q_1, 100, 1\\$) \\Rightarrow (q_3, 00, 1\\$) \\Rightarrow (q_1, 00, 11\\$) \\Rightarrow (q_1, 0, 1\\$) \\Rightarrow (q_1, \\epsilon, \\$) \\Rightarrow (q_4, \\epsilon, \\epsilon)\\)\nPushdown Automata and CFLs Are Equivalent\nProperties of Context-Free Languages\n\nTheorem. The context-free languages are closed under union, concatenation, and star.\n\nProof\n\nLet \\( S_1 \\) and \\( S_2 \\) be the start symbols of two CFG. Let \\( S_0 \\) be the new start symbol of the new CFG we are to create. (If needed, first rename things to ensure that the nonterminals of the two CFGs are disjoint, and that \\( S_0 \\) is not in either of the nonterminal symbol sets.)\n\nAdding \\( S_0 \\Rightarrow S_1 \\mid S_2 \\) works for union.\n\nAdding \\( S_0 \\Rightarrow S_1S_2 \\) works for concatenation.\n\nAdding \\( S_0 \\Rightarrow \\epsilon \\mid S_0S_1 \\) works for star.\nTheorem. Every language recognized by PDA is context-free.\n\nLet \\( L \\) be a language recognized by a PDA \\( M = (Q, \\Sigma, \\Gamma, \\delta, p_0, F) \\).\n\nWe can modify \\( M \\) so that:\n\n(*) \\( M \\) has a unique accept state and, when it enters the state, the stack is empty.\n\n(**) In a single move \\( M \\) may not both pop and push.\nUnique accept state and Empty Stack Acceptance\n\nModify $M$ to create an equivalent PDA $N = (Q', \\Sigma, \\Gamma', \\delta', q'_0, \\{q_f\\})$. \nUnique accept state and Empty Stack Acceptance\n\nModify $M$ to create an equivalent PDA $N = (Q', \\Sigma, \\Gamma', \\delta', q'_0, \\{q_f\\})$.\n\n$N$ simulates $M$ after adding a new special symbol $\\perp$ to the stack. If $M$ enters a accept state, $N$ may choose to empty the stack until it encounters $\\perp$, when $N$ may accept.\nModify $M$ to create an equivalent PDA $N = (Q', \\Sigma, \\Gamma', \\delta', q_0', \\{q_f\\})$.\n\n- $\\Gamma' = \\Gamma \\cup \\{\\perp\\}$.\n- $Q'$ consists of:\n - $Q$,\n - a new initial state $q_0'$,\n - a new, unique accept state $q_f$,\n - a clean-up state $C$,\n - some additional states for achieving the “not both push and pop” requirement.\nThe use of $q_0'$ and $C$ as a Bottom Marker\n\nThere is just one move in state $q_0$: $\\delta'(q_0', \\epsilon, \\epsilon) = \\{(p_0, \\bot)\\}$.\n\nThe transition means: **place a $\\bot$ on stack** and then proceed to the initial state of $M$. \n\nThe Role of \\( \\bot \\) and \\( C \\)\n\nIn each accept state \\( p \\) of \\( M \\), we add \\((C, \\epsilon)\\) to \\( \\delta'(p, \\epsilon, \\epsilon) \\).\n\nThe transition means: from any accept state of \\( F \\), you may proceed to \\( C \\).\nThe Role of $\\bot$ and $C$\n\nWe have\n\n- $\\delta'(C, \\epsilon, \\bot) = \\{(q_f, \\epsilon)\\}$ and\n- for each $a \\in \\Gamma$, $\\delta'(C, \\epsilon, a) = \\{(C, \\epsilon)\\}$.\n\nThese transitions allow emptying stack and then entering $q_f$. \nNo Pop and Push at the Same Time\n\nSuppose we have a permissible transition \\((q, c)\\) for \\(\\delta(p, a, b)\\), where \\(a \\in \\Sigma_\\epsilon\\) and \\(b, c \\in \\Gamma\\). Then we add a new state \\(q'\\) exclusively for this particular transition and replace this transition with two transitions:\n\n1. \\((q', \\epsilon)\\) in \\(\\delta(p, a, b)\\) and\n2. \\((q, c)\\) in \\(\\delta(q', \\epsilon, \\epsilon)\\).\nConstruction of Grammar\n\nWe say that $M$ can transition from state $p$ to state $q$ on input $w$ while maintaining the minimum stack height if it is possible for $M$ to transition from $p$ to $q$ by processing $w$ so that\n\n- the stack height before reading $w$ is the same as the stack height after finishing to read $w$ and then entering $q$,\n- during these two events the stack height never goes below the stack level at the time $M$ starts processing $w$. \nConstruction of Grammar\n\nConstruct a CFG \\((V, \\Sigma, P, S)\\): \\(V = \\{A_{pq} \\mid p, q \\in Q\\}\\) and \\(S = A_{q_0q_f}\\), where \\(q_0\\) is the initial state of \\(M\\) and \\(q_f\\) is the unique accept state of \\(M\\).\n\n\\(A_{pq}\\) is the variable corresponding to the set of all strings \\(w\\) that \\(M\\) can process and transition from \\(p\\) to \\(q\\) while maintaining the minimum stack height.\nProduction rules:\n\n- For every $p \\in Q$, $A_{pp} \\rightarrow \\epsilon$. \nProduction rules:\n\n- For every $p \\in Q$, $A_{pp} \\rightarrow \\epsilon$.\n- For all $p, q, r \\in Q$, $A_{pq} \\rightarrow A_{pr}A_{rq}$.\nProduction rules:\n\n- For every $p \\in Q$, $A_{pp} \\rightarrow \\epsilon$.\n- For all $p, q, r \\in Q$, $A_{pq} \\rightarrow A_{pr}A_{rq}$.\n- For all $p, q, r, s \\in Q$, $b, c \\in \\Sigma$, and $d \\in \\Gamma$, if $(r, d) \\in \\delta(p, b, \\epsilon)$ and $(q, \\epsilon) \\in \\delta(s, c, d)$, then $A_{pq} \\rightarrow bA_{rs}c$.\n\nThis means: one possibility for transition from $p$ to $q$ while maintaining the stack height is to:\n\n- transition from $p$ to $r$ after adding $d$ on top of stack,\n- transition from $r$ to $s$ while maintaining the stack height, and\n- transition from $s$ to $q$ while popping the $d$. \n**Theorem.** Each context-free language is recognized by a PDA.\n\nGiven any CFL $L$ such that $\\epsilon \\not\\in L$, we want to construct a PDA for $L$.\n\nWe can assume that $L$ is given by a CNF grammar $G = (V, \\Sigma, R, S)$. (Warning: This is a somewhat different proof approach than Sipser’s!)\n\nWe will design a PDA that simulates a leftmost derivation with respect to $G$.\n\n\\[1\\] Adding in $\\epsilon$ is not hard—it just takes a tweaking of the construction, namely, at the very start guessing whether the input is or is not $\\epsilon$, and if we guess the former, going into the accepting state, and if we guess the latter, doing the programming described below.\nSimulating a Leftmost Derivation\n\nUse symbol $\\perp$ to mark the bottom of stack.\n\nAfter placing a string $S\\perp$ (read from top to bottom) on top of the stack, repeat the following:\n\n- Pop one symbol $X$ from stack.\n- If $X = \\perp$ enter a unique accept state (so if we’re through the input, then the input is accepted).\n- Otherwise, nondeterministically select a rule $X \\rightarrow w$.\n - If $w = a$ for some terminal $a$, read one input symbol; if the symbol is $a$, continue; otherwise, stop without accepting.\n - If $w = AB$, place $AB$ on top of the stack and continue.\n\nThis simple approach correctly accepts $L$. \nNon-context-free Languages\n\nHow do we show something is not context free?\nThe Pumping Lemma\n\nTheorem. (Pumping Lemma) Let $L$ be context free. There exists a positive integer $p$ with the following property.\n\nFor every $w \\in L$ of length at least $p$, there exist $u, v, x, y, z$, with $w = uvxyz$, such that the following hold:\n\n- $|vy| \\geq 1$,\n- $|vxy| \\leq p$, and\n- for each $i \\geq 0$, $uv^i xy^i z \\in L$. \n\nThe Pumping Lemma\n\nTheorem. (Pumping Lemma) Let $L$ be context free. There exists a positive integer $p$ with the following property.\n\nFor every $w \\in L$ of length at least $p$, there exist $u, v, x, y, z$, with $w = uvxyz$, such that the following hold:\n\n- $|vy| \\geq 1$,\n- $|vxy| \\leq p$, and\n- for each $i \\geq 0$, $uv^i xy^i z \\in L$.\n\nThe differences between this pumping lemma and the regular-sets one.\n\n- There are two components that are jointly inserted or deleted.\n- The part $vxy$ might not be at the beginning of $w$. \nProving the Pumping Lemma\n\nLet \\( L = L(G) \\) for some CNF grammar \\( G = (V, \\Sigma, R, S) \\).\n\nIf \\( L \\) is finite (i.e., has only a finite number of members), then there is a length \\( k \\) such that each member of \\( L \\) has length less than \\( k \\). We have only to choose \\( p \\) to be \\( k \\).\n\nSo we will assume \\( L \\) is infinite.\nProving the Pumping Lemma\n\nSet $m = \\|V\\|$ and $p = 2^m$.\n\nLet $w$ be an arbitrary member of $L$ having length at least $p$. Let $T$ be a derivation tree for $w$.\n\nSince $G$ is a CNF grammar, for each subtree of $T$, the following properties hold:\n\n- Each nonleaf node of $R$ is a variable.\n- Each leaf of $R$ is a terminal.\n- Each leaf of $R$ is a unique child of its parent.\n- Except for the leaves and their parents each node of $R$ has exactly two children.\n- The concatenation of the leaves of $R$ is a substring of $w$. \nA Useful Property\n\nAn ancestor–descendant pair with identical label (ADPIL, for short) in a production tree $R$ is a node pair $(r, s)$ such that\n\n- $r$ is an ancestor of $s$ and\n- the label of $r$ is identical to the label of $s$ (and thus, the label is a nonterminal).\nProof (cont’d)\n\nClaim. If $R$ has more than $p/2 = 2^{m-1}$ leaves, then $R$ contains an ADPIL.\nClaim. If \\( R \\) has more than \\( \\frac{p}{2} = 2^{m-1} \\) leaves, then \\( R \\) contains an ADPIL.\n\nProof\n\nSuppose \\( R \\) is a subtree of \\( T \\) with at least \\( 2^{m-1} + 1 \\) leaves.\n\nLet \\( R' \\) be the tree constructed form \\( R \\) by removing all the leaves.\n\nSince the terminals appear only at the leaves, the claim is equivalent to saying that \\( R' \\) has an ADPIL.\n\nThe claim is proved by showing, by contradiction, that there is a root-to-leaf path in \\( R' \\) with at least \\( m + 1 \\) nodes,\nProof (cont’d)\n\nAssume, by way of contradiction, that every root-to-leaf path of $R'$ has at most $m$ nodes,\nAssume, by way of contradiction, that every root-to-leaf path of $R'$ has at most $m$ nodes,\n\nThen the number of branches in any such path is at most $m - 1$. Since $R'$ is a binary tree, $R'$ has at most $2^{m-1}$ leaves.\nProof (cont’d)\n\nHowever, the number of leaves of $R'$ is greater than $2^{m-1}$. Thus, there is a root-to-leaf path, say $\\pi$, in $R'$ having length at least $m + 1$.\n\nThen, by the pigeonhole principle, an ADPIL appears on $\\pi$.\n\nProof of Claim\nUsing the following algorithm to find an ADPIL \\((r, s)\\) farthest from the root of \\(T\\).\n\n1. Set \\(u\\) to the root of \\(T\\).\n\n2. Execute the following loop:\n - If the left child of \\(u\\) has an ADPIL, set \\(u\\) to the left child of \\(u\\).\n - Otherwise, if the right child of \\(u\\) has an ADPIL, set \\(u\\) to the right child of \\(u\\).\n - Otherwise, quit the loop.\n\n3. Set \\(r = u\\) and \\(s\\) to the leftmost node with the same label as \\(r\\).\nProof of Pumping Lemma (cont’d)\n\nUsing the following algorithm to find an ADPIL \\((r, s)\\) farthest from the root of \\(T\\).\n\n1. Set \\(u\\) to the root of \\(T\\).\n2. Execute the following loop:\n - If the left child of \\(u\\) has an ADPIL, set \\(u\\) to the left child of \\(u\\).\n - Otherwise, if the right child of \\(u\\) has an ADPIL, set \\(u\\) to the right child of \\(u\\).\n - Otherwise, quit the loop.\n3. Set \\(r = u\\) and \\(s\\) to the leftmost node with the same label as \\(r\\).\n\nThe children of \\(r\\) have no ADPILs. Thus, both children have at most \\(2^m - 1\\) leaves and so \\(r\\) has at most \\(p = 2^m\\) leaves.\nProof of Pumping Lemma (cont’d)\n\nLet $x$ be the string at the leaf-level of the subtree rooted at $s$. Similarly, let $vxy$ be the one for $r$, where $v$ and $y$ are those to the left and to the right of $x$, respectively.\n\nLet $u$ be the string produced to the left of $r$ and $z$ to the right of $s$. \n\n![Diagram of trees with labels $u$, $v$, $x$, $y$, and $z$.]\nProof of Pumping Lemma (cont’d)\n\nLet $x$ be the string at the leaf-level of the subtree rooted at $s$. Similarly, let $vxy$ be the one for $r$, where $v$ and $y$ are those to the left and to the right of $x$, respectively.\n\nLet $u$ be the string produced to the left of $r$ and $z$ to the right of $s$.\n\nThen $|vxy| \\leq p$.\n\nAlso, since $s$ is a descendant of $r$ and $G$ has no $\\epsilon$-production except for $S \\rightarrow \\epsilon$, $x$ is a proper substring of $vxy$. Thus, $|vy| \\geq 1$. \nProof of Pumping Lemma (cont’d)\n\nSince both $r$ and $s$ have the same label, they are swappable. So, for every $i \\geq 0$, $uv^i xy^i z \\in L$. \nExample 1\n\n\\[ A = \\{0^n1^n2^n \\mid n \\geq 0\\} \\] is not context free.\n**Example 1**\n\n\\[ A = \\{0^n1^n2^n \\mid n \\geq 0 \\} \\] is not context free.\n\n**Proof** Assume, to the contrary, that \\( A \\) is context free. By Pumping Lemma there exists a constant \\( p \\) such that every \\( w \\in A \\) of length \\( \\geq p \\) can be divided into \\( w = uvxyz \\) such that \\(|vxy| \\leq p\\), \\(|vy| \\geq 1\\), and for every \\( i \\geq 0\\), \\( uv^ixy^iz \\in A\\).\n\nLet \\( w = 0^p1^p2^p \\). Since \\(|vxy| \\leq p\\), \\( vxy \\) is either in \\( 0^*1^* \\) or in \\( 1^*2^* \\). This means that \\( uv^2xy^2z \\) cannot have the same number of 0s, 1s, as 2s.\nHey, I think I can show $0^n1^n2^n$ isn't context free.\nHey, I think I can show $0^n 1^n 2^n$ isn't context free.\n\nWow, that's great. Tell me about it.\nIllustrating Conversation\n\nIf that thing is context free, I get this magic constant $p$. \nIllustrating Conversation\n\nIf that thing is context free, I get this magic constant $p$.\n\nOh, I know it. You can divide any word in that thing into three parts...\nIllustrating Conversation\n\nNo, you idiot! It's FIVE parts, $w=uvxyz$!\nIllustrating Conversation\n\nNo, you idiot! It's FIVE parts, $w=uvxyz$!\n\nOkay. Let's say $w = 0^p1^p2^p$. Then what?\nIllustrating Conversation\n\n$w$ can be broken down into $uvxyz$, where $vy$ is nonempty and $vxy$ has length at most $p$. \nIllustrating Conversation\n\nw can be broken down into uvxyz, where vy is nonempty and vxy has length at most p.\n\nI see. Then v and y can touch at most two sections.\nRight. So, either pumping in or pumping out, you can create a word that can't be in that thing.\nRight. So, either pumping in or pumping out, you can create a word that can't be in that thing.\n\nBrilliant. You learned well in your CSC280.\nIllustrating Conversation\n\nBy the way, didn't you call me \"idiot\"?\nExample 2\n\n\\[ B = \\{ a\\#b\\#c \\mid a, b \\text{ and } c \\text{ are binary numbers such that } a + b = c \\} \\]\n\nis not context free.\nExample 2\n\n\\[ B = \\{a\\#b\\#c \\mid a, b \\text{ and } c \\text{ are binary numbers such that } a + b = c \\} \\]\n\nis not context free.\n\n**Proof** Assume, to the contrary, that \\( B \\) is context free. Let \\( p \\) be the constant from Pumping Lemma for \\( B \\). Let \\( w = 10^p \\#10^p \\#10^{p+1} \\), where \\( a = b = 2^p \\) and \\( c = 2^{p+1} \\). Let \\( uvxyz \\) be a decomposition of \\( w \\) as in the lemma.\nExample 2\n\n\\[ B = \\{a\\#b\\#c \\mid a, b \\text{ and } c \\text{ are binary numbers such that } a + b = c\\} \\]\nis not context free.\n\nProof Assume, to the contrary, that \\( B \\) is context free. Let \\( p \\) be the constant from Pumping Lemma for \\( B \\). Let \\( w = 10^p \\#10^p \\#10^{p+1} \\), where \\( a = b = 2^p \\) and \\( c = 2^{p+1} \\). Let \\( uvxyz \\) be a decomposition of \\( w \\) as in the lemma.\n\nSince each member of \\( B \\) has exactly two \\( \\# \\)'s, neither \\( v \\) nor \\( y \\) can contain a \\( \\# \\) (as otherwise pumping with \\( i = 2 \\) would put us clearly out of the language due to too many \\( \\# \\)'s). So, \\( v \\) must be a substring of \\( a \\), a substring of \\( b \\), or a substring of \\( c \\). The same holds for \\( y \\).\nExample 2 (cont’d)\n\nSince the equality $a + b = c$ must be maintained during pumping and $|vy| \\geq 1$, $y$ must be a nonempty substring of $c$ and $v$ must be either a nonempty substring of $a$ or a nonempty substring of $b$. However, since $vxy$ has length at most $p$, it must be the case that $v$ is a nonempty substring of $b$. \nExample 2 (cont’d)\n\nSince the equality $a + b = c$ must be maintained during pumping and $|vy| \\geq 1$, $y$ must be a nonempty substring of $c$ and $v$ must be either a nonempty substring of $a$ or a nonempty substring of $b$. However, since $vxy$ has length at most $p$, it must be the case that $v$ is a nonempty substring of $b$.\n\nIf $v$ contains the first letter of $b$, then $vxy$ (due to its length) must all be a part of $b$, contradicting the above; so $v$ should consist solely of 0’s.\nExample 2 (cont’d)\n\nSince the equality $a + b = c$ must be maintained during pumping and $|vy| \\geq 1$, $y$ must be a nonempty substring of $c$ and $v$ must be either a nonempty substring of $a$ or a nonempty substring of $b$. However, since $vxy$ has length at most $p$, it must be the case that $v$ is a nonempty substring of $b$.\n\nIf $v$ contains the first letter of $b$, then $vxy$ (due to its length) must all be a part of $b$, contradicting the above; so $v$ should consist solely of 0’s.\n\nSuppose $y$ contains 1, the first letter of $c$. Then $uvz$ is the form $10^p \\#10^q \\#0^r$, which clearly is not a member of $B$. \nExample 2 (cont’d)\n\nSince the equality $a + b = c$ must be maintained during pumping and $|vy| \\geq 1$, $y$ must be a nonempty substring of $c$ and $v$ must be either a nonempty substring of $a$ or a nonempty substring of $b$. However, since $vxy$ has length at most $p$, it must be the case that $v$ is a nonempty substring of $b$.\n\nIf $v$ contains the first letter of $b$, then $vxy$ (due to its length) must all be a part of $b$, contradicting the above; so $v$ should consist solely of 0’s.\n\nSuppose $y$ contains 1, the first letter of $c$. Then $uvz$ is the form $10^p\\#10^q\\#0^r$, which clearly is not a member of $B$.\n\nSuppose $y$ doesn’t contain the letter 1. Then $y$ consists solely of 0s; so $uvvxyyz$ is of the form $10^p\\#10^q\\#10^r$ such that $q, r > p$, which isn’t a member of $B$ (consider: $2 + 8$ isn’t a power of 2).\nExample 3\n\n\\[ C = \\{ww \\mid w \\in \\{0, 1\\}^*\\} \\text{ is not context free.} \\]\nExample 3\n\n\\[ C = \\{ww \\mid w \\in \\{0, 1\\}^*\\} \\text{ is not context free.} \\]\n\n**Proof** Assume \\( C \\) is context free. Let \\( p \\) the constant from the pumping lemma for \\( C \\).\n\nLet \\( w = 0^p1^p0^p1^p \\). Then \\( w \\) in \\( C \\).\nExample 3\n\n$C = \\{ww \\mid w \\in \\{0, 1\\}^*\\}$ is not context free.\n\nProof Assume $C$ is context free. Let $p$ the constant from the pumping lemma for $C$.\n\nLet $w = 0^p1^p0^p1^p$. Then $w$ in $C$.\n\nLet $w = uvxyz$ be a decomposition of $w$ such that $|vy| > 0,$ $|vxy| \\leq p$, and for every $i \\geq 0$, $uv^i xy^i z \\in C$. \nExample 3\n\n\\[ C = \\{ww \\mid w \\in \\{0, 1\\}^*\\} \\] is not context free.\n\n**Proof** Assume \\( C \\) is context free. Let \\( p \\) the constant from the pumping lemma for \\( C \\).\n\nLet \\( w = 0^p1^p0^p1^p \\). Then \\( w \\) in \\( C \\).\n\nLet \\( w = uvxyz \\) be a decomposition of \\( w \\) such that \\( |vy| > 0 \\), \\( |vxy| \\leq p \\), and for every \\( i \\geq 0 \\), \\( uv^i x y^i z \\in C \\).\n\nIf \\( v \\) contains a symbol from the first \\( 0^p \\) then \\( y \\) cannot contain one from the second \\( 0^p \\), so pumping doesn’t work.\nExample 3\n\n$C = \\{ww \\mid w \\in \\{0, 1\\}^*\\}$ is not context free.\n\n**Proof** Assume $C$ is context free. Let $p$ the constant from the pumping lemma for $C$.\n\nLet $w = 0^p1^p0^p1^p$. Then $w$ in $C$.\n\nLet $w = uvxyz$ be a decomposition of $w$ such that $|vy| > 0$, $|vxy| \\leq p$, and for every $i \\geq 0$, $uv^i xy^i z \\in C$.\n\nIf $v$ contains a symbol from the first $0^p$ then $y$ cannot contain one from the second $0^p$, so pumping doesn’t work.\n\nIf $v$ contains only symbols from the first $1^p$ then $y$ cannot contain one from the second $1^p$, so pumping doesn’t work.\nExample 3\n\n$C = \\{ww \\mid w \\in \\{0, 1\\}^*\\}$ is not context free.\n\nProof Assume $C$ is context free. Let $p$ the constant from the pumping lemma for $C$.\n\nLet $w = 0^p1^p0^p1^p$. Then $w$ in $C$.\n\nLet $w = uvxyz$ be a decomposition of $w$ such that $|vy| > 0$, $|vxy| \\leq p$, and for every $i \\geq 0$, $uv^i xy^i z \\in C$.\n\nIf $v$ contains a symbol from the first $0^p$ then $y$ cannot contain one from the second $0^p$, so pumping doesn’t work.\n\nIf $v$ contains only symbols from the first $1^p$ then $y$ cannot contain one from the second $1^p$, so pumping doesn’t work.\n\nIf $v$ contains only symbols from the second $0^p1^p$ then pumping does not work.\nCorollary. The class of context-free languages is not closed under intersection.\n\n**Proof** Let $L_1 = \\{0^i1^j2^k | i = j\\}$ and $L_2 = \\{0^i1^j2^k | j = k\\}$. Then $L_1$ and $L_2$ are both context free. If the class were closed under intersection then $L_1 \\cap L_2 = \\{0^n1^n2^n | n \\geq 0\\}$ would be context free.\n\nCorollary. The class of context-free languages is not closed under complement.\n\n**Proof** We know that the class is closed under union. If the class were closed under complement, then by DeMorgan’s Law, it would be closed under intersection.\nChapter 3, Part 1\n\nComputability Theory\nA **Turing machine** is a step-wise computing device consisting of:\n\n1. an infinitely long **tape** divided into **tape squares** (or **tape cells**),\n2. a **head** for scanning the tape, and\n3. a **finite control** that maintains the current state.\nTuring Machines\n\nA Turing machine is a step-wise computing device consisting of:\n\n1. an infinitely long tape divided into tape squares (or tape cells),\n2. a head for scanning the tape, and\n3. a finite control that maintains the current state.\nComputation by a Turing Machine\n\nIn each computational step, a Turing machine:\n\n• reads the symbol written at the current head location, and then,\n\n• depending on the symbol and the current state\n • determines its next state,\n\n• write a symbol at the current head location, and\n\n• moves the head to either the next or the prior tape square.\nA Turing machine is a 7-tuple \\((Q, \\Sigma, \\Gamma, \\delta, q_0, q_{\\text{accept}}, q_{\\text{reject}})\\), where \\(Q, \\Sigma, \\Gamma\\) are finite sets,\n\n1. \\(Q\\) is a set of states,\n2. \\(\\Sigma\\) is the input alphabet,\n3. \\(\\Gamma\\) is the tape alphabet such that \\(\\Sigma \\subset \\Gamma\\). There is a special symbol \\(\\sqcup\\) in \\(\\Gamma - \\Sigma\\).\n4. \\(\\delta : Q \\times \\Gamma \\rightarrow Q \\times \\Gamma \\times \\{L, R\\}\\) is the transition function,\n5. \\(q_0 \\in Q\\) is called the initial state,\n6. \\(q_{\\text{accept}} \\in Q\\) is called the accept state, and\n7. \\(q_{\\text{reject}} \\in Q\\) is called the reject state, \\(q_{\\text{accept}} \\neq q_{\\text{reject}}\\).\nAt the beginning\n\n1. the tape contains its input in the leftmost squares,\n2. the rest of the tape is filled with $\\Box$,\n3. the head is at the leftmost cell, and\n4. the state is $q_0$. \n\n\\[\n\\begin{array}{cccccccc}\n a & b & a & b & c & \\Box & \\Box & \\Box \\\\\n\\end{array}\n\\]\n\nleft end of tape\n\nhead\n\nfinite control\nTermination of a Turing Machine\n\nThe Turing machine halts when it enters either $q_{\\text{accept}}$ or $q_{\\text{reject}}$. We say that the machine accepts when the former occurs and rejects when the latter occurs.\nComputation of a Turing Machine in One Step (Again)\n\nIn each computational step, a Turing machine:\n\n• reads the symbol written at the current head location, and then,\n\n• depending on the symbol and the current state\n • determines its next state,\n • write a symbol at the current head location, and\n • moves the head to either the next or the prior tape square.\nComputation of a Turing Machine in One Step (Again)\n\nIn each computational step, a Turing machine:\n\n• reads the symbol written at the current head location, and then,\n• depending on the symbol and the current state\n • determines its next state,\n• write a symbol at the current head location, and\n• moves the head to either the next or the prior tape square.\n\nHowever, if the instruction is to move the head to the left and the current head position is the leftmost square, then the head stays at the leftmost square.\nExample\n\nbecomes\n\n\\[\n\\begin{array}{cccccc}\n a & b & a & b & c & \\\\\n \\end{array}\n\\]\n\n\\[\n\\begin{array}{cccccc}\n a & b & b & b & c & \\\\\n \\end{array}\n\\]\n\nq₁\n\nq₂\nThe Languages of Turing Machines\n\nA Turing machine $M$ **accepts** (rej**ects**) a string $x$ if it enters the accepting (rejecting) state on input $x$.\n\nA Turing machine $M$ **recognizes** a language $L$, if for every input $x$, $M$ on $x$ accepts if $x \\in L$ and does not accept if $x \\notin L$.\n\nA language is **Turing-recognizable** (or **recursively enumerable**) if there is a Turing machine that recognizes it.\nA Turing machine \\( M \\) \\textbf{decides} a language \\( L \\), if \\( M \\) recognizes \\( L \\) and halts on all inputs.\n\nIn other words, a Turing machine \\( M \\) \\textbf{decides} a language \\( L \\) if, for all \\( x \\), \\( M \\) on \\( x \\) accepts if \\( x \\in L \\) and rejects if \\( x \\notin L \\).\n\nA language is \\textbf{Turing-decidable} (or simply \\textbf{decidable}, or \\textbf{recursive}) if there is a Turing machine that decides it.\nExample 1: \\[ L = \\{ w\\#w \\mid w \\in \\{0, 1\\}^* \\} \\]\n\n\\( L \\) is not context free.\n\nTo decide whether an input \\( z \\in \\{0, 1, \\#\\}^* \\) is in \\( L \\) our Turing machine \\( M \\) operates as follows:\n\n- \\( M \\) attempts to match letter by letter the word to the left of \\( \\# \\) (call the word \\( u \\)) and the word to the right of \\( \\# \\) (call the word \\( v \\)).\n- When a letter in \\( u \\) matches a letter in \\( v \\) at the corresponding position, both letters are erased using a special letter \\( x \\).\n- When all the letters of \\( u \\) and \\( v \\) have been matched, \\( M \\) accepts.\nComponents of $M$\n\nAs a very informal, loose intuition, $M$ inside itself has the following components:\n\n- an automaton for $x^* \\# x^*$;\n- an automaton for $x^* 0 \\{0, 1\\}^* \\# x^* 0 \\{0, 1\\}^*$; and\n- an automaton for $x^* 1 \\{0, 1\\}^* \\# x^* 1 \\{0, 1\\}^*$;\n\nOr, to be more detailed and to be correct (always a nice thing) in phrasing this, $M$ will have the programming that is necessary to correctly handle *everything* it might face, including these three situations, which are central ones underpinning the language we are trying to handle (namely, to decide).\n\nThe last two automata will replace the letter immediately after each run of $x$ with an $x$ if the two letters match.\nMethod for Matching\n\nThe tape contents are always of the form $x^*\\{0, 1\\}^* \\#x^*\\{0, 1\\}^*$, where the number of $x$'s on the left is equal to the number of $x$'s on the right.\nAction in the Very First Step\n\n• If the symbol being scanned is $\\sqcup$, then immediately reject $z$ because $z = \\epsilon$.\n\n• Otherwise, enter the loop.\nMain Loop\n\n• (Case 1) If the letter at the current head position is a #, then:\n • scan to the right until a letter other than x is found, and then\n • accept if that non-x is ⊔; reject otherwise.\n**Method for Matching**\n\n- **(Case 2)** If the letter at the current head location is a 0 or a 1, then:\n - memorize the letter, say \\( c \\), and write an \\( x \\),\n - scan to the right until a \\( \\# \\) is found,\n - scan to the right until a non-\\( x \\) is found, and then\n - if that non-\\( x \\) is not a \\( c \\), then reject,\n - replace the non-\\( x \\) with an \\( x \\),\n - scan to the left until a \\( \\# \\) is found,\n - scan to the left until an \\( x \\) is found,\n - move to the right thereby locating the head to the very first non-\\( x \\).\nExample $\\{w#w \\mid w \\in \\{0, 1\\}^*\\}$\nThe Main Loop\n\nFirst non-X\nThe Main Loop\n\n0 memorized\nThe Main Loop\n\n0 memorized\nThe Main Loop\n\n0 memorized\nThe Main Loop\n\n0 memorized and # found\nThe Main Loop\n\n0 memorized and # found\nThe Main Loop\n\nX X 1 0 # X 0 1 0\n\n0 memorized\n# found\nand\n0 found\nThe Main Loop\n\nmatched\nThe Main Loop\n\nX X 1 0 # X X 1 0\n\nmatched\n# found\nThe Main Loop\n\n\\[\n\\begin{array}{cccccc}\nX & X & 1 & 0 & \\# & X & X & 1 & 0 \\\\\n\\end{array}\n\\]\n\nmatched\n\n# found\nThe Main Loop\n\n\\[\n\\begin{array}{cccccc}\nX & X & 1 & 0 & \\# & X & X & 1 & 0\n\\end{array}\n\\]\n\nmatched\n# found\nThe Main Loop\n\n\\[\n\\begin{array}{cccccc}\nX & X & 1 & 0 & \\# & X & X & 1 & 0 \\\\\n\\end{array}\n\\]\n\nmatched\n\\# found\nX found\nThe Main Loop\n\n```\nX X 1 0 # X X 1 0\n```\n\nmatched\n# found\nX found\nStart of new round\nExample 2: \\( \\{w\\#w\\#w \\mid w \\in \\{0, 1\\}^*\\} \\)\n\n- Instead of \\( x \\), use special symbols \\( x_0 \\) and \\( x_1 \\) used for crossing out a 0 and a 1, respectively.\n- Execute the algorithm for the previous example with these substitutions and treating the second \\( \\# \\) as \\( \\Box \\).\n- The algorithm halts in the accept state if and only if the input is in the form \\( w\\#w\\#y \\) for some \\( w, y \\in \\{0, 1\\}^* \\).\n- If accept, move on to the next stage.\nExample 2: \\( \\{w#w#w \\mid w \\in \\{0, 1\\}^*\\} \\)\n\n- Move the head to the symbol immediately to the right of the first \\#.\n- Execute the algorithm for the previous example by treating \\( x_0 \\) as 0 and \\( x_1 \\) as 1.\n- Accept if and only if this simulation accepts.\nA **configuration** of a Turing machine is the setting of its tape, head, and state.\n\nIf the tape contents are $a_1, \\ldots, a_m, \\square, \\ldots$, the head is located on the $k$th square, and the state is $q$, then write\n\n$$a_1 \\ldots a_{k-1}qa_k \\ldots a_m$$\n\nto represent the configuration as a word. Note that $Q$ is treated as an alphabet. Of the infinite stretch of $\\square$’s that form a right suffix of the tape, we leave out of the configuration any that happen to fall to the right of the head position (and optionally if one of that infinite right-suffix of blanks is under the tape head it can also be omitted, since $uq_i$ should and will be treated as being in fact $uq_i\\square$). Thus a configuration is a word in $\\Gamma^*Q\\Gamma^*$. \nThe configuration is $abq_1abc$.\n\nThe configuration is $aq_2bbbc$. \nConfigurations (cont’d)\n\nThe action of a TM can be viewed as rewriting of the configuration.\n\nA configuration $C_1$ **yields** $C_2$ if the Turing machine can go from $C_1$ to $C_2$ in a single step. (Recall that $\\hat{u}q_i$ is treated as equivalent to $\\hat{u}q_i\\sqcup$; for this case, the rules below regard the latter.)\n\n- $uaq_ibv$ yields $uq_jacv$ if $\\delta(q_i, b) = (q_j, c, L)$.\n- $q_ibv$ yields $q_jcv$ if $\\delta(q_i, b) = (q_j, c, L)$ (the set cannot move to the left).\n- $uq_ibv$ yields $ucq_jv'$ if $\\delta(q_i, b) = (q_j, c, R)$. Here $v' = v$ if $v \\neq \\epsilon$ and $v' = \\sqcup$ if $v = \\epsilon$. \nSpecial Configurations\n\nAn accepting configuration (A rejecting configuration) is one in which the state is $q_{\\text{accept}}$ ($q_{\\text{reject}}$).\n\nBoth accepting configuration and rejecting configuration are halting configurations.\nChapter 3, Part 2\n\nVariants of Turing Machines\nA multitape Turing machine is a Turing machine with additional tapes with each tape is accessible individually, with the input on the first tape, and with the others blank at the beginning.\n\nFor a $k$-tape Turing machine, the transition $\\delta$ is a mapping from $Q \\times \\Gamma^k$ to $Q \\times \\Gamma^k \\times \\{L, R\\}^k$. \nNondeterministic TMs\n\nA **nondeterministic Turing machine** is one in which the transition is mapping to the power set of \\( Q \\times \\Gamma \\times \\{L, R\\} \\).\n\nA nondeterministic Turing machine **accepts** an input if it enters an accepting state **for some computation path**.\nTheorem. Every multitape Turing machine has an equivalent single-tape Turing machine.\nTheorem. Every multitape Turing machine has an equivalent single-tape Turing machine.\n\nProof From a $k$-tape TM $M$ build a single-tape simulator $S$. \nEquivalence Between Single-tape TMs and Multitape TMs\n\nTheorem. Every multitape Turing machine has an equivalent single-tape Turing machine.\n\nProof From a \\( k \\)-tape TM \\( M \\) build a single-tape simulator \\( S \\).\n\nThe main idea is to use the tape available to represent\n\n- the contents of the tape squares that the head has ever visited for each tape, including the entire squares that initially hold the input,\n- and the current head position for each tape.\n\nCreate such a representation for each tape and connect them with a delimiter in between, at the beginning, and at the end.\nTape Encoding\n\nFor each $a \\in \\Gamma$, let $\\tilde{a}$ be a new symbol to signify that a head is located on the symbol.\n\n- The input tape $w_1 \\cdots w_n \\sqcup \\cdots$ with the head scanning the first symbol (this occurs at the beginning)\n\n$$\\tilde{w}_1w_2\\cdots w_n.$$\nTape Encoding\n\n- If a tape holds $a_1 \\cdots a_s \\sqcup \\cdots$ and the farthest position the head has traveled is $t > r$.\n - If the head position is $r < s$, then its representation is:\n\n$$a_1 \\cdots a_{r-1} \\tilde{\\sim}_s a_r \\cdots a_s \\sqcup \\cdots \\sqcup_{t-s}.$$ \n\n- If the head position is $r > s$, then its representation is:\n\n$$a_1 \\cdots a_s \\sqcup \\cdots \\tilde{\\sim}_{r-s-1} \\cdots \\sqcup \\cdots \\sqcup_{t-r}.$$ \n\nThe encoding never decreases in length.\nDelimiter\n\nUse a new symbol $\\#$ as a delimiter.\n\nOn input $w = w_1 \\cdots w_n$, the initial form of encoding is:\n\n$$\n\\#\\tilde{w}_1 w_2 \\cdots w_n \\#\\tilde{\\emptyset} \\#\\tilde{\\emptyset} \\# \\cdots \\#\\tilde{\\emptyset}\n$$\nMemorize $M$’s state using a state.\n\n1. Construct the initial form.\n\n2. Repeat the following:\n (a) If $M$ has accepted or rejected, accept or reject accordingly.\n (b) Otherwise, scan the tape in a direction and record, using the state, the symbols being scanned by the heads of $M$.\n (c) **Determine the next move** of $M$.\n (d) **Modify the encoding accordingly.** Insert symbols if necessary.\n (e) **Change the state accordingly.**\nIdentification of Symbols Scanned\n\nIn the case when the tape is scanned from right to left, use the following states.\n\n1. $(p_{\\text{scan}}, q, a_1, \\ldots, a_k), a_1, \\ldots, a_k \\in \\Gamma$: This means that the current state is $q$ and the symbols being scanned are $a_1, \\ldots, a_k$.\n\n2. $(p_{\\text{scan}}, q, ?, \\ldots, ?, a_{r+1}, \\ldots, a_k), a_{r+1}, \\ldots, a_k \\in \\Gamma$: This means that for the first $r$ tapes the symbols being scanned are yet to be identified but for the others the symbols have been identified to be $a_{r+1}, \\ldots, a_k$. \n\nIdentification of Symbols Scanned\n\nIn the case when the tape is scanned from right to left, use the following states.\n\n1. \\((p_{\\text{scan}}, q, a_1, \\ldots, a_k), a_1, \\ldots, a_k \\in \\Gamma\\): This means that the current state is \\(q\\) and the symbols being scanned are \\((p_{\\text{scan}}, q, ?, \\ldots, ?, a_{r+1}, \\ldots, a_k), a_{r+1}, \\ldots, a_k \\in \\Gamma\\): This means that for the first \\(r\\) tapes the symbols being scanned are yet to be identified but for the others the symbols have been identified to be \\(a_{r+1}, \\ldots, a_k\\).\n\nStart scanning from the end in state \\((p_{\\text{scan}}, q, ?, \\ldots, ?)\\).\n\nEach time a symbol of the form \\(\\hat{X}\\) is encountered, replace the rightmost ? with that \\(X\\).\n\nWhen all ?’s are gone, \\(S\\) knows the action of \\(M\\).\n\nIf forward motion is used, the symbols are from left to right.\nTape Modification\n\nThis step consists of\n\n• rewriting the symbol on the current head position and\n• rewriting the symbols around the current head position to move the head to the left or to the right.\nTape Modification Rules\n\n- If the current contents are $\\cdots a\\tilde{b}\\cdots$, $a \\neq \\#$, $b$ is to be replaced by $b'$, and the head moves to the left, then replace the two symbols by $\\tilde{a}b'$.\n\n- If the current contents are $\\cdots \\#\\tilde{b}\\cdots$, $b$ is to be replaced by $b'$, and the head moves to the left, then replace the two symbols by $\\#\\tilde{b}'$.\n\n- If the current contents are $\\cdots \\tilde{b}a\\cdots$, $a \\neq \\#$, $b$ is to be replaced by $b'$, and the head moves to the right, then replace the two symbols by $b'\\tilde{a}$.\nTape Modification Rules (cont’d)\n\n• If the current contents are \\( \\cdots \\tilde{b}\\# \\cdots \\), \\( b \\) is to be replaced by \\( b' \\), and the head moves to the right, then replace the \\( \\tilde{b}\\# \\) by \\( b'\\tilde{\\square}\\# \\).\n\nThis triggers insertion:\n\n• Use a state to remember the symbol to be inserted.\n\n• Start by memorizing the very first insertion, \\( \\tilde{\\square} \\), and then move to the right.\n\n• While scanning to the right, swap the symbol to be inserted and the symbol stored in the tape cell.\n\n• Keep scanning until the \\( \\square \\) after the very last symbol of the encoding.\nInsertion\n\n\\[\n\\begin{array}{cccccc}\n\\# & X & Y & Z & U & \\# \\\\\n\\# & V & A & B & C & \\#\n\\end{array}\n\\]\n\nChange Y to \\( Y'D \\)\nInsertion\n\nMust Insert D Here\nInsertion\n\n\\[ \\# \\ X \\ Y' \\ D \\ U \\ # \\ V \\ A \\ B \\ C \\ # \\ \\square \\ \\square \\ \\square \\ \\square \\ \\square \\]\n\nMust Insert Z Here\n**Insertion**\n\nMust Insert U Here\nInsertion\n\n\\[ \\text{Must Insert # Here} \\]\nInsertion\n\nMust Insert V\nHere\nInsertion\n\n# X Y' D Z U # V B C # [ ] [ ] [ ] [ ]\n\nMust Insert A Here\nInsertion\n\nMust Insert B Here\nInsertion\n\nMust Insert C Here\nInsertion\n\nMust Insert # Here\n\n# X Y' D Z U # V A B C | | | |\nInsertion\n\n# X Y'D Z U # V A B C # □ □ □ □\n\nDone\nEquivalence Between NTMs and TMs\nEquivalence Between NTMs and TMs\n\n**Theorem.** Every nondeterministic Turing machine has an equivalent deterministic Turing machine.\nTheorem. Every nondeterministic Turing machine has an equivalent deterministic Turing machine.\n\nProof We may assume that $N$ is a single-tape machine — we can use the same proof as before.\nEquivalence Between NTMs and TMs\n\nTheorem. Every nondeterministic Turing machine has an equivalent deterministic Turing machine.\n\nProof We may assume that $N$ is a single-tape machine — we can use the same proof as before.\n\nWe will construct a three-tape simulator $D$ of $N$. \nConstruction\n\nLet \\( C \\) be a constant such that each transition has at most \\( C \\) possible values. Let \\( \\Theta = \\{a_1, a_2, \\ldots, a_C\\} \\).\n\nUse a word \\( p \\in \\Theta^* \\) to encode a nondeterministic path, where for all \\( i \\geq 1 \\) and \\( j, 1 \\leq j \\leq b \\), if the \\( i \\)-th symbol of \\( p \\) is \\( a_j \\), then it specifies at step \\( i \\), \\( M \\) must choose the \\( j \\)-th possibility from all possible moves available at that point (if such one exists).\n\nThe word \\( p \\) over \\( \\Theta \\) is a valid computation path of \\( N \\) on input \\( w \\) if \\( N \\) on \\( w \\) halts according to the choices written on \\( p \\).\nThree-tape Simulation\n\nUse Tape 1 to store the input, Tape 2 to simulate the tape of $N$, and Tape 3 to keep an encoding of a computation path.\n\nDefine the lexicographic order of paths:\n\n$u_1 \\cdots u_s < v_1 \\cdots v_t \\in \\Theta^*$ if and only if either\n\n- $s < t$ or\n- $s = t$ and there exists some $k$, $1 \\leq k \\leq s$, such that $u_1 = v_1, \\ldots, u_{k-1} = v_{k-1}$, and $u_k < v_k$.\n\nHere $u_k < v_k$ is evaluated according to a fixed ordering of letters in $\\Theta$. \nAn Algorithm for $N$\n\nOn input $w$, write the word $\\#a_1$ on Tape 3, then repeat:\n\n1. **Copy the input onto Tape 2.**\n2. **Try to simulate $N$ on $w$ using the word in Tape 3 as the path.** If successful and if $N$ has accepted, then accept and halt.\n3. **Modify the path to the next smallest path by incrementing it.**\n4. **Erase Tape 2.**\nSome Additional Results\n\nCorollary. A language is Turing-recognizable if and only if it is recognized by a multitape TM.\n\nCorollary. A language is Turing-recognizable if and only if it is recognized by an NTM.\nWeaker Models: Two-Stack Machines\n\nTheorem. A language is Turing-recognizable if and only if it is recognized by a “two stack” machine (which is a machine that is TM-like except the input is read-only on its own tape, and instead of a tape the machine controls two stacks).\n\nCan you see how to prove this?\nWeaker Models: How Weak Can We Go?\n\nHow weak can we push things? Well, for example, we have:\n\n**Theorem.** A language is Turing-recognizable if and only if it is recognized (in Sipser’s model for how the left end of the tape is handled) by a “three pebble machine” (the machine has three identical pebbles, that start on the left end of a Sipser-like one-way-infinite work tape and it can read whether on its current cell there are zero or one or two or three pebbles and it can lift and move a pebble one cell at a time, and the input is on a separate read-only input tape).\n\nProving this is way hard.\nWeaker Models: How Weak Can We Go?\n\n**Theorem.** A language is Turing-recognizable if and only if it is recognized (in Sipser’s model for how the left end of the tape is handled) by a “three pebble machine.”\n\nAs mentioned last slide, proving this is way hard. We have to see that three pebbles can in the Sipser model simulate “two nonnegative integer counters.” And that two counters can simulate four counters. And that four counters can simulate an arbitrary TM. Each of those steps takes serious proving, and we won’t cover them, except you probably can see right now how to simulate two counters with three pebbles in the Sipser model. (I mention in passing that if the only actions we need to perform on our counters are increment, test-for-zero, and proper-decrement, we can even do that in the Sipser-type model with two pebbles, being very careful about the left end of the tape. Do you see how?)\nEnumerators\n\nAn enumerator of a language $A$ is a TM with a special output tape such that the machines write on the output tape all the members of $A$ with a special symbol $#$ as a delimiter (put at the end of each string). Note: The output-tape head can only either write-a-character-and-move-right or stay-in-place.\n\nWhat we mean by this is that it must have the property that each string it prints is in the set, and for each string in the set it holds that that string will eventually be printed. For example, an enumerator for the set $0^*$ might, after a certain number of steps, have this on its output tape (and it would eventually have to catch the ones currently skipped):\n\n$0##00000#0#0#0#0#0#000###000#$\n\n(An enumerator for $\\{\\epsilon\\}$ might print for example $#$ or ##. An enumerator for $\\emptyset$ ideally should just leave its output tape blank.)\nEnumerators\n\nAn **enumerator** of a language $A$ is a TM with a special output tape such that the machines write on the output tape all the members of $A$ with a special symbol $#$ as a delimiter.\n\n**Theorem.** A language is Turing-recognizable if and only if it has an enumerator.\nEnumerators\n\nAn **enumerator** of a language $A$ is a TM with a special **output tape** such that the machines write on the output tape all the members of $A$ with a special symbol $#$ as a delimiter.\n\n**Theorem.** A language is Turing-recognizable if and only if it has an enumerator.\n\n**Proof** The “if” part: Simulate the enumerator, and accept when the input word is produced by the enumerator.\n\nThe “only if” part: Simulate a recognizer $M$. For $i = 1, 2, \\ldots$, for each $w$ coming at or before position $i$ within the shortlex (aka string; CS theory people other than Sipser typically call this lexicographical order but, sigh, he saves that term for the dictionary order) order on $\\Sigma^*$, simulate $M$ on $w$ for $i$ steps and output $w$ if $M$ accepts $w$ within $i$ steps.\nEnumerators\n\nAn **enumerator** of a language $A$ is a TM with a special **output tape** such that the machines write on the output tape all the members of $A$ with a special symbol $\\#$ as a delimiter.\n\n**Theorem.** A language is Turing-decidable if and only if it has an enumerator that enumerates the strings in increasing order (within the shortlex ordering).\n\nCan you see the proof of each direction? Be careful—there is a shocking twist in proving the “if” direction. (Hint: Are there two quite different cases there?)\nEnumerators Applied\n\nAn **enumerator** of a language \\( A \\) is a TM with a special **output tape** such that the machines write on the output tape all the members of \\( A \\) with a special symbol \\( \\# \\) as a delimiter.\n\n**Theorem.** A language \\( L \\) is Turing-decidable if and only if both \\( L \\) and \\( \\overline{L} \\) are Turing-recognizable.\n\nCan you see the proof of each direction?\n\nNote: The complexity analogue of this result would be \\( \\text{NP} \\cap \\text{coNP} = \\text{P} \\)—but that complexity analogue most definitely is an open issue!\nDescription of Objects\n\nWe assume that there is a systematic way of describing computing devices as well as their inputs. For example, a Turing machine $M$ can be described by putting down in symbols states, symbols, and transition. We fix such an encoding system. We will use $\\langle M \\rangle$ to represent the encoding of $M$. \nDescription of Multiple Objects\n\nTo encode multiple objects in a sequence, we simply concatenate the encodings of the objects in order with a special delimiter in between.\nDescription of Multiple Objects\n\nTo encode multiple objects in a sequence, we simply concatenate the encodings of the objects in order with a special delimiter in between.\n\nIf you’re a student, ignore the rest of this page.¹\n\n¹ Note just to myself: If I am going to cover the recursion theorem and use the Chapter-6-slides’ rather than Sipser’s version of its proof, then one has to add in this unnatural special requirement as to the interpretation of the coding: For Turing machines \\( M \\) and \\( N \\), \\( \\langle M \\rangle \\langle N \\rangle \\) (yes, that really is a concatenation with no special delimiter, sigh) is a representation of a Turing machine that executes \\( M \\)’s program first and if \\( M \\) accepts immediately jumps into \\( N \\)’s program.\nA Fun, Hard Challenge\n\nCan you write a Turing machine that on each input $i = 1, 2, 3, \\ldots$ outputs a Turing machine encoding, call it $\\langle \\sigma(i) \\rangle$, and halts, and those outputs are such that we have that the set $\\{L(\\sigma(1)), L(\\sigma(2)), L(\\sigma(3)), \\ldots\\}$ is the set of all decidable languages over the alphabet $\\{0, 1\\}$? Many people who know a lot might think it is impossible to do this. But it can be done (admittedly in an extremely evil, sneaky, unsatisfying way)!\n\nTo think about this, you might want to think about how to do it in C++ or Java!\n\nSuper-challenge: Can you remove the extremely evil, sneaky, unsatisfying trick? Or can you prove that it cannot possibly be removed!? (Hint: The latter holds, using a technique that will be central to us in Ch. 4, Pt. 2.)\nAnother (Your Lucky Day!) Fun, Hard Challenge\n\nCan you write a Turing machine that on each input $i = 1, 2, 3, ...$ outputs a Turing machine encoding, call it $\\langle \\sigma(i) \\rangle$, and halts, such that both of the following hold: (1) in the LIST of languages $L(\\sigma(1))$, $L(\\sigma(2))$, $L(\\sigma(3))$, ..., no three languages in a row in that list are all the same, and (2) the set \\{ $L(\\sigma(1))$, $L(\\sigma(2))$, $L(\\sigma(3))$, ... \\} is the set of all Turing-recognizable languages over the alphabet \\{0, 1\\}? What about if we change clause (1) to say no two languages in a row? (Hint: The answer is yes even for that, even though the “recursion theorem” would seem to prove that the answer is no—amaze your professors with this, as a CSC280 student once amazed me!)\nChapter 4, Part 1\n\nDecidability\nDecidable Problems About Regular Languages\n\nThe Acceptance Problem for DFA\n\nDefine $A_{\\text{DFA}}$ to be:\n\n$$\\{\\langle B, w \\rangle \\mid B \\text{ is a DFA that accepts input string } w \\}.$$ \n\nTheorem. $A_{\\text{DFA}}$ is decidable.\n\nProof A Turing machine can, given an input $x$, try to decode $x$ into a DFA $B$ and a string $w$. If the decoding is successful then it can test whether $B$ accepts $w$ by simulating $B$ on $w$. \n\n\\[ \\square \\]\nHow This Can Be Done\n\n- After checking the legitimacy of encoding, our Turing machine writes on its second tape the input $w$ (as an encoded form).\n- Our machine starts simulating $M$, using the second tape as the tape of $M$ by looking up information about $M$’s action in the first tape and using a tape symbol encoding scheme consistent with the input $x$.\n\nWhen $M$ terminates, our machine terminates accordingly.\nThe Acceptance Problem for NFA\n\nDefine $A_{\\text{NFA}}$ to be:\n\n$$\\{ \\langle B, w \\rangle \\mid B \\text{ is an NFA that accepts input string } w \\}.$$ \n\n**Theorem.** $A_{\\text{NFA}}$ is decidable.\n\n**Proof** Given an input $x$, try to decode $x$ into an NFA $B$ and a string $w$. If “successful” then:\n\n1. Convert $B$ to a DFA $C$.\n2. Run the machine for $A_{\\text{DFA}}$ on $\\langle C, w \\rangle$. If the machine accepts, then **accept**; otherwise **reject**.\nDefine $A_{\\text{REX}}$ to be:\n\n$$\\{\\langle R, w \\rangle \\mid R \\text{ is a regular expression that produces } w \\}.$$\n\n**Theorem.** $A_{\\text{REX}}$ is decidable.\n\n**Proof** Given an input $x$, try to decode $x$ into a regular expression $R$ and a string $w$. If “successful” then:\n\n1. Convert $R$ to a DFA $C$.\n2. Run the machine for $A_{\\text{DFA}}$ on $\\langle C, w \\rangle$. If the machine accepts, then **accept**; otherwise **reject**.\nDefine $E_{\\text{DFA}} = \\{ \\langle A \\rangle \\mid A \\text{ is a DFA that accepts no string} \\}$.\n\n**Theorem.** $E_{\\text{DFA}}$ is decidable.\n\n**Proof.** Given an input $x$, try to decode a DFA $A$ out of $x$. If “successful” then:\n\n1. **Mark the start state** of $A$.\n2. **Repeat until no new states are marked:**\n - Mark any unmarked state that has a transition from a marked state\n3. Accept if **no final state is marked**; reject otherwise.\nThe Equivalence Problem for DFA\n\nDefine $EQ_{DFA}$ to be:\n\\[ \\{ \\langle A, B \\rangle \\mid A \\text{ and } B \\text{ are DFA and accept the same language } \\}. \\]\n\n**Theorem.** $EQ_{DFA}$ is decidable.\n\n**Proof** Given a string $x$, try to decode $x$ into a pair of DFAs $A$ and $B$. If “successful” then construct a DFA $C$ that accepts the symmetric difference of $L(A)$ and $L(B)$,\n\\[ (L(A) \\cap L(B)) \\cup (\\overline{L(A)} \\cap \\overline{L(B)}), \\]\nand test the emptiness of $L(C)$.\nThe Acceptance Problem for CFG\n\nDefine $A_{\\text{CFG}} = \\{ \\langle G, w \\rangle \\mid G \\text{ is a CFG that generates } w \\}$.\n\n**Theorem.** $A_{\\text{CFG}}$ is decidable.\n\n**Proof** Given an input $x$, try to decode $x$ into a CFG $G$ and a string $w$. If “successful” then:\n\n2. List all derivations with $2n - 1$ steps, where $n = |w|$.\n3. If any of the listed derivations generate $w$, then accept; otherwise, reject.\nThe Acceptance Problem for CFG\n\nDefine $A_{CFG} = \\{ \\langle G, w \\rangle \\mid G \\text{ is a CFG that generates } w \\}$.\n\n**Theorem.** $A_{CFG}$ is decidable.\n\n**Proof** Given an input $x$, try to decode $x$ into a CFG $G$ and a string $w$. If “successful” then:\n\n2. List all derivations with $2n - 1$ steps, where $n = |w|$.\n3. If any of the listed derivations generate $w$, then accept; otherwise, reject.\n\nWarning: The above proof is so terse that it contains an error. Can you see that and fix that? Hint: Think “boundary.” (See the next slide for the answer.)\nThe Acceptance Problem for CFG\n\nDefine \\( A_{\\text{CFG}} = \\{ \\langle G, w \\rangle \\mid G \\text{ is a CFG that generates } w \\} \\).\n\n**Theorem.** \\( A_{\\text{CFG}} \\) is decidable.\n\n**Proof** Given an input \\( x \\), try to decode \\( x \\) into a CFG \\( G \\) and a string \\( w \\). If “successful” then:\n\n1. Convert \\( G \\) to an equivalent Chomsky normal form grammar \\( G' \\).\n2. List all derivations with \\( 2n - 1 \\) steps, where \\( n = |w| \\).\n3. If any of the listed derivations generate \\( w \\), then accept; otherwise, reject.\n\nWarning: The above proof is so terse that it contains an error. Can you see that and fix that? Hint: Think “boundary.”\n\nAnswer: The proof above mishandles the empty string. For that, we need to check all length 1 derivations, not all length -1 derivations. (Don’t worry; the proof in SIP is fine!)\nThe Emptiness Problem for CFG\n\nDefine $E_{\\text{CFG}} = \\{ \\langle G \\rangle \\mid G \\text{ is a CFG such that } L(G) = \\emptyset \\}$.\n\n**Theorem.** $E_{\\text{CFG}}$ is decidable.\n\n**Proof** Given $x$, first try to decode a grammar $G$ out of it. If “pass” then test the ability of generating terminal strings:\n\n1. **Mark all the terminals.**\n2. Repeat the following until no new symbols are marked:\n - Mark any variables $A$ such that $G$ has a production $A \\rightarrow w$ such that all symbols in $w$ are *already* marked.\n3. **Accept** if the start symbol is marked; **reject** otherwise.\nTheorem. Every context-free language is decidable.\n\nSimulation of a PDA may not halt.\n\nProof Use the machine $M$ for $A_{\\text{CFG}}$. Let $G$ be a fixed CFG. The machine for $L(G)$, on input $w$,\n\n1. run $\\langle G, w \\rangle$ on $M$, and\n2. accepts if $M$ accepts and rejects otherwise.\nThe Halting Problem\nThe Halting Problem\n\nDefine $A_{TM} = \\{\\langle M, w \\rangle | M \\text{ is a Turing machine and accepts } w \\}$. \n\nTheorem. $A_{TM}$ is not decidable.\nThe Halting Problem\n\nDefine $A_{TM} = \\{ \\langle M, w \\rangle \\mid M \\text{ is a Turing machine and accepts } w \\}$. \n\n**Theorem.** $A_{TM}$ is not decidable.\n\nFrom this theorem we obtain:\n\n**Corollary.** $\\overline{A_{TM}}$ is not Turing-recognizable, and thus, not decidable.\nThe Halting Problem\n\nDefine $A_{TM} = \\{ \\langle M, w \\rangle \\mid M \\text{ is a Turing machine and accepts } w \\}$. \n\n**Theorem.** $A_{TM}$ is not decidable.\n\nFrom this theorem we obtain:\n\n**Corollary.** $\\overline{A_{TM}}$ is not Turing-recognizable, and thus, not decidable.\n\nFor this corollary we need the following fact.\n\n**Fact.** A language $L$ is decidable if and only if both $L$ and $\\overline{L}$ are Turing-recognizable.\n\n**Proof of Corollary** $A_{TM}$ is clearly Turing-recognizable. If $\\overline{A_{TM}}$ were also Turing-recognizable, then by the Fact $A_{TM}$ would be decidable; but the theorem says that $A_{TM}$ is not decidable.\nProof of Fact \\[\n\\Rightarrow \\] Let \\( L \\) be decidable and let \\( M \\) be a Turing machine that decides \\( L \\). By swapping \\( q_{\\text{accept}} \\) and \\( q_{\\text{reject}} \\) of \\( M \\) we get a Turing machine \\( M' \\) that decides \\( \\overline{L} \\). So both \\( L \\) and \\( \\overline{L} \\) are Turing-decidable, and thus, Turing-recognizable.\nProof of Fact (cont’d)\n\n[⇐] Let $L$ and $\\overline{L}$ be recognized by TMs $M_1$ and $M_2$, respectively. Define a two-tape machine $M$ that, on input $x$, does the following:\n\n1. $M$ copies $x$ onto Tape 2.\n2. $M$ repeats the following until either $M_1$ or $M_2$ accepts:\n - $M$ simulates one (more) step of $M_1$ on Tape 1 then one (more) step of $M_2$ on Tape 2.\n3. $M$ accepts $x$ if either $M_1$ accepts $x$ or $M_2$ rejects $x$; $M$ rejects $x$ if either $M_2$ accepts $x$ or $M_1$ rejects $x$.\n\nThen $M$ decides $L$ because for every $x$, at least one of the two machines halts on input $x$. □\n\nFact\nDiagonalization\n\n(For the rest of these Chapter 4, Part 2 slides, we’ll write \\( \\mathcal{N} \\) but will actually mean \\( \\mathcal{N}^+ \\), i.e., \\( \\{1, 2, 3, \\ldots\\} \\); SIP actually himself always uses \\( \\mathcal{N} \\) to mean \\( \\mathcal{N}^+ \\).)\n\nA set \\( S \\) is **countable** if either it is finite or it has the same size as \\( \\mathcal{N} \\); i.e., there is a **one-to-one, onto correspondence** between \\( S \\) and \\( \\mathcal{N} \\) (i.e., there is a **bijection** from \\( S \\) to \\( \\mathcal{N} \\)).\nSimple Facts About the Countable\n\nLet $\\mathbb{Q}$ be the set of all positive rational numbers and let $\\mathbb{R}$ be the set of all positive real numbers. (That “positive” is not standard, but this is just a local definition for this section of the slides. You can imagine a “$+$” superscript if you prefer.)\n\n**Fact.** $\\mathbb{Q}$ is countable while $\\mathbb{R}$ is not.\n**Proving the Fact**\n\n**Proof** Each member of $Q$ is expressed as a fraction $\\frac{m}{n}$ such that $m, n \\in \\mathbb{N}$ and $\\gcd(m, n) = 1$.\n\nSo we have only to come up with a bijection from $\\mathbb{N}$ to the set $\\left\\{\\frac{m}{n} \\mid m, n \\geq 1 \\land \\gcd(m, n) = 1\\right\\}$. \n\\( \\mathbb{Q} \\) is countable\n\nWe will visit all the grid points in the first quadrant of the \\( xy \\)-plane.\n\nFor \\( p = 2, 3, 4, \\ldots \\), visit the points \\((x, y)\\) on the line \\( x + y = p \\)\n\n\\[\n(1, p - 1), (2, p - 2), \\ldots, (p - 1, 1)\n\\]\n\nand collect only those points at which \\( x \\) and \\( y \\) are relatively prime to each other and both are at least one.\nThe numbers show the visiting order (not the bijection, e.g., the number 5 is \\((2, 2)\\) and since 2 and 2 are not relatively prime this point is skipped in the bijection; so in the bijection, 1 maps to \\((1, 1)\\) and 5 maps to \\((3, 1)\\), which is the point numbered 6 above).\n\\( \\mathcal{R} \\) is not countable\n\nAssume, by way of contradiction, that \\( \\mathcal{R} \\) is countable. Then the real numbers can be enumerated as \\( r_1, r_2, \\ldots \\) (where no \\( r_i \\) ends with an infinite string of adjacent 9’s).\n\nDefine \\( x \\) to be the number between 0 and 1 defined as follows:\n\n\\(^{(*)}\\) For each \\( i \\in \\mathbb{N} \\), the \\( i \\)th digit of \\( x \\) after the decimal point is that of \\( r_i \\) plus 1 (modulo 10).\n\nFor example, if \\( r_1 = 3.1\\overline{4159}, r_2 = 2.2\\overline{3606}, r_3 = 1.73\\overline{205}, \\ldots \\), then \\( x = .243\\ldots \\),\n\\( \\mathcal{R} \\) is not countable\n\nAssume, by way of contradiction, that \\( \\mathcal{R} \\) is countable. Then the real numbers can be enumerated as \\( r_1, r_2, \\ldots \\) (where no \\( r_i \\) ends with an infinite string of adjacent 9’s).\n\nDefine \\( x \\) to be the number between 0 and 1 defined as follows:\n\n\\[\n(*) \\text{ For each } i \\in \\mathbb{N}, \\text{ the } i\\text{th digit of } x \\text{ after the decimal point is that of } r_i \\text{ plus 1 (modulo 10).}\n\\]\n\nFor example, if \\( r_1 = 3.14159, r_2 = 2.23606, r_3 = 1.73205, \\ldots \\), then \\( x = .243\\ldots \\),\n\nThis \\( x \\) is real. By assumption there must exist a \\( k \\) such that \\( r_k \\) is \\( x \\). However, by definition, the \\( k \\)-th digit of \\( r_k \\) is different from that of \\( x \\), a contradiction. (WARNING: That claim isn’t quite true, as we’ll discuss on the next slide! Do you see what the potential problem is here?) Thus, \\( \\mathcal{R} \\) is not countable.\n**R is not countable**\n\nAssume, by way of contradiction, that $\\mathcal{R}$ is countable. Then the real numbers can be enumerated as $r_1, r_2, \\ldots$ (where no $r_i$ ends with an infinite string of adjacent 9's).\n\nDefine $x$ to be the number between 0 and 1 defined as follows:\n\n(*) For each $i \\in \\mathcal{N}$, the $i$th digit of $x$ after the decimal point is that of $r_i$ plus 1 (modulo 10).\n\nFor example, if $r_1 = 3.\\overline{14159}$, $r_2 = 2.\\overline{23606}$, $r_3 = 1.\\overline{73205}$, \\ldots, then $x = .243\\ldots$.\n\nThis $x$ is real. By assumption there must exist a $k$ such that $r_k$ is $x$. However, by definition, the $k$-th digit of $r_k$ is different from that of $x$, a contradiction.\n\nHold on! What if $x$ ends with an infinite string of adjacent 9's? Then it MIGHT equal some $r_k$ even though it differs from that $r_k$ in the $k$-th digit. Here is a clever patch (suggested by a previous CSC280 student, Doug Miller): Infinitely many $r_i$'s have no 8's anywhere, and so $x$ cannot end with an infinite string of 9's! Here is an alternate patch (suggested by a previous CSC280 student, Chris Frederickson): Alter line (*) above to now change 0 to 1 and “nonzero” to 0; this ensures $x$ won’t have any 9’s! (NOTE: The proof found in SIP is clean; you don’t have to worry about that proof.)\n\nThus, $\\mathcal{R}$ is not countable.\nCorollary. There is a language that is not Turing-recognizable.\nCorollary. There is a language that is not Turing-recognizable.\n\nProof Consider all Turing machines whose input alphabet is \\( \\{0\\} \\).\n\nSince each Turing machine can be encoded as a word of finite length, this set of Turing machines is countable.\n\nLet \\( M_1, M_2, \\ldots \\) be the enumeration of all Turing machines in this set.\nAn Immediate Application of Diagonalization\n\nCorollary. There is a language that is not Turing-recognizable.\n\nProof Consider all Turing machines whose input alphabet is \\{0\\}.\n\nSince each Turing machine can be encoded as a word of finite length, this set of Turing machines is countable.\n\nLet \\( M_1, M_2, \\ldots \\) be the enumeration of all Turing machines in this set.\n\nDefine \\( L = \\{0^i \\mid M_i \\text{ on input } 0^i \\text{ does not accept}\\} \\).\nDefine $L = \\{0^i \\mid M_i \\text{ on input } 0^i \\text{ does not accept }\\}$.\n\nThere is no machine $M_k$ that recognizes $L$. Why?\n\nIf there were such a $k$, then we have by definition of $L$\n\n$$0^k \\in L \\iff M_k \\text{ does not accept } 0^k.$$ \n\nThe latter condition is equivalent to $0^k \\not\\in L(M_k)$. But by the definition of $k$, $L(M_k) = L$ (!!), so $0^k \\not\\in L(M_k)$ is equivalent to $0^k \\not\\in L$. Thus, we have\n\n$$0^k \\in L \\iff 0^k \\not\\in L,$$\n\na contradiction.\nProof of Theorem \\((A_{TM} \\text{ is not decidable})\\)\n\nAssume that \\(A_{TM}\\) is decidable. Let \\(T\\) be a Turing machine that decides \\(A_{TM}\\). Define \\(D\\) to be a machine that, on input \\(w\\), does this:\n\n1. Check whether \\(w\\) is a legal encoding of some Turing machine, say \\(M\\). If not, immediately reject \\(w\\).\n2. Simulate \\(T\\) on \\(\\langle M, \\langle M \\rangle \\rangle\\).\n3. If \\(T\\) accepts, then reject; otherwise, accept.\n\nSince \\(T\\) decides \\(A_{TM}\\) by assumption, \\(T\\) always halts; thus by the above program, so does \\(D\\). For every Turing machine \\(M\\),\n\n\\[\nD \\text{ accepts } \\langle M \\rangle \\iff M \\text{ does not accept } \\langle M \\rangle\n\\]\n\nWith \\(M = D\\), we have\n\n\\[\nD \\text{ accepts } \\langle D \\rangle \\iff D \\text{ does not accept } \\langle D \\rangle.\n\\]\n\nThis is a contradiction.\nChapter 5, Part 1\n\nReducibility\nThe Halting Problem\n\nBased on undecidability of one language, $A$, undecidability of another language, $B$, can sometimes be shown.\nThe Halting Problem\n\nBased on undecidability of one language, $A$, undecidability of another language, $B$, can sometimes be shown.\n\nWe will use the concept of a reduction for this purpose.\n\nThis involves showing that one could build a Turing machine that decides $A$ assuming that there is a Turing machine for deciding $B$. \nAssumption About Coding\n\nThe set of all possible inputs to the machine we will build as well as that to the machine we assume to exist (that is, $\\Sigma^*$ of the input alphabet $\\Sigma$) may contain strings not encoding any meaningful objects.\n\nFor completeness our reduction has to handle such strings, but since the way we handle them is very simple (either accept all such strings or reject all such strings depending on how $A$ or $B$ is defined), we will simply ignore such strings.\nThe Halting Problem\n\n\\[ \\text{HALT}_{TM} = \\{ \\langle M, w \\rangle \\mid M \\text{ is a TM and halts on input } w \\} \\].\n\n**Theorem.** \\( \\text{HALT}_{TM} \\) is undecidable.\nThe Halting Problem\n\n\\[ \\text{HALT}_{\\text{TM}} = \\{ \\langle M, w \\rangle \\mid M \\text{ is a TM and halts on input } w \\} \\].\n\n**Theorem.** \\( \\text{HALT}_{\\text{TM}} \\) is undecidable.\n\n**Proof** (Proof 1: Contradiction-based) Assume that there is a Turing machine \\( R \\) that decides \\( \\text{HALT}_{\\text{TM}} \\).\n\nWe then would be able to construct a Turing machine \\( S \\) that decides \\( \\text{A}_{\\text{TM}} = \\{ \\langle M, w \\rangle \\mid M \\text{ is a Turing machine and accepts } w \\} \\), which is, however, known to be undecidable.\nLogic Behind the Construction\n\n• To handle $A_{TM}$, we want to know whether a Turing machine $M$ accepts on input $w$.\n\n• A natural direct approach to finding an answer to that will be to simulate $M$ on $w$, but the simulation may not stop.\n 1. $M$ accepts $w \\rightarrow \\text{\"yes\"} \\ldots \\text{ACCEPT}$\n 2. $M$ rejects $w \\rightarrow \\text{\"no\"} \\ldots \\text{REJECT}$\n 3. $M$ on $w$ never stops $\\rightarrow \\text{\"no\"} \\ldots \\text{PROBLEM}$\n\n• If there is a TM machine that tells whether on a given input we will fall into that horrible, evil Case 3, we can use that TM to avoid the problem.\nOur Turing Machine $S$ for $A_{TM}$\n\nLet the input $x = \\langle M, w \\rangle$.\n\n1. Simulate $R$ on $x$.\n \n **Note:** $R$ decides $HALT_{TM}$ and so $R$ on $x$ halts.\n\n2. If $R$ rejects $x$, reject $x$.\n \n **Note:** This corresponds to Case 3 - the problematic case.\n\n3. If $R$ accepts $x$, immersively simulate $M$ on $w$ (and so we will accept if $M$ accepts $w$ and will reject otherwise; keep in mind that $R$ never runs forever so that is not on the table here).\n \n **Note:** Here we are distinguishing between Case 1 and Case 2.\n\nThis machine would correctly decide $A_{TM}$. So a contradiction has been reached to our earlier result that $A_{TM}$ is not decidable.\nAlternative Approach (Proof 2: Slightly More Reduction-like in Flavor, though Not Really)\n\n• $R$ is a Turing machine that purportedly decides the halting problem.\n\n• Given a machine $M$ we can modify its code to create a new machine $M'$ such that $M'$ enters a nonaccepting infinite loop instead of rejecting. Then we have:\n 1. $M$ accepts $w$ ... $M'$ on $w$ accepts.\n 2. $M$ rejects $w$ ... $M'$ on $w$ does not halt.\n 3. $M$ on $w$ never stops ... $M'$ on $w$ does not halt.\n\n• Then $M$ on $w$ accepts if and only if $M'$ on $w$ halts.\nAlternative Approach (Proof 2: Slightly More Reduction-like in Flavor, though Not Really)\n\n1. From $M$ construct a new Turing $M'$ that simulates $M$ and instead of entering $q_{\\text{reject}}$, $M'$ enters an infinite loop.\n2. Simulate $R$ on $\\langle M', w \\rangle$.\n3. Accept if $R$ accepts and reject otherwise.\nIn constructions, we sometimes internally build a TM and speak about it. In doing so, we often describe it in high-level pseudocode. This raises (as a side effect of Sipser’s sort of kinky approach to Turing machine behavior) a question as to what the action is of the actual underlying TM being described, if the high-level code simply reaches its very, very end without having itself, or within a machine it was simulating, halted by rejecting or accepting. (Should we say the underlying TM loops since it neither accepted not rejected, even though the pseudocode seems itself to halt?? Yuck!)\n\nSipser is silent on this because he by hand just avoids having it happen in any of his constructions. (And that is a good thing, but we can’t make it a “syntactic” validity requirement, because doing so would make validity testing itself become undecidable!)\nA Convention About High-Level Descriptions—Part II\n\nOur convention will simply be to view hitting the very end of your code in a high-level pseudocode description to be, when translated into action TM behavior, (halting and) rejecting. You can view the program’s final “}” as, by this convention, being a “Reject;}”.\n\nSo for example, if we write in a proof/construction:\n\nLet $M'$ be the TM that on arbitrary input $y$ does:\n{If $y = \\epsilon$ then accept;}\n\nThen by our convention we’ll take that pseudocode as describing a TM $M'$ that on input $\\epsilon$ accepts (thus surely halts), and that on all other inputs rejects (and thus surely halts).\n\nBut nonetheless it is most elegant and clear to write only pseudocode that will simply never smash into its final “}”.\nThe Emptiness Problem\n\nDefine $E_{TM} = \\{ \\langle M \\rangle \\mid M \\text{ is a TM and } L(M) = \\emptyset \\}$.\n\n**Theorem.** $E_{TM}$ is undecidable.\nThe Emptiness Problem\n\nDefine $E_{\\text{TM}} = \\{\\langle M \\rangle \\mid M \\text{ is a TM and } L(M) = \\emptyset\\}$. \n\n**Theorem.** $E_{\\text{TM}}$ is undecidable.\n\n**Proof** Assume there is a TM $R$ that decides $E_{\\text{TM}}$. We’ll construct a TM $S$ that decides $A_{\\text{TM}}$. \nAlgorithm of $S$ for $A_{TM}$\n\n1. Input $x$ is $\\langle M, w \\rangle$ for some $M$ and $w$. \n **We want to know whether $M$ on $w$ accepts.**\n\n2. Construct a Turing machine $M_1$: \n $M_1$ erases its input $y$, reproduces $w$ on the input tape, and then enters an (immersive) simulation of $M$. That is, $M_1$ ultimately behaves as $M$ on input $w$, regardless of the input to $M_1$. We have:\n\n $$L(M_1) = \\begin{cases} \n \\Sigma^* & \\text{if } M \\text{ accepts } w \\\\\n \\emptyset & \\text{if } M \\text{ does not accept } w.\n \\end{cases}$$\n\n Also, we have $\\langle M_1 \\rangle \\in E_{TM}$ if and only if $L(M_1) = \\emptyset$. \n $R$ purportedly decides $E_{TM}$. \n\n3. Simulate $R$ on $\\langle M_1 \\rangle$. Accept if $R$ rejects and reject otherwise.\nTesting Whether a TM Accepts a Regular Language\n\n\\[ REGULAR_{TM} = \\{ \\langle M \\rangle \\mid M \\text{ is a TM and } L(M) \\text{ is regular} \\}. \\]\n\n**Theorem.** \\( REGULAR_{TM} \\) is undecidable.\nTesting Whether a TM Accepts a Regular Language\n\n\\[ \\text{REGULAR}_{TM} = \\{ \\langle M \\rangle \\mid M \\text{ is a TM and } L(M) \\text{ is regular} \\} \\].\n\n**Theorem.** \\( \\text{REGULAR}_{TM} \\) is undecidable.\n\n**Proof** Assume there is a TM \\( R \\) that decides \\( \\text{REGULAR}_{TM} \\). We’ll construct a TM \\( S \\) that decides \\( A_{TM} \\).\nTesting Whether a TM Accepts a Regular Language\n\nInput \\( x = \\langle M, w \\rangle \\).\n\n1. Let \\( \\Sigma \\) be the input alphabet of \\( M \\). If \\( \\Sigma \\) has only one symbol add another symbol.\n2. Choose two symbols, say \\( a \\) and \\( b \\), from \\( \\Sigma \\).\n3. Construct a machine \\( M_1 \\) that on input \\( y \\) behaves as follow:\n (a) If \\( y = a^n b^n \\) for some \\( n \\geq 0 \\), accept.\n (b) Otherwise, erase \\( y \\), reproduce \\( w \\), simulate \\( M \\) on \\( w \\).\n\n We have:\n\n \\[\n L(M_1) = \\begin{cases} \\Sigma^* & \\text{if } M \\text{ accepts } w \\\\ \\{a^n b^n \\mid n \\geq 0\\} & \\text{if } M \\text{ does not accept } w \\end{cases}\n \\]\n\n Also, \\( \\Sigma^* \\) is regular and \\( \\{a^n b^n \\mid n \\geq 0\\} \\) is nonregular.\n\n4. Simulate \\( R \\) on \\( \\langle M_1 \\rangle \\). Accept if \\( R \\) accepts and otherwise reject.\nDefine $EQ_{TM} = \\{\\langle M_1, M_2 \\rangle \\mid \\text{both } M_1 \\text{ and } M_2 \\text{ are TMs and } L(M_1) = L(M_2)\\}$.\n\n**Theorem.** $EQ_{TM}$ is undecidable.\nTesting Equivalence Between TMs\n\nDefine $EQ_{TM} = \\{ \\langle M_1, M_2 \\rangle \\mid \\text{both } M_1 \\text{ and } M_2 \\text{ are TMs and } L(M_1) = L(M_2) \\}$.\n\n**Theorem.** $EQ_{TM}$ is undecidable.\n\n**Proof** Assume there is a TM $R$ that decides $EQ_{TM}$. We’ll construct a TM $S$ that decides $A_{TM}$.\n\nBuild $M_1$ just as in the previous proof. In addition, construct a machine that accepts $\\Sigma^*$; call that machine $M_2$. Then we have\n\n$$L(M_1) = L(M_2) \\text{ if and only if } M \\text{ accepts } w.$$ \n\nWe simulate $R$ on $\\langle M_1, M_2 \\rangle$. Accept if $R$ accepts and reject otherwise.\nMapping Reducibility\n\n(This generally corresponds to Chapter 5.3 of SIP.)\nA function $f : \\Sigma^* \\rightarrow \\Sigma^*$ is **computable** if there exists a Turing machine $M$ such that for every $x \\in \\Sigma^*$, $M$ on $x$ halts with just $f(x)$ on its tape.\n\n**Example:** Let $\\Sigma$ be a fixed alphabet. Define $f : \\Sigma^* \\rightarrow \\Sigma^*$ as follows:\n\n- If $w = \\langle M \\rangle$ for some Turing machine, then $f(w) = \\langle M' \\rangle$ where $M'$ is $M$ with $q_{\\text{accept}}$ and $q_{\\text{reject}}$ swapped.\n\n- Otherwise, $f(w) = w$.\n\nThen $f$ is computable.\nMapping Reductions, a.k.a. Many-One Reductions\n\nA language $A \\subseteq \\Sigma^*$ is **mapping reducible** (or, equivalently, is (recursive) **many-one reducible**) to $B \\subseteq \\Sigma^*$ (often written as $A \\leq_m B$) if there exists a computable function $f : \\Sigma^* \\to \\Sigma^*$ such that for every $x \\in \\Sigma^*$, $x \\in A$ if and only if $f(x) \\in B$.\n\nNamely, the function $f$ maps members of $A$ to members of $B$ and nonmembers of $A$ to nonmembers of $B$. The function $f$ is said to be a reduction from $A$ to $B$.\n\nCan you draw a clear picture of what is up here?\n\nA particularly elegant way to do undecidability proofs is to note that if $A \\leq_m B$ and $A$ is not decidable, then $B$ is not decidable, and then to apply that. We then prove a set is undecidable by $\\leq_m$-reducing to it from some already-known-undecidable set!\nProperties About Mapping Reducibility\n\n**Theorem.** If $A \\leq_m B$ and $B$ is decidable then $A$ is decidable.\n\n**Proof** Let $A \\leq_m B$ be witnessed by a Turing machine $R$ that computes a mapping reduction $f$ from $A$ to $B$.\n\nSuppose $B$ is decided by a Turing machine $M$. Construct a new Turing machine $N$:\n\n1. On input $x$, simulate $R$ on $x$ to compute $f(x)$.\n2. **Simulate $M$ on $f(x)$**. Accept if $M$ accepts and reject if $M$ rejects.\n\nThen $N$ decides $A$. \n\n\\hfill \\square\nCorollary. If $A \\leq_m B$ and $A$ is undecidable then $B$ is undecidable.\n\nTheorem. If $A \\leq_m B$ and $B$ is Turing-recognizable then $A$ is Turing-recognizable.\n\nCorollary. If $A \\leq_m B$ and $A$ is not Turing-recognizable then $B$ is not Turing-recognizable.\n\nCan you see why each of these holds?\nRecall that $EQ_{TM} = \\{ \\langle M_1, M_2 \\rangle \\mid M_1 \\text{ and } M_2 \\text{ are Turing machines and } L(M_1) = L(M_2) \\}$.\n\n**Theorem.** $EQ_{TM}$ is neither Turing-recognizable nor co-Turing-recognizable.\nProof\n\nShow that $A_{TM}$ is mapping reducible to $EQ_{TM}$ as well as to $\\overline{EQ_{TM}}$. Let $s \\in EQ_{TM}$ and $t \\in \\overline{EQ_{TM}}$ be fixed.\n\nReduction to $EQ_{TM}$\n\n- If $x$ is of the form $\\langle M, w \\rangle$, then $f(x) = \\langle M_1, M_2 \\rangle$, where\n - $M_1$ accepts every input; and\n - $M_2$ first simulates $M$ on $w$ and accepts its own input if $M$ accepts.\n- Otherwise, $f(x) = t$.\n\n$f$ is computable, and for every $x$, $x \\in A_{TM}$ if and only if $f(x) \\in EQ_{TM}$. \nProof (cont’d)\n\nReduction to $\\overline{EQ}_{TM}$\n\n- If $x$ is of the form $\\langle M, w \\rangle$, then $g(x) = \\langle M_1, M_2 \\rangle$, where\n - $M_1$ rejects every input; and\n - $M_2$ first simulates $M$ on $w$ and accepts its own input if $M$ accepts.\n- Otherwise, $g(x) = s$.\n\n$g$ is computable and for every $x$, $x \\in A_{TM}$ if and only if $g(x) \\notin EQ_{TM}$.\n\nThus, $A_{TM} \\leq_m EQ_{TM}$ and $A_{TM} \\leq_m \\overline{EQ}_{TM}$, and so by the second corollary from a few slides ago, the theorem is proven.\nChapter “P and NP”\n\nP and NP\n\nFor our quick coverage of P and NP, we’ll use (a subset of) my handwritten slides used in the UR graduate continuation of this course!\n\nAnd then if time permits we’ll have some lecture(s) on P and NP-completeness in use, perhaps taking as our focus area the complexity of protecting (and attacking) elections."}}},{"rowIdx":274,"cells":{"id":{"kind":"string","value":"dc5ad8d77d83da113d18083b6d36dea39c33c2d2"},"text":{"kind":"string","value":"Described herein are techniques to perform reassembly of a Transmission Control Protocol (TCP) data stream from payloads of TCP segments of a bidirectional TCP connection between a first TCP end-point operating at a first network device and a second TCP end-point operating at a second network device.\nOTHER PUBLICATIONS\n\nCISCO: Interface Queue Management; XP-002210177; Aug. 1, 2002; 12 pages.\n\nKumar et al: Beyond Best Effort: Router Architectures for the differentiated Services of Tomorrow’s Internet; IEEE Communications Magazine, May 1998; XP-000752860; pp. 152-164\n\n* cited by examiner\nFIG. 1\nAPPLICATION\n\n1402\n\nAP MODULE 1406\n\nStandard System API 1410\n\nNetBoost API 1412\n\nHost Protocol Stack 1404\n\nPE MODULE 1408\n\nFIG. 5\nFIG. 6\nREASSEMBLY OF A TRANSMISSION CONTROL PROTOCOL (TCP) DATA STREAM FROM PAYLOADS OF TCP SEGMENTS OF A BIDIRECTIONAL TCP CONNECTION\n\nRELATED APPLICATIONS\n\n\nFIELD OF THE INVENTION\n\nThe present invention relates to computer networks and, more particularly, to reassembly of a Transmission Control Protocol (TCP) data stream from payloads of TCP segments of a bidirectional TCP connection.\n\nBACKGROUND OF THE INVENTION\n\nComputer networks have become a key part of the corporate infrastructure. Organizations have become increasingly dependent on intranets and the Internet and are demanding much greater levels of performance from their network infrastructure. The network infrastructure is being viewed: (1) as a competitive advantage; (2) as mission critical; (3) as a cost center. The infrastructure itself is transitioning from 10 Mb/s (megabits per second) capability to 100 Mb/s capability. Soon, infrastructure capable of 1 Gb/s (gigabits per second) will start appearing on server connections, trunks and backbones. As more and more computing equipment gets deployed, the number of nodes within an organization has also grown. There has been a doubling of users, and a ten-fold increase in the amount of traffic every year.\n\nNetwork infrastructure applications monitor, manage and manipulate network traffic in the fabric of computer networks. The high demand for network bandwidth and connectivity has led to tremendous complexity and performance requirements for this class of application. Traditional methods of dealing with these problems are no longer adequate.\n\nSeveral sophisticated software applications that provide solutions to the problems encountered by the network manager have emerged. The main areas for such applications are Security, Quality of Service (QoS), Class of Service (CoS) and Network Management. Examples are: Firewalls; Intrusion Detection; Encryption; Virtual Private Networks (VPN); enabling services for ISPs (load balancing and such); Accounting; Web billing; Bandwidth Optimization; Service Level Management; Commerce; Application Level Management; Active Network Management\n\nThere are three conventional ways in which these applications are deployed:\n\n1. On general purpose computers.\n2. Using single function boxes.\n3. On switches and routers.\n\nIt is instructive to examine the issues related to each of these deployment techniques.\n\n1. General Purpose Computers\n\nGeneral Purpose computers, such as PCs running NT/Windows or workstations running Solaris/HP-UX, etc., are a common method for deploying network infrastructure applications. The typical configuration consists of two or more network interfaces each providing a connection to a network segment. The application runs on the main processor (Pentium/SPARC etc.) and communicates with the Network Interface Controller (NIC) card either through (typically) the socket interface or (in some cases) a specialized driver “shim” in the operating system (OS). The “shim” approach allows access to “raw” packets, which is necessary for many of the packet oriented applications. Applications that are end-point oriented, such as proxies can interface to the top of the IP (Internet Protocol) or other protocol stack.\n\nThe advantages of running the application on a general purpose computer include: a full development environment; all the OS services (IPC, file system, memory management, threads, I/O etc); low cost due to ubiquity of the platform; stability of the APIs; and assurance that performance will increase with each new generation of the general purpose computer technology.\n\nThere are, however, many disadvantages of running the application on a general purpose computer. First, the I/O subsystem on a general purpose computer is optimized to provide a standard connection to a variety of peripherals at reasonable cost and, hence, reasonable performance. 32/64 MHz PCI (Peripheral Connection Interface), the dominant I/O connection on common general purpose platforms today) has an effective bandwidth in the 50-75 MB/s range. While this is adequate for a few interfaces to high performance networks, it does not scale. Also, there is significant latency involved in accesses to the card. Therefore, any kind of non-pipelined activity results in a significant performance impact.\n\nAnother disadvantage is that general purpose computers do not typically have good interrupt response time and context switch characteristics (as opposed to real-time operating systems used in many embedded applications). While this is not a problem for most computing environments, it is far from ideal for a network infrastructure application. Network infrastructure applications have to deal with network traffic operating at increasingly higher speeds and less time between packets. Small interrupt response times and small context switch times are very necessary.\n\nAnother disadvantage is that general purpose platforms do not have any specialized hardware that assist with network infrastructure applications. With rare exception, none of the\ninstruction sets for general purpose computers are optimized for network infrastructure applications.\n\nAnother disadvantage is that, on a general purpose computer, typical network applications are built on top of the TCP/IP stack. This severely limits the packet processing capability of the application.\n\nAnother disadvantage is that packets need to be pulled into the processor cache for processing. Cache fills and write backs become a severe bottleneck for high bandwidth networks.\n\nFinally, general purpose platforms use general purpose operating systems (OS's). These operating systems are generally not known for having quick reboots on power-cycle or other wiring-closet appliance oriented characteristics important for network infrastructure applications.\n\n2. Fixed-Function Appliances\n\nThere are a couple of different ways to build single function appliances. The first way is to take a single board computer, add in a couple of NIC cards, and run an executive program on the main processor. This approach avoids some of the problems that a general purpose OS brings, but the performance is still limited to that of the base platform architecture (as described above).\n\nA way to enhance the performance is to build special purpose hardware that performs functions required by the specific application very well. Therefore, from a performance standpoint, this can be very good approach.\n\nThere are, however, a couple of key issues with special function appliances. For example, they are not expandable by their very nature. If the network manager needs a new application, he/she will need to procure a new appliance. Contrast this with adding a new application on a desktop PC. In the case of a PC, a new appliance is not needed with every new application.\n\nFinally, if the solution is not completely custom, it is unlikely that the solution is scalable. Using a PC or other single board computer as the packet processor for each location at which that application is installed is not cost-effective.\n\n3. Switches and Routers\n\nAnother approach is to deploy a scaled down version of an application on switches and routers which comprise the fabric of the network. The advantages of this approach are that: (1) no additional equipment is required for the deployment of the application; and (2) all of the segments in a network are visible at the switches.\n\nThere are a number of problems with this approach.\n\nOne disadvantage is that the processing power available at a switch or router is limited. Typically, this processing power is dedicated to the primary business of the switch/router—switching or routing. When significant applications have to be run on these switches or routers, their performance drops.\n\nAnother disadvantage is that not all nodes in a network need to be managed in the same way. Putting significant processing power on all the ports of a switch or router is not cost-effective.\n\nAnother disadvantage is that, even if processing power become so cheap as to be deployed freely at every port of a switch or router, a switch or router is optimized to move frames/packets from port to port. It is not optimized to process packets, for applications.\n\nAnother disadvantage is that a typical switch or router does not provide the facilities that are necessary for the creation and deployment of sophisticated network infrastructure applications. The services required can be quite extensive and porting an application to run on a switch or router can be very difficult.\n\nFinally, replacing existing network switching equipment with new versions that support new applications can be difficult. It is much more effective to \"add applications\" to the network where needed.\n\nWhat is needed is an optimized platform for the deployment of sophisticated software applications in a network environment.\n\nSUMMARY\n\nDescribed herein are techniques to perform reassembly of a Transmission Control Protocol (TCP) data stream from payloads of TCP segments of a bidirectional TCP connection between a first TCP end-point operating at a first network device and a second TCP end-point operating at a second network device.\n\nBRIEF DESCRIPTION OF THE DRAWINGS\n\nFIG. 1 is a block diagram of a system in accordance with the present invention.\n\nFIG. 2 is a block diagram showing packet flow according to an embodiment of the present invention.\n\nFIG. 3 is a Policy Engine ASIC block diagram according to the present invention.\n\nFIG. 4 is a sample system-level block diagram related to the present invention.\n\nFIG. 5 is an application structure diagram related to the present invention.\n\nFIG. 6 is a diagram showing an Action Classification Engine (ACE) related to the present invention.\n\nFIG. 7 shows a cascade of ACEs related to the present invention.\n\nFIG. 8 shows a system architecture related to the present invention.\n\nFIG. 9 shows an application deploying six ACEs related to the present invention.\n\nDETAILED DESCRIPTION OF PREFERRED EMBODIMENTS\n\nThis section describes the programming model and set of abstractions employed when creating an application for a platform such as the sample NetBoost platform illustrated in FIGS. 1-4. An application on the NetBoost platform is to be considered a service, provided within the network, that may require direct knowledge or manipulation of network packets or frames. The programming model provides for direct access to low-level frame data, plus a set of library functions capable of reassembling low-level frame data into higher-layer messages or packets. In addition, the library contains functions capable of performing protocol operations on network or transport-layer messages.\n\nAn application developed for the NetBoost platform receives link-layer frames from an attached network interface, matches the frames against some set of selection criteria, and determines their disposition. Frame processing takes place as a sequence of serialized processing steps. Each step includes a classification and action phase. During the classification phase, frame data is compared against application-specified matching criteria called rules. When a rule’s matching criteria evaluates true, its action portion specifies the disposition of the frame. Execution of the\naction portion constitutes the action Phase. Only the actions of rules with true matching criteria are executed.\n\nImplementing an application for the NetBoost platform involves partitioning the application into two modules. Modules are a grouping of application code destined to execute in a particular portion of the NetBoost platform. There are two modules required: the application processor (AP) module, and the policy engine (PE) module. Application code in the AP module runs on the host processor, and is most appropriate for processing not requiring wire-speed access to network frames. Application code for the PE module comprises the set of classification rules written in the NetBoost Classification Language (NCL), and an accompanying set of compiled actions (C or C++ functions/objects). PE actions are able to manipulate network frames with minimal overhead, and are thus the appropriate mechanism for implementing fast and simple manipulation of frame data. The execution environment for PE action code is more restricted than that of AP code (no virtual memory or threads), but includes a library providing efficient implementation for common frame manipulation tasks. A message passing facility allows for communication between PE action code and the AP module.\n\n1. Application Structure\n\nFIG. 5 illustrates the NetBoost application structure. Applications 1402 written for the NetBoost platform must be partitioned into the following modules and sub-modules, as illustrated in FIG. 5.\n\nAP Module (application processor (host) module) 1406\nPE Module (policy engine module) 1408\nClassification rules—specified in NCL.\nAction implementation—object code provided by app developer.\n\nThe AP module 1406 executes in the programming environment of a standard operating system and has access to all PEs 1408 available on the system, plus the conventional APIs implemented in the host operating system. Thus, the AP module 1406 has the capability of performing both frame-level processing (in conjunction with the PE), or traditional network processing using a standard API.\n\nThe PE 1408 module is subdivided into a set of classification rules and actions. Classification rules are specified in the NetBoost Classification Language (NCL) and are compiled on-the-fly by a fast incremental compiler provided by NetBoost. Actions are implemented as relocatable object code provided by the application developer. A dynamic linker/loader included with the NetBoost platform is capable of linking and loading the classification rules with the action implementations and loading these either into the host (software implementation) or hardware PE (hardware implementation) for execution.\n\nThe specific division of functionality between AP and PE modules 1406 and 1408 in an application is left entirely up to the application designer. Preferably, the AP module 1406 should be used to implement initialization and control, user interaction, exception handling, and infrequent processing of frames requiring special attention. The PE module 1408 preferably should implement simple processing on frames (possibly including the reconstruction of higher-layer messages) requiring extremely fast execution. PE action code runs in a run-to-completion real-time environment without memory protection, similar to an interrupt handler in most conventional operating systems. Thus, functions requiring lengthy processing times should be avoided, or executed in the AP module 1406. In addition, other functions may be loaded into the PE to support actions, asynchronous execution, timing, or other processing (such as upcalls/downcalls, below). All code loaded into the PE has access to the PE runtime environment, provided by the ASL.\n\nThe upcall/downcall facility provides for communication between PE actions and AP functions. An application may use upcalls/downcalls for sharing information or signaling between the two modules. The programmer may use the facility to pass memory blocks, frame contents, or other messages constructed by applications in a manner similar to asynchronous remote procedure calls.\n\n2. Basic Building Blocks\n\nThis section describes the C++ classes needed to develop an application for the NetBoost platform. Two fundamental classes are used to abstract the classification and handling of network frames:\n\nACE, representing classification and action steps\nTarget, representing possible frame destinations\n\n2.1 ACEs\n\nThe ACE class (short for Action-Classification-Engine) abstracts a set of frame classification criteria and associated actions, upcall/downcall entrypoints, and targets. They are simple: frame processing is uni-directional. An application may make use of cascaded ACEs to achieve serialization of frame processing. ACEs are local to an application.\n\nACEs provide an abstraction of the execution of classification rules, plus a container for holding the rules and actions. ACEs are instantiated on particular hardware resources either by direct control of the application or by the plumber application.\n\nAn ACE 1500 is illustrated in FIG. 6:\n\nThe ACE is the abstraction of frame classification rules 1506 and associated actions 1508, destinations for processed frames, and downcall/upcall entrypoints. An application may employ several ACEs, which are executed in a serial fashion, possibly on different hardware processors.\n\nFIG. 6 illustrates an ACE with two targets 1502 and 1504. The targets represent possible destinations for frames and are described in the following section.\n\nFrames arrive at an ACE from either a network interface or from an ACE. The ACE classifies the frame according its rules. A rule is a combination of a predicate and action. A rule is said to be “true” or to “evaluate true” or to be a “matching rule” if its predicate portion evaluates true in the Boolean sense for the current frame being processed. The action portion of each matching rule indicates what processing should take place.\n\nThe application programmer specifies rule predicates within an ACE using Boolean operators, packet header fields, constants, set membership queries, and other operations defined in the NetBoost Classification Language (NCL), a declarative language described below. A set of rules (an NCL program) may be loaded or unloaded from an ACE dynamically under application control. In certain embodiments, the application developer implements actions in a conventional high level language. Special external declaration statements in NCL indicate the names of actions supplied by the application developer to be called as the action portion for matching rules.\n\nActions are function entry-points implemented according to the calling conventions of the C programming language (static member functions in C++ classes are also supported). The execution environment for actions includes a C and C++ runtime environment with restricted standard libraries appropriate to the PE execution environment. In addition to the C environment, the ASL library provides additional functionality for developing network applications. The ASL\nprovides support for handling many TCP/IP functions such as IP fragmentation and re-assembly, Network Address Translation (NAT), and TCP connection monitoring (including stream reconstruction). The ASL also provides support for encryption and basic system services (e.g., timers, memory management).\n\nDuring classification, rules are evaluated first-to-last. When a matching rule is encountered, its action executes and returns a value indicating whether it disposed of the frame. Disposing of a frame corresponds to taking the final desired action on the frame for a single classification step (e.g., dropping it, queuing it, or delivering it to a target). If an action executes but does not dispose of the current frame, it returns a code indicating the frame should undergo further rule evaluations in the current classification step. If any action disposes of the frame, the classification phase terminates. If all rules are evaluated without a disposing action, the frame is delivered to the default target of the ACE.\n\n2.2 Targets\n\nTargets specify possible destinations for frames (an ACE or network interface). A target is said to be bound to either an ACE or network interface (in the outgoing direction), otherwise it is unbound. Frames delivered to unbound targets are dropped. Target bindings are manipulated by a plumbing application in accordance with the present invention.\n\nFIG. 7 shows a cascade of ACEs. ACEs use targets as frame destinations. Targets 1 and 2 (illustrated at 1602 and 1604) are bound to ACEs 1 and 2 (illustrated at 1610 and 1612), respectively. Target 3 (at 1606) is bound to a network interface (1620) in the outgoing direction. Processing occurs serially from left to right. Ovals indicate ACEs, hexagons indicate network interfaces. Outgoing arcs indicate bound targets. An ACE with multiple outgoing arcs indicates an ACE that performs a demultiplexing function: the set of outgoing arcs represent the set off all frame destinations in the ACE, across all actions. In this example, each ACE has a single destination (the default target). When several hardware resources are available for executing ACEs (e.g., in the case of the NetBoost hardware platform), ACEs may execute more efficiently (using pipelining). Note, however, that when one ACE has finished processing a frame, it is given to another ACE that may execute on the same hardware resource.\n\n3. Complex Configurations\n\nAs described above, a single application may employ more than one ACE. Generally, processing bidirectional network data will require a minimum of two ACEs. Four ACEs may be a common configuration for a system providing two network interfaces and an application wishing to install ACEs at the input and output for each interface (e.g. in the NetBoost hardware environment with one PE).\n\nFIG. 8 illustrates an application employing six ACEs 1802, 1804, 1806, 1808, 1810 and 1812. Shaded circles represent targets. Two directions of processing are depicted, as well as an ACE with more than one output arc and an ACE with more than one input arc. The arcs represent possible destinations for frames.\n\nAn ACE depicted with more than one outgoing arc may represent the processing of a single frame, or in certain circumstances, the replication (copying) of a frame to be sent to more than one downstream ACE simultaneously. Frame replication is used in implementing broadcast and multicast forwarding (e.g. in layer 2 bridging and IP multicast forwarding). The interconnection of targets to downstream objects is typically performed by the plumber application described in the next section.\n\n4. Software Architecture\n\nThis section describes the major components comprising the NetBoost software implementation. The software architecture provides for the execution of several applications performing frame-layer processing of network data, and includes user-level, kernel-level, and embedded processor-level components (for the hardware platform). The software architecture is illustrated FIG. 9.\n\nThe layers of software comprising the overall architecture are described bottom-up. The first layer is the NetBoost Policy Engine 2000 (PE). Each host system may be equipped with one or more PEs. In systems equipped with NetBoost hardware PEs, each PE will be equipped with several frame classifiers and a processor responsible for executing action code. For systems lacking the hardware PE, all PE functionality is implemented in software. The PE includes a set of C++ library functions comprising the Action Services Library (ASL) which may be used by action code in ACE rules to perform messaging, timer-driven event dispatch, network packet reassembly or other processing.\n\nThe PE interacts with the host system via a device driver 2010 and ASL 2012 supplied by NetBoost. The device driver is responsible for supporting maintenance operations to NetBoost PE cards. In addition, this driver is responsible for making the network interfaces supplied on NetBoost PE cards available to the host system as standard network interfaces. Also, specialized kernel code is inserted into the host’s protocol stack to intercept frames prior to receipt by the host protocol stack (incoming) or transmission by conventional network interface cards (outgoing).\n\nThe Resolver 2008 is a user-level process started at boot time responsible for managing the status of all applications using the NetBoost facilities. In addition, it includes the NCL compiler and PE linker/loader. The process responds to requests from applications to set up ACEs, bind targets, and perform other maintenance operations on the NetBoost hardware or software-emulated PE.\n\nThe Application Library 2002 (having application 1, 2 & 3 shown at 2020, 2040, 2042) is a set of C++ classes providing the API to the NetBoost system. It allows for the creation and configuration of ACEs, binding of targets, passing of messages to/from the PE, and the maintenance of the name-to-object bindings for objects which exist in both the AP and PE modules.\n\nThe plumber 2014 is a management application used to set up or modify the bindings of every ACE in the system (across all applications). It provides the network administrator the ability to specify the serial order of frame processing by binding ACE targets to subsequent ACEs. The plumber is built using a client/server architecture, allowing for both local and remote access to specify configuration control. All remote access is authenticated and encrypted.\n\nClassification Language\n\nThe NetBoost Classification Language (NCL) is a declarative high level language for defining packet filters. The language has six primary constructs: protocol definitions, predicates, sets, set searches, rules and external actions. Protocol definitions are organized in an object-oriented fashion and describe the position of protocol header fields in packets. Predicates are Boolean functions on protocol header fields and other predicates. Rules consist of a predicate/action pair having a predicate portion and an...\naction portion where an action is invoked if its corresponding predicate is true. Actions refer to procedure entrypoints implemented external to the language.\n\nIndividual packets are classified according to the predicate portions of the NCL rules. More than one rule may be true for any single packet classification. The action portion of rules with true predicates are invoked in the order the rules have been specified. Any of these actions invoked may indicate that no further actions are to be invoked. NCL provides a number of operators to access packet fields and execute comparisons of those fields. In addition, it provides a set abstraction, which can be used to determine containment relationships between packets and groups of defined objects (e.g., determining if a particular packet belongs to some TCP/IP flow or set of flows), providing the ability to keep persistent state in the classification process between packets.\n\nStandard arithmetic, logical and bit-wise operators are supported and follow their equivalents in the C programming language. These operators provide operations on the fields of the protocols headers and result in scalar or Boolean values. An include directive allows for splitting NCL programs into several files.\n\n1. Names and Data Types\n\nThe following definitions in NCL constants have names: protocols, predicates, fields, sets, searches on sets, and rules (defined later subsequent sections). A name is formed using any combination of alphanumeric characters and underscores except the first character must be an alphabetic character. Names are case sensitive. For example,\n\n```\nset_tcp_udp\nisIP\nisIPv6\nset_udp_ports\n```\n\nThe above examples are all legal names. The following examples are all illegal names:\n\n```\n6_byte_ip\nset_tcp+udp\nip_src&dst\n```\n\nThe first is illegal because it starts with a numeric character, the other two are illegal because they contain operators.\n\nProtocol fields (see Section 6) are declared in byte-oriented units, and used in constructing protocols definitions. All values are big-endian. Fields specify the location and size of portions of a packet header. All offsets are relative to a particular protocol. In this way it is possible to specify a particular header field without knowing the absolute offset of the any particular protocol header. Mask and shift operations support the accessing of non-byte-sized header fields. For example,\n\n```\ndst { ip[16:4] }\nver { (ip[0:1] & 0x80) >> 4 }\n```\n\nIn the first line, the 4-byte field dst is specified as being at byte offset 16 from the beginning of the IP protocol header. In the second example, the field ver is a half-byte sized field at the beginning of the IP header.\n\n2. Operators\n\nArithmetic, logical and bit-wise binary operators are supported. Table 23 lists the arithmetic operators and grouping operator supported.\n\n```\n<table>\n<thead>\n<tr>\n<th>Operator</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>( )</td>\n<td>Grouping operator</td>\n</tr>\n<tr>\n<td>+</td>\n<td>Addition</td>\n</tr>\n<tr>\n<td>-</td>\n<td>Subtraction</td>\n</tr>\n<tr>\n<td><<=</td>\n<td>Logical left shift</td>\n</tr>\n<tr>\n<td>>>=</td>\n<td>Logical right shift</td>\n</tr>\n</tbody>\n</table>\n```\n\nThe arithmetic operators result in scalar quantities, which are typically used for comparison. These operators may be used in field and predicate definitions. The shift operations do not support arithmetic shifts. The shift amount is a compile time constant. Multiplication, division and modulo operators are not supported. The addition and subtraction operations are not supported for fields greater than 4 bytes.\n\nLogical operators are supported that result in Boolean values. Table 24 provides the logical operators that are supported by the language.\n\n```\n<table>\n<thead>\n<tr>\n<th>Operator</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>&&</td>\n<td>Logical AND</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>?</td>\n<td>Net</td>\n</tr>\n<tr>\n<td>></td>\n<td>Greater Than</td>\n</tr>\n<tr>\n<td>>=</td>\n<td>Greater Than or Equal To</td>\n</tr>\n<tr>\n<td><</td>\n<td>Less Than</td>\n</tr>\n<tr>\n<td><=</td>\n<td>Less Than or Equal To</td>\n</tr>\n<tr>\n<td>==</td>\n<td>Equal To</td>\n</tr>\n<tr>\n<td>!=</td>\n<td>Not Equal</td>\n</tr>\n</tbody>\n</table>\n```\n\nBit-wise operators are provided for masking and setting of bits. The operators supported are as follows:\n\n```\n<table>\n<thead>\n<tr>\n<th>Operators</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>&</td>\n<td>Bit-wise AND</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>~</td>\n<td>Bit-wise Exclusive OR</td>\n</tr>\n</tbody>\n</table>\n```\n\nThe precedence and the associativity of all the operators listed above are shown in Table 26. The precedence is listed in decreasing order.\n\n```\n<table>\n<thead>\n<tr>\n<th>Precedence</th>\n<th>Operators</th>\n<th>Associativity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>High</td>\n<td>( ) [ ]</td>\n<td>Left to right</td>\n</tr>\n<tr>\n<td>.</td>\n<td>!</td>\n<td>Right to left</td>\n</tr>\n<tr>\n<td>.</td>\n<td>+=</td>\n<td>Left to right</td>\n</tr>\n<tr>\n<td>.</td>\n<td><<=</td>\n<td>Left to right</td>\n</tr>\n<tr>\n<td>.</td>\n<td>>>=</td>\n<td>Left to right</td>\n</tr>\n<tr>\n<td>.</td>\n<td>== ! =</td>\n<td>Left to right</td>\n</tr>\n<tr>\n<td>.</td>\n<td>&</td>\n<td>Left to right</td>\n</tr>\n<tr>\n<td>.</td>\n<td></td>\n<td>Left to right</td>\n</tr>\n</tbody>\n</table>\n```\nTABLE 26-continued\n\n<table>\n<thead>\n<tr>\n<th>Precedence</th>\n<th>Operators</th>\n<th>Associativity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>.</td>\n<td></td>\n<td>Left to right</td>\n</tr>\n<tr>\n<td>101.230.135.45</td>\n<td>Dot separated IP address form</td>\n<td></td>\n</tr>\n<tr>\n<td>ff12:34:56:78:9a</td>\n<td>Colon separated MAC address form</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n3. Field Formats\nThe language supports several standard formats, and also domain specific formats, for constants, including the dotted-quad form for IP version 4 addresses and colon-separated hexadecimal for Ethernet and IP version 6 addresses, in addition to conventional decimal and hexadecimal constants. Standard hexadecimal constants are defined as they are in the C language, with a leading 0x prefix.\n\nFor data smaller than 4 bytes in length, unsigned extension to 4 bytes is performed automatically. A few examples are as shown below:\n\nTABLE 27\n\n<table>\n<thead>\n<tr>\n<th>Constant formats</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0x12345678</td>\n</tr>\n<tr>\n<td>101.23.45.67</td>\n</tr>\n<tr>\n<td>ff12:34:56:78:9a</td>\n</tr>\n</tbody>\n</table>\n\n4. Comments\nC and C++ style comments are supported. One syntax supports multiple lines, the other supports comments terminating with a newline. The syntax for the first form follows the C language comment syntax using /* and */ to demark the start and end of a comment, respectively. The syntax for the second form follows the C++ comment syntax, using /* to indicate the start of the comment. Such comments end at the end of the line. Nesting of comments is not allowed in the case of the first form. In the second case, everything is discarded to the end of the line, so nesting of the second form is allowed. Comments can occur anywhere in the program. A few examples of comments are shown below,\n\nDiagram 1: Legal comments\n\n/* Comment in a single line */\n// Second form of the comment; compiler ignores to end-of-line\n/* Comments across multiple line second line third line */\n// Legal comment // still ignored to end-of-line\n*/\n/* First form // Second form, but OK\n*/\n\nThe examples above are all legal. The examples shown in Diagram 11 (below) are illegal.\n\nDiagram 2: Illegal comments\n\n/* space */\n/ new line\n* Testing */\n/* Nesting */ Second level */\n*/\n\nThe first comment is illegal because of the space between / and *, and the second one because of the new-line. The third is illegal because of nesting. The fourth is illegal because of the space between the */\" chars and the next one because of the new-line. The last one is illegal because the */\" is ignored, causing the */\" to be in error of nesting of the first form of the comment in the second form.\n\n5. Constant Definitions and Include Directives\nThe language provides user-definable symbolic constants. The syntax for the definition is the keyword #define, then the name followed by the constant. No spaces are allowed between # and define. The constant can be in any of the forms described in the next subsection of this patent application. The definition can start at the beginning of a line or any other location on a line as long as the preceding characters are either spaces or tabs. For example,\n\nDiagram 3: Sample of constant definition usage\n\n#define TELNET_PORT_NUM 23 // Port number for telnet\n#define IP_ADDR 10.4.7.18\n#define MAC_ADDR ed:dc:93:47:93\n\nThe language provides the ability to include files within the compilation unit so that pre-existing code can be reused. The keyword #include is used, followed by the filename enclosed in double quotes. The # must start on a new-line, but may have spaces immediately preceding the keyword. No space are allowed between # and the include. The filename is any legal filename supported by the host. For example,\n\nDiagram 4: Sample include directives\n\n#include \"myproto.def\" // Could be protocol definitions\n#include \"utils.h\" // Some standard rules\n#include \"newproto.def\" /* New protocol definitions */\n\n6. Protocol Definitions\nNCL provides a convenient method for describing the relationship between multiple protocols and the header fields they contain. A protocol defines fields within a protocol header, intrinsics (built-in functions helpful in processing headers and fields), predicates (Boolean functions on fields and other predicates), and the demultiplexing method to high-layer protocols. The keyword protocol identifies a protocol definition and its name. The name may later be referenced as a Boolean value which evaluates true if the protocol is activated (see 6.2). The declarations for fields, intrinsics and demultiplexing are contained in a protocol definition as illustrated below.\n6.1 Fields\n\nFields within the protocol are declared by specifying a field name followed by the offset and field length in bytes. Offsets are always defined relative to a protocol. The base offset is specified by the protocol name, followed by colon separated offset and size enclosed in square brackets. This syntax is as shown below:\n\n\\[\n\\text{field_name \\{ protocol_name[offset:size] } \\]\n\nFields may be defined using a combination of byte ranges within the protocol header and shift/mask or grouping operations. The field definitions act as access methods to the areas within the protocol header or payload. For example, fields within a protocol named MyProto might be specified as follows:\n\n\\[\n\\begin{align*}\n\\text{dest_addr} & \\{ \\text{MyProto}[6:4] \\\\\n\\text{bit Flags} & \\{ (\\text{MyProto}[10:2] & 0x0f0) >> 8 \\}\n\\end{align*}\n\\]\n\nIn the first example, field dest_addr is declared as a field at offset 6 bytes from the start of the protocol MyProto and 4 bytes in size. In the second example, the field bit Flags is a bit field because it crosses a byte boundary, two bytes are used in conjunction with a mask and right shift operation to get the field value.\n\n6.2 Intrinsics\n\nIntrinsics are functions listed in a protocol statement, but implemented internally. Compiler-provided intrinsics are declared in the protocol definition (for consistency) using the keyword intrinsic followed by the intrinsic name. Intrinsics provide convenient or highly optimized functions that are not easily expressed using the standard language constructs. One such intrinsic is the IP checksum. Intrinsics may be declared within the scope of a protocol definition or outside, as in the following examples:\n\n\\[\n\\text{Diagram 5: Sample intrinsic declarations}\n\\]\n\n\\[\n\\begin{align*}\n\\text{protocol foo} \\{ \\\\\n\\text{...field def...} \\\\\n\\text{intrinsic checksum valid \\{\\}} \\\\\n\\text{intrinsic now}\n\\end{align*}\n\\]\n\nThe first example indicates checksum valid intrinsic is associated with the protocol foo. Thus, the expression foo.checksum valid could be used in the creation of predicates or expressions defined later. The second example indicates a global intrinsic called now that may be used anywhere within the program. Intrinsics can return Boolean and scalar values.\n\nIn a protocol definition, predicates are used to define frequently used Boolean results from the fields within the protocol being defined. They are identified by the keyword predicate. Predicates are described in section 7.\n\n6.3 Demux\n\nThe keyword demux in each protocol statement indicates how demultiplexing should be performed to higher-layer protocols. In effect, it indicates which subsequent protocol is \"activated\", as a function of fields and predicates defined within the current set of activated protocols.\n\nEvaluation of the Boolean expressions within a protocol demux statement determines which protocol is activated next. Within a demux statement, the first expression which evaluates to true indicates that the associated protocol is to be activated at a specified offset relative to the first byte of the present protocol. The starting offset of the protocol to be activated is specified using the keyword at. A default protocol may be specified using the keyword default. The first case of the demux to evaluate true indicates which protocol is activated next. All others are ignored. The syntax for the demux is as follows:\n\n\\[\n\\text{Diagram 6: Demux syntax sample}\n\\]\n\n\\[\n\\begin{align*}\n\\text{demux} \\{ \\\\\n\\text{boolean exp \\{ protocol\\_name at offset \\}} \\\\\n\\text{default \\{ protocol\\_name at offset \\}} \\\\\n\\}\n\\end{align*}\n\\]\n\nDiagram 7 shows an example of the demux declaration.\n\n\\[\n\\text{Diagram 7: Sample protocol demux}\n\\]\n\n\\[\n\\begin{align*}\n\\text{demux} \\{ \\\\\n\\text{(length == 10) \\{ proto\\_a at offset\\_a \\}} \\\\\n\\text{(flags & predicate x) \\{ proto\\_b at offset\\_b \\}} \\\\\n\\text{default \\{ proto\\_default at offset\\_default \\}} \\\\\n\\}\n\\end{align*}\n\\]\n\nIn the above example, protocol proto_a is \"activated\" at offset offset_a if the expression length equals ten. Protocol proto_b is activated at offset offset_b if flags is true, predicate_x is true and length is not equal to 10. predicate_x is a pre-defined Boolean expression. The default protocol is proto_default, which is defined here so that packets not matching the predefined criteria can be processed. The fields and predicates in a protocol are accessed by specifying the protocol and the field or predicate separated by the dot operator. This hierarchical naming model facilitates easy extension to new protocols. Consider the IP protocol example shown below.\n\n\\[\n\\text{Diagram 8: Protocol Sample: IP}\n\\]\n\n\\[\n\\begin{align*}\n\\text{protocol ip} \\{ \\\\\n\\text{vers \\{ (ip[0:1] & 0x0f) >> 4 \\}} \\\\\n\\text{hlen \\{ (ip[0:1] & 0x0f) \\}} \\\\\n\\text{hlen.b \\{ (ip[1:1] & 0x0f) \\}} \\\\\n\\text{tos \\{ (ip[1:1] & 0x0f) \\}} \\\\\n\\text{length \\{ (ip[2:2] \\}} \\\\\n\\text{id \\{ (ip[4:2] \\}} \\\\\n\\text{flags \\{ (ip[6:1] & 0xe0) >> 5 \\}} \\\\\n\\text{frag.off \\{ (ip[6:2] & 0x1ff) \\}} \\\\\n\\text{ttl \\{ ip[8:1] \\}} \\\\\n\\text{proto \\{ ip[9:1] \\}} \\\\\n\\text{chksum \\{ ip[10:2] \\}} \\\\\n\\text{src \\{ ip[12:4] \\}} \\\\\n\\text{dst \\{ ip[16:4] \\}} \\\\\n\\text{intrinsic checksum valid \\{\\}} \\\\\n\\text{intrinsic icmp checksum \\{\\}} \\\\\n\\text{predicate behav \\{ dst == 255,255,255,255 \\}} \\\\\n\\text{predicate mcstr \\{ (dst & 0xff000000) == 0x00000000 \\}} \\\\\n\\text{predicate flag \\{ frag.offset != 0 \\}} \\\\\n\\text{demux \\{ \\\\\n\\text{(proto == 6) \\{ tcp at hlen.b \\}} \\\\\n\\text{(proto == 17) \\{ udp at hlen.b \\}} \\\\\n\\text{(proto == 1) \\{ icmp at hlen.b \\}} \\\\\n\\text{(proto == 2) \\{ igmp at hlen.b \\}} \\\\\n\\}\n\\end{align*}\n\\]\nHere, ip is the protocol name being defined. The protocol definition includes a number of fields which correspond to portions of the IP header comprising one or more bytes. The fields vers, length, flags and fragoffset have special operations that extract certain bits from the IP header. length_b holds the length of the header in bytes computed using the hlength field (which is in units of 32-bit words).\n\nbcast, mecast, and frag are predicates which may be useful in defining other rules or predicates. Predicates are defined in Section 7.\n\nThis protocol demuxes into four other protocols, excluding the default, under different conditions. In this example, the demultiplexing key is the protocol type specified by the value of the IP proto field. All the protocols are activated at offset hlength_b relative to the start of the IP header.\n\nWhen a protocol is activated due to the processing of a lower-layer demux statement, the activated protocol’s name becomes a Boolean that evaluates true (it is otherwise false). Thus, if the IP protocol is activated, the expression ip will evaluate to a true Boolean expression. The fields and predicates in a protocol are accessed by specifying the protocol and the field, predicate or intrinsic separated by the dot operator. For example:\n\n7. Predicates\nPredicates are named Boolean expressions that use protocol header fields, other Boolean expressions, and previously-defined predicates as operands. The syntax for predicates is as follows:\n\npredicate predicate_name { boolean_expression }\n\nFor example,\n\npredicate isTcpSyn { tcp & & (tcp.flags & 0x02) != 0 }\n\n8. Sets\nThe language supports the notion of sets and named searches on sets, which can be used to efficiently check whether a packet should be considered a member of some application-defined equivalence class. Using sets, classification rules requiring persistent state may be constructed. The classification language only supports the evaluation of set membership; modification to the contents of the sets are handled exclusively by actions in conjunction with the ASL. A named search defines a particular search on a set and its name may be used as a Boolean variable in subsequent Boolean expressions. Named searches are used to tie pre-computed lookup results calculated in the classification phase to actions executing in the action phase.\n\nA set is defined using the keyword set followed by an identifier specifying the name of the set. The number of keys for any search on the set is specified following the name, between < and >. A set definition may optionally include a hint as to the expected number of members of the set, specified using the keyword size_hint. The syntax is as follows:\n\nset set_name < size > { size_hint { expected_population } }\n\nThe size_hint does not place a strict limit on the population of the set, but as the set size grows beyond the hint value, the search time may slowly increase.\n\nPredicates and rules may perform named searches (see the following section for a discussion of rules). Named searches are specified using the keyword search followed by the search name and search keys. The search name consists of two parts: the name of the set to search, and the name of the\n17\n\nsearch being defined. The keys may refer to arbitrary expres-\nsions, but typically refer to fields in protocols. The number of\nkeys defined in the named search must match the number of\nekys defined for the set. The named search may be used in\nsequent predicates as a Boolean value, where \"true\" indi-\nates a record is present in the associated set with the\nspecified keys. An optional Boolean expression may be\nincluded in a named search using the requires keyword. If\nthe Boolean expression fails to evaluate true, the search\nresult is always \"false\". The syntax for named searches is as\nfollows:\n\nDiagram 12: Named search\n\nsearch set_name.search._name (key1, key2) {\n requires { boolean_expression }\n}\n\nConsider the following example defining a set of trans-\nport-layer protocol ports (tcp or udp):\n\nDiagram 13: Sharing a set definition\n\n#define MAX_TCP_UDP_PORTS_SET_SZ 200\n/* TPORTS: a set of TCP or UDP ports */\nset tports<1> {\n size_hint { MAX_TCP_UDP_PORTS_SET_SZ }\n search tports.tcp_sport (tcp.sport)\n search tports.tcp_dport (tcp.dport)\n search tportsudp_sport (udp.sport)\n search tportsudp_dport (udp.dport)\n}\n\nThis example illustrates how one set may be used by\nmultiple searches. The set tports might contain a collection\nof port numbers of interest for either protocol, TCP/IP or\nUDP/IP. The four named searches provide checks as to\nwhether different TCP or UDP source or destination port\nnumbers are present in the set. The results of named searches\nmay be used as Boolean values in expressions, as illustrated\nbelow:\n\nDiagram 14: Using shared sets\n\npredicate tcp_sport_in [tports.tcp_sport]\npredicate tcp_port_in [tports.tcp_sport & tports.tcp_dport]\npredicate udp_sport_in [tportsudp_sport & tportsudp_dport]\n\nIn the first example, a predicate tcp_sport_in is defined to\nbe the Boolean result of the named search tports.tcp_sport,\nwhich determines whether or not the tcp_sport field (source\nport) of a TCP segment is in the set tports. In the second\nexample, both the source and destination ports of the TCP\nprotocol header are searched using named searches. In the\nthird case, membership of either the source or destination\nports of a UDP datagram in the set is determined.\n\n9. Rules and Actions\n\nRules are a named combination of a predicate and action.\nThey are defined using the keyword rule. The predicate\nportion is a Boolean expression consisting of any combi-\nnation of individual Boolean subexpressions or other predicate\nnames. The Boolean value of a predicate name corresponds\n\nto the Boolean value of its associated predicate portion. The\naction portion specifies the name of the action which is to be\ninvoked when the predicate portion evaluates \"true\" for the\ncurrent frame. Actions are implemented external to the\nclassifier and supplied by application developers. Arguments\ncan be specified for the action function and may include\npredicates, named searches on sets, or results of intrinsic\nfunctions. The following illustrates the syntax:\n\nDiagram 15: Rule syntax\n\nrule rule_name ( predicate ) {\n external_action_func (arg1, arg2, . . . )\n}\n\nThe argument list defines the values passed to the action\ncode executed externally to NCL. An arbitrary number of\narguments are supported.\n\nDiagram 16: Telnet/FTP example\n\nset set_ip_tcp_ports <2> {\n size_hint { 100 }\n} \nset set_ip_udp_ports <3> {\n size_hint { 100 }\n}\n\nDiagram 17: Using the set definition\n\nsearch set_ip_tcp_ports.tcp.dport (tcp.dport)\nsearch set_ip_udp_ports.udp.dport (udp.dport)\n\nIn the above example, two sets are defined. One contains\nsource and destination IP addresses, plus TCP ports. The\nother set contains IP addresses and UDP ports. Two named\nsearches are defined. The first search uses the IP source and\ndestination addresses and the TCP destination port number\nas keys. The second search uses the IP source and destina-\ntion addresses and UDP destination port as keys. The predi-\ncate ipValid checks to make sure the packet is an IP\npacket with valid checksum, has a header of acceptable size,\nand is IP version 4. The predicate newtelnet determines if\nthe current TCP segment is a SYN packet destined for a telnet\nport. The predicate tcp_port determines if the UDP destination\nport corresponds to the TFTP port number and the combi-\nnation of IP source and destination addresses and destination\nUDP port number is in the set ip_udp_ports. The rule\ntelnetNewCon determines if the current segment is a new\ntelnet connection, and specifies that the associated external\nfunction start_telnet will be invoked when this rule is true.\nThe function takes the search result as argument. The rule\ntftpPkt checks whether the packet belongs to a TFTP\nconnection. If so, the associated action is tftp_pkt will be\ninvoked with udp.dport as the argument. The third checks if\nthe current segment is a new telnet connection and defines the associated action function add_to_tep_plt_count.\n\n10. With Clauses\n\nA with clause is a special directive providing for conditional execution of a group of rules or predicates. The syntax is as follows:\n\n```ncl\nDiagram 17: With clause syntax sample\n\nwith boolean_expression {cheid aBoolean_exp } rule rule_name [ anyBoolean_exp ] { action_reference }\n```\n\nIf the Boolean expression in the with clause evaluates false, all the enclosed predicates and rules evaluate false. For example, if we want to evaluate the validity of an IP datagram and use it in a set of predicates and rules, these can be encapsulated using the with clause and a conditional, which could be the checksum of the IP header. Nested with clauses are allowed, as illustrated in the following example:\n\n```ncl\nDiagram 18: Nested with clauses\n\nwith tcpValid [ tcp & tcp.chualvalid ]\n # define TELNET with ipValid [ tcp &]\n with tcpValid [ tcp & tcp.chualvalid ]\n\n with tcpValid [ tcp & tcp.chualvalid ]\n with tcpValid [ tcp & tcp.chualvalid ]\n\nrule telnetNewCon [ (tcp.flags & 0x02) & tcp.dport == TELNET ]\n rule telnetNewCon [ (tcp.flags & 0x02) & tcp.dport == TELNET ]\n rule telnetNewCon [ (tcp.flags & 0x02) & tcp.dport == TELNET ]\n\nrule tryplkt [ tcp & ip udp ports udpd dport ]\nrule tryplkt [ tcp & ip udp ports udpd dport ]\nrule tryplkt [ tcp & ip udp ports udpd dport ]\n```\n\n11. Protocol Definitions for TCP/IP\n\nThe following NCL definitions are used for processing of TCP/IP and related protocols.\n\n```ncl\nprotocol frame [data]\n // status words written by NetBoost Ethernet MACs\n // source: 6: NetBoost onboard MAC A ethernet packet\n // source: 1: NetBoost onboard MAC B ethernet packet\n // source: 2: Other rxstatus-encodeable ethernet packet\n\n default [ frame.had_at 0 ]\n default [ frame.had_at 0 ]\n default [ frame.had_at 0 ]\n```\n\n```ncl\nprotocol frame_bad [data]\n```\n\n```ncl\n#define ETHER_PTYPE0x0806\n#define ETHER_ARPTYPE 0x0806\n#define ETHER_RARPType 0x0805\n```\n\n```ncl\nprotocol ether [data]\n```\n\n```ncl\n#define ETHER_IPTYPE 0x0800\n```\n\n```ncl\n#define ETHER_ARPTYPE 0x0806\n#define ETHER_RARPType 0x0805\n```\n\n```ncl\nprotocol ether [data]\n```\n\n```ncl\n#define ETHER_PTYPE 0x0806\n#define ETHER_ARPTYPE 0x0806\n#define ETHER_RARPType 0x0805\n```\n\n```ncl\nprotocol ether [data]\n```\n\n```ncl\n#define ETHER_PTYPE 0x0806\n#define ETHER_ARPTYPE 0x0806\n#define ETHER_RARPType 0x0805\n```\n\n```ncl\nprotocol ether [data]\n```\n\n```ncl\n#define ETHER_PTYPE 0x0806\n#define ETHER_ARPTYPE 0x0806\n#define ETHER_RARPType 0x0805\n```\n\n```ncl\nprotocol ether [data]\n```\n\n```ncl\n#define ETHER_PTYPE 0x0806\n#define ETHER_ARPTYPE 0x0806\n#define ETHER_RARPType 0x0805\n```\n\n```ncl\nprotocol ether [data]\n```\n\n```ncl\n#define ETHER_PTYPE 0x0806\n#define ETHER_ARPTYPE 0x0806\n#define ETHER_RARPType 0x0805\n```\n\n```ncl\nprotocol ether [data]\n```\n\n```ncl\n#define ETHER_PTYPE 0x0806\n#define ETHER_ARPTYPE 0x0806\n#define ETHER_RARPType 0x0805\n```\n\n```ncl\nprotocol ether [data]\n```\n\n```ncl\n#define ETHER_PTYPE 0x0806\n#define ETHER_ARPTYPE 0x0806\n#define ETHER_RARPType 0x0805\n```\n\n```ncl\nprotocol ether [data]\n```\n***ARP PROTOCOL***\n\n- **#define ARPHRD_EETHER** 1 /* ethernet hardware format */\n- **#define ARPHRD_FRELAY** 15 /* frame relay hardware format */\n- **#define ARPOP_REQUEST** 1 /* request to resolve address */\n- **#define ARPOP_REPLY** 2 /* response to previous request */\n- **#define ARPOP_REVREQUEST** 3 /* request protocol address given hardware */\n- **#define ARPOP_REVREPLY** 4 /* response giving protocol address */\n- **#define ARPOP_INVREQUEST** 8 /* request to identify peer */\n- **#define ARPOP_INVREPLY** 9 /* response identifying peer */\n\n```c\nstruct arp {\n uint8_t hwtype; // 1 or 2\n uint16_t htwlen; // 6 or 8\n uint8_t ptype; // 8 or 21\n uint16_t ptlen; // 8 or 8\n uint16_t op; // request or reply\n uint16_t sa; // source address\n uint16_t da; // destination address\n //... more fields...\n};\n```\n\n```c\nprotocol ether::arp {\n op = ARP_REQUEST && hwtype == 1\n && (htwlen == 6 || htwlen == 8)\n && ptype == ETHER::IP\n && (ptlen == 8 || ptlen == 8)\n && (hwtype == 1 || hwtype == 2)\n && !ether::broadcast && !ether::arp\n }\n```\n\n```c\nprotocol ARPv4 {\n src = ip::src\n dst = ip::dst\n proto = ip::proto\n flags = ip::flags\n ... more fields...\n}\n```\n\n- **#define OP_REQUEST** 1 /* request to resolve address */\n- **#define OP_REPLY** 2 /* response to previous request */\n- **#define OP_REVREQUEST** 3 /* request protocol address given hardware */\n- **#define OP_REVREPLY** 4 /* response giving protocol address */\n- **#define OP_INVREQUEST** 8 /* request to identify peer */\n- **#define OP_INVREPLY** 9 /* response identifying peer */\n\n```c\nprotocol ether::arp {\n op = ARP_REQUEST && hwtype == 1\n && (htwlen == 6 || htwlen == 8)\n && ptype == ETHER::IP\n && (ptlen == 8 || ptlen == 8)\n && (hwtype == 1 || hwtype == 2)\n && !ether::broadcast && !ether::arp\n }\n```\n\n```c\nprotocol ARPv4 {\n src = ip::src\n dst = ip::dst\n proto = ip::proto\n flags = ip::flags\n ... more fields...\n}\n```\nThe Application Services Library (ASL) provides a set of library functions available to action code that are useful for packet processing. The complete environment available to action code includes: the ASL, a restricted C/C++ library and runtime environment; one or more domain specific extensions such as TCP/IP.\n\nThe Restricted C/C++ Libraries and Runtime Environment\n\nAction code may be implemented in either the ANSI C or C++ programming languages. A library supporting most of the functions defined in the ANSI C and C++ libraries is provided. These libraries are customized for the NetBoost PE hardware environment, and as such differ slightly from their equivalents in a standard host operating system. Most notably, file operations are restricted to the standard error and output streams (which are mapped into upcalls).\n\nIn addition to the C and C++ libraries available to action code, NetBoost supplies a specialized C and C++ runtime initialization object module which sets up the C and C++ run-time environments by initializing the set of environment variables and, in the case of C++, executing constructors for static objects.\n\n1. ASL Functions\n\nThe ASL contains class definitions of potential use to any action code executing in the PE. It includes memory allocation, management of API objects (ACEs, targets), upcall/downcall support, set manipulation, timers, and a namespace support facility. The components comprising the ASL library are as follows:\n\nBasic Scalar Types\n\nThe library contains basic type definitions that include the number of bits represented. These include int8 (8 bit integers), int16 (16 bit integers), int32 (32 bit integers), and int64 (64 bit integers). In addition, unsigned values (uint8, uint16, uint32, uint64) are also supported.\n\nSpecial Endian-Sensitive Scalar Types\n\nThe ASL is commonly used for manipulating the contents of packets which are generally in network byte order. The\nASL provides type definitions similar to the basic scalar types, but which represent data in network byte order. Types in network byte order as declared in the same fashion as the basic scalar types but with a leading ‘@’ prefix (e.g. `uint16` refers to an unsigned 16 bit quantity in network byte order). The following functions are used to convert between the basic types (host order) and the network order types:\n\n```c\nuint32 ntohl(uint32 n); // network to host (32 bit)\nuint16 ntohs(uint16 n); // network to host (16 bit)\nuint32 htonl(uint32 n); // host to network (32 bit)\nuint16 htons(uint16 n); // host to network (16 bit)\n```\n\nMacros and Classes for Handling Errors and Exceptions in the ASL.\n\nThe ASL contains a number of C/C++ macro definitions used to aid in debugging and code development (and mark fatal error conditions). These are listed below:\n\n- `ASSERT` Macros (asserts boolean expression, halts on failure)\n- `CHECK` Macros (asserts boolean, returns from current real-time loop on failure)\n- `STUB` Macros (gives message, c++ file name and line number)\n- `SIO` Macros (used to monitor value of a variable/expression during execution)\n\nExceptions\n\nThe ASL contains a number of functions available for use as exception handlers. Exceptions are a programming construct used to deliver error information up the call stack. The following functions are provided for handling exceptions:\n\n- `NAction_err` and `NAction_warn` functions to be invoked when exceptions are thrown.\n- `OnError` class, used to invoke functions during exception handling, mostly for debugger breakpoints.\n\nACE Support\n\nACE objects in the ASL contain the per-Ace state information. To facilitate common operations, the Base class ace’s pass and drop targets are provided by the base class and built when an Ace instance is constructed. If no write action is taken on a buffer that arrives at the Ace (i.e. none of the actions of matching rules indicates it took ownership), the buffer is sent to the pass target. The pass and drop functions (i.e. target take functions, below) may be used directly as actions within the NCL application description, or they may be called by other actions. Member functions of the Ace class include: pass( ), drop( ), enqRule( )—enable a rule, disRule( )—disable a rule.\n\nAction Support:\n\nThe init_act ions call is the primary entry point into the application’s Action code. It is used by the ASL startup code to initialize the PE portion of the Network Application. It is responsible for constructing an Ace object of the proper class, and typically does nothing else. Example syntax:\n\n```c\nNTIF init_actions( void* id, char* name, Image* obj)\n```\n\n```c\n{ return new ExampleAce(id, name, obj); }\n```\n\nThe function should return a pointer to an object Subclassed from the Ace class, or a NULL pointer if an Ace could not be constructed. Throwing an NAction_err or NAction_warn exception may also be appropriate and will be caught by the initialization code. Error conditions will be reported back to the Resolver as a failure to create the Ace.\n\nReturn Values from Action Code/Handlers\n\nWhen a rule’s action portion is invoked because the rule predication portion evaluated true, the action function must return a code indicating how processing should proceed. The action may return a code indicating it has disposed of the frame (ending the classification phase), or it may indicate it did not dispose of the frame, and further classification (rule evaluations) should continue. A final option available is for the action to return a defer code, indicating that it wishes to modify a frame, but that the frame is in use elsewhere. The return values are defined as C/C++ pre-processor definitions:\n\n```c\n#define RULE_DONE . . .\nActions should return RULE_DONE to terminate processing of rules and actions within the context of the current Ace; for instance, when a buffer has been sent to a target, or stored for later processing.\n#define RULE_CONT . . .\nActions should return RULE_CONT if they have merely observed the buffer and wish for additional rules and actions within the context of the current ace to be processed.\n#define RULE_DEFER . . .\nActions should return RULE_DEFER if they wish to modify a packet within a buffer but the buffer notes that the packet is currently busy elsewhere.\n```\n\nPredefined Actions\n\nThe common cases of disposing of a frame by either dropping it or sending it on to the next classification entity for processing is supported by two helper functions available to NCL code and result in calling the functions Ace::pass( ) or Ace::drop( ) within the ASL: action_pass (predefined action), passes frame to ‘pass target’, always returns RULE_DONE, action_drop (predefined action), passes frame to ‘drop target’, always returns RULE_DONE.\n\nUser-Defined Actions\n\nMost often, user-defined actions are used in an Ace. Such actions are implemented with the following calling structure.\n\nThe ACTNF return type is used to set up linkage. Action handlers take two arguments: pointer to the current buffer being processed, and the Ace associated with this action. Example:\n\n```c\nACTNF do_mcast(Buffer *buf, ExAce *ace) {\n ace->mcast_ct ++;\n count << ace->name() (\"=\"); << ace->mcast_ct << endi;\n return ace->drop(buf);\n}\n```\n\nThus, the Buffera and ExAce bravery types are passed to the handler. In this case, ExAce is derived from the base Ace class:\n\n```c\n#include \"NBAction/ NBAction.h\"\nclass ExAce : public Ace {\npublic:\n ExAce(ModuleId id, char *name, Image *obj) : Ace(id, name, obj), mcast_ct0() {} } \n int mcast_ct;\n```\nBuffer Management (Buffer Class)\n\nThe basic unit of processing in the ASL is the Buffer. All data received from the network is received in buffers, and all the data to be transmitted must be properly formatted into buffers. Buffers are reference-counted. Contents are typed (more specifically, the type of the first header has a certain type [an integer/enum type]). Member functions of the Buffer class support common trimming operations (trim head, trim tail) and additions (prepend and append date). Buffers are assigned a timestamp upon arrival and departure (if they are transmitted). The memory function xTime() returns receipt time stamp of the frame contained in the buffer. The xTime() function gives transmission complete time stamp of the buffer if the frame it contains has been transmitted. Several additional member functions and operators are supported: new( )—allocates buffer from pool structure (see below), headerBase( )—location of first network header, headerOffset( )—reference to byte offset from start of storage to first network header, packetSize( )—number of bytes in frame, headerType( )—type of first header, packetPadHeadSize( )—space before net packet, packetPadTailSize( )—space after net packet, prepend( )—add data to beginning, append( )—add data to end, trim_head( )—remove data from head, trim_tail( )—remove data from end. {rx, tx} Time( )—see above, next( )—reference to next buffer on chain, incref( )—bump reference count, decref( )—decrement reference count, busy( )—indicates buffer being processed, log( )—allows for adding info to the \"transaction log\" of a buffer which can indicate what has processed it.\n\nTargets\n\nTarget objects within an Ace indicate the next hardware or software resource that will classify a buffer along a selected path. Targets are bound to another Ace within the same application, an Ace within a different application, or a built-in resource such as a file system. Bindings for Targets are set up by the user (see above). The class includes the member function take( ) which sends a buffer to the next downstream entity for classification.\n\nTargets have an associated module and Ace (specified by a \"ModuleName\" object and an Ace*). They also have a name in the name space contained in the resolver, which associates Aces to applications.\n\nUpcall\n\nAn upcall is a form of procedure call initiated in the PE module and handled in the AP module. Upcalls provide communication between the \"inline\" portion of an application and its \"sloppy path\" executing in the host environment. Within the ASL, the upcall facility sends messages to the AP. Messages are defined below. The upcall class contains the member function call( )—which takes objects of type Message* and sends them asynchronously to AP module.\n\nDowncallHandler\n\nA downcall is a form of procedure call initiated in the AP module and handled in the PE module. Downcalls provide the opposite direction of communication than upcalls. The class contains the member function direct( ) which provides a pointer to the member function of the Ace class that is to be invoked when the associated downcall is requested in the AP. The Ace member function pointed to takes a Message* type as an argument.\n\nMessage\n\nMessages contain zero, one, or two blocks of message data, which are independently constructed using the MessageBlock constructors (below). Uninitialized blocks will appear at the Upcall handler in the AP module as zero-length messages. Member functions of the Message class include: msg1( ), msg2( ), len1( ), len2( )—returns addresses and lengths of the messages [if present]. Other member functions: clr1( ), clr2( ), done( )—acknowledge receipt of a message and free resources.\n\nMessageBlock\n\nThe MessageBlock class is used to encapsulate a region of storage within the Policy Engine memory that will be used in a future Upcall Message. It also includes a method to be called when the service software has copied the data out of that storage and no longer needs it to be stable (and can allow it to be recycled). Constructor syntax is as follows:\n\n```\nMessageBlock(char *msg, int len=0, DoneFp done=0);\nMessageBlock(Bufg *buf);\nMessageBlock(int len, int elf=0);\n```\n\nThe first form specifies an existing data area to be used as the data source. If the completion callback function (DoneFp) is specified, it will be called when the data has been copied out of the source area. Otherwise, no callback is made and no special actions are taken after the data is copied out of the message block. If no length is specified, then the base pointer is assumed to point to a zero-terminated string; the length is calculated to include the null termination. The second form specifies a Buffer object; the data transferred is the data contained within the buffer, and the relative alignment of the data within the 32-bit word is retained. The reference count on the buffer is incremented when the MessageBlock is created, and the callback function is set to decrement the reference count when the copy out is complete. This will have the effect of marking the packet as \"busy\" for any actions that check for busy buffers, as well as preventing the buffer from being recycled before the copy out is complete. The third form requests that MessageBlock handle dynamic allocation of a region of memory large enough to hold a message of a specified size. Optionally, a second parameter can be specified that gives the offset from the 32-bit word alignment boundary where the data should start. The data block will retain this relative byte offset throughout its transfer to the Application Processor. This allows, for instance, allocating a 1514-byte data area with 2-byte offset, building an Ethernet frame within it, and having any IP headers included in the packet land properly aligned on 32-bit alignment boundaries.\n\nSets\n\nSets are an efficient way to track a large number of equivalence classes of packets, so that state can be kept for all packets that have the same values in specific fields. For instance, the programmer might wish to count the number of packets that flow between any two specific IP address pairs, or keep state for each TCP stream. Sets represent collections of individual members, each one of which matches buffers with a specific combination of field values. If the program-\nmmer instead wishes to form sets of the form “the set of all packets with IP header lengths greater than twenty bytes,” then the present form of sets are not appropriate; instead, a Classification Predicate should be used.\n\nIn NCL, the only information available regarding a set is whether or not a set contained a record corresponding to a vector of search keys. Within the ASL, all other set operations are supported: searches, insertions, and removals. For searches conducted in the CE, the ASL provides access to additional information obtained during the search operation: specifically, a pointer to the actual element located (for successful searches), and other helpful information such as an insertion pointer (on failure). The actual elements stored in each set are of a class constructed by the compiler, or are of a class that the software vendor has subclassed from that class. The hardware environment places strict requirements on the alignment modulus and alignment offset for each set element.\n\nAs shown in the NCL specification, a single set may be searched by several vectors of keys, resulting in multiple search results that share the same target element records. Each of these directives results in the construction of a function that fills the key fields of the suitable Element subclass from a buffer.\n\nWithin the ASL, the class set is used to abstract a set. It serves as a base class for compiler generated classes specific to the sets specified in the NCL program (see below).\n\nSearch\nThe Search class is the data type returned by all set searching operations, whether provided directly by the ASL or executed within the classification engine. Member functions: ran( )—true if the CE executed this search on a set, hit( )—true if the CE found a match using this search, miss( )—inverse of hit( ) but can return a cookie making inserts faster, toElement( )—converts successful search result to underlying object, insert( )—insert an object at the place the miss( ) function indicates we should.\n\nElement\nContents of sets are called elements, and the NCL compiler generates a collection of specialized classes derived from the Element base class to contain user-specified data within set elements. Set elements may have an associated timeout value, indicating the maximum amount of time the set element should be maintained. After the time out is reached, the set element is automatically removed from the set. The time out facility is useful for monitoring network activity such as packet flows that should eventually be cleared due to inactivity.\n\nCompiler-Generated Elt_<setname> Classes\nFor each set directive in the NCL program, the NCL compiler produces an adjusted subclass of the Element class called Elt_<setname>, substituting the name of the set for <setname>. This class is used to define the type of elements of the specified set. Because each set declaration contains the number of keys needed to search the set, this compiler-generated class is specialized from the element base class for the number of words of search key being used.\n\nCompiler-Generated Set_<setname> Classes\nFor each set directive in the NCL program, the NCL compiler produces an adjusted subclass of the Element class called Set_<setname>, substituting the name of the set for <setname>. This class is used to define the lookup functions of the specified set. The NCL compiler uses the number of words of keys information to customize the parameter list for the lookup function; the NCL size_limit is used to adjust a protected field within the class. Aces that needing to manipulate sets should include an object of the customized Set class as a member of their Ace.\n\nEvents\nThe Event class provides for execution of functions at arbitrary times in the future, with efficient rescheduling of the event and the ability to cancel an event without destroying the event marker itself. A calendar queue is used to implement the event mechanism. When constructing objects of the Event class, two optional parameters may be specified: the function to be called (which must be a member function of a class based on Event), and an initial scheduled time (how long in the future, expressed as a Time object). When both parameters are specified, the event’s service function is set and the event is scheduled. If the Time parameter is not specified, the Event’s service function is still set but the event is not scheduled. If the service function is not set, it is assumed that the event will be directed to a service function before it is scheduled in the future. Member functions of this class include: direct( )—specifies what function to be executed at expiry, schedule( )—indicates how far in the future for event to trigger, cancel( )—un-schedule event, curr( )—get time of currently running event.\n\nRate\nThe Rate class provides a simple way to track event rates and bandwidths in order to watch for rates exceeding desired values. The Rate constructor allows the application to specify arbitrary sampling periods. The application can (optionally) specify how finely to divide the sampling period. Larger divisors result in more precise rate measurement but require more overhead, since the Rate object schedules Events for each of the shorter periods while there are events within the longer period. Member functions of this class include: clear( )—reset internal state, add( )—bumps event count, count( )—gives best estimate of current trailing rate of events over last/longer period.\n\nTime\nThe Time class provides a common format for carrying around a time value. Absolute, relative, and elapsed times are all handled identically. As conversions to and from int64 (a sixty-four bit unsigned integer value) are provided, all scalar operators are available for use; in addition, the assignment operators are explicitly provided. Various other classes use Time objects to specify absolute times and time intervals. For maximum future flexibility in selection of storage formats, the actual units of the scalar time value are not specified; instead, they are stored as a class variable. Extraction of meaningful data should be done via the appropriate access methods rather than by direct arithmetic on the Time object.\n\nClass methods are available to construct Time objects for specified numbers of standard time units (milliseconds, microseconds, seconds, minutes, hours, days and weeks); also, methods are provided for extraction of those standard time periods from any Time object. Member functions include: curr( )—returns current real time, operators: +=, -=, /=, *=, ?<, <<=, >>, >>=, &<, &>, &<, accessors+builders: usec(), msec(), sec(), min(), hour(), days(), week(), which access or build Time objects using the specified number of microseconds, milliseconds, seconds, minutes, hours, days, and weeks, respectively.\n\nMemory Pool\nThe Pool class provides a mechanism for fast allocation of objects of fixed sizes at specified offsets from specified power-of-two alignments, restocking the raw memory\nresources from the PE module memory pool as required. The constructor creates an object that describes the contents of the memory pool and contains the configuration control information for how future allocations will be handled.\n\nSpecial ‘offset’ and ‘restock’ parameters are used. The offset parameter allows allocation of classes where a specific member needs to be strongly aligned; for example, objects from the Buffer class contain an element called hand that must start at the beginning of a 2048-byte-aligned region. The restock parameter controls how much memory is allocated from the surrounding environment when the pool is empty. Enough memory is allocated to contain at least the requested number of objects, of the specified size, at the specified offset from the alignment modulus. Member function include: take( )—allocate a chunk, free( )—return a chunk to the pool.\n\nTagged Memory Pool\n\nObjects that carry with them a reference back to the pool from which they were taken are called tagged. This is most useful for cases when the code that frees the object will not necessarily know what pool it came from. This class is similar to normal Memory Pools, except for internal details and the calling sequence for freeing objects back into the pool. The tagged class trades some additional space overhead for the flexibility of being able to free objects without knowing which Tagged pool they came from; this is similar to the overhead required by most C library malloc implementations. If the object has strong alignment requirements, the additional word of overhead could cause much space to be wasted between the objects. For instance, if the objects were 32 bytes long and were required to start on 32-byte boundaries, the additional word would cause another 28 bytes of padding to be wasted between adjacent objects.\n\nThe Tagged class adds a second (static) version of the take method, which is passed the size of the object to be allocated. The Tagged class manages an appropriate set of pools based on possible object sizes, grouping objects of similar size together to limit the number of pools and allow sharing of real memory between objects of slightly different sizes. Member functions include: take( )—allocate a chunk, free( )—return a chunk to the pool.\n\nDynamic\n\nThis class takes care of overloading the new and delete operators, redirecting the memory allocation to use a number of Tagged Pools managed by the NBAction DLL. All classes derived from Dynamic share the same set of Tagged Pools; each pool handles a specific range of object sizes, and objects of similar sizes will share the same Tagged Pool. The dynamic class has no storage requirements and no virtual functions. Thus, declaring objects derived from Dynamic will not change the size or layout of your objects (just how they are allocated). Operators defined include: new( )—allocate object from underlying pool, delete( )—return to underlying pool.\n\nName Dictionary\n\nThe Name class keeps a database of named objects (that are arbitrary pointers in the memory address space of the ASL). It provides mechanisms for adding objects to the dictionary, finding objects by name, and removing them from the dictionary. It is implemented with a Patricia Tree (a structure often used in longest prefix match in routing table lookups). Member functions include: find( )—look up string, name( )—return name of dictionary.\n\n2. ASL Extensions for TCP/IP\n\nThe TCP/IP Extensions to the Action Services Library (ASL) provides a set of class definitions designed to make several tasks common to TCP/IP-based network-oriented applications easier. With functions spanning several protocol layers, it includes operations such as IP fragment reassembly and TCP stream reconstruction. Note that many of the functions that handle Internet data make use of 16 and 32-bit data types, including both struct and struct2. These data types refer to data in network byte order (i.e., little endian). Functions used to convert between host and network byte order such as htonl( ) (which converts a 32-bit word from host to network byte order), are also defined.\n\n3. The Internet Class\n\nFunctions of potential use to any Internet application are grouped together as methods of the Internet class. These functions are declared static within the class, so that they may be used easily without requiring an instantiation of the Internet class.\n\nInternet Checksum Support\n\nThe Internet Checksum is used extensively within the TCP/IP protocols to provide reasonably high assurance that data has been delivered correctly. In particular, it is used in IP (for headers), TCP and UDP (for headers and data), ICMP (for headers and data), and IGMP (for headers).\n\nThe Internet checksum is defined to be the 1's complement of the sum of a region of data, where the sum is computed using 16-bit words and 1's complement addition.\n\nComputation of this checksum is documented in a number of RFCs (available from http://www.internic.net/rfc). RFC 1356 describes the hardware implementation, RFC 1634 and RFC 1141 describe incremental updates, RFC 1071 describes a number of mathematical properties of the checksum and how to compute it quickly. RFC 1071 also includes a copy of IEN 45 (from 1978), which describes motivations for the design of the checksum.\n\nThe ASL provides the following functions to calculate Internet Checksums:\n\ncalculate\n\nDescription\n\nComputes the Internet Checksum of the data specified. This function works properly for data aligned to any byte boundary, but may perform (significantly) better for 32-bit aligned data.\n\nSyntax\n\nstatic uint16 Internet::calculate(u_char* base, int len);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>base</td>\n<td>unsigned char*</td>\n<td>The starting address of the data.</td>\n</tr>\n<tr>\n<td>len</td>\n<td>int</td>\n<td>The number of bytes of data.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\n\nReturns the Internet Checksum in the same byte order as the underlying data, which is assumed to be in network byte order (big endian).\n\npsum\n\nDescription\n\nComputes the 2’s-complement of a region of data taken as 16-bit words. The Internet Checksum for the\nspecified data region may be generated by folding any carry bits above the low-order 16 bits and taking the 1's complement of the resulting value.\n\nSyntax\nstatic uint32 Internet::psum(u_char* base, int len);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>base</td>\n<td>uint32</td>\n<td>The starting address of the data.</td>\n</tr>\n<tr>\n<td>len</td>\n<td>int</td>\n<td>The number of bytes of data.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nReturns the 2's-complement 32-bit sum of the data treated as an array of 16-bit words.\n\nincrcksum\n\nDescription\nComputes a new Internet Checksum incrementally. That is, a new checksum is computed given the original checksum for a region of data, a checksum for a block of data to be replaced, and a checksum of the new data replacing the old data. This function is especially useful when small regions of packets are modified and checksums must be updated appropriately (e.g. for decrementing IP ttl fields or rewriting address fields for NAT).\n\nSyntax\nstatic uint16 Internet::incrcksum(uint16 ocksum, uint16 odsum, uint16 ndsum);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ocksum</td>\n<td>uint16</td>\n<td>The original checksum.</td>\n</tr>\n<tr>\n<td>odsum</td>\n<td>uint16</td>\n<td>The checksum of the old data.</td>\n</tr>\n<tr>\n<td>ndsum</td>\n<td>uint16</td>\n<td>The checksum of the new (replacing) data.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nReturns the computed checksum.\n\napsum\n\nDescription\nThe function apsum computes the checksum over only the IP source and destination addresses.\n\nSyntax\nstatic uint16 apsum(IP4Header* hdr);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>hdr</td>\n<td>IP4Header*</td>\n<td>Pointer to the header.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nReturns the checksum.\n\napsasm\n\nDescription\nThe function apsum behaves like apsum, but covers the TCP ACK field instead of the sequence number field.\n\nSyntax\nstatic uint16 apsum(IP4Header* hdr);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>hdr</td>\n<td>IP4Header*</td>\n<td>Pointer to the header.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nReturns the checksum.\n\napsasum\n\nDescription\nThe function apsum behaves like apsum but covers the IP addresses, ports, plus the TCP ACK and sequence numbers.\nSyntax\n\nstatic uint16 apsasum(IP4Header* hdr);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>hdr</td>\n<td>IP4Header*</td>\n<td>Pointer to the header.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\n\nReturns the checksum.\n\n4. IP Support\n\nThis section describes the class definitions and constants used in processing IP-layer data. Generally, all data is stored in network byte order (big endian). Thus, care should be taken by the caller to ensure computations result in proper values when processing network byte ordered data on little endian machines (e.g. in the NetBoost software-only environment on pC-compatible architectures).\n\n5. IP Addresses\n\nThe IP4Addr class defines 32-bit IP version 4 addresses.\n\nConstructors\n\nDescription\n\nThe class IP4Addr is the abstraction of an IP (version 4) address within the ASL. It has two constructors, allowing for the creation of the IPv4 addresses given an unsigned 32-bit word in either host or network byte order. In addition, the class is derived from uint32, so IP addresses may generally be treated as 32-bit integers in network byte order.\n\nSyntax\n\nIP4Addr(uint32 an);\nIP4Addr(uint32 ah);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>an</td>\n<td>uint32</td>\n<td>Unsigned 32-bit word in network byte order.</td>\n</tr>\n<tr>\n<td>ah</td>\n<td>uint32</td>\n<td>Unsigned 32-bit word in host byte order.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\n\nNone.\n\nExample\n\nThe following simple example illustrates the creation of addresses:\n\n```c\n#include \"NBip.h\"\n\nuint32 myhaddr = (128 << 24)(32 << 16)(12 << 8)4;\nuint32 mynaddr = htonl((128 << 24)(32 << 16)(12 << 8)4);\nIP4Addr ip1(myhaddr);\nIP4Addr ip2(mynaddr);\n```\n\nThis example creates two IP4Addr objects, each of which refer to the IP address 128.32.12.4. Note the use of the htonl( ) ASL function to convert the host 32-bit word into network byte order.\n\n6. IP Masks\n\nMasks are often applied to IP addresses in order to determine network or subnet numbers, CIDR blocks, etc. The class IP4Mask is the ASL abstraction for a 32-bit mask, available to be applied to an IPv4 address (or for any other use).\n\nConstructor\n\nDescription\n\nInstantiates the IP4Mask object with the mask specified.\n\nSyntax\n\nIP4Mask(uint32 nm);\nIP4Mask(uint32 mh);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>mh</td>\n<td>uint32</td>\n<td>32-bit mask in host byte order</td>\n</tr>\n<tr>\n<td>nh</td>\n<td>uint32</td>\n<td>32-bit mask in network byte order</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\n\nNone.\n\nleftcontig\n\nDescription\n\nReturns true if all of the 1-bits in the mask are left-contiguous, and returns false otherwise.\n\nSyntax\n\nbool leftcontig( );\n\nParameters\n\nNone.\n\nReturn Value\n\nReturns true if all the 1-bits in the mask are left-contiguous.\n\nExample\n\n```c\n#include NBip.h\n\nuint32 mymask = 0x0FFFF00; // 255.255.255.128 or /25\nIP4Mask ipm(mymask);\nint abits = ipm.bits( );\nif (abits >= 0) {\n sprintf(msgbuf, \"Mask is of the form %d\", abits);\n} else {\n sprintf(msgbuf, \"Mask is not left-contiguous\");\n}\n```\nThis example creates a subnet mask with 25 bits, and sets up a message buffer containing a string which describes the form of the mask (using the common \"slash notation\" for subnet masks).\n\n7. IP Header\n\nThe IP4Header class defines the standard IP header, where sub-byte sized fields have been merged in order to reduce byte-order dependencies. In addition to the standard IP header, the class includes a number of methods for convenience. The class contains no virtual functions, and therefore pointers to the IP4Header class may be used to point to IP headers received in live network packets.\n\nThe class contains a number of member functions, some of which provide direct access to the header fields and others which provide computed values based on header fields. Members which return computed values are described individually; those functions which provide only simple access to fields are as follows:\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Return Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>vlh( )</td>\n<td>uint8&</td>\n<td>Returns a reference to the byte containing the IP version and header length</td>\n</tr>\n<tr>\n<td>tos( )</td>\n<td>uint8&</td>\n<td>Returns a reference to the IP type of service byte</td>\n</tr>\n<tr>\n<td>len( )</td>\n<td>uint8&</td>\n<td>Returns a reference to the IP datagram (fragment) length in bytes</td>\n</tr>\n<tr>\n<td>id( )</td>\n<td>uint16&</td>\n<td>Returns a reference to the IP identification field (used for fragmentation)</td>\n</tr>\n<tr>\n<td>offset( )</td>\n<td>uint16&</td>\n<td>Returns a reference to the word containing fragmentation flags and fragment offset</td>\n</tr>\n<tr>\n<td>ttl( )</td>\n<td>uint8&</td>\n<td>Returns a reference to the IP time-to-live byte</td>\n</tr>\n<tr>\n<td>proto( )</td>\n<td>uint8&</td>\n<td>Returns a reference to the IP protocol byte</td>\n</tr>\n<tr>\n<td>cksum( )</td>\n<td>uint16&</td>\n<td>Returns a reference to the IP checksum</td>\n</tr>\n<tr>\n<td>src( )</td>\n<td>IP4Addr&</td>\n<td>Returns a reference to the IP source address</td>\n</tr>\n<tr>\n<td>dst( )</td>\n<td>IP4Addr&</td>\n<td>Returns a reference to the IP destination address</td>\n</tr>\n</tbody>\n</table>\n\nThe following member functions of the IP4Header class provide convenient methods for accessing various information about an IP header.\n\noptbase\n\nDescription\nReturns the location of the first IP option in the IP header (if present).\n\nSyntax\nunsigned char* optbase( );\n\nParameters\nNone.\n\nReturn Value\nReturns the address of the first option present in the header. If no options are present, it returns the address of the first byte of the payload.\n\nhl\n\nDescription\nThe first form of this function returns the number of 32-bit words in the IP header. The second form modifies the header length field to be equal to the specified length.\n\nSyntax\nint hl( )\nvoid hl(int h);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>v</td>\n<td>int</td>\n<td>Specifies the version number.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nThe first form returns the version field of the IP header.\n\npayload\n\nDescription\nThe function payload returns the address of the first byte of data (beyond any options present).\n\nSyntax\nunsigned char* payload( );\n\nParameters\nNone.\n\nReturn Value\nReturns the address of the first byte of payload data in the IP packet.\n\npsum\n\nDescription\nThe function psum is used internally by the ASL library, but may be useful to some applications. It returns the 16-bit\none's complement sum of the source and destination IP addresses plus 8-bit protocol field [in the low-order byte]. It is useful in computing pseudo-header checksums for UDP and TCP.\n\nSyntax\n\nuint32 psum();\n\nParameters\n\nNone.\n\nReturn Value\n\nReturns the 16-bit one's complement sum of the source and destination IP addresses plus the 8-bit protocol field.\n\nDefinitions\n\nIn addition to the IP header itself, a number of definitions are provided for manipulating fields of the IP header with specific semantic meanings.\n\nFragmentation\n\n<table>\n<thead>\n<tr>\n<th>Define</th>\n<th>Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>IP_DF</td>\n<td>0x0000</td>\n<td>Don't fragment flag, RFC 791, p. 13.</td>\n</tr>\n<tr>\n<td>IP_OFFSETMASK</td>\n<td>0x1FF</td>\n<td>Mask for determining the fragment offset from the IP header offset() function.</td>\n</tr>\n</tbody>\n</table>\n\nLimitations\n\n| IP_MAX_PACKET | 65535 | Maximum IP datagram size. |\n\nIP Service Type\n\nThe following table contains the definitions for IP type of service byte (not commonly used):\n\n<table>\n<thead>\n<tr>\n<th>Define</th>\n<th>Value</th>\n<th>Reference</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>IFTOS_LOWDELAY</td>\n<td>0x10</td>\n<td>RFC 791, p. 12.</td>\n</tr>\n<tr>\n<td>IFTOS_THROUGPUT</td>\n<td>0x08</td>\n<td>RFC 791, p. 12.</td>\n</tr>\n<tr>\n<td>IFTOS_RELIABILITY</td>\n<td>0x04</td>\n<td>RFC 791, p. 12.</td>\n</tr>\n<tr>\n<td>IFTOS_MINCOST</td>\n<td>0x02</td>\n<td>RFC 1349.</td>\n</tr>\n</tbody>\n</table>\n\nIP Precedence\n\nThe following table contains the definitions for IP precedence. All are from RFC 791, p. 12 (not widely used).\n\n<table>\n<thead>\n<tr>\n<th>Define</th>\n<th>Value</th>\n<th>Reference</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>IFTOS_PREC_NETCONTROL</td>\n<td>0x30</td>\n<td></td>\n</tr>\n<tr>\n<td>IFTOS_PREC_INTERNETCONTROL</td>\n<td>0x00</td>\n<td></td>\n</tr>\n<tr>\n<td>IFTOS_PREC_CRITIC_ECP</td>\n<td>0xA0</td>\n<td></td>\n</tr>\n<tr>\n<td>IFTOS_PREC_FLASHOVERIDE</td>\n<td>0x80</td>\n<td></td>\n</tr>\n<tr>\n<td>IFTOS_PREC_FLASH</td>\n<td>0x00</td>\n<td></td>\n</tr>\n<tr>\n<td>IFTOS_PREC_IMMEDIATE</td>\n<td>0x00</td>\n<td></td>\n</tr>\n<tr>\n<td>IFTOS_PREC_PRIORITY</td>\n<td>0x20</td>\n<td></td>\n</tr>\n<tr>\n<td>IFTOS_PREC_ROUTINE</td>\n<td>0x00</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nOption Definitions\n\nThe following table contains the definitions for supporting IP options. All definitions are from RFC 791, pp. 15–23.\n\n<table>\n<thead>\n<tr>\n<th>Define</th>\n<th>Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>IPOPT_COPIED</td>\n<td>(o)&(o&0x80)</td>\n<td>A macro which returns true if the option 'o' is to be copy upon fragmentation.</td>\n</tr>\n<tr>\n<td>IPOPT_CLASS</td>\n<td>(o)&(o&0x60)</td>\n<td>A macro giving the option class for the option 'o'.</td>\n</tr>\n<tr>\n<td>IPOPT_NUMBER</td>\n<td>(o)&(o&0x1F)</td>\n<td>A macro giving the option number for the option 'o'.</td>\n</tr>\n<tr>\n<td>IPOPT_CONTROL</td>\n<td>0x30</td>\n<td>Control class.</td>\n</tr>\n<tr>\n<td>IPOPT_RESERVED</td>\n<td>0x20</td>\n<td>Reserved.</td>\n</tr>\n<tr>\n<td>IPOPT_DEBMEAS</td>\n<td>0x40</td>\n<td>Debugging and/or measurement class.</td>\n</tr>\n<tr>\n<td>IPOPT_RESERVED2</td>\n<td>0x60</td>\n<td>Reserved.</td>\n</tr>\n<tr>\n<td>IPOPT_EOL</td>\n<td>0</td>\n<td>End of option list.</td>\n</tr>\n<tr>\n<td>IPOPT_NOP</td>\n<td>1</td>\n<td>No operation.</td>\n</tr>\n<tr>\n<td>IPOPT_RR</td>\n<td>7</td>\n<td>Record route.</td>\n</tr>\n<tr>\n<td>IPOPT_TS</td>\n<td>68</td>\n<td>Time stamp.</td>\n</tr>\n<tr>\n<td>IPOPT_SECURITY</td>\n<td>130</td>\n<td>Incl. e, h, t, c.</td>\n</tr>\n<tr>\n<td>IPOPT_ESR</td>\n<td>131</td>\n<td>Loose source route.</td>\n</tr>\n<tr>\n<td>IPOPT_SATID</td>\n<td>136</td>\n<td>Satnet ID.</td>\n</tr>\n<tr>\n<td>IPOPT_SRR</td>\n<td>137</td>\n<td>Strict source route.</td>\n</tr>\n<tr>\n<td>IPOPT_TA</td>\n<td>148</td>\n<td>Router alert.</td>\n</tr>\n</tbody>\n</table>\n\nOptions Field Offsets\n\nThe following table contains the offsets to fields in options other than EOL and NOP.\n\n<table>\n<thead>\n<tr>\n<th>Define</th>\n<th>Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>IPOPT_OPTVAL</td>\n<td>0</td>\n<td>Option ID.</td>\n</tr>\n<tr>\n<td>IPOPT_OLEN</td>\n<td>1</td>\n<td>Option length.</td>\n</tr>\n<tr>\n<td>IPOPT_OFFSET</td>\n<td>2</td>\n<td>Offset within option.</td>\n</tr>\n<tr>\n<td>IPOPT_MINOFF</td>\n<td>4</td>\n<td>Minimum value of offset.</td>\n</tr>\n</tbody>\n</table>\n\n7. Fragments and Datagrams\n\nThe IP protocol performs adaptation of its datagram size by an operation known as fragmentation. Fragmentation allows for an initial (large) IP datagram to be broken into a sequence of IP fragments, each of which is treated as an independent packet until they are received and reassembled at the original datagram's ultimate destination. Conventional IP routers never reassemble fragments but instead route them independently, leaving the destination host to reassemble them. In some circumstances, however, applications running on the NetBoost platform may wish to reassemble fragments themselves (e.g. to simulate the operation of the destination host).\n\n8. IP Fragment class\n\nWithin the ASL, a fragment represents a single IP packet (containing an IP header), which may or may not be a complete IP layer datagram. In addition, a datagram within the ASL represents a collection of fragments. A datagram (or fragment) is said to be complete if it represents or contains all the fragments necessary to represent an entire IP-layer datagram.\n\nThe IP4 Fragment class is defined as follows.\n\nConstructors\n\nDescription\n\nThe IP4Fragment class provides the abstraction of a single IP packet placed in an ASL buffer (see the description of the Buffer elsewhere in this chapter). It has meaningful only for use by applications.\n\nThe first of these allows for specifying the buffer containing an IP fragment as the parameter bp. The loca-\ntion of the of the IP header within the buffer is the second argument. This is the most commonly-used constructor when processing IP fragments in ACE action code.\n\nThe second form of the constructor performs the same steps as the first form, but also allocates a new Buffer object and copies the IP header pointed to by iph into the new buffer (if specified). This form of the constructor is primarily intended for creation of IP fragments during IP datagram fragmentation. If the specified header contains IP options, only those options which are copied during fragmentation are copied.\n\nSyntax\nIP4Fragment(Buffer* bp, IP4Header* iph);\nIP4Fragment(int maxiplen, IP4Header* protohdr = 0);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>bp</td>\n<td>Buffer*</td>\n<td>The starting address of the buffer containing the IP fragment.</td>\n</tr>\n<tr>\n<td>maxiplen</td>\n<td>int</td>\n<td>The maximum size of the fragment being created, used to size the allocated Buffer.</td>\n</tr>\n<tr>\n<td>protohdr</td>\n<td>IP4Header*</td>\n<td>The IP4 header to copy into the buffer, if provided. If the header contains IP options, only those options normally copied during fragmentation are copied.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nDestructor\nFree the fragment.\n\nSyntax\n~IP4Fragment( );\n\nParameters\nNone.\n\nReturn Value\nNone.\n\nhdr\nDescription\nThe function hdr returns the address of the IP header of the fragment.\n\nSyntax\nIP4Header* hdr( );\n\nParameters\nNone.\n\nReturn Value\nReturns the address of the IP4Header class at the beginning of the fragment.\n\npayload\nDescription\nThe function payload returns the address of the first byte of data in the IP fragment (after the basic header and options).\n\nSyntax\nu_char* payload( );\n\nParameters\nNone.\n\nReturn Value\nReturns the address of the first byte of data in the IP fragment.\n\nbuf\nDescription\nThe function buf returns the address of the Buffer structure containing the IP fragment.\n\nSyntax\nBuffer* buf( );\n\nParameters\nNone.\n\nReturn Value\nReturns the address of the Buffer structure containing the IP fragment. This may return NULL if there is no buffer associated with the fragment.\n\nnext\nDescription\nReturns a reference to the pointer pointing to the next fragment of a doubly-linked list of fragments. This is used to link together fragments when they are reassembled (in Datagrams), or queued, etc. Typically, fragments are linked together in a doubly-linked list fashion with NULL pointers indicating the list endpoints.\n\nSyntax\nIP4Fragment*& next( );\n\nParameters\nNone.\n\nReturn Value\nReturns a reference to the internal linked-list pointer.\n\nprev\nDescription\nLike next, but returns a reference to pointer to the previous fragment on the list.\n\nSyntax\nIP4Fragment*& prev( );\n\nParameters\nNone.\n\nReturn Value\nReturns a reference to the internal linked-list pointer.\n\nfirst\nDescription\nThe function first returns true when the fragment represents the first fragment of a datagram.\n\nSyntax\nbool first( );\n\nParameters\nNone.\nReturn Value\nReturns true when the fragment represents the first fragment of a datagram.\n\nDescription\nFragments an IP datagram comprising a single fragment. The fragment function allocates Buffer structures to hold the newly-formed IP fragments and links them together. It returns the head of the doubly-linked list of fragments. Each fragment in the list will be limited in size to at most the specified MTU size. The original fragment is unaffected.\n\nSyntax\nIP4Datagram* fragment(int mtu);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>mtu</td>\n<td>int</td>\n<td>The maximum transmission unit MTU size limiting the maximum fragment size</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nReturns a pointer to an IP4Datagram object containing a doubly-linked list of IP4Fragment objects. Each fragment object is contained within a Buffer class allocated by the ASL library. The original fragment object (the one fragmented) is not freed by this function. The caller must free the original fragment when it is no longer needed.\n\ncomplete\nDescription\nThe function complete returns true when the fragment represents a complete IP datagram.\n\nSyntax\nbool complete();\n\nParameters\nNone.\n\nReturn Value\nReturns true when the fragment represents a complete IP datagram (that is, when the fragment offset field is zero and there are no additional fragments).\n\noptcopy\nDescription\nThe static method opt copy is used to copy options from one header to another during IP fragmentation. The function will only copy those options that are supposed to be copied during fragmentation (i.e. for those options x where the macro IPOPT_COPIED(x) is non zero (true)).\n\nSyntax\nstatic int optcopy(IP4Header* src, IP4Header* dst);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>src</td>\n<td>IP4Header*</td>\n<td>Pointer to the source IP header containing options</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nDestructor\nDescription\nThe destructor calls the destructors for each of the fragments comprising the datagram and frees the datagram object.\n\nlen\nDescription\nThe len function returns the entire length (in bytes) of the datagram, including all of its comprising fragments. Its value is only meaningful if the datagram is complete.\nSyntax\nint len();\n\nParameters\nNone.\n\nReturn Value\nReturns the length of the entire datagram (in bytes). If the datagram contains multiple fragments, only the size of the first fragment header is included in this value.\n\nDescription\nThe fragment function breaks an IP datagram into a series of IP fragments, each of which will fit in the packet size specified by mtu. Its behavior is equivalent to the IP4Fragment::fragment(int mtu) function described previously.\n\nSyntax\nIP4Datagram* fragment(int mtu);\n\nParameters\nSee IP4Fragment::fragment(int mtu) above.\n\nReturn Value\nSee IP4Fragment::fragment(int mtu) above.\n\nDescription\nThe function insert inserts a fragment into the datagram. The function attempts to reassemble the overall datagram by checking the IP offset and ID fields.\n\nSyntax\nint insert(IP4Fragment* frag);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>frag</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the fragment being inserted.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nBecause this function can fail/act in a large number of ways, the following definitions are provided to indicate the results of insertions that were attempted by the caller. The return value is a 32-bit word where each bit indicates a different error or unusual condition. The first definition below, IPD_INSERT_ERROR is set whenever any of the other conditions are encountered. This is an extensible list which may evolve to indicate new error conditions in future releases:\n\nDefine Description\nIPD_INSERT_ERROR \"Or\" of all other error bits.\nIPD_INSERT_OH Head overlapped.\nIPD_INSERT_OT Tail overlapped.\nIPD_INSERT_MISMATCH Payload mismatch.\nIPD_INSERT_CKFAIL IP header checksum failed (if enabled)\n\nnfrags\n\nDescription\nThe function nfrags returns the number of fragments currently present in the datagram.\n\nSyntax\nint nfrags();\n\ncomplete\n\nDescription\nThe function complete returns true when all fragments comprising the original datagram are present.\n\nSyntax\n\nbool complete();\n\nParameters\nNone.\n\nReturn Value\nReturns a boolean value indicating when all fragments comprising the original datagram are present.\n\nhead\n\nDescription\nThe function head returns the address of the first IP fragment in the datagram's linked list of fragments.\n\nSyntax\n\nIP4Fragment* head();\n\nParameters\nNone.\n\nReturn Value\nReturns the address of the first IP fragment in the datagram's linked list of fragments.\n\n10. UDP Support\nThe UDP protocol provides a best-effort datagram service. Due to its limited complexity, only the simple UDP header definitions are included here. Additional functions operating on several protocols (e.g. UDP and TCP NAT) are defined in subsequent sections.\n\n11. UDP Header\nThe UDPHeader class defines the standard UDP header. It is defined in NBudp.h. In addition to the standard UDP header, the class includes a single method for convenience in accessing the payload portion of the UDP datagram. The class contains no virtual functions, and therefore pointers to the UDPHeader class may be used to point to UDP headers received in live network packets.\n\nThe class contains a number of member functions, most of which provide direct access to the header fields. A special payload function may be used to obtain a pointer immediately beyond the UDP header. The following table lists the functions providing direct access to the header fields:\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Return Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>sport( )</td>\n<td>uint16_t</td>\n<td>Returns a reference to the source UDP port number</td>\n</tr>\n<tr>\n<td>dport( )</td>\n<td>uint16_t</td>\n<td>Returns a reference to the destination UDP port number</td>\n</tr>\n<tr>\n<td>len( )</td>\n<td>uint16_t</td>\n<td>Returns a reference to the UDP length field</td>\n</tr>\n<tr>\n<td>cksum( )</td>\n<td>uint16_t</td>\n<td>Returns a reference to the UDP checksums. UDP checksums are optional; a value of all zero bits indicates no checksum was computed.</td>\n</tr>\n</tbody>\n</table>\nThe following function provides convenient access to the payload portion of the datagram, and maintains consistency with other protocol headers (i.e. IP and TCP).\n\n**Function**\n\n**Description**\n\nThe function payload returns the address of the first byte of data (beyond the UDP header).\n\n**Syntax**\n\n```c\nunsigned char* payload( );\n```\n\n**Parameters**\n\nNone.\n\n**Return Value**\n\nReturns the address of the first byte of payload data in the UDP packet.\n\n12. TCP Support\n\nThe TCP protocol provides a stateful connection-oriented stream service. The ASL provides the TCP-specific definitions, including the TCP header, plus a facility to monitor the content and progress of an active TCP flow as a third party (i.e. without having to be an endpoint). For address and port number translation of TCP, see the section on NAT in subsequent sections of this document.\n\n13. TCP Sequence Numbers\n\nTCP uses sequence numbers to keep track of an active data transfer. Each unit of data transfer is called a segment, and each segment contains a range of sequence numbers. In TCP, sequence numbers are in byte units. If a TCP connection is open and data transfer is progressing from computer A to B, TCP segments will be flowing from A to B and acknowledgements will be flowing from B toward A. The acknowledgements indicate to the sender the amount of data the receiver has received. TCP is a bi-directional protocol, so that data may be flowing simultaneously from A to B and from B to A. In such cases, each segment (in both directions) contains data for one direction of the connection and acknowledgements for the other direction of the connection. Both sequence numbers (sending direction) and acknowledgment numbers (reverse direction) use TCP sequence numbers as the data type in the TCP header. TCP sequence numbers are 32-bit unsigned numbers that are allowed to wrap beyond 2^32-1. Within the ASL, a special class called TCPSeq defines this class and associated operators, so that objects of this type may be treated like ordinary scalar types (e.g. unsigned integers).\n\n14. TCP Header\n\nThe TCPHeader class defines the standard TCP header. In addition to the standard TCP header, the class includes a set of methods for convenience in accessing the payload portion of the TCP stream. The class contains no virtual functions, and therefore pointers to the TCPHeader class may be used to point to TCP headers received in live network packets.\n\nThe class contains a number of member functions, most of which provide direct access to the header fields. A special payload function may be used to obtain a pointer immediately beyond the TCP header. The following table lists the functions providing direct access to the header fields:\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Return Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dport( )</td>\n<td>uint16_t &</td>\n<td>Returns a reference to the destination TCP port number</td>\n</tr>\n<tr>\n<td>seq( )</td>\n<td>TCPSeq &</td>\n<td>Returns a reference to the TCP sequence number</td>\n</tr>\n<tr>\n<td>ack( )</td>\n<td>TCPSeq &</td>\n<td>Returns a reference to the TCP acknowledgement number</td>\n</tr>\n<tr>\n<td>off( )</td>\n<td>uint32_t</td>\n<td>Returns the number of 32-bit words in the TCP header (includes TCP options)</td>\n</tr>\n<tr>\n<td>flags( )</td>\n<td>uint8_t &</td>\n<td>Returns a reference to the byte containing the 6 flags bits and 2 reserved bits</td>\n</tr>\n<tr>\n<td>win( )</td>\n<td>uint16_t &</td>\n<td>Returns a reference to the window advertisement field (unscaled)</td>\n</tr>\n<tr>\n<td>cksum( )</td>\n<td>uint16_t &</td>\n<td>Returns a reference to the TCP pseudoheader checksum. TCP checksums are not optional.</td>\n</tr>\n<tr>\n<td>ulp( )</td>\n<td>uint16_t &</td>\n<td>Returns a reference to the TCP urgent pointer field</td>\n</tr>\n</tbody>\n</table>\n\nThe following functions provides convenient access to other characteristics of the segment: payload\n\n**Function**\n\n**Description**\n\nThe function payload returns the address of the first byte of data (beyond the TCP header).\n\n**Syntax**\n\n```c\nunsigned char* payload( );\n```\n\n**Parameters**\n\nNone.\n\n**Return Value**\n\nReturns the address of the first byte of payload data in the TCP packet.\n\n**Function**\n\n**Description**\n\nThe function window returns the window advertisement contained in the segment, taking into account the use of TCP large windows (see RFC 1323).\n\n**Syntax**\n\n```c\nuint32_t window(int wshift)\n```\n\n**Parameters**\n\n- wshift int: The \"window shift value\" (number of left-shift bit positions to scale window field)\n\n**Function**\n\n**Description**\n\nThe function optbase returns the address of the first option in the TCP header, if any are present. If no options are present, it returns the address of the first payload byte (which may be urgent data if the URG bit is set in the flags field).\nSyntax\n\nu_char* optbase( )\n\nParameters\n\nNone.\n\nReturn Value\n\nReturns the address of the first byte of data beyond the urgent pointer field of the TCP header.\n\nhlen\n\nDescription\n\nThe first form of this function ver returns the TCP header length in bytes. The second form assigns the TCP header length to the number of bytes specified.\n\nSyntax\n\nint hlen( );\n\nvoid hlen(int bytes);\n\nParameters\n\n- **Parameter**: bytes\n - **Type**: int\n - **Description**: Specifies the number of bytes present in the TCP header.\n\nReturn Value\n\nThe first form returns the number of bytes in the TCP header.\n\nDefinitions\n\nIn addition to the TCP header itself, a number of definitions are provided for manipulating options in TCP headers:\n\nTCP Options\n\n<table>\n<thead>\n<tr>\n<th>Define</th>\n<th>Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>TCLOPT_EOL</td>\n<td>0</td>\n<td>End of Option List</td>\n</tr>\n<tr>\n<td>TCLOPT_NOP</td>\n<td>1</td>\n<td>No operation (used for padding)</td>\n</tr>\n<tr>\n<td>TCLOPT_MAXSEG</td>\n<td>2</td>\n<td>Maximum segment size</td>\n</tr>\n<tr>\n<td>TCLOPT_SACK</td>\n<td>4</td>\n<td>Selective Acknowledgements</td>\n</tr>\n<tr>\n<td>PERMITTED</td>\n<td></td>\n<td>available</td>\n</tr>\n<tr>\n<td>TCLOPT_SACK</td>\n<td>5</td>\n<td>Selective Acknowledgements</td>\n</tr>\n<tr>\n<td>in this segment</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>TCLOPT_TIMESTAMP</td>\n<td>8</td>\n<td>Time stamps</td>\n</tr>\n<tr>\n<td>TCLOPT_CC</td>\n<td>11</td>\n<td>for TCP/CC (see RFC 1644)</td>\n</tr>\n<tr>\n<td>TCLOPT_CCNEW</td>\n<td>12</td>\n<td>for TCP/CC</td>\n</tr>\n<tr>\n<td>TCLOPT_CCECHO</td>\n<td>13</td>\n<td>for TCP/CC</td>\n</tr>\n</tbody>\n</table>\n\nTCP Following\n\nTCP operates as an 11-state finite state machine. Most of the states are related to connection establishment and teardown. By following certain control bits in the TCP headers of segments passed along a connection, it is possible to infer the TCP state at each endpoint, and to monitor the data exchanged between the two endpoints.\n\nDefines\n\nThe following definitions are for TCP state monitoring, and indicate states in the TCP finite state machine:\n\n<table>\n<thead>\n<tr>\n<th>Define</th>\n<th>Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>TCPS_CLOSED</td>\n<td>0</td>\n<td>Closed</td>\n</tr>\n<tr>\n<td>TCPS_LISTEN</td>\n<td>1</td>\n<td>Listening for connection.</td>\n</tr>\n<tr>\n<td>TCPS_SYN_SENT</td>\n<td>2</td>\n<td>Active open, have sent SYN.</td>\n</tr>\n<tr>\n<td>TCPS_SYN_RECEIVED</td>\n<td>3</td>\n<td>Have sent and received SYN.</td>\n</tr>\n<tr>\n<td>TCPS_ESTABLISHED</td>\n<td>4</td>\n<td>Established.</td>\n</tr>\n<tr>\n<td>TCPS_CLOSE_WAIT</td>\n<td>5</td>\n<td>Received FIN, waiting for closed.</td>\n</tr>\n<tr>\n<td>TCPS_FIN_WAIT_1</td>\n<td>6</td>\n<td>Have closed; sent FIN.</td>\n</tr>\n<tr>\n<td>TCPS_CLOSING</td>\n<td>7</td>\n<td>Closed exchanged FIN; awaiting FIN ACK.</td>\n</tr>\n<tr>\n<td>TCPS_LAST_ACK</td>\n<td>8</td>\n<td>Had FIN and close; await FIN ACK.</td>\n</tr>\n<tr>\n<td>TCPS_FIN_WAIT_2</td>\n<td>9</td>\n<td>Have closed, FIN is acked.</td>\n</tr>\n<tr>\n<td>TCPS_TIME_WAIT</td>\n<td>10</td>\n<td>In 2*MSL quiet wait after close.</td>\n</tr>\n<tr>\n<td>TCPS_HAVECVDYN(s)</td>\n<td>(s) => TCPS_SYN_RECEIVED</td>\n<td>True if state s indicates a SYN has been received</td>\n</tr>\n<tr>\n<td>TCPS_HAVEESTABLISHED(s)</td>\n<td>(s) => TCPS_ESTABLISHED</td>\n<td>True if state s indicates have established ever</td>\n</tr>\n<tr>\n<td>TCPS_HAVECVDFIN(s)</td>\n<td>(s) => TCPS_TIME_WAIT</td>\n<td>True if state s indicates a FIN ever received</td>\n</tr>\n</tbody>\n</table>\n\nNote 1: States less than TCPS_ESTABLISHED indicate connections not yet established.\n\nNote 2: States greater than TCPS_CLOSE_WAIT are those where the user has closed.\n\nNote 3: States greater than TCPS_CLOSE_WAIT and less than TCPS_FIN_WAIT_2 await ACK of FIN.\nThe TCPSegInfo Class\n\nThe TCPSegInfo class is a container class for TCP segments that have been queued during TCP stream reconstruction and may be read by applications (using the ReassemblyQueue::read function, defined below). When segments are queued, they are maintained in a doubly-linked list sorted by sequence number order. Note that the list may contain \"holes\". That is, it may contain segments that are not adjacent in the space of sequence numbers because some data is missing in between. In addition, because retransmitted TCP segments can potentially overlap one another's data areas, the starting and ending sequence number fields (startseq_ and endseq_) may not correspond to the starting sequence number.\n\nThe class contains the following fields, all of which are declared public:\n\n<table>\n<thead>\n<tr>\n<th>Field</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>prev_</td>\n<td>TCPSegInfo*</td>\n<td>Pointer to the next TCPSegInfo object of the forward linked list; NULL if no more</td>\n</tr>\n<tr>\n<td>next_</td>\n<td>TCPSegInfo*</td>\n<td>Pointer to the previous TCPSegInfo object of the reverse linked list; NULL if no previous segment exists</td>\n</tr>\n<tr>\n<td>segment_</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram containing the TCP segment</td>\n</tr>\n<tr>\n<td>startseq_</td>\n<td>TCPSeq</td>\n<td>The starting sequence number for the segment</td>\n</tr>\n<tr>\n<td>endseq_</td>\n<td>TCPSeq</td>\n<td>The ending sequence number for the segment</td>\n</tr>\n<tr>\n<td>startbuf_</td>\n<td>u_char</td>\n<td>Pointer to the byte whose sequence number is specified by the startseq_field</td>\n</tr>\n<tr>\n<td>endbuf_</td>\n<td>u_char</td>\n<td>Pointer to the byte whose sequence number is specified by the endseq_field</td>\n</tr>\n<tr>\n<td>flags_</td>\n<td>uint32</td>\n<td>Flags field for the segment (reserved as of the EA2 release)</td>\n</tr>\n</tbody>\n</table>\n\nThe ReassemblyQueue Class\n\nThe ReassemblyQueue class is a container class used in reconstructing TCP streams from TCP segments that have been \"snooped\" on a TCP connection. This class contains a list of TCPSegInfo objects, each of which corresponds to a single TCP segment. The purpose of this class is not only to contain the segments, but to reassemble received segments as they arrive and present them in proper sequence number order for applications to read. Applications are generally able to read data on the connection in order, or to skip past some fixed amount of enqueued data.\n\nConstructor\n\nDescription\n\nA ReassemblyQueue object is used internally by the TCP stream reconstruction facility, but may be useful to applications in general under some circumstances. It provides for reassembly of TCP streams based on sequence numbers contained in TCP segments. The constructor takes an argument specifying the next sequence number to expect. It is updated as additional segments are inserted into the object. If a segment is inserted which is not contiguous in sequence number space, it is considered \"out of order\" and is queued in the object until the \"hole\" (data between it and the previous in-sequence data) is filled.\n\nSyntax\n\nReassemblyQueue(TCPSeq & rcvnext)\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>rcvnext</td>\n<td>TCPSeq</td>\n<td>A reference to the next TCP sequence number to expect. The sequence number referred to by rcvnext is updated by the add function (see below) to always indicate the next in-order TCP sequence number expected</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nDefines\n\nThe following definitions are provided for insertion of TCP segments into a ReassemblyQueue object, and are used as return values for the add function defined below. Generally, acceptable conditions are indicated by bits in the low-order half-word, and suspicious or error conditions are indicated in the upper half-word.\n\n<table>\n<thead>\n<tr>\n<th>Define</th>\n<th>Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>RQ_OK</td>\n<td>0x00000000</td>\n<td>Segment was non-overlapping and in-order</td>\n</tr>\n<tr>\n<td>RQ_OUTORDER</td>\n<td>0x00000001</td>\n<td>Segment was out of order (didn't match next expected sequence number)</td>\n</tr>\n<tr>\n<td>RQ_LOW_OAP</td>\n<td>0x00000002</td>\n<td>Segment's sequence number was below next expected but segment extended past next expected</td>\n</tr>\n<tr>\n<td>RQ_HIGH_OAP</td>\n<td>0x00000004</td>\n<td>Segment's data overlapped another queued segment's data</td>\n</tr>\n<tr>\n<td>RQ_DUP</td>\n<td>0x00000008</td>\n<td>Completely duplicate segment</td>\n</tr>\n<tr>\n<td>RQ_BAD_HLEN</td>\n<td>0x00010000</td>\n<td>Bad header length (e.g. less than 5)</td>\n</tr>\n<tr>\n<td>RQ_BAD_RSV</td>\n<td>0x00020000</td>\n<td>Bad reserved field (reserved bits are non-zero)</td>\n</tr>\n<tr>\n<td>RQ_FLAGS_ALERT</td>\n<td>0x00040000</td>\n<td>Suspicious combination of flags (e.g. RST on or all on, etc)</td>\n</tr>\n<tr>\n<td>RQ_FLAGS_BADURP</td>\n<td>0x00080000</td>\n<td>Bad urgent pointer</td>\n</tr>\n</tbody>\n</table>\nadd\n\nDescription\nThe add function inserts an IP datagram or complete IP fragment containing a TCP segment into the reassembly queue. The TCP sequence number referenced by recvnt in the constructor is updated to reflect the next in-sequence sequence number expected.\n\nSyntax\nint add(IP4Datagram* dp, TCPSeq seq, uint32 dlen);\nint add(IP4Fragment* fp, TCPSeq seq, uint32 dlen);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to an unfragmented IP fragment containing a TCP segment</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>A pointer to a complete IP datagram containing a TCP segment</td>\n</tr>\n<tr>\n<td>seq</td>\n<td>TCPSeq</td>\n<td>Initial sequence number for the TCP segment</td>\n</tr>\n<tr>\n<td>dlen</td>\n<td>uint32</td>\n<td>Usable length of the TCP segment</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nReturns a 32-bit integer with the possible values indicated above (definitions beginning with RQ_).\n\nempty\n\nDescription\nThe empty function returns true if the reassembly queue contains no segments.\n\nSyntax\nbool empty( )\n\nParameters\nNone.\n\nReturn Value\nReturns true if the reassembly queue contains no segments.\n\nclear\n\nDescription\nThe clear function removes all queued segments from the reassembly queue and frees their storage.\n\nSyntax\nvoid clear( )\n\nParameters\nNone.\n\nReturn Value\nNone.\n\nread\n\nDescription\nThe read function provides application access to the contiguous data currently queued in the reassembly queue. The function returns a linked list of TCPSegInfo objects. The list is in order sorted by sequence number beginning with the first in-order sequence number and continues no further than the number of bytes specified by the caller. Note that the caller must inspect the value filled in by the call to determine how many byte worth of sequence number space is consumed by the linked list. This call removes the segments returned to the caller from the reassembly queue.\n\nSyntax\nTCPSegInfo* read(int& len);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>len</td>\n<td>int&</td>\n<td>Contains the number of bytes worth of in-sequence data the application is interested in reading from the reassembly queue. The underlying integer is modified by this call to indicate the number of bytes actually covered by the list of segments returned. The call is guaranteed to never return a larger number of bytes than requested.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nReturns a pointer to the first TCPSegInfo object in a doubly-linked list of objects each of which point to TCP segments that are numerically adjacent in TCP sequence number space.\n\nThe TCPEndpoint Class\nThe TCPEndpoint class is the abstraction of a single endpoint of a TCP connection. In TCP, a connection is identified by a 4-tuple of two IP addresses and two port numbers. Each endpoint is identified by a single IP address and port number. Thus, a TCP connection (or \"session\"—see below) actually comprises two endpoint objects. Each endpoint contains the TCP finite state machine state as well as a ReassemblyQueue object, used to contain queued data. The TCPEndpoint class is used internally by the TCPSession class below, but may be useful to applications in certain circumstances.\n\nConstructor\nDescription\nThe TCPEndpoint class is created in an empty state and is unable to determine which endpoint of a connection it represents. The user should call the init function described below after object instantiation to begin use of the object.\n\nSyntax\nTCPEndpoint( )\n\nParameters\nNone.\n\nReturn Value\nNone.\n\nDestructor\nDescription\nDeletes all queued TCP segments and frees the object’s memory.\n\nSyntax\n~TCPEndpoint( )\n\nParameters\nNone.\n\nReturn Value\nNone.\nreset\nDescription\nResets the endpoint internal state to closed and clears any queued data.\nSyntax\n~TCPEndpoint()\nParameters\nNone.\nReturn Value\nNone.\nstate\nDescription\nReturns the current state in the TCP finite state machine associated with the TCP endpoint.\nSyntax\nint state()\nParameters\nNone.\nReturn Value\nReturns an integer indicating the internal state according to the definitions given above (defines beginning with TCPFS_).\ninit\nDescription\nThe init function provides initialization of a TCP endpoint object by specifying the IP address and port number the endpoint is acting as. After this call has been made, subsequent processing of IP datagrams and fragments containing TCP segments (and ACKs) is accomplished by the process calls described below.\nSyntax\nvoid init(IP4Addr* myaddr, uint16 myport);\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>myaddr</td>\n<td>IP4Addr*</td>\n<td>A pointer to the IP address identifying this TCP endpoint</td>\n</tr>\n<tr>\n<td>myport</td>\n<td>uint16</td>\n<td>The port number (in network byte order) of port number identifying this TCP endpoint</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\nprocess\nDescription\nThe process function processes an incoming or outgoing TCP segment relative to the TCP endpoint object. The first form of the function operates on a datagram which must be complete; the second form operates on a fragment which must also be complete. Given that the TCPEndpoint object is not actually the literal endpoint of the TCP connection itself, it must infer state transitions at the literal endpoints based upon observed traffic. Thus, it must monitor both directions of the TCP connection to properly follow the state at each literal endpoint.\nSyntax\nint process(IP4Datagram* pd);\nint process(IP4Fragment* pf);\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>pd</td>\n<td>IP4Datagram*</td>\n<td>A pointer to a complete IP datagram containing a TCP segment</td>\n</tr>\n<tr>\n<td>pf</td>\n<td>IP4Fragment*</td>\n<td>Pointer to an unfragmented IP fragment containing a TCP segment</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nReturns a 32-bit integer with the same semantics defined for ReassemblyQueue::add (see above).\nThe TCPSession Class\nThe TCPSession class is the abstraction of a complete, bi-directional TCP connection. It includes two TCP endpoint objects, which each include a reassembly queue. Thus, provided the TCPSession object is able to process all data sent on the connection in either direction it will have a reasonably complete picture of the progress and data exchanged across the connection.\nConstructor\nDescription\nThe TCPSession object is created by the caller when a TCP segment arrives on a new connection. The session object will infer from the contents of the segment which endpoint will be considered the client (the active opener—generally the sender of the first SYN), and which will be considered the server (the passive opener—generally the sender of the first SYN+ACK). In circumstances of simultaneous active opens (a rare case when both endpoints send SYN packets), the notion of client and server is not well defined, but the session object will behave as though the sender of the first SYN received by the session object is the client. In any case, the terms client and server are only loosely defined and do not affect the proper operation of the object.\nSyntax\nTCPSession(IP4Datagram* dp);\nTCPSession(IP4Fragment* fp);\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>pd</td>\n<td>IP4Datagram*</td>\n<td>A pointer to a complete IP datagram containing the first TCP segment on the connection</td>\n</tr>\n<tr>\n<td>pf</td>\n<td>IP4Fragment*</td>\n<td>Pointer to a complete IP fragment containing the first TCP segment on the connection</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\nDestructor\nDescription\nDeletes all TCP segments queued and frees the object’s memory.\nSyntax\n~TCPSession( )\nParameters\nNone.\nReturn Value\nNone.\n\nprocess\nDescription\nThe process function processes a TCP segment on the connection. The first form of the function operates on a\ndatagram which must be complete; the second form operates on a fragment which must also be complete. This function\noperates by passing the datagram or fragment to each endpoint’s process function.\nSyntax\nint process(IP4Datagram* pd);\nint process(IP4Fragment* pf);\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>pd</td>\n<td>IP4Datagram*</td>\n<td>A pointer to a complete IP datagram containing a TCP segment</td>\n</tr>\n<tr>\n<td>pf</td>\n<td>IP4Fragment*</td>\n<td>Pointer to an unfragmented IP fragment containing a TCP segment</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nReturns a 32-bit integer with the same semantics defined for ReassemblyQueue::add (see above). The value returned\nwill be the result of calling the add function of the reassembly queue object embedded in the endpoint object corre-\nsponding to the destination address and port of the received segment.\n\n16. Network Address Translation (NAT)\nNetwork Address Translation (NAT) refers to the general ability to modify various fields of different protocols so that\nthe effective source, destination, or source and destination entities are replaced by an alternative. The definitions to\nperform NAT for the IP, UDP, and TCP protocols are defined within the ASL. The NAT implementation uses incremental\nchecksum computation, so performance should not degrade in proportion to packet size.\n\n17. IP NAT\nIP address translation refers to the mapping of an IP datagram (fragment) with source and destination IP address\n(s1, d1) to the same datagram (fragment) with new address pair (s2, d2). A source-rewrite only modifies the source\naddress (d1 is left equal to d2). A destination rewrite implies only the destination address is rewritten (s1 is left equal to\ns2). A source and destination rewrite refers to a change in both the source and destination IP addresses. Note that for IP\nNAT, only the IP source and/or destination addresses are rewritten (in addition to rewriting the IP header checksum).\nFor traffic such as TCP or UDP, NAT functionality must include modification of the TCP or UDP pseudo-header\nchecksum (which covers the IP header source and destination addresses plus protocol field). Properly performing\nNAT on TCP or UDP traffic, requires attention to these details.\n\n18. IP NAT Base Class\nThe class IPNat provides a base class for other IP NAT classes. Because of the pure virtual function rewrite, applica-\ntions will not create objects of type IP4Nat directly, but rather use the objects of types IP4SNat, IP4DNat, and\nIP4SNat defined below.\nrewrite\nDescription\nThis pure-virtual function is defined in derived classes. It performs address rewriting in a specific fashion imple-\nmented by the specific derived classes (i.e. source, destination, or source/destination combination). The rewrite call, as\napplied to a fragment, only affects the given fragment. When applied to a datagram, each of the fragment headers com-\nprising the datagram are re-written.\nSyntax\nvirtual void rewrite(IP4Datagram* fp) = 0;\nvirtual void rewrite(IP4Fragment* fp) = 0;\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram to rewrite</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the single fragment to rewrite</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nThere are three classes available for implementing IP\nNAT: all of which are derived from the base class IP4Nat.\nThe classes IP4SNat, IP4DNat, and IP4SNat define the\nstructure of objects implementing source, destination, and\nsource/destination rewriting for IP datagrams and fragments.\n\n19. IP4SNat class\nThe IP4 SNat class is derived from the IP4Nat class. It\ndefines the class of objects implementing source rewriting\nfor IP datagrams and fragments.\nConstructor\nDescription\nInstantiates the IP4 SNat object.\nSyntax\nIP4SNat(IP4Addr* newsrc);\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>newsrc</td>\n<td>IP4Addr*</td>\n<td>Pointer to the new source address for IP NAT.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\nrewrite\nDescription\nDefines the pure virtual rewrite functions in the parent\nclass.\nSyntax\nvoid rewrite(IP4Datagram* dp);\nvoid rewrite(IP4Fragment* fp);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram to be rewritten (all fragment headers are modified)</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the fragment to rewrite (only the single fragment header is modified)</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\n20. IP4DNat Class\nThe IP4 DNat class is derived from the IP4Nat class. It defines the class of objects implementing destination rewriting for IP datagrams and fragments.\n\nConstructor\nDescription\nInstantiates the IP4 DNat object.\n\nSyntax\nIP4DNat(IP4Addr* newsrc, IP4Addr* newdst);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>newsrc</td>\n<td>IP4Addr*</td>\n<td>Pointer to the new source address for IP NAT.</td>\n</tr>\n<tr>\n<td>newdst</td>\n<td>IP4Addr*</td>\n<td>Pointer to the new destination address for IP NAT.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nrewrite\nDescription\nDefines the pure virtual rewrite functions in the parent class.\n\nSyntax\nvoid rewrite(IP4Datagram* dp);\nvoid rewrite(IP4Fragment* fp);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram to be rewritten (all fragment headers are modified)</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the fragment to rewrite (only the single fragment header is modified)</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nExample\nFor fragments, only the single fragment is modified. For datagrams, all comprising fragments are updated. The following simple example illustrates the use of one of these objects:\n\nAssuming ipm1 is an address we wish to place in the IP packet's destination address field, buf points to the ASL buffer containing an IP packet we wish to rewrite, and iph points the IP header of the packet contained in the buffer:\n\nIPDNat *ipd = new IPDNat(&ipm1); // create IP DNat object\nIP4Fragment ipf(buf, iph); // create IP fragment object\nipd rewrite(&ipf); // rewrite fragment's header\n\nThe use of other IP NAT objects follows a similar pattern.\n\n22. UDP NAT\nThe organization of the UDP NAT classes follows the IP NAT classes very closely. The primary difference is in the handling of UDP ports. For UDP NAT, the optional rewriting of port numbers (in addition to IP layer rewriting) is specified in the constructor.\n23. UDPNat Base Class\n\nThe class UDPNat provides a base class for other UDP NAT classes. The constructor is given a value indicating whether port number rewriting is enabled. Because of the pure virtual function rewrite, applications will not create objects of type UDPNat directly, but rather use the objects of type UDPSNat, UDPDNat, and UDPSDNNat defined below.\n\nConstructor\n\nDescription\nThe constructor is given a value indicating whether port number rewriting is enabled.\n\nSyntax\n\nUDPNat(bool doports);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>doports</td>\n<td>bool</td>\n<td>Boolean value indicating whether the port number rewriting is enabled. A true value indicates port number rewriting is enabled.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nrewrite\n\nDescription\nThis pure-virtual function is defined in derived classes. It performs address rewriting in a specific fashion implemented by the specific derived classes (e.g., source, destination, or source/destination combination). The rewrite call, as applied to a fragment, only affects the given fragment. When applied to a datagram, each of the fragment headers comprising the datagram are re-written.\n\nSyntax\n\nvirtual void rewrite(IP4Datagram*fp) = 0;\nvirtual void rewrite(IP4Fragment*fp) = 0;\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram to rewrite</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the single fragment to rewrite</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nports\n\nDescription\nThe first form of this function returns true if the NAT object is configured to rewrite port numbers. The second form of this function configures the object to enable or disable port number rewriting using the values true and false, respectively.\n\nSyntax\n\nbool ports();\nvoid ports(bool p);\n\n24. UDPSNat Class\n\nThe UDPSNat class is derived from the UDPNat class. It defines the class of objects implementing source address and (optionally) port number rewriting for complete and fragmented UDP datagrams.\n\nConstructors\n\nDescription\nThe single-argument constructor is used to create UDP NAT objects that rewrite only the addresses in the IP header (and update the IP header checksum and UDP pseudo-header checksum appropriately). The two-argument constructor is used to create NAT objects that also rewrite the source port number in the UDP header. For fragmented UDP datagrams, the port numbers will generally be present in only the first fragment.\n\nSyntax\n\nUDPSNat(IP4Addr* newsaddr, uint16 newsport);\nUDPSNat(IP4Addr* newsaddr); \n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>newsaddr</td>\n<td>IP4Addr*</td>\n<td>Pointer the new source address to be used</td>\n</tr>\n<tr>\n<td>newsport</td>\n<td>uint16</td>\n<td>The new source port number to be used</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nrewrite\n\nDescription\nDefines the pure virtual rewrite functions in the parent class.\n\nSyntax\n\nvoid rewrite(IP4Datagram* dp);\nvoid rewrite(IP4Fragment* fp);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram to be rewritten (all fragment headers are modified)</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the fragment to rewrite (only the single fragment header is modified). Should only be called when the fragment represents a complete UDP/IP datagram.</td>\n</tr>\n</tbody>\n</table>\nReturn Value\nNone.\n\n25. UDPDNat Class\nThe UDPDNat class is derived from the UDPNAT class. It defines the class of objects implementing destination address and (optionally) port number rewriting for complete and fragmented UDP datagrams.\n\nConstructors\n\nDescription\nThe single-argument constructor is used to create UDP NAT objects that rewrite only the addresses in the IP header (and update the IP header checksum and UDP pseudo-header checksum appropriately). The two-argument constructor is used to create NAT objects that also rewrite the destination port number in the UDP header. For fragmented UDP datagrams, the port numbers will generally be present in only the first fragment.\n\nSyntax\n\nUDPSNat(IP4Addr* newaddr, uint16 newport);\nUDPSNat(IP4Addr* newaddr);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>newaddr</td>\n<td>IP4Addr*</td>\n<td>Pointer the new source address to be used</td>\n</tr>\n<tr>\n<td>newport</td>\n<td>uint16</td>\n<td>The new destination port number to be used</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nrewrite\n\nDescription\nDefines the pure virtual rewrite functions in the parent class.\n\nSyntax\n\nvoid rewrite(IP4Datagram* dp);\nvoid rewrite(IP4Fragment* fp);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram to be rewritten (all fragment headers are modified)</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the fragment to rewrite (only the single fragment header is modified). Should only be called when the fragment represents a complete UDP/IP datagram.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\n26. UDPDSNAT Class\nThe UDPDSNAT class is derived from the UDPNAT class. It defines the class of objects implementing source and destination address and (optionally) port number rewriting for complete and fragmented UDP datagrams.\n\nConstructors\n\nDescription\nThe two-argument constructor is used to create UDP NAT objects that rewrite only the addresses in the IP header (and update the IP header checksum and UDP pseudo-header checksum appropriately). The four-argument constructor is used to create NAT objects that also rewrite the source and destination port number in the UDP header. For fragmented UDP datagrams, the port numbers will generally be present in only the first fragment.\n\nSyntax\n\nUDPSNat(IP4Addr* newsaddr, uint16 newport, IP4Addr* newdaddr, uint16 newdport);\nUDPSNat(IP4Addr* newsaddr, IP4Addr* newdaddr);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>newsaddr</td>\n<td>IP4Addr*</td>\n<td>Pointer the new source address to be used</td>\n</tr>\n<tr>\n<td>newport</td>\n<td>uint16</td>\n<td>The new source port number to be used</td>\n</tr>\n<tr>\n<td>newsaddr</td>\n<td>IP4Addr*</td>\n<td>Pointer the new destination address to be used</td>\n</tr>\n<tr>\n<td>newdport</td>\n<td>uint16</td>\n<td>The new destination port number to be used</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nrewrite\n\nDescription\nDefines the pure virtual rewrite functions in the parent class.\n\nSyntax\n\nvoid rewrite(IP4Datagram* dp);\nvoid rewrite(IP4Fragment* fp);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram to be rewritten (all fragment headers are modified)</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the fragment to rewrite (only the single fragment header is modified). Should only be called when the fragment represents a complete UDP/IP datagram.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\n27. TCP NAT\nThe structure of the TCP NAT support classes follow the UDP classes very closely. The primary difference is in the handling of TCP sequence and ACK numbers.\n\n28. TCPNAT Base Class\nThe class TCPNAT provides a base class for other TCP NAT classes. The constructor is given a pair of values indicating whether port number, sequence number,\nacknowledgement number rewriting is enabled. Sequence number and ACK number rewriting are coupled such that enabling sequence number rewriting for source-rewriting will modify the sequence number field of the TCP segment, but enabling sequence number rewriting for destination-rewriting will instead modify the ACK field. This arrangement makes it possible to perform NAT on TCP streams without unnecessary complexity in the TCP NAT interface. Because of the pure virtual function rewrite, applications will not create objects of type TCPSNat directly, but rather use the objects of type TCPSNat, TCPSDNat, and TCPDSDNat defined below.\n\nConstructor\n\nDescription\n\nThe constructor is given a value indicating whether port number rewriting is enabled.\n\nSyntax\n\nTCPNat(bool doports, bool dosenqs);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>doports</td>\n<td>bool</td>\n<td>Boolean value indicating whether the port number rewriting is enabled. A true value indicates port number rewriting is enabled.</td>\n</tr>\n<tr>\n<td>dosenqs</td>\n<td>bool</td>\n<td>Boolean value indicating whether the sequence/ACK number rewriting is enabled. A true value indicates sequence/ACK number rewriting is enabled.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\n\nNone.\n\nrewrite\n\nDescription\n\nThis pure-virtual function is defined in derived classes. It performs address rewriting in a specific fashion implemented by the specific derived classes (i.e. source, destination, or source/destination combination). The rewrite call, as applied to a fragment, only affects the given fragment. When applied to a datagram, each of the fragment headers comprising the datagram are re-written.\n\nSyntax\n\nvirtual void rewrite(IP4Datagram* dp) = 0;\nvirtual void rewrite(IP4Fragment* fp) = 0;\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram to rewrite</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the single fragment to rewrite</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\n\nNone.\n\nports\n\nDescription\n\nThe first form of this function returns true if the NAT object is configured to rewrite port numbers. The second form of this function configures the object to enable or disable port number rewriting using the values true and false, respectively.\n\nSyntax\n\nbool ports();\nvoid ports(bool p);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>p</td>\n<td>bool</td>\n<td>Boolean indicating whether port number rewriting is enabled.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\n\nThe first form of this function returns true if the NAT object is configured to rewrite TCP port numbers.\n\nseqs\n\nDescription\n\nThe first form of this function returns true if the NAT object is configured to rewrite sequence/ACK numbers. The second form of this function configures the object to enable or disable sequence/ACK number rewriting using the values true and false, respectively.\n\nSyntax\n\nbool seqs ( );\nvoid seqs (bool s);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>s</td>\n<td>bool</td>\n<td>Boolean indicating whether sequence/ACK number rewriting is enabled.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\n\nThe first form of this function returns true if the NAT object is configured to rewrite TCP port numbers.\n\n29. TCPSNat Class\n\nThe TCPSNat class is derived from the TCPNat class. It defines the class of objects implementing source address and (optionally) port number and sequence number rewriting for complete and fragmented TCP segments.\n\nConstructors\n\nDescription\n\nThe single-argument constructor is used to create TCP NAT objects that rewrite only the addresses in the IP header (and update the IP header checksum and TCP pseudo-header checksum appropriately). The two-argument constructor is used to create NAT objects that also rewrite the source port number in the TCP header. The three-argument constructor is used to rewrite the IP address, source port number, and to modify the TCP sequence number by a relative (constant) amount. The sequence offset provided may be positive or negative.\nSyntax\nTCPSNat(IP4Addr* newsaddr);\nTCPSNat(IP4Addr* newsaddr, uint16 newport);\nTCPSNat(IP4Addr* newsaddr, uint16 newport, long seqoff);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>newsaddr</td>\n<td>IP4Addr*</td>\n<td>Pointer to the new source address to be used</td>\n</tr>\n<tr>\n<td>newport</td>\n<td>uint16</td>\n<td>The new source port number to be used</td>\n</tr>\n<tr>\n<td>seqoff</td>\n<td>long</td>\n<td>Relative change to make to TCP sequence number fields. A positive value indicates the TCP sequence number is increased by the amount specified. A negative value indicates the sequence number is reduced by the amount specified.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nDescription\nDefines the pure virtual rewrite functions in the parent class.\n\nSyntax\nvoid rewrite(IP4Datagram* dp);\nvoid rewrite(IP4Fragment* fp);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram to be rewritten (all fragment headers are modified)</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the fragment to rewrite (only the single fragment header is modified). Should only be called when the fragment represents a complete TCP/IP segment.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\n30. TCPSDNat Class\nThe TCPSDNat class is derived from the TCPSnat class. It defines the class of objects implementing source address and (optionally) port number and sequence number/ACK number rewriting for complete and fragmented TCP segments.\n\nConstructors\n\nDescription\nThe two-argument constructor is used to create TCP NAT objects that rewrite only the addresses in the IP header (and update the IP header checksum and TCP pseudo-header checksum appropriately). The four-argument constructor is used to create NAT objects that also rewrite the source and destination port numbers in the TCP header. The three-argument constructor is used to rewrite the IP address, source port number, and to modify the TCP ACK number by a relative (constant) amount. The ACK offset provided may be positive or negative.\n\nSyntax\nTCPSDNat(IP4Addr* newsaddr, IP4Addr* newdaddr);\nTCPSDNat(IP4Addr* newsaddr, uint16 newport, IP4Addr* newdaddr, uint16 newdport);\nTCPSDNat(IP4Addr* newsaddr, uint16 newport, long seqoff);\nIP4Addr* newdaddr, uint16 newdport, long ackoff); \n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>newsaddr</td>\n<td>IP4Addr*</td>\n<td>The new source address to be used</td>\n</tr>\n<tr>\n<td>newport</td>\n<td>uint16</td>\n<td>The new source port number to be used</td>\n</tr>\n<tr>\n<td>seqoff</td>\n<td>long</td>\n<td>Relative change to make to TCP sequence number fields. A positive value indicates the TCP sequence number is increased by the amount specified. A negative value indicates the sequence number is reduced by the amount specified.</td>\n</tr>\n<tr>\n<td>newdaddr</td>\n<td>IP4Addr*</td>\n<td>The new destination address to be used</td>\n</tr>\n<tr>\n<td>newdport</td>\n<td>uint16</td>\n<td>The new destination port number to be used</td>\n</tr>\n<tr>\n<td>ackoff</td>\n<td>long</td>\n<td>Relative change to make to TCP ACK number fields. A positive value indicates the TCP ACK number is increased by the amount specified. A negative value indicates the ACK number is reduced by the amount specified.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nDescription\nDefines the pure virtual rewrite functions in the parent class.\n\nSyntax\nvoid rewrite(IP4Datagram* dp);\nvoid rewrite(IP4Fragment* fp);\n\nParameters\n\n<table>\n<thead>\n<tr>\n<th>Parameter</th>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>dp</td>\n<td>IP4Datagram*</td>\n<td>Pointer to the datagram to be rewritten (all fragment headers are modified)</td>\n</tr>\n<tr>\n<td>fp</td>\n<td>IP4Fragment*</td>\n<td>Pointer to the fragment to rewrite (only the single fragment header is modified). Should only be called when the fragment represents a complete TCP/IP segment.</td>\n</tr>\n</tbody>\n</table>\n\nReturn Value\nNone.\n\nNetBoost Platform\n\nFIGS. 1-4 depict a sample platform for use with the compiler described above.\n\nFIG. 1 shows a Network Infrastructure Application, called Application 2, being deployed on an Application Processor (AP) 4 running a standard operating system. The policy\nenforcement section of the Application 2, called Wire Speed Policy 3, runs on the Policy Engine (PE) 6. The Policy Engine 6 transforms the inbound Packet Stream 8 into the outbound Packet Stream 10 per the Wire Speed Policy 3. Communications from the Application Processor 4 to the Policy Engine 6, in addition to the Wire Speed Policy 3, consists of control, policy modifications and packet data as desired the Application 2. Communication from the Policy Engine 3 to the Application Processor 4 consists of status, exception conditions and packet data as desired by the Application 2.\n\nIn a preferred embodiment of a Policy Engine (PE) according to the present invention, the PE provides a highly programmable platform for classifying network packets and implementing policy decisions about those packets at wire speed. Certain embodiments provide two Fast Ethernet ports and implement a pipelined dataflow architecture with store-and-forward. Packets are run through a Classification Engine (CE) which executes a programmed series of hardware assist operations such as chained field comparisons and generation of checksums and hash pointers, then are handed to a microprocessor (\"Policy Processor\" or PP) for execution of policy decisions such as Pass, Drop, Enqueue/Delay, (de/encapsulate, and (de/enc)rypt based on the results from the CE. Some packets which require higher level processing may be sent to the host computer system (\"Application Processor\" or AP). (See FIG. 4.) An optional cryptographic (\"Crypto\") Processor is provided for accelerating such functions as encryption and key management.\n\nCE programs can be written directly in binary; however for programmer convenience a microassembly language was has been developed which allows a microcode to be constructed by declaring fields and their values in a symbolic form. The set of common microwords for the intended use of the CE have also been described in a higher-level CE Assembly Language called masm which allows the programmer to describe operations in a register-transfer format and to describe concurrent operations without having to worry about the details of microcode control of the underlying hardware. Both of these languages can be used by a compiler which translates CE programs from a higher-level language such as NetBoost Classification Language (NCL).\n\nA sample system level block diagram is shown in FIG. 4. FIG. 4 shows an application processor 302 which contains a host interface 304 to a PCI bus 324. Fanout of the PCI bus 324 to a larger number of loads is accomplished with PCI-to-PCI Bridge devices 306, 308, 310, and 312; each of those controls an isolated segment on a \"child\" PCI bus 326, 328, 330, and 332 respectively. On these of these isolated segments 326, 328, 330, and 332 is a number of Policy Engines 322, each Policy Engine 322 connects to two Ethernet ports 320 which connects the Policy Engine 322 to a network segment.\n\nOne of the PCI-to-PCI Bridges 312 controls child PCI bus 322, which provides the Application Processor 302 with connection to standard I/O devices 314 and optionally to PCI expansion slots 316 into which additional PCI devices can be connected.\n\nIn a smaller configuration of the preferred embodiment of the invention the number of Policy Engines 322 does not exceed the maximum load allowed on a PCI bus 324; in that case the PCI-to-PCI bridges 306, 308, and 310 are eliminated and up to four Policy Engines 322 are connected directly to the host PCI bus 324, each connecting also to two Ethernet ports 320. This smaller configuration may still have the PCI-to-PCI Bridge 312 present to isolate Local I/O 314 and expansion slots 316 from the PCI bus 324, or the Bridge 312 may also be eliminated and the devices 314 and expansion 316 may also be connected directly to the host PCI bus 324.\n\nIn certain embodiments, the PE utilizes two Fast Ethernet MAC's (Media Access Controllers) with IEEE 802.3 standard Media Independent Interface (\"MII\") connections to external physical media (PHY) devices which attach to Ethernet segments. Each Ethernet MAC receives packets into buffers addressed by buffer pointers obtained from a producer-consumer ring and then passes the buffer (that is, passes the buffer pointer) to a Classification Engine for processing, and from there to the Policy Processor. The \"buffer pointer\" is a data structure comprising the address of a buffer and a software-assigned \"tag\" field containing other information about that buffer. The \"buffer pointer\" is a fundamental unit of communication among the various hardware and software modules comprising a PE. From the PP, there are many paths the packet can take, depending on what the application(s) running on the PP decide is the proper disposition of that packet. It can be transmitted, sent to Crypto, delayed in memory, passed through a Classification Engine again for further processing, or copied from the PE's memory over the PCI bus to the host's memory or to a peer device's memory, using the DMA engine. The PP may also gather statistics on that packet into records in a hash table or in general memory. A pointer to the buffer containing both the packet and data structures describing that packet is passed around among the various modules.\n\nThe PP may choose to drop a packet, to modify the contents of the packet, or to forward the packet to the AP or to a different network segment over the PCI Bus (e.g. for routing.) The AP or PP can create packets of its own for transmission. A 3rd-party NIC (Network Interface Card) on the PCI bus can use the PE memory for receiving packets, and the PP and AP can then cooperate to feed those packets into the classification stream, effectively providing acceleration for packets from arbitrary networks. When doing so, adjacent 2 KB buffers can be concatenated to provide buffers of any size needed for a particular protocol.\n\nFIG. 2 illustrates packet flow according to certain embodiments of the present invention. Each box represents a process which is applied to a packet buffer and/or the contents of a packet buffer. The buffer management process involves buffer allocation 102 and the recovery of retired buffers 118. When buffer allocation 102 into an RX Ring occurs, the Policy Processor 244 enqueues a buffer pointer into the RX Ring and thus allocates the buffer to the receive MAC 216 or 230, respectively. Upon receiving a packet, the RX MAC controller 220 or 228 uses the buffer pointer at the entry in the RX ring structure which is pointed to by MEI to identify a 2 KB section of memory 260 that it can use to store the newly received packet. This process of receiving a packet and placing it into a buffer is represented by physical receive 104 in FIG. 2.\n\nThe RX MAC controller 220 or 228 increments the MFILL pointer modulo ring size to signal that the buffer whose pointer is in the RX Ring has been filled with a new packet plus receive status. The Ring Translation Unit 264 detects a difference between MFILL and MCCONS and signals to the classification engine 238 or 242, respectively, for RX Ring, that a newly received packet is ready for processing. The Classification Engine 238 or 242 applies Classification 106 to that packet and creates a description of the packet which is placed in the packet buffer software area, then increments MCCONS to indicate that it has completed classification 106 of that packet. The Ring Translation Unit\n264 detects a difference between MCCONS and MPCONS and signals to the Policy Processor 244 that a classified packet is ready for action processing 108.\n\nThe Policy Processor 244 obtains the buffer pointer from the ring location by dequeueing that pointer from the RX Ring, and executes application-specific action code 108 to determine the disposition of the packet. The action code 108 may choose to send the packet to an Ethernet Transmit MAC 218 or 234 by enqueueing the buffer pointer on a TX Ring, respectively; the packet may or may not have been modified by the action code 108 prior to this. Alternatively the action code 108 may choose to send the packet to the attached cryptographic processor (Crypto) 246 for encryption, decryption, compression, decompression, security key management, parsing of IPSEC headers, or other associated functions; this entire bundle of functions is described by Crypto 112. Alternatively the action code 108 may choose to copy the packet to a PCI peer 322 or 314 or 316, or to the host memory 330, both paths being accomplished by the process 114 of creating a DMA descriptor as shown in Table 3 and then enqueuing the pointer to that descriptor into a DMA Ring by writing that pointer to DMA_PROD, which triggers the DMA Unit 210 to initiate a transfer. Alternatively the action code 118 can choose to temporarily enqueue the packet for delay 110 in memory 260 that is managed by the action code 118. Finally, the action code 108 can choose to send a packet for further classification 106 on any of the Classification Engines 208, 212, 238, or 242, either because the packet has been modified or because there is additional classification which can be run on the packet which the action code 108 can command the Classification process 106 to execute via flags in the RX Status Word, through the buffer’s software area, or by use of tag bits in the 32-bit buffer pointer reserved for that use.\n\nPackets can arrive at the classification process 106 from additional sources besides physical receive 104. Classification 106 may receive a packet from the output of the Crypto processing 112, from the Application Processor 302 or from a PCI peer 322 or 314 or 316, or from the application code 108.\n\nPackets can arrive at the action code 108 from classification 106, from the Application Processor 302, from a PCI peer 322 or 314 or 316, from the output of the Crypto processing 112, and from a delay queue 110. Additionally the action code 108 can create a packet. The disposition options for these packets are the same as those described for the receive path, above.\n\nThe Crypto processing 112 can receive a packet from the Policy Processor 244 as described above. The Application Processor 302 or a PCI peer 322 or 314 or 316 can also enqueue the pointer to a buffer onto a Crypto Ring to schedule that packet for Crypto processing 112. The TX MAC 218 or 234 transmits packets whose buffer pointer have been enqueued on the TX Ring, respectively. Those pointers may have been enqueued by the action code 106 running on the Policy Processor 244, by the Crypto processing 112, by the Application Processor 302, or by a PCI peer 322 or 314 or 316. When the TX MAC controller 222 or 232 has retired a buffer either by successfully transmitting the packet it contains, or by abandoning the transmit due to transmit termination conditions, it will optionally write back TX status and TX Timestamp if programmed to do so, then will increment MTCONS to indicate that this buffer has been retired. The Ring Transfer Unit 264 detects that there is a difference between MTCONS and MTREQCVR and signals to the Policy Processor 244 that the TX Ring has at least one retired buffer to recover; this triggers the buffer recovery process 118, which will dequeue the buffer pointer from the TX ring and either send the buffer pointer to Buffer Allocation 102 or will add the recovered buffer to a software-managed free list for later use by Buffer Allocation 102.\n\nIt is also possible for a device in the PCI expansion slot 316 to play the role defined for the attached Crypto processor 246 performing crypto processing 112 via DMA 114 in this flow.\n\nFIG. 3 shows a Policy Engine ASIC block diagram according to certain embodiments of the present invention. The ASIC 290 contains an interface 206 to an external RISC microprocessor which is known as the Policy Processor 244. Internal to the RISC Processor Interface 206 are registers for all units in the ASIC 290 to signal status to the RISC Processor 244.\n\nThere is an interface 204 to a host PCI Bus 280 which is used for movement of data into and out of the memory 260, and is also used for external access to control registers throughout the ASIC 290. The DMA unit 210 is the Policy Engine 322’s agent for master activity on the PCI bus 280. Transactions by DMA 210 are scheduled through the DMA Ring. The Memory Controller 240 receives memory access requests from all agents in the ASIC and translates them to transactions sent to the Synchronous DRAM Memory 260. Addresses issued to the Memory Controller 240 will be translated by the Ring Translation Unit 264 if address bit 27 is a ‘1’, or will be used untranslated by the memory controller 240 to access memory 260 if address bit 27 is a ‘0’. Untranslated addresses are also examined by the Mailbox Unit 262 and if the address matches the memory address of one of the mailboxes the associated mailbox status bit is set if the transaction is a write, or cleared if the transaction is a read. In addition to the dedicated rings in the Ring Translation Unit 264 which are described here, the Ring Translation Unit also implements 5 general-purpose communications rings COM[4:0] 226 which software can allocate as desired. The memory controller 240 also implements an interface to serial PROMs 270 for obtaining information about memory configuration, MAC addresses, board manufacturing information, Crypto Daughtercard identification and other information.\n\nThe ASIC contains two Fast Ethernet MACs MAC_A and MAC_B. Each contains a receive MAC 216 or 230, respectively, with associated control logic and an interface to the memory unit 220 or 228, respectively; and a transmit MAC 218 or 234 respectively with associated control logic and an interface to the memory unit 222 or 232, respectively. Also associated with each MAC is an RMON counter unit 224 or 236, respectively, which counts certain aspects of all packets received and transmitted in support of providing the Ethernet MIB as defined in Internet Engineering Task Force (IETF) standard RFC 1213 and related RFC’s.\n\nThere are four Classification Engines 208, 212, 238, and 242 which are microprogrammed processors optimized for the predicate analysis associated with packet filtering. Packets are scheduled for processing by these engines through the use of the Reclassify Rings respectively, plus the RX MAC controllers MAC_A 220 and MAC_B 228 can schedule packets for processing by Classification Engines 238 and 242, respectively, through use of the RX Rings, respectively.\n\nThere is Crypto Processor Interface 202 which enables attachment of an encryption processor 246. The RISC Processor 244 can issue reads and writes to the Crypto Processor 246 through this interface, and the Crypto Processor 246 can access SDRAM 260 and control and status registers internal to the interface 202 through use of interface 202.\nA Timestamp counter 214 is driven by a stable oscillator 292 and is used by the RX MAC logic 220 and 228, the TX MAC logic 222 and 232, the Classification Engines 208, 212, 238, and 242, the Crypto Processor 246, and the Policy Processor 244 to obtain timestamps during processing of packets.\n\nFurther details of this system have been described in a patent entitled \"Packet Processing System including a Policy Engine having a Classification Unit\" filed Jun. 15, 1998, now U.S. Pat. No. 6,157,955. Some details about the NetBoost sample platform have been omitted to conceal the disclosure to details related to overall sample software environment.\n\nThose skilled in the art will appreciate variations of the above described embodiments. In addition to these embodiments, other variations will be appreciated by those skilled in the art. As such, the scope of the invention is not limited to the specified embodiments, but is defined by the following claims.\n\nThe invention claimed is:\n\n1. A computer program product, disposed on a computer readable storage medium, the product including instructions for causing a processor, at a third network device intermediate to a first network device and a second network device, to:\n - access Transmission Control Protocol (TCP) segments of a bidirectional TCP connection between a first TCP end-point operating at the first network device and a second TCP end-point operating at the second network device;\n - determine a first TCP state machine state of the first TCP end-point based on at least some of the accessed TCP segments;\n - determine a second TCP state machine state of the second TCP end-point based on at least some of the accessed TCP segments;\n - reassemble a first TCP data stream of data sent from the first TCP end-point to the second TCP end-point from payloads of the accessed TCP segments sent from the first TCP end-point to the second TCP end-point based on sequence numbers of the accessed TCP segments sent from the first TCP end-point to the second TCP end-point, at least some of the accessed TCP segments sent from the first TCP end-point to the second TCP end-point being received out of order; and\n - reassemble a second TCP data stream of data sent from the second TCP end-point to the first TCP end-point from payloads of the accessed TCP segments sent from the second TCP end-point to the first TCP end-point based on sequence numbers of the accessed TCP segments sent from the second TCP end-point to the first TCP end-point, at least some of the accessed TCP segments sent from the second TCP end-point to the first TCP end-point being received out of order.\n\n2. The computer program product of claim 1, wherein the instructions comprise instructions of a software library.\n\n3. The computer program product of claim 2, wherein the instructions comprise instructions of at least one object-oriented class.\n\n4. The computer program of claim 3, wherein the at least one object-oriented class comprises at least one of the following: a class for a bidirectional connection, a class for a TCP end-point, and a class for TCP segment reassembly.\n\n5. The computer program product of claim 1, wherein the instructions that determine the TCP state machine state of the first TCP end-point comprise instructions that determine a change in the TCP state machine state of the first TCP end-point.\n\n6. The computer program product of claim 1, wherein the instructions to reassemble the first TCP data stream of data sent from the first TCP end-point to the second TCP end-point from the payloads of the accessed TCP segments sent from the first TCP end-point to the second TCP end-point comprise instructions that maintain a linked list storing the first TCP data stream in contiguous memory locations linked by the linked list.\n\n7. The computer program product of claim 1, wherein the instructions further comprise instructions to provide a return code indicating at least one of: whether a TCP segment was received out-of-order and whether a TCP segment overlapped another TCP segment.\n\n8. The computer program product of claim 1, wherein the instructions further comprise instructions to return data of a field within a header of a TCP segment.\n\n9. The computer program product of claim 1 further comprising application program instructions that invoke the instructions to access TCP segments, determine the first TCP state machine state, determine the second TCP state machine state, reassemble the first TCP data stream, and reassemble the second TCP data stream.\n\n10. A method, comprising:\n - providing a software library embodied on a computer readable storage medium featuring operations to cause a processor at a third network device intermediate to a first network device and a second network device to:\n - access Transmission Control Protocol (TCP) segments of a bidirectional TCP connection between a first TCP end-point operating at the first network device and a second TCP end-point operating at the second network device;\n - determine a first TCP state machine state of the first TCP end-point based on at least some of the accessed TCP segments;\n - determine a second TCP state machine state of the second TCP end-point based on at least some of the accessed TCP segments;\n - reassemble a first TCP data stream of data sent from the first TCP end-point to the second TCP end-point from payloads of the accessed TCP segments sent from the first TCP end-point to the second TCP end-point based on sequence numbers of the accessed TCP segments sent from the first TCP end-point to the second TCP end-point, at least some of the accessed TCP segments sent from the first TCP end-point to the second TCP end-point being received out of order; and\n - reassemble a second TCP data stream of data sent from the second TCP end-point to the first TCP end-point from payloads of the accessed TCP segments sent from the second TCP end-point to the first TCP end-point based on sequence numbers of the accessed TCP segments sent from the second TCP end-point to the first TCP end-point, at least some of the accessed TCP segments sent from the second TCP end-point to the first TCP end-point being received out of order.\n\n11. The method of claim 10, wherein the operations to determine the TCP state machine state of the first TCP end-point comprises operations to determine a change in the TCP state machine state of the first TCP end-point.\n\n12. The method of claim 10, wherein the operations to determine the TCP state machine state of the first TCP end-point comprises operations to determine a change in the TCP state machine state of the first TCP end-point.\n\n13. The method of claim 10, wherein the at least one object-oriented class comprises at least one of the following:\na class for a bidirectional connection, a class for a TCP end-point, and a class for TCP segment reassembly.\n\n14. The method of claim 10, wherein the operations to reassemble data from accessed TCP segments sent from the first TCP end-point to the second TCP end-point comprise operations that maintain a linked list storing the first TCP data stream in contiguous memory locations linked by the linked list.\n\n15. The method of claim 10, wherein the operations further comprise operations to provide a return code indicating at least one of: whether a TCP segment was received out-of-order and whether a TCP segment overlapped another TCP segment.\n\n16. The method of claim 10, wherein the operations further comprise operations to return data of a field within a header of a TCP segment.\n\n17. The method of claim 10, further comprising invoking the software library operations from an application program."}}},{"rowIdx":275,"cells":{"id":{"kind":"string","value":"636a13f41c5748f97c831a7b303089e633d29fbd"},"text":{"kind":"string","value":"Web-based visualization of guidelines and drug use in epilepsy: a project contributing to smart drug prescriptions\n\nCitation for published version (APA):\n\nDocument status and date:\nPublished: 25/09/2015\n\nDocument Version:\nPublisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers)\n\nPlease check the document version of this publication:\n• A submitted manuscript is the version of the article upon submission and before peer-review. There can be important differences between the submitted version and the official published version of record. People interested in the research are advised to contact the author for the final version of the publication, or visit the DOI to the publisher’s website.\n• The final author version and the galley proof are versions of the publication after peer review.\n• The final published version features the final layout of the paper including the volume, issue and page numbers.\n\nLink to publication\n\nGeneral rights\nCopyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights.\n\n• Users may download and print one copy of any publication from the public portal for the purpose of private study or research.\n• You may not further distribute the material or use it for any profit-making activity or commercial gain\n• You may freely distribute the URL identifying the publication in the public portal.\n\nIf the publication is distributed under the terms of Article 25fa of the Dutch Copyright Act, indicated by the “Taverne” license above, please follow below link for the End User Agreement:\nwww.tue.nl/taverne\n\nTake down policy\nIf you believe that this document breaches copyright please contact us at:\nopenaccess@tue.nl\nproviding details and we will investigate your claim.\n\nDownload date: 31. Oct. 2019\nWeb-based visualization of guidelines and drug use in epilepsy\n\nTrajche Masinov\nSeptember 2015\nWeb-based visualization of guidelines and drug use in epilepsy\nA project contributing to smart drug prescriptions\n\nEindhoven University of Technology\nStan Ackermans Institute / Software Technology\n\nPartners\n\nEpilepsy Center Kempenhaeghe\nSynergetics Benelux B.V.\nEindhoven University of Technology\nZonMW - The Netherlands Organization for Health Research and Development\n\nSteering Group\n\nMarian Majoie (Kempenhaeghe)\nJohan Arends (Kempenhaeghe)\nLuk Vervenne (Synergetics)\nJack van Wijk (TU/e)\n\nDate\nSeptember 2015\n\nDocument status\nPublic\n\nThe design described in this report has been carried out in accordance with the TU/e Code of Scientific Conduct\nAbstract\n\nEpilepsy is a chronic brain disease with unpredictable recurrence of seizures. It is not a curable disease, and the treatment for it is long and often difficult for the patient. Over the years, healthcare professionals have developed a set of guidelines for treating epilepsy. Improving patient’s care is of great importance to Kempenhaeghe. This report describes a project to analyze and interpret epilepsy-related information, and to design a system that provides valuable feedback for healthcare professionals and patients to improve treatment via the use of visualization techniques. A formal model of the epilepsy information and guidelines is developed, and coupled with a prototype. The prototype supports checking conformance of doctors’ prescriptions against the epilepsy guidelines, checking of future prescriptions for conformance and patient-specific applicability, and exploring patient’s care journey with epilepsy. This is supported with visualizations that provide the user with immediate data interpretation and feedback. The project lists also several suggestions for future improvements.\n\nKeywords\nepilepsy, guidelines, visualization, DCM, HL7, three-tier architecture, conformance, decision-support, Kempenhaeghe, Synergetics, TUE, Software technology, PDEng\n\nPreferred reference\n\nPartnership\nThis project was supported by Eindhoven University of Technology, Kempenhaeghe, ZonMW and Synergetics Benelux B.V.\nForeword\n\nThe project ‘Web-based visualization of guidelines and drug use in epilepsy’ is part of the new ‘Dutch Epilepsy Register’. In this project we try to provide a database that is able to give advanced feedback to its users, mainly doctors and patients, but also other parties such as health insurance and pharmaceutical companies. This internet-based system should also serve as an intermediate between many hospitals and (epilepsy) institutes and become the communicative backbone between patients, doctors and epilepsy-related organizations.\n\nWith this in mind, we asked and received a grant from ZonMW (program ‘Goed Geneesmiddelen Gebruik’, project number 836022001) and asked Trajche Masinov as PDEng to write the medical and visualization part. Apart from acquiring the medical data he also had to translate the Dutch and English Epilepsy Guidelines into logical units that were suited for use in this information system. Finally all the data had to be visualized in a transparent and attractive way. So he had to enter the domain of the doctors and health care regulations without leaving his own.\n\nNow we can say that Trajche has succeeded very well in this mission. This is due to his very intelligent reasoning and tactical attitude towards the health care professionals without using too much the language of an information expert. He continuously translated both domains internally in his head during the discussions. Furthermore he showed much flexibility to adapt to doctors wishes that are not always logical. In the meantime he did not forget his roots as an informatics engineer. His knowledge of medical Dutch language and habits has grown a lot since last year.\n\nThanks to him we now have a very attractively looking prototype epilepsy program that allows us to give feedback to individual doctors and groups of doctors or other interested parties. The medical data also allow a comprehensive patient view, but since diary data still are lacking, a full feedback system for patients could not be written during Trajche’s presence with us. We are very grateful to Trajche for delivering such an important key element of the future Dutch Epilepsy register. He has done a great job.\n\nprof. dr. Johan Arends\nSeptember 2015\nPreface\n\nThis report summarizes the “Web-based visualization of guidelines and drug use in epilepsy” project executed by Trajche Masinov, as part of his graduation assignment for the PDEng (Professional Doctorate in Engineering) program offered by the Eindhoven University of Technology, Stan Ackermans Institute. The project was executed over the last nine months of the two-year program, under supervision of Synergetics Benelux B.V. and Kempenhaeghe.\n\nThe goal of the project is to exploit visualization techniques to improve epilepsy treatment through insight and decision support, and provide a solution based on this findings. This was possible with close collaboration from experts from Kempenhaeghe, and their technology partner, Synergetics Benelux B.V. A prototype was developed that\n\nThis report is primarily intended for readers with a technical background in different disciplines, such as visualization, healthcare technology standards and general software engineering. However, certain chapters may be interesting for non-technical readers, such as project managers and doctors.\n\nThis table lists the types of readers based on their background and chapters they need to focus on:\n\n<table>\n<thead>\n<tr>\n<th>Reader</th>\n<th>Chapters</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Healthcare technology specialist</td>\n<td>Introduction Problem analysis Domain analysis Conclusions</td>\n</tr>\n<tr>\n<td>Visualization specialists</td>\n<td>Introduction Problem analysis User interface design Conclusions</td>\n</tr>\n<tr>\n<td>Software engineer</td>\n<td>System requirements System architecture System design Implementation Verification & validation</td>\n</tr>\n<tr>\n<td>Project managers</td>\n<td>Introduction Stakeholders analysis Problem analysis Project management Project retrospective</td>\n</tr>\n<tr>\n<td>Doctors</td>\n<td>Introduction Problem analysis Conclusions</td>\n</tr>\n</tbody>\n</table>\n\nTrajche Masinov\nSeptember 2015\nAcknowledgements\n\nI owe the success of this project to the unprecedented help from all involved parties. This project was a great experience, and it gave me the opportunity to work with many wonderful people, which inspired and guided me throughout the project.\n\nFirst of all, this project was made possible on behalf of the ZonMW, The Netherlands Organization for Health Research and Development. Via their funding, the Epilepsy Register project was initiated (project number 836022001), and my project, as a subproject of the epilepsy register.\n\nI want to acknowledge the help from the specialists from Kempenhaeghe, especially Dr. Marian Majoie and Dr. Johan Arends. I would like to thank you both for your help and support throughout the project, with your knowledge and patience, as well as understanding. I really appreciate everything you did for me.\n\nI would like to thank Luk Vervenne and Paul Imholz from Synergetics Benelux B.V. Your guidance and support was crucial for me, and I would not have make it without you. I enjoyed my internship with you, and the pleasant moments spent together. I would also like to thank you, William and Anneke Goosen, for your devoted cooperation on this project, and your support.\n\nThis project would not have been a success without the support from my university supervisor, Prof. Jack van Wijk. I thank you for your critical thinking, advises, and continuous support during this project. I learned a great deal about visualizations from you. I would also like to thank everyone involved in the PDEng programme, especially our programme director Ad Aerts. Thank you for everything, this programme is one of the best experiences of my life.\n\nAnd last but not least, I would like to thank my family for their continuous support during this programme, and for believing in me. A special thank you goes to my girlfriend, Mimoza, for her patience and support. A special thank you to my mother, Gordana, for everything she has done for me, and to my brother Nenad for his support.\n\nI would also like to thank my friends from the programme, for our shared experience and cooperation during these past two years.\n\nTrajche Masinov\nSeptember 2015\nExecutive Summary\n\nEpilepsy is a chronic brain disease with unpredictable recurrence of seizures. It is not a curable disease, and the treatment for it is long and often difficult for the patient. Like every other treatment, the epilepsy treatment is bound to rules and regulations based on scientific research and experience. Over the years, healthcare professionals have developed a set of guidelines for treating epilepsy.\n\nImproving patient’s care is of great importance to Kempenhaeghe. But improving care is not always done by simply trying new approaches, it often involves looking back and learning from the past. Coupled with the guidelines, Kempenhaeghe aims to learn and derive new insights to improve the treatment process even further. This is the main focus of this project, to utilize existing information to produce insights that will guide caregivers in making better future decisions. The output of this project will be part of the future ‘Dutch Epilepsy Register’.\n\nAll these insights derived from the data represent nothing if they are not properly delegated to the end users. Proper delegation means effective and efficient presentation of information in such a way that users can understand it. To address this issue, the use of visualization techniques is chosen to facilitate the data representation.\n\nThis report describes a project to analyze and interpret epilepsy-related information, and to design a system that provides valuable feedback to healthcare professionals via the use of visualization techniques. As part of the domain analysis, a formalization of the epilepsy guidelines is created, that serves as a basis for the project. The formalization presents an extendible model for representing guideline information. Another product of the domain analysis is a design of an information model for representing epilepsy-related data by using healthcare technology standards, such as HL7 [4, 5].\n\nAs part of the project, a prototype is developed that serves as a decision support tool, intended primarily for healthcare professionals. The support tools provide checking conformance of doctors’ prescriptions against the epilepsy guidelines, checking of future prescriptions for conformance and patient-specific applicability, and exploring patient’s care journeys with epilepsy. The tools are supported by visualizations that provide the user with immediate data interpretation and feedback.\n\nThe system described in this report is based on a three-tier web-based architecture (presentation, logic, and data) that is easily maintainable, extendable, and scalable, with particular focus on usability, especially in visualizations and user interface design. The architecture defined supports tier replacements as long as the interfaces between tiers remain the same. Additionally, the system supports multiple presentation tiers due to its web-based architecture and deployment strategy.\n\nThe prototype shows that the use of visualization techniques is beneficial for data interpretation and insight extraction. It is recommended that the system is installed on a trial basis, and additional time and resources are spend for creating a production-level system.\n# Table of Contents\n\nForeword ........................................................................................................................... i\nPreface ............................................................................................................................... iii\nAcknowledgements ........................................................................................................... v\nExecutive Summary .......................................................................................................... vii\nTable of Contents ............................................................................................................. ix\nList of Figures ................................................................................................................... xiii\nList of Tables ................................................................................................................... xv\n\n## 1. Introduction ................................................................................................................. 1\n 1.1 Context ...................................................................................................................... 1\n 1.2 Rational pharmacotherapy ....................................................................................... 1\n 1.3 National Epilepsy Register (NER) ........................................................................... 2\n 1.4 Web-based visualization of guidelines and drug use in epilepsy ......................... 2\n 1.5 Related work ............................................................................................................ 3\n 1.6 Outline ..................................................................................................................... 3\n\n## 2. Stakeholder Analysis ................................................................................................. 5\n 2.1 Kempenhaeghe ......................................................................................................... 5\n 2.2 Eindhoven University of Technology (TU/e) .......................................................... 5\n 2.3 Synergetics Benelux BV .......................................................................................... 6\n\n## 3. Problem Analysis ..................................................................................................... 7\n 3.1 Context ...................................................................................................................... 7\n 3.2 Epilepsy treatment guidelines .................................................................................. 7\n 3.3 Insight and decision support .................................................................................... 8\n 3.4 Visualization ............................................................................................................ 9\n 3.5 Design opportunities ............................................................................................... 9\n\n## 4. Domain Analysis ...................................................................................................... 11\n 4.1 Introduction .............................................................................................................. 11\n 4.2 Health Level 7 (HL7) standard ................................................................................ 11\n 4.3 Patient ..................................................................................................................... 13\n 4.4 Treatment ................................................................................................................. 14\n 4.5 Detailed Clinical Models as building blocks ......................................................... 16\n 4.6 Epilepsy patients ................................................................................................. 18\nList of Figures\n\nFigure 1 Healthcare related projects submitted under the Rational Pharmacotherapy program................................................................. 2\nFigure 2 Types of blocks in a Detailed Clinical Model used to represent entity types ........................................................................... 12\nFigure 3 Detailed Clinical Model representing personal information about a patient ........................................................................ 13\nFigure 4 Two DCMs representing information about a patient's birth and death 14\nFigure 5 A DCM expressing an implementation specification of a Personal Identification block for a patient ........................................... 14\nFigure 6 A DCM describing a problem ............................................................... 15\nFigure 7 A DCM describing a procedure or treatment .................................... 15\nFigure 8 DCM representing prescription information (part 1) ..................... 16\nFigure 9 DCM representing prescription information (part 2) ..................... 16\nFigure 10 Model representing patient treatment. The model is constructed by using separate DCMs ................................................................. 17\nFigure 11 Model that captures information about side effects and seizures for a patient ........................................................................ 18\nFigure 12 Proposed structure of a guideline for a single syndrome or seizure type ................................................................. 19\nFigure 13 Model of the guidelines. The top section represents the abstract part and the lower one is the epilepsy specific .................................. 22\nFigure 14 Structure of the NICE guidelines .................................................. 22\nFigure 15 System level use cases for the project ......................................... 29\nFigure 16 Operating environment for the system ....................................... 29\nFigure 17 3-tier architecture deployment on separate physical servers ........ 36\nFigure 18 Logic tier architecture ................................................................ 41\nFigure 19 MVC pattern .............................................................................. 43\nFigure 20 MVVM pattern ........................................................................... 43\nFigure 21 Traditional page lifecycle vs. SPA lifecycle. The difference is in the second request to the server, where traditional web pages send a synchronous request, SPA send an asynchronous request (or Asynchronous JavaScript And XML or AJAX calls) to retrieve the data needed, usually in JSON format (image borrowed from https://msdn.microsoft.com/en-us/magazine/dn463786.aspx?f=255&MSPError=2147217396 ) ......... 44\nFigure 22 Presentation tier architecture ....................................................... 46\nFigure 23 Design of a module, following the MVVM pattern ....................... 47\nFigure 24 Service and component architecture ......................................... 51\nFigure 25 The API section of the logic tier. An API consists of controllers that handle HTTP requests (GET, POST, PUT, and DELETE). The URI to a specific resource is constructed from the entry point to the service, the entry point of the controller, and the entry point to the resource .................................................. 52\nFigure 26 Provider, abstract and concrete service factory. The responsibility of the service factory is to instantiate concrete services that process the request ........................................... 52\nFigure 27 Sequence diagram representing interaction between the client and the API .............................................................................. 55\nFigure 28 Module design. Other modules follow the same style ................. 57\nFigure 29 Sequence diagram representing interaction between the user and the client ............................................................................ 58\nFigure 30 Generic process view for handling a request. Three tiers are involved in the communication ...................................................................... 58\nFigure 31 Development view of the logic tier ............................................. 59\nFigure 32 Development view of the presentation tier ................................. 60\nFigure 33 Deployment view of the entire system. A more comprehensive view is offered in the Deployment chapter ........................................ 61\nFigure 34 Data model regarding patient-related information ..................... 63\nFigure 35 Data model representing output information ............................ 65\n## List of Tables\n\nTable 1 Kempenhaeghe's stakeholders................................................................. 5 \nTable 2 TU/e's stakeholders................................................................................. 6 \nTable 3 Synergetics' stakeholders...................................................................... 6 \nTable 4 DCM datatypes....................................................................................... 12 \nTable 5 Part of the epilepsy guidelines regarding treatment based on seizure type. .................................................................................................................. 20 \nTable 6 Treatment process for focal seizures ...................................................... 21 \nTable 7 Treatment process for absence seizures.................................................. 21 \nTable 8 Main users and scenarios in the system..................................................... 28 \nTable 9 Functional requirements for the Conformance check feature ................. 30 \nTable 10 Functional requirements for the Pre-prescription check feature .......... 31 \nTable 11 Functional requirements for the Advised vs. practical care journey feature ....................................................................................................................... 32 \nTable 12 Functional requirements for the Guidelines management feature ........ 32 \nTable 13 Matrix of features and roles allowed to use a feature ......................... 66 \nTable 14 Survey to validate the application ......................................................... 82 \nTable 15 Initial project planning .......................................................................... 92 \nTable 16 Final project planning ........................................................................... 93 \nTable 17 Glossary ................................................................................................. 97 \nTable 18 Mapping of seizure types (from old ILAE and Luders classification to new ILAE classification) ................................................................................. 115 \nTable 19 Syndrome mapping between old and new classification ..................... 116 \n\n---\n\n*Note: The above list is a placeholder for the purpose of this exercise.*\n1. Introduction\n\nThis chapter introduces the project, its context, and the ecosystem where it lives. The scope of the project and its goals are briefly mentioned. The outline section of this chapter gives a brief overview of what is discussed in the following chapters.\n\n1.1 Context\n\nThe “Web-based visualization of guidelines and drug use in epilepsy” project was conducted by Trajche Masinov, as part of his Professional Doctorate in Engineering (PDEng) program. The PDEng degree program in Software Technology is provided by the Department of Mathematics and Computer Science of Eindhoven University of Technology in the context of the 3TU.School for Technological Design, Stan Ackermans Institute.\n\nThe PDEng program is a two-year, third-cycle (doctorate-level) engineering degree program during which the trainee focuses on strengthening his/her technical and non-technical competencies related to the effective and efficient design and development of software for resource-constrained software-intensive systems, such as real-time embedded or distributed systems, in an industrial setting. In particular the focus is on large-scale project-based design and development of this kind of software.\n\nThe project was initiated by Kempenhaeghe, a leading center of medical expertise. They offer diagnosis and treatment to adults and children who suffer or are suspected to suffer from a complex form of epilepsy, a sleeping disorder, and/or neurological learning disabilities. Kempenhaeghe is involved in various software-related projects with the goal of improving patient care both for the patient and the caregiver.\n\nThis project is part of a bigger project called the “National Epilepsy Register (NER)” (project number 836022001) which is funded by ZonMW1, under the Rational Pharmacotherapy program. The description and context of that project is stated below.\n\n1.2 Rational pharmacotherapy\n\nThe Rational Pharmacotherapy program (in Dutch, Goed Gebruik Geneesmiddelen) aims to make the use of medicines safer, more effective, and more efficient. Patients and care providers, in particular, stand to gain from the best possible use of the medicines available. The program encourages the gathering of reliable, independent data from practice. This information can be useful both for practitioners and for the government, health insurance companies, and the pharmaceutical industry. A number of project proposals have been submitted under this program, such as “Epilepsy Register,” and “Optimizing Drug Therapy in Patients with Epilepsy: An Adverse Drug Reaction Service Tool,” by Kempenhaeghe in collaboration with others (see Figure 1).\n\n1 http://www.zonmw.nl/nl/over-zonmw/over-zonmw/\n1.3 **National Epilepsy Register (NER)**\n\nThe National Epilepsy Register project is part of the Rational Pharmacotherapy program. It is established in collaboration with the TU/e, the Maastricht University Medical Center, Synergetics Benelux BV, the National Epilepsy Funds, the Knowledge Institute for Medical Specialists, and the Dutch Epilepsy Association or EVN (in Dutch, Epilepsie Vereniging Nederland).\n\nThe goal of the register will be to collect and centralize knowledge about the treatment of epilepsy, which will become available for patients and physicians. The registry will support sampling of data by patients, nurses, physicians, pharmacies and hospitals. The registry will be built around the patient. The patient maintains his own data, can use these for diverse applications and decides which healthcare providers and physicians are allowed to have entry to these personal and clinical data. The relevant juridical laws and guidelines are considered during the development of the registry.\n\nPatients and healthcare providers may use the registry as an electronic patient dossier or personal health dossier. The registry will function as an epilepsy healthcare ecosystem.\n\n1.4 **Web-based visualization of guidelines and drug use in epilepsy**\n\nThe project is a part of the NER project (see Figure 1). The idea behind the project is utilization of modern visualization techniques for big data analytics and exploration. The visualizations should provide visual feedback and interpretation of the data gathered by the NER to the stakeholders.\n\nThe focus of the project is on epilepsy treatment, as one of the core businesses of Kempenhaeghe. Treatment for epilepsy is defined through a set of guidelines. A guideline merely gives a suggestion about the direction of the treatment when a patient is diagnosed with epilepsy with a specific syndrome or seizure type. Doctors take these guidelines into consideration, but also, the prescribed medicine depends on factors related to the patients, such as age, gender, lifestyle, and current health conditions.\n\nEpilepsy is treated with anti-epileptic medications, which can often cause side effects. Sometimes these side effects can cause severe damage to the patient’s health. With this in mind, the scope of the project extends to managing this information in improving a patient’s care.\n\nThe project aims to improve patient’s care by providing the following:\n\n- Visualize the patient journeys during their epilepsy period and give valuable feedback to doctors;\n• Provide a tool for the doctors that will allow them to check their issued prescriptions for adherence to the guidelines in a visual way;\n• Provide decision support to doctors when prescribing an anti-epileptic medication to a patient based on the patient’s current status as well as the guidelines.\n\n1.5 Related work\nSimilar work has been conducted in the area of visualizing the prescription behavior [1] [2]. The project was a master’s thesis conducted at the Technical University of Eindhoven. The main focus of the thesis was visualization of the doctor’s prescription behavior, for instance what and how much medication a doctor prescribed during a patient’s epilepsy treatment.\n\n1.6 Outline\nThe next chapter introduces the stakeholders involved in this project as well as their interests and goal. A brief analysis is presented for each stakeholder. After the stakeholder analysis, a problem analysis is presented (Chapter 3) that depicts the problem of the project in detail and the expectations for the project itself. The story continues with a discussion about the domain of the problem (Chapter 4), its ecosystem, and limitations.\n\nAs with any other project, there are always certain risks or issues that may arise during the lifespan of the project. This is explained in Chapter 5 together with mitigation techniques for the issues/risks.\n\nThe next seven chapters address the solution to the problem in a structured manner. First, Chapter 6 presents the specific requirements derived from the problem and domain analysis. The functional and non-functional requirements specified in this chapter give a basis for designing the architecture of the system. The architecture of the system is specified in Chapter 7. Moving on, Chapter 8 presents the design of the system based on the architecture defined previously. The next chapter (Chapter 9) explains how the system is implemented following the previous architecture and design. This chapter also explains the decisions taken for using a specific technology for the implementation. Chapter 10 elaborates on the design of the user interface and visualization executed for the project. Chapter 11 discusses verification and validation, since every system needs to be verified and validated. This process ensures that the system meets the requirements and the expectations of the stakeholders. Finally, Chapter 12 depicts the complete deployment of the system as part of an ecosystem for healthcare related projects.\n\nThe results and future work for the project are presented in Chapter 13. This chapter also gives a conclusion about the project.\n\nThe last two chapters of this report reflect on the management part of the project. Chapter 14 addresses the management process during the nine months of the project as well as techniques used to manage it. Chapter 15 gives the author’s retrospective and reflection on the project.\n2. Stakeholder Analysis\n\nThe previous chapter introduced the project and its position within a larger project, namely the NER. This chapter analyzes the stakeholders involved in the project and their interests and goals. There are three concerned parties in this project, each with its own interest, namely Kempenhaeghe, Synergetics Benelux BV, and the Eindhoven University of Technology. The following describes each party and introduces the main stakeholders and persons involved.\n\n2.1 Kempenhaeghe\n\nKempenhaeghe is a leading center of medical expertise in epilepsy, sleeping disorder, and neurological learning disabilities. The members of this organization are the owner and initiator of the project; therefore this makes them the most important stakeholder in the project itself. They have several interests as their key drivers for the project.\n\nThe first interest is starting up the NER and making it a showcase product for the entire healthcare industry in The Netherlands. It is already an ongoing project as part of the Rational Pharmacotherapy program. The NER will also be a basis for development of a wide variety of healthcare related systems, and even in other areas (e.g. statistics, insurance).\n\nThe second interest is extracting useful information from their data on epilepsy treatment and using it to further improve the treatment itself. This is expressed through a need for tools that can help doctors directly to make better decisions when treating patients. These tools involve analytics and decision support.\n\nAs an addition, Kempenhaeghe is interested in including side-effects information registered by the patient themselves through a smartphone app called Eppy. This information can be used to improve patient’s care.\n\nTable 1 lists the specific stakeholders from Kempenhaeghe.\n\n<table>\n<thead>\n<tr>\n<th>Stakeholder</th>\n<th>Position</th>\n<th>Role</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Prof. Dr. Johan Arends</td>\n<td>Neurologist</td>\n<td>Project owner</td>\n</tr>\n<tr>\n<td>Dr. Marian Majoie</td>\n<td>Neurologist</td>\n<td>Project manager</td>\n</tr>\n</tbody>\n</table>\n\nDr. Marian Majoie is the coordinator of the epilepsy guidelines’ authors, and her greatest concern is proper interpretation and representation of the guidelines in a certain system.\n\n2.2 Eindhoven University of Technology (TU/e)\n\nThe Eindhoven University of Technology is responsible for the educational aspect of this project and fulfilling the requirements for a project of this type. That means certain standards need to be met. The TU/e is concerned with the design process, project management, and implementation.\n\nThe stakeholder from the university is prof. Jack van Wijk who has the role of a supervisor and a mentor for this project. He is a full-time professor in visualization at the Department of Mathematics and Computer Science and the group leader of the Visualization Group at Eindhoven University of Technology. Besides his mentorship, his role includes making sure that the design and documentation meet the standard of a PDEng project. Another stakeholder from the TU/e is Trajche Masinov, the PDEng candidate responsible for the implementation of the project.\nSynergetics Benelux BV\nSynergetics Benelux BV is a service-oriented company that focuses on personal data storage with enhanced security. Another focus is big data analytics and visualization. Synergetics tries to position itself as a utility company providing these personal data stores, coupled with analytics and visualizations, to customers or vendors.\n\nIn collaboration with Kempenhaeghe, they are directly involved in the NER project as providers of secure data storage capabilities.\n\nWith respect to this project, they have several interests. The first interest is starting the NER on their platform and making it a showcase project for the whole Dutch healthcare industry. The success of this project is clearly a major interest as it will put their name on the map as a healthcare utility company.\n\nThe second interest of Synergetics is adhering to standards, especially health-related standards, such as HL7 (see section 4.2). This adherence concerns the design process where certain criteria need to be met with respect to software models and interoperability between systems.\n\nTable 3 Synergetics' stakeholders\n\n<table>\n<thead>\n<tr>\n<th>Stakeholder</th>\n<th>Position</th>\n<th>Role</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Luk Vervenne</td>\n<td>Chief Executive Officer</td>\n<td>Company supervisor</td>\n</tr>\n</tbody>\n</table>\n3. Problem Analysis\n\nThe first and second chapter discuss the position of this project in a greater ecosystem as well as the stakeholders with their interests and goals, respectively. This chapter focuses on the problem that the project is trying to solve. First, an introduction to epilepsy is given, followed by the guidelines for its treatment, and finally, reasons why visualizations are needed for this project are given.\n\n3.1 Context\n\nEpilepsy is a chronic brain disease with unpredictable recurrence of seizures. The seizures themselves are caused by sudden and temporary disruption of the electrical equilibrium in the brain. Seizures vary from person to person. An epileptic may fall down and go into shock with contraction of the muscles in the arms and legs. Another may feel strange tingling or hear strange noises, or stare somewhere for a short period of time.\n\nThe classification of epilepsy is based on seizure type and syndrome (see Appendix B: Classification of epilepsy syndromes and seizure types). The latest classification on seizure types distinguishes them based on the location of the brain which is affected, namely generalized, focal, and unknown. Generalized seizures affect both hemispheres of the brain, while focal seizures affect only one. The unknown seizures cannot be clearly diagnosed so they are considered unclassified until further information reveals their accurate diagnosis. Each seizure type has different effects on the patient, ranging from harmless to the immediate need of a healthcare professional.\n\nThe classification on syndromes is larger than the one on seizure types. Hierarchically, this classification is higher than the one on seizure types, regarding importance. Epilepsy syndromes are grouped by age, starting from neonatal period, to infancy, childhood, adulthood, and some syndromes with characteristic finding or syndromes that cannot be placed in a specific group age.\n\nConsidering all of these seizures and syndromes, proper diagnosis and treatment significantly improves the patient’s quality of life by reducing the number of seizures. Epilepsy conditions often require the expertise of several specialists to diagnose and treat, resulting in complex care needs. Medical specialists, behavioral scientists, social workers, educational specialists, paramedics, and specialized nurses collaborate to develop a treatment plan that is customized to the needs of the patient in question.\n\nThe treatment for epilepsy is a variety of antiepileptic medications and sometimes psychoactive medications (benzodiazepine) that have sedative, hypnotic, and muscle relaxant properties. Due to the strong effect of the medications, side effects are common for epilepsy patients. Every patient reacts differently to different medications. The side effects that a medication can induce include drowsiness, tiredness, dizziness, or blurriness in vision. These are dose-dependent side effects. There are also non dose-dependent side effects, such as allergic reactions. The treatment usually consists of trying one or more medications to determine the best antiepileptic medications for the patient.\n\nIt is estimated that over 100,000 people suffer from epilepsy in the Netherlands. Epilepsy occurs relatively more often in the mentally retarded [3].\n\n3.2 Epilepsy treatment guidelines\n\nLike every other treatment, the epilepsy treatment is bound to rules and regulations on what should be administered to the patient and in what doses. In order to formalize the treatment, guidelines have been developed based on proven scientific research, best practices, and past experiences. The guidelines for epilepsy treatment merely suggest what kind of antiepileptic medication should be prescribed to a patient who suffers\nfrom a specific epilepsy syndrome or experiences specific seizure type(s). The guidelines are a suggestion, because the current condition of the patient determines the proper course of action. Factors that need to be taken into consideration include: age, gender, pregnancy status (if the patient is a woman), allergies, and other ongoing medications.\n\nPatients had been treated for epilepsy prior to the existence of the guidelines. Along the years, progress has been made in both science and medicine, which resulted in the invention of new or improved medications for epilepsy. These discoveries changed how epilepsy is treated, and as a result, the guidelines are ever changing.\n\nAnother factor that contributes to these changing guidelines is experience itself. Clinical trials as well as individual reports from professionals influence the guidelines and their content. During their career, healthcare professionals experience various cases of epilepsy and try out different treatments that sometimes lead to unexpected seizure freedom or patterns in treatment that improve a patient’s life. The treatment process is extensively explained in section 4.7.2.\n\n### 3.3 Insight and decision support\n\nAs a leading center for expertise and treatment in the field of epilepsy, Kempenhaeghe has almost a hundred years of experience. Throughout these years, more than 30,000 patients have been treated and different treatments have been applied. Over the past forty years Kempenhaeghe has transformed into a specialist hospital (specializing in epilepsy, sleep medicine, and neurological learning disorders) for epilepsy patients.\n\nThroughout these last forty years, in parallel with the evolution of the computer, Kempenhaeghe has gathered a vast quantity of data regarding epilepsy treatment. This data spans from patient information to epilepsy treatment, side effects and other healthcare-related information.\n\nTo further improve patients’ care and quality of life, Kempenhaeghe wants to make use of this data and extract meaningful information out of it. This information can be a basis for research and discovery of new insights, identification of patterns in treatment, extracting behavior of professionals, and much more.\n\nConsidering the guidelines on one side and the treatment information on the other side, Kempenhaeghe is interested in deriving three kinds of information from these data:\n\n- Doctors’ prescription adherence to the guidelines;\n- Decision support to doctors when treating a patient;\n- Comparison of the advised care journey versus the patient’s actual care journey.\n\nThe first kind of information that Kempenhaeghe is interested in is checking the doctors’ prescription behavior for compliance to the guidelines. This means that a doctor can be evaluated whether his or her treatment for epilepsy is consistent to the guidelines. By addressing this, Kempenhaeghe can examine doctors’ behavior and identify patterns in prescriptions. These patterns can influence the guidelines themselves.\n\nThe second kind of information is support rather than insight. Using the guidelines as a basis, Kempenhaeghe wants to have a support tool both for the doctors and for the patients. The goal of this tool is to give suggestions based on the guidelines before the doctor decides to prescribe a medication to an epilepsy patient. This way, Kempenhaeghe wants to steer the direction of prescribing antiepileptic medications according to the guidelines. Important here is that the current condition of the patient is the driving factor for prescribing the right antiepileptic medication as guidelines do not cover every situation or every different patient condition.\n\nThe third kind of information is a comparison between two distinct timelines of a patient suffering from epilepsy. The first timeline is called advised care journey and it\nrepresents a form of guidelines or recommended actions a patients must take from the moment the patient is diagnosed with epilepsy to the moment the patient is admitted to a specialized epilepsy center, such as Kempenhaeghe. The second timeline is called practical care journey and it consists of all events that transpired in the same time frame as the advised care journey. These events include visits to the general practitioner, visits to the neurologist, administration of various antiepileptic drugs, and seizure information. Comparison of these two journeys will give Kempenhaeghe a clear picture of what patients are experiencing and provide them with future action points for improving a patient’s quality of life.\n\n3.4 Visualization\n\nAll these insights derived from the data represent nothing if they are not properly delegated to the end users. Proper delegation means effective and efficient presentation of information in such a way that users can understand it.\n\nThis is where visualization comes into play. Data visualization is a science that deals with visual representation of the data, which allows representation of information in a schematic form or uses graphical primitives. It is scientifically proven that the human brain consumes an image much faster than a table with raw data or plain text. Humans are creatures who establish an idea of a thing by its visual perception. They try to apply visual representations such as tables or images to process the increasing amount of information.\n\nFrom the point of view of epilepsy, proper interpretation of acquired information or insight in a visual form is key to delegating the information to the end user and indirectly improving a patient’s quality of life. If data is properly visualized, the end user is able to comprehend this information and make better decisions for future treatments.\n\nFor that purpose, appropriate visualization techniques need to be carefully selected. These techniques need to be coupled with a user interface that must be easy to understand and use. The design of the user interface is an essential part of the project and it must be designed in such a manner that it can be understood by the users within seconds. The interaction between the user and the system needs to be made simple, because the system will be used mostly by people with no technical knowledge. Hence, a complex interaction and interface is out of the question.\n\n3.5 Design opportunities\n\nDuring the study of the epilepsy domain and problem analysis, a single design opportunities was identified, namely usability. The issues discussed in this chapter suggest a need for a system that can improve patient’s quality of life by helping doctors understand patient history and improve future decisions. Section 3.4 discusses visualization techniques as a way of conveying information to the user. Hence, usability should be carefully addressed by means of making the product easy to understand and use, and to be intuitive.\n4. Domain Analysis\n\nThe problem analysis discussed in the previous chapter reveals the domain in which the project resides, namely healthcare with specialization in epilepsy. The objective of this chapter is to broaden the understanding of the domain and identify the relevant parts that will provide insight for the solution to the problem. This chapter addresses the domain of patients and their epilepsy treatment with anti-epileptic drugs as well as the known guidelines for optimal treatment.\n\n4.1 Introduction\n\nThe healthcare domain is vast and has many different disciplines. Each discipline in healthcare represents its own domain with different approaches for handling patients, and treating them. Epilepsy is one of these disciplines. Residing under the neurological diseases discipline, epilepsy has evolved its own domain of knowledge about treatment and handling patients, starting from classification of the epilepsies by syndromes and seizure types, developing care plans for individual patients, to long term hospitalizations of patients with severe forms of epilepsy. Epilepsy is not a curable condition but controllable, which means that the treatment is a long and difficult process that can take many years, even the entire lifespan of the patient.\n\nThe analysis of the domain is split into sections that focus on different parts of the domain. Before the sections are explained, an introduction to the HL7 standard is given and its influence in the analysis of the domain is explained. The sections to follow explain the following parts:\n\n- Patient – relevant information about patients;\n- Treatment – treatment of patients and the process itself;\n- Guidelines – recommendations regarding optimal treatment for epilepsy.\n\n4.2 Health Level 7 (HL7) standard\n\nHealth Level Seven International (HL7) is a non-profit, ANSI-accredited standard development organization founded in 1987. The mission of this organization is empowering global health data interoperability by developing standards and enabling their adoption and implementation [4].\n\nHL7 and its members provide a framework (and related standards) for the exchange, integration, sharing, and retrieval of electronic health information. These standards define how information is packaged and communicated from one party to another, setting the language, structure and data types required for seamless integration between systems. HL7 standards support clinical practice and the management, delivery, and evaluation of health services, and are recognized as the most commonly used in the world [5].\n\nThe above-mentioned packaging and exchange of information implies existence of a model that represents health related information. The model is a large collection of smaller models called Detailed Clinical Models or DCMs. A Detailed Clinical Model (DCM) is an information model of a discrete set of precise clinical knowledge that can be used in a variety of contexts. In some cases, a DCM offers technical implementation specifications.\n\nThe purpose of Detailed Clinical Models is to provide precise semantically consistent data and terminology specifications that are comparable and sharable between multiple care providers, health enterprises, and standards-based Healthcare Information Technology [6].\n\nExamples of items described by DCMs are medicinal products (medication), patient treatment, and description of a problem or diagnosis.\nFor the purpose of this project, several DCMs are used to describe the domain itself and provide a structure for its representation. The models used are shown in the subsequent sections of the chapter.\n\nDeveloping such models includes providing types for the entities in the model. Within the DCMs, a number of data types are recognized that are used to label attributes or entire model entities. Table 4 lists the data types used.\n\nTable 4 DCM datatypes\n\n<table>\n<thead>\n<tr>\n<th>Data type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>BL</td>\n<td>Boolean value</td>\n</tr>\n<tr>\n<td>ED</td>\n<td>Encapsulated data (binary information such as an image or a report in a procedure)</td>\n</tr>\n<tr>\n<td>II</td>\n<td>Instance identifier (identification of patients or medical products)</td>\n</tr>\n<tr>\n<td>TS</td>\n<td>Time stamp</td>\n</tr>\n<tr>\n<td>CD</td>\n<td>Coded data. Similar to enumeration. Values usually come from a defined coded dataset.</td>\n</tr>\n<tr>\n<td>CO</td>\n<td>Coded ordinal</td>\n</tr>\n<tr>\n<td>INT</td>\n<td>Integer value (number)</td>\n</tr>\n<tr>\n<td>ST</td>\n<td>String value (text)</td>\n</tr>\n<tr>\n<td>PQ</td>\n<td>Physical quantity. Expressed through unit and value. Units come from the unified code for units of measure, UCUM [7]</td>\n</tr>\n</tbody>\n</table>\n\nThroughout the DCMs, different colors are used for the blocks to indicate different types of blocks. Essentially, there are three types of blocks, shown in Figure 2.\n\n\n\nThe rootconcept notation represents the main entity of the model. The notation is used to represent top level concepts, such as problem, medication, procedure, and person. The container notation is used to represent an entity that holds related information, for example, an address consisting of a street name, number of the house, postal code, city, and a country. Finally, the data notation is used to label entities representing atomic information such as raw text, numbers, Boolean values, and concepts that represent slightly more complex information. One example of this is an enumeration value where besides the value itself, information about the source or the code system used for the enumeration is stored in the entity.\n\nAll of these entities are connected with relations. A relation specifies a semantic link between two entities. For example, an entity containing address information has no added value on its own unless it is linked to another entity, such as a person. There are different types of relationships used to make up the semantics of a model. For a com-\nplete overview of the available relationships, see Appendix A: Types of UML relationships. Typically, DCMs use composition relationships to build the model, starting from atomic information and going to containers that aggregate the atomic information, leading up to the root concept. A composition is depicted as a solid line connecting two entities with a black rhomboid placed on the beginning of the line on the entity that contains the other entity.\n\n4.3 Patient\n\nThe bigger part of the healthcare domain revolves around patients. Throughout their lifespan, patients are typically involved in multiple domains with different specializations, such as general practitioners, and dentists. This adds to the complexity of representing the relevant data accurately and completely.\n\nPatient related information is essential for effective and efficient treatment, especially in epilepsy. During epilepsy treatment, the patient can go through many physical and psychological (mental) changes that the caregiver should be aware of.\n\nThe HL7 organization has developed models for this in the form of small building blocks that can be combined. As explained in the section above, each block represents a piece of clinical information. With respect to the patient, these building blocks include personal information, medication use (dispensing), treatments or procedures, and problems or diagnoses.\n\nThe information about the patient such as personal, contact, and address data are bundled within a single detailed clinical model called Person. Figure 3 shows the detailed clinical model that captures personal information about a patient. Standard information is noted for a patient, such as birth data, name, and address information.\n\n\n\nRegarding the birth and death information, the DCM goes into more detail by further specializing the birth and death information about a patient. Figure 4 shows these models.\nThe DCMs of the HL7 organization also provide specifications for the implementation of the models, regarding their representation within a system. Figure 5 illustrates such a specification. It depicts implementation details for the personal identification block of a patient shown in Figure 3. One can observe that personal identification of a patient is divided over several distinct identification systems, such as the Dutch BSN number and the local identification (within an institution). Other identification systems may also exist.\n\n4.4 Treatment\n\nTreatment of patients is a complicated and often very long process. Different factors influence the setting of a treatment plan for a patient. Proper diagnosis of the problem is merely a starting point for determining a treatment plan. This is due to the variety of factors that a patient can have at that point in time, such as allergies, other conditions/problems, and childbearing period.\n\nDescription of a problem should be conducted such that it captures all relevant information about the problem. A DCM has been developed that models this information. As one can observe in Figure 6, a problem is distinguished by many types, each with its own level of complexity. Moreover, the description of a problem involves information about date of occurrence, its frequency, and clinical description.\nBased on the knowledge about the problem and the patient, a treatment plan can be defined. Again, the HL7 organization devised a model for this, including relevant information about treatments, shown in Figure 7.\n\nA typical treatment, especially in epilepsy, involves prescribing medication to patients. A caregiver, usually the treating doctor, issues a prescription, which is realized by the patient in a pharmacy or in a healthcare institution, such as a hospital. The prescription representation is a separate DCM, which includes information about when and what\nhas been prescribed, by whom, and dosage information. Figure 8 and Figure 9 show the DCM that captures this information.\n\nAll of the above mentioned DCMs are used to define a larger model that describes a domain, in this case, the epilepsy domain. This is discussed in the following sections.\n\n4.5 Detailed Clinical Models as building blocks\n\nAs explained in the HL7 introduction in the beginning of this chapter, the DCMs are merely building blocks, or specifications of structure for clinical data in healthcare systems and communication between them. A single DCM is not sufficient to model an entire system. For this reason, the DCMs are building blocks that can be combined to form a bigger model for a particular domain in healthcare.\nNot all DCMs are available for the purposes of this project. Furthermore, DCMs are constantly being evaluated and changed. The models shown in Figure 10 are DCMs with sufficient level of maturity, provided by Synergetics.\n\nThe diagram in Figure 10 represents a model for patient treatment, designed by the candidate for the purposes of this project, and constructed solely of detailed clinical models. For simplicity, only the rootconcept elements are shown to model the domain, otherwise the diagram will be too large. Connections between DCMs are defined by logical relationships that represent real life associations. For example, the relationship between Person and Procedure marked as “treatments” represents the association of treatments related to the patient.\n\nThe model designed contains no specifics regarding epilepsy. This is one of the main advantages of using DCMs; models can be abstracted to the level where they are applicable in different domains. However, in many cases, including this one, specifics are inevitable, which is discussed further in this chapter.\n\n*Figure 10 Model representing patient treatment. The model is constructed by using separate DCMs*\n\nFor the specifics regarding epilepsy, sections 4.6 and 4.7 present models designed specifically to express the domain knowledge and problem definition of the project. The data models defined are not DCMs, they simply enrich the model defined in Figure 10 by filling in the gaps made by the missing DCMs (see section 5.2.1).\n4.6 Epilepsy patients\n\nAs mentioned before, epilepsy treatment is based mostly on anti-epileptic medications. Doctors can prescribe one or many concurrent treatments with various medications that are often adjusted to fit the profile of the patient or based on the response of their administration. The reason for this adjustment is the strength of the medications themselves. Almost all of the anti-epileptic medications affect the brain cells, which often leads to other complications. This is essential information for the doctors since it gives them feedback on how a patient is reacting to a specific medication. It is quite often that patients experience side effects or adverse drug reactions (ADR) to anti-epileptic medications. These side effects include sleepiness, tiredness, and gaining weight.\n\nSeizure-wise, epilepsy is manifested differently in every patient, and patients respond differently to medications. In some patients, the seizures are completely withdrawn or lowered to a minimum, whereas in others, the seizures recur often. Due to the complexity of the disease and the patient himself or herself, seizures can also be provoked by an anti-epileptic medication. This is why seizure information is essential. Based on this information, doctors can observe how patients react to a specific medication and adjust or stop a prescription.\n\nFigure 11 presents the model designed that captures this information. Both seizure and side-effect information contain the date of occurrence and the severity of the event. This information can be related to the current treatment plan, which can give the doctor a better perspective of its effectiveness and possible next actions.\n\n\n\n4.7 Guidelines\n\nBased on research and previous experiences, epilepsy specialists around the world have tried to formalize these experiences in the form of guidelines, which in fact are merely suggestions. The reason why these guidelines cannot be further formalized into rules is because of the different conditions of patients regarding their mental state, health state, lifestyle, age, and gender.\nIn the Netherlands, the Dutch Association for Neurology (in Dutch, Nederlandse Vereniging voor Neurologie) has been developing guidelines as a result of their past experiences and scientific proofs. This resulted in the publication of the document “Epilepsy: Guidelines for diagnosis and treatment” (in Dutch, “Epilepsie: Richtlijnen voor diagnostiek en behandeling”) [8] [9]. As the name suggests, the document elaborates on the diagnosis and treatment, especially the process and medications involved. Since epilepsy is classified by syndromes and seizure types, each of these groups has a separate subset of medications per syndrome and seizure type. Medications can appear as proposed treatment for many syndromes and/or seizure types because of their generic use, regarding epilepsy. Furthermore, patients can experience several syndromes during their lifetime, combined with various seizure types. In some cases, the use of antiepileptic medications is not efficient, and the patients still experience seizures. In these cases, patients can undergo epilepsy surgery, get admitted to specialized epilepsy centers (such as Kempenhaeghe) or have specialized epilepsy treatments. The document focuses on treatment for syndromes and seizure types encountered in the Netherlands, based on experience and research. For the rest, other guidelines are consulted (see section 4.7.4).\n\nAn analysis of this document gives a deeper understanding of the guidelines and a structure is produced that facilitates developing a model that captures guideline information (see Appendix D: The epilepsy guidelines). First, the analysis is discussed and part of the structured view is given. Also, the treatment process is explained. Second, based on this structure, a model is proposed and elaborated.\n\n4.7.1. Analysis of the guidelines\nBased on the analysis of the guidelines document, a structure is identified that can help organize the guidelines. First of all, the guidelines are divided by syndromes and seizure types. Each syndrome is a form of epilepsy that is manifested through different types of seizures. The full classification is elaborated in Appendix B: Classification of epilepsy syndromes and seizure types. For each group, several sub-groups are defined that contain medications that are suggested or recommended for the group. Figure 12 presents the proposed structure for organizing the guidelines per syndrome or seizure type.\n\n<table>\n<thead>\n<tr>\n<th>Syndrome or seizure type</th>\n<th>First choice</th>\n<th>Second choice</th>\n<th>Adjunctive</th>\n<th>Do not use</th>\n</tr>\n</thead>\n</table>\n\n*Figure 12 Proposed structure of a guideline for a single syndrome or seizure type*\n\nThe structure reveals four groups, each one offering or prohibiting anti-epileptic medications that can be tried based on the seizure types or the syndrome that the patient is experiencing.\n\nThe meaning behind each is as follows:\n\n- First choice – best choice medications;\n- Second choice – second best choice medications;\n- Adjunctive – combination of two anti-epileptic medications;\n- Do not use – medication that should never be prescribed to a patient because they can cause side effects or even worsen the seizures.\n\nTable 5 shows part of the guidelines. The full specification of the guidelines separates the guidelines into those based on seizure type, syndrome, status epilepticus for adults, and status epilepticus for children. Status epilepticus is a special seizure, whose duration is longer than five minutes.\nAs mentioned earlier, treatment with antiepileptic medications is not always successful. For this reason, several high-level guidelines are defined that help healthcare professionals decide when it is time to try something else, such as surgery, or admittance to a specialized care center. Refer to Appendix D: The epilepsy guidelines for an overview of these guidelines. Because of their high-level definitions, some of the guidelines are difficult to formalize and operationalize. For example, one of the guidelines states: “Refer epilepsy patients to assess the possibility of specialized epilepsy treatments instead of surgery,” which cannot be made operational because it does not reveal any specifics. On the other hand, a guideline that states: “Consider referring the patient to specialized epilepsy care if the epilepsy debuts in the early years” is clear and easy to formalize, if sufficient patient information is available.\n\n4.7.2. The treatment process\n\nEpilepsy is a serious condition, which has proven to be quite resistant to anti-epileptic medications. As mentioned earlier, epilepsy is classified by syndromes, each one manifesting via one or more seizure types. The selection of treatment is chosen primarily by the seizure type, and secondary on syndrome. Some syndromes, however, determine the optimal choice for the anti-epileptic medications, or advise the medications that should not be used, irrespective of the seizure types. Additionally, factors such as the etiology of the syndrome or its time of onset influence the treatment process.\n\nThe treatment process differs for each syndrome and seizure type. On top of that, the complexity of the disease itself, combined with the effect of the medications and the state of the patient, makes the process more difficult. The existence of several groups or categories of medications allows doctors to try different approaches in different patients. The goal is to find the optimal treatment that will diminish or at least reduce the number of seizures to a minimum.\n\nThe typical treatment involves trying out medication(s) from the before mentioned groups (except the ‘Do not use’ one) based on the seizure types the patient is experiencing. It is often the case that patients still experience seizures after an anti-epileptic medication is administered, and for this reason, doctors try different approaches. These approaches include trying different medications, increasing or decreasing dosages, or starting a combination therapy with two anti-epileptic medications.\n\nGiven that the process is different per syndrome and seizure type, the following tables (Table 6 and Table 7) present the treatment process for two different seizure types, namely focal and absence seizures.\n\n### Table 5 Part of the epilepsy guidelines regarding treatment based on seizure type.\n\n<table>\n<thead>\n<tr>\n<th>Absence seizures (Generalized seizures)</th>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>First choice</td>\n<td></td>\n<td>Ethosuximide</td>\n<td></td>\n</tr>\n<tr>\n<td>Second choice</td>\n<td>Lamotrigine</td>\n<td>Valproate</td>\n<td>Not on pregnant women</td>\n</tr>\n<tr>\n<td>Adjunctive</td>\n<td>1. Any first or second choice</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Vigabatrin</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Phenobarbital</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Carbamazepine</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Phenytoin</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Gabapentin</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Oxcarbazepine</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Pregabalin</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Do not use</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nAs mentioned earlier, treatment with antiepileptic medications is not always successful. For this reason, several high-level guidelines are defined that help healthcare professionals decide when it is time to try something else, such as surgery, or admittance to a specialized care center. Refer to Appendix D: The epilepsy guidelines for an overview of these guidelines. Because of their high-level definitions, some of the guidelines are difficult to formalize and operationalize. For example, one of the guidelines states: “Refer epilepsy patients to assess the possibility of specialized epilepsy treatments instead of surgery,” which cannot be made operational because it does not reveal any specifics. On the other hand, a guideline that states: “Consider referring the patient to specialized epilepsy care if the epilepsy debuts in the early years” is clear and easy to formalize, if sufficient patient information is available.\n\n4.7.2. The treatment process\n\nEpilepsy is a serious condition, which has proven to be quite resistant to anti-epileptic medications. As mentioned earlier, epilepsy is classified by syndromes, each one manifesting via one or more seizure types. The selection of treatment is chosen primarily by the seizure type, and secondary on syndrome. Some syndromes, however, determine the optimal choice for the anti-epileptic medications, or advise the medications that should not be used, irrespective of the seizure types. Additionally, factors such as the etiology of the syndrome or its time of onset influence the treatment process.\n\nThe treatment process differs for each syndrome and seizure type. On top of that, the complexity of the disease itself, combined with the effect of the medications and the state of the patient, makes the process more difficult. The existence of several groups or categories of medications allows doctors to try different approaches in different patients. The goal is to find the optimal treatment that will diminish or at least reduce the number of seizures to a minimum.\n\nThe typical treatment involves trying out medication(s) from the before mentioned groups (except the ‘Do not use’ one) based on the seizure types the patient is experiencing. It is often the case that patients still experience seizures after an anti-epileptic medication is administered, and for this reason, doctors try different approaches. These approaches include trying different medications, increasing or decreasing dosages, or starting a combination therapy with two anti-epileptic medications.\n\nGiven that the process is different per syndrome and seizure type, the following tables (Table 6 and Table 7) present the treatment process for two different seizure types, namely focal and absence seizures.\nTable 6 Treatment process for focal seizures\n\n<table>\n<thead>\n<tr>\n<th>Focal seizures</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>First attempt</td>\n</tr>\n<tr>\n<td>Second attempt</td>\n</tr>\n<tr>\n<td>Third attempt</td>\n</tr>\n</tbody>\n</table>\n\nTable 7 Treatment process for absence seizures\n\n<table>\n<thead>\n<tr>\n<th>Absence seizures</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>First attempt</td>\n</tr>\n<tr>\n<td>Second attempt</td>\n</tr>\n<tr>\n<td>Third attempt</td>\n</tr>\n</tbody>\n</table>\n\nThe complete overview of the guidelines together with the treatment process of all seizure types and syndromes is elaborated in Appendix D: The epilepsy guidelines.\n\nNaturally, there are deviations from this process due to patient’s state. But the process itself reveals a sequence of actions for a treatment. This can be further abstracted as shown in the next section.\n\n4.7.3. Guidelines model\n\nTo capture the model of the guidelines, one needs to take the divisions, groups, and the process into consideration. Looking at a more abstract level, the model or parts of it can also be reused for different domains. The process described in the previous section reveals sequences of actions that can be abstracted to match different healthcare domains. Figure 13 shows the model designed that captures the guidelines information. The elements at the top level of the diagram, Guideline and TreatmentStep, represent the abstraction that can be reused for different domains. As one can observe, a guideline refers to a problem, and the guideline contains a sequence of steps that describe the actions that need to be taken.\n\nFor the epilepsy domain, specifics need to be introduced. The bottom part refers to the specifics, by modeling the relevant parts that encapsulate the information about the guidelines. A special form of TreatmentStep is EpilepsyTreatmentStep that encapsulates additional information, such as what kind of seizure it is related, what medication to use, the category (based on the groups identified), and recommended use (based on the process identified) of the medication and its dosage, and the adjunctive medication and its dosage (for combination therapy).\nFigure 13 Model of the guidelines. The top section represents the abstract part and the lower one is the epilepsy specific.\n\nSyndrome is a specialization of a problem. As mentioned earlier, syndrome is a form of epilepsy that is manifested through different types of seizures.\n\n4.7.4. Other guidelines\nAn often consulted and referred to guideline by healthcare professionals in the field of epilepsy is the guideline defined by the National Institute for Health and Clinical Excellence (NICE)2 situated in the United Kingdom. We will refer to these guidelines as the NICE guidelines3. In their publication, an extensive overview of epilepsy, its classification, diagnosis, treatments, and proof is provided. The use of these guidelines for the purpose of this project is to serve as a backup, when the information in the Dutch guidelines is not present (due to syndrome or seizure not previously encountered within the Dutch healthcare industry).\n\nCompared to the Dutch guidelines, there are small but significant differences between the medication categories as well as the treatment process. Figure 14 shows the structure used in the NICE guidelines.\n\n<table>\n<thead>\n<tr>\n<th>Syndrome or seizure type</th>\n<th>First-line</th>\n<th>Adjunctive</th>\n<th>Other (on referral to tertiary care)</th>\n<th>Do not offer</th>\n</tr>\n</thead>\n</table>\n\nFigure 14 Structure of the NICE guidelines\n\n2 http://www.nice.org.uk/\nThe meaning of each category is as follows:\n\n- **First-line** – same as ‘First choice’ medications in the Dutch guidelines, these are best choice medications;\n- **Adjunctive** – same as ‘Adjunctive’ in the Dutch guidelines, combination of two anti-epileptic medications;\n- **Other** – medications that may be considered on referral to tertiary care;\n- **Do not offer** – same as ‘Do not use’ in the Dutch guidelines, medications that may worsen seizures.\n\nThe NICE guidelines also differ in the treatment process compared to the Dutch guidelines. They do not suggest first or second attempt, although the structure does give some indications on the order of treatment selection.\n\nThe correlation between the first-line and first choice medication in both guidelines suggest that the first and subsequent attempts be selected from the first-line medications. The adjunctive category is never a first attempt for an epilepsy treatment, therefore in the NICE guidelines, it is a second attempt and its subsequent attempts. Regarding the ‘Other’ category, according to the NICE guidelines, this category of medications should be considered when a patient is referred to a tertiary center, but it does not reveal how many attempts should be tried before referral. In these guidelines, a patient is advised for referral to a tertiary center if after two years, the epilepsy is not controlled. The ‘Do not offer’ category is the same as ‘Do not use’ in the Dutch guidelines.\n5. Feasibility Analysis\n\nAfter explaining the problem and the domain, a feasibility analysis is performed to identify the issues and risks that may arise or exist. This chapter covers the issues identified, coupled with the risks and mitigation strategies.\n\n5.1 Issues and challenges\n\nThis section describes the perceived issues and challenges that are encountered during the lifetime of the project.\n\n5.1.1 Detailed Clinical Models\n\nUnderstanding detailed clinical models and how they can be used in the epilepsy domain is critical in the modeling step of the project. Given their different notations of expressing models and their complexity, DCMs add an extra level of complexity in the project.\n\n5.2 Risks\n\nSeveral risks are identified within this project. This section explains the risks identified and the corresponding mitigation techniques.\n\n5.2.1 DCM availability\n\nBecause the DCM models are under development, their availability and level of maturity is an identified risk to the project. The process of designing a DCM takes a long time, because it involves consulting healthcare specialists of different domains, reading literature, and iterations until the model is ready. The goal of a DCM is to be as general as possible so it can be used in different domains.\n\nIn collaboration with experts from Synergetics Benelux BV, a good deal of the DCMs were available, some later than others. On the other hand, some of them were not ready or do not even exist. We assume that these models will arrive, but in order to keep the project going, models were designed that covered the missing information (see sections 4.5, 4.6, and 4.7).\n\n5.2.2 Data variety and availability\n\nSince this project involves working with sensitive data about patients and treatments, a rule was imposed that no personal data will be shared or made available for the needs of this project. Security and privacy issues impose rules about how the data can be used. This means that the user of the data should not be able to identify individuals in any way. These issues also affect the variety of data available for the project.\n\nFor this purpose, Kempenhaeghe already owns a historical data set of anonymous data that is used previously for research purposes. An analysis of this data revealed that these were sufficient for the purposes of this project. By consensus it was decided to use this data in the project. However, a limitation of this historical dataset is that it is not complete, especially for the purposes of the model defined in Chapter 4. The dataset contains the very minimum information provided to fulfil the needs of the project. This has a direct influence on the data models used for the system under design.\n\n5.2.3 Formalization of the guidelines\n\nAs mentioned in section 4.7.1, some of the guidelines are informal and cannot be made operational. On top of that, the data made available for this project, restricts further\nformalization of other guidelines. This is an identified risk, since this part of the guidelines is still under development.\n\nA decision has been made to formalize and put to use guidelines that can be used within the system and can show meaningful feedback based on the data available.\n\n5.2.4. Platform unavailability\nSince the inception of the project, it was decided that NER will be the data provider. This meant that the database setup and data provider is not a concern for this project.\n\nSince the platform was under development and not available in due time for the purposes of this project, a mitigation strategy was imposed to migrate to an existing platform for data storage. A standard relational database was selected as a data provider for the project. The choice was set to MySQL⁴, a relational database management system. MySQL is a popular choice of database for use in web applications.\n\n5.2.5. Structural difference in the guidelines\nTwo different guidelines are used in the project, namely the Dutch and NICE epilepsy guidelines. As explained in sections 4.7.1 and 4.7.4, there is a structural difference in the categorization of the anti-epileptic medications, as well as the treatment process. This causes a problem in the representation of the guidelines within a model.\n\nIn collaboration with experts from Kempenhaeghe, an alignment has been reached that helps to fit the NICE guideline structure into the developed structure for the Dutch guidelines.\n\n⁴ https://www.mysql.com/\n6. System Requirements\n\nAfter analysis of the domain and its problems, a set of requirements are extracted and formulated that have to be satisfied for this project. This chapter presents these requirements, both functional and non-functional ones.\n\n6.1 Requirements gathering process\n\nBoth the problem and domain analysis reveal the core of the problem and its position in the healthcare ecosystem. But a simple problem statement is not enough to proceed with solving the problem itself. What is necessary is a problem decomposition into small and traceable sub-problems that address a specific issue. This decomposition leads to the formalized requirements of the project.\n\nThe problem decomposition process is conducted by repeated discussions with relevant stakeholders and thorough analysis of the problem and domain. These repeated discussions reveal the fine details of the problem and its subcomponents, which further help to differentiate specific requirements for the project.\n\nAfter a number of discussions, a set of requirements is defined. Each requirement has a priority assigned to it, which denotes the importance of that requirement. Three categories of priority are identified:\n\n1. High – requirement must be fulfilled;\n2. Medium – requirement would be nice to have;\n3. Low – requirement is optional (if time permits).\n\n6.2 Product perspective\n\nAs mentioned in the introduction, the project is part of a bigger project, namely the National Epilepsy Register. Previous work on a part of the subject has already been done (\"Prescription visualization\", P. van der Corput, TU/e, 2013 [1]) in the area of prescription visualization over a historical dataset provided from Kempenhaeghe.\n\nThis project takes the visualization to the next level by focusing on the end user ease of use and decision support for doctors. The product will offer tools that help doctors provide better treatment for patients, as well as tools for checking conformance against a set of epilepsy treatment guidelines. This check will allow concerned parties to evaluate how doctors are treating epilepsy patients and will provide feedback for improving the guidelines themselves.\n\nThe stakeholders envisioned the product to be a Web-based application, available to both doctors and patients. A clear distinction must be made between the types of users regarding their actions within the application.\n\nAnother aspect is data anonymity. Stakeholders are concerned with disclosure of sensitive information, hence the data must be anonymized and used solely for research purposes within this project. This refers to patient and conformance information.\n\n6.3 Main features and use cases\n\nThree main features are identified from the requirements gathering process, namely conformance check, pre-prescription check and advised care journey.\n\nThe first feature, conformance check, deals with doctors’ adherence to the epilepsy treatment guidelines. This feature should help doctors identify their prescription patterns and their deviations from the rules. Also, doctors can compare themselves against a certain group of doctors, for example, from another institution.\nThe second feature, pre-prescription check, addresses the possibility of performing a check prior to the actual prescription. Exploring the patients’ medication history and seizures should help doctors to make better decisions before an actual prescription is made.\n\nThe third feature, advised vs. practical care journey, focuses on visualizing the patient journey with epilepsy and its comparison with a set of predefined rules. This feature should enable doctors to point out the similarities or differences of the advised versus the actual patient care journey.\n\nThe refinement of the requirements revealed also the main actors or users of the product. Table 8 lists the identified users and their main scenarios within the system. The presented scenarios in the table are expressed from an abstract point of view. Detailed versions are presented in section 6.5.\n\n*Table 8 Main users and scenarios in the system*\n\n<table>\n<thead>\n<tr>\n<th>User</th>\n<th>Main scenario</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Doctor</td>\n<td>• Check his/her conformance to the guidelines</td>\n</tr>\n<tr>\n<td></td>\n<td>• Check prescription for a patient</td>\n</tr>\n<tr>\n<td></td>\n<td>• Inspect patient’s epilepsy treatment and journey throughout the years</td>\n</tr>\n<tr>\n<td></td>\n<td>• Submit a request to view group data</td>\n</tr>\n<tr>\n<td>Analyst</td>\n<td>• Check doctors’ conformance to the guidelines</td>\n</tr>\n<tr>\n<td></td>\n<td>• Compare doctors’ and group’s conformance</td>\n</tr>\n<tr>\n<td>Patient</td>\n<td>• Check prescription for him/her</td>\n</tr>\n<tr>\n<td></td>\n<td>• View the epilepsy treatment guidelines</td>\n</tr>\n<tr>\n<td>Guidelines manager</td>\n<td>• Maintain epilepsy treatment guidelines</td>\n</tr>\n<tr>\n<td>Group administrator</td>\n<td>• Approve/deny a request to view group data</td>\n</tr>\n<tr>\n<td></td>\n<td>• Delete a request to view group data</td>\n</tr>\n</tbody>\n</table>\n\nFigure 15 shows the system level use cases, which are based on the identified main features and actors within the product. Actors are linked to different use cases they can perform within the system. The use cases marked orange represent the main use cases of the system.\n6.4 Operating environment\n\nOne of the main requirements for the system is that it should be easily accessible via the Web from everywhere. Figure 16 depicts the envisioned deployment of the system.\n\n---\n\n**Figure 15** System level use cases for the project\n\n**Figure 16** Operating environment for the system\n6.5 **Functional requirements**\n\nThis section lists the high-level functional requirements identified after communication with the stakeholders. The requirements are grouped by feature and each of them has an assigned priority.\n\n### 6.5.1. Feature 1: Conformance check\n\nThis feature should provide doctors with the ability to check their conformance against the epilepsy treatment guidelines. The basis for the check are the epilepsy guidelines, and the data that is checked are the doctor’s prescriptions. A prescription is conforming to the guidelines if the prescribed medication is in the list of recommended medications for the syndrome/seizure type that the patient is experiencing.\n\nConformance should be calculated on subsets of the doctor’s prescriptions based on data about patients, such as age, gender, and level of intelligence.\n\nVisualization techniques should be used to convey the information to the end user.\n\nThe feature should also provide means for the doctors to compare their conformance to a group’s conformance of their choosing. However, viewing a group’s conformance results should only be visible after prior authorization by an administrator from the requesting group. Table 9 lists the specific functional requirements connected to this feature.\n\nThe output of this feature should provide the doctors with insight on their conformance to the guidelines and point out similarities or differences when compared to a group.\n\n**Table 9 Functional requirements for the Conformance check feature**\n\n<table>\n<thead>\n<tr>\n<th>ID</th>\n<th>Description</th>\n<th>Priority</th>\n<th>Depends on</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>FR_1.1</td>\n<td>The system should enable the user to calculate his/her conformance to the guidelines, using his/her prescriptions as input</td>\n<td>High</td>\n<td></td>\n</tr>\n<tr>\n<td>FR_1.2</td>\n<td>The system should visualize the results of the conformance check</td>\n<td>High</td>\n<td></td>\n</tr>\n<tr>\n<td>FR_1.3</td>\n<td>The system should enable the user to compare his/her conformance to a group of his/her choosing</td>\n<td>High</td>\n<td>FR_1.1, FR_1.5</td>\n</tr>\n<tr>\n<td>FR_1.4</td>\n<td>The system should enable a specific user type (researcher) to check conformance of any doctor or a group</td>\n<td>Medium</td>\n<td>FR_1.1</td>\n</tr>\n<tr>\n<td>FR_1.5</td>\n<td>The system should enable the user (doctor) to submit a request to view a specific group’s data within a specific time period</td>\n<td>High</td>\n<td></td>\n</tr>\n<tr>\n<td>FR_1.6</td>\n<td>The system should enable a specific user to approve, deny or delete a request to view group’s data</td>\n<td>High</td>\n<td>FR_1.5</td>\n</tr>\n<tr>\n<td>FR_1.7</td>\n<td>The system should allow only registered doctors to use this feature</td>\n<td>High</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n6.5.2. Feature 2: Pre-prescription check\n\nThis feature should provide the end user with decision support by means of prescription checking when prescribing medications to an epilepsy patient. Dosages should not be suggested, unless they are strictly defined and apply to every epilepsy patient. The information shown should provide the user with relevant feedback and suggestions about the prescription itself.\n\nThe prescription checking includes checking for conformance to the guidelines and checking for reported side effects to the prescribed medication. The results should be presented in a neutral way, meaning the doctors should not be directly advised on their next actions. Other possibilities or alternatives on a medication selection should be provided to the user, based on the experienced syndromes/seizure types of the patient.\n\nThe feature should provide a view into the patient history with medications (with their retention times, seizures, and level of medications in patient’s blood. A retention time is the longest period a medication has been prescribed to a patient.\n\nIn case information is missing from the Dutch guidelines, the NICE guidelines should be used as a backup. Table 10 lists the specific functional requirements connected to this feature.\n\nThe benefit from this feature is decision support for better medication prescription based on previous information about a patient.\n\n<table>\n<thead>\n<tr>\n<th>ID</th>\n<th>Description</th>\n<th>Priority</th>\n<th>Depends on</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>FR_2.1</td>\n<td>The system should enable the user to check a prescription for compliance to the guidelines</td>\n<td>High</td>\n<td></td>\n</tr>\n<tr>\n<td>FR_2.2</td>\n<td>The system should offer alternatives for other medications available for the same condition of the patient in question</td>\n<td>High</td>\n<td>FR_2.1</td>\n</tr>\n<tr>\n<td>FR_2.3</td>\n<td>The system should check for reported side effects based on the selected medication</td>\n<td>High</td>\n<td>FR_2.1</td>\n</tr>\n<tr>\n<td>FR_2.4</td>\n<td>The system should check for reported seizures when the patient had a treatment with the selected medication</td>\n<td>Low</td>\n<td>FR_2.1</td>\n</tr>\n<tr>\n<td>FR_2.5</td>\n<td>The system should visualize the medication and seizure history of the patient</td>\n<td>High</td>\n<td></td>\n</tr>\n<tr>\n<td>FR_2.6</td>\n<td>The system should allow only registered doctors and patients to use this feature</td>\n<td>High</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n6.5.3. Feature 3: Advised vs. practical care journey\n\nThis feature should provide the end user with a tool for comparing the advised care journey versus the practical care journey. The patient’s practical care journey is represented by all the actual events that transpired during the patient’s epilepsy related care. The advised care journey is represented in the guidelines in a form of advises with dates referencing from the point of diagnosis of epilepsy to the patient.\n\nVisualization should be used to show the two timelines.\n\nThe feature should provide a clear view of the similarities and differences in the journeys, which should give valuable feedback to both doctors and patients. Table 11 lists the specific functional requirements connected to this feature.\n\nThe benefit of the feature is a deeper understanding of the history of the patient through graphical representation of his events.\n\nTable 11 Functional requirements for the Advised vs. practical care journey feature\n\n<table>\n<thead>\n<tr>\n<th>ID</th>\n<th>Description</th>\n<th>Priority</th>\n<th>Depends on</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>FR_3.1</td>\n<td>The system should enable the user to compare his/her practical care journey against the advised care journey</td>\n<td>Medium</td>\n<td></td>\n</tr>\n<tr>\n<td>FR_3.2</td>\n<td>The system should enable doctors to check a patient’s journey.</td>\n<td>Medium</td>\n<td>FR_3.1, FR_3.3</td>\n</tr>\n<tr>\n<td>FR_3.3</td>\n<td>The system should allow only registered doctors and patients to use this feature</td>\n<td>Medium</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n6.5.4. Feature 4: Guidelines management\n\nThis feature should provide end users with the ability to manage the data about the guidelines. This includes addition of new data, and removal or modification of existing data. This operation is to be performed by a special role in the system. Viewing the epilepsy treatment guidelines should be enabled for any user, even the ones not registered in the system.\n\nTable 12 lists the specific functional requirements connected to this feature.\n\nTable 12 Functional requirements for the Guidelines management feature\n\n<table>\n<thead>\n<tr>\n<th>ID</th>\n<th>Description</th>\n<th>Priority</th>\n<th>Depends on</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>FR_4.1</td>\n<td>The system should enable users with a specific role (administrative role) to make changes in the guidelines information</td>\n<td>High</td>\n<td></td>\n</tr>\n<tr>\n<td>FR_4.2</td>\n<td>The system should enable users to add new data, modify or delete existing data</td>\n<td>High</td>\n<td>FR_4.1</td>\n</tr>\n<tr>\n<td>FR_4.3</td>\n<td>The system should enable read-only access to the guideline information to all users to the system</td>\n<td>High</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n### 6.6 Non-functional requirements\n\nBesides the functional requirements, a number of non-functional requirements are identified from the requirements gathering process.\n\n#### 6.6.1. Security requirements\n\nThe product is meant to be used both by healthcare professionals as well as patients. Each user should have its own profile and access credentials that are for personal use only.\n\nSince the system is dealing with personal data, sharing this data must be controlled via access rights and policies for proper use. Trusted sharing however, can be made possible because the end user is in control and it is he/she that manages who can access their data.\n\nOn the other side, law and regulations will overrule the users’ full access and control. As an example, a doctor has the rights and obligations to access all healthcare related data of his/her patients.\n\n#### 6.6.2. Software quality attributes\n\nA number of software quality attributes are identified that the system should satisfy.\n\n**Maintainability**\n\nThe system should be easily maintainable, meaning that the system can undergo changes with a degree of ease.\n\n**Performance**\n\nThe system should respond reasonably fast to user requests. In clinical use, the maximum response time is 3 seconds for any clinical operation. For complex procedures and calculations, information should be shown about the status of the current operation.\n\n**Extensibility**\n\nSystem should be both vertically and horizontally extendable. This means that it should be easy to add or modify features.\n\n**Usability**\n\nThe system should satisfy the requirements of the owner and the stakeholders of the project in a way that the system is made usable, intuitive, and friendly.\n\nUpon opening the system, user should immediately understand the interface and its basic navigation. After following a 1 hour course without any prior knowledge of the system, and basic knowledge of computers, the user should be enabled to perform all the features that the product offers.\n\nLocalization of the system is important, because the majority of the users speak the Dutch language.\n7. System Architecture\n\nThe purpose of designing an architecture for a system is solving a problem statement formalized with system requirements. The previous chapter (Chapter 6) elaborates on both functional and non-functional requirements of the system. This chapter elaborates the architectural reasoning and design decisions made that resulted in a design of the system based on the identified requirements.\n\n7.1 Architectural reasoning\n\nA good starting point when designing an architecture is choosing a suitable architectural style or pattern. An architectural pattern is a set of principles that provide an abstract framework for solving frequently recurring problems. Formally, an architectural pattern is a description of element and relation types together with a set of constraints on how they may be used [10].\n\nAn architectural pattern gives the backbone of the design. The pattern is typically chosen based on the non-functional requirements. Every pattern exhibits certain quality attributes, but not all can fit the non-functional requirements of a project or are not needed.\n\nFor the purposes of this project, several key drivers steer the decision for an architectural pattern and later design of the system (ordered by importance):\n\n1. High-level requirements;\n2. Non-functional requirements;\n3. Functional requirements.\n\nOne of the main requirements of the product (see section 6.2) is for it to be a web application available to end users, such as doctors and patients. Typically, web applications follow the client-server architectural style, where clients (web pages viewed in users’ browsers) make requests to servers (in many cases, server is a database with application logic represented as stored procedures). The client-server architectural style is also referred as 2-tier architectural style.\n\nAlthough it is not an explicit requirement for this project, one of the main interests of Kempenhaeghe is setting up the NER as a centralized knowledge base. This database should serve as a basis for development of variety of healthcare-related systems. Putting this into perspective, the design of this system should be such that the database is decoupled from the specifics of the system under design.\n\nStarting from a client-server architecture, this decoupling of the database imposes addition of a new tier and hence a move towards a 3-tier architecture, namely presentation, logic, and data tier. The 3-tier architecture is very common in today’s systems, due to the qualities it exhibits, such as maintainability, scalability, flexibility, and availability. The basic idea behind this architecture is to separate the functionality into segments or tiers that can be deployed (not necessarily) on different physical computing platforms.\n\nIf we reflect on the non-functional requirements in section 6.6, again the 3-tier architecture suggests a good fit. It adds qualities not envisioned initially, such as flexibility to manage and scale tiers individually and availability of tiers to other systems or components. This is complemented with the functional requirements where different features are identified, each with its own distinctive purpose.\nOne of the core principles behind the client-server model (the predecessor of the 3-tier model) is separation of concerns. By separation of the tiers’ concerns from each other, an independent evolution of each tier is allowed, as long as communication between them remains the same. This separation of concerns allows any tier to be changed or replaced without affecting the rest of the system as long as the communication interface remains the same.\n\nThe deployment of a typical 3-tier web architecture consists of a presentation tier (front-end web server that hosts the web application), logic tier (application server that hosts the business logic of the system), and data tier (database server that hosts the data itself).\n\nThe following sections focus on the logical segments of each tier and the reasoning behind the architectural style selected for each of them. The order is bottom-up, starting from the data tier, to the logic and presentation tier.\n\n### 7.2 Data tier\nThe data tier is responsible for data storage and manipulation. The manipulation involves serving the upper tier by executing its requests. The requests involve retrieving, storing, modifying or deleting data. Sometimes complex processing is also done on this tier in the form of stored procedures for optimization.\n\nThe data tier typically consists of a physical computer (usually called server) that runs database management systems, which allow access to the data itself. These servers are high-end processing machines that can support many requests at the same time and heavy processing. Naturally, the NER resides in this tier.\n\n### 7.3 Logic tier\nThe logic tier is responsible for coordinating the application, processing of commands, and enforcing logical decisions related to business rules for the application in question. The responsibility extends to moving and processing data between its two surrounding layers [11].\nOne of the key drivers for designing this tier is the requirement of making the NER the basis for development of other healthcare-related systems. Having not to expose the NER directly to these other systems, a structured and well-defined way of exposing the data is needed. Since the NER is in very early stages, many modifications are expected. With this in mind, this structured and well-defined way must be easily extendable, both vertically and horizontally. Vertical extensibility means that new features can be easily added, and horizontal extensibility means existing ones can be easily extended.\n\nBesides extensibility, ease of modification and the rest of the identified non-functional requirements steer the design choice into a component-based architecture. The main idea behind a component-based architecture is decomposition of the design into individual functional components that expose well-defined communication interfaces. The benefit of using components is that they are reusable, replaceable, easily extendable, and independent [12].\n\nAnother driver to be considered in the design of this tier are the functional requirements. As explained in the functional requirements section, several features are identified, which are decoupled from each other. They only share the domain model regarding patient-related information. All features use data from this model to realize their intent. The feature decoupling is in line with using a component-based approach, where each feature represents its own component.\n\nIn the world of distributed network systems, a typical way of offering functionalities usable by multiple systems is through services, specifically web services. A web service is a method of communication between two devices over a network. For simplicity, consider a service as a functionality that can be reused for different purposes. One of its purposes is to serve the needs of the system under design.\n\nThe idea of the services to be usable by other systems rather than only the system under design imposes additional requirements. Such requirements are:\n\n- Services should be independent of the clients that use them;\n- Services should not be aware of the clients that use them;\n- Services should provide a uniform interface.\n\nDue to the variety of technologies nowadays, systems are built using different programming languages and different technologies. For the services to be independent and unaware of their clients, they need to exchange data in such a manner that is indifferent to the programming language used to build the client systems.\n\nSuch a way is achieved through exposing an Application Programming Interface (API), or in case of the system under design, a web API. A web API is a programmatic interface to a defined request-response message system, typically expressed with languages such as JavaScript Object Notation (JSON) or Extensible Markup Language (XML). These APIs are exposed via the web by using the Hyper Text Transfer Protocol, or HTTP (see section 7.3.2).\n\nFrom a functional point of view, the web application (presentation tier) will request functionalities offered by the services or APIs (logic tier, or even service tier), which in turn will process the request and access the database (data tier) to retrieve the necessary information, if needed.\n\nThere is an architectural style that encourages development of scalable web services (APIs), uses well-known protocol for communication (HTTP), and promotes independence from clients that use them: the Representational State Transfer architectural style, or REST.\n\nThe following sections present the architectural styles and protocols that play a role in the architecture, and finally, section 7.3.4 presents the architecture of the logic tier.\n7.3.1. Representational State Transfer (REST)\n\nREST is a hybrid style derived from several network-based architectural styles, such as data flow styles (Pipe and Filter), replication styles (Cache), and hierarchical styles (Client-Server, Layers) combined with additional constraints that define a uniform connector interface. The World Wide Web itself represents the largest implementation of a system conforming to the REST style.\n\nThe REST style exhibits certain properties and imposes several constraints. Some of the architectural properties of REST are:\n\n- Scalability (support for large number of components and interaction between them);\n- Simplicity of interfaces;\n- Modifiability to meet changing needs;\n- Portability of components.\n\nThe properties of REST are realized by applying several constraints to the architecture. The formal constraints of REST are:\n\n- **Client-Server** – separation of concerns is the principle behind this constraint. By separation of the user interface from the application or data logic, an independent evolution to components is allowed;\n- **Stateless** – communication must be stateless in nature. Each request from client to server must contain all the information for the server to understand the request and cannot take advantage of any stored context on the server. This improves visibility (no need to get additional info about a request), reliability (easy recovery from partial failures), and scalability (state is not stored between request, less resource usage);\n- **Cache** – data within a response should be explicitly labeled as cacheable or non-cacheable, for equivalent requests;\n- **Uniform interface** – a distinguishable central feature of REST is a uniform interface between components. Implementations are decoupled from the services they provide. The trade-off is efficiency, uniform interfaces degrade efficiency, since information is transferred in a standardized form rather than format specific to an application’s needs. REST defines four interface constraints: identification of resources, manipulation of resources through representation, self-descriptive messages, and hypermedia as the engine of the application state;\n- **Layered system** – encapsulate legacy services and protect new services from legacy clients. A disadvantage is that they add overhead and latency to data processing. The combination of a layered system and uniform interface resemble the pipe-and-filter architectural style;\n- **Code-On-Demand (optional)** – REST allows client functionality to be extended by downloading and executing code in the form of applets or scripts. This improves system extensibility but reduces visibility.\n\nThe key abstraction of REST is a resource. Any information that can be named can be a resource, such as documents, images, services, and other resources. REST uses a resource identifier to identify the particular resource involved in the interaction between components. These identifiers are called uniform resource identifiers (URI) [13].\n\n7.3.2. Hypertext Transfer Protocol (HTTP)\n\nHTTP is the foundation of data communication for the World Wide Web. This protocol is an application-level protocol for distributed, collaborative, hypermedia information systems. It is used to deliver data, such as images, services, and other resources. REST uses a resource identifier to identify the particular resource involved in the interaction between components. These identifiers are called uniform resource identifiers (URI) [13].\nis processed by the server, the server re-establishes connection with the client to send a response back:\n\n- **Media independent** — Any type of data can be sent by HTTP as long as both the client and server know how to handle it;\n- **Stateless** — As a consequence of the first feature, HTTP is a stateless protocol. The client and server know about each other only during a current request. After this, they both forget about each other.\n\nA request from a client to a server contains an URI, the version of the protocol used, media type requested, information about the client and possibly some contents in the request. A response from the server to the client includes the protocol version, a success or error code, followed by the server information, metadata information, and request-related data [14].\n\n### 7.3.3. RESTful APIs\n\nHaving explained the REST style, APIs, and HTTP, a Web service API that adhere to the REST architectural constraints is called a RESTful API. HTTP based RESTful APIs are defined with these aspects:\n\n- Base URI, such as http://example.com/resources/;\n- An Internet media type for the data. This is often JSON but can be any other valid Internet media type (e.g., XML, and images);\n- Standard HTTP methods (e.g., GET, PUT, POST, or DELETE);\n- Hypertext links to reference state;\n- Hypertext links to reference related resources [15].\n\n### 7.3.4. Towards an architecture\n\nIt is not uncommon to combine multiple architectural styles in one design. Such a case is the system under design, where component-based style is mixed with the REST style. The component-based design allows features to be independent, while REST allows for the web APIs to be independent of its clients.\n\nFigure 18 shows the logic tier architecture. The functionalities of the system are exposed through the REST API, which uses the components of the system to process the requests.\n\nThe goal of this modular design is to separate the concerns of each component. The REST API is only concerned with accepting and acting upon a request. It delegates the processing to the component intended to perform it. As soon as the request is processed, the API component is responsible for replying to the request.\n\nThe application components handle the specific processing they are intended to perform. As discussed previously, each feature of the system is independent of each other, with the exception of sharing domain information and data access. As one can observe from the diagram, all of the application components use the Data Access and Domain component. The Pre-prescription check component is responsible for checking and controlling prescriptions before they are issued. The component gives feedback and suggestions based on the information provided in the prescription. The Conformance check component is responsible for processing doctors’ prescriptions and calculating their conformance to the epilepsy guidelines. It also involves conformance comparisons between doctor and a group. The Advised Care Journey component is responsible for determining the similarities or differences between the actual care journey of the patient and the advised one. The Guidelines component offers services related to the epilepsy guidelines, such as modifying, adding, or deleting data. The Benchmark Request component offers services for requesting conformance comparisons against other groups or organizations. It involves submitting, approving or denying a request, as well as deleting an existing request. Finally, the Analytics component is responsible for statistical analysis and insights creation regarding doctors’ prescription patterns.\nFigure 18 Logic tier architecture\nThe application components do not depend on the REST API component, meaning they can be reused in different applications with different technologies.\n\nThe Domain component is a representation of the domain objects that are needed for the system under design. It involves generic and domain specific representations, such as patient, treatment, and epilepsy-related representation.\n\nThe Data access component is responsible for database access and data manipulation, mainly to retrieve, or issue commands to insert, modify, or delete data. Depending on the database technology used, most of the database management systems support execution of procedures in the database for optimization in processing large datasets. Chapter 8 dives into more detail for the API and the components.\n\n### 7.4 Presentation tier\n\nThe presentation tier is responsible for presenting data to the user and usually allows data manipulation and entry. The two main types of user interface for this layer are traditional applications and Web-based applications.\n\nOver the years, the World Wide Web has evolved dramatically. Traditional web applications involved transitioning from page to page, where each page is generated dynamically on a remote server and sent to the browser where it is rendered. The beginning of the 21st century spawned the term Web 2.0. The term describes World Wide Web sites that emphasize user-generated content, usability, and interoperability. Parallel to the World Wide Web, a lot of progress has been made in modern web development. A shift has been made towards thin client-side Web-based applications that contain only the user interface (UI) and the data to be displayed. All the data processing is done in the logic tier. Page rendering is transferred on the client-side as the browsers became more and more powerful.\n\nBesides the requirement of a web-based application, one of the main non-functional requirements for the system under design is usability. According to an older definition (ISO9126-2001 standard, revised with ISO/IEC 25010:2011 standard), usability is the capability of the software product to be understood, learned, used and attractive to the user, when used under specified conditions. The new definition states: degree to which a product or system can be used by specified users to achieve specified goals with effectiveness, efficiency and satisfaction in a specified context of use [16].\n\nUtilizing the advances made in modern web development, the choice of the architecture for the presentation tier should maximize the usability. The other requirements should not be excluded as well. Maintainability, performance, and scalability have to be taken into consideration.\n\n#### 7.4.1. Model View Controller (MVC)\n\nOne of the most famous and often used architectural patterns for developing user interfaces is the Model View Controller (MVC) pattern. It started as a framework developed by Trygve Reenskaug for the Smalltalk platform in the late 1970s. The pattern divides an interactive application into three components:\n\n- **Model** – a nonvisual object that contains the core functionality and data;\n- **Views** – display of the model in the user interface;\n- **Controllers** – handler for user input and model manipulation.\n\nThe views and the controllers comprise the user interface. A mechanism that propagates changes ensures consistency between the user interface and the model.\n\nThe MVC pattern introduces two principal separations, the model from its presentation and the controller from the view. The first one is the fundamental one, because model and view have different concerns. The model represents business or application specific data, while the presentation concerns how this data is presented to the user and the interface mechanics. The pattern also allows for independent development of\npresentations of the same model. This is useful when different users want different presentations. The presentation, however, depends on the model, but not vice versa [11].\n\n\n\n### 7.4.2. Model View ViewModel (MVVM)\n\nThe MVVM architectural pattern is a derivative of MVC and it has been developed in the last decade. It is a well know user interface design pattern used in many applications. MVVM consists of the following parts:\n\n- Model – same as the model part of MVC;\n- View – same as the view part in MVC;\n- ViewModel – handles UI input and is responsible for propagating changes either one or two way between the view and the model. It can also pass commands from the view to the model.\n\nThe main difference between MVC and MVVM is the view model’s responsibility. While controllers can serve more than one view, the view model is coupled only to one view. In fact, the view model is a very specific controller. Moreover, the view model is used as a container for data and commands that the view can use and not as an orchestrator like controllers in MVC [17].\n\n\n7.4.3. Single-Page Application (SPA)\n\nSingle-Page Application (SPA) is a term that is not new (appeared first around 2004), but has been getting a lot of attention in the past 5 years. A SPA is a web application or a web site that aims to provide a more fluid user experience such as one in desktop applications. The paradigm of SPA is that either all code is downloaded with a single page load or resources are loaded dynamically as they are requested (typically by user actions). The idea is that the page does not reload at any point in the process, nor the control is transferred to another page [18].\n\nIn traditional web applications, every time the application makes a request to the server, the server has to create the whole HTML page. This triggers a page refresh in the browser, which causes the page to be reloaded and the user experience the disappearing and appearing of a web page. In a SPA, however, after the first page loads, all interactions with the server are done through asynchronous calls that return only the data needed (usually in JSON format). The SPA uses this data to update the page dynamically, without reloading. This gives a more fluid and responsive experience to the user. From an architectural point of view, this enables the separation of the presentation tier and the logic tier. As mentioned previously, this separation allows independent evolution of each tier, which increases the maintainability and scalability of the system under design.\n\nFigure 21 shows a comparison between a traditional page’s lifecycle and an SPA lifecycle.\n\n\n\nFigure 21 Traditional page lifecycle vs. SPA lifecycle. The difference is in the second request to the server, where traditional web pages send a synchronous request, SPA send an asynchronous request (or Asynchronous JavaScript And XML or AJAX calls) to retrieve the data needed, usually in JSON format (image borrowed from https://msdn.microsoft.com/en-us/magazine/dn463786.aspx?f=255&MSPPError=-2147217396)\n\nIn a pure SPA, all the user interface interaction occurs on the client side. After the initial page load, the server acts purely as a service layer. The client just needs to know what requests it needs to send. It doesn’t care how the server implements things on the back end. With this isolation, the client and the server become independent. Both of them could be easily replaced as long as the API remains the same [19].\n\nAs the concept of SPA started to become more and more popular, frameworks have been developed that enable development of such SPAs. Almost every framework developed encourages using the MVC pattern for developing SPAs. The pattern serves as a foundation. The reasoning behind it is separation of concerns, where the designer\ndesigns for reusability, maintainability, and testability. If properly designed, MVC provides a clean architecture that allows the SPA to be easily modified or scaled [17].\n\n7.4.4. Towards an architecture\n\nThe reasoning behind the architecture is based on the user interface point of view. The system under design should maximize the usability by providing the best user experience. Usability by itself is defined with several other non-functional requirements, such as understandability, learnability, and attractiveness. Maximization of the usability means that the product is easy to learn and use, and is also attractive to the user.\n\nDue to the nature of SPAs and their focus on user experience, the architecture for the presentation tier chosen is MVVM, particularly SPA designed using the MVVM pattern.\n\nFigure 22 shows the high-level architecture of the presentation tier. Again, the component-based or modular style is followed to model the separate features. The architecture consists of six different components that cover the desired functionalities of the system under design and several other components for various purposes, such as communication with the service API that will provide the presentation tier with data, or visualization libraries to support the data visualization.\nFigure 22 Presentation tier architecture\nThe six application-specific components follow the MVVM pattern, with each module having a separate view, view model, and model component. In this way, modularity is achieved on both component and sub-component level.\n\nChapter 8 (\"System Design\") elaborates on the specifics of the component design whereas Chapter 9 (\"Implementation\") dives even deeper with concrete frameworks used and implementation details.\n8. System Design\n\nThe previous chapter, “System architecture,” shows the high-level view on the system and its major components. The logic and presentation tier have different responsibilities and therefore different designs are created. This chapter elaborates the two designs and the transition from high-level architecture to component design.\n\n8.1 Introduction\n\nThe system design is explained by utilizing the “4+1” view for describing software-intensive systems architecture developed by Philippe Kruchten. The approach suggests using multiple, concurrent views to express different concerns separately to various stakeholders, such as end users, developers, and system engineers, and to handle separately the functional and non-functional requirements. The views in question are as follows:\n\n- Logical view – object model and behavior of the design;\n- Process view – concurrency and synchronization aspects of the design;\n- Development view – static organization of the software in its development environment;\n- Deployment view – software-to-hardware mappings and distribution aspects.\n\nThe fifth view of the “4+1” is the scenario view, which serves as a reference point for the decisions made for the design of the architecture [20]. The scenario view is presented through use cases (see section 6.3).\n\nAn additional view is introduced in order not to clutter the logical design. The view in question is the data (base) view and depicts the models of the domain, in this case patient, treatment and epilepsy-related information.\n\nThe following sections discuss the different views for the logic and presentation tier. The data tier is separately discussed at the end of the chapter.\n\n8.2 Reference use case\n\nSection 6.3 discusses the main features and use cases of the product. Figure 15 in section 6.3 depicts several main use cases and a number of auxiliary ones. The use cases represent the user stories in the system, or what the system is supposed to do in interaction with the user.\n\nAs mentioned earlier, several scenarios are identified, such as checking a prescription, checking for conformance, and viewing a patient’s journey. All of these scenarios involve participation of the end user. Furthermore, similarities between them exist. For example, most of the scenarios involve selecting a patient or a doctor. Next, an action is triggered to retrieve an answer. The request is processed, data is generated and returned back to the end user in the form of a visual information or feedback. With this, we can identify common steps that identify a use case. The notation used to describe the use case is:\n\n- User – represents the end user, such as doctor or patient;\n- Client-side system – represents the presentation tier, or the web application;\n- Server-side system – represents the logic tier, or the services for the web application.\nThe steps are as follows:\n\n1. User request to perform a feature;\n2. Client-side system shows the interface;\n3. User enters required information and initiates action;\n4. Client-side system verifies information\n a. If entered information is incorrect, user is notified. No action is taken;\n b. If entered information is correct, scenario continues;\n5. Client-side system sends request to Server-side system to perform the requested action;\n6. Server-side system accepts and processes the request;\n7. Server-side system generates the requested information and sends it back to the client-side system;\n8. Client-side system receives the information and displays it to the user.\n\nRefer to Appendix C: Use cases of the system for specific use cases and their concrete steps. The steps described in the appendix are at a more abstract level, as they should be, understandable to end users. The steps described in this section serve as a reference for the design of the system and reveal some technology-specific information. A typical use case should be technology independent.\n\n8.3 Logical view\n\nBoth designs of the logic and presentation tier follow the component-based approach. Each component in the design has distinctive responsibilities, which makes it easier to be replaced or modified.\n\n8.3.1. Logic tier\n\nThe architecture of the logic tier includes a combination of two architectural styles, namely REST and component-based. The REST style is used to design the request handling part and the component-based style to design the business or application logic. A total of six components are designed in the architecture. For sake of simplicity and understandability, the designs shown in the following figures concern one chosen component, namely Prescription checks. If the name Prescription checks is replaced with the name of the other components, such as Conformance check, Patient journey, and Guideline management, one obtains the design of the other components. Figure 24 depicts the logic tier architecture, starting from the REST service on the top and moving towards concrete components in the bottom.\nThe service part of the architecture (the API) is further modularized to offer services for each component it serves, namely the conformance check service for the conformance check component. This way, both the service and component can be easily maintainable. The API consists of several services, represented with the Application component and its controllers. A service for a component is divided into two parts, a Controller that handles the requests from various clients, and a ServiceProxy that processes the request.\n\nSection 7.3.1 defined an API conforming to the REST style with several aspects, one of them being the Universal Resource Identifier, URI. These URIs are uniquely identifiable access points or endpoints for each service offered by the API. Each controller is identified by a segment of the URI it can handle. In Figure 24, this is shown through the Endpoint section of the concrete controller PrescriptionCheckController, and its endpoint value of “prescription.” Combined with the entry point of the whole API (the endpoint value of Application being “/api”), every request with a URI that has a segment equal to “/api/prescription” will be handled by the PrescriptionCheckController. Furthermore, each controller exposes concrete endpoints that clients can use to request their service.\n\nEach controller has exactly one service proxy. As the name suggest, the service proxy delegates the request handling to the component it is connected to. This delegation helps to further separate the responsibilities of the REST service and the application logic, if one wishes to replace one of the two (with different implementations, for example). Figure 25 depicts the PrescriptionCheckController and its service proxy.\nFigure 25 The API section of the logic tier. An API consists of controllers that handle HTTP requests (GET, POST, PUT, and DELETE). The URI to a specific resource is constructed from the entry point to the service, the entry point of the controller, and the entry point to the resource.\n\nIn order to hide details about implementation of the components, each proxy requests a `ServiceFactory` from a component called `FactoryProvider`. The role of this provider is to provide factory instances to the service, which in turn can produce concrete components that handle the requests. The REST service knows nothing about their implementation. This is controlled through a set of defined interfaces. Figure 26 shows the responsibilities of the provider and service factories.\n\nFigure 26 Provider, abstract and concrete service factory. The responsibility of the service factory is to instantiate concrete services that process the request.\n\nThe extra layer of abstractions between the service factories and components and concrete service factories and components is added for extensibility and maintainability purposes. If a different implementation of an existing component has to be made, a change has to be made only in the factory that instantiates that component. Moreover,\neven a complete implementation of the application-specific component can be changed by simply changing the service factory that the provider supplies to the API.\n\nAs depicted in the architecture in Figure 18 each of the application-specific components uses the DataAccess component to perform some action with data from the database. The same level of abstraction is applied as in the other components, an abstract factory that provides its clients with interfaces for creating data access components, and concrete factories that implement these interfaces. The data access component is the one responsible for communication with the data tier and manipulating the data. The abstraction of the factory and the data access component makes the switch to a different component very easy. If the database is changed, and different technology is used, then only the data access component needs to be adjusted (or re-implemented). To the application-specific components, the data access is available through the provider.\n\nAnother component depicted in the architecture is the domain component. This component consists of the domain models representing system-specific information, in this case, patient, treatment, and epilepsy information. A more detailed view of the contents of this component is presented in the data view.\n\n8.3.2. Logic tier behavior\n\nPart of the logical view of the system is to describe its behavior, by means of sequences of communication between components. For this system, the behavior is expressed through a client-server communication via exchanging HTTP messages that contain the data needed for the client, or the web application. The sequence shown in the two tiers’ diagrams represent instances of the reference use case, described in section 8.2, for a particular module.\n\nThe behavior of the logic tier is represented with the request handling and response dispatching part of the client-server communication. Figure 27 shows a sequence diagram of an interaction between the client and the API.\n\nThe interaction starts with the controller receiving the request from the client. Based on the URI, a specific controller is chosen that handles the requested segment and the concrete service requested by the URI. The controller simply delegates the call to the service proxy. Since each service proxy knows which concrete service it needs to process the request, the factory provider is consulted to provide the proxy with a service factory instance. As depicted in the design of the logic view, Figure 24, the FactoryProvider is marked as singleton. This means that only one instance is created within the system, in this case, all requests use the single instance of the factory provider to create specific components. This also means that the factory instances for both the component and data access are persistent throughout the lifetime of the process. Since the factories have no state and their sole purpose is to create components, a single instance of them is sufficient. Through this instance, the proxy creates the concrete service it needs without knowing its implementation and delegates the request to the service.\n\nIf the service requires data from the data tier (usually it does) then again the factory provider is consulted for the data access factory instance. Through this instance, the service creates a data access component that will provide the service with the data needed. The communication starts by establishing a connection to the data tier. When the connection is established, the data access components requests the data needed. After it is received, it is returned to the service, the connection to the data tier is not needed anymore, and therefore it is closed. The service uses this data to process the request, and creates (if needed) a response. This response is returned via the service proxy back to the controller. Since the controller is responsible for accepting requests and dispatching responses, the response data needs to be converted to a standardized format before it is sent back to the client. In this case, the response data is converted to JSON format, and the response is sent back to the client.\nFigure 27 Sequence diagram representing interaction between the client and the API\nAs one can observe from this interaction, no state information is requested or stored anywhere about the client that requests information. Also, the server does not use any context stored on the machine to handle the request. The service is completely stateless, it reacts to requests and issues responses.\n\n8.3.3. Presentation tier\n\nThe architecture of the presentation tier is based upon the MVC design pattern. The pattern is very common in user interface development, because of its separation of concerns and ability to independently develop parts of the system, for example views and controllers. The choice of the design is influenced also by the SPA approach, which encourages the use of the MV* patterns (where the star can replace: C for controller, VM for view model, or P for presentation).\n\nTo further segregate the responsibilities, the design of the tier is made modular based on the features identified for the product. With this in mind, the design of the tier includes modules, such as conformance check, and pre-prescription check, which are designed following the MVVM pattern.\n\nFigure 28 shows the design of the presentation tier. Again, the design shown, namely for Conformance check, represent a design of a single module. The rest of the modules follow the same approach, if the name is replaced with the other modules’ names, such as Prescription check, Patient journey, and Guideline management. As one can observe, a module consists of a view, a controller and a model. The view is responsible for the user interface, displaying data to the user, and user interaction. The controller is responsible for handling the interaction between the user and the view, hence the connection between them. Both the view and controller have references to the model. This is of course the nature of the MVC pattern itself. In this case, the model represents module-dependent information, specifically conformance check information.\n\nThe controller utilizes several other components for the purpose of handling the user-view interaction. The first component is the ApiConnector. As the name suggests, the component is responsible for communication with the logic tier, specifically the REST API. The connector needs to know the web address of the machine where the REST API is provided, or its Uniform Resource Locator (URL). Also, it needs to know the endpoints or the specific services that the API is offering in order to request them.\n\nAnother component that the controller is utilizing is the Visualizer. This component is responsible for visualizing the information, and providing the visualizations back to the view. The last component for the controller is the Translator. As the name suggests, the component is responsible for translating the view’s information into a specified language. Since the product is to be used by doctors and patients, understandability is extended to provide the end user with means to choose the preferred language for the product.\nChapter 9 elaborates on the concrete technologies and frameworks used to implement this design.\n\n### 8.3.4. Presentation tier behavior\n\nThe behavior of the presentation tier is represented with the request part of the request-response sequence, and the later response handling.\n\n*Figure 29* represents the sequence of actions in the presentation tier. The sequence starts with the user initiating an action on the view. The view reacts to this by invoking an appropriate action/event handler in the controller. In this case, and almost all the others, the controller needs data from the service. For this purpose, the controller asks the API connector to make the request for him. Additionally, the controller provides a reference to a callback function that should be invoked when a response arrives. When the control is transferred to the connector, an appropriate API endpoint is selected, which maps to the service requested initially by the user. The connector uses a component which dispatches requests to the API and waits for the response. As soon as the response arrives, the callback method is invoked, and control is transferred back to the controller. The controller performs the necessary actions, for example, updates the model. After that, the controller updates the view, and the end user can see the result of his action.\n\nThe response from the server is not immediate. Due to the client-server communication over the Internet, a delay is introduced which can vary depending on the request and its processing. This is depicted by the separate sequence of actions in the lower part of the diagram. The gap between sending the request and receiving the response is discussed in the section 8.4.\nThe process view is concerned with aspects regarding non-functional requirements, such as performance and availability. It mainly focuses on the runtime behavior of the system. Typically, the process view is explained through the use of activity diagrams.\n\nFigure 30 depicts the process view of the system, showing a request-response sequence. The delay mentioned in the previous section is due to the processing that has to be done on the server side. Since the client does not wait for the response, there is a delay until the server side finishes the processing and send the response to the client.\n8.5 Development view\n\nThe development view focuses on the actual module organization within the software development environment. This organization is expressed through packages or libraries organized in a way that they provide interfaces between them.\n\nFigure 31 depicts the development view of the logic tier. The organization of the view is layered, so that each layer communicates with the layers next to it. The API is on the top of the diagram composed of two sub-packages, one for the controllers and one for the services.\n\nThe layer below the API package is represented by the core package. As the name suggests, it includes the core of the system, meaning the interfaces and key aspects of the design. The package consists of three sub-packages, namely Domain, Interfaces, and Data Access. The domain package contains the model regarding the epilepsy domain. The interfaces package defines the services provided to the API layer, as well as infrastructure elements, such as service factories and providers. The data access package contains the interface definition for accessing the data tier.\n\nThe last layer is the coreImpl package. The name stands for core implementation. This package contains the implementations of the interfaces defined in the core package, more specifically, the data access and concrete service implementation.\nThis organization allows concrete implementations to be replaced and even complete packages, which makes it easily maintainable.\n\nThe development view of the presentation tier is much simpler than the one of the logic tier. Figure 32 depicts this view. The tier is split into three distinct packages: Views which contains the user interface specifics; Controllers, which contains user interaction handling; and Factories, which contains utility components, such as connecting to the logic tier, visualizing data, and translating the interface.\n\n8.6 Deployment view\n\nThe deployment view concerns the structure of the product after implementation regarding software to hardware mappings and distribution aspects. Given that the very core of the system is client-server communication, client being the end user browser and server being a machine that will host the service, a straightforward approach is followed when designing the deployment view of the system.\n\nFigure 33 depicts the designed deployment view of the system. The client, which is the web application executing on the end user’s personal computer, makes requests via HTTP to the REST API, which is running on a remote machine accessible via the World Wide Web. And last, the service is communicating with the database server, which hosts the database that contains all data.\n\nIn order to elaborate the specifics for the deployment view, implementation aspects of the systems need to be taken into consideration. These aspects influence the semantics used in the deployment view. For this reasons, the deployment view is revisited in Chapter 12.\nFigure 33 Deployment view of the entire system. A more comprehensive view is offered in the Deployment chapter.\n8.7 Data view\n\nThe goal of the data view is to describe the structure of the data entities and their relationships within the system. The data view is applicable only if the system needs data structures for its implementation. All the features of the system rely on input data, such as patients and their treatments, seizure and syndrome information, and side effects information; as well as output data, such as prescription check results, and conformance check results. Output data can also be entities from the input data. For example, a conformance check about a doctor contains information about the doctor in question.\n\n8.7.1. Input model\n\nThe following figure, Figure 34, represents the data model regarding information about patients necessary for the realization of the features described for the system under design. This model can be considered as the input model of the system under design. Another name is operational data.\n\nDue to the constraints imposed and risks identified on the project, explained in sections 5.2.1, 5.2.2, and 5.2.4, the initial design of the model presented in Chapter 4 is not used for the purposes of this project. The designed model follows the HL7 standard for expressing clinical knowledge. The design shown in Figure 34 resembles to the model designed using DCMs, but due to the restrictions on the variety of data, a simpler model is designed that fits the purposes of the project. Entities found in the domain model can also be found in this model, except that do not contain all the information defined in the DCMs.\n\nThe central entity of the model is Patient, and all other information is aggregated around it. A patient has information regarding his/her treatments combined with the dose changes that occurred, measurement of medication levels in the blood, reported seizures and side effects, and information about patient’s condition regarding types of seizures experienced and syndromes encountered. The treatment information is connected to specific medications and their active substances. Another entity that is of interest is the Doctor entity and its relationships towards treatments and measurements.\n\nEvery entity contains attributes that characterize it. For example, a treatment is characterized by the person it was assigned to, the start and end date of the treatment, the medication used, and the list of dose changes for that treatment.\nFigure 34 Data model regarding patient-related information\n8.7.2. Syndrome and seizure mapping\n\nFigure 34 reveals two other entities in the model, namely SyndromeMapping and SeizureMapping. The role of these entities is to provide a uniform way of representing seizures and syndromes, through the use of the latest classification (and the one used in the guidelines). The reason why these entities are designed is to deal with the different classifications used for distinguishing epilepsy syndromes and seizure types (see Appendix B: Classification of epilepsy syndromes and seizure types). Since the provided dataset contains syndrome and seizure information from different classifications (ILAE, both old and new, and Luders [21]) and the guidelines follow the latest ILAE classification, mapping is necessary to achieve the desired goals.\n\nThe SeizureMapping entity provides translation from the different classifications used to the latest ILAE classification. Additionally, treatment for certain seizure types is identical with certain other seizures, thus besides the mapping, an option to specify which actual seizure type to use is allowed.\n\nThe SyndromeMapping entity offers similar functionality as the SeizureMapping entity. It maps different syndrome classification, but instead to syndrome classified with the latest ILAE classification, it maps them to seizure types. The reason behind this is the more comprehensive information about seizure types in the guidelines instead of syndromes.\n\nThe mapping data is not part of the dataset, but it is created in close collaboration with doctors from Kempenhaeghe. Refer to Appendix E: Syndrome and seizure mapping for a complete view of the mapping between seizure types and syndromes.\n\n8.7.3. Output model\n\nAll this information is used to support the features provided by the system under design. Based on this information and the business logic defined behind the features, the system under design outputs certain information that is used in the presentation tier and shown to the end user. This output model is depicted in Figure 35.\n\nSome segments of the model are reused from the model designed in the “Domain Analysis” chapter, specifically information related to epilepsy guidelines. This information is both basis for the logic behind the features, and output information to be shown to the end user. Other information includes conformance results consisting of general results, and population subdivision results based on the information stored for the patients. In this case, the population is subdivided by age, gender, and intellectual level. This is represented with the entities ConformanceResult and ConformanceStatistics.\n\nOne of the requirements defined for the system under design is that conformance comparison between a doctor and an organization is to be strictly within a time frame and approved by an administrator from the requested organization. The entity BenchmarkRequest is designed for this reason. It encapsulates the information needed to request, and approve or deny a request to view conformance data.\nFigure 35 Data model representing output information\nThe User and Role entities represent basic user information and support the entire system by providing context of the end user within the system. The role distinguishes users by introducing different roles, such as Doctor, Patient, Group Administrator, and Guidelines Administrator. Based on these roles, certain actions are allowed to be performed within the system. The matrix shown in the table below, shows the actions associated with each role.\n\nTable 13 Matrix of features and roles allowed to use a feature\n\n<table>\n<thead>\n<tr>\n<th>Feature</th>\n<th>Role</th>\n<th>Epilepsy guidelines</th>\n<th>Pre-pre-scription check</th>\n<th>Conformance check</th>\n<th>Advised care journey</th>\n<th>Submit benchmark request</th>\n<th>Control benchmark request</th>\n<th>Modify guidelines</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Doctor</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Group Administra-</td>\n<td>X</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>tor Guidelines Administrator</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Patient</td>\n<td>X</td>\n<td>X</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nKeep in mind that both Group Administrator and Guidelines Administrator are sub-roles of Doctor, meaning a Group Administrator is also a Doctor.\n\nAs mentioned, the model for the guidelines and their representation is the one presented in the domain analysis chapter. For more information, refer to section 4.7.3.\n\nThe AdvisedEvent entity is concerned with information regarding the Advised Care Journey feature of the system. The entity encapsulates event information about action that the patient should consider based on his/her history. These events include referral to epilepsy surgery, admittance to a specialized care center and other. For a complete overview refer to Appendix D: The epilepsy guidelines.\n\nThe last section of the output model refers to statistical information on medication usage. This is part of the conformance check feature, where besides the check, a comparison is offered on the prescription behavior of the doctor and the group, regarding first choice medication for an epilepsy syndrome.\n9. Implementation\n\nThe previous two chapters discussed the system architecture and design. This chapter elaborates on the realization of the design, specifically the technologies chosen for the development.\n\n9.1 Introduction\n\nAn implementation is provided as part of the project. The implementation is based on the architecture and design, elaborated in the corresponding chapters, and satisfies the functional requirements defined in the “System requirements” chapter. The implementation provided is in the form of a prototype, to demonstrate the feasibility of the project.\n\nFor the purpose of implementing the design, choices are made on which technologies to use. Due to the client-server nature of this system, several choices are made, one for each tier.\n\nWith the evolution of modern Web development, a number of new technologies and frameworks for development have emerged. Choosing a correct technology is both difficult and easy; difficult, because of the many options and their pros and cons, which some fit and some do not, for the purpose of the system under design; easy, because sometimes the choice of technology is dependent on other technologies used in the system under design. The choice can also be easy if the technology and framework one needs to use is the single one available or mature enough. For this project, some decisions are based on the requirements and some on the candidate’s personal preference.\n\n9.2 Presentation tier\n\nThe type of user application for this system was decided when the requirements were gathered for this project. The stakeholders explicitly requested a Web application. This means that one decision is already made. The non-functional requirements steered the decision of what type of Web application is to be chosen. The main non-functional requirement being usability, the decision has to maximize this requirement. The choice of the technology is partially decided in the design process, especially when defining the system architecture. Section 7.4.3 elaborates on this latest trend of modern Web development, where these SPAs maximize the user experience through a single page view instead of the entire page being sent back and forward, observed by page flickering in traditional Web applications.\n\nAs mentioned, the evolution towards modern Web introduced frameworks for developing SPAs. These all rely on standard Web development technologies, such as Hyper Text Markup Language\\(^5\\) (HTML), JavaScript\\(^6\\) and Cascading Style Sheets\\(^7\\) (CSS).\n\nThe selection of the framework for developing an SPA is based on the framework’s popularity, online support, and the personal preference of the candidate. For these reasons, AngularJS\\(^8\\) is selected as a framework for development of an SPA. AngularJS is an open-source web application framework developed by Google for developing SPAs. It provides a framework for development of client-side MVC and MVVM architectures.\n\n\\(^6\\) [http://www.w3schools.com/js/](http://www.w3schools.com/js/)\n\\(^7\\) [http://www.w3schools.com/css/css_intro.asp](http://www.w3schools.com/css/css_intro.asp)\n\\(^8\\) [https://angularjs.org/](https://angularjs.org/)\nThe idea behind SPAs is that when a user visits the web page through his/her browser, the application itself is downloaded in the user’s machine and it is executed in the browser. For this reason, initially, the web application needs to be hosted on a network server that will stream the application to the clients, when they request it. Chapter 12 discusses this matter.\n\nThe design of the user interface is also a crucial part of the project. As explained in the requirements chapter (Chapter 6), the web application should be accessible from everywhere via the web. This means that users can use devices, such as personal computers, laptops, tablets, or smartphones, to access it. In order to provide a consistent design, a specific approach is taken, namely responsive web design (see section 10.5). One of the most famous and often used framework for developing responsive sites is Bootstrap. Chapter 10 reflects in detail about the user interface design.\n\n9.2.1. Visualization\n\nVisualization is a big part of the project. Through the use of visualization techniques, data needs to be presented to the user with high understandability and ease of use. Since the application is web-based, the visualization technologies need to be web-based also. There are many visualization libraries that are web-based and are mainly written using the JavaScript language. For the purposes of this project, a number of visualization libraries are evaluated and several are chosen. The libraries chosen for this project are:\n\n- Highcharts\\(^9\\) - charting library written in pure JavaScript, offering an easy way of adding interactive charts to a web site or web application;\n- TimelineJS\\(^11\\) - open-source tool that enables building of visually, rich, interactive timelines;\n- FullCalendar\\(^12\\) - a jQuery\\(^13\\) plugin that provides a full-sized, event calendar.\n\nAnother framework for data visualization that is evaluated is D3\\(^14\\). This is one, and probably the most powerful data visualization frameworks intended for web standards. The reason for not selecting this tool is the specifics for its usage, meaning that the learning curve is much larger than the other tools, in the given time period.\n\n9.3 Logic tier\n\nThe logic tier is represented by a service that supports the Web application and the application logic modules. In order for the service to support different clients, REST style is followed in the architecture, and hence the service is a RESTful API. Again, there are multiple technologies and frameworks that support development of RESTful APIs. One requirement that needs to be supported by the technology chosen is the ability to connect to a database and manipulate data. The choice of the programming language is not difficult because almost all modern languages support it. Based on the candidate preference, Java is selected as a language for development of the API and the modules.\n\n9.4 Data tier\n\nDue to the risk explained in section 5.2.4 a decision had to be taken to implement and set up the data tier. Based on available technologies and platforms provided by stakeholders, a decision is made to use MySQL, a relational database management system, as the data platform and provider. MySQL is an open-source, free-to-use database management system, and it is widely used. This choice is a good fit until the NER is available.\n\n---\n\n\\(^9\\) http://getbootstrap.com/\n\\(^10\\) http://www.highcharts.com/\n\\(^11\\) http://timeline.knightlab.com/\n\\(^12\\) http://fullcalendar.io/\n\\(^13\\) https://jquery.com/\n\\(^14\\) http://d3js.org/\n10. User interface design\n\nIn the previous three chapters, the architecture, design, and implementation details are elaborated. This chapter elaborates on the design of the user interface and presents the visualizations executed as part of the project.\n\n10.1 Introduction\n\nSince the main focus of this project is utilization of visualization techniques to provide insights to the users, primarily doctors, a great amount of effort is spent in the design of the user interface and visualizations that are displayed to them. The requirement of creating a product that maximizes usability imposes additional challenges to the design.\n\nThe main driver behind the design process of the user interface is simplicity. Taking into account that the primary users of the product are healthcare professionals and patients, the assumption that the majority of users has little to none technical knowledge is valid. For this reason, simplicity in the design is key for a fast learning curve of the product and its attractiveness.\n\nOn the other hand, the design as such needs to be able to convey the information, and provide the feedback to the user as clearly as possible. Depending on the amount of information, it is not always easy to put everything in one screen. Even if it is possible, it does not mean that the user will understand it and extract meaningful information from it. Based on our cognitive abilities, we as humans, understand information better when it is depicted rather than written. Visualization of data helps us to grasp vast amount of data and extract information out of it.\n\nSuch is the case for this project. Due to the constantly increasing amount of data in the healthcare domain, visualization is often sought as a solution to battle this information overload. This chapter covers these issues by first addressing the web application design and later the visualizations executed. The design realized as part of this project is validated and verified continuously with the stakeholders. The next chapter (Chapter 11) discusses in details the process of validation and verification.\n\n10.2 Web application\n\nThe advances made in today’s modern Web are astonishing. Section 9.2 in the implementation chapter introduces the tools used to build today’s web sites and applications. The interfaces are richer and more intuitive to use, and lately they are becoming responsive. The responsive design of the application is discussed in section 10.5. Regarding the simplicity, several guidelines are followed in the design of the interface. The guidelines are as follows:\n\n- Interfaces should be self-explanatory;\n- Short descriptions should be provided for each feature in the form of a manual;\n- Users should be enabled to clearly identify what action they are executing;\n- The number of steps for completing an action or scenario must be minimized.\n\nThe rest of the section shows the interface designed by following the above-mentioned guidelines. A number of screen shots are presented that show the concrete design created for the project.\n\nFigure 36 shows the default page, or home page, of the application. This is what the user sees, when opening the web application from his browser. First thing to notice is the title of the project, with a link to its description. The bottom section shows the\nfeatures provided by the web application, combined with a short description and a link to enter and use the feature. In the top-right section of the figure, the possibility of changing the language of the application is provided, coupled with the ability to login to the application, either as a doctor or a patient.\n\n\n\n**Figure 36 Default page of the application (also referred to as home page)**\n\nThe design is simple and straightforward. The following sections focus on the design of each feature. The design of each feature is based on a template derived from the guidelines mentioned above, both for the interface and interaction. The template consists of two parts:\n\n- **Input** – Feature description and data input needed for the feature combined with commands to execute the action\n- **Output (Results)** – Display of the results. This part is different for every feature.\n\nFigure 37 shows the template for the design of the features. The input section differs in the type of data entered for every feature, but the template still holds. In the top part, the title of the feature is clearly presented, and immediately below it, a description of the feature followed by a short manual on how to use the interface are shown. The data input section is located below the description part. In this section the user enters feature-specific data in order to execute the functionality provided by the feature. Depending on the user logged in to the system, the data that is entered includes doctor, patient, medication, or dates. Utilizing rich user controls offered by HTML and JavaScript, the data input is facilitated through specific controls, such as drop-down lists, calendars for date selection, or text auto completion for searching in a big list. Below the data input controls, a set of actions are placed via buttons for the user to press. They initiate the actions offered by the feature.\nWhen the user issues an action, a processing occurs, and the view changes. The input section is hidden, and the output section is shown. The design of the output section is shown in Figure 38. The majority of the features follow this design, but it mainly depends on the results that are displayed. The top part of the output section gives a summary of the input provided in the input section, coupled with actions (via buttons) that the user can perform. The bottom section is where the results of the feature are presented. Due to the amount of information that is usually needed for each feature, this section is split into subsections or tabs. The number of subsections may vary for each feature (typically, three subsections).\n\nThe following figures (Figure 39 and Figure 40) show concrete examples, or instantiations, of the template used for the design of the interface. The feature chosen for the concrete example is Prescription check. In the input section of Figure 39 the user has to select a patient, a medication (or substance), and optionally, a concrete brand of the medication. The button Check this prescription invokes the processing and results are displayed, as shown in Figure 40.\n10.3 User interaction\n\nAs mentioned in the guidelines for designing the interface, the design focuses on minimizing the number of actions a user must perform in order to get the results. In the previous section, some of these actions are explained. In general, a total of three steps are required to perform an action or utilize a feature:\n• Input data – user inputs data needed for the feature;\n• Invoke action – user invokes the action provided by the feature;\n• Explore results – user explores the results obtained by the action invocation.\n\n10.4 Visualization\nA number of visualization techniques are applied in order to interpret and present data to the user. The visualizations provide insight and decision support to the main three features of the product, namely Conformance check, Prescription check, and Patient care journey. Depending on the data that is visualized, the techniques range from elementary, such as tables with no interaction, to advanced, such as a timeline with multiple different datasets. The choice for elementary or simple visualizations is driven by the fact that this type of techniques suits best for small datasets where there is not much information to extract.\n\nThe techniques chosen for data visualization are validated and verified with the stakeholders with an iterative approach. This is explained in Chapter 11. The following sections discuss the visualizations applied to each of the three features.\n\n10.4.1. Conformance check\nThe main goal of the feature is to calculate to what extent doctors are conforming to the epilepsy guidelines by inspecting their prescription dataset. Additionally, this calculation extends to subsets of data based on patient’s attributes, such as age, gender, and intellectual level. The output of the feature is primarily a percentage, showing how much a doctor is conforming to the guidelines. Added to that, conformance values of the subsets is provided.\n\nAn extension to the feature is comparison between the conformance value of the doctor and another organization. The idea is to provide enough data for the user to be able to extract meaningful information.\n\nFigure 41 shows a conformance result of a comparison between a doctor and an organization. In the top section, the overall conformance value is presented, for both the doctor and the organization. The bottom section consists of several subsections, each one presenting different aspects. In Figure 41 the second subsection is shown which uses a table to plot the results. The table is split into sections equivalent to the population subdivision. Each section of the table contains two or more categories, and for each of them, a conformance value is presented. To emphasize and easily interpret this value, color coding is used. Depending on the value, a different background color is used for the table cell where the value is displayed.\n\nWhen it comes to choosing which color palette to use, a decision towards something that is familiar to everyone has to be made. We as humans, have become accustomed to relate certain colors to certain situations. For example, red color means danger, yellow means warning, and green means ok or good. Hence, the color palette is based on these conventions. Figure 42 shows the colors used for coding the conformance value.\n\nThe goal of using a color palette is not to judge the doctors’ decisions, it simply relates to how close a doctor is conforming to the guidelines. As mentioned multiple times in this report, the choice of the medication is not based simply on what the guidelines suggest, it is mostly influenced by the condition of the patient.\nFigure 41 Visualization of the conformance results. The top section gives the overall results and the table lists the population subdivision. Color coding of the conformance value is used to emphasize the level of conformance.\n\nFigure 42 Color palette for the conformance value\n\n10.4.2. Prescription check\n\nThis feature provides the user with a tool to check a prescription before it is issued. Prescription issuing is not a part of this system. The check includes: checking a prescription for conformance to the guidelines, and checking whether there are reported side effects to the medication selected in the prescription. Additionally, the feature provides alternatives to the selected medication, based on the guidelines. In order to further facilitate the decision process, the feature is extended with the possibility to explore patient history regarding events, such as prescribed medications, seizures reported, and medication levels measured in the blood. This is where visualization techniques are applied.\n\nAs with the other features, the output is split into several sections, one for the check, one for the alternatives, and one for exploring patient’s history. The remaining of this section focuses on the exploration of a patient’s history, as the most interesting part and it is where visualization is applied. Figure 43 shows the visualization of the patient history.\nFigure 43 Visualization of the patient's history\nThe entire visualization is one big timeline representing different types of events. It is split into four different sections (top to bottom):\n\n- Medication dosages – information about prescribed medication and their corresponding dose changes over the years;\n- Blood level measurements – measurements on the medication level in patient’s blood;\n- Seizure frequency – frequency of seizures grouped by month;\n- Navigator – exploration of the timeline, zooming and panning.\n\nThe horizontal axis represents time, and the vertical axis is different for each section. This type of visualization allows for exploring different kinds of data with respect to time. The four sections are vertically aligned to match the time axis. Below the four sections there is a legend that color-codes the different medications used in the selected patient.\n\nThe first section visualizes the medications prescribed represented by their respective dose changes over time. Due to different stakeholders’ opinions on the expression of the dosage levels, a configuration is added that lets the user choose what kind of technique to use to visualize this information. Two different representations of dosage levels are offered: total, meaning the exact amount of medication prescribed (usually in milligrams), and normalized by the Defined Daily Dose (DDD) of the medication. The DDD is the assumed average maintenance dose per day for a drug used for its main indication in adults [22]. This normalization exists in order to compare prescribed dosages, where one medication may be prescribed in the range of thousands and other in the range of tens of milligrams. By normalizing the values, the user can see if the dosage prescribed is low or high, based on the medication’s DDD. The formula for normalizing the medication is simply dividing the actual prescribed dosage by the DDD of the medication.\n\nBesides the dosage level configurations, stakeholders requested a configurable view of the dosage levels over time. Based on this, two techniques are offered: stacked area charts (as the one shown in Figure 43), and individual line charts. A line chart is a type of chart that displays information on a 2-dimensional system in the form of markers or data points that are connected with straight lines. The area chart is based on the line chart with the difference that the area below the line connecting two markers is typically painted, as an area. Stacked area charts are based on area charts, and as the name suggests, a data series is stacked on top of the previous one. Figure 44 explains the difference between the two visualization techniques, line charts and stacked area charts. The same dataset is visualized using the two techniques.\n\n\n\nBy using a stacked area chart a user can observe the total amount of medication that was prescribed in a particular instance of time. As shown in Figure 43, a small window is shown if the user hovers the mouse anywhere in the chart. This window shows the concrete brands of the medications prescribed and their respective dose at that point in time.\nThe second section visualizes the medication levels in the blood. These levels are simple data points or markers on the timeline that provide information on the tests performed on the patient to measure the medication level in the blood. Figure 45 shows the information window that is displayed when the user hovers with the mouse over one of the markers. The total level is defined by summing the individual tests performed for a medication at that point in time.\n\n\n\nThe third section visualizes the seizure information and aims to provide feedback on the frequency of seizures based on the medications prescribed. The yellow block in the seizure graph represents that no seizures are recorded or there is no information about it in the data set. That does not mean that there were no seizures in that period. The seizure information is presented in the form of a column chart, where the height of the column is determined by the number of seizures the patient has had in that month.\n\nThe last section of the visualization is the navigator. This is part of the tool used to visualize the data and it facilitates in navigation in the timeline. The user can zoom in and out, and pan through the timeline. The line represented within the navigator represents the total dosage of all medication. This gives the user perspective when the view is zoomed in to explore what is before or after the current view, and keep in mind the overall picture.\n\nLooking at the whole picture, this visualization allows the user to explore the patient history from different perspectives to support decisions.\n\n### 10.4.3. Patient care journey\n\nThe initial idea behind this feature was to compare the patient’s actual care journey versus the advised one. Since the information in the advised care journey is not complete (see section 5.2.3), a decision was made to use only the ones that can be made operational (in this case, only one).\n\nThe guideline states that if a patient still experiences seizures after trying two or three antiepileptic medications, then the patient should be referred to evaluation for epilepsy surgery (see Appendix D: The epilepsy guidelines for the complete list of guidelines for the advised care journey). After consultation of the stakeholders, the application of the other guidelines was planned as future work when the guidelines are more mature.\n\nWith this in mind, this feature aims to create a story based on the events that transpired for a patient. Creating a story indirectly implies a form of a timeline. For this feature, two visualizations of the patient journey are offered, a timeline and a calendar. The timeline lets users jump backwards and forwards in the patient history, and the calendar is pretty self-descriptive. Both visualizations plot the same data, just in a different way.\n\nFigure 46 shows the timeline visualization for exploring the patient’s events, such as treatments, and reported seizures. The visualization is in a form of a slide show. Users can navigate back and forth through the events (by clicking on the arrows on the side of the top part), and the central section displays information about the event. The bottom part is the timeline, where all the events are plotted and represented by markers in the form of a label spanning from the start to the end of the event. The user can zoom\n\nin and out, and pan through the timeline. This visualization creates a story for the user, by providing a path of what the patient has been through during his epilepsy treatment.\n\nFigure 46 Timeline for exploring the patient care journey\n\nThe other type of visualization, the calendar, is simply a tool for the user to explore the events in a well-known manner. A calendar is something that everyone uses and is familiar with. For this reason, this simple visualization was chosen. Figure 47 shows the visualization.\n\nFigure 47 Calendar for exploring the patient care journey\n\nPatient events are plotted on the calendar the same as the ones for the timeline. At the top part, a familiar set of controls are offered. These controls provide navigation\nthroughout the calendar. Additionally, the view of the calendar can be changed from the default month view to a week or day view. The user can get current medication information by selecting any date in the calendar (top section, left of the calendar), or information about a certain event when it is selected (bottom section, left of the calendar).\n\nThe use of a calendar facilitates the user with exploring a patient history in a familiar way and extracting information, such as how many seizures a patient has had, what is the time between seizures, do they occur right after a medication is prescribed or a specific dose is reached, and do the seizures stop after a medication is prescribed.\n\n10.5 Responsive design\n\nResponsive web design is a web design approach that aims to provide optimal viewing and interaction experience across a wide range of devices [23]. Hence the web application is accessible from everywhere, the design has to be such that the experience and interaction is natural based on the device used. Users today browse the Internet through their devices, such as personal computer, laptop, tablet, or smartphone, and these devices differ from each other in their screen size. Since the user accesses the site via a browser, an interface should adjust itself based on the right size that it will be shown, so the users have a smooth experience on the site.\n\nA site developed using responsive web design principles adapts to the user’s needs and device capabilities. It does not mean simply rescaling to fit the content on the screen size, it also involves decisions about what will be shown first to the user, which may lead to different presentations and layout of the information [24].\n\nSuch an approach is taken for the design of the web application, as part of the deliverables of the project. As explained in section 9.2, a framework is used to facilitate a responsive application, namely Bootstrap. Bootstrap is a collection of tools and templates for developing mobile first user interfaces. It adopts the responsive web design principles, allowing adjustable interfaces based on the screen size. The use of this framework allowed the web application to follow the responsive design principles. Figure 48 shows the interface when viewed from a mobile device (smartphone).\n\n\n\n*Figure 48 Adaptation of the interface based on the screen it is viewed on. The figure depicts the web site viewed from a smartphone*\n11. Verification & Validation\n\nThe previous chapters explain the design and development of the project. In order to confirm that the right product is being built, verification and validation techniques need to be applied. This chapter discusses these techniques and explains the process of verification and validation.\n\n11.1 Validation\n\nValidation of a software product is the process of checking whether the product built satisfies the stakeholder’s requirements. As explained in Chapter 6, the goal of the project is to create a set of tools, for both healthcare professionals and patients, which will provide decision support and insight for improving epilepsy care.\n\nTwo aspects need to be taken into consideration in the validation process. First, does the product built satisfy the functional requirements; does it do what it says in the functional requirements? Second, does the product satisfy the non-functional requirements? For the functional requirement, the validation should address whether the product offers the features defined. As for the non-functional requirements, the main one being usability, the validation should address the user interface design and how easy it is to learn and use the product.\n\nFollowing an iterative development approach (see chapter 14), the results were continuously validated by the stakeholders. At least once per month, a meeting was scheduled that included a progress report and a demo of the current version of the product. During the demo, feedback was provided on the completeness and correctness of the product under development.\n\nIn order to formalize the validation process, a survey is created and dispatched to a group of users (doctors) for assessment. This assessment includes providing the users with access to the web application and letting them use it for a while. After that certain questions need to be filled out in the survey that address the functionality and usefulness of the product.\n\n11.1.1. Survey\n\nThe table below shows the survey created for validation purposes of the product. The questions address the user interface and functionality. Users can answer each question with an answer scaling from:\n\n- 1 (bad) – Feature is not easy to use or don’t understand it / User interface is bad;\n- 2 (not good) – Feature takes time to learn, can be made more intuitive / User interface is a bit difficult to use\n- 3 (good) – Feature is fairly easy to use / User interface is easy enough to use\n- 4 (very good) – Feature is very easy to use / User interface is easy to use\n- 5 (excellent) – Feature exceeds expectations / User interface is very easy and intuitive\n\nThe time required for completing the survey is less than 5 minutes after spending about 30 minutes on the application. The survey and the results are shown in Table 14. The dots that mark the answers represent an average grade from all the answers collected from the survey.\n### Table 14 Survey to validate the application\n\n<table>\n<thead>\n<tr>\n<th>Question (mark the answer with an X)</th>\n<th>1 (bad)</th>\n<th>2 (not good)</th>\n<th>3 (good)</th>\n<th>4 (very good)</th>\n<th>5 (excellent)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Feature 1 (Conformance check)</strong></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>How easy it is to use this feature?</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Does the feature performs as is</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>How clear are the results displayed?</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Did the results provide you with</td>\n<td></td>\n<td></td>\n<td></td>\n<td>●</td>\n<td></td>\n</tr>\n<tr>\n<td>meaningful information?</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Feature 2 (Prescription check)</strong></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>How easy it is to use this feature?</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Does the feature performs as is</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>How clear are the results displayed?</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Did the results provide you with</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>meaningful information?</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Feature 3 (Patient care journey)</strong></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>How easy it is to use this feature?</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Does the feature performs as is</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>How clear are the results displayed?</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Did the results provide you with</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>meaningful information?</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>General</strong></td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>How easy it is to learn the applica-</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>tion?</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>How did you like the overall de-</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>sign of the application?</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>How helpful is the application in</td>\n<td></td>\n<td>●</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>your daily work?</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nThe results show that the features satisfy the stakeholders’ needs to a certain level, but there is still room for improvement. The average grade shows the difference of opinions and needs of each user, where some features are graded better than others. These improvements are laid out in Chapter 13, “Conclusions,” in section 13.2.\n\n### 11.2 Verification\n\nVerification of a software product is the process of evaluating whether the system is engineered properly. This means that verification should check how well the product is developed, tested, and documented. To ensure the quality of the product, verification is performed by software testing and code quality measurements.\n\nSince the product is split into two parts, namely web application and web service, different testing is applied to them. In the web application, the user interface needs to be tested, as well as the code, and in the web service besides the code, the API needs to be tested.\n11.2.1. Testing the user interface\nManual testing is conducted on the user interface. This revealed several bugs that were fixed, and identified some missing features. Some of them were implemented, some of them are left as future work (see section 13.2). A set of testing tools exist that can automate the testing of the user interface. The tools range from using languages such as JavaScript to write tests, to browser application or plugins that record the user actions on the screen and create tests from them to be executed later. Such tools include PhantomJS\\textsuperscript{16}, Selenium\\textsuperscript{17}, and Watir\\textsuperscript{18}. Due to lack of time, they were not used. Automated user interface testing is also listed as future work (see section 13.2).\n\n11.2.2. Unit testing\nDue to time constraints, unit testing is not performed on the system developed. This is identified as a future work for the project (see section 13.2).\n\n\\textsuperscript{16} \\texttt{http://phantomjs.org/}\n\\textsuperscript{17} \\texttt{http://www.seleniumhq.org/}\n\\textsuperscript{18} \\texttt{http://watir.com/}\n12. Deployment\n\nBased on the architecture and design of the system, a prototype is implemented that satisfies the stakeholders’ requirements. This chapter elaborates on the specifics of the deployment considering the implementation choices regarding technologies and programming languages.\n\n12.1 Deployment view\n\nBased on the decisions for client and server implementation (described in Chapter 9), the development view defined in the “4+1” model is revisited to take these choices into consideration and provide a clearer picture of the entire system. Figure 49 depicts the revisited deployment view of the system.\n\nSince the web application is executed on the end user’s personal computer it first needs to be provided or delivered to him/her. The easiest way to do this is through content delivery networks. Content Delivery Network (CDN) is a distributed system of servers with a sole purpose of providing content to end users with high availability and high performance. The use of CDN increases the availability of the application by distributing the load to multiple servers, instead of using a single server that hosts the application and all the end users accessing it to retrieve the application.\n\nThe application server that hosts the RESTful API is connected to the Internet and is publicly visible. The web application sends HTTP requests and the application server responds with HTTP response. In order to run the API and the services behind it, an environment that hosts a Java Virtual Machine is required.\n\nLast, a database server that hosts the database is required for the deployment of the system. A management service is needed to handle connections to the database as well as management of the database itself. The JDBC acronym stands for Java Database Connector.\nFigure 49 Deployment view revisited. Concrete implementation specifics are taken into consideration.\nA single-machine solution is also possible, meaning, this single machine will distribute the web application on request, will host the RESTful API and the database itself. This, of course, breaks the maintainability and scalability of the entire system. First of all, changing the any part may result in stopping the complete system, whereas the first solution requires only a redirection to a backup or a secondary machine. Also, upgrading the hardware on the machine will most probably initiate a long setup process of the entire system. Changing the database, however, requires even more attention since this is the source of information. Still, there are mitigation techniques, such as database replication. Figure 50 depicts the single-machine solution.\n\nFigure 50 Single-machine solution. Everything is hosted on a single network server (not recommended)\n13. Conclusions\n\nThis chapter elaborates the results achieved by this project and the added value to the stakeholders. It also discusses future work related to the project.\n\n13.1 Results\n\nEpilepsy is not a curable disease, and the treatment for it is long and often difficult for the patient. Improving patient’s care is of great importance to Kempenhaeghe. Improving care involves trying new approaches, as well as looking back and learning from the past. That was the main focus of this project, to utilize existing information to produce insights that will guide caregivers in making better future decisions.\n\nUtilizing past data to produce new insights involves analysis and interpretation. The requirements defined for the project included the analysis that had to be done in order to produce feedback. The main challenge was how to convey this feedback to the end users. By applying data visualization techniques, data can be made easy to read and effective to use. By visualizing data, one can identify patterns or grasp an enormous amount of data by simply looking at a visual representation of it. In healthcare, this is important, because often time is of the essence. Choosing the correct visualization technique is a difficult process, since preferences and needs of users are different. Some are prone to simpler views than others. This was a challenge during the project, and the reason behind it is that end users are often non-technical people with some to very little knowledge in data visualization. Conveying the proper message through data creates challenges that were addressed throughout this project.\n\nThe end result is a decision support tool for the doctors. All this is achieved with simple and easy to use design of the user interface. The visualization techniques chosen offer clear data representation, are easy to understand and use, and are configurable based on user preferences. Chapter 10, “User interface design” presents the results and visualizations executed for the project.\n\nFrom the software architecture point of view, the designed system exhibits properties, such as modularity, maintainability, and scalability, which makes it easily extendible and usable by other systems.\n\n13.2 Future work\n\nThis section discusses future possibilities or extensions for the product that were identified along the way as well as work that was not performed due to various constraints, such as time, or unavailability of knowledge, data, and technology (see section 5.2).\n\nThe possible extensions are as follows:\n\ni. Currently, the list of medications used throughout the project is an internal list by Kempenhaeghe. This can be improved by retrieving a list of medications from the Royal Dutch Association for the Advancement of Pharmacy (in Dutch, Koninklijke Nederlandse Maatschappij ter bevordering der Pharmacie or KNMP). They provide a service to retrieve full information regarding a specific medicine and their database is regularly updated.\n\nii. A lot of information about seizures is stored in the form of free text in the doctors’ personal notes. This information can be processed using natural language processing techniques to complement the data about seizures. By doing this, data will be enriched and more accurate.\niii. As mentioned several times, the advised care journey guidelines are not at a mature level. This means that not all guidelines can be formalized and made operational, which caused a partial implementation of this feature. Further improvement of the guidelines is a future extension of the product. In addition, appropriate data need to be provided for this to work, just like the current project has strongly benefit from the historical dataset on medicine prescriptions that was available.\n\niv. In discussion with the stakeholders from Kempenhaeghe, it was revealed that some of the prescribed medications for the patients were actually ongoing medications that the admitting doctors logged in the system under their name, just to have information on what the patient is administering. With the provided dataset, there was no possibility to distinguish which medications are prescribed by them, and which were ongoing medications. This influences the conformance check feature, where these ongoing medications were part of the doctors’ prescriptions. Clearly, a richer dataset would eliminate this.\n\nv. The model used to represent the domain knowledge was built partially using Detailed Clinical Models. A possible extension is to finish the model when the remaining DCMs are available and use this model as a data model. This way, the system will comply with HL7 standards.\n\nvi. As soon as the NER is completed and started up, the prototype needs to be revised and adjusted so that eventually it can connect to the NER and use live patient data.\n\nvii. Currently, the user management part of the prototype is developed pretty straightforward, in order to present the functionalities offered to different types of users. An extension would be to design and develop an extensive user management and authentication module that will control every action and aspect of the application. This is essential, since the site will be available from everywhere and data privacy and sharing is becoming a pressing issue.\n\nviii. Due to time constraints, manual testing was conducted on the developed software. As a future work, proper unit testing has to be conducted using test frameworks for every aspect of the system, especially the API.\n\nix. The information in the guidelines is somewhat contradictory when it comes to advising medications for seizure types and syndromes. A patient may be diagnosed with a specific syndrome, and experience different seizure types. There are cases when a medication is forbidden for a seizure type, but it is advised as a first choice medication in the guidelines for a syndrome. This is not taken into consideration in the prescription and conformance check, since a mapping was created to align the different classifications used in the data from Kempenhaeghe. The system can be extended to take this into consideration and provide a more complete feedback to the user.\n14. Project Management\n\nThis chapter elaborates on the management conducted throughout the project’s lifetime.\n\n14.1 Introduction\n\nThe management of the project was conducted under the agile methodology\\(^\\text{19}\\) by using the Scrum approach. The agile methodology suggests iterative and incremental development through so called sprints. Sprint is a short time span of usually two weeks, where a deliverable needs to be produced. This methodology is applicable in different domains, but it was initially forged for software development as an alternative to the traditional waterfall approach.\n\nThe project consisted of two parts. The first part of the project focused on epilepsy domain study and analysis, model definitions, and formalization of the epilepsy guidelines. The second part of the project focused on design and implementation based on the outcomes of the first part.\n\nThe following sections dive into the details of the project, such as the work-breakdown structure, project plan and execution.\n\n14.2 Work-Breakdown Structure (WBS)\n\nThe work-breakdown structure for the project is presented in Figure 51. Two top-level packages are identified to match the two parts discussed earlier. Each package is further decomposed to smaller packages. These packages are later on referenced in the project plan and execution section.\n\n\n\n\\(^{19}\\) [http://agilemethodology.org/](http://agilemethodology.org/)\nThe Epilepsy domain analysis part consists of three packages:\n- **Domain study** – research and study about epilepsy and treatment;\n- **HL7** – research and study about the standard including DCMs, and building an epilepsy model using DCMs;\n- **Epilepsy guidelines** – research and analysis on the epilepsy guidelines followed by a formalization and concise presentation.\n\nThe Design and implementation part consists of two packages, each with its own set of sub-packages. It includes:\n- **Database** – setting up the data source for the product\n - **Data import** – importing historical data in the database;\n- **Application** – design and implementation of a client-server application. The sub-packages defined under the Application package represent separate work packages for each feature. They include design and implementation of both client and server side software.\n\n### 14.3 Project Planning\n\nBased on the breakdown structure defined in the previous section, a project plan was formulated accordingly. As expected, the initial project planning devised in the beginning did not match the actual project execution due to the incremental approach. Several adjustments were introduced along the way, as the knowledge and understanding deepened. The next two sections show the initial and final version of the project plan.\n\n#### 14.3.1. Initial\n\nThe initial version of the planning involved four major parts: the epilepsy domain analysis, for which the first three months were reserved; the design and implementation, for which five months were reserved; and preparation for the final presentation, one month. The reporting on the project is considered an ongoing task for the entire lifespan of the project. Table 15 shows a Gantt chart for the initial planning for the project.\n\n*Table 15 Initial project planning*\n14.3.2. Final\n\nAfter the first two months, several adjustments were introduced. The adjustments were reflection on the understanding of the project and refinement of the stakeholders’ requirements. New tasks were added, several modified or deleted. Table 16 shows a Gantt chart of the final project planning.\n\nTable 16 Final project planning\n\nSince the technology for the selected database platform was not available in due time, a mitigation strategy was introduced in order to keep the project going. This strategy included transition to a more familiar and mature database platform. The negative side of the strategy was that the database design was not following the HL7 standards for representing clinical knowledge.\n\nThe long running tasks are the overlaps that can be observed in the charts mean that time was spent on both tasks during a day’s work.\n\n14.4 Project execution\n\nThe execution of the project followed a structured path based on the project planning. The first month comprised of meeting stakeholders and reading literature about the domain. It also included getting to know the high-level requirements of the stakeholders.\n\nFollowing the agile approach of iterative software development, every month a Project Steering Group (PSG) meeting was held where the progress of the project was presented by the candidate and the direction of the project was maintained. During these meetings, the candidate presented the current status as well as demonstration of the product. The stakeholders gave feedback and to some extent validation of the product. If necessary, additional meetings were scheduled by the candidate to obtain additional information regarding visualization or epilepsy-related knowledge. For each meeting,\nnotes were taken by the candidate (meeting minutes), which were later put in a document and set to the stakeholders for review and comment.\n\nBy following the project plan, stakeholders could transparently observe how the project is progressing, and if the deliverables satisfy their requirements. Since the product includes several features, an ordered approach was followed in their development, one at a time.\n\nAs mentioned in section 5.2, a number of risks were identified throughout the project which caused slight changes in the direction of development. These changes were clearly presented to the stakeholders coupled with a proposed mitigation strategy from the candidate. Some of these risks are mentioned as future work for the product.\n15. Project Retrospective\n\nThis chapter gives a reflection on the project based on the candidate’s perspective. At the end, the design opportunities set in the beginning of the project are revisited and evaluated.\n\n15.1 Reflection\n\nThe project conducted in the past nine months exhibited both familiar and unfamiliar, yet challenging, characteristics. On the familiar side, there was already sufficient knowledge in web technologies and web development, as well as knowledge in data visualization. The challenging parts include working with doctors, getting to know the domain, and translating their requirements into tangible results.\n\nAs with every project, a sufficient level of understanding of the domain is required to be able to translate requirements into a result. Having a slight medical background, made the process a bit easy, but the complexity of the domain has its own weight. Luckily, the stakeholders from Kempenhaeghe were more than helpful and provided needed information and feedback whenever it was requested. This is important because it gives a two-way feedback, for the candidate to understand them, and for them to understand whether the candidate understands the domain.\n\nOne of the biggest concerns of the project was the formalization of the guidelines, and their applicability in a system. Significant time was spent on this, especially in the first three months. An additional overhead was that the guidelines were written in Dutch. Using translation tools and the candidate’s beginner knowledge in the Dutch language a translation was made, followed by a formalization with a model. In the beginning, this language barrier introduced a minor problem, but the continuous effort and the use of tools mitigated this problem. This of course was constantly evaluated by stakeholders from Kempenhaeghe for preciseness and completeness.\n\nHaving to work with Detailed Clinical Models proved to be not that difficult except the notation used to express the models. This was different than the typical use of UML, so it took a little time to get a grasp on it.\n\nOverall, the project was a great experience and a change to exercise many skills related to software development. Cooperating with people and managing expectations is crucial and this was repeatedly exercised along the project. On top of that, several new technologies were used that broadened the knowledge and opened new horizons for the future.\n\n15.2 Design opportunities revisited\n\nDuring the problem analysis process, a single design opportunity was identified, namely usability. Since the goal of the project was to make a tool for end users, such as doctors and patient, and the tool had to make use of visualization techniques, special consideration was taken to ensure that usability is maximized. Following the iterative development approach and receiving constant feedback, stakeholders were able to evaluate the usability, look, and feel of the product. Formally, the use of a survey provided a feedback from a larger group of users.\n## Glossary\n\nThis chapter presents the terminologies used throughout this report. Table 17 lists the terminologies with their definition.\n\n**Table 17 Glossary**\n\n<table>\n<thead>\n<tr>\n<th>Term</th>\n<th>Definition</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>PDEng</td>\n<td>Professional Doctorate in Engineering</td>\n</tr>\n<tr>\n<td>NER</td>\n<td>National Epilepsy Register. Database for centralizing knowledge about epilepsy</td>\n</tr>\n<tr>\n<td>TU/e</td>\n<td>Eindhoven University of Technology</td>\n</tr>\n<tr>\n<td>HL7</td>\n<td>Health Level Seven</td>\n</tr>\n<tr>\n<td>ANSI</td>\n<td>American National Standards Institute</td>\n</tr>\n<tr>\n<td>ADR</td>\n<td>Adverse Drug Reaction</td>\n</tr>\n<tr>\n<td>NICE</td>\n<td>National Institute for Health and Clinical Excellence</td>\n</tr>\n<tr>\n<td>Cloud</td>\n<td>General term for anything that involves delivering hosted services over the Internet</td>\n</tr>\n<tr>\n<td>Server</td>\n<td>A computing platform whose purpose is to serve other computing platforms</td>\n</tr>\n<tr>\n<td>Web server</td>\n<td>Same as server, available over the Internet</td>\n</tr>\n<tr>\n<td>Database server</td>\n<td>Same as server, used to host a database</td>\n</tr>\n<tr>\n<td>API</td>\n<td>Application Programming Interface</td>\n</tr>\n<tr>\n<td>JSON</td>\n<td>JavaScript Object Notation</td>\n</tr>\n<tr>\n<td>XML</td>\n<td>eXtensible Markup Language</td>\n</tr>\n<tr>\n<td>HTTP</td>\n<td>HyperText Transfer Protocol</td>\n</tr>\n<tr>\n<td>REST</td>\n<td>Representational State Transfer (architectural style)</td>\n</tr>\n<tr>\n<td>RESTful APIs</td>\n<td>Interfaces that adhere to the REST style</td>\n</tr>\n<tr>\n<td>MVC</td>\n<td>Model View Controller (architectural style)</td>\n</tr>\n<tr>\n<td>MVVM</td>\n<td>Model View ViewModel (architectural style)</td>\n</tr>\n<tr>\n<td>SPA</td>\n<td>Single Page Application</td>\n</tr>\n<tr>\n<td>Client-side</td>\n<td>Operations that are performed by the client in a client–server relationship in a computer network. Typically, a client is a computer application, such as a web browser, that runs on a user's local computer or workstation and connects to a server as necessary.</td>\n</tr>\n<tr>\n<td>Server-side</td>\n<td>Operations that are performed by the server in a client–server relationship in a computer network. Typically, a server is a computer program, such as a web server, that runs on a remote server, reachable from a user's local computer or workstation.</td>\n</tr>\n<tr>\n<td>URI</td>\n<td>Uniform Resource Identifier</td>\n</tr>\n<tr>\n<td>URL</td>\n<td>Uniform Resource Locator</td>\n</tr>\n<tr>\n<td>Factory</td>\n<td>Component responsible for providing instances of classes</td>\n</tr>\n<tr>\n<td>CSS</td>\n<td>Cascading Style Sheets</td>\n</tr>\n<tr>\n<td>JDBC</td>\n<td>Java database connectivity technology that defines how a client may access a database</td>\n</tr>\n</tbody>\n</table>\nReferences\n\n\nAppendix A: Types of UML relationships\n\nThe UML relationships are thoroughly specified in the UML specification, but this section gives a brief and simple overview of them.\n\nFor explanation, consider two entities A and B, and relationships between them according to Figure 52. The relationships user are:\n\n- **Dependency** – A uses B for its implementation;\n- **Aggregation** – A has an B;\n- **Inheritance** – B is an A (or B extends A);\n- **Composition** – A owns B;\n- **Association** – similar as dependency, represents logical links between A and B (for example, A is linked to B, Passenger is linked with Airplane);\n- **Directed association** – see Association. It involves additional direction that constrains the reading direction of the relationship;\n- **Interface Type Implementation** – B realizes interface A.\n\nFigure 52 Types of UML relationships\nAppendix B: Classification of epilepsy syndromes and seizure types\n\nILAE seizure type classification of 1981\nThe epilepsy classification is based on seizure type and syndrome. The first widely accepted classification of epileptic seizures was published in 1981 by the International League Against Epilepsy (ILAE).\n\n- **Focal (local) seizures**\n - Simple focal seizures (consciousness not impaired)\n - With motor signs\n - With somatosensory or special-sensory symptoms (simple hallucinations, for example, tingling, light flashes, buzzing)\n - With autonomic symptoms or signs (for example, epigastric sensation, pallor, sweating, flushing, piloerection and papillary dilatation)\n - With psychic symptoms (disturbance of higher cerebral function) (for example, déjà vu, distortion of time sense, fear. NB these rarely occur without impairment of consciousness and are much more commonly experienced as 1.2 complex focal seizures)\n - Complex focal seizures (with impairment of consciousness)\n - With simple partial onset followed by impairment of consciousness\n - With impairment of consciousness at onset\n - Focal seizures evolving to secondarily generalized seizures (may be generalized tonic-clonic, tonic, or clonic)\n - Simple focal seizures evolving to generalized seizures\n - Complex focal seizures evolving to generalized seizures\n - Simple focal seizures evolving to complex focal seizures and then evolving to generalized seizures\n\n- **Generalized seizures (convulsive or non-convulsive)**\n - Absence seizures (impairment of consciousness alone or with: mild clonic, atonic or tonic components, automatisms and/or autonomic symptoms or signs)\n - Atypical absence\n - Myoclonic seizures\n - Clonic seizures\n - Tonic-clonic seizures\n - Atonic seizures\n\n- **Unclassified seizures**\n\nILAE syndrome classification of 1989\nIn 1989, a classification of epilepsies and epilepsy syndromes was published.\n\n- **Localization-related (focal, local, ) epilepsies and syndromes**\n - Idiopathic (listed in order of age of onset)\n - Benign childhood epilepsy with centrotemporal spike\n - Childhood epilepsy with occipital paroxysms\n - Symptomatic\n - Cryptogenic\n\n- **Generalized epilepsies and syndromes**\n - Idiopathic (listed in order of age of onset)\n - Benign neonatal familial convulsions\n\n- Benign neonatal convulsions\n- Benign myoclonic epilepsy in infancy\n- Childhood absence epilepsy (pyknolepsy)\n- Juvenile absence epilepsy\n- Juvenile myoclonic epilepsy (impulsive petit mal)\n- Epilepsy with grand mal (generalized tonic-clonic) seizures on awakening\n - Cryptogenic or symptomatic (listed in order of age of onset)\n - West syndrome (infantile spasms)\n - Lennox-Gastaut syndrome\n - Epilepsy with myoclonic-astatic seizures\n - Epilepsy with myoclonic absences\n - Symptomatic\n - Non-specific etiology\n - Early myoclonic encephalopathy\n - Early infantile epileptic encephalopathy with suppression burst\n - Other symptomatic generalized epilepsies not defined above\n - Specific syndromes\n - Epileptic seizures may complicate many disease states. Under this heading are included diseases in which seizures are a presenting or predominant feature\n\n- Epilepsies and syndromes undetermined whether focal or generalized\n - With both generalized and focal seizures\n - Neonatal seizures – excluded from G/L\n - Severe myoclonic epilepsy in infancy\n - Epilepsy with continuous spike-waves during slow wave sleep\n - Acquired epileptic aphasia (Landau-Kleffner syndrome)\n - Without unequivocal generalized or focal features\n\nAll cases with generalized tonic-clonic seizures in which clinical and EEG findings do not permit classification as clearly generalized or localization related, such as in many cases of sleep-grand mal are considered not to have unequivocal generalized or focal features.\n\n- Special syndromes\n - Febrile convulsions\n - Isolated seizures or isolated status epilepticus\n - Seizures occurring only when there is an acute metabolic or toxic event.\n\n**ILAE classification of 2010 (seizure types and syndromes)**\n\nAfter years of research and experiments, a new classification emerged in 2010. This classification, however, is not recognized globally, so both classifications are still used. The 2010 ILAE seizure classification is listed below [3] [25]:\n\n- **Generalized seizures**\n - Tonic-clonic (in any combination)\n - Absence\n - Typical\n - Atypical\n - Absence with special features\n - Myoclonic absence\n - Eyelid myoclonia\n - Myoclonic\n - Myoclonic\n - Myoclonic atonic\n - Myoclonic tonic\n - Clonic\n- **Focal seizures**\n - Without reduced level of consciousness\n - **Motoric**\n - **Autonomic**\n - **Subjective sensory or psychic phenomenon**\n - Dyscognitive (change of awareness/consciousness)\n - Becoming bilateral convulsive seizures\n - **Motoric**\n - **Autonomic**\n - **Subjective sensory or psychic phenomenon**\n - Unknown (epileptic spasms)\n\n- **Unknown seizures**\n - Epileptic spasms\n\nGeneralized seizures affect both hemispheres of the brain, while focal seizures affect only one. The unknown seizures cannot be clearly diagnosed so they are considered unclassified until further information reveals their accurate diagnosis. Each seizure type has different effects on the patient, ranging from harmless to the immediate need of a healthcare professional.\n\nThe number of syndromes is greater than the number of seizure types. They are grouped by age, starting from neonatal period, infancy, children age, adults, and some syndromes with characteristic finding or syndromes that cannot be placed in a specific group age. Figure 53 depicts part of the classification, where the syndromes are grouped based on the age of onset.\n\n\nAppendix C: Use cases of the system\n\nThis section lists the identified use cases in the system and their concrete steps.\n\nFigure 54 Use cases identified for the system\n\nThe use cases described start from top to bottom. In the listing of the concrete steps of the scenarios, characters representing the actor and the system are used. For the system, the character is “S”, and depending on the type of actor, it can be “P” for patient, “D” for doctor, “GR_A” for group administrator, “GL_A” for guidelines administrator, or simply “U” for a general user.\n\nUse case 01: View the epilepsy guidelines\n\n<table>\n<thead>\n<tr>\n<th>Description</th>\n<th>The user wants to view the epilepsy guidelines. This scenario is available to registered and non-registered users.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Level</td>\n<td>User-goal</td>\n</tr>\n<tr>\n<td>Primary actor</td>\n<td>Patient, Doctor, Anonymous user</td>\n</tr>\n<tr>\n<td>Precondition(s)</td>\n<td>System has Internet access and the application is opened</td>\n</tr>\n</tbody>\n</table>\n\nMain scenario\n\n1. U: Requests to view guidelines\n2. S: Retrieves the guidelines\n3. S: Displays the guidelines\n\nAlternative flow\n\n2a. System cannot retrieve guidelines\n 1. S: An error message is displayed to the user\n### Use case 02: View patient’s care journey\n\n**Description**\nUser wants to explore patient’s care journey with epilepsy\n\n**Level**\nUser-goal\n\n**Primary actor**\nPatient, Doctor\n\n**Precondition(s)**\nSystem has Internet access and the application is opened\n\n**Main scenario**\n1. U: Selects patient to view\n2. S: Retrieves data\n3. S: Displays patient’s care journey\n\n**Alternative flow**\n1a. User is patient\n 1. U: Selects himself as patient\n\n---\n\n### Use case 03: Check prescription\n\n**Description**\nUser wants to check a prescription for conformance to the guidelines and for registered side effects\n\n**Level**\nUser-goal\n\n**Primary actor**\nPatient, Doctor\n\n**Precondition(s)**\nSystem has Internet access and the application is opened\n\n**Main scenario**\n1. U: Enters information about patient, doctor, and medication\n2. S: Validates the information\n3. S: Checks the prescription\n4. S: Presents results\n\n**Alternative flow**\n1a: User is doctor\n 1. U: Enters information about patient and medication\n1b: User is patient\n 1. U: Enters information about doctor and medication\n2a: Information is invalid\n 1. S: Displays error information\n 2. U: Corrects the entered information\n\n---\n\n### Use case 04: Check for conformance\n\n**Description**\nDoctor wants to check his conformance to the guidelines\n\n**Level**\nUser-goal\n\n**Primary actor**\nDoctor\n\n**Precondition(s)**\nSystem has Internet access and the application is opened\n\n**Main scenario**\n1. D: Chooses guidelines for comparison and range of prescriptions based on date\n2. D: Chooses a group to compare to (optional, Use case 05).\n3. S: Validates entered information\n4. S: Checks for conformance\n5. S: Presents results\n\n**Alternative flow**\n1a: Range information is not entered\n 1. D: Chooses guidelines to compare against\n3b: Information is invalid\n 1. S: Displays error information\n 2. D: Corrects the entered information\n### Use case 05: Compare doctor to group\n\n<table>\n<thead>\n<tr>\n<th>Description</th>\n<th>Part of the check conformance scenario. User can optionally select a group to compare conformance results</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Level</td>\n<td>Sub-function</td>\n</tr>\n<tr>\n<td>Primary actor</td>\n<td>Doctor</td>\n</tr>\n<tr>\n<td>Precondition(s)</td>\n<td>System has Internet access and the application is opened</td>\n</tr>\n<tr>\n<td>Main scenario</td>\n<td>1. D: Chooses a group to compare against</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n### Use case 06: Request to view data\n\n<table>\n<thead>\n<tr>\n<th>Description</th>\n<th>Doctors requests to view data about a group’s conformance for comparison</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Primary actor</td>\n<td>Doctor</td>\n</tr>\n<tr>\n<td>Precondition(s)</td>\n<td>System has Internet access and the application is opened</td>\n</tr>\n<tr>\n<td>Main scenario</td>\n<td>1. D: Enters required information to request for comparison (group, date from, date to)</td>\n</tr>\n<tr>\n<td></td>\n<td>2. S: Validates the information</td>\n</tr>\n<tr>\n<td></td>\n<td>3. S: Sends the request</td>\n</tr>\n<tr>\n<td></td>\n<td>4. S: Displays confirmation</td>\n</tr>\n<tr>\n<td></td>\n<td><strong>Alternative flow</strong></td>\n</tr>\n<tr>\n<td></td>\n<td>1. S: Displays error message</td>\n</tr>\n<tr>\n<td></td>\n<td>2. D: Corrects entered information</td>\n</tr>\n<tr>\n<td></td>\n<td>4a: Error in saving request</td>\n</tr>\n<tr>\n<td></td>\n<td>1. S: Displays error message</td>\n</tr>\n</tbody>\n</table>\n\n### Use case 07: Manage request to view data\n\n<table>\n<thead>\n<tr>\n<th>Description</th>\n<th>A group administrator manages requests to view the group data. The administrator can approve, deny, or delete a request.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Primary actor</td>\n<td>Group Administrator</td>\n</tr>\n<tr>\n<td>Precondition(s)</td>\n<td>System has Internet access and the application is opened</td>\n</tr>\n<tr>\n<td>Main scenario</td>\n<td>1. GR_A: Requests to view benchmark requests for the group</td>\n</tr>\n<tr>\n<td></td>\n<td>2. S: Displays requests</td>\n</tr>\n<tr>\n<td></td>\n<td>3. GR_A: Selects a request</td>\n</tr>\n<tr>\n<td></td>\n<td>4. S: Presents details of the request</td>\n</tr>\n<tr>\n<td></td>\n<td>5. GR_A: Approves a request</td>\n</tr>\n<tr>\n<td></td>\n<td>6. S: Updates the request</td>\n</tr>\n<tr>\n<td></td>\n<td><strong>Alternative flow</strong></td>\n</tr>\n<tr>\n<td></td>\n<td>5a: Administrator denies a request</td>\n</tr>\n<tr>\n<td></td>\n<td>1. GR_A: Denies a request</td>\n</tr>\n<tr>\n<td></td>\n<td>5b: Administrator deletes a request</td>\n</tr>\n<tr>\n<td></td>\n<td>1. GR_A: Deletes a request</td>\n</tr>\n<tr>\n<td>Use case 08: Modify the epilepsy guidelines</td>\n<td></td>\n</tr>\n<tr>\n<td>--------------------------------------------</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Description</strong></td>\n<td>A guideline administrator wants to add, modify or delete data from the guidelines</td>\n</tr>\n<tr>\n<td><strong>Primary actor</strong></td>\n<td>Guideline Administrator</td>\n</tr>\n<tr>\n<td><strong>Precondition(s)</strong></td>\n<td>System has Internet access, the application is opened and guidelines are displayed</td>\n</tr>\n<tr>\n<td><strong>Main scenario</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>1. GL_A: Selects an entry from the guidelines</td>\n<td></td>\n</tr>\n<tr>\n<td>2. S: Displays details about the entry</td>\n<td></td>\n</tr>\n<tr>\n<td>3. GL_A: Makes changes to the entry</td>\n<td></td>\n</tr>\n<tr>\n<td>4. GL_A: Requests to modify the entry</td>\n<td></td>\n</tr>\n<tr>\n<td>5. S: Modifies the entry</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Alternative flow</strong></td>\n<td></td>\n</tr>\n<tr>\n<td>1a: User adds new entry in the guidelines</td>\n<td></td>\n</tr>\n<tr>\n<td>1. GL_A: Enters required information</td>\n<td></td>\n</tr>\n<tr>\n<td>2. S: Validates information</td>\n<td></td>\n</tr>\n<tr>\n<td>3. S: Saves the entry</td>\n<td></td>\n</tr>\n<tr>\n<td>3a: User deletes an entry</td>\n<td></td>\n</tr>\n<tr>\n<td>1. GL_A: Requests to delete an entry</td>\n<td></td>\n</tr>\n<tr>\n<td>2. S: System deletes the entry</td>\n<td></td>\n</tr>\n<tr>\n<td>5a: System cannot modify entry</td>\n<td></td>\n</tr>\n<tr>\n<td>1. S: Displays error information</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n# Appendix D: The epilepsy guidelines\n\n## Seizure types\n\n### Focal seizures\n\n<table>\n<thead>\n<tr>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>First choice</strong> <em>(first & second attempt)</em></td>\n<td>Carbamazepine Lamotrigine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Levetiracetam Oxcarbazepine Valproate</td>\n<td>Not on pregnant women</td>\n</tr>\n<tr>\n<td><strong>Second choice</strong> <em>(third attempt)</em></td>\n<td>Phenytoin Gabapentin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Lacosamide Pregabalin Topiramate</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Clobazam Perampanel</td>\n<td>Only as adjunctive AED</td>\n</tr>\n<tr>\n<td></td>\n<td>Zonisamide</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Adjunctive</strong> <em>(third attempt)</em></td>\n<td>1. Any first choice 2. Any first or second choice</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Do not use</strong></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n### Absence seizures *(Generalized seizures)*\n\n<table>\n<thead>\n<tr>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>First choice</strong> <em>(first attempt)</em></td>\n<td>Ethosuximide</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Second choice</strong> <em>(second attempt)</em></td>\n<td>Lamotrigine Valproate</td>\n<td>not on pregnant women</td>\n</tr>\n<tr>\n<td><strong>Adjunctive</strong> <em>(third attempt)</em></td>\n<td>1. Any first or second choice 2. Any first or second choice</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Do not use</strong></td>\n<td>Phenobarbital Carbamazepine Phenytoin Gabapentin Oxcarbazepine Pregabalin</td>\n<td>Do not use this medication in case of childhood absence epilepsy</td>\n</tr>\n</tbody>\n</table>\n\nDo not use Vigabatrin in case of childhood absence epilepsy.\n### Tonic-clonic seizures combined with myoclonus *(Generalized seizures)*\n\n<table>\n<thead>\n<tr>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>First choice</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(first & second</td>\n<td>Levetiracetam</td>\n<td></td>\n</tr>\n<tr>\n<td>attempt)</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Valproate</td>\n<td>Not on pregnant women</td>\n</tr>\n<tr>\n<td><strong>Second choice</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(second attempt)</td>\n<td>Clobazam</td>\n<td>Only as adjunctive AED</td>\n</tr>\n<tr>\n<td></td>\n<td>Topiramate</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Zonisamide</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Adjunctive</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(third attempt)</td>\n<td>Clonazepam</td>\n<td>Only as adjunctive AED</td>\n</tr>\n<tr>\n<td></td>\n<td>1. Clobazam</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>1. Clonazepam</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>2. Any first or second</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>choice</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Do not use</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Vigabatrin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Phenobarbital</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Carbamazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Phenytoin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Gabapentin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Oxcarbazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Pregabalin</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n### Tonic-clonic seizures without myoclonus *(Generalized seizures)*\n\n<table>\n<thead>\n<tr>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>First choice</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(first & second</td>\n<td>Levetiracetam</td>\n<td></td>\n</tr>\n<tr>\n<td>attempt)</td>\n<td>Lamotrigine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Valproate</td>\n<td>Not on pregnant women</td>\n</tr>\n<tr>\n<td></td>\n<td>Clonazepam</td>\n<td>Only as adjunctive AED</td>\n</tr>\n<tr>\n<td><strong>Second choice</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(second attempt)</td>\n<td>Topiramate</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Zonisamide</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Carbamazepine</td>\n<td>Only as adjunctive AED</td>\n</tr>\n<tr>\n<td></td>\n<td>Clobazam</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>1. Clobazam</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>1. Clonazepam</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>2. Any first or second</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>choice</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Do not use</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Vigabatrin</td>\n<td>Do not use in case of absences and/or</td>\n</tr>\n<tr>\n<td></td>\n<td>Phenobarbital</td>\n<td>myoclonus</td>\n</tr>\n<tr>\n<td></td>\n<td>Carbamazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Phenytoin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Gabapentin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Oxcarbazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Pregabalin</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n### Unclassifiable seizures\n\n<table>\n<thead>\n<tr>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>First choice</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(first & second attempt)</td>\n<td>First choice</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Levetiracetam</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Lamotrigine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Valproate</td>\n<td>not on pregnant women</td>\n</tr>\n<tr>\n<td></td>\n<td>Clobazam</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Second choice</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(second attempt)</td>\n<td>Topiramate</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Carbamazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Phenytoin</td>\n<td>Caution when used because of paradoxical</td>\n</tr>\n<tr>\n<td></td>\n<td>Gabapentin</td>\n<td>effect in myoclonus or absence seizures</td>\n</tr>\n<tr>\n<td></td>\n<td>Oxcarbazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Pregabalin</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Adjunctive</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Do not use</strong></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n*Note: Third attempt – refer to specialized center*\n\n### Syndromes\n\n#### Childhood absence epilepsy (CAE)\n\n<table>\n<thead>\n<tr>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>First choice</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(first & second attempt)</td>\n<td>Ethosuximide</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Lamotrigine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Valproate</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Second choice</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Adjunctive</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(third attempt)</td>\n<td>1. Ethosuximide</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>1. Lamotrigine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>2. Valproate</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Carbamazepine</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Do not use</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Oxcarbazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Phenytoin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Phenobarbital</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Tiagabine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Gabapentin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Pregabalin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Vigabatrin</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n#### Juvenile myoclonic epilepsy (JME)\n\n<table>\n<thead>\n<tr>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>First choice</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(first & second attempt)</td>\n<td>Valproate</td>\n<td>not on pregnant women</td>\n</tr>\n<tr>\n<td></td>\n<td>Lamotrigine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Levetiracetam</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Second choice</strong></td>\n<td>Topiramate</td>\n<td>Only as adjunctive AED</td>\n</tr>\n<tr>\n<td></td>\n<td>Clobazam</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Adjunctive</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>(third attempt)</td>\n<td>1. Valproate</td>\n<td>may increase absence and/or myoclonic</td>\n</tr>\n<tr>\n<td></td>\n<td>2. Clobazam</td>\n<td>seizures</td>\n</tr>\n<tr>\n<td></td>\n<td>2. Lamotrigine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Carbamazepine</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Do not use</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Oxcarbazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Phenytoin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Gabapentin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Tiagabine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Vigabatrin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Pregabalin</td>\n<td></td>\n</tr>\n<tr>\n<td>Category</td>\n<td>AED</td>\n<td>Remark</td>\n</tr>\n<tr>\n<td>---------------------------------------</td>\n<td>-----------------------------</td>\n<td>---------------------------------------------</td>\n</tr>\n<tr>\n<td><strong>First choice</strong> (first & second attempt)</td>\n<td>Carbamazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Lamotrigine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Levetiracetam</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Oxcarbazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Valproate</td>\n<td>Not on pregnant women</td>\n</tr>\n<tr>\n<td></td>\n<td>Clobazam</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Second choice</strong></td>\n<td>Topiramate</td>\n<td>Not on children, can cause cognitive side-effects</td>\n</tr>\n<tr>\n<td><strong>Adjunctive</strong> (third attempt)</td>\n<td>1. Any first or second choice</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>2. Any first or second choice</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Do not use</strong></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**Panayiotopoulus syndrome**\n\n<table>\n<thead>\n<tr>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>First choice</strong> (first & second attempt)</td>\n<td>Carbamazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Lamotrigine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Oxcarbazepine</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Valproate</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Second choice</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Adjunctive</strong></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Do not use</strong></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n## Status epilepticus\n\n### Status epilepticus in children\n\n<table>\n<thead>\n<tr>\n<th>Steps</th>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Step 1: t=0</strong> (for medical intervention)</td>\n<td>First choice</td>\n<td>Midazolam</td>\n<td></td>\n</tr>\n<tr>\n<td>Attack duration of 5 minutes</td>\n<td>Second choice</td>\n<td>Diazepam</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Step 2: t=5min.</strong> Insufficient results after step 1</td>\n<td>First choice</td>\n<td>Midazolam</td>\n<td></td>\n</tr>\n<tr>\n<td>First choice Midazolam</td>\n<td>Second choice</td>\n<td>Diazepam</td>\n<td></td>\n</tr>\n<tr>\n<td>First choice Midazolam</td>\n<td>First choice</td>\n<td>Midazolam</td>\n<td></td>\n</tr>\n<tr>\n<td>Insufficient results after 5 minutes</td>\n<td>Second choice</td>\n<td>Lorazepam</td>\n<td></td>\n</tr>\n<tr>\n<td>Do not use Phenytoin</td>\n<td>Valproate</td>\n<td></td>\n<td>In case of known hypersensitivity, cardiac arrhythmias, or Dravet syndrome in case of liver disease, thrombocytopenia, metabolic disease</td>\n</tr>\n<tr>\n<td><strong>Step 3: t=10min.</strong> Insufficient results after 5 minutes</td>\n<td>First choice</td>\n<td>Midazolam</td>\n<td></td>\n</tr>\n<tr>\n<td>First choice Midazolam</td>\n<td>Second choice</td>\n<td>Lorazepam</td>\n<td></td>\n</tr>\n<tr>\n<td>Do not use Phenytoin</td>\n<td>Valproate</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Step 4: t=15min.</strong> Insufficient results after 10 minutes</td>\n<td>First choice</td>\n<td>Phenytoin (in 0.9% NaCl)</td>\n<td>except in liver disease, thrombocytopenia or suspected metabolic disease</td>\n</tr>\n<tr>\n<td>First choice Phenytoin</td>\n<td>Second choice</td>\n<td>Valproate</td>\n<td></td>\n</tr>\n<tr>\n<td>Second choice Levetiracetam</td>\n<td>Valproate</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Second choice Phenytoin (in 0.9% NaCl)</td>\n<td>Valproate</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Refractory status (Failure of benzodiazepine and antiepileptic drug)</td>\n<td>First choice</td>\n<td>Midazolam</td>\n<td></td>\n</tr>\n<tr>\n<td>Refractory status (Failure of benzodiazepine and antiepileptic drug)</td>\n<td>First choice</td>\n<td>Midazolam</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>Step 5: t=25-35min.</strong> Consultation with intensive care (consider intubation and ventilation)</td>\n<td>First choice</td>\n<td>Midazolam</td>\n<td></td>\n</tr>\n<tr>\n<td>First choice Midazolam</td>\n<td>Second choice</td>\n<td>Thioridazine</td>\n<td></td>\n</tr>\n<tr>\n<td>First choice Midazolam</td>\n<td>Second choice</td>\n<td>Thiopental</td>\n<td></td>\n</tr>\n<tr>\n<td>Special case</td>\n<td>First choice</td>\n<td>Midazolam</td>\n<td></td>\n</tr>\n<tr>\n<td>Children under 2 years with little or no effect of AEDs</td>\n<td>First choice</td>\n<td>Pyridoxine</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n## Status epilepticus in adults\n\n### Tonic-clonic seizures longer than 5 minutes or series of seizures without the patient regaining consciousness\n\n<table>\n<thead>\n<tr>\n<th>Steps</th>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Step 1</td>\n<td>First choice</td>\n<td>Lorazepam</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Midazolam</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Phenytoin</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Second choice</td>\n<td>Valproate</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Levetiracetam</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n### Refractory status\n\n(Failure of benzodiazepine and antiepileptic drug)\n\n<table>\n<thead>\n<tr>\n<th>Steps</th>\n<th>Category</th>\n<th>AED</th>\n<th>Remark</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Step 2</td>\n<td>First choice</td>\n<td>Midazolam</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Thiopental</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Propofol</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n### Advised care journey\n\n<table>\n<thead>\n<tr>\n<th>#</th>\n<th>Advice</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Refer epilepsy patients to evaluation for surgery if the patient is drug resistant and keeps getting attacks despite treatment with two or three antiepileptic drugs in adequate dosage</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Refer epilepsy patients to assess the possibility of specialized epilepsy treatments instead of surgery</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Refer to a pediatric neurologist or epilepsy center if the clinical symptoms and/or seizures on children with benign Rolandic epilepsy change</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Refer the patient to specialized epilepsy care if within two years from the debut of the epilepsy and/or failure of two antiepileptics the patient is still not seizure-free</td>\n</tr>\n<tr>\n<td>5</td>\n<td>Consider referring the patient to specialized epilepsy care if the epilepsy debuts in the early years</td>\n</tr>\n</tbody>\n</table>\nAppendix E: Syndrome and seizure mapping\n\nThis section lists the mapping developed to translate the different classifications used into a single one, namely ILAE classification of 2010. Table 18 lists the Luders and ILAE classification of seizure types (names are in Dutch) and their respective mapping to the new classification. Seizure types marked light red are from the Luders classification, and seizure types marked light yellow are from the ILAE classification.\n\nTable 18 Mapping of seizure types (from old ILAE and Luders classification to new ILAE classification)\n\n<table>\n<thead>\n<tr>\n<th>Original seizure name (as recorded in the dataset)</th>\n<th>Seizure (ILAE classification)</th>\n<th>Combined with</th>\n<th>Treat as</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Diallepthische aanvallen</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Automotore aanvallen</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Somatosensorische aura's</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Hypermotorische aanvallen</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Autonome aanvallen</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Psychische aura's</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Buikaura's</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Afatisme aanvallen</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Autonome aura's</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Smaakaura's</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Gelastische aanvallen</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Visuele aura's</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Tonisch-clonische aanvallen</td>\n<td>Tonic-clonic seizures</td>\n<td>Tonic-clonic seizures</td>\n<td>Tonic-clonic seizures</td>\n</tr>\n<tr>\n<td>Tonische aanvallen</td>\n<td>Tonic seizures</td>\n<td>Tonic seizures</td>\n<td>Tonic seizures</td>\n</tr>\n<tr>\n<td>Clonische aanvallen</td>\n<td>Clonic seizures</td>\n<td>Clonic seizures</td>\n<td>Clonic seizures</td>\n</tr>\n<tr>\n<td>Versiee aanvallen</td>\n<td>Tonic seizures</td>\n<td>Tonic seizures</td>\n<td>Tonic seizures</td>\n</tr>\n<tr>\n<td>Myoclonische aanvallen</td>\n<td>Myoclonic seizures</td>\n<td>Myoclonic seizures</td>\n<td>Myoclonic seizures</td>\n</tr>\n<tr>\n<td>Atone aanvallen</td>\n<td>Atonic seizures</td>\n<td>Atonic seizures</td>\n<td>Atonic seizures</td>\n</tr>\n<tr>\n<td>Astatiche aanvallen</td>\n<td>Myoclonic seizures</td>\n<td>Myoclonic seizures</td>\n<td>Myoclonic seizures</td>\n</tr>\n<tr>\n<td>Epileptische spasmen</td>\n<td>Tonic seizures</td>\n<td>Myoclonic seizures</td>\n<td>Tonic seizures</td>\n</tr>\n<tr>\n<td>Epileptie-aanval niet nader gespecificeerd</td>\n<td>Unclassified seizures</td>\n<td>Unclassified seizures</td>\n<td>Unclassified seizures</td>\n</tr>\n<tr>\n<td>Aanvallige incidenten niet-epileptisch</td>\n<td>Non-epileptic seizures</td>\n<td>Non-epileptic seizures</td>\n<td>Non-epileptic seizures</td>\n</tr>\n<tr>\n<td>Complex Partiele Aanval (Cpa)</td>\n<td>Unclassified seizures</td>\n<td>Unclassified seizures</td>\n<td>Unclassified seizures</td>\n</tr>\n<tr>\n<td>Tonisch-Clonische Aanval</td>\n<td>Tonic-clonic seizures</td>\n<td>Tonic-clonic seizures</td>\n<td>Tonic-clonic seizures</td>\n</tr>\n<tr>\n<td>Eenvoudig Partiele Aanval (E.P.A.)</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Clonische Aanval</td>\n<td>Clonic seizures</td>\n<td>Clonic seizures</td>\n<td>Clonic seizures</td>\n</tr>\n</tbody>\n</table>\n### Partiele Aanval, Overgaand In Secundair Gegeneraliseerd\n\n<table>\n<thead>\n<tr>\n<th>Syndrome (registered in Kempenhaeghe)</th>\n<th>Syndrome (ILAE classification)</th>\n<th>Manifested with (seizure type)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Tonicia Aanval</td>\n<td>Tonic seizures</td>\n<td>Tonic seizures</td>\n</tr>\n<tr>\n<td>Absences</td>\n<td>Absence seizures</td>\n<td>Absence seizures</td>\n</tr>\n<tr>\n<td>Niet Geclasseificeerde Aanval</td>\n<td>Unclassifiable seizures</td>\n<td>Unclassifiable seizures</td>\n</tr>\n<tr>\n<td>Myoclonische Aanval</td>\n<td>Myoclonic seizures</td>\n<td>Myoclonic seizures</td>\n</tr>\n<tr>\n<td>Psychogene Aanval</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Syncope</td>\n<td>Focal seizures</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Atonische Of Val-Aanval</td>\n<td>Atonic seizures</td>\n<td>Myoclonic seizures</td>\n</tr>\n<tr>\n<td>Drop Attack</td>\n<td>Myoclonic-astatic seizures</td>\n<td>Myoclonic-astatic seizures</td>\n</tr>\n</tbody>\n</table>\n\nThe next table, Table 19, lists the syndrome translation from the different classification to the ILAE classification of syndromes. It also lists the different types of seizure types that the syndrome is manifested through.\n\n**Table 19 Syndrome mapping between old and new classification**\n\n<table>\n<thead>\n<tr>\n<th>Syndrome (registered in Kempenhaeghe)</th>\n<th>Syndrome (ILAE classification)</th>\n<th>Manifested with (seizure type)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Situation-Related Seizures (Gelegenheitsanfälle)</td>\n<td>Epilepsy with provoked generalized convulsive seizures</td>\n<td>Tonic-clonic seizures</td>\n</tr>\n<tr>\n<td>Undetermined Epilepsies Without Unequivocal General. Or Focal Features</td>\n<td>Epilepsies with unknown cause</td>\n<td>Unclassifiable seizures</td>\n</tr>\n<tr>\n<td>Cryptogenic Localization-Related (Focal, Local, Partial)</td>\n<td>Epilepsies with unknown cause</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td></td>\n<td>Juvenile myoclonic epilepsy (JME)</td>\n<td>Myoclonic seizures</td>\n</tr>\n<tr>\n<td></td>\n<td>Juvenile absence epilepsy (JAE)</td>\n<td>Absence seizures</td>\n</tr>\n<tr>\n<td></td>\n<td>Childhood absence epilepsy (CAE)</td>\n<td>Absence seizures</td>\n</tr>\n<tr>\n<td></td>\n<td>Epilepsy with generalized tonic–clonic seizures alone</td>\n<td>Tonic-clonic seizures</td>\n</tr>\n<tr>\n<td>Idiopathic (Primary) Generalized</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Symptomatic (Secondary) Generalized With Specific Syndromes</td>\n<td>Epilepsies attributed to and organized by structural-metabolic causes</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Symptomatic (Secondary) Localization-Related (Focal, Local, Partial)</td>\n<td>Epilepsies attributed to and organized by structural-metabolic causes</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Symptomatic (Secondary) Generalized, Nonspecific Etiology</td>\n<td>Epilepsies attributed to and organized by structural-metabolic causes</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>No Epilepsy</td>\n<td>Benign epilepsy with centrotemporal spikes (BECTS)</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>----------------------------------------------------------------------------</td>\n<td>-------------------------------------------------</td>\n<td>------------------------------------------</td>\n</tr>\n<tr>\n<td>Idiopathic (Primary) Localization-Related (Focal, Local, Partial)</td>\n<td>Late-onset childhood occipital epilepsy (Gastaut type)</td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>Undetermined Epilepsies With Both Generalized And Focal Seizures</td>\n<td>Epilepsies with unknown cause</td>\n<td>Unclassifiable seizures</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Cryptogenic Or Symptomatic Generalized</th>\n<th>Lennox–Gastaut syndrome</th>\n<th>Tonic seizures</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n<td>Atonic seizures</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Atypical absence seizures</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Atypical seizures</td>\n</tr>\n<tr>\n<td>Dravet syndrome</td>\n<td>Myoclonic seizures</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Atypical absence seizures</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Focal seizures</td>\n</tr>\n<tr>\n<td>West syndrome</td>\n<td>Tonic-clonic seizures</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Infantile spasms</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Tonic-clonic seizures</td>\n</tr>\n<tr>\n<td></td>\n<td>Tonic seizures</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Other seizure types</td>\n<td></td>\n</tr>\n<tr>\n<td>Ohathara syndrome</td>\n<td>Tonic-clonic seizures</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Tonic seizures</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Other seizure types</td>\n<td></td>\n</tr>\n</tbody>\n</table>\nAbout the Author\n\nTrajche Masinov received his Bachelor of Electrical Engineering and Information Technologies from the Faculty of Electrical Engineering and Information Technology (Skopje, Macedonia), in October 2009, specializing in Informatics and Computer Engineering. He received his MSc degree in Software Engineering of the Faculty of Computer Science and Engineering (Skopje, Macedonia) in November 2013. His master thesis involved utilizing modern data visualization techniques as a tool for displaying news, offering different ways a user consumes everyday news. In parallel with the master studies he worked for almost 5 years as a Software Developer at Edusoft, Macedonia, developing Web-based information systems in ASP.NET and SQL Server/Oracle RDBMS.\n\nFrom September 2013 until September 2015, he worked at the Eindhoven University of Technology, as PDEng trainee in the Software Technology program from the 3TU.Stan Ackermans Institute. During his graduation project, he worked for the Epilepsy Center Kempenhaeghe (under supervision of Synergetics Benelux BV) on a project focused on decision support via data visualization for improving epilepsy care.\n3TU.School for Technological Design, Stan Ackermans Institute offers two-year postgraduate technological designer programmes. This institute is a joint initiative of the three technological universities of the Netherlands: Delft University of Technology, Eindhoven University of Technology and University of Twente. For more information please visit: www.3tu.nl/sai."}}},{"rowIdx":276,"cells":{"id":{"kind":"string","value":"9e1bc2078e0d46d65f272e2ee11e4cfe5f2b578b"},"text":{"kind":"string","value":"Package ‘dtwclust’\n\nJuly 7, 2019\n\nType Package\n\nTitle Time Series Clustering Along with Optimizations for the Dynamic Time Warping Distance\n\nDescription Time series clustering along with optimized techniques related to the Dynamic Time Warping distance and its corresponding lower bounds. Implementations of partitional, hierarchical, fuzzy, k-Shape and TADPole clustering are available. Functionality can be easily extended with custom distance measures and centroid definitions. Implementations of DTW barycenter averaging, a distance based on global alignment kernels, and the soft-DTW distance and centroid routines are also provided. All included distance functions have custom loops optimized for the calculation of cross-distance matrices, including parallelization support. Several cluster validity indices are included.\n\nVersion 5.5.4\n\nDepends R (>= 3.2.0), methods, proxy (>= 0.4-16), dtw\n\nImports parallel, stats, bigmemory, clue, cluster, dplyr, flexclust, foreach, ggplot2, ggrepel, Matrix, nloptr, RSpectra, Rcpp, RcppParallel (>= 4.4.0), reshape2, shiny, shinyjs\n\nLinkingTo Rcpp, RcppArmadillo, RcppParallel, RcppThread\n\nSuggests doParallel, knitr, rmarkdown, testthat\n\nDate 2019-07-07\n\nAuthor Alexis Sarda-Espinosa\n\nMaintainer Alexis Sarda <alexis.sarda@gmail.com>\n\nBugReports https://github.com/asardaes/dtwclust/issues\n\nLicense GPL-3\n\nURL https://github.com/asardaes/dtwclust\n\nNeedsCompilation yes\n\nSystemRequirements C++11, GNU make\n\nEncoding UTF-8\n\nLazyData TRUE\nRoxygenNote 6.1.1\n\nVignetteBuilder knitr\n\nCollate 'CENTROIDS-dba.R' 'CENTROIDS-pam.R' 'CENTROIDS-sdtw-cent.R'\n 'CENTROIDS-shape-extraction.R' 'CLUSTERING-all-cent2.R'\n 'CLUSTERING-compare-clusterings.R'\n 'CLUSTERING-cvi-evaluators.R' 'CLUSTERING-ddist2.R'\n 'CLUSTERING-partitional-fuzzy.R'\n 'CLUSTERING-repeat-clustering.R' 'CLUSTERING-tadpole.R'\n 'CLUSTERING-tsclust-controls.R' 'CLUSTERING-tsclust.R'\n 'DISTANCES-dtw-basic.R' 'DISTANCES-dtw-lb.R' 'DISTANCES-dtw2.R'\n 'DISTANCES-gak.R' 'DISTANCES-lb-improved.R'\n 'DISTANCES-lb-keogh.R' 'DISTANCES-sbd.R' 'DISTANCES-sdtw.R'\n 'GENERICS-cvi.R' 'S4-Distmat.R' 'S4-PairTracker.R'\n 'S4-SparseDistmat.R' 'S4-tsclustFamily.R'\n 'S4-TSClusters-classes.R' 'S4-TSClusters-methods.R'\n 'SHINY-interactive-clustering.R' 'SHINY-sdtwclust.R'\n 'SHINY-utils.R' 'UTILS-as-methods.R' 'UTILS-compute-envelope.R'\n 'UTILS-data.R' 'UTILS-expressions.R' 'UTILS-globals-internal.R'\n 'UTILS-nccc.R' 'UTILS-reinterpolate.R' 'UTILS-rng.R'\n 'UTILS-tsclist.R' 'UTILS-utils.R' 'UTILS-zscore.R' 'pkg.R'\n\nRepository CRAN\n\nDate/Publication 2019-07-07 04:30:02 UTC\n\nR topics documented:\n\n dtwclus-package .................................................. 3\n as.matrix .......................................................... 4\n compare_clusterings .............................................. 5\n compare_clusterings_configs .................................... 11\n compute_envelope .................................................. 12\n cvi .............................................................. 13\n cvi_evaluators .................................................... 17\n DBA .............................................................. 18\n dtw2 ............................................................ 21\n dtwclusTimings ..................................................... 22\n dtw_basic ........................................................ 22\n dtw_lb ........................................................... 26\n GAK .............................................................. 29\n interactive_clustering ............................................ 31\n lb_improved ....................................................... 32\n lb_keogh ........................................................ 34\n NCCc ............................................................. 37\n pam_cent ......................................................... 37\n pdc_configs ...................................................... 38\n reinterpolate ..................................................... 39\n repeat_clustering ................................................ 40\n**Description**\n\nTime series clustering with a wide variety of strategies and a series of optimizations specific to the Dynamic Time Warping (DTW) distance and its corresponding lower bounds (LBs).\n\n**Details**\n\nMany of the algorithms implemented in this package are specifically tailored to DTW, hence its name. However, the main clustering function is flexible so that one can test many different clustering approaches, using either the time series directly, or by applying suitable transformations and then clustering in the resulting space. Other implementations included in the package provide some alternatives to DTW.\n\nDTW is a dynamic programming algorithm that tries to find the optimum warping path between two series. Over the years, several variations have appeared in order to make the procedure faster or more efficient. Please refer to the included references for more information, especially Giorgino (2009), which is a good practical introduction.\n\nMost optimizations require equal dimensionality, which means time series should have equal length. DTW itself does not require this, but it is relatively expensive to compute. Other distance definitions may be used, or series could be reinterpolated to a matching length (Ratanamahatana and Keogh 2004).\n\nThe main clustering function and entry point for this package is `tsclust()`, with a convenience wrapper for multiple tests in `compare_clusterings()`, and a shiny app in `interactive_clustering()`. There is another less-general-purpose shiny app in `ssdtwclust()`.\n\nPlease note the random number generator is set to L’Ecuyer-CMRG when `dtwclust` is attached in an attempt to preserve reproducibility. You are free to change this afterwards if you wish (see `base:::RNGkind()`), but `dtwclust` will always use L’Ecuyer-CMRG internally.\nFor more information, please read the included package vignettes, which can be accessed by typing `browseVignettes(\"dtwclust\")`.\n\n**Note**\n\nThis software package was developed independently of any organization or institution that is or has been associated with the author.\n\nThis package can be used without attaching it with `base::library()` with some caveats:\n\n- The **methods** package must be attached. R usually does this automatically, but `utils::Rscript()` only does so in R versions 3.5.0 and above.\n- If you want to use the **proxy** version of `dtw::dtw()` (e.g. for clustering), you have to attach the **dtw** package manually.\n\nBe careful with reproducibility, R’s random number generator is only changed session-wide if **dtwclust** is attached.\n\n**Author(s)**\n\nAlexis Sarda-Espinosa\n\n**References**\n\nPlease refer to the package’s vignette’s references.\n\n**See Also**\n\n`tsclust`, `compare_clusterings`, `interactive_clustering`, `ssdtwclust`, `dtw_basic`, `proxy::dist`.\n\n---\n\n**as.matrix**\n\n**Description**\n\n**proxy** exported a non-generic `as.matrix` function. This is to re-export the base version and add coercion methods for `pairdist` and `crossdist`.\n\n**Usage**\n\n`as.matrix(x, ...)`\n\n**Arguments**\n\n`x, ...` See `base::as.matrix()`.\n\n**See Also**\n\n`base::as.matrix()`\n**compare_clusterings**\n\n**Compare different clustering configurations**\n\n**Description**\n\nCompare many different clustering algorithms with support for parallelization.\n\n**Usage**\n\n```r\ncompare_clusterings(series = NULL, types = c(\"p\", \"h\", \"f\", \"t\"),\n configs = compare_clusterings_configs(types), seed = NULL,\n trace = FALSE, ..., score.clus = function(...) stop(\"No scoring\"),\n pick.clus = function(...) stop(\"No picking\"),\n shuffle.configs = FALSE, return.objects = FALSE,\n packages = character(0L), .errorhandling = \"stop\")\n```\n\n**Arguments**\n\n- **series**\n A list of series, a numeric matrix or a data frame. Matrices and data frames are coerced to a list row-wise (see `tslist()`).\n\n- **types**\n Clustering types. It must be any combination of (possibly abbreviated): \"partitional\", \"hierarchical\", \"fuzzy\", \"tadpole.\"\n\n- **configs**\n The list of data frames with the desired configurations to run. See `pdc_configs()` and `compare_clusterings_configs()`.\n\n- **seed**\n Seed for random reproducibility.\n\n- **trace**\n Logical indicating that more output should be printed to screen.\n\n- **score.clus**\n A function that gets the list of results (and ...) and scores each one. It may also be a named list of functions, one for each type of clustering. See Scoring section.\n\n- **pick.clus**\n A function to pick the best result. See Picking section.\n\n- **shuffle.configs**\n Randomly shuffle the order of configs, which can be useful to balance load when using parallel computation.\n\n- **return.objects**\n Logical indicating whether the objects returned by `tsclust()` should be given in the result.\n\n- **packages**\n A character vector with the names of any packages needed for any functions used (distance, centroid, preprocessing, etc.). The name \"dtwclust\" is added automatically. Relevant for parallel computation.\n\n- **.errorhandling**\n This will be passed to `foreach::foreach()`. See Parallel section below.\nDetails\n\nThis function calls `tsclust()` with different configurations and evaluates the results with the provided functions. Parallel support is included. See the examples.\n\nParameters specified in `configs` whose values are NA will be ignored automatically.\n\nThe scoring and picking functions are for convenience, if they are not specified, the scores and pick elements of the result will be NULL.\n\nSee `repeat_clustering()` for when `return.objects = FALSE`.\n\nValue\n\nA list with:\n\n- `results`: A list of data frames with the flattened `configs` and the corresponding scores returned by `score.clus`.\n- `scores`: The scores given by `score.clus`.\n- `pick`: The object returned by `pick.clus`.\n- `proc_time`: The measured execution time, using `base::proc.time()`.\n- `seeds`: A list of lists with the random seeds computed for each configuration.\n\nThe cluster objects are also returned if `return.objects = TRUE`.\n\nParallel computation\n\nThe configurations for each clustering type can be evaluated in parallel (multi-processing) with the `foreach` package. A parallel backend can be registered, e.g., with `doParallel`.\n\nIf the `.errorhandling` parameter is changed to \"pass\" and a custom `score.clus` function is used, said function should be able to deal with possible error objects.\n\nIf it is changed to \"remove\", it might not be possible to attach the scores to the results data frame, or it may be inconsistent. Additionally, if `return.objects` is TRUE, the names given to the objects might also be inconsistent.\n\nParallelization can incur a lot of deep copies of data when returning the cluster objects, since each one will contain a copy of `datalist`. If you want to avoid this, consider specifying `score.clus` and setting `return.objects` to FALSE, and then using `repeat_clustering()`.\n\nScoring\n\nThe clustering results are organized in a `list of lists` in the following way (where only applicable types exist; first-level list names in bold):\n\n- **partitional** - list with\n - Clustering results from first partitional config\n - etc.\n- **hierarchical** - list with\n - Clustering results from first hierarchical config\n - etc.\n• **fuzzy** - list with\n – Clustering results from first fuzzy config\n – etc.\n\n• **tadpole** - list with\n – Clustering results from first tadpole config\n – etc.\n\nIf `score.clus` is a function, it will be applied to the available partitional, hierarchical, fuzzy and/or tadpole results via:\n\n```r\nscores <- lapply(list_of_lists, score.clus, ...)\n```\n\nOtherwise, `score.clus` should be a list of functions with the same names as the list above, so that `score.clus$partitional` is used to score `list_of_lists$partitional` and so on (via `base::Map()`).\n\nTherefore, the scores returned shall always be a list of lists with first-level names as above.\n\n### Picking\n\nIf `return.objects` is `TRUE`, the results’ data frames and the list of `TSClusters` objects are given to `pick.clus` as first and second arguments respectively, followed by .... Otherwise, `pick.clus` will receive only the data frames and the contents of ... (since the objects will not be returned by the preceding step).\n\n### Limitations\n\nNote that the configurations returned by the helper functions assign special names to preprocessing/distance/centroid arguments, and these names are used internally to recognize them.\n\nIf some of these arguments are more complex (e.g. matrices) and should *not* be expanded, consider passing them directly via the ellipsis (…) instead of using `pdc_configs()`. This assumes that said arguments can be passed to all functions without affecting their results.\n\nThe distance matrices (if calculated) are not re-used across configurations. Given the way the configurations are created, this shouldn’t matter, because clusterings with arguments that can use the same distance matrix are already grouped together by `compare_clusterings_configs()` and `pdc_configs()`.\n\n### Author(s)\n\nAlexis Sarda-Espinosa\n\n### See Also\n\n`compare_clusterings_configs()`, `tsclust()`\nExamples\n\n# Fuzzy preprocessing: calculate autocorrelation up to 50th lag\nacf_fun <- function(series, ...) {\n lapply(series, function(x) {\n as.numeric(acf(x, lag.max = 50, plot = FALSE)$acf)\n })\n}\n\n# Define overall configuration\ncf <- compare_clusterings_configs(\n types = c(\"p\", \"h\", \"f\", \"t\"),\n k = 19L:20L,\n controls = list(\n partitional = partitional_control(\n iter.max = 30L,\n nrep = 1L\n ),\n hierarchical = hierarchical_control(\n method = \"all\"\n ),\n fuzzy = fuzzy_control(\n # notice the vector\n fuzziness = c(2, 2.5),\n iter.max = 30L\n ),\n tadpole = tadpole_control(\n # notice the vectors\n dc = c(1.5, 2),\n window.size = 19L:20L\n )\n ),\n preprocs = pdc_configs(\n type = \"preproc\",\n # shared\n none = list(),\n zscore = list(center = c(FALSE)),\n # only for fuzzy\n fuzzy = list(\n acf_fun = list()\n ),\n # only for tadpole\n tadpole = list(\n reinterpolate = list(new.length = 205L)\n ),\n # specify which should consider the shared ones\n share.config = c(\"p\", \"h\")\n ),\n distances = pdc_configs(\n type = \"distance\",\n sbd = list(),\n fuzzy = list(\n L2 = list()\n )\n )}\ncompare_clusterings\n\n),\nshare.config = c(\"p\", \"h\")\n),\ncentroids = pdc_configs(\n type = \"centroid\",\n partitional = list(\n pam = list()\n ),\n # special name 'default'\n hierarchical = list(\n default = list()\n ),\n fuzzy = list(\n fcmd = list()\n ),\n tadpole = list(\n default = list(),\n shape_extraction = list(znorm = TRUE)\n )\n)\n\n# Number of configurations is returned as attribute\nnum_configs <- sapply(cfgs, attr, which = \"num.configs\")\ncat(\"\\nTotal number of configurations without considering optimizations: \",\n sum(num_configs),\n \"\\n\")\n\n# Define evaluation functions based on CVI: Variation of Information (only crisp partition)\nvi_evaluators <- cvi_evaluators(\"VI\", ground.truth = CharTrajLabels)\nscore_fun <- vi_evaluators$score\npick_fun <- vi_evaluators$pick\n\n# Short run with only fuzzy clustering\n# comparison_short <- compare_clusterings(CharTraj, types = c(\"f\"), configs = cfgs,\n# seed = 293L, trace = TRUE,\n# score.clus = score_fun, pick.clus = pick_fun,\n# return.objects = TRUE)\n\n## Not run:\n# Parallel run with all comparisons\n# require(doParallel)\n# registerDoParallel(cl <- makeCluster(detectCores()))\n\ncomparison_long <- compare_clusterings(CharTraj, types = c(\"p\", \"h\", \"f\", \"t\"),\n configs = cfgs,\n seed = 293L, trace = TRUE,\n```r\nscore.clus = score_fun,\npick.clus = pick_fun,\nreturn.objects = TRUE)\n\n# Using all external CVIs and majority vote\nexternal_evaluators <- cvi_evaluators(\"external\", ground.truth = CharTrajLabels)\nscore_external <- external_evaluators$score\npick_majority <- external_evaluators$pick\n\ncomparison_majority <- compare_clusterings(CharTraj, types = c(\"p\", \"h\", \"f\", \"t\"),\n configs = cfgs,\n seed = 84L, trace = TRUE,\n score.clus = score_external,\npick.clus = pick_majority,\nreturn.objects = TRUE)\n\n# best results\nplot(comparison_majority$pick$object)\nprint(comparison_majority$pick$config)\nstopCluster(cl); registerDoSEQ()\n\n# A run with only partitional clusterings\n\np_cfgs <- compare_clusterings_configs(\n types = \"p\", k = 19L:21L,\n controls = list(\n partitional = partitional_control(\n iter.max = 20L,\n nrep = 8L\n )\n ),\n preprocs = pdc_configs(\"preproc\",\n none = list(),\n zscore = list(center = c(FALSE, TRUE))\n ),\n distances = pdc_configs(\"distance\",\n sbd = list(),\n dtw_basic = list(window.size = 19L:20L,\n norm = c(\"L1\", \"L2\")),\n gak = list(window.size = 19L:20L,\n sigma = 100)\n ),\n centroids = pdc_configs(\"centroid\",\n partitional = list(\n pam = list(),\n shape = list()\n )\n )\n)\ncompare_clusterings_configs\n\nCreate clustering configurations.\n\nDescription\n\nCreate configurations for `compare_clusterings()`\n\nUsage\n\n```r\ncompare_clusterings_configs(types = c(\"p\", \"h\", \"f\"), k = 2L,\ncontrols = NULL, preprocs = pdc_configs(\"preproc\", none = list()),\ndistances = pdc_configs(\"distance\", dtw_basic = list()),\ncentroids = pdc_configs(\"centroid\", default = list()),\nno.expand = character(0L))\n```\n\nArguments\n\n- **types**: Clustering types. It must be any combination of (possibly abbreviated): partitional, hierarchical, fuzzy, tadpole.\n- **k**: A numeric vector with one or more elements specifying the number of clusters to test.\n- **controls**: A named list of `tsclust-controls`. NULL means defaults. See details.\n- **preprocs**: Preprocessing configurations. See details.\n- **distances**: Distance configurations. See details.\n- **centroids**: Centroid configurations. See details.\n- **no.expand**: A character vector indicating parameters that should not be expanded between `pdc_configs()` configurations. See examples.\nDetails\n\nPreprocessing, distance and centroid configurations are specified with the helper function `pdc_configs()`, refer to the examples in `compare_clusterings()` to see how this is used.\n\nThe controls list may be specified with the usual `tsclust-controls` functions. The names of the list must correspond to \"partitional\", \"hierarchical\", \"fuzzy\" or \"tadpole\" clustering. Again, please refer to the examples in `compare_clusterings()`.\n\nValue\n\nA list for each clustering type, each of which includes a data frame with the computed and merged configurations. Each data frame has an extra attribute `num.configs` specifying the number of configurations.\n\nExamples\n\n```r\n# compare this with leaving no.expand empty\ncompare_clusterings_configs(\n distances = pdc_configs(\"d\", dtw_basic = list(window.size = 1L:2L, norm = c(\"L1\", \"L2\"))),\n centroids = pdc_configs(\"c\", dba = list(window.size = 1L:2L, norm = c(\"L1\", \"L2\"))),\n no.expand = c(\"window.size\", \"norm\")\n)\n```\n\n---\n\n**compute_envelope**\n\n*Time series warping envelopes*\n\n**Description**\n\nThis function computes the envelopes for DTW lower bound calculations with a Sakoe-Chiba band for a given univariate time series using the streaming algorithm proposed by Lemire (2009).\n\n**Usage**\n\n```r\ncompute_envelope(x, window.size, error.check = TRUE)\n```\n\n**Arguments**\n\n- `x`: A univariate time series.\n- `window.size`: Window size for envelope calculation. See details.\n- `error.check`: Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\nDetails\n\nThe windowing constraint uses a centered window. The calculations expect a value in window.size that represents the distance between the point considered and one of the edges of the window. Therefore, if, for example, window.size = 10, the warping for an observation \\(x_i\\) considers the points between \\(x_{i-10}\\) and \\(x_{i+10}\\), resulting in \\(10(2) + 1 = 21\\) observations falling within the window.\n\nValue\n\nA list with two elements (lower and upper envelopes respectively): lower and upper.\n\nNote\n\nThis envelope is calculated assuming a Sakoe-Chiba constraint for DTW.\n\nReferences\n\n\nExamples\n\ndata(uciCT)\n\n\\[\nH <- \\text{compute_envelope(CharTraj[[1L]], 18L)}\n\\]\n\nmatplot(do.call(cbind, H), type = \"l\", col = 2:3)\nlines(CharTraj[[1L]])\n\n---\n\n**cvi**\n\n*Cluster validity indices*\n\nDescription\n\nCompute different cluster validity indices (CVIs) of a given cluster partition, using the clustering distance measure and centroid function if applicable.\n\nUsage\n\n```r\ncvi(a, b = NULL, type = \"valid\", ..., log.base = 10)\n```\n\n## S4 method for signature 'matrix'\n```r\ncvi(a, b = NULL, type = \"valid\", ..., log.base = 10)\n```\n## Arguments\n\na \nAn object returned by `tsclust()`, for crisp partitions a vector that can be coerced to integers which indicate the cluster memberships, or the membership matrix for soft clustering.\n\nb \nIf needed, a vector that can be coerced to integers which indicate the cluster memberships. The ground truth (if known) should be provided here.\n\ntype \nCharacter vector indicating which indices are to be computed. See supported values below.\n\n... \nArguments to pass to and from other methods.\n\nlog.base \nBase of the logarithm to be used in the calculation of VI (see details).\n\n## Details\n\nClustering is commonly considered to be an unsupervised procedure, so evaluating its performance can be rather subjective. However, a great amount of effort has been invested in trying to standardize cluster evaluation metrics by using cluster validity indices (CVIs).\n\nIn general, CVIs can be either tailored to crisp or fuzzy partitions. CVIs can be classified as internal, external or relative depending on how they are computed. Focusing on the first two, the crucial difference is that internal CVIs only consider the partitioned data and try to define a measure of cluster purity, whereas external CVIs compare the obtained partition to the correct one. Thus, external CVIs can only be used if the ground truth is known.\n\nNote that even though a fuzzy partition can be changed into a crisp one, making it compatible with many of the existing crisp CVIs, there are also fuzzy CVIs tailored specifically to fuzzy clustering, and these may be more suitable in those situations. Fuzzy partitions usually have no ground truth associated with them, but there are exceptions depending on the task’s goal.\n\nEach index defines their range of values and whether they are to be minimized or maximized. In many cases, these CVIs can be used to evaluate the result of a clustering algorithm regardless of how the clustering works internally, or how the partition came to be.\n\nKnowing which CVI will work best cannot be determined a priori, so they should be tested for each specific application. Usually, many CVIs are utilized and compared to each other, maybe using a majority vote to decide on a final result. Furthermore, it should be noted that many CVIs perform additional distance calculations when being computed, which can be very considerable if using DTW or GAK.\nValue\n\nThe chosen CVIs\n\nExternal CVIs\n\n- Crisp partitions (the first 4 are calculated via `flexclust::comPart()`)\n - \"RI\": Rand Index (to be maximized).\n - \"ARI\": Adjusted Rand Index (to be maximized).\n - \"J\": Jaccard Index (to be maximized).\n - \"FM\": Fowlkes-Mallows (to be maximized).\n - \"VI\": Variation of Information (Meila (2003); to be minimized).\n- Fuzzy partitions (based on Lei et al. (2017))\n - \"RI\": Soft Rand Index (to be maximized).\n - \"ARI\": Soft Adjusted Rand Index (to be maximized).\n - \"VI\": Soft Variation of Information (to be minimized).\n - \"NMIM\": Soft Normalized Mutual Information based on Max entropy (to be maximized).\n\nInternal CVIs\n\nThe indices marked with an exclamation mark (!) calculate (or re-use if already available) the whole distance matrix between the series in the data. If you were trying to avoid this in the first place, then these CVIs might not be suitable for your application.\n\nThe indices marked with a question mark (?) depend on the extracted centroids, so bear that in mind if a hierarchical procedure was used and/or the centroid function has associated randomness (such as `shape_extraction()` with series of different length).\n\nThe indices marked with a tilde (~) require the calculation of a global centroid. Since `DBA()` and `shape_extraction()` (for series of different length) have some randomness associated, these indices might not be appropriate for those centroids.\n\n- Crisp partitions\n - \"Sil\" (!): Silhouette index (Rousseeuw (1987); to be maximized).\n - \"D\" (!): Dunn index (Arbelaitz et al. (2013); to be maximized).\n - \"COP\" (!): COP index (Arbelaitz et al. (2013); to be minimized).\n - \"DB\" (?): Davies-Bouldin index (Arbelaitz et al. (2013); to be minimized).\n - \"DBstar\" (?): Modified Davies-Bouldin index (DB*) (Kim and Ramakrishna (2005); to be minimized).\n - \"CH\" (~): Calinski-Harabasz index (Arbelaitz et al. (2013); to be maximized).\n - \"SF\" (~): Score Function (Saitta et al. (2007); to be maximized; see notes).\n- Fuzzy partitions (using the nomenclature from Wang and Zhang (2007))\n - \"MPC\": to be maximized.\n - \"K\" (~): to be minimized.\n - \"T\": to be minimized.\n - \"SC\" (~): to be maximized.\n - \"PBMF\" (~): to be maximized (see notes).\nAdditionally\n\n- \"valid\": Returns all valid indices depending on the type of a and whether b was provided or not.\n- \"internal\": Returns all internal CVIs. Only supported for TSClusters objects.\n- \"external\": Returns all external CVIs. Requires b to be provided.\n\nNote\n\nIn the original definition of many internal and fuzzy CVIs, the Euclidean distance and a mean centroid was used. **The implementations here change this, making use of whatever distance/centroid was chosen during clustering.** However, some of the CVIs assume that the distances are symmetric, since cross-distance matrices are calculated and only the upper/lower triangulars are considered. A warning will be given if the matrices are not symmetric and the CVI assumes so.\n\nBecause of the above, calculating CVIs for clusterings made with TADPole() is a special case. Since TADPole uses 3 distances during its execution (DTW, LB Keogh and Euclidean), it is not obvious which one should be used for the calculation of CVIs. Nevertheless, dtw_basic() is used by default.\n\nThe formula for the SF index in Saitta et al. (2007) does not correspond to the one in Arbelaitz et al. (2013). The one specified in the former is used here.\n\nThe formulas for the Silhouette index are not entirely correct in Arbelaitz et al. (2013), refer to Rousseeuw (1987) for the correct ones.\n\nThe formulas for the PBMF index are not entirely unambiguous in the literature, the ones given in Lin (2013) are used here.\n\nReferences\n\n\ncvi_evaluators\n\nExamples\n\ncvi(CharTrajLabels, sample(CharTrajLabels), type = c(\"ARI\", \"VI\"))\n\ncvi_evaluators Cluster comparison based on CVIs\n\nDescription\n\nCreate evaluation functions for `compare_clusterings()`.\n\nUsage\n\ncvi_evaluators(type = \"valid\", fuzzy = FALSE, ground.truth = NULL)\n\nArguments\n\ntype A character vector with options supported by `cvi()`.\nfuzzy Logical indicating whether to use fuzzy CVIs or not.\nground.truth A vector that can be coerced to integers used for the calculation of external CVIs (passed as b to `cvi()`).\n\nDetails\n\nThink of this as a factory for `compare_clusterings()` that creates functions that can be passed as its `score.clus` and `pick.clus` arguments. It is somewhat limited in scope because it depends on the cluster validity indices available in `cvi()` for scoring and performs majority voting for picking. They always assume that no errors occurred.\n\nThe scoring function takes the CVIs that are to be minimized and \"inverts\" them by taking their reciprocal so that maximization can be considered. Its ellipsis (\\ldots) is passed to `cvi()`.\n\nThe picking function returns the best configuration if `return.objects` is `FALSE`, or a list with the chosen TSClusters object and the corresponding configuration otherwise.\n\nRefer to the examples in `compare_clusterings()`.\n\nValue\n\nA list with two functions: score and pick.\nDescription\n\nA global averaging method for time series under DTW (Petitjean, Ketterlin and Gancarski 2011).\n\nUsage\n\nDBA(X, centroid = NULL, ..., window.size = NULL, norm = \"L1\",\nmax.iter = 20L, delta = 0.001, error.check = TRUE, trace = FALSE,\nmv.ver = \"by-variable\")\n\ndba(X, centroid = NULL, ..., window.size = NULL, norm = \"L1\",\nmax.iter = 20L, delta = 0.001, error.check = TRUE, trace = FALSE,\nmv.ver = \"by-variable\")\n\nArguments\n\nX\nA matrix or data frame where each row is a time series, or a list where each element is a time series. Multivariate series should be provided as a list of matrices where time spans the rows and the variables span the columns of each matrix.\n\ncentroid\nOptionally, a time series to use as reference. Defaults to a random series of X if NULL. For multivariate series, this should be a matrix with the same characteristics as the matrices in X.\n\n...\nFurther arguments for dtw_basic(). However, the following are already pre-specified: window.size, norm (passed along), and backtrack.\n\nwindow.size\nWindow constraint for the DTW calculations. NULL means no constraint. A slanted band is used.\n\nnorm\nNorm for the local cost matrix of DTW. Either \"L1\" for Manhattan distance or \"L2\" for Euclidean distance.\n\nmax.iter\nMaximum number of iterations allowed.\n\ndelta\nAt iteration i, if all(abs(centroid_{i} - centroid_{i-1}) < delta), convergence is assumed.\n\nerror.check\nLogical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\ntrace\nIf TRUE, the current iteration is printed to output.\n\nmv.ver\nMultivariate version to use. See below.\nDetails\n\nThis function tries to find the optimum average series between a group of time series in DTW space. Refer to the cited article for specific details on the algorithm.\n\nIf a given series reference is provided in centroid, the algorithm should always converge to the same result provided the elements of X keep the same values, although their order may change.\n\nThe windowing constraint uses a centered window. The calculations expect a value in window.size that represents the distance between the point considered and one of the edges of the window. Therefore, if, for example, window.size = 10, the warping for an observation \\( x_i \\) considers the points between \\( x_{i-10} \\) and \\( x_{i+10} \\), resulting in \\( 10(2) + 1 = 21 \\) observations falling within the window.\n\nValue\n\nThe average time series.\n\nParallel Computing\n\nPlease note that running tasks in parallel does not guarantee faster computations. The overhead introduced is sometimes too large, and it’s better to run tasks sequentially.\n\nThis function uses the RcppParallel package for parallelization. It uses all available threads by default (see RcppParallel::defaultNumThreads()), but this can be changed by the user with RcppParallel::setThreadOptions().\n\nAn exception to the above is when this function is called within a foreach parallel loop made by dtwclust. If the parallel workers do not have the number of threads explicitly specified, this function will default to 1 thread per worker. See the parallelization vignette for more information (browseVignettes(\"dtwclust\")).\n\nThis function appears to be very sensitive to numerical inaccuracies if multi-threading is used in a 32 bit installation. In such systems, consider limiting calculations to 1 thread.\n\nMultivariate series\n\nThere are currently 2 versions of DBA implemented for multivariate series (see examples):\n\n- If multivariate = \"by-variable\", then each variable of each series in X and centroid are extracted, and the univariate version of the algorithm is applied to each set of variables, binding the results by column. Therefore, the DTW backtracking is different for each variable.\n\n- If multivariate = \"by-series\", then all variables are considered at the same time, so the DTW backtracking is computed based on each multivariate series as a whole. This version was implemented in version 4.0.0 of dtwclust, and it is faster, but not necessarily more correct.\n\nNote\n\nThe indices of the DTW alignment are obtained by calling dtw_basic() with backtrack = TRUE.\nReferences\n\n\nExamples\n\n```r\n# Sample data\ndata(uciCT)\n\n# Obtain an average for the first 5 time series\ndtw_avg <- DBA(CharTraj[1:5], CharTraj[[1]], trace = TRUE)\n\n# Plot\nmatplot(do.call(cbind, CharTraj[1:5]), type = \"l\")\npoints(dtw_avg)\n\n# Change the provided order\ndtw_avg2 <- DBA(CharTraj[5:1], CharTraj[[1]], trace = TRUE)\n\n# Same result?\nall.equal(dtw_avg, dtw_avg2)\n\n## Not run:\n## ================\n## Multivariate versions\n## ================\n\n# sample centroid reference\ncent <- CharTrajMV[[3L]]\n# sample series\nx <- CharTrajMV[[1L]]\n# sample set of series\nX <- CharTrajMV[[1L:5L]]\n\n# the by-series version does something like this for each series and the centroid\nalignment <- dtw_basic(x, cent, backtrack = TRUE)\n# alignment$index1 and alignment$index2 indicate how to map x to cent (row-wise)\n\n# the by-variable version treats each variable separately\nalignment1 <- dtw_basic(x[,1L], cent[,1L], backtrack = TRUE)\nalignment2 <- dtw_basic(x[,2L], cent[,2L], backtrack = TRUE)\nalignment3 <- dtw_basic(x[,3L], cent[,3L], backtrack = TRUE)\n\n# effectively doing:\nX1 <- lapply(X, function(x) { x[,1L] })\nX2 <- lapply(X, function(x) { x[,2L] })\nX3 <- lapply(X, function(x) { x[,3L] })\n\ndba1 <- dba(X1, cent[,1L])\ndba2 <- dba(X2, cent[,2L])\n```\ndtw2 <- dba(X3, cent[,3L])\n\nnew_cent <- cbind(dba1, dba2, dba3)\n\n# sanity check\nnewer_cent <- dba(X, cent, mv.ver = \"by-variable\")\nall.equal(newer_cent, new_cent, check.attributes = FALSE) # ignore names\n\n# End(Not run)\n\n---\n\n**Description**\n\nWrapper for the `dtw::dtw()` function using L2 norm for both the local cost matrix (LCM) creation as well as the final cost aggregation step.\n\n**Usage**\n\n```r\ndtw2(x, y, ...)\n```\n\n**Arguments**\n\n- `x, y` A time series. A multivariate series should have time spanning the rows and variables spanning the columns.\n- `...` Further arguments for `dtw::dtw()`.\n\n**Details**\n\nThe L-norms are used in two different steps by the DTW algorithm. First when creating the LCM, where the element $(i, j)$ of the matrix is computed as the L-norm of $x_i^v - y_j^v$ for all variables $v$. Note that this means that, in case of multivariate series, they must have the same number of variables, and that univariate series will produce the same LCM regardless of the L-norm used. After the warping path is found by DTW, the final distance is calculated as the L-norm of all $(i, j)$ elements of the LCM that fall on the warping path.\n\nThe `dtw::dtw()` function allows changing the norm by means of its `dist.method` parameter, but it only uses it when creating the LCM, and not when calculating the final aggregated cost, i.e. the DTW distance.\n\nThis wrapper simply returns the appropriate DTW distance using L2 norm (Euclidean norm). A `proxy::dist()` version is also registered.\n\nThe windowing constraint uses a centered window. The calculations expect a value in `window.size` that represents the distance between the point considered and one of the edges of the window. Therefore, if, for example, `window.size = 10`, the warping for an observation $x_i$ considers the points between $x_{i-10}$ and $x_{i+10}$, resulting in $10(2) + 1 = 21$ observations falling within the window.\nValue\n\nAn object of class dtw.\n\n__dtwclustTimings Results of timing experiments__\n\nDescription\n\nThis is the list with data frames containing the results of the timing experiments vignette included with `dtwclust`. See `browseVignettes(\"dtwclust\")`.\n\nFormat\n\nThe results are organized into different data frames and saved in one list with nested lists. For more details, refer to the included vignette or the scripts available at [https://github.com/asardaes/dtwclust/tree/master/timing-experiments](https://github.com/asardaes/dtwclust/tree/master/timing-experiments).\n\nSource\n\nRefer to the timing experiments vignette.\n\n__dtw_basic Basic DTW distance__\n\nDescription\n\nThis is a custom implementation of the DTW algorithm without all the functionality included in `dtw::dtw()`. Because of that, it should be faster, while still supporting the most common options.\n\nUsage\n\n```r\ndtw_basic(x, y, window.size = NULL, norm = \"L1\", step.pattern = dtw::symmetric2, backtrack = FALSE, normalize = FALSE, ..., error.check = TRUE)\n```\n\nArguments\n\n- `x, y` Time series. Multivariate series must have time spanning the rows and variables spanning the columns.\n- `window.size` Size for slanted band window. NULL means no constraint.\n- `norm` Norm for the DTW calculation, \"L1\" for Manhattan or \"L2\" for Euclidean.\n- `step.pattern` Step pattern for DTW. Only symmetric1 or symmetric2 supported here. Note that these are not characters. See `dtw::stepPattern`.\n- `backtrack` Also compute the warping path between series? See details.\n**dtw_basic**\n\nnormalize Should the distance be normalized? Only supported for symmetric2.\n\n... Currently ignored.\n\nerror.check Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\n**Details**\n\nIf backtrack is TRUE, the mapping of indices between series is returned in a list.\n\nThe windowing constraint uses a centered window. The calculations expect a value in window.size that represents the distance between the point considered and one of the edges of the window. Therefore, if, for example, window.size = 10, the warping for an observation \\(x_i\\) considers the points between \\(x_{i-10}\\) and \\(x_{i+10}\\), resulting in \\(10(2) + 1 = 21\\) observations falling within the window.\n\n**Value**\n\nThe DTW distance. For backtrack = TRUE, a list with:\n\n- distance: The DTW distance.\n- index1: x indices for the matched elements in the warping path.\n- index2: y indices for the matched elements in the warping path.\n\n**Proxy version**\n\nThe version registered with `dist` is custom (`loop = FALSE` in `pr_DB`). The custom function handles multi-threaded parallelization directly (with `RcppParallel`). It uses all available threads by default (see `RcppParallel::defaultNumThreads()`), but this can be changed by the user with `RcppParallel::setThreadOptions()`.\n\nAn exception to the above is when it is called within a `foreach` parallel loop made by `dtwclust`. If the parallel workers do not have the number of threads explicitly specified, this function will default to 1 thread per worker. See the parallelization vignette for more information (browseVignettes(\"dtwclust\").\n\nIt also includes symmetric optimizations to calculate only half a distance matrix when appropriate—only one list of series should be provided in x. If you want to avoid this optimization, call `dist` by giving the same list of series in both x and y.\n\nIn order for symmetry to apply here, the following must be true: no window constraint is used (window.size is NULL) or, if one is used, all series have the same length.\n\n**Note**\n\nThe DTW algorithm (and the functions that depend on it) might return different values in 32 bit installations compared to 64 bit ones.\n\nAn infinite distance value indicates that the constraints could not be fulfilled, probably due to a too small window.size or a very large length difference between the series.\nExamples\n\n```r\n## Not run:\n#\n# Understanding multivariate DTW\n#\n#\n# The variables for each multivariate time series are:\n# tip force, x velocity, and y velocity\nA1 <- CharTrajMV[['1L']] # A character\nB1 <- CharTrajMV[['6L']] # B character\n\n# Let's extract univariate time series\nA1_TipForce <- A1[,1L] # first variable (column)\nA1_VelX <- A1[,2L] # second variable (column)\nA1_VelY <- A1[,3L] # third variable (column)\nB1_TipForce <- B1[,1L] # first variable (column)\nB1_VelX <- B1[,2L] # second variable (column)\nB1_VelY <- B1[,3L] # third variable (column)\n\n# Looking at each variable independently:\n\n# Just force\ndtw_basic(A1_TipForce, B1_TipForce, norm = \"L1\", step.pattern = symmetric)\n# Corresponding LCM\nproxy::dist(A1_TipForce, B1_TipForce, method = \"L1\")\n\n# Just x velocity\ndtw_basic(A1_VelX, B1_VelX, norm = \"L1\", step.pattern = symmetric)\n# Corresponding LCM\nproxy::dist(A1_VelX, B1_VelX, method = \"L1\")\n\n# Just y velocity\ndtw_basic(A1_VelY, B1_VelY, norm = \"L1\", step.pattern = symmetric)\n# Corresponding LCM\nproxy::dist(A1_VelY, B1_VelY, method = \"L1\")\n\n# NOTES:\n# In the previous examples there was one LCM for each *pair* of series.\n# Additionally, each LCM has dimensions length(A1_*) x length(B1_*)\n\n# proxy::dist won't return the LCM for multivariate series,\n# but we can do it manually:\nmv_lcm <- function(mvts1, mvts2) {\n # Notice how the number of variables (columns) doesn't come into play here\n num_obs1 <- nrow(mvts1)\n num_obs2 <- nrow(mvts2)\n\n lcm <- matrix(0, nrow = num_obs1, ncol = num_obs2)\n\n for (i in 1L:num_obs1) {\n for (j in 1L:num_obs2) {\n # L1 norm for ALL variables (columns).\n }\n }\n}\n```\n# Consideration: mvts1 and mvts2 MUST have the same number of variables\nlcm[i, j] <- sum(abs(mvts1[i,] - mvts2[j,]))\n#\n#\n# return\nlcm\n#\n# Let's say we start with only x velocity and y velocity for each character\nmvts1 <- cbind(A1_VelX, A1_VelY)\nmvts2 <- cbind(B1_VelX, B1_VelY)\n\n# DTW distance\ndtw_d <- dtw_basic(mvts1, mvts2, norm = \"L1\", step.pattern = symmetric)\n# Corresponding LCM\nlcm <- mv_lcm(mvts1, mvts2) # still 178 x 174\n# Sanity check\nall.equal(\n dtw_d,\n dtw::dtw(lcm, step.pattern = symmetric)$distance # supports LCM as input\n)\n\n# Now let's consider all variables for each character\nmvts1 <- cbind(mvts1, A1_TipForce)\nmvts2 <- cbind(mvts2, B1_TipForce)\n\n# Notice how the next code is exactly the same as before,\n# even though we have one extra variable now\n\n# DTW distance\ndtw_d <- dtw_basic(mvts1, mvts2, norm = \"L1\", step.pattern = symmetric)\n# Corresponding LCM\nlcm <- mv_lcm(mvts1, mvts2) # still 178 x 174\n# Sanity check\nall.equal(\n dtw_d,\n dtw::dtw(lcm, step.pattern = symmetric)$distance # supports LCM as input\n)\n\n# By putting things in a list,\n# proxy::dist returns the *cross-distance matrix*, not the LCM\nseries_list <- list(mvts1, mvts2)\ndistmat <- proxy::dist(series_list, method = \"dtw_basic\",\n norm = \"L1\", step.pattern = symmetric)\n# So this should be TRUE\nall.equal(distmat[1L, 2L], dtw_d)\n\n# NOTE: distmat is a 2 x 2 matrix, because there are 2 multivariate series.\n# Each *cell* in distmat has a corresponding LCM (not returned by the function).\n# Proof:\nmanual_distmat <- matrix(0, nrow = 2L, ncol = 2L)\nfor (i in 1L:nrow(manual_distmat)) {\nfor (j in 1L:ncol(manual_distmat)) {\n lcm_cell <- mv.lcm(series_list[[i]], series_list[[j]]) # LCM for this pair\n manual_distmat[i, j] <- dtw::dtw(lcm_cell, step.pattern = symmetric)$distance\n}\n#\n# TRUE\nall.equal( \nas.matrix(distmat),\n manual_distmat\n)\n\n## End(Not run)\n\n---\n\n**dtw_lb**\n\n*DTW distance matrix guided by Lemire's improved lower bound*\n\n---\n\n**Description**\n\nCalculation of a distance matrix with the Dynamic Time Warping (DTW) distance guided by Lemire’s improved lower bound (LB_Improved).\n\n**Usage**\n\ndtw_lb(x, y = NULL, window.size = NULL, norm = \"L1\",\n error.check = TRUE, pairwise = FALSE, dtw.func = \"dtw_basic\",\n nn.margin = 1L, ...)\n\n**Arguments**\n\n- **x, y**\n - A matrix or data frame where rows are time series, or a list of time series.\n- **window.size**\n - Window size to use with the LB and DTW calculation. See details.\n- **norm**\n - Either \"L1\" for Manhattan distance or \"L2\" for Euclidean.\n- **error.check**\n - Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n- **pairwise**\n - Calculate pairwise distances?\n- **dtw.func**\n - Which function to use for the core DTW calculations, either \"dtw\" or \"dtw_basic\". See `dtw::dtw()` and `dtw_basic()`.\n- **nn.margin**\n - Either 1 to search for nearest neighbors row-wise, or 2 to search column-wise. Only implemented for `dtw.func = \"dtw_basic\"`.\n- **...**\n - Further arguments for `dtw.func` or `lb_improved()`.\nDetails\n\nThis function first calculates an initial estimate of a distance matrix between two sets of time series using lb_improved() (the proxy::dist() version). Afterwards, it uses the estimate to calculate the corresponding true DTW distance between only the nearest neighbors of each series in \\(x\\) found in \\(y\\), and it continues iteratively until no changes in the nearest neighbors occur.\n\nIf only \\(x\\) is provided, the distance matrix is calculated between all its time series, effectively returning a matrix filled with the LB_Improved values.\n\nThis could be useful in case one is interested in only the nearest neighbor of one or more series within a dataset.\n\nThe windowing constraint uses a centered window. The calculations expect a value in window.size that represents the distance between the point considered and one of the edges of the window. Therefore, if, for example, window.size = 10, the warping for an observation \\(x_i\\) considers the points between \\(x_{i-10}\\) and \\(x_{i+10}\\), resulting in \\(10(2) + 1 = 21\\) observations falling within the window.\n\nValue\n\nThe distance matrix with class crossdist.\n\nParallel Computing\n\nPlease note that running tasks in parallel does not guarantee faster computations. The overhead introduced is sometimes too large, and it’s better to run tasks sequentially.\n\nThis function uses the RcppParallel package for parallelization. It uses all available threads by default (see RcppParallel::defaultNumThreads()), but this can be changed by the user with RcppParallel::setThreadOptions().\n\nAn exception to the above is when this function is called within a foreach parallel loop made by dtwclust. If the parallel workers do not have the number of threads explicitly specified, this function will default to 1 thread per worker. See the parallelization vignette for more information (browseVignettes(\"dtwclust\").)\n\nNote\n\nThis function uses a lower bound that is only defined for time series of equal length.\n\nThe proxy::dist() version simply calls this function.\n\nA considerably large dataset is probably necessary before this is faster than using dtw_basic() with proxy::dist(). Also note that lb_improved() calculates warping envelopes for the series in \\(y\\), so be careful with the provided order and \\(nn.margin\\) (see examples).\n\nAuthor(s)\n\nAlexis Sarda-Espinosa\nReferences\n\n\nSee Also\n\n`lb_keogh()`, `lb_improved()`\n\nExamples\n\n```r\n# Load data\ndata(uciCT)\n\n# Reinterpolate to same length\ndata <- reinterpolate(CharTraj, new.length = max(lengths(CharTraj)))\n\n# Calculate the DTW distance between a certain subset aided with the lower bound\nsystem.time(d <- dtw_lb(data[1:5], data[6:50], window.size = 20L))\n\n# Nearest neighbors\nNN1 <- apply(d, 1L, which.min)\n\n# Calculate the DTW distances between all elements (slower)\nsystem.time(d2 <- proxy::dist(data[1:5], data[6:50], method = \"DTW\",\n window.type = \"sakoechiba\", window.size = 20L))\n\n# Nearest neighbors\nNN2 <- apply(d2, 1L, which.min)\n\n# Calculate the DTW distances between all elements using dtw_basic\n# (might be faster, see notes)\nsystem.time(d3 <- proxy::dist(data[1:5], data[6:50], method = \"DTW_BASIC\",\n window.size = 20L))\n\n# Nearest neighbors\nNN3 <- apply(d3, 1L, which.min)\n\n# Change order and margin for nearest neighbor search\n# (usually fastest, see notes)\nsystem.time(d4 <- dtw_lb(data[6:50], data[1:5],\n window.size = 20L, nn.margin = 2L))\n\n# Nearest neighbors *column-wise*\nNN4 <- apply(d4, 2L, which.min)\n\n# Same results?\nidentical(NN1, NN2)\nidentical(NN1, NN3)\nidentical(NN1, NN4)\n```\nDescription\n\nDistance based on (triangular) global alignment kernels.\n\nUsage\n\n\\[\n\\text{GAK}(x, y, ..., \\text{sigma} = \\text{NULL}, \\text{window.size} = \\text{NULL}, \\text{normalize} = \\text{TRUE}, \\\\\n\\text{error.check} = \\text{TRUE})\n\\]\n\n\\[\n\\text{gak}(x, y, ..., \\text{sigma} = \\text{NULL}, \\text{window.size} = \\text{NULL}, \\text{normalize} = \\text{TRUE}, \\\\\n\\text{error.check} = \\text{TRUE})\n\\]\n\nArguments\n\n- **x**, **y** Time series. A multivariate series should have time spanning the rows and variables spanning the columns.\n- **...** Currently ignored.\n- **sigma** Parameter for the Gaussian kernel’s width. See details for the interpretation of NULL.\n- **window.size** Parameterization of the constraining band ($T$ in Cuturi (2011)). See details.\n- **normalize** Normalize the result by considering diagonal terms.\n- **error.check** Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\nDetails\n\nThis function uses the Triangular Global Alignment Kernel (TGAK) described in Cuturi (2011). It supports series of different length and multivariate series, so long as the ratio of the series’ lengths doesn’t differ by more than 2 (or less than 0.5).\n\nThe **window.size** parameter is similar to the one used in DTW, so NULL signifies no constraint, and its value should be greater than 1 if used with series of different length.\n\nThe Gaussian kernel is parameterized by **sigma**. Providing NULL means that the value will be estimated by using the strategy mentioned in Cuturi (2011) with a constant of 1. This estimation is subject to randomness, so consider estimating the value once and re-using it (the estimate is returned as an attribute of the result). See the examples.\n\nFor more information, refer to the package vignette and the referenced article.\n\nValue\n\nThe logarithm of the GAK if **normalize** = FALSE, otherwise 1 minus the normalized GAK. The value of **sigma** is assigned as an attribute of the result.\nProxy version\n\nThe version registered with `dist` is custom (loop = FALSE in `pr_DB`). The custom function handles multi-threaded parallelization directly (with `RcppParallel`). It uses all available threads by default (see `RcppParallel::defaultNumThreads()`), but this can be changed by the user with `RcppParallel::setThreadOptions()`.\n\nAn exception to the above is when it is called within a `foreach` parallel loop made by `dwtclust`. If the parallel workers do not have the number of threads explicitly specified, this function will default to 1 thread per worker. See the parallelization vignette for more information (browseVignettes(\"dwtclust\")).\n\nIt also includes symmetric optimizations to calculate only half a distance matrix when appropriate—only one list of series should be provided in `x`. If you want to avoid this optimization, call `dist` by giving the same list of series in both `x` and `y`.\n\nNote\n\nThe estimation of sigma does not depend on window.size.\n\nIf `normalize` is set to FALSE, the returned value is not a distance, rather a similarity. The `proxy::dist()` version is thus always normalized. Use `proxy::simil()` with method set to \"uGAK\" if you want the unnormalized similarities.\n\nA constrained unnormalized calculation (i.e. with `window.size > 0` and `normalize = FALSE`) will return negative infinity if `abs(NROW(x) - NROW(y)) > window.size`. Since the function won’t perform calculations in that case, it might be faster, but if this behavior is not desired, consider reinterpolating the time series (see `reinterpolate()`) or increasing the window size.\n\nReferences\n\n\nExamples\n\n```r\n## Not run:\ndata(uciCT)\nset.seed(832)\nGAKd <- proxy::dist(zscore(CharTraj), method = \"gak\",\n pairwise = TRUE, window.size = 18L)\n\n# Obtained estimate of sigma\nsigma <- attr(GAKd, \"sigma\")\n\n# Use value for clustering\ntsclust(CharTraj, k = 20L,\n distance = \"gak\", centroid = \"shape\",\n trace = TRUE,\n args = tsclust_args(dist = list(sigma = sigma,\n window.size = 18L)))\n```\n\n## End(Not run)\nA shiny app for interactive clustering\n\nDescription\n\nDisplay a shiny user interface to do clustering based on the provided series.\n\nUsage\n\ninteractive_clustering(series, ...)\n\nArguments\n\nseries Time series in the formats accepted by tsclust().\n...\n\nMore arguments for shiny::runApp().\n\nExplore\n\nThis part of the app is simply to see some basic characteristics of the provided series and plot some of them. The field for integer IDs expects a valid R expression that specifies which of the series should be plotted. Multivariate series are plotted with each variable in a different facet.\n\nCluster\n\nThis part of the app wraps tsclust(), so you should be familiar with it. Some remarks:\n\n- Specifying a custom centroid or hierarchical method expects the name of a function available in the R session (without quotes). Naturally, any required package should be loaded before calling interactive_clustering. For example, if you want to use cluster::agnes(), you should load cluster beforehand.\n- A random seed of 0 means that it will be left as NULL when calling tsclust().\n- The input fields for Extra parameters (distance, centroid and ellipsis) expect a comma-separated sequence of key-value pairs. For example: window.size = 10L, trace = TRUE. You should be able to pass any variables available in the R session’s global environment.\n- Regarding plot parameters:\n - The Clusters field is like the integer IDs from the Explore section.\n - The Labels field is passed to the plot method (see TSClusters-methods). You can specify several values like with the Extra parameters, e.g.: nudge_x = 10, nudge_y = 1. You can type an empty space to activate them with the defaults, and delete everything to hide them. Note that the location of the labels is random each time.\nThe plot area reacts to the plot parameters, but the actual clustering with \\texttt{tsclust()} won’t be executed until you click the Cluster! button. The \\textbf{plot can take a couple of seconds to load!} Plotting multivariate series might generate warnings about missing values, they can be safely ignored.\n\nSome of the control parameters are disabled when \\texttt{dtwclust} detects them automatically.\n\nThe cross-distance matrix is cached so that it can be re-used when appropriate. The cached version is invalidated automatically when necessary.\n\n\\section*{Evaluate}\n\nThis part of the app provides results of the current clustering. External CVIs can be calculated if the name of a variable with the ground truth is provided (see \\texttt{cvi()}).\n\n\\section*{Note}\n\nTracing is printed to the console.\n\n\\section*{Author(s)}\n\nAlexis Sarda-Espinosa\n\n\\section*{Examples}\n\n```r\n## Not run:\ninteractive_clustering(CharTrajMV)\n## End(Not run)\n```\n\n\\begin{knitrout}\n\\small\n\\begin{verbatim}\n\\tv\n\\end{verbatim}\n\\end{knitrout}\n\n\\begin{verbatim}\n lb_improved Lemire's improved DTW lower bound\n\\end{verbatim}\n\n\\section*{Description}\n\nThis function calculates an improved lower bound (LB) on the Dynamic Time Warp (DTW) distance between two time series. It uses a Sakoe-Chiba constraint.\n\n\\section*{Usage}\n\n\\begin{verbatim}\n lb_improved(x, y, window.size = NULL, norm = \"L1\", lower.env = NULL,\n upper.env = NULL, force.symmetry = FALSE, error.check = TRUE)\n\\end{verbatim}\nArguments\n\n- **x**: A time series (reference).\n- **y**: A time series with the same length as x (query).\n- **window.size**: Window size for envelope calculation. See details.\n- **norm**: Vector norm. Either \"L1\" for Manhattan distance or \"L2\" for Euclidean.\n- **lower.env**: Optionally, a pre-computed lower envelope for y can be provided (non-proxy version only). See `compute_envelope()`.\n- **upper.env**: Optionally, a pre-computed upper envelope for y can be provided (non-proxy version only). See `compute_envelope()`.\n- **force.symmetry**: If TRUE, a second lower bound is calculated by swapping x and y, and whichever result has a higher distance value is returned. The proxy version can only work if a square matrix is obtained, but use carefully.\n- **error.check**: Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\nDetails\n\nThe reference time series should go in x, whereas the query time series should go in y.\n\nIf the envelopes are provided, they should be provided together. If either one is missing, both will be computed.\n\nThe windowing constraint uses a centered window. The calculations expect a value in `window.size` that represents the distance between the point considered and one of the edges of the window. Therefore, if, for example, `window.size = 10`, the warping for an observation $x_i$ considers the points between $x_{i-10}$ and $x_{i+10}$, resulting in $10(2) + 1 = 21$ observations falling within the window.\n\nValue\n\nThe improved lower bound for the DTW distance.\n\nProxy version\n\nThe version registered with `dist` is custom (loop = FALSE in `pr_db`). The custom function handles multi-threaded parallelization directly (with `RcppParallel`). It uses all available threads by default (see `RcppParallel::defaultNumThreads()`), but this can be changed by the user with `RcppParallel::setThreadOptions()`.\n\nAn exception to the above is when it is called within a foreach parallel loop made by `dtwclust`. If the parallel workers do not have the number of threads explicitly specified, this function will default to 1 thread per worker. See the parallelization vignette for more information (browseVignettes(\"dtwclust\")).\n\nNote\n\nThe lower bound is only defined for time series of equal length and is **not** symmetric.\nIf you wish to calculate the lower bound between several time series, it would be better to use the version registered with the proxy package, since it includes some small optimizations. The convention mentioned above for references and queries still holds. See the examples.\n\nThe proxy version of force::symmetry should only be used when only x is provided or both x and y are identical. It compares the lower and upper triangular of the resulting distance matrix and forces symmetry in such a way that the tightest lower bound is obtained.\n\n**References**\n\n\n**Examples**\n\n```r\n# Sample data\ndata(uciCT)\n\ndata # Lower bound distance between two series\nd.lbi <- lb_improved(CharTraj[[1]], CharTraj[[2]], window.size = 20)\n\ndata # Corresponding true DTW distance\nd.dtw <- dtw(CharTraj[[1]], CharTraj[[2]],\n window.type = \"sakoechiba\", window.size = 20)$distance\n\nd.lbi <= d.dtw\n\n# Calculating the LB between several time series using the 'proxy' package\n# (notice how both arguments must be lists)\nD.lbi <- proxy::dist(CharTraj[1], CharTraj[2:5], method = \"LB_Improved\",\n window.size = 20, norm = \"L2\")\n\n# Corresponding true DTW distance\nD.dtw <- proxy::dist(CharTraj[1], CharTraj[2:5], method = \"dtw_basic\",\n norm = \"L2\", window.size = 20)\n\nD.lbi <= D.dtw\n```\n\n**lb_keogh**\n\n*Keogh’s DTW lower bound*\n\n**Description**\n\nThis function calculates a lower bound (LB) on the Dynamic Time Warp (DTW) distance between two time series. It uses a Sakoe-Chiba constraint.\nUsage\n\n```\nlb_keogh(x, y, window.size = NULL, norm = \"L1\", lower.env = NULL,\n upper.env = NULL, force.symmetry = FALSE, error.check = TRUE)\n```\n\nArguments\n\n- **x**: A time series (reference).\n- **y**: A time series with the same length as x (query).\n- **window.size**: Window size for envelope calculation. See details.\n- **norm**: Vector norm. Either \"L1\" for Manhattan distance or \"L2\" for Euclidean.\n- **lower.env**: Optionally, a pre-computed lower envelope for y can be provided (non-proxy version only). See `compute_envelope()`.\n- **upper.env**: Optionally, a pre-computed upper envelope for y can be provided (non-proxy version only). See `compute_envelope()`.\n- **force.symmetry**: If TRUE, a second lower bound is calculated by swapping x and y, and whichever result has a higher distance value is returned. The proxy version can only work if a square matrix is obtained, but use carefully.\n- **error.check**: Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\nDetails\n\nThe reference time series should go in x, whereas the query time series should go in y.\n\nIf the envelopes are provided, they should be provided together. If either one is missing, both will be computed.\n\nThe windowing constraint uses a centered window. The calculations expect a value in `window.size` that represents the distance between the point considered and one of the edges of the window. Therefore, if, for example, `window.size = 10`, the warping for an observation $x_i$ considers the points between $x_{i-10}$ and $x_{i+10}$, resulting in $10(2) + 1 = 21$ observations falling within the window.\n\nValue\n\nA list with:\n\n- **d**: The lower bound of the DTW distance.\n- **upper.env**: The time series of y's upper envelope.\n- **lower.env**: The time series of y's lower envelope.\n\nProxy version\n\nThe version registered with `dist` is custom (loop = FALSE in `pr_DB`). The custom function handles multi-threaded parallelization directly (with `RcppParallel`). It uses all available threads by default (see `RcppParallel::defaultNumThreads()`), but this can be changed by the user with `RcppParallel::setThreadOptions()`.\nAn exception to the above is when it is called within a `foreach` parallel loop made by `dtwclust`. If the parallel workers do not have the number of threads explicitly specified, this function will default to 1 thread per worker. See the parallelization vignette for more information (browseVignettes(\"dtwclust\")).\n\n**Note**\n\nThe lower bound is only defined for time series of equal length and is **not** symmetric.\n\nIf you wish to calculate the lower bound between several time series, it would be better to use the version registered with the proxy package, since it includes some small optimizations. The convention mentioned above for references and queries still holds. See the examples.\n\nThe proxy version of `force_symmetry` should only be used when only `x` is provided or both `x` and `y` are identical. It compares the lower and upper triangular of the resulting distance matrix and forces symmetry in such a way that the tightest lower bound is obtained.\n\n**References**\n\n\n**Examples**\n\n```r\n# Sample data\ndata(uciCT)\n\n# Lower bound distance between two series\nd.lbk <- lb_keogh(CharTraj[[1]], CharTraj[[2]], window.size = 20)\n\nd.lbk <- lb_keogh(CharTraj[[1]], CharTraj[[2]], window.size = 20)\n\n# Corresponding true DTW distance\nd.dtw <- dtw(CharTraj[[1]], CharTraj[[2]],\n window.type = \"sakoechiba\", window.size = 20)\n\nd.dtw <- dtw(CharTraj[[1]], CharTraj[[2]],\n window.type = \"sakoechiba\", window.size = 20)\n\n# Calculating the LB between several time series using the 'proxy' package\n# (notice how both arguments must be lists)\nD.lbk <- proxy::dist(CharTraj[1], CharTraj[2:5], method = \"LB_Keogh\",\n window.size = 20, norm = \"L2\")\n\nD.lbk <- proxy::dist(CharTraj[1], CharTraj[2:5], method = \"LB_Keogh\",\n window.size = 20, norm = \"L2\")\n\n# Corresponding true DTW distance\nD.dtw <- proxy::dist(CharTraj[1], CharTraj[2:5], method = \"dtw_basic\",\n norm = \"L2\", window.size = 20)\n\nD.dtw <- proxy::dist(CharTraj[1], CharTraj[2:5], method = \"dtw_basic\",\n norm = \"L2\", window.size = 20)\n```\n\nNCCc\n\nCross-correlation with coefficient normalization\n\nDescription\nThis function uses the FFT to compute the cross-correlation sequence between two series. They need *not* be of equal length.\n\nUsage\nnccc(x, y, error.check = TRUE)\n\nArguments\n- `x, y`: Univariate time series.\n- `error.check`: Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\nValue\nThe cross-correlation sequence with length `length(x) + length(y) - 1`.\n\nReferences\n\nSee Also\n- `sbd()`\n\n---\n\npam_cent\n\nCentroid for partition around medoids\n\nDescription\nExtract the medoid time series based on a distance measure.\n\nUsage\npam_cent(series, distance, ids = seq_along(series), distmat = NULL, ..., error.check = TRUE)\n**Arguments**\n\n- **series**: The time series in one of the formats accepted by `tslist()`.\n- **distance**: A character indicating which distance to use. Only needed if `distmat` is NULL. The distance must be registered in `proxy::pr_DB()`.\n- **ids**: Integer vector indicating which of the `series` should be considered.\n- **distmat**: Optionally, a pre-computed cross-distance matrix of all `series`.\n- **...**: Any extra parameters for the distance function that may be used.\n- **error.check**: Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\n**Details**\n\nThe medoid's index is determined by taking the `argmin` of the `distmat`'s row-sums (considering only the rows in `ids`). The distance matrix is calculated if needed.\n\n**Value**\n\nThe medoid time series.\n\n**Examples**\n\n```r\n# Computes the distance matrix for all series\npam_cent(CharTraj, \"dtw_basic\", ids = 6L:10L, window.size = 15L) # series_id = 7L\n\n# Computes the distance matrix for the chosen subset only\npam_cent(CharTraj[6L:10L], \"dtw_basic\", window.size = 15L) # series_id = 2L\n```\n\n**pdc_configs**\n\n*Helper function for preprocessing/distance/centroid configurations*\n\n**Description**\n\nCreate preprocessing, distance and centroid configurations for `compare_clusterings_configs()`.\n\n**Usage**\n\n```r\npdc_configs(type = c(\"preproc\", \"distance\", \"centroid\"), ...,\n partitional = NULL, hierarchical = NULL, fuzzy = NULL,\n tadpole = NULL, share.config = c(\"p\", \"h\", \"f\", \"t\"))\n```\nArguments\n\n- **type**: Which type of function is being targeted by this configuration. Any number of named lists with functions and arguments that will be shared by all clusterings. See details.\n- **partitional**: A named list of lists with functions and arguments for partitional clusterings.\n- **hierarchical**: A named list of lists with functions and arguments for hierarchical clusterings.\n- **fuzzy**: A named list of lists with functions and arguments for fuzzy clusterings.\n- **tadpole**: A named list of lists with functions and arguments for TADPole clusterings.\n- **share.config**: A character vector specifying which clusterings should include the shared lists (the ones specified in ...). It must be any combination of (possibly abbreviated): partitional, hierarchical, fuzzy, tadpole.\n\nDetails\n\nThe named lists are interpreted in the following way: the name of the list will be considered to be a function name, and the elements of the list will be the possible parameters for the function. Each function must have at least an empty list. The parameters may be vectors that specify different values to be tested.\n\n- For preprocessing, the special name `none` signifies no preprocessing.\n- For centroids, the special name `default` leaves the centroid unspecified.\n\nPlease see the examples in `compare.clusterings()` to see how this is used.\n\nValue\n\nA list for each clustering, each of which includes a data frame with the computed configurations.\n\n---\n\n**reinterpolate** \n*Wrapper for simple linear reinterpolation*\n\n**Description**\n\nThis function is just a wrapper for the native function `stats::approx()` to do simple linear reinterpolation. It also supports matrices, data frames, and lists of time series.\n\n**Usage**\n\n```r\nreinterpolate(x, new.length, multivariate = FALSE)\n```\n\n**Arguments**\n\n- **x**: Data to reinterpolate. Either a vector, a matrix/data.frame where each row is to be reinterpolated, or a list of vectors/matrices.\n- **new.length**: Desired length of the output series.\n- **multivariate**: Is x a multivariate time series? It will be detected automatically if a list is provided in x.\nDetails\n\nMultivariate series must have time spanning the rows and variables spanning the columns.\n\nValue\n\nReinterpolated time series\n\nExamples\n\ndata(uciCT)\n\n# list of univariate series\nseries <- reinterpolate(CharTraj, 205L)\n\n# list of multivariate series\nseries <- reinterpolate(CharTrajMV, 205L)\n\n# single multivariate series\nseries <- reinterpolate(CharTrajMV[[1L]], 205L, TRUE)\n\nrepeat_clustering Repeat a clustering configuration\n\nDescription\n\nRepeat a clustering made with compare_clusterings() in order to obtain the TSClusters object.\n\nUsage\n\nrepeat_clustering(series, clusterings, config_id, ...)\n\nArguments\n\n<table>\n<thead>\n<tr>\n<th>Argument</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>series</td>\n<td>The same time series that were given to compare_clusterings().</td>\n</tr>\n<tr>\n<td>clusterings</td>\n<td>The list returned by compare_clusterings().</td>\n</tr>\n<tr>\n<td>config_id</td>\n<td>The character indicating which configuration should be re-computed. Obtained from the clusterings’ results’ data frames.</td>\n</tr>\n<tr>\n<td>...</td>\n<td>More arguments for tsclust() (e.g. trace).</td>\n</tr>\n</tbody>\n</table>\n\nDetails\n\nSince the purpose of compare_clusterings() is to test many configurations, it is desirable to set its return.objects parameter to FALSE in order to save RAM. This function can then be used to compute the clustering object for a specific config_id.\nValue\n\nA `TSClusters` object.\n\nLimitations\n\nIf the preprocessing function is subject to randomness, the clustering will not be correctly recreated by this function, since `compare_clusterings()` applies all preprocessing before calling `tsclust()`.\n\nIf any parameters were given to `compare_clusterings()` through its ellipsis, they should probably be given to this function too.\n\n---\n\n**SBD**\n\n*Shape-based distance*\n\n---\n\nDescription\n\nDistance based on coefficient-normalized cross-correlation as proposed by Paparrizos and Gravano (2015) for the k-Shape clustering algorithm.\n\nUsage\n\n\\[\n\\text{SBD}(x, y, \\text{znorm} = \\text{FALSE}, \\text{error.check} = \\text{TRUE}, \\text{return.shifted} = \\text{TRUE})\n\\]\n\n\\[\n\\text{sbd}(x, y, \\text{znorm} = \\text{FALSE}, \\text{error.check} = \\text{TRUE}, \\text{return.shifted} = \\text{TRUE})\n\\]\n\nArguments\n\n- `x, y` Univariate time series.\n- `znorm` Logical. Should each series be z-normalized before calculating the distance?\n- `error.check` Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n- `return.shifted` Logical. Should the shifted version of `y` be returned? See details.\n\nDetails\n\nThis distance works best if the series are *z-normalized*. If not, at least they should have appropriate amplitudes, since the values of the signals do affect the outcome.\n\nIf `x` and `y` do not have the same length, it would be best if the longer sequence is provided in `y`, because it will be shifted to match `x`. After matching, the series may have to be truncated or extended and padded with zeros if needed.\n\nThe output values lie between 0 and 2, with 0 indicating perfect similarity.\nValue\n\nFor return.shifted = FALSE, the numeric distance value, otherwise a list with:\n\n- dist: The shape-based distance between x and y.\n- yshift: A shifted version of y so that it optimally matches x (based on NCCc()).\n\nProxy version\n\nThe version registered with dist is custom (loop = FALSE in pr_DB). The custom function handles multi-threaded parallelization directly (with RcppParallel). It uses all available threads by default (see RcppParallel::defaultNumThreads()), but this can be changed by the user with RcppParallel::setThreadOptions().\n\nAn exception to the above is when it is called within a foreach parallel loop made by dtwclus. If the parallel workers do not have the number of threads explicitly specified, this function will default to 1 thread per worker. See the parallelization vignette for more information (browseVignettes(\"dtwclus\")).\n\nIt also includes symmetric optimizations to calculate only half a distance matrix when appropriate—only one list of series should be provided in x. If you want to avoid this optimization, call dist by giving the same list of series in both x and y.\n\nIn some situations, e.g. for relatively small distance matrices, the overhead introduced by the logic that computes only half the distance matrix can be bigger than just calculating the whole matrix.\n\nNote\n\nIf you wish to calculate the distance between several time series, it would be better to use the version registered with the proxy package, since it includes some small optimizations. See the examples.\n\nThis distance is calculated with help of the Fast Fourier Transform, so it can be sensitive to numerical precision. Thus, this function (and the functions that depend on it) might return different values in 32 bit installations compared to 64 bit ones.\n\nReferences\n\n\nSee Also\n\nNCCc(), shape_extraction()\n\nExamples\n\n```r\n# load data\ndata(uciCT)\n\n# distance between series of different lengths\nsbd <- SBD(CharTraj[[1]], CharTraj[[100]], znorm = TRUE)$dist\n```\nsdtw\n\n# cross-distance matrix for series subset (notice the two-list input)\nsbD <- proxy::dist(CharTraj[1:10], CharTraj[1:10], method = \"SBD\", znorm = TRUE)\n\n---\n\n### Description\n\nSoft-DTW distance measure as proposed in Cuturi and Blondel (2017).\n\n### Usage\n\n`sdtw(x, y, gamma = 0.01, ..., error.check = TRUE)`\n\n### Arguments\n\n- **x**, **y**\n - Time series. Multivariate series must have time spanning the rows and variables spanning the columns.\n- **gamma**\n - Positive regularization parameter, with lower values resulting in less smoothing.\n- **...**\n - Currently ignored.\n- **error.check**\n - Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\n### Details\n\nUnlike other distances, soft-DTW can return negative values, and `sdtw(x, x)` is not always equal to zero. Like DTW, soft-DTW does not fulfill the triangle inequality, but it is always symmetric.\n\n### Value\n\nThe Soft DTW distance.\n\n### Proxy version\n\nThe version registered with `dist` is custom (loop = FALSE in `pr_DB`). The custom function handles multi-threaded parallelization directly (with `RcppParallel`). It uses all available threads by default (see `RcppParallel::defaultNumThreads()`), but this can be changed by the user with `RcppParallel::setThreadOptions()`.\n\nAn exception to the above is when it is called within a `foreach` parallel loop made by `dtwclust`. If the parallel workers do not have the number of threads explicitly specified, this function will default to 1 thread per worker. See the parallelization vignette for more information (browseVignettes(\"dtwclust\")). It also includes symmetric optimizations to calculate only half a distance matrix when appropriate—only one list of series should be provided in x. If you want to avoid this optimization, call `dist` by giving the same list of series in both x and y.\nReferences\n\n\n---\n\n**sdtw_cent** \n*Centroid calculation based on soft-DTW*\n\n---\n\n**Description**\n\nSoft-DTW centroid function as proposed in Cuturi and Blondel (2017).\n\n**Usage**\n\n```r\nsdtw_cent(series, centroid = NULL, gamma = 0.01, weights = rep(1, length(series)), ..., opts = list(algorithm = \"NLOPT_LD_LBFGS\", maxeval = 20L), error.check = TRUE)\n```\n\n**Arguments**\n\n- `series` A matrix or data frame where each row is a time series, or a list where each element is a time series. Multivariate series should be provided as a list of matrices where time spans the rows and the variables span the columns of each matrix.\n- `centroid` Optionally, a time series to use as reference. Defaults to a random series of `series` if `NULL`. For multivariate series, this should be a matrix with the same characteristics as the matrices in `series`.\n- `gamma` Positive regularization parameter, with lower values resulting in less smoothing.\n- `weights` A vector of weights for each element of `series`.\n- `...` Further arguments for `nloptr::nloptr()` (except `opts` and `...`).\n- `opts` List of options to pass to `nloptr::nloptr()`.\n- `error.check` Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\n**Details**\n\nNote that you can trace the optimization by specifying `print_level > 0` in `opts`.\n\n**Value**\n\nThe resulting centroid, with attribute `nloptr_results` specifying the optimization results (except for `solution`, which is the returned centroid).\nParallel Computing\n\nPlease note that running tasks in parallel does not guarantee faster computations. The overhead introduced is sometimes too large, and it's better to run tasks sequentially.\n\nThis function uses the RcppParallel package for parallelization. It uses all available threads by default (see RcppParallel::defaultNumThreads()), but this can be changed by the user with RcppParallel::setThreadOptions().\n\nAn exception to the above is when this function is called within a foreach parallel loop made by dtwclust. If the parallel workers do not have the number of threads explicitly specified, this function will default to 1 thread per worker. See the parallelization vignette for more information (browseVignettes(\"dtwclust\")).\n\nFor unknown reasons, this function has returned different results (in the order of 1e-6) when using multi-threading in x64 Windows installations in comparison to other environments (using nloptr v1.0.4). Consider limiting the number of threads if you run into reproducibility problems.\n\nReferences\n\n\nshape_extraction\n\nShape average of several time series\n\nDescription\n\nTime-series shape extraction based on optimal alignments as proposed by Paparrizos and Gravano (2015) for the k-Shape clustering algorithm.\n\nUsage\n\n```r\nshape_extraction(X, centroid = NULL, znorm = FALSE, ..., error.check = TRUE)\n```\n\nArguments\n\n- `X`: A matrix or data frame where each row is a time series, or a list where each element is a time series. Multivariate series should be provided as a list of matrices where time spans the rows and the variables span the columns.\n- `centroid`: Optionally, a time series to use as reference. Defaults to a random series of `X` if NULL. For multivariate series, this should be a matrix with the same characteristics as the matrices in `X`. It will be z-normalized.\n- `znorm`: Logical flag. Should z-scores be calculated for `X` before processing?\n- `...`: Further arguments for `zscore()`.\n- `error.check`: Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\nDetails\n\nThis works only if the series are \\textit{z-normalized}, since the output will also have this normalization.\n\nThe resulting centroid will have the same length as centroid if provided. Otherwise, there are two possibilities: if all series from \\(X\\) have the same length, all of them will be used as-is, and the output will have the same length as the series; if series have different lengths, a series will be chosen at random and used as reference. The output series will then have the same length as the chosen series.\n\nThis centroid computation is cast as an optimization problem called maximization of Rayleigh Quotient. It depends on the \\texttt{SBD()} algorithm. See the cited article for more details.\n\nValue\n\nCentroid time series (\\(z\\)-normalized).\n\nReferences\n\n\nSee Also\n\n\\texttt{SBD()}, \\texttt{zscore()}\n\nExamples\n\n```r\n# Sample data\ndata(uciCT)\n\n# Normalize desired subset\nX <- zscore(CharTraj[1:5])\n\n# Obtain centroid series\nC <- shape_extraction(X)\n\n# Result\nmatplot(do.call(cbind, X),\n type = \"l\", col = 1:5)\npoints(C)\n```\nA shiny app for semi-supervised DTW-based clustering\n\nDescription\n\nDisplay a shiny user interface that implements the approach in Dau et al. (2016).\n\nUsage\n\n```\nssdtwclust(series, ..., complexity = NULL)\n```\n\nArguments\n\n- `series` Time series in the formats accepted by `compare_clusterings()`.\n- `...` More arguments for `shiny::runApp()`.\n- `complexity` A function to calculate a constraint’s complexity. See details in the Cluster section.\n\nDetails\n\nThe approach developed in Dau et al. (2016) argues that finding a good value of window size for the DTW distance is very important, and suggests how to find one by using user-provided feedback. After clustering is done, a pair of series is presented at a time, and the user must annotate the pair as:\n\n- Must link: the series should be in the same cluster.\n- Cannot link: the series should *not* be in the same cluster.\n- Skip: the choice is unclear.\n\nAfter each step, a good value of the window size is suggested by evaluating which clusterings fulfill the constraint(s) so far, and how (see Dau et al. (2016) for more information), and performing a majority vote using the window sizes inferred from each constraint. The (main) procedure is thus interactive and can be abandoned at any point.\n\nExplore\n\nThis part of the app is simply to see some basic characteristics of the provided series and plot some of them. The field for integer IDs expects a valid R expression that specifies which of the series should be plotted. Multivariate series are plotted with each variable in a different facet.\n\nCluster\n\nThis part of the app implements the main procedure by leveraging `compare_clusterings()`. The interface is similar to `interactive_clustering()`, so it’s worth checking its documentation too. Since `compare_clusterings()` supports parallelization with `foreach::foreach()`, you can register a parallel backend before opening the shiny app, but you should pre-load the workers with the\nnecessary packages and/or functions. See parallel::clusterEvalQ() and parallel::clusterExport(), as well as the examples below.\n\nThe range of window sizes is specified with a slider, and represents the size as a percentage of the shortest series’ length. The step parameter indicates how spaced apart should the sizes be (parameter 'by' in base::seq()). A 0-size window should only be used if all series have the same length. If the series have different lengths, using small window sizes can be problematic if the length differences are very big, see the notes in dtw_basic().\n\nA window.size should not be specified in the extra parameters, it will be replaced with the computed values based on the slider. Using dba() centroid is detected, and will use the same window sizes.\n\nFor partitional clusterings with many repetitions, and hierarchical clusterings with many linkage methods, the resulting partitions are aggregated by calling clue::cl_medoid() with the specified aggregation method.\n\nBy default, complexity of a constraint is calculated differently from what is suggested in Dau et al. (2016):\n\n- Allocate a logical flag vector with length equal to the number of tested window sizes.\n- For each window size, set the corresponding flag to TRUE if the constraint given by the user is fulfilled.\n- Calculate complexity as: (number of sign changes in the vector) / (number of window sizes - 1L) / (maximum number of contiguous TRUE flags).\n\nYou can provide your own function in the complexity parameter. It will receive the flag vector as only input, and a single number is expected as a result.\n\nThe complexity threshold can be specified in the app. Any constraint whose complexity is higher than the threshold will not be considered for the majority vote. Constraints with a complexity of 0 are also ignored. An infinite complexity means that the constraint is never fulfilled by any clustering.\n\nEvaluate\n\nThis section provides numerical results for reference. The latest results can be saved in the global environment, which includes clustering results, constraints so far, and the suggested window size. Since this includes everything returned by compare_clusterings(), you could also use repeat_clustering() afterwards.\n\nThe constraint plots depict if the constraints are fulfilled or not for the given window sizes, where 1 means it was fulfilled and 0 means it wasn’t. An error about a zero-dimension viewport indicates the plot height is too small to fit the plots, so please increase the height.\n\nNote\n\nThe optimization mentioned in section 3.4 of Dau et al. (2016) is also implemented here.\n\nTracing is printed to the console.\n\nAuthor(s)\n\nAlexis Sarda-Espinosa\nReferences\n\n\nSee Also\n\ninteractive_clustering(), compare_clusterings()\n\nExamples\n\n## Not run:\nrequire(doParallel)\nworkers <- makeCluster(detectCores())\nclusterEvalQ(workers, {\n library(dtwclust)\n RcppParallel::setThreadOptions(1L)\n})\nregisterDoParallel(workers)\nssdtwclust(reinterpolate(CharTraj[1L:20L], 150L))\n\n## End(Not run)\n\nTADPole TADPole clustering\n\nDescription\n\nTime-series Anytime Density Peaks Clustering as proposed by Begum et al. (2015).\n\nUsage\n\nTADPole(data, k = 2L, dc, window.size, error.check = TRUE,\n lb = \"lbk\", trace = FALSE)\ntadpole(data, k = 2L, dc, window.size, error.check = TRUE,\n lb = \"lbk\", trace = FALSE)\n\nArguments\n\ndata A matrix or data frame where each row is a time series, or a list where each element is a time series. Multivariate series are not supported.\nk The number of desired clusters. Can be a vector with several values.\ndc The cutoff distance(s). Can be a vector with several values.\nwindow.size Window size constraint for DTW (Sakoe-Chiba). See details.\nerror.check Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\nlb Which lower bound to use, \"lbk\" for lb_keogh() or \"lbi\" for lb_improved().\ntrace Logical flag. If TRUE, more output regarding the progress is printed to screen.\n\nDetails\n\nThis function can be called either directly or through tsclust().\n\nTADPole clustering adopts a relatively new clustering framework and adapts it to time series clustering with DTW. See the cited article for the details of the algorithm.\n\nBecause of the way the algorithm works, it can be considered a kind of Partitioning Around Medoids (PAM). This means that the cluster centroids are always elements of the data. However, this algorithm is deterministic, depending on the value of dc.\n\nThe algorithm first uses the DTW's upper and lower bounds (Euclidean and LB_Keogh respectively) to find series with many close neighbors (in DTW space). Anything below the cutoff distance (dc) is considered a neighbor. Aided with this information, the algorithm then tries to prune as many DTW calculations as possible in order to accelerate the clustering procedure. The series that lie in dense areas (i.e. that have lots of neighbors) are taken as cluster centroids.\n\nThe algorithm relies on the DTW bounds, which are only defined for univariate time series of equal length.\n\nParallelization is supported in the following way:\n\n- For multiple dc values, multi-processing with foreach::foreach().\n- The internal distance calculations use multi-threading with RcppParallel::RcppParallel.\n\nThe windowing constraint uses a centered window. The calculations expect a value in window.size that represents the distance between the point considered and one of the edges of the window. Therefore, if, for example, window.size = 10, the warping for an observation $x_i$ considers the points between $x_{i-10}$ and $x_{i+10}$, resulting in $10(2) + 1 = 21$ observations falling within the window.\n\nValue\n\nA list with:\n\n- cl: Cluster indices.\n- centroids: Indices of the centroids.\n- distCalcPercentage: Percentage of distance calculations that were actually performed.\n\nFor multiple k/dc values, a list of lists is returned, each internal list having the aforementioned elements.\nParallel Computing\n\nPlease note that running tasks in parallel does not guarantee faster computations. The overhead introduced is sometimes too large, and it’s better to run tasks sequentially.\n\nThis function uses the RcppParallel package for parallelization. It uses all available threads by default (see RcppParallel:::defaultNumThreads()), but this can be changed by the user with RcppParallel:::setThreadOptions().\n\nAn exception to the above is when this function is called within a foreach parallel loop made by dtwclust. If the parallel workers do not have the number of threads explicitly specified, this function will default to 1 thread per worker. See the parallelization vignette for more information (browseVignettes(\"dtwclust\")).\n\nReferences\n\n\ntscult\n\nTime series clustering\n\nDescription\n\nThis is the main function to perform time series clustering. See the details and the examples for more information, as well as the included package vignettes (which can be found by typing browseVignettes(\"dtwclust\")). A convenience wrapper is available in compare_clusterings(), and a shiny app in interactive_clustering().\n\nUsage\n\ntscult(series = NULL, type = \"partitional\", k = 2L, ..., preproc = NULL, distance = \"dtw_basic\", centroid = ifelse(type == \"fuzzy\", \"fcm\", \"pam\"), control = do.call(paste0(type, \",\"_control\"), list()), args = tsclust_args(), seed = NULL, trace = FALSE, error.check = TRUE)\n\nArguments\n\n<table>\n<thead>\n<tr>\n<th>Argument</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>series</td>\n<td>A list of series, a numeric matrix or a data frame. Matrices and data frames are coerced to a list row-wise (see tslist()).</td>\n</tr>\n<tr>\n<td>type</td>\n<td>What type of clustering method to use: "partitional", "hierarchical", "tadpole" or "fuzzy".</td>\n</tr>\n<tr>\n<td>k</td>\n<td>Number of desired clusters. It can be a numeric vector with different values.</td>\n</tr>\n<tr>\n<td>...</td>\n<td>Arguments to pass to preprocessing, centroid and distance functions (added to args). Also passed to method from hierarchical_control() if it happens to be a function, and to stats::hclust() if it contains the members parameter.</td>\n</tr>\n</tbody>\n</table>\npreproc Function to preprocess data. Defaults to \\texttt{zscore()} only if \\texttt{centroid = \\textquotesingle shape\\textquotesingle}, but will be replaced by a custom function if provided.\n\ndistance A registered distance from \\texttt{proxy::dist()}. Ignored for \\texttt{type = \\textquotesingle tadpole\\textquotesingle}.\n\ncentroid Either a supported string, or an appropriate function to calculate centroids when using partitional/hierarchical/tadpole methods. See Centroids section.\n\ncontrol An appropriate list of controls. See \\texttt{tsclust-controls}.\n\nargs An appropriate list of arguments for preprocessing, distance and centroid functions. See \\texttt{tsclust_args()} and the examples.\n\nseed Random seed for reproducibility.\n\ntrace Logical flag. If \\texttt{TRUE}, more output regarding the progress is printed to screen.\n\nerror.check Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\nDetails\n\nPartitional and fuzzy clustering procedures use a custom implementation. Hierarchical clustering is done with \\texttt{stats::hclust()} by default. TADPole clustering uses the \\texttt{TADPole()} function. Specifying \\texttt{type = \\textquotesingle partitional\\textquotesingle}, \\texttt{preproc = zscore}, \\texttt{distance = \\textquotesingle sbd\\textquotesingle} and \\texttt{centroid = \\textquotesingle shape\\textquotesingle} is equivalent to the k-Shape algorithm (Paparrizos and Gravano 2015).\n\nThe series may be provided as a matrix, a data frame or a list. Matrices and data frames are coerced to a list, both row-wise. Only lists can have series with different lengths or multiple dimensions. Most of the optimizations require series to have the same length, so consider reinterpolating them to save some time (see Ratanamahatana and Keogh 2004; \\texttt{reinterpolate()}). No missing values are allowed.\n\nIn the case of multivariate time series, they should be provided as a list of matrices, where time spans the rows of each matrix and the variables span the columns (see \\texttt{CharTrajMV} for an example). All included centroid functions should work with the aforementioned format, although \\texttt{shape} is \\textit{not} recommended. Note that the \\texttt{plot} method will simply append all dimensions (columns) one after the other.\n\nValue\n\nAn object with an appropriate class from \\texttt{TSClusters}.\n\nIf \\texttt{control$nrep > 1} and a partitional procedure is used, \\texttt{length(method) > 1} and hierarchical procedures are used, or \\texttt{length(k) > 1}, a list of objects is returned.\n\nCentroid Calculation\n\nIn the case of partitional/fuzzy algorithms, a suitable function should calculate the cluster centroids at every iteration. In this case, the centroids may also be time series. Fuzzy clustering uses the standard fuzzy c-means centroid by default.\n\nIn either case, a custom function can be provided. If one is provided, it will receive the following parameters with the shown names (examples for partitional clustering are shown in parentheses):\n\n- \\texttt{x}: The \\textit{whole} data list (\\texttt{list(ts1, ts2, ts3)})\n• `cl_id`: An integer vector with length equal to the number of series in data, indicating which cluster a series belongs to (c(1L, 2L, 2L))\n• `k`: The desired number of total clusters (2L)\n• `cent`: The current centroids in order, in a list (list(centroid1, centroid2))\n• `cl_old`: The membership vector of the previous iteration (c(1L, 1L, 2L))\n• The elements of ... that match its formal arguments\n\nIn case of fuzzy clustering, the membership vectors (2nd and 5th elements above) are matrices with number of rows equal to amount of elements in the data, and number of columns equal to the number of desired clusters. Each row must sum to 1.\n\nThe other option is to provide a character string for the custom implementations. The following options are available:\n\n• \"mean\": The average along each dimension. In other words, the average of all $x_{ij}$ among the $j$ series that belong to the same cluster for all time points $t_i$.\n• \"median\": The median along each dimension. Similar to mean.\n• \"shape\": Shape averaging. By default, all series are z-normalized in this case, since the resulting centroids will also have this normalization. See `shape_extraction()` for more details.\n• \"dba\": DTW Barycenter Averaging. See `DBA()` for more details.\n• \"sdtw_cent\": Soft-DTW centroids, See `sdtw_cent()` for more details.\n• \"pam\": Partition around medoids (PAM). This basically means that the cluster centroids are always one of the time series in the data. In this case, the distance matrix can be pre-computed once using all time series in the data and then re-used at each iteration. It usually saves overhead overall for small datasets (see `tsclust-controls`).\n• \"fcm\": Fuzzy c-means. Only supported for fuzzy clustering and used by default in that case.\n• \"fcmdd\": Fuzzy c-medoids. Only supported for fuzzy clustering. It always precomputes/uses the whole cross-distance matrix.\n\nThe `dba`, `shape` and `sdtw_cent` implementations check for parallelization. Note that only `shape`, `dba`, `sdtw_cent`, `pam` and `fcmdd` support series of different length. Also note that for `shape`, `dba` and `sdtw_cent`, this support has a caveat: the final centroids’ length will depend on the length of those series that were randomly chosen at the beginning of the clustering algorithm. For example, if the series in the dataset have a length of either 10 or 15, 2 clusters are desired, and the initial choice selects two series with length of 10, the final centroids will have this same length.\n\nAs special cases, if hierarchical or tadpole clustering is used, you can provide a centroid function that takes a list of series as first input. It will also receive the contents of `args$cent` that match its formal arguments, and should return a single centroid series. These centroids are returned in the centroids slot. By default, the medoid of each cluster is extracted (similar to what `pam_cent()` does).\n\nIn the following cases, the centroids list will have an attribute `series_id` with an integer vector indicating which series were chosen as centroids:\n\n• Partitional clustering using \"pam\" centroid.\n• Fuzzy clustering using \"fcmdd\" centroid.\n• Hierarchical clustering with the default centroid extraction.\n• TADPole clustering with the default centroid extraction.\nDistance Measures\n\nThe distance measure to be used with partitional, hierarchical and fuzzy clustering can be modified with the distance parameter. The supported option is to provide a string, which must represent a compatible distance registered with proxy’s `proxy::dist()`. Registration is done via `proxy::pr_DB()`, and extra parameters can be provided in `args$dist` (see the examples).\n\nNote that you are free to create your own distance functions and register them. Optionally, you can use one of the following custom implementations (all registered with `proxy`):\n\n- \"dtw\": DTW, optionally with a Sakoe-Chiba/Slanted-band constraint. Done with `dtw::dtw()`.\n- \"dtw2\": DTW with L2 norm and optionally a Sakoe-Chiba/Slanted-band constraint. See `dtw2()`.\n- \"dtw_basic\": A custom version of DTW with less functionality, but faster. See `dtw_basic()`.\n- \"dtw_lb\": DTW with L1 or L2 norm and a Sakoe-Chiba constraint. Some computations are avoided by first estimating the distance matrix with Lemire’s lower bound and then iteratively refining with DTW. See `dtw_lb()`. Not suitable for `pam.precompute = TRUE` nor hierarchical clustering.\n- \"lbk\": Keogh’s lower bound for DTW with either L1 or L2 norm for the Sakoe-Chiba constraint. See `lb_keogh()`.\n- \"lb1\": Lemire’s lower bound for DTW with either L1 or L2 norm for the Sakoe-Chiba constraint. See `lb_improved()`.\n- \"sbd\": Shape-based distance. See `sbd()`.\n- \"gak\": Global alignment kernels. See `gak()`.\n- \"sdtw\": Soft-DTW. See `sdtw()`.\n\nOut of the aforementioned, only the distances based on DTW lower bounds don’t support series of different length. The lower bounds are probably unsuitable for direct clustering unless series are very easily distinguishable.\n\nIf you know that the distance function is symmetric, and you use a hierarchical algorithm, or a partitional algorithm with PAM centroids, or fuzzy c-medoids, some time can be saved by calculating only half the distance matrix. Therefore, consider setting the symmetric control parameter to `TRUE` if this is the case (see `tsclust-controls`).\n\nPreprocessing\n\nIt is strongly advised to use z-normalization in case of `centroid = \"shape\"`, because the resulting series have this normalization (see `shape_extraction()`). Therefore, `zscore()` is the default in this case. The user can, however, specify a custom function that performs any transformation on the data, but the user must make sure that the format stays consistent, i.e. a list of time series.\n\nSetting to `NULL` means no preprocessing (except for `centroid = \"shape\"`). A provided function will receive the data as first argument, followed by the contents of `args$preproc` that match its formal arguments.\n\nIt is convenient to provide this function if you’re planning on using the `stats::predict()` generic (see also `TSClusters-methods`).\nRepetitions\n\nDue to their stochastic nature, partitional clustering is usually repeated several times with different random seeds to allow for different starting points. This function uses `parallel:::nextRNGStream()` to obtain different seed streams for each repetition, utilizing the seed parameter (if provided) to initialize it. If more than one repetition is made, the streams are returned in an attribute called `rng`.\n\nMultiple values of $k$ can also be provided to get different partitions using any type of clustering. Repetitions are greatly optimized when PAM centroids are used and the whole distance matrix is precomputed, since said matrix is reused for every repetition.\n\nParallel Computing\n\nPlease note that running tasks in parallel does **not** guarantee faster computations. The overhead introduced is sometimes too large, and it’s better to run tasks sequentially.\n\nThe user can register a parallel backend, e.g. with the `doParallel` package, in order to attempt to speed up the calculations (see the examples). This relies on `foreach`, i.e. it uses multi-processing. Multi-processing is used in partitional and fuzzy clustering for multiple values of $k$ and/or `nrep` (in `partitional.control()`). See `TADPole()` to know how it uses parallelization. For cross-distance matrix calculations, the parallelization strategy depends on whether the distance is included with `dtwclust` or not, see the caveats in `tsclustFamily`.\n\nIf you register a parallel backend and special packages must be loaded, provide their names in the `packages` element of `control`. Note that \"dtwclust\" is always loaded in each parallel worker, so that doesn’t need to be included. Alternatively, you may want to pre-load `dtwclust` in each worker with `parallel:::clusterEvalQ()`.\n\nNote\n\nThe lower bounds are defined only for time series of equal length. They are **not** symmetric, and DTW is not symmetric in general.\n\nAuthor(s)\n\nAlexis Sarda-Espinosa\n\nReferences\n\nPlease refer to the package vignette references (which can be loaded by typing `vignette(\"dtwclust\")`).\n\nSee Also\n\n`TSClusters, TSClusters-methods, tsclustFamily, tsclust-controls, compare_clusterings(), interactive_clustering(), ssdtwclust()`.\n\nExamples\n\n```r\n# NOTE: More examples are available in the vignette. Here are just some miscellaneous\n# examples that might come in handy. They should all work, but some don't run\n# automatically.\n```\n# Load data\ndata(uciCT)\n\n# Simple partitional clustering with Euclidean distance and PAM centroids\n# Reinterpolate to same length\nseries <- reinterpolate(CharTraj, new.length = max(lengths(CharTraj)))\n\n# Subset for speed\nseries <- series[1:20]\nlabels <- CharTrajLabels[1:20]\n\n# Making many repetitions\npc.12 <- tsclust(series, k = 4L,\n distance = \"L2\", centroid = \"pam\",\n seed = 3247, trace = TRUE,\n control = partitional_control(nrep = 10L))\n\n# Cluster validity indices\nsapply(pc.12, cvi, b = labels)\n\n# Hierarchical clustering with Euclidean distance\n# Re-use the distance matrix from the previous example (all matrices are the same)\n# Use all available linkage methods for function hclust\nhc.12 <- tsclust(series, type = \"hierarchical\",\n k = 4L, trace = TRUE,\n control = hierarchical_control(method = \"all\",\n distmat = pc.12[[1L]]@distmat))\n\n# Plot the best dendrogram according to variation of information\nplot(hc.12[[which.min(sapply(hc.12, cvi, b = labels, type = \"VI\"))]])\n\n# Multivariate time series\n# Multivariate series, provided as a list of matrices\nmv <- CharTrajMV[1L:20L]\n\n# Using GAK distance\nmvc <- tsclust(mv, k = 4L, distance = \"gak\", seed = 390,\n args = tsclust_args(dist = list(sigma = 100)))\n\n# Note how the variables of each series are appended one after the other in the plot\nplot(mvc)\n\n## Not run:\n##\n# This function is more verbose but allows for more explicit fine-grained control\n\ntsc <- tsclust(series, k = 4L,\n distance = \"gak\", centroid = \"dba\",\n preproc = zscore, seed = 382L, trace = TRUE,\n control = partitional_control(iter.max = 30L),\n args = tsclust_args(preproc = list(center = FALSE),\n dist = list(window.size = 20L,\n sigma = 100),\n cent = list(window.size = 15L,\n norm = \"L2\",\n trace = TRUE)))\n\n# Normalized asymmetric DTW distance\nndtw <- function(x, y, ...) {\n dtw::dtw(x, y, step.pattern = asymmetric,\n distance.only = TRUE, ...)$normalizedDistance\n}\n\n# Registering the function with 'proxy'\nif (!pr_DB$entry_exists(\"nDTW\"))\n proxy::pr_DB$set_entry(FUN = ndtw, names=c(\"nDTW\"),\n loop = TRUE, type = \"metric\", distance = TRUE,\n description = \"Normalized asymmetric DTW\")\n\n# Subset of (original) data for speed\npc.ndtw <- tsclust(series[-1L], k = 4L,\n distance = \"nDTW\",\n seed = 8319,\n trace = TRUE,\n args = tsclust_args(dist = list(window.size = 18L)))\n\n# Which cluster would the first series belong to?\n# Notice that newdata is provided as a list\npredict(pc.ndtw, newdata = series[1L])\n\n# Custom hierarchical clustering\n\nrequire(cluster)\n\nhc.diana <- tsclust(series, type = \"h\", k = 4L,\n distance = \"L2\", trace = TRUE,\n control = hierarchical_control(method = diana))\n\nplot(hc.diana, type = \"sc\")\ntsclust\n\nC tadpole clustering\n\npcNtadp \\M tsclustHseriesL type \\] BtadpoleBL k \\] TL\n\nC modify plot, show only clusters S and T\nplot(pcNtadp, clus \\] S:TL)\nlabsNarg \\] listHtitle \\] BtadpoleL clusters S and TBL\nx \\] BtimeBL y \\] BseriesBII\n\nC saving and modifying the ggplot object with custom time labels\nrequire(scales)\nt <- seq(sysNdateHIL, len \\] lengthHseries{{Ql}}IL, by \\] BdayBI\ngpc \\M plotHpcNtadpL time \\] tL plot \\] falseI\ngpc K ggplotR::scale_x_dateHlabels \\] date_formatHBEbMEyBIL\nbreaks \\] date_breaksHBR monthsBII\n\nC specifying a centroid function for prototype extraction in hierarchical clustering\nC seed is due to possible randomness in shape_extraction when selecting a basis series\nhcNsbd \\M tsclustHchartrajL type \\] BhierarchicalBL k \\] RPlL distance \\] BsbdBL\npreproc \\] zscoreL centroid \\] shape_extractionL seed \\] SRUQL trace \\] trueL\n\nC using parallel computation to optimize several random repetitions and distance matrix calculation\nrequire(doparallel)\ncl \\M makeclusterHdetectcoresHII\ninvisibleHclusterevalqHclL library(dtwclust)\nregisterdoparallelHclI\nCC use constrained dtw and pam\npcNdtw \\M tsclustHchartrajL k \\] RPlL seed \\] SRUQL trace \\] trueL\nargs \\] tsclust_argsHdist \\] listHwindowNsize \\] QXlIII\n\nCC use constrained dtw with dba centroids\npcNdba \\M tsclustHchartrajL k \\] RPlL centroid \\] BdbaBL seed \\] SRUQL trace \\] trueL\nargs \\] tsclust_argsHdist \\] listHwindowNsize \\] QXlIL\n\n# saving and modifying the ggplot object with custom time labels\n# use constrainted dtw with pam centroids\ngpc + ggpcl2::scaleHxL.date(labs \\] date_formatHUSCMMDDHHMMZ\\\")\nbreaks \\] date_breaksH2 months\")\nControl parameters for clusterings with tsclust()\n\nDescription\n\nControl parameters for fine-grained control.\n\nUsage\n\n```r\npartitional_control(pam.precompute = TRUE, iter.max = 100L, nrep = 1L, symmetric = FALSE, packages = character(0L), distmat = NULL, pam.sparse = FALSE, version = 2L)\n```\n\n```r\nhierarchical_control(method = \"average\", symmetric = FALSE, packages = character(0L), distmat = NULL)\n```\n\n```r\nfuzzy_control(fuzziness = 2, iter.max = 100L, delta = 0.001, packages = character(0L), symmetric = FALSE, version = 2L, distmat = NULL)\n```\n\n```r\ntaxpole_control(dc, window.size, lb = \"lbk\")\n```\n\n```r\ntsclust_args(preproc = list(), dist = list(), cent = list())\n```\n\nArguments\n\n- **pam.precompute**: Logical flag. Precompute the whole distance matrix once and reuse it on each iteration if using PAM centroids. Otherwise calculate distances at every iteration. See details.\niter.max Integer. Maximum number of allowed iterations for partitional/fuzzy clustering.\nnrep Integer. How many times to repeat clustering with different starting points (i.e.,\ndifferent random seeds).\nsymmetric Logical flag. Is the distance function symmetric? In other words, is dist(x,y)\n== dist(y,x)? If TRUE, only half the distance matrix needs to be computed.\nAutomatically detected and overridden for the distances included in dtwclust.\npackages Character vector with the names of any packages required for custom proxy\nfunctions. Relevant for parallel computation, although since the distance entries\nare re-registered in each parallel worker if needed, this is probably useless, but\njust in case.\ndistmat If available, the cross-distance matrix can be provided here. Only relevant for\npartitional with PAM centroids, fuzzy with FCMdd centroids, or hierarchical\nclustering.\npam.sparse Attempt to use a sparse matrix for PAM centroids. See details.\nversion Which version of partitional/fuzzy clustering to use. See details.\nmethod Character vector with one or more linkage methods to use in hierarchical proce-\ndures (see stats::hclust()), the character \"all\" to use all of the available\nones, or a function that performs hierarchical clustering based on distance ma-\ntrices (e.g. cluster::diana()). See details.\nfuzziness Numeric. Exponent used for fuzzy clustering. Commonly termed m in the liter-\nature.\ndelta Numeric. Convergence criterion for fuzzy clustering.\ndc The cutoff distance for the TADPole algorithm.\nwindow.size The window.size specifically for the TADPole algorithm.\nlb The lower bound to use with TADPole. Either \"lbb\" or \"lbi\".\npreproc A list of arguments for a preprocessing function to be used in tsclust().\ndist A list of arguments for a distance function to be used in tsclust().\ncent A list of arguments for a centroid function to be used in tsclust().\n\nDetails\n\nThe functions essentially return their function arguments in a classed list, although some checks are\nperformed.\n\nRegarding parameter version: the first version of partitional/fuzzy clustering implemented in the\npackage always performed an extra iteration, which is unnecessary. Use version 1 to mimic this\nprevious behavior.\n\nPartitional\n\nWhen pam.precompute = FALSE, using pam.sparse = TRUE defines a sparse matrix (refer to\nMatrix::sparseMatrix()) and updates it every iteration (except for \"dtw_lb\" distance). For most\ncases, precomputing the whole distance matrix is still probably faster. See the timing experiments\nin browseVignettes(\"dtwclust\").\n\nParallel computations for PAM centroids have the following considerations:\n• If `pam.precompute` is `TRUE`, both distance matrix calculations and repetitions are done in parallel, regardless of `pam.sparse`.\n• If `pam.precompute` is `FALSE` and `pam.sparse` is `TRUE`, repetitions are done sequentially, so that the distance calculations can be done in parallel and the sparse matrix updated iteratively.\n• If both `pam.precompute` and `pam.sparse` are `FALSE`, repetitions are done in parallel, and each repetition performs distance calculations sequentially, but the distance matrix cannot be updated iteratively.\n\nHierarchical\n\nThere are some limitations when using a custom hierarchical function in method: it will receive the lower triangular of the distance matrix as first argument (see `stats::as.dist()` and the result should support the `stats::as.hclust()` generic. This functionality was added with the `cluster` package in mind, since its functions follow this convention, but other functions could be used if they are adapted to work similarly.\n\nTADPole\n\nWhen using TADPole, the `dist` argument list includes the `window.size` and specifies `norm = \"L2\"`.\n\n---\n\n**TSClusters-class**\n\nClass definition for `TSClusters` and derived classes\n\n---\n\n**Description**\n\nFormal S4 classes for time-series clusters. See class hierarchy and slot organization at the bottom.\n\n**Details**\n\nThe base class is `TSClusters`. The 3 classes that inherit from it are: `PartitionalTSClusters`, `HierarchicalTSClusters` and `FuzzyTSClusters`.\n\n`HierarchicalTSClusters` also contain `stats::hclust()` as parent class.\n\nPackage `clue` is supported, but generics from `flexclust` are not. See also `TSClusters-methods`.\n\n**Slots**\n\ncall The function call.\nfamily An object of class `tsclustFamily`.\ncontrol An appropriate control object for `tsclust()`. See `tsclust-controls`.\ndatalist The provided data in the form of a list, where each element is a time series.\ntype A string indicating one of the supported clustering types of `tsclust()`.\ndistance A string indicating the distance used.\ncentroid A string indicating the centroid used.\npreproc A string indicating the preprocessing used.\nk Integer indicating the number of desired clusters.\n\ncluster Integer vector indicating which cluster a series belongs to (crisp partition). For fuzzy clustering, this is based on distance, not on fcluster. For hierarchical, this is obtained by calling stats::cutree() with the given value of k.\n\ncentroids A list with the centroid time series.\n\ndistmat If computed, the cross-distance matrix.\n\nproctime Time during function execution, as measured with base::proc.time().\n\ndots The contents of the original call’s ellipsis (...).\n\nargs The contents of the original call’s args parameter. See tsclust_args().\n\nseed The random seed that was used.\n\niter The number of iterations used.\n\nconverged A logical indicating whether the function converged.\n\nclusinfo A data frame with two columns: size indicates the number of series each cluster has, and av_dist indicates, for each cluster, the average distance between series and their respective centroids (crisp partition).\n\ncldist A column vector with the distance between each series in the data and its corresponding centroid (crisp partition).\n\nmethod A string indicating which hierarchical method was used.\n\nfcluster Numeric matrix that contains membership of fuzzy clusters. It has one row for each series and one column for each cluster. The rows must sum to 1. Only relevant for fuzzy clustering.\n\nTSClusters\n\nThe base class contains the following slots:\n\n- call\n- family\n- control\n- datalist\n- type\n- distance\n- centroid\n- preproc\n- k\n- cluster\n- centroids\n- distmat\n- proctime\n- dots\n- args\n- seed\nPartitionalTSClusters\n\nThis class adds the following slots to the base class:\n\n- iter\n- converged\n- clusinfo\n- cldist\n\nHierarchicalTSClusters\n\nThis class adds the following slots to the base class:\n\n- method\n- clusinfo\n- cldist\n\nFuzzyTSClusters\n\nThis class adds the following slots to the base class:\n\n- iter\n- converged\n- fcluster\n\nSee Also\n\nTSClusters-methods\n\nDescription\n\nMethods associated with TSClusters and derived objects.\n\nUsage\n\n```r\n## S4 method for signature 'TSclusters'\ninitialize(.Object, ..., override.family = TRUE)\n\n## S4 method for signature 'TSclusters'\nshow(object)\n\n## S3 method for class 'TSclusters'\nupdate(object, ..., evaluate = TRUE)\n```\n## S4 method for signature 'TSClusters'\nupdate(object, ..., evaluate = TRUE)\n\n## S3 method for class 'TSClusters'\npredict(object, newdata = NULL, ...)\n\n## S4 method for signature 'TSClusters'\npredict(object, newdata = NULL, ...)\n\n## S3 method for class 'TSClusters'\nplot(x, y, ..., clus = seq_len(x@k),\n labs.arg = NULL, series = NULL, time = NULL, plot = TRUE,\n type = NULL, labels = NULL)\n\n## S4 method for signature 'TSClusters,missing'\nplot(x, y, ..., clus = seq_len(x@k),\n labs.arg = NULL, series = NULL, time = NULL, plot = TRUE,\n type = NULL, labels = NULL)\n\n### Arguments\n\n- **object**: A TSClusters prototype. You shouldn't use this, see Initialize section and the examples.\n- **...**: For initialize, any valid slots. For plot, passed to ggplot2::geom_line() for the plotting of the cluster centroids, or to stats::plotHclust(); see Plotting section and the examples. For update, any supported argument. Otherwise ignored.\n- **override.family**: Logical. Attempt to substitute the default family with one that conforms to the provided elements? See Initialize section.\n- **object, x**: An object that inherits from TSClusters as returned by tsclust().\n- **evaluate**: Logical. Defaults to TRUE and evaluates the updated call, which will result in a new TSclusters object. Otherwise, it returns the unevaluated call.\n- **newdata**: New data to be assigned to a cluster. It can take any of the supported formats of tsclust(). Note that for multivariate series, this means that it must be a list of matrices, even if the list has only one matrix.\n- **y**: Ignored.\n- **clus**: A numeric vector indicating which clusters to plot.\n- **labs.arg**: A list with arguments to change the title and/or axis labels. See the examples and ggplot2::labs() for more information.\n- **series**: Optionally, the data in the same format as it was provided to tsclust().\n- **time**: Optional values for the time axis. If series have different lengths, provide the time values of the longest series.\n- **plot**: Logical flag. You can set this to FALSE in case you want to save the ggplot object without printing anything to screen.\nMore parameters can be provided, e.g. for plotting.\n\nPredict\n\nThe predict generic can take the usual newdata argument. If NULL, the method simply returns the obtained cluster indices. Otherwise, a nearest-neighbor classification based on the centroids obtained from clustering is performed:\n\n1. newdata is preprocessed with object@family@preproc using the parameters in object@args$preproc.\n2. A cross-distance matrix between the processed series and object@centroids is computed with object@family@dist using the parameters in object@args$dist.\n3. For non-fuzzy clustering, the series are assigned to their nearest centroid’s cluster. For fuzzy clustering, the fuzzy membership matrix for the series is calculated. In both cases, the function in object@family@cluster is used.\nPlotting\n\nThe plot method uses the ggplot2 plotting system (see `ggplot2::ggplot()`).\n\nThe default depends on whether a hierarchical method was used or not. In those cases, the dendrogram is plotted by default; you can pass any extra parameters to `stats::plot.hclust()` via the ellipsis (...).\n\nOtherwise, the function plots the time series of each cluster along with the obtained centroid. The default values for cluster centroids are: `linetype = \"dashed\", size = 1.5, colour = \"black\", alpha = 0.5`. You can change this by means of the ellipsis (...).\n\nYou can choose what to plot with the `type` parameter. Possible options are:\n\n- \"dendrogram\": Only available for hierarchical clustering.\n- \"series\": Plot the time series divided into clusters without including centroids.\n- \"centroids\": Plot the obtained centroids only.\n- \"sc\": Plot both series and centroids\n\nIn order to enable labels on the (non-dendrogram) plot, you have to select an option that plots the series and at least provide an empty list in the `labels` argument. This list can contain arguments for `ggrepel::geom_label_repel()` and will be passed along. The following are set by the plot method if they are not provided:\n\n- \"mapping\": set to `aes_string(x = \"t\", y = \"value\", label = \"label\")`\n- \"data\": a data frame with as many rows as series in the `datalist` and 4 columns:\n - `t`: x coordinate of the label for each series.\n - `value`: y coordinate of the label for each series.\n - `cl`: index of the cluster to which the series belongs (i.e. `x@cluster`).\n - `label`: the label for the given series (i.e. `names(x@datalist)`).\n\nYou can provide your own data frame if you want, but it must have those columns and, even if you override `mapping`, the `cl` column must have that name. The method will attempt to spread the labels across the plot, but note that this is **subject to randomness**, so be careful if you need reproducibility of any commands used after plotting (see examples).\n\nIf created, the function returns the gg object invisibly, in case you want to modify it to your liking. You might want to look at `ggplot2::ggplot_build()` if that’s the case.\n\nIf you want to free the scale of the X axis, you can do the following:\n\n```r\nplot(x, plot = FALSE) + facet_wrap(~cl, scales = \"free\")\n```\n\nFor more complicated changes, you’re better off looking at the source code at `https://github.com/asardaes/dtwclus/blob/master/R/S4-TSClusters-methods.R` and creating your own plotting function.\n\nExamples\n\ndata(uciCT)\n\n# Assuming this was generated by some clustering procedure\ncentroids <- CharTraj[seq(1L, 100L, 5L)]\ncluster <- unclass(CharTrajLabels)\n\npc_obj <- new(\"PartitionalTSClusters\",\n type = \"partitional\", datalist = CharTraj,\n centroids = centroids, cluster = cluster,\n distance = \"sbd\", centroid = \"dba\",\n control = partitional_control(),\n args = tsclust_args(cen = list(window.size = 8L, norm = \"L2\")))\n\nfc_obj <- new(\"FuzzyTSClusters\",\n type = \"fuzzy\", datalist = CharTraj,\n centroids = centroids, cluster = cluster,\n distance = \"sbd\", centroid = \"fcm\",\n control = fuzzy_control())\n\nshow(fc_obj)\n\n## Not run:\nplot(pc_obj, type = \"c\", linetype = \"solid\",\n labs.arg = list(title = \"Clusters' centroids\"))\n\nset.seed(15L)\nplot(pc_obj, labels = list(nudge_x = -5, nudge_y = 0.2),\n clus = c(1L,4L))\n\n## End(Not run)\n\n---\n\n### Description\n\nFormal S4 class with a family of functions used in `tsclust()`.\n\n### Details\n\nThe custom implementations also handle parallelization.\n\nSince the distance function makes use of `proxy`, it also supports any extra `proxy::dist()` parameters in . . .\n\nThe prototype includes the `cluster` function for partitional methods, as well as a pass-through `preproc` function. The initializer expects a control from `tsclust-controls`. See more below.\n\n### Slots\n\n- `dist` The function to calculate the distance matrices.\n- `allcent` The function to calculate centroids on each iteration.\n- `cluster` The function used to assign a series to a cluster.\n- `preproc` The function used to preprocess the data (relevant for `stats::predict()`).\nDistance function\n\nThe family’s dist() function works like proxy::dist() but supports parallelization and optimized symmetric calculations. If you like, you can use the function more or less directly, but provide a control argument when creating the family (see examples). However, bear in mind the following considerations.\n\n- The second argument is called centroids (inconsistent with proxy::dist()).\n- If control$distmat is not NULL, the function will try to subset it.\n- If control$symmetric is TRUE, centroids is NULL, and there is no argument pairwise that is TRUE, only half the distance matrix will be computed.\n - If the distance was registered in proxy::pr_DB with loop = TRUE and more than one parallel worker is detected, the computation will be in parallel (using multi-processing with foreach::foreach()), otherwise it will be sequential with proxy::dist().\n- The function always returns a crossdist matrix.\n\nNote that all distances implemented as part of dtwclus have custom proxy loops that use multi-threading independently of foreach, so see their respective documentation to see what optimizations apply to each one.\n\nFor distances not included in dtwclus, the symmetric, parallel case mentioned above makes chunks for parallel workers, but they are not perfectly balanced, so some workers might finish before the others.\n\nCentroid function\n\nThe default partitional allcent() function is a closure with the implementations of the included centroids. The ones for DBA(), shape_extraction() and sdtw_cent() can use multi-process parallelization with foreach::foreach(). Its formal arguments are described in the Centroid Calculation section from tsclust().\n\nNote\n\nThis class is meant to group together the relevant functions, but they are not linked with each other automatically. In other words, neither dist nor allcent apply preproc. They essentially don’t know of each other’s existence.\n\nSee Also\n\ndtw_basic(), dtw_lb(), gak(), lb_improved(), lb_keogh(), sbd(), sdtw().\n\nExamples\n\n```r\n## Not run:\ndata(uciCT)\n# See \"GAK\" documentation\nfam <- new(\"tsclustFamily\", dist = \"gak\")\n\n# This is done with symmetric optimizations, regardless of control$symmetric\ncrossdist <- fam@dist(CharTraj, window.size = 18L)\n```\n# This is done without symmetric optimizations, regardless of control$symmetric\ncrossdist <- fam@dist(CharTraj, CharTraj, window.size = 10L)\n\n# For non-dtwclust distances, symmetric optimizations only apply\n# with an appropriate control AND a single data argument:\nfam <- new(\"tsclustFamily\", dist = \"dtw\",\n control = partitional_control(symmetric = TRUE))\nfam@dist(CharTraj[1L:5L])\n\n# If you want the fuzzy family, use fuzzy = TRUE\nffam <- new(\"tsclustFamily\", control = fuzzy_control(), fuzzy = TRUE)\n\n## End(Not run)\n\n---\n\ntslist\n\nCoerce matrices or data frames to a list of time series\n\nDescription\n\nChange a matrix or data frame to a list of univariate time series\n\nUsage\n\n```r\ntslist(series, simplify = FALSE)\n```\n\nArguments\n\n- **series**: A matrix or data frame where each row is a time series.\n- **simplify**: Coerce all series in the resulting list to either matrix (multivariate) or numeric (univariate).\n\nDetails\n\nAlmost all functions in `dtwclust` work internally with lists of time series. If you want to avoid constant coercion, create a list of time series once by calling this function.\n\nFor matrices and data frames, each `row` is considered as one time series. A list input is simply passed through.\n\nValue\n\nA list of time series.\n\nNote\n\nThe function assumes that matrix-like objects can be first coerced via `base::as.matrix()`, so that the result can be indexed with `series[i, ]`.\n\nNo consistency checks are performed by this function.\nuciCT Subset of character trajectories data set\n\nDescription\nSubset: only 5 examples of each considered character. See details.\n\nFormat\nLists with 100 elements. Each element is a time series. Labels included as factor vector.\n\nDetails\nQuoting the source:\n\"Multiple, labelled samples of pen tip trajectories recorded whilst writing individual characters. All samples are from the same writer, for the purposes of primitive extraction. Only characters with a single pen-down segment were considered.\"\n\nThe subset included in CharTraj has only 5 examples of the X velocity for each character. A vector with labels is also loaded in CharTrajLabels.\n\nThe subset included in CharTrajMV has 5 examples too, but includes tip force as well as X and Y velocity. Each element of the list is a multivariate series with 3 variables.\n\nPlease note that even though both CharTraj and CharTrajMV have the same series names, the actual series in each subset are not the same, i.e., CharTraj$A.V1 is not in CharTrajMV$A.V1.\n\nSource\nhttps://archive.ics.uci.edu/ml/datasets/Character+Trajectories\n\nzscore Wrapper for z-normalization\n\nDescription\nWrapper for function base::scale() that returns zeros instead of NaN. It also supports matrices, data frames, and lists of time series.\n\nUsage\nzscore(x, ..., multivariate = FALSE, keep.attributes = FALSE, error.check = TRUE)\nArguments\n\nx Data to normalize. Either a vector, a matrix/data.frame where each row is to be normalized, or a list of vectors/matrices.\n\n... Further arguments to pass to \\texttt{base::scale()}. \nmultivariate Is \\texttt{x} a multivariate time series? It will be detected automatically if a list is provided in \\texttt{x}. \nkeep.attributes Should the mean and standard deviation returned by \\texttt{base::scale()} be preserved? \nerror.check Logical indicating whether the function should try to detect inconsistencies and give more informative errors messages. Also used internally to avoid repeating checks.\n\nDetails\n\nMultivariate series must have time spanning the rows and variables spanning the columns.\n\nValue\n\nNormalized data in the same format as provided.\nIndex\n\naes_string, 66\nas.matrix, 4\n\nbase::as.matrix(), 4, 69\nbase::library(), 4\nbase::Map(), 7\nbase::proc.time(), 6, 62\nbase::RNGkind(), 3\nbase::scale(), 70, 71\nbase::seq(), 48\n\nCharTraj (uciCT), 70\nCharTrajLabels (uciCT), 70\nCharTrajMV, 52\nCharTrajMV (uciCT), 70\ncue::cl_medoid(), 48\ncluster::agnes(), 31\ncluster::diana(), 60\ncompare_clusterings, 5\ncompare_clusterings(), 3, 4, 11, 12, 17, 39–41, 47–49, 51, 55\ncompare_clusterings_configs, 11\ncompare_clusterings_configs(), 5, 7, 38\ncompute_envelope, 12\ncompute_envelope(), 33, 35\ncvi, 13\ncvi(), 17, 32\ncvi,FuzzyTSClusters (cvi), 13\ncvi,FuzzyTSClusters-method (cvi), 13\ncvi,HierarchicalTSClusters (cvi), 13\ncvi,HierarchicalTSClusters-method (cvi), 13\ncvi,matrix-method (cvi), 13\ncvi,PartitionalTSClusters (cvi), 13\ncvi,PartitionalTSClusters-method (cvi), 13\ncvi_evaluators, 17\n\nDBA, 18\ndba (DBA), 18\n\nDBA(), 15, 53, 68\ndba(), 48\ndist, 23, 30, 33, 35, 42, 43\ndtw2, 21\ndtw2(), 54\ndtw::dtw(), 4, 21, 22, 26, 54\ndtw::stepPattern, 22\ndtw_basic, 22\ndtw_basic(), 4, 16, 18, 19, 26, 27, 48, 54, 68\ndtw_lb, 26\ndtw_lb(), 54, 68\ndtwclust (dtwclust-package), 3\ndtwclust-package, 3\ndtwclustTimings, 22\n\nflexclust::comPart(), 15\nforeach, 19, 23, 27, 30, 33, 36, 42, 43, 45, 51, 55\nforeach::foreach(), 5, 47, 50, 68\nfuzzy_control (tsclust-controls), 59\nFuzzyTSClusters (TSClusters-class), 61\nFuzzyTSClusters-class (TSClusters-class), 61\n\nGAK, 29\ngak (GAK), 29\ngak(), 54, 68\nggplot2::geom_line(), 64\nggplot2::ggplot(), 66\nggplot2::ggplot_build(), 66\nggplot2::labs(), 64\nggrepel::geom_label_repel(), 66\n\nhierarchical_control (tsclust-controls), 59\nhierarchical_control(), 51\nHierarchicalTSClusters (TSClusters-class), 61\nHierarchicalTSClusters-class (TSClusters-class), 61\ninitializeTSClusters\n (tsclusters-methods), 63\ninitializeTSClusters-method\n (tsclusters-methods), 63\ninteractive_clustering\ninteractive_clustering(), 31\ninteractive_clusteringHI\n 3, 31, 47, 49, 51, 55\n\nlb_improved, 32\nlb_improved(), 26–28, 50, 54, 68\nlb_keogh, 34\nlb_keogh(), 28, 50, 54, 68\n\nMatrix::sparseMatrix(), 60\nmethods::new(), 65\n\nNCCc, 37\nNCCc(), 42\nnloptr::nloptr(), 44\n\npackage, 4\npam_cent, 37\npam_cent(), 53\nparallel::clusterEvalQ(), 48, 55\nparallel::clusterExport(), 48\nparallel::nextRNGStream(), 55\npartitional_control (tsclust-controls), 59\n\npartitional_control(), 55\nPartitionalTSClusters\n (TSClusters-class), 61\nPartitionalTSClusters-class\n (TSClusters-class), 61\npdc_configs, 38\npdc_configs(), 5, 7, 11, 12\nplot,TSClusters,missing\n (tsclusters-methods), 63\nplot,TSClusters,missing-method\n (tsclusters-methods), 63\nplot.TSClusters (tsclusters-methods), 63\npr_DB, 23, 30, 33, 35, 42, 43\npredict,TSClusters\n (tsclusters-methods), 63\npredict,TSClusters-method\n (tsclusters-methods), 63\npredict.TSClusters\n (tsclusters-methods), 63\nproxy::dist(), 4, 21, 27, 30, 52, 54, 67, 68\nproxy::pr_DB, 68\nproxy::pr_DB(), 38, 54\nproxy::simil(), 30\n\nRcppParallel, 19, 23, 27, 30, 33, 35, 42, 43, 45, 51\nRcppParallel::defaultNumThreads(), 19, 23, 27, 30, 33, 35, 42, 43, 45, 51\nRcppParallel::RcppParallel, 50\nRcppParallel::setThreadOptions(), 19, 23, 27, 30, 33, 42, 43, 45, 51\nreinterpolate, 39\nreinterpolate(), 30, 52\nrepeat_clustering, 40\nrepeat_clustering(), 6, 48\n\nSBD, 41\nsbd (SBD), 41\nSBD(), 37, 46\nsbd(), 54, 68\nsdtw, 43\nsdtw(), 54, 68\nsdtw_cent(), 54, 68\nshape_extraction, 45\nshape_extraction(), 15, 42, 53, 54, 68\nshiny::runApp(), 31, 47\nshow,TSClusters (tsclusters-methods), 63\nshow,TSClusters-method\n (tsclusters-method), 63\n\nssdtwclust, 47\nssdtwclust(), 3, 4, 55\nstats::approx(), 39\nstats::as.dist(), 61\nstats::as.hclust(), 61\nstats::cutree(), 62\nstats::hclust(), 51, 52, 60, 61\nstats::plot.hclust(), 64, 66\nstats::predict(), 54, 67\n\nTADPole, 49\ntadpole (TADPole), 49\nTADPole(), 16, 52, 55\ntadpole_control (tsclust-controls), 59\ntsclust, 51\ntsclust(), 3–7, 14, 31, 32, 40, 41, 50, 59–61, 64, 67, 68\ntsclust-controls, 11, 12, 52–55, 59, 61, 65, 67\ntsclust_args (tsclust-controls), 59\ntsclust_args(), 52, 62\nTSClusters, 7, 16, 17, 40, 41, 52, 55, 63, 64\nTSClusters (TSClusters-class), 61\nTSClusters-class, 61\nTSClusters-methods, 31, 54, 55, 61, 63\nTSClusters-methods\n (tsclusters-methods), 63\ntsclusters-methods, 63\ntsclustFamily, 55, 61\ntsclustFamily (tsclustFamily-class), 67\ntsclustFamily-class, 67\ntslist, 69\ntslist(), 5, 38, 51\n\nciCT, 70\nuciCT (uciCT), 70\nupdate, TSClusters (tsclusters-methods), 63\nupdate, TSClusters-method\n (tsclusters-methods), 63\nupdate.TSClusters (tsclusters-methods), 63\nutils::Rscript(), 4\n\ntscore, 70\ntscore(), 45, 46, 52, 54"}}},{"rowIdx":277,"cells":{"id":{"kind":"string","value":"477a90cb7026d833e6a96756be4dd8dfc4e3a129"},"text":{"kind":"string","value":"A SYNTACTIC APPROACH TO TYPE SOUNDNESS\n\nAndrew K. Wright* Matthias Felleisen*\n\nDepartment of Computer Science\nRice University\nHouston, TX 77251-1892\nJune 18, 1992\n\nRice Technical Report TR91-160\nTo appear in: Information and Computation\n\nAbstract\n\nWe present a new approach to proving type soundness for Hindley/Milner-style polymorphic type systems. The keys to our approach are (1) an adaptation of subject reduction theorems from combinatory logic to programming languages, and (2) the use of rewriting techniques for the specification of the language semantics. The approach easily extends from polymorphic functional languages to imperative languages that provide references, exceptions, continuations, and similar features. We illustrate the technique with a type soundness theorem for the core of STANDARD ML, which includes the first type soundness proof for polymorphic exceptions and continuations.\n\n1 Type Soundness\n\nStatic type systems for programming languages attempt to prevent the occurrence of type errors during execution. A definition of type error depends on a specific language and type system, but always includes the use of a function on arguments for which it is not defined, and the attempted application of a non-function. A static type system is sound if well-typed programs cannot cause type errors; a programming language with a sound static type system is strongly typed [7].\n\nWhile it is easy to design a sound type system for an explicitly typed monomorphic language, the formulation of a sound type system for a language based on Hindley/Milner-style polymorphism and type inference is delicate [6, 8, 15, 17, 20, 37]. Although the treatment of purely functional languages is relatively well understood in this framework, the incorporation of imperative features such as references and exceptions requires extreme care, and the soundness of such systems is not obvious. A formal proof of soundness is\n\n*This research was supported in part by the United States Department of Defense under a National Defense Science and Engineering Graduate Fellowship, by NSF grant CCR 89-17022, and by Texas Grant ARP/ATP-91 #009604-014.\nrequired to lend credibility to the claim that such a system prevents type errors, and may be a crucial tool in the design of the type system.\n\nWe view a static type system for an implicitly typed language as a filter that selects well-typed programs from a larger universe of untyped programs. A partial function eval : Programs ∪ {wrong} → Answers defines the semantics of untyped programs. The result wrong is returned for programs whose evaluation causes a type error; eval is undefined for programs whose evaluation does not terminate. Let ▷ e : τ mean that the type system assigns program e the type τ, i.e., e is well-typed. The simplest soundness property states that well-typed programs do not yield wrong [20].\n\n**Definition (Weak Soundness)** If ▷ e : τ then eval(e) ≠ wrong.\n\nWhile weak soundness establishes that a static type system achieves its primary goal of preventing type errors, it is often possible to demonstrate a stronger property that relates the answer produced to the type of the program. If we view each type τ as denoting different subsets Vτ of the set of all answers V, then strong soundness states that an answer v produced by a terminating program of type τ is an element of the subset Vτ.\n\n**Definition (Strong Soundness)** If ▷ e : τ and eval(e) = v then v ∈ Vτ.\n\nStrong soundness permits an implementation of the language to associate the representation of a value with its type, and thereby omit the representation tags required by dynamically typed languages. Weak soundness follows from strong soundness since wrong is not a member of Vτ for any type τ.\n\nSignificant effort has been invested in proving type soundness for Hindley/Milner-style type systems, and their practical realization in the programming language STANDARD ML [22, 23]. Soundness proofs exist for the functional fragment [20, 36], for extensions including references [6, 17, 35, 37], and for a monomorphic language including first-class continuations [8]. However, there are several drawbacks to the existing proofs. Proofs of type soundness are sensitive to the precise formulation of the semantics of the language—different techniques are required for denotational versus operational formulations of the semantics, and even for different languages within the same semantic framework. The proofs for two different languages are difficult to reconcile to prove soundness for a language including features of both. The existing techniques are complicated, and the resulting proofs are lengthy and error-prone. For an illustration of the difficulties with such proofs, we refer the reader to Tofte’s [37] discussion of Damas’s [6] faulty proof of a type soundness theorem for a polymorphic language with references.\n\nWe present a simple approach to the proof of soundness for Hindley/Milner-style polymorphic type systems. Our approach is based on subject reduction, a classical result from combinatory logic [4], and on rewriting as a means to specifying operational semantics [11, 12, 13, 14]. To demonstrate the approach, we develop a proof of soundness for the core of STANDARD ML, which extends a functional polymorphic language with references and exceptions. We also show soundness for an extension to STANDARD ML with first-class continuations. In principle, our approach is uniformly applicable to any language;\n\n---\n\n1Mitchell and Harper refer to the functional polymorphic sublanguage as the essence of ML [24]. However, the difficulties of typing references and exceptions [6, 17, 35, 37] and the fact that they cannot be expressed by facilities of the functional core [10] indicate that they are equally important.\nin practice, the resulting proofs are lengthy but simple, requiring only ordinary inductive\ntechniques.\n\nIn the next section, we describe a prototypical functional language with a polymorphic\ntype system, and discuss the various approaches that have previously been used to prove\ntype soundness. Section 3 presents the essence of our approach to proving type soundness;\nthe remaining sections develop illustrative proofs of type soundness for a specific functional\nlanguage and various extensions.\n\n2 Previous Approaches to Proving Type Soundness\n\nAny proof of type soundness is intimately tied to the formulation of the semantics of the\nlanguage. The earlier proofs relied on denotational semantics; later proofs used structural\noperational semantics. The following two subsections briefly present these approaches from\na historical perspective. The third subsection discusses the problems with them. We begin\nwith a brief introduction to the formulation of Hindley/Milner-style type systems, in order\nto introduce our notation.\n\nOur prototypical functional language has the following (abstract) syntax:\n\n\\[ e ::= c \\mid x \\mid \\lambda x.e \\mid e_1 e_2 \\mid \\textbf{let} \\; x \\; \\textbf{be} \\; e_1 \\; \\text{in} \\; e_2 \\]\n\nwhere \\( x \\in \\text{Var} \\) and \\( c \\in \\text{Const} \\). Constants (\\text{Const}) include both data (integer, real, boolean,\netc.) and operations (+, ÷, \\&, ∨, etc.). Variables (\\text{Var}) are lexically scoped. Juxtaposition\ndenotes application and is left associative; \\( \\lambda \\)-expressions construct call-by-value procedural\nabstractions. Semantically the \\textbf{let}-expression behaves like \\(((\\lambda x.e_2)e_1)\\), binding the value of\n\\( e_1 \\) to \\( x \\) in \\( e_2 \\); however, the type system allows \\( x \\) to be \\textit{polymorphic}: different occurrences\nof \\( x \\) in \\( e_2 \\) may be assigned different types.\n\nA polymorphic type system for this language has types of the form:\n\n\\[ \\tau ::= \\iota_1 \\mid \\ldots \\mid \\iota_n \\mid \\tau_1 \\to \\tau_2 \\]\n\nwhere \\( \\iota_1, \\ldots, \\iota_n \\) are ground types like \\textit{int} and \\textit{bool}. The type system is formulated as\na deductive proof system that assigns types to expressions. The proof system produces\nconclusions, or \\textit{type judgments}, of the form \\( \\Gamma \\vdash e : \\tau \\), meaning that expression \\( e \\) has type\n\\( \\tau \\) in type environment \\( \\Gamma \\). Type environments are finite maps from variables to types, and\nare used to give types to open expressions. The typing rules are:\n\n\\begin{enumerate}\n \\item[(\\textbf{var})] \\hspace{1cm} \\Gamma \\vdash x : \\tau \\; \\text{if} \\; \\Gamma(x) = \\tau\n \\item[(\\textbf{const})] \\hspace{1cm} \\Gamma \\vdash c : \\tau \\; \\text{if} \\; TypeOf(c) = \\tau\n \\item[(\\textbf{abs})] \\hspace{1cm} \\begin{array}{c}\n \\Gamma[x \\mapsto \\tau_1] \\vdash e : \\tau_2 \\\\\n \\Gamma \\vdash \\lambda x.e : \\tau_1 \\to \\tau_2 \\\\\n \\end{array}\n \\item[(\\textbf{app})] \\hspace{1cm} \\begin{array}{c}\n \\Gamma \\vdash e_1 : \\tau_1 \\to \\tau_2 \\\\\n \\Gamma \\vdash e_2 : \\tau_1 \\\\\n \\Gamma \\vdash e_1 e_2 : \\tau_2 \\\\\n \\end{array}\n \\item[(\\textbf{let})] \\hspace{1cm} \\begin{array}{c}\n \\Gamma \\vdash e_1 : \\tau_1 \\\\\n \\Gamma \\vdash e_2[x \\mapsto e_1] : \\tau_2 \\\\\n \\Gamma \\vdash \\textbf{let} \\; x \\; \\textbf{be} \\; e_1 \\; \\text{in} \\; e_2 : \\tau_2 \\\\\n \\end{array}\n\\end{enumerate}\nThe function $\\text{TypeOf}$ assigns types to constants. $\\Gamma[x \\mapsto \\tau]$ denotes the functional extension or update of map $\\Gamma$ at $x$ to $\\tau$; $e[x \\mapsto e']$ means the capture-avoiding substitution of $e'$ for $x$ in $e$. Programs are closed expressions. A program $e$ is well-typed if it has a type $\\tau$ in the empty type environment; we then write $\\triangleright e : \\tau$.\n\n2.1 Proofs based on Denotational Semantics\n\nMilner [20]: Milner formulated and proved a type soundness theorem for a functional language like the above based on a denotational semantics for the language of untyped expressions. The semantic domain is the solution of the following reflexive domain equation [32]:\n\n$$\n\\begin{align*}\nV &= B_0 \\oplus \\ldots \\oplus B_n \\oplus F \\oplus W \\\\\nF &= V \\rightarrow V\n\\end{align*}\n$$\n\n$B_0, \\ldots, B_n$ are basic domains (with bottom), such as integers and booleans; $F$ is the function domain; $W$ is a domain consisting of the single element $\\text{WRONG}; \\oplus$ is the separated sum; and $\\rightarrow$ builds continuous functions. The meaning function $\\mathcal{E}$ is constructed so as to assign the denotation $\\text{WRONG}$ to programs that result in type errors. To assign meanings to expressions with free variables, the meaning function takes an environment $\\rho : \\text{Var} \\rightarrow \\text{V}$, a finite map from variables to denotational values.\n\nTo establish soundness, Milner introduced a semantic relation $\\models$. This relation identifies each type $\\tau$ with an ideal $V^\\tau$ of the domain $V$ [18]. An ideal is simply a subset of the domain that is closed under certain operations (subset and least upper bounds of finite consistent subsets); each of the basic domains forms an ideal. A denotational value $v \\in V$ possesses type $\\tau$, written $\\models v : \\tau$, if $v$ is a member of the ideal corresponding to $\\tau$, i.e.,\n\n$$\nv \\in V^\\tau \\text{ iff } \\models v : \\tau.\n$$\n\nAn environment $\\rho$ respects a type environment $\\Gamma$, written $\\models \\rho : \\Gamma$, if the domain of $\\rho$ is at least as large as the domain of $\\Gamma$, and for every variable $x$ in the domain of $\\Gamma, \\models \\rho(x) : \\Gamma(x)$.\n\nA semantic soundness theorem states that if an expression $e$ has type $\\tau$ in type environment $\\Gamma$, and if environment $\\rho$ respects $\\Gamma$, then the denotation of $e$ in $\\rho$ possesses type $\\tau$.\n\n**Theorem (Semantic Soundness)** If $\\Gamma \\triangleright e : \\tau$ and $\\models \\rho : \\Gamma$ then $\\models \\mathcal{E}[e] \\rho : \\tau$.\n\nThis theorem is proved by induction on the structure of $e$. Strong soundness follows by restricting the theorem to closed expressions.\n\n**Theorem (Strong Soundness)** If $\\triangleright e : \\tau$ then $\\models \\mathcal{E}[e] \\emptyset : \\tau$.\n\nWeak soundness is a consequence of the fact that $\\text{WRONG}$ does not possess any type.\n\n**Theorem (Weak Soundness)** If $\\triangleright e : \\tau$ then $\\mathcal{E}[e] \\emptyset \\neq \\text{WRONG}$.\nDamas [5, 6]: Damas extended Milner’s results to a language with reference cells and destructive assignment. The proof technique is derived from Milner’s technique; however, the proof is significantly more complicated. The denotational semantics uses the following domain construction:\n\n\\[\n\\begin{align*}\n\\mathcal{V} & = B_0 \\oplus \\ldots \\oplus B_n \\oplus F \\oplus L \\oplus W \\\\\n\\mathcal{F} & = \\mathcal{V} \\rightarrow \\mathcal{S} \\oplus \\mathcal{V} \\oplus \\mathcal{S} \\\\\n\\mathcal{S} & = \\mathcal{V}^* \\\\\nL & = \\mathbb{N}_L \n\\end{align*}\n\\]\n\nwhere the domain of locations \\(L\\) is the flat domain of natural numbers, \\(S\\) is the domain of stores (sequences of values), and \\(\\otimes\\) is the smash product. Procedures take both an input value and a store, and produce a result and a new store. The meaning function is parameterized over both a store and an environment. Due to the presence of stores, types are no longer ideals in \\(\\mathcal{V}\\), but are finite maps from store typings to subsets of \\(\\mathcal{V}\\).\\(^2\\) A store typing is a finite map from locations to the types of values stored there. Since the semantic relation (\\(\\models\\)) must involve the types of values in the store, it can no longer be defined by induction on types; its existence must be established by a category theoretical argument that generalizes the technique of inclusive predicates [31]. The complexity of the semantic relation complicates the proof; indeed, Tofte found a mistake in Damas’s proof, although the theorem is not thought to be false [37: page 2].\n\nAbadi, Cardelli, Pierce, and Plotkin [1]: Abadi et al. demonstrate type soundness for a functional language with a dynamic type and related operations. Their proof with respect to a denotational semantics is similar to Milner’s proof, although it is complicated by the presence of dynamic values. A dynamic value is a pair consisting of a value \\(v\\) and a tag, drawn from a set \\(\\text{TypeCode}\\), that encodes the type of \\(v\\). The domain equation includes a domain of dynamic values \\(D\\):\n\n\\[\n\\begin{align*}\n\\mathcal{V} & = B_0 \\oplus \\ldots \\oplus B_n \\oplus F \\oplus D \\oplus W \\\\\n\\mathcal{F} & = \\mathcal{V} \\rightarrow \\mathcal{V} \\\\\nD & = \\text{TypeCode} \\times \\mathcal{V}\n\\end{align*}\n\\]\n\nAs type codes correspond to types, the denotation of a type code is a type. Types, in turn, denote ideals over \\(\\mathcal{V}\\), but due to the unusual element \\(D\\) of the domain equation, establishing that types denote ideals requires extending the ideal model for recursive types [18]. The proof that the required fixed points exist in the new model involves a metric space argument, but is a straightforward extension of the original. Although the type system Abadi et al. use is not polymorphic, it should be possible to extend the type system and the soundness proof to include polymorphism.\n\nDuba, Harper, and MacQueen [8]: Duba et al. present several languages extending a monomorphic functional core with first-class continuations in the spirit of Scheme [28]. They describe several approaches to proving type soundness for the languages. One is with\n\n\\(^2\\)This is an over-simplification; the reader interested in the precise definition is referred to Damas’s thesis [6].\nrespect to a continuation-passing denotational semantics, based on the following domain equations:\n\n\\[\n\\begin{align*}\nV &= B_0 \\oplus \\ldots \\oplus B_n \\oplus F \\oplus K \\\\\nF &= V \\rightarrow K \\rightarrow A \\\\\nK &= V \\rightarrow A \\\\\nA &= V \\oplus W\n\\end{align*}\n\\]\n\nwhere \\( K \\) is the domain of continuations, and \\( A \\) is the domain of answers. The meaning function \\( \\mathcal{E} \\) takes both an environment and a continuation. Two semantic relations state what it means for a value \\( v \\) to possess a type \\( \\tau \\), written \\( \\models v : \\tau \\), and for a continuation \\( \\kappa \\) to accept a value of type \\( \\tau \\), written \\( \\models \\kappa :: \\tau \\). These relations are defined simultaneously by induction on types. The semantic soundness theorem states that if an expression \\( e \\) has type \\( \\tau \\) in type environment \\( \\Gamma \\), and if \\( \\rho \\) respects \\( \\Gamma \\), and if continuation \\( \\kappa \\) accepts values of type \\( \\tau \\), then the meaning of \\( e \\) in environment \\( \\rho \\) and continuation \\( \\kappa \\) is not wrong.\n\n**Theorem (Semantic Soundness)** If \\( \\Gamma \\triangleright e : \\tau \\) and \\( \\models \\rho : \\Gamma \\) and \\( \\models \\kappa :: \\tau \\) then \\( \\mathcal{E}[e]_\\rho \\kappa \\neq \\text{Wrong} \\).\n\nUnlike in the purely functional setting, the semantic soundness theorem only states that well-typed programs do not go Wrong (weak soundness), not that they produce answers of the expected type. To approach strong soundness, Duba et al. give an argument based on a continuation-passing-style (CPS) translation into the simply typed \\( \\lambda \\)-calculus. For programs of ground type, the denotation of an expression is the same as the denotation of its CPS transform with the identity function as an initial continuation, i.e.,\n\n\\[\n\\mathcal{E}[e]_\\emptyset = \\mathcal{E}[\\text{CPS}(e) \\ (\\lambda x. x)]_\\emptyset.\n\\]\n\nSince strong soundness holds for the simply typed \\( \\lambda \\)-calculus, and \\( \\text{CPS}(e) \\ (\\lambda x. x) \\) has the same type as \\( e \\) for programs of ground type, strong soundness holds for programs of ground type. However, the argument does not extend to higher types. For further details, we refer the reader to their paper [8: page 169].\n\n### 2.2 Proofs based on Structural Operational Semantics\n\n**Tofte** [36, 37]: Tofte reformulated Milner's functional language with a structural operational semantics [27]. The semantics is specified as a deductive proof system; a conclusion \\( E \\vdash e \\Rightarrow v \\) of a deduction states that expression \\( e \\) evaluates to \\( v \\) in value environment \\( E \\). A value environment is a finite map from variables to operational values. Values are either basic constants or closures, which result from the evaluation of \\( \\lambda \\)-expressions. The soundness theorem again requires the definition of a semantic relation (\\( \\equiv \\)) between operational values and types. For basic constants, the relation is explicitly specified by the function \\( \\text{TypeOf} \\); for closures, the relation is defined by induction on types, and by evaluation at correctly typed argument values. The semantic soundness theorem states that if an expression \\( e \\) has type \\( \\tau \\) in type environment \\( \\Gamma \\), and if environment \\( E \\) respects \\( \\Gamma \\), and if \\( e \\) evaluates to a value \\( v \\) in environment \\( E \\), then \\( v \\) possesses type \\( \\tau \\).\n\n**Theorem (Semantic Soundness)** If \\( \\Gamma \\triangleright e : \\tau \\) and \\( \\models : \\Gamma \\) and \\( E \\vdash e \\Rightarrow v \\) then \\( \\models v : \\tau \\).\nThe proof is straightforward, and proceeds by induction on the depth of the deduction of $E \\vdash e \\Rightarrow v$. Strong and weak soundness follow as before.\n\nTofte turned to structural operational semantics in order to consider references. To this end, he reformulated the semantics with conclusions of the form $s, E \\vdash e \\Rightarrow v, s'$, meaning that in environment $E$ and store $s$, expression $e$ evaluates to value $v$ and the new store $s'$. The semantic relation now involves the contents of the store and the store typing $(ST)$, a map from locations to the types of values stored there. The semantic relation $s : ST \\vdash v : \\tau$ may be read as “given the $ST$-typed store $s$, value $v$ possesses type $\\tau$.” Because of the possibility of cycles amongst references in the store, this relation is not definable by induction, but must be defined as the maximal fixed-point of a monotonic operator on the appropriate space. The semantic soundness theorem states that if an expression $e$ has type $\\tau$ in type environment $\\Gamma$, and given store $s$ of type $ST$, environment $E$ respecting $\\Gamma$, and that $e$ evaluates to $v$ and store $s'$, then a typing $ST'$ can be found for $s'$ such that $v$ possesses type $\\tau$.\n\n**Theorem (Semantic Soundness)** If $\\Gamma \\triangleright e : \\tau$ and $s : ST \\vdash E : \\Gamma$ and $s, E \\vdash e \\Rightarrow v, s'$ then there exists $ST'$ such that $s' : ST' \\vdash v : \\tau$.\n\nThe theorem is proved by induction on the depth of the deduction of $s, E \\vdash e \\Rightarrow v, s'$. Lemmas involving the semantic relation are proved using the technique of co-induction that Milner and Tofte developed for this purpose [21]. Leroy and Weis have successfully applied Tofte’s technique to show soundness for a different type system for polymorphic references [17]. Talpin and Jouvelot have also applied the technique to demonstrate soundness for a system that infers types, effects, and regions for references [35].\n\n**Duba, Harper, and MacQueen** [8]: Duba et al. also present a proof of type soundness with respect to a structural operational semantics for a monomorphic language with continuations. The proof is an adaptation of Tofte’s technique; however, the semantics is significantly restructured, as the technique of defunctionalization [30] is used to represent the flow of control explicitly. The semantics has two judgment forms. The first kind of conclusion, $E ; K \\vdash e \\Rightarrow v$, indicates that expression $e$ evaluates to answer $v$ in environment $E$ and continuation $K$. The second kind of conclusion, $v \\vdash K \\Rightarrow v'$, indicates that continuation $K$ evaluated at value $v$ produces answer $v'$. As in the denotational case, two semantic relations are defined, indicating what it means for a value to possess a type ($\\models v : \\tau$), and for a continuation to accept a type ($\\models K :: \\tau$). Like the denotational case, the theorem only establishes weak soundness.\n\n**Theorem (Semantic Soundness)** If $\\Gamma \\triangleright e : \\tau$ and $\\models E : \\Gamma$ and $\\models K :: \\tau$ and $E ; K \\vdash e \\Rightarrow v$ then $v \\neq$ WRONG.\n\nIt is not clear that the proof goes through in the presence of fixed-point operators [8: page 171], nor how to obtain strong soundness in this framework.\n\n2.3 Discussion\n\nIn each case above, the proof of soundness for a language or for a different formulation of a language’s semantics involves the use of a different proof technique. The techniques\nare often unrelated, so they provide no guidance in proving soundness for new languages or language features. A seemingly minor extension to a language may require a complete restructuring of its denotational or structural operational semantics, and may therefore require a completely new approach to re-establish soundness. For example, in introducing references to Milner’s functional language, Damas changed the domain equations for the denotational semantics to accommodate a store component, necessitating a completely different strategy for induction. In introducing type dynamic, Abadi et al. again changed the domain equations, and extended the ideal model of types to match. To accommodate continuations, Duba et al. changed the domain equations yet again, also foregoing the tools developed by Milner and Damas. They used a separate argument to establish strong soundness. In introducing references to an operational formulation of the functional language, Tofte changed the form of judgments obtained by the semantics, and used the technique of co-induction to establish a proof. For continuations in a structural operational semantics, Duba et al. completely altered the semantics, again changing the structure of the proof dramatically.\n\nEach of the above proofs considers a language with a single extension to a functional core. It is natural to ask whether two extensions can be merged, such that a natural union of the two type systems is sound. However, since each of the proofs involves a different technique, it is generally impossible to merge the proofs. Tofte’s proof for references and Duba et al.’s proof for continuations give no direct assurance that Standard ML’s type system is sound, even if the other features of Standard ML are ignored.\n\n3 A Syntactic Approach to Proving Type Soundness\n\nOur approach to type soundness is based upon an operational formulation of a language’s semantics by rewriting. Each intermediate state of an evaluation of a program is itself a program, and the evaluation of a program is performed by successive reductions into a new state: \\( e_1 \\rightarrow e_2 \\rightarrow \\ldots \\) Reduction may either continue forever (e), or may reach a final state where no further evaluation is possible: \\( e_1 \\rightarrow e_k \\) and \\( e_k \\rightarrow e_{k+1} \\). Such a final state represents either an answer or a type error. Thus, proving type soundness reduces to proving that well-typed programs yield only well-typed answers.\n\nProgramming language calculi, like the \\( \\lambda \\)-calculus, are the natural choice to specify the semantics of a language such that each intermediate step of evaluation is a program. Plotkin [26] shows how the semantics of a prototypical functional language relates to the \\( \\lambda \\)-calculus. The \\( \\lambda \\)-calculi extensions for state [12, 14] extend this strategy to languages with references and similar constructs. Likewise, the control calculi [13, 14] can be adapted to address non-local control facilities such as exceptions and first-class continuations.\n\nSince the intermediate states of evaluation are programs, we may apply the type system to deduce a type for each state. Our strategy for proving type soundness rests upon two fundamental observations about the types of states. The first observation is that each intermediate state may be assigned the same type as the original program, i.e., reductions preserve type:\n\n\\[ e_1 \\rightarrow e_k \\]\n\nFurthermore, they take this as “evidence that the addition of [continuations] to Standard ML would be a substantial change, rather than an incremental modification, to the language” [8: page 170]. However, we believe that this only indicates a problem with their semantic framework.\nif $\\triangleright e_1 : \\tau$ and $e_1 \\mapsto e_2$ then $\\triangleright e_2 : \\tau$.\n\nIn combinatory logic, this property is known as subject reduction [4].\n\nThe second observation is that sound type systems do not assign a type to irreducible expressions that are the sources of type errors, such as $1 + \\text{true}$. Furthermore, any expression containing such a subexpression is untypable; we call expressions containing such irreducible subexpressions faulty:\n\nif $e$ is faulty, there is no $\\tau$ such that $\\triangleright e : \\tau$.\n\nTogether, these two observations imply that all final states that can be reached from a well-typed program are well-typed answers. With a definition of eval that takes faulty expressions to wrong, the type system is weakly sound.\n\nAs all answers produced are well-typed programs, subject reduction also establishes strong soundness. To state that an answer $v$ lies within the correct subset $V^\\tau$ of values, we employ the type system itself:\n\n$v \\in V^\\tau$ iff $\\triangleright v : \\tau$.\n\nThis yields a soundness theorem based on a syntactic connection between answers and types:\n\nif $\\triangleright e : \\tau$ then either $e \\dagger$ or $e \\mapsto v$ and $\\triangleright v : \\tau$.\n\nAgain, strong soundness follows with a definition of eval that takes faulty expressions to wrong.\n\nIn summary, proving a syntactic soundness theorem involves:\n\n- demonstrating subject reduction,\n- characterizing answers and faulty expressions, and\n- showing that the faulty expressions are untypable.\n\nThe structure of the proof always remains the same, whether or not the language includes some combination of references, exceptions, continuations, or other features.\n\n### 3.1 Related Work\n\nCurry and Feys [4] introduced the notion of subject reduction for combinatory logic. In the language of combinatory logic, the CL-term $e$ of a deduction concluding $\\triangleright e : \\tau$ is called the subject, and the type $\\tau$ is called the predicate. Subject reduction states that reduction of the subject of a deduction preserves the predicate. Subject reduction holds for terms in CL and the $\\lambda$-calculus [33].\n\nMitchell and Plotkin [25] present a type preservation theorem, i.e., subject reduction, for a variant of the second order polymorphic $\\lambda$-calculus. This language has explicitly typed declarations; the proof of type preservation is significantly simpler in the presence of such declarations. They do not develop a type soundness theorem.\n\nAbadi et al. [1] give a proof of soundness for type dynamic with respect to a structural operational semantics, in addition to their denotationally based proof. In their structural\noperational semantics, substitutions are carried out immediately: \\( \\lambda \\)-expressions evaluate to themselves, rather than closures, and judgments do not contain an environment component. Since answers are syntactic values, the type system can be applied to answers to show that evaluation preserves typing. Although this proof is similar to our proof of subject reduction, its extension to references or continuations apparently involves the same difficulties as Tofte’s and Duba et al.’s proofs.\n\n3.2 Road Map\n\nThe next three sections illustrate our approach by proving soundness for several languages. Section 4 considers a functional language, similar to that considered by Milner [20]. Section 5 considers an extension to references, an extension to exceptions, and shows how the results may be merged to consider a language with both. To our knowledge, this is the first proof of soundness for exceptions. Section 6 illustrates soundness for an extension providing first-class continuations, and is the first proof of strong type soundness for continuations in a polymorphic language. We conclude with a discussion of our technique, and suggestions for its application to other languages.\n\n4 Functional ML\n\nFunctional ML is an applicative language with constants, call-by-value higher-order functions, and a Hindley/Milner-style polymorphic type system. A natural basis for a calculus of Functional ML is Plotkin’s untyped \\( \\lambda \\)-calculus [26].\n\nLet \\( \\text{Var} \\) be a denumerable set of variables and \\( \\text{Const} \\) be a set of constants. The expressions and values of Functional ML are:\n\n\\[\n\\begin{align*}\n(\\text{Expressions}) & \\quad \\ e ::= v \\mid e_1 \\ e_2 \\mid \\text{let } x \\ \\text{be } e_1 \\ \\text{in } e_2 \\\\\n(\\text{Values}) & \\quad \\ v ::= e \\mid x \\mid \\mathbf{Y} \\mid \\lambda x . e\n\\end{align*}\n\\]\n\nwhere \\( x \\in \\text{Var} \\) and \\( e \\in \\text{Const} \\). The free variables, \\( \\text{FV}(e) \\), and bound variables of an expression are defined as usual, with \\( \\lambda \\) and \\text{let}-expressions binding their variables. The \\text{let}-expression binds \\( x \\) in \\( e_2 \\) but not \\( e_1 \\), \\text{i.e.}, \\text{let} bindings are not recursive. The fixed-point combinator \\( \\mathbf{Y} \\) provides recursion. Following Barendregt [2], we adopt the convention that bound variables are always distinct from free variables in distinct expressions, and we identify expressions that differ only by a consistent renaming of the bound variables. \\( \\text{ClosedVal} \\) is the set of values with no free variables.\n\n4.1 Semantics\n\nThe calculus for Functional ML is based upon four relations, called notions of reduction:\n\n\\[\n\\begin{align*}\n(\\delta) & \\quad e \\ v \\rightarrow \\delta(e, v) \\text{ if } \\delta(e, v) \\text{ is defined} \\\\\n(\\beta_x) & \\quad (\\lambda x . e) \\ v \\rightarrow e[x \\leftarrow v] \\\\\n(\\text{let}) & \\quad \\text{let } x \\ \\text{be } v \\ \\text{in } e \\rightarrow e[x \\leftarrow v] \\\\\n(\\mathbf{Y}) & \\quad \\mathbf{Y} \\ v \\rightarrow v \\ (\\lambda x . (\\mathbf{Y} \\ v) \\ x)\n\\end{align*}\n\\]\nTo abstract from the precise set of constants, we only assume the existence of a partial function:\n\n\\[ \\delta : \\text{Const} \\times \\text{ClosedVal} \\rightarrow \\text{ClosedVal} \\]\n\nthat interprets the application of functional constants to closed values and yields closed values. The \\( \\beta \\) and \\( \\text{let} \\) reductions use substitution: the notation \\( e[x \\leftarrow v] \\) means the substitution of \\( v \\) for free occurrences of \\( x \\) in \\( e \\), renaming bound variables of \\( v \\) as necessary to avoid capture. The \\( Y \\) reduction introduces an abstraction around \\( (Y \\, v) \\) as \\( v \\) must be applied to a value \\( (x \\) does not appear free in \\( v \\) by the variable conventions).\n\nWe refer to the union of these relations as \\( \\nu \\), or simply \\( \\rightarrow \\) when there is no danger of confusion. The notion of reduction \\( \\nu \\) gives rise to a system of reductions, \\( \\rightarrow \\). The relation \\( \\rightarrow \\) is the reflexive, transitive, and compatible closure of \\( \\rightarrow \\):\n\n\\[\n\\begin{align*}\n\\frac{e_1 \\rightarrow e_2}{e_1 \\rightarrow e_2} & \\quad \\frac{e_1 \\rightarrow e_2}{e_2 \\rightarrow e_3} & \\quad \\frac{e_1 \\rightarrow e_2}{e_3 \\rightarrow e_3} & \\quad \\frac{C[e_1] \\rightarrow C[e_2]}{C[e_1] \\rightarrow C[e_2]}\n\\end{align*}\n\\]\n\nwhere\n\n\\[ C ::= [] \\mid C \\, e \\mid e \\, C \\mid \\text{let } x \\, \\text{be } C \\, \\text{in } e \\mid \\text{let } x \\, \\text{be } e \\, \\text{in } C \\mid \\lambda x.C. \\]\n\nA context \\( C \\) is an expression with one subexpression replaced by a hole, denoted \\( [] \\). The expression \\( C[e] \\) results from placing an expression \\( e \\) in the hole of \\( C \\); this operation may involve capture of the free variables of \\( e \\) by \\( C \\). An equational system may be constructed as the congruence closure of \\( \\nu \\), but plays no rôle for our work.\n\nWith an appropriate choice of \\( \\delta \\), the calculus satisfies Church-Rosser and Standardization properties; the proofs are variants of Plotkin’s proofs for the \\( \\lambda \\)-calculus [26]. By Standardization, we know that an expression reduces to a value precisely if a reduction of leftmost-outermost redexes outside of abstractions leads to a value. Based on this idea, we can use the calculus to define an evaluation function [11]. Let \\( \\leftarrow \\) be the relation:\n\n\\[\n\\begin{align*}\n\\frac{E[e] \\leftarrow E[e']}{e \\rightarrow e'}\n\\end{align*}\n\\]\n\nwhere\n\n\\[ E ::= [] \\mid E \\, e \\mid v \\, E \\mid \\text{let } x \\, \\text{be } E \\, \\text{in } e. \\]\n\nThe special contexts \\( E \\) are evaluation contexts: they ensure that the leftmost-outermost reduction is the only applicable reduction in the entire program. Evaluating from left to right in an application is consistent with STANDARD ML. Unlike with \\( C \\) contexts, there is no possibility of capture when placing an expression in the hole of an evaluation context, because the hole cannot appear inside a binding construct. Let \\( \\leftarrow \\) be the reflexive and transitive closure of \\( \\leftarrow \\). Then the partial function \\( \\text{eval} \\) is defined for closed expressions \\( e \\) as:\n\n\\[\n\\text{eval}(e) = v \\quad \\text{iff } e \\leftarrow v.\n\\]\n\nIt is easy to see that the decomposition of a program into a \\( \\nu \\)-redex and an evaluation context is unique. It follows that the stepping relation \\( (\\rightarrow) \\) is a function, and therefore that \\( \\text{eval} \\) is a function, too.\n4.2 Typing\n\nThe type system is a deductive proof system that assigns types to expressions. The types of Functional ML are:\n\n\\[\n\\tau ::= \\iota_1 \\mid \\ldots \\mid \\iota_n \\mid \\alpha \\mid \\tau_1 \\rightarrow \\tau_2\n\\]\n\nwhere \\(\\iota_1, \\ldots, \\iota_n\\) are ground types for basic constants (\\(\\text{int}, \\text{bool}, \\text{real}\\), etc.), and \\(\\alpha\\) ranges over a denumerable set of type variables. Type variables stand for some fixed but unknown type. Function types, \\(\\tau_1 \\rightarrow \\tau_2\\), are right associative.\n\nThe polymorphic type system allows certain variables to be used with a set of different types. For example, if the identity function \\(\\lambda x . x\\) is let-bound to the variable \\(f\\), then \\(f\\) may used as a function of type \\(\\text{int} \\rightarrow \\text{int}\\) and applied to values of type \\(\\text{int}\\), or \\(f\\) may be used as a function of type \\(\\text{bool} \\rightarrow \\text{bool}\\) and applied to values of type \\(\\text{bool}\\). Type schemes represent such sets of types (\\(\\alpha^*\\) means zero or more distinct type variables):\n\n\\[\n\\sigma ::= \\forall \\alpha^* . \\tau\n\\]\n\nThe free type variables \\(FTV(\\sigma)\\) of a type or type scheme are defined as usual, where \\(\\forall \\alpha_1 \\ldots \\alpha_n . \\tau\\) binds \\(\\alpha_1\\) through \\(\\alpha_n\\) in \\(\\tau\\). We identify type schemes that differ only by a consistent renaming of bound type variables, or by a reordering of the binding occurrences. We also identify \\(\\forall . \\tau\\) with \\(\\tau\\), so types may be regarded as type schemes with no bound type variables.\n\nA type scheme \\(\\forall \\alpha_1 \\ldots \\alpha_n . \\tau\\) represents the set of types that may be obtained from \\(\\tau\\) by substituting for \\(\\alpha_1\\) through \\(\\alpha_n\\). This is formalized by the notion of generalization: a type scheme \\(\\sigma\\) generalizes a type \\(\\tau\\), written \\(\\sigma \\succ \\tau\\), if there is a substitution for the bound variables of \\(\\sigma\\) yielding \\(\\tau\\). A substitution \\(S\\) is a (partial) function from type variables to types. A substitution may be applied to a type in the obvious way; we write \\(S\\tau\\). Substitution on type schemes respects bound type variables and is capture-avoiding. Generalization of a type is defined as:\n\n\\[(\\succ)\\quad \\forall \\alpha_1 \\ldots \\alpha_n . \\tau' \\succ \\tau \\quad \\text{iff} \\quad S\\tau' = \\tau \\quad \\text{and} \\quad \\text{Dom}(S) = \\{\\alpha_1, \\ldots, \\alpha_n\\} \\quad \\text{for some} \\quad S.\\]\n\nGeneralization is extended to type schemes:\n\n\\[(\\succ)\\quad \\sigma \\succ \\sigma' \\quad \\text{iff} \\quad \\text{whenever} \\quad \\sigma' \\succ \\tau \\quad \\text{then} \\quad \\sigma \\succ \\tau.\\]\n\nSome examples are:\n\n\\[\n\\begin{align*}\n\\forall \\alpha . \\alpha & \\succ \\tau \\\\\n\\forall \\alpha_1 . \\alpha_2 . \\alpha_1 & \\succ \\alpha_2 \\\\\n\\forall \\alpha . \\alpha & \\succ \\alpha_2 \\\\\n\\forall \\alpha_1 . \\alpha_1 . \\alpha_1 & \\succ \\forall \\alpha_1 . \\alpha_1 & \\succ \\alpha_2\n\\end{align*}\n\\]\n\nGeneralization is a partial order on type schemes.\n\nIn order to assign types to open expressions, assumptions about the types of free variables are provided by type environments, denoted \\(\\Gamma\\). Type environments are finite maps from variables to type schemes. The free type variables \\(FTV(\\Gamma)\\) of a type environment\n(var) \\[ \\Gamma \\vdash x : \\tau \\text{ if } \\Gamma(x) \\vdash \\tau \\]\n\n(const) \\[ \\Gamma \\vdash c : \\tau \\text{ if } TypeOf(c) \\vdash \\tau \\]\n\n(Y) \\[ \\Gamma \\vdash Y : ((\\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1 \\rightarrow \\tau_2 \\]\n\n(abs) \\[ \\begin{align*}\n\\Gamma \\vdash e_1 : \\tau_1 & \\quad \\Gamma \\vdash e_2 : \\tau_2 \\\\\n[\\Gamma \\vdash x \\mapsto \\tau_1] \\vdash e & : \\tau_2\n\\end{align*} \\]\n\n(app) \\[ \\begin{align*}\n\\Gamma \\vdash e_1 : \\tau_1 & \\quad \\Gamma \\vdash e_2 : \\tau_2 \\\\\n\\Gamma \\vdash e : \\tau_2\n\\end{align*} \\]\n\n(let) \\[ \\begin{align*}\n\\Gamma \\vdash e_1 : \\tau_1 & \\quad \\Gamma \\vdash e_2 : \\tau_2 \\\\\n[\\Gamma \\vdash x \\mapsto \\text{Close}(\\tau_1, \\Gamma)] \\vdash e \\in e_2 : \\tau_2 \\\\\n\\Gamma \\vdash \\text{let } x \\text{ be } e_1 \\text{ in } e_2 : \\tau_2\n\\end{align*} \\]\n\n\\[ \\text{Close}(\\tau, \\Gamma) = \\forall \\alpha_1 \\ldots \\alpha_n. \\tau \\text{ where } \\{\\alpha_1, \\ldots, \\alpha_n\\} = \\text{FTV}(\\tau) \\setminus \\text{FTV}(\\Gamma) \\]\n\nFigure 1: Typing rules for Functional ML\n\nare the free type variables of the type schemes in its range. For stating and proving various lemmas, it is convenient to define substitution on type environments pointwise, i.e.,\n\n\\[ S(\\{(x_1, \\sigma_1), \\ldots, (x_n, \\sigma_n)\\}) = \\{(x_1, S\\sigma_1), \\ldots, (x_n, S\\sigma_n)\\} \\]\n\nThe function \\( TypeOf : \\text{Const} \\rightarrow \\text{TypeSchemes} \\) associates a type scheme with every constant. Since we have not precisely specified the set of constants, Functional ML is really a class of languages parameterized by the set \\( \\text{Const} \\) and the functions \\( \\delta \\) and \\( TypeOf \\). Just as the Standardization and Church-Rosser properties restrict the admissible set of \\( \\delta \\) functions, a particular choice of \\( \\text{Const} \\), \\( \\delta \\), and \\( TypeOf \\) must satisfy a typability condition for type soundness to hold. For every \\( c, \\tau, \\tau' \\), and \\( v \\),\n\n\\[ \\text{(\\( \\delta \\)-typability)} \\]\n\n\\[ \\begin{align*}\n\\text{if } TypeOf(c) \\vdash \\tau' \\rightarrow \\tau \\text{ and } \\vdash v : \\tau', \\\\\n\\text{then } \\delta(c, v) \\text{ is defined and } \\vdash \\delta(c, v) : \\tau.\n\\end{align*} \\]\n\nThis condition requires that \\( \\delta \\) be defined for all constants of functional type and arguments of matching type, and restricts the set of results that \\( \\delta \\) may produce. This rules out, for the moment, functional constants such as division that are not defined on all values of their input type.\n\nA \\textit{type judgment} \\( \\Gamma \\vdash e : \\tau \\) for \\( e \\) an expression of Functional ML is the conclusion of a deduction constructed according to the inference rules in Figure 1. The judgment \\( \\Gamma \\vdash e : \\tau \\) is read “in type environment \\( \\Gamma \\), expression \\( e \\) has type \\( \\tau \\)”. If the type environment in a judgment is empty, we write \\( \\vdash e : \\tau \\). An expression \\( e \\) is a \\textit{well-typed program} if it is closed and there is a judgment \\( \\vdash e : \\tau \\).\n\nIn this formulation of the typing rules, only one rule is applicable to an expression. Hence if there is a deduction assigning an expression a specific type, that deduction is unique. This permits proofs by induction on the structure of a deduction for a type judgment to proceed by case analysis on the structure of the expression of the type judgment.\n\nThis type system has the important property that there is an algorithm \\( W \\) to determine whether an expression has a type [20]. Given a type environment and an expression, the algorithm computes a substitution and a type. The algorithm is sound [20] with respect to\nthe type system, meaning that it infers only valid typings.\n\n**Theorem (Soundness of \\( W \\))** [Milner] If \\((S, \\tau) = W(\\Gamma, e)\\) succeeds then \\(ST \\triangleright e : \\tau\\).\n\nThe algorithm is also complete [5], meaning that if an expression has a valid typing, then the algorithm will find a typing. Furthermore, the algorithm always terminates.\n\n**Theorem (Completeness of \\( W \\))** [Damas, Milner] If \\(S_1 \\Gamma \\triangleright e : \\tau_1\\) then \\((S, \\tau) = W(\\Gamma, e)\\) succeeds and there exists \\(S'\\) such that \\(S'(ST) = S_1\\Gamma\\) and \\(S' \\text{Close}(\\tau, ST) \\triangleright \\tau_1\\). If \\(W(\\Gamma, e)\\) does not succeed, then it stops with fail.\n\nProving completeness involves demonstrating that if an expression has a type, then it has a principal type, of which all others are substitution instances.\n\n**Theorem (Principal Typing)** If \\(\\Gamma \\triangleright e : \\tau_1\\) then there exists \\(\\tau\\) such that \\(\\Gamma \\triangleright e : \\tau\\) and whenever \\(\\Gamma \\triangleright e : \\tau_2\\) then \\(\\text{Close}(\\tau, \\Gamma) \\triangleright \\tau_2\\). The type \\(\\tau\\) is principal for \\(e\\) in \\(\\Gamma\\).\n\nThe existence of a sound and complete algorithm establishes the decidability of the type system. However, this is solely a property of the type system, and says nothing about the relation of the type system to the semantics of the language.\n\n### 4.3 Type Soundness\n\nOur proof of type soundness rests upon the notion of subject reduction [4]. The subject reduction property states that reductions preserve the type of expressions. Lemma 4.3 below extends subject reduction to Functional ML.\n\nSubject reduction by itself is not sufficient for type soundness. In addition, we must prove that programs containing type errors are not typable. Put differently, if an expression \\(e\\) is irreducible due to some type error, say \\((/ 1 0)\\), then the type system should not be able to assign a type to the expression. Otherwise, a well-typed program could reduce to such an expression without violating subject reduction, and still cause a type error to occur. We call such expressions with type errors faulty expressions and prove that faulty expressions cannot be typed.\n\nSome obvious facts about deductions that we use with no more ado are:\n\n1. if \\(\\Gamma \\triangleright C[e] : \\tau\\) then there exist \\(\\Gamma'\\) and \\(\\tau'\\) such that \\(\\Gamma' \\triangleright e : \\tau'\\);\n2. if there are no \\(\\Gamma', \\tau'\\) such that \\(\\Gamma' \\triangleright e : \\tau'\\), then there are no \\(\\Gamma, \\tau\\) such that \\(\\Gamma \\triangleright C[e] : \\tau\\).\n\nThese follow from the facts that (1) there is exactly one inference rule for each expression form, and (2) each inference rule requires a proof for each subexpression of the expression in its conclusion. Several facts about generalization follow from the definition of \\(\\text{Close}\\):\n\n1. if \\(\\sigma' \\triangleright \\sigma\\) then \\(\\text{Close}(\\tau_1, \\Gamma[x \\leftarrow \\sigma']) \\triangleright \\text{Close}(\\tau_1, \\Gamma[x \\leftarrow \\sigma])\\);\n2. if \\(x \\notin \\text{Dom}(\\Gamma)\\) then \\(\\text{Close}(\\tau_1, \\Gamma) \\triangleright \\text{Close}(\\tau_1, \\Gamma[x \\leftarrow \\sigma])\\).\n\nThe following lemma states that extra variables in the type environment \\(\\Gamma\\) of a judgment \\(\\Gamma \\triangleright e : \\tau\\) that are not free in the expression \\(e\\) may be ignored.\nLemma 4.1 If $\\Gamma(x) = \\Gamma'(x)$ for all $x \\in FV(e)$, then $\\Gamma \\triangleright e : \\tau$ iff $\\Gamma' \\triangleright e : \\tau$.\n\nA key lemma that we use in the proof of Subject Reduction for Functional ML and its extensions is the Replacement Lemma, adapted from Hindley and Seldin [16: page 181]. This allows the replacement of one of the subexpressions of a typable expression with another subexpression of the same type, without disturbing the type of the overall expression.\n\nLemma 4.2 (Replacement) If:\n\n(i) $D$ is a deduction concluding $\\Gamma \\triangleright C[e_1] : \\tau$,\n(ii) $D_1$ is a subdeduction of $D$ concluding $\\Gamma' \\triangleright e_1 : \\tau'$,\n(iii) $D_1$ occurs in $D$ in the position corresponding to the hole ([]) in $C$, and\n(iv) $\\Gamma' \\triangleright e_2 : \\tau'$,\n\nthen $\\Gamma \\triangleright C[e_2] : \\tau$.\n\nProof. We think of deductions as trees with the conclusion at the root. Let $D_2$ be the deduction concluding $\\Gamma' \\triangleright e_2 : \\tau'$. Cut the subtree $D_1$ out of $D$ and replace it with $D_2$. Replace all relevant occurrences of $e_1$ in the resulting tree with $e_2$. Then the resulting tree is a valid deduction concluding $\\Gamma \\triangleright C[e_2] : \\tau$, as may be shown by induction on the height of the tree [16: page 181].\n\nSubject reduction for Functional ML states that the reductions of $v$ preserve type.\n\nMain Lemma 4.3 (Subject Reduction) If $\\Gamma \\triangleright e_1 : \\tau$ and $e_1 \\rightarrow e_2$ then $\\Gamma \\triangleright e_2 : \\tau$.\n\nProof. The proof proceeds by case analysis according to the reduction $e_1 \\rightarrow e_2$.\n\nCase $e \\triangleright v \\rightarrow \\delta(e,v)$. Then $\\Gamma \\triangleright e : \\tau' \\rightarrow \\tau$ and $\\Gamma \\triangleright v : \\tau'$ follow from $\\Gamma \\triangleright e \\triangleright v : \\tau$ by app. Hence $\\Gamma \\triangleright \\delta(e,v) : \\tau$ by the $\\delta$-typability condition.\n\nCase $(\\lambda x.e) \\triangleright v \\rightarrow e[x \\leftarrow v]$. From $\\Gamma \\triangleright (\\lambda x.e) : v : \\tau$ we have $\\Gamma \\triangleright v : \\tau'$ and $\\Gamma \\triangleright \\lambda x.e : \\tau' \\rightarrow \\tau$ by app. From the latter, $\\Gamma[x \\leftarrow \\tau'] \\triangleright e : \\tau$ follows by abs. Hence $\\Gamma \\triangleright e[x \\leftarrow v] : \\tau$ by Lemma 4.4.\n\nCase let $x$ be $v$ in $e \\rightarrow e[x \\leftarrow v]$. From $\\Gamma \\triangleright \\text{let } x \\triangleright v$ in $e : \\tau$ we have $\\Gamma \\triangleright v : \\tau'$ and $\\Gamma[x \\leftarrow \\text{Close}(\\tau',\\Gamma)] \\triangleright e : \\tau$ by let. As $\\text{Close}(\\tau',\\Gamma) = \\forall \\alpha_1 \\ldots \\alpha_n. \\tau'$ where $\\{\\alpha_1, \\ldots, \\alpha_n\\} = FTV(\\tau') \\setminus FTV(\\Gamma)$, we have $\\Gamma \\triangleright e[x \\leftarrow v] : \\tau$ by Lemma 4.4.\n\nCase $\\forall v \\rightarrow v (\\lambda x.(Y \\triangleright v) x)$. From $\\Gamma \\triangleright \\forall v : \\tau$, where $\\tau = \\tau_1 \\rightarrow \\tau_2$, by $\\forall$ and app\n\n(1) $\\Gamma \\triangleright v : (\\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1 \\rightarrow \\tau_2$.\n\nThen from $\\Gamma \\triangleright \\forall v : \\tau$,\n\n$\\Gamma[x \\leftarrow \\tau_1] \\triangleright \\forall v : \\tau_1 \\rightarrow \\tau_2$ by Lemma 4.1,\n\n$\\Gamma[x \\leftarrow \\tau_1] \\triangleright (\\forall v) x : \\tau_2$ by app,\n\n$\\Gamma \\triangleright \\lambda x.(\\forall v) x : \\tau_1 \\rightarrow \\tau_2$ by abs,\n\n$\\Gamma \\triangleright v (\\lambda x.(\\forall v) x) : \\tau_1 \\rightarrow \\tau_2$ by app with (1).\nThis completes the essence of the proof. It remains to establish several lemmas.\n\nA Substitution Lemma is the key to showing type preservation for reductions involving substitution.\n\n**Lemma 4.4 (Substitution)** If $\\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleright e : \\tau'$ and $x \\notin \\text{Dom}(\\Gamma)$ and $\\Gamma \\triangleright v : \\tau$ and $\\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap FTV(\\Gamma) = \\emptyset$ then $\\Gamma \\triangleright e[x \\mapsto v] : \\tau'$.\n\n**Proof.** We proceed by induction on the length of the proof of $\\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleright e : \\tau'$, and case analysis on the last step.\n\n**Case** $e = c$. Then $\\text{TypeOf}(c) \\triangleright \\tau'$ by const, and thus $\\Gamma \\triangleright c : \\tau'$ by const. Then $\\Gamma \\triangleright c[x \\mapsto v] : \\tau'$ since $c[x \\mapsto v] = e$.\n\n**Case** $e = x'$. If $x' \\neq x$, then $\\Gamma x' \\triangleright \\tau'$ by var, and $\\Gamma \\triangleright x' : \\tau'$ again by var. Hence $\\Gamma \\triangleright x'[x \\mapsto v] : \\tau'$ since $x'[x \\mapsto v] = x'$.\n\nIf $x' = x$, then by var\n\n$$\\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau](x) \\triangleright \\tau'$$\n\ni.e. $\\forall \\alpha_1 \\ldots \\alpha_n. \\tau \\triangleright \\tau'$,\n\ni.e. we can find a substitution $S$ with domain $\\{\\alpha_1, \\ldots, \\alpha_n\\}$ such that $S\\tau = \\tau'$. Next, we have $SG \\triangleright v : S\\tau$ by Lemma 4.5 since $\\Gamma \\triangleright v : \\tau$, and therefore $SG \\triangleright v : \\tau'$. But $\\text{Dom}(S) \\cap FTV(\\Gamma) = \\emptyset$, so $SG = \\Gamma$. Also $x[x \\mapsto v] = v$, hence $\\Gamma \\triangleright x[x \\mapsto v] : \\tau'$.\n\n**Case** $e = \\lambda x'. e_1$. By abs, it follows from the assumption $\\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleright \\lambda x'. e_1 : \\tau'$ that $\\tau' = \\tau_1 \\rightarrow \\tau_2$, and\n\n$$\\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau][x' \\mapsto \\tau_1] \\triangleright e_1 : \\tau_2$$\n\ni.e. $\\Gamma[x' \\mapsto \\tau_1][x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleright e_1 : \\tau_2$.\n\nChoose a substitution $S : \\{\\alpha_1, \\ldots, \\alpha_n\\} \\rightarrow \\{\\alpha'_1, \\ldots, \\alpha'_n\\}$ such that $\\alpha'_1, \\ldots, \\alpha'_n$, $\\alpha_1, \\ldots, \\alpha_n$, and $FTV(\\Gamma)$ are all distinct. Then\n\n1. $\\Gamma[x' \\mapsto S\\tau_1][x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleright e_1 : S\\tau_2$ by Lemma 4.5,\n2. $\\Gamma[x' \\mapsto S\\tau_1] \\triangleright v : \\tau$ by Lemma 4.1, and\n3. $FTV(\\Gamma[x' \\mapsto S\\tau_1]) \\cap \\{\\alpha_1, \\ldots, \\alpha_n\\} = \\emptyset$ by the choice of $S$.\n\nThus, $\\Gamma[x' \\mapsto S\\tau_1] \\triangleright e_1[x \\mapsto v] : S\\tau_2$ by the inductive hypothesis with (2), (3), and (4). Since $S$ is a bijection, $S^{-1}$ exists, hence\n\n$$S^{-1}(\\Gamma[x' \\mapsto S\\tau_1]) \\triangleright e_1[x \\mapsto v] : S^{-1}(S\\tau_2)$$\n\ni.e. $\\Gamma[x' \\mapsto \\tau_1] \\triangleright e_1[x \\mapsto v] : \\tau_2$.\n\nBut then\n\n$$\\Gamma \\triangleright \\lambda x'. e_1[x \\mapsto v] : \\tau_1 \\rightarrow \\tau_2$$\n\ni.e. $\\Gamma \\triangleright (\\lambda x'. e_1)[x \\mapsto v] : \\tau_1 \\rightarrow \\tau_2$.\nCase $e = (e_1 \\ e_2)$. From $\\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleleft (e_1 \\ e_2) : \\tau'$ by the first premise of $\\mathbf{app}$\n\n$$\\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleleft e_1 : \\tau$$\n\n(5) \n\nBy the second premise of $\\mathbf{app}$\n\n$$\\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleleft e_2 : \\tau$$\n\n(6) \n\nThen by $\\mathbf{app}$ with (5) and (6)\n\n$$\\Gamma \\triangleright (e_1 [x \\mapsto v] \\ e_2 [x \\mapsto v]) : \\tau'$$\n\ni.e. $\\Gamma \\triangleright (e_1 \\ e_2) [x \\mapsto v] : \\tau'$.\n\nCase $e = \\mathbf{let} \\ x' \\mathbf{be} \\ e_1$ in $e_2$. By the first premise of $\\mathbf{let}$\n\n$$\\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleright e_1 : \\tau$$\n\n(7) \n\nBy the second premise of $\\mathbf{let}$\n\n$$\\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] [x' \\mapsto \\mathbf{Close}(\\tau_1, \\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])] \\triangleright e_2 : \\tau'$$\n\n(8) \n\ni.e. $\\Gamma [x' \\mapsto \\mathbf{Close}(\\tau_1, \\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])] [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleright e_2 : \\tau'$.\n\nSince $\\Gamma \\triangleright v : \\tau$\n\n(9) \n\n$$\\Gamma [x' \\mapsto \\mathbf{Close}(\\tau_1, \\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])] \\triangleright v : \\tau$$\n\nby Lemma 4.1.\n\nNow\n\n$$\\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap \\mathit{FTV}(\\Gamma [x' \\mapsto \\mathbf{Close}(\\tau_1, \\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau]))$$\n\n$$\\subseteq \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap (\\mathit{FTV}(\\Gamma) \\cup \\mathit{FTV}(\\mathbf{Close}(\\tau_1, \\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau]))$$\n\n$$= \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap \\mathit{FTV}(\\mathbf{Close}(\\tau_1, \\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau]))$$\n\n$$= \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap (\\mathit{FTV}(\\tau_1) \\setminus (\\mathit{FTV}(\\tau_1) \\setminus \\mathit{FTV}(\\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau]))$$\n\n$$= \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap \\mathit{FTV}(\\mathbf{Close}(\\tau_1, \\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau]))$$\n\n$$\\subseteq \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap (\\mathit{FTV}(\\Gamma) \\cup \\mathit{FTV}(\\forall \\alpha_1 \\ldots \\alpha_n. \\tau))$$\n\n$$= \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap \\mathit{FTV}(\\forall \\alpha_1 \\ldots \\alpha_n. \\tau)$$\n\n$$= \\emptyset$$\n\nso by the inductive hypothesis with (8) and (9)\n\n$$\\Gamma [x' \\mapsto \\mathbf{Close}(\\tau_1, \\Gamma [x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])] \\triangleright (e_1 \\ e_2) [x \\mapsto v] : \\tau'$$\n\nby Lemma 4.6,\n\n$$\\Gamma \\triangleright \\mathbf{let} \\ x' \\mathbf{be} \\ v_1 [x \\mapsto v] \\mathbf{in} \\ e_2 [x \\mapsto v] : \\tau'$$\n\nby $\\mathbf{let}$ with (7),\n\ni.e. $\\Gamma \\triangleright (\\mathbf{let} \\ x' \\mathbf{be} \\ v_1 \\mathbf{in} \\ e_2) [x \\mapsto v] : \\tau'$.\n\nLemma 4.5 establishes that typing is stable under substitution.\nLemma 4.5 If $\\Gamma \\vdash e : \\tau$ and $S$ is a substitution then $S\\Gamma \\vdash e : S\\tau$.\n\nProof. The proof proceeds by induction on the length of the proof of $\\Gamma \\vdash e : \\tau$ and case analysis on the last step. The proof is an adaptation of Tofte's proof of a similar lemma [37: lemma 4.2].\n\nFinally, Lemma 4.6 shows that generalizing the type of a variable in the type environment has no impact on the conclusion of a deduction.\n\nLemma 4.6 If $\\Gamma[x \\mapsto \\sigma] \\vdash e : \\tau$ and $\\sigma' \\supset \\sigma$ then $\\Gamma[x \\mapsto \\sigma'] \\vdash e : \\tau$.\n\nProof. The proof proceeds by induction on the length of the proof of $\\Gamma[x \\mapsto \\sigma] \\vdash e : \\tau$ and case analysis on the last step. The proof is an adaptation of Damas and Milner's proof of a similar lemma [5: lemma 1]. The only interesting case is the case for let-expressions.\n\nCase $e = \\text{let } x' \\text{ be } e_1 \\text{ in } e_2$. By the first premise of let\n\n\\begin{equation}\n\\Gamma[x \\mapsto \\sigma] \\vdash e_1 : \\tau_1\n\\end{equation}\n\n(10) \\hspace{1cm} \\Gamma[x \\mapsto \\sigma'] \\vdash e_1 : \\tau_1 \\hspace{1cm} \\text{by ind. hyp.}\n\nBy the second premise of let\n\n\\begin{equation}\n\\Gamma[x \\mapsto \\sigma][x' \\mapsto \\text{Close}(\\tau_1, \\Gamma[x \\mapsto \\sigma])] \\vdash e_2 : \\tau\n\\end{equation}\n\n(11) \\hspace{1cm} \\Gamma[x \\mapsto \\sigma'][x' \\mapsto \\text{Close}(\\tau_1, \\Gamma[x \\mapsto \\sigma'])] \\vdash e_2 : \\tau \\hspace{1cm} \\text{by ind. hyp.}\n\nThen $\\Gamma[x \\mapsto \\sigma'] \\vdash \\text{let } x' \\text{ be } e_1 \\text{ in } e_2 : \\tau$ by let with (10) and (11).\n\nA corollary of Subject Reduction is that standard reduction steps preserve type.\n\nCorollary 4.7 If $\\Gamma \\vdash e_1 : \\tau$ and $e_1 \\longrightarrow e_2$ then $\\Gamma \\vdash e_2 : \\tau$.\n\nProof. First, if $e_1 \\longrightarrow e_2$ then $e_1 = E[e]$ and $e_2 = E[e']$ and $e \\longrightarrow e'$, so $\\Gamma \\vdash e_2 : \\tau$ by the Replacement Lemma. Then the result follows by induction on the length of the reduction sequence $e_1 \\longrightarrow e_2$.\n\nSubject reduction ensures that if we start with a typable expression, we cannot reach an untypable expression through any sequence of reductions. This by itself, however, does not yield type soundness. Subject reduction simply ensures that any properties implied by typability are preserved by reduction. The critical property we seek is that evaluation of a typable expression cannot get stuck.\n\nDefinition 4.8 (Stuck Expressions) The evaluation of an expression $e$ is stuck if $e$ is not a value and there is no $e'$ such that $e \\longrightarrow e'$.\n\nOf course, whether an expression eventually reduces to a stuck expression is not a decidable property. We approximate the set of expressions that become stuck with a set of faulty expressions.\nDefinition 4.9 (Faulty Expressions) The faulty expressions of Functional ML are the expressions containing a subexpression \\((e \\, v)\\) where \\(\\delta(e, v)\\) is undefined.\n\nThe idea is that any faulty expression may become stuck, i.e., the property “reduces to a faulty expression” is a conservative approximation to “reduces to an expression that is stuck”. Thus the faulty expressions are a superset of the stuck expressions. For example, the expression \\(((\\lambda y.2) \\, (\\lambda x. + 1 \\, \\text{true}))\\) is faulty because of the subexpression \\((+ 1 \\, \\text{true})\\), but is not stuck because it reduces to 2.\n\nThe behavior of evaluation is summarized by the following lemma. Let \\(e \\Downarrow\\) mean that \\(e\\) diverges, i.e., \\(e \\mapsto e'\\) for some \\(e'\\), and for all \\(e'\\) such that \\(e \\mapsto e'\\), there exists \\(e''\\) such that \\(e' \\mapsto e''\\).\n\nLemma 4.10 (Uniform Evaluation) For closed \\(e\\), if there is no \\(e'\\) such that \\(e \\mapsto e'\\) and \\(e'\\) is faulty, then either \\(e \\Downarrow\\) or \\(e \\mapsto v\\).\n\nProof. By induction on the length of the reduction sequence, we need only show that either \\(e\\) is faulty, \\(e \\mapsto e'\\) and \\(e'\\) is closed, or \\(e\\) is a value. From the definition of \\(\\mapsto\\), \\(e \\mapsto e'\\) iff \\(e = E[e_1], e' = E[e_1'],\\) and \\(e_1 \\mapsto e_1'\\). (Recall that \\(E ::= [] \\mid E \\, e \\mid v \\, E \\mid \\text{let } x \\, \\text{be } E \\, \\text{in } e\\) ) We proceed by induction on the structure of \\(e\\).\n\nCase \\(e = c, Y, \\text{or } \\lambda x. e\\). Then \\(e\\) is a value.\n\nCase \\(e = x\\). Since \\(e\\) is closed, this case cannot occur.\n\nCase \\(e = \\text{let } x \\, \\text{be } e_1 \\, \\text{in } e_2\\). By the inductive hypothesis with \\(e_1\\), there are three cases to consider. If \\(e_1\\) is faulty, then \\(\\text{let } x \\, \\text{be } e_1 \\, \\text{in } e_2\\) is faulty. If \\(e_1 = E_1[e']\\) and \\(e' \\mapsto e''\\) then \\(e = E[e']\\) where \\(E = \\text{let } x \\, \\text{be } E_1 \\, \\text{in } e_2\\); thus \\(e \\mapsto E[e'']\\). Otherwise, if \\(e_1\\) is a value, then \\(\\text{let } x \\, \\text{be } e_1 \\, \\text{in } e_2 \\mapsto e_2[x \\mapsto e_1]\\).\n\nCase \\(e = (e_1 \\, e_2)\\). By the inductive hypothesis with \\(e_1\\), there are three cases to consider. If \\(e_1\\) is faulty, then \\((e_1 \\, e_2)\\) is faulty. If \\(e_1 = E_1[e']\\) and \\(e' \\mapsto e''\\) then \\(e = E[e']\\) where \\(E = (E_1 \\, e_2)\\); thus \\(e \\mapsto E[e'']\\). Otherwise, \\(e_1\\) is a value. By the inductive hypothesis with \\(e_2\\), there are three subcases to consider. If \\(e_2\\) is faulty, then \\((e_1 \\, e_2)\\) is faulty. If \\(e_2 = E_2[e']\\) and \\(e' \\mapsto e''\\) then \\(e = E[e']\\) where \\(E = (e_1 \\, E_2)\\); thus \\(e \\mapsto E[e'']\\). Otherwise, both \\(e_1\\) and \\(e_2\\) are values, and the possibilities can be summarized as follows:\n\n<table>\n<thead>\n<tr>\n<th>(e_1, e_2)</th>\n<th>(c)</th>\n<th>(\\lambda x. e)</th>\n<th>(Y)</th>\n<th>(x)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>(c)</td>\n<td>(\\mapsto)</td>\n<td>(\\mapsto)</td>\n<td>(\\mapsto)</td>\n<td>(\\times)</td>\n</tr>\n<tr>\n<td>(\\lambda x. e)</td>\n<td>(\\mapsto)</td>\n<td>(\\mapsto)</td>\n<td>(\\mapsto)</td>\n<td>(\\times)</td>\n</tr>\n<tr>\n<td>(Y)</td>\n<td>(\\mapsto)</td>\n<td>(\\mapsto)</td>\n<td>(\\mapsto)</td>\n<td>(\\times)</td>\n</tr>\n<tr>\n<td>(x)</td>\n<td>(\\times)</td>\n<td>(\\times)</td>\n<td>(\\times)</td>\n<td>(\\times)</td>\n</tr>\n</tbody>\n</table>\n\nCases marked with \\(\\times\\) cannot occur because the expression is not closed. Cases marked with \\(\\mapsto\\) indicate that the combination reduces with \\(E = []\\).\n\nTo relate faulty expressions and typability, we show that no faulty expression is typable.\nMain Lemma 4.11 (Faulty Expressions are Untypable) If $e$ is faulty, there are no $\\Gamma, \\tau$ such that $\\Gamma \\vdash e : \\tau$.\n\nProof. It suffices to show that the subexpressions of $e$ that cause $e$ to be faulty are untypable. In general, we proceed by case analysis according to the form of the subexpression, but for Functional ML, there is only one case.\n\nSuppose $(c \\; v)$ is faulty and $\\Gamma \\vdash c \\; v : \\tau$. By app, $\\Gamma \\vdash c : \\tau' \\rightarrow \\tau$ and $\\Gamma \\vdash v : \\tau'$. Then by the $\\delta$-typability condition, $\\delta(c, v)$ is defined, but this contradicts the assumption that $(c \\; v)$ is faulty.\n\nSince the faulty expressions are untypable and we have type preservation, the property “does not reduce to a faulty expression” is implied by typability.\\footnote{Type preservation by itself does not guarantee type soundness. Consider the (trivial) type system where every type is a subtype of every other type. Type preservation holds since every expression can be assigned every type. However, the system does not prevent type errors, because it rejects no expressions.}\n\nTheorem 4.12 (Syntactic Soundness) If $\\triangleright e : \\tau$ then either $e \\upharpoonright$ or $e \\not\\rightarrow v$ and $\\triangleright v : \\tau$.\n\nProof. By Uniform Evaluation, either $e \\rightarrow e'$ and $e'$ is faulty, or $e \\upharpoonright$, or $e \\not\\rightarrow v$. Since $\\triangleright e : \\tau$, Subject Reduction implies $\\triangleright v : \\tau$ and $\\triangleright e' : \\tau$. Suppose $e \\rightarrow e'$ and $e'$ is faulty. Since faulty expressions are untypable, $\\triangleright e' : \\tau$ is a contradiction, therefore this case cannot occur. Hence either $e \\upharpoonright$ or $e \\not\\rightarrow v$ and $\\triangleright v : \\tau$.\n\nTo state strong and weak soundness theorems, we must have a definition of evaluation that differentiates between programs that diverge and those that cause type errors. Let answers (a) be values or the special result wrong, and define eval' as:\n\n\\[\n(eval') \\quad eval'(e) = \\begin{cases} \n\\text{wrong} & \\text{if } e \\not\\rightarrow e' \\text{ and } e' \\text{ is faulty;} \\\\\n v & \\text{if } e \\rightarrow v.\n\\end{cases}\n\\]\n\nPrograms that cause a type error return the special answer wrong. Strong and weak soundness are now corollaries of Syntactic Soundness.\n\nTheorem 4.13 (Strong Soundness) If $\\triangleright e : \\tau$ and $eval'(e) = a$ then $\\triangleright a : \\tau$.\n\nTheorem 4.14 (Weak soundness) If $\\triangleright e : \\tau$ then $eval'(e) \\neq \\text{wrong}$.\n\n5 References and Exceptions\n\nBesides functional facilities, first-class references and exceptions are the most important core programming facilities of STANDARD ML and similar languages. In this section we consider several extensions to Functional ML. The first subsection deals with Reference ML, an extension of Functional ML with references. It uses our previous work on a calculus of state, $\\lambda_v$-S [12, 14], and in particular its cell-oriented variant [3]. The second subsection addresses Exception ML, an extension of Functional ML with exceptions. It uses a modified version of our control calculus, $\\lambda_v$-C [13, 14], especially its fragment with prompts [9]. The final subsection presents Core ML, which includes both references and exceptions.\n5.1 Reference ML\n\nExtending the $\\lambda$-calculus to a calculus of functions and references requires extending the syntax with a new kind of expression and several new values (underlined):\n\n\\[\n\\begin{align*}\n(\\textit{Expressions}) & & \\quad e ::= v \\mid e_1 e_2 \\mid \\text{let } x \\text{ be } e_1 \\text{ in } e_2 \\mid \\rho \\theta. e \\\\\n(\\textit{Values}) & & \\quad v ::= c \\mid x \\mid \\gamma \\mid \\lambda x. e \\mid \\text{ref} \\mid ! \\mid \\_ \\mid \\_ \\equiv v \\\\\n& & \\quad \\theta ::= \\{ \\langle x, v \\rangle \\}^*\n\\end{align*}\n\\]\n\nThe expression $\\rho(x_1, v_1) \\ldots (x_n, v_n). e$ binds $x_1, \\ldots, x_n$ in $v_1, \\ldots, v_n$ and $e$. Above, $\\theta$ represents a finite function from variables to values, i.e., we treat $\\theta$ as a set of pairs whose first components are distinct. We also identify all $\\rho$-expressions that differ only by a consistent renaming of bound variables.\n\nThe values $\\text{ref}$, $!$, and $\\_ \\equiv$ are the familiar operations of ML.\\textsuperscript{5} The application of $\\text{ref}$ to a value creates a reference cell containing that value. The application of $!$ to a cell returns the value contained in that cell. The binary assignment operator $\\_ \\equiv$ evaluates both its operands, the first of which must evaluate to a cell, and assigns the value of the second operand to that cell. Since all operations are curried, the application of the assignment operator to a variable is a value. Specifically, the expression $(\\_ \\equiv c)$ may be thought of as a capability to assign to the cell $c$. The $\\rho$-expression is semantically an abbreviation of a let-expression:\n\n\\[\n\\rho(x_1, v_1) \\ldots (x_n, v_n). e \\\\\n\\equiv \\quad \\text{let } x_1 \\text{ be ref } u_1 \\text{ in} \\\\\n\\cdots \\\\\n\\text{let } x_n \\text{ be ref } u_n \\text{ in} \\\\\n(\\lambda y_1 \\ldots y_n y_{n+1}. y_{n+1}) (\\_ \\equiv x_1 v_1) \\ldots (\\_ \\equiv x_n v_n) e\n\\]\n\nwhere $u_1, \\ldots, u_n$ are arbitrary values (of the right type). In order to simplify the semantics, we do not treat it as such \\textsuperscript{14}. Intuitively, a $\\rho$-expression plays the rôle of a store fragment during the reduction of a program with imperative assignment statements. A reference cell is represented as a variable; the pair $\\langle x, v \\rangle$ in a $\\rho$-expression indicates that reference cell $x$ contains value $v$.\n\n5.1.1 Semantics\n\nIn addition to the reductions for $v$, the reductions for references are:\\textsuperscript{6}\n\n\\[\n\\begin{align*}\n(\\text{ref}) & \\quad \\text{ref } v \\rightarrow \\rho(x, v). x \\\\\n(\\text{dereff}) & \\quad \\rho \\theta(x, v). R[! x] \\rightarrow \\rho \\theta(x, v). R[v] \\\\\n(\\text{assn}) & \\quad \\rho \\theta(x, v_1). R[\\_ \\equiv x v_2] \\rightarrow \\rho \\theta(x, v_2). R[v_2] \\\\\n(\\rho \\text{merge}) & \\quad \\rho \\theta_1. \\rho \\theta_2. e \\rightarrow \\rho \\theta_1 \\theta_2. e \\\\\n(\\rho \\text{inh}) & \\quad R[\\rho \\theta. e] \\rightarrow \\rho \\theta. R[e] \\quad \\text{if } R \\neq []\n\\end{align*}\n\\]\n\n\\textsuperscript{5}Introducing ref, !, and $\\_ \\equiv$ as values rather than special forms like (ref $c$), (! $c$), and $(\\_ \\equiv c_1 c_2)$ simplifies the proofs of several lemmas that proceed by induction on the structure of expressions. The latter approach requires duplicating much of the work of the case for applications.\n\n\\textsuperscript{6}This semantics is due to Crank and Felkisen \\textsuperscript{3}, which was derived from Felkisen and Heib’s work \\textsuperscript{14}. A similar definition of evaluation for dealing with state using rewriting techniques also appears in the work of Mason and Talcott \\textsuperscript{19}. \nBy the variable conventions, \\( x \\) is not free in \\( v \\) in the \\( ref \\) reduction; the domains of \\( \\theta_1 \\) and \\( \\theta_2 \\) are disjoint in \\( \\rho_{merge} \\); and the free variables of \\( R \\) are disjoint from the domain of \\( \\theta \\) in \\( \\rho_{init} \\). We refer to the union of these five reductions as \\( r \\). The notions of reduction \\( r \\) and \\( v \\) (adapted \\textit{mutatis mutandis} to the full syntax) form the basis for a calculus of functions and references. We refer to the union as \\( vr \\), and write \\( \\xrightarrow{vr} \\) for a reduction in \\( vr \\). The extended notion of reduction gives rise to a system of reductions and equations with the extension of contexts to:\n\n\\[\nC ::= [] \\mid C \\ e \\mid e \\ C \\mid \\text{let } x \\text{ be } C \\text{ in } e \\mid \\text{let } x \\text{ be } e \\text{ in } C \\mid \\lambda x.\\ C \\mid \\rho \\theta.\\ C \\mid \\rho \\theta(\\ x,\\ C)\\ e.\n\\]\n\nThe calculus satisfies the same basic properties as the \\( \\lambda_v \\)-calculus [3].\n\nThe definition of \\( r \\) relies on a set of \\( R \\) contexts:\n\n\\[\nR ::= [] \\mid R \\ e \\mid v \\ R \\mid \\text{let } x \\text{ be } R \\text{ in } e.\n\\]\n\nThe use of \\( R \\) contexts in the new reductions reflects the additional sequencing restrictions that the introduction of side-effects in a programming language requires for the semantics to be deterministic. In particular, the creation, the dereferencing, and the updating operations on a reference cell must be ordered in a linear fashion, which implies some further ordering among the operations on distinct cells. The \\( R \\) contexts build this minimal order of evaluation into those reductions that refer to reference cells and their operations; following ML, we choose to perform operations from left to right.\n\nFor \\( r \\) reductions, a cell is represented by an ordinary variable appearing in the domain of a store fragment \\( \\theta \\). When a program creates a new cell via \\( ref \\), the \\( ref \\) reduction introduces a \\( \\rho \\)-expression that records the cell’s current value. The dereference operator \\( ! \\) selects a cell’s value from the closest \\( \\rho \\)-expression (relative to \\( R \\) contexts). If the appropriate cell is bound in a \\( \\rho \\)-expression that is not the closest one, the intervening \\( \\rho \\)-expressions must first be merged with the outer one. This is accomplished with \\( \\rho_{init} \\) and \\( \\rho_{merge} \\) reductions, which lift a partial store out of \\( R \\) contexts, and merge it with outer stores (by the variable convention, cells are renamed appropriately to avoid collisions). An assignment replaces a cell’s current value in the closest \\( \\rho \\)-expression, after performing all necessary lift and merge steps, and returns the assigned value.\n\nFor example, consider the following expression:\n\n\\[\n((\\text{let } x \\text{ be } ref (\\lambda x.\\ ! x 2) \\text{ in } := x (\\lambda x.\\ ! x 3))\n\\]\n\n\\[\n(\\text{let } x \\text{ be } ref 2 \\text{ in } (\\lambda z.x) := x 4)))\n\\]\n\nIn this expression, the two assignments can happen in an arbitrary order, and the system of reductions admits both possibilities. Both assignments, however, must happen before the outermost application is reduced. Figure 2 gives one possible reduction sequence.\n\nThe above calculus only constrains the relative ordering of \\( ref \\), \\( deref \\), and \\( assign \\) reductions. By defining extended evaluation contexts:\n\n\\[\nE ::= [] \\mid E \\ e \\mid v \\ E \\mid \\text{let } x \\text{ be } E \\text{ in } e \\mid \\rho \\theta.\\ E\n\\]\n\nwe fix the order in which reductions in \\( v \\) and \\( ref \\), \\( deref \\), and \\( assign \\) may be applied. The stepping function \\( \\xrightarrow{vr} \\) is defined as before. To show that \\( \\xrightarrow{vr} \\) is a function requires a simple\n\\[\n\\begin{align*}\n &((\\text{let } x \\text{ be ref } (\\lambda x. + !x) \\text{ in } := x (\\lambda x. + !x)) \\\\\n &((\\text{let } x \\text{ be ref } 2 \\text{ in } (\\lambda z. x)(:: = x 4))) \\\\\n &\\quad \\longrightarrow (\\rho (x, \\lambda x. + !x) :: = x (\\lambda x. + !x 3)) \\\\\n &\\quad \\longrightarrow (\\rho (x, \\lambda x. + !x 3) (\\lambda x. + !x 3) (\\rho (x, 2). (\\lambda z. x)(:: = x 4)) \\\\\n &\\quad \\longrightarrow (\\rho (x, \\lambda x. + !x 3) (\\lambda x. + !x 3) (\\rho (x, 4). x) \\\\\n &\\quad \\longrightarrow (\\rho (x, \\lambda x. + !x 3) (y, 4) \\cdot + !y 3) \\\\\n &\\quad \\longrightarrow (\\rho (x, \\lambda x. + !x 3) (y, 4) \\cdot + 4 3) \\\\\n &\\quad \\longrightarrow (\\rho (x, \\lambda x. + !x 3) (y, 4) \\cdot T)\n\\end{align*}\n\\]\n\nFigure 2: Reducing a program with side-effects\n\nThe diamond theorem, since the order in which \\(\\rho_{lift}\\) and \\(\\rho_{merge}\\) reductions happen is not fixed, and the context \\(R\\) in the \\(\\rho_{lift}\\) rule is selected in a nondeterministic fashion. The answers returned by evaluation of a program are no longer simply closed values, since an answer may be a reference cell. Answers are values or \\(\\rho\\)-expressions enclosing values:\n\n\\[\n(\\text{answers}) \\quad a ::= v \\mid \\rho \\theta . v.\n\\]\n\nBased on these definitions, evaluation may be defined like before:\n\n\\[\n(\\text{eval}_{\\text{vr}}) \\quad \\text{eval}_{\\text{vr}}(e) = a \\quad \\text{iff} \\quad e \\xrightarrow{\\text{vr}} a.\n\\]\n\n### 5.1.2 Typing\n\nTyping reference cells in the presence of polymorphism is not straightforward, as the obvious solution is unsound [6, 36, 37]. To assign types to reference cells, we extend the set of types with an additional constructor:\n\n\\[\n\\tau ::= \\iota_1 | \\ldots | \\iota_n | \\alpha | \\tau_1 \\rightarrow \\tau_2 | \\tau \\text{ ref}\n\\]\n\nThe type \\(\\tau \\text{ ref}\\) is the type of cells containing a value of type \\(\\tau\\).\n\nThe obvious types for the three operators are indicated by their semantics:\n\n\\[\n\\begin{align*}\n &\\Gamma \\triangleright \\text{ ref : } \\tau \\rightarrow \\tau \\text{ ref} \\\\\n &\\Gamma \\triangleright ! : \\tau \\text{ ref } \\rightarrow \\tau \\\\\n &\\Gamma \\triangleright ::= \\text{ : } \\tau \\text{ ref } \\rightarrow \\tau \\rightarrow \\tau\n\\end{align*}\n\\]\n\nFor example, the first argument of the assignment operator (\\(=\\)) must be a reference cell. The second argument must be a value matching the type of the cell. The result is of the same type as the second argument since our assignment operator returns the value assigned. The following expression illustrates why this typing is unsound:\n\n\\[\n\\begin{align*}\n &\\text{let } f \\text{ be ref } (\\lambda y. y) \\text{ in} \\\\\n &\\quad (\\lambda z. ! f \\text{ true) (:= f (\\lambda n. + 1 n))}\n\\end{align*}\n\\]\nIf the type of the reference bound to \\( x \\) is generalized to \\( \\forall \\alpha. (\\alpha \\rightarrow \\alpha) \\) ref, then the reference cell can be treated as having type \\((\\text{int} \\rightarrow \\text{int}) \\) ref for the assignment, and as having type \\((\\text{bool} \\rightarrow \\text{bool}) \\) ref for the dereference, hence this expression is typable as \\( \\text{bool} \\). But evaluating this expression leads to a type error:\n\n\\[\n\\text{let } f \\text{ be ref } (\\lambda y.y) \\text{ in}\n\\]\n\n\\[\n(\\lambda z. \\ f \\text{ true}) (:= f (\\lambda n. + n))\n\\]\n\n\\[\n\\rightarrow \\text{let } f \\text{ be ref } (\\lambda x. (\\lambda y.y). x) \\text{ in}\n\\]\n\n\\[\n(\\lambda z. \\ f \\text{ true}) (:= f (\\lambda n. + n))\n\\]\n\n\\[\n\\rightarrow \\rho(\\lambda x. (\\lambda y.y)).\n\\]\n\n\\[\n(\\lambda z. \\ x \\text{ true}) (:= x (\\lambda n. + n))\n\\]\n\n\\[\n\\rightarrow \\rho(\\lambda x. (\\lambda n. + n)). ! x \\text{ true}\n\\]\n\n\\[\n\\rightarrow \\rho(\\lambda x. (\\lambda n. + n)). + 1 \\text{ true}\n\\]\n\nAs Tøfte [36, 37] points out, the problem with the obvious typing is the generalization of type variables that appear free in the type of a value in the store.\n\nThe central idea of Tøfte’s solution is to ensure that the only storable values are those that will not be used polymorphically at run-time. To this end, type variables are partitioned into imperative and applicative variables: the former set of type variables is named \\( \\text{ImpTypeVar} \\); the latter \\( \\text{AppTypeVar} \\). Types are classified accordingly: an imperative type cannot contain any applicative type variables. Only values of imperative type can be stored. When the type of a value is generalized in a let-expression, type variables that might appear in the types of values in the store are required to be imperative, and are not generalized.\n\nThe notion of generalization requires appropriate adaptation. We still have:\n\n\\[\n(\\succ) \\quad \\forall \\alpha_1 \\ldots \\alpha_n. \\tau' \\succ \\tau \\text{ if } S' = \\tau \\text{ and } \\text{Dom}(S) = \\{\\alpha_1, \\ldots, \\alpha_n\\} \\text{ for some } S,\n\\]\n\nbut the substitution \\( S \\) is required to map imperative type variables to imperative types. Thus, if \\( _\\alpha \\) is an imperative type variable, we have:\n\n\\[\n\\forall \\alpha _\\alpha \\rightarrow _\\alpha \\succ \\text{ int } \\rightarrow \\text{ int}\n\\]\n\nand \\( \\forall _\\alpha \\alpha _\\alpha \\rightarrow _\\alpha \\succ _\\alpha \\rightarrow _\\alpha \\)\n\nbut not \\( \\forall _\\alpha \\alpha _\\alpha \\rightarrow _\\alpha \\succ _\\alpha \\rightarrow _\\alpha \\)\n\nsince \\( _\\alpha \\) is potentially applicative (the meta-variable \\( _\\alpha \\) still represents any type variable—imperative or applicative).\n\nLike all other techniques for typing references, Tøfte’s system requires modifying the typing rule for let-expressions. The let rule is split into two rules, according to whether or not the right-hand side of the declaration is a value. Figure 3 gives the new rules. The second rule does not generalize over imperative type variables, and thus will not generalize the type of a value in the store. However, if the expression bound by a let-expression is a value, as in the first rule, then its evaluation cannot create a new cell, so generalization of imperative type variables in its type cannot generalize the type of a value in the store. Tøfte uses the terminology expansive and non-expansive to denote this syntactic classification of expressions into those that may create new references, and those that definitely do not create new references. Like Tøfte, we classify only values as non-expansive, but a stronger type system is possible by classifying more expressions as non-expansive [36, 37].\n\\[\n\\begin{align*}\n\\text{(let)} \\\\\n\\quad & \\Gamma \\vdash v : \\tau_1 \\\\\n\\quad & \\Gamma [x \\mapsto \\text{Close}(\\tau_1, \\Gamma)] \\vdash e : \\tau_2 \\\\\n\\quad & \\Gamma \\vdash \\text{let } x \\text{ be } v \\text{ in } e : \\tau_2 \\\\\n\\quad & \\Gamma \\vdash \\text{let } x \\text{ be } e_1 \\text{ in } e_2 : \\tau_2 \\\\\n\\end{align*}\n\\]\n\n\\[Close(\\tau, \\Gamma) = \\forall \\alpha_1 \\ldots \\alpha_n. \\tau \\text{ where } \\{\\alpha_1, \\ldots, \\alpha_n\\} = \\text{FTV}(\\tau) \\setminus \\text{FTV}(\\Gamma)\\]\n\n\\[\\text{AppClose}(\\tau, \\Gamma) = \\forall \\alpha_1 \\ldots \\alpha_n. \\tau \\text{ where } \\{\\alpha_1, \\ldots, \\alpha_n\\} = (\\text{FTV}(\\tau) \\setminus \\text{FTV}(\\Gamma)) \\cap \\text{App Type Var}\\]\n\nFigure 3: Modified let-expression typing rules\n\n\\[\n\\begin{align*}\n\\text{(ref)} & \\quad \\Gamma \\vdash \\text{ref} : \\tau \\rightarrow \\tau \\text{ ref if } \\tau \\text{ is imperative} \\\\\n\\text{(deref)} & \\quad \\Gamma \\vdash ! : \\tau \\text{ ref } \\rightarrow \\tau \\\\\n\\text{(assign)} & \\quad \\Gamma \\vdash := : (\\tau \\text{ ref } \\rightarrow \\tau \\rightarrow \\tau) \\\\\n\\quad & \\Gamma [x_1 \\mapsto \\tau_1 \\text{ ref}] \\ldots [x_n \\mapsto \\tau_n \\text{ ref}] \\vdash e : \\tau \\\\\n\\quad & \\Gamma [x_1 \\mapsto \\tau_1 \\text{ ref}] \\ldots [x_n \\mapsto \\tau_n \\text{ ref}] \\vdash v_i : \\tau_i \\quad \\tau_i \\text{ is imperative } \\quad 1 \\leq i \\leq n \\\\\n\\text{(rho)} & \\quad \\Gamma \\vdash \\rho(x_1, v_1) \\ldots (x_n, v_n), e : \\tau\n\\end{align*}\n\\]\n\nFigure 4: Additional typing rules for references\n\nFigure 4 gives four additional typing rules for reference cells. The typing rules for \\text{ref} and \\rho-expressions ensure that any value placed in the store has an imperative type. The typing rules for \\text{!} and := do not need to be explicitly constrained, since their use is implicitly constrained by the type of a value already in the store.\n\nIn addition to the restrictions placed on the typing of constants by Functional ML, we also require that there be no constants of reference type (\\tau \\text{ ref}). This ensures that all values of reference type are in fact reference cells, and can be assigned or dereferenced. This restriction is used in the proof of Theorem 5.6.\n\nThe new system assigns the same types as the old one to Functional ML expressions.\n\nLet \\text{\\vec{\\cdot}} indicate provability in the old, functional system, and let \\text{\\vec{\\cdot}} indicate provability in the system with references.\n\n\\textbf{Proposition 5.1} If \\text{e} is an expression in Functional ML, and \\Gamma and \\tau are purely applicative, then \\Gamma \\vdash e : \\tau \\text{ iff } \\Gamma \\vec{\\vdash} e : \\tau.\n\nSince Functional ML expressions do not contain \\text{ref} or \\rho-expressions, no imperative type variables need be chosen to type an expression, and \\text{Close} and \\text{AppClose} yield the same type scheme for applicative types.\n\n\\textbf{5.1.3 Type Soundness for References}\n\nTo prove type preservation for the extended language, we must show that the notion of reduction \\text{v} extended to the new syntax preserves types, and that the reductions of \\text{r}\nSyntactic Type Soundness\n\npreserve types. Showing that the extended $\\nu$ preserves types amounts to re-proving the various lemmas used in section 4.3 for the extended system. In general, we refer to the extension of Lemma 4.9 as Lemma 4.9+. Showing that $\\rho$ preserves types involves adding a case for each reduction to the proof of Subject Reduction. The cases involving $R$ contexts use the fact that:\n\n$$\\text{if } \\Gamma \\triangleright R[e] : \\tau \\text{ then } \\Gamma \\triangleright e : \\tau'.$$\n\nThe type environment $\\Gamma$ is the same in both the antecedent and consequent since $R$ contexts do not bind variables.\n\n**Main Lemma 5.2 (Subject Reduction for $\\nu$)**\n\nIf $\\Gamma \\triangleright e_1 : \\tau$ and $e_1 \\overset{\\nu}{\\rightarrow} e_2$ then $\\Gamma \\triangleright e_2 : \\tau$.\n\n**Proof.** The cases for the reductions of $\\nu$ are the same as before, using an appropriately extended Replacement Lemma and a similarly extended Lemma 4.1.\n\n**Case** $\\text{ref} \\ v \\rightarrow \\rho(x, v).x$. From $\\Gamma \\triangleright \\text{ref} \\ v : \\tau$, where $\\tau = \\tau' \\text{ref}$ and $\\tau'$ is imperative, $\\Gamma \\triangleright v : \\tau'$ by $\\text{ref}$ and $\\text{app}$, and $\\Gamma[x \\mapsto \\tau' \\text{ref}] \\triangleright v : \\tau'$ by Lemma 4.1+. Since $\\Gamma[x \\mapsto \\tau' \\text{ref}] \\triangleright x : \\tau' \\text{ref}$ by $\\text{var}$, $\\Gamma \\triangleright \\rho(x, v).x : \\tau' \\text{ref}$ by $\\rho$.\n\nIn order to satisfy the imperative restriction on the typing of $\\rho$-expressions, $\\text{ref}$ applications must yield values of imperative type, as ensured by $\\text{ref}$.\n\n**Case** $\\rho\\theta(x, v).R[! \\ x] \\rightarrow \\rho\\theta(x, v).R[v]$. From $\\Gamma \\triangleright \\rho\\theta(x, v).R[! \\ x] : \\tau$ by $\\rho$\\n\n(12) $\\Gamma' \\triangleright v : \\tau'$\n\nwhere $\\tau'$ is imperative and $\\Gamma'x = \\tau'\\text{ref}$. Thus $\\Gamma' \\triangleright x : \\tau'\\text{ref}$, hence $\\Gamma' \\triangleright ! \\ x : \\tau'$ by $\\text{deref}$ and $\\text{app}$. With (12) by the Replacement$^+$ Lemma, we have $\\Gamma \\triangleright \\rho\\theta(x, v).R[v] : \\tau$.\n\n**Case** $\\rho\\theta(x, v_1).R[: = x \\ v_2] \\rightarrow \\rho\\theta(x, v_2).R[v_2]$. From $\\Gamma \\triangleright \\rho\\theta(x, v_1).R[: = x \\ v_2] : \\tau$ by $\\rho$\\n\n(13) $\\Gamma' \\triangleright v_1 : \\tau'$\n\nwhere $\\tau'$ is imperative and $\\Gamma'x = \\tau'\\text{ref}$. Thus $\\Gamma' \\triangleright x : \\tau'\\text{ref}$, and by $\\text{assign}$ and $\\text{app}$\n\n\\[\\Gamma' \\triangleright \\ := x : \\tau' \\rightarrow \\tau'\\]\n\n\\[\\Gamma' \\triangleright := x \\ v_2 : \\tau' \\quad \\text{and} \\quad \\Gamma' \\triangleright v_2 : \\tau' \\quad \\text{by app.}\\]\n\nWith (13) and using the Replacement$^+$ Lemma twice, we have $\\Gamma \\triangleright \\rho\\theta(x, v_2).R[v_2] : \\tau$.\n\n**Case** $\\rho\\theta_1, \\rho\\theta_2.e \\rightarrow \\rho\\theta_1, \\rho\\theta_2.e : \\tau$ by $\\rho$\\n\n(14) $\\Gamma' \\triangleright \\rho\\theta_2.e : \\tau$ and $\\Gamma' \\triangleright v_i : \\tau_i$\n\nwhere $\\theta_1 = \\langle x_1, v_1 \\rangle \\ldots \\langle x_n, v_n \\rangle$, $\\Gamma' = \\Gamma[x_1 \\mapsto \\tau_1 \\text{ref}] \\ldots [x_n \\mapsto \\tau_n \\text{ref}]$, and $1 \\leq i \\leq n$. Again by $\\rho$\\n\n(15) $\\Gamma'' \\triangleright e : \\tau$ and $\\Gamma'' \\triangleright v'_j : \\tau'_j$\n\nwhere $\\theta_2 = \\langle x'_1, v'_1 \\rangle \\ldots \\langle x'_m, v'_m \\rangle$, $\\Gamma'' = \\Gamma'[x'_1 \\mapsto \\tau'_1 \\text{ref}] \\ldots [x'_m \\mapsto \\tau'_m \\text{ref}]$, and $1 \\leq j \\leq m$. Since $\\text{Dom}(\\theta_1) \\cap \\text{Dom}(\\theta_2) = \\emptyset$ (by the variable conventions),\n\n\\[\\Gamma'' \\triangleright v_i : \\tau_i \\quad \\text{for } 1 \\leq i \\leq n\\]\n\nby (14),\n\n\\[\\Gamma \\triangleright \\rho\\theta_1, \\rho\\theta_2.e : \\tau\\]\n\nby $\\rho$ with (15).\nCase $R[\\rho \\theta . e] \\rightarrow \\rho \\theta . R[e]$. We have $\\Gamma \\triangleright R[\\rho \\theta . e] : \\tau$, and proceed by induction on the structure of $R$ to show $\\Gamma \\triangleright \\rho \\theta . R[e] : \\tau$.\n\nCase $R = \\emptyset$. Then $R[\\rho \\theta . e] = \\rho \\theta . R[e]$.\n\nCase $R = (R' \\ e')$. Then $\\Gamma \\triangleright (R'[\\rho \\theta . e] \\ e') : \\tau$, and by \\textbf{app}\n\n(16) \\hspace{1cm} \\Gamma \\triangleright R'[\\rho \\theta . e] : \\tau' \\rightarrow \\tau\n(17) \\hspace{1cm} \\text{and } \\Gamma \\triangleright e' : \\tau'.\n\nThen $\\Gamma \\triangleright \\rho \\theta . R'[e] : \\tau' \\rightarrow \\tau$ by ind. hyp. with (16), and by \\textbf{rho}\n\n(18) \\hspace{1cm} \\Gamma[x_i \\mapsto \\tau_i \\text{ ref}] \\triangleright v_i : \\tau_i\n(19) \\hspace{1cm} \\text{and } \\Gamma[x_i \\mapsto \\tau_i \\text{ ref}] \\triangleright R'[e] : \\tau' \\rightarrow \\tau\n\nwhere $\\theta = \\langle x_1, v_1 \\rangle \\ldots \\langle x_n, v_n \\rangle$ and $1 \\leq i \\leq n$. Since $x_1, \\ldots, x_n \\notin FV(e')$, $\\Gamma[x_i \\mapsto \\tau_i \\text{ ref}] \\triangleright e' : \\tau'$ \\hspace{1cm} \\text{by Lemma 4.1}^+ \\text{ with (17)}, $\\Gamma[x_i \\mapsto \\tau_i \\text{ ref}] \\triangleright R'[e] : e' : \\tau$ \\hspace{1cm} \\text{by \\textbf{app} with (19)}, $\\Gamma \\triangleright \\rho \\theta . R'[e] : e' : \\tau$ \\hspace{1cm} \\text{by \\textbf{rho} with (18)}.\n\nCase $R = (v \\ R')$. Similar to the previous case.\n\nCase $R = \\text{let } x \\ \\text{ be } R' \\ \\text{ in } e'$. Then $\\Gamma \\triangleright \\text{let } x \\ \\text{ be } R'[\\rho \\theta . e] \\ \\text{ in } e' : \\tau$, and by \\textbf{let}_e\n\n(20) \\hspace{1cm} \\Gamma \\triangleright R'[\\rho \\theta . e] : \\tau'\n(21) \\hspace{1cm} \\text{and } \\Gamma[x \\mapsto \\text{AppClose}(\\tau', \\Gamma)] \\triangleright e' : \\tau.\n\nThen $\\Gamma \\triangleright \\rho \\theta . R'[e] : \\tau'$ by ind. hyp. with (20), and by \\textbf{rho}\n\n(22) \\hspace{1cm} \\Gamma[x_i \\mapsto \\tau_i \\text{ ref}] \\triangleright v_i : \\tau_i\n(23) \\hspace{1cm} \\text{and } \\Gamma[x_i \\mapsto \\tau_i \\text{ ref}] \\triangleright R'[e] : \\tau'\n\nwhere $\\theta = \\langle x_1, v_1 \\rangle \\ldots \\langle x_n, v_n \\rangle$ and each $\\tau_i$ is imperative for $1 \\leq i \\leq n$. Since $x_1, \\ldots, x_n \\notin FV(e')$, $\\Gamma[x \\mapsto \\text{AppClose}(\\tau', \\Gamma)] \\triangleright v_i : \\tau'$ \\hspace{1cm} \\text{by Lemma 4.1}^+ \\text{ with (21)}$i.e. \\Gamma[x_i \\mapsto \\tau_i \\text{ ref}] \\triangleright e' : \\tau$.\n\nBut each $\\tau_i$ is imperative, due to the restriction on the typing of $\\rho$-expressions, hence $\\text{AppClose}(\\tau', \\Gamma) = \\text{AppClose}(\\tau', \\Gamma[x_i \\mapsto \\tau_i \\text{ ref}])$.\n\nIf $R'[e]$ is expansive, then\n\n$\\Gamma[x_i \\mapsto \\tau_i \\text{ ref}] \\triangleright \\text{let } x \\ \\text{ be } R'[e] \\ \\text{ in } e' : \\tau$ \\hspace{1cm} \\text{by \\textbf{let}_e with (23)}\n\n$\\Gamma \\triangleright \\rho \\theta . \\text{let } x \\ \\text{ be } R'[e] \\ \\text{ in } e' : \\tau$ \\hspace{1cm} \\text{by \\textbf{rho} with (22)}.\n\nOtherwise, $R'[e]$ is non-expansive, and\n\n$\\Gamma[x_i \\mapsto \\tau_i \\text{ ref}] \\triangleright \\text{let } x \\ \\text{ be } R'[e] \\ \\text{ in } e' : \\tau$ \\hspace{1cm} \\text{by \\textbf{let}_v with (23)}\n\n$\\Gamma \\triangleright \\rho \\theta . \\text{let } x \\ \\text{ be } R'[e] \\ \\text{ in } e' : \\tau$ \\hspace{1cm} \\text{by \\textbf{rho} with (22)}.\nThus $\\Gamma \\vdash \\rho \\theta.R[e] : \\tau$ by induction.\n\nIt remains to extend the proofs of the various lemmas. The only one that is not straightforward is the Substitution Lemma. As in the definition of generalization, substitutions $S$ in the following proof are required to map imperative type variables to imperative types.\n\n**Lemma 5.3 (Substitution)** \\(\\text{If } \\Gamma[x \\leftarrow \\forall \\alpha_1 \\ldots \\alpha_n, \\tau] \\vdash e : \\tau' \\text{ and } x \\notin \\text{Dom}(\\Gamma) \\text{ and } \\Gamma \\vdash v : \\tau \\text{ and } \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap \\text{FTV}(\\Gamma) = \\emptyset \\text{ then } \\Gamma \\vdash e[x \\leftarrow v] : \\tau'.\\)\n\n**Proof.** The cases from the proof for Functional ML are unchanged, with the exception that the let-expression case applies only when the bound expression is a value. There is one new case for expansive let-expressions, and new cases for the additional syntax.\n\n**Case** $e = \\text{ref, !, or :=}. \\text{ In each case, } \\Gamma' \\vdash e : \\tau' \\text{ for any } \\Gamma', \\text{ hence } \\Gamma \\vdash e : \\tau'$. \\text{ Also in each case, } e[x \\leftarrow v] = e, \\text{ so } \\Gamma \\vdash e[x \\leftarrow v] : \\tau'.\n\n**Case** $e = \\rho \\theta.e_1$. \\text{ From } $\\Gamma[x \\leftarrow \\forall \\alpha_1 \\ldots \\alpha_n, \\tau] \\vdash \\rho \\theta.e_1 : \\tau'$ by rho\n\n\\[\n\\Gamma[x \\leftarrow \\forall \\alpha_1 \\ldots \\alpha_n, \\tau][x_i \\leftarrow \\tau_i \\text{ ref}] \\vdash v_i : \\tau_i\n\\]\n\n\\text{ and in } $\\Gamma[x \\leftarrow \\forall \\alpha_1 \\ldots \\alpha_n, \\tau][x_i \\leftarrow \\tau_i \\text{ ref}] \\vdash e_1 : \\tau'$\n\nwhere $\\theta = \\langle x_1, v_1 \\rangle \\ldots \\langle x_m, v_m \\rangle$, $x_1, \\ldots, x_m, x$ are distinct, and each $\\tau_i$ is imperative for $1 \\leq i \\leq m$. Choose a substitution $S : \\{\\alpha_1, \\ldots, \\alpha_n\\} \\rightarrow \\{\\alpha'_1, \\ldots, \\alpha'_n\\}$ such that $\\alpha'_1, \\ldots, \\alpha'_n$ are distinct type variables, $\\alpha_i = \\alpha'_i$, and $\\{\\alpha'_1, \\ldots, \\alpha'_n\\} \\cap (\\{\\alpha_1, \\ldots, \\alpha_n\\} \\cup \\text{FTV}(\\Gamma) \\cup \\text{FTV}(\\tau') \\cup \\bigcup_i \\text{FTV}(\\tau_i)) = \\emptyset$. Then by Lemma 4.5+\n\n\\[\nS(\\Gamma[x \\leftarrow \\forall \\alpha_1 \\ldots \\alpha_n, \\tau][x_i \\leftarrow \\tau_i \\text{ ref}] \\vdash v_i : S\\tau_i\n\\]\n\n\\text{i.e. } $\\Gamma[x \\leftarrow \\forall \\alpha_1 \\ldots \\alpha_n, \\tau][x_i \\leftarrow \\tau_i \\text{ ref}] \\vdash v_i : S\\tau_i\n\\]\n\n\\text{i.e. } $\\Gamma[x_i \\leftarrow S\\tau_i \\text{ ref}][x \\leftarrow \\forall \\alpha_1 \\ldots \\alpha_n, \\tau] \\vdash e_1 : S\\tau_i\n\\]\n\nAlso by Lemma 4.5+\n\n\\[\nS(\\Gamma[x \\leftarrow \\forall \\alpha_1 \\ldots \\alpha_n, \\tau][x_i \\leftarrow \\tau_i \\text{ ref}] \\vdash e_1 : S\\tau'\n\\]\n\n\\text{i.e. } $\\Gamma[x \\leftarrow \\forall \\alpha_1 \\ldots \\alpha_n, \\tau][x_i \\leftarrow S\\tau_i \\text{ ref}] \\vdash e_1 : S\\tau'\n\\]\n\n\\text{i.e. } $\\Gamma[x_i \\leftarrow S\\tau_i \\text{ ref}][x \\leftarrow \\forall \\alpha_1 \\ldots \\alpha_n, \\tau] \\vdash e_1 : S\\tau'.\n\\]\n\nBy applying the inductive hypothesis to each,\n\n\\[\n\\Gamma[x_i \\leftarrow \\tau_i \\text{ ref}] \\vdash v_i[x \\leftarrow v] : S\\tau_i\n\\]\n\n\\text{ and } $\\Gamma[x_i \\leftarrow \\tau_i \\text{ ref}] \\vdash e_1[x \\leftarrow v] : S\\tau'.\n\\]\n\nSince $S$ is a bijection, $S^{-1}$ exists; hence\n\n\\[\n\\Gamma[x_i \\leftarrow \\tau_i \\text{ ref}] \\vdash v_i[x \\leftarrow v] : \\tau_i\n\\]\n\n\\text{ and } $\\Gamma[x_i \\leftarrow \\tau_i \\text{ ref}] \\vdash e_1[x \\leftarrow v] : \\tau'.\n\\]\n\nThen $\\Gamma \\vdash \\rho \\theta[e[x \\leftarrow v].e_1[x \\leftarrow v] : \\tau' \\text{ by rho, thus } \\Gamma \\vdash (\\rho \\theta.e_1)[x \\leftarrow v] : \\tau'.}$\nCase $e = \\text{let } x' \\text{ be } e_1 \\text{ in } e_2$ where $e_1 \\notin \\text{Values}$. By the first premise of let$_e$\n\n\\[\n\\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau] \\triangleright e_1 : \\tau_1\n\\]\n\n(24)\n\n$\\Gamma \\triangleright e_1[x \\mapsto v] : \\tau_1$\n\nby ind. hyp.\n\nBy the second premise of let$_e$\n\n\\[\n\\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau][x' \\mapsto \\text{AppClose}(\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])] \\triangleright e_2 : \\tau'\n\\]\n\ni.e. $\\Gamma[x' \\mapsto \\text{AppClose}(\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])] \\triangleright e_2 : \\tau'$\n\nChoose a substitution $S : \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap \\text{ImpTypeVar} \\rightarrow \\{\\alpha'_1, \\ldots, \\alpha'_m\\}$ such that $\\alpha'_1, \\ldots, \\alpha'_m$ are distinct imperative type variables, $S$ is a bijection, and $\\{\\alpha_1', \\ldots, \\alpha_m'\\} \\cap (\\text{FTV}(\\Gamma) \\cup \\text{FTV}(\\tau) \\cup \\{\\alpha_1, \\ldots, \\alpha_n\\}) = \\emptyset$. Then by Lemma 4.5$^+$\n\n\\[\nS(\\Gamma[x' \\mapsto \\text{AppClose}(\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])]\\triangleright e_2 : S\\tau'\n\\]\n\ni.e. $\\Gamma[x' \\mapsto S\\text{AppClose}(\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])]\\triangleright e_2 : S\\tau'$\n\n(25) i.e. $\\Gamma[x' \\mapsto \\text{AppClose}(S\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])]\\triangleright e_2 : S\\tau'$\n\nsince the domain of $S$ contains only imperative type variables. From $\\Gamma \\triangleright v : \\tau$ since $x'$ is not free in $v$\n\n(26)\n\n\\[\n\\Gamma[x' \\mapsto \\text{AppClose}(S\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])] \\triangleright v : \\tau.\n\\]\n\nNow,\n\n\\[\n\\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap \\text{FTV}(\\Gamma[x' \\mapsto \\text{AppClose}(S\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])])\n\\]\n\n$\\subseteq \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap (\\text{FTV}(\\Gamma) \\cup \\text{FTV}(\\text{AppClose}(S\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])))$\n\n$= \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap \\text{FTV}(\\text{AppClose}(S\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau]))$\n\n$= \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap \\text{FTV}(\\forall \\alpha_{1''} \\ldots \\alpha_{m''}. S\\tau_1)$\n\n$= \\{\\alpha_1, \\ldots, \\alpha_n\\} \\cap (\\text{FTV}(S\\tau_1) \\setminus \\{\\alpha_{1''}, \\ldots, \\alpha_{m''}\\})$\n\n$= \\emptyset$\n\nwhere $\\{\\alpha_{1''}, \\ldots, \\alpha_{m''}\\} = (\\text{FTV}(S\\tau_1) \\setminus \\text{FTV}(\\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])) \\cap \\text{AppTypeVar}$. By the inductive hypothesis with (25) and (26), it follows that\n\n\\[\n\\Gamma[x' \\mapsto \\text{AppClose}(S\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])] \\triangleright e_2[x \\mapsto v] : S\\tau'.\n\\]\n\nSince $S$ is a bijection, $S^{-1}$ exists, so by Lemma 4.5$^+$\n\n\\[\nS^{-1}(\\Gamma[x' \\mapsto \\text{AppClose}(S\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])] \\triangleright e_2[x \\mapsto v] : S^{-1}(S\\tau')\n\\]\n\ni.e. $\\Gamma[x' \\mapsto \\text{AppClose}(\\tau_1, \\Gamma[x \\mapsto \\forall \\alpha_1 \\ldots \\alpha_n. \\tau])] \\triangleright e_2[x \\mapsto v] : \\tau'$.\n\nThen by Lemma 4.6$^+$\n\n\\[\n\\Gamma[x' \\mapsto \\text{AppClose}(\\tau_1, \\Gamma)] \\triangleright e_2[x \\mapsto v] : \\tau'\n\\]\n\nand by let$_e$ with (24)\n\n\\[\n\\Gamma \\triangleright \\text{let } x \\text{ be } e_1[x \\mapsto v] \\text{ in } e_2[x \\mapsto v] : \\tau'\n\\]\n\ni.e. $\\Gamma \\triangleright (\\text{let } x \\text{ be } e_1 \\text{ in } e_2)[x \\mapsto v] : \\tau'$. \n\n$\\blacksquare$\nThe evaluation of an expression in Reference ML can become stuck for several new reasons. The expanded definition of faulty expressions reflects this fact.\n\n**Definition 5.4 (Faulty Expressions)** The faulty expressions of Reference ML are those expressions containing a subexpression of the form:\n\n\\[\n(c \\; v) \\text{ where } \\delta(c, v) \\text{ is undefined};\n\\]\n\n\\[\n(\\! v) \\text{ where } v \\notin \\text{Var};\n\\]\n\n\\[\n(= v) \\text{ where } v \\notin \\text{Var}; \\text{ or}\n\\]\n\n\\[\n\\rho\\theta(x, v_2).C[x \\; v_1].\n\\]\n\nAs before, we have a Uniform Evaluation Lemma, stating that programs either yield an answer, diverge, or reduce to a faulty expression.\n\n**Lemma 5.5 (Uniform Evaluation)** For closed \\( e \\), if there is no \\( e' \\) such that \\( e \\xrightarrow{\\text{vr}} e' \\) and \\( e' \\) is faulty, then either \\( e \\Downarrow \\) or \\( e \\xrightarrow{\\text{vr}} a \\).\n\n**Proof.** The proof proceeds by induction on the length of the reduction sequence, and is similar to the proof for Functional ML. \\( \\blacksquare \\)\n\nAll of the expressions in the expanded definition are untypable.\n\n**Main Lemma 5.6 (Faulty Expressions are Untypable)** If \\( e \\) is faulty, there are no \\( \\Gamma \\) and \\( \\tau \\) such that \\( \\Gamma \\vdash e : \\tau \\).\n\n**Proof.** Again, it suffices to show that the subexpressions of \\( e \\) that cause \\( e \\) to be faulty are untypable. We proceed by case analysis according to the form of the subexpression, assuming for each case that the expression can be typed, and deriving a contradiction.\n\n**Case** \\((c \\; v)\\) where \\( \\delta(c, v) \\) is undefined. As for Functional ML.\n\n**Case** \\((\\! v)\\) where \\( v \\notin \\text{Var} \\). Assume that \\( \\Gamma \\vdash \\! v : \\tau \\). Then \\( \\Gamma \\vdash v : \\tau \\text{ ref} \\) by \\texttt{app} and \\texttt{deref},\n\nwhich implies \\( v \\) is a variable (since no other value can have type \\( \\tau \\text{ ref} \\)), contrary to the assumption.\n\n**Case** \\((= v)\\) where \\( v \\notin \\text{Var} \\). Assume that \\( \\Gamma \\vdash = v : \\tau \\). Then \\( \\Gamma \\vdash v : \\tau' \\text{ ref} \\) where \\( \\tau = \\tau' \\rightarrow \\tau' \\) by \\texttt{app} and \\texttt{assign}, which implies \\( v \\) is a variable, contrary to the assumption.\n\n**Case** \\(\\rho\\theta(x, v').C[x \\; v]\\). Assume that \\( \\Gamma \\vdash \\rho\\theta(x, v').C[x \\; v] : \\tau \\). Then \\( \\Gamma' \\vdash C[x \\; v] : \\tau \\) by \\texttt{rho},\n\nwhere \\( \\Gamma'(x) = \\tau' \\text{ ref} \\). Since \\( \\Gamma'' \\vdash x \\; v : \\tau_2 \\) where \\( \\Gamma''(x) = \\Gamma''(x), \\; \\Gamma'' \\vdash x : \\tau_1 \\rightarrow \\tau_2 \\) by \\texttt{app}, hence \\( \\Gamma''(x) \\vdash \\tau_1 \\rightarrow \\tau_2 \\). This contradicts \\( \\Gamma''(x) = \\tau' \\text{ ref} \\). \\( \\blacksquare \\)\n\nType soundness now follows as before.\n\n**Theorem 5.7 (Syntactic Soundness for Reference ML)** If \\( \\vdash e : \\tau \\) then either \\( e \\Downarrow \\) or \\( e \\xrightarrow{\\text{vr}} a \\) and \\( \\vdash a : \\tau \\).\n\n**Proof.** Exactly as for Theorem 4.12, using the appropriately extended lemmas. \\( \\blacksquare \\)\n5.2 Exception ML\n\nDue to δ-typability, constant functions must be defined for all values of their input type. This precludes constants, such as integer or real division, that are defined on all but a few recognizable input values of correct type. STANDARD ML solves this problem by introducing exceptions.\n\nOur exception extension provides named exceptions with parameters, a means of raising exceptions, and a means of handling exceptions. Our extension thus includes three new phrases:\n\n\\[ \\text{exception } x_1 \\ldots x_n \\text{ in } e, \\quad \\text{raise } e_1 \\ e_2, \\quad e_3 \\text{ handle } e_1 \\ e_2. \\]\n\nThe first phrase declares \\( x_1, \\ldots, x_n \\) to be exception names lexically bound in \\( e \\). The second phrase requires \\( e_1 \\) to evaluate to an exception name, and raises that exception with a parameter, the value of \\( e_2 \\). The parameter propagates along with the exception, and is used at the site where an exception is handled. The third phrase evaluates its subexpressions \\( e_1 \\) and \\( e_2 \\) first, and installs the value of \\( e_2 \\) as an exception handler for \\( e_1 \\) exceptions that are raised during the evaluation of \\( e_3 \\). The subexpression \\( e_1 \\) must evaluate to an exception name, and \\( e_2 \\) must evaluate to a function that accepts parameters of \\( e_1 \\) exceptions. When an exception is raised, control transfers to the dynamically closest handler for that kind of exception. The handler function is applied to the exception parameter, and the result of the application is returned as the result of the \\textit{handle}-phrase. If there is no active handler for a raised exception, evaluation terminates with an “unhandled exception” answer.\n\nTo extend Functional ML with exceptions, we add several new phrases to the syntax:\n\n\\[\n(\\text{Expressions}) \\quad e ::= v \\mid e_1 e_2 \\mid \\text{let } x \\text{ be } e_1 \\text{ in } e_2 \\mid \\text{exception } \\chi \\text{ in } e \\\\\n(\\text{Values}) \\quad v ::= c \\mid x \\mid \\lambda x.e \\mid \\text{raise } e \\mid \\text{handle } e \\mid \\text{raise } v \\mid e \\text{ handle } v \\\\\n\\chi ::= x^* \n\\]\n\nIn the expression \\text{exception } \\chi \\text{ in } e, \\) the variables in \\( \\chi \\) are bound in \\( e \\). We treat \\( \\chi \\) as a set of variables, and call these exception names. As \\text{raise} is a curried binary operator, the application of \\text{raise} to a value is a value, and is included in the syntactic class of values (like := in Reference ML). Likewise, the expression \\( e \\text{ handle} \\) is a value, and receives an exception name and handler function by ordinary application. Hence the application of \\( e \\text{ handle} \\) to a value is also a value.\n\n5.2.1 Semantics\n\nRaising and handling exceptions requires several new reductions:\n\n\\[\n(\\text{raise}) \\quad U[\\text{raise } x \\ v] \\rightarrow \\text{raise } x \\ v \\quad \\text{if } U \\neq [] \\\\\n(\\text{handle}) \\quad (\\text{raise } x \\ v_1) \\text{ handle } x \\ v_2 \\rightarrow v_2 \\ v_1 \\\\\n(\\text{reraise}) \\quad \\text{exception } \\chi^1 x_2 \\text{ in } X[(\\text{raise } x_1 \\ v_1) \\text{ handle } x_2 \\ v_2] \\rightarrow \\text{exception } \\chi^1 x_2 \\text{ in } X[\\text{raise } x_1 \\ v_1] \\quad x_1 \\neq x_2 \\\\\n(\\text{unhandle}) \\quad v_1 \\text{ handle } x \\ v_2 \\rightarrow v_1 \n\\]\n\nThese new notions of reduction again rely on (two different kinds of) contexts for the enforcement of a specific order of evaluation for applications in connection with the raising\nand handling of exceptions:\n\n\\[\n\\begin{align*}\n\\text{(raising)} & \\quad U ::= \\emptyset \\mid U \\; e \\; U \\mid \\text{let } x \\; \\text{be } U \\text{ in } e \\\\\n\\text{(handling)} & \\quad X ::= \\emptyset \\mid X \\; e \\; X \\mid \\text{let } x \\; \\text{be } X \\text{ in } e \\mid X \\; \\text{handle } x \\; v.\n\\end{align*}\n\\]\n\nWhen an exception is raised, \\textit{raise} reductions propagate the exception outwards, eliminating pending computations. As \\(U\\) contexts do not include the phrase \\(U \\; \\text{handle } x \\; v\\), \\textit{raise} reductions propagate the exception only to the closest exception handler. If the closest handler matches the raised exception, a \\textit{handle} reduction applies the handler function to the exception parameter. If the handler does not match the exception, a \\textit{reraise} reduction discards the handler, and the exception may continue to propagate by \\textit{raise} reductions. Should an expression protected by a handler evaluate to a value without raising an exception, the \\textit{unhandle} reduction discards the handler.\n\nThe \\textit{exception} expression requires two additional reductions, similar to those for \\(\\rho\\)-expressions:\\footnote{Due to our use of the variable conventions for \\textit{exnmerge}, our exceptions are \\textit{general} as in \\textsc{Standard ML} [22, 23].}\n\n\\[\n\\begin{align*}\n\\text{(exnmerge)} & \\quad \\text{exception } \\chi_1 \\text{ in exception } \\chi_2 \\text{ in } e \\longrightarrow \\text{exception } \\chi_1 \\chi_2 \\text{ in } e \\\\\n\\text{(exnify)} & \\quad X[\\text{exception } \\chi \\text{ in } e] \\longrightarrow \\text{exception } \\chi \\text{ in } X[e] \\text{ if } X \\neq \\emptyset\n\\end{align*}\n\\]\n\nIndeed, the only difference is that the \\textit{exception} expression does not bind any values to its variables. The purpose of an \\textit{exception} expression is to distinguish different exceptions in the \\textit{reraise} reduction, in order that evaluation be deterministic. If \\(x_1\\) and \\(x_2\\) are different but only \\(\\lambda\\)- or \\textit{let}-bound, subsequent reductions may substitute them to the same \\textit{exception}-bound variable, making the \\textit{raise} reduction applicable. For example:\n\n\\[\n\\begin{align*}\n\\text{exception } x & \\text{ in } (\\lambda y. \\lambda z. (\\text{raise } y \\; v_1) \\text{ handle } z \\; v_2) \\; x \\; x \\\\\n& \\longrightarrow \\text{exception } x \\text{ in } (\\text{raise } x \\; v_1) \\text{ handle } x \\; v_2 \\\\\n& \\longrightarrow \\text{exception } x \\text{ in } v_2 \\; v_1.\n\\end{align*}\n\\]\n\nInsisting that \\(x_1\\) and \\(x_2\\) be \\textit{exception}-bound in \\textit{reraise} ensures that they refer to distinct exceptions. The reduction \\textit{handle} does not require its variables to be \\textit{exception}-bound, because substitution necessarily replaces both instances of \\(x\\) in the \\textit{handle} redex with the same exception name.\n\nWe use \\(x\\) to refer to the six reductions for exceptions introduced above. Taking the union of \\(v\\) (extended to the full syntax) and \\(x\\) yields \\(v_x\\), the notion of reduction for Exception ML. With evaluation contexts extended to:\n\n\\[\nE ::= \\emptyset \\mid E \\; e \\mid v \\; E \\mid \\text{let } x \\; \\text{be } E \\text{ in } e \\mid \\text{exception } \\chi \\text{ in } E \\mid E \\; \\text{handle } x \\; v\n\\]\n\nthe stepping function \\(\\xrightarrow{v_x}\\) may be defined along the same lines as before. Answers for \\textit{evalv} are:\n\n\\[\n\\text{(answers)} \\quad a ::= v \\mid \\text{exception } \\chi \\text{ in } v \\mid \\text{exception } \\chi x \\text{ in } \\text{raise } x \\; v.\n\\]\nAnswers of the third form are *unhandled exceptions*: since handlers are dynamically bound, it is possible for an exception to be raised when no handler for it is installed. Evaluation is defined as:\n\n\\[(\\text{eval}_V x) \\quad \\text{eval}_V (e) = a \\quad \\text{iff} \\quad e \\xrightarrow{V} a.\\]\n\nWe can now extend the domain of \\(\\delta\\) to admit functions such as division, by allowing \\(\\delta\\) to return an expression that raises an exception:\\(^8\\)\n\n\\[\\delta : \\text{Const} \\times \\text{ClosedVal} \\rightarrow \\text{ClosedVal} \\cup \\{\\text{exception x in raise x v | v is closed}\\}.\\]\n\nFunctions such as division can now be defined on every element of their input type, by returning an exception when their application does not make sense.\n\n### 5.2.2 Typing\n\nWe extend the set of types with an additional type constructor:\n\n\\[\\tau ::= \\iota_1 | \\ldots | \\iota_n | \\alpha | \\tau_1 \\rightarrow \\tau_2 | \\tau \\text{ except} \\]\n\nThe type \\(\\tau \\text{ except}\\) is the type of exceptions with a parameter of type \\(\\tau\\).\n\nIn typing exceptions in the presence of polymorphism, one encounters similar difficulties as in typing references. The phrase \\(\\text{raise } e_1 e_2\\) requires \\(e_1\\) to be an exception of type \\(\\tau \\text{ except}\\), and \\(e_2\\) to be a matching parameter of type \\(\\tau\\). If \\(e_3\\) has type \\(\\tau'\\), the phrase \\(e_3 \\text{ handle } e_1 e_2\\) requires \\(e_1\\) to be an exception of type \\(\\tau \\text{ except}\\), and \\(e_2\\) to be a handler for such exceptions. The handler must be a function of type \\(\\tau \\rightarrow \\tau'\\), since it takes the exception parameter as input, and returns a value to be returned in place of the value of \\(e_3\\). The obvious typing for exceptions allows the parameter types of exceptions to be fully polymorphic, permitting the following expression to be typed:\\(^9\\)\n\n\\[\n\\text{let } rh \\text{ be exception x in pair (raise x) (\\lambda a. \\lambda b. (a 3) handle x b)} \\\\\n\\quad \\text{in (snd rh) (\\lambda d. (fst rh) true) (\\lambda y. + 1 y)} \\\\\n\\quad \\rightarrow \\text{exception x in } + 1 \\text{ true}\n\\]\n\nHere, functions to raise and handle the same \\(x\\)-exception are returned as a pair, bound by a \\textit{let}-expression to \\(rh\\), and then used. In the body of the \\textit{let}-expression, the expression \\((\\text{raise } x)\\) has type \\(\\alpha_1 \\rightarrow \\alpha_2\\), and \\((\\lambda a. \\lambda b. (a 3) \\text{ handle } x b)\\) has type \\((\\text{int} \\rightarrow \\alpha_3) \\rightarrow (\\alpha_1 \\rightarrow \\alpha_3) \\rightarrow \\alpha_3\\). If the exception parameter type \\(\\alpha_1\\) is generalized, then in the body of the \\textit{let}-expression an \\(x\\)-exception may be raised with an argument of type \\(\\text{bool}\\) by \\((\\text{fst } rh)\\), and caught by \\((\\text{snd } rh)\\), which is expecting an argument of type \\(\\text{int}\\).\n\nSince the problems of typing exceptions and references are similar, it is not surprising that the same modifications to the typing rules for functional expressions apply: types and type variables are classified as imperative or applicative, and the \\textit{let} rule is split according to whether the bound expression is expansive (see Figure 3). Figure 5 presents the additional typing rules for exceptions. Again, as with Reference ML, we require the additional restriction that there be no constants of exception type \\((\\tau \\text{ except})\\).\n\n---\n\n\\(^8\\) Usually a set of exceptions that may be raised by constant functions is defined in an initial environment; we take an alternative approach to simplify the presentation.\n\n\\(^9\\) The constants \\textit{pair}, \\textit{fst}, and \\textit{snd} provide pairing and projection operations.\n5.2.3 Type Soundness for Exceptions\n\nTo establish soundness for the exception typing, we proceed as for references: we establish type preservation for \\( \\mathbf{vx} \\), and show that the faulty expressions of Exception ML are untypeable.\n\n**Main Lemma 5.8 (Subject Reduction for \\( \\mathbf{vx} \\))**\n\nIf \\( \\Gamma \\vdash e_1 : \\tau \\) and \\( e_1 \\xrightarrow{\\mathbf{vx}} e_2 \\) then \\( \\Gamma \\vdash e_2 : \\tau \\).\n\n**Proof.** The cases for the reductions of \\( \\mathbf{v} \\) are the same as before.\n\n**Case** \\( U[\\text{raise } x \\ v] \\rightarrow \\text{raise } x \\ v \\). From \\( \\Gamma \\vdash U[\\text{raise } x \\ v] : \\tau \\)\n\n\\[ \\Gamma \\vdash \\text{raise } x \\ v : \\tau' \\]\n\nby \\text{app}. Hence\n\n(27) \\[ \\Gamma \\vdash \\text{raise } x : \\tau_1 \\rightarrow \\tau_2 \\]\n\n(28) \\[ \\Gamma \\vdash v : \\tau_1 \\]\n\nby \\text{app}. From (27)\n\n\\[ \\Gamma \\vdash x : \\tau_1 \\ \\text{exn} \\quad \\text{by } \\text{app} \\text{ and } \\text{raise}, \\]\n\n\\[ \\Gamma \\vdash \\text{raise } x : \\tau_1 \\rightarrow \\tau \\quad \\text{by } \\text{app} \\text{ and } \\text{raise}, \\]\n\n\\[ \\Gamma \\vdash \\text{raise } x \\ v : \\tau \\quad \\text{by } \\text{app} \\text{ with (28)}. \\]\n\n**Case exception** \\( \\chi_1 \\) in exception \\( \\chi_2 \\) in \\( e \\rightarrow \\text{exception } \\chi_1 \\chi_2 \\) in \\( e \\). Similar to \\( \\rho_{\\text{merge}} \\) in Lemma 5.2.\n\n**Case** \\( X[\\text{exception } \\chi \\text{ in } e] \\rightarrow \\text{exception } \\chi \\text{ in } X[e] \\). Similar to \\( \\rho_{\\text{lift}} \\) in Lemma 5.2.\n\n**Case** \\( v_1 \\text{ handle } x \\ v_2 \\rightarrow v_1 \\). \\( \\Gamma \\vdash v_1 : \\tau \\) from \\( \\Gamma \\vdash v_1 \\text{ handle } x \\ v_2 : \\tau \\) by \\text{handle} and \\text{app}.\n\n**Case** \\( \\text{raise } x \\ v_1 \\) handle \\( x \\ v_2 \\rightarrow v_2 \\ v_1 \\). From \\( \\Gamma \\vdash (\\text{raise } x \\ v_1) \\text{ handle } x \\ v_2 : \\tau \\) by \\text{handle}, \\text{app}, and \\text{raise}\n\n\\[ \\Gamma \\vdash v_1 : \\tau' \\quad \\text{and } \\quad \\Gamma \\vdash v_2 : \\tau' \\rightarrow \\tau \\]\n\nwhere \\( \\Gamma x = \\tau' \\text{ exn} \\). Then \\( \\Gamma \\vdash v_2 \\ v_1 : \\tau \\) by \\text{app}.\nCase exception $\\chi x_1 x_2$ in $X[(\\text{raise } x_1 v_1) \\text{ handle } x_2 v_2] \\rightarrow$ exception $\\chi x_1 x_2$ in $X[\\text{raise } x_1 v_1]$. Then\n\n$$\n\\Gamma' \\models (\\text{raise } x_1 v_1) \\text{ handle } x_2 v_2 : \\tau' \\\\\n\\Gamma' \\models (\\text{raise } x_1 v_1) \\text{ handle } : \\tau_2 \\text{ expr } \\rightarrow (\\tau_2 \\rightarrow \\tau') \\rightarrow \\tau'\n$$\n\nby $\\text{app}$,\n\n$$\n\\Gamma' \\models \\text{raise } x_1 v_1 : \\tau'\n$$\n\nby $\\text{handle}$,\n\n$$\n\\Gamma \\models \\text{exception } \\chi x_1 x_2 \\text{ in } X[\\text{raise } x_1 v_1] : \\tau\n$$\n\nby Replacement$^+$.\n\nWith the extension of the various lemmas, the proof of type preservation for Exception ML is complete. The lemmas go through with simple adaptations to the new syntax. □\n\nThere are several new kinds of faulty expressions for Exception ML.\n\n**Definition 5.9 (Faulty expressions)** The faulty expressions of Exception ML are those expressions containing a subexpression of the form:\n\n$$\n(\\text{e } v) \\text{ where } \\delta(e, v) \\text{ is undefined,} \\\\\n(\\text{raise } v) \\text{ where } v \\notin \\text{Var}, \\\\\n(\\text{e handle } v) \\text{ where } v \\notin \\text{Var}, \\text{ or} \\\\\n\\text{exception } \\chi x \\text{ in } C[x \\ v],\n$$\n\nwhere\n\n$$\nC ::= [] | C \\ e | e \\ C | \\text{let } x \\text{ be } C \\text{ in } e | \\text{let } x \\text{ be } e \\text{ in } C | \\lambda x. C \\\\\n| \\text{exception } \\chi x \\text{ in } C | C \\text{ handle}.\n$$\n\nAgain, a uniform evaluation lemma can be shown, and the faulty expressions can be proven untypable. Type soundness for Exception ML follows as before.\n\n**Theorem 5.10 (Syntactic Soundness for Exception ML)** If $\\bar{v} e : \\tau$ then either $e \\uparrow$ or $e \\xrightarrow{\\bar{v}} a$ and $\\bar{v} a : \\tau$.\n\n### 5.3 Core ML\n\nWe can combine references and exceptions in one language, Core ML, that has all the essential features of Standard ML. In combining the reference and exception extensions, we must ensure that they interact appropriately.\n\n#### 5.3.1 Semantics\n\nTo combine the calculi for the two extensions, the $R$ contexts of the reference fragment must be extended to include phrases from the exception fragment; likewise, $X$ contexts must be extended to include phrases from the reference fragment:\n\n$$\nR ::= \\ldots | R \\text{ handle } v_1 v_2 \\\\\nX ::= \\ldots | \\rho \\theta . X\n$$\nThe phrase exception $\\chi$ in $R$ is not included in $R$ in order that exceptions in the store do not escape their bindings, i.e., exception-expressions can move through $\\rho$-expressions by the $exn_{ij\\theta}$ reduction, with appropriate variable renaming:\n\n$$\\rho\\theta.\\text{exception } \\chi x \\text{ in } e \\longrightarrow \\text{exception } \\chi x \\text{ in } \\rho \\theta.e$$\n\nbut not vice versa:\n\n$$\\text{exception } \\chi x \\text{ in } \\rho \\theta(r, x).e \\nrightarrow \\rho \\theta(r, x).\\text{exception } \\chi x \\text{ in } e.$$\n\nIf the second were a permissible reduction, the occurrence of $x$ in the store would escape its binding.\n\nAfter this extension of the $R$ and $X$ contexts, the resulting notion of reduction for the full syntax is $\\text{vrx}$. The $E$ evaluation contexts used in defining $\\text{vrx}$ and $\\text{eval}_{\\text{vrx}}$ must also be extended:\n\n$$E ::= [] | E \\ e | v \\ E | \\text{let } x \\ be \\ E \\ in \\ e | \\text{let } x \\ be \\ E \\ in \\ e \\ handle \\ v_1 \\ v_2 | \\rho \\theta. E | \\text{exception } \\chi \\text{ in } E.$$\n\nAnswers are:\n\n(answers)\n\n$$a ::= \\{\\text{exception } \\chi \\text{ in } \\} \\{\\rho \\theta.\\} \\ v$$\n\n$$\\qquad \\qquad \\mid \\{\\text{exception } \\chi x \\text{ in } \\} \\{\\rho \\theta.\\} \\text{raise } x \\ v$$\n\n(where $\\{\\text{phrase}\\}$ means phrase may be omitted). The complete calculus for Core ML may be found in the appendix.\n\n### 5.3.2 Typing\n\nTo combine the typing rules for the two fragments is easy, since they both rely on the same classification of types as imperative or applicative, and do not interfere. The complete typing rules for Core ML may be found in the appendix.\n\n### 5.3.3 Type Soundness for Core ML\n\nThe type soundness of the resulting calculus requires re-establishing the various lemmas and theorems for the extended syntax and extended evaluation contexts. These proofs are all straightforward. There is a combinatorial increase in the kinds of faulty expressions because of the interaction between the two fragments: references cannot be raised or handled; exceptions cannot be dereferenced nor assigned. The structure of the proof, however, stays the same.\n\n**Definition 5.11 (Faulty Expressions)** The faulty expressions of Core ML are those expressions containing a subexpression of the form:\n\n$$(e \\ v) \\text{ where } \\delta(e, v) \\text{ is undefined;}$$\n\n$$(! v) \\text{ where } v \\notin \\text{Var},$$\n\n$$(:= v) \\text{ where } v \\notin \\text{Var},$$\n\n$$\\rho \\theta(x, v_2).C[x \\ v_1],$$\n\n$$\\text{exception } \\chi x \\text{ in } C[! x],$$\n\n$$\\text{exception } \\chi x \\text{ in } C[:= x],$$\n\n$$\\rho \\theta(x, v).C[\\text{raise } x],$$\n\n$$\\rho \\theta(x, v).C[\\text{handle } x],$$\n\n$$\\rho \\theta(x, v).C[\\text{exception } \\chi x].$$\nwhere\n\\[\nC ::= [] \\mid C . e \\mid e . C \\mid \\text{let } x \\text{ be } C \\text{ in } e \\mid \\text{let } x \\text{ be } e \\text{ in } C \\mid \\lambda x . C \\\\\n\\mid \\rho \\theta . C \\mid \\rho \\theta (x, C) . e \\mid \\text{exception } \\chi \\text{ in } C \\mid \\text{handle}.\n\\]\n\nType soundness follows from subject reduction, uniform evaluation, and faulty expressions being untypable, as before.\n\n**Theorem 5.12 (Syntactic Soundness for Core ML)** If \\( \\Downarrow e : \\tau \\) then either \\( e \\Updownarrow \\) or \\( e \\Downarrow \\alpha \\) and \\( \\Downarrow \\alpha : \\tau \\).\n\n## 6 Control ML\n\nIn this section we present an extension to Functional ML providing first-class continuations. The typing of our extension is similar to that described by Duba et al. [8], and implemented in Standard ML of New Jersey [34]. It is a simple matter to merge this extension with Core ML.\n\nControl ML extends Functional ML’s syntax with two new constructs:\n\n| Expressions | \\( e ::= v \\mid e_1 \\cdot e_2 \\mid \\text{let } x \\text{ be } e_1 \\text{ in } e_2 \\mid \\text{abort } e \\) |\n| Values | \\( v ::= e \\mid x \\mid \\lambda x . e \\mid \\text{callcc} \\) |\n\nAn abort-expression evaluates its subexpression to a value, and returns this value as the result of the program. When the callcc operator (call-with-current-continuation) is applied to a function \\( f \\), it captures a representation of the current continuation (or program control stack), encapsulates this continuation in an abstraction, and applies \\( f \\) to this abstraction. If this abstraction is later applied to a value, control transfers to the captured continuation.\n\n### 6.1 Semantics\n\nWhile defining calculus reductions for first-class continuations is possible [13, 14], the resulting calculus is inappropriate for our problem. Since we are only interested in evaluation, we take a simpler approach [11]. We give top-level evaluation rules, program reductions, for the control operators by extending the stepping relation (\\( \\Downarrow \\)) directly:\n\n\\[\n\\begin{align*}\n(\\delta, \\beta, \\text{let, } Y) & \\quad E[e] \\Downarrow E[e'] \\iff e \\Downarrow \\gamma e' \\\\\n(\\text{callcc}) & \\quad E[\\text{callcc } v] \\Downarrow E[v (\\lambda x . \\text{abort } E[x])] \\\\\n(\\text{abort}) & \\quad E[\\text{abort } e] \\Downarrow e\n\\end{align*}\n\\]\n\nwhere\n\\[\nE ::= [] \\mid E \\cdot e \\mid v . E \\mid \\text{let } x \\text{ be } E \\text{ in } e.\n\\]\n\nIn this style of semantics, the evaluation context \\( E \\) represents the current continuation. An abort reduction simply discards the current continuation, continuing evaluation with its subexpression. The callcc reduction captures the current continuation, encapsulates it in a function, and applies callcc’s argument to this function. The continuations created by callcc are abortive: when invoked, they discard the continuation surrounding their application.\nlet product be \\( \\lambda x. \\) callcc\n\\[\n(\\lambda k.\\ \\text{letrec}\\ p = \\lambda z.\\ \\text{if}\\ n\\text{il?}\\ z\\ \\text{then}\\ 1\nelse\\ \\text{if}\\ 0\\ (\\text{car}\\ z)\\ \\text{then}\\ k\\ 0\nelse\\ *\\ (\\text{car}\\ z)\\ (p\\ (\\text{cdr}\\ z))\n\\]\nin\\ p\\ x)\nin\\ product\\ (\\text{cons} 2\\ (\\text{cons} 3\\ (\\text{cons} 0\\ (\\text{cons} 5\\ \\text{nil}))))\n\nFigure 6: A program illustrating a simple use of callcc\n\n(via an abort reduction), installing instead the captured continuation. Answers are simply\nvalues, and eval is defined as for Functional ML.\n\nFigure 6 illustrates a simple use of callcc. This program computes the product of a\nlist of numbers, performing no multiplications if the answer is zero. The constants nil,\ncons, nil?, car, and cdr are the usual constants and operations for lists. The expressions\nif..then..else.. and letrec..be..in.. are syntactic sugar for appropriate constant applica-\ntions. This program computes the product of a list of numbers, performing no multiplications\nif the answer is zero. The program escapes from pending multiplications by jumping\nout of the recursion to the continuation of the application of product.\n\n6.2 Typing\nThe obvious approach to typing callcc leads to the following rule:\n\n\\[ \\text{(naive-callcc)} \\quad \\Gamma \\vdash \\text{callcc} : ((\\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1) \\rightarrow \\tau_1 \\]\n\nAs indicated by the callcc reduction, callcc takes a function whose argument is a procedural\nabstraction of the evaluation context, the continuation. If the evaluation context expects\na value of type \\( \\tau_1 \\), then the continuation has type \\( \\tau_1 \\rightarrow \\tau_2 \\) for any type \\( \\tau_2 \\). If callcc’s\nargument ignores this continuation, it must produce a value of type \\( \\tau_1 \\), which implies that\ncallcc’s argument must have type \\( (\\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1 \\). The result type of the continuation, \\( \\tau_2 \\),\nis arbitrary, because the application of \\( k \\) built into the continuation ensures that it never\nreturns.\n\nHowever, this obvious typing is unsound, as illustrated by the following example:\n\\[ \\text{let } x = \\text{callcc} (\\lambda k.\\ \\text{pair} (\\lambda x. x) (\\lambda f.\\ k (\\text{pair} f (\\lambda d.5))))\n\\]\nin \\( (\\lambda z.\\ \\text{snd} x (\\lambda x. z \\cdot x + 1)) (\\text{fst} x \\text{ true}) \\)\n\nThe callcc application returns a pair of type \\( (\\alpha \\rightarrow \\alpha) \\times ((\\alpha \\rightarrow \\alpha) \\rightarrow \\text{int}) \\), consisting of\nthe identity function and a function that applies a continuation. Since \\( \\alpha \\) is not free in\nthe type environment, it is closed over, and \\( x \\) has type scheme \\( \\forall \\alpha. (\\alpha \\rightarrow \\alpha) \\times ((\\alpha \\rightarrow \\alpha) \\rightarrow \\text{int}) \\)\nin the body of the let-expression. In evaluating the body, \\( \\text{fst} x \\) is the polymorphic identity\nfunction, so it may validly be applied to \\( \\text{true} \\). Then the second function of the pair is applied\n\n\\[^{10}\\text{A variation of this example was discovered by Robert Harper and Mark Lillibridge [sml electronic mailing list, July 8, 1991]. Despite widespread use of a naively typed callcc extension in Standard ML of New Jersey, it took two years until this problem was discovered.}\\]\nto \\((\\lambda x . x \\ 1)\\), and the continuation so invoked rebinds \\(x\\) to the pair consisting of \\((\\lambda x . x \\ 1)\\) and \\((\\lambda d.5)\\). The second evaluation of \\(\\texttt{fst } x \\ \\texttt{true}\\) results in an attempt to add \\(1\\) to \\(\\texttt{true}\\).\n\nAs with references and exceptions, a correct typing for continuations builds upon the classification of types as imperative or applicative, and requires the \\texttt{let} typing rules of Figure 3. The correct typing rules are:\n\n\\[(\\text{callcc}) \\quad \\Gamma \\triangleright \\text{callcc} : ((\\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1) \\rightarrow \\tau_1 \\quad \\text{if} \\quad \\tau_1 \\text{ is imperative.}\\]\n\n\\[(\\text{abort}) \\quad \\Gamma \\triangleright e : \\tau_1 \\quad \\frac{}{\\Gamma \\triangleright \\text{abort } e : \\tau_2}\\]\n\nAn \\texttt{abort}-expression may have any type, regardless of the type of its subexpression, because when evaluated it never returns.\n\n### 6.3 Weak Type Soundness\n\nBecause \\texttt{abort}-expressions can return a value of any type, proving type soundness for the continuation extension is not as simple as for the previous extensions. For example, if \\(e\\) is an expression of type \\texttt{bool}, the program:\n\n\\[\n\\text{if } e \\text{ then } 1 \\text{ else } (\\text{abort}\\ true)\n\\]\n\nis typable according to the above typing rules, but returns either \\texttt{int} or \\texttt{bool} according to whether \\(e\\) is true or false. Thus subject reduction in the usual sense does not hold; however, a weaker lemma does hold, stating that \\textit{typability} is preserved.\n\n**Main Lemma 6.1 (Typability Preservation)** If \\(\\triangleright e_1 : \\tau\\) and \\(e_1 \\leftarrow e_2\\) then \\(\\triangleright e_2 : \\tau'\\).\n\n**Proof.** We need only consider the additional cases for the \\texttt{callcc} and \\texttt{abort} reductions. The others are simply adapted from Lemma 4.3 (Subject Reduction for Functional ML).\n\n**Case** \\(E[\\text{abort } e] \\leftarrow e\\). Then \\(\\Gamma \\triangleright e : \\tau'\\) for some \\(\\tau'\\). But since \\(E[\\text{abort } e]\\) is closed and \\(E\\) does not bind variables, \\(e\\) is closed, hence \\(\\triangleright e : \\tau'\\).\n\n**Case** \\(E[\\text{callcc } v] \\leftarrow E[v (\\lambda x . \\text{abort } E[x])]\\). From \\(\\triangleright E[\\text{callcc } v] : \\tau\\) we have \\(\\triangleright \\text{callcc } v : \\tau_1\\), and by \\texttt{callcc} and \\texttt{app}\n\n\\[\n\\triangleright v : (\\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1\n\\]\n\nwhere \\(\\tau_1\\) is imperative.\n\nSince \\(E\\) is closed, \\(x\\) does not appear free in \\(E\\), and we claim that \\([x \\mapsto \\tau_1] \\triangleright E[x] : \\tau\\). The proof of this claim proceeds by induction on the structure of \\(E\\).\n\n**Case** \\(E = [\\].\\) Then \\(\\tau = \\tau_1\\), and \\([x \\mapsto \\tau_1] \\triangleright x : \\tau\\) by \\texttt{var}.\n\n**Case** \\(E = (E' \\ e')\\). Then \\(\\triangleright (E'[\\text{callcc } v] \\ e') : \\tau\\), and by \\texttt{app}\n\n\\[\n\\triangleright E'[\\text{callcc } v] : \\tau_3 \\rightarrow \\tau \\quad (30) \\\\\n\\triangleright e' : \\tau_3 \\quad (31)\n\\]\n\nfor some \\(\\tau_3\\). Then \\([x \\mapsto \\tau_1] \\triangleright E'[x] : \\tau_3 \\rightarrow \\tau\\) by ind. hyp. with (30). Also \\([x \\mapsto \\tau_1] \\triangleright e' : \\tau_3\\) by Lemma 4.1 with (31) since \\(x \\notin FV(E)\\). Hence \\([x \\mapsto \\tau_1] \\triangleright E'[x] \\ e' : \\tau\\) by \\texttt{app}.\nCase $E = (v \\ E')$. Similar to the previous case.\n\nCase $E = \\text{let } x' \\text{ be } E' \\text{ in } e'$. Then $E'[\\text{callcc } v] \\vdash e' : \\tau$. Since (\\text{callcc } v) is expansive, $E'[\\text{callcc } v]$ is expansive. Thus by $\\text{let}_e$\n\n\\begin{align}\n(32) & \\quad \\triangleright E'[\\text{callcc } v] : \\tau_3 \\\\\n(33) & \\quad \\text{and } [x' \\mapsto \\text{AppClose}(\\tau_3, \\emptyset)] \\triangleright e' : \\tau\n\\end{align}\n\nfor some $\\tau_3$. Then\n\n\\begin{align}\n(34) & \\quad [x \\mapsto \\tau_1] \\triangleright E'[x] : \\tau_3 \\quad \\text{by ind. hyp. with (32),}\n\\end{align}\n\nand\n\n\\begin{align}\n[x' \\mapsto \\text{AppClose}(\\tau_3, \\emptyset)][x \\mapsto \\tau_1] \\triangleright e' : \\tau & \\quad \\text{by Lemma 4.1 with (33)} \\\\\n\\text{i.e. } [x \\mapsto \\tau_1][x' \\mapsto \\text{AppClose}(\\tau_3, \\emptyset)] \\triangleright e' : \\tau.\n\\end{align}\n\nBy the critical restriction that $\\tau_1$ is imperative,\n\n\\[ \\text{AppClose}(\\tau_3, \\emptyset) = \\text{AppClose}(\\tau_3, [x \\mapsto \\tau_1]), \\]\n\nhence\n\n\\begin{align}\n[x \\mapsto \\tau_1][x' \\mapsto \\text{AppClose}(\\tau_3, [x \\mapsto \\tau_1])] \\triangleright e' : \\tau \\\\\n[x \\mapsto \\tau_1] \\triangleright \\text{let } x' \\text{ be } E'[x] \\text{ in } e' : \\tau \\quad \\text{by } \\text{let}_e \\text{ with (34).}\n\\end{align}\n\nThis completes the proof of the claim. Hence\n\n\\begin{align}\n[x \\mapsto \\tau_1] \\triangleright \\text{abort } E[x] : \\tau_2 & \\quad \\text{by } \\text{abort}, \\\\\n\\triangleright (\\lambda x. \\text{abort } E[x]) : \\tau_1 \\rightarrow \\tau_2 & \\quad \\text{by } \\text{abs,} \\\\\n\\triangleright v (\\lambda x. \\text{abort } E[x]) : \\tau_1 & \\quad \\text{by } \\text{app} \\text{ with (29)} \\\\\n\\triangleright E[v (\\lambda x. \\text{abort } E[x])] : \\tau & \\quad \\text{by Replacement}^+.\\]\n\nThe faulty expressions for Control ML are the same as those of Functional ML, extended to the new syntax.\n\n**Definition 6.2 (Faulty Expressions)** The faulty expressions of Control ML are the expressions containing a subexpression ($e \\ v$) where $\\delta(e, v)$ is undefined.\n\nAs with Functional ML, the faulty expressions are untypable and Uniform Evaluation holds. However, since we only have typability preservation, we obtain a weaker version of syntactic soundness that does not indicate the type of answers.\n\n**Theorem 6.3 (Weak Syntactic Soundness)** If $\\triangleright e : \\tau$ then either $e \\uparrow$ or $e \\leftarrow v$.\n\n**Proof.** By Uniform Evaluation, either $e \\downarrow e'$ and $e'$ is faulty, or $e \\uparrow$, or $e \\leftarrow v$. Since $\\triangleright e : \\tau$, Typability Preservation implies $\\triangleright v : \\tau'$ and $\\triangleright e' : \\tau'$. Suppose $e \\downarrow e'$ and $e'$ is faulty. Since faulty expressions are untypable, $\\triangleright e' : \\tau'$ is a contradiction, therefore this case cannot occur. Hence either $e \\uparrow$ or $e \\leftarrow v$.\n\nThis weaker theorem establishes weak soundness, but does not imply strong soundness. In fact, if the use of abort is unrestricted, it is not possible to predict the type of an answer, as the example at the beginning of this section illustrates.\n6.4 Strong Type Soundness\n\nExamining the proof of Typability Preservation reveals that every reduction with the exception of abort preserves type. In particular, the callcc reduction preserves type, which suggests that callcc by itself is strongly sound. To obtain a proof of strong soundness for callcc, we must eliminate abort from the surface language available to programmers, but retain it in the underlying language of evaluation for callcc reductions. Because the abort expressions introduced by callcc applications have a restricted shape, they never return values of other than the top-level type of the program, and do not compromise strong soundness.\n\nTo establish a subject reduction lemma, we define an augmented type system that infers both the ordinary type of an expression and a set of abort types. The abort types of an expression e are the types of the immediate subexpressions of abort-expressions in e. The augmented system does not permit abort types to be generalized, thereby ensuring that each syntactic occurrence of abort can produce only one type of answer. This restriction eliminates expressions such as the following:\n\n\\[\n\\text{let } a \\text{ be } \\lambda x. \\text{abort } x \\\\\n\\text{in if } e \\text{ then } a \\ 1 \\\\\n\\text{else a true}\n\\]\n\nHence if a well-typed program aborts, the answer produced is one of the program's abort types. Type judgments for this augmented system have the form \\( \\Gamma \\vdash a e : \\tau, T \\), meaning that in type environment \\( \\Gamma \\), expression e has ordinary type \\( \\tau \\) and abort types \\( T \\), where \\( T \\) is a set of types. Figure 7 presents the typing rules of the augmented system.\n\nThe augmented type system corresponds closely to our original type system for Control ML. The rule for typing abort-expressions is the only rule that connects the ordinary type and the abort types of an expression. In each axiom (\\texttt{var, const, Y, callcc}) the abort set is completely unconstrained; the inference rules simply propagate the abort set. The let-expression rules do not generalize type variables in the set of abort types, hence the augmented system does not permit polymorphic uses of abort, and accepts a subset of the expressions accepted by the ordinary system. A Correspondence Lemma establishes this connection between the ordinary system \\((\\vdash)\\) and the augmented system \\((\\vdash a)\\).\n\n**Lemma 6.4 (Correspondence)**\n\n(i) If \\( \\Gamma \\vdash e : \\tau \\) and e contains no abort-expressions then \\( \\Gamma \\vdash a e : \\tau, T \\) for any \\( T \\);\n\n(ii) If \\( \\Gamma \\vdash a e : \\tau, T \\) then \\( \\Gamma \\vdash e : \\tau \\).\n\n**Proof.** The proof of each direction shows how to construct a deduction for the consequent from a deduction of the antecedent. Both proofs are straightforward.\n\nSubject Reduction for the augmented system establishes that reduction preserves the set of abort types. As the callcc reduction introduces an abort-expression with the top-level type of the program, the set of abort types preserved by Subject reduction includes the top-level type.\n(var) \\( \\Gamma \\vdash x : \\tau, T \\) if \\( \\Gamma(x) \\vdash \\tau \\)\n\n(const) \\( \\Gamma \\vdash c : \\tau, T \\) if \\( \\text{TypeOf}(c) \\vdash \\tau \\)\n\n(Y) \\( \\Gamma \\vdash Y : ((\\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1 \\rightarrow \\tau_2, T \\)\n\n(abs) \\( \\Gamma \\vdash e : \\tau, T \\)\n\n(app) \\( \\Gamma \\vdash e_1 : \\tau_1 \\rightarrow \\tau_2, T \\quad \\Gamma \\vdash e_2 : \\tau_1, T \\)\n\n(let) \\( \\Gamma \\vdash e_1 : \\tau_1, T \\quad \\Gamma \\vdash \\text{Close}(\\tau_1, \\Gamma, T)] \\vdash e : \\tau_2, T \\quad e_1 \\notin \\text{Values} \\)\n\n(let) \\( \\Gamma \\vdash e_1 : \\tau_1, T \\quad \\Gamma \\vdash \\text{let } x \\text{ be } v \\text{ in } e : \\tau_2, T \\)\n\n(letcc) \\( \\Gamma \\vdash \\text{callcc} : ((\\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1) \\rightarrow \\tau_1, T \\) if \\( \\tau_1 \\) is imperative\n\n(abort) \\( \\Gamma \\vdash e : \\tau, T \\quad \\tau_1 \\in T \\)\n\n\\( \\text{Close}(\\tau, \\Gamma, T) = \\forall \\alpha_1, \\ldots, \\alpha_n, \\tau \\)\n\nwhere \\( \\{\\alpha_1, \\ldots, \\alpha_n\\} = \\text{FTV}(\\tau) \\setminus (\\text{FTV}(\\Gamma) \\cup \\text{FTV}(T)) \\)\n\n\\( \\text{AppClose}(\\tau, \\Gamma, T) = \\forall \\alpha_1, \\ldots, \\alpha_n, \\tau \\)\n\nwhere \\( \\{\\alpha_1, \\ldots, \\alpha_n\\} = (\\text{FTV}(\\tau) \\setminus (\\text{FTV}(\\Gamma) \\cup \\text{FTV}(T))) \\setminus \\text{AppType Var} \\)\n\nFigure 7: The augmented type system for Control ML\n\nMain Lemma 6.5 (Subject Reduction) If \\( \\Gamma \\vdash e_1 : \\tau, T \\) and \\( \\tau \\in T \\) and \\( e_1 \\red e_2 \\) then \\( \\Gamma \\vdash e_2 : \\tau', T \\) and \\( \\tau' \\in T \\).\n\nProof. The proof proceeds by case analysis according to the reduction \\( e_1 \\red e_2 \\). Each case is easily adapted from the corresponding case in the proof of Typability Preservation with straightforward adaptations of the necessary lemmas.\n\nWith Uniform Evaluation and the fact that faulty expressions are untypable (in the ordinary system), we obtain a syntactic soundness theorem for abort-free expressions.\n\nTheorem 6.6 (Syntactic Soundness) If \\( \\Gamma \\vdash e : \\tau \\) and \\( e \\) contains no abort-expressions then either \\( e \\upharpoonright \\) or \\( e \\red v \\) and \\( v : \\tau \\).\n\nProof. By Uniform Evaluation, either \\( e \\red e' \\) and \\( e' \\) is faulty, or \\( e \\upharpoonright \\), or \\( e \\red v \\). Since \\( \\Gamma \\vdash e : \\tau \\) and \\( e \\) contains no abort-expressions, by Correspondence \\( \\Gamma \\vdash e : \\tau, \\{\\tau\\} \\). Subject Reduction then implies \\( \\Gamma \\vdash e' : \\tau, \\{\\tau\\} \\). Similarly \\( \\Gamma \\vdash v : \\tau, \\{\\tau\\} \\), and by Correspondence \\( \\Gamma \\vdash e' : \\tau \\) and \\( \\Gamma \\vdash v : \\tau \\). Suppose \\( e \\red e' \\) and \\( e' \\) is faulty. Since faulty expressions are untypable, \\( \\Gamma \\vdash e : \\tau \\) is a contradiction, therefore this case cannot occur. Hence either \\( e \\upharpoonright \\) or \\( e \\red v \\) and \\( v : \\tau \\).\n7 Discussion\n\nSubject reduction is the key lemma in our approach to proving type soundness. In order to demonstrate subject reduction, it must be possible to assign a type to each intermediate evaluation state of a program. This is most easily accomplished by specifying evaluation as rewriting. Rewriting may be specified as local reductions, as our calculus for Core ML, or as program (or top-level) rewriting, as in Control ML.\n\nThrough most of this paper, we present the semantics of the various languages with calculi that permit local reductions. It is also possible to use our proof technique with a semantics that specifies only program reductions (\\(\\longrightarrow\\)), as in Control ML. Such a semantics for Reference ML is slightly simpler, as the \\(\\text{ref} \\), \\(\\mu_{\\text{ref}}\\), and \\(\\mu_{\\text{top}}\\) reductions coalesce into one program reduction, but the structure of the proof is essentially the same. Our work on an alternative type system for references uses this approach [38]. We chose to use calculi in this paper as the resulting proofs are more regular in structure.\n\nIn specifying the semantics of references as a calculus, we use an additional expression form, the \\(\\rho\\)-expression, that is not present in ML. As noted earlier, \\(\\rho\\)-expressions may be regarded as abbreviations, both from a semantic perspective and a typing perspective (the typing rule for \\(\\rho\\)-expressions can be derived from the abbreviation). In principle, it is possible to eliminate \\(\\rho\\)-expressions from the syntax, however the specification of redexes in the reduction rules becomes complicated. Alternatively, \\(\\rho\\)-expressions may be considered as belonging to the state space of evaluation, and not to the language of programs that may be written by a programmer. In a presentation of the typing rules for consumption by programmers, the typing rule for \\(\\rho\\)-expressions may be deleted. However, unlike \\(\\rho\\)-expressions, the \\texttt{abort}\\-expressions of the continuation fragment cannot be considered as abbreviations [10]. To obtain a strong soundness theorem, \\texttt{abort}\\-expressions must be considered as belonging only to the evaluation space, and not to the syntax of programs. The exception fragment has no such additional expressions.\n\nOther operational or denotational techniques for specifying semantics introduce additional semantic objects, such as closures and stores, rather than additional expression forms. Since the type system does not apply to such objects, stating and proving strong type soundness requires introducing a semantic relation \\((\\models)\\) between semantic objects and types (see Section 2). We believe that introducing additional expression forms and typing rules is the simpler choice, and offer the simpler proofs produced by our method as evidence.\n\nWhile in this paper we have concentrated on the essential aspects of ML, there are other features of static type systems that we believe our technique can address. \\texttt{STANDARD ML} contains a datatype specification mechanism that allows the definition of new types and associated data constructors. This mechanism is indispensable when writing non-trivial ML programs. Subtyping, inheritance, and type inference for records are a strong focus of recent research efforts to explain object-oriented languages, as many popular object-oriented languages have unsound static type systems. Reppy [29] has successfully addressed concurrency with our technique; it should also be possible to treat nondeterminism and distributed computing. We have used our technique to prove an alternative type system for references sound [38]. Finally, it may be possible to adapt our technique to demonstrate the consistency of module systems like that of \\texttt{STANDARD ML}.\nAcknowledgements\n\nWe would like to thank Bob Harper for pointing out that type preservation is known as subject reduction in combinatory logic, and Hans Boehm and the anonymous referees for comments on earlier drafts of this paper.\nAppendix: The Core of Standard ML\n\nSyntax\n\n\\[ e ::= v \\mid e_1 \\; e_2 \\mid \\text{let } x \\text{ be } e_1 \\text{ in } e_2 \\mid \\rho \\theta . e \\mid \\text{exception } \\chi \\text{ in } e \\]\n\\[ v ::= e \\mid x \\mid Y \\mid \\lambda x . e \\mid \\text{ref} \\mid ! := \\text{raise } e \\mid e \\text{ handle } e \\]\n\\[ \\theta ::= \\{ \\langle x, v \\rangle \\}^* \\]\n\\[ \\chi ::= x^* \\]\n\\[ a ::= \\{ \\text{exception } \\chi \\text{ in } \\} \\{ \\rho \\theta . \\} v \\mid \\{ \\text{exception } \\chi x \\text{ in } \\} \\{ \\rho \\theta . \\} \\text{raise } x \\; v \\]\n\nSemantics\n\n\\[ \\text{eval}(e) = a \\text{ iff } e \\stackrel{a}{\\rightarrow} a \\]\n\\[ E[e] \\longrightarrow E[e'] \\text{ iff } e \\rightarrow e' \\]\n\\[ E ::= [] \\mid E \\; e \\mid v \\; E \\mid \\text{let } x \\text{ be } E \\text{ in } e \\mid E \\text{ handle } v_1 \\; v_2 \\mid \\rho \\theta . E \\mid \\text{exception } \\chi \\text{ in } E \\]\n\nFunctional ML\n\n\\[ (\\delta) \\quad \\quad \\quad c \\; v \\longrightarrow \\delta(c, v) \\text{ if } \\delta(c, v) \\text{ is defined} \\]\n\\[ (\\beta_v) \\quad \\quad \\quad (\\lambda x . e) \\; v \\longrightarrow e[x \\rightarrow v] \\]\n\\[ (\\text{let}) \\quad \\quad \\quad \\text{let } x \\text{ be } v \\text{ in } e \\longrightarrow e[x \\rightarrow v] \\]\n\\[ (Y) \\quad \\quad \\quad Y \\; v \\longrightarrow v \\; (\\lambda x . (Y \\; v) \\; x) \\]\n\nReferences\n\n\\[ (\\text{ref}) \\quad \\quad \\quad \\text{ref} \\; v \\longrightarrow \\rho(x, v).x \\]\n\\[ (\\text{deref}) \\quad \\quad \\quad \\rho\\theta(x, v).R! x \\longrightarrow \\rho\\theta(x, v).R[v] \\]\n\\[ (\\text{assign}) \\quad \\quad \\quad \\rho\\theta(x, v_1).R[\\![:= x \\; v_2]\\!] \\longrightarrow \\rho\\theta(x, v_2).R[v_2] \\]\n\\[ (\\rho_{\\text{merge}}) \\quad \\quad \\quad \\rho\\theta_1, \\rho\\theta_2. e \\longrightarrow \\rho\\theta_1 \\theta_2. e \\]\n\\[ (\\rho_{\\text{join}}) \\quad \\quad \\quad R[\\rho \\theta . e] \\longrightarrow \\rho \\theta . R[e] \\text{ if } R \\neq [] \\]\n\\[ R ::= [] \\mid R \\; e \\mid v \\; R \\mid \\text{let } x \\text{ be } R \\text{ in } e \\mid R \\text{ handle } v_1 \\; v_2 \\]\n\nExceptions\n\n\\[ (\\text{raise}) \\quad \\quad \\quad U[\\text{raise } x \\; v] \\longrightarrow \\text{raise } x \\; v \\text{ if } U \\neq [] \\]\n\\[ (\\text{handle}) \\quad \\quad \\quad (\\text{raise } x \\; v_1) \\text{ handle } x \\; v_2 \\longrightarrow v_2 \\; v_1 \\]\n\\[ (\\text{reraise}) \\quad \\quad \\quad \\text{exception } \\chi x_1 x_2 \\text{ in } X[\\text{raise } x_1 \\; v_1] \\text{ handle } x_2 \\; v_2 \\longrightarrow \\text{exception } \\chi x_1 x_2 \\text{ in } x_1 \\neq x_2 \\]\n\\[ (\\text{unhandle}) \\quad \\quad \\quad v_1 \\text{ handle } x \\; v_2 \\longrightarrow v_1 \\]\n\\[ (\\text{exnmerge}) \\quad \\quad \\quad \\text{exception } \\chi_1 \\text{ in exception } \\chi_2 \\text{ in } e \\longrightarrow \\text{exception } \\chi_1 \\chi_2 \\text{ in } e \\]\n\\[ (\\text{exnjoin}) \\quad \\quad \\quad X[\\text{exception } \\chi \\text{ in } e] \\longrightarrow \\text{exception } \\chi \\text{ in } X[e] \\text{ if } X \\neq [] \\]\n\\[ U ::= [] \\mid U \\; e \\mid v \\; U \\mid \\text{let } x \\text{ be } U \\text{ in } e \\]\n\\[ X ::= [] \\mid X \\; e \\mid v \\; X \\mid \\text{let } x \\text{ be } X \\text{ in } e \\mid X \\text{ handle } v_1 \\; v_2 \\mid \\rho \\theta . X \\]\nTyping\n\nFunctional ML\n\n**(var)**\n\n\\( \\Gamma \\triangleright x : \\tau \\) if \\( \\Gamma(x) \\triangleright \\tau \\)\n\n**(const)**\n\n\\( \\Gamma \\triangleright c : \\tau \\) if \\( \\text{TypeOf}(c) \\triangleright \\tau \\)\n\n**(Y)**\n\n\\( \\Gamma \\triangleright \\chi : (\\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_1 \\rightarrow \\tau_2 \\)\n\n**(abs)**\n\n\\[\n\\Gamma \\triangleright e : \\chi\n\\]\n\n\\[\\Gamma \\triangleright \\lambda x. e : \\tau_1 \\rightarrow \\tau_2\\]\n\n**(app)**\n\n\\( \\Gamma \\triangleright e_1 : \\tau_1 \\rightarrow \\tau_2 \\quad \\Gamma \\triangleright e_2 : \\tau_1 \\)\n\n\\[\\Gamma \\triangleright e_1 e_2 : \\tau_2\\]\n\n**(let_v)**\n\n\\( \\Gamma \\triangleright v : \\tau_1 \\quad \\Gamma[\\chi \\mapsto \\text{Close}(\\tau_1, \\Gamma)] \\triangleright e : \\tau_2 \\)\n\n\\[\\Gamma \\triangleright \\text{let } x \\text{ be } v \\text{ in } e : \\tau_2\\]\n\n**(let_c)**\n\n\\( \\Gamma \\triangleright e_1 : \\tau_1 \\quad \\Gamma[\\chi \\mapsto \\text{AppClose}(\\tau_1, \\Gamma)] \\triangleright e_2 : \\tau_2 \\quad e_1 \\notin \\text{Values} \\)\n\n\\[\\Gamma \\triangleright \\text{let } x \\text{ be } e_1 \\text{ in } e_2 : \\tau_2\\]\n\n\\( \\text{Close}(\\tau, \\Gamma) = \\forall \\alpha_1 \\ldots \\alpha_n . \\tau \\) where \\( \\{\\alpha_1, \\ldots, \\alpha_n\\} = \\text{FTV}(\\tau) \\setminus \\text{FTV}(\\Gamma) \\)\n\n\\( \\text{AppClose}(\\tau, \\Gamma) = \\forall \\alpha_1 \\ldots \\alpha_n . \\tau \\) where \\( \\{\\alpha_1, \\ldots, \\alpha_n\\} = (\\text{FTV}(\\tau) \\setminus \\text{FTV}(\\Gamma)) \\cap \\text{AppTypeVar} \\)\n\nReferences\n\n**(ref)**\n\n\\( \\Gamma \\triangleright \\text{ref} : \\tau \\rightarrow \\tau \\text{ ref} \\) if \\( \\tau \\) is imperative\n\n**(deref)**\n\n\\( \\Gamma \\triangleright \\text{!} : \\tau \\text{ ref} \\rightarrow \\tau \\)\n\n**(assign)**\n\n\\( \\Gamma \\triangleright \\text{:=} : (\\tau \\text{ ref} \\rightarrow \\tau \\rightarrow \\tau) \\)\n\n\\[\\Gamma[\\chi_1 \\mapsto \\tau_1 \\text{ ref}] \\ldots [\\chi_n \\mapsto \\tau_n \\text{ ref}] \\triangleright e : \\tau \\]\n\n**(rho)**\n\n\\( \\Gamma \\triangleright \\rho(\\chi_1, v_1) \\ldots (\\chi_n, v_n). e : \\tau \\)\n\nExceptions\n\n**(raise)**\n\n\\( \\Gamma \\triangleright \\text{raise} : \\tau_1 \\text{ exn} \\rightarrow \\tau_1 \\rightarrow \\tau_2 \\)\n\n**(handle)**\n\n\\( \\Gamma \\triangleright e \\text{ handle} : \\tau_1 \\text{ exn} \\rightarrow (\\tau_1 \\rightarrow \\tau_2) \\rightarrow \\tau_2 \\)\n\n**(exn)**\n\n\\( \\Gamma[\\chi_1 \\mapsto \\tau_1 \\text{ exn}] \\ldots [\\chi_n \\mapsto \\tau_n \\text{ exn}] \\triangleright e : \\tau \\quad \\text{tau is imperative} \\quad 1 \\leq i \\leq n \\)\n\n\\[\\Gamma \\triangleright \\text{exception } x_1 \\ldots x_n \\text{ in } e : \\tau\\]\nReferences\n\n\nSyntactic Type Soundness\n\n\n[34] **Standard ML of New Jersey** release notes (version 0.75). AT&T Bell Laboratories, November 1991.\n\n\n[37] **Tofte, M.** Type inference for polymorphic references. *Information and Computation* 89, 1 (November 1990), 1–34."}}},{"rowIdx":278,"cells":{"id":{"kind":"string","value":"91f4473b27e2870b49b768117a0c7555c7e3a503"},"text":{"kind":"string","value":"## Contents\n\n1 Introduction ................................. 1\n 1.1 Related Documentation ................................. 1\n 1.2 Prerequisites ................................. 2\n 1.2.1 Red Hat Subscription ................................. 2\n 1.2.2 Access to Repositories ................................. 2\n 1.2.2.1 NVIDIA Repositories ................................. 2\n 1.2.2.2 Red Hat Repositories ................................. 2\n 1.2.3 Network File System ................................. 2\n 1.2.4 BMC Password ................................. 3\n\n2 Release Notes ................................. 5\n 2.1 Current Contents of the Repositories ................................. 5\n 2.2 Release Information ................................. 7\n 2.2.1 EL9-24.06 Release ................................. 8\n 2.2.2 EL9-23.12 Release ................................. 10\n 2.2.3 EL9-23.08 Release ................................. 12\n 2.2.4 EL9-23.01 Release ................................. 14\n\n3 Installing Red Hat Enterprise Linux ................................. 17\n 3.1 Obtaining Red Hat Enterprise Linux ................................. 17\n 3.2 Booting the Red Hat Enterprise Linux ISO Locally ................................. 18\n 3.3 Booting the Red Hat Enterprise Linux ISO Remotely ................................. 18\n 3.3.1 Booting the ISO Image on the DGX-2, DGX A100, DGX A800, or DGX H100 Remotely ................................. 18\n 3.3.2 Booting the ISO Image on the DGX-1 Remotely ................................. 22\n 3.4 Installing and Configuring Red Hat Enterprise Linux ................................. 25\n 3.5 Partitioning ................................. 30\n 3.5.1 Disk Partitioning for DGX-1, DGX Station, and DGX Station A100 ................................. 30\n 3.5.2 Disk Partitioning with Encryption for DGX-1, DGX Station, and DGX Station A100 Remotely ................................. 36\n 3.5.3 Disk Partitioning for DGX-2, DGX A100, DGX A800, and DGX H100 ................................. 46\n 3.5.4 Disk Partitioning with Encryption for DGX-2, DGX A100, DGX A800, and DGX H100 ................................. 53\n\n4 Installing the DGX Software ................................. 63\n 4.1 Configuring a System Proxy ................................. 63\n 4.2 Enabling the DGX Software Repository ................................. 63\n 4.3 Installing Required Components ................................. 64\n 4.4 Configuring Data Drives ................................. 65\n 4.5 Installing the GPU Driver ................................. 66\n 4.5.1 Installing and Running Docker CE ................................. 68\n 4.5.2 Installing and Running Podman ................................. 69\n 4.6 Installing Optional Components ................................. 70\n 4.7 Installing NVIDIA GPUDirect Storage ................................. 71\n 4.7.1 Prerequisites ................................. 71\n 4.7.2 Procedure ................................. 71\nChapter 1. Introduction\n\nThis document explains the installation and configuration of the NVIDIA DGX Software Stack on DGX systems installed with Red Hat Enterprise Linux.\n\nNVIDIA provides the NVIDIA DGX Software Stack targeted for installation on DGX systems that have been user-installed with Red Hat Enterprise Linux. The software stack provides the same features and functionality that are provided by the original DGX OS built on the Ubuntu.\n\n**Note:** NVIDIA acknowledges the wide use of Rocky Linux and understands that it is a community-developed derivative of the NVIDIA supported Red Hat Enterprise Linux. Support for Rocky Linux is available directly from the Rocky Linux community. NVIDIA ensures that NVIDIA provided software runs on tested Rocky Linux versions and will try to identify and correct issues related to NVIDIA provided software.\n\nWhile it might be possible to use other derived Linux distributions, not all have been tested and qualified by NVIDIA. Refer to the *Release Notes* for the list of tested and qualified software and Linux distributions.\n\n1.1. Related Documentation\n\n- NVIDIA DGX-1 User Guide\n- NVIDIA DGX-2 User Guide\n- NVIDIA DGX Station User Guide\n- NVIDIA DGX A100 User Guide\n- NVIDIA DGX Station A100 User Guide\n- NVIDIA DGX H100 User Guide\n1.2. Prerequisites\n\nThe following are required (or recommended wherever indicated).\n\n1.2.1. Red Hat Subscription\n\nYou need a Red Hat subscription if you plan to install and use Red Hat Enterprise Linux on the DGX. A subscription also lets you obtain update packages and additional packages for Red Hat Enterprise Linux. You can either purchase a subscription or obtain a free evaluation subscription from the Red Hat Software & Download Center.\n\n1.2.2. Access to Repositories\n\nThe repositories can be accessed from the internet.\n\nIf you are using a proxy server, then follow the instructions in the section Configuring a System Proxy to make sure the system can access the necessary URIs.\n\n1.2.2.1 NVIDIA Repositories\n\nAfter installing Red Hat Enterprise Linux on the DGX system, you must enable the NVIDIA DGX software repository (https://repo.download.nvidia.com). The repository includes the NVIDIA drivers and software for supporting DGX systems.\n\nSee the section Enabling the DGX Software Repository for instructions on how to enable the repository.\n\n1.2.2.2 Red Hat Repositories\n\nInstallation of the DGX Software over Red Hat Enterprise Linux 9 requires access to several additional repositories.\n\n- Red Hat Enterprise BaseOS Repository: `rhe1-9-for-x86_64-baseos-rpms`\n- Red Hat Enterprise AppStream Repository: `rhe1-9-for-x86_64-appstream-rpms`\n- Red Hat Enterprise CodeReady Linux Builder Repository: `codeready-builder-for-rhel-9-x86_64-debug-rpms`\n\n1.2.3. Network File System\n\nOn DGX servers, the data drives are meant to be used as a cache. DGX Station users can follow the same usage, or can alternatively opt to use these drives for storage. When using the data drives as cache, a network file system (NFS) is recommended to take advantage of the cache file system provided by the DGX software stack.\n1.2.4. BMC Password\n\nThe NVIDIA DGX server includes a base management controller (BMC) for out-of-band management of the DGX system. NVIDIA recommends disabling the default username and creating a unique username and password as soon as possible.\nChapter 2. Release Notes\n\nThis section provides detailed information for releases and upgrades available for the NVIDIA DGX™ Software Stack for Red Hat Enterprise Linux 9 and Rocky Linux 9.\n\n2.1. Current Contents of the Repositories\n\nThe following table shows the current version information of the software packages provided in the NVIDIA repositories for the NVIDIA DGX Software Stack.\nTable 1: Current Software Versions (Last Updated on August 9, 2024)\n\n<table>\n<thead>\n<tr>\n<th>Component</th>\n<th>Version</th>\n<th>Additional Information</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>GPU Driver</td>\n<td>550.90.07</td>\n<td>EL8: RPM installer EL9: RPM installer</td>\n</tr>\n<tr>\n<td>GPU Driver</td>\n<td>535.183.06</td>\n<td>EL8: RPM installer EL9: RPM installer</td>\n</tr>\n<tr>\n<td>GPU Driver</td>\n<td>470.256.02</td>\n<td>For EL8 and DGX OS 5 only. EL8: RPM installer</td>\n</tr>\n<tr>\n<td>CUDA Toolkit</td>\n<td>12.4 Update 1</td>\n<td>R550: 12.4 Update 1 download</td>\n</tr>\n<tr>\n<td>CUDA Toolkit</td>\n<td>12.2 Update 2</td>\n<td>R535: 12.2 Update 2 download</td>\n</tr>\n<tr>\n<td>CUDA Toolkit</td>\n<td>11.4 Update 4</td>\n<td>For EL8 and DGX OS 5 only. R470: 14.4 Update 4 download</td>\n</tr>\n<tr>\n<td>MLNX_OFED</td>\n<td>24.04-0.7.0.0</td>\n<td>24.04-0.7.0.0 download</td>\n</tr>\n<tr>\n<td>DOCA OFED</td>\n<td>2.7.0</td>\n<td>2.7.0 download</td>\n</tr>\n<tr>\n<td>Inbox OFED</td>\n<td>39.0-1</td>\n<td>For DGX OS 6 only</td>\n</tr>\n<tr>\n<td>NCCL</td>\n<td>2.22.3</td>\n<td></td>\n</tr>\n<tr>\n<td>cuDNN</td>\n<td>9.3.0</td>\n<td></td>\n</tr>\n<tr>\n<td>DCGM</td>\n<td>3.3.7</td>\n<td></td>\n</tr>\n<tr>\n<td>GPUDirect (GDS)</td>\n<td></td>\n<td>1.9.1 for CUDA Toolkit 12.4</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>1.7.2 for CUDA Toolkit 12.2</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>1.0 for CUDA Toolkit 11.4</td>\n</tr>\n<tr>\n<td>NVIDIA Toolkit</td>\n<td>Container</td>\n<td>NVIDIA Container Toolkit includes the following packages:</td>\n</tr>\n<tr>\n<td></td>\n<td>1.16.1</td>\n<td>◀ nvidia-container-toolkit: 1.16.1</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>◀ libnvidia-container-tools: 1.16.1</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>◀ libnvidia-container1: 1.16.1</td>\n</tr>\n<tr>\n<td>nvidia-peer-memory</td>\n<td>1.3</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**Note:**\nCUDA Toolkit is installed by default only for DGX stations and is optional for DGX servers. Refer to the CUDA Release Notes for driver compatibility information.\n\nFor CUDA Toolkit minor version compatibility and the minimum required driver version, refer to CUDA Compatibility.\n\nThe following table provides information about the matching firmware versions for NVIDIA® OpenFabrics Enterprise Distribution for Linux (MLNX_OFED) version 23.10-3.2.2.0. For more information about this long-term support (LTS) release, refer to\n\n- NVIDIA MLNX_OFED Documentation v23.10-3.2.2.0 LTS\n- Software download: version 23.10-3.2.2.0\n\nTable 2: Matching Firmware Versions (Last Updated on August 9, 2024)\n\n<table>\n<thead>\n<tr>\n<th>DGX-1, DGX-2 ConnectX-4 (CX-4) or ConnectX-5 (CX-5)</th>\n<th>DGX A100 ConnectX-6</th>\n<th>DGX A100 ConnectX-7</th>\n<th>DGX H100/H200 ConnectX-7</th>\n</tr>\n</thead>\n</table>\n\nFor installation instructions, refer to\n\n- NVIDIA MLNX_OFED: Installing NVIDIA MLNX_OFED\n- ConnectX®-7 adapter cards: Installing ConnectX-7 Firmware\n- ConnectX®-6 adapter cards: Firmware Downloads\n\nNote: For information about LTS software versions for related networking components, refer to the Networking Long-Term Support Releases page.\n\n2.2. Release Information\n\nThis section provides details of each DGX Software for Red Hat Enterprise Linux release. These include mostly new NVIDIA features and accumulated bug fixes and security updates.\n\n- To check the latest Red Hat Enterprise Linux 9 version, refer to Red Hat Knowledgebase article 3078.\n\n- To check the MLNX_OFED package OS support, visit Mellanox and click the latest NVIDIA MLNX_OFED software version. Use the side menu to navigate to Release Notes > General Support and view Supported Operating Systems.\n\nImportant: Installing or updating to the DGX Software also updates the installed Red Hat Enterprise Linux 9 distribution to the latest version.\nIf you use NVIDIA MLNX_OFED, then before installing or updating to EL9-23.08, be sure that there is a MLNX_OFED package version available that supports the latest Red Hat Enterprise Linux 9 version.\n\n2.2.1. EL9-24.06 Release\n\n**Release Date:** July 11, 2024\n\n**Release Highlights**\n\n- Added support for Red Hat Enterprise Linux 9.4 and Rocky 9.4.\n- Introduced support for the NVIDIA DOCA™ Host package with the doca-ofed installation profile v2.7.0.\n - DOCA OFED download\n- Included support for the NVIDIA® OpenFabrics Enterprise Distribution for Linux (MLNX_OFED) v24.04-0.6.6.0\n - MLNX_OFED download\n- Continued support for single-port ConnectX-7 VPI adapter card for DGX A100 System.\n- Updated the DGX Software Stack.\n\n**Known Issues**\n\n- [NVIDIA GPU Driver 550 Not Supported on DGX Station A100](#)\n\n**Qualified Software Stack**\n\nThe following table shows the current version information of the software packages provided in the NVIDIA repositories for the NVIDIA DGX Software Stack.\n## Component\n\n<table>\n<thead>\n<tr>\n<th>Component</th>\n<th>Latest versions in the repositories</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>DGX Base OS</td>\n<td>EL9-24.06</td>\n</tr>\n<tr>\n<td>OS</td>\n<td>Red Hat Enterprise Linux 9.4 and Rocky Linux 9.4</td>\n</tr>\n<tr>\n<td>Kernel</td>\n<td>5.14.0-427.18.1.el9_4.x86_64</td>\n</tr>\n<tr>\n<td>GPU Driver</td>\n<td>▶ 550.90.07</td>\n</tr>\n<tr>\n<td></td>\n<td>▶ 535.183.01</td>\n</tr>\n<tr>\n<td>CUDA Toolkit</td>\n<td>▶ 12.4 Update 1 for GPU driver 550.90.07</td>\n</tr>\n<tr>\n<td></td>\n<td>▶ 12.2 Update 2 for GPU driver 535.183.01</td>\n</tr>\n<tr>\n<td>NCCL</td>\n<td>2.21.5</td>\n</tr>\n<tr>\n<td>cuDNN</td>\n<td>9.1.1</td>\n</tr>\n<tr>\n<td>DCGM</td>\n<td>3.3.6</td>\n</tr>\n<tr>\n<td>GPU Direct Storage</td>\n<td>▶ 1.9.1 for CUDA 12.4</td>\n</tr>\n<tr>\n<td></td>\n<td>▶ 1.7.2 for CUDA 12.2</td>\n</tr>\n<tr>\n<td>NVIDIA System Management (NVSM)</td>\n<td>24.03.03</td>\n</tr>\n<tr>\n<td>Docker CE</td>\n<td>26.1.3</td>\n</tr>\n<tr>\n<td>NVIDIA Container Runtime</td>\n<td>▶ nvidia-container-toolkit: 1.15.0</td>\n</tr>\n<tr>\n<td></td>\n<td>▶ libnvidia-container-tools: 1.15.0</td>\n</tr>\n<tr>\n<td></td>\n<td>▶ libnvidia-container1: 1.15.0</td>\n</tr>\n<tr>\n<td>MIG Configuration Tool</td>\n<td>0.7.0</td>\n</tr>\n<tr>\n<td>GDRCopy</td>\n<td>2.4.1</td>\n</tr>\n<tr>\n<td>DLFW (Deep Learning Frameworks)</td>\n<td>24.05</td>\n</tr>\n</tbody>\n</table>\n\nThe following table provides information about the supported OS and matching firmware versions for the NVIDIA® OpenFabrics Enterprise Distribution for Linux (MLNX_OFED) v24.04-0.6.6.0 and the NVIDIA DOCA™ Host package with the doca-ofed installation profile v2.7.0.\n\n<table>\n<thead>\n<tr>\n<th>OS</th>\n<th>DGX-1, DGX-2 ConnectX-4 (CX-4) or ConnectX-5 (CX-5)</th>\n<th>DGX A100 ConnectX-6</th>\n<th>DGX A100 ConnectX-7</th>\n<th>DGX H100 ConnectX-7</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>RHEL 9</td>\n<td>CX-5: 16.35.3502</td>\n<td>20.41.1000</td>\n<td>28.41.1000</td>\n<td>28.41.1000</td>\n</tr>\n<tr>\n<td></td>\n<td>CX-4: 12.28.2006</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n### 2.2. Release Information\nSupported DGX Systems\n\nThe EL9-24.06 release supports the following DGX systems:\n\n▶ DGX H100\n▶ DGX A100 640 GB\n▶ DGX A100 320 GB\n▶ DGX A800 640 GB\n▶ DGX-2\n▶ DGX-1 32 GB\n▶ DGX Station A100 320 GB\n▶ DGX Station A100 160 GB\n▶ DGX Station A800 320 GB\n▶ DGX Station 32 GB\n\n2.2.2. EL9-23.12 Release\n\nRelease Date: December 19, 2023\n\nRelease Highlights\n\n▶ Added support for Red Hat Enterprise Linux 9.3 and Rocky 9.3.\n▶ Continued support for Red Hat Enterprise Linux 9.2 and Rocky Linux 9.2.\n▶ Added support for single-port ConnectX-7 VPI adapter card for DGX A100 System.\n▶ Added support for NVIDIA® OpenFabrics Enterprise Distribution for Linux (MLNX_OFED) version 23.10-1.1.9.0 - a long-term support (LTS) release.\n▶ Continued support for DGX H100.\n\nKnown Issues\n\n▶ NVIDIA GPU Driver 550 Not Supported on DGX Station A100\n\nQualified Software Stack\n\nThe following table shows the current version information of the software packages provided in the NVIDIA repositories for the NVIDIA DGX Software Stack.\n## Component\n\n<table>\n<thead>\n<tr>\n<th>Component</th>\n<th>Latest versions in the repositories</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>DGX Base OS</td>\n<td>EL9-23.12</td>\n</tr>\n<tr>\n<td>OS</td>\n<td>Red Hat Enterprise Linux 9.3 and Rocky Linux 9.3</td>\n</tr>\n<tr>\n<td>Kernel</td>\n<td>5.14.0-362.8.1.el9_3</td>\n</tr>\n<tr>\n<td>GPU Driver and CUDA Toolkit</td>\n<td>CUDA Toolkit 12.2 and GPU Driver 535.129.03 (Default)</td>\n</tr>\n<tr>\n<td>NCCL</td>\n<td>2.19.3</td>\n</tr>\n<tr>\n<td>cuDNN</td>\n<td>8.9.6</td>\n</tr>\n<tr>\n<td>DCGM</td>\n<td>3.3.0-002</td>\n</tr>\n<tr>\n<td>GPU Direct Storage</td>\n<td>1.7.2 or later</td>\n</tr>\n<tr>\n<td>NVIDIA System Management (NVSM)</td>\n<td>23.09.02</td>\n</tr>\n<tr>\n<td>Docker-CE</td>\n<td>24.0.7-1</td>\n</tr>\n</tbody>\n</table>\n\n### NVIDIA Container Runtime\n\n- nvidia-docker2: 2.13.0-1\n- nvidia-container-toolkit (and base): 1.14.3-1\n- libnvidia-container-tools: 1.14.3-1\n- libnvidia-container1: 1.14.3-1\n\n### MIG Configuration Tool\n\n| 0.5.4-1 |\n\n### NGC CLI\n\n| 3.17.0-1 |\n\n### DLFW (Deep Learning Frameworks)\n\n| 23.10 |\n\nThe following table provides information about the supported OS and matching firmware versions for NVIDIA® OpenFabrics Enterprise Distribution for Linux (MLNX_OFED) version 23.10-1.1.9.0.\n\n<table>\n<thead>\n<tr>\n<th>OS</th>\n<th>DGX-1, DGX-2 ConnectX-4 (CX-4) or ConnectX-5 (CX-5)</th>\n<th>DGX A100 ConnectX-6</th>\n<th>DGX A100 ConnectX-7</th>\n<th>DGX H100 ConnectX-7</th>\n</tr>\n</thead>\n</table>\nSupported DGX Systems\n\nNVIDIA has validated and tested EL9-23.12 with the following DGX systems:\n\n- DGX H100\n- DGX A100 640 GB\n- DGX A100 320 GB\n- DGX A800 640 GB\n- DGX-2\n- DGX-1 32 GB\n- DGX Station A100 320 GB\n- DGX Station A100 160 GB\n- DGX Station 32 GB\n\nResolved Issues\n\nThe following issues have been resolved in the EL9-23.12 release:\n\n<table>\n<thead>\n<tr>\n<th>Bug ID</th>\n<th>Issue</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>4108242</td>\n<td>Running joc tests resulted in an unrecognized arguments: --local-rank error with GPU driver R525.105.17.</td>\n</tr>\n<tr>\n<td>4386925</td>\n<td>GPUDirect RDMA bandwidth test failed with the Xid (PCI:0000:0f:00): 79, pid='<unknown>', name='<unknown>', GPU has fallen off the bus.message.</td>\n</tr>\n</tbody>\n</table>\n\n2.2.3. EL9-23.08 Release\n\nRelease Highlights\n\n- Add support for NVIDIA DGX H100 System. Support is limited to the Red Hat Enterprise Linux 9.1 release.\n- Add support for Red Hat Enterprise Linux 9.2 and Rocky Linux 9.2.\n\nQualified Software Stack\n\nThe following table provides version information for EL9-23.08 and the software it has been qualified:\n<table>\n<thead>\n<tr>\n<th>Component</th>\n<th>Latest versions in the repositories</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Linux Distribution</td>\n<td>Red Hat Enterprise Linux 9.2 and Rocky Linux 9.2 For NVIDIA DGX H100 Systems, only Red Hat Enterprise Linux 9.1 is supported.</td>\n</tr>\n<tr>\n<td>GPU Driver</td>\n<td>535.86.10</td>\n</tr>\n<tr>\n<td>CUDA Toolkit</td>\n<td>12.2.0</td>\n</tr>\n<tr>\n<td>NCCL</td>\n<td>2.18.3</td>\n</tr>\n<tr>\n<td>CuDNN</td>\n<td>8.9.2.26</td>\n</tr>\n<tr>\n<td>DCGM</td>\n<td>3.1.8</td>\n</tr>\n<tr>\n<td>MLNX OFED</td>\n<td>ConnectX-7 with DGX H100: 5.9-0.5.6.0.125 ConnectX-7 with DGX A100: 5.4-3.7.5.0 ConnectX-6 with DGX A100: 5.8-3.0.7.0 ConnectX-5 and ConnectX-4: 5.8-3.0.7.0</td>\n</tr>\n<tr>\n<td>MLNX FW</td>\n<td>ConnectX-7 and DGX H100: 28.36.2050 ConnectX-7 and DGX A100: 28.34.4000 ConnectX-6 and DGX A100: 20.35.4000 ConnectX-5: 16.35.3006 ConnectX-4: 12.28.2006</td>\n</tr>\n<tr>\n<td>GPU Direct Storage</td>\n<td>1.7.2</td>\n</tr>\n<tr>\n<td>NVIDIA System Management (NVSM)</td>\n<td>23.06.04</td>\n</tr>\n<tr>\n<td>Docker Engine</td>\n<td>23.0.4</td>\n</tr>\n<tr>\n<td>MIG Configuration Tool</td>\n<td>0.5.1</td>\n</tr>\n<tr>\n<td>NGC CLI</td>\n<td>3.17.0</td>\n</tr>\n<tr>\n<td>DLFW (Deep Learning Frameworks)</td>\n<td>23.07</td>\n</tr>\n</tbody>\n</table>\n\nThe following table provides information about the supported OS and matching firmware versions for Mellanox OFED.\n## Hardware Compatibility\n\nNVIDIA has validated and tested EL9-23.08 with the following DGX systems:\n\n- NVIDIA DGX H100\n- NVIDIA DGX A100\n- NVIDIA DGX Station A100\n- NVIDIA DGX Station\n- NVIDIA DGX-2\n- NVIDIA DGX-1\n\n### 2.2.4. EL9-23.01 Release\n\nInitial release of the DGX Software Stack for Red Hat Enterprise Linux 9.\n\n### Qualified Software Stack\n\nThe following table provides version information for EL9-23.01 and the software it has been qualified:\n\n<table>\n<thead>\n<tr>\n<th>OS</th>\n<th>DGX-1, DGX-2 ConnectX-4 or ConnectX-5</th>\n<th>DGX A100 ConnectX-6 (CX-6)</th>\n<th>DGX A100 ConnectX-7 (CX-7)</th>\n<th>DGX H100 ConnectX-7 (CX-7)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>RHEL 8</td>\n<td>5.8-3.0.7.0</td>\n<td>5.8-3.0.7.0</td>\n<td>5.4-3.7.5.0</td>\n<td>5.9-0.5.6.0.127</td>\n</tr>\n<tr>\n<td></td>\n<td>▶ CX-5: 16.35.3006</td>\n<td>▶ CX-6: 20.35.3006</td>\n<td>▶ CX-7: 28.34.4000</td>\n<td>▶ CX-7: 28.36.2050</td>\n</tr>\n<tr>\n<td></td>\n<td>▶ CX-4: 12.28.2006</td>\n<td>▶ RHEL 8.8</td>\n<td>▶ RHEL 8.8</td>\n<td>▶ RHEL 8.7</td>\n</tr>\n<tr>\n<td>RHEL 9</td>\n<td>5.8-3.0.7.0</td>\n<td>5.8-3.0.7.0</td>\n<td>5.4-3.7.5.0</td>\n<td>5.9-0.5.6.0.127</td>\n</tr>\n<tr>\n<td></td>\n<td>▶ CX-5: 16.35.3006</td>\n<td>▶ CX-6: 20.35.3006</td>\n<td>▶ CX-7: 28.34.4000</td>\n<td>▶ CX-7: 28.36.2050</td>\n</tr>\n<tr>\n<td></td>\n<td>▶ CX-4: 12.28.2006</td>\n<td>▶ RHEL 9.2</td>\n<td>▶ RHEL 9.2</td>\n<td>▶ RHEL 9.1</td>\n</tr>\n<tr>\n<td>Component</td>\n<td>Versions in this release</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>------------------------------------------</td>\n<td>------------------------------------------</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Linux Distribution</td>\n<td>Red Hat Enterprise Linux 9.1 and Rocky Linux 9.1</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>GPU Driver</td>\n<td>525.105.17</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>CUDA Toolkit</td>\n<td>12.0</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>NCCL</td>\n<td>2.18.1</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>CuDNN</td>\n<td>8.9.1.23</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>DCGM</td>\n<td>3.1.8</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>NVIDIA MLNX_OFED</td>\n<td>5.8-2.0.3.0</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>NVIDIA ConnectX Firmware</td>\n<td>► CX-4: 12.28.2006</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>► CX-5: 16.35.2000</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>► CX-6: 20.35.2000</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>NVIDIA System Management (NVSM)</td>\n<td>22.12.04</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Docker Engine</td>\n<td>23.0.4</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>NVIDIA Container Runtime</td>\n<td>► nvidia-docker2: 2.13.0-1</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>► nvidia-container-toolkit (and base): 1.13.1-1</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>► libnvidia-container-tools: 1.13.1-1</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>► libnvidia-container1: 1.13.1-1</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>MIG Configuration Tool</td>\n<td>0.5.1</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>NGC CLI</td>\n<td>3.17.0</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>DLFW (Deep Learning Frameworks)</td>\n<td>23.03</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n**Hardware Compatibility**\n\nNVIDIA has validated and tested EL9-23.01 with the following DGX systems:\n\n- DGX-1\n- DGX-2\n- DGX Station\n- DGX A100\n- DGX Station A100\nChapter 3. Installing Red Hat Enterprise Linux\n\nRed Hat provides several methods for installing Red Hat Enterprise Linux as described in Performing a Standard RHEL 9 Installation.\n\nThe installation instructions in this topic are for the latest release of the DGX Software for Red Hat Enterprise Linux 9. The DGX Software does not include Extended Update Support (EUS), which is an optional subscription for Red Hat Enterprise Linux. For more information about EUS, refer to Red Hat Enterprise Linux (RHEL) Extended Update Support (EUS) Overview.\n\nFor convenience, this topic describes how to install Red Hat Enterprise Linux using the Quick Install method, and shows when to reclaim disk space in the process. It describes a minimal installation. If you have a preferred method for installing Red Hat Enterprise Linux, then you can skip this section but be sure to reclaim disk space occupied by the existing Ubuntu installation.\n\nThe interactive method described here installs Red Hat Enterprise Linux on DGX using a connected monitor and keyboard and USB stick with the ISO image, or remotely through the remote console of the BMC.\n\n**Important:** Refer to the Release Notes for any critical information regarding supported releases or dependencies. You will also find the version of Red Hat Enterprise Linux that is qualified and tested for use with the DGX Software.\n\n3.1. Obtaining Red Hat Enterprise Linux\n\nObtain the Red Hat Enterprise Linux 9 ISO image and store on your local disk or create a boot USB drive formatted for UEFI. See Downloading Red Hat Enterprise Linux for instructions.\n3.2. Booting the Red Hat Enterprise Linux ISO Locally\n\n1. Plug the USB flash drive containing the Red Hat Enterprise Linux 9 ISO image into the DGX.\n2. Connect a monitor and keyboard directly to the DGX.\n3. Boot the system and press **F11** when the NVIDIA logo appears to get to the boot menu.\n4. Select the USB volume name that corresponds to the inserted USB flash drive, and boot the system from it.\n5. Follow the instructions at *Installing and Configuring Red Hat Enterprise Linux*\n\n3.3. Booting the Red Hat Enterprise Linux ISO Remotely\n\nThis chapter describes the steps for booting the Red Hat Enterprise Linux ISO remotely using the BMC:\n\n▶ For DGX-2, DGX A100, DGX A800, or DGX H100, refer to *Booting the ISO Image on the DGX-2, DGX A100, DGX A800, or DGX H100 Remotely*.\n\n▶ For DGX-1, refer to *Booting the ISO Image on the DGX-1 Remotely*.\n\nSkip this chapter if you are using a monitor and keyboard for installing locally, or if you are installing on a DGX Station. The DGX Station **cannot** be booted remotely.\n\n3.3.1. Booting the ISO Image on the DGX-2, DGX A100, DGX A800, or DGX H100 Remotely\n\n1. Connect to the BMC and ensure the required user privileges are set.\n a. Open a browser within your LAN and go to `https://<BMC-ip-address>/`, then log in.\n b. From the left-side menu, click Settings and then select User Management.\n c. Click the card with the user name that you created for the BMC.\n d. In the User Management Configuration dialog, make sure the VMedia Access checkbox is selected, then click Save.\n2. Set up the ISO image as virtual media.\n a. From the left-side menu, click Remote Control.\n \n b. Select Launch KVM.\nc. From the top menu bar in the KVM window, click Browse File and select the ISO image, then click Start Media.\n\nThe CD image should now be connected.\n\nd. From the top menu bar in the KVM window, click Power and then select Reset Server.\n\n3. Boot from the virtual media.\n\nTypically, the default boot order does not boot the CDROM image. You can change this in the BIOS or as a one-time option in the boot menu.\n\na. To bring up the boot menu, press F11 at the beginning of the boot process.\n\nPressing F11 will display Entering Boot Menu in the virtual display before entering the boot menu.\nb. In the boot menu, select UEFI: AMI Virtual CDROM0 1.00 as the boot device and then press ENTER\n\n```\nPlease select boot device:\n\nM2_1 Red Hat Enterprise Linux (S436NA0M519464)\nM2_1 RedHat Boot Manager (S436NA0M519464)\nUEFI: AMI Virtual CDROM0 1.00\nUEFI: Built-In EFI Shell\nEnter Setup\n\n↑ and ↓ to move selection\nENTER to select boot device\nESC to boot using defaults\n```\n\nIf you are booting from the DGX-2, the boot device is labeled UEFI: Virtual CDROM0 1.00.\n3.3.2. Booting the ISO Image on the DGX-1 Remotely\n\n1. Connect to the BMC and change user privileges.\n a. Open a Java-enabled web browser within your LAN and go to http://<BMC-ip-address>/, then log in.\n Use Firefox or Internet Explorer. Google Chrome is not officially supported by the BMC.\n b. From the top menu, click Configuration and then select Users.\n c. Select the user name that you created for the BMC, then click Modify User.\n d. In the Modify User dialog, select the VMedia checkbox to add it to the extended privileges for the user, then click Modify.\n2. Set up the ISO image as virtual media and reboot the system.\n a. From the top menu, click Remote Control and select Remote KVM.\n b. Click Launch KVM to open the remote console.\n c. From the top menu bar in the KVM window, click Browse File and select the ISO image, then click Start Media.\n\nThe CD image should now be connected.\nd. From the top menu bar in the KVM window, click Power and then select Reset Server.\n\n3. Boot the CD ROM image.\n\nThe default boot order does not boot the CDROM image. This can be changed in the BIOS or as a one-time option in the boot menu. To bring up the boot menu, press F11 at the beginning of the boot process. Pressing F11 will display Show Boot Options at the top of the virtual display before entering the boot menu. Use the \"soft\" keyboard (Menu → Keyboard Layout → SoftKeyboard → <Language>) to bring up a virtual keyboard if pressing the physical key has no effect.\n\na. In the boot menu, select UEFI: AMI Virtual CDROM 1.00 as the boot device and then press ENTER\n\nb. Follow the instructions at Installing and Configuring Red Hat Enterprise Linux\n3.4. Installing and Configuring Red Hat Enterprise Linux\n\nThis section assumes you have booted the Red Hat Enterprise Linux ISO image.\n\n**Note:** Rocky Linux: The procedures for installing Rocky Linux are essentially the same as those described here, except where noted. The bootup installation screen will refer to Rocky Linux instead of Red Hat Enterprise Linux, and the Quick Start installer for Rocky Linux is based on the Red Hat Enterprise Linux installer, so the look is similar except, again, for the naming.\n\n1. After booting the ISO image, the GRUB menu for the installer appears.\n\n \n\n **Install Red Hat Enterprise Linux 8.2**\n Test this media & install Red Hat Enterprise Linux 8.2\n Troubleshooting -->\n\n Use the ↑ and ↓ keys to change the selection.\n Press 'e' to edit the selected item, or 'c' for a command prompt.\n\n2. If you wish to automate the installation with a kickstart file, see the section Installing with Kickstart.\n\n3. Select Install Red Hat Enterprise Linux and press 'e' to edit the selected option.\n a. Add the \"nomodeset\" parameter as shown below.\n\n \"nomodeset\" prevents the in-box Nouveau driver from loading as it might not properly support the GPUs used in the DGX systems, resulting in display issues.\nb. Press Ctrl-x to save your changes and start the installation.\n\n4. Refer to Performing a Standard RHEL 9 Installation for additional guidance on using the RHEL 9 installer.\n\n5. Configure the language, region, date, time, keyboard, and other configuration options you might need from the Installation Summary Screen.\n\n6. Set the Software Selection to the correct value.\n - For DGX Station and DGX Station A100: Set to Server with GUI.\n - For DGX Servers (DGX 1-1, DGX-2, DGX A100, DGX A800, and DGX H100): Set to Minimal Install.\n\n**Note:** Setting the correct Software Selection is critical for proper operation.\n7. Partition your disks based on the platform and whether or not you would like to use encryption:\n - Disk Partitioning for DGX-1, DGX Station, and DGX Station A100\n - Disk Partitioning with Encryption for DGX-1, DGX Station, and DGX Station A100\n - Disk Partitioning for DGX-2, DGX A100, DGX A800, and DGX H100\n - Disk Partitioning with Encryption for DGX-2, DGX A100, DGX A800, and DGX H100\n\n8. Configure Ethernet.\n\n From the Network & Host Name section, select and enable the Ethernet device. This defaults to DHCP and can be changed for static IP configurations under Configure.\n9. From the INSTALLATION SUMMARY screen, set your password (at User Settings > Root Password) and create a new user (at User Settings > User Creation), then click Begin installation to start the installation.\nWhen the system reboots, be sure and eject any still-mounted installation discs.\n\n10. Complete the initial Red Hat Enterprise Linux setup.\n\n ▶ If you installed using the Server with GUI base environment, the Initial Setup starts automatically where you can accept the license agreement and register the system. See the Red Hat instructions for details.\n\n ▶ If you are using CentOS you will need to accept the license agreement.\n\n ▶ If you installed with any other base environment, log on to the system as root user and then register the system.\n\n ```\n subscription-manager register --auto-attach --username=user_name --password=password\n ```\n\n ▶ To prevent accidental upgrade of the Linux kernel, such as from RHEL 9.3 to 9.4, when pre-compiled GPU modules and drivers for that kernel are not available, you should pin the desired RHEL release by setting the `--set=<release>` option of the `release` command.\n\n For example, to stay on the RHEL 9.3 release:\n\n ```\n subscription-manager release --set=9.3\n ```\n\n You should check the Release Notes section for GPU driver and Linux kernel support before changing the `--set=<release>` setting and performing `sudo dnf update --nobest`.\n\n See How to register and subscribe a system to the Red Hat Customer Portal using Red Hat Subscription-Manager for further information.\n3.5. Partitioning\n\nThis chapter provides instructions for partitioning the DGX system:\n\n- Disk Partitioning for DGX-1, DGX Station, and DGX Station A100\n- Disk Partitioning for DGX-2, DGX A100, DGX A800, and DGX H100\n- Disk Partitioning with Encryption for DGX-1, DGX Station, and DGX Station A100\n- Disk Partitioning with Encryption for DGX-2, DGX A100, DGX A800, and DGX H100\n\n3.5.1. Disk Partitioning for DGX-1, DGX Station, and DGX Station A100\n\nNote: The screenshots in the following section are taken from a DGX-1. The screens for the DGX Station and DGX Station A100 installations can present slightly different information for such things as disk size, disk space available, interface names, and so on.\n\n1. At the Installation Destination screen, select the smaller of the available drives to install on.\n\n Under Storage Configuration, click the Custom radio button and then click Done.\nThis brings up the **Manual Partitioning** window.\n\n2. Expand the drop-down menu for the device you've selected and delete all existing partitions until there are none remaining.\n\n3. Click the + button on the bottom left to create a new partition.\n\nCreate the `boot/efi` partition with a size of 512 MiB.\n4. Select **Standard Partition** for the **Device Type**.\nUnder **Devices**, ensure only the drive you chose in step 1 is selected. Click **Update Settings** to confirm your changes.\n\n5. Click the + button on the bottom left again to create another new partition. Create the / partition, this time leaving the **Desired Capacity** field empty. This lets the installer know to use the remaining capacity of the disks.\n6. For the `/` partition, again select Standard Partition for the Device Type. Under Devices, ensure that only the drive you chose in step 1 is selected. For the File System, select XFS.\nUnder **Devices**, ensure that only the drive you chose in step 1 is selected. For the **File System**, select **XFS**. Click **Update Settings** to confirm your changes.\n\n7. Click **Done**. This causes a yellow warning bar to appear on the bottom because no swap partition has been created.\n\n8. Click **Done** again and then click **Accept Changes** to write all of our customizations to disk.\n9. Return to step 8 in the *Installing and Configuring Red Hat Enterprise Linux* section.\n\n### 3.5.2. Disk Partitioning with Encryption for DGX-1, DGX Station, and DGX Station A100\n\n**Note:** The screenshots in the following section are taken from a DGX-1. The screens for the DGX Station and DGX Station A100 installations can present slightly different information for such things as disk size, disk space available, interface names, etc.\n\n1. At the Installation Destination screen, select the smaller of the available drives to install on. Under *Storage Configuration*, click the **Custom** radio button and then click Done.\n2. This brings up the **Manual Partitioning** window. Expand the drop-down menu for the device you’ve selected and delete all existing partitions until there are none remaining.\n3. Click the + button on the bottom left to create a new partition.\n\nCreate the /boot/efi partition with a size of 512 MiB.\nUnder **Devices**, ensure only the drive you chose in step 1 is selected.\n\nClick **Update Settings** to confirm your changes.\n\n5. Click the + button on the bottom left again to create another new partition.\n\nCreate the `/boot` partition with a size of 2 GiB.\n6. For the /boot partition, again select Standard Partition for the Device Type.\nUnder **Devices**, ensure that only the drive you chose in step 1 is selected. For the **File System**, select **XFS**.\n\nClick **Update Settings** to confirm your changes.\n\n7. Click the + button on the bottom left again to create another new partition.\n\n Create the `/` partition, this time leaving the **Desired Capacity** field empty. This lets the installer know to use the remaining capacity of the disks.\n8. For the / partition, again select Standard Partition for the Device Type. Be sure to check the Encrypt checkbox, and choose luks2 for the LUKS Version. For the File System, select XFS. Again confirm that this partition uses both of the devices you selected in step 2. Then click Done.\n9. A prompt will now appear, asking for a LUKS password. Be sure to choose a strong and secure password. After entering your password twice, click **Save Passphrase**\n\n10. Click **Done**. This causes a yellow warning bar to appear on the bottom because no swap partition has been created.\n11. Click **Done** again and then click **Accept Changes** to write all of our customizations to disk.\n3.5.3. Disk Partitioning for DGX-2, DGX A100, DGX A800, and DGX H100\n\n**Note:** The screenshots in the following section are taken from a DGX A100. The instructions for the DGX-2, DGX H100, and DGX A800 installation can present slightly different information, such as disk size, disk space available, interface names, and so on.\n\n1. At the **Installation Destination** screen, select the smaller of the available drives to install on. Under **Storage Configuration**, click the **Custom** radio button and then click **Done**.\nThis brings up the Manual Partitioning window.\n\n2. Expand the drop-down menu for the device you have selected and delete all existing partitions until there are none remaining.\n3. Click the + button on the bottom left to create a new partition. Create the `/boot/efi` partition with a size of 512 MiB.\n4. Change the **Device Type** to RAID, change the **RAID Level** to RAID1, and confirm that this partition covers both of the devices you selected in step 2 by clicking **Modify** in the **Device(s)** section and making sure both disks are still selected.\n\nNote that the partition information on the left might not reflect both devices yet. Click **Update Settings** to confirm your changes.\n5. Click the + button on the bottom left again to create another new partition.\n\nCreate the / partition, this time leaving the Desired Capacity field empty. This lets the installer know to use the remaining capacity of the disks.\n6. For the / partition, again select RAID for the Device Type and RAID1 for the RAID Level. For the File System, select XFS.\n\n Confirm that this partition uses both of the devices you selected in step 2 by clicking Modify in the Device(s) section and making sure both disks are still selected.\n7. Click **Done**.\n \n This causes a yellow warning bar to appear on the bottom because no swap partition has been created.\n\n8. Click **Done** again and then click **Accept Changes** to write all of our customizations to disk.\n9. Return to step 8 in the *Installing and Configuring Red Hat Enterprise Linux* section.\n\n### 3.5.4. Disk Partitioning with Encryption for DGX-2, DGX A100, DGX A800, and DGX H100\n\n**Note:** The screenshots in the following section are taken from a DGX A100. The following instructions will use LUKS to create an encrypted root filesystem on your boot devices. This is a separate process from using self-encrypting data-drives.\n\n1. At the Installation Destination screen, select the smaller of the available drives to install on.\n\n \n\n Under Storage Configuration, click the Custom radio button and then click Done.\n\n This brings up the Manual Partitioning window.\n\n2. Expand the drop-down menu for the device you have selected and delete all existing partitions until there are none remaining.\n3. Click the + button on the bottom left to create a new partition. Create the `/boot/efi` partition with a size of 512 MiB.\n4. Change the Device Type to RAID, change the RAID Level to RAID 1, and confirm that this partition covers both of the devices you selected in step 2 by clicking Modify in the Device(s) section and making sure both disks are still selected.\nNote that the partition information on the left might not reflect both devices yet.\nClick Update Settings to confirm your changes, and verify that the /boot/efi partition shown lists the partition name and not the individual device.\n\n5. Click the + button on the bottom left again to create another new partition.\nCreate the /boot partition with a size of 2 GiB.\n6. For the /boot partition, again select RAID for the Device Type, RAID1, and the RAID Level. For the File System, select XFS.\nAgain confirm that this partition uses both of the devices you selected in step 2 by clicking **Modify** in the **Device(s)** section and making sure both disks are still selected.\n\nClick **Update Settings** to confirm your changes. Click the + button on the bottom left again to create another new partition.\n\nCreate the / partition, this time leaving the **Desired Capacity** field empty. This lets the installer know to use the remaining capacity of the disks.\n\n7. For the / partition, again select RAID for the **Device Type**, RAID1 and the **RAID Level**.\n \n Be sure to check the Encrypt checkbox, and choose luks2 for the LUKS Version.\nFor the File System, select XFS. Again confirm that this partition uses both of the devices you selected in step 2.\n\nClick Update Settings to confirm your changes, and Done to begin exiting the partition menu.\n\nA prompt will now appear asking for a LUKS password.\n\n8. Be sure to choose a strong and secure password.\nAfter entering your password twice, click Save Passphrase.\n\n9. Click Done.\n\nThis causes a yellow warning bar to appear on the bottom because no swap partition has been created.\n10. Click Done again and then click Accept Changes to write all of our customizations to disk.\nChapter 4. Installing the DGX Software\n\nThis section requires that you have already installed Red Hat Enterprise Linux or derived operating system on the DGX™ system. You can skip this section if you already installed the DGX software stack during a kickstart install.\n\n**Important:** Before performing the installation, refer to the *Release Notes* for the latest information and additional instructions depending on the specific release.\n\n### 4.1. Configuring a System Proxy\n\nIf your network requires you to use a proxy:\n\n- Edit the file `/etc/dnf/dnf.conf` and make sure the following lines are present in the `[main]` section, using the parameters that apply to your network:\n\n ```\n proxy=http://<Proxy-Server-IP-Address>:<Proxy-Port>\n proxy_username=<Proxy-User-Name>\n proxy_password=<Proxy-Password>\n ```\n\n### 4.2. Enabling the DGX Software Repository\n\n**Attention:** By running these commands, you are confirming that you have read and agree to be bound by the *DGX Software License Agreement*. You are also confirming that you understand that any pre-release software and materials available that you elect to install in a DGX might not be fully functional, might contain errors or design flaws, and might have reduced or different security, privacy, availability, and reliability standards relative to commercial versions of NVIDIA software and materials, and that you use pre-release versions at your own risk.\n\nInstall the NVIDIA DGX Package for Red Hat Enterprise Linux.\n\n```bash\nsudo dnf install -y https://repo.download.nvidia.com/baseos/el/el-files/9/\\n nvidia-repo-setup-22.12-1.el9.x86_64.rpm\n```\n4.3. Installing Required Components\n\n1. On Red Hat Enterprise Linux, run the following commands to enable additional repositories required by the DGX software.\n\n ```bash\n sudo subscription-manager repos --enable=rhel-9-for-x86_64-appstream-rpms\n sudo subscription-manager repos --enable=rhel-9-for-x86_64-baseos-rpms\n sudo subscription-manager repos --enable=codeready-builder-for-rhel-9-x86_64-rpms\n ```\n\n2. Upgrade to the latest software.\n\n ```bash\n sudo dnf update -y --nobest\n ```\n\n3. Install DGX tools and configuration files.\n\n ```bash\n ▶ For DGX-1, install DGX-1 Configurations.\n sudo dnf group install -y 'DGX-1 Configurations'\n \n ▶ For the DGX-2, install DGX-2 Configurations.\n sudo dnf group install -y 'DGX-2 Configurations'\n \n ▶ For the DGX A100, install DGX A100 Configurations.\n sudo dnf group install -y 'DGX A100 Configurations'\n \n ▶ For the DGX A800, install DGX A800 Configurations.\n sudo dnf group install -y 'DGX A800 Configurations'\n \n ▶ For the DGX H100, install DGX H100 Configurations.\n sudo dnf group install -y 'DGX H100 Configurations'\n \n ▶ For the DGX Station, install DGX Station Configurations.\n sudo dnf group install -y 'DGX Station Configurations'\n \n ▶ For the DGX Station A100, install DGX Station A100 Configurations.\n sudo dnf group install -y 'DGX Station A100 Configurations'\n ```\n\n The configuration changes take effect only after rebooting the system. To reduce the number of reboots, you can defer rebooting until after you install the drivers.\n4.4. Configuring Data Drives\n\nThe data drives in the DGX systems can be configured as RAID 0 or RAID 5. RAID 0 provides the maximum storage capacity and performance, but does not provide any redundancy. RAID 0 is often used for data caching. You can use cachefilesd to provide a cache for NFS shares.\n\n**Important:** You can change the RAID level later but this will destroy the data on those drives.\n\nExcept for the DGX-1, the RAID configuration can be configured during the operating system installation. If you have already configured the RAID array during the installation, you can skip the first step and go to step 2.\n\n1. Configure the `/raid` partition.\n \n All DGX systems support RAID 0 or RAID 5 arrays.\n \n The following commands create a RAID array, mount it to `/raid` and create an appropriate entry in `/etc/fstab`.\n \n ▶ To create a RAID 0 array:\n ```bash\n sudo /usr/bin/configure_raid_array.py -c -f\n ```\n \n ▶ To create a RAID 5 array:\n ```bash\n sudo /usr/bin/configure_raid_array.py -c -f -5\n ```\n\n **Note:** The RAID array must be configured before installing `nvidia-conf-cachefilesd`, which places the proper SELinux label on the `/raid` directory. If you ever need to recreate the RAID array — which will wipe out any labeling on `/raid` — after `nvidia-conf-cachefilesd` has already been installed, be sure to restore the label manually before restarting cachefilesd.\n\n ```bash\n sudo restorecon /raid\n sudo systemctl restart cachefilesd\n ```\n\n2. *(Optional)* Install tools for managing the self-encrypting drives (SED) for the data drives on DGX A100, DGX A800, or DGX H100 systems.\n \n Refer to *Managing Self-Encrypting Drives* for more information.\n\n3. *(Optional)* If you wish to use your RAID array for caching, install `nvidia-conf-cachefilesd`. This will update the cachefilesd configuration to use the `/raid` partition.\n\n ```bash\n sudo dnf install -y nvidia-conf-cachefilesd\n ```\n4.5. Installing the GPU Driver\n\nYou have the option to choose between different GPU driver branches for your DGX system. The latest driver release includes new features but might not provide the same support duration as an older release. Refer to the release notes at the NVIDIA Driver Documentation for more details and the minimum required driver release for the GPU architecture.\n\n1. Display a list of available drivers.\n\n```\ndnf module list nvidia-driver\n```\n\n**Example Output**\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Stream</th>\n<th>Summary</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>nvidia-driver</td>\n<td>latest</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>latest branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>latest-dkms [d]</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>latest-dkms branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>open-dkms</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>open-dkms branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>515</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>515 branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>515-dkms</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>515-dkms branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>515-open</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>515-open branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>520</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>520 branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>520-dkms</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>520-dkms branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>520-open</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>520-open branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>525</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>525 branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>525-dkms</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>525-dkms branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>525-open</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>525-open branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>530</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>530 branch</td>\n<td></td>\n</tr>\n<tr>\n<td>nvidia-driver</td>\n<td>530-dkms</td>\n<td>Nvidia driver for</td>\n</tr>\n<tr>\n<td></td>\n<td>default [d], fm, ks</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>530-dkms branch</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n(continues on next page)\nBefore installing the NVIDIA CUDA driver and configure the system,\n\n- Replace the release version (535) used as an example in step 2 with the release you want to install.\n- If the Stream column in the example output does not display the compiled driver version you want (for example, 535) but only the DKMS version (535-dkms), replace the `sudo dnf module install --nobest -y nvidia-driver:535...` command with the following command in step 2 regardless of the system:\n\n ```bash\n sudo dnf module install --nobest -y nvidia-driver:535-dkms/fm\n ```\n- Ensure that the driver release you intend to install is supported by the GPU in the system.\n\n```\nCaution: A known issue has been identified with DGX Station A100. For more information, refer to NVIDIA GPU Driver 550 Not Supported on DGX Station A100.\n```\n\n2. Install the NVIDIA CUDA driver.\n\n 1. For non-NVSwitch systems, such as DGX-1, DGX Station, and DGX Station A100, install the driver using the default and src profiles:\n\n ```bash\n sudo dnf module install --nobest -y nvidia-driver:535/{default,src}\n sudo dnf install -y nv-persistence-mode libnvidia-nscq-535\n ```\n\n 2. For NVSwitch systems, such as DGX-2, DGX A100, DGX H100, and DGX A800, install the driver using the fabric manager (fm) and source (src) profiles:\n\n ```bash\n sudo dnf module install --nobest -y nvidia-driver:535/{fm,src}\n sudo dnf install -y nv-persistence-mode nvidia-fm-enable\n ```\n\n3. (DGX Station A100 only) Install additional packages required for DGX Station A100. These packages must be installed after installation of the nvidia-driver module.\n\n ```bash\n sudo dnf install -y nvidia-conf-xconfig nv-docker-gpus\n ```\n\n The configuration changes take effect only after rebooting the system. To reduce the number of reboots, you can defer rebooting until after you install the NVIDIA Container Runtime group.\n\n4. Install and configure the NVIDIA Container Toolkit with Docker CE or Podman.\n\n Choose one of the following options:\n\n4.5. Installing the GPU Driver\n4.5.1. Installing and Running Docker CE\n\nTo run an NVIDIA container with Docker CE:\n\n1. Installing the NVIDIA container device plugin along with Docker CE.\n Install the NVIDIA Container Runtime group:\n ```bash\n sudo dnf group install -y --allowerasing 'NVIDIA Container Runtime'\n ```\n\n2. Reboot the system to load the drivers and to update system configurations.\n 1. Reboot the system.\n ```bash\n sudo reboot\n ```\n 2. After the system reboots, verify that the drivers are loaded and are handling the NVIDIA devices.\n ```bash\n nvidia-smi\n ```\n\n The output shows all available GPUs.\n\n **Example Output**\n\n ```plaintext\n +-----------------------------------------------------------------------------------------------+\n | NVIDIA-SMI 535.86.10 Driver Version: 535.86.10 CUDA Version: 12.2 |\n +-----------------------------------------------------------------------------------------------+\n | GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n | Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n +-----------------------------------------------------------------------------------------------+\n | 0 Tesla V100-SXM2... On | 00000000:06:00.0 Off | 0 |\n | N/A 35C P0 42W / 300W | 0MiB / 16160MiB | 0% Default |\n +-----------------------------------------------------------------------------------------------+\n | 1 Tesla V100-SXM2... On | 00000000:07:00.0 Off | 0 |\n | N/A 35C P0 44W / 300W | 0MiB / 16160MiB | 0% Default |\n +-----------------------------------------------------------------------------------------------+\n ```\n\n (continues on next page)\n3. Run the following command to verify the installation:\n\n```bash\nsudo docker run --gpus=all --rm nvcr.io/nvidia/cuda:12.2.0-base-ubi8 nvidia-smi\n```\n\nThe output shows all available GPUs.\n\nFor information about `nvcr.io`, refer to the NGC Private Registry User Guide.\n\n### 4.5.2. Installing and Running Podman\n\nTo run an NVIDIA container with Podman:\n\n1. Install Podman.\n ```bash\n sudo dnf install podman\n ```\n\n2. Install the `nvidia-container-toolkit-base` package.\n ```bash\n sudo dnf clean expire-cache && sudo dnf install -y nvidia-container-toolkit-base\n ```\n\n3. Check the NVIDIA Container Toolkit version.\n ```bash\n nvidia-ctk --version\n ```\n\n4. Generate the Container Device Interface (CDI) specification file.\n ```bash\n sudo nvidia-ctk cdi generate --output=/etc/cdi/nvidia.yaml\n ```\n\n The sample command uses sudo to ensure that the file at `/etc/cdi/nvidia.yaml` is created. You can omit the `--output` argument to print the generated specification to STDOUT.\n5. Verify that the GPU drivers are loaded and are handling the NVIDIA devices.\n \n ```\n nvidia-smi -L\n ```\n\n6. Run the following command to verify the installation.\n \n ```\n sudo podman run --rm --device nvidia.com/gpu=all ubuntu nvidia-smi -L\n ```\n\n7. Verify your installation by running a sample container with Podman.\n \n ```\n podman run --security-opt=label:disable --rm --device nvidia.com/gpu=all ubuntu -v nvidia-smi\n ```\n\n### 4.6. Installing Optional Components\n\nThe DGX is fully functional after installing the components as described in [Installing Required Components](#). If you intend to launch NGC containers (which incorporate the CUDA toolkit, NCCL, cuDNN, and TensorRT) on the DGX system, which is the expected use case, then you can skip this section.\n\nIf you intend to use your DGX as a development system for running deep learning applications on bare metal, then install the optional components as described in this section. Install CUDA Toolkit 12.2 packages (see [Installing the NVIDIA CUDA Driver from the Local Repository](#))\n\n```\nsudo dnf install -y cuda-toolkit-12-2 cuda-compat-12-2 nvidia-cuda-compat-setup\n```\n\n**Note:** The output of `nvidia-smi` shows the version of CUDA that is native-compatible with the installed driver (e.g. \"NVIDIA-SMI 535.86.10 Driver Version: 535.86.10 CUDA Version: 12.2\" in the prior steps). It is recommended to install the CUDA toolkit and compatible packages which match this version.\n\n- To install the NVIDIA Collectives Communication Library (NCCL) Runtime, refer to the [NCCL:Getting Started](#) documentation\n ```\n sudo dnf group install -y 'NVIDIA Collectives Communication Library Runtime'\n ```\n- To install the CUDA Deep Neural Networks (cuDNN) Library Runtime, refer to the [NVIDIA cuDNN](#) page.\n ```\n sudo dnf group install -y 'CUDA Deep Neural Networks Library Runtime'\n ```\n- To install NVIDIA TensorRT, refer to the [NVIDIA TensorRT](#) page.\n4.7. Installing NVIDIA GPUDirect Storage\n\n4.7.1. Prerequisites\n\n▶ For systems other than NVIDIA DGX-1, DGX-2, and DGX Station, to use the latest GDS version, 12.2.2-1, that is provided by nvidia-fs-dkms-2.17.5-1, you must install an NVIDIA Open GPU Kernel module driver. Refer to Installing the GPU Driver for more information about installing the driver.\n\n▶ For NVIDIA DGX-1, DGX-2, and DGX Station running the generic Linux Kernel, the GPUs in these systems are not supported with the NVIDIA Open GPU Kernel modules. The GDS versions 12.2.2-1 and higher only support the Open GPU Kernel modules.\n\nFor these systems, you must lock the nvidia-fs package to version 2.17.3 or lower and the nvidia-gds package to version 12.2.1-1 or lower.\n\n```\nsudo dnf install python3-dnf-plugin-versionlock\nsudo dnf versionlock add nvidia-fs-0:2.17.3-1 nvidia-fs-dkms-0:2.17.3-1 nvidia-\ngds-0:12.2.1-1\n```\n\nExample Output\n\n```\nAdding versionlock on: nvidia-fs-0:2.17.3-1.*\nAdding versionlock on: nvidia-gds-0:12.2.1-1.*\n```\n\n4.7.2. Procedure\n\nTo install NVIDIA GPUDirect Storage (GDS), perform the following steps.\n\n1. Install the kernel headers and development packages for your kernel.\n\n```\nsudo dnf install -y kernel-headers-$(uname -r) kernel-devel-$(uname -r)\n```\n\n2. Install the GDS package.\n\n```\nsudo dnf install -y nvidia-gds\n```\n\nRefer to Verifying a Successful GDS Installation in the NVIDIA GPUDirect Storage Installation and Troubleshooting Guide.\n\n4.8. Installing the Optional NVIDIA Desktop Theme\n\nThe DGX Software Repository also provides optional theme packages and desktop wallpapers to give the user-interface an NVIDIA look-and-feel for the DGX Station desktop. These packages would have been installed as part of the DGX Station Configurations group.\n\n1. To apply the theme and background images, first open gnome-tweaks.\n2. Under Applications, select one of the NV-Yaru themes. This comes in default, light, and dark variations.\n\n If this field is grayed out, you might need to reboot the system or restart GDM in order to enable the user-themes extension.\n\n4. To restart GDM, issue the following.\n \n ```bash\n sudo systemctl restart gdm\n ```\n\n5. Select one of the NVIDIA wallpapers for the background image and lock screen.\nChapter 5. Installing on “Air-Gapped” Systems\n\nFor security purposes, some installations require that systems be isolated from the internet or outside networks. Since most DGX software updates are accomplished through an over-the-network process with NVIDIA servers, this section explains how updates can be made when using an over-the-network method is not an option. It includes a process for installing containers as well.\n\n5.1. Registering Your System\n\nSee the Red Hat customer portal knowledge base article [How to register and subscribe a system offline to the Red Hat Customer Portal](#).\n\n5.2. Creating a Local Mirror of the NVIDIA Repository\n\nInstructions for setting up a private repository or mirroring the NVIDIA and the Red Hat repositories are beyond the scope of this document. It is expected that users are knowledgeable about those processes.\n\nThe Red Hat customer portal provides a knowledge base article for [creating a local mirror](#). Pay particular attention to the instructions under Create a local repo with Red Hat Enterprise Linux 9. The reposync command can now download repository metadata as well, so there is no longer a need to use createrepo after.\n\nThe repositories that will need to be mirrored are:\n\n- `rhel-9-for-x86_64-appstream-rpms`\n- `rhel-9-for-x86_64-baseos-rpms`\n- `codeready-builder-for-rhel-9-x86_64-rpms`\n- `nvidia-dgx-9`\n- `CUDA`\n\nOnce mirrored, be sure to configure the target system to use your local repository. This can be accomplished by creating file under `/etc/yum.repos.d/my_mirror.repo` with the following contents:\nNVIDIA DGX Software for Red Hat Enterprise Linux 9\n\n[nvidia-dgx-9]\nname=NVIDIA DGX EL9\nbaseurl=file://path/to/your/nvidia-dgx-9-repo-mirror/\nenabled=1\ngpgcheck=1\ngpgkey=file://etc/pki/rpm-gpg/RPM-GPG-KEY-dgx-cosmos-support\n\n[CUDA]\nname=NVIDIA CUDA for EL9\nbaseurl=file://path/to/your/CUDA-repo-mirror/\nenabled=1\ngpgcheck=1\ngpgkey=file://etc/pki/rpm-gpg/RPM-GPG-KEY-cuda\n\n**Note:** The instructions assume that you have the repositories enabled on the local machine. See [Enabling the DGX Software Repository](#) for instructions on enabling the NVIDIA DGX EL8 repository.\n\nThe CUDA repository makes use of modularity streams. If mirroring onto a Red Hat Enterprise Linux 9 (or Fedora) system, it’s possible to synchronize the modularity metadata in a single command:\n\n```\nreposync -p /path/to/your/mirror/ --repoid=CUDA --download-metadata --downloadcomps\n```\n\nHowever, if you are mirroring the CUDA repository onto another distribution (for example Ubuntu, CentOS 7, Red Hat Enterprise Linux 7) then you will have to manually generate the repository metadata:\n\n```\nreposync -p /path/to/your/mirror/ --repoid=CUDA --downloadcomps\ncreatererepo -v /path/to/your/mirror/\npython3 genmodules.py /path/to/your/mirror/ /tmp/modules.yaml\nmodifypkg /tmp/modules.yaml /path/to/your/mirror/repodata/\n```\n\nNote that you can find the genmodules.py script from NVIDIA’s yum-packaging-precompiled-kmod repository on GitHub:\n\nhttps://github.com/NVIDIA/yum-packaging-precompiled-kmod\n\n### 5.3. Installing Docker Containers\n\nThis method applies to Docker containers hosted on the NGC Container Registry. Most container images are freely available, but some are locked and require that you have an NGC account to access. See the [NGC Private Registry User Guide](#) for instructions on accessing locked container images.\n\n1. Enter the docker pull command, specifying the image registry, image repository, and tag.\n\n```\ndocker pull nvcr.io/nvidia/repository:tag\n```\n\n2. Verify the image is on your system using docker images.\n\n```\ndocker images\n```\n\n3. Save the Docker image as an archive.\n\n```\ndocker save nvcr.io/nvidia/repository:tag > framework.tar\n```\n4. Transfer the image to the air-gapped system using removable media such as a USB flash drive.\n\n5. Load the NVIDIA Docker image.\n\n `docker load -i framework.tar`\n\n6. Verify the image is on your system.\n\n `docker images`\nChapter 6. Installing with Local Repositories\n\nAs an alternative to the method described in Creating a Local Mirror of the NVIDIA Repository, the DGX software can also be installed using local repositories. These repositories are provided by NVIDIA for installing the required packages from local repositories, allowing installation of packages without network access.\n\n6.1. Installing the Base Red Hat Enterprise Linux System\n\nThe Red Hat components of the software must be installed either using the standard network based installation, or as described in Installing on \"Air-Gapped\" Systems. This includes registering and subscribing to the Red Hat Customer Portal.\n\nIf the system is connected to the network, follow the steps of the standard Red Hat Enterprise Linux installation, then enable the additional Red Hat repositories. Finally, execute:\n\n```\nsudo dnf update -y\nsudo dnf install -y kernel-devel kernel-headers\nsudo reboot\n```\n\nIf the system is not connected to the network, follow the instructions in Creating a Local Mirror of the NVIDIA Repository.\n\n6.2. Downloading the Local Repositories\n\nDownload the packages that apply to your release.\n## 6.2.1. Release 24.06\n\n<table>\n<thead>\n<tr>\n<th>Repository</th>\n<th>URL</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>DGX Software local repository</td>\n<td>dgx-local-repo-24.06-3.el9.x86_64.rpm</td>\n</tr>\n<tr>\n<td>NVIDIA CUDA driver local repository</td>\n<td>nvidia-driver-local-repo-rhel9-550.90.07-1.0-1.x86_64.rpm</td>\n</tr>\n<tr>\n<td>NVIDIA CUDA Toolkit local repository</td>\n<td>cuda-repo-rhel9-12-4-local-12.4.1_550.54.15-1.x86_64.rpm</td>\n</tr>\n</tbody>\n</table>\n\n## 6.2.2. Release 23.12\n\n<table>\n<thead>\n<tr>\n<th>Repository</th>\n<th>URL</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>DGX Software local repository</td>\n<td>dgx-local-repo-23.12-3.el9.x86_64.rpm</td>\n</tr>\n<tr>\n<td>NVIDIA CUDA driver local repository</td>\n<td>nvidia-driver-local-repo-rhel9-535.129.03-1.0-1.x86_64.rpm</td>\n</tr>\n<tr>\n<td>NVIDIA CUDA Toolkit local repository</td>\n<td>cuda-repo-rhel9-12-2-local-12.2.2_535.104.05-1.x86_64.rpm</td>\n</tr>\n</tbody>\n</table>\n\n## 6.2.3. Release 23.08\n\n<table>\n<thead>\n<tr>\n<th>Repository</th>\n<th>URL</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>DGX Software local repository</td>\n<td>dgx-local-repo-23.08-11.el9.x86_64.rpm</td>\n</tr>\n<tr>\n<td>NVIDIA CUDA driver local repository</td>\n<td>nvidia-driver-local-repo-rhel9-535.104.05-1.0-1.x86_64.rpm</td>\n</tr>\n<tr>\n<td>NVIDIA CUDA Toolkit local repository</td>\n<td>cuda-repo-rhel9-12-2-local-12.2.2_535.104.05-1.x86_64.rpm</td>\n</tr>\n</tbody>\n</table>\n\n## 6.2.4. Release 23.01\n\n<table>\n<thead>\n<tr>\n<th>Repository</th>\n<th>URL</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>DGX Software local repository</td>\n<td>dgx-local-repo-23.01-14.el9.x86_64.rpm</td>\n</tr>\n<tr>\n<td>NVIDIA CUDA driver local repository</td>\n<td>nvidia-driver-local-repo-rhel9-525.105.17-1.0-1.x86_64.rpm</td>\n</tr>\n<tr>\n<td>NVIDIA CUDA Toolkit local repository</td>\n<td>cuda-repo-rhel9-12-1-local-12.1.1_530.30.02-1.x86_64.rpm</td>\n</tr>\n</tbody>\n</table>\n6.3. Installing the Local Repositories\n\nInstall the local repositories:\n\n```\nsudo dnf install -y ./dgx-local-repo-24.06-3.el9.x86_64.rpm\nsudo dnf install -y ./nvidia-driver-local-repo-rhel9-535.183.01-1.0-1.x86_64.rpm\nsudo dnf install -y ./cuda-repo-rhel9-12-2-local-12.2.2_535.104.05-1.x86_64.rpm\n```\n\nWith the local repositories installed, proceed with the standard Installing the DGX Software instructions, with the exception of the CUDA driver installation. To install the CUDA driver from the local repository, follow the steps in the next section Installing the NVIDIA CUDA Driver from the Local Repository.\n\n6.4. Installing the NVIDIA CUDA Driver from the Local Repository\n\n▶ For non-NVSwitch systems, such as DGX-1, DGX Station, and DGX Station A100, install the driver using the default profile:\n\n```\nsudo dnf module install -y nvidia-driver:535-dkms\nsudo dnf install -y --allowerasing nv-persistence-mode libnvidia-nscq-535\n```\n\n▶ For NVSwitch systems, such as DGX-2, DGX A100, and DGX A800, install the driver using the fabric manager (fm) profile:\n\n```\nsudo dnf module install -y nvidia-driver:535-dkms/fm\nsudo dnf install -y nv-persistence-mode nvidia-fm-enable\n```\n\n▶ For DGX H100, install the DKMS version of the driver using the fabric manager (fm) profile:\n\n```\nsudo dnf module install -y nvidia-driver:535-dkms/fm\nsudo dnf install -y nv-persistence-mode nvidia-fm-enable\n```\nChapter 6. Installing with Local Repositories\nChapter 7. Installing NVIDIA MLNX_OFED\n\nThe DGX software stack for Red Hat Enterprise Linux does not include the NVIDIA MLNX_OFED (OpenFabrics Enterprise Distribution) for Linux. This is to ensure that the MLNX_OFED driver is in sync with the Red Hat distribution kernel. This section describes how to download, install, and upgrade MLNX_OFED on systems that are running Red Hat Enterprise Linux.\n\n7.1. Prerequisites\n\n- NVIDIA validates each release of NVIDIA DGX Software for Red Hat Enterprise Linux with a specific MLNX_OFED version. Refer to the Release Notes for the recommended MLNX_OFED version to install.\n\n7.2. Installing and Configuring MLNX_OFED\n\nThis section describes how to install MLNX_OFED on systems that do not yet have it installed. It is imperative that a validated MLNX_OFED version is used for the RHEL version that the DGX system is running.\n\n**Important:** Running the `dnf update` command at any time to install the drivers can update the system to the latest Red Hat Enterprise Linux version.\n\n1. Determine which version of Red Hat Enterprise Linux is installed on the DGX system.\n\n ```bash\ncat /etc/redhat-release\n ```\n\n2. After referring to the release notes, download the MLNX_OFED software bundle.\n 1. Go to the Linux InfiniBand Drivers page, and scroll down to the MLNX_OFED Download Center matrix.\n2. At the **MLNX_OFED Download Center** matrix, choose the MLNX_OFED version, OS distribution and distribution version, and architecture to show the software package and documentation. For example,\n\n- **Version**: 23.10-1.1.9.0-LTS\n- **OS Distribution**: RHEL/CentOS/Rocky\n- **OS Distribution Version**: RHEL/Rocky 9.2\n- **Architecture**: x86_64\n\n3. Click the supported ISO or tgz package.\n\nThe **Mellanox OFED (MLNX_OFED) Software: End-User Agreement** page appears.\n\n4. Accept the End User License Agreement by clicking **I Have Read the Above End User License Agreement**.\n\nThe selected software package starts to download.\n3. After downloading the correct MLNX_OFED software package, proceed with the installation steps.\n\nFor issues during RHEL 9.2 install using MODEF mlnxofedinstall, refer to the Known Issues MOFED mlnxofedinstall reports \"Current operation system is not supported\" using RHEL 9.2.\n\n1. Go to the MLNX_OFED Software Releases site and select the MLNX_OFED software version that you downloaded.\n\n2. Click the User Manual link and then navigate to Installation > Installing MLNX_OFED.\n\nFollow the installation instructions.\n\n**Note:** The system might report that additional software needs to be installed before performing the installation. If such a message appears, install the software and then retry installing the MLNX_OFED driver.\n\n4. If you intend to use NVIDIA GPUDirect Storage (GDS), enable the driver’s GDS support according to the instructions at MLNX_OFED Requirements and Installation.\n\n5. Install nvidia-mlnx-config.\n\n ```bash\n sudo dnf install -y nvidia-mlnx-config\n ```\n\n6. Install kernel headers and development packages for your kernel.\n\n These are needed for the ensuing DKMS compilation.\n\n ```bash\n sudo dnf install -y kernel-headers-$(uname -r) kernel-devel-$(uname -r)\n ```\n\n7. After installing the MLNX_OFED drivers, install the NVIDIA peer memory module.\n\n ```bash\n sudo dnf install -y nvidia-peer-memory-dkms\n ```\n\n**Note:** nvidia-peer-memory-dkms version 1.2 or later, requires MOFED version 5.4-3.0.3.0 or later. Using MOFED versions that do not fit this criteria will result in a build failure of the nv_peer_mem DKMS\nmodule. For more information, see: https://github.com/Mellanox/nv_peer_memory/issues/94#\n\n**Note:** While in-box drivers might be available, using the in-box drivers is not recommended as they provide lower performance than the official MLNX OFED drivers and they do not support the GPUDirect™ RDMA feature. For more information on configuring the in-box drivers, see the following Red Hat Enterprise Linux documentation: Configuring InfiniBand and RDMA Networks.\n\n### 7.3. Updating NVIDIA MLNX_OFED\n\nThis section describes how to update MOFED on systems that already have it installed. The Mellanox InfiniBand Drivers in RPM packages are precompiled for a specific kernel version. Again – it is imperative that the correct MOFED version is used for the RHEL version that the DGX system has been updated to. There is no need to uninstall the current MOFED first, because the “mlnxofedinstall” script will automatically uninstall any previously installed versions.\n\n1. Upgrade the Red Hat Enterprise Linux release and kernel version.\n ```bash\n sudo dnf update --nobest\n ```\n\n2. Determine which version of Red Hat Enterprise Linux is installed on the DGX system.\n ```bash\n cat /etc/redhat-release\n ```\n\n3. After referring to the release notes, download the MLNX_OFED software bundle.\n 1. Go to the [Linux InfiniBand Drivers](https://linuxinfinibanddrivers.com) page, and scroll down to the MLNX_OFED Download Center matrix.\n 2. At the MLNX_OFED Download Center matrix, choose the MLNX_OFED version, OS distribution and distribution version, and architecture to show the software package and documentation. For example,\n - **Version:** 23.10-1.1.9.0-LTS\n - **OS Distribution:** RHEL/CentOS/Rocky\n - **OS Distribution Version:** RHEL/Rocky 9.2\n - **Architecture:** X86_64\n3. Click the supported ISO or tgz package.\n\n The **Mellanox OFED (MLNX_OFED) Software: End-User Agreement** page appears.\n\n4. Accept the End User License Agreement by clicking **I Have Read the Above End User License Agreement**.\n\n The selected software package starts to download.\n\n4. Mount the downloaded ISO on the system. The following example shows the ISO being mounted on the /mnt directory.\n\n ```bash\n sudo mount MLNX_OFED_LINUX-<version>.iso /mnt\n ```\n\n5. Prepare to install the driver.\n\n 1. Remove `nvidia-mlnx-config` and `nvidia-peer-memory-dkms`.\n\n ```bash\n sudo dnf remove -y nvidia-mlnx-config nvidia-peer-memory-dkms\n ```\n\n The `mlnxofedinstall` step will remove packages prior to installing new ones, causing `nvidia-mlnx-config` and `nvidia-peer-memory-dkms` to fall out because they depend on some of these removed packages. Removing those components ahead of time avoids issues. These will be reinstalled as a final step.\n\n 2. Specify the new kernel version to use when installing the driver.\n\n ```bash\n NEXTKERNEL=$(sudo grubby --default-kernel | sed 's/.*vmlinuz-//g')\n ```\n\n6. Install the driver with the `-k` and `-s` flags to specify the new kernel version and kernel source path.\n\n ```bash\n sudo /mnt/mlnxofedinstall -k ${NEXTKERNEL} -s /lib/modules/${NEXTKERNEL}/build --force\n ```\n\n**Note:** Note: The system might report that additional software needs to be installed before performing the installation. If such a message appears, install the software and then repeat this step.\n\n---\n\n### 7.3. Updating NVIDIA MLNX_OFED\n\n---\n7. Reboot.\n\n```bash\nsudo reboot\n```\n\n\n```bash\nsudo dnf install -y nvidia-mlnx-config nvidia-peer-memory-dkms\n```\nChapter 8. Installing NVIDIA DOCA OFED\n\nThe NVIDIA DGX™ Software Stack for Red Hat Enterprise Linux does not include the NVIDIA DOCA™ OFED (OpenFabrics Enterprise Distribution) software for Linux. This is to ensure that the DOCA OFED software, a subset of the full DOCA package, is in sync with the Red Hat distribution kernel. This topic describes how to download, install, and upgrade the DOCA OFED software on systems that are running Red Hat Enterprise Linux.\n\n8.1. DOCA-Host Installation Profiles\n\nThe DOCA software package contains several subsets called the DOCA-Host installation profiles, which are fully validated and tested installation packages. The following table lists the available DOCA-Host profiles:\n\n<table>\n<thead>\n<tr>\n<th>DOCA-Host Profile</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>doca-ofed</td>\n<td>Allows you to install the same drivers and tools of MLNX_OFED using the DOCA-Host package, but without other DOCA functionality.</td>\n</tr>\n<tr>\n<td>doca-network</td>\n<td>Intended for users who want to use only the networking functionality of the DOCA-Host package.</td>\n</tr>\n<tr>\n<td>doca-all</td>\n<td>Intended for users who want to use the full extent of DOCA drivers and libraries, the full DOCA-Host installation.</td>\n</tr>\n</tbody>\n</table>\n\nFor more information, refer to NVIDIA DOCA Profiles.\n### 8.2. Prerequisites\n\n1. Before installing a different version of DOCA OFED software, you must remove the installed DOCA OFED or MLNX_OFED software on your system.\n\n - **Debian-based Linux**\n ```bash\n $ for f in $(dpkg --list | grep doca | awk '{print $2}'); do echo $f; sudo apt remove --purge $f -y; done\n \n $ sudo /usr/sbin/ofed_uninstall.sh --force\n ```\n\n - **RPM-based Linux**\n ```bash\n # Remove the installed DOCA OFED software from the host.\n for f in $(rpm -qa | grep -i doca); do sudo yum -y remove $f; done\n \n # Remove the installed MLNX_OFED software.\n sudo /usr/sbin/ofed_uninstall.sh --force\n sudo yum autoremove\n sudo yum makecache\n ```\n\n2. Download and install the NVIDIA RPM GPG key.\n\n 1. Download the NVIDIA RPM-GPG-KEY-Mellanox-SHA256 key.\n ```bash\n ```\n 2. Install the key.\n ```bash\n sudo rpm --import RPM-GPG-KEY-Mellanox-SHA256\n ```\n 3. Verify that the key was successfully imported.\n ```bash\n sudo rpm -q gpg-pubkey --qf '%{NAME}-%{VERSION}-%{RELEASE}\\t%{SUMMARY}\\n' | grep Mellanox\n ```\n\n### 8.3. Installation Steps\n\nThe DOCA-Host package includes drivers, libraries, and tools to support the NVIDIA® ConnectX®-7 adapter cards and the NVIDIA® BlueField®-3 DPUs:\n\n- **DGX Systems with NVIDIA ConnectX-7 Adapter Cards**\n- **DGX systems with BlueField-3 DPU in NIC Mode (Optional)**\n8.3.1. DGX Systems with NVIDIA ConnectX-7 Adapter Cards\n\nTo install the DOCA-Host package of the doca-ofed profile on the host,\n\n1. Open the Installation Files page, download the DOCA-Host installation file based on the OS and Arch options you want.\n Alternatively, you can download the installation file using the DOCA Downloads page.\n2. Unpack the RPM package.\n\n `sudo rpm -Uvh <repo_file>.rpm`\n\n3. Perform an update using the yum command.\n\n `sudo yum makecache`\n\n4. Determine if the kernel version on your host is supported as shown in Supported Host OS per DOCA-Host Installation Profile.\n If the kernel version is not supported, follow the instructions described in DOCA Extra Package.\n5. Run the yum install command for the doca-ofed profile installation.\n\n `sudo yum install -y doca-ofed`\n\n6. Re-create an initramfs image.\n\n `sudo dracut -f`\n\n7. Reboot the system.\n\n `sudo systemctl reboot`\n\n8. Register your new Red Hat Enterprise Linux system to the Customer Portal using Red Hat Subscription-Manager.\n\n For more information, refer to How to register and subscribe a RHEL system to the Red Hat Customer Portal using Red Hat Subscription-Manager?\n\nFor more information about the doca-ofed profile installation on the host, refer to Installing Software on Host.\n\n8.3.2. DGX systems with BlueField-3 DPU in NIC Mode (Optional)\n\nIf your system is equipped with the NVIDIA BlueField-3 DPU, ensure that the DPU is set in NIC mode (NIC Mode for BlueField-3) and then proceed with the following instructions.\n\n1. Install the RShim driver to manage and flash the BlueField-3 DPU.\n Follow the procedure described in Installing Prerequisites on Host for Target BlueField.\n ▶ Choose the procedure for the RPM-based Linux.\n2. Determine the BlueField-3 device ID.\n Follow the instructions described in Determining BlueField Device ID.\n\n3. Install the DOCA-Host software on the host.\n Follow the instructions for the selected DOCA-Host profile to install the DOCA drivers and tools as described in Installing Software on Host.\n\nAdditional Information\n\n► MFT download instructions: Updating Firmware for a Single Network Interface Card (NIC)\n► Changing BlueField-3 BMC default password: Changing Default Password\nChapter 9. Installing ConnectX-7 Firmware\n\nFollow these steps to update firmware for the ConnectX®-7 InfiniBand/Ethernet PCI Express Adapter Cards using the NVIDIA Networking Firmware Downloads Page.\n\n1. Navigate to the NVIDIA Networking Firmware Downloads page.\n2. From the ConnectX Adapter Cards Firmware table, select version ConnectX-7 and click the InfiniBand/Ethernet network protocol.\n\n<table>\n<thead>\n<tr>\n<th>ConnectX Adapter Cards Firmware</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Product Line</strong></td>\n</tr>\n<tr>\n<td>ConnectX-7</td>\n</tr>\n<tr>\n<td>ConnectX-6 DE</td>\n</tr>\n<tr>\n<td>ConnectX-6 Lx</td>\n</tr>\n<tr>\n<td>ConnectX-6 Dx</td>\n</tr>\n</tbody>\n</table>\n\nThe Firmware for ConnectX®-7 InfiniBand page opens.\n\n3. At the ConnectX-7 Firmware Download Center matrix, choose\n - The firmware version under CURRENT VERSIONS to install, such as 28.39.2048-LTS\n You might need to select a version under ARCHIVE VERSIONS, for example, 28.39.1002.\n - The OPN number of the ConnectX-7 adapter card\n For example, MCX75510AAS-NEA.\n4. Click the corresponding PSID number, for example, MT_00000000800, to show the firmware information and documentation.\n5. Click the ConnectX7IB link to download the firmware BIN file.\n\n6. After downloading the correct ConnectX-7 firmware, proceed with the installation steps. Alternatively, you can use the following methods to install the ConnectX-7 adapter card firmware:\n\n - **Using the mstflint tool**\n \n If you have installed the MTNIC Driver on your machine, you can update the firmware using the mstflint tool as described in the mstflint FW Burning Tool README. You can download the mstflint tool from the OpenFabrics site at mstflint_SW for Linux.\n\n - **Using the NVIDIA Firmware Tools (MFT)**\n \n For details, refer to Updating Firmware for a Single Network Interface Card (NIC).\nChapter 10. Installing BlueField-3 NIC Firmware\n\nFollow these steps to update firmware for the NVIDIA® BlueField®-3 DPUs in NIC mode using the NVIDIA Networking Firmware Downloads Page.\n\n1. Navigate to the NVIDIA Networking Firmware Downloads page.\n2. From the NVIDIA BlueField DPU Firmware table, select product line NVIDIA BlueField-3 and click the InfiniBand/Ethernet network protocol.\n\nThe Firmware for NVIDIA BlueField-3 page opens.\n\n3. On the NVIDIA BlueField-3 DPU Firmware Download Center matrix, display the firmware information and documentation.\n 1. Select the CURRENT VERSIONS tab.\n 2. Choose the Version (Current), OPN (ordering part number), and PSID options you want. For example,\n4. Click the BlueField3IB link to download the firmware BIN file.\n\n5. After downloading the correct BlueField-3 NIC firmware, proceed with the installation steps.\n\nTo learn more about the BlueField-3 firmware, refer to NVIDIA BlueField-3 DPU NIC Firmware Release Notes v32.41.1000\n\n10.1. Alternative Methods\n\nAlternatively, you can use the following methods to install the BlueField-3 NIC firmware:\n\n- Using the mstflint tool\n - If you have installed the MTNIC Driver on your system, you can update the firmware using the mstflint tool as described in the mstflint FW Burning Tool README.\n - To download the mstflint tool from the OpenFabrics site, refer to mstflint_SW for Linux.\n\n- Using the NVIDIA firmware tools (MFT)\n - To download MFT, refer to the MFT download page.\n - For installation details, refer to Updating Firmware for a Single Network Interface Card (NIC).\nChapter 11. Installing with Kickstart\n\nKickstart provides a method of automating the installation process by providing a file which contains the answers to the questions that would be asked during installation. NVIDIA provides kickstart templates for all supported platforms in the following locations:\n\n- https://repo.download.nvidia.com/baseos/el/el-files/9/el9-ks/dgx1-ks.cfg\n- https://repo.download.nvidia.com/baseos/el/el-files/9/el9-ks/dgx2-ks.cfg\n- https://repo.download.nvidia.com/baseos/el/el-files/9/el9-ks/dgx-a100-ks.cfg\n- https://repo.download.nvidia.com/baseos/el/el-files/9/el9-ks/dgx-a800-ks.cfg\n- https://repo.download.nvidia.com/baseos/el/el-files/9/el9-ks/dgx-h100-ks.cfg\n- https://repo.download.nvidia.com/baseos/el/el-files/9/el9-ks/dgxstation-a100-ks.cfg\n- https://repo.download.nvidia.com/baseos/el/el-files/9/el9-ks/dgxstation-a800-ks.cfg\n\nFor more information on using kickstart files with Red Hat 9, refer to the 27.2. How Do You Perform a Kickstart Installation? section in Red Hat documentation.\n\nIn these files are tags that you must replace with your site specific information: language, keyboard, timezone, hostname, etc.\n\nEach tag is of the form \"CHANGE_YOUR_xxxx\". These tags must be replaced with your specific information.\n\nOnce you have a kickstart file customized for your installation, place that file in a location that can be accessed by NFS, FTP, HTTP, or HTTPS.\n\nAfter booting from the installation medium, when the grub menu appears, press e to edit the grub entry as you normally would to add the \"nomodeset\" option. In addition to \"nomodeset\", add an option in the format \"inst.ks=<URL>\".\n\nFor example:\n\n```\ninst.ks=https://192.168.1.2/kickstart/dgx-a100-ks.cfg\n```\n\nLastly, after using these kickstart files – remember to reboot the system one final time to apply all settings.\nChapter 12. Configuring Storage\n\nBy default, the DGX System includes multiple SSDs in a RAID configuration (4 SSDs in the DGX-1, 8 or 16 SSDs in the DGX-2, and 3 SSDs in the DGX Station). These SSDs are intended for application caching, so NVIDIA recommends that you set up your own NFS storage for long term data storage. The following instructions describe how to mount the NFS onto the DGX System, and how to cache the NFS using the DGX SSDs for improved performance.\n\nMake sure that you have an NFS server with one or more exports with data to be accessed by the DGX System, and that there is network access between the DGX System and the NFS server.\n\n1. Install the NFS packages.\n\n $ sudo dnf install nfs-utils\n\n2. Configure an NFS mount for the DGX.\n a. Edit the filesystem tables configuration.\n\n sudo vi /etc/fstab\n\n b. Add a new line for the NFS mount, using the local mount point of /mnt.\n\n <nfs_server>:<export_path> /mnt nfs rw,noatime,rsize=32768,wsize=32768,nolock,tcp,intr,fsc,nofail 0 0\n\n /mnt is used here as an example mount point.\n\n Consult your Network Administrator for the correct values for <nfs_server> and <export_path>.\n\n The nfs arguments presented here are a list of recommended values based on typical use cases. However, “fsc” must always be included as that argument specifies use of FS-Cache.\n\n c. Save the changes.\n\n3. Verify the NFS server is reachable.\n\n ping <nfs_server>\n\n Use the server IP address or the server name provided by your network administrator.\n\n4. Mount the NFS export.\n\n sudo mount /mnt\n\n /mnt is the example mount point used in step 1.\n\n5. Verify caching is enabled.\ncat /proc/fs/nfsfs/volumes\n\nLook for the text FSC=yes in the output. The NFS will be mounted and cached on the DGX System automatically upon subsequent reboot cycles.\nChapter 13. Upgrading\n\nNVIDIA and Red Hat provide updates to the OS in the form of updated software packages between releases with security mitigations and bug fixes.\n\n**Important:** Here is some important information you need to know before upgrading:\n\n- An in-place upgrade from Red Hat Linux 8 to Red Hat Linux 9 with the DGX software stack installed is not supported.\n- Before you install or perform the upgrade, refer to the *Release Notes* section for the latest Red Hat Linux version, known issues, and workarounds.\n\n To remain at the same RHEL release and prevent incompatibility between Linux kernel and GPU drivers, pin the RHEL release by using the `subscription-manager release --set=<release>` command. For example, the `subscription-manager release --set=9.3` command ties the system to RHEL 9.3.\n\nYou should evaluate the available updates in regular intervals and update the system by using the `sudo dnf update --nobest` command.\n\nFor a list of the known Common Vulnerabilities and Exposures (CVEs), including those that can be resolved by updating the OS software, refer to the *Red Hat Security Updates*\n\n**Note:** You are responsible for upgrading the software on the DGX system to install the updates from these sources.\n\nIf updates are available, you can obtain the package upgrades by running:\n\n```\nsudo dnf update -nobest\n```\n\nUpgrades to the NVIDIA Graphics Drivers for Linux requires a restart to complete the kernel upgrade. If you upgrade the NVIDIA Graphics Drivers for Linux without restarting the DGX system, when you run the `nvidia-smi` command, an error message is displayed.\n\n```\nnvidia-smi\nFailed to initialize NVML: Driver/library version mismatch\n```\n13.1. Upgrading the OS and DGX Software\n\nThis section provides information for upgrading your DGX system and optionally upgrading to a different GPU branch.\n\n13.1.1. Upgrading the Software without Moving to a New Driver Branch\n\nTo upgrade your DGX system with the latest Red Hat Linux upgrades, run the following command:\n\n```\nsudo dnf update -y --nobest\n```\n\n13.1.2. Updating the Software and Moving to a New Driver Branch on non-NVSwitch Systems\n\nThis procedure applies to DGX-1, DGX-2, DGX Station, and DGX Station A100 systems.\n\n1. Issue the following to remove the current driver package and install the new driver package.\n\n```\nsudo dnf remove -y nv-persistence-mode libnvidia-nscq-<current driver version>\nsudo dnf module remove --all -y nvidia-driver\nsudo dnf module reset -y nvidia-driver\nsudo dnf module install -y nvidia-driver:<new driver version>{default,src}\nsudo dnf install -y nv-persistence-mode libnvidia-nscq-<new driver version>\nsudo dnf update -y --nobest\n```\n\n1. For DGX Station A100 only - Install additional required DGX Station A100 packages. These packages must be installed after the nvidia-driver module. sudo dnf install nvidia-conf-xconfig nv-docker-gpus\n\n```\nsudo dnf install nvidia-conf-xconfig nv-docker-gpus\n```\n\n2. Reboot the system.\n\n```\nsudo reboot\n```\n\n13.1.3. Updating the Software and Moving to a New Driver Branch on NVSwitch Systems\n\nThis procedure applies to DGX-2, DGX A100, and DGX A800 systems.\n\n1. Run the following commands to remove the current driver package and install the new driver package:\nsudo dnf remove -y nv-persistence-mode libnvidia-nscq-<current driver version> nvidia-...fm-enable\nsudo dnf module remove --all -y nvidia-driver\nsudo dnf module reset -y nvidia-driver\nsudo dnf module install -y nvidia-driver:<new driver version>/{fm,src}\nsudo dnf install -y nv-persistence-mode libnvidia-nscq-<new driver version> nvidia-fm-enable\nsudo dnf update -y --nobest\n\n1. Reboot the system.\n\n sudo reboot\n\n13.2. Changing only the NVIDIA Driver Branch\n\nTo switch driver branches, you must first remove the existing branch before installing the new branch:\n\n1. Remove and clear the existing stream:\n\n sudo dnf module remove --all nvidia-driver\n sudo dnf module reset nvidia-driver\n\n2. Follow the “Install NVIDIA CUDA driver” section to install the new driver branch.\n\n3. If the nvidia-peer-memory-dkms driver is installed it must be reinstalled to match the new driver branch:\n\n sudo dnf reinstall -y nvidia-peer-memory-dkms\n\n13.3. Installing or Upgrading to a Newer CUDA Toolkit Release\n\n**Important:** Before you install or upgrade to any CUDA Toolkit release, ensure the release is compatible with the driver that is installed on the system. Refer to CUDA Compatibility for more information and a compatibility matrix.\n\nOnly DGX Station and DGX Station A100 have a CUDA Toolkit release installed by default. DGX servers are intended to be shared resources that use containers and do not have CUDA Toolkit installed by default. However, you have the option to install a qualified CUDA Toolkit release.\n\nAlthough all CUDA Toolkit releases are supported that interoperate with the installed driver, DGX releases might include a default CUDA Toolkit release that might not be the most recently released version. Unless you must use a new CUDA Toolkit version that contains the new features, we recommend that you remain on the default version that is included in the DGX RHEL9 release. Refer to the *Release Notes* for the default CUDA Toolkit release.\n13.3.1. Checking the Currently Installed CUDA Toolkit Release\n\nHere is some information about the prerequisite to determine the CUDA Toolkit release that you currently have installed.\n\n**Important:** The CUDA Toolkit is not installed on DGX servers by default, and if you try to run the following command, no installed package will be listed.\n\nBefore you install a new CUDA Toolkit release, to check the currently installed release, run the following command:\n\n```\nsudo dnf list installed \"cuda-toolkit-*\"\n```\n\nThe following output shows that CUDA Toolkit 12.0 is installed:\n\n```\nUpdating Subscription Management repositories.\n\nInstalled Packages\ncuda-toolkit-12-0.x86_64 12.0.0-1 @CUDA\ncuda-toolkit-12-0-config-common.noarch 12.0.107-1 @CUDA\ncuda-toolkit-12-config-common.noarch 12.0.107-1 @CUDA\ncuda-toolkit-config-common.noarch\n```\n\n13.3.2. Determining the New Available CUDA Toolkit Releases\n\nThese steps help you determine which new CUDA Toolkit releases are available. To see the new available CUDA Toolkit releases:\n\n```\nsudo dnf search \"cuda-toolkit-*\"\n```\n\nThe following output shows that 11.7, 11.8, and 12.0 are the possible CUDA Toolkit versions that can be installed.\n13.3.3. Installing the CUDA Toolkit or Upgrading Your CUDA Toolkit to a Newer Release\n\nYou can install or upgrade your CUDA Toolkit to a newer release.\n\nTo install or upgrade the CUDA Toolkit, run the following command:\n\n```\nsudo dnf install cuda-toolkit-12-0\n```\n\n**Note:** Version 12.0 is shown as an example - replace the value with the version you wish to install.\n\n13.4. Installing GPUDirect Storage Support\n\nNVIDIA® Magnum IO GPUDirect® Storage (GDS) enables a direct data path for direct memory access (DMA) transfers between GPU memory and storage, which avoids a bounce buffer through the CPU.\n\n13.4.1. Installing nvidia-gds\n\nTo use GDS, perform the following steps:\n\n1. Populate the `$NVIDIA_DRV_VERSION` variable\n2. Install `nvidia-gds` with the correct dependencies:\n\n```\nsudo install nvidia-gds-{ver} nvidia-dkms-$(NVIDIA_DRV_VERSION)-server\n```\n\nUse the CUDA Toolkit version number in place of `<ver>`; for example, `12-0`\nChapter 14. Managing Self-Encrypting Drives\n\nThe NVIDIA DGX OS software supports the ability to manage self-encrypting drives (SEDs), including setting an Authentication Key for locking and unlocking the drives on NVIDIA DGX H100, DGX A100, DGX A800, DGX Station A100, and DGX-2 systems.\n\nYou can manage only the SED data drives. The software cannot be used to manage OS drives even if they are SED-capable.\n\n14.1. Overview\n\nThe SED management software is in the `nv-disk-encrypt` package.\n\nThe software supports the following configurations:\n\n- NVIDIA DGX H100, DGX A100, DGX A800, DGX Station A100, and DGX-2 systems where all data drives are self-encrypting drives.\n- Only SEDs used as data drives are supported.\n The software will not manage SEDs that are OS drives.\n\nThe software provides the following functionality:\n\n- Identifies eligible drives on the system.\n- Allows you to assign Authentication Keys (passwords) for each SED as part of the initialization process.\n - Alternatively, the software can generate random passwords for each drive.\n - The passwords are stored in a password-protected vault on the system.\n- Once initialized, SEDs are locked upon power loss, such as a system shutdown or drive removal.\n Locked drives get unlocked after power is restored and the root file system is mounted.\n- Provides functionality to export the vault.\n- Provides functionality for erasing the drives.\n- Provides the ability to revert the initialization.\n14.2. Installing the Software\n\nUse the package manager to install the nv-disk-encrypt package and, optionally, the TPM2 tools package, and reboot the system. You need the TPM tools package if you plan to use the TPM2 to store security keys.\n\n1. Update the packages.\n ```\n sudo dnf update\n ```\n\n2. Install nv-disk-encrypt.\n ```\n sudo dnf install -y nv-disk-encrypt\n ```\n\n3. (Optional) Install the TPM tools package.\n - For DGX A100, DGX A800, DGX Station A100, or DGX H100, install the tpm2-tools package.\n ```\n sudo dnf install -y tpm2-tools\n ```\n - For DGX-2, install the tpm-tools package.\n ```\n sudo dnf install -y tpm-tools\n ```\n\n4. Reboot.\n ```\n sudo reboot\n ```\n\nIf you plan to use TPM2, enable it. Refer to *Configuring Trusted Computing* for more information.\n\n14.3. Configuring Trusted Computing\n\nHere is some information about the controls that are required to configure Trusted Computing (TC).\n\nThe DGX H100 system BIOS provides setup controls for configuring the following TC features:\n\n- **Trusted Platform Module**\n The NVIDIA DGX H100, DGX A100, DGX A800, and DGX Station A100 incorporate Trusted Platform Module 2.0 (TPM 2.0). The DGX-2 incorporates a TPM module. These modules can be enabled from the system BIOS and used in conjunction with the nv-disk-encrypt tool. After being enabled, the nv-disk-encrypt tool uses the TPM for encryption and stores the vault and SED authentication keys on the TPM instead of on the file system. Using the TPM is preferred because this allows the vault data to persist even if the system is reimaged.\n\n- **Block SID**\n Certain drives shipped with the DGX systems support the Block SID authentication feature. Block SID authentication prevents malicious actors from taking ownership of drives and blocks others from using the drives. By default, the DGX BIOS will send the Block SID request. On such setups, you will need to enable the Disable Block Sid feature in the BIOS before proceeding with the initialization steps.\nNote: Enabling the “Disable Block SID” option is only valid for one reboot, so if drive encryption needs to be enabled again, then the feature needs to be enabled in BIOS as well.\n\n14.3.1. Determining Whether Drives Support SID\n\nThe drive model is a good indicator of whether the drive supports this feature. Issue the following and look for one of the following model strings:\n\n- KCM6DRUL3T84\n- KCM6DRUL7T68\n- MZQLB7T6HMLA-00007\n\n```\nsudo nvme list\n```\n\n<table>\n<thead>\n<tr>\n<th>Node</th>\n<th>SN</th>\n<th>Model</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>/dev/nvme0n1</td>\n<td>70H0A0AHTTHR</td>\n<td>KCM6DRUL3T84...</td>\n</tr>\n<tr>\n<td>/dev/nvme1n1</td>\n<td>70H0A007TTHR</td>\n<td>KCM6DRUL3T84...</td>\n</tr>\n</tbody>\n</table>\n\n14.3.2. Enabling the TPM and Preventing the BIOS from Sending Block SID Requests\n\nThis section provides instructions to enable the TPM and prevent the SBIOS from sending Block SID request. Each task is independent, so you can select which task to complete.\n\n1. Reboot the system, then press [Del] or [F2] at the NVIDIA splash screen to enter the BIOS Setup.\n2. Navigate to the Advanced tab on the top menu, then scroll to Trusted Computing and press [Enter].\nTo enable TPM, scroll to Security Device and switch the setting to Enabled.\n\nTo disable Block SID, go to the Security tab to the right, and scroll to Disable Block Sid, then switch to Enabled.\n3. Save and exit the BIOS Setup to continue the boot process.\n\nIf you disabled Block SID, you will be prompted to accept the request to disable issuing a Block SID Authentication command.\n\n4. Press F10 at the prompt. After the system boots, you can proceed to initialize drive encryption.\n14.4. Initializing the System for Drive Encryption\n\nHere is some information about how to initialize the system for drive encryption.\n\nNote: Before initializing drive encryption, review the information in Configuring Trusted Computing and follow the configuration instructions if needed.\n\nInitialize the system for drive encryption using the `nv-disk-encrypt` command.\n\n```bash\nsudo nv-disk-encrypt init [-k <your-vault-password>] [-f <path/to/json-file>] [-g] [-r]\n```\n\nHere is a list of the options:\n\n- `-k`: Lets you create the vault password in the command. Otherwise, the software will prompt you to create a password before proceeding.\n- `-f`: Lets you specify a JSON file that contains a mapping of passwords to drives. Refer to “Example 1: Passing in the JSON File” for further instructions.\n- `-g`: Generates random salt values (stored in `/etc/nv-disk-encrypt/.dgxenc.salt`) for each drive password. Salt values are characters added to a password for enhanced password security. NVIDIA strongly recommends using this option for best security, otherwise the software will use a default salt value instead of a randomly generated one.\n- `-r`: Generates random passwords for each drive. This avoids the need to create a JSON file or the need to enter a password one by one during the initialization.\n\n14.5. Enabling Drive Locking\n\nAfter initializing the system for SED management, issue the following command, which uses the `nv-disk-encrypt` command to enable drive locking.\n\n```bash\nsudo nv-disk-encrypt lock\n```\n\nAfter initializing the system and enabling drive locking, the drives will become locked when they lose power. The system will automatically unlock each drive when power is restored to the system and the system is rebooted.\n14.6. Initialization Examples\n\nThis section provides some initialization examples.\n\n14.6.1. Example 1: Passing in the JSON File\n\nThe following instructions in this section describe a method to specify the drive/password mapping ahead of time. This method is useful for initializing several drives at a time and avoids the need to enter the password for each drive after issuing the initialization command, or if you want control of the passwords.\n\nRefer to the following for more information:\n- Determining Which Drives Can be Managed as Self-Encrypting\n- Creating the Drive/Password Mapping JSON Files and Using it to Initialize the System\n\n14.6.1.1 Determining Which Drives Can be Managed as Self-Encrypting\n\nHere is some information about how you can determine which drives can be managed as self-encrypting.\n\nReview the storage layout of the DGX system to determine which drives are eligible to be managed as SEDs.\n\n```\nsudo nv-disk-encrypt info\n```\n\nThe default output shows which drives can be used for encryption and which drives cannot. The following status information is provided:\n- SED capable: Is this a self-encrypting drive?\n- Boot disk: Is this drive currently being used as a boot drive? Does it contain the root filesystem?\n- Locked: Is this drive currently in the locked state? Is it able to accept I/O?. It can only be in this state after the following conditions have been met:\n - Locking has been enabled (nv-disk-encrypt init, followed by `nv-disk-encrypt init lock`)\n - The drive is coming back from power-off.\n - The user queries this state prior to it being (automatically) unlocked.\n- Lock Enabled: Are locks enabled on this drive? It will be in this state after initialization (`nv-disk-encrypt init`).\n- MBR done: This setting is only relevant for drives that support MBR shadowing. On drives that support this feature, this will report ‘Y’ after initialization (`nv-disk-encrypt init`).\n\nMBR done: This setting is only relevant for drives that support MBR shadowing. On drives that support this feature, this will report ‘Y’ after initialization (`nv-disk-encrypt init`).\n\nThe following example output snippet shows drives that can be used for encryption. Notice SED capable = Y and Boot disk = N.\nThe following example output snippet shows drives that cannot be used for encryption. Notice SED capable = Y and Boot disk = Y, or SED capable = N.\n\nAlternatively, you can specify the output be presented in JSON format by using the -j option.\n\n```\nsudo nv-disk-encrypt info -j\n```\n\nIn this case, drives that can be used for encryption are indicated by the following:\n\n```\n\"sed_capable\": true \"used_for_boot\": false\n```\n\nAnd drives that cannot be used for encryption are indicated by one of the following:\n\n```\n\"sed_capable\": true \"used_for_boot\": true\n```\n\nOr\n\n```\n\"sed_capable\": false\n```\n\n14.6.1.2 Creating the Drive/Password Mapping JSON Files and Using it to Initialize the System\n\nYou can initialize the system by creating the drive and password map the JSON files.\n\n1. Create a JSON file that lists all the eligible SED-capable drives that you want to manage. Note: These are the list of drives that you obtained from Determining Which Drives Can be Managed as Self-Encrypting\n\n The following example shows the format of the JSON file.\n\n ```\n {\n \"/dev/nvme2n1\": \".your-password”,\n \"dev/nvme3n1\": \".your-password”,\n \"dev/nvme4n1\": \".your-password”,\n \"dev/nvme5n1\": \".your-password”,\n }\n ```\n\n ▶ Ensure that you follow the syntax exactly.\n ▶ Passwords must consist of only upper-case letters, lower-case letters, digits, and/or the following special characters: ~ @ % ^ + = ,\n\n2. Initialize the system and then enable locking.\n\n The following command assumes you have placed the JSON file in the /tmp directory.\nNVIDIA DGX Software for Red Hat Enterprise Linux 9\n\n```\nsudo nv-disk-encrypt init -f /tmp/<your-file>.json -g\nsudo nv-disk-encrypt lock\n```\n\nWhen prompted, enter a password for the vault.\n\nPasswords must consist of only upper-case letters, lower-case letters, digits, and/or the following special characters: ~ : @ % ^ + = _ ,\n\n### 14.6.2. Example 2: Generating Random Passwords\n\nThe commands in this topic use the `-k` and `-r` options so that you are not prompted to enter passwords. You pass the vault password into the command and then the command instructs the tool to generate random passwords for each drive.\n\nThe vault password must consist of only upper-case letters, lower-case letters, digits, and/or the following special characters: ~ : @ % ^ + = _ ,\n\n```\nsudo nv-disk-encrypt init -k <your-vault-password> -g -r\nsudo nv-disk-encrypt lock\n```\n\n### 14.6.3. Example 3: Specifying Passwords One at a Time When Prompted\n\nIf there are a small number of drives, or you do not want to create a JSON file, issue the following command.\n\n```\nsudo nv-disk-encrypt init -g\nsudo nv-disk-encrypt lock\n```\n\nThe software prompts you to enter a password for the vault and then a password for each eligible SED. Passwords must consist of only upper-case letters, lower-case letters, digits, and/or the following special characters: ~ : @ % ^ + = _ ,\n\n### 14.7. Disabling Drive Locking\n\nTo disable drive locking at any time after you initialize, run the following command: `sudo nv-disk-encrypt disable`\n\nThis command disables locking on all drives. You can run the initial set up again at any time after this process is complete.\n14.8. Enabling Drive Locking\n\nAfter initializing the system for SED management, issue the following command, which uses the nv-disk-encrypt command to enable drive locking.\n\n```\nsudo nv-disk-encrypt lock\n```\n\nAfter initializing the system and enabling drive locking, the drives will become locked when they lose power. The system will automatically unlock each drive when power is restored to the system and the system is rebooted.\n\n14.9. Exporting the Vault\n\nHere is some information about how to export the vault.\n\nTo export all drive keys out to a file, use the export function. This requires that you pass in the vault password.\n\n```\nsudo nv-disk-encrypt export -k yourvaultpassword\nWriting vault data to /tmp/secrets.out\n```\n\n14.10. Erasing Your Data\n\nHere is some information about how you can erase your data.\n\n**Warning:** Be aware when executing this that all data will be lost. On DGX H100 systems, these drives generally form a RAID 0 array, and this array will also be destroyed when you perform an erase.\n\nAfter initializing the system for SED management, use the nv-disk-encrypt command to erase data on your drives after stopping cachefilesd and unmounting the RAID array as follows.\n\n1. Completely stop the RAID.\n\n ```\n systemctl stop cachefilesd\n sudo umount /raid\n sudo mdadm --stop /dev/md1\n ```\n\n2. Perform the erase.\n\n ```\n sudo nv-disk-encrypt erase\n ```\n\nThis command does the following:\n\n- Sets the drives in an unlocked state.\n- Disables locking on the drives.\n- Removes the RAID 0 array configuration.\nTo rebuild the RAID array, issue the following command:\n\n```\nsudo /usr/bin/configure_raid_array.py -c -f\n```\n\n14.11. Clearing the TPM\n\nIf you’ve lost the password to your TPM, you will not be able to access its contents. In this case, the only way to regain access to the TPM is to clear the TPM’s contents. After clearing the TPM, you will need to re-initialize the vault and SED authentication keys.\n\n1. Reboot the system, then press [Del] or [F2] at the NVIDIA splash screen to enter the BIOS Setup.\n2. Navigate to the Advanced tab on the top menu, scroll to Trusted Computing, and press [Enter].\n3. Clear TPM.\n 1. Scroll to Trusted Computing and press [Enter].\n 2. Scroll to Pending Operation and press [Enter].\n 3. Select TPM Clear at the Pending Operation popup and press [Enter].\n4. Save and exit the BIOS Setup.\n\n\nThe same steps are needed for changing or rotating passwords, adding disks, or replacing disks.\n\n1. Disable SED management.\n\n```\nsudo nv-disk-encrypt disable\n```\n\n2. Add or replace drives as needed and then rebuild the RAID array. Refer to your system’s Service Manual for more information.\n3. Enable SED management and assign passwords per the instructions in Initializing the System for Drive Encryption.\n\n14.13. Recovering From Lost Keys\n\nNVIDIA recommends backing up your keys and storing them in a secure location. If you lost the key used to initialize and lock your drives, you will not be able to unlock the drive again. If this happens, the only way to recover is to perform a factory-reset, which will result in a loss of data.\n\nSED drives come with a PSID printed on the label; this value can only be obtained by physically examining the drive as exemplified in the following image.\nSpecify the PSID to reset the drive using the following sedutil-cli command:\n\n```bash\nsudo sedutil-cli ----yesIreallywanttoERASEALLmydatausingthePSID yourdrivesPSID /dev/nvme3n1\n```\nChapter 15. Known Issues\n\nThis section provides summaries of the issues in the DGX Software for Red Hat Enterprise Linux.\n\n15.1. Virtualization Not Supported\n\nIssue\n\nVirtualization technology, such as ESXi hypervisors or kernel-based virtual machines (KVM), is not an intended use case on DGX systems and has not been tested.\n\n15.2. NVIDIA GPU Driver 550 Not Supported on DGX Station A100\n\nPlatform\n\nDGX Station A100 with EL9-24.06 or EL9-23.12\n\nIssue\n\nWhen the NVIDIA Data Center GPU Driver of the Release 550 family is installed on DGX Station A100 running the EL9-24.06 or EL9-23.12 release, a kernel panic or hang might occur.\n\nThe Release 550 GPU driver runs successfully on all other platforms.\nWorkaround\n\nOn DGX Station A100 running EL9-24.06 or EL9-23.12, install the Release 535 GPU driver.\n\n15.3. NVSM Service and Fabric Manager Service Reported as Inactive\n\nPlatform\n\nDGX H100 System, A100 System, and A100 Station with EL9-24.06\n\nIssue\n\nAfter EL9-24.06 upgrade and a system reboot, the status of nvsm.service and nvidia-fabricmanager.service shows inactive (dead) when you run systemctl status nvsm and systemctl status nvidia-fabricmanager, respectively.\n\n```\n$ sudo systemctl status nvsm\n... nvsm.service - NVIDIA System Management service suite\n Loaded: loaded (/usr/lib/systemd/system/nvsm.service; enabled; preset: disabled)\n Active: inactive (dead)\n... \n$ sudo systemctl status nvidia-fabricmanager\n... nvidia-fabricmanager.service - NVIDIA fabric manager service\n Loaded: loaded (/usr/lib/systemd/system/nvidia-fabricmanager.service; enabled; preset: disabled)\n Active: inactive (dead)\n... \n```\n\nWorkaround\n\nThe nvsm.service service manages the start and stop of services running under NVSM. Because the NVSM services are operating normally and NVSM is fully functioning, you can ignore the inactive status of nvsm.service. To fix the nvsm.service status issue, run the systemctl start nvsm command after a system reboot.\n\nHowever, the nvidia-fabricmanager.service service remains inactive. To resolve this issue, manually start the service by running the systemctl start nvidia-fabricmanager.service command.\nExplanation\n\nAfter a system reboot on DGX systems running the GPU Driver Release 550 or newer, nvsm.service and nvidia-fabricmanager.service appear inactive because systemd finds a dependency on nvidia-fabricmanager.service during startup. The circular dependency between nvsm.service and nvidia-fabricmanager.service makes one service wait for the other and prevents the services from starting.\n\n15.4. Excessive OpenSM Log Growth Causing DGX Systems to Become Inoperable\n\nIssue\n\nAn exceptionally large /var/log/opensm.log file can cause DGX systems to become inoperable.\n\nExplanation\n\nDuring the installation process of the MLNX_OFED or DOCA OFED software, the opensm package is also installed. By default, OpenSM is disabled. On systems where OpenSM is enabled, the /etc/logrotate.d/opensm file should be configured to include the following options to manage the size of the opensm.log file:\n\n- The maximum size of log files for log rotation, such as maxsize 10M or maxsize 100M\n- The rotation duration, such as daily, weekly, or monthly\n\nNot specifying the two configuration options might result in an exceptionally large /var/log/opensm.log file that can cause DGX systems to become inoperable. For more information about OpenSM network topology, configuration, and enablement, refer to the NVIDIA OpenSM documentation.\n\n15.5. Reboot Hang after Configuring RAID\n\nPlatform\n\nDGX H100 System with EL9-23.08 and RHEL 9.1 or 9.2\nIssue\n\nAfter installing the DGX H100 Configurations group and configuring RAID with the `sudo /usr/bin/configure_raid_array.py -c -f -5` command and rebooting, the system can hang and display console messages like the following example:\n\n```\n...\n```\n\nWorkaround\n\nPerform a power cycle to reboot the system successfully. The system boots normally on subsequent reboots.\n\nExplanation\n\nBefore rebooting, this issue is triggered by a RAID State of active, degraded, recovering that can be displayed by running the `sudo mdadm --detail /dev/mdXXX` command. Replace XXX with the RAID array that you configured with the `configure_raid_array.py` command.\n\nRefer to the following sample output:\n\n```\n$ sudo mdadm --detail /dev/md125\n/dev/md125:\n Version : 1.2\n Creation Time : Wed Aug 30 11:39:08 2023\n Raid Level : raid5\n Array Size : 26254240768 (24.45 TiB 26.88 TB)\n Used Dev Size : 3750605824 (3.49 TiB 3.84 TB)\n Raid Devices : 8\n Total Devices : 8\n Persistence : Superblock is persistent\n Intent Bitmap : Internal\n State : active, degraded, recovering\n Active Devices : 7\n Working Devices : 8\n Failed Devices : 0\n Spare Devices : 1\n Layout : left-symmetric\n Chunk Size : 512K\n Consistency Policy : bitmap\n Rebuild Status : 5% complete\n Name : nv-data-array\n UUID : 2dbe34c6:70decf1e:c54206a6:e78b9161\n Events : 204\n```\n\n(continues on next page)\n### 15.6. MOFED `mlnxofedinstall` reports “Current operation system is not supported” using RHEL 9.2\n\n**Platform**\n\nEL9-23.01 and RHEL 9.2 with MLNX_OFED_LINUX-5.8-2.0.3.0-rhel9.1-x86_64.iso\n\n**Issue**\n\nWhen installing MLNX MOFED driver from the downloaded ISO using `mlnxofedinstall --add-kernel-support` the system generates a warning: “Current operation system is not supported!”\n\n**Workaround**\n\nSpecify the last supported version of RHEL on the commandline by adding “--distro rhel9.1” `mlnxofedinstall --add-kernel-support`\n\n**Explanation**\n\nThe current MLNX MOFED installer script can require the most recent supported OS to be specified by name if the OS is upgraded before the installer support is added for that OS version.\n15.7. Precompiled GPU Driver 525 package is not available for Rocky 9.1\n\n**Platform**\n\nRocky 9.1 with EL9-23.01\n\n**Issue**\n\nThe Pre-compiled GPU Driver might not support the installed Rocky Linux kernel.\n\n**Workaround**\n\nYou can install the GPU driver by using the DKMS subsystem by running the following commands:\n\n```\nsudo dnf module reset -y nvidia-driver\nsudo dnf install kernel-devel-$(uname -r) kernel-headers-$(uname -r)\nsudo dnf module install nvidia-driver:525-dkms\n```\n\n15.8. Yellow screen appears during RHEL 9.1 installation\n\n**Issue**\n\nWhen installing the RedHat Enterprise Linux 9.1 ISO on a DGX Station V100, the first installation page shows a yellow screen. This can persist through the installation process and when complete.\n\n**Workaround**\n\nInstall RedHat Enterprise Linux 9.0 on the DGX Station V100, then perform the over the air (OTA) update for the latest RHEL9 version and the DGX EL9-23.01 updates.\n\n15.9. DGX A100: VBIOS cannot update due to running service processes\n\n**Issue**\n\nVBIOS fails to update on Red Hat Enterprise Linux 9 because service(s)/process(es) are holding onto the resource about to be upgraded.\nWorkaround\n\nThe following services (system processes) must be stopped manually for the firmware update to start:\n\n- process nvidia-persistenced\n- process nv-hostengine\n- process cache_mgr_event\n- process cache_mgr_main\n- process dcgm_ipc\n\nIf `xorg` is holding the resources, try to stop it by running\n\n```\nsudo systemctl stop (display manager)\n```\n\nwhere the (display manager) can be acquired by\n\n```\ncat /etc/X11/default-display-manager\n```\n\n### 15.10. NVSM Unsupported Drive Error\n\n#### Issue\n\nWhen running `nvsm show storage`, the NV-DRIVE-01 alert displays an \"Unsupported Drive Configuration\" message.\n\n#### Workaround\n\nThe following services (system processes) must be stopped manually for the firmware update to start:\n\n1. Create a config file to disable nvme multipath:\n\n ```\nsudo sh -c 'echo \"options nvme-core multipath=n\" > /etc/modprobe.d/nvidia-nvme.conf'\n \n dracut --force /boot/initramfs-$\\{uname -r\\}.img $\\{uname -r\\}\n \n sudo systemctl reboot\n ```\n\n The message might be displayed when you log in or when you run the `nvsm show alert` and `nvsm show storage` commands and can be safely ignored. This issue will be fixed in a future release.\n15.11. Tuned profiles do not take effect in graphical mode\n\n**Issue**\n\nDGX tuned profiles might not take effect due to a known Red Hat Enterprise Linux 9 issue. This affects systems that use a graphical target mode.\n\n**Workaround**\n\nThis issue can be fixed by running the following commands:\n\n- Mask the power-profiles-daemon service then tuned is able to start during boot.\n \n ```\n systemctl mask power-profiles-daemon\n ```\n\n- Reboot the system\n \n ```\n reboot\n ```\nChapter 16. Third-Party License Notices\n\nThis NVIDIA product contains third party software that is being made available to you under their respective open source software licenses. Some of those licenses also require specific legal information to be included in the product. This section provides such information.\n\n16.1. Micron msecli\n\nThe msecli utility is provided under the following terms:\n\nMicron Technology, Inc. Software License Agreement PLEASE READ THIS LICENSE AGREEMENT (\"AGREEMENT\") FROM MICRON TECHNOLOGY, INC. (\"MTI\") CAREFULLY: BY INSTALLING, COPYING OR OTHERWISE USING THIS SOFTWARE AND ANY RELATED PRINTED MATERIALS (\"SOFTWARE\"), YOU ARE ACCEPTING AND AGREEING TO THE TERMS OF THIS AGREEMENT. IF YOU DO NOT AGREE WITH THE TERMS OF THIS AGREEMENT, DO NOT INSTALL THE SOFTWARE. LICENSE: MTI hereby grants to you the following rights: You may use and make one (1) backup copy the Software subject to the terms of this Agreement. You must maintain all copyright notices on all copies of the Software. You agree not to modify, adapt, decompile, reverse engineer, disassemble, or otherwise translate the Software. MTI may make changes to the Software at any time without notice to you. In addition MTI is under no obligation whatsoever to update, maintain, or provide new versions or other support for the Software. OWNERSHIP OF MATERIALS: You acknowledge and agree that the Software is proprietary property of MTI (and/or its licensors) and is protected by United States copyright law and international treaty provisions. Except as expressly provided herein, MTI does not grant any express or implied right to you under any patents, copyrights, trademarks, or trade secret information. You further acknowledge and agree that all right, title, and interest in and to the Software, including associated proprietary rights, are and shall remain with MTI (and/or its licensors). This Agreement does not convey to you an interest in or to the Software, but only a limited right to use and copy the Software in accordance with the terms of this Agreement. The Software is licensed to you and not sold.\n\nDISCLAIMER OF WARRANTY:\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. MTI EXPRESSLY DISCLAIMS ALL WARRANTIES EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, NONINFRINGEMENT OF THIRD PARTY RIGHTS, AND ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE. MTI DOES NOT WARRANT THAT THE SOFTWARE WILL MEET YOUR REQUIREMENTS, OR THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE. FURTHERMORE, MTI DOES NOT MAKE ANY REPRESENTATIONS REGARDING THE USE OR THE RESULTS OF THE USE OF THE SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY, OR OTHERWISE. THE ENTIRE RISK ARISING OUT OF USE OR PERFORMANCE OF THE SOFTWARE REMAINS WITH YOU. IN NO EVENT SHALL MTI, ITS AFFILIATED COMPANIES OR THEIR SUPPLIERS BE LIABLE FOR ANY DIRECT, INDIRECT, CONSEQUENTIAL, INCIDENTAL, OR SPECIAL DAMAGES (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF PROFITS, BUSINESS INTERRUPTION, OR LOSS OF\nINFORMATION) ARISING OUT OF YOUR USE OF OR INABILITY TO USE THE SOFTWARE, EVEN IF MTI\nHAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. Because some jurisdictions prohibit\nthe exclusion or limitation of liability for consequential or incidental damages, the above limitation\nmay not apply to you.\n\nTERMINATION OF THIS LICENSE: MTI may terminate this license at any time if you are in breach of\nany of the terms of this Agreement. Upon termination, you will immediately destroy all copies the\nSoftware.\n\nGENERAL: This Agreement constitutes the entire agreement between MTI and you regarding the sub-\nject matter hereof and supersedes all previous oral or written communications between the parties.\nThis Agreement shall be governed by the laws of the State of Idaho without regard to its conflict of\nlaws rules.\n\nCONTACT: If you have any questions about the terms of this Agreement, please contact MTI’s legal\ndepartment at (208) 368-4500. By proceeding with the installation of the Software, you agree to the\nterms of this Agreement. You must agree to the terms in order to install and use the Software.\n\n16.2. Mellanox (OFED)\n\nMLNX_OFED <http://www.mellanox.com/> is provided under the following terms:\n\nCopyright (c) 2006 Mellanox Technologies. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted pro-\nvided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this list of conditions and\nthe following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions\nand the following disclaimer in the documentation and/or other materials provided with the dis-\ntribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\nOF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT\nSHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCI-\nDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\nPROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSI-\nNESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CON-\nTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\nOUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\nChapter 17. Notices\n\n17.1. Notice\n\nThis document is provided for information purposes only and shall not be regarded as a warranty of a certain functionality, condition, or quality of a product. NVIDIA Corporation (\"NVIDIA\") makes no representations or warranties, expressed or implied, as to the accuracy or completeness of the information contained in this document and assumes no responsibility for any errors contained herein. NVIDIA shall have no liability for the consequences or use of such information or for any infringement of patents or other rights of third parties that may result from its use. This document is not a commitment to develop, release, or deliver any Material (defined below), code, or functionality.\n\nNVIDIA reserves the right to make corrections, modifications, enhancements, improvements, and any other changes to this document, at any time without notice.\n\nCustomer should obtain the latest relevant information before placing orders and should verify that such information is current and complete.\n\nNVIDIA products are sold subject to the NVIDIA standard terms and conditions of sale supplied at the time of order acknowledgement, unless otherwise agreed in an individual sales agreement signed by authorized representatives of NVIDIA and customer (\"Terms of Sale\"). NVIDIA hereby expressly objects to applying any customer general terms and conditions with regards to the purchase of the NVIDIA product referenced in this document. No contractual obligations are formed either directly or indirectly by this document.\n\nNVIDIA products are not designed, authorized, or warranted to be suitable for use in medical, military, aircraft, space, or life support equipment, nor in applications where failure or malfunction of the NVIDIA product can reasonably be expected to result in personal injury, death, or property or environmental damage. NVIDIA accepts no liability for inclusion and/or use of NVIDIA products in such equipment or applications and therefore such inclusion and/or use is at customer’s own risk.\n\nNVIDIA makes no representation or warranty that products based on this document will be suitable for any specified use. Testing of all parameters of each product is not necessarily performed by NVIDIA. It is customer’s sole responsibility to evaluate and determine the applicability of any information contained in this document, ensure the product is suitable and fit for the application planned by customer, and perform the necessary testing for the application in order to avoid a default of the application or the product. Weaknesses in customer’s product designs may affect the quality and reliability of the NVIDIA product and may result in additional or different conditions and/or requirements beyond those contained in this document. NVIDIA accepts no liability related to any default, damage, costs, or problem which may be based on or attributable to: (i) the use of the NVIDIA product in any manner that is contrary to this document or (ii) customer product designs.\n\nNo license, either expressed or implied, is granted under any NVIDIA patent right, copyright, or other NVIDIA intellectual property right under this document. Information published by NVIDIA regarding third-party products or services does not constitute a license from NVIDIA to use such products or\nservices or a warranty or endorsement thereof. Use of such information may require a license from a third party under the patents or other intellectual property rights of the third party, or a license from NVIDIA under the patents or other intellectual property rights of NVIDIA.\n\nReproduction of information in this document is permissible only if approved in advance by NVIDIA in writing, reproduced without alteration and in full compliance with all applicable export laws and regulations, and accompanied by all associated conditions, limitations, and notices.\n\nTHIS DOCUMENT AND ALL NVIDIA DESIGN SPECIFICATIONS, REFERENCE BOARDS, FILES, DRAWINGS, DIAGNOSTICS, LISTS, AND OTHER DOCUMENTS (TOGETHER AND SEPARATELY, “MATERIALS”) ARE BEING PROVIDED “AS IS.” NVIDIA MAKES NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT WILL NVIDIA BE LIABLE FOR ANY DAMAGES, INCLUDING WITHOUT LIMITATION ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF ANY USE OF THIS DOCUMENT, EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. Notwithstanding any damages that customer might incur for any reason whatsoever, NVIDIA’s aggregate and cumulative liability towards customer for the products described herein shall be limited in accordance with the Terms of Sale for the product.\n\n17.2. Trademarks\n\nNVIDIA, the NVIDIA logo, DGX, DGX-1, DGX-2, DGX A100, DGX A800, DGX H100, DGX Station, and DGX Station A100 are trademarks and/or registered trademarks of NVIDIA Corporation in the United States and other countries. Other company and product names may be trademarks of the respective companies with which they are associated.\n\nCopyright\n\n©2022-2024, NVIDIA Corporation"}}},{"rowIdx":279,"cells":{"id":{"kind":"string","value":"7776db014e65621e6dc1d5afa69041d9053d1b1b"},"text":{"kind":"string","value":"Notice of Disclaimer\n\nThe information disclosed to you hereunder (the “Materials”) is provided solely for the selection and use of Xilinx products. To the maximum extent permitted by applicable law: (1) Materials are made available “AS IS” and with all faults, Xilinx hereby DISCLAIMS ALL WARRANTIES AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and (2) Xilinx shall not be liable (whether in contract or tort, including negligence, or under any other theory of liability) for any loss or damage of any kind or nature related to, arising under, or in connection with, the Materials (including your use of the Materials), including for any direct, indirect, special, incidental, or consequential loss or damage (including loss of data, profits, goodwill, or any type of loss or damage suffered as a result of any action brought by a third party) even if such damage or loss was reasonably foreseeable or Xilinx had been advised of the possibility of the same. Xilinx assumes no obligation to correct any errors contained in the Materials or to notify you of updates to the Materials or to product specifications. You may not reproduce, modify, distribute, or publicly display the Materials without prior written consent. Certain products are subject to the terms and conditions of the Limited Warranties which can be viewed at http://www.xilinx.com/warranty.htm; IP cores may be subject to warranty and support terms contained in a license issued to you by Xilinx. Xilinx products are not designed or intended to be fail-safe or for use in any application requiring fail-safe performance; you assume sole risk and liability for use of Xilinx products in Critical Applications: http://www.xilinx.com/warranty.htm#critapps.\n\n© Copyright 2012-2013 Xilinx, Inc. Xilinx, the Xilinx logo, Artix, ISE, Kintex, Spartan, Virtex, Vivado, Zynq, and other designated brands included herein are trademarks of Xilinx in the United States and other countries. All other trademarks are the property of their respective owners.\n\nRevision History\n\nThe following table shows the revision history for this document.\n\n<table>\n<thead>\n<tr>\n<th>Date</th>\n<th>Version</th>\n<th>Revision</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>10/23/2013</td>\n<td>2013.3</td>\n<td>Changed title of Chapter 3, Modifying Placement, Routing, and Logic, to include reference to Placement.</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Added new section Modifying Placement, page 99.</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Added new report under Incremental Reuse Summary, page 49.</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Added new section Reuse Reporting, page 56.</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Added new section Incremental Compile Advanced Analysis, page 56.</td>\n</tr>\n<tr>\n<td>12/18/2013</td>\n<td>2013.4</td>\n<td><strong>Chapter 1:</strong></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>At the end of the section Vivado Implementation Sub-Processes, added a note regarding module analysis.</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Added section on Multithreading in Vivado.</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td><strong>Chapter 2:</strong></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Added a section on Global Clock Buffer Insertion.</td>\n</tr>\n</tbody>\n</table>\n# Table of Contents\n\nRevision History 2\n\n## Chapter 1: Vivado Implementation Process\n\n- About the Vivado Implementation Process 5\n- Getting to Implementation 9\n- Configuring, Implementing, and Verifying IP 13\n- Guiding Implementation With Design Constraints 14\n- Using Design Checkpoints to Save and Restore Snapshots 17\n- Running Implementation in Non-Project Mode 18\n- Running Implementation in Project Mode 21\n- Customizing Implementation Strategies 32\n- Launching Implementation Runs 38\n- Moving Processes into the Background 40\n- Running Implementation in Steps 41\n- Monitoring the Implementation Run 42\n- Incremental Compile 46\n- Moving Forward After Implementation 60\n- Viewing Messages 62\n- Viewing Implementation Reports 65\n\n## Chapter 2: Implementation Commands\n\n- About Implementation Commands 70\n- Implementation Sub-Processes 70\n- Opening the Synthesized Design 71\n- Logic Optimization 75\n- Power Optimization 79\n- Placement 81\n- Physical Optimization 87\n- Routing 94\n\n## Chapter 3: Modifying Placement, Routing, and Logic\n\n- Introduction to Modifying Placement, Routing, and Logic 99\n- Modifying Placement 99\nAppendix A: Using Remote Hosts\n Launching Runs on Remote Linux Hosts. ......................................................... 117\n Setting Up SSH Key Agent Forward. ................................................................. 121\n\nAppendix B: ISE Command Map\n Tcl Commands and Options. ................................................................. 122\n\nAppendix C: Implementation Categories, Strategy Descriptions, and Directive Mapping\n Implementation Categories. ................................................................. 124\n Implementation Strategy Descriptions. ......................................................... 124\n Directives Used By opt_design and place_design in Implementation Strategies ....... 126\n Directives Used by phys_opt_design and route_design in Implementation Strategies .... 127\n\nAppendix D: Additional Resources\n Xilinx Resources ................................................................. 128\n Solution Centers ................................................................. 128\n References ................................................................. 128\nChapter 1\n\nVivado Implementation Process\n\nAbout the Vivado Implementation Process\n\nThe Xilinx® Vivado® Design Suite enables implementation of Xilinx 7 series FPGA designs from a variety of design sources, including:\n\n- RTL designs\n- Netlist designs\n- IP centric design flows\n\nSee Figure 1-1, Vivado Design Suite High-Level Design Flow, page 6.\n\nVivado implementation includes all steps necessary to place and route the netlist onto the FPGA device resources, while meeting the design’s logical, physical, and timing constraints.\n\nFor more information about the design flows supported by the Vivado tools, see the Vivado Design Suite User Guide: Design Flows Overview (UG892) [Ref 1].\n\nVivado Implementation Supports SDC and XDC Constraints\n\nThe Vivado Design Suite implementation is a timing-driven flow. It supports industry standard Synopsys Design Constraints (SDC) commands to specify design requirements and restrictions, as well as additional commands in the Xilinx Design Constraints format (XDC).\nVivado Implementation Sub-Processes\n\nThe Vivado Design Suite implementation process includes logical and physical transformations of the design. The implementation process consists of the following sub-processes:\n\n- **Opt Design**\n Optimizes the logical design to make it easier to fit onto the target Xilinx device.\n\n- **Power Opt Design**\n Optimizes design elements to reduce the power demands of the target Xilinx device.\n\n *Note:* This step is optional.\n\n- **Place Design**\n Places the design onto the target Xilinx device.\n\n- **Phys Opt Design**\n Optimizes design timing by replicating drivers of high-fanout nets to distribute the loads.\n\n *Note:* This step is optional.\n\n- **Route Design**\n Routes the design onto the target Xilinx device.\n• **Write Bitstream**\n\n Generates a bitstream for Xilinx device configuration.\n\n**Note:** Vivado supports Module Analysis which is the implementation of a part of a design to estimate performance. I/O buffer insertion is skipped for this flow to prevent over-utilization of I/O. For further information, search on “module analysis” in the Vivado Design Suite User Guide: Hierarchical Design (UG905) [Ref 2].\n\n### Multithreading in Vivado\n\nOn multiprocessor systems Vivado uses multithreading to speed up certain processes, including DRC reporting, static timing analysis, placement, and routing. The maximum number of simultaneous threads varies, depending on the OS, number of processors, and the particular task. The maximum number of threads by task is:\n\n- DRC reporting: 8\n- Static timing analysis: 8\n- Placement: 4\n- Routing: 4\n\nThere is also a general limit that applies to all tasks and is based on the OS. For Windows systems, the limit is 2; for Linux systems the limit is 8. The limit can be changed using a parameter called `general.maxThreads`. To change the limit:\n\n```\nVivado% set_param general.maxThreads <new limit>\n```\n\n—where the new limit must be an integer from 1 to 8, inclusive. Example: On a Windows system:\n\n```\nVivado% get_param general.maxThreads\n2\n```\n\nThis means all tasks are limited to 2 threads regardless of number of processors or the task being executed. If the system has at least 8 processors, you can set the limit to 8 and allow each task to use the maximum number of threads.\n\n```\nVivado% set_param general.maxThreads 8\n```\n\nTo summarize, the number of simultaneous threads is the minimum of the following:\n\n- Maximum number of processors\n- Limit of threads for the task\n- General limit of threads\nFlow Navigator Assembles, Implements, and Validates Your Design\n\nThe complete design flow is integrated in the Vivado Integrated Design Environment (IDE). The Vivado IDE includes a standardized interface called the Flow Navigator.\n\nThe Flow Navigator assembles, implements, and validates the design and IP of the FPGA design. It features a push-button interface to the entire implementation process to simplify the design flow.\n\nSee Figure 1-2, Flow Navigator - Implementation Section.\n\n\n\n**IMPORTANT:** This guide does not give a detailed explanation of the Vivado IDE, except as it applies to implementation. For more information about the Vivado IDE as it relates to the entire FPGA design flow, see the Vivado Design Suite User Guide: Using the Vivado IDE (UG893) [Ref 3].\n\nTcl API Supports Scripting\n\nThe Vivado Design Suite includes a Tool Command Language (Tcl) Application Programming Interface (API). The Tcl API supports scripting for all design flows, allowing you to customize the design flow to meet your specific requirements.\n\n**Note:** For more information about Tcl commands, see the Vivado Design Suite Tcl Command Reference Guide (UG835) [Ref 13], or type `<command> -help`. \nGetting to Implementation\n\nThe Vivado Design Suite includes a variety of design flows, and supports an array of design sources. In order to generate a bitstream that can be downloaded onto an FPGA device, the design must pass through implementation.\n\nImplementation is a series of steps that takes the logical netlist and maps it into the physical array of the target Xilinx device. These steps include:\n\n- Logic optimization\n- Placement of logic cells\n- Routing of connections between cells\n\nWorking in Project Mode and Non-Project Mode\n\nThe Vivado Design Suite lets you create a project file (.xpr) and directory structure that allows you to:\n\n- Manage the design source files.\n- Store the results of the synthesis and implementation runs.\n- Track the project status through the design flow.\n\n**TIP:** The Vivado tools also let you work strictly in memory, without the need for a project file and local directory.\n\nWorking in Project Mode\n\nIn Project Mode, a directory structure is created on disk to help you manage:\n\n- Design sources\n- Run results\n- Project status\n\nThe automated management of the design data, process, and status requires a project infrastructure that is stored in the Vivado project file (.xpr).\n\nIn Project Mode, the Vivado tools automatically write checkpoint files into the local project directory at key points in the design flow.\nWorking in Non-Project Mode\n\nWorking without a project file in the compilation style flow is called Non-Project Mode. Non-Project Mode allows you to work with the design in memory. Source files and design constraints are read into memory from their current locations. The in-memory design is stepped through the design flow without being written to intermediate files.\n\nIn Non-Project Mode, you must run each design step individually, and set design parameters and implementation options using Tcl commands.\n\nNon-Project Mode allows you to apply design changes and proceed through the design flow without needing to save changes and rerun steps. You can run reports and save design checkpoints (.dcp) at any stage of the design flow.\n\n**IMPORTANT:** In Non-Project Mode, when you exit the Vivado design tools, the in-memory design is lost. For this reason, Xilinx recommends that you write design checkpoints after major steps such as synthesis, placement, and routing.\n\nYou can save design checkpoints in both Project Mode and Non-Project Mode. You can only read design checkpoints in Non-Project Mode.\n\nSimilarities and Differences Between Project Mode and Non-Project Mode\n\nVivado implementation can be run in either Project Mode or Non-Project Mode. The Vivado IDE and Tcl API can be used in both Project Mode and Non-Project Mode.\n\nThere are many differences between Project Mode and Non-Project Mode. Features not available in Non-Project Mode include:\n\n- Flow Navigator\n- Design status indicators\n- IP catalog\n- Implementation runs and run strategies\n- Design Runs window\n- Messages window\n- Reports window\n\n**Note:** This list illustrates features that are not supported in Non-Project Mode. It is not exhaustive.\n\nYou must implement the non-project based design by running the individual Tcl commands:\n\n- opt_design\n- place_design\n- route_design\nYou can run implementation steps interactively in the Tcl Console or the Vivado IDE, or by using a custom Tcl script. You can customize the design flow as needed to include reporting commands and additional optimizations. For more information, see Running Implementation in Non-Project Mode.\n\nThe details of running implementation in Project Mode and Non-Project Mode are described in this guide.\n\nFor more information on running the Vivado Design Suite using either Project Mode or Non-Project Mode, see:\n\n- *Vivado Design Suite User Guide: Using the Vivado IDE (UG893)* [Ref 3]\n\n### RTL and Synthesized Design\n\nThe Vivado Design Suite allows you to manage the entire FPGA design process, including RTL development, IP customization, synthesis, and implementation through to programming and validating the device.\n\n### Adding Objects to Your Project\n\nYou can add the following objects to your project:\n\n- HDL source files from Verilog, SystemVerilog, and VHDL\n- Previously defined and configured Xilinx IP cores\n- Digital signal processing (DSP) modules from System Generator.\n- C-based DSP modules from Vivado High-level Synthesis (HLS)\n- Embedded processor modules from Xilinx Platform Studio (XPS)\n\n### Importing Previously Synthesized Netlists\n\nThe Vivado Design Suite supports netlist-driven design by importing previously synthesized netlists from Xilinx or third-party tools. The netlist input formats include:\n\n- Structural Verilog\n- SystemVerilog\n- EDIF\n- Xilinx NGC\n\nFor more information on the source files and project types supported by the Vivado Design Suite, see the *Vivado Design Suite User Guide: System-Level Design Entry (UG895)* [Ref 5].\nStarting From RTL Sources\n\nAt a minimum, Vivado implementation requires a synthesized netlist. A design can start from a synthesized netlist, or from RTL source files.\n\n**IMPORTANT:** If you start from RTL sources, you must first run either Vivado synthesis before implementation can begin. The Vivado IDE manages this automatically if you attempt to run implementation on an un-synthesized design. The tools allow you to run synthesis first.\n\nFor information on running Vivado synthesis, see the *Vivado Design Suite User Guide: Synthesis* (UG901) [Ref 7].\n\nCreating and Opening the Synthesized Design in Non-Project Mode\n\nIn Non-Project Mode, you must run the Tcl command `synth_design` to create and open the synthesized design. You can also run the Tcl command `link_design` to open a synthesized netlist in any supported input format.\n\nFor more information, see Opening the Synthesized Design in Chapter 2, Implementation Commands.\n\nLoading the Design Netlist in Project Mode Before Implementation\n\nIn Project Mode, after synthesis of an RTL design, or with a netlist-based project open, you can load the design netlist for analysis before implementation.\n\nTo open a synthesized design, do one of the following:\n\n- From the main menu, run **Flow > Open Synthesized Design**.\n- In the Flow Navigator, run **Synthesis > Open Synthesized Design**.\n- In the Design Runs window, select the synthesis run and select **Open Synthesized Design** from the context menu.\nConfiguring, Implementing, and Verifying IP\n\nThe Vivado IP catalog allows you to configure, implement, and verify IP. The IP can be configured and verified as a standalone module, or within the context of a larger system level design.\n\nIP Catalog Contents\n\nThe IP catalog displays all available Xilinx LogicCORE™ IP and user-defined IP or third party IP that has been added to the IP catalog.\n\nThe catalog includes data related to:\n\n- IP type\n- Version\n- Datasheet\n- License information\n\nAdding an IP Core to an RTL Design\n\nTo add an IP core to an RTL design, define the instantiation template into the system-level design.\n\nIP is created as RTL sources, not netlists. Running synthesis and implementation implements the IP along with the rest of the design.\n\nYou can also synthesize the IP as a standalone module, and add the netlist to a netlist design. See Table 1-1, Supported IP Netlist Formats.\n\nTable 1-1: Supported IP Netlist Formats\n\n<table>\n<thead>\n<tr>\n<th>Xilinx</th>\n<th>Verilog</th>\n<th>EDIF</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>.xco</td>\n<td>.v</td>\n<td>.edf</td>\n</tr>\n<tr>\n<td>.xcii</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>.ngc</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nFor more information on how Vivado tools support IP centric design, see the Vivado Design Suite User Guide: Designing with IP (UG896) [Ref 6].\nGuiding Implementation With Design Constraints\n\nXilinx highly recommends that you include design constraints to guide implementation. There are two types of design constraints, physical constraints and timing constraints.\n\nThis section includes:\n\n- What Physical Constraints Define\n- What Timing Constraints Define\n- UCF Format Not Supported\n- Constraint Sets Apply Lists of Constraint Files to Your Design\n- Adding Constraints as Attribute Statements\n\nWhat Physical Constraints Define\n\nPhysical constraints define a relationship between logical design objects and device resources such as:\n\n- Pin placement\n- Absolute or relative placement of cells, including:\n - BRAM\n - DSP\n - LUT\n - Flip flops\n- Device configuration settings\n\nWhat Timing Constraints Define\n\nTiming constraints define the frequency requirements for the design, and are written in industry standard SDC.\n\nWithout timing constraints, the Vivado Design Suite optimizes the design solely for wire length and routing congestion, and makes no effort to assess or improve design performance.\nUCF Format Not Supported\n\n**IMPORTANT:** The Vivado Design Suite does not support the UCF format.\n\nFor information on migrating UCF constraints to XDC commands, see the *ISE to Vivado Design Suite Migration Guide* (UG911) [Ref 14].\n\nConstraint Sets Apply Lists of Constraint Files to Your Design\n\nA constraint set is a list of constraint files that can be applied to your design. The set contains design constraints captured in XDC files.\n\nAllowed Constraint Set Structures\n\nThe following constraint set structures are allowed:\n\n- Multiple constraint files within a constraint set\n- Constraint sets with separate physical and timing constraint files\n- A master constraint file\n- A new constraint file that accepts constraint changes\n- Multiple constraint sets\n\n**TIP:** Separate constraints by function into different constraint files to (a) make your constraint strategy clearer, and (b) to facilitate targeting timing and implementation changes.\n\nMultiple Constraint Sets Are Allowed\n\nYou can have multiple constraint sets for a project. Multiple constraint sets allow you to use different implementation runs to test different approaches.\n\nFor example, you can have one constraint set for synthesis, and a second constraint set for implementation. Having two constraint sets allows you to experiment by applying different constraints during synthesis, simulation, and implementation.\nGuiding Implementation With Design Constraints\n\nOrganizing design constraints into multiple constraint sets can help you:\n\n• Target various Xilinx FPGA devices for the same project. Different physical and timing constraints may be needed for different target devices.\n\n• Perform what-if design exploration. Use constraint sets to explore various scenarios for floorplanning and over-constraining the design.\n\n• Manage constraint changes. Override master constraints with local changes in a separate constraint file.\n\n**TIP:** To validate the timing constraints, run `report_timing_summary` on the synthesized design. Fix problematic constraints before implementation!\n\nFor more information on defining and working with constraints that affect placement and routing, see the *Vivado Design Suite User Guide: Using Constraints* (UG903) [Ref 8].\n\n### Adding Constraints as Attribute Statements\n\nConstraints can be added to HDL sources as attribute statements. Attributes can be added to both Verilog and VHDL sources to pass through to Vivado synthesis or Vivado implementation.\n\nIn some cases, constraints are available only as RTL attributes, and are not available in XDC. In those cases, the constraint must be specified as an attribute in the HDL source file. For example, Relatively Placed Macros (RPMs) must be defined as properties. An RPM is a list of logic elements (such as FF, LUT, DSP, and RAM) grouped into a set.\n\nYou can define sets of design elements using U Set (U_SET) or HU Set (HU_SET) constraints, and place these objects in relation to the other elements of the set using Relative Location Constraints (RLOC).\n\nFor more information about Relative Location Constraints, see the *Vivado Design Suite User Guide: Using Constraints* (UG903) [Ref 8].\n\nThe U_SET, HU_SET, and RLOC constraints are not supported in XDC by Tcl commands, and they be defined as attributes in the HDL source files.\n\nFor more information on constraints that are not supported in XDC, see the *ISE to Vivado Design Suite Migration Guide* (UG911) [Ref 14].\nUsing Design Checkpoints to Save and Restore Snapshots\n\nThe Vivado Design Suite uses a physical design database to store placement and routing information. Design checkpoint files (\\*.dcp) allow you to save and restore this physical database at key points in the design flow. A checkpoint is a snapshot of a design at a specific point in the flow.\n\nThis design checkpoint file includes:\n\n- Current netlist, including any optimizations made during implementation\n- Design constraints\n- Implementation results\n\nCheckpoint designs can be run through the remainder of the design flow using Tcl commands. They cannot be modified with new design sources.\n\nWriting Checkpoint Files\n\nRun **File > Write Checkpoint** to capture a snapshot of the design database at any point in the flow. This creates a file with a dcp extension.\n\nThe related Tcl command is `write_checkpoint`.\n\nReading Checkpoint Files\n\nRun **File > Open Checkpoint** to open the checkpoint in the Vivado Design Suite.\n\nThe design checkpoint is opened as a separate project. It can not be read into an existing project.\n\nThe related Tcl command is `read_checkpoint`.\nRunning Implementation in Non-Project Mode\n\nTo implement the synthesized design or netlist onto the targeted Xilinx FPGA device, you must run the netlist and the design constraints through a series of steps:\n\n- Optimization\n- Placement\n- Routing\n\nThese steps are collectively known as *implementation*.\n\nIn Non-Project Mode, you must run implementation using a series of Tcl commands, or a Tcl script that defines the design flow. Enter the commands in the Tcl Console from the Vivado IDE or from the Tcl prompt in the Vivado Design Suite Tcl shell.\n\n**Non-Project Mode Example Script**\n\nThe following script is an example of running implementation in Non-Project Mode.\n\n```tcl\n# Step 1: Read in top-level EDIF netlist from synthesis tool\nread_edif c:/top.edf\n# Read in lower level IP core netlists\nread_edif c:/core1.edf\nread_edif c:/core2.edf\n\n# Step 2: Specify target device and link the netlists\n# Merge lower level cores with top level into single design\nlink_design -part xc7k325tfbg900-1 -top top\n\n# Step 3: Read XDC constraints to specify timing requirements\nread_xdc c:/top_timing.xdc\n# Read XDC constraints that specify physical constraints such as pin locations\nread_xdc c:/top_physical.xdc\n\n# Step 4: Optimize the design with default settings\nopt_design\n\n# Step 5: Place the design\nplace_design\n\n# Step 6: Route the design\nroute_design\n\n# Step 7: Run Timing Summary Report to see timing results\nreport_timing_summary -file post_route_timing.rpt\n# Run Utilization Report for device resource utilization\nreport_utilization -file post_route_utilization.rpt\n\n# Step 8: Write checkpoint to capture the design database;\n# The checkpoint can be used for design analysis in Vivado IDE or TCL API\nwrite_checkpoint post_route.dcp\n```\nKey Steps in Non-Project Mode Example Script\n\nThe key steps in the Non-Project Mode Example Script, page 18 above, are:\n\n- Step 1: Read Design Source Files\n- Step 2: Build the In-Memory Design\n- Step 3: Read Design Constraints\n- Step 4: Perform Logic Optimization\n- Step 5: Place the Netlist Elements\n- Step 6: Route the Design\n- Step 7: Run Required Reports\n- Step 8: Save the Design Checkpoint\n\nStep 1: Read Design Source Files\n\nIn the Non-Project Mode Example Script, page 18 above, the design sources are EDIF netlist files. Non-Project Mode also supports an RTL design flow, which allows you to read source files and run synthesis before implementation.\n\nThe read_* Tcl commands are designed for use with Non-Project Mode. This allows a file on the disk to be read by the Vivado Design Suite to build the in-memory design, without copying the file or creating a dependency on the file.\n\nThis approach makes Non-Project Mode extremely flexible with regard to design.\n\nIMPORTANT: You must monitor any changes to the source design files, and update the design as needed.\n\nStep 2: Build the In-Memory Design\n\nIn the Non-Project Mode Example Script, page 18 above, the Vivado tools build an in-memory view of the design using link_design. The link_design command combines the netlist based source files read into the tools with the Xilinx part information, to create a design database in memory.\n\nAll actions taken in Non-Project Mode are directed at the in-memory database within the Vivado tools.\n\nThe in-memory design resides in the Vivado tools, whether running in batch mode, Tcl shell mode for interactive Tcl commands, or in the Vivado IDE for interaction with the design data in a graphical form.\nStep 3: Read Design Constraints\n\nThe Vivado Design Suite uses design constraints to define requirements for both the physical and timing characteristics of the design.\n\nFor more information, see Guiding Implementation With Design Constraints, page 14.\n\nThe `read_xdc` command reads an XDC constraint file, then applies it to the in-memory design.\n\n*TIP:* Although Project Mode supports the definition of constraint sets, containing multiple constraint files for different purposes, Non-Project Mode uses multiple `read_xdc` commands to achieve the same effect.\n\nStep 4: Perform Logic Optimization\n\nThe Non-Project Mode Example Script, page 18 above, performs logic optimization in preparation for placement and routing. Optimization simplifies the logic design before committing to physical resources on the target part.\n\nThe Vivado netlist optimizer includes many different types of optimizations to meet varying design requirements.\n\nFor more information, see Logic Optimization, page 75.\n\nStep 5: Place the Netlist Elements\n\nThe Non-Project Mode Example Script, page 18 above, performs a general placement of the design. For more information, see Placement, page 81.\n\nStep 6: Route the Design\n\nThe `route_design` command completes the required routing for the design. The Vivado router performs timing-driven routing for all design types. The router allows a great deal of control for re-entrant routing to complete challenging designs.\n\nFor more information, see Routing, page 94.\n\nStep 7: Run Required Reports\n\nThe Non-Project Mode Example Script, page 18 above, generates two of the many reports available from the Vivado Design Suite. In Non-Project Mode, you must use the appropriate Tcl command to specify each report that you want to create.\nYou can output reports to files for later review, or you can send the reports directly to the Vivado IDE to review now.\n\nFor more information, see Viewing Implementation Reports, page 65.\n\n**Step 8: Save the Design Checkpoint**\n\nThe Non-Project Mode Example Script, page 18 above, saves the in-memory design into a design checkpoint file. The saved in-memory design includes its:\n\n- Optimized netlist\n- Physical and timing related constraints\n- Xilinx part data\n- Placement and routing information\n\nIn Non-Project Mode, the design checkpoint file saves the design, and allows it to be reloaded for further analysis and modification.\n\nFor more information, see Using Design Checkpoints to Save and Restore Snapshots, page 17.\n\n---\n\n**Running Implementation in Project Mode**\n\nIn Project Mode, the Vivado IDE allows you to:\n\n- Define implementation runs that are configured to use specific synthesis results and design constraints.\n- Run multiple strategies on a single design.\n- Customize implementation strategies to meet specific design requirements.\n- Save customized implementation strategies to use in other designs.\n\n**IMPORTANT:** Non-Project Mode does not support predefined implementation runs and strategies. Non-project based designs must be manually moved through each step of the implementation process using Tcl commands. For more information, see Running Implementation in Non-Project Mode, page 18.\n\n---\n\n**Creating Implementation Runs**\n\nYou can create and launch new implementation runs to explore design alternatives and find the best results. You can queue and launch the runs serially, or in parallel using multiple local CPUs.\nOn Linux systems, you can launch runs on remote servers. For more information, see Appendix A, Using Remote Hosts.\n\n**Defining Implementation Runs**\n\nTo define an implementation run:\n\n1. Do one of the following:\n a. From the main menu, select **Flow > Create Runs**, or\n b. In the Flow Navigator, select **Create Implementation Runs** from the Implementation popup menu, or\n c. In the Design Runs window, select **Create Runs** from the popup menu.\n\n The Create New Runs wizard opens. The first page summarizes the command.\n\n2. Click **Next**.\n\n **Note:** If you used **Flow > Create Runs**, select **Implementation** on the first page of the Create New Runs wizard.\n\n3. Enter a **Name** for the run in the Configure Implementation Runs dialog box, or accept the default name.\n\n4. Select a **Synth Name** to choose the synthesis run that will be used to generate (or that has already generated) the synthesized netlist to be implemented.\n\n Alternatively, you can select a synthesized netlist that was imported into the project from a third party synthesis tool.\nFor more information, see the *Vivado Design Suite User Guide: Synthesis* (UG901) [Ref 7].\n\nThe default is the currently active synthesis run in the Design Runs window. For more information, see Appendix C, Implementation Categories, Strategy Descriptions, and Directive Mapping.\n\n5. Select a **Constraints Set**.\n\nSelect a **Constraints Set** to specify the constraint set to apply during implementation. The optimization, placement, and routing are largely directed by the physical and timing constraints in the specified constraint set.\n\nFor more information on constraint sets, see the *Vivado Design Suite User Guide: Using Constraints* (UG903) [Ref 8].\n\n6. Select a target **Part**.\n\nThe default values for Constraints Set and Part are defined by the Project Settings when the **Create New Runs** command is executed.\n\nFor more information on the Project Settings, see the *Vivado Design Suite User Guide: Using the Vivado IDE* (UG893) [Ref 3].\n\nTo create runs with different constraint sets or target parts, use the **Create New Runs** command. To change these values in the Run Properties window, select the run in the Design Runs window.\n\nFor more information, see Changing Implementation Run Settings, page 27.\n\n7. Select a **Strategy**.\n\nStrategies are a defined set of Vivado implementation feature options controlling the implementation results. Vivado Design Suite includes a set of pre-defined strategies. You can also create your own implementation strategies.\n\nSelect from among the strategies shown in Appendix C, Implementation Categories, Strategy Descriptions, and Directive Mapping.\n\nThe strategies are broken into categories according to their purposes, with the category name as a prefix. The categories are shown in Appendix C, Implementation Categories, Strategy Descriptions, and Directive Mapping.\n\nFor more information see Defining Strategies, page 33.\n\nThe Performance strategies aim to improve design performance at the expense of runtime. The **Performance_Explore** strategy is a good first choice, because it covers all types of designs.\n\n---\n\n**IMPORTANT:** Strategies containing the terms SLL or SLR are for use with SSI devices only.\nBefore launching a run, you can change the settings for each step in the implementation process, overriding the default settings for the selected strategy. You can also save those new settings as a new strategy. For more information, see Changing Implementation Run Settings, page 27.\n\n8. Click **More** to define additional runs. Specify names and strategies for the added runs. See Figure 1-3, Configure Implementation Runs.\n\n9. Click **Next**.\n\nThe Launch Options dialog box opens. See Figure 1-4, Implementation Launch Options.\n\n10. Specify the **Launch Directory**.\n\n Creates and stores the implementation run data.\n\n The default directory is located in the local project directory structure. Files for implementation runs are stored by default at:\n\n ```\n <project_name>/<project_name>.runs/<run_name>\n ```\n\n **TIP:** Defining a directory location outside the project directory structure makes the project non-portable, because absolute paths are written into the project files.\n\n11. Specify the **Launch Options**.\n\n a. **Launch Runs on Local Host**\n\n Launches the run on the local machine.\nb. **Number of Jobs**\n\nDefines the number of local processors to use when launching multiple runs simultaneously.\n\nc. **Launch Runs on Remote Hosts** (Linux only)\n\nUses remote hosts to launch one or more jobs.\n\nFor more information, see Appendix A, Using Remote Hosts.\n\nd. **Configure Hosts**\n\nConfigures remote hosts.\n\ne. **Generate scripts only**\n\nExports and creates the run directory and run script, but does not launch the run at this time. The script can be run later outside the Vivado IDE tools.\n\nf. **Do not launch now**\n\nSaves the new runs, but does not launch or create run scripts at this time.\n\n12. Click **Next** to review the Create New Runs Summary.\n\n13. Click **Finish** to create the defined runs and execute the specified launch options.\n\nNew runs are added to the Design Runs window. See **Using the Design Runs Window**.\n\n**Using the Design Runs Window**\n\nThe Design Runs window displays all synthesis and implementation runs created in the project. It includes commands to configure, manage, and launch the runs.\n\n**Opening the Design Runs Window**\n\nSelect **Window > Design Runs** to open the Design Runs window if it is not already open. See Figure 1-5, Design Runs Window.\n\n**Design Runs Window Functionality**\n\n- Each implementation run appears indented beneath the synthesis run of which it is a child.\n- A synthesis run can have multiple implementation runs. Use the tree widgets in the window to expand and collapse synthesis runs.\n- The Design Runs window is a tree table window.\nFor more information on working with the columns to sort the data in this window, see the *Vivado Design Suite User Guide: Using the Vivado IDE* (UG893) [Ref 3].\n\n\n\n**Figure 1-5: Design Runs Window**\n\n### Run Status\n\nThe Design Runs window reports the run status, including when:\n\n- The run has not been started.\n- The run is in progress.\n- The run is complete.\n- The run is out-of-date.\n\n### Run Timing Results\n\nThe Design Runs window reports timing results for implementation runs including WNS, TNS, WHS, THS, and TPWS.\n\n### Out-of-Date Runs\n\nRuns can become out-of-date when source files, constraints, or project settings are modified. You can reset and delete stale run data in the Design Runs window.\n\n### Active Run\n\nAll views in the Vivado IDE reference the active run. The Log view, Report view, Status Bar, and Project Summary display information for the active run. The Project Summary window displays only compilation, resource, and summary information for the active run.\n\n**TIP:** *Only one synthesis run and one implementation run can be active in the Vivado IDE at any time.*\nThe active run is displayed in **bold** text.\n\nTo make a run active:\n\n1. Select the run in the Design Runs window\n2. Select **Make Active** from the popup menu.\n\n**Changing Implementation Run Settings**\n\nSelect a run in the Design Runs window to display the current configuration of the run in the Run Properties window. See **Figure 1-6, Run Properties Window**.\n\nIn the Run Properties window you can change:\n\n- The **Name** of the run\n- The Xilinx **Part** targeted by the run\n- The run **Description**\n- The **Constraints** set that both drives the implementation and is the target of new constraints from implementation\n\nFor more information on the Run Properties window, see the *Vivado Design Suite User Guide: Using the Vivado IDE* (UG893) [Ref 3].\n\n\n\nYou can also change the options used by Vivado implementation features.\nSpecifying Design Run Settings\n\nSpecify design run settings in the Design Run Settings dialog box. To open the Design Run Settings dialog box:\n\n1. Select a run in the Design Runs window.\n2. Select **Change Run Settings** from the popup menu.\n\nSee **Figure 1-7, Design Run Settings**.\n\n**TIP:** You can change the settings only for a run that has a **Not Started** status. Use Reset Run to return a run to the **Not Started** status. See **Resetting Runs, page 30**.\n\n**Figure 1-7:** **Design Run Settings**\n\nThe Design Run Settings dialog box displays: (1) the implementation strategy currently employed by the run; and (2) the command options associated with that strategy for each step of the implementation process. The command options are:\n\n- **Strategy**\n- **Description**\n- **Options**\n\n**Strategy**\n\nSelects the strategy to use for the implementation run. Vivado Design Suite includes a set of pre-defined implementation strategies, or you can create your own.\n\nFor more information see **Defining Strategies, page 33**.\nDescription\n\nDescribes the selected implementation strategy.\n\nOptions\n\nWhen you select a strategy, each step of the Vivado implementation process displays in a table in the lower part of the dialog box:\n\n- opt_design\n- power_opt_design\n- place_design\n- phys_opt_design\n- route_design\n- write_bitstream\n\nClick the command option to view a brief description of the option at the bottom of the Design Run Settings dialog box.\n\nFor more information about the implementation steps and their available options, see Chapter 2, Implementation Commands.\n\nModifying Command Options\n\nTo modify command options, click the right-side column of a specific option. You can do the following:\n\n- Select options with predefined settings from the pull down menu.\n- Select or deselect a check box to enable or disable options.\n- Type a value to define options that accept a user-defined value.\n- Options accepting a file name and path open a file browser to let you locate and specify the file.\n- Insert a custom Tcl script (called a hook script) before and after each step in the implementation process (tcl.pre and tcl.post).\n\nInserting a hook script lets you perform specific tasks before or after each implementation step (for example: generate a timing report before and after Place Design to compare timing results).\n\nFor more information on defining Tcl hook scripts, see the Vivado Design Suite User Guide: Using Tcl Scripting (UG894) [Ref 4].\nRunning Implementation in Project Mode\n\nTIP: Relative paths in the tcl.pre and tcl.post scripts are relative to the appropriate run directory of the project they are applied to: <project>/<project.runs>/<run_name>\n\nUse the DIRECTORY property of the current project or current run to define the relative paths in your Tcl scripts:\n\nget_property DIRECTORY [current_project]\nget_property DIRECTORY [current_run]\n\nSave Strategy As\n\nSelect the Save Strategy As icon next to the Strategy field to save any changes to the strategy as a new strategy for future use.\n\nCAUTION! If you do not select Save Strategy As, changes are saved to the current implementation run, but are not preserved for future use.\n\nVerifying Run Status\n\nThe Vivado IDE processes the run, and launches implementation, depending on the status of the run. The status is displayed in the Design Runs window. See Figure 1-5, Design Runs Window.\n\n- If the status of the run is Not Started, the run begins immediately.\n- If the status of the run is Error, the tools reset the run to remove any incomplete run data, then restarts the run.\n- If the status of the run is Complete (or Out-of-Date), the tools prompt you to confirm that the run should be reset before proceeding with the run.\n\nResetting Runs\n\nTo reset a run:\n\n1. Select a run in the Design Runs window.\n2. Select Reset Runs from the popup menu.\n\nResetting an implementation run returns it to the first step of implementation (opt_design) for the selected run.\nRunning Implementation in Project Mode\n\nThe Vivado tools prompt you to confirm the **Reset Runs** command, and optionally delete the generated files from the run directory.\n\n**TIP:** The default setting is to delete the generated files. Disable this check box to preserve the generated run files.\n\n### Deleting Runs\n\nTo delete runs from the Design Runs window:\n\n1. Select the run.\n2. Select **Delete** from the popup menu.\n\nThe Vivado tools prompt you to confirm the **Delete Runs** command, and optionally delete the generated files from the run directory.\n\n**TIP:** The default setting is to delete the generated files. Disable this check box to preserve the generated run files.\n\n---\n\n\n\n**Figure 1-8:** Reset Run\n\n\n\n**Figure 1-9:** Delete Runs\nCustomizing Implementation Strategies\n\nImplementation Settings define the default options used when you define new implementation runs. Configure these options in the Vivado IDE.\n\nFigure 1-10, Implementation Settings, shows the Implementation Settings of the Project Settings dialog box. To open this dialog box from the Vivado IDE, select Tools > Project Settings from the main menu.\n\nTIP: The Project Settings command is not available in the Vivado IDE when running in Non-Project Mode. In this case, you can define and preserve implementation strategies as Tcl scripts that can be used in batch mode, or interactively in the Vivado IDE.\n\nAccessing Implementation Settings for the Active Run from Flow Navigator\n\nImplementation Settings for the active implementation run can also be accessed directly from the Flow Navigator.\n\nImplementation Settings contains the following fields:\n\n• Default Constraint Set\n Select the constraint set to be used by default for the implementation run.\n\n• Strategy\n Select the strategy to use for the implementation run. The Vivado Design Suite includes a set of pre-defined strategies. You can also create your own implementation strategies.\n For more information see Defining Strategies.\n\n• Save Strategy As\n Saves any changes to the strategy as a new strategy for future use.\n\n• Description\n • Describes the selected implementation strategy.\n • The description of user-defined strategies can be changed by entering a new description.\n • The description of Vivado tools standard implementation strategies cannot be changed.\nDefining Strategies\n\nA strategy is a defined approach for resolving the synthesis or implementation challenges of the design.\n\n- Strategies are defined in pre-configured sets of options for the Vivado implementation features.\n- Strategies are tool and version specific.\n- Each major release of the Vivado Design Suite includes version-specific strategies.\n\nFigure 1-10: Implementation Settings\nCustomizing Implementation Strategies\n\nVivado implementation includes several commonly used strategies that are tested against internal benchmarks.\n\n**TIP:** You cannot save changes to the predefined implementation strategies. However, you can copy, modify, and save the predefined strategies to create your own.\n\n### Accessing Currently Defined Strategies\n\nTo access the currently defined strategies, select **Tools > Options** in the Vivado IDE main menu.\n\n**Figure 1-11, Default Implementation Strategies**, shows the default strategies included with the Vivado tools.\nCustomizing Implementation Strategies\n\nReviewing, Copying, and Modifying Strategies\n\nTo review, copy, and modify strategies:\n\n1. Select **Tools > Options** from the main menu.\n2. Select **Strategies** in the left-side panel.\n \nThe Strategies dialog box contains a list of pre-defined strategies for various tools and release versions. See Figure 1-11, Default Implementation Strategies.\n3. In the **Flow** pulldown, select the appropriate **Vivado Implementation** version for the available strategies. A list of included strategies is displayed.\n4. To create a new strategy, select **Create New Strategy** on the toolbar or from the popup menu.\n5. To copy an existing strategy, select **Create a copy of this strategy** from the toolbar or from the popup menu. The Vivado design tools:\n a. Create a copy of the currently selected strategy.\n b. Add it to the User Defined Strategies list.\n c. Display the strategy options on the right side of the dialog box for you to modify.\n6. Provide a name and description for the new strategy as follows:\n - **Name**\n Enter a strategy name to assign to a run.\n - **Type**\n Specify **Synthesis** or **Implement**.\n - **Tool Version**\n Specify the tool version.\n - **Description**\n Enter the strategy description displayed in the Design Run results table.\n7. Edit the **Options** for the various implementation steps:\n - opt_design\n - power_opt_design\n - place_design\n - phys_opt_design\n - route_design\n - write_bitstream\n\n **TIP:** Select an option to view a brief description of the option at the bottom of the Design Run Settings dialog box.\n\n For more information about the implementation steps and their options, see Chapter 2, Implementation Commands.\n8. Click the right-side column of a specific option to modify command options. See Figure 1-13, **Edit Implementation Steps**, immediately above for an example.\n\nYou can then:\n\n- Select predefined options from the pull down menu.\n- Enable or disable some options with a check box.\n- Type a user-defined value for options with a text entry field.\n- Use the file browser to specify a file for options accepting a file name and path.\n- Insert a custom Tcl script (called a hook script) before and after each step in the implementation process (tcl.pre and tcl.post). This lets you perform specific tasks either before or after each implementation step (for example, generating a timing report before and after Place Design to compare timing results).\n\nFor more information on defining Tcl hook scripts, see the *Vivado Design Suite User Guide: Using Tcl Scripting (UG894)* [Ref 4].\n\n**Note:** Relative paths in the tcl.pre and tcl.post scripts are relative to the appropriate run directory of the project they are applied to: `<project>,/project.runs,/run_name>`\nYou can use the DIRECTORY property of the current project or current run to define the relative paths in your scripts:\n\n```\nget_property DIRECTORY [current_project]\nget_property DIRECTORY [current_run]\n```\n\n9. Click **OK** to save the new strategy.\n\nThe new strategy is listed under User Defined Strategy. The Vivado tools save user-defined strategies to the following locations:\n\n- **Linux OS**\n \n $HOME/.Xilinx/Vivado/strategies\n\n- **Windows 7**\n \n C:\\Users\\<username>\\AppData\\Roaming\\Xilinx\\Vivado\\strategies\n\n- **Windows XP**\n \n C:\\Documents and Settings\\username\\Application Data\\Xilinx\\Vivado\\strategies\n\n**Sharing Strategies**\n\nDesign teams that want to create and share strategies can copy any user-defined strategy from the user directory to the `<InstallDir>/Vivado/<version>/strategies` directory\n\nwhere\n\n- `<InstallDir>` is the installation directory of the Xilinx software.\n- `<version>` is the release version.\n\n---\n\n**Launching Implementation Runs**\n\nDo any of the following to launch the active implementation run in the Design Runs window:\n\n- Select **Run Implementation** in the Flow Navigator.\n- Select **Flow > Run Implementation** from the main menu.\n- Select **Run Implementation** from the toolbar menu.\n- Select a run in the Design Runs window and select **Launch Runs** from the popup menu.\n\nLaunching a single implementation run initiates a separate process for the implementation.\n**TIP:** Select a run in the Design Runs window to launch a run other than the active run. Select two or more runs in the Design Runs window to launch multiple runs at the same time.\n\n1. Use **Shift+click** or **Ctrl+click** to select multiple runs.\n\n **Note:** You can choose both synthesis and implementation runs when selecting multiple runs in the Design Runs window. The Vivado IDE manages run dependencies and launches runs in the correct order.\n\n2. Select **Launch Runs** to open the Launch Selected Runs dialog box. See **Figure 1-14, Launch Selected Implementation Runs**.\n\n **Note:** You can select **Launch Runs** from the popup menu, or from the Design Runs window toolbar menu.\n\n \n\n **Figure 1-14:** Launch Selected Implementation Runs\n\n3. Select **Launch Directory**.\n\n The default launch directory is in the local project directory structure. Files for implementation runs are stored at:\n\n `<project_name>/<project_name>.runs/<run_name>`\n\n **TIP:** Defining any non-default location outside the project directory structure makes the project non-portable because absolute paths are written into the project files.\n4. Specify Options.\n\na. **Launch Runs on Local Host**\n\n Launch the run on the local machine.\n\nb. **Number of Jobs**\n\n Define the number of local processors to use when launching multiple runs simultaneously. Individual runs are launched on each processor.\n\nc. **Launch Runs on Remote Hosts** (Linux only)\n\n Use remote hosts to launch one or more jobs.\n\n For more information, see Appendix A, Using Remote Hosts.\n\nd. **Configure Hosts**\n\n Select this option to configure remote hosts.\n\ne. **Generate scripts only**\n\n Export and create the run directory and run script, but do not launch the run at this time. You can run the script later outside the Vivado tools.\n\n---\n\n**Moving Processes into the Background**\n\nAs the Vivado IDE initiates the process to run synthesis or implementation, it reads design files and constraint files in preparation for the run. The Starting Run dialog box lets you move this preparation into the background. See Figure 1-15, Start Run - Background Process.\n\nPutting this process into the background releases the Vivado IDE to perform other functions while it completes the background task. The other functions can include functions such as viewing reports and opening design files. You can use this time, for example, to review previous runs, or to examine reports.\n\n**CAUTION!** When you put this process into the background, the Tcl Console is blocked. You cannot execute Tcl commands, or perform tasks that require Tcl commands, such as switching to another open design.\nRunning Implementation in Steps\n\nVivado implementation consists of a number of smaller processes such as:\n\n- Logic optimizer\n- Placer\n- Router\n\nThe Vivado tools let you run implementation as a series of steps, rather than as a single process.\n\nHow to Run Implementation in Steps\n\nTo run implementation in steps:\n\n1. Select a run in the Design Runs window.\n2. Select **Launch Next Step: <Step>** or **Launch Step To** from the popup menu.\n\nValid `<Step>` values depend on which run steps have been enabled in the Run Settings. The steps that are available in an implementation run are:\n\n- **Opt Design**\n \n Optimizes the logical design and fit sit onto the target Xilinx FPGA device.\n\n- **Power Opt Design**\n \n Optimizes elements of the design to reduce power demands of the implemented FPGA device.\n\n- **Place Design**\n \n Places the design onto the target Xilinx device.\n\n- **Phys Opt Design**\n \n Performs timing-driven optimization on the negative-slack paths of a design.\n- **Route Design**\n Routes the design onto the target Xilinx device.\n\n- **Write Bitstream**\n Generates a bitstream for Xilinx device configuration. Although not technically part of an implementation run, bitstream generation is available as an incremental step.\n\n3. Repeat **Launch Next Step: <Step>** or **Launch Step To** as needed to move the design through implementation.\n\nYou can run any reports or analysis needed between implementation steps to explore design options.\n\n4. To back up from a completed step, select **Reset to Previous Step: <Step>** from the Design Runs window popup menu.\n\nSelect **Reset to Previous Step** to reset the selected run from its current state to the prior incremental step. This allows you to:\n\n- Step backward through a run.\n- Make any needed changes.\n- Step forward again to incrementally complete the run.\n\n---\n\n**Monitoring the Implementation Run**\n\nMonitoring the implementation run allows you to:\n\n- Read the compilation information.\n- Review warnings and errors in the Messages window.\n- View the Project Summary.\n- Open the Design Runs window.\n\nMonitor the status of a Synthesis or Implementation run in the Log window.\nMonitoring the Implementation Run\n\nViewing the Run Status Display\n\nThe status of a run that is in progress can be displayed in two ways for synthesis and implementation runs. These status displays show that a run is in progress. They allow you to cancel the run if desired. See Figure 1-16, Implementation Run Status.\n\nThe Run Status indicator in the project status bar at the upper right corner of the Vivado IDE displays a scrolling bar to indicate the run is in process. You can use the Cancel button to end the run.\n\nThe Run Status indicator in the Design Runs window, as shown at the bottom of Figure 1-16, Implementation Run Status, displays a circular arrow to indicate the run is in process. You can select the run and use the Reset Run command from the popup menu to cancel the run.\n\nCancelling/Resetting the Run\n\nIf you cancel a run that is in-progress, either through the Cancel button, or through the Reset Run command, the Vivado IDE prompts you to delete any run files created during the cancelled run. See Figure 1-17, Cancel Implementation.\n\nSelect Delete Generated Files to clear the run data from the local project directories.\n\nRECOMMENDED: Delete any data created as a result of a cancelled run to avoid conflicts with future runs.\nViewing the Log in the Log Window\n\nThe Log window opens in the Vivado IDE after you launch a run. It shows the standard output messages. It also displays details about the progress of each individual implementation process, such as place_design and route_design.\n\nThe Log window can help you understand where different messages originate to aid in debugging the implementation run. See Figure 1-18, Compilation Log, for an example of the Log window.\n\n**TIP:** View the Log window to see where messages originated as an aid in debugging the implementation run.\n\nPausing Output\n\nClick Pause to pause the output to the Log window. Pausing allows you to read the log while implementation continues running.\n\nDisplaying the Project Status\n\nThe Vivado IDE uses several methods to display the project status and which step to take next. The project status reports only the results of the major design tasks.\n\nThe project status is displayed in the Project summary and the Status bar. It allows you to immediately see the status of a project when you open the project, or while you are running the design flow commands, including:\n\n- RTL elaboration\n- Synthesis\n- Implementation\n- Bitstream generation\nMonitoring the Implementation Run\n\nViewing Project Status in the Project Status Bar\n\nThe project status is displayed in the project status bar in the upper-right corner of the Vivado IDE.\n\nAs the run progresses through the Synthesize, Implement, and Write Bitstream commands, the Project Status Bar changes to show either a successful or failed attempt. Failures are displayed in red text.\n\nViewing Out-of-Date Status\n\nIf source files or design constraints change, and either synthesis or implementation was previously completed, the project might be marked as Out-of-Date. See Figure 1-19, Implementation Out-of-Date.\n\nThe project status bar shows an Out-of-Date status. Click more info to display which aspects of the design are out of date. It may be necessary to rerun implementation, or both synthesis and implementation.\n\nForcing Runs Up-to-Date\n\nClick Force-up-to-date to force the implementation or synthesis runs up to date. Use Force-up-to-date if you changed the design or constraints, but still want to analyze the results of the current run.\n\nTIP: The Force-up-to-date command is also available from the popup menu of the Design Runs window when an out-of-date run is selected.\n\nFor more information, see the Vivado Design Suite User Guide: Using the Vivado IDE (UG893) [Ref 3].\nIncremental Compile\n\nIncremental Compile is an advanced design flow for designs that are nearing completion, where small changes are required. After resynthesizing small changes, the flow:\n\n- Speeds up place and route runtime; and\n- Preserves timing closure by reusing prior placement and routing from a reference design. The flow is most effective when synthesis changes result in at least 95 percent similarity to the reference design.\n\n**Note:** Only the changed portions of the current design are placed and routed from scratch.\n\n**Incremental Compile Flow Diagram**\n\n\nIncremental Compile Flow Designs\n\nThe Incremental Compile flow involves two different designs:\n\n- **Reference Design**\n- **Current Design**\n\nSee Figure 1-20, Incremental Compile Flow.\n\nReference Design\n\nThe reference design is usually an earlier iteration or variation of the current design that has been synthesized, placed, and routed.\n\nHowever, you can use a checkpoint that has any amount of placement, routing, or both. The reference design checkpoint (DCP) may be the product of many design iterations involving code changes, floorplanning, and revised constraints necessary to close timing.\n\nAfter the current design is loaded, load the reference design checkpoint using the `read_checkpont -incremental <dcp>` command. Loading the reference design checkpoint with the `-incremental` option enables the Incremental Compile design flow for subsequent place and route operations. For more information, see Examining the Similarity Between the Reference Design and the Current Design, page 49.\n\nCurrent Design\n\nThe current design incorporates small design changes or variations from the reference design. These changes or variations can include:\n\n- RTL changes\n- Netlist changes\n- Both RTL changes and netlist changes\nRunning Incremental Place and Route\n\nThe updated, current design is first loaded into memory. The reference design checkpoint is then loaded incrementally.\n\nThe key component of the Incremental Compile process is incremental place and route. The reference design checkpoint contains a netlist, constraints, and physical data including the placement and routing.\n\n- The netlist in the current design is compared to the reference design to identify matching cells and nets.\n- Placement from the reference design checkpoint is reused to place matching cells in the current design.\n- Routing is reused to route matching nets on a per-load-pin basis. If a load pin disappears due to netlist changes, then its routing is discarded, otherwise it is reused. Therefore it is possible to have partially-reused routes.\n\nIncremental placement and incremental routing may discard cell placements and net routes instead of reusing them, if it will improve routability of the netlist, or maintain performance comparable to that of the reference design.\n\nNets with Multiple Fanouts\n\nThe Vivado router performs fine-grained matching for nets with multiple fanouts, in which each routing segment can be reused or discarded as appropriate.\n\nDesign objects that do not match between the reference design and the current design are placed after incremental placement is complete, and routed after existing routing is reused.\n\nEffectively Reusing Placement and Routing\n\nEffective reuse of the placement and routing from the reference design depends on the differences between the two designs. Even small differences can have a large impact.\n\nImpact of Small RTL Changes\n\nAlthough synthesis tries to minimize netlist name changes, sometimes small RTL changes such as the following can lead to very large changes in the synthesized netlist:\n\n- Increasing the size of an inferred memory\n- Widening an internal bus\n- Changing data types from unsigned to signed\nImpact of Changing Constraints and Synthesis Options\n\nSimilarly, changing constraints and synthesis options such as the following can also have a large impact on incremental placement and routing runtime:\n\n- Changing timing constraints and resynthesizing\n- Preserving or dissolving logical hierarchy\n- Enabling register re-timing\n\nUsing phys_opt_design\n\nIf the reference checkpoint was created with phys_opt_design, ensure that the incremental run also uses phys_opt_design. This captures the placement optimizations performed by phys_opt_design in the reference design and allows related routes to be reused. Unlike place_design and route_design, phys_opt_design does not have an incremental mode, but it will perform logic transformations in the revised design that are very similar to those of the reference design.\n\nExamining the Similarity Between the Reference Design and the Current Design\n\nRun report_incremental_reuse to examine and report the similarity between a reference design checkpoint file and the current design. The report_incremental_reuse command compares the netlist from the reference design checkpoint with the current in-memory design, and reports the percentage of matching of cells, nets, and ports.\n\nNote: The report_design_similarity command in previous versions of the Vivado tools has been replaced with the report_incremental_reuse command in the current version. The new report_incremental_reuse command (unlike the old report_design_similarity command) does not take an argument. Instead you must run read_checkpoint -incremental <dcp> first. You can then run report_incremental_reuse at any time thereafter. It automatically compares the design in memory against the <dcp> that was read in by read_checkpoint -incremental.\n\nA higher degree of design similarity results in more effective reuse of placement and routing from the reference design. Below is an example of a report_incremental_reuse report comparing an in-memory synthesized design to a route_design checkpoint\n\nIncremental Reuse Summary\n\nThe reuse report is divided into two sections, the Netlist Similarity Summary and the Implementation Reuse Summary. The Netlist Similarity Summary shows how many logical objects in the current design match objects in the reference design. This indicates how logically similar the design is after updating it with small changes.\n\nThe Implementation Reuse Summary shows physical data reuse of matching logical objects, including what percentage of cells, ports, and nets are reused, along with their placement and routing information from the reference design. For cells that are not reused, it provides\na breakdown of which cells are new cells in the netlist, those cells that do not exist in the reference design, and which cells have placements that must be discarded because their placements become illegal after updating the design. For nets, the report provides a breakdown of fully-reused routes, partially-reused routes, and nets that are new (that is, those nets that do not exist in the reference design).\n\nAn example reuse report is shown below.\n\n1. Netlist Similarity Summary\n -----------------------------\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Count</th>\n<th>Total</th>\n<th>Percentage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Matched Cells</td>\n<td>3609</td>\n<td>3618</td>\n<td>99.75</td>\n</tr>\n<tr>\n<td>Matched Ports</td>\n<td>71</td>\n<td>71</td>\n<td>100.00</td>\n</tr>\n<tr>\n<td>Matched Nets</td>\n<td>6154</td>\n<td>6171</td>\n<td>99.72</td>\n</tr>\n</tbody>\n</table>\n -----------------------------\n\n2. Implementation Reuse Summary\n ---------------------------------\n | Type | Count | Total | Percentage |\n | Reused Cells | 3607 | 3618 | 99.69 |\n | Reused Ports | 71 | 71 | 100.00 |\n | Reused Nets | 5135 | 5155 | 99.61 |\n | Non-Reused Cells | 11 | 3618 | 0.30 |\n | New | 9 | 3618 | 0.24 |\n | Discarded illegal placement due to netlist changes | 2 | 3618 | 0.05 |\n | Fully Reused nets | 4776 | 5155 | 92.64 |\n | Partially reused nets | 359 | 5155 | 6.96 |\n | Non-Reused nets | 20 | 5155 | 0.38 |\n ---------------------------------\n\nIn general, the higher the match percentage, the more placement and routing can be reused, and the faster place and route will run.\n\nRECOMMENDED: Select report_incremental_reuse to assess the feasibility of using a checkpoint as a reference design for running incremental place and route on the current design.\n\nIncremental Place and Route Metrics\n\nIncremental place and route in the Vivado Design Suite can achieve an average of a 2x improvement over normal place and route runtimes when designs have at least 95 percent similar cells.\nThe average runtime improvement decreases as similarity between the reference design and the current design decreases.\n\nBelow 85 percent, there may be little or no benefit to using the incremental place and route feature.\n\nFactors Affecting Runtime Improvement\n\nFactors that can affect runtime improvement include:\n\n- The amount of change in timing-critical areas. If critical path placement and routing cannot be reused, more effort is required to preserve timing. Also, if the small design changes introduce new timing problems that did not exist in the reference design, higher effort and runtime might be required, and the design might not meet timing.\n- The initialization portion of the place and route runtime. In short place and route runs, the initialization overhead of the Vivado placer and router may eliminate any gain from the incremental place and route process. For designs with longer runtimes, initialization becomes a small percentage of the runtime.\n\nUsing Incremental Compile\n\nIn both Project Mode and Non-Project Mode, incremental place and route mode is entered when you load the reference design checkpoint using the `read_checkpoint -incremental <dcp_file>` command where `<dcp_file>` specifies the path and filename of the reference design checkpoint. Loading the reference design checkpoint with the `-incremental` option enables the Incremental Compile design flow for subsequent place and route operations. In Non-Project Mode, `read_checkpoint -incremental` should: (1) follow `opt_design` and; (2) precede `place_design`.\n\nUsing Incremental Compile in Non-Project Mode\n\nTo specify a design checkpoint file (DCP) to use as the reference design, and to run incremental place in Non-Project Mode:\n\n1. Load the current design.\n2. Run `opt_design`.\nIncremental Compile\n\n1. Run `place_design`.\n2. Run `phys_opt_design` (optional). Run `phys_opt_design` if it was used in the reference design.\n3. Run `route_design`.\n\n ```\n link_design; # to load the current design\n opt_design\n read_checkpoint -incremental <dcp_file>\n place_design\n phys_opt_design; #if used in reference design\n route_design\n ```\n\nIncremental placement relies on the ability of the Vivado tools to match design objects in the current design with design objects in the reference design. However, use of the following `opt_design` command options typically results in poor cell-name matching between the reference and current designs (which, in turn, results in poor matching of placement and routing data):\n\n- `-resynth_area`\n- `-resynth_seq_area`\n- `-directive ExploreArea`\n- `-directive ExploreAreaSequential`\n\n**RECOMMENDED:** When running the Incremental Compile flow, avoid use of the four `opt_design` command options listed above.\n\n**Using Incremental Compile in Project Mode**\n\nIn Project Mode, you can set the incremental compile option in the Design Runs window. To set the incremental compile option:\n\n1. Select a run in the Design Runs window.\n2. Click **Set Incremental Compile** from the context menu.\n3. In the Set Incremental Compile window, select a reference design checkpoint.\n\nThis enables incremental compile mode for the run.\n\n**IMPORTANT:** When you choose a checkpoint from a design run, it is deleted if the design run is reset. If you want to choose a checkpoint from a design run, copy it into a separate directory before selecting it as your reference checkpoint.\n\nSee Figure 1-21, Setting Incremental Compile.\nAfter incremental placement and routing are complete, you can review the messages generated by the Vivado tools.\n\n**Note:** Implementation command directives and strategies are ignored when running the Incremental Compile flow because they have incompatible goals.\n\nTo disable incremental compile for the current run:\n\n1. Clear the `incremental_checkpoint` property in the Set Incremental Compile window or the Implementation Run Properties window, or\n2. Run the following command in the Tcl Console:\n ```tcl\n reset_property INCREMENTAL_CHECKPOINT [current_run]\n ```\n\n### Orphaned Route Segments\n\nSome cells may have been eliminated from the current design, or moved during placement, leaving orphaned route segments from the reference design. If you are running in the Vivado IDE, you might see potentially problematic nets. These orphaned or improperly connected route segments are cleaned up during incremental routing by the Vivado router.\nThe following INFO message appears during placement.\n\n```\nINFO: [Place 46-2] During incremental compilation, routing data from the original checkpoint is applied during place_design. As a result, dangling route segments and route conflicts may appear in the post place_design implementation due to changes between the original and incremental netlists. These routes can be ignored as they will be subsequently resolved by route_design. This issue will be cleaned up automatically in place_design in a future software release.\n```\n\n### Using Synplify Compile Points\n\nThe Incremental Compile flow is most effective when the revised and reference designs are most similar, preferably with at least 95 percent matching cells. Synthesis flows such as Synplify Compile Points minimize the amount of netlist changes resulting from RTL changes. Compile points are logical boundaries across which no optimization may occur. This sacrifices some design performance for predictability, but when combined with Incremental Compile, the resulting flow yields even more runtime savings and predictability.\n\nSynplify provides two different compile point flows: automatic and manual. In the automatic compile point mode, compile points are automatically chosen by synthesis, based on existing hierarchy and utilization estimates. This is a pushbutton mode. No user interaction is required besides enabling the flow. To enable, check the **Auto Compile Point** checkbox in the GUI or add the following setting to the Synplify project:\n\n```\nset_option -automatic_compile_point 1\n```\n\nThe manual compile point flow offers more flexibility, but requires more interaction to choose compile points. The flow involves compiling the design, then using either the SCOPE editor Compile Points tab or the `define_compile_point` setting. For further information on compile point flows, see the Synplify online help.\n\n### Saving Post-Reuse Checkpoints\n\nAfter `read_checkpoint -incremental` applies the reference checkpoint to the current design, the incremental reuse data is retained throughout the flow. If a checkpoint is saved, then reloaded in the same or a separate Vivado session, it remains in incremental compile mode. Consider the following command sequence:\n\n```\nopt_design; # optimize the current design\nread_checkpoint -incremental reference.dcp; # apply reference data to current design\nwrite_checkpoint incr.dcp; # save a snapshot of the current design\nread_checkpoint incr.dcp\nplace_design\nwrite_checkpoint top_placed.dcp; # save incremental placement result\nroute_design\n```\n\nUpon `read_checkpoint incr.dcp`, the Vivado tools determine that incremental data exists, and the subsequent `place_design` and `route_design` commands run incrementally.\nEven if you exit and restart the Vivado Design Suite, in the following command sequence the `route_design` command is run in incremental mode, using the routing data from the original reference checkpoint `reference.dcp`:\n\n```\nread_checkpoint top_placed.dcp\nphys_opt_design\nroute_design\n```\n\n**Constraint Conflicts**\n\nConstraints of the revised design can conflict with the physical data of the reference checkpoint. When conflicts occur, constraints of the revised design take precedence. This is illustrated in the following **Constraint Conflict Example**.\n\n**Constraint Conflict Example**\n\nA constraint assigns a fixed location `RAMB36_X0Y0` for a cell `cell_A`. However in the reference checkpoint `reference.dcp`, `cell_A` is placed at `RAMB36_X0Y1` and a different cell `cell_B` is placed at `RAMB36_X0Y0`.\n\nAfter running `read_checkpoint -incremental reference.dcp`, `cell_A` is placed at `RAMB36_X0Y0` and `cell_B` is unplaced. The cell `cell_B` will be placed during incremental placement.\n\n**IMPORTANT:** You cannot use Pblocks when using incremental compile. Pblocks can create unmanageable placement conflicts.\n\n**Incremental Compile Advanced Controls**\n\nThe following `read_checkpoint` options provide control over cell placement reuse from a reference checkpoint:\n\n- **-only_reuse option**\n- **-dont_reuse option**\n- **-fix_reuse option**\n\nThese options must be specified with the `read_checkpoint -incremental` option.\n\n**-only_reuse option**\n\n```\n-only_reuse <cell objects>\n```\n\nThe `-only_reuse` option limits the cell placement reuse to the list of specified cells. The cells may be either leaf cells or hierarchical cells. Examples:\nIncremental Compile\n\n- **Only reuse the placement from a top-level instance `mem_ctrl_inst` within `routed.dcp`:**\n \n ```sh\n read_checkpoint -incremental routed.dcp -only_reuse [get_cells mem_ctrl_inst]\n ```\n\n- **Only reuse the block RAM placement within `routed.dcp`:**\n \n ```sh\n read_checkpoint -incremental routed.dcp -only_reuse [get_cells -hier -filter { PRIMITIVE_TYPE =~ BMEM.bram.* } ]\n ```\n\n**-dont_reuse option**\n\n- `dont_reuse <cell objects>`\n\nThe `-dont_reuse` option reuses all cell placement except for those in the specified list. The cells may be either leaf cells or hierarchical cells. Examples:\n\n- **Reuse all placement from `routed.dcp` except for the cell placements from top-level instance `mem_ctrl_inst`:**\n \n ```sh\n read_checkpoint -incremental routed.dcp -dont_reuse [get_cells mem_ctrl_inst]\n ```\n\n- **Reuse all placement from `routed.dcp` except for the block RAM placement:**\n \n ```sh\n read_checkpoint -incremental routed.dcp -dont_reuse [get_cells -hier -filter { PRIMITIVE_TYPE =~ BMEM.bram.* } ]\n ```\n\n**-fix_reuse option**\n\nThe `-fix_reuse` option can be used with `-only_reuse` or `-dont_reuse` to lock down the placement of the reused cells automatically. Example:\n\n- **Only reuse the block RAM placement within `routed.dcp`, and lock down the reused cell placement:**\n \n ```sh\n read_checkpoint -incremental routed.dcp -only_reuse [get_cells -hier -filter { PRIMITIVE_TYPE =~ BMEM.bram.* } ] -fix_reuse\n ```\n\nReminder: in general, reused placement and routing can be modified. Therefore, `-fix_reuse` should be specified if modification is not desired.\n\nAfter applying the RAM cell locations, the cells are affixed with `IS_LOC_FIXED` properties with value TRUE.\n\n**Incremental Compile Advanced Analysis**\n\nVivado provides reporting, timing labels, and object properties for advanced reuse analysis.\n\n**Reuse Reporting**\n\nThe `report_incremental_reuse` command provides options for more detailed analysis, similar to `report_utilization`.\n-cells <list of cells>\n\nThe -cells option limits the reuse reporting to the list of given cells instead of reporting reuse of the entire design.\n\nExample: Limit the reuse reporting to only block RAMs:\n\n```bash\nreport_incremental_reuse -cells [get_cells -hierarchical -filter { PRIMITIVE_TYPE =~ BMEM.bram.* } ]\n```\n\n**Incremental Reuse Summary**\n\n1. **Netlist Similarity Summary**\n \n +---------------+-------+-------+------------+\n | Type | Count | Total | Percentage |\n +---------------+-------+-------+------------+\n | Matched Cells | 16 | 16 | 100.00 |\n | Matched Ports | 71 | 71 | 100.00 |\n | Matched Nets | 6154 | 6171 | 99.72 |\n +---------------+-------+-------+------------+\n\n2. **Implementation Reuse Summary**\n \n +------------------+-------+-------+------------+\n | Type | Count | Total | Percentage |\n +------------------+-------+-------+------------+\n | Reused Cells | 16 | 16 | 100.00 |\n | Non-Reused Cells | 0 | 16 | 0.00 |\n +------------------+-------+-------+------------+\n\nThe -hierarchical option displays a breakdown of cell reuse at each hierarchical level. Following is an example of `report_incremental_reuse -hierarchical`:\n\n**Note**: The sample report has been truncated horizontally and vertically to fit.\n\n**Hierarchical Implementation Reuse Summary**\n\n1. **Summary**\n \n +--------------------------+------------------+--------+-----+---------------------+\n | Instance | Module | Reused | New | Discarded(Illegal)* |\n +--------------------------+------------------+--------+-----+---------------------+\n | bft | (top) | 3607 | 9 | 2 |\n | (bft) | (top) | 210 | 9 | 2 |\n | arnd1 | round_1 | 256 | 0 | 0 |\n | transformLoop[0].ct | coreTransform_43| 32 | 0 | 0 |\n | transformLoop[1].ct | coreTransform_38| 32 | 0 | 0 |\n | transformLoop[2].ct | coreTransform_42| 32 | 0 | 0 |\n | transformLoop[3].ct | coreTransform_40| 32 | 0 | 0 |\n | transformLoop[4].ct | coreTransform_45| 32 | 0 | 0 |\n . . .\nThe reuse status of each cell is reported, beginning with the top-level hierarchy, then covering each level hierarchy contained within that level. The report progresses to the lowest level of hierarchy contained within the first sub-module, then moves on to the next one.\n\nIn this example, the top level cell is \\texttt{bft} with a cumulative reuse total of 3607 cells with 9 new cells. The row with \\texttt{bft} in parentheses show the cell reuse status contained within \\texttt{bft} and but not its sub-modules. Of the 3607 cells, only 210 are within \\texttt{bft} and the remainder are within its sub-modules. However all 9 new cells are within \\texttt{bft}. Within \\texttt{bft} is a sub-module \\texttt{arnd1} containing 256 reused cells, and no cells within \\texttt{arnd1} itself, only in sub-modules \\texttt{transformLoop[0].ct}, \\texttt{transformLoop[1].ct}, and so on.\n\nThere are 5 columns indicating cell reuse status at each level, although only the first one Discarded(Illegal) is shown. These columns have footnote references in the report with further reasons for discarding reused placement.\n\n* Discarded illegal placement due to netlist changes\n** Discarded to improve timing\n*** Discarded placement by user\n**** Discarded due to its control set source is unguided\n***** Discarded due to its connectivity has Loc Fixed Insts\n\nInstead of reporting all hierarchical levels, the \\texttt{--hierarchical} option can be used to limit the number of sub-modules to an exact number of levels. Following is the previous example, adding \\texttt{--hierarchical_depth} of 1:\n\n```\nreport_incremental_reuse --hierarchical --hierarchical_depth 1\n```\n\nThis limits reporting to the top level \\texttt{bft}. Using a \\texttt{--hierarchical_depth} of 2 reports the top and each level of hierarchy contained within \\texttt{bft}, but not below those hierarchical cells.\n### Hierarchical Implementation Reuse Summary\n\n1. Summary\n\n<table>\n<thead>\n<tr>\n<th>Instance</th>\n<th>Module</th>\n<th>Reused</th>\n<th>New</th>\n<th>Discarded(Illegal)*</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>bft</td>\n<td>(top)</td>\n<td>3607</td>\n<td>9</td>\n<td>2</td>\n</tr>\n<tr>\n<td>(bft)</td>\n<td>(top)</td>\n<td>210</td>\n<td>9</td>\n<td>2</td>\n</tr>\n<tr>\n<td>arnd1</td>\n<td>round_1</td>\n<td>256</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>arnd2</td>\n<td>round_2</td>\n<td>256</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>arnd3</td>\n<td>round_3</td>\n<td>256</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>arnd4</td>\n<td>round_4</td>\n<td>256</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>egressLoop[0].egressFifo</td>\n<td>FifoBuffer_6</td>\n<td>173</td>\n<td>0</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n\n### Timing Reports\n\nAfter completing an incremental place and route, you can analyze timing with details of cell and net reuse. Objects are tagged in timing reports to show the level of physical data reuse. This identifies whether or not your design updates are affecting critical paths.\n\nTo see incremental flow details in timing reports, use the `report_timing -label_reused` option. This generates a report showing reuse labels on input and output pins, indicating the amount of physical data reused for the pin’s cell and net. The following label descriptions are included as a legend in the timing report:\n\n- **(R)**: Both the cell placement and net routing are reused.\n- **(NR)**: Neither the cell placement nor the routing to the pin is reused.\n- **(PNR)**: The cell placement is reused but the routing to the pin is not reused.\n- **(N)**: The pin, cell, or net is a new design object, not present in the reference design.\n\nSee the following example.\n\n```\n(R) SLICE_X46Y43 LUT4 (Prop_lut4_I1_O) 0.043 -1.340 r fftI/wbDOut_reg[31]i5/O\nnet (fo=32, routed) 1.325 -0.014 fftI/wbDOut_reg[31]i5\n\n(PN) SLICE_X44Y39 MUXF7 (Prop_muxf7_S_O) 0.154 0.140 r fftI/wbcI/wbDOut_reg[0]i1/S\nfftI/wbcI/wbDOut_reg[0]i1/O\nnet (fo=1, routed) 0.000 0.140 fftI/wbcI/wbDOut_reg[0]i1\n```\n\n---\n\nSend Feedback\nObject Properties\n\nThe `read_checkpoint -incremental` command assigns two cell properties which are useful for analyzing incremental flow results using scripts or interactive Tcl commands.\n\n- **IS_REUSED**: A boolean property on cell, port, net, and pin objects. The property is set to TRUE on the respective object if any of the following incremental data is reused:\n - A cell placement\n - A port’s package pin assignment\n - Any portion of a net’s routing\n - Routing to a pin\n\n- **REUSE_STATUS**: A string property on cells and nets denoting the reuse status after incremental placement and routing.\n\n Possible values for cells are:\n - New\n - Reused\n - Discarded placement to improve timing\n - Discarded illegal placement due to netlist changes\n\n Possible values for nets are:\n - REUSED\n - NON_REUSED\n - PARTIALLY_REUSED\n\nMoving Forward After Implementation\n\nAfter implementation has completed, for both Project Mode and Non-Project Mode, the direction you take the design next depends on the results of the implementation.\n\n- Is the design fully placed and routed, or are there issues that need to be resolved?\n- Have the timing constraints and design requirements been met, or are their additional changes required to complete the design?\n- Are you ready to generate the bitstream for the Xilinx part?\nRecommended Steps After Implementation\n\nThe recommended steps after implementation are:\n\n1. Review the implementation messages.\n2. Review the implementation reports to validate key aspects of the design:\n - Timing constraints are met (report_timing_summary).\n - Utilization is as expected (report_utilization).\n - Power is as expected (report_power).\n3. Write the bitstream file.\n\n Writing the bitstream file includes a final DRC to ensure that the design does not violate any hardware rules.\n4. If any design requirements have not been met:\n a. In Project Mode, open the implemented design for further analysis.\n b. In Non-Project Mode, open a post-implementation design checkpoint.\n\nFor more information on analysis of the implemented design, see the Vivado Design Suite User Guide: Design Analysis and Closure Techniques (UG906) [Ref 9].\n\nMoving Forward in Non-Project Mode\n\nIn Non-Project Mode, the Vivado Design Suite generated messages for the design session, and wrote the messages to the Vivado log file (vivado.log). Examine this log file and the reports generated from the design data to view an accurate assessment of the current project state.\n\nMoving Forward in Project Mode\n\nIn Project Mode, the Vivado Design Suite:\n\n- Displays the messages from the log file in the Messages window.\n- Automates the creation and delivery of numerous reports for you to review.\n\nIn Project Mode, after an implementation run is complete in the Vivado IDE, you are prompted for the next step. See Figure 1-22, Project Mode - Implementation Completed.\nIn the Implementation Completed dialog box:\n\n1. Select the appropriate option:\n \n - **Open Implemented Design**\n - Imports the netlist, design constraints, the target part, and the results from place and route into the Vivado IDE for design analysis and further work as needed.\n \n - **Generate Bitstream**\n - Launches the Generate Bitstream dialog box.\n - For more information, see the *Vivado Design Suite User Guide: Programming and Debugging* (UG908) [Ref 11].\n \n - **View Reports**\n - Opens the Reports window for you to select and view the various reports produced by the Vivado tools during implementation.\n - For more information, see Viewing Implementation Reports, page 65.\n\n2. Click **OK**.\n\n---\n\n**Viewing Messages**\n\n**IMPORTANT:** Review all messages. The messages may suggest ways to improve your design for performance, power, area, and routing. Critical warnings may also expose timing constraint problems that must be resolved.\nViewing Messages in Non-Project Mode\n\nIn Non-Project Mode, review the Vivado log file (vivado.log) for:\n\n- The commands that you used during a single design session\n- The results and messages from those commands\n\n**RECOMMENDED:** Open the log file in the Vivado text editor and review the results of all commands for valuable insights.\n\nViewing Messages in Project Mode\n\nIn Project Mode, the Messages window displays a filtered list of the Vivado log. This list includes only the main Messages, Warnings, and Errors. The Messages window sorts by feature, and includes toolbar options to filter and display only specific types of messages.\n\nSee Figure 1-23, Messages Window, for an example.\n\nUse the following features when viewing messages in Project Mode:\n\n- Click the expand and collapse tree widgets to view the individual messages.\n- Check the appropriate check box in the banner to display Errors, Critical Warnings, Warnings, and Informational Messages in the Messages window.\n- Select a linked message in the Messages window to open the source file and highlight the appropriate line in the file.\n- Run **Search for Answer Record** from the Messages window popup menu to search the Xilinx Customer Support database for answer records related to a specific message.\nIncremental Compile Messages\n\nThe Vivado tools report summary results from Incremental Compile in the log file, including:\n\n- Incremental Placement Summary\n- Incremental Routing Summary\n\nIncremental Placement Summary\n\nThe following example of the Incremental Placement Summary includes a final assessment of:\n\n- Cell placement reuse\n- Runtime statistics\n\n```\n+-----------------------------------------------------------------+\n|Incremental Placement Summary |\n+-----------------------------------------------------------------+\n| Reused instances | 40336|\n| Non-reused instances | 1158|\n| %similarity | 97.21|\n+-----------------------------------------------------------------+\n\nIncremental Placement Runtime Summary\n\n|Initialization time(elapsed secs) | 87.54|\n|Incremental Placer time(elapsed secs) | 50.42|\n```\n\nIncremental Routing Summary\n\nThe Incremental Routing Summary displays reuse statistics for all nets in the design. The categories reported include:\n\n- Fully Reused\n \n The entire net's routing is reused from the reference design.\n\n- Partially Reused\n \n Some of the net's routing from the reference design is reused. Some segments are re-routed due to changed cells, changed cell placements, or both.\n• **New/Unmatched**\n\nThe net in the current design was not matched in the reference design.\n\n<table>\n<thead>\n<tr>\n<th>Incremental Routing Reuse Summary</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Type</td>\n</tr>\n<tr>\n<td>------------------------------------------</td>\n</tr>\n<tr>\n<td>Fully reused nets</td>\n</tr>\n<tr>\n<td>Partially reused nets</td>\n</tr>\n<tr>\n<td>Non Reused nets</td>\n</tr>\n</tbody>\n</table>\n\n### Viewing Implementation Reports\n\nThe Vivado Design Suite generates many types of reports, including reports on:\n\n- Timing, timing configuration, and timing summary\n- Clocks, clock networks, and clock utilization\n- Power, switching activity, and noise analysis\n\nWhen viewing reports, you can:\n\n- Browse the report file using the scroll bar.\n- Click **Find** or **Find in Files** to search for specific text.\n\n- Click **Go to the Beginning** to scroll to the beginning file.\n\n- Click **Go to the End** to scroll to end of the file.\nReporting in Non-Project Mode\n\nIn Non-Project Mode, you must run these reports manually.\n\n- Use Tcl commands to create an individual report.\n- Use a Tcl script to create a series of reports.\n\nExample Tcl Script\n\nThe following Tcl script runs a series of reports and saves them to a Reports folder:\n\n```tcl\n# Report the control sets sorted by clk, clkEn\nreport_control_sets -verbose -sort_by {clk clkEn} -file C:/Report/cntrl_sets.rpt\n# Run Timing Summary Report for post implementation timing report_timing_summary\n# -file C:/Reports/post_route_timing.rpt -name timel\n# Run Utilization Report for device resource utilization report_utilization -file\n# C:/Reports/post_route_utilization.rpt\n```\n\nOpening Reports in a Vivado IDE Window\n\nYou can open these reports in a Vivado IDE window. In the Example Tcl Script immediately above, the `report_timing_summary` command:\n\n- Uses the `-file` option to direct the output of the report to a file.\n- Uses the `-name` option to direct the output of the report to a Vivado IDE window.\n\nFigure 1-25, Control Sets Report, shows an example of a report opened in a Vivado IDE window.\n\n**TIP:** The directory to which the reports are to be written to must exist before running the report, or the file cannot be saved, and an error message will be generated.\n\nGetting Help With Implementation Reports\n\nUse the Tcl `help` command in the Vivado IDE or at the Tcl command prompt.\n\nFor a complete description of the Tcl reporting commands and their options, see the Vivado Design Suite Tcl Command Reference Guide (UG835) [Ref 13].\n\nReporting in Project Mode\n\nIn Project Mode, many reports are generated automatically. View report files in the Reports window. See Figure 1-24, Reports Window.\nThe Reports window usually opens automatically after synthesis or implementation commands are run. If the window does not open:\n\n- Select the **Reports** link in the Project Summary, or\n- Select **Windows > Reports**.\n\n**TIP:** The `tcl.pre` and `tcl.post` options of an implementation run let you output custom reports at each step in the process. These reports are not listed in the Reports window, but can be customized to meet your specific needs. For more information, see *Changing Implementation Run Settings*.\n\n\n\nThe reports available from the Reports window contain information related to the run. The selected report opens in text form in the Vivado IDE. See *Figure 1-25, Control Sets Report*. \nCross-Probing from Reports\n\nIn both Project Mode and Non-Project Mode, the Vivado IDE supports cross-probing between reports and the associated design data in different windows (for example, the Device window).\n\n- You generate the report using a menu command or Tcl command.\n- Text reports do not support cross-probing.\n\nFor example, the Reports window includes a text-based Timing Summary Report under Route Design. See Figure 1-24, Reports Window.\n\nWhen analyzing timing, it is helpful to see the design data associated with critical paths, including placement and routing resources in the Device window.\n\nTo regenerate the report in the Vivado IDE, select Tools > Timing > Report Timing Summary. The resulting report allows you to cross-probe among the various views of the design.\nCross-Probing Between Timing Report and Device Window Example\n\nFigure 1-26, Cross-Probing Between Timing Report and Device Window, shows an example of cross-probing between the Timing Summary report and the Device window. The following steps took place in this Non-Project Mode example:\n\n- A post-route design checkpoint was opened in the Vivado IDE.\n- The Timing Summary report was generated and opened using `report_timing_summary -name`.\n- The Routing Resources were enabled in the Device window.\n- When the timing path was selected in the Timing Summary report, the path was automatically cross-probed in the Device window. See Figure 1-26, Cross-Probing Between Timing Report and Device Window.\n\nFor more information on analyzing reports and strategies for design closure, see the Vivado Design Suite User Guide: Design Analysis and Closure Techniques (UG906) [Ref 9].\nChapter 2\n\nImplementation Commands\n\nAbout Implementation Commands\n\nThe Xilinx® Vivado® Design Suite includes many features to manage and simplify the implementation process for project-based designs. These features include the ability to step manually through the implementation process.\n\nFor more information, see Running Implementation in Project Mode, page 21, in Chapter 1, Vivado Implementation Process.\n\nNon-Project based designs must be manually taken through each step of the implementation process using Tcl commands or Tcl scripts.\n\nNote: For more information about Tcl commands, see the Vivado Design Suite Tcl Command Reference Guide (UG835) [Ref 13], or type <command> -help.\n\nFor more information, see Running Implementation in Non-Project Mode, page 18, in Chapter 1, Vivado Implementation Process.\n\nImplementation Sub-Processes\n\nPutting a design through the Vivado implementation process, whether in Project Mode or Non-Project Mode, consists of several sub-processes:\n\n- **Open Synthesized Design**: Combines the netlist, the design constraints, and Xilinx target part data, to build the in-memory design to drive implementation.\n\n- **Opt Design**: Optimizes the logical design and fits it onto the target Xilinx FPGA device.\n\n- **Power Opt Design**: Optimizes elements of the design to reduce power demands of the implemented FPGA device.\n\nNote: This step is optional.\n• **Place Design**: Places the design onto the target Xilinx device.\n\n• **Phys Opt Design**: Optimizes timing on the negative-slack paths of a design using various physical optimization techniques.\n\n *Note*: This step is optional.\n\n• **Route Design**: Routes the design onto the target Xilinx device.\n\n• **Write Bitstream**: Generates a bitstream for Xilinx device configuration.\n\n *Note*: Although not technically part of an implementation run, Write Bitstream is available as a separate step.\n\nTo provide a better understanding of the individual steps in the implementation process, the details of each step, and the associated Tcl commands, are documented in this chapter. For a complete description of the Tcl reporting commands and their options, see the [Vivado Design Suite Tcl Command Reference Guide](UG835) [Ref 13].\n\n---\n\n**Opening the Synthesized Design**\n\nThe first steps in implementation are to read the netlist from the synthesized design into memory and apply design constraints. You can open the synthesized design in various ways, depending on the flow used.\n\n**Creating the In-Memory Design**\n\nTo create the in-memory design, the Vivado Design Suite uses the following process to combine the netlist files, constraint files, and the target part information:\n\n1. Assembles the netlist.\n\n The netlist is assembled from multiple sources if needed. Designs can consist of a mix of structural Verilog, EDIF, and NGC.\n\n2. Transforms legacy netlist primitives to the currently supported subset of Unisim primitives.\n\n *TIP*: Use `report_transformed_primitives` to generate a list of transformed cells.\n\n\n • The Vivado tools create implicit shapes of cells based on their connectivity or placement constraints to simplify placement.\n• Examples of implicit shapes include:\n - A relatively placed macro (RPM).\n \n **Note:** RPMs are placed as a group rather than as individual cells.\n - A long carry chain that needs to be placed in multiple slices.\n \n **Note:** The CARRY4 elements making up the carry chains must belong to a single shape to ensure downstream placement aligns it into vertical slices.\n\n**Tcl Commands**\n\nThe following Tcl commands can be used to read the synthesized design into memory, depending on the source files in the design, and the state of the design:\n\n- `synth_design`\n- `read_checkpoint`\n- `open_run`\n- `link_design`\n\n**Table 2-1: Modes in Which Tcl Commands Can Be Used**\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Project Mode</th>\n<th>Non-Project Mode</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>synth_design</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>read_checkpoint</td>\n<td></td>\n<td>X</td>\n</tr>\n<tr>\n<td>open_run</td>\n<td>X</td>\n<td></td>\n</tr>\n<tr>\n<td>link_design</td>\n<td>X</td>\n<td>X</td>\n</tr>\n</tbody>\n</table>\n\n**synth_design**\n\nThe `synth_design` command can be used in both Project Mode and Non-Project Mode. It runs Vivado synthesis on RTL sources with the specified options, and reads the design into memory after synthesis.\n\n```\nsynth_design [-name <arg>] [-part <arg>] [-constrset <arg>] [-top <arg>]\n [-include_dirs <args>] [-generic <args>] [-verilog_define <args>]\n [-flatten_hierarchy <arg>] [-gated_clock_conversion <arg>]\n [-effort_level <arg>] [-rtl] [-no_iobuf] [-bufg <arg>]\n [-fanout_limit <arg>] [-mode <arg>] [-fsm_extraction <arg>]\n [-keep_equivalent_registers] [-quiet] [-verbose]\n```\n**synth_design Example Script**\n\nThe following is an excerpt from the `create_bft_batch.tcl` script found in the `examples/Vivado_Tutorials` directory of the software installation.\n\n```tcl\n# Setup design sources and constraints\nread_vhdl -library bftLib [ glob ./Sources/hdl/bftLib/*.vhdl ]\nread_vhdl ./Sources/hdl/bft.vhdl\nread_verilog [ glob ./Sources/hdl/*.v ]\nread_xdc ./Sources/bft_full.xdc\n\n# Run synthesis, report utilization and timing estimates, write design checkpoint\nsynth_design -top bft -part xc7k70tfbg484-2 -flatten rebuilt\nwrite_checkpoint -force $outputDir/post_synth\n```\n\nFor more information on using the `synth_design` example script, see the *Vivado Design Suite Tutorial: Design Flows Overview* (UG888) [Ref 15].\n\nThe `synth_design` example script reads VHDL and Verilog files; reads a constraint file; and synthesizes the design on the specified part. The design is opened by the Vivado tools into memory when `synth_design` completes. A design checkpoint is written after completing synthesis.\n\nFor a complete description of the Tcl commands and their options, see the *Vivado Design Suite Tcl Command Reference Guide* (UG835) [Ref 13].\n\n**read_checkpoint**\n\nThe `read_checkpoint` command simply reads the associated checkpoint file, without opening a design or project in-memory. To create a project from the imported checkpoint, use the `open_checkpoint` command instead of `read_checkpoint`, or use the `link_design` command to open the in-memory design from the checkpoint or checkpoint files currently read.\n\n**read_checkpoint Syntax**\n\n```\nread_checkpoint [-part <arg>] [-quiet] [-verbose] <file>\n```\n\n**read_checkpoint Example Script**\n\n```tcl\n# Read the specified design checkpoint and create an in-memory design.\nread_checkpoint C:/Data/post_synth.dcp\n```\n\nThe `read_checkpoint` example script opens the post synthesis design checkpoint file.\n**open_run**\n\nThe **open_run** command opens a previously completed synthesis or implementation run, then loads the in-memory design of the Vivado tools.\n\n**IMPORTANT:** The **open_run** command works in Project Mode only. Design runs are not supported in Non-Project Mode.\n\nUse **open_run** before implementation on an RTL design in order to open a previously completed Vivado synthesis run then load the synthesized netlist into memory.\n\n**TIP:** Because the in-memory design is updated automatically, you do not need to use **open_run** after **synth_design**. You need to use **open_run** only to open a previously completed synthesis run from an earlier design session.\n\nThe **open_run** command is for use with RTL designs only. To open a netlist-based design, use **link_design**.\n\n**open_run Syntax**\n\n```\nopen_run [-name <arg>] [-quiet] [-verbose] <run>\n```\n\n**open_run Example Script**\n\n```\n# Open named design from completed synthesis run\nopen_run -name synth_1 synth_1\n```\n\nThe **open_run** example script opens a design (**synth_1**) into the Vivado tools memory from the completed synthesis run (also named **synth_1**).\n\nIf you use **open_run** while a design is already in memory, the Vivado tools prompt you to save any changes to the current design before opening the new design.\n\n**link_design**\n\nThe **link_design** command creates an in-memory design from netlist sources (such as from a third-party synthesis tool), and links the netlists and design constraints with the target part.\n\n**TIP:** The **link_design** command supports both Project Mode and Non-Project Mode to create the netlist design.\nlink_design Syntax\n\n link_design [-name <arg>] [-part <arg>] [-constrset <arg>] [-top <arg>]\n [-mode <arg>] [-quiet] [-verbose]\n\nlink_design Example Script\n\n # Open named design from netlist sources.\n link_design -name netDriven -constrset constrs_1 -part xc7k325tfbg900-1\n\nIf you use link_design while a design is already in memory, the Vivado tools prompt you to\nsave any changes to the current design before opening the new design.\n\nRECOMMENDED: After creating the in-memory synthesized design in the Vivado tools, review Errors\nand Critical Warnings for missing or incorrect constraints. After the design is successfully created, you\ncan begin running analysis, generating reports, applying new constraints, or running implementation.\n\nImmediately after opening the in-memory synthesized design, run\nreport_timing_summary to check timing constraints. This ensures that the design goals\nare complete and reasonable.\n\nLogic Optimization\n\nLogic optimization ensures the most efficient logic design before attempting placement. It\nperforms a netlist connectivity check to warn of potential design problems such as nets with\nmultiple drivers and un-driven inputs. Logic optimization also performs Block RAM power\noptimization.\n\nOften design connectivity errors are propagated to the logic optimization step where the\nflow fails. It is important to ensure valid connectivity using DRC Reports before running\nimplementation.\n\nAvailable Logic Optimizations\n\nThe Vivado tools can perform the following logic optimizations on the in-memory design:\n\n- Retargeting (Default)\n- Constant Propagation (Default)\n- Sweep (Default)\n- Block RAM Power Optimization (Default)\n- Remap\n- Resynth Area\n- Resynth Sequential Area\nIMPORTANT: Logic optimization can be limited to specific optimizations by choosing the corresponding command options. Only those specified optimizations are run, while all others are disabled, even those normally performed by default.\n\nRetargeting (Default)\n\nRetargeting replaces one cell type with another to ease optimization. Example: A MUXF7 replaced by a LUT3 can be combined with other LUTs. In addition, simple cells such as inverters are absorbed into downstream logic.\n\nConstant Propagation (Default)\n\nConstant Propagation propagates constant values through logic, which results in:\n\n- **Eliminated logic**\n \n Example: an AND with a constant 0 input\n\n- **Reduced logic**\n \n Example: A 3-input AND with a constant 1 input is reduced to a 2-input AND.\n\n- **Redundant logic**\n \n Example: A 2-input OR with a logic 0 input is reduced to a wire.\n\nSweep (Default)\n\nSweep removes cells that have no loads.\n\nBlock RAM Power Optimization (Default)\n\nBlock RAM Power Optimization enables power optimization on Block RAM cells including:\n\n- Changing the WRITE_MODE on unread ports of true dual-port RAMs to NO_CHANGE.\n- Applying intelligent clock gating to Block RAM outputs.\n\nRemap\n\nRemap combines multiple LUTs into a single LUT to reduce the depth of the logic.\n\nResynth Area\n\nResynth Area performs re-synthesis in area mode to reduce the number of LUTs.\nResynth Sequential Area\n\nResynth Sequential Area performs re-synthesis to reduce both combinational and sequential logic. Performs a superset of the optimization of Resynth Area.\n\n**IMPORTANT:** Each use of logic optimization affects the in-memory design, not the synthesized design that was originally opened.\n\nopt_design\n\nThe opt_design command optimizes the current netlist. It also reads the in-memory design, optimizes it, and outputs the optimized design back into memory.\n\n**opt_design Syntax**\n\n```\n```\n\n**opt_design Example Script**\n\n```sh\n# Run logic optimization, save results in a checkpoint, report timing estimates\nopt_design -retarget -propconst -sweep\nwrite_checkpoint -force $outputDir/post_opt\nreport_timing_summary -file $outputDir/post_opt_timing_summary.rpt\n```\n\nThe opt_design example script performs logic optimization on the in-memory design, rewriting it in the process. It also writes a design checkpoint after completing optimization, and generates a timing summary report and writes the report to the specified file.\n\nRestrict Optimization to Listed Types\n\nUse command line options to restrict optimization to one or more of the listed types. For example, use the following to skip block RAM optimization that is run by default:\n\n```\nopt_design -retarget -propconst -sweep\n```\n\nUsing Directives\n\nDirectives provide different modes of behavior for the opt_design command. Only one directive may be specified at a time. The directive option is incompatible with other options.\n\nThe Placer has the most directives of all commands because placement typically has the most impact on overall design performance guidelines on which directives may benefit which types of designs:\n\n- Block placement directives for designs with many Block RAM, DSP blocks, or both.\n• NetDelay directives for designs that anticipate many long-distance net connections and nets that fan out to many different modules.\n\n• SpreadLogic directives for designs with very high connectivity that tend to create congestion.\n\n• ExtraPostPlacementOpt for all design types.\n\n• SSI directives for SSI designs that may benefit from different styles of partitioning to relieve congestion or improve timing.\n\nThe following directives are available:\n\n• **Explore**: Runs multiple passes of optimization.\n\n• **ExploreArea**: Runs multiple passes of optimization with emphasis on reducing combinational logic.\n\n• **AddRemap**: Runs the default logic optimization flow and includes LUT remapping to reduce logic levels.\n\n• **ExploreSequentialArea**: Runs multiple passes of optimization with emphasis on reducing registers and related combinational logic.\n\n• **RuntimeOptimized**: Runs minimal passes of optimization, trading design performance for faster runtime.\n\n**Using the -verbose Option**\n\nTo better analyze optimization results, use the **-verbose** option to see additional details of the logic affected by **opt_design** optimization.\n\nThe **-verbose** option is off by default due to the potential for a large volume of additional messages. Use the **-verbose** option if you believe it might be helpful.\n\n**IMPORTANT**: The **opt_design** command operates on the in-memory design. If run multiple times, the subsequent run optimizes the results of the previous run. Therefore you may need to reload the implemented design before adding the **-verbose** option.\n\n**Logic Optimization Constraints**\n\nThe Vivado Design Suite respects the **DONT_TOUCH** property during logic optimization. It does not optimize away nets with these properties.\n\nFor more information, see the *Vivado Design Suite User Guide: Synthesis* (UG901) [Ref 7].\n\nThe **DONT_TOUCH** property is typically placed on leaf cells to prevent them from being optimized. **DONT_TOUCH** on a hierarchical cell preserves the cell boundary, but optimization may still occur within the cell.\nGlobal Clock Buffer Insertion\n\nLogic optimization conservatively inserts global clock buffers on high-fanout clock and reset nets whenever (1) the net fanout is greater than 50,000 (2) there are fewer than 12 total global clock buffers in the design. This is provided mainly to help bottom-up flows, where both an out-of-context (OOC) module and the top module are skipped for global clock buffer insertion because the OOC module is a black box.\n\nPower Optimization\n\nPower optimization optimizes dynamic power using clock gating (optional). It can be used in both Project Mode and Non-Project Mode, and can be run after logic optimization or after placement to reduce power demand in the design. Power optimization includes Xilinx intelligent clock gating solutions that can reduce dynamic power in FPGA designs, but do not change the clocks or logic of the design.\n\nFor more information, see the Vivado Design Suite User Guide: Power Analysis and Optimization (UG907) [Ref 10].\n\nVivado Tools Power Analysis\n\nThe Vivado tools analyze all portions of the design, including legacy and third-party IP blocks. It also identifies output logic from sourcing registers that does not contribute to the result for each clock cycle.\n\nUsing Clock Enables (CEs)\n\nThe Vivado power optimizer takes advantage of the abundant supply of Clock Enables (CEs) available in the logic of Xilinx 7 series FPGA devices. The tools create fine-grain clock gating, or logic gating signals, that eliminate unnecessary switching activity in the register.\n\nIn addition, at the flip-flop level, CEs are actually gating the clock rather than selecting between the D input and feedback Q output of the flip-flop. This increases the performance of the CE input but also reduces clock power.\nIntelligent Clock Gating\n\nIntelligent clock gating also reduces power for dedicated block RAMs in either simple dual-port or true dual-port mode. See Figure 2-2, Leveraging BRAM Enables.\n\nThese blocks include several enables:\n\n- Array enable\n- Write enable\n- Output register clock enable\n\nMost of the power savings comes from using the array enable. The Vivado power optimizer implements functionality to reduce power when no data is being written and when the output is not being used.\n\npower_opt_design\n\nThe `power_opt_design` command analyzes and optimizes the design. It analyzes and optimizes the entire design as a default. The command also performs intelligent clock gating to optimize power.\n\npower_opt_design Syntax\n\n```\npower_opt_design [-quiet] [-verbose]\n```\nIf you do not want to analyze and optimize the entire design, configure the optimizer with `set_power_opt`. This lets you specify the appropriate cell types or hierarchy to include or exclude in the optimization.\n\nThe syntax for `set_power_opt` is:\n\n```\nset_power_opt [-include_cells <args>] [-exclude_cells <args>] [-clocks <args>]\n [-cell_types <args>] [-quiet] [-verbose]\n```\n\n**Note:** block RAM power optimization is skipped if it is run using `opt_design`.\n\n---\n\n### Placement\n\nThe Vivado placer engine positions cells from the netlist onto specific sites in the target Xilinx device. Like the other implementation commands, the Vivado placer works from, and updates, the in-memory design.\n\n### Design Placement Optimization\n\nThe Vivado placer engine simultaneously optimizes the design placement for:\n\n- **Timing slack:** Placement of cells in timing-critical paths is chosen to minimize negative slack.\n- **Wirelength:** Overall placement is driven to minimize the overall wirelength of connections.\n- **Congestion:** The Vivado placer monitors pin density and spreads cells to reduce potential routing congestion.\n\n### Design Rule Checks\n\nBefore starting placement, Vivado implementation runs Design Rule Checks (DRCs), including user-selected DRCs from `report_drc`, and built-in DRCs internal to the Vivado placer engine. Internal DRCs report many issues, including memory Interface Generator (MIG) cells without LOC constraints, and I/O banks with conflicting IOSTANDARDs.\n\n### Clock and I/O Placement\n\nAfter design rule checking, the Vivado placer places clock and I/O cells before placing other logic cells. Clock and I/O cells are placed concurrently because they are often related through complex placement rules specific to the targeted Xilinx device.\nPlacer Targets\n\nThe placer targets at this stage of placement are:\n\n- I/O ports and logic\n- Global and local clock buffers\n- Clock management tiles (MMCMs and PLLs)\n- Gigabit Transceiver (GT) cells\n\nPlacing Unfixed Logic\n\nWhen placing unfixed logic during this stage of placement, the placer adheres to physical constraints, such as LOC properties and Pblock assignments. It also validates existing LOC constraints against the netlist connectivity and device sites. Certain IP (such as MIGs and GTs) are generated with device-specific placement constraints.\n\nIMPORTANT: Due to the device I/O architecture, a LOC property often constrains cells other than the cell to which LOC has been applied. A LOC on an input port also fixes the location of its related I/O buffer, IDELAY, and ILOGIC. Conflicting LOC constraints cannot be applied to individual cells in the input path. The same applies for outputs and GT-related cells.\n\nClock Resources Placement Rules\n\nClock resources must follow the placement rules described in the 7 Series FPGAs Clocking Resources (UG472) [Ref 12]. For example, an input that drives a global clock buffer must be located at a clock-capable I/O site, and must be located in the same upper or lower half of the device. These clock placement rules are also validated against the logical netlist connectivity and device sites.\n\nWhen Clock and I/O Placement Fails\n\nIf the Vivado placer fails to find a solution for the clock and I/O placement, the placer reports the placement rules that were violated, and briefly describes the affected cells. In some cases, the Vivado placer provisionally places cells at sites, and attempts to place other cells as it tries to solve the placement problem. The provisional placements often pinpoint the source of clock and I/O placement failure. Manually placing a cell that failed provisional placement may help placement converge.\n\nTIP: Use place_ports to run the clock and I/O placement step first. Then run place_design. If port placement fails, the placement is saved to memory to allow failure analysis. For more information, run place_ports -help from the Vivado Tcl command prompt.\nGlobal Placement, Detailed Placement, and Packing and Legalization\n\nAfter Clock and I/O placement, the remaining placement phases consist of:\n\n- Global placement\n- Detailed placement\n- Packing and legalization\n\nAfter placement, an estimated timing summary is output to the log file:\n\n```\nPhase 12 Placer Reporting\nINFO: [Place-100] Post Placement Timing Summary | WNS=-0.08836| TNS=-1.479 |\n```\n\nwhere\n\n- WNS = Worst Negative Slack\n- TNS = Total Negative Slack\n\n**RECOMMENDED:** Run `report_timing` after placement to check the critical paths. Paths with very large negative slack may need manual placement, further constraining, or logic restructuring to achieve timing closure.\n\nplace_design\n\nThe `place_design` command automatically places ports and cells. Like the other implementation commands, `place_design` is re-entrant or incremental in nature. For a partially placed design, the Vivado placer uses the existing placement as the starting point, instead of starting from scratch.\n\n**place_design Syntax**\n\n```\nplace_design [-directive <arg>] [-no_timing_driven] [-unplace] [-cells <args>]\n[-post_place_opt] [-quiet] [-verbose]\n```\n\n**place_design Example Script**\n\n```\n# Run placement, save results to checkpoint, report timing estimates\nplace_design\nwrite_checkpoint -force $outputDir/post_place\nreport_timing_summary -file $outputDir/post_place_timing_summary.rpt\n```\n\nThe `place_design` example script places the in-memory design. It then writes a design checkpoint after completing placement, generates a timing summary report, and writes the report to the specified file.\nUsing Directives\n\nDirectives provide different modes of behavior for the `place_design` command. Only one directive may be specified at a time. The directive option is incompatible with other options.\n\nPlacer Directives\n\nBecause placement typically has the greatest impact on overall design performance, the Placer has the most directives of all commands. Table 2-2, Directive Guidelines, shows which directives may benefit which types of designs.\n\n<table>\n<thead>\n<tr>\n<th>Directive</th>\n<th>Designs Benefitted</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Block Placement</td>\n<td>Designs with many Block RAM, DSP blocks, or both</td>\n</tr>\n<tr>\n<td>NetDelay</td>\n<td>Designs that anticipate many long-distance net connections and nets that fan out to many different modules</td>\n</tr>\n<tr>\n<td>SpreadLogic</td>\n<td>Designs with very high connectivity that tend to create congestion</td>\n</tr>\n<tr>\n<td>ExtraPostPlacement Opt</td>\n<td>All design types</td>\n</tr>\n<tr>\n<td>SSI</td>\n<td>SSI designs that may benefit from different styles of partitioning to relieve congestion or improve timing.</td>\n</tr>\n</tbody>\n</table>\n\nAvailable Directives\n\n- **Explore**: Higher placer effort in detail placement and post-placement optimization.\n- **WLDrivenBlockPlacement**: Wirelength-driven placement of RAM and DSP blocks. Override timing-driven placement by directing the Placer to minimize the distance of connections to and from blocks.\n- **LateBlockPlacement**: Defers detailed placement of RAMB and DSP blocks to the final stages of placement. Normally blocks are committed to valid sites early in the placement process. Instead, the Placer uses coarse block placements that may not align with proper columns, then places blocks at valid sites during detail placement.\n- **ExtraNetDelay_high**: Increases estimated delay of high fanout and long-distance nets. Three levels of pessimism are supported: high, medium, and low. `ExtraNetDelay_high` applies the highest level of pessimism.\n- **ExtraNetDelay_medium**: Increases estimated delay of high fanout and long-distance nets. Three levels of pessimism are supported: high, medium, and low. `ExtraNetDelay_medium` applies the default level of pessimism.\n- **ExtraNetDelay_low**: Increases estimated delay of high fanout and long-distance nets. Three levels of pessimism are supported: high, medium, and low. `ExtraNetDelay_low` applies the lowest level of pessimism.\n• **SpreadLogic_high**: Spreads logic throughout the device. Three levels are supported: high, medium, and low. **SpreadLogic_high** achieves the highest level of spreading.\n\n• **SpreadLogic_medium**: Spreads logic throughout the device. Three levels are supported: high, medium, and low. **SpreadLogic_medium** achieves a nominal level of spreading.\n\n• **SpreadLogic_low**: Spreads logic throughout the device. Three levels are supported: high, medium, and low. **SpreadLogic_low** achieves a minimal level of spreading.\n\n• **ExtraPostPlacementOpt**: Higher placer effort in post-placement optimization.\n\n• **SSI_ExtraTimingOpt**: Use an alternate algorithm for timing-driven partitioning across SLRs.\n\n• **SSI_SpreadSLLs**: Partition across SLRs and allocate extra area for regions of higher connectivity.\n\n• **SSI_BalanceSLLs**: Partition across SLRs while attempting to balance SLLs between SLRs.\n\n• **SSI_BalanceSLRs**: Partition across SLRs to balance number of cells between SLRs.\n\n• **SSI_HighUtilSLRs**: Force the placer to attempt to place logic closer together in each SLR.\n\n• **RuntimeOptimized**: Run fewest iterations, trade higher design performance for faster runtime.\n\n• **Quick**: Absolute, fastest runtime, non-timing-driven, performs the minimum required for a legal design.\n\n• **Default**: Run **place_design** with default settings.\n\n**TIP:** Use the **-directive** option to explore different placement options for your design.\n\n**Using the -unplace Option**\n\nThe **-unplace** option unplaces all cells and all ports in a design that do not have fixed locations. An object with fixed location has an IS_LOC_FIXED property value of true.\n\n**Using the -no_timing_driven Option**\n\nThe **-no_timing_driven** option disables the default timing driven placement algorithm. This results in a faster placement based on wire lengths, but ignores any timing constraints during the placement process.\n\n**Using the -verbose Option**\n\nTo better analyze placement results, use the **-verbose** option to see additional details of the cell and I/O placement by the **place_design** command.\nThe `-verbose` option is off by default due to the potential for a large volume of additional messages. Use the `-verbose` option if you believe it might be helpful.\n\n**Using the `-post_place_opt` Option**\n\nPost placement optimization is a placement optimization that can potentially improve critical path timing at the expense of additional runtime. The optimization is performed on a fully placed design with timing violations. For each of the top few critical paths, the placer tries moving critical cells to improve delay and commits new cell placements if they improve estimated delay. For designs with longer runtimes and relatively more critical paths, these placement passes may further improve timing.\n\nThis optimization can be run at any stage after placement, and can be particularly effective on a routed design. Be aware of the following when running this optimization on a routed design:\n\n- Because the timing data reflects the actual routed delays, it ensures the optimization considers the most critical paths.\n- When evaluating cell movements, the placer must estimate delays based on cell placements. It does not have access to the actual route delays.\n- If new cell placements are committed, the related nets become unrouted and it is required to run `route_design` to route those nets.\n\nSee the following examples:\n\n1. Run post placement optimization after placement:\n\n ```\n place_design\n place_design -post_place_opt\n ```\n\n2. Run post placement optimization after routing:\n\n ```\n place_design\n phys_opt_design\n route_design\n place_design -post_place_opt\n route_design\n ```\n\n3. Run multiple iterations of post placement optimization in a loop, after routing. For convenience, the implementation commands are wrapped in a Tcl proc called `runPPO` with arguments to choose the number of iterations and whether or not to enable `phys_opt_design` in each iteration:\n\n ```\n proc runPPO { {numIters 1} {enablePhysOpt 1} } {\n for {set i 0} {$i < $numIters} {incr i} {\n place_design -post_place_opt\n if {$enablePhysOpt != 0} {\n phys_opt_design\n }\n route_design\n }\n }\n ```\nPhysical Optimization\n\nPhysical optimization optionally performs timing-driven optimization on the negative-slack paths of a design. Optimizations involve replication, retiming, hold fixing, and placement improvement. Physical optimization automatically performs all necessary netlist and placement changes.\n\nIf a design does not have negative slack, and a physical optimization with a timing based optimization option is requested, the command exits quickly without performing optimization.\n\nAvailable Physical Optimizations\n\nThe Vivado tools perform the following physical optimizations on the in-memory design:\n\n- High-Fanout Optimization (Default)\n- Placement-Based Optimization (Default)\n- Rewire (Default)\n- Critical-Cell Optimization (Default)\n- DSP Register Optimization (Default)\n- BRAM Register Optimization (Default)\n- Shift Register Optimization (Default)\n- Critical Pin Optimization (Default)\n- Block RAM Enable Optimization (Default)\n- Hold-Fixing\n- Retiming\n- Forced Net Replication\n\nIMPORTANT: Physical optimization can be limited to specific optimizations by choosing the corresponding command options. Only those specified optimizations are run, while all others are disabled, even those normally performed by default.\nPhysical Optimization\n\nHigh-Fanout Optimization (Default)\n\nHigh-Fanout Optimization works as follows:\n\n1. High fanout nets, with negative slack within a percentage of the WNS, are considered for replication.\n2. Loads are clustered based on proximity, and drivers are replicated and placed for each load cluster.\n3. Timing is re-analyzed, and logical changes are committed if timing is improved.\n4. After replication, the design is checked again for high fanout nets to replicate. If high fanout nets still exist, the replication process continues until there are no high fanout nets to optimize.\n\nPlacement-Based Optimization (Default)\n\nPlacement-Based Optimization optimizes placement on the critical path by re-placing all the cells in the critical path to reduce wire delays.\n\nRewire (Default)\n\nRewire optimization the critical path by swapping connections on LUTs to reduce the number of logic levels for critical signals. LUT equations are modified to maintain design functionality.\n\nCritical-Cell Optimization (Default)\n\nCritical-Cell Optimization replicates cells in failing paths. If the loads on a specific cell are placed far apart, the cell may be replicated with new drivers placed closer to load clusters. High fanout is not a requirement for this optimization to occur, but the path must fail timing with slack within a percentage of the worst negative slack.\n\nDSP Register Optimization (Default)\n\nDSP Register Optimization can move registers out of the DSP cell into the logic array or from logic to DSP cells if it improves the delay on the critical path.\n\nBRAM Register Optimization (Default)\n\nBRAM Register Optimization can move registers out of the BRAM cell into the logic array or from logic to BRAM cells if it improves the delay on the critical path.\nShift Register Optimization (Default)\n\nThe shift register optimization improves timing on negative slack paths between shift register cells (SRLs) and other logic cells.\n\nIf there are timing violations to or from shift register cells (SRL16E or SRLC32E), the optimization extracts a register from the beginning or end of the SRL register chain and places it into the logic fabric to improve timing. The optimization shortens the wirelength of the original critical path.\n\nThe optimization only moves registers from a shift register to logic fabric, but never from logic fabric into a shift register, because the latter never improves timing.\n\nThe prerequisites for this optimization to occur are:\n\n• The SRL address must be one or greater, such that there are register stages that can be moved out of the SRL.\n• The SRL address must be a constant value, driven by logic 1 or logic 0.\n• There must be a timing violation ending or beginning from the SRL cell that is among the worst critical paths.\n\nCertain circuit topologies are not optimized:\n\n• SRLC32E that are chained together to form larger shift registers are not optimized.\n• SRLC32E using a Q31 output pin.\n• SRL16E that are combined into a single LUT with both O5 and O6 output pins used.\n\nRegisters moved from SRLs to logic fabric are FDRE cells. The FDRE and SRL INIT properties are adjusted accordingly as is the SRL address. Following is an example.\nA critical path begins at a shift register (SRL16E) `srl_inste`, as shown in Figure 2-3, Critical Path Starting at Shift Register `srl_inste`.\n\nAfter shift register optimization, the final stage of the shift register is pulled from the SRL16E and placed in the logic fabric to improve timing, as shown in Figure 2-4, Critical Path after Shift Register Optimization.\nThe `srl_inste` SRL16E address is decremented to reflect one fewer internal register stage. The original critical path is now shorter as the `sr1opt` register is placed closer to the downstream cells and the FDRE cell has a relatively faster clock-to-output delay.\n\n**Critical Pin Optimization (Default)**\n\nCritical pin optimization performs remapping of logical LUT input pins to faster physical pins to improve critical path timing. A critical path traversing a logical pin mapped to a slow physical pin such as A1 or A2 is reassigned to a faster physical pin such as A6 or A5 if it improves timing. A cell with a LOCK_PINS property is skipped, and the cell retains the mapping specified by LOCK_PINS. Logical-to-physical pin mapping is given by the command `get_site_pins`.\n\n**Block RAM Enable Optimization (Default)**\n\nThe block RAM enable optimization improves timing on critical paths involving power-optimized block RAMs.\n\nPre-placement block RAM power optimization restructures the logic driving block RAM read and write enable inputs, to reduce dynamic power consumption. After placement, the restructured logic may become timing-critical. The block RAM enable optimization reverses the enable-logic optimization to improve the slack on the critical enable-logic paths.\n\n**Hold-Fixing**\n\n`Hold-Fixing` attempts to improve slack of high hold violators by increasing delay on the hold critical path.\n\n**Retiming**\n\n`Retiming` improves the delay on the critical path by moving registers across combinational logic.\n\n**Forced Net Replication**\n\n`Forced Net Replication` forces the net drivers to be replicated, regardless of timing slack. Replication is based on load placements and requires manual analysis to determine if replication is sufficient. If further replication is required, nets can be replicated repeatedly by successive commands. Although timing is ignored, the net must be in a timing-constrained path to trigger the replication.\nPhysical Optimization Reports\n\nPhysical Optimization reports each net processed for optimization, and a summary of the optimization performed (if any).\n\nTIP: Replicated objects are named by appending _replica to the original object name, followed by the replicated object count.\n\nphys_opt_design\n\nIMPORTANT: The phys_opt_design command optionally performs physical optimizations such as timing-driven replication of high fanout nets to improve timing results. Running phys_opt_design on a routed design is not supported.\n\nphys_opt_design Syntax\n\n```\nphys_opt_design [-fanout_opt] [-placement_opt] [-rewire] [-critical_cell_opt]\n[-dsp_register_opt] [-bram_register_opt] [-bram_enable_opt]\n[-shift_register_opt] [-hold_fix] [-retime]\n[-force_replication_on_nets <args>] [-directive <arg>]\n[-critical_pin_opt] [-quiet] [-verbose]\n```\n\nphys_opt_design Example Script\n\n```\n# Run physical optimization, save results to checkpoint, report timing estimates\nphys_opt_design\nwrite_checkpoint -force $outputDir/post_phys_opt.dcp\nreport_timing_summary -file $outputDir/post_phys_opt_timing_summary.rpt\n```\n\nThe phys_opt_design example script performs physical optimization on in-memory design, rewriting it in the process. It then writes a design checkpoint after completing physical optimization, and generates a timing summary report and writes the report to the specified file.\n\nUsing Directives\n\nDirectives provide different modes of behavior for the phys_opt_design command. Only one directive may be specified at a time and the directive option is incompatible with other options. The following directives are available:\n\n- **Explore**: Run different algorithms in multiple passes of optimization, including replication for very high fanout nets.\n\n- **ExploreWithHoldFix**: Run different algorithms in multiple passes of optimization, including hold violation fixing and replication for very high fanout nets.\n• **AggressiveExplore**: Similar to Explore but with different optimization algorithms and more aggressive goals.\n\n• **AlternateReplication**: Use different algorithms for performing critical cell replication.\n\n• **AggressiveFanoutOpt**: Uses different algorithms for fanout-related optimizations with more aggressive goals.\n\n• **AlternateDelayModeling**: Performs all optimizations using alternate algorithms for estimating net delays.\n\n• **AddRetime**: Performs the default `phys_opt_design` flow and adds register retiming.\n\n• **Default**: Run `phys_opt_design` with default settings.\n\n**Using the -verbose Option**\n\nTo better analyze physical optimization results, use the `-verbose` option to see additional details of the optimizations performed by the `phys_opt_design` command.\n\nThe `-verbose` option is off by default due to the potential for a large volume of additional messages. Use the `-verbose` option if you believe it might be helpful.\n\n**IMPORTANT**: The `phys_opt_design` command operates on the in-memory design. If run twice, the second run optimizes the results of the first run.\n\n**Physical Optimization Constraints**\n\nThe Vivado Design Suite respects the DONT_TOUCH property during physical optimization. It does not perform physical optimization on nets or cells with these properties. Additionally, Pblock assignments are obeyed such that replicated logic inherits the Pblock assignments of the original logic. Timing exceptions are also copied from original to replicated cells.\n\nFor more information, see the *Vivado Design Suite User Guide: Synthesis* (UG901) [Ref 7].\n\nThe DONT_TOUCH property is typically placed on leaf cells to prevent them from being optimized. DONT_TOUCH on a hierarchical cell preserves the cell boundary, but optimization may still occur within the cell.\nRouting\n\nThe Vivado router performs routing on the placed design, and performs optimization on the routed design to resolve hold time violations. It is timing driven by default, although this can be disabled.\n\nRouting Modes\n\nThe router can be run in two modes:\n\n• Normal Mode\n• Re-Entrant Mode\n\nNormal Mode\n\nNormal Mode is the default. In Normal Mode, the Vivado router starts with a placed design, and attempts to route all nets.\n\nThe Vivado router can start with a placed design that is:\n\n• Unrouted\n• Partially routed\n• Fully routed\n\nThe `route_design` command is incremental in nature. For a partially routed design, the Vivado router uses the existing routes as the starting point, instead of starting from scratch.\n\nRe-Entrant Mode\n\nLike other implementation commands, the router is re-entrant. Re-entrant means that the router continues routing a design with existing routes, instead of discarding them and starting from scratch.\n\nRECOMMENDED: Because routing initialization is costly in terms of runtime (especially for multiple re-entrant routing passes), use Re-Entrant Mode when you intend to run multiple routing passes for a sequence of operations.\n\nWithout Re-Entrant Mode, the Vivado router exits and clears its memory after each routing operation, requiring the router to be initialized each time it is run. This can be time consuming for multiple routing steps.\n\nIn Re-Entrant Mode, the Vivado router keeps its data structures in memory in anticipation of subsequent routing operations. Subsequent commands such as unrouting and routing individual nets can be performed immediately.\nDesign Rule Checks\n\nBefore starting routing, the Vivado tools run Design Rule Checks (DRC), including:\n\n- User-selected DRCs from report_drc\n- Built-in DRCs internal to the Vivado router engine\n\nRouting Priorities\n\nThe Vivado Design Suite routes global resources first, such as:\n\n- Clocks\n- Resets\n- I/O\n- Other dedicated resources\n\nThis default priority is built into the Vivado router. The router then prioritizes data signals according to timing criticality.\n\nImpact of Poor Timing Constraints\n\nNets that are routed sub-optimally are often the result of incorrect timing constraints. Before you experiment with router settings, make sure that you have validated the constraints and the timing picture seen by the router. Validate timing and constraints by reviewing timing reports from the placed design before routing.\n\nCommon examples of poor timing constraints include:\n\n- Cross-clock paths and multi-cycle paths in which hold timing causes route delay insertion\n- Congested areas, which can be addressed by targeted fanout optimization in RTL synthesis or through physical optimization\n\nRECOMMENDED: Clean up constraints (or consider RTL changes) rather than simply increasing routing resources.\n\nroute_design\n\nRoute the nets in the current design to complete logic connections on the target part.\n\nroute_design Syntax\n\n```\nroute_design [-unroute] [-re_entrant <arg>] [-nets <args>] [-physical_nets]\n```\n[-free_resource_mode] -max_delay <arg> -min_delay <arg>\n[-quiet] [-verbose]\n\nUsing Directives\n\nDirectives provide different modes of behavior for the route_design command. Only one directive may be specified at a time. The directive option is incompatible with other options. The following directives are available:\n\n- **Explore**: Allows the router to explore different critical path placements after an initial route.\n- **NoTimingRelaxation**: Prevents the router from relaxing timing to complete routing. If the router has difficulty meeting timing, it will run longer to try to meet the original timing constraints.\n- **MoreGlobalIterations**: Uses detailed timing analysis throughout all stages instead of just the final stages, and will run more global iterations even when timing improves only slightly.\n- **HigherDelayCost**: Adjusts the router’s internal cost functions to emphasize delay over iterations, allowing a tradeoff of runtime for better performance.\n- **AdvancedSkewModeling**: Uses more accurate skew modeling throughout all routing stages which may improve design performance on higher-skew clock networks.\n- **RuntimeOptimized**: Run fewest iterations, trade higher design performance for faster runtime.\n- **Quick**: Absolute, fastest runtime, non-timing-driven, performs the minimum required for a legal design.\n- **Default**: Run route_design with default settings.\n\nTrading Runtime for Better Routing\n\nThe following directives are methods of trading runtime for potentially better routing results:\n\n- NoTimingRelaxation\n- MoreGlobalIterations\n- HigherDelayCost\n- AdvancedSkewModeling\nNormal Mode Routing Example Script\n\n```bash\n# Route design, save results to checkpoint, report timing estimates\nroute_design\nwrite_checkpoint -force $outputDir/post_route\nreport_timing_summary -file $outputDir/post_route_timing_summary.rpt\n```\n\nThe `route_design` example script places the in-memory design, rewriting it in the process. It then writes a design checkpoint after completing routing, generates a timing summary report, and writes the report to the specified file.\n\nNormal mode routing is performed as part of an implementation run, or by running `route_design` after `place_design` as part of a Tcl script.\n\nAfter routing is complete, routing statistics summarize the routing resources used by resource type, and display a timing summary:\n\n```\n[Route-20] Post Routing Timing Summary | WNS=0.0585 TNS=0 WHS=0 THS=0 |\n```\n\nwhere:\n\n- WNS = Worst Negative Slack\n- TNS = Total Negative Slack\n- WHS = Worst Hold Slack\n- THS = Total Hold Slack\n\nRe-Entrant Mode Routing Example Script One\n\n```bash\n# route a few critical nets\nroute_design -delay -nets [get_nets myPreRoutes*]\n# Complete full route\nroute_design\n```\n\nRe-entrant mode is implicitly entered when using a re-entrant routing option, such as `-nets` or `-pin`.\n\nRe-entrant mode is usually run interactively to address specific routing issues such as:\n\n- Pre-routing critical nets and locking down resources before a full route.\n- Manually unrouting non-critical nets to free up routing resources for more critical nets.\n\nThe first re-entrant route command initializes the router and routes essential nets, such as clocks. This allows the router to perform:\n\n- Timing analysis\n- Timing-driven routing\n- Hold-fixing\nAfter re-entrant mode is enabled, the results of iterative routing and unrouting reside in memory.\n\n### Exiting Re-Entrant Mode\n\nTo exit re-entrant mode run the full `route_design` command, or directly disable re-entrant routing:\n\n```\nroute_design -re_entrant off\n```\n\n### Re-Entrant Mode Routing Example Script Two\n\n```tcl\n# Get the nets in the top 10 critical paths, assign to $preRoutes\nset preRoutes [get_nets -of [get_timing_paths -max_paths 10]]\nroute_design -nets [get_nets $preRoutes] -delay\n# lock down the routing for $preRoutes nets\nroute_design -preserve\n\n# Unroute all the nets in u0/u1, and route the critical nets first\nroute_design -unroute [get_nets u0/u1/*]\nroute_design -delay -nets [get_nets $myCritNets]\nroute_design -directive Explore\n```\n\nThe strategy in this example script is to:\n\n- Identify the top ten critical paths using `get_timing_paths`.\n- Create a list of the net objects ($preRoutes) of those critical paths using `get_nets -of`.\n- Route those nets first.\n\nThe script continues after routing the pre-route nets.\n\nAfter `route_design` completes, the Vivado router unroutes all nets in cell `u0/u1`, then re-routes identified critical nets first (`myCritNets`). The general router finishes any remaining unrouted nets.\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Function</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>report_route_status</td>\n<td>Reports route status for nets</td>\n</tr>\n<tr>\n<td>report_timing</td>\n<td>Performs path endpoint analysis</td>\n</tr>\n</tbody>\n</table>\n\nFor a complete description of the Tcl reporting commands and their options, see the *Vivado Design Suite Tcl Command Reference Guide* (UG835) [Ref 13].\nIntroduction to Modifying Placement, Routing, and Logic\n\nThe Xilinx® Vivado® Design Suite provides several ways to modify placement, routing, and logic in the implementation flow. These methods allow you to: (1) precisely control placement, routing, and delays; and (2) make quick logic changes.\n\n- Modifying Placement\n- Modifying Routing\n- Modifying Logic\n\nModifying Placement\n\nThe Vivado tools track states for placed cells:\n\n- Fixed Cells\n- Unfixed Cells\n\nFixed and Unfixed apply to placed cells. They describe the way in which the Vivado tools view placed cells in the design.\n\nFixed Cells\n\nFixed cells have been placed by a designer, or have been imported from a constraints file.\n\n- The Vivado Design Suite treats these placed cells as Fixed.\n- Fixed cells are not moved unless directed to do so.\n- The FF in Figure 3-1, Logic Placed in a Slice, is shown in orange (default) to indicate that it is Fixed.\nUnfixed Cells\n\nUnfixed cells have been placed by the Vivado tools in implementation, during the `place_design` command, or one of optimization commands.\n\n- The Vivado Design Suite treats these placed cells as Unfixed (or loosely placed).\n- These cells can be moved by the implementation tools as needed in design iterations.\n- The LUT in Figure 3-1, Logic Placed in a Slice, is shown in blue (default) to indicate that it is Unfixed.\n\n\n\n*Figure 3-1: Logic Placed in a Slice*\n\nBoth LOCS and BELS can be fixed. The placement above generates the following constraints:\n\n```plaintext\nset_property BEL BFF [get_cells {fftEngine/control_reg_reg[1]}]\nset_property LOC SLICE_X1Y199 [get_cells {fftEngine/control_reg_reg[1]}]\n```\n\nThere is no placement constraint on the LUT. Its placement is unfixed, indicating that the placement should not go into the XDC.\nFixing Placer Placed Logic\n\nTo fix cells placed by the Vivado placer in the Vivado IDE:\n\n1. Select the cells.\n2. Choose **Fix Cells** from the popup menu.\n\nTo fix cell placement with Tcl, use a command of this form:\n\n```tcl\nset_property is_bel_fixed TRUE [get_cells [list {fftEngine/control_reg_reg[1]_i_1}]]\nset_property is_loc_fixed TRUE [get_cells [list {fftEngine/control_reg_reg[1]_i_1}]]\n```\n\nFor more information on Tcl commands, see the *Vivado Design Suite Tcl Command Reference Guide* (UG835) [Ref 8], or type `<command> -help`.\n\nPlacing and Moving Logic by Hand\n\nYou can place and move logic by hand.\n\n- If the cell is already placed, drag and drop it to a new location.\n- If the cell is unplaced:\n a. Enter **Create BEL Constraint Instance Drag & Drop** mode.\n b. Drag the logic from the Netlist window, or from the Timing Report window, onto the Device window.\n\nThe logic snaps to a new legal location.\n\nHand placing logic can be slow. The constraints are fragile with respect to design changes, because the cell name is used in the constraint.\n\n---\n\nModifying Routing\n\nThe Device View allows you to modify the routing for your design. You can Unroute, Route, and Fix Routing on any individual net.\n\nTo Unroute, Route, or Fix Routing on a net:\n\n1. Open Device View.\n2. Select the net.\n - Unrouted nets are indicated by a red flyline.\n - Partially routed nets are highlighted in yellow.\n3. Right click and select **Unroute**, **Route**, or **Fix Routing**.\n• **Unroute** and **Route**: Calls the router in re-entrant mode to perform the operation on the net. For more information, see route_design, page 95, in Chapter 2, Implementation Commands.\n\n• **Fix Routing**: Deposits the route, marks it fixed in the route database, and fixes the LOC and BEL of the driver and the load of the net. You can also enter Assign Routing Mode, which allows you to manually route a net. For more information, see Manual Routing, page 102.\n\n_TIP:_ All net commands are available from the context menu on a net.\n\n---\n\n**Figure 3-2:** Modify Routing\n\n---\n\n**Manual Routing**\n\nManual routing allows you to select specific routing resources for your nets. This gives you complete control over the routing paths that a signal is going to take. Manual routing does not invoke route_design. Routes are directly updated in the route database.\n\nYou may want to use manual routing when you want to precisely control the delay for a net. For example, assume a source synchronous interface, in which you want to minimize routing delay variation to the capture registers in the device. To accomplish this, you can assign LOC\nand BEL constraints to the registers and I/Os, and then precisely control the route delay from the IOB to the register by manual routing the nets.\n\nManual routing requires detailed knowledge of a device’s interconnect architecture. It is best used for a limited number of signals and for short connections.\n\n**Manual Routing Rules**\n\nObserve these rules during manual routing:\n\n- The driver and the load require a LOC constraint and a BEL constraint.\n- Branching is not allowed during manual routing, but you can implement branches by starting a new manual route from a branch point.\n- LUT loads must have their pins locked.\n- You must route to loads that are not already connected to a driver.\n- Only complete connections are permitted. Antennas are not allowed.\n- Overlap with existing unfixed routed nets is allowed. Run `route_design` after manual routing to resolve any conflicts due to overlapping nets.\n\n**Entering Assign Routing Mode**\n\nTo enter Assign Routing Mode:\n\n1. Open Device View.\n2. Be sure that **Displays routing resources** in the Device window is selected.\n3. Enable the Layers for **Unrouted Net** and **Partially Routed Net** in the Device Options Layers view. See Figure 3-3, Device Options Layers.\n\n\n\n*Figure 3-3: Device Options Layers*\n\n4. Select the net that requires routing.\n - Unrouted nets are indicated by a red flyline.\n - Partially routed nets are highlighted in yellow.\n\n5. Right-click and select **Enter Assign Routing Mode**.\n\n The Target Load Cell Pin window opens.\n\n6. Optionally, select a load cell pin to which you want to route.\n\n7. Click **OK**.\n**Note:** To display partially routed or unrouted nets in the Device View, you must ensure that those layers are selected in the Device Options pull-out menu. See Figure 3-4, Device Options Pull-Out Menu.\n\n\n\n**Figure 3-4:** Device Options Pull-Out Menu\n\nYou are now in Manual Routing Mode. A Routing Assignment window appears next to the Device View. See Figure 3-5, Routing Assignment Window.\nRouting Assignment Window\n\nThe routing assignment window is divided into three sections:\n\n- **Options Section**\n- **Assigned Nodes Section**\n- **Neighbor Nodes Section**\n\n**Options Section**\n\nThe Options section controls the settings for the Routing Assignment window. See *Figure 3-6, Routing Assignment Options*. \n\nFigure 3-5: Routing Assignment Window\n\nFigure 3-6: Routing Assignment Options\n• The **Number of hops** value allows you to specify the number of routing hops that can be assigned for Neighbor Nodes. This also affects the Neighbor Nodes displayed. If the number of hops is greater than 1, only the last node of the route is displayed in the Neighbor Nodes section.\n\n• The **Maximum number of neighbors** value allows you to limit the number of neighbor nodes that are displayed in the Neighbor Nodes section. Only the last node of the route is displayed.\n\n• The **Allow overlap with unfixed nets** switch controls whether overlaps of assigned routing with existing unfixed routing is allowed. Any overlaps need to be resolved by running the route_design command after fixed route assignment.\n\nThe Options section is hidden by default. To show the Options section, click **Show**.\n\n**Assigned Nodes Section**\n\nThe Assigned Nodes section shows the nodes that already have assigned routing. Each assigned node is displayed as a separate line item.\n\nIn the Device View, nodes with assigned routing are highlighted in orange. Any gaps between assigned nodes are shown in the Assigned nodes section as a GAP line item. To auto-route gaps:\n\n1. Right-click a net gap in the Assigned Nodes section.\n2. Select **Auto-route** from the context sensitive menu.\n\nTo assign the next routing segment, select an assigned node before or after a gap, or the last assigned node in the Assigned Nodes section.\n**Neighbor Nodes Section**\n\nThis displays the allowed neighbor nodes in the Neighbor Nodes section. It also highlights the current selected nodes (in white) and the allowed neighbor nodes (white dotted) in the Device View. See Figure 3-7, Assign Next Routing Segment.\n\n\n\n**Assigning Routing Nodes**\n\nOnce you have decided which Neighbor Node to assign for your next route segment, you can:\n\n- Right-click the node in the Neighbor Nodes section and select **Assign Node**.\n- Double-click the node in the Neighbor Nodes section.\n- Click the node in the Device View\n\nAfter you have assigned routing to a Neighbor Node, the node is displayed in the assigned nodes section and highlighted in orange in the Device View.\n\nAssign nodes until you have reached the load, or until you are ready to assign routing with a gap.\nUn-Assigning Routing Nodes\n\nTo un-assign nodes:\n\n1. Go to the Assigned Nodes pane of the Routing Assignment window.\n2. Select the nodes to be un-assigned.\n3. Right-click and select Remove.\n\nThe nodes are removed from the assignment.\n\nExiting Assign Routing Mode\n\nTo finish the routing assignment and exit Assign Routing Mode:\n\nClick the Assign Routing button in the Routing Assignment window.\n\nThe Assign Routing Window is displayed, allowing you to verify the assigned nodes before they are committed. See Figure 3-8, Assign Routing Confirmation.\n\nCancelling Out of Assign Routing Mode\n\nIf you are not ready to commit your routing assignments, you can cancel out of the Assign Routing Mode using one of the following methods:\n\n• Click Exit Mode in the Routing Assignment window, or\n• Right-click in the Device View and select Exit Assign Routing Mode.\n\nWhen the routes are committed, the driver and load BEL and LOC are also fixed.\nVerifying Assigned Routes\n\n- Assigned routes appear as dotted green lines in the Device View.\n- Partially assigned routes appear as dotted yellow lines in the Device view.\n\n*Figure 3-9, Assigned Partially Assigned Routing,* shows an example of an assigned and partially assigned route.\n\nLocking Cell Inputs on LUT Loads\n\nYou must ensure that the inputs of LUT loads to which you are routing are not being swapped with other inputs on those LUTs. To do so, lock the cell inputs of LUT loads as follows:\n\n1. Open Device View.\n2. Select the load LUT.\n3. Right click and select **Lock Cell Input Pins**.\n\nThe equivalent TCL command is:\n\n```\nset_property LOCK_PINS {NAME:BEL_PIN} <cell object>\n```\nBranching\n\nWhen assigning routing to a net with more than one load, you must route the net in the following steps:\n\n1. Assign routing to one load following the steps shown in Entering Assign Routing Mode, page 103 above.\n2. Assign routing to all the branches of the net.\n\nFigure 3-10, Assign Branching Route, shows an example of a net that has assigned routing to one load and requires routing to two additional loads.\nAssigning Routing to a Branch\n\nTo assign routing to a branch:\n\n1. Go to Device View.\n2. Select the net to be routed.\n3. Right-click and select **Enter Assign Routing Mode**.\n\n The Target Load Cell Pin window opens, showing all loads.\n\n **Note:** The loads that already have assigned routing have a checkmark in the Routed column of the table.\n\n4. Select the load to which you want to route.\n5. Click **OK**.\n\n The Branch Start window opens.\n\n See Figure 3-12, Branch Start, page 113.\n\n6. Select the node from which you want to branch off the route for your selected load.\n7. Click **OK**.\n8. Follow the steps shown in Assigning Routing Nodes, page 108.\nDirected Routing Constraints\n\nFixed route assignments are stored as Directed Routing Strings in the route database. In a Directed Routing String, branching is indicated by nested (curly braces).\n\nFor example, consider the route described in Figure 3-13, Branch Route Example, page 114. In that simplified picture of a route, the various elements are indicated as shown in the following table (Directed Routing Constraints).\n\n<table>\n<thead>\n<tr>\n<th>Elements</th>\n<th>Indicated By</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Driver and Loads</td>\n<td>Orange Rectangles</td>\n</tr>\n<tr>\n<td>Nodes</td>\n<td>Red lines</td>\n</tr>\n<tr>\n<td>Switchboxes</td>\n<td>Blue rectangles</td>\n</tr>\n</tbody>\n</table>\n\nA simplified version of a Directed Routing String for that route is as follows:\n\n\\[\n\\{ A B \\ ( D E T ) \\ C \\ ( F G H I N M ) \\ ( O P Q ) \\ R J K L S \\}.\n\\]\n\nThe route branches at B and C. The main trunk of this route is A B C R J K L S.\nModifying Logic\n\nProperties on logical objects that are not Read Only can be modified after Implementation in the Vivado IDE graphical user interface as well as Tcl.\n\n**Note:** For more information about Tcl commands, see the *Vivado Design Suite Tcl Command Reference Guide* (UG835) [Ref 13], or type `<command> -help`.\n\nTo modify a property on an object in Device View:\n\n1. Select the object.\n2. Modify the property value of the object in the Properties section of the Properties window.\nThese properties can include everything from Block RAM INITs to the clock modifying properties on MMCMs. There is also a special dialog box to set or modify INIT on LUT objects. This dialog box allows you to specify the LUT equation and have the tools determine the appropriate INIT.\n\nFigure 3-14: Property Modify\nSaving Modifications\n\nTo capture the changes to the design made in memory, write a checkpoint of the design.\n\nBecause the assignments are not back-annotated to the design, you must add the assignments to the XDC for them to impact the next run.\n\nTo save the constraints to your constraints file in Project Mode, select **File > Save Constraints**.\nUsing Remote Hosts\n\nLaunching Runs on Remote Linux Hosts\n\nThe Xilinx® Vivado® Integrated Design Environment (IDE) supports simultaneous parallel execution of synthesis and implementation runs on multiple Linux hosts. This is accomplished in the application with simplified versions of more robust load-sharing software, such as Oracle Grid Engine and IBM® Platform™ LSF.\n\nLinux is the only operating system supporting remote hosts because of:\n\n- Superior security handling in Linux\n- The lack of remote-shell capabilities on Microsoft Windows systems\n\nJob submission algorithms are implemented using a “greedy,” round-robin style with Tcl pipes within Secure Shell (SSH), a service within the Linux operating system.\n\n**RECOMMENDED:** Before launching runs on multiple Linux hosts in the Vivado IDE, configure SSH so that the host does not require a password each time you launch a remote run.\n\nFor instructions on configuring SSH, see Setting Up SSH Key Agent Forward, page 121.\n\nLaunch Requirements\n\nThe requirements for launching synthesis and implementation runs on remote Linux hosts are:\n\n- Vivado tools installation is assumed to be available from the login shell, which means that `$XILINX_VIVADO` and `$PATH` are configured correctly in your `.cshrc/.bashrc` setup scripts. If you can log into a remote machine and enter `vivado -help` without sourcing any other scripts, this flow should work.\n\nIf you do not have Vivado set up upon login (CSHRC or BASHRC), use the Run pre-launch script option, as described below, to define an environment setup script to be run prior to all jobs.\n• Vivado IDE installation must be visible from the mounted file systems on remote machines. If the Vivado IDE installation is stored on a local disk on your own machine, it may not be visible from remote machines.\n\n• Vivado IDE project files (.xpr) and directories (.data and .runs) must be visible from the mounted file systems on remote machines. If the design data is saved to a local disk, it may not be visible from remote machines.\n\nConfiguring Remote Hosts\n\nTo configure the Vivado IDE to run synthesis or implementation on a remote Linux host:\n\n1. Select one of the following commands:\n - Main Menu > Tools > Options > Remote Hosts\n - Flow Navigator > Synthesis > Launch Synthesis Runs > Configure Hosts\n - Flow Navigator > Implementation > Launch Implementation Runs > Configure Hosts\n - Launch Selected Runs Dialog Box > Configure Hosts\n\n See Figure A-1, Configure Hosts from Launch Synthesis and Launch Implementation Runs.\n\nThe Vivado Options dialog box displays with the Remote Hosts section selected. The list of currently defined remote Linux hosts is displayed. See Figure A-2, Configuring Remote Hosts.\n\n2. Click Add to enter the names of additional remote servers.\n3. Specify the number of processors the remote machine has available to run simultaneous processes using the Jobs field next to the host name. Individual runs require a separate processor.\n\n4. Toggle Enabled to specify whether the server is available. Use this field when launching runs to specify which servers to use for selected runs.\n\n5. Modify Launch jobs with to change the remote access command used when launching runs.\n\n Note: This step is optional.\n\n The default command is:\n\n ```\n ssh -q -o BatchMode=yes\n ```\n\n **IMPORTANT:** Use caution when modifying this field. For example, removing `BatchMode =yes` might cause the remote process to hang because the Secure Shell incorrectly prompts for an interactive password.\n\n6. Optionally, check Run pre-launch script and define a shell script to run before launching the runs. Use this option to run script to setup the host environment if you do not have Vivado IDE set up upon login.\n\n7. Optionally, check Run post-completion script and define a custom script to run after the run completes, to move or copy the results for example.\n\n8. Optionally, check Send email to and enter an Email address to send a notification when the runs complete. You can have notifications sent After each Job, or After all jobs.\n\n9. Click OK to accept the Remote Host configuration settings.\nLaunching Runs on Remote Linux Hosts\n\nTo test the connection to the remote host:\n\n1. Select one or more hosts.\n2. Click Test.\n\nThe tools verify that the server is available and that the configuration is properly set.\n\n**RECOMMENDED:** Test each host to ensure proper set up before submitting runs to the host.\nRemoving Remote Hosts\n\nTo remove a remote host:\n\n1. Select the remote host.\n2. Click Remove.\n\nSetting Up SSH Key Agent Forward\n\nSSH configuration is accomplished with the following commands at a Linux terminal or shell:\n\n**Note:** This is a one-time step. When successfully set-up, this step does not need to be repeated.\n\n1. Run the following command at a Linux terminal or shell to generate a public key on your primary machine. Though not required, it is a good practice to enter (and remember) a private key phrase when prompted for maximum security.\n\n ```bash\n ssh-keygen -t rsa\n ```\n\n2. Append the contents of your publish key to an `authorized_keys` file on the remote machine. Change `remote_server` to a valid host name:\n\n ```bash\n cat ~/.ssh/id_rsa.pub | ssh remote_server \"cat - >> ~/.ssh/authorized_keys\"\n ```\n\n3. Run the following command to prompt for your private key pass phrase, and enable key forwarding:\n\n ```bash\n ssh-add\n ```\n\nYou should now be able to `ssh` to any machine without typing a password. The first time you access a new machine, it prompts you for a password. It does not prompt upon subsequent access.\n\n**TIP:** If you are always prompted for a password, contact your System Administrator.\nAppendix B\n\nISE Command Map\n\nTcl Commands and Options\n\nSome command line options in the Xilinx® Vivado® Integrated Design Environment (IDE) implementation are one-to-one equivalents of Xilinx Integrated Software Environment (ISE®) Design Suite commands.\n\nTable B-1 lists various ISE tool command line options, and their equivalent Vivado Design Suite Tcl command and Tcl command options.\n\nNote: For more information about Tcl commands, see the Vivado Design Suite Tcl Command Reference Guide (UG835) [Ref 13], or type `<command> -help`.\n\nTable B-1: ISE Command Map\n\n<table>\n<thead>\n<tr>\n<th>ISE Command</th>\n<th>Vivado Tcl Command and Option</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ngdbuild -p partname</td>\n<td>link_design -part partname</td>\n</tr>\n<tr>\n<td>ngdbuild -a (insert pads)</td>\n<td>synth_design -no_iobuf (opposite)</td>\n</tr>\n<tr>\n<td>ngdbuild -u (unexpanded blocks)</td>\n<td>Enabled by default, generates critical warnings</td>\n</tr>\n<tr>\n<td>ngdbuild -quiet</td>\n<td>link_design -quiet</td>\n</tr>\n<tr>\n<td>map -detail</td>\n<td>opt_design -verbose</td>\n</tr>\n<tr>\n<td>map -lc auto</td>\n<td>Enabled by default in place_design</td>\n</tr>\n<tr>\n<td>map -logic_opt</td>\n<td>opt_design and phys_opt_design</td>\n</tr>\n<tr>\n<td>map -mt</td>\n<td>place_design automatically runs multi-threaded with four processors on Linux or two processors on Windows</td>\n</tr>\n<tr>\n<td>map -ntd</td>\n<td>place_design -non_timing_driven</td>\n</tr>\n<tr>\n<td>map -ol</td>\n<td>place_design -effort_level</td>\n</tr>\n<tr>\n<td>map -power</td>\n<td>power_opt_design</td>\n</tr>\n<tr>\n<td>map -u</td>\n<td>link_design -mode out_of_context, opt_design -retarget (skip constant propagation and sweep)</td>\n</tr>\n<tr>\n<td>par -pl</td>\n<td>place_design -effort_level</td>\n</tr>\n<tr>\n<td>par -rl</td>\n<td>route_design -effort_level</td>\n</tr>\n</tbody>\n</table>\n### Table B-1: ISE Command Map (Cont’d)\n\n<table>\n<thead>\n<tr>\n<th>ISE Command</th>\n<th>Vivado Tcl Command and Option</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>par -mt</code></td>\n<td><code>route_design</code> automatically runs multi-threaded with four processors on Linux, or two processors on Windows</td>\n</tr>\n<tr>\n<td><code>par -k</code></td>\n<td>The re-entrant routing mode is the default mode of <code>route_design</code></td>\n</tr>\n<tr>\n<td><code>par -nopad</code></td>\n<td>The <code>-nopad</code> behavior is the default behavior of Vivado. You must use <code>report_io</code> to obtain the PAD file report generated by PAR.</td>\n</tr>\n<tr>\n<td><code>par -ntd</code></td>\n<td><code>route_design -no_timing_driven</code></td>\n</tr>\n</tbody>\n</table>\n\n\nImplementation Categories, Strategy Descriptions, and Directive Mapping\n\nImplementation Categories\n\nTable C-1: Implementation Categories\n\n<table>\n<thead>\n<tr>\n<th>Category</th>\n<th>Purpose</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Performance</td>\n<td>Improve design performance.</td>\n</tr>\n<tr>\n<td>Area</td>\n<td>Reduce LUT count.</td>\n</tr>\n<tr>\n<td>Power</td>\n<td>Add full power optimization.</td>\n</tr>\n<tr>\n<td>Flow</td>\n<td>Modify flow steps.</td>\n</tr>\n<tr>\n<td>Congestion</td>\n<td>Reduce congestion and related problems.</td>\n</tr>\n</tbody>\n</table>\n\nImplementation Strategy Descriptions\n\nTable C-2: Implementation Strategy Descriptions\n\n<table>\n<thead>\n<tr>\n<th>Implementation Strategy Name</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Vivado Implementation Defaults</td>\n<td>Balances runtime with trying to achieve timing closure.</td>\n</tr>\n<tr>\n<td>Performance_Explore</td>\n<td>Uses multiple algorithms for optimization, placement, and routing to get potentially better results.</td>\n</tr>\n<tr>\n<td>Performance_RefinePlacement</td>\n<td>Increase placer effort in the post-placement optimization phase, and disable timing relaxation in the router.</td>\n</tr>\n<tr>\n<td>Performance_WLBlockPlacement</td>\n<td>Ignore timing constraints for placing Block RAM and DSPs, use wirelength instead.</td>\n</tr>\n<tr>\n<td>Performance_WLBlockPlacementFanoutOpt</td>\n<td>Ignore timing constraints for placing Block RAM and DSPs, use wirelength instead, and perform aggressive replication of high fanout drivers.</td>\n</tr>\n<tr>\n<td>Performance_LateBlockPlacement</td>\n<td>Use approximate Block RAM and DSP placement until late placement phases. May result in better overall placement.</td>\n</tr>\n</tbody>\n</table>\n**Table C-2: Implementation Strategy Descriptions (Cont’d)**\n\n<table>\n<thead>\n<tr>\n<th>Implementation Strategy Name</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Performance_NetDelay_high</td>\n<td>To compensate for optimistic delay estimation, add extra delay cost to long distance and high fanout connections. (high setting, most pessimistic)</td>\n</tr>\n<tr>\n<td>Performance_NetDelay_medium</td>\n<td>To compensate for optimistic delay estimation, add extra delay cost to long distance and high fanout connections. (medium setting,)</td>\n</tr>\n<tr>\n<td>Performance_NetDelay_low</td>\n<td>To compensate for optimistic delay estimation, add extra delay cost to long distance and high fanout connections. low setting, least pessimistic)</td>\n</tr>\n<tr>\n<td>Performance_ExploreSLLs</td>\n<td>Explores SLR reassignments to potentially improve overall timing slack.</td>\n</tr>\n<tr>\n<td>Area_Explore</td>\n<td>Uses multiple optimization algorithms to get potentially fewer LUTs.</td>\n</tr>\n<tr>\n<td>Power_DefaultOpt</td>\n<td>Adds power optimization (power_opt_design) to reduce power consumption.</td>\n</tr>\n<tr>\n<td>Flow_RunPhysOpt</td>\n<td>Similar to the Implementation Run Defaults, but enables the physical optimization step (phys_opt_design).</td>\n</tr>\n<tr>\n<td>Flow_RuntimeOptimized</td>\n<td>Each implementation step trades design performance for better runtime. Physical optimization (phys_opt_design) is disabled.</td>\n</tr>\n<tr>\n<td>Flow_Quick</td>\n<td>Only placement and routing are run, with all optimization and timing-driven behavior disabled. Useful for utilization estimation.</td>\n</tr>\n<tr>\n<td>Congestion_SpreadLogic_high</td>\n<td>Spread logic throughout the device to avoid creating congested regions. (high setting: highest degree of spreading)</td>\n</tr>\n<tr>\n<td>Congestion_SpreadLogic_medium</td>\n<td>Spread logic throughout the device to avoid creating congested regions. (medium setting)</td>\n</tr>\n<tr>\n<td>Congestion_SpreadLogic_low</td>\n<td>Spread logic throughout the device to avoid creating congested regions. (low setting: lowest degree of spreading)</td>\n</tr>\n<tr>\n<td>Congestion_SpreadLogicSLLs</td>\n<td>Allocate SLLs such that logic can be spread throughout all SLRs to avoid creating congested regions inside SLRs.</td>\n</tr>\n<tr>\n<td>Congestion_BalanceSLLs</td>\n<td>Allocate SLLs such that no two SLRs require a disproportionately large number of SLLs, thereby reducing congestion in those SLRs.</td>\n</tr>\n<tr>\n<td>Congestion_BalanceSLRs</td>\n<td>Partition such that each SLR has similar area, to avoid creating congestion within an SLR.</td>\n</tr>\n<tr>\n<td>Congestion_CompressSLRs</td>\n<td>Partition with higher SLR utilization, to reduce number of overall SLLs.</td>\n</tr>\n</tbody>\n</table>\n# Directives Used By opt_design and place_design in Implementation Strategies\n\n**Table C-3:** Directives Used by opt_design and place_design in Implementation Strategies\n\n<table>\n<thead>\n<tr>\n<th>Strategy</th>\n<th>opt_design -directive</th>\n<th>place_design -directive</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Performance_Explore</td>\n<td>Explore</td>\n<td>Explore</td>\n</tr>\n<tr>\n<td>Performance_RefinePlacement</td>\n<td>Default</td>\n<td>ExtraPostPlacementOpt</td>\n</tr>\n<tr>\n<td>Performance_WLBlockPlacement</td>\n<td>Default</td>\n<td>WLDrivenBlockPlacement</td>\n</tr>\n<tr>\n<td>Performance_WLBlockPlacementFanoutOpt</td>\n<td>Default</td>\n<td>WLDrivenBlockPlacement</td>\n</tr>\n<tr>\n<td>Performance_LateBlockPlacement</td>\n<td>Default</td>\n<td>LateBlockPlacement</td>\n</tr>\n<tr>\n<td>Performance_NetDelay_high</td>\n<td>Default</td>\n<td>ExtraNetDelay_high</td>\n</tr>\n<tr>\n<td>Performance_NetDelay_medium</td>\n<td>Default</td>\n<td>ExtraNetDelay_medium</td>\n</tr>\n<tr>\n<td>Performance_NetDelay_low</td>\n<td>Default</td>\n<td>ExtraNetDelay_low</td>\n</tr>\n<tr>\n<td>Performance_ExploreSLLs</td>\n<td>Default</td>\n<td>SSI_ExtraTimingOpt</td>\n</tr>\n<tr>\n<td>Area_Explore</td>\n<td>ExploreArea</td>\n<td>Default</td>\n</tr>\n<tr>\n<td>Power_DefaultOpts</td>\n<td>Default</td>\n<td>Default</td>\n</tr>\n<tr>\n<td>Flow_RunPhysOpt</td>\n<td>Default</td>\n<td>Default</td>\n</tr>\n<tr>\n<td>Flow_RuntimeOptimized</td>\n<td>RuntimeOptimized</td>\n<td>RuntimeOptimized</td>\n</tr>\n<tr>\n<td>Flow_Quick</td>\n<td>Default</td>\n<td>Quick</td>\n</tr>\n<tr>\n<td>Congestion_SpreadLogic_high</td>\n<td>Default</td>\n<td>SpreadLogic_high</td>\n</tr>\n<tr>\n<td>Congestion_SpreadLogic_medium</td>\n<td>Default</td>\n<td>SpreadLogic_medium</td>\n</tr>\n<tr>\n<td>Congestion_SpreadLogic_low</td>\n<td>Default</td>\n<td>SpreadLogic_low</td>\n</tr>\n<tr>\n<td>Congestion_SpreadLogicSLLs</td>\n<td>Default</td>\n<td>SSI_SpreadSLLs</td>\n</tr>\n<tr>\n<td>Congestion_BalanceSLLs</td>\n<td>Default</td>\n<td>SSI_BalanceSLLs</td>\n</tr>\n<tr>\n<td>Congestion_BalanceSLRs</td>\n<td>Default</td>\n<td>SSI_BalanceSLRs</td>\n</tr>\n<tr>\n<td>Congestion_CompressSLR</td>\n<td>Default</td>\n<td>SSI_HighUtilSLRs</td>\n</tr>\n</tbody>\n</table>\n### Directives Used by phys_opt_design and route_design in Implementation Strategies\n\n<table>\n<thead>\n<tr>\n<th>Strategy</th>\n<th>phys_opt_design -directive</th>\n<th>route_design -directive</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>PerformanceExplore</td>\n<td>Explore</td>\n<td>Explore</td>\n</tr>\n<tr>\n<td>PerformanceRefinePlacement</td>\n<td>Default</td>\n<td>NoTimingRelaxation</td>\n</tr>\n<tr>\n<td>PerformanceWLBlockPlacement</td>\n<td>AlternateReplication</td>\n<td>MoreGlobalIterations</td>\n</tr>\n<tr>\n<td>PerformanceWLBlockPlacementFanoutOpt</td>\n<td>AggressiveFanoutOpt</td>\n<td>HigherDelayCost</td>\n</tr>\n<tr>\n<td>PerformanceLateBlockPlacement</td>\n<td>AlternateReplication</td>\n<td>HigherDelayCost</td>\n</tr>\n<tr>\n<td>PerformanceNetDelay_high</td>\n<td>Default</td>\n<td>AdvancedSkewModeling</td>\n</tr>\n<tr>\n<td>PerformanceNetDelay_medium</td>\n<td>Default</td>\n<td>AdvancedSkewModeling</td>\n</tr>\n<tr>\n<td>PerformanceNetDelay_low</td>\n<td>Default</td>\n<td>AdvancedSkewModeling</td>\n</tr>\n<tr>\n<td>PerformanceExploreSLLs</td>\n<td>Default</td>\n<td>NoTimingRelaxation</td>\n</tr>\n<tr>\n<td>Area_Explore</td>\n<td>Default</td>\n<td>Default</td>\n</tr>\n<tr>\n<td>Power_DefaultOpts</td>\n<td>Default</td>\n<td>Default</td>\n</tr>\n<tr>\n<td>Flow_RunPhysOpt</td>\n<td>Explore</td>\n<td>Default</td>\n</tr>\n<tr>\n<td>Flow_RuntimeOptimized</td>\n<td>not enabled</td>\n<td>RuntimeOptimized</td>\n</tr>\n<tr>\n<td>Flow_Quick</td>\n<td>not enabled</td>\n<td>Quick</td>\n</tr>\n<tr>\n<td>CongestionSpreadLogic_high</td>\n<td>AggressiveFanoutOpt</td>\n<td>MoreGlobalIterations</td>\n</tr>\n<tr>\n<td>CongestionSpreadLogic_medium</td>\n<td>AggressiveFanoutOpt</td>\n<td>HigherDelayCost</td>\n</tr>\n<tr>\n<td>CongestionSpreadLogic_low</td>\n<td>Default</td>\n<td>NoTimingRelaxation</td>\n</tr>\n<tr>\n<td>CongestionSpreadLogicSLLs</td>\n<td>Default</td>\n<td>NoTimingRelaxation</td>\n</tr>\n<tr>\n<td>CongestionBalanceSLLs</td>\n<td>Default</td>\n<td>NoTimingRelaxation</td>\n</tr>\n<tr>\n<td>CongestionBalanceSLRs</td>\n<td>Default</td>\n<td>Default</td>\n</tr>\n<tr>\n<td>CongestionCompressSLR</td>\n<td>Default</td>\n<td>Default</td>\n</tr>\n</tbody>\n</table>\nAdditional Resources\n\nXilinx Resources\n\nFor support resources such as Answers, Documentation, Downloads, and Forums, see the Xilinx® Support website at:\n\nwww.xilinx.com/support\n\nFor a glossary of technical terms used in Xilinx documentation, see:\n\nwww.xilinx.com/company/terms.htm\n\nSolution Centers\n\nSee the Xilinx Solution Centers for support on devices, software tools, and intellectual property at all stages of the design cycle. Topics include design assistance, advisories, and troubleshooting tips.\n\nReferences\n\nVivado® Design Suite User Guides\n\n8. \n9. \n10. \n11. \n\nOther Vivado Design Suite Documents\n\n12. \n13. \n14. \n15. \n\nVivado Design Suite Video Tutorials\n\n16. \n\nVivado Design Suite Documentation\n\n17. "}}},{"rowIdx":280,"cells":{"id":{"kind":"string","value":"93cf3e9e6679e6c13860fc003dbd7389c9b8dc93"},"text":{"kind":"string","value":"1 Diameter Users Guide\n\nThe diameter application is a framework for building applications on top of the Diameter protocol.\n\n1.1 Introduction\n\nThe diameter application is an implementation of the Diameter protocol as defined by RFC 6733. It supports arbitrary Diameter applications by way of a dictionary interface that allows messages and AVPs to be defined and input into diameter as configuration. It has support for all roles defined in the RFC: client, server and agent. This chapter provides a short overview of the application.\n\nA Diameter node is implemented by configuring a service and one or more transports using the interface module diameter. The service configuration defines the Diameter applications to be supported by the node and, typically, the capabilities that it should send to remote peers at capabilities exchange upon the establishment of transport connections. A transport is configured on a service and provides protocol-specific send/receive functionality by way of a transport interface defined by diameter and implemented by a transport module. The diameter application provides two transport modules: diameter_tcp and diameter_sctp for transport over TCP (using gen_tcp) and SCTP (using gen_sctp) respectively. Other transports can be provided by any module that implements diameter's transport interface.\n\nWhile a service typically implements a single Diameter node (as identified by an Origin-Host AVP), transports can themselves be associated with capabilities AVPs so that a single service can be used to implement more than one Diameter node.\n\nEach Diameter application defined on a service is configured with a callback module that implements the application interface through which diameter communicates the connectivity of remote peers, requests peer selection for outgoing requests, and communicates the reception of incoming Diameter request and answer messages. An application using diameter implements these application callback modules to provide the functionality of the Diameter node(s) it implements.\n\nEach Diameter application is also configured with a dictionary module that provide encode/decode functionality for outgoing/incoming Diameter messages belonging to the application. A dictionary module is generated from a dictionary file using the diameterc utility. Dictionaries for the RFC 6733 Diameter Common Messages, Base Accounting and Relay applications are provided with the diameter application.\n\n1.2 Usage\n\nTo be written.\n\n1.3 Examples\n\nExample code can be found in the diameter application's examples subdirectory.\n\n1.4 Standards Compliance\n\nThe table below summarizes the diameter application's compliance with RFC 6733. Since the diameter application isn't a Diameter node on its own, compliance is strictly the responsibility of the user in many cases, diameter providing the means for the user to be compliant rather than being compliant on its own.\n1.4 Standards Compliance\n\nThe Compliance column notes C (Compliant) if the required functionality is implemented, PC (Partially Compliant) if there are limitations, NC (Not Compliant) if functionality is not implemented, or a dash if text is informational or only places requirements that must be met by the user’s implementation.\n\nCapitalized Diameter refers to the protocol, lowercase diameter to the Erlang application.\n\n### 1.4.1 RFC 6733 - Diameter Base Protocol\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Title</th>\n<th>Compliance</th>\n<th>Notes</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Introduction</td>\n<td>—</td>\n<td></td>\n</tr>\n<tr>\n<td>1.1</td>\n<td>Diameter Protocol</td>\n<td>—</td>\n<td></td>\n</tr>\n<tr>\n<td>1.1.1</td>\n<td>Description of the Document Set</td>\n<td>—</td>\n<td></td>\n</tr>\n<tr>\n<td>1.1.2</td>\n<td>Conventions Used in This Document</td>\n<td>—</td>\n<td></td>\n</tr>\n<tr>\n<td>1.1.3</td>\n<td>Changes from RFC 3588</td>\n<td>—</td>\n<td>It is possible to configure a 3588 dictionary in order to get 3588 semantics, where the differ from 6733.</td>\n</tr>\n<tr>\n<td>1.2</td>\n<td>Terminology</td>\n<td>—</td>\n<td></td>\n</tr>\n<tr>\n<td>1.3</td>\n<td>Approach to Extensibility</td>\n<td>—</td>\n<td>The dictionary interface documented in diameter_dict(4) provides extensibility, allowing the user to defined new AVPs, commands, and applications. Ready dictionaries are provided for the RFC 6733 common message, base accounting, and relay applications, as well as for RFC 7683, Diameter Overload Indicator Conveyance.</td>\n</tr>\n<tr>\n<td>1.3.1</td>\n<td>Defining New AVP Values</td>\n<td>—</td>\n<td></td>\n</tr>\n<tr>\n<td>1.3.2</td>\n<td>Creating New AVPs</td>\n<td>—</td>\n<td>New AVPs can be defined using the dictionary interface. Both RFC data formats and extensions are supported.</td>\n</tr>\n<tr>\n<td>Section</td>\n<td>Topic</td>\n<td>Notes</td>\n<td></td>\n</tr>\n<tr>\n<td>---------</td>\n<td>--------------------------------------</td>\n<td>----------------------------------------------------------------------</td>\n<td></td>\n</tr>\n<tr>\n<td>1.3.3</td>\n<td>Creating New Commands</td>\n<td>New commands can be defined using the dictionary interface.</td>\n<td></td>\n</tr>\n<tr>\n<td>1.3.4</td>\n<td>Creating New Diameter Applications</td>\n<td>New applications can be defined using the dictionary interface.</td>\n<td></td>\n</tr>\n<tr>\n<td>2</td>\n<td>Protocol Overview</td>\n<td>Session state is the responsibility of the user.</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>The role of a Diameter node is determined by the user's implementation.</td>\n<td></td>\n</tr>\n<tr>\n<td>2.1</td>\n<td>Transport</td>\n<td>Ports are configured by the user: diameter places no restrictions.</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>The transport interface documented in diameter_transport(3) allows the user to implement their own methods. Ready support is provided for TCP, TCP/TLS, and SCTP, but not DTLS/SCTP. Multiple connections to the same peer is possible. ICMP messages are not interpreted.</td>\n<td></td>\n</tr>\n<tr>\n<td>2.1.1</td>\n<td>SCTP Guidelines</td>\n<td>Unordered sending is configurable in diameter_sctp(3). There is no special handling of DPR/DPA: since a user that cares about pending answers should wait for them before initiating DPR. A PPID can be configured with a a gen_sctp sctp_default_send_param option.</td>\n<td></td>\n</tr>\n<tr>\n<td>Section</td>\n<td>Description</td>\n<td>Type</td>\n<td>Notes</td>\n</tr>\n<tr>\n<td>---------</td>\n<td>-------------</td>\n<td>------</td>\n<td>-------</td>\n</tr>\n<tr>\n<td>2.2</td>\n<td>Securing Diameter Messages</td>\n<td>PC</td>\n<td>DTLS is not supported by <code>diameter_sctp(3)</code>. See also 2.1.</td>\n</tr>\n<tr>\n<td>2.3</td>\n<td>Diameter Application Compliance</td>\n<td>—</td>\n<td>The user configures <code>diameter</code> with the identifiers to send at capabilities exchange, along with corresponding dictionaries defining the messages of the applications.</td>\n</tr>\n<tr>\n<td>2.4</td>\n<td>Application Identifiers</td>\n<td>C</td>\n<td>Connections are realized by configuring transport. Sessions are the responsibility of the user.</td>\n</tr>\n<tr>\n<td>2.5</td>\n<td>Connections vs. Sessions</td>\n<td>C</td>\n<td>Routing is implemented by the user in callbacks documented in <code>diameter_app(3)</code>. A peer table of the documented form is not exposed to the user.</td>\n</tr>\n<tr>\n<td>2.6</td>\n<td>Peer Table</td>\n<td>PC</td>\n<td>See 2.6. A routing table of the documented form is not exposed to the user.</td>\n</tr>\n<tr>\n<td>2.7</td>\n<td>Routing Table</td>\n<td>PC</td>\n<td>Most role-specific behaviour is implemented by the user. How a node advertises itself at capabilities exchange is determined by user configuration.</td>\n</tr>\n<tr>\n<td>2.8</td>\n<td>Role of Diameter Agents</td>\n<td>C</td>\n<td>Authorization is the responsibility of the user.</td>\n</tr>\n<tr>\n<td>2.8.1</td>\n<td>Relay Agents</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>2.8.2</td>\n<td>Proxy Agents</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>2.8.3</td>\n<td>Redirect Agents</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>2.8.4</td>\n<td>Translation Agents</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>2.9</td>\n<td>Diameter Path Authorization</td>\n<td>—</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n### 1.4 Standards Compliance\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Description</th>\n<th>Type</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>3</td>\n<td>Diameter Header</td>\n<td>C</td>\n</tr>\n<tr>\n<td></td>\n<td>Hop-by-Hop and End-to-End Identifiers are set by diameter when sending</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>outgoing requests.</td>\n<td></td>\n</tr>\n<tr>\n<td>3.1</td>\n<td>Command Codes</td>\n<td>C</td>\n</tr>\n<tr>\n<td>3.2</td>\n<td>Command Code Format Specification</td>\n<td>C</td>\n</tr>\n<tr>\n<td></td>\n<td>Commands are defined as CCF specifications in dictionary files.</td>\n<td></td>\n</tr>\n<tr>\n<td>3.3</td>\n<td>Diameter Command Naming Conventions</td>\n<td></td>\n</tr>\n<tr>\n<td>4</td>\n<td>Diameter AVPs</td>\n<td>C</td>\n</tr>\n<tr>\n<td></td>\n<td>Any required padding is added by diameter when encoding outgoing messages.</td>\n<td></td>\n</tr>\n<tr>\n<td>4.1</td>\n<td>AVP Header</td>\n<td>C</td>\n</tr>\n<tr>\n<td>4.1.1</td>\n<td>Optional Header Elements</td>\n<td>C</td>\n</tr>\n<tr>\n<td>4.2</td>\n<td>Basic AVP Data Formats</td>\n<td>C</td>\n</tr>\n<tr>\n<td>4.3</td>\n<td>Derived AVP Data Formats</td>\n<td>C</td>\n</tr>\n<tr>\n<td></td>\n<td>Arbitrary derived data formats are supported by the dictionary interface.</td>\n<td></td>\n</tr>\n<tr>\n<td>4.3.1</td>\n<td>Common Derived AVP Data Formats</td>\n<td>C</td>\n</tr>\n<tr>\n<td></td>\n<td>Beware that RFC 6733 changed the DiameterURI transport/port defaults</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>specified in RFC3588. Relying on the defaults can result in interoperability</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>problems.</td>\n<td></td>\n</tr>\n<tr>\n<td>4.4</td>\n<td>Grouped AVP Values</td>\n<td>C</td>\n</tr>\n<tr>\n<td></td>\n<td>The M-bit on a component AVP of a Grouped AVP that does not set M is</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>ignored: such AVPs are not regarded as erroneous at decode.</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>Grouped AVPs are defined as CCF specifications in dictionary files.</td>\n<td></td>\n</tr>\n<tr>\n<td>4.4.1</td>\n<td>Example AVP with a Grouped Data Type</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n## 1.4 Standards Compliance\n\n<table>\n<thead>\n<tr>\n<th>4.5</th>\n<th>Diameter Base Protocol AVPs</th>\n<th>C</th>\n<th>The base AVPs are defined in the common dictionary provided by diameter. There are common dictionaries for both RFC 3588 and RFC 6733 since the latter made changes to both syntax and semantics.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>5</td>\n<td>Diameter Peers</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>5.1</td>\n<td>Peer Connections</td>\n<td>PC</td>\n<td>A peer's DiameterIdentity is not required when initiating a connection: the identify is received at capabilities exchange, at which time the connection can be rejected if the identity is objectionable. The number of connections established depends on the user's configuration. Multiple connections per peer is possible.</td>\n</tr>\n<tr>\n<td>5.2</td>\n<td>Diameter Peer Discovery</td>\n<td>NC</td>\n<td>No form of peer discovery is implemented. The user can implement this independently of diameter if required.</td>\n</tr>\n<tr>\n<td>5.3</td>\n<td>Capabilities Exchange</td>\n<td>C</td>\n<td>All supported applications are sent in CEA. The user can reject an incoming CER or CEA in a configured callback. Both transport security at connection establishment and negotiated via an Inband-Security AVP are supported.</td>\n</tr>\n<tr>\n<td>5.3.1</td>\n<td>Capabilities-Exchange-Request</td>\n<td>C</td>\n<td>CER is sent and received by diameter.</td>\n</tr>\n<tr>\n<td>5.3.2</td>\n<td>Capabilities-Exchange-Answer</td>\n<td>C</td>\n<td>CEA is sent and received by diameter.</td>\n</tr>\n<tr>\n<td>5.3.3</td>\n<td>Vendor-Id AVP</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>Section</td>\n<td>Description</td>\n<td>Type</td>\n<td>Notes</td>\n</tr>\n<tr>\n<td>---------</td>\n<td>------------------------------</td>\n<td>------</td>\n<td>-------</td>\n</tr>\n<tr>\n<td>5.3.4</td>\n<td>Firmware-Revision AVP</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>5.3.5</td>\n<td>Host-IP-Address AVP</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>5.3.6</td>\n<td>Supported-Vendor-Id AVP</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>5.3.7</td>\n<td>Product-Name AVP</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>5.4</td>\n<td>Disconnecting Peer Connections</td>\n<td>C</td>\n<td>DPA will not be answered with error: a peer that wants to avoid a race can wait for pending answers before sending DPR.</td>\n</tr>\n<tr>\n<td>5.4.1</td>\n<td>Disconnect-Peer-Request</td>\n<td>C</td>\n<td>DPR is sent by diameter in response to configuration changes requiring a connection to be broken. The user can also send DPR.</td>\n</tr>\n<tr>\n<td>5.4.2</td>\n<td>Disconnect-Peer-Answer</td>\n<td>C</td>\n<td>DPR is answered by diameter.</td>\n</tr>\n<tr>\n<td>5.4.3</td>\n<td>Disconnect-Cause AVP</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>5.5</td>\n<td>Transport Failure Detection</td>\n<td>—</td>\n<td></td>\n</tr>\n<tr>\n<td>5.5.1</td>\n<td>Device-Watchdog-Request</td>\n<td>C</td>\n<td>DWR is sent and received by diameter. Callbacks notify the user of transitions into and out of the OKAY state.</td>\n</tr>\n<tr>\n<td>5.5.2</td>\n<td>Device-Watchdog-Answer</td>\n<td>C</td>\n<td>DWA is sent and received by diameter.</td>\n</tr>\n<tr>\n<td>5.5.3</td>\n<td>Transport Failure Algorithm</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>5.5.4</td>\n<td>Failover and Failback Procedures</td>\n<td>C</td>\n<td>The election process is modified as described in 5.6.4.</td>\n</tr>\n<tr>\n<td>5.6</td>\n<td>Peer State Machine</td>\n<td>PC</td>\n<td></td>\n</tr>\n<tr>\n<td>5.6.1</td>\n<td>Incoming Connections</td>\n<td>C</td>\n<td></td>\n</tr>\n<tr>\n<td>5.6.2</td>\n<td>Events</td>\n<td>—</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n### 5.6.3 Actions\n\n<table>\n<thead>\n<tr>\n<th>5.6.4</th>\n<th>The Election Process</th>\n<th>PC</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>As documented, the</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>election assumes</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>knowledge of a peer's</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>DiameterIdentity</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>when initiating a</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>connection, which</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>diameter doesn't</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>require. Connections</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>will be accepted if</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>configuration allows</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>multiple connections</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>per peer to be</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>established or there</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>is no existing</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>connection. Note that</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>the election process</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>is only applicable</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>when multiple</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>connections per peer</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>is disallowed.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n### 6 Diameter Message Processing\n\n<table>\n<thead>\n<tr>\n<th>6.1</th>\n<th>Diameter Request Routing Overview</th>\n<th>—</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Routing is performed by the user.</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>A callback from diameter provides</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>a list of available suitable peer</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>connections.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>6.1.1</th>\n<th>Originating a Request</th>\n<th>C</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Requests are constructed</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>by the user; diameter</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>sets header fields as</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>defined in the relevant</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>dictionary.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>6.1.2</th>\n<th>Sending a Request</th>\n<th>C</th>\n</tr>\n</thead>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>6.1.3</th>\n<th>Receiving Requests</th>\n<th>C</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Loops are detected</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>by diameter when</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>the return value of</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>a request callback</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>asks that a request</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>be forwarded. Loop</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>detection in other</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>cases is the</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>responsibility of</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>the user.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>6.1.4</th>\n<th>Processing Local Requests</th>\n<th>C</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>The user decides whether</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>or not to process a</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>request locally in the</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>request callback from</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>diameter.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>6.1.5</th>\n<th>Request Forwarding</th>\n<th>PC</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>See 2.6.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>6.1.6</th>\n<th>Request Routing</th>\n<th>PC</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>See 2.7.</td>\n<td></td>\n</tr>\n<tr>\n<td>Section</td>\n<td>Description</td>\n<td>Requirement</td>\n</tr>\n<tr>\n<td>---------</td>\n<td>-------------</td>\n<td>-------------</td>\n</tr>\n<tr>\n<td>6.1.7</td>\n<td>Predictive Loop Avoidance</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.1.8</td>\n<td>Redirecting Requests</td>\n<td>PC</td>\n</tr>\n<tr>\n<td>6.1.9</td>\n<td>Relaying and Proxying Requests</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.2</td>\n<td>Diameter Answer Processing</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.2.1</td>\n<td>Processing Received Answers</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.2.2</td>\n<td>Relaying and Proxying Answers</td>\n<td>—</td>\n</tr>\n<tr>\n<td>6.3</td>\n<td>Origin-Host AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.4</td>\n<td>Origin-Realm AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.5</td>\n<td>Destination-Host AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.6</td>\n<td>Destination-Realm AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.7</td>\n<td>Routing AVPs</td>\n<td>—</td>\n</tr>\n<tr>\n<td>6.7.1</td>\n<td>Route-Record AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.7.2</td>\n<td>Proxy-Info AVP</td>\n<td>C</td>\n</tr>\n</tbody>\n</table>\n### 1.4 Standards Compliance\n\n<table>\n<thead>\n<tr>\n<th>6.7.3</th>\n<th>Proxy-Host AVP</th>\n<th>C</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>6.7.4</td>\n<td>Proxy-State AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.8</td>\n<td>Auth-Application-Id AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.9</td>\n<td>Acct-Application-Id AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.10</td>\n<td>Inband-Security-Id AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.11</td>\n<td>Vendor-Specific-Application-Id AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.12</td>\n<td>Redirect-Host AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.13</td>\n<td>Redirect-Host-Usage AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>6.14</td>\n<td>Redirect-Max-Cache-Time AVP</td>\n<td>C</td>\n</tr>\n</tbody>\n</table>\n\n| 7 | Error Handling | C |\n\n#### 7 Error Handling\n\n<table>\n<thead>\n<tr>\n<th>7.1</th>\n<th>Result-Code AVP</th>\n<th>C</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>7.1.1</td>\n<td>Informational</td>\n<td>C</td>\n</tr>\n<tr>\n<td>7.1.2</td>\n<td>Success</td>\n<td>C</td>\n</tr>\n<tr>\n<td>7.1.3</td>\n<td>Protocol Errors</td>\n<td>C</td>\n</tr>\n<tr>\n<td>7.1.4</td>\n<td>Transient Failures</td>\n<td>C</td>\n</tr>\n<tr>\n<td>7.1.5</td>\n<td>Permanent Failures</td>\n<td>C</td>\n</tr>\n</tbody>\n</table>\n1.4 Standards Compliance\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>7.2</td>\n<td>Error Bit</td>\n</tr>\n<tr>\n<td>7.3</td>\n<td>Error-Message AVP</td>\n</tr>\n<tr>\n<td>7.4</td>\n<td>Error-Reporting-Host AVP</td>\n</tr>\n<tr>\n<td>7.5</td>\n<td>Failed-AVP AVP</td>\n</tr>\n<tr>\n<td>7.6</td>\n<td>Experimental-Result AVP</td>\n</tr>\n<tr>\n<td>7.7</td>\n<td>Experimental-Result-Code AVP</td>\n</tr>\n<tr>\n<td>8</td>\n<td>Diameter User Sessions</td>\n</tr>\n<tr>\n<td>8.1</td>\n<td>Authorization Session State Machine</td>\n</tr>\n<tr>\n<td>8.2</td>\n<td>Accounting Session State Machine</td>\n</tr>\n</tbody>\n</table>\n\nadmonition of sections 3 and 4.1.\n\nNote that RFC 3588 did not allow 5xxx result codes in answers setting the E-bit, while RFC 6733 does. This is a potential interoperability problem since the Diameter protocol version has not changed.\n### 1.4 Standards Compliance\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Description</th>\n<th>Implementation Notes</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>8.3</td>\n<td>Server-Initiated Re-Auth</td>\n<td>—</td>\n</tr>\n<tr>\n<td>8.3.1</td>\n<td>Re-Auth-Request</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.3.2</td>\n<td>Re-Auth-Answer</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.4</td>\n<td>Session Termination</td>\n<td>—</td>\n</tr>\n<tr>\n<td>8.4.1</td>\n<td>Session-Termination-Request</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.4.2</td>\n<td>Session-Termination-Answer</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.5</td>\n<td>Aborting a Session</td>\n<td>—</td>\n</tr>\n<tr>\n<td>8.5.1</td>\n<td>Abort-Session-Request</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.5.2</td>\n<td>Abort-Session-Answer</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.6</td>\n<td>Inferring Session Termination from Origin-State-Id</td>\n<td>—</td>\n</tr>\n<tr>\n<td>8.7</td>\n<td>Auth-Request-Type AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.8</td>\n<td>Session-Id AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.9</td>\n<td>Authorization-Lifetime AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.10</td>\n<td>Auth-Grace-Period AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.11</td>\n<td>Auth-Session-State AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.12</td>\n<td>Re-Auth-Request-Type AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.13</td>\n<td>Session-Timeout AVP</td>\n<td>C</td>\n</tr>\n</tbody>\n</table>\n\nSession-related messages and AVPs are defined in provided dictionaries. Their proper use is the user's responsibility.\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Description</th>\n<th>Code</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>8.14</td>\n<td>User-Name AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.15</td>\n<td>Termination-Cause AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.16</td>\n<td>Origin-State-Id AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.17</td>\n<td>Session-Binding AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.18</td>\n<td>Session-Server-Failover AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.19</td>\n<td>Multi-Round-Time-Out AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.20</td>\n<td>Class AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>8.21</td>\n<td>Event-Timestamp AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>9</td>\n<td>Accounting</td>\n<td>—</td>\n</tr>\n<tr>\n<td>9.1</td>\n<td>Server Directed Model</td>\n<td>—</td>\n</tr>\n<tr>\n<td>9.2</td>\n<td>Protocol Messages</td>\n<td>—</td>\n</tr>\n<tr>\n<td>9.3</td>\n<td>Accounting Application Extension and Requirements</td>\n<td>—</td>\n</tr>\n<tr>\n<td>9.4</td>\n<td>Fault Resilience</td>\n<td>—</td>\n</tr>\n<tr>\n<td>9.5</td>\n<td>Accounting Records</td>\n<td>—</td>\n</tr>\n<tr>\n<td>9.6</td>\n<td>Correlation of Accounting Records</td>\n<td>—</td>\n</tr>\n<tr>\n<td>9.7</td>\n<td>Accounting Command Codes</td>\n<td>—</td>\n</tr>\n<tr>\n<td>9.7.1</td>\n<td>Accounting-Request</td>\n<td>C</td>\n</tr>\n<tr>\n<td>9.7.2</td>\n<td>Accounting-Answer</td>\n<td>C</td>\n</tr>\n<tr>\n<td>9.8</td>\n<td>Accounting AVPs</td>\n<td>—</td>\n</tr>\n<tr>\n<td>9.8.1</td>\n<td>Accounting-Record-Type AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>9.8.2</td>\n<td>Acct-Interim-Interval AVP</td>\n<td>C</td>\n</tr>\n</tbody>\n</table>\n\nAccounting-related messages and AVPs are defined in provided dictionaries. Their proper use is the user's responsibility.\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Description</th>\n<th>Status</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>9.8.3</td>\n<td>Accounting-Record-Number AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>9.8.4</td>\n<td>Acct-Session-Id AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>9.8.5</td>\n<td>Acct-Multi-Session-Id AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>9.8.6</td>\n<td>Accounting-Sub-Session-Id AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>9.8.7</td>\n<td>Accounting-Realtime-Required AVP</td>\n<td>C</td>\n</tr>\n<tr>\n<td>10</td>\n<td>AVP Occurrence Tables</td>\n<td>—</td>\n</tr>\n<tr>\n<td>10.1</td>\n<td>Base Protocol Command AVP Table</td>\n<td>—</td>\n</tr>\n<tr>\n<td>10.2</td>\n<td>Accounting AVP Table</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11</td>\n<td>IANA Considerations</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.1</td>\n<td>AVP Header</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.1.1</td>\n<td>AVP Codes</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.1.2</td>\n<td>AVP Flags</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.2</td>\n<td>Diameter Header</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.2.1</td>\n<td>Command Codes</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.2.2</td>\n<td>Command Flags</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3</td>\n<td>AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.1</td>\n<td>Experimental-Result-Code AVP</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.2</td>\n<td>Result-Code AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.3</td>\n<td>Accounting-Record-Type AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.4</td>\n<td>Termination-Cause AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.5</td>\n<td>Redirect-Host-Usage AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.6</td>\n<td>Session-Server-Failover AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.7</td>\n<td>Session-Binding AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.8</td>\n<td>Disconnect-Cause AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.9</td>\n<td>Auth-Request-Type AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.10</td>\n<td>Auth-Session-State AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.11</td>\n<td>Re-Auth-Request-Type AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.12</td>\n<td>Accounting-Realtime-Required AVP Values</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.3.13</td>\n<td>Inband-Security-Id AVP (code 299)</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.4</td>\n<td>_diameters Service Name and Port Number Registration</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.5</td>\n<td>SCTP Payload Protocol Identifiers</td>\n<td>—</td>\n</tr>\n<tr>\n<td>11.6</td>\n<td>S-NAPTR Parameters</td>\n<td>—</td>\n</tr>\n<tr>\n<td>12</td>\n<td>Diameter Protocol-Related Configurable Parameters</td>\n<td>—</td>\n</tr>\n<tr>\n<td>13</td>\n<td>Security Considerations</td>\n<td>PC</td>\n</tr>\n<tr>\n<td>13.1</td>\n<td>TLS/TCP and DTLS/SCTP Usage</td>\n<td>PC</td>\n</tr>\n<tr>\n<td>13.2</td>\n<td>Peer-to-Peer Considerations</td>\n<td>—</td>\n</tr>\n<tr>\n<td>13.3</td>\n<td>AVP Considerations</td>\n<td>—</td>\n</tr>\n<tr>\n<td>14</td>\n<td>References</td>\n<td>—</td>\n</tr>\n<tr>\n<td>14.1</td>\n<td>Normative References</td>\n<td>—</td>\n</tr>\n<tr>\n<td>14.2</td>\n<td>Informative References</td>\n<td>—</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.1: RFC 6733 Compliance\n2 Reference Manual\n\nThe Diameter application is a framework for building applications on top of the Diameter protocol.\ndiameter\n\nErlang module\n\nThis module provides the interface with which a user can implement a Diameter node that sends and receives messages using the Diameter protocol as defined in RFC 6733.\n\nBasic usage consists of creating a representation of a locally implemented Diameter node and its capabilities with `start_service/2`, adding transport capability using `add_transport/2` and sending Diameter requests and receiving Diameter answers with `call/4`. Incoming Diameter requests are communicated as callbacks to a `diameter_app(3)` callback modules as specified in the service configuration.\n\nBeware the difference between `diameter` (not capitalized) and `Diameter` (capitalized). The former refers to the Erlang application named `diameter` whose main api is defined here, the latter to Diameter protocol in the sense of RFC 6733.\n\nThe diameter application must be started before calling most functions in this module.\n\nDATA TYPES\n\n- `Address()`\n- `DiameterIdentity()`\n- `Grouped()`\n- `OctetString()`\n- `Time()`\n- `Unsigned32()`\n- `UTF8String()`\n\nTypes corresponding to RFC 6733 AVP Data Formats. Defined in `diameter_dict(4)`.\n\n- `application_alias() = term()`\n \n Name identifying a Diameter application in service configuration. Passed to `call/4` when sending requests defined by the application.\n\n- `application_module() = Mod | [Mod | ExtraArgs] | #diameter_callback{}`\n \n Module implementing the callback interface defined in `diameter_app(3)`, along with any extra arguments to be appended to those documented. Note that extra arguments specific to an outgoing request can be specified to `call/4`, in which case those are appended to any module-specific extra arguments.\n\n Specifying a `#diameter_callback{}` record allows individual functions to be configured in place of the usual `diameter_app(3)` callbacks. See `diameter_callback.erl` for details.\n\n- `application_opt()`\n \n Options defining a Diameter application. Has one of the following types.\n\n ```erlang```\n {alias, application_alias()}\n \n Unique identifier for the application in the scope of the service. Defaults to the value of the `dictionary` option.\n\n ```erlang```\n {dictionary, atom()}\n \n Name of an encode/decode module for the Diameter messages defined by the application. These modules are generated from files whose format is documented in `diameter_dict(4)`.\n(module, application_module())\n\nCallback module in which messages of the Diameter application are handled. See diameter_app(3) for the required interface and semantics.\n\n(state, term())\n\nInitial callback state. The prevailing state is passed to some diameter_app(3) callbacks, which can then return a new state. Defaults to the value of the alias option.\n\n(call_mutates_state, true|false)\n\nWhether or not the pick_peer/4 application callback can modify the application state. Defaults to false.\n\n**Warning:**\npick_peer/4 callbacks are serialized when this option is true, which is a potential performance bottleneck. A simple Diameter client may suffer no ill effects from using mutable state but a server or agent that responds to incoming request should probably avoid it.\n\n(answer_errors, callback|report|discard)\n\nManner in which incoming answer messages containing decode errors are handled.\n\nIf callback then errors result in a handle_answer/4 callback in the same fashion as for handle_request/3, with errors communicated in the errors field of the #diameter_packet() passed to the callback. If report then an answer containing errors is discarded without a callback and a warning report is written to the log. If discard then an answer containing errors is silently discarded without a callback. In both the report and discard cases the return value for the call/4 invocation in question is as if a callback had taken place and returned {error, failure}.\n\nDefaults to discard.\n\n(request_errors, answer_3xxx|answer|callback)\n\nManner in which incoming requests are handled when an error other than 3007 (DIAMETER_APPLICATION_UNSUPPORTED, which cannot be associated with an application callback module), is detected.\n\nIf answer_3xxx then requests are answered without a handle_request/3 callback taking place. If answer then even 5xxx errors are answered without a callback unless the connection in question has configured the RFC 3588 common dictionary as noted below. If callback then a handle_request/3 callback always takes place and its return value determines the answer sent to the peer, if any.\n\nDefaults to answer_3xxx.\n\n**Note:**\n\nAnswers sent by diameter set the E-bit in the Diameter Header. Since RFC 3588 allows only 3xx result codes in an answer-message, answer has the same semantics as answer_3xxx when the transport in question has been configured with diameter_gen_base_rfc3588 as its common dictionary. Since RFC 6733 allows both 3xx and 5xx result codes in an answer-message, a transport with diameter_gen_base_rfc6733 as its common dictionary does distinguish between answer_3xxx and answer.\n\ncall_opt()\n\nOptions available to call/4 when sending an outgoing Diameter request. Has one of the following types.\n{extra, list()}\nExtra arguments to append to callbacks to the callback module in question. These are appended to any extra arguments configured on the callback itself. Multiple options append to the argument list.\n\n{filter, peer_filter()}\nFilter to apply to the list of available peers before passing it to the pick_peer/4 callback for the application in question. Multiple options are equivalent a single all filter on the corresponding list of filters. Defaults to none.\n\n{peer, diameter_app:peer_ref()}\nPeer to which the request in question can be sent, preempting the selection of peers having advertised support for the Diameter application in question. Multiple options can be specified, and their order is respected in the candidate lists passed to a subsequent pick_peer/4 callback.\n\n{timeout, Unsigned32()}\nNumber of milliseconds after which the request should timeout. Defaults to 5000.\n\ndetach\nCause call/4 to return ok as soon as the request in question has been encoded, instead of waiting for and returning the result from a subsequent handle_answer/4 or handle_error/4 callback.\n\nAn invalid option will cause call/4 to fail.\n\ncapability()\nAVP values sent in outgoing CER or CEA messages during capabilities exchange. Can be configured both on a service and a transport, values on the latter taking precedence. Has one of the following types.\n\n{Origin-Host, DiameterIdentity()}\n{Origin-Realm, DiameterIdentity()}\n{Host-IP-Address, [Address()]}\n\nAn address list is available to the start function of a transport module, which can return a new list for use in the subsequent CER or CEA. Host-IP-Address need not be specified if the transport module in question communicates an address list as described in diameter_transport(3)\n\n{Vendor-Id, Unsigned32()}\n{Product-Name, UTF8String()}\n{Origin-State-Id, Unsigned32()}\n\nOrigin-State-Id is optional but, if configured, will be included in outgoing CER/CEA and DWR/DWA messages. Setting a value of 0 (zero) is equivalent to not setting a value, as documented in RFC 6733. The function origin_state_id/0 can be used as to retrieve a value that is computed when the diameter application is started.\n\n{Supported-Vendor-Id, [Unsigned32()]\n{Auth-Application-Id, [Unsigned32()]\n{Inband-Security-Id, [Unsigned32()]\n\nInband-Security-Id defaults to the empty list, which is equivalent to a list containing only 0 (NO_INBAND_SECURITY). If 1 (TLS) is specified then TLS is selected if the CER/CEA received from the peer offers it.\n\n{Acct-Application-Id, [Unsigned32()]\n{Vendor-Specific-Application-Id, [Grouped()]\n{Firmware-Revision, Unsigned32()}\n\nNote that each tuple communicates one or more AVP values. It is an error to specify duplicate tuples.\neval() = \\{M, F, A\\} | fun() | [eval() | A]\n\nAn expression that can be evaluated as a function in the following sense.\n\n\\[\n\\begin{align*}\n\\text{eval}(\\{M, F, A\\} | T) & \\rightarrow \\\\\n& \\text{apply}(M, F, T + A);\n\\text{eval}(\\{F | A\\} | T) & \\rightarrow \\\\\n& \\text{eval}(\\{F | T + A\\});\n\\text{eval}(F) & \\rightarrow \\\\\n& \\text{eval}(F).\n\\end{align*}\n\\]\n\nApplying an \\texttt{eval()} \\texttt{E} to an argument list \\texttt{A} is meant in the sense of \\texttt{eval([E | A])}.\n\n**Warning:**\n\nBeware of using fun expressions of the form \\texttt{fun Name/Arity} in situations in which the fun is not short-lived and code is to be upgraded at runtime since any processes retaining such a fun will have a reference to old code. In particular, such a value is typically inappropriate in configuration passed to \\texttt{start_service/2} or \\texttt{add_transport/2}.\n\n\\texttt{peer_filter() = term()}\n\nFilter passed to \\texttt{call/4} in order to select candidate peers for a \\texttt{pick_peer/4} callback. Has one of the following types.\n\n\\begin{itemize}\n\\item \\texttt{none}\n Matches any peer. This is a convenience that provides a filter equivalent to no filter.\n\\item \\texttt{host}\n Matches only those peers whose Origin-Host has the same value as Destination-Host in the outgoing request in question, or any peer if the request does not contain a Destination-Host AVP.\n\\item \\texttt{realm}\n Matches only those peers whose Origin-Realm has the same value as Destination-Realm in the outgoing request in question, or any peer if the request does not contain a Destination-Realm AVP.\n\\item \\texttt{(host, any|DiameterIdentity())}\n Matches only those peers whose Origin-Host has the specified value, or all peers if the atom \\texttt{any}.\n\\item \\texttt{(realm, any|DiameterIdentity())}\n Matches only those peers whose Origin-Realm has the specified value, or all peers if the atom \\texttt{any}.\n\\item \\texttt{(eval, eval())}\n Matches only those peers for which the specified \\texttt{eval()} returns \\texttt{true} when applied to the connection's \\texttt{diameter_caps} record. Any other return value or exception is equivalent to \\texttt{false}.\n\\item \\texttt{(neg, peer_filter())}\n Matches only those peers not matched by the specified filter.\n\\item \\texttt{(all, [peer_filter()])}\n Matches only those peers matched by each filter in the specified list.\n\\item \\texttt{(any, [peer_filter()])}\n Matches only those peers matched by at least one filter in the specified list. The resulting list will be in match order, peers matching the first filter of the list sorting before those matched by the second, and so on.\n\\end{itemize}\n{first, [peer_filter()])}\n\nLike any, but stops at the first filter for which there are matches, which can be much more efficient when there are many peers. For example, the following filter causes only peers best matching both the host and realm filters to be presented.\n\n{first, [{all, [host, realm]}, realm]}\n\nAn invalid filter is equivalent to {any, []}, a filter that matches no peer.\n\n**Note:**\n\nThe host and realm filters cause the Destination-Host and Destination-Realm AVPs to be extracted from the outgoing request, assuming it to be a record- or list-valued diameter_codec:message(), and assuming at most one of each AVP. If this is not the case then the (host | realm, DiameterIdentity()) filters must be used to achieve the desired result. An empty DiameterIdentity() (which should not be typical) matches all hosts/realms for the purposes of filtering.\n\n**Warning:**\n\nA host filter is not typically desirable when setting Destination-Host since it will remove peer agents from the candidates list.\n\n```\nservice_event() = #diameter_event{service = service_name(), info = service_event_info()}\n\nAn event message sent to processes that have subscribed to these using subscribe/1.\n\nservice_event_info() = term()\n\nThe info field of a service_event() record. Can have one of the following types.\n\nstart\nstop\n\nThe service is being started or stopped. No event precedes a start event. No event follows a stop event, and this event implies the termination of all transport processes.\n\n{up, Ref, Peer, Config, Pkt}\n{up, Ref, Peer, Config}\n{down, Ref, Peer, Config}\n```\n\n```\nRef = transport_ref()\nPeer = diameter_app:peer()\nConfig = {connect|listen, [transport_opt()]}\nPkt = #diameter_packet{}\n```\n\nThe RFC 3539 watchdog state machine has transitioned into (up) or out of (down) the OKAY state. If a #diameter_packet{} is present in an up event then there has been a capabilities exchange on a newly established transport connection and the record contains the received CER or CEA.\n\nNote that a single up or down event for a given peer corresponds to multiple peer_up/3 or peer_down/3 callbacks, one for each of the Diameter applications negotiated during capabilities exchange. That is, the event communicates connectivity with the peer as a whole while the callbacks communicate connectivity with respect to individual Diameter applications.\n{reconnect, Ref, Opts}\n\nRef = transport_ref()\nOpts = [transport_opt()]\n\nA connecting transport is attempting to establish/reestablish a transport connection with a peer following connect_timer or watchdog_timer expiry.\n\n{closed, Ref, Reason, Config}\n\nRef = transport_ref()\nConfig = [connect|listen, [transport_opt()]]\n\nCapabilities exchange has failed. Reason can have one of the following types.\n\n{'CER', Result, Caps, Pkt}\n\nResult = ResultCode | {capabilities_cb, CB, ResultCode|discard}\nCaps = #diameter_caps()\nPkt = #diameter_packet()\nResultCode = integer()\nCB = eval()\n\nAn incoming CER has been answered with the indicated result code, or discarded. Caps contains pairs of values, for the local node and remote peer respectively. Pkt contains the CER in question. In the case of rejection by a capabilities callback, the tuple contains the rejecting callback.\n\n{'CER', Caps, {ResultCode, Pkt}}\n\nResultCode = integer()\nCaps = #diameter_caps()\nPkt = #diameter_packet()\n\nAn incoming CER contained errors and has been answered with the indicated result code. Caps contains values for the local node only. Pkt contains the CER in question.\n\n{'CER', timeout}\n\nAn expected CER was not received within capx_timeout of connection establishment.\n\n{'CEA', Result, Caps, Pkt}\n\nResult = ResultCode | atom() | {capabilities_cb, CB, ResultCode|discard}\nCaps = #diameter_caps()\nPkt = #diameter_packet()\nResultCode = integer()\n\nAn incoming CEA has been rejected for the indicated reason. An integer-valued Result indicates the result code sent by the peer. Caps contains pairs of values for the local node and remote peer. Pkt contains the CEA in question. In the case of rejection by a capabilities callback, the tuple contains the rejecting callback.\n\n{'CEA', Caps, Pkt}\n\nCaps = #diameter_caps()\nPkt = #diameter_packet()\nAn incoming CEA contained errors and has been rejected. Caps contains only values for the local node. Pkt contains the CEA in question.\n\n{\\'CEA\\', timeout}\n\nAn expected CEA was not received within capx_timeout of connection establishment.\n\n{ watchdog, Ref, PeerRef, {From, To}, Config }\n\nRef = transport_ref()\nPeerRef = diameter_app:peer_ref()\nFrom, To = initial | okay | suspect | down | reopen\nConfig = {connect|listen, [transport_opt()]} An RFC 3539 watchdog state machine has changed state.\n\nany()\n\nFor forward compatibility, a subscriber should be prepared to receive info fields of forms other than the above.\n\n\\n\n\\n\n\\n\n\\n\n\\n\n\\n\n\\n\nWarning:\nThe capabilities advertised by a node must match its configured applications. In particular, application configuration must be matched by corresponding capability() configuration, of *-Application-Id AVPs in particular.\n\n{ decode_format, record | list | map | none }\nThe format of decoded messages and grouped AVPs in the msg field of diameter_packet records and value field of diameter_avp records respectively. If record then a record whose definition is generated from the dictionary file in question. If list or map then a [Name | Avps] pair where Avps is a list of AVP name/values pairs or a map keyed on AVP names respectively. If none then the atom-value message name, or undefined for a Grouped AVP. See also diameter_codec:message().\n\nDefaults to record.\n\nNote:\nAVPs are decoded into a list of diameter_avp records in avps field of diameter_packet records independently of decode_format.\nThe degree to which the service allows multiple transport connections to the same peer, as identified by its Origin-Host at capabilities exchange.\n\nIf \\([\\text{node()}]\\) then a connection is rejected if another already exists on any of the specified nodes. Types \\(\\text{false, node, nodes}\\) and \\(\\text{eval()}\\) are equivalent to \\([\\text{}], [\\text{node()}], [\\text{node()}|\\text{nodes()}]\\) and the evaluated value respectively, evaluation of each expression taking place whenever a new connection is to be established. Note that \\(\\text{false}\\) allows an unlimited number of connections to be established with the same peer.\n\nMultiple connections are independent and governed by their own peer and watchdog state machines.\n\nDefaults to \\(\\text{nodes}\\).\n\nA constant value \\(H\\) for the topmost \\(32-N\\) bits of of 32-bit End-to-End and Hop-by-Hop Identifiers generated by the service, either explicitly or as a return value of a function to be evaluated at \\(\\text{start_service/2}\\). In particular, an identifier \\(Id\\) is mapped to a new identifier as follows.\n\n\\[\n(H \\text{ bsl } N) \\text{ bsr (Id bsl ((1 \\text{ bsl } N) - 1))}\n\\]\n\nNote that RFC 6733 requires that End-to-End Identifiers remain unique for a period of at least 4 minutes and that this and the call rate places a lower bound on appropriate values of \\(N\\): at a rate of \\(R\\) requests per second, an \\(N\\)-bit counter traverses all of its values in \\((1 \\text{ bsl } N) \\text{ div } (R*60)\\) minutes, so the bound is \\(4*R*60 <= 1 \\text{ bsl } N\\).\n\n\\(N\\) must lie in the range \\(0..32\\) and \\(H\\) must be a non-negative integer less than \\(1 \\text{ bsl } (32-N)\\).\n\nDefaults to \\(\\{0,32\\}\\).\n\nMultiple Erlang nodes implementing the same Diameter node should be configured with different sequence masks to ensure that each node uses a unique range of End-to-End and Hop-by-Hop Identifiers for outgoing requests.\n\nNodes to which peer connections established on the local Erlang node are communicated. Shared peers become available in the remote candidates list passed to \\(\\text{pick_peer/4}\\) callbacks on remote nodes whose services are configured to use them: see \\(\\text{use_shared_peers}\\) below.\n\nIf \\(\\text{false}\\) then peers are not shared. If \\([\\text{node()}]\\) then peers are shared with the specified list of nodes. If \\(\\text{eval()}\\) then peers are shared with the nodes returned by the specified function, evaluated whenever a peer connection becomes available or a remote service requests information about local connections. The value \\(\\text{true}\\) is equivalent to \\(\\text{fun erlang:nodes/0}\\). The value \\(\\text{node()}\\) in a list is ignored, so a collection of services can all be configured to share with the same list of nodes.\n\nDefaults to \\(\\text{false}\\).\nNote:\n\nPeers are only shared with services of the same name for the purpose of sending outgoing requests. Since the value of the application_opt() alias, passed to call/4, is the handle for identifying a peer as a suitable candidate, services that share peers must use the same aliases to identify their supported applications. They should typically also configure identical capabilities(), since by sharing peer connections they are distributing the implementation of a single Diameter node across multiple Erlang nodes.\n\n{strict_arities, boolean() | encode | decode}\n\nWhether or not to require that the number of AVPs in a message or grouped AVP agree with those specified in the dictionary in question when passing messages to diameter_app(3) callbacks. If true then mismatches in an outgoing messages cause message encoding to fail, while mismatches in an incoming message are reported as 5005/5009 errors in the errors field of the diameter_packet record passed to handle_request/3 or handle_answer/4 callbacks. If false then neither error is enforced/detected. If encode or decode then errors are only enforced/detected on outgoing or incoming messages respectively.\n\nDefaults to true.\n\nNote:\n\nDisabling arity checks affects the form of messages at encode/decode. In particular, decoded AVPs are represented as lists of values, regardless of the AVP’s arity (ie. expected number in the message/AVP grammar in question), and values are expected to be supplied as lists at encode. This differs from the historic decode behaviour of representing AVPs of arity 1 as bare values, not wrapped in a list.\n\n{string_decode, boolean()}\n\nWhether or not to decode AVPs of type OctetString() and its derived types DiameterIdentity(), DiameterURI(), IPFilterRule(), QoSFilterRule(), and UTF8String(). If true then AVPs of these types are decoded to string(). If false then values are retained as binary().\n\nDefaults to true.\n\nWarning:\n\nThis option should be set to false since a sufficiently malicious peer can otherwise cause large amounts of memory to be consumed when decoded Diameter messages are passed between processes. The default value is for backwards compatibility.\n\n{traffic_counters, boolean()}\n\nWhether or not to count application-specific messages; those for which diameter_app(3) callbacks take place. If false then only messages handled by diameter itself are counted: CER/CEA, DWR/DWA, DPR/DPA.\n\nDefaults to true.\n\nNote:\n\nDisabling counters is a performance improvement, but means that the omitted counters are not returned by service_info/2.\n\n{use_shared_peers, boolean() | [node()] | eval()}\n\nNodes from which communicated peers are made available in the remote candidates list of pick_peer/4 callbacks.\n\nEricsson AB. All Rights Reserved.: Diameter | 25\nIf `false` then remote peers are not used. If `[node()]` then only peers from the specified list of nodes are used. If `eval()` then only peers returned by the specified function are used, evaluated whenever a remote service communicates information about an available peer connection. The value `true` is equivalent to `fun erlang:nodes/0`. The value `node()` in a list is ignored.\n\nDefaults to `false`.\n\n**Note:**\n\nA service that does not use shared peers will always pass the empty list as the second argument of `pick_peer/4` callbacks.\n\n**Warning:**\n\nSending a request over a peer connection on a remote node is less efficient than sending it over a local connection. It may be preferable to make use of the `service_opt()` `restrict_connections` and maintain a dedicated connection on each node from which requests are sent.\n\n---\n\n**transport_opt()**\n\nAny transport option except `applications`, `capabilities`, `transport_config`, and `transport_module`. Used as defaults for transport configuration, values passed to `add_transport/2` overriding values configured on the service.\n\n**transport_opt()**\n\nOption passed to `add_transport/2`. Has one of the following types.\n\n```erlang\n{applications, [application_alias()]} \n```\n\nDiameter applications to which the transport should be restricted. Defaults to all applications configured on the service in question. Applications not configured on the service in question are ignored.\n\n**Warning:**\n\nThe capabilities advertised by a node must match its configured applications. In particular, setting `applications` on a transport typically implies having to set matching `-Application-Id` AVPs in a `capabilities()` tuple.\n\n```erlang\n{avp_dictionaries, [module()]} \n```\n\nA list of alternate dictionary modules with which to encode/decode AVPs that are not defined by the dictionary of the application in question. At decode, such AVPs are represented as `diameter_avp` records in the `'AVP'` field of a decoded message or Grouped AVP, the first alternate that succeeds in decoding the AVP setting the record's value field. At encode, values in an `'AVP'` list can be passed as AVP name/value 2-tuples, and it is an encode error for no alternate to define the AVP of such a tuple.\n\nDefaults to the empty list.\n**Note:**\n\nThe motivation for alternate dictionaries is RFC 7683, Diameter Overload Indication Conveyance (DOIC), which defines AVPs to be piggybacked onto existing application messages rather than defining an application of its own. The DOIC dictionary is provided by the diameter application, as module `diameter_gen_doic_rfc7683`, but alternate dictionaries can be used to encode/decode any set of AVPs not known to an application dictionary.\n\n```\n{capabilities, [capability()]} \nAVPs used to construct outgoing CER/CEA messages. Values take precedence over any specified on the service in question.\n\nSpecifying a capability as a transport option may be particularly appropriate for Inband-Security-Id, in case TLS is desired over TCP as implemented by `diameter_tcp(3)`.\n\n{capabilities_cb, eval()}\nCallback invoked upon reception of CER/CEA during capabilities exchange in order to ask whether or not the connection should be accepted. Applied to the `transport_ref()` and `#diameter_caps()` record of the connection.\n\nThe return value can have one of the following types.\n\nok\nAccept the connection.\n\ninteger()\nCauses an incoming CER to be answered with the specified Result-Code.\n\ndiscard\nCauses an incoming CER to be discarded without CEA being sent.\n\nunknown\nEquivalent to returning 3010, DIAMETER_UNKNOWN_PEER.\n\nReturning anything but `ok` or a 2xxx series result code causes the transport connection to be broken. Multiple `capabilities_cb` options can be specified, in which case the corresponding callbacks are applied until either all return `ok` or one does not.\n\n{capx_timeout, Unsigned32()}\nNumber of milliseconds after which a transport process having an established transport connection will be terminated if the expected capabilities exchange message (CER or CEA) is not received from the peer. For a connecting transport, the timing of connection attempts is governed by `connect_timer` or `watchdog_timer` expiry. For a listening transport, the peer determines the timing.\n\nDefaults to 10000.\n\n{connect_timer, Tc}\n\nTc = Unsigned32()\n\nFor a connecting transport, the RFC 6733 Tc timer, in milliseconds. This timer determines the frequency with which a transport attempts to establish an initial connection with its peer following transport configuration. Once an initial connection has been established, `watchdog_timer` determines the frequency of reconnection attempts, as required by RFC 3539.\nFor a listening transport, the timer specifies the time after which a previously connected peer will be forgotten: a connection after this time is regarded as an initial connection rather than reestablishment, causing the RFC 3539 state machine to pass to state OKAY rather than REOPEN. Note that these semantics are not governed by the RFC and that a listening transport's connect_timer should be greater than its peer's Tw plus jitter.\n\nDefaults to 30000 for a connecting transport and 60000 for a listening transport.\n\n\\{disconnect_cb, eval()\\}\n\nCallback invoked prior to terminating the transport process of a transport connection having watchdog state OKAY. Applied to application|service|transport and the transport_ref() and diameter_app:peer() in question: application indicates that the diameter application is being stopped, service that the service in question is being stopped by stop_service/1, and transport that the transport in question is being removed by remove_transport/2.\n\nThe return value can have one of the following types.\n\n\\{dpr, [option()]\\}\n\nSend Disconnect-Peer-Request to the peer, the transport process being terminated following reception of Disconnect-Peer-Answer or timeout. An option() can be one of the following.\n\n\\{cause, 0|rebooting|1|busy|2|goaway\\}\n\nDisconnect-Cause to send, REBOOTING, BUSY and DO_NOT_WANT_TO_TALK_TO_YOU respectively. Defaults to rebooting for Reason=service|application and goaway for Reason=transport.\n\n\\{timeout, Unsigned32()\\}\n\nNumber of milliseconds after which the transport process is terminated if DPA has not been received. Defaults to the value of dpa_timeout.\n\ndpr\n\nEquivalent to \\{dpr, []\\}.\n\nclose\n\nTerminate the transport process without Disconnect-Peer-Request being sent to the peer.\n\nignore\n\nEquivalent to not having configured the callback.\n\nMultiple disconnect_cb options can be specified, in which case the corresponding callbacks are applied until one of them returns a value other than ignore. All callbacks returning ignore is equivalent to not having configured them.\n\nDefaults to a single callback returning dpr.\n\n\\{dpa_timeout, Unsigned32()\\}\n\nNumber of milliseconds after which a transport connection is terminated following an outgoing DPR if DPA is not received.\n\nDefaults to 1000.\n\n\\{dpr_timeout, Unsigned32()\\}\n\nNumber of milliseconds after which a transport connection is terminated following an incoming DPR if the peer does not close the connection.\n\nDefaults to 5000.\n{incoming_maxlen, 0..16777215} \nBound on the expected size of incoming Diameter messages. Messages larger than the specified number of bytes are discarded.\nDefaults to 16777215, the maximum value of the 24-bit Message Length field in a Diameter Header.\n\n{length_errors, exit|handle|discard} \nHow to deal with errors in the Message Length field of the Diameter Header in an incoming message. An error in this context is that the length is not at least 20 bytes (the length of a Header), is not a multiple of 4 (a valid length) or is not the length of the message in question, as received over the transport interface documented in diameter_transport(3).\nIf exit then the transport process in question exits. If handle then the message is processed as usual, a resulting handle_request/3 or handle_answer/4 callback (if one takes place) indicating the 5015 error (DIAMETER_INVALID_MESSAGE_LENGTH). If discard then the message in question is silently discarded.\nDefaults to exit.\n\nNote:\nThe default value reflects the fact that a transport module for a stream-oriented transport like TCP may not be able to recover from a message length error since such a transport must use the Message Length header to divide the incoming byte stream into individual Diameter messages. An invalid length leaves it with no reliable way to rediscover message boundaries, which may result in the failure of subsequent messages. See diameter_tcp(3) for the behaviour of that module.\n\n{pool_size, pos_integer()} \nNumber of transport processes to start. For a listening transport, determines the size of the pool of accepting transport processes, a larger number being desirable for processing multiple concurrent peer connection attempts. For a connecting transport, determines the number of connections to the peer in question that will be attempted to be established: the service_opt(): restrict_connections should also be configured on the service in question to allow multiple connections to the same peer.\n\n{spawn_opt, [term()] | {M,F,A}} \nAn options list passed to erlang:spawn_opt/2 to spawn a handler process for an incoming Diameter request on the local node, or an MFA that returns the pid of a handler process.\nOptions monitor and link are ignored in the list-valued case. An MFA is applied with an additional term prepended to its argument list, and should return either the pid of the handler process that invokes diameter_traffic:request/1 on the argument in order to process the request, or the atom discard. The handler process need not be local, and diameter need not be started on the remote node, but diameter and relevant application callbacks must be on the code path.\nDefaults to the empty list.\n\n{strict_capx, boolean()} \nWhether or not to enforce the RFC 6733 requirement that any message before capabilities exchange should close the peer connection. If false then unexpected messages are discarded.\nDefaults to true. Changing this results in non-standard behaviour, but can be useful in case peers are known to be behave badly.\nWhether or not to regard an AVP setting the M-bit as erroneous when the command grammar in question does not explicitly allow the AVP. If `true` then such AVPs are regarded as 5001 errors, `DIAMETER_AVP_UNSUPPORTED`. If `false` then the M-bit is ignored and policing it becomes the receiver's responsibility.\n\nDefaults to `true`.\n\n**Warning:**\n\nRFC 6733 is unclear about the semantics of the M-bit. One the one hand, the CCF specification in section 3.2 documents AVP in a command grammar as meaning any arbitrary AVP; on the other hand, 1.3.4 states that AVPs setting the M-bit cannot be added to an existing command; the modified command must instead be placed in a new Diameter application.\n\nThe reason for the latter is presumably interoperability: allowing arbitrary AVPs setting the M-bit in a command makes its interpretation implementation-dependent, since there's no guarantee that all implementations will understand the same set of arbitrary AVPs in the context of a given command. However, interpreting AVP in a command grammar as any AVP, regardless of M-bit, renders 1.3.4 meaningless, since the receiver can simply ignore any AVP it thinks isn't relevant, regardless of the sender's intent.\n\nBeware of confusing mandatory in the sense of the M-bit with mandatory in the sense of the command grammar. The former is a semantic requirement: that the receiver understand the semantics of the AVP in the context in question. The latter is a syntactic requirement: whether or not the AVP must occur in the message in question.\n\n**{transport_config, term()}**\n\nTerm passed as the third argument to the `start/3` function of the relevant transport module in order to start a transport process. Defaults to the empty list.\n\nThe 3-tuple form additionally specifies an interval, in milliseconds, after which a started transport process should be terminated if it has not yet established a connection. For example, the following options on a connecting transport request a connection with one peer over SCTP or another (typically the same) over TCP.\n\n```\n{transport_module, diameter_sctp}\n{transport_config, SctpOpts, 5000}\n{transport_module, diameter_tcp}\n{transport_config, TcpOpts}\n```\n\nTo listen on both SCTP and TCP, define one transport for each.\n\n**{transport_module, atom()}**\n\nModule implementing a transport process as defined in `diameter_transport(3)`. Defaults to `diameter_tcp`.\n\nMultiple `transport_module` and `transport_config` options are allowed. The order of these is significant in this case (and only in this case), a `transport_module` being paired with the first `transport_config` following it in the options list, or the default value for trailing modules. Transport starts will be attempted with each of the modules in order until one establishes a connection within the corresponding timeout (see below) or all fail.\n\n**{watchdog_config, [{okay|suspect, non_neg_integer()}]}**\n\nConfiguration that alters the behaviour of the watchdog state machine. On key `okay`, the non-negative number of answered DWR messages before transitioning from REOPEN to OKAY. On key `suspect`, the...\nnumber of watchdog timeouts before transitioning from OKAY to SUSPECT when DWR is unanswered, or 0 to not make the transition.\n\nDefaults to \\{\\{okay, 3\\}, \\{suspect, 1\\}\\}. Not specifying a key is equivalent to specifying the default value for that key.\n\n**Warning:**\n\nThe default value is as required by RFC 3539: changing it results in non-standard behaviour that should only be used to simulate misbehaving nodes during test.\n\n\\{watchdog_timer, TwInit\\}\n\n\\begin{verbatim}\nTwInit = Unsigned32()\n| {M,F,A}\n\\end{verbatim}\n\nThe RFC 3539 watchdog timer. An integer value is interpreted as the RFC’s TwInit in milliseconds, a jitter of ± 2 seconds being added at each rearming of the timer to compute the RFC’s Tw. An MFA is expected to return the RFC’s Tw directly, with jitter applied, allowing the jitter calculation to be performed by the callback.\n\nAn integer value must be at least 6000 as required by RFC 3539. Defaults to 30000.\n\nUnrecognized options are silently ignored but are returned unmodified by service_info/2 and can be referred to in predicate functions passed to remove_transport/2.\n\ntransport_ref() = reference()\n\nReference returned by add_transport/2 that identifies the configuration.\n\n**Exports**\n\nadd_transport(SvcName, \\{connect|listen, [Opt]\\}) -> \\{ok, Ref\\} | \\{error, Reason\\}\n\nTypes:\n\n\\begin{verbatim}\nSvcName = service_name()\nOpt = transport_opt()\nRef = transport_ref()\nReason = term()\n\\end{verbatim}\n\nAdd transport capability to a service.\n\nThe service will start transport processes as required in order to establish a connection with the peer, either by connecting to the peer (connect) or by accepting incoming connection requests (listen). A connecting transport establishes transport connections with at most one peer, an listening transport potentially with many.\n\nThe diameter application takes responsibility for exchanging CER/CEA with the peer. Upon successful completion of capabilities exchange the service calls each relevant application module’s peer_up/3 callback after which the caller can exchange Diameter messages with the peer over the transport. In addition to CER/CEA, the service takes responsibility for the handling of DWR/DWA and required by RFC 3539, as well as for DPR/DPA.\n\nThe returned reference uniquely identifies the transport within the scope of the service. Note that the function returns before a transport connection has been established.\nNote:\n\nIt is not an error to add a transport to a service that has not yet been configured: a service can be started after configuring its transports.\n\ncall(SvcName, App, Request, [Opt]) -> Answer | ok | {error, Reason}\n\nTypes:\n\n\\[\n\\begin{align*}\n\\text{SvcName} &= \\text{service\\_name}() \\\\\n\\text{App} &= \\text{application\\_alias}() \\\\\n\\text{Request} &= \\text{diameter\\_codec\\_message}() \\\\\n\\text{Answer} &= \\text{term}() \\\\\n\\text{Opt} &= \\text{call\\_opt}()\n\\end{align*}\n\\]\n\nSend a Diameter request message.\n\nApp specifies the Diameter application in which the request is defined and callbacks to the corresponding callback module will follow as described below and in diameter_app(3). Unless the detach option is specified, the call returns either when an answer message is received from the peer or an error occurs. In the answer case, the return value is as returned by a handle_answer/4 callback. In the error case, whether or not the error is returned directly by diameter or from a handle_error/4 callback depends on whether or not the outgoing request is successfully encoded for transmission to the peer, the cases being documented below.\n\nIf there are no suitable peers, or if pick_peer/4 rejects them by returning false, then {error, no_connection} is returned. Otherwise pick_peer/4 is followed by a prepare_request/3 callback, the message is encoded and then sent.\n\nThere are several error cases which may prevent an answer from being received and passed to a handle_answer/4 callback:\n\n- If the initial encode of the outgoing request fails, then the request process fails and {error, encode} is returned.\n- If the request is successfully encoded and sent but the answer times out then a handle_error/4 callback takes place with Reason = timeout.\n- If the request is successfully encoded and sent but the service in question is stopped before an answer is received then a handle_error/4 callback takes place with Reason = cancel.\n- If the transport connection with the peer goes down after the request has been sent but before an answer has been received then an attempt is made to resend the request to an alternate peer. If no such peer is available, or if the subsequent pick_peer/4 callback rejects the candidates, then a handle_error/4 callback takes place with Reason = failover. If a peer is selected then a prepare_retransmit/3 callback takes place, after which the semantics are the same as following an initial prepare_request/3 callback.\n- If an encode error takes place during retransmission then the request process fails and {error, failure} is returned.\n- If an application callback made in processing the request fails (pick_peer, prepare_request, prepare_retransmit, handle_answer or handle_error) then either {error, encode} or {error, failure} is returned depending on whether or not there has been an attempt to send the request over the transport.\n\nNote that {error, encode} is the only return value which guarantees that the request has not been sent over the transport connection.\n\norigin_state_id() -> Unsigned32()\n\nReturn a reasonable value for use as Origin-State-Id in outgoing messages.\nThe value returned is the number of seconds since 19680120T031408Z, the first value that can be encoded as a Diameter Time(), at the time the diameter application was started.\n\n```\nremove_transport(SvcName, Pred) -> ok | {error, Reason}\nTypes:\n SvcName = service_name()\n Pred = Fun | MFA | transport_ref() | list() | true | false\n Fun = fun((transport_ref(), connect|listen, list()) -> boolean())\n | fun((transport_ref(), list()) -> boolean())\n | fun((list()) -> boolean())\n MFA = {atom(), atom(), list()}\n Reason = term()\n```\n\nRemove previously added transports. \nPred determines which transports to remove. An arity-3-valued Pred removes all transports for which Pred(Ref, Type, Opts) returns true, where Type and Opts are as passed to add_transport/2 and Ref is as returned by it. The remaining forms are equivalent to an arity-3 fun as follows.\n\n```\nPred = fun(transport_ref(), list()): fun(Ref, _, Opts) -> Pred(Ref, Opts) end\nPred = fun(list()): fun(_, _, Opts) -> Pred(Opts) end\nPred = transport_ref(): fun(Ref, _, _) -> Pred == Ref end\nPred = list(): fun(_, _, Opts) -> [] == Pred -- Opts end\nPred = true: fun(_, _, _) -> true end\nPred = false: fun(_, _, _) -> false end\nPred = {M,F,A}: fun(Ref, Type, Opts) -> apply(M, F, [Ref, Type, Opts | A]) end\n```\n\nRemoving a transport causes the corresponding transport processes to be terminated. Whether or not a DPR message is sent to a peer is controlled by value of disconnect_cb configured on the transport.\n\n```\nservice_info(SvcName, Info) -> term()\nTypes:\n SvcName = service_name()\n Info = Item | [Info]\n Item = atom()\n```\n\nReturn information about a started service. Requesting info for an unknown service causes undefined to be returned. Requesting a list of items causes a tagged list to be returned.\n\nItem can be one of the following.\n\n'Origin-Host'\n'Origin-Realm'\n'Vendor-Id'\n'Product-Name'\n'Origin-State-Id'\n'Host-IP-Address'\n'Supported-Vendor'\n'Auth-Application-Id'\n'Inband-Security-Id'\n'Acct-Application-Id'\n'Vendor-Specific-Application-Id'\ndiameter\n\n'Firmware-Revision'\n Return a capability value as configured with start_service/2.\napplications\n Return the list of applications as configured with start_service/2.\ncapabilities\n Return a tagged list of all capabilities values as configured with start_service/2.\ntransport\n Return a list containing one entry for each of the service's transport as configured with add_transport/2. Each entry is a tagged list containing both configuration and information about established peer connections. An example return value with for a client service with Origin-Host \"client.example.com\" configured with a single transport connected to \"server.example.com\" might look as follows.\nHere ref is a transport_ref() and options the corresponding transport_opt() list passed to add_transport/2. The watchdog entry shows the state of a connection's RFC 3539 watchdog state machine. The peer entry identifies the diameter_app:peer_ref() for which there will have been peer_up/3 callbacks for the Diameter applications identified by the apps entry, common being the application_alias(). The caps entry identifies the capabilities sent by the local node and received from the peer during capabilities exchange. The port entry displays socket-level information about the transport connection. The statistics entry presents Diameter-level counters, an entry like {{{0,280,1},recv},2} saying that the client has received 2 DWR messages: {0,280,1} = {Application_Id, Command_Code, R_Flag}.\n\nNote that watchdog, peer, apps, caps and port entries depend on connectivity with the peer and may not be present. Note also that the statistics entry presents values accumulated during the lifetime of the transport configuration.\nA listening transport presents its information slightly differently since there may be multiple accepted connections for the same transport_ref(). The transport info returned by a server with a single client connection might look as follows.\n\n```erlang\ndiameter |\n{[ref,Ref<0.0.0.61>],\n {type,listen},\n {options,{{transport_module,diameter_tcp},\n {transport_config,{{reuseaddr,true},\n {ip,[127,0,0,1]},\n {port,3868}}}}},\n {accept,[[{watchdog,<{0.56.0>,-576460739249514012,okay}>,\n {peer,<{0.58.0>,576460638229179167}>},\n {apps,[[0,common]]},\n {caps,{{origin_host,{\"server.example.com\",\"client.example.com\"}},\n {origin_state_id,[]},\n {supported_vendor_id,[]},\n {auth_application_id,[]},\n {acct_application_id,[]},\n {vendor_specific_application_id,[]},\n {firmware_revision,[]},\n {avp,[]}}},\n {port,{{owner,<0.62.0>},\n {module,diameter_tcp},\n {socket,[127,0,0,1],3868},\n {peer,[127,0,0,1],48758}},\n {statistics,{{recv_oct,1576},\n {recv_cnt,16},\n {recv_max,184},\n {recv_avg,98},\n {recv_dvi,26},\n {send_oct,1396},\n {send_cnt,16},\n {send_max,148},\n {send_avg,87},\n {send_pend,0}]]},\n {watchdog,<{0.72.0>,-576460638229179167,initial}>}]}],\n{statistics,[[{{0,280,0},recv},7],\n {{0,280,1},send},7],\n {{0,280,0},recv,{'Result-Code',2001}},7],\n {{0,258,1},recv},3],\n {{0,258,0},send},3],\n {{0,258,0},send,{'Result-Code',2001}},3],\n {{0,280,1},recv},5],\n {{0,280,0},send},5],\n {{0,280,0},send,{'Result-Code',2001}},5],\n {{0,257,1},recv},1],\n {{0,257,0},send},1],\n {{0,257,0},send,{'Result-Code',2001}},1}]}}]\n```\n\nThe information presented here is as in the connect case except that the client connections are grouped under an accept tuple.\n\nWhether or not the transport_opt() pool_size has been configured affects the format of the listing in the case of a connecting transport, since a value greater than 1 implies multiple transport processes for the same transport_ref(), as in the listening case. The format in this case is similar to the listing case, with a pool tuple in place of an accept tuple.\nReturn a list containing one entry for every established transport connection whose watchdog state machine is not in the down state. This is a flat view of transport info which lists only active connections and for which Diameter-level statistics are accumulated only for the lifetime of the transport connection. A return value for the server above might look as follows.\n\n```plaintext\n[[{ref,#Ref<0.0.0.61>},\n {type,accept},\n {options,[[{transport_module,diameter_tcp},\n {transport_config,[[{reuseaddr,true},\n {ip,[[127,0,0,1]],\n {port,3868}]}]},\n {watchdog,[[<0.56.0>,-576460739249514012,okay}]},\n {peer,[[<0.58.0>,-576460638229179167]}]},\n {caps,[[{origin_host,{\"server.example.com\",\"client.example.com\"}},\n {originRealm,[[\"example.com\",\"example.com\"]},\n {host_ip_address,[[[127,0,0,1]],[[127,0,0,1]]]]},\n {vendor_id,193},\n {product_name,\"Server\",\"Client\"}],\n {origin_state_id,[[],[]]},\n {supported_vendor_id,[[[],[]]]},\n {auth_application_id,[[0],[0]]},\n {inband_security_id,[[[],[]]]},\n {acct_application_id,[[[],[]]]},\n {vendor_specific_application_id,[[[],[]]]},\n {firmware_revision,[[[],[]]]},\n {app,[[0],[0]]}]},\n {port,[[{owner,<0.62.0>},\n {module,diameter_tcp},\n {socket,[[127,0,0,1],3868}]}],\n {statistics,[[{recvOct,10124},\n {recvCnt,132},\n {recvMax,184},\n {recvAvg,76},\n {recvDvi,9}],\n {sendOct,10016},\n {sendCnt,132},\n {sendMax,148},\n {sendAvg,75},\n {sendPend,0}]},\n {statistics,[[{[0,280,0],recv},62],\n {[0,280,1],recv},62],\n {[0,258,0],recv,\"Result-Code\",2001},62],\n {[0,258,1],recv},3],\n {[0,258,0],send},3],\n {[0,258,0],send,\"Result-Code\",2001},3],\n {[0,280,1],recv},66],\n {[0,280,0],send},66],\n {[0,280,0],send,\"Result-Code\",2001},66],\n {[0,257,1],recv},1],\n {[0,257,0],send},1],\n {[0,257,0],send,\"Result-Code\",2001},1]]}\n```\n\nNote that there may be multiple entries with the same ref, in contrast to transport info.\n\n**statistics**\n\nReturn a [{Counter, Ref}, non_neg_integer()] list of counter values. Ref can be either a transport_ref() or a diameter_app:peer_ref(). Entries for the latter are folded into corresponding\nentries for the former as peer connections go down. Entries for both are removed at remove_transport/2. The Diameter-level statistics returned by transport and connections info are based upon these entries.\n\ndiameter_app:peer_ref()\n\nReturn transport configuration associated with a single peer, as passed to add_transport/2. The returned list is empty if the peer is unknown. Otherwise it contains the ref, type and options tuples as in transport and connections info above. For example:\n\n```\n[{ref,#Ref<0.0.0.61>},\n {type,accept},\n {options,[{transport_module,diameter_tcp},\n {transport_config,[{reuseaddr,true},\n {ip,[127,0,0,1]}},\n {port,3868}]]}]\n```\n\nservices() -> [SvcName]\n\nTypes:\n\n```\nSvcName = service_name()\n```\n\nReturn the list of started services.\n\nsession_id(Ident) -> OctetString()\n\nTypes:\n\n```\nIdent = DiameterIdentity()\n```\n\nReturn a value for a Session-Id AVP.\n\nThe value has the form required by section 8.8 of RFC 6733. Ident should be the Origin-Host of the peer from which the message containing the returned value will be sent.\n\nstart() -> ok | {error, Reason}\n\nStart the diameter application.\n\nThe diameter application must be started before starting a service. In a production system this is typically accomplished by a boot file, not by calling start/0 explicitly.\n\nstart_service(SvcName, Options) -> ok | {error, Reason}\n\nTypes:\n\n```\nSvcName = service_name()\nOptions = [service_opt()]\nReason = term()\n```\n\nStart a diameter service.\n\nA service defines a locally-implemented Diameter node, specifying the capabilities to be advertised during capabilities exchange. Transports are added to a service using add_transport/2.\n\n**Note:**\n\nA transport can both override its service's capabilities and restrict its supported Diameter applications so \"service = Diameter node as identified by Origin-Host\" is not necessarily the case.\nstop() -> ok | {error, Reason}\nStop the diameter application.\n\nstop_service(SvcName) -> ok | {error, Reason}\nTypes:\n SvcName = service_name()\n Reason = term()\nStop a diameter service.\nStopping a service causes all associated transport connections to be broken. A DPR message will be sent as in the case of remove_transport/2.\n\nNote:\nStopping a service does not remove any associated transports: remove_transport/2 must be called to remove transport configuration.\n\nsubscribe(SvcName) -> true\nTypes:\n SvcName = service_name()\nSubscribe to service_event() messages from a service.\nIt is not an error to subscribe to events from a service that does not yet exist. Doing so before adding transports is required to guarantee the reception of all transport-related events.\n\nunsubscribe(SvcName) -> true\nTypes:\n SvcName = service_name()\nUnsubscribe to event messages from a service.\n\nSEE ALSO\ndiameter_app(3), diameter_transport(3), diameter_dict(4)\ndiameterc\n\nCommand\n\nThe diameterc utility is used to compile a diameter dictionary file into Erlang source. The resulting source implements the interface diameter required to encode and decode the dictionary's messages and AVPs. The module diameter_make(3) provides an alternate compilation interface.\n\nUSAGE\n\ndiameterc [ <options> ] <file>\n\nCompile a single dictionary file to Erlang source. Valid options are as follows.\n\n-\\i <dir>\n\nPrepend the specified directory to the code path. Use to point at beam files compiled from inherited dictionaries, @inherits in a dictionary file creating a beam dependency, not an erl/hrl dependency.\n\nMultiple -i options can be specified.\n\n-o <dir>\n\nWrite generated source to the specified directory. Defaults to the current working directory.\n\n-E\n\n-H\n\nSuppress erl and hrl generation, respectively.\n\n--name <name>\n\n--prefix <prefix>\n\nTransform the input dictionary before compilation, setting @name or @prefix to the specified string.\n\n-\\inherits <arg>\n\nTransform the input dictionary before compilation, appending @inherits of the specified string.\n\nTwo forms of --inherits have special meaning:\n\n-\\inherits\n\n-\\inherits Prev/Mod\n\nThe first has the effect of clearing any previous inherits, the second of replacing a previous inherits of Prev to one of Mod. This allows the semantics of the input dictionary to be changed without modifying the file itself.\n\nMultiple --inherits options can be specified.\n\nEXIT STATUS\n\nReturns 0 on success, non-zero on failure.\n\nSEE ALSO\n\ndiameter_make(3), diameter_dict(4)\ndiameter_app\n\nErlang module\n\nA diameter service as started by `diameter:start_service/2` configures one of more Diameter applications, each of whose configuration specifies a callback that handles messages specific to the application. The messages and AVPs of the application are defined in a dictionary file whose format is documented in `diameter_dict(4)` while the callback module is documented here. The callback module implements the Diameter application-specific functionality of a service.\n\nA callback module must export all of the functions documented below. The functions themselves are of three distinct flavours:\n\n- `peer_up/3` and `peer_down/3` signal the attainment or loss of connectivity with a Diameter peer.\n- `pick_peer/4`, `prepare_request/3`, `prepare_retransmit/3`, `handle_answer/4` and `handle_error/4` are (or may be) called as a consequence of a call to `diameter:call/4` to send an outgoing Diameter request message.\n- `handle_request/3` is called in response to an incoming Diameter request message.\n\nThe arities for the the callback functions here assume no extra arguments. All functions will also be passed any extra arguments configured with the callback module itself when calling `diameter:start_service/2` and, for the call-specific callbacks, any extra arguments passed to `diameter:call/4`.\n\nDATA TYPES\n\n`capabilities() = #diameter_caps{}`\n\nA record containing the identities of the local Diameter node and the remote Diameter peer having an established transport connection, as well as the capabilities as determined by capabilities exchange. Each field of the record is a 2-tuple consisting of values for the (local) host and (remote) peer. Optional or possibly multiple values are encoded as lists of values, mandatory values as the bare value.\n\n`message() = diameter_codec:message()`\n\nThe representation of a Diameter message as passed to `diameter:call/4` or returned from a `handle_request/3` callback.\n\n`packet() = diameter_codec:packet()`\n\nA container for incoming and outgoing Diameter messages that’s passed through encode/decode and transport. Fields should not be set in return values except as documented.\n\n`peer_ref() = term()`\n\nA term identifying a transport connection with a Diameter peer.\n\n`peer() = {peer_ref(), capabilities{}}`\n\nA tuple representing a Diameter peer connection.\n\n`state() = term{}`\n\nThe state maintained by the application callback functions `peer_up/3`, `peer_down/3` and (optionally) `pick_peer/4`. The initial state is configured in the call to `diameter:start_service/2` that configures the application on a service. Callback functions returning a state are evaluated in a common service-specific process while those not returning state are evaluated in a request-specific process.\nExports\n\nMod:peer_up(SvcName, Peer, State) -> NewState\nTypes:\n SvcName = diameter:service_name()\n Peer = peer()\n State = NewState = state()\n\nInvoked to signal the availability of a peer connection on the local Erlang node. In particular, capabilities exchange with the peer has indicated support for the application in question, the RFC 3539 watchdog state machine for the connection has reached state \\texttt{OKAY} and Diameter messages can be both sent and received.\n\n\\textbf{Note:}\n\nA watchdog state machine can reach state \\texttt{OKAY} from state \\texttt{SUSPECT} without a new capabilities exchange taking place. A new transport connection (and capabilities exchange) results in a new peer_ref().\n\n\\textbf{Note:}\n\nThere is no requirement that a callback return before incoming requests are received: handle_request/3 callbacks must be handled independently of peer_up/3 and peer_down/3.\n\nMod:peer_down(SvcName, Peer, State) -> NewState\nTypes:\n SvcName = diameter:service_name()\n Peer = peer()\n State = NewState = state()\n\nInvoked to signal that a peer connection on the local Erlang node is no longer available following a previous call to peer_up/3. In particular, that the RFC 3539 watchdog state machine for the connection has left state \\texttt{OKAY} and the peer will no longer be a candidate in pick_peer/4 callbacks.\n\nMod:pick_peer(LocalCandidates, RemoteCandidates, SvcName, State) -> Selection | false\nTypes:\n LocalCandidates = RemoteCandidates = [peer()]\n SvcName = diameter:service_name()\n State = NewState = state()\n Selection = (ok, Peer) | (Peer, NewState)\n Peer = peer() | false\n\nInvoked as a consequence of a call to diameter:call/4 to select a destination peer for an outgoing request. The return value indicates the selected peer.\n\nThe candidate lists contain only those peers that have advertised support for the Diameter application in question during capabilities exchange, that have not be excluded by a \\texttt{filter} option in the call to diameter:call/4 and whose watchdog state machine is in the \\texttt{OKAY} state. The order of the elements is unspecified except that any peers whose Origin-Host and Origin-Realm matches that of the outgoing request (in the sense of a \\{filter, \\{all, [host, realm]\\}\\}) option to diameter:call/4 will be placed at the head of the list. LocalCandidates contains peers\nwhose transport process resides on the local Erlang node while RemoteCandidates contains peers that have been communicated from other nodes by services of the same name.\n\nA callback that returns a peer() will be followed by a prepare_request/3 callback and, if the latter indicates that the request should be sent, by either handle_answer/4 or handle_error/4 depending on whether or not an answer message is received from the peer. If the transport becomes unavailable after prepare_request/3 then a new pick_peer/4 callback may take place to failover to an alternate peer, after which prepare_retransmit/3 takes the place of prepare_request/3 in resending the request. There is no guarantee that a pick_peer/4 callback to select an alternate peer will be followed by any additional callbacks since a retransmission to an alternate peer is abandoned if an answer is received from a previously selected peer.\n\nThe return values false and \\(\\text{false, State}\\) (that is, NewState = State) are equivalent, as are \\(\\text{ok, Peer}\\) and \\(\\text{Peer, State}\\).\n\n### Note:\n\nThe `diameter:service_opt()` `use_shared_peers` determines whether or not a service uses peers shared from other nodes. If not then RemoteCandidates is the empty list.\n\n### Warning:\n\nThe return value \\(\\text{Peer, NewState}\\) is only allowed if the Diameter application in question was configured with the `diameter:application_opt()` `call_mutates_state`, true. Otherwise, the State argument is always the initial value as configured on the application, not any subsequent value returned by a peer_up/3 or peer_down/3 callback.\n\n```erlang\nMod:prepare_request(Packet, SvcName, Peer) -> Action\nTypes:\n Packet = packet()\n SvcName = diameter:service_name()\n Peer = peer()\n Action = Send | Discard | \\{eval_packet, Action, PostF\\}\n Send = \\{send, packet() | message()\\}\n Discard = \\{discard, Reason\\} | discard\n PostF = diameter:eval()\n```\n\nInvoked to return a request for encoding and transport. Allows the sender to use the selected peer's capabilities to modify the outgoing request. Many implementations may simply want to return \\{send, Packet\\}\n\nA returned packet() should set the request to be encoded in its `msg` field and can set the `transport_data` field in order to pass information to the transport process. Extra arguments passed to `diameter:call/4` can be used to communicate transport (or any other) data to the callback.\n\nA returned packet() can set the `header` field to a `#diameter_header{}` to specify values that should be preserved in the outgoing request, values otherwise being those in the header record contained in `Packet`. A returned length, `cmd_code` or `application_id` is ignored.\n\nA returned `PostF` will be evaluated on any encoded `#diameter_packet{}` prior to transmission, the `bin` field containing the encoded binary. The return value is ignored.\n\nReturning \\{discard, Reason\\} causes the request to be aborted and the `diameter:call/4` for which the callback has taken place to return \\{error, Reason\\}. Returning `discard` is equivalent to returning \\{discard, discarded\\}. \n\nEricsson AB. All Rights Reserved.: Diameter | 43\nMod:prepare_retransmit(Packet, SvcName, Peer) -> Action\n\nTypes:\n Packet = packet()\n SvcName = diameter:service_name()\n Peer = peer()\n Action = Send | Discard | {eval_packet, Action, PostF}\n Send = {send, packet() | message()}\n Discard = {discard, Reason} | discard\n PostF = diameter:eval()\n\nInvoked to return a request for encoding and retransmission. Has the same role as prepare_request/3 in the case that a peer connection is lost an an alternate peer selected but the argument packet() is as returned by the initial prepare_request/3.\n\nReturning {discard, Reason} causes the request to be aborted and a handle_error/4 callback to take place with Reason as initial argument. Returning discard is equivalent to returning {discard, discarded}.\n\nMod:handle_answer(Packet, Request, SvcName, Peer) -> Result\n\nTypes:\n Packet = packet()\n Request = message()\n SvcName = diameter:service_name()\n Peer = peer()\n Result = term()\n\nInvoked when an answer message is received from a peer. The return value is returned from diameter:call/4 unless the detach option was specified.\n\nThe decoded answer record and undecoded binary are in the msg and bin fields of the argument packet() respectively. Request is the outgoing request message as was returned from prepare_request/3 or prepare_retransmit/3.\n\nFor any given call to diameter:call/4 there is at most one handle_answer/4 callback: any duplicate answer (due to retransmission or otherwise) is discarded. Similarly, only one of handle_answer/4 or handle_error/4 is called.\n\nBy default, an incoming answer message that cannot be successfully decoded causes the request process to fail, causing diameter:call/4 to return {error, failure} unless the detach option was specified. In particular, there is no handle_error/4 callback in this case. The diameter:application_opt() answer_errors can be set to change this behaviour.\n\nMod:handle_error(Reason, Request, SvcName, Peer) -> Result\n\nTypes:\n Reason = timeout | failover | term()\n Request = message()\n SvcName = diameter:service_name()\n Peer = peer()\n Result = term()\n\nInvoked when an error occurs before an answer message is received in response to an outgoing request. The return value is returned from diameter:call/4 unless the detach option was specified.\nReason `timeout` indicates that an answer message has not been received within the time specified with the corresponding `diameter:call_opt()`. Reason `failover` indicates that the transport connection to the peer to which the request has been sent has become unavailable and that no alternate peer was not selected.\n\n```\nMod:handle_request(Packet, SvcName, Peer) -> Action\nTypes:\n Packet = packet()\n SvcName = term()\n Peer = peer()\n Action = Reply | {relay, [Opt]} | discard | {eval|eval_packet, Action, PostF}\n Reply = {reply, packet() | message()} | {answer_message, 3000..3999|5000..5999} | {protocol_error, 3000..3999}\n Opt = diameter:call_opt()\n PostF = diameter:eval()\n```\n\nInvoked when a request message is received from a peer. The application in which the callback takes place (that is, the callback module as configured with `diameter:start_service/2`) is determined by the Application Identifier in the header of the incoming request message, the selected module being the one whose corresponding dictionary declares itself as defining either the application in question or the Relay application.\n\nThe argument `packet()` has the following signature.\n\n```\n#diameter_packet{header = #diameter_header{},\n avps = [#diameter_avp{}],\n msg = record() | undefined,\n errors = [Unsigned32() | {Unsigned32(), #diameter_avp{}}],\n bin = binary(),\n transport_data = term()}\n```\n\nThe `msg` field will be `undefined` in case the request has been received in the relay application. Otherwise it contains the record representing the request as outlined in `diameter:dict(4)`.\n\nThe `errors` field specifies any results codes identifying errors found while decoding the request. This is used to set Result-Code and/or Failed-AVP in a returned answer unless the callback returns a `#diameter_packet{}` whose `errors` field is set to either a non-empty list of its own, in which case this list is used instead, or the atom `false` to disable any setting of Result-Code and Failed-AVP. Note that the errors detected by `diameter` are of the 3xxx and 5xxx series, Protocol Errors and Permanent Failures respectively. The `errors` list is empty if the request has been received in the relay application.\n\nThe `transport_data` field contains an arbitrary term passed into `diameter` from the transport module in question, or the atom `undefined` if the transport specified no data. The term is preserved if a `message()` is returned but must be set explicitly in a returned `packet()`.\n\nThe semantics of each of the possible return values are as follows.\n\n```\n{reply, packet() | message()}\n```\n\nSend the specified answer message to the peer. In the case of a `packet()`, the message to be sent must be set in the `msg` field and the `header` field can be set to a `#diameter_header{}` to specify values that should be preserved in the outgoing answer, appropriate values otherwise being set by `diameter`.\n\n```\n{answer_message, 3000..3999|5000..5999}\n```\n\nSend an answer message to the peer containing the specified Result-Code. Equivalent to\nwhere **Avps** sets the Origin-Host, Origin-Realm, the specified Result-Code and (if the request contained one) Session-Id AVPs, and possibly Failed-AVP as described below.\n\nReturning a value other than 3xxx or 5xxx will cause the request process in question to fail, as will returning a 5xxx value if the peer connection in question has been configured with the RFC 3588 common dictionary `diameter_gen_base_rfc3588`. (Since RFC 3588 only allows 3xxx values in an answer-message.)\n\nWhen returning 5xxx, Failed-AVP will be populated with the AVP of the first matching Result-Code/AVP pair in the errors field of the argument packet(), if found. If this is not appropriate then an answer-message should be constructed explicitly and returned in a reply tuple instead.\n\n**relay, Opts**\nRelay a request to another peer in the role of a Diameter relay agent. If a routing loop is detected then the request is answered with 3005 (DIAMETER_LOOP_DETECTED). Otherwise a Route-Record AVP (containing the sending peer's Origin-Host) is added to the request and pick_peer/4 and subsequent callbacks take place just as if `diameter:call/4` had been called explicitly. The End-to-End Identifier of the incoming request is preserved in the header of the relayed request.\n\nThe returned Opts should not specify detach. A subsequent handle_answer/4 callback for the relayed request must return its first argument, the packet() containing the answer message. Note that the extra option can be specified to supply arguments that can distinguish the relay case from others if so desired. Any other return value (for example, from a handle_error/4 callback) causes the request to be answered with 3002 (DIAMETER_UNABLE_TO_DELIVER).\n\ndiscard\nDiscard the request. No answer message is sent to the peer.\n\n**eval, Action, PostF**\nHandle the request as if Action has been returned and then evaluate PostF in the request process. The return value is ignored.\n\n**eval_packet, Action, PostF**\nLike eval but evaluate PostF on any encoded #diameter_packet{} prior to transmission, the bin field containing the encoded binary. The return value is ignored.\n\n**protocol_error, 3000..3999**\nEquivalent to {answer_message, 3000..3999).\n\n**Note:**\nRequests containing errors may be answered by diameter, without a callback taking place, depending on the value of the `diameter:application_opt(request_errors).`\n**diameter_codec**\n\nErlang module\n\nIncoming Diameter messages are decoded from binary() before being communicated to diameter_app(3) callbacks. Similarly, outgoing Diameter messages are encoded into binary() before being passed to the appropriate diameter_transport(3) module for transmission. The functions documented here implement the default encode/decode.\n\n**Warning:**\n\nThe diameter user does not need to call functions here explicitly when sending and receiving messages using diameter:call/4 and the callback interface documented in diameter_app(3): diameter itself provides encode/decode as a consequence of configuration passed to diameter:start_service/2, and the results may differ from those returned by the functions documented here, depending on configuration.\n\nThe header() and packet() records below are defined in diameter.hrl, which can be included as follows.\n\n```erlang\n-includelib(\"diameter/include/diameter.hrl\").\n```\n\nApplication-specific records are defined in the hrl files resulting from dictionary file compilation.\n\n**DATA TYPES**\n\n- **uint8()** = 0..255\n- **uint24()** = 0..16777215\n- **uint32()** = 0..4294967295\n\n8-bit, 24-bit and 32-bit integers occurring in Diameter and AVP headers.\n\n- **avp() = #diameter_avp{}**\n\n The application-neutral representation of an AVP. Primarily intended for use by relay applications that need to handle arbitrary Diameter applications. A service implementing a specific Diameter application (for which it configures a dictionary) can manipulate values of type message() instead.\n\n Fields have the following types.\n\n- **code = uint32()**\n- **is_mandatory = boolean()**\n- **need_encryption = boolean()**\n- **vendor_id = uint32() | undefined**\n\n Values in the AVP header, corresponding to AVP Code, the M flag, P flags and Vendor-ID respectively. A Vendor-ID other than undefined implies a set V flag.\n\n- **data = iolist()**\n\n The data bytes of the AVP.\n\n- **name = atom()**\n\n The name of the AVP as defined in the dictionary file in question, or undefined if the AVP is unknown to the dictionary file in question.\ndiameter_codec\n\nvalue = term()\n\nThe decoded value of an AVP. Will be undefined on decode if the data bytes could not be decoded, the AVP is unknown, or if the decode format is none. The type of a decoded value is as document in diameter_dict(4).\n\ntype = atom()\n\nThe type of the AVP as specified in the dictionary file in question (or one it inherits). Possible types are undefined and the Diameter types: OctetString, Integer32, Integer64, Unsigned32, Unsigned64, Float32, Float64, Grouped, Enumerated, Address, Time, UTF8String, DiameterIdentity, DiameterURI, IPFilterRule and QoSFilterRule.\n\ndictionary() = module()\n\nThe name of a generated dictionary module as generated by diameterc(1) or diameter_make:codec/2. The interface provided by a dictionary module is an implementation detail that may change.\n\nheader() = #diameter_header{}\n\nThe record representation of the Diameter header. Values in a packet() returned by decode/2 are as extracted from the incoming message. Values set in an packet() passed to encode/2 are preserved in the encoded binary(), with the exception of length, cmd_code and application_id, all of which are determined by the dictionary() in question.\n\nNote:\n\nIt is not necessary to set header fields explicitly in outgoing messages as diameter itself will set appropriate values. Setting inappropriate values can be useful for test purposes.\n\nFields have the following types.\n\nversion = uint8()\nlength = uint24()\ncmd_code = uint24()\napplication_id = uint32()\nhop_by_hop_id = uint32()\nend_to_end_id = uint32()\n\n\nis_request = boolean()\nis_proxiable = boolean()\nis_error = boolean()\nis_retransmitted = boolean()\n\nValues corresponding to the R(equest), P(roxiable), E(rror) and T(Potentially re-transmitted message) flags of the Diameter header.\n\nmessage() = record() | maybe_improper_list()\n\nThe representation of a Diameter message as passed to diameter:call/4 or returned from a handle_request/3 callback. The record representation is as outlined in diameter_dict(4): a message as defined in a dictionary file is encoded as a record with one field for each component AVP. Equivalently, a message can also be encoded as a list whose head is the atom-valued message name (as specified in the relevant dictionary file) and whose tail is either a list of AVP name/values pairs or a map with values keyed on AVP names. The format at decode is determined by diameter:service_opt() decode_format. Any of the formats is accepted at encode.\nAnother list-valued representation allows a message to be specified as a list whose head is a header() and whose tail is an avp() list. This representation is used by diameter itself when relaying requests as directed by the return value of a handle_request/3 callback. It differs from the other two in that it bypasses the checks for messages that do not agree with their definitions in the dictionary in question: messages are sent exactly as specified.\n\n```\npacket() = #diameter_packet{\n header = header() | undefined\n avps = [avp()] | undefined\n msg = message() | undefined\n}\n```\n\nA container for incoming and outgoing Diameter messages. Fields have the following types.\n\n- **header**: The Diameter header of the message. Can be (and typically should be) `undefined` for an outgoing message in a non-relay application, in which case diameter provides appropriate values.\n- **avps**: The AVPs of the message. Ignored for an outgoing message if the `msg` field is set to a value other than `undefined`.\n- **msg**: The incoming/outgoing message. For an incoming message, a term corresponding to the configured decode format if the message can be decoded in a non-relay application, `undefined` otherwise. For an outgoing message, setting a `[header() | avp()]` list is equivalent to setting the `header` and `avps` fields to the corresponding values.\n\n**Warning:**\n\nA value in the `msg` field does **not** imply an absence of decode errors. The `errors` field should also be examined.\n\n```\nbin = binary()\n```\n\nThe incoming message prior to encode or the outgoing message after encode.\n\n```\nerrors = [5000..5999 | {5000..5999, avp()}]\n```\n\nErrors detected at decode of an incoming message, as identified by a corresponding 5xxx series Result-Code (Permanent Failures). For an incoming request, these should be used to formulate an appropriate answer as documented for the handle_request/3 callback in `diameter_app(3)`. For an incoming answer, the `diameter:application_opt()` `answer_errors` determines the behaviour.\n\n```\ntransport_data = term()\n```\n\nAn arbitrary term of meaning only to the transport process in question, as documented in `diameter_transport(3)`.\n\n### Exports\n\n```\ndecode(Mod, Bin) -> Pkt\n```\n\nTypes:\n\n```\nMod = dictionary()\nBin = binary()\nPkt = packet()\n```\n\nDecode a Diameter message.\nencode(Mod, Msg) -> Pkt\nTypes:\n Mod = dictionary()\n Msg = message() | packet()\n Pkt = packet()\nEncode a Diameter message.\n\nSEE ALSO\ndiameterc(1), diameter_app(3), diameter_dict(4), diameter_make(3)\nA diameter service, as configured with `diameter:start_service/2`, specifies one or more supported Diameter applications. Each Diameter application specifies a dictionary module that knows how to encode and decode its messages and AVPs. The dictionary module is in turn generated from a file that defines these messages and AVPs. The format of such a file is defined in FILE FORMAT below. Users add support for their specific applications by creating dictionary files, compiling them to Erlang modules using either `diameterc(1)` or `diameter_make(3)` and configuring the resulting dictionaries modules on a service.\n\nDictionary module generation also results in a hrl file that defines records for the messages and Grouped AVPs defined by the dictionary, these records being what a user of the diameter application sends and receives, modulo other possible formats as discussed in `diameter_app(3)`. These records and the underlying Erlang data types corresponding to Diameter data formats are discussed in MESSAGE RECORDS and DATA TYPES respectively. The generated hrl also contains macro definitions for the possible values of AVPs of type Enumerated.\n\nThe diameter application includes five dictionary modules corresponding to applications defined in section 2.4 of RFC 6733: `diameter_gen_base_rfc3588` and `diameter_gen_base_rfc6733` for the Diameter Common Messages application with application identifier 0, `diameter_gen_accounting` (for RFC 3588) and `diameter_gen_acct_rfc6733` for the Diameter Base Accounting application with application identifier 3 and `diameter_gen_relay` the Relay application with application identifier 0xFFFFFFFF. The Common Message and Relay applications are the only applications that diameter itself has any specific knowledge of. The Common Message application is used for messages that diameter itself handles: CER/CEA, DWR/DWA and DPR/DPA. The Relay application is given special treatment with regard to encode/decode since the messages and AVPs it handles are not specifically defined.\n\nFILE FORMAT\n\nA dictionary file consists of distinct sections. Each section starts with a tag followed by zero or more arguments and ends at the the start of the next section or end of file. Tags consist of an ampersand character followed by a keyword and are separated from their arguments by whitespace. Whitespace separates individual tokens but is otherwise insignificant.\n\nThe tags, their arguments and the contents of each corresponding section are as follows. Each section can occur multiple times unless otherwise specified. The order in which sections are specified is unimportant.\n\n@id Number\n\nDefines the integer Number as the Diameter Application Id of the application in question. Can occur at most once and is required if the dictionary defines `@messages`. The section has empty content.\n\nThe Application Id is set in the Diameter Header of outgoing messages of the application, and the value in the header of an incoming message is used to identify the relevant dictionary module.\n\nExample:\n\n```\n@id 16777231\n```\n\n@name Mod\n\nDefines the name of the generated dictionary module. Can occur at most once and defaults to the name of the dictionary file minus any extension. The section has empty content.\n\nNote that a dictionary module should have a unique name so as not collide with existing modules in the system.\n\nExample:\n@name etsi_e2\n\n@prefix Name\n\nDefines Name as the prefix to be added to record and constant names (followed by a '_' character) in the generated dictionary module and hrl. Can occur at most once. The section has empty content.\n\nA prefix is optional but can be be used to disambiguate between record and constant names resulting from similarly named messages and AVPs in different Diameter applications.\n\nExample:\n\n@prefix etsi_e2\n\n@vendor Number Name\n\nDefines the integer Number as the the default Vendor-Id of AVPs for which the V flag is set. Name documents the owner of the application but is otherwise unused. Can occur at most once and is required if an AVP sets the V flag and is not otherwise assigned a Vendor-Id. The section has empty content.\n\nExample:\n\n@vendor 13019 ETSI\n\n@avp_vendor_id Number\n\nDefines the integer Number as the Vendor-Id of the AVPs listed in the section content, overriding the @vendor default. The section content consists of AVP names.\n\nExample:\n\n@avp_vendor_id 2937\nWWW-Auth\nDomain-Index\nRegion-Set\n\n@inherits Mod\n\nDefines the name of a dictionary module containing AVP definitions that should be imported into the current dictionary. The section content consists of the names of those AVPs whose definitions should be imported from the dictionary, an empty list causing all to be imported. Any listed AVPs must not be defined in the current dictionary and it is an error to inherit the same AVP from more than one dictionary.\n\nNote that an inherited AVP that sets the V flag takes its Vendor-Id from either @avp_vendor_id in the inheriting dictionary or @vendor in the inherited dictionary. In particular, @avp_vendor_id in the inherited dictionary is ignored. Inheriting from a dictionary that specifies the required @vendor is equivalent to using @avp_vendor_id with a copy of the dictionary's definitions but the former makes for easier reuse.\n\nAll dictionaries should typically inherit RFC 6733 AVPs from diameter_gen_base_rfc6733.\n\nExample:\n\n@inherits diameter_gen_base_rfc6733\n\n@avp_types\n\nDefines the name, code, type and flags of individual AVPs. The section consists of definitions of the form\nName Code Type Flags\n\nwhere Code is the integer AVP code, Type identifies an AVP Data Format as defined in section DATA TYPES below, and Flags is a string of V, M and P characters indicating the flags to be set on an outgoing AVP or a single '-' (minus) character if none are to be set.\n\nExample:\n\n```\n@avp_types\nLocation-Information 350 Grouped MV\nRequested-Information 353 Enumerated V\n```\n\n**Warning:**\nThe P flag has been deprecated by RFC 6733.\n\n@custom_types Mod\n\nSpecifies AVPs for which module Mod provides encode/decode functions. The section contents consists of AVP names. For each such name, `Mod:Name(encode|decode, Type, Data, Opts)` is expected to provide encode/decode for values of the AVP, where Name is the name of the AVP, Type is it's type as declared in the @avp_types section of the dictionary, Data is the value to encode/decode, and Opts is a term that is passed through encode/decode.\n\nExample:\n\n```\n@custom_types rfc4005_avps\nFramed-IP-Address\n```\n\n@codecs Mod\n\nLike @custom_types but requires the specified module to export `Mod:Type(encode|decode, Name, Data, Opts)` rather than `Mod:Name(encode|decode, Type, Data, Opts)`.\n\nExample:\n\n```\n@codecs rfc4005_avps\nFramed-IP-Address\n```\n\n@messages\n\nDefines the messages of the application. The section content consists of definitions of the form specified in section 3.2 of RFC 6733, \"Command Code Format Specification\".\n@messages\n\nRTR ::= < Diameter Header: 287, REQ, PXY >\n < Session-Id >\n { Auth-Application-Id }\n { Auth-Session-State }\n { Origin-Host }\n { Origin-Realm }\n { Destination-Host }\n { SIP-Deregistration-Reason }\n { Destination-Realm }\n { User-Name }\n * [ SIP-AOR ]\n * [ Proxy-Info ]\n * [ Route-Record ]\n * [ AVP ]\n\nRTA ::= < Diameter Header: 287, PXY >\n < Session-Id >\n { Auth-Application-Id }\n { Result-Code }\n { Auth-Session-State }\n { Origin-Host }\n { Origin-Realm }\n { Authorization-Lifetime }\n { Auth-Grace-Period }\n { Redirect-Host }\n { Redirect-Host-Usage }\n { Redirect-Max-Cache-Time }\n * [ Proxy-Info ]\n * [ Route-Record ]\n * [ AVP ]\n\n@grouped\n\nDefines the contents of the AVPs of the application having type Grouped. The section content consists of definitions of the form specified in section 4.4 of RFC 6733, “Grouped AVP Values”.\n\nExample:\n\n@grouped\n\nSIP-Deregistration-Reason ::= < AVP Header: 383 >\n { SIP-Reason-Code }\n [ SIP-Reason-Info ]\n * [ AVP ]\n\nSpecifying a Vendor-Id in the definition of a grouped AVP is equivalent to specifying it with @avp_vendor_id.\n\n@enum Name\n\nDefines values of AVP Name having type Enumerated. Section content consists of names and corresponding integer values. Integer values can be prefixed with 0x to be interpreted as hexadecimal.\n\nNote that the AVP in question can be defined in an inherited dictionary in order to introduce additional values to an enumeration otherwise defined in another dictionary.\n\nExample:\nMESSAGE RECORDS\n\nThe hrl generated from a dictionary specification defines records for the messages and grouped AVPs defined in @messages and @grouped sections. For each message or grouped AVP definition, a record is defined whose name is the message or AVP name, prefixed with any dictionary prefix defined with @prefix, and whose fields are the names of the AVPs contained in the message or grouped AVP in the order specified in the definition in question. For example, the grouped AVP\n\n\\[\n\\text{SIP-Deregistration-Reason ::= < AVP Header: 383 >}\n\\]\n\\[\n\\quad \\{ \\text{SIP-Reason-Code} \\}\n\\]\n\\[\n\\quad [ \\text{SIP-Reason-Info} ]\n\\]\n\\[\n\\quad * [ \\text{AVP} ]\n\\]\n\nwill result in the following record definition given an empty prefix.\n\n- record('SIP-Deregistration-Reason', {'SIP-Reason-Code', 'SIP-Reason-Info', 'AVP'}).\n\nThe values encoded in the fields of generated records depends on the type and number of times the AVP can occur. In particular, an AVP which is specified as occurring exactly once is encoded as a value of the AVP's type while an AVP with any other specification is encoded as a list of values of the AVP's type. The AVP's type is as specified in the AVP definition, the RFC 6733 types being described below.\n\nDATA TYPES\n\nThe data formats defined in sections 4.2 (\"Basic AVP Data Formats\") and 4.3 (\"Derived AVP Data Formats\") of RFC 6733 are encoded as values of the types defined here. Values are passed to diameter:call/4 in a request record when sending a request, returned in a resulting answer record and passed to a handle_request/3 callback upon reception of an incoming request.\n\nIn cases in which there is a choice between string() and binary() types for OctetString() and derived types, the representation is determined by the value of diameter:service_opt() string_decode.\n\n**Basic AVP Data Formats**\n\n0ctetString() = string() | binary()\nInteger32() = -2147483647..2147483647\nInteger64() = -9223372036854775807..9223372036854775807\nUnsigned32() = 0..4294967295\nUnsigned64() = 0..18446744073709551615\nFloat32() = '-infinity' | float() | infinity\nFloat64() = '-infinity' | float() | infinity\nGrouped() = record()\nOn encode, an OctetString() can be specified as an iolist(), excessively large floats (in absolute value) are equivalent to infinity or '-infinity' and excessively large integers result in encode failure. The records for grouped AVPs are as discussed in the previous section.\n\nDerived AVP Data Formats\n\n**Address() = OctetString() | tuple()**\n\nOn encode, an OctetString() IPv4 address is parsed in the usual x.x.x.x format while an IPv6 address is parsed in any of the formats specified by section 2.2 of RFC 2373, \"Text Representation of Addresses\". An IPv4 tuple() has length 4 and contains values of type 0..255. An IPv6 tuple() has length 8 and contains values of type 0..65535. The tuple representation is used on decode.\n\n**Time() = {date(), time()}**\n\nwhere\n\n- **date() = {Year, Month, Day}**\n- **time() = {Hour, Minute, Second}**\n\n- Year = integer()\n- Month = 1..12\n- Day = 1..31\n- Hour = 0..23\n- Minute = 0..59\n- Second = 0..59\n\nAdditionally, values that can be encoded are limited by way of their encoding as four octets as required by RFC 6733 with the required extension from RFC 2030. In particular, only values between \\((1968, 1, 20), (3, 14, 8)\\) and \\((2104, 2, 26), (9, 42, 23)\\) (both inclusive) can be encoded.\n\n**UTF8String() = [integer()] | binary()**\n\nList elements are the UTF-8 encodings of the individual characters in the string. Invalid codepoints will result in encode/decode failure. On encode, a UTF8String() can be specified as a binary, or as a nested list of binaries and codepoints.\n\n**DiameterIdentity() = OctetString()**\n\nA value must have length at least 1.\n\n**DiameterURI() = OctetString() | #diameter_URI{type = Type, fqdn = FQDN, port = Port, transport = Transport, protocol = Protocol}**\n\nwhere\n\n- **Type = aaa | aaas**\n- **FQDN = OctetString()**\n- **Port = integer()**\n- **Transport = sctp | tcp**\n- **Protocol = diameter | radius | 'tacacs+'**\nOn encode, fields port, transport and protocol default to 3868, sctp and diameter respectively. The grammar of an OctetString-valued DiameterURI() is as specified in section 4.3 of RFC 6733. The record representation is used on decode.\n\nEnumerated() = Integer32()\n\nOn encode, values can be specified using the macros defined in a dictionary's hrl file.\n\nIPFilterRule() = OctetString()\nQoSFilterRule() = OctetString()\n\nValues of these types are not currently parsed by diameter.\n\nSEE ALSO\ndiameterc(1), diameter(3), diameter_app(3), diameter_codec(3), diameter_make(3)\n**diameter_make**\n\nErlang module\n\nThe function codec/2 is used to compile a diameter dictionary file into Erlang source. The resulting source implements the interface diameter requires to encode and decode the dictionary’s messages and AVPs.\n\nThe utility diameterc(1) provides an alternate compilation interface.\n\n**Exports**\n\ncodec(File :: iolist() | binary(), [Opt]) -> ok | {ok, [Out]} | {error, Reason}\n\nCompile a single dictionary file. The input File can be either a path or a literal dictionary, the occurrence of newline (ascii NL) or carriage return (ascii CR) identifying the latter. Opt determines the format of the results and whether they are written to file or returned, and can have the following types.\n\n```\nparse | forms | erl | hrl\n```\n\nSpecifies an output format. Whether the output is returned or written to file depends on whether or not option return is specified. When written to file, the resulting file(s) will have extensions .D, .F, .erl, and .hrl respectively, basenames defaulting to dictionary if the input dictionary is literal and does not specify @name. When returned, results are in the order of the corresponding format options. Format options default to erl and hrl (in this order) if unspecified.\n\nThe parse format is an internal representation that can be passed to flatten/1 and format/1, while the forms format can be passed to compile:forms/2. The erl and hrl formats are returned as iolists.\n\n```\n{include, string()}\n\nPrepend the specified directory to the code path. Use to point at beam files compiled from inherited dictionaries, @inherits in a dictionary file creating a beam dependency, not an erl/hrl dependency.\n\nMultiple include options can be specified.\n```\n\n```\n{outdir, string()}\n\nWrite generated source to the specified directory. Defaults to the current working directory. Has no effect if option return is specified.\n```\n\n```\nreturn\n\nReturn results in a {ok, [Out]} tuple instead of writing to file and returning ok.\n```\n\n```\n{name|prefix, string()}\n\nTransform the input dictionary before compilation, setting @name or @prefix to the specified string.\n```\n\n```\n{inherits, string()}\n\nTransform the input dictionary before compilation, appending @inherits of the specified string.\n\nTwo forms have special meaning:\n\n```\n{inherits, \"+\"}\n{inherits, \"Prev/Mod\"}\n```\n\nThe first has the effect of clearing any previous inherits, the second of replacing a previous inherits of Prev to one of Mod. This allows the semantics of the input dictionary to be changed without modifying the file itself.\nMultiple inherits options can be specified.\n\nNote that a dictionary's @name, together with the outdir option, determine the output paths when the return option is not specified. The @name of a literal input dictionary defaults to dictionary.\n\nA returned error reason can be converted into a readable string using format_error/1.\n\nformat(Parsed) -> iolist()\nTurns a parsed dictionary, as returned by codec/2, back into the dictionary format.\n\nflatten(Parsed) -> term()\nReconstitute a parsed dictionary, as returned by codec/2, without using @inherits. That is, construct an equivalent dictionary in which all AVP's are defined in the dictionary itself. The return value is also a parsed dictionary.\n\nformat_error(Reason) -> string()\nTurn an error reason returned by codec/2 into a readable string.\n\nBUGS\nUnrecognized options are silently ignored.\n\nSEE ALSO\ndiametc(1), diameter_dict(4)\ndiameter_transport\n\nErlang module\n\nA module specified as a transport_module to diameter:add_transport/2 must implement the interface documented here. The interface consists of a function with which diameter starts a transport process and a message interface with which the transport process communicates with the process that starts it (aka its parent).\n\nDATA TYPES\n\nmessage() = binary() | diameter_codec:packet()\n\nA Diameter message as passed over the transport interface.\n\nFor an inbound message from a transport process, a diameter_codec:packet() must contain the received message in its bin field. In the case of an inbound request, any value set in the transport_data field will passed back to the transport module in the corresponding answer message, unless the sender supplies another value.\n\nFor an outbound message to a transport process, a diameter_codec:packet() has a value other than undefined in its transport_data field and has the binary() to send in its bin field.\n\nExports\n\nMod:start({Type, Ref}, Svc, Config) -> {ok, Pid} | {ok, Pid, LAddrs} | {error, Reason}\n\nTypes:\n\nType = connect | accept\n\nRef = diameter:transport_ref()\n\nSvc = #diameter_service{}\n\nConfig = term()\n\nPid = pid()\n\nLAddrs = [inet:ip_address()]\n\nReason = term()\n\nStart a transport process. Called by diameter as a consequence of a call to diameter:add_transport/2 in order to establish or accept a transport connection respectively. A transport process maintains a connection with a single remote peer.\n\nType indicates whether the transport process in question is being started for a connecting (Type=connect) or listening (Type=accept) transport. In the latter case, transport processes are started as required to accept connections from multiple peers.\n\nRef is the value that was returned from the call to diameter:add_transport/2 that has lead to starting of a transport process.\n\nSvc contains capabilities passed to diameter:start_service/2 and diameter:add_transport/2, values passed to the latter overriding those passed to the former.\n\nConfig is as passed in transport_config tuple in the diameter:transport_opt() list passed to diameter:add_transport/2.\n\nThe start function should use the Host-IP-Address list in Svc and/or Config to select and return an appropriate list of local IP addresses. In the connecting case, the local address list can instead be communicated in a connected message (see MESSAGES below) following connection establishment. In either case, the local address list is used\nto populate Host-IP-Address AVPs in outgoing capabilities exchange messages if Host-IP-Address is unspecified.\n\nA transport process must implement the message interface documented below. It should retain the pid of its parent, monitor the parent and terminate if it dies. It should not link to the parent. It should exit if its transport connection with its peer is lost.\n\nMESSAGES\n\nAll messages sent over the transport interface are of the form \\{diameter, term()\\}.\n\nA transport process can expect messages of the following types from its parent.\n\n\\{diameter, {send, message() | false}\\}\n\nAn outbound Diameter message. The atom false can only be received when request acknowledgements have been requests: see the ack message below.\n\n\\{diameter, {close, Pid}\\}\n\nA request to terminate the transport process after having received DPA in response to DPR. The transport process should exit. Pid is the pid() of the parent process.\n\n\\{diameter, {tls, Ref, Type, Bool}\\}\n\nIndication of whether or not capabilities exchange has selected inband security using TLS. Ref is a reference() that must be included in the \\{diameter, {tls, Ref}\\} reply message to the transport's parent process (see below). Type is either connect or accept depending on whether the process has been started for a connecting or listening transport respectively. Bool is a boolean() indicating whether or not the transport connection should be upgraded to TLS.\n\nIf TLS is requested (Bool=true) then a connecting process should initiate a TLS handshake with the peer and an accepting process should prepare to accept a handshake. A successful handshake should be followed by a \\{diameter, {tls, Ref}\\} message to the parent process. A failed handshake should cause the process to exit.\n\nThis message is only sent to a transport process over whose Inband-Security-Id configuration has indicated support for TLS.\n\nA transport process should send messages of the following types to its parent.\n\n\\{diameter, {self(), connected}\\}\n\nInform the parent that the transport process with Type=accept has established a connection with the peer. Not sent if the transport process has Type=connect.\n\n\\{diameter, {self(), connected, Remote}\\}\n\\{diameter, {self(), connected, Remote, [LocalAddr]}\\}\n\nInform the parent that the transport process with Type=connect has established a connection with a peer. Not sent if the transport process has Type=accept. Remote is an arbitrary term that uniquely identifies the remote endpoint to which the transport has connected. A LocalAddr list has the same semantics as one returned from start/3.\n\n\\{diameter, ack\\}\n\nRequest acknowledgements of unanswered requests. A transport process should send this once before passing incoming Diameter messages into diameter. As a result, every Diameter request passed into diameter with a recv message (below) will be answered with a send message (above), either a message() for the transport process to send or the atom false if the request has been discarded or otherwise not answered.\n\nThis is to allow a transport process to keep count of the number of incoming request messages that have not yet been answered or discarded, to allow it to regulate the amount of incoming traffic. Both diameter_tcp and\n\nEricsson AB. All Rights Reserved.: Diameter | 61\ndiameter_sctp request acknowledgements when a message_cb is configured, turning send/recv message into callbacks that can be used to regulate traffic.\n\n{diameter, {recv, message()}}\n\nAn inbound Diameter message.\n\n{diameter, {tls, Ref}}\n\nAcknowledgment of a successful TLS handshake. Ref is the reference() received in the {diameter, {tls, Ref, Type, Bool}} message in response to which the reply is sent. A transport must exit if a handshake is not successful.\n\nSEE ALSO\ndiameter_tcp(3), diameter_sctp(3)\ndiameter_tcp\n\nErlang module\n\nThis module implements diameter transport over TCP using gen_tcp(3). It can be specified as the value of a transport_module option to diameter:add_transport/2 and implements the behaviour documented in diameter_transport(3). TLS security is supported, either as an upgrade following capabilities exchange or at connection establishment.\n\nNote that the ssl application is required for TLS and must be started before configuring TLS capability on diameter transports.\n\nExports\n\nstart({Type, Ref}, Svc, [Opt]) -> {ok, Pid} | {ok, Pid, [LAddr]} | {error, Reason}\n\nTypes:\n\n Type = connect | accept\n Ref = diameter:transport_ref()\n Svc = #diameter_service{}\n Opt = OwnOpt | SslOpt | TcpOpt\n Pid = pid()\n LAddr = inet:ip_address()\n Reason = term()\n OwnOpt = {raddr, inet:ip_address()} | {rport, integer()} | {accept, Match} | {port, integer()} | {fragment_timer, infinity | 0..16#FFFFFFFF} | {message_cb, diameter:eval()} | {sender, boolean()}\n SslOpt = {ssl_options, true | list()}\n TcpOpt = term()\n Match = inet:ip_address() | string() | [Match]\n\nThe start function required by diameter_transport(3).\n\nOptions raddr and rport specify the remote address and port for a connecting transport and are not valid for a listening transport.\n\nOption accept specifies remote addresses for a listening transport and is not valid for a connecting transport. If specified, a remote address that does not match one of the specified addresses causes the connection to be aborted. Multiple accept options can be specified. A string-valued Match that does not parse as an address is interpreted as a regular expression.\n\nOption ssl_options must be specified for a transport that should support TLS: a value of true results in a TLS handshake immediately upon connection establishment while list() specifies options to be passed to ssl:connect/2 or ssl:ssl_accept/2 after capabilities exchange if TLS is negotiated.\n\nOption fragment_timer specifies the timeout, in milliseconds, of a timer used to flush messages from the incoming byte stream even if the number of bytes indicated in the Message Length field of its Diameter Header have not yet been accumulated: such a message is received over the transport interface after two successive timeouts without the reception of additional bytes. Defaults to 1000.\nOption `sender` specifies whether or not to use a dedicated process for sending outgoing messages, which avoids the possibility of send blocking reception. Defaults to `false`. If set to `true` then a `message_cb` that avoids the possibility of messages being queued in the sender process without bound should be configured.\n\nOption `message_cb` specifies a callback that is invoked on incoming and outgoing messages, that can be used to implement flow control. It is applied to two arguments: an atom indicating the reason for the callback (`send`, `recv`, or `ack` after a completed `send`), and the message in question (`binary()` on `recv`, `binary()` or `diameter_packet` record on `send` or `ack`, or `false` on `ack` when an incoming request has been discarded). It should return a list of actions and a new callback as tail; eg. `[fun cb/3, State]`. Valid actions are the atoms `send` or `recv`, to cause a following message-valued action to be sent/received, a message to send/receive (`binary()` or `diameter_packet` record), or a boolean() to enable/disable reading on the socket. More than one `send/recv` message sequence can be returned from the same callback, and an initial `send/recv` can be omitted if the same as the value passed as the callback's first argument. Reading is initially enabled, and returning `false` does not imply there cannot be subsequent `recv` callbacks since messages may already have been read. An empty tail is equivalent to the prevailing callback. Defaults to a callback equivalent to `fun(ack, _) -> []; (_, Msg) -> [Msg] end`. Remaining options are any accepted by `ssl:connect/3` or `gen_tcp:connect/3` for a connecting transport, or `ssl:listen/2` or `gen_tcp:listen/2` for a listening transport, depending on whether or not `{ssl_options, true}` has been specified. Options `binary`, `packet` and `active` cannot be specified. Also, option `port` can be specified for a listening transport to specify the local listening port, the default being the standardized 3868. Note that the option `ip` specifies the local address.\n\nAn `ssl_options` list must be specified if and only if the transport in question has set `Inband-Security-Id` to 1 (TLS), as specified to either `diameter:start_service/2` or `diameter:add_transport/2`, so that the transport process will receive notification of whether or not to commence with a TLS handshake following capabilities exchange. Failing to specify an options list on a TLS-capable transport for which TLS is negotiated will cause TLS handshake to fail. Failing to specify TLS capability when `ssl_options` has been specified will cause the transport process to wait for a notification that will not be forthcoming, which will eventually cause the RFC 3539 watchdog to take down the connection.\n\nThe first element of a non-empty `Host-IP-Address` list in `Svc` provides the local IP address if an `ip` option is not specified. The local address is either returned from `start/3` or passed in a `connected` message over the transport interface.\n\n**SEE ALSO**\n\ndiameter(3), `diameter_transport(3)`, `gen_tcp(3)`, `inet(3)`, `ssl(3)`\ndiameter_sctp\n\nErlang module\n\nThis module implements diameter transport over SCTP using gen_sctp(3). It can be specified as the value of a transport_module option to diameter:add_transport/2 and implements the behaviour documented in diameter_transport(3).\n\nExports\n\nstart({Type, Ref}, Svc, [Opt]) -> {ok, Pid, [LAddr]} | {error, Reason}\n\nTypes:\n\n- Type = connect | accept\n- Ref = diameter:transport_ref()\n- Svc = #diameter_service{}\n- Opt = OwnOpt | SctpOpt\n- Pid = pid()\n- LAddr = inet:ip_address()\n- Reason = term()\n- OwnOpt = {raddr, inet:ip_address()} | {rport, integer()} | {accept, Match} | {unordered, boolean() | pos_integer()} | {packet, boolean() | raw} | {message_cb, diameter:eval()} | {sender, boolean()}\n- SctpOpt = term()\n- Match = inet:ip_address() | string() | [Match]\n\nThe start function required by diameter_transport(3).\n\nOptions raddr and rport specify the remote address and port for a connecting transport and not valid for a listening transport: the former is required while latter defaults to 3868 if unspecified. Multiple raddr options can be specified, in which case the connecting transport in question attempts each in sequence until an association is established.\n\nOption accept specifies remote addresses for a listening transport and is not valid for a connecting transport. If specified, a remote address that does not match one of the specified addresses causes the association to be aborted. Multiple accept options can be specified. A string-valued Match that does not parse as an address is interpreted as a regular expression.\n\nOption unordered specifies whether or not to use unordered delivery, integer N being equivalent to N =< OS, where OS is the number of outbound streams negotiated on the association in question. Regardless of configuration, sending is ordered on stream 0 until reception of a second incoming message, to ensure that a peer receives capabilities exchange messages before any other. Defaults to false.\n\nOption packet determines how/if an incoming message is packaged into a diameter_packet record. If false then messages are received as binary(). If true then as a record with the binary() message in the bin field and a {stream, Id} tuple in the transport_data field, where Id is the identifier of the inbound stream the message was received on. If raw then as a record with the received ancillary sctp_sndrcvinfo record in the transport_data field. Defaults to true.\n\nOptions message_cb and sender have semantics identical to those documented in diameter_tcp(3), but with the message argument to a recv callback being as directed by the packet option.\nAn \\{outstream, Id\\} tuple in the transport_data field of a outgoing diameter_packet record sets the outbound stream on which the message is sent, modulo the negotiated number of outbound streams. Any other value causes successive such sends to cycle though all outbound streams.\n\nRemaining options are any accepted by gen_sctp:open/1, with the exception of options \\texttt{mode}, \\texttt{binary}, \\texttt{list}, \\texttt{active} and \\texttt{sctp_events}. Note that options \\texttt{ip} and \\texttt{port} specify the local address and port respectively.\n\nMultiple \\texttt{ip} options can be specified for a multihomed peer. If none are specified then the values of \\texttt{Host-IP-Address} in the \\texttt{diameter_service} record are used. Option \\texttt{port} defaults to 3868 for a listening transport and 0 for a connecting transport.\n\n\\begin{center}\n\\textbf{Warning:}\n\\end{center}\n\n<table>\n<thead>\n<tr>\n<th>Warning:</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>An small receive buffer may result in a peer having to resend incoming messages: set the inet(3) option \\texttt{rebuf} to increase the buffer size.</td>\n<td></td>\n</tr>\n<tr>\n<td>An small send buffer may result in outgoing messages being discarded: set the inet(3) option \\texttt{sndbuf} to increase the buffer size.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n\\textbf{SEE ALSO}\n\ndiameter(3), diameter_transport(3), gen_sctp(3), inet(3)"}}},{"rowIdx":281,"cells":{"id":{"kind":"string","value":"c2bf0abce56bd4b008532845147a091cc58be040"},"text":{"kind":"string","value":"Preface .............................................................................................................................................. v\n\nI. Introduction .................................................................................................................................. 1\n 1. Why Spring Dynamic Modules? ............................................................................................ 2\n 2. Requirements ........................................................................................................................ 3\n 3. What is new? ........................................................................................................................ 4\n 3.1. 1.1.x ........................................................................................................................ 4\n 3.1.1. Web Support ........................................................................................................ 4\n 3.1.2. Classpath Resource Abstraction ......................................................................... 4\n 3.1.3. Pluggable Extender Configuration ....................................................................... 4\n 3.1.4. Improved class loading ...................................................................................... 4\n\nII. Reference Documentation .......................................................................................................... 5\n 4. Bundles and Application Contexts ......................................................................................... 6\n 4.1. The Spring Dynamic Modules Extender bundle ............................................................ 6\n 4.2. Application Context Creation ....................................................................................... 6\n 4.2.1. Mandatory Service Dependencies ....................................................................... 7\n 4.2.2. Application Context Service Publication ............................................................... 7\n 4.3. Bundle Lifecycle ............................................................................................................ 7\n 4.4. The Resource abstraction .............................................................................................. 8\n 4.5. Accessing the BundleContext ..................................................................................... 9\n 4.6. Application Context Destruction ................................................................................... 9\n 4.7. Stopping the extender bundle ....................................................................................... 10\n 5. Packaging and Deploying Spring-based OSGi applications .................................................... 11\n 5.1. Bundle format and Manifest headers .............................................................................. 12\n 5.2. Extender configuration options ..................................................................................... 14\n 5.2.1. Listening to Extender events ................................................................................ 16\n 5.3. Required Spring Framework and Spring Dynamic Modules Bundles ............................ 17\n 5.4. Spring XML authoring support ..................................................................................... 18\n 5.5. Importing and Exporting packages ............................................................................. 18\n 5.6. Considerations when using external libraries ............................................................... 18\n 5.7. Diagnosing problems .................................................................................................... 19\n 6. The Service Registry ................................................................................................................ 20\n 6.1. Exporting a Spring bean as an OSGi service ................................................................. 21\n 6.1.1. Controlling the set of advertised service interfaces for an exported service .......... 21\n 6.1.2. Controlling the set of advertised properties for an exported service .................... 23\n 6.1.3. The depends-on attribute ..................................................................................... 23\n 6.1.4. The context-class-loader attribute .................................................................... 23\n 6.1.5. The ranking attribute ......................................................................................... 24\n 6.1.6. service element attribute .................................................................................. 24\n 6.1.7. Service registration and unregistration lifecycle ............................................... 25\n 6.2. Defining references to OSGi services .............................................................................. 27\n 6.2.1. Referencing an individual service ......................................................................... 27\n 6.2.2. Referencing a collection of services ..................................................................... 31\n 6.2.3. Dealing with the dynamics of OSGi imported services ......................................... 37\n 6.2.4. Listener and service proxies ............................................................................... 38\n 6.2.5. Accessing the caller BundleContext ................................................................ 38\n 6.3. Exporter/Importer listener best practices ......................................................................... 39\n 6.3.1. Listener and cyclic dependencies ......................................................................... 39\n 6.4. Service importer global defaults .................................................................................... 41\n 6.5. Relationship between the service exporter and service importer .................................... 42\n 7. Working with Bundles .............................................................................................................. 43\n 8. Web Support .......................................................................................................................... 45\n 8.1. Supported Web Containers ......................................................................................... 45\n8.2. Web support usage ........................................................................................................... 45\n8.3. WAR classpath in OSGi ................................................................................................. 46\n 8.3.1. Static Resources ......................................................................................................... 46\n 8.3.2. Servlets .................................................................................................................. 46\n 8.3.3. Java Server Pages ................................................................................................. 47\n8.4. Configuring the web extender ....................................................................................... 48\n 8.4.1. Changing the war deployer .................................................................................... 49\n8.5. Customizing the standard deployers ............................................................................... 49\n8.6. OSGi-ready libraries and web development .................................................................. 50\n 8.6.1. Deploying web containers as OSGi bundles ......................................................... 50\n 8.6.2. Common libraries .................................................................................................. 51\n8.7. Spring-MVC Integration ............................................................................................... 51\n9. Testing OSGi based Applications ...................................................................................... 53\n 9.1. OSGi Mocks ................................................................................................................. 53\n 9.2. Integration Testing ......................................................................................................... 54\n 9.2.1. Creating a simple OSGi integration test ............................................................... 54\n 9.2.2. Installing test prerequisites .................................................................................. 55\n 9.2.3. Advanced testing framework topics ...................................................................... 56\n 9.2.4. Creating an OSGi application context ................................................................. 59\n 9.2.5. Specifying the OSGi platform to use .................................................................. 59\n 9.2.6. Waiting for the test dependencies ....................................................................... 59\n 9.2.7. Testing framework performance ......................................................................... 59\nIII. Other Resources .................................................................................................................. 61\n10. Useful links ......................................................................................................................... 62\nIV. Appendixes .......................................................................................................................... 63\n A. Compendium Services ...................................................................................................... 64\n A.1. Configuration Admin ................................................................................................. 64\n A.1.1. Property placeholder support .............................................................................. 64\n A.1.2. Configuration Dictionaries .................................................................................. 65\n B. Extensions ........................................................................................................................ 66\n B.1. Annotation-based injection ...................................................................................... 66\n B.1.1. Enabling/Disabling annotation processing ........................................................... 66\n C. Eclipse Plug-in Development integration ......................................................................... 68\n D. Spring Dynamic Modules Maven Archetype ................................................................... 72\n D.1. Generated Project Features at-a-glance ................................................................... 73\n E. Useful OSGi tips ............................................................................................................... 74\n E.1. OSGi Fragments ......................................................................................................... 74\n F. Roadmap ............................................................................................................................. 76\n F.1. Enhanced Configuration Admin Support .................................................................... 76\n F.1.1. Managed Services ............................................................................................... 76\n F.1.2. Managed Service Factories ................................................................................. 77\n F.1.3. Direct access to configuration data ...................................................................... 77\n F.1.4. Publishing configuration administration properties with exported services ...... 77\n F.2. Access to Service References for Collections .......................................................... 78\n F.3. Start level integration ................................................................................................. 78\n F.4. Web library integration .............................................................................................. 78\n F.5. ORM/Persistence support .......................................................................................... 78\n F.6. OSGi standards .......................................................................................................... 79\n G. Spring-DM OSGi Repository ........................................................................................... 80\n G.1. Spring-DM temporary OSGi Repository ................................................................. 80\n G.1.1. Repository conventions ....................................................................................... 80\n G.1.2. Browsing the repository content ......................................................................... 80\nPreface\n\nApplication development has seen significant changes in the last years, moving towards a simpler, more agile, POJO-based programming model in order to keep a fast pace. Dependency injection and Aspect Oriented Programming, which were once bleeding edge ideas, are used on a daily basis by most developers to manage and simplify the complexity of their applications.\n\nHowever, in terms of deployment, things have remained mainly unchanged. Even though code bases are divided into modules, whether logical, conceptual or physical, at runtime they are seen as one monolithic application in which, making a change (be it large or small), requires a restart. OSGi aims to change this by allowing applications to be divided into modules that can have different life cycles, dependencies and still exist as a whole.\n\nSpring Dynamic Modules focuses on integrating Spring Framework powerful, non-invasive programming model and concepts with the dynamics and modularity of OSGi platform. It allows transparent exporting and importing of OSGi services, life cycle management and control.\n\nWhile every effort has been made to ensure that this documentation is comprehensive and there are no errors, nevertheless some topics might require more explanation and some typos might have crept in. If you do spot any mistakes or even more serious errors and you can spare a few cycles during lunch, please do bring the error to the attention of the Spring Dynamic Modules team by raising an issue. Thank you.\nPart I. Introduction\n\nThis document is the reference guide for Spring Dynamic Modules. It defines Spring Dynamic Modules concepts and semantics, the syntax for the OSGi Service Platform based namespaces, the Dynamic Modules extender bundle and the OSGi manifest header entries defined by Dynamic Modules. For a tutorial introduction to building OSGi-based applications with Spring Dynamic Modules see our online page.\n\nOSGi developers looking for an introduction to Spring should review the introductory articles on the springframework.org site.\n\nNote: OSGi is a trademark of the OSGi Alliance. Project name is pending final approval from the Alliance.\n\nNote: Please see the known issues page for Spring Dynamic Modules release.\nChapter 1. Why Spring Dynamic Modules?\n\nThe Spring Framework is the leading full-stack Java/JEE application framework. It provides a lightweight container and a non-invasive programming model enabled by the use of dependency injection, AOP, and portable service abstractions. The OSGi Service Platform offers a dynamic application execution environment in which modules (bundles) can be installed, updated, or removed on the fly. It also has excellent support for modularity and versioning.\n\nSpring Dynamic Modules makes it easy to write Spring applications that can be deployed in an OSGi execution environment, and that can take advantage of the services offered by the OSGi framework. Spring’s OSGi support also makes development of OSGi applications simpler and more productive by building on the ease-of-use and power of the Spring Framework. For enterprise applications, the combination of Spring Dynamic Modules and the OSGi platform provides:\n\n- Better separation of application logic into modules, with runtime enforcement of module boundaries\n- The ability to deploy multiple versions of a module (or library) concurrently\n- The ability to dynamically discover and use services provided by other modules in the system\n- The ability to dynamically install, update and uninstall modules in a running system\n- Use of the Spring Framework to instantiate, configure, assemble, and decorate components within and across modules.\n- A simple and familiar programming model for enterprise developers to exploit the features of the OSGi platform.\n\nWe believe that the combination of OSGi and Spring offers a comprehensive model for building enterprise applications.\nChapter 2. Requirements\n\nSpring Dynamic Modules 1.0 supports JDK level 1.4 and above and OSGi R4 and above. Bundles deployed for use with Spring Dynamic Modules should specify \"Bundle-ManifestVersion: 2\" in their manifest (OSGi R4). We test against Equinox 3.2.2, Felix 1.0.3, and Knopflerfish 2.0.4 as part of our continuous integration process.\nChapter 3. What is new?\n\nWhile a relatively young project, each version of Spring Dynamic Modules (even minor ones) offers new functionality. This chapter is a guide to the new and improved feature and intended as a high-level, short summary. Please follow the appropriate links for more in-depth information.\n\n3.1. 1.1.x\n\n3.1.1. Web Support\n\nThe biggest feature in Spring Dynamic Modules 1.1.x is the transparent support for web applications on OSGi platforms. By integrating directly with web containers (such as Apache Tomcat and Jetty), Spring-DM allows WARs using Servlet, JSP and taglib technologies to be used with little or no effort at all. Please see Chapter 8, Web Support for details.\n\n3.1.1.1. Spring-MVC Integration\n\nAdditionally, with 1.1.x it is possible to run Spring-MVC applications inside OSGi environments. See Section 8.7, “Spring-MVC Integration” for more information.\n\n3.1.2. Classpath Resource Abstraction\n\n1.1.x adds support for classpath: and classpath*: prefixes to the OSGi Resource abstraction. This allows the discovery of classpath resources (such as Spring’s component scanning) to work out-of-the-box across multiple bundles on the supported OSGi platforms. See Section 4.4, “The Resource abstraction” for more information.\n\n3.1.3. Pluggable Extender Configuration\n\n1.1.x makes it easy to change the default configuration for the various extenders used by Spring-DM. By using fragments, users can customize the way application contexts are started, the web container used for web deployment or the thread-pool for running Spring applications. Additionally, it is possible to receive events regarding the OSGi Spring application contexts lifecycle. Section 4.1, “The Spring Dynamic Modules Extender bundle” lists the available options and explains them in detail.\n\n3.1.4. Improved class loading\n\nIn 1.1.x, the proxy creation has been improved, leading to better package wiring for the managed bundles. See the FAQ for more information.\nPart II. Reference Documentation\n\nDocument structure\n\nThis part of the reference documentation explains the core functionality offered by Spring Dynamic Modules.\n\nChapter 4, Bundles and Application Contexts describes the relationship between an OSGi Bundle and a Spring Application Context, and introduces the Spring Extender Bundle support for instantiating application contexts automatically.\n\nChapter 5, Packaging and Deploying Spring-based OSGi applications describes how to deploy the Spring Framework jar files in an OSGi environment, and how to reference external APIs from your application bundles should you need to do so. This chapter also explains some of the issues to be aware of when using existing enterprise libraries not designed for OSGi in an OSGi environment.\n\nChapter 6, The Service Registry describes how to export Spring beans as services in the OSGi service registry, and how to inject references to OSGi services into beans. This chapter also defines how the dynamic life-cycle of OSGi services and bundles is supported.\n\nChapter 7, Working with Bundles describes how to declare a bean that represents an OSGi bundle, including support for installing new bundles into the OSGi platform.\n\nChapter 9, Testing OSGi Based Applications explains the integration testing support provided by Spring Dynamic Modules. This support enables you to write simple JUnit integration tests that can start up an OSGi environment, install the bundles needed for the integration test, execute the test case(s) inside of OSGi, and return the results to the runner. This makes it easy to integrate OSGi integration testing into any environment that can work with JUnit.\nChapter 4. Bundles and Application Contexts\n\nThe unit of deployment (and modularity) in OSGi is the bundle (see section 3.2 of the OSGi Service Platform Core Specification). A bundle known to the OSGi runtime is in one of three steady states: installed, resolved, or active. Bundles may export services (objects) to the OSGi service registry, and by so doing make these services available for other bundles to discover and to use. Bundles may also export Java packages, enabling other bundles to import the exported types.\n\nIn Spring the primary unit of modularity is an application context, which contains some number of beans (objects managed by the Spring application context). Application contexts can be configured in a hierarchy such that a child application context can see beans defined in a parent, but not vice-versa. The Spring concepts of exporters and factory beans are used to export references to beans to clients outside of the application context, and to inject references to services that are defined outside of the application context.\n\nThere is a natural affinity between an OSGi bundle and a Spring application context. Using Spring Dynamic Modules, an active bundle may contain a Spring application context, responsible for the instantiation, configuration, assembly, and decoration of the objects (beans) within the bundle. Some of these beans may optionally be exported as OSGi services and thus made available to other bundles, beans within the bundle may also be transparently injected with references to OSGi services.\n\n4.1. The Spring Dynamic Modules Extender bundle\n\nExtender Pattern\n\nA common pattern in OSGi applications is the extender, that (quoting Peter Kriens, OSGi Technical Director), “allows other bundles to extend the functionality in a specific domain”. See this OSGi Alliance blog entry for an in-depth explanation.\n\nSpring Dynamic Modules provides an OSGi bundle org.springframework.osgi.bundle.extender. This bundle is responsible for instantiating the Spring application contexts for your application bundles. It serves the same purpose as the ContextLoaderListener does for Spring web applications. Once the extender bundle is installed and started it looks for any existing Spring-powered bundles that are already in the ACTIVE state and creates application contexts on their behalf. In addition, it listens for bundle starting events and automatically creates an application context for any Spring-powered bundle that is subsequently started. Section 5.1, “Bundle format and Manifest headers” describes what the extender recognizes as a “Spring-powered bundle” while Section 5.2, “Extender configuration options” how the extender can be configured.\n\n4.2. Application Context Creation\n\nThe extender bundle creates applications contexts asynchronously. This behaviour ensures that starting an OSGi Service Platform is fast and that bundles with service inter-dependencies do not cause deadlock on startup. A Spring-powered bundle may therefore transition to the STARTED state before its application context has been created. It is possible to force synchronous creation of application contexts on a bundle-by-bundle basis. See Section 5.1, “Bundle format and Manifest headers” for information on how to specify this behaviour.\n\nIf application context creation fails for any reason then the failure cause is logged. The bundle remains in the STARTED state. There will be no services exported to the registry from the application context in this scenario.\n4.2.1. Mandatory Service Dependencies\n\nIf an application context declares mandatory dependencies on the availability of certain OSGi services (see Chapter 6, The Service Registry) then creation of the application context is blocked until all mandatory dependencies can be satisfied through matching services available in the OSGi service registry. Since a service may come and go at any moment in an OSGi environment, this behaviour only guarantees that all mandatory services were available at the moment creation of the application context began. One or more services may subsequently become unavailable again during the process of application context creation. Chapter 6, The Service Registry describes what happens when a mandatory service reference becomes unsatisfied. In practice, for most enterprise applications built using Spring Dynamic Modules services, the set of available services and bundles will reach a steady state once the platform and its installed bundles are all started. In such a world the behaviour of waiting for mandatory dependencies simply ensures that bundles A and B, where bundle A depends on services exported by bundle B, may be started in any order.\n\nA timeout applies to the wait for mandatory dependencies to be satisfied. By default the timeout is set to 5 minutes, but this value can be configured using the timeout directive. See Section 5.1, “Bundle format and Manifest headers” for details.\n\nIt is possible to change the application context creation semantics so that application context creation fails if all mandatory services are not immediately available upon startup (see section 4.1). When configured to not wait for dependencies, a bundle with unsatisfied mandatory dependencies will be stopped, leaving the bundle in the RESOLVED state.\n\n4.2.2. Application Context Service Publication\n\nOnce the application context creation for a bundle has completed, the application context object is automatically exported as a service available through the OSGi Service Registry. The context is published under the interface org.springframework.context.ApplicationContext (and also all of the visible super-interfaces and types implemented by the context). The published service has a service property named org.springframework.context.service.name whose value is set to the bundle symbolic name of the bundle hosting the application context. It is possible to prevent publication of the application context as a service using a directive in the bundle's manifest. See Section 5.1, “Bundle format and Manifest headers” for details.\n\nNote: the application context is published as a service primarily to facilitate testing, administration, and management. Accessing this context object at runtime and invoking getBean() or similar operations is discouraged. The preferred way to access a bean defined in another application context is to export that bean as an OSGi service from the defining context, and then to import a reference to that service in the context that needs access to the service. Going via the service registry in this way ensures that a bean only sees services with compatible versions of service types, and that OSGi platform dynamics are respected.\n\n4.3. Bundle Lifecycle\n\nOSGi is a dynamic platform: bundles may be installed, started, updated, stopped, and uninstalled at any time during the running of the framework.\n\nWhen an active bundle is stopped, any services it exported during its lifetime are automatically unregistered and the bundle returns to the resolved state. A stopped bundle should release any resources it has acquired and terminate any threads. Packages exported by a stopped bundle continue to be available to other bundles.\n\nA bundle in the resolved state may be uninstalled: packages that were exported by an uninstalled bundle continue to be available to bundles that imported them (but not to newly installed bundles).\nA bundle in the resolved state may also be updated. The update process migrates from one version of a bundle to another version of the same bundle.\n\nFinally of course, a resolved bundle can be started, which transitions it to the active state.\n\nThe OSGi PackageAdmin refreshPackages operation refreshes packages across the whole OSGi framework or a given subset of installed bundles. During the refresh, an application context in an affected bundle will be stopped and restarted. After a refreshPackages operation, packages exported by older versions of updated bundles, or packages exported by uninstalled bundles, are no longer available. Consult the OSGi specifications for full details.\n\nWhen a Spring-powered bundle is stopped, the application context created for it is automatically destroyed. All services exported by the bundle will be unregistered (removed from the service registry) and the normal application context tear-down life-cycle is observed (org.springframework.beans.factory.DisposableBean implementors and destroy-method callbacks are invoked on beans in the context).\n\nIf a Spring-powered bundle that has been stopped is subsequently re-started, a new application context will be created for it.\n\n### 4.4. The Resource abstraction\n\nThe Spring Framework defines a resource abstraction for loading resources within an application context (see Spring's resource abstraction). All resource loading is done through the org.springframework.core.io.ResourceLoader associated with the application context. The org.springframework.core.io.ResourceLoader is also available to beans wishing to load resources programmatically. Resource paths with explicit prefixes - such as classpath: - are treated uniformly across all application context types (for example, web application contexts and classpath-based application contexts). Relative resource paths are interpreted differently based on the type of application context being created. This enables easy integration testing outside the ultimate deployment environment.\n\nOSGi 4.0.x specification defines three different spaces from which a resource can be loaded. Spring-DM supports all of them through its dedicated OSGi-specific application context and dedicated prefixes:\n\n<table>\n<thead>\n<tr>\n<th>OSGi Search Strategy</th>\n<th>Prefix</th>\n<th>Explanation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Class Space</td>\n<td>classpath:</td>\n<td>Searches the bundle classloader (the bundle, all imported packages and required bundles). Forces the bundle to be resolved. This method has similar semantics to Bundle#getResource(String)</td>\n</tr>\n<tr>\n<td>Class Space</td>\n<td>classpath*:</td>\n<td>Searches the bundle classloader (the bundle and all imported packages and required bundles). Forces the bundle to be resolved. This method has similar semantics to Bundle#getResources(String)</td>\n</tr>\n<tr>\n<td>JAR File (or JarSpace)</td>\n<td>osgibundlejar:</td>\n<td>Searches only the bundle jar. Provides low-level access without</td>\n</tr>\n<tr>\n<td>OSGi Search Strategy</td>\n<td>Prefix</td>\n<td>Explanation</td>\n</tr>\n<tr>\n<td>----------------------</td>\n<td>------------</td>\n<td>-----------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>Bundle Space</td>\n<td>osgibundle:</td>\n<td>Searches the bundle jar and its attached fragments (if there are any). Does not create a class loader or force the bundle to be resolved.</td>\n</tr>\n</tbody>\n</table>\n\nPlease consult section 4.3.12 of the OSGi specification for an in depth explanation of the differences between them.\n\n**Note**\n\nIf no prefix is specified, the bundle space (osgibundle:) will be used.\n\n**Note**\n\nDue to the OSGi dynamic nature, a bundle classpath can change during its life time (for example when dynamic imports are used). This might cause different classpath Resources to be returned when doing pattern matching based on the running environment or target platform.\n\nAll of the regular Spring resource prefixes such as file: and http: are also supported, as are the pattern matching wildcards. Resources loaded using such prefixes may come from any location, they are not restricted to being defined within the resource-loading bundle or its attached fragments.\n\nOSGi platforms may define their own unique prefixes for accessing bundle contents. For example, Equinox defines the bundleresource: and bundlentry: prefixes. These platform specific prefixes may also be used with Spring OSGi, at the cost, of course, of tying yourself to a particular OSGi implementation.\n\n### 4.5. Accessing the BundleContext\n\nIn general there is no need to depend on any OSGi APIs when using the Spring Dynamic Modules support. If you *do* need access to the OSGi BundleContext object for your bundle, then Spring makes this easy to do.\n\nThe OSGi application context created by the Spring extender will automatically contain a bean of type BundleContext and with name bundleContext. You can inject a reference to this bean into any bean in the application context either by-name or by-type. In addition, Spring Dynamic Modules defines the interface `org.springframework.osgi.context.BundleContextAware`:\n\n```java\npublic interface BundleContextAware {\n public void setBundleContext(BundleContext context);\n}\n```\n\nAny bean implementing this interface will be injected with a reference to the bundle context when it is configured by Spring. If you wish to use this facility within a bundle, remember to import the package `org.springframework.osgi.context` in your bundle manifest.\n\n### 4.6. Application Context Destruction\n\nThe application context is bound to the bundle in which it lives. Thus, if the declaring bundle is being\nshutdown, the application context will be destroyed as well, all exported services being unregistered and all service imported dispose of.\n\nNote however that a bundle can be closed individually or as part of a bigger event such as shutting down the entire OSGi platform. In this case or when the extender bundle is being closed down, the managed application contexts will be closed in a managed manner based on the service dependencies between them. Please see the next section for more details.\n\n4.7. Stopping the extender bundle\n\nIf the extender bundle is stopped, then all the application contexts created by the extender will be destroyed. Application contexts are shutdown in the following order:\n\n1. Application contexts that do not export any services, or that export services that are not currently referenced, are shutdown in reverse order of bundle id. (Most recently installed bundles have their application contexts shutdown first).\n\n2. Shutting down the application contexts in step (1) may have released references these contexts were holding such that there are now additional application contexts that can be shutdown. If so, repeat step 1 again.\n\n3. If there are no more active application contexts, we have finished. If there are active application contexts then there must be a cyclic dependency of references. The circle is broken by determining the highest ranking service exported by each context: the bundle with the lowest ranking service in this set (or in the event of a tie, the highest service id), is shut down. Repeat from step (1).\nChapter 5. Packaging and Deploying Spring-based OSGi applications\n\nA traditional Spring application uses either a single application context, or a parent context containing service layer, data layer, and domain objects with a child context containing web layer components. The application context may well be formed by aggregating the contents of multiple configuration files.\n\nWhen deploying an application to OSGi the more natural structure is to package the application as a set of peer bundles (application contexts) interacting via the OSGi service registry. Independent subsystems should be packaged as independent bundles or sets of bundles (vertical partitioning). A subsystem may be package in a single bundle, or divided into several bundles partitioned by layer (horizontal partitioning). A straightforward web application may for example be divided into four modules (bundles): a web bundle, service layer bundle, data layer bundle, and domain model bundle. Such an application would look like this:\n\nIn this example the data layer bundle yields a data layer application context that contains a number of internal components (beans). Two of those beans are made publicly available outside of the application context by...\npublishing them as services in the OSGi service registry.\n\nThe service layer bundle yields a service layer application context that contains a number of internal components (beans). Some of those components depend on data layer services, and import those services from the OSGi service registry. Two of the service layer components are made externally available as services in the OSGi service registry.\n\nThe web component bundle yields a web application context that contains a number of internal components (beans). Some of those components depend on application services, and import those services from the OSGi service registry. Since the domain model bundle contributes only domain model types, but does not need to create any components of its own, it has no associated application context.\n\n5.1. Bundle format and Manifest headers\n\nEach application module should be packaged as an OSGi bundle. A bundle is essentially a jar file with a META-INF/MANIFEST.MF file containing a series of headers recognized by the OSGi Service Platform. See the OSGi Service Platform Core Specification section 3.2 for details. Some OSGi implementations may support exploded jar files, but the format remains the same.\n\nThe Spring extender recognizes a bundle as \"Spring-powered\" and will create an associated application context when the bundle is started and one or both of the following conditions is true:\n\n- The bundle path contains a folder META-INF/spring with one or more files in that folder with a '.xml' extension.\n- META-INF/MANIFEST.MF contains a manifest header Spring-Context.\n\nIn addition, if the optional SpringExtender-Version header is declared in the bundle manifest, then the extender will only recognize bundles where the specified version constraints are satisfied by the version of the extender bundle (Bundle-Version). The value of the SpringExtender-Version header must follow the syntax for a version range as specified in section 3.2.5 of the OSGi Service Platform Core Specification.\n\nIn the absence of the Spring-Context header the extender expects every \".xml\" file in the META-INF/spring folder to be a valid Spring configuration file, and all directives (see below) take on their default values.\n\nAn application context is constructed from this set of files. A suggested practice is to split the application context configuration into at least two files, named by convention modulename-context.xml and modulename-osgi-context.xml. The modulename-context.xml file contains regular bean definitions independent of any knowledge of OSGi. The modulename-osgi-context.xml file contains the bean definitions for importing and exporting OSGi services. It may (but is not required to) use the Spring Dynamic Modules OSGi schema as the top-level namespace instead of the Spring 'beans' namespace.\n\nThe Spring-Context manifest header may be used to specify an alternate set of configuration files. The resource paths are treated as relative resource paths and resolve to entries defined in the bundle and the set of attached fragments. When the Spring-Context header defines at least one configuration file location, any files in META-INF/spring are ignored unless directly referenced from the Spring-Context header.\n\nThe syntax for the Spring-Context header value is:\n\n```\nSpring-Context-Value ::= context ( ',' context ) *\ncontext ::= path ( ';' path ) * (';' directive) *\n```\nThis syntax is consistent with the OSGi Service Platform common header syntax defined in section 3.2.3 of the OSGi Service Platform Core Specification.\n\nFor example, the manifest entry:\n\n```\nSpring-Context: config/account-data-context.xml, config/account-security-context.xml\n```\n\nwill cause an application context to be instantiated using the configuration found in the files `account-data-context.xml` and `account-security-context.xml` in the bundle jar file.\n\nA number of directives are available for use with the `Spring-Context` header. These directives are:\n\n- **create-asynchronously** (false|true): controls whether the application context is created asynchronously (the default), or synchronously.\n\n For example:\n\n ```\n Spring-Context: *;create-asynchronously:=false\n ```\n\n Creates an application context synchronously, using all of the \"*.xml\" files contained in the `META-INF/spring` folder.\n\n ```\n Spring-Context: config/account-data-context.xml;create-asynchronously:=false\n ```\n\n Creates an application context synchronously using the `config/account-data-context.xml` configuration file. Care must be taken when specifying synchronous context creation as the application context will be created on the OSGi event thread, blocking further event delivery until the context is fully initialized. If an error occurs during the synchronous creation of the application context then a `FrameworkEvent.ERROR` event is raised. The bundle will still proceed to the ACTIVE state.\n\n- **wait-for-dependencies** (true|false): controls whether or not application context creation should wait for any mandatory service dependencies to be satisfied before proceeding (the default), or proceed immediately without waiting if dependencies are not satisfied upon startup.\n\n For example:\n\n ```\n Spring-Context: config/osgi-*.xml;wait-for-dependencies:=false\n ```\n\n Creates an application context using all the files matching \"osgi-*.xml\" in the config directory. Context creation will begin immediately even if dependencies are not satisfied. This essentially means that mandatory service references are treated as though they were optional - clients will be injected with a service object that may not be backed by an actual service in the registry initially. See section 5.2 for more details.\n\n- **timeout** (300): the time to wait (in seconds) for mandatory dependencies to be satisfied before giving up and failing application context creation. This setting is ignored if `wait-for-dependencies:=false` is specified. The default is 5 minutes (300 seconds).\n\n For example:\n\n ```\n Spring-Context: *;timeout:=60\n ```\n\n Creates an application context that waits up to 1 minute (60 seconds) for its mandatory dependencies to\nappear.\n\n- `publish-context` (true|false): controls whether or not the application context object itself should be published in the OSGi service registry. The default is to publish the context.\n\nFor example:\n\n```\nSpring-Context: *;publish-context:=false\n```\n\nIf there is no Spring-Context manifest entry, or no value is specified for a given directive in that entry, then the directive takes on its default value.\n\n## 5.2. Extender configuration options\n\nAside from bundle-specific configurations, Spring-DM allows the core extender generic behaviour be configured. This is useful when embedding Spring-DM inside a managed environment or when a bundles-wide functionality is desired. To allow for extensible configuration, the extender relies on OSGi `fragments` to override its defaults. The extender looks for all XML files under `META-INF/spring/extender` folder in its bundle space and assembled them into an application context (of type `OsgiBundleXmlApplicationContext`) that is used internally as its configuration. To override a default setting of the extender, look up the appropriate bean name from the table below, define it in a suitable manner and then attach it as a `fragment` to the `spring-osgi-extender.jar`, using:\n\n```\nFragment-Host: org.springframework.bundle.osgi.extender\n```\n\nThe following beans are currently recognized by the extender:\n\n### Table 5.1. Extender Configuration Options\n\n<table>\n<thead>\n<tr>\n<th>Bean Name</th>\n<th>Type</th>\n<th>Role</th>\n<th>Default Behaviour/Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>taskExecutor</td>\n<td>TaskExecutor(^a)</td>\n<td>Creates and runs the Spring application contexts associated with each bundle. The task executor is responsible for managing its own pool of threads used by the application contexts.</td>\n<td>SimpleAsyncTaskExecutor is used by default which means a new thread will be created for each application contexts. While this is suitable for testing and development, we strongly recommend to use a thread pool in a production environment.</td>\n</tr>\n<tr>\n<td>shutdownTaskExecutor</td>\n<td>TaskExecutor(^b)</td>\n<td>Destroys managed Spring application contexts associated with each bundle. The task executor is responsible for managing its own pool of threads used by the application contexts.</td>\n<td>TimerTaskExecutor is used by default which means all application context will be destroyed in a serialized manner (which is desired). Since the shutdown order normally matters, it is...</td>\n</tr>\n<tr>\n<td>Bean Name</td>\n<td>Type</td>\n<td>Role</td>\n<td>Default Behaviour/Value</td>\n</tr>\n<tr>\n<td>-----------------------</td>\n<td>-------------------------------------------</td>\n<td>----------------------------------------------------------------------</td>\n<td>----------------------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>extenderProperties</td>\n<td>java.util.Properties</td>\n<td>Defines simple properties such as the maximum time for contexts to gracefully close</td>\n<td>recommended to keep the default implementation or, for managed environments, to use a thread-pool that executes only one task at a time (so that contexts are stopped in the given order).</td>\n</tr>\n<tr>\n<td>applicationEventMulticaster</td>\n<td>ApplicationEventMulticaster</td>\n<td>An instance of SimpleApplicationEventMulticaster is used. See AbstractApplicationContext javadoc for more information regarding available beans in an application context.</td>\n<td></td>\n</tr>\n<tr>\n<td>applicationContextCreator</td>\n<td>OsgiApplicationContextCreator</td>\n<td>Allows customization of the application context created by the extender. This includes changing the application context class type or additional processing (see below).</td>\n<td>The Extender default behaviour applies.</td>\n</tr>\n<tr>\n<td>(irrelevant)</td>\n<td>OsgiBeanFactoryPostProcessor</td>\n<td>Similar to Spring’s BeanFactoryPostProcessor interface, beans of type OsgiBeanFactoryPostProcessor are automatically detected and applied to all contexts created by the extender (whether user-defined or not). This type of post processor is useful as it allows customization of the bean factory such as adding/removing/changing existing bean definitions or adding new bean instances.</td>\n<td>The Extender default behaviour applies.</td>\n</tr>\n</tbody>\n</table>\n\n---\n\n*a.org.springframework.core.task\n*b.org.springframework.core.task*\nFrom the `extenderProperties` bean, the following properties are recognized:\n\n### Table 5.2. Available `extenderProperties`\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Type</th>\n<th>Description</th>\n<th>Default Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>shutdown.wait.time</td>\n<td><code>java.lang.Number</code></td>\n<td>The amount of time the extender will wait for each application context to shutdown gracefully. Expressed in milliseconds.</td>\n<td>10000 ms (10 s)</td>\n</tr>\n<tr>\n<td>process.annotations</td>\n<td><code>java.lang.Boolean</code></td>\n<td>Flag indicating whether or not, the extender will process Spring-DM annotations. Note that this can be enabled in each process bundle by adding the appropriate bean post processor. See Section B.1, “Annotation-based injection” for more information.</td>\n<td>false</td>\n</tr>\n</tbody>\n</table>\n\n**Note**\n\nSince an application context is used, the full power of the Spring IoC container can be used for creating the extender configuration beans.\n\n### 5.2.1. Listening to Extender events\n\nThere are cases when the failure or successful startup of an application context needs to be acknowledged for logging purposes (for example). For these cases, Spring-DM offers a dedicated package `org.springframework.osgi.context.event` which defines the events that OSGi application contexts can send during their lifecycle. At the moment, the following events are available:\n\n### Table 5.3. Spring-DM build-in events\n\n<table>\n<thead>\n<tr>\n<th>Event</th>\n<th>Explanation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>OsgiBundleContextRefreshedEvent</code></td>\n<td>Published when an OSGi application context has been successfully initialized or refreshed (e.g. using the <code>refresh()</code> method on the <code>ConfigurableApplicationContext</code> interface). There are no guarantees on how many times this event might be received during the lifecycle of an application context - this is left up to the used</td>\n</tr>\n<tr>\n<td>Event</td>\n<td>Explanation</td>\n</tr>\n<tr>\n<td>------------------------------</td>\n<td>---------------------------------------------------------------------------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td>OsgiBundleContextFailedEvent</td>\n<td>Published when an OSGi application context is closed due to a failure. This event can appear any time during the lifecycle of an application context - before, during or after refresh. Usually the cause indicates an error in the configuration - syntax typo, incorrect wiring, missing bean and so forth.</td>\n</tr>\n</tbody>\n</table>\n\nParties interested in receiving these events should implement `OsgiBundleApplicationContextListener` and then publish it as an OSGi service. The Spring-DM extender will automatically detect the listener and will send the events to it. By taking advantage of the OSGi service registry, the extender decouples the received from the event publisher and moreover, makes the registration/unregistration process easier. For example, there is nothing special a client should do to unregister the listener - simply stopping the bundle will automatically unregister all its published services (including the listener), an event which will be detected by the extender which will remove the listener. Of course, it is also possible for the client to unregister the listener manually during a bundle lifecycle.\n\n**Note**\n\nThe Spring-DM events semantics are slightly different than Spring's. The OSGi events are not sent to beans inside the *causing* application context but to other parties (possible beans in other application contexts) interested in monitoring its behaviour.\n\n### 5.3. Required Spring Framework and Spring Dynamic Modules Bundles\n\nThe Spring Dynamic Modules project provides an number of bundle artifacts that must be installed in your OSGi platform in order for the Spring extender to function correctly:\n\n- The extender bundle itself, `org.springframework.osgi.extender`\n- The core implementation bundle for the Spring Dynamic Modules support, `org.springframework.osgi.core`\n- The Spring Dynamic Modules I/O support library bundle, `org.springframework.osgi.io`\n\nIn addition the Spring Framework provides a number of bundles that are required to be installed. As of release 2.5 of the Spring Framework, the Spring jars included in the Spring distribution are valid OSGi bundles and can be installed directly into an OSGi platform. The minimum required set of bundles is:\n\n- `spring-core.jar` (bundle symbolic name `org.springframework.bundle.spring.core`)\n- `spring-context.jar` (bundle symbolic name `org.springframework.bundle.spring.context`)\n- `spring-beans.jar` (bundle symbolic name `org.springframework.bundle.spring.beans`)\n- `spring-aop.jar` (bundle symbolic name `org.springframework.bundle.spring.aop`)\nIn addition the following supporting library bundles are required. OSGi-ready versions of these libraries are shipped with the Spring Dynamic Modules distribution.\n\n- aopalliance\n- backport-util (when running on JDK 1.4)\n- cglib-nodep (when proxying classes rather then interfaces, needed in most cases)\n- commons-logging API (SLF4J version highly recommended)\n- logging implementation such as log4j\n\n5.4. Spring XML authoring support\n\nSpring 2.0 introduced (among other things) easier XML configuration and extensible XML authoring. The latter gives the ability of creating custom schemas that are discovered automatically (in non-OSGi environment) by the Spring XML infrastructure by including them in the classpath. Spring-DM is aware of this process and supports it in OSGi environments so that custom schemas are available to bundles that use them without any extra code or manifest declaration.\n\nAll bundles deployed in the OSGi space (whether they are Spring-powered or not) are scanned by Spring-DM for custom Spring namespace declaration (by checking the bundle space for META-INF/spring.handlers and META-INF/spring.schemas). If these are found, Spring-DM will make the schemas and the namespaces available through an OSGi service that will be automatically used by Spring-powered bundles. This mean that if you deploy a bundle that uses a custom schema, all you have to do is deploy the library that provides the namespace parser and the schema. Bundles that embedded inside their classpath libraries that provide custom schemas will use these over those available in the OSGi space. However, the namespaces of the embedded libraries will not shared with other bundles, that is, they will not be seen by any other bundle.\n\nIn short, with using Spring-DM, custom Spring namespaces are supported transparently without any additional work. Embedded namespace providers will have priority but will not be shared, as opposed to providers deployed as bundles which will be seen (and used) by others.\n\n5.5. Importing and Exporting packages\n\nRefer to the OSGi Service Platform for details of the Import-Package and Export-Package manifest headers. Your bundle will need an Import-Package entry for every external package that the bundle depends on. If your bundle provides types that other bundles need access to, you will need Export-Package entries for every package that should be available from outside of the bundle.\n\n5.6. Considerations when using external libraries\n\nWhat is the context class loader?\n\nThe thread context class loader was introduced in J2SE without much fanfare. Below is a short definition for it, quoted from one of the tutorials available on Java site:\n\nThe Java 2 platform also introduced the notion of context class loader. A thread's context class loader is,\nby default, set to the context class loader of the thread's parent. The hierarchy of threads is rooted at the\nprimordial thread (the one that runs the program). The context class loader of the primordial thread is set\nto the class loader that loaded the application. So unless you explicitly change the thread's context class\nloader, its context class loader will be the application's class loader. That is, the context class loader can\nload the classes that the application can load. This loader is used by the Java runtime such as the RMI\n(Java Remote Method Invocation) to load classes and resources on behalf of the user application. The\ncontext class loader, like any Java 2 platform class loader, has a parent class loader and supports the same\ndelegation model for class loading described previously.\n\nMany enterprise application libraries assume that all of the types and resources that comprise the application\nare accessible through the context class loader. While most developers do not use the context class loader, the\nloader is used heavily by application servers, containers or applications that are multi-threaded.\n\nIn OSGi R4, the set of types and resources available through the context class loader is undefined. This means\nthat the OSGi platform does not make a guarantee of the thread context class loader value or in other words, it\ndoes not manage it.\n\nThus code (for example libraries) that performs manual class loading or that generates new classes dynamically\ncan cause problems when executed inside an OSGi environment.\n\nSpring Dynamic Modules guarantees that during the creation of an application context on behalf of a given\nbundle, all of the types and resources on the bundle's classpath are accessible via the context class loader.\nSpring Dynamic Modules also allows you to control what is accessible through the context class loader when\ninvoking external services and when servicing requests on exported services. See section 5 for details on this.\n\nWork is underway in the OSGi R5 timeframe to provide standardized support for dealing with generated\nclasses and implicit class path dependencies introduced by third-party libraries. In the interim you may need to\nrely on workarounds such as the DynamicImport-Package manifest header, or the facilities provided by specific\nOSGi implementations such as Equinox's buddy mechanism. The Spring Dynamic Modules documentation\ncontains more details on known issues with common enterprise libraries and the workarounds.\n\n5.7. Diagnosing problems\n\nYour chosen OSGi platform implementation should be able to provide you with a good deal of information\nabout the current status of the OSGi environment. For example, starting Equinox with the -console argument\nprovides a command-line console through which you can determine which bundles are installed and their states,\nthe packages and services exported by bundles, find out why a bundle has failed to resolve, and drive bundles\nthrough the lifecycle.\n\nIn addition, Spring itself and the Spring Dynamic Modules bundles contain extensive logging instrumentation\nthat can help you diagnose problems. The recommended approach is to deploy the Simple Logging Facade for\nJava (slf4j) slf4j-api.jar and slf4j-log4j13.jar bundles (the jar files distributed by the project are valid OSGi\nbundles). Then you simply need to create a log4j.properties file in the root of your bundle classpath.\n\nNote that Spring Dynamic Modules uses commons-logging API internally which means that its logging\nimplementation is fully pluggable. Please see the FAQ and Resources pages for more information on other\nlogging libraries besides log4j.\nChapter 6. The Service Registry\n\nThe OSGi service registry enables a bundle to publish objects to a shared registry, advertised via a given set of Java interfaces. Published services also have service properties associated with them in the registry.\n\nSpring Dynamic Modules provides an osgi namespace for Spring (see Appendix H, Spring Dynamic Modules Schema) that can be used to export Spring beans as OSGi services, and to define references to services obtained via the service registry. The namespace elements may be used nested inside another top-level namespace (typically the Spring beans namespace), or within the top-level osgi element.\n\nThe following example shows the use of the osgi namespace within the familiar Spring beans element:\n\n```xml\n<beans xmlns=\"http://www.springframework.org/schema/beans\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xmlns:osgi=\"http://www.springframework.org/schema/osgi\"\n <osgi:service id=\"simpleServiceOsgi\" ref=\"simpleService\"\n interface=\"org.xyz.MyService\" />\n</beans>\n```\n\n1. Use Spring Framework beans schema as the default namespace.\n2. Import Spring Dynamic Modules schema and associate a prefix with its namespace (osgi in this example).\n3. Make sure to import Spring beans schema version 2.5.\n4. Use Spring Dynamic Modules elements using the declared namespace prefix (in this example osgi).\n\nUsing the OSGi namespace as a top-level namespace, the same service would be declared as follows:\n\n```xml\n<beans xmlns=\"http://www.springframework.org/schema/osgi\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xmlns:beans=\"http://www.springframework.org/schema/beans\"\n <service id=\"simpleServiceOsgi\" ref=\"simpleService\"\n interface=\"org.xyz.MyService\" />\n</beans>\n```\n\n1. beans root element has to be prefixed with Spring Framework beans schema prefix (beans in this example).\n2. Use Spring Dynamic Modules schema as the default namespace.\n3. Import Spring Framework beans schema and associate a prefix with its namespace (beans in this example).\n4. Make sure to import Spring beans schema version 2.5.\n5. Use Spring Dynamic Modules elements without any prefix.\n\nUsing the OSGi namespace as a top-level namespace is particularly convenient when following the recommendation of Section 5.1, “Bundle format and Manifest headers” to use a dedicated configuration file for all OSGi-related declarations.\n6.1. Exporting a Spring bean as an OSGi service\n\nThe service element is used to define a bean representing an exported OSGi service. At a minimum you must specify the bean to be exported, and the service interface that the service advertises.\n\nFor example, the declaration\n\n```xml\n<service ref=\"beanToPublish\" interface=\"com.xyz.MessageService\"/>\n```\n\nexports the bean with name beanToPublish with interface com.xyz.MessageService. The published service will have a service property with the name org.springframework.osgi.bean.name set to the name of the target bean being registered (beanToPublish in this case).\n\nThe bean defined by the service element is of type org.osgi.framework.ServiceRegistration and is the ServiceRegistration object resulting from registering the exported bean with the OSGi service registry. By giving this bean an id you can inject a reference to the ServiceRegistration object into other beans if needed. For example:\n\n```xml\n<service id=\"myServiceRegistration\" ref=\"beanToPublish\" interface=\"com.xyz.MessageService\"/>\n```\n\nAs an alternative to exporting a named bean, the bean to be exported to the service registry may be defined as an anonymous inner bean of the service element. Typically the top-level namespace would be the beans namespace when using this style:\n\n```xml\n<osgi:service interface=\"com.xyz.MessageService\">\n <bean class=\"SomeClass\">\n ...\n </bean>\n</osgi:service>\n```\n\nIf the bean to be exported implements the org.osgi.framework.ServiceFactory interface then the ServiceFactory contract is honored as per section 5.6 of the OSGi Service Platform Core Specification. As an alternative to implementing this OSGi API, Spring Dynamic Modules introduces a new bean scope, the bundle scope. When a bean with bundle scope is exported as an OSGi service then one instance of the bean will be created for each unique client (service importer) bundle that obtains a reference to it through the OSGi service registry. When a service importing bundle is stopped, the bean instance associated with it is disposed. To declare a bean with bundle scope simply use the scope attribute of the bean element:\n\n```xml\n<osgi:service ref=\"beanToBeExported\" interface=\"com.xyz.MessageService\"/>\n<bean id=\"beanToBeExported\" scope=\"bundle\" class=\"com.xyz.MessageServiceImpl\"/>\n```\n\n6.1.1. Controlling the set of advertised service interfaces for an exported service\n\nThe OSGi Service Platform Core Specification defines the term service interface to represent the specification of a service's public methods. Typically this will be a Java interface, but the specification also supports registering service objects under a class name, so the phrase service interface can be interpreted as referring to either an interface or a class.\n\nThere are several options for specifying the service interface(s) under which the exported service is registered. The simplest mechanism, shown above, is to use the interface attribute to specify a fully-qualified interface\nname. To register a service under multiple interfaces the nested `interfaces` element can be used in place of the `interface` attribute.\n\n```xml\n<osgi:service ref=\"beanToBeExported\">\n <osgi:interfaces>\n <value>com.xyz.MessageService</value>\n <value>com.xyz.MarkerInterface</value>\n </osgi:interfaces>\n</osgi:service>\n```\n\nIt is illegal to use both `interface` attribute and `interfaces` element at the same time - use only one of them.\n\n### 6.1.1.1. Detecting the advertised interfaces at runtime\n\n#### Hierarchy visibility\n\nNote that when using `auto-export`, only types visible to the bundle exporting the service are registered. For example, a super-interface `SI` would not be exported as a supported service interface even when using `auto-export=\"interfaces\"` if `SI` was not on the exporting bundle's classpath.\n\nEven if exported service class does implement `SI` transitively based on its parent, if the declaring bundle doesn't import the interface, the class is unknown to the exported service. While this might seem counter intuitive, it is actually one of the most powerful features of OSGi which give the bundle authors control over the class visibility and path.\n\nPlease see the FAQ for a more detailed explanation.\n\nUsing the `auto-export` attribute you can avoid the need to explicitly declare the service interfaces at all by analyzing the object class hierarchy and its interfaces.\n\nThe `auto-export` attribute can have one of four values:\n\n- **disabled**: the default value; no auto-detected of service interfaces is undertaken and the `interface` attribute or `interfaces` element must be used instead.\n- **interfaces**: the service will be registered using all of the Java interface types implemented by the bean to be exported\n- **class-hierarchy**: the service will be registered using the exported bean's implementation type and super-types\n- **all-classes**: the service will be registered using the exported bean's implementation type and super-types plus all interfaces implemented by the bean.\n\n`auto-export` and `interface(s)` option are not exclusive; both can be used at the same time for fine grained control over the advertised interfaces if there is such a need. However, the former option should be enough for most cases.\n\nFor example, to automatically register a bean under all of the interfaces that it supports you would declare:\n\n```xml\n<service ref=\"beanToBeExported\" auto-export=\"interfaces\"/>\n```\n\nGiven the interface hierarchy:\n\n```java\npublic interface SuperInterface {}\n```\npublic interface SubInterface extends SuperInterface {}\n\nthen a service registered as supporting the SubInterface interface is *not* considered a match in OSGi when a lookup is done for services supporting the SuperInterface interface. For this reason it is a best practice to export all interfaces supported by the service being registered explicitly, using either the interfaces element or auto-export=\"interfaces\".\n\n### 6.1.2. Controlling the set of advertised properties for an exported service\n\nAs previously described, an exported service is always registered with the service property org.springframework.osgi.bean.name set to the name of the bean being exported. Additional service properties can be specified using the nested service-properties element. The service-properties element contains key-value pairs to be included in the advertised properties of the service. The key must be a string value, and the value must be a type recognized by OSGi Filters. See section 5.5 of the OSGi Service Platform Core Specification for details of how property values are matched against filter expressions.\n\nThe service-properties element must contain at least one nested entry element from the Spring beans namespace. For example:\n\n```\n<service ref=\"beanToBeExported\" interface=\"com.xyz.MyServiceInterface\">\n <service-properties>\n <beans:entry key= \"myOtherKey\" value= \"aStringValue\"/>\n <beans:entry key= \"aThirdKey\" value-ref= \"beanToExposeAsProperty\"/>\n </service-properties>\n</service>\n```\n\nThe Spring Dynamic Modules roadmap includes support for exporting properties registered in the OSGi Configuration Administration service as properties of the registered service. See Appendix F, Roadmap for more details.\n\n### 6.1.3. The depends-on attribute\n\nSpring will manage explicit dependencies of a service element, ensuring for example that the bean to be exported as a service is fully constructed and configured before exporting it. If a service has implicit dependencies on other components (including other service elements) that must be fully initialized before the service can be exported, then the optional depends-on attribute can be used to express these dependencies.\n\n```\n<service ref=\"beanToBeExported\" interface=\"com.xyz.MyServiceInterface\"\n depends-on= \"myOtherComponent\"/>\n```\n\n### 6.1.4. The context-class-loader attribute\n\nThe OSGi Service Platform Core Specification (most current version is 4.1 at time of writing) does not specify what types and resources are visible through the context class loader when an operation is invoked on a service obtained via the service registry. Since some services may use libraries that make certain assumptions about the context class loader, Spring Dynamic Modules enables you to explicitly control the context class loader during service execution. This is achieved using the option context-class-loader attribute of the service element.\n\nThe permissible values for the context-class-loader attribute are unmanaged (the default) and service-provider. When the service-provider value is specified, Spring Dynamic Modules ensures that the context class loader can see all of the resources on the class path of the bundle exporting the service. *When setting context-class-loader to service-provider, the service object will be proxied to handle the*\nclass loader. If the service advertises any concrete class then CGLIB library is required.\n\n### 6.1.5. The ranking attribute\n\nWhen registering a service with the service registry, you may optionally specify a service ranking (see section 5.2.5 of the OSGi Service Platform Core Specification). When a bundle looks up a service in the service registry, given two or more matching services the one with the highest ranking will be returned. The default ranking value is zero. To explicitly specify a ranking value for the registered service, use the optional `ranking` attribute.\n\n```xml\n<service ref=\"beanToBeExported\" interface=\"com.xyz.MyServiceInterface\" ranking=\"9\" />\n```\n\n### 6.1.6. service element attribute\n\nAs a summary, the following table lists the attributes names, possible values and a short description for each of them.\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Values</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>interface</td>\n<td>fully qualified class name (such as <code>java.lang.Thread</code>)</td>\n<td>the fully qualified name of the class under which the object will be exported</td>\n</tr>\n<tr>\n<td>ref</td>\n<td>any bean name</td>\n<td>Reference to the named bean to be exported as a service in the service registry.</td>\n</tr>\n<tr>\n<td>context-class-loader</td>\n<td>unmanaged</td>\n<td>Defines how the context class loader will be managed when an operation is invoked on the exported service. The default value is <code>unmanaged</code> which means that no management of the context class loader is attempted. A value of <code>service-provider</code> will attempt to manage the context class loader.</td>\n</tr>\n</tbody>\n</table>\n\nTable 6.1. OSGi `<service>` attributes\n### 6.1.7. Service registration and unregistration lifecycle\n\nThe service defined by a `service` element is registered with the OSGi service registry when the application\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Values</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>auto-export</td>\n<td>disabled, interfaces, class-hierarchy, all-classes</td>\n<td>Enables Spring to automatically manage the set of service interfaces advertised for the service. By default this facility is disabled. A value of <code>interfaces</code> advertises all of the Java interfaces supported by the exported service. A value of <code>class-hierarchy</code> advertises all the Java classes in the hierarchy of the exported service. A value of <code>all-classes</code> advertises all Java interfaces and classes.</td>\n</tr>\n<tr>\n<td>ranking</td>\n<td>any integer value</td>\n<td>Specify the service ranking to be used when advertising the service. Default value is 0.</td>\n</tr>\n</tbody>\n</table>\ncontext is first created. It will be unregistered automatically when the bundle is stopped and the application context is disposed.\n\nIf you need to take some action when a service is unregistered because its dependencies are not satisfied (or when it is registered), then you can define a listener bean using the nested registration-listener element.\n\nThe declaration of a registration listener must use either the ref attribute to refer to a top-level bean definition, or declare an anonymous listener bean inline. For example:\n\n```xml\n<service ref=\"beanToBeExported\" interface=\"SomeInterface\">\n <registration-listener ref=\"myListener\"\n registration-method=\"serviceRegistered\"\n unregistration-method=\"serviceUnregistered\"/>\n <registration-listener\n registration-method=\"register\">\n <bean class=\"SomeListenerClass\"/>\n </registration-listener>\n</service>\n```\n\n1. Listener declaration referring to a top-level bean declaration.\n2. Indicate the registration and unregistration methods.\n3. Declare only a registration custom method for this listener.\n4. Nested listener bean declaration.\n\nThe optional registration-method and unregistration-method attributes specify the names of the methods defined on the listener bean that are to be invoked during registration and unregistration. A registration and unregistration callback methods must have a signature matching one of the following formats:\n\n```java\npublic void anyMethodName(ServiceType serviceInstance, Map serviceProperties);\n\npublic void anyMethodName(ServiceType serviceInstance, Dictionary serviceProperties);\n```\n\nwhere ServiceType can be any type compatible with the exported service interface of the service.\n\nThe register callback is invoked when the service is initially registered at startup, and whenever it is subsequently re-registered. The unregister callback is invoked during the service unregistration process, no matter the cause (such as the owning bundle stopping).\n\nSpring-DM will use the declared ServiceType argument type and invoke the registration/unregistration method only when a service of a compatible type will be registered/unregistered.\n\nserviceProperties represents a map holding all the properties of the registered/unregistered service. To preserve compatibility with the OSGi specification this argument can be cast, if needed, to a java.util.Dictionary.\n\n### 6.1.7.1. Using OsgiServiceRegistrationListener interface\n\nWhile we discourage, it is possible to implement a Spring-DM specific interface, namely org.springframework.osgi.service.exporter.OsgiServiceRegistrationListener which avoids the need to declare the registration-method and unregistration-method. However, by implementing OsgiServiceRegistrationListener, your code becomes Spring-DM aware (which goes against the POJO philosophy).\n\nIt is possible for a listener to implement OsgiServiceRegistrationListener interface and declare custom methods. In this case, the Spring-DM interface methods will be called first, followed by the custom methods.\n6.2. Defining references to OSGi services\n\nSpring Dynamic Modules supports the declaration of beans that represent services accessed via the OSGi Service Registry. In this manner references to OSGi services can be injected into application components. The service lookup is made using the service interface type that the service is required to support, plus an optional filter expression that matches against the service properties published in the registry.\n\nFor some scenarios, a single matching service that meets the application requirements is all that is needed. The `reference` element defines a reference to a single service that meets the required specification. In other scenarios, especially when using the OSGi whiteboard pattern, references to all available matching services are required. Spring Dynamic Modules supports the management of this set of references as a `List`, `Set` collection.\n\n6.2.1. Referencing an individual service\n\nThe `reference` element is used to define a reference to a service in the service registry.\n\nSince there can be multiple service matching a given description, the service returned is the service that would be returned by a call to `BundleContext.getServiceReference`. This means that the service with the highest ranking will be returned, or if there is a tie in ranking, the service with the lowest service id (the service registered first with the framework) is returned (please see Section 5 from the OSGi spec for more information on the service selection algorithm).\n\n6.2.1.1. Controlling the set of advertised interfaces for the imported service\n\nThe `interface` attribute identifies the service interface that a matching service must implement. For example, the following declaration creates a bean `messageService`, which is backed by the service returned from the service registry when querying it for a service offering the `MessageService` interface.\n\n```\n<reference id=\"messageService\" interface=\"com.xyz.MessageService\"/>\n```\n\nJust like the `service` declaration, when specifying multiple interfaces, use the nested `interfaces` element instead of `interface` attribute:\n\n```\n<osgi:reference id=\"importedOsgiService\">\n <osgi:interfaces>\n <value>com.xyz.MessageService</value>\n <value>com.xyz.MarkerInterface</value>\n </osgi:interfaces>\n</osgi:reference>\n```\n\nIt is illegal to use both `interface` attribute and `interfaces` element at the same time - use only one of them.\n\nThe bean defined by reference element implements all of the advertised interfaces of the service that are visible to the bundle (called greedy proxying). If the registered service interfaces include Java class types (as opposed to interface types) then support for these types is subject to the restrictions of Spring's AOP implementation (see the Spring Reference Guide). In short, if the specified interfaces are classes (rather then interfaces), then cglib library must be available, and `final` methods are not supported.\n\n6.2.1.2. The `filter` attribute\n\nThe optional `filter` attribute can be used to specify an OSGi filter expression and constrains the service registry lookup to only those services that match the given filter.\nFor example:\n\n```xml\n<reference id=\"asyncMessageService\" interface=\"com.xyz.MessageService\" filter=\"(asynchronous-delivery=true)\"/>\n```\n\nwill match only OSGi services that advertise MessageService interface and have the property named asynchronous-delivery set to value true.\n\n### 6.2.1.3. The `bean-name` attribute\n\nThe `bean-name` attribute is a convenient short-cut for specifying a filter expression that matches on the `bean-name` property automatically set when exporting a bean using the `service` element (see Section 6.1, “Exporting a Spring bean as an OSGi service”).\n\nConsider the following exporter/importer declarations:\n\n```xml\n<bean id=\"messageServiceBean\" scope=\"bundle\" class=\"com.xyz.MessageServiceImpl\" />\n<osgi:service id=\"messageServiceExporter\" ref=\"messageServiceBean\" interface=\"com.xyz.MessageService\"/>\n<osgi:reference id=\"messageService\" interface=\"com.xyz.MessageService\" bean-name=\"messageServiceBean\"/>\n```\n\nThe name used with `bean-name` attribute\n\nwill match only OSGi services that advertise MessageService interface and have the property named org.springframework.osgi.bean.name set to value messageServiceBean. In short, this means finding all Spring-DM exported beans that implement interface MessageService and are named messageServiceBean.\n\n### 6.2.1.4. The `cardinality` attribute\n\nThe `cardinality` attribute is used to specify whether or not a matching service is required at all times. A cardinality value of 1..1 (the default) indicates that a matching service must always be available. A cardinality value of 0..1 indicates that a matching service is not required at all times (see section 4.2.1.6 for more details).\n\nA reference with cardinality 1..1 is also known as a mandatory service reference and, by default, application context creation is deferred until the reference is satisfied.\n\n#### Note\n\nIt is an error to declare a mandatory reference to a service that is also exported by the same bundle; this behavior can cause application context creation to fail through either deadlock or timeout.\n\n### 6.2.1.5. The `depends-on` attribute\n\nThe `depends-on` attribute is used to specify that the service reference should not be looked up in the service registry until the named dependent bean has been instantiated.\n\n---\n\n**Spring Dynamic Modules (1.1.2)**\n\n28\n6.2.1.6. The context-class-loader attribute\n\nThe OSGi Service Platform Core Specification (latest version is 4.1 at time of writing) does not specify what types and resources are visible through the context class loader when an operation is invoked on a service obtained via the service registry. Since some services may use libraries that make certain assumptions about the context class loader, Spring Dynamic Modules enables you to explicitly control the context class loader during service invocation. This is achieved using the option context-class-loader attribute of the reference element.\n\n<table>\n<thead>\n<tr>\n<th>context class loader management on the importer and exporter</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Spring-DM has the ability to do context class loader management on both the importer and exporter side. Normally, if Spring-DM works on both sides, only one side should have this feature enabled. However, if both sides (importer and exporter) take advantage of this capability, the last entity in the call chain will win. This means that the exporter setting, if enabled, will always override the importer setting (whatever that is).</td>\n</tr>\n</tbody>\n</table>\n\nThe permissible values for the context-class-loader attribute are:\n\n- **client** - during the service invocation, the context class loader is guaranteed to be able to see types on the classpath of the invoking bundle. This is the default option.\n- **service-provider** - during the service invocation, the context class loader is guaranteed to be able to see types on the classpath of the bundle exporting the service.\n- **unmanaged** - no context class loader management will occur during the service invocation\n\n6.2.1.7. reference element attributes\n\nAs a summary, the following table lists the reference element attributes names, possible values and a short description for each of them.\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Values</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>interface</td>\n<td>fully qualified class name (such as java.lang.Thread)</td>\n</tr>\n<tr>\n<td>filter</td>\n<td>OSGi filter expression (such as ((asynchronous-delivery=true))</td>\n</tr>\n<tr>\n<td>bean-name</td>\n<td>any string value</td>\n</tr>\n<tr>\n<td>context-class-loader</td>\n<td>client</td>\n</tr>\n<tr>\n<td>cardinality</td>\n<td>0..1</td>\n</tr>\n<tr>\n<td>timeout</td>\n<td>any positive long</td>\n</tr>\n</tbody>\n</table>\n\n6.2.1.8. reference and OSGi Service Dynamics\n\nThe bean defined by the reference element is unchanged throughout the lifetime of the application context (the object reference remains constant). However, the OSGi service that backs the reference may come and go.\nat any time. For a mandatory service reference (cardinality 1..1), creation of the application context will block until a matching service is available. For an optional service reference (cardinality 0..1), the reference bean will be created immediately, regardless of whether or not there is currently a matching service.\n\nWhen the service backing a reference bean goes away, Spring Dynamic Modules tries to replace the backing service with another service matching the reference criteria. An application may be notified of a change in backing service by registering a listener. If no matching service is available, then the reference is said to be unsatisfied. An unsatisfied mandatory service causes any exported service (service bean) that depends on it to be unregistered from the service registry until such time as the reference is satisfied again. See Section 6.5, “Relationship between the service exporter and service importer” for more information.\n\nWhen an operation is invoked on an unsatisfied reference bean (either optional or mandatory), the invocation blocks until the reference becomes satisfied. The optional timeout attribute of the reference element enables a timeout value (in milliseconds) to be specified. If a timeout value is specified and no matching service becomes available within the timeout period, an unchecked ServiceUnavailableException is thrown.\n\n6.2.1.9. Getting a hold of the managed service reference\n\nSpring-DM can automatically convert a managed OSGi service to service reference. That is, if the property into which a reference bean is to be injected, has type ServiceReference (instead of the service interface supported by the reference), then the managed OSGi ServiceReference for the service will be injected in place of the service itself:\n\n```java\npublic class BeanWithServiceReference {\n private ServiceReference serviceReference;\n private SomeService service;\n // getters/setters omitted\n}\n```\n\n```xml\n<reference id=\"service\" interface=\"com.xyz.SomeService\"/>\n<br:bean id=\"someBean\" class=\"BeanWithServiceReference\">\n <property name=\"serviceReference\" ref=\"service\"/>\n <property name=\"service\" ref=\"service\"/>\n</br:bean>\n```\n\n❶ Automatic managed service to ServiceReference conversion.\n\n❷ Managed service is injected without any conversion\n\nNote\n\nThe injected ServiceReference is managed by Spring-DM and will change at the same time as the referenced backing OSGi service instance.\n\nThere are cases when the managed ServiceReference is needed to get a hold of the OSGi service. Unfortunately, most of the OSGi frameworks expect their own ServiceReference classes and will fail when the Spring-DM managed reference is used. For such cases, one can get a hold of the native ServiceReference bound at that moment, by casting the reference object to ServiceReferenceProxy and then calling getTargetServiceReference. Using the example context above, one might use the following code:\n\n```java\nServiceReference nativeReference = ((ServiceReferenceProxy)serviceReference).getTargetServiceReference();\n```\n\nThe returned nativeReference can be safely passed to the OSGi framework however, since it is not managed by Spring-DM, in time, it might refer to a service different then the one backing the imported OSGi service.\nTo avoid this desynchronization, consider using managed ServiceReference objects mainly for reading the bound OSGi service properties rather than getting a hold of OSGi services (which can be simply injected by Spring-DM).\n\n### 6.2.2. Referencing a collection of services\n\n#### Natural vs custom ordering\n\nJava collection API defines two interfaces for ordering objects - Comparable and Comparator. The first is meant to be implemented by objects for providing natural ordering. String, Long or Date are good examples of objects that implement the Comparable interface.\n\nHowever, there are cases where sorting is different than the natural ordering or, the objects meant to be sort do not implement Comparable. To address this cases, Comparator interface was designed.\n\nFor more information on this subject, please consult the [Object ordering](#) chapter from Java [collection](#) tutorial.\n\nSometimes an application needs access not simply to any service meeting some criteria, but to *all* services meeting some criteria. Spring-DM allows the matching services may be held in a List or Set (optionally sorted).\n\nThe difference between using a List and a Set to manage the collection is one of equality. Two or more services published in the registry (and with distinct service ids) may be \"equal\" to each other, depending on the implementation of equals used by the service implementations. Only one such service will be present in a set, whereas all services returned from the registry will be present in a list. For more details on collections, see [this](#) tutorial.\n\nThe set and list schema elements are used to define collections of services with set or list semantics respectively.\n\nThese elements support the attributes interface, filter, bean-name, cardinality, and context-class-loader, with the same semantics as for the reference element. The allowable values for the cardinality attribute are 0..N and 1..N.\n\nA cardinality value of 0..n indicates that it is permissible for their to be no matching services. A cardinality value of 1..n indicates that at least one matching service is required at all times. Such a reference is considered a mandatory reference and any exported services from the same bundle (service defined beans) that depend on a mandatory reference will automatically be unregistered when the reference becomes unsatisfied, and reregistered when the reference becomes satisfied again.\n\nThe bean defined by a list element is of type java.util.List. The bean defined by a set element is of type java.util.Set.\n\nThe following example defines a bean of type List that will contain all registered services supporting the EventListener interface:\n\n```\n<list id=\"myEventListeners\" interface=\"com.xyz.EventListener\"/>\n```\n\nThe members of the collection defined by the bean are managed dynamically by Spring. As matching services are registered and unregistered in the service registry, the collection membership will be kept up to date. Each member of the collection supports the service interfaces that the corresponding service was registered with and\nthat are visible to the bundle.\n\nSpring-DM supports sorted collections as well, both for set and list.\n\nIt is possible to specify a sorting order using either the comparator-ref attribute, or the nested comparator element. The comparator-ref attribute is used to refer to a named bean implementing java.util.Comparator. The comparator element can be used to define an inline bean. For example:\n\n```xml\n<set id=\"myServices\" interface=\"com.xyz.MyService\"\n comparator-ref=\"someComparator\"/>\n\n<li list id=\"myOtherServices\" interface=\"com.xyz.OtherService\">\n <comparator>\n <beans:bean class=\"MyOtherServiceComparator\"/>\n </comparator>\n</list>\n```\n\nTo sort using a natural ordering instead of an explicit comparator, you can use the natural element inside of comparator. You need to specify the basis for the natural ordering: based on the service references, following the ServiceReference natural ordering defined in the OSGi Core Specification release 4, version 4.1, section 6.1.23; or based on the services themselves (in which case the services must be Comparable).\n\n```xml\n<list id=\"myServices\" interface=\"com.xyz.MyService\">\n <comparator><natural basis=\"services\" /></comparator>\n</list>\n\n<set id=\"myOtherServices\" interface=\"com.xyz.OtherService\">\n <comparator><natural basis=\"service-references\" /></comparator>\n</set>\n```\n\n**Note**\n\nFor a sorted set, a SortedSet implementation will be created. However, since the JDK API does not provide a dedicated SortedList interface, the sorted list will implement only the List interface.\n\n### 6.2.2.1. Greedy Proxying\n\nAll OSGi services imported by a Spring-DM service collection publish and are type-compatible with the classes declared by the interfaces property. However, some services might expose additional (optional) classes that could be relevant to your application.\n\nFor these cases, Spring-DM collections offer a dedicated attribute called greedy-proxying which will cause the creates proxies to use all the classes advertised by the imported services, visible to the consuming importing bundle. Thus, it is possible to cast the imported proxies to classes different then those specified in the interfaces. For example, with the following list definition:\n\n```xml\n<list id=\"services\" interface=\"com.xyz.SomeService\" greedy-proxying=\"true\"/>\n```\n\none can do the following iteration (assuming MessageDispatcher type is imported by the bundle):\n\n```java\nfor (Iterator iterator = services.iterator(); iterator.hasNext();) {\n SomeService service = (SomeService) iterator.next();\n service.executeOperation();\n // if the service implements an additional type\n // do something extra\n if (service instanceof MessageDispatcher) {\n ((MessageDispatcher)service).sendAckMessage();\n }\n}\n```\nNote\nBefore using greedy proxies and `instanceof` statements, consider using a different interface/class for your services which provides better polymorphism and is more object-oriented.\n\n6.2.2.2. Collection (`list` and `set`) element attributes\n\n`list` and `set` elements support all the attributes available to `reference` element except the `timeout` attribute. See the following table as a summary of the `list` and `set` element attribute names, possible values and a short description for each of them.\n\nTable 6.3. `<list>`/`<set>` attributes\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Values</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>interface</td>\n<td>fully qualified class name (such as <code>java.lang.Thread</code>)</td>\n<td>The fully qualified name of the class under which the object will be exported.</td>\n</tr>\n<tr>\n<td>filter</td>\n<td>OSGi filter expression (such as <code>((asynchronous-delivery=true))</code>)</td>\n<td>OSGi filter expression that is used to constrain the set of matching services in the service registry.</td>\n</tr>\n<tr>\n<td>bean-name</td>\n<td>any string value</td>\n<td>Convenient shortcut for specifying a filter expression that matches on the bean-name property that is automatically advertised for beans published using the <code><service></code> element.</td>\n</tr>\n<tr>\n<td>context-class-loader</td>\n<td>client</td>\n<td>service-provider</td>\n</tr>\n<tr>\n<td>Name</td>\n<td>Values</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>------------</td>\n<td>--------</td>\n<td>--------------------------------------------------------------------------------------------------------------------------------------------</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>default value is <code>client</code> which means that the context class loader has visibility of the resources on this bundle's classpath. Alternate options are <code>service-provider</code> which means that the context class loader has visibility of resources on the bundle classpath of the bundle that exported the service, and <code>unmanaged</code> which does not do any management of the context class loader.</td>\n</tr>\n<tr>\n<td>cardinality</td>\n<td>0..N</td>\n<td>1..N</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Defines the required cardinality of the relationship to the backing service. If not specified, the <code>default-cardinality</code> attribute will apply. A value is '1..N' means that a backing service must exist (this is a mandatory service reference). A value of '0..N' indicates that it is acceptable to be no backing service (an optional service)</td>\n</tr>\n</tbody>\n</table>\nThe table below lists the attributes available for the `<comparator>` sub element.\n\nTable 6.4. collection `<comparator>` attributes\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Values</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>comparator-ref</td>\n<td>any string value</td>\n<td>Named reference to a bean acting as comparator for the declaring collection. Declaring a comparator automatically makes the declaring collection sorted.</td>\n</tr>\n<tr>\n<td>greedy-proxying</td>\n<td>true/false</td>\n<td>Indicates whether the proxies created for the imported OSGi services will be generated using just the classes specified (false) or all the classes exported by the service and visible to the importing bundle (true). The default value is false.</td>\n</tr>\n</tbody>\n</table>\n\nThe Service Registry\n\n6.2.2.3. `list` / `set` and OSGi Service Dynamics\n\nA collection of OSGi services will change its content during the lifetime of the application context since it needs to reflect the state of the OSGi space. As service are registered and unregistered, they will be added or removed from the collection.\n\nWhile a `reference` declaration will try to find a replacement if the backing service is unregistered, the\ncollection will simply remove the service from the collection. Like reference, a collection with cardinality $1..N$ is said to be mandatory while a collection with cardinality $0..N$ is referred to as being optional. If no matching service is available then only mandatory collections become unsatisfied. That is if no service is available invoking an operation on:\n\n- mandatory collection - will throw an unchecked ServiceUnavailableException.\n- optional collection - will not throw any exceptions (however the collection will be empty).\n\nJust like reference, mandatory collections will trigger the unregistration of any exported service that depends upon it. See Section 6.5, “Relationship between the service exporter and service importer” for more information.\n\n6.2.2.4. Iterator contract and service collections\n\nThe recommend way of traversing a collection is by using an Iterator. However, since OSGi services can come and go, the content of the managed service collection will be adjusted accordingly. Spring-DM will transparently update all Iterators held by the user so it is possible to safely traverse the collection while it is being modified. Moreover, the Iterators will reflect all the changes made to the collection, even if they occurred after the Iterators were created (that is during the iteration). Consider a case where a collection shrinks significantly (for example a big number of OSGi services are shutdown) right after an iteration started. To avoid dealing with the resulting 'dead' service references, Spring-DM iterators do not take collection snapshots (that can be inaccurate) but rather are updated on each service event so they reflect the latest collection state, no matter how fast or slow the iteration is.\n\nIt is important to note that a service update will only influence Iterator operations that are executed after the event occurred. Services already returned by the iterator will not be updated even if the backing service has been unregistered. As a side note, if an operation is invoked on such a service that has been unregistered, a ServiceUnavailableException will be thrown.\n\nTo conclude, while a reference declaration will search for candidates in case the backing service has been unregistered, a service collections will not replace unregistered services returned to the user. However, it will remove the unregistered services from the collection so future iterations will not encounter them.\n\nPlease note that the Iterator contract is guaranteed meaning that next() method always obey the result of the previous hasNext() invocation.\n\nTable 6.5. Dynamic service collection Iterator contract\n\n<table>\n<thead>\n<tr>\n<th>hasNext() returned value</th>\n<th>next() behaviour</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>true</td>\n<td>Always return a non-null value, even when the collection has shrunk as services when away.</td>\n</tr>\n<tr>\n<td>false</td>\n<td>per Iterator contract, NoSuchElementException is thrown. This applies even if other services are added to the collection</td>\n</tr>\n</tbody>\n</table>\n\nThe behaviour described above, offers a consistent view over the collection even if its structure changes during iteration. To simply refresh the iterator, call hasNext() again. This will force the Iterator to check again the collection status for its particular entry in the iteration.\n\nIn addition, any elements added to the collection during iteration over a sorted collection will only be visible if\nthe iterator has not already passed their sort point.\n\n### 6.2.3. Dealing with the dynamics of OSGi imported services\n\nWhether you are using `reference` or `set` or `list`, Spring Dynamic Modules will manage the backing service. However there are cases where the application needs to be aware when the backing service is updated.\n\nSuch applications, that need to be aware of when the service backing a `reference` bean is bound and unbound, can register one or more listeners using the nested `listener` element. This element is available on both `reference` and `set`, `list` declarations. In many respects, the service importer listener declaration is similar to the service exporter listener declaration (Section 6.1.7, “Service registration and unregistration lifecycle”). The `listener` element refers to a bean (either by name, or by defining one inline) that will receive bind and unbind notifications. If this bean implements Spring-DM’s `org.springframework.osgi.service.importer.OsgiServiceLifecycleListener` interface, then the bind and unbind operations in this interface will be invoked. Instead of implementing this interface (or in addition), custom bind and unbind callback methods may be named.\n\nAn example of declaring a listener that implements `OsgiServiceLifecycleListener`:\n\n```xml\n<reference id=\"someService\" interface=\"com.xyz.MessageService\">\n <listener ref=\"aListenerBean\"/>\n</reference>\n```\n\nAn example of declaring an inline listener bean with custom bind and unbind methods:\n\n```xml\n<reference id=\"someService\" interface=\"com.xyz.MessageService\">\n <listener bind-method=\"onBind\" unbind-method=\"onUnbind\">\n <beans:bean class=\"MyCustomListener\"/>\n </listener>\n</reference>\n```\n\nIf the listener bean implements the `OsgiServiceLifecycleListener` interface and the listener definition specifies custom bind and unbind operations then both the `OsgiServiceLifecycleListener` operation and the custom operation will be invoked, in that order.\n\nThe signature of a custom bind or unbind method must be one of:\n\n```java\npublic void anyMethodName(ServiceType service, Dictionary properties);\npublic void anyMethodName(ServiceType service, Map properties);\npublic void anyMethodName(ServiceReference ref);\n```\n\nwhere `ServiceType` can be any type. Please note that bind and unbind callbacks are invoked only if the backing service matches the type declared in the method signature(`ServiceType`). If you want the callbacks to be called no matter the type, use `java.lang.Object` as a `ServiceType`.\n\nThe `properties` parameter contains the set of properties that the service was registered with.\n\nIf the method signature has a single argument of type `ServiceReference` then the `ServiceReference` of the service will be passed to the callback in place of the service object itself.\n\nWhen the listener is used with a `reference` declaration:\n\n- A `bind` callback is invoked when the reference is initially bound to a backing service, and whenever the backing service is replaced by a new backing service.\n• An *unbind* callback is only invoked when the current backing service is unregistered, and no replacement service is immediately available (i.e., the reference becomes unsatisfied).\n\nWhen the listener is used with a collection declaration (set or list):\n\n• A *bind* callback is invoked when a new service is added to the collection.\n\n• An *unbind* callback is invoked when a service is unregistered and is removed from the collection.\n\nAgain note that service collections there is no notion of *service rebind*: services are added or removed from the collection.\n\nBind and unbind callbacks are made synchronously as part of processing an OSGi `serviceChanged` event for the backing OSGi service, and are invoked on the OSGi thread that delivers the corresponding OSGi `ServiceEvent`.\n\nThe table below lists the attributes available for the `reference listener` sub element.\n\n**Table 6.6. OSGi `<listener>` attributes**\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Values</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ref</td>\n<td>bean name reference</td>\n<td>Name based reference to another bean acting as listener.</td>\n</tr>\n<tr>\n<td>bind-method</td>\n<td>string representing a valid method name</td>\n<td>The name of the method to be invoked when a backing service is bound.</td>\n</tr>\n<tr>\n<td>unbind-method</td>\n<td>string representing a valid method name</td>\n<td>The name of the method to be invoked when a backing service is bound.</td>\n</tr>\n</tbody>\n</table>\n\n**6.2.4. Listener and service proxies**\n\nWhile the importer listener provides access to the OSGi service bound at a certain point, it is important to note that the given argument is *not* the actual service but a *proxy*. This can have subtle side effects especially with regards to service class name and identity. The reason behind using a proxy is to prevent the listener from holding strong reference to the service (which can disappear at any point). Listeners interested in tracking certain services should not rely on instance equality (=). Object equality (equals/hashcode) can be used but only if the backing service has exposed the aforementioned methods as part of its contract (normally by declaring them on a certain published interface/class). If these methods are not published, the proxy will invoke its own method, not the targets. This is on purpose since, while the proxy tries to be as transparent as possible, it is up to the developer to define the desired semantics.\n\nThus, it is recommended (especially for reference importers) to do tracking based on just the service interface/contract (not identity), service properties (see `org.osgi.framework.Constants#SERVICE_ID`) or service notification (bind/unbind).\n\n**6.2.5. Accessing the caller BundleContext**\nIt is sometimes useful for an imported service to know which bundle is using it at a certain time. To help with this scenario, in Spring-DM imported services publish the importing bundle BundleContext through LocalBundleContext class. Each time a method on the importer is invoked, the caller BundleContext will be made available, using a ThreadLocal, through getInvokerBundleContext().\n\nPlease be careful when using this class since it ties your code to Spring-DM API.\n\n6.3. Exporter/Importer listener best practices\n\nAs mentioned above, Spring-DM exporter and importer allow listeners to be used for receiving notifications on when services are bound, unbound, registered or unregistered. Below you can find some guidance advices when working with listeners:\n\n- Do not execute long activity tasks inside the listener. If you really have to, use a separate thread for executing the work. The listener are called synchronously and so try to be as fast as possible. Doing work inside the listener prevents other the event to be sent to other listeners and the OSGi service to resume activity.\n\n- Use listener custom declaration as much as possible - it doesn't tie your code to Spring-DM API and it doesn't enforce certain signature names.\n\n- If find yourself repeating bind/unbind method declarations for your listener definitions, consider using Spring bean definition inheritance to define a common definition that can be reused and customized accordingly.\n\n- Prefer java.util.Map instead of java.util.Dictionary class. The first is an interface while the latter is a deprecated, abstract class. To preserve compatibility, Spring-DM will pass to the listeners a Map implementation that can be casted, if needed, to a Dictionary.\n\n- Be careful when using overloaded methods: all methods matching a certain service type will be called which is not always expected. Consider the following listener:\n\n```java\npublic class MyListener {\n void register(Object service, Map properties);\n void register(Collection dataService, Map properties);\n void register(SortedSet orderedDataService, Map properties);\n}\n```\n\n1. Object type - will match all services for which the listener is triggered. This method will be always called.\n2. Collection type - if this method is called, the Object method is also called.\n3. SortedSet type - if this method is called, then both the Object and Collection methods are called.\n\n6.3.1. Listener and cyclic dependencies\n\nThere are cases where an exporter/importer listener needs a reference back to the bean it is defined on:\n\n```xml\n<bean id=\"listener\" class=\"cycle.Listener\">\n <property name=\"target\" ref=\"importer\" />\n</bean>\n< osgi:reference id=\"importer\" interface=\"SomeService\">\n```\n\n1. Object - will match all services for which the listener is triggered. This method will be always called.\n2. Collection - if this method is called, the Object method is also called.\n3. SortedSet - if this method is called, then both the Object and Collection methods are called.\nThe declaration above while valid, creates a dependency between the `listener` and the importer it is defined upon. In order to create the importer, the `listener` has to be resolved and created but in order to do that, the importer called `service` needs to be retrieved (instantiated and configured). This cycle needs to be broken down so that at least one bean can be fully created and configured. This scenario is supported by Spring-DM for both exporter and importers however, if the listener is defined as a nested bean, the cycle cannot be resolved:\n\n```\n<osgi:reference id=\"importer\" interface=\"SomeService\">\n<osgi:listener bind-method=\"bind\">\n <bean class=\"cycle.Listener\">\n <property name=\"target\" ref=\"importer\" />\n </bean>\n</osgi:listener>\n</osgi:reference>\n```\n\n1. OSGi service importer\n2. Dependency between importer -> listener\n3. Nested listener declaration\n4. Dependency nested listener -> importer\n\n**Beans and Cycles**\n\nCyclic dependencies (A depends on B which depends back on A) increase the complexity of your configuration and in most cases indicate a design issue. What beans should be created and destroyed first for example? While they are a bad practice, the Spring container makes a best attempt to solve the cyclic configurations when singletons are involved (since the instances can be cached). However this does not work all the time and depends heavily on your specific configuration (Can the bean class be partially initialized? Does it rely on special Aware interfaces? Are BeanPostProcessor involved?)\n\nThe example above will fail since `service` bean cannot be initialized as it depends on the listener. The same cycle was seen before but in this case there is subtle yet big different from the container perspective - the listener is declared as a nested/inner-bean (hence the missing bean `id`). Inner beans have the same life cycle as their declaring parents and do not have any name. By definition, they are not tracked by the container and are simply created on demand. Since the importer cannot be partially created and the nested listener cannot be cached, the container cannot break the cycle and create the beans. While the two configurations shown above seem similar, one works while the other does not. Another reason to not use cycles unless you really, really have to.\n\nTo conclude, if you need inside the listener to hold a reference to the exporter/importer on which the listener is declared, either declare the listener as a top-level bean (as shown before) or consider doing dependency lookup. However, the latter approach requires extra contextual information such as the BeanFactory to use and the bean name and is more fragile then dependency injection.\n\n**Note**\n\nFor those interested in the technical details, neither the exporter and importer cannot be partially\ninitialized since they require the application context ClassLoader which is requested through the BeanClassLoaderAware which relies on a built-in BeanPostProcessor which is applied only after the bean has been configured and is ready for initialization. If the ClassLoader was not required then the exporter/importer could have been partially initialized and the case above supported.\n\n6.4. Service importer global defaults\n\nThe osgi namespace offers two global attributes for specifying default behaviours for all importers declared in that file.\n\nThus, when using the osgi namespace to enclose set, list or reference elements, one can use:\n\n- **default-timeout** - can be used to specify the default timeout (in milliseconds) for all importer elements that do not explicitly specify one. For example:\n\n```\n<beans xmlns=\"http://www.springframework.org/schema/beans\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xmlns:osgi=\"http://www.springframework.org/schema/osgi\"\n osgi:default-timeout=\"5000\">\n <reference id=\"someService\" interface=\"com.xyz.AService\"/>\n <reference id=\"someOtherService\" interface=\"com.xyz.BService\" timeout=\"1000\"/>\n</beans>\n```\n\n1. Declare osgi namespace prefix.\n2. Declare default-timeout (in milliseconds) on the root element. If the default is not set, it will have a value of 5 minutes. In this example, the default value is 5 seconds.\n3. This reference will inherit the default timeout value since it does not specify one. This service reference will have a timeout of 5 seconds.\n4. This reference declares a timeout, overriding the default value. This service reference will have a timeout of 1 second.\n\n- **default-cardinality** - can be used to specify the default cardinality for all importer elements that do not explicitly specify one. Possible values are 0..1 and 1..x where x is substituted at runtime to 1 for reference elements or N for collection types such as set or list.\n\nConsider the following example:\n\n```\n<beans xmlns=\"http://www.springframework.org/schema/osgi\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xmlns:beans=\"http://www.springframework.org/schema/beans\"\n xmlns:osgi=\"http://www.springframework.org/schema/osgi\"\n osgi:default-cardinality=\"0..X\"\n default-lazy-init=\"false\">\n <reference id=\"someService\" interface=\"com.xyz.AService\"/>\n <set id=\"someSetOfService\" interface=\"com.xyz.BService\"/>\n <list id=\"anotherListOfServices\" interface=\"com.xyz.CService\" cardinality=\"1..N\"/>\n</beans>\n```\n\n1. Declare osgi namespace prefix.\n2. Declare default-cardinality on the root element. If the default is not set, it will have a value of 0..X. In this example, the default value is 0..X.\n3. This reference will inherit the default cardinality value since it does not specify one. This service reference will have a cardinality of 1..X.\n4. This reference declares a cardinality, overriding the default value. This service reference will have a cardinality of 1..N.\n1. Declare Spring Dynamic Modules schema as the default namespace.\n2. Import Spring Framework beans schema and associate a prefix with its namespace (beans in this example).\n3. Import Spring Dynamic Modules schema and associate a prefix with its namespace (osgi in this example). This is required since the global attributes have to be declared to an element (beans) belonging to another schema. To avoid ambiguity, the Spring-DM schema is imported under a specified prefix as well.\n4. Declare default-cardinality on the root element. If the default is not set, it will have a value of 1..N. In this example, the default value is 0..N. Note the osgi prefix added to the global attribute.\n5. beans element attributes (such as default-lazy-init) do not need a prefix since they are declared as being local and unqualified (see the beans schema for more information).\n6. The reference declaration will inherit the default cardinality value since it does not specify one. As reference represents a single service, its cardinality will be 0..1.\n7. The set declaration will inherit the default cardinality value since it does not specify one. As set (or list) represents a collection of service, its cardinality will be 0..N.\n8. The list declaration specifies its cardinality (1..N), overriding the default value.\n\nThe default-* attributes allow for concise and shorter declarations as well as easy propagation of changes (such as increasing or decreasing the timeout).\n\n6.5. Relationship between the service exporter and service importer\n\nAn exported service may depend, either directly or indirectly, on other services in order to perform its function. If one of these services is considered a mandatory dependency (has cardinality 1..x) and the dependency can no longer be satisfied (because the backing service has gone away and there is no suitable replacement available) then the exported service that depends on it will be automatically unregistered from the service registry - meaning that it is no longer available to clients. If the mandatory dependency becomes satisfied once more (by registration of a suitable service), then the exported service will be re-registered in the service registry.\n\nThis automatic unregistering and re-registering of exported services based on the availability of mandatory dependencies only takes into account declarative dependencies. If exported service S depends on bean A, which in turn depends on mandatory imported service M, and these dependencies are explicit in the Spring configuration file as per the example below, then when M becomes unsatisfied S will be unregistered. When M becomes satisfied again, S will be re-registered.\n\n```xml\n<osgi:service id=\"S\" ref=\"A\" interface=\"SomeInterface\"/>\n<bean id=\"A\" class=\"SomeImplementation\">\n <property name=\"helperService\" ref=\"M\"/>\n</bean>\n<osgi:reference id=\"M\" interface=\"HelperService\" cardinality=\"1..1\"/>\n```\n\nIf however the dependency from A on M is not established through configuration as shown above, but instead at runtime through for example passing a reference to M to A without any involvement from the Spring container, then Spring Dynamic Modules will not track this dependency.\nChapter 7. Working with Bundles\n\nSpring-DM offers a dedicated schema element for interacting with existing bundles or for installing new ones. While it is not intended to be used as a replacement for proper OSGi services, the bundle element offers a very easy way of executing actions on bundles based on the lifecycle of the application context.\n\nThe bundle element defines a bean of type org.osgi.framework.Bundle. It provides a simple way to work directly with bundles, including driving their lifecycle. In the simplest case all you need to do is specify the symbolic-name of the bundle you are interested in:\n\n```xml\n<bundle id=\"aBundle\" symbolic-name=\"org.xyz.abundle\"/>\n```\n\nThe bean aBundle can now be injected into any property of type Bundle.\n\nIf the needed bundle is not installed, one can use location attribute to indicate install or/and the action/destroy-action attributes provide declarative control over the bundle's lifecycle. The location attribute is used to specify a URL where the bundle jar file artifact can be found. The action attribute specifies the lifecycle operation to be invoked on the bundle object. The supported action values are install, start, update, stop, and uninstall. These actions have the same semantics as the operations of the corresponding names defined on the Bundle interface (see the OSGi Service Platform Core Specification), with the exception that pre-conditions are weakened to allow for example a start action to be specified against a bundle that is not currently installed (it will be installed first).\n\nThe following table shows how actions are interpreted for the given Bundle states:\n\n**Table 7.1. <bundle> action values**\n\n<table>\n<thead>\n<tr>\n<th>Action</th>\n<th>UNINSTALLED</th>\n<th>INSTALLED/RESOLVED</th>\n<th>ACTIVE</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>START</td>\n<td>installs and starts the bundle</td>\n<td>starts the bundle</td>\n<td>no action taken, bundle already started</td>\n</tr>\n<tr>\n<td>UPDATE</td>\n<td>installs the bundle and then updates it ('Bundle.update()')</td>\n<td>updates the bundle</td>\n<td>updates the bundle</td>\n</tr>\n<tr>\n<td>STOP</td>\n<td>no action taken</td>\n<td>no action taken</td>\n<td>bundle is stopped</td>\n</tr>\n<tr>\n<td>UNINSTALL</td>\n<td>no action taken</td>\n<td>bundle is uninstalled</td>\n<td>bundle is stopped and then uninstalled</td>\n</tr>\n</tbody>\n</table>\n\nFor example:\n\n```xml\n<!-- ensure this bundle is installed and started -->\n<bundle id=\"aBundle\" symbolic-name=\"org.xyz.abundle\"\n location=\"http://www.xyz.com/bundles/org.xyz.abundle.jar\"\n action=\"start\"/>\n```\n\nThe following table lists the bundle element attributes names, possible values and a short description for each of them:\n\n**Table 7.2. <bundle> attributes**\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Values</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>symbolic-name</td>\n<td>any valid symbolic-name String</td>\n<td>The symbolic name of the bundle object. Normally used when interacting with an already installed bundle.</td>\n</tr>\n<tr>\n<td>location</td>\n<td>String that can be converted into an URL</td>\n<td>Location used to install, update or/and identify a bundle.</td>\n</tr>\n<tr>\n<td>action</td>\n<td>start stop install uninstall update</td>\n<td>Lifecycle action to drive on the bundle. The action is executed at startup.</td>\n</tr>\n<tr>\n<td>destroy-action</td>\n<td>(same as action)</td>\n<td>Lifecycle action to drive on the bundle. The action is executed at shutdown.</td>\n</tr>\n</tbody>\n</table>\n\nThe samples that ship with the Spring Dynamic Modules project include further support for a virtual-bundle element that can be used to create and install OSGi bundles on the fly from existing artifacts.\nChapter 8. Web Support\n\nOSGi bundles and WARs\n\nWeb ARchives, or in short WARs, are specialized JAR for packaging web applications. Since the same archive format is used (Java ARchive), each war can be considered an OSGi bundle if the proper OSGi manifest entries are present. Note that it is not required for a bundle to have a .jar file extension, which means .war files can be installed just as well.\n\nA major feature introduced in the 1.1.0 release is support for web applications which enables easy deployment of web artifacts to OSGi.\n\nThe biggest problems in running web applications in OSGi involve resource and class loading; there is no notion of bundle space or imported packages in a web application. Each web container has its own class loading hierarchy and classpath assumption which can conflict with the OSGi space. Spring-DM addresses these problems by bridging the web container and the OSGi space so loading is no longer a concern. Unique in its functionality, the web support in Spring-DM integrates directly with the web container so the WAR processing is literally handled by the server, giving full access to its configuration and capabilities (non-blocking vs blocking IO, thread pool, specification support (Servlet 2.3, 2.4, 2.5) and so on). The entire web.xml syntax is supported (without any parsing on Spring-DM behalf), as well as any custom configuration file particular to the target container. In short, everything that the target container supports is available to the OSGi WAR through Spring-DM.\n\nTip\nAs a complement to this chapter, the Spring-DM distribution contains a number of web samples involving static resources, Servlets and JSPs running inside OSGi.\n\nNote\nFor more information on web applications on Java platform, please see the Servlet home page.\n\n8.1. Supported Web Containers\n\nCurrently, Spring-DM supports Apache Tomcat 5.5.x/6.0.x and Jetty 6.1.8+/6.2.x out of the box (other containers can be easily plugged in). The web support is JDK 1.4 compatible. Please check the chosen container requirements for more information on the required JVM. In general, Servlet 2.4/JSP 2.0 require JDK 1.4 while Servlet 2.5/JSP 2.1 require JDK 1.5.\n\n8.2. Web support usage\n\nWAR vs Web Application\n\nThis document understand by web application an instance of a WAR: a WAR is a definition while a web application a runtime instance of a definition. This is similar to the difference between a class and an object: the class represents a (bytecode) definition while the object, the instance of a class.\nJust like with non-WAR bundles, Spring-DM Web uses the extender pattern to detect and install WARs. However, one crucial difference from the standard Spring-DM Extender is that Spring-DM will only trigger the install and uninstall of the WAR - the actual web application creation and thread management is delegated to the web container in which the WAR is installed. That is, Spring-DM Web only dictates when a WAR is deployed to and undeployed from a web container; it is up to the web container to create and manage the equivalent web application.\n\nTo use Spring-DM Web, install:\n\n- `spring-osgi-web.jar` - Spring-DM web support\n- `spring-osgi-web-extender.jar` - Spring-DM web extender\n\nbundles to detect started OSGi WAR bundles (bundles with `.war` extension) and to deploy them to one of the supported web containers. By default, Tomcat will be used but this can be changed to Jetty or to another custom server. When the war bundle is stopped, Spring-DM will also stop and uninstall the web application associated with it. Different from traditional web development, the Servlet classes need to be explicitly imported as the OSGi class path always takes priority (see below).\n\nSince, when running a web application, it's the web container that does the bootstrapping and instantiation, there is no need to place the Spring .xml files under `META-INF/spring` or use the Spring-DM manifest entries. Simply bundle your files in the WAR and use your web framework (or `Servlets/Listeners`) to bootstrap the Spring container. See Section 8.7, “Spring-MVC Integration” for Spring-MVC integration and/or Spring reference documentation for more information. These being said, the Spring Extender is still required as it performs namespace handlers discovery - without it, it would not be possible to use Spring namespaces (like `osgi:`, `aop:` or even `beans:` for that matter).\n\n### 8.3. WAR classpath in OSGi\n\nThe servlet specification defines a number of rules and locations which special meaning inside a WAR. This section will explain how these are handled in an OSGi environment.\n\n#### 8.3.1. Static Resources\n\nWhen installing a WAR bundle, for static resources, Spring-DM will only consider what is available in the bundle space - this means what is available in the bundle jar and its attached fragments. Conforming to the Servlet spec, resources under `WEB-INF` folder will be available through the `ServletContext` API but not to remote clients connecting to the web application. In addition, any resource available in the classpath (imported packages, required bundles or dynamic imports) can be loaded and used by the application code but cannot be seen outside of it.\n\n#### 8.3.2. Servlets\n\nThe main difference from the traditional WAR deployment is that the Servlet packages need to be imported so they are available to the WAR bundle. To do that, add the following packages to the `Import-Package` entry:\n\n```\nImport-Package: javax.servlet, javax.servlet.http, javax.servlet.resources\n```\n\nAdditionally, the servlet specification defines the classpath of a WAR, based on some predefined locations. To quickly recap, these are:\n• WEB-INF/classes - all resources under WEB-INF/classes\n• WEB-INF/lib/*.jar - all jars under WEB-INF/lib\n\nIn addition, each container implementation can provide common libraries that are appended to the war classpath. Since OSGi, with its class wiring, versioning, reloading, superseeds the WAR classpath, Spring-DM will ignore the WAR predefined locations and will always use the OSGi classpath instead. This means that classes imported by a WAR bundle can be used even if they are not present under WEB-INF/classes folder or inside a jar under WEB-INF/lib. This also means that any class under WEB-INF/classes will not be considered if it's not available in the WAR OSGi classpath.\n\nOne of the easiest ways to support the pre-defined WAR locations, is to add them to the bundle classpath, by adding them to the bundle manifest:\n\n```\nBundle-Classpath: .,WEB-INF/classes,WEB-INF/lib/some.jar,WEB-INF/lib/lib.jar\n```\n\nMake sure the default Bundle-Classpath location (.) is present and there are no whitespaces between the commas.\n\n**Note**\nSince the OSGi API doesn't provide a hook for bundles to be pre-processed, Spring-DM cannot automate this process in a reliable way. However, we are working on finding a suitable solution. Note that there are tools (bnd) that can add these entries during packaging.\n\nBefore creating entries for embedded libraries, consider whether they can be installed as OSGi bundles - doing so allows them to be shared with other WARs if needed and since OSGi allows versioning, it is perfectly okay to have multiple versions of the same library inside the same VM.\n\n### 8.3.3. Java Server Pages\n\nFor JSPs, Spring-DM integrates with Tomcat Jasper 2 Engine which means JSP 1.2, 2.0 and 2.1 are supported. OSGified versions for Jasper (from Tomcat 5.5.x and 6.0.x distribution respectively) are available in the Spring-DM OSGi repository. No imports on Jasper classes are required for the OSGi bundle.\n\n#### 8.3.3.1. Tag libraries\n\nThe JSP spec allows the creation of tag libraries to “define declarative, modular functionality that can be reused by any JSP page”. Also known as taglibs, these reusable components consist of Java classes (the tag implementation) and description files that indicate how the tags can be used. Spring-DM extends the JSP convention, of placing the taglibs either packed as a jar under WEB-INF/lib or unpacked under WEB-INF/classes, by detecting any taglib defined in the bundle classpath (imported packages or required bundles).\n\nSpring-DM will automatically look for any taglib file (*.tld) available in the bundle classpath and will make them available to the Jasper engine. However, while the tag definitions are automatically discovered, the tag classes are not - again, the OSGi classpath takes priority. This means that in order to use a tag, the war bundle would have to import the tag corresponding classes since otherwise, they are not seen by the bundle and the tag cannot be used.\n\nWhen dealing with libraries that export a lot of tags, one can use the Require-Bundle header instead of Import-Package for importing the tags:\nUsing the manifest entry above, all the classes (and thus tag implementations) exported by the JSP Standard Tag Library (or JSTL, in short), are seen by the war bundle and thus can be used inside the JSPs.\n\n**Warning**\nBefore using `Require-Bundle` on a large scale, please read the OSGi specification (section 3.13) for an in-depth review of its implications.\n\nNo matter what mechanism you decide to use for the war classpath, due to the OSGi capabilities, it is possible to create libraries that are *shared* between multiple WARs while having full control over the used packages. Each bundle can import only the packages (and the versions) needed not an entire library jar - in fact, packages from different bundles/jars can be selectively used to obtain the desired behaviour - a very powerful capability which should make web application deployment easier.\n\n### 8.4. Configuring the web extender\n\nJust like the core extender, the web extender can be configured by using OSGi fragments. Following a similar pattern, the web extender looks for all XMLs under `META-INF/spring/extender` folder in its bundle space and assembles them into an application context that is used internally as its configuration. To override a default setting of the web extender, look up the appropriate bean name from the table below, define it in a suitable manner and then attach it as a fragment to the `spring-osgi-web.jar`, using:\n\n```\nFragment-Host: org.springframework.bundle.osgi.web.extender\n```\n\nThe following beans are currently recognized by the web extender:\n\n<table>\n<thead>\n<tr>\n<th>Bean Name</th>\n<th>Type</th>\n<th>Role</th>\n<th>Default Class</th>\n<th>Default Behaviour</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>warDeployer</td>\n<td>WarDeployer</td>\n<td>Installs OSGi bundles as web applications. The deployers take care of locating the required web container and installing and uninstalling web applications.</td>\n<td>TomcatWarDeployer</td>\n<td>Installs OSGi WARs to Tomcat 5.5.x/6.0.x. The servers needs to be installed, started and published as OSGi services as explained <a href=\"#\">here</a>.</td>\n</tr>\n<tr>\n<td>contextPath</td>\n<td>ContextPath</td>\n<td>Determines the context path associated with an OSGi bundle/WAR. The returned path is used by the war deployer to install the war application.</td>\n<td>DefaultContextPath</td>\n<td>Returns the context path of the war bundle based on the <code>Web-ContextPath</code> manifest header or (if missing), the file name from the bundle location, falling back to the bundle name and bundle symbolic name respectively. If neither of these is present, the bundle object identity will be used.</td>\n</tr>\n</tbody>\n</table>\n\n*Part of `org.springframework.osgi.web.deployer` package\n\n*Part of `org.springframework.osgi.web.deployer.tomcat` package\n\n*Part of `org.springframework.osgi.web.deployer.support` package\nNote that to properly support wars, whether they are using Servlet 2.5 or not, the Spring-DM web extender considers as WARs bundles that contains a .war extension.\n\n### 8.4.1. Changing the war deployer\n\nTo change the Tomcat deployer to Jetty for example, one can create a configuration file `META-INF/spring/extender/jetty-deployer.xml` with the following content:\n\n```xml\n<beans xmlns=\"http://www.springframework.org/schema/beans\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xsi:schemaLocation=\"http://www.springframework.org/schema/beans\n http://www.springframework.org/schema/beans/spring-beans.xsd\">\n <bean id=\"warDeployer\" class=\"org.springframework.osgi.web.deployer.jetty.JettyWarDeployer\"/>\n</beans>\n```\n\n1. **Pre-defined** bean name used by the web extender\n2. **Bean implementing** `org.springframework.osgi.web.deployer.WarDeployer` interface\n\nOnce the file is created, it should be bundled in an OSGi fragment attached to the Spring-DM Web Extender bundle by adding the `Fragment-Host` header:\n\n```\nFragment-Host: org.springframework.bundle.osgi.web.extender\n```\n\nNow the fragment can be deployed alongside `spring-osgi-web.jar` bundle to plug in Jetty.\n\nA pre-packed Jetty fragment is available in the Spring-DM [maven repository](https://mvnrepository.com/artifact) under `jetty.web.extender.fragment.osgi` artifactId.\n\n### 8.5. Customizing the standard deployers\n\nBy default, the out of the box deployers look up the needed services, at startup. As the services are considered mandatory, the deployers will wait for them and, in case they are not found, will throw an exception. In cases where the default timeout or service lookup filter is not be appropriate, one can customize the service used through a Spring-DM reference:\n\n```xml\n<beans xmlns=\"http://www.springframework.org/schema/beans\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xmlns:osgi=\"http://www.springframework.org/schema/osgi\"\n xmlns:p=\"http://www.springframework.org/schema/p\"\n xsi:schemaLocation=\"http://www.springframework.org/schema/beans\n http://www.springframework.org/schema/beans/spring-beans.xsd\n http://www.springframework.org/schema/osgi\n http://www.springframework.org/schema/osgi/spring-osgi.xsd\">\n <osgi:reference id=\"myTomcatServer\" interface=\"org.apache.catalina.Service\"\n filter=\"(environment=testing)\"\n cardinality=\"0..1\"/>\n\n <bean id=\"warDeployer\" class=\"org.springframework.osgi.web.deployer.tomcat.TomcatWarDeployer\"\n p:service-ref=\"myTomcatServer\"/>\n</beans>\n```\n8.6. OSGi-ready libraries and web development\n\nUnfortunately, at the moment most libraries used for web development are not OSGi bundles, which means they cannot be used inside the OSGi space unless they are embedded in other bundles. To address this problem, the Spring-DM project has osgified most of the common libraries and made them available through a dedicated Maven repository (which can be found in the appendix). Please note that the current repository, for now, is provided as-is without any support. These being said, we hope you find it useful.\n\n8.6.1. Deploying web containers as OSGi bundles\n\nSpring-DM web support expects the web containers to be installed as OSGi services. Since neither the Tomcat nor the Jetty distribution do this, Spring-DM offers two simple yet useful OSGi Activators for both containers at the Spring-DM OSGi repository. Once installed, these will programmatically start the appropriate web container based on a default configuration (which can be customized and publish it as an OSGi service. While the activators are generic, they can be easily customized for advanced usages or even replaced - it's up to each deployer to decide how the server instances are looked up.\n\nNote\n\nThe activator binaries and sources can be found either in the Spring-DM repository (see below) or under the lib/ folder inside the Spring-DM (with-dependencies) distribution\n\nAll entries in the repository belong to the org.springframework.osgi group and have an .osgi termination to differentiate them from the original jars.\n\n8.6.1.1. Tomcat 5.5.x/6.0.x\n\nApache Tomcat version 5.5.x and 6.0.x are available as OSGi artifacts in the repository under catalina.osgi artifactId. The jars require only commons-logging, JMX and Servlet/JSP libraries to be present.\n\nIn addition to the Catalina artifacts, the repository contains also a Tomcat activator (that works with both 5.5.x and 6.0.x versions) named catalina.osgi.start. The activator understands Tomcat XML configuration and contains a default, minimal setup that starts the server on localhost, port 8080. This behaviour can be customized by placing the desired configuration (which will override the default one) under conf/server.xml location (following the Tomcat folder layout) in a fragment attached to the Tomcat activator.\n\nTo attach fragments to the Tomcat activator, specify the following host name in the fragment manifest:\n8.6.1.2. Jetty 6.1.8+/6.2.0\n\nSince Jetty is OSGi-ready by default, the official distribution can be installed without any transformation/processing on the OSGi platform. However, since there is no activator, Spring-DM provides one, similar in functionality to the one available for Tomcat. The activator has `jetty.start.osgi` as artifact id. Just like the Tomcat case, a default configuration is included which starts a Jetty instance on localhost, port 8080. To change the defaults, place your Jetty configuration under etc/jetty.xml location.\n\nTo attach fragments to the Jetty activator, specify the following host name in the fragment manifest:\n\n```\nFragment-Host: org.springframework.osgi.jetty.start.osgi\n```\n\nJust like the extender, each activator uses a default configuration if the user doesn't provide one. For the latter case, one should use fragments (as mentioned above) to provide a customized configuration and to avoid modifying the distribution jar.\n\n8.6.2. Common libraries\n\nThe Servlet, Java Server Pages, Standard Taglib, Commons-EL and other web libraries are available as well in the Spring-DM repository. When browsing use an S3 compatible application.\n\n8.7. Spring-MVC Integration\n\nSince 1.1, Spring-DM integrates closely with Spring-MVC framework. This section details how Spring-MVC applications can be run into OSGi environments (it is assumed the reader is familiar with Spring-MVC concepts and APIs).\n\nIn order to be properly used inside an OSGi platform, a Spring-MVC application needs to adapt to its new environment. Spring-DM provides a dedicated, OSGi-aware, web application context (called `OsgiBundleXmlWebApplicationContext`) that offers the same functionality and behaviour to its Spring-MVC brethren, `XmlWebApplicationContext`. The application context is aware of the web application BundleContext and thus is able to load resources from the OSGi space, import and export OSGi services and support the BundleContextAware and component scanning across the bundles included in the classpath.\n\nTo use this application context instead of the default one, use the `contextClass` parameters supported by Spring's `ContextLoaderListener` and `DispatcherServlet` inside your web application WEB-INF/web.xml:\n\n```xml\n<context-param>\n <param-name/contextClass</param-name>\n <param-value>org.springframework.osgi.web.context.support.OsgiBundleXmlWebApplicationContext</param-value>\n</context-param>\n\n<listener>\n <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>\n</listener>\n\n<servlet>\n <servlet-name>petclinic</servlet-name>\n <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>\n <load-on-startup>2</load-on-startup>\n <init-param>\n <param-name>contextClass</param-name>\n <param-value>org.springframework.osgi.web.context.support.OsgiBundleXmlWebApplicationContext</param-value>\n </init-param>\n</servlet>\n```\nName of the context-param used by Spring's ContextLoaderListener to determine the root web application context type\n\nFully qualified name of the OSGi-aware web application context class\n\nSpring configuration bootstrap listener\n\nSpring MVC front controller\n\nName of the init-param used by Spring's DispatcherServlet to determine the web application context type\n\nWith this configuration, deployed Spring-MVC bundles will be able to look up the existing BundleContext and be aware of the OSGi environment.\n\n**Note**\n\nYou still need to add the proper package imports to your Spring-MVC application - the WAR is still a bundle after all which means without the proper manifest entries, it will have an invalid class path and will not be able to work properly.\nChapter 9. Testing OSGi based Applications\n\nBy following best practices and using the Spring Dynamic Modules support, your bean classes should be easy to unit test as they will have no hard dependencies on OSGi, and the few OSGi APIs that you may interact with (such as BundleContext) are interface-based and easy to mock. Whether you want to do unit testing or integration testing, Spring-DM can ease your task.\n\n9.1. OSGiMocks\n\nMocks vs Stubs\n\nThere are various strategies to unit test code that requires collaborators. The two most popular strategies are stubs and mocks.\n\nSee this article by Martin Fowler which describes in detail the difference between them.\n\nEven though most OSGi API are interfaces and creating mocks using a specialized library like EasyMock is fairly simple, in practice the amount of code of setting the code (especially on JDK 1.4) becomes cumbersome. To keep the tests short and concise, Spring-DM provides OSGi mocks under org.springframework.osgi.mock package.\n\nIt's up to you to decide whether they are useful or not however, we make extensive use of them inside Spring-DM test suite. Below you can find a code snippet that you are likely to encounter in our code base:\n\n```java\nprivate ServiceReference reference;\nprivate BundleContext bundleContext;\nprivate Object service;\n\nprotected void setUp() throws Exception {\n reference = new MockServiceReference();\n bundleContext = new MockBundleContext() {\n public ServiceReference getServiceReference(String clazz) {\n return reference;\n }\n\n public ServiceReference[] getServiceReferences(String clazz, String filter) throws InvalidSyntaxException {\n return new ServiceReference[] { reference };}\n\n public Object getService(ServiceReference ref) {\n if (reference == ref)\n return service;\n super.getService(ref);\n }\n };\n ...\n}\n\npublic void testComponent() throws Exception {\n OsgiComponent comp = new OsgiComponent(bundleContext);\n assertEquals(reference, comp.getReference());\n assertEquals(object, comp.getTarget());\n}\n```\n\nAs ending words, experiment with them and choose whatever style or library you feel most confortable with. In our test suite we use the aforementioned mocks, EasyMock library and plenty of integration testing (see below).\n9.2. Integration Testing\n\nWhat about JUnit4/TestNG?\n\nWhile JUnit4/TestNG overcome the class inheritance problem that appears when building base JUnit classes, by decoupling the runner from the test through annotations, Spring-DM cannot use them since it has to support Java 1.4.\n\nHowever, it is planned for the future to provide an optional, JVM 5-based testing extension to integrate the existing testing framework with the aforementioned libraries.\n\nIn a restricted environment such as OSGi, it's important to test the visibility and versioning of your classes, the manifests or how your bundles interact with each other (just to name a few).\n\nTo ease integration testing, the Spring Dynamic Modules project provides a test class hierarchy (based on org.springframework.osgi.test.AbstractOsgiTests) that provides support for writing regular JUnit test cases that are then automatically executed in an OSGi environment.\n\nIn general, the scenario supported by Spring-DM testing framework is:\n\n- start the OSGi framework (Equinox, Knopflerfish, Felix)\n- install and start any specified bundles required for the test\n- package the test case itself into a on the fly bundle, generate the manifest (if none is provided) and install it in the OSGi framework\n- execute the test case inside the OSGi framework\n- shut down the framework\n- passes the test results back to the originating test case instance that is running outside of OSGi\n\n**Warning**\n\nThe testing framework is aimed at running OSGi integration tests from a non-OSGi environment (like Ant/Maven/IDE). The testing framework is NOT meant to be used as an OSGi bundle (nor will it work for that matter). In practice this means that the testing bundle should be separate from the bundle(s) it tests (similar to unit testing, where tests are separate from the classes they test).\n\nBy following this sequence it is trivial to write JUnit-based integration tests for OSGi and have them integration into any environment (IDE, build (ant, maven), etc.) that can work with JUnit.\n\nThe rest of this chapter details (with examples) the features offered by Spring-DM testing suite.\n\n9.2.1. Creating a simple OSGi integration test\n\nWhile the testing framework contains several classes that offer specific features, it is most likely that your test cases will extend org.springframework.osgi.test.AbstractConfigurableBundleCreatorTests (at least this is what we use in practice).\n\nLet's extend this class and interact with the OSGi platform through the bundleContext field:\npublic class SimpleOsgiTest extends AbstractConfigurableBundleCreatorTests {\n\npublic void testOsgiPlatformStarts() throws Exception {\n System.out.println(bundleContext.getProperty(Constants.FRAMEWORK_VENDOR));\n System.out.println(bundleContext.getProperty(Constants.FRAMEWORK_VERSION));\n System.out.println(bundleContext.getProperty(Constants.FRAMEWORK_EXECUTIONENVIRONMENT));\n}\n}\n\nSimply execute the test as you normally do with any JUnit test. On Equinox 3.2.x, the output is similar to:\n\nEclipse\n1.3.0\nOSGi/Minimum-1.0, OSGi/Minimum-1.1, JRE-1.1, J2SE-1.2, J2SE-1.3, J2SE-1.4\n\nIt's likely that you will see other log statements made by the testing framework during your test execution by these can be disabled and have only an informative value as they don't affect your test execution.\n\nNote that you did not have to create any bundle, write any MANIFEST or bother with imports or exports, let alone starting and shutting down the OSGi platform. The testing framework takes care of these automatically when the test is executed.\n\nLet's do some querying and figure out what the environment in which the tests run is. A simple way to do that is to query the BundleContext for the installed bundles:\n\npublic void testOsgiEnvironment() throws Exception {\n Bundle[] bundles = bundleContext.getBundles();\n for (int i = 0; i < bundles.length; i++) {\n System.out.print(OsgiStringUtils.nullSafeName(bundles[i]));\n System.out.print(\", \");\n }\n System.out.println();\n}\n\nThe output should be similar to:\n\nOSGi System Bundle, ObjectWeb ASM, log4j.osgi, spring-test, spring-osgi-test, spring-osgi-core, spring-test, spring-osgi-test, spring-osgi-test, spring-osgi-test, spring-osgi-test, spring-osgi-test, spring-osgi-test, slf4j-api, spring-osgi-test, etc... TestBundle-testOsgiPlatformStarts-com.your.package.SimpleOsgiTest,\n\nAs you can see, the testing framework installs the mandatory requirements required for running the test such as the Spring, Spring-DM, slf4j jars among others.\n\n9.2.2. Installing test prerequisites\n\nOSGi-friendly libraries\n\nTo work in OSGi environments, jars need to declare in their MANIFEST.MF, Export or Import packages; that is declare what classes they need or offer to other bundles. Most libraries are OSGi unaware and do not provide the proper manifest entries which means they are unusable in an OSGi environment.\n\nAt the moment, there are several initiatives in the open source space to provide the proper manifest - please see the FAQ for more information.\n\nBesides the Spring-DM jars and the test itself is highly likely that you depend on several libraries or your own code for the integration test.\nConsider the following test that relies on Apache Commons \\textit{Lang}:\n\n```java\nimport org.apache.commons.lang.time.DateFormatUtils;\n\npublic void testCommonsLangDateFormat() throws Exception {\n System.out.println(DateFormatUtils.format(new Date(), \"HH:mm:ssZZ\"));\n}\n```\n\nRunning the test however yields an exception:\n\n```\njava.lang.IllegalStateException: Unable to dynamically start generated unit test bundle\n... \nCaused by: org.osgi.framework.BundleException: The bundle could not be resolved.\nReason: Missing Constraint: Import-Package: org.apache.commons.lang.time; version=\"0.0.0\"\n... 15 more\n```\n\nThe test requires \\textit{org.apache.commons.lang.time} package but there is no bundle that exports it. Let's fix this by installing a commons-lang bundle (make sure you use at least version 2.4 which adds the proper OSGi entries to the jar manifest).\n\nOne can specify the bundles that she wants to be installed using \\texttt{getTestBundlesNames} or \\texttt{getTestBundles} method. The first one returns an array of String that indicate the bundle name, package and versioning through as a String while the latter returns an array of \\texttt{Resource}s that can be used directly for installing the bundles. That is, use \\texttt{getTestBundlesNames} when you rely on somebody else to locate (the most common case) the bundles and \\texttt{getTestBundles} when you want to locate the bundles yourself.\n\nBy default, the test suite uses the local \\texttt{maven2} repository to locate the artifacts. The locator expects the bundle String to be a comma separated values containing the artifact group, name, version and (optionally) type. It's likely that in the future, various other locators will be available. One can plug in their own locator through the \\texttt{org.springframework.osgi.test.provisioning.ArtifactLocator} interface.\n\nLet's fix our integration test by installing the required bundle (and some extra osgi libraries):\n\n```java\nprotected String[] getTestBundlesNames() {\n return new String[] { \"net.sourceforge.cglib, com.springsource.net.sf.cglib, 2.1.3\",\n \"javax.transaction, com.springsource.javax.transaction, 1.1.0\",\n \"commons-lang, commons-lang, 2.4\" };\n}\n```\n\nRerunning the test should show that these bundles are now installed in the OSGi platform.\n\n\\textbf{Note}\n\nThe artifacts mentioned above have to exist in your local maven repository.\n\n\\section*{9.2.3. Advanced testing framework topics}\n\nThe testing framework allows a lot of customization to be made. This chapter details some of the existing hooks that you might want to know about. However, these are advanced topics as they increase the complexity of your test infrastructure.\n\n\\subsection*{9.2.3.1. Customizing the test manifest}\nThere are cases where the auto-generated test manifest does not suite the needs of the test. For example the manifest requires some different headers or a certain package needs to be an optional import.\n\nFor simple cases, one can work directly with the generated manifest - in the example below, the bundle class path is being specified:\n\n```java\nprotected Manifest getManifest() {\n // let the testing framework create/load the manifest\n Manifest mf = super.getManifest();\n // add Bundle-Classpath:\n mf.getMainAttributes().putValue(Constants.BUNDLE_CLASSPATH, \".,bundleclasspath/simple.jar\");\n return mf;\n}\n```\n\nAnother alternative is to provide your own manifest by overriding `getManifestLocations()`:\n\n```java\nprotected String getManifestLocation() {\n return \"classpath:com/xyz/abc/test/MyTestTest.MF\";\n}\n```\n\nHowever each manifest needs the following entry:\n\n```\n\"Bundle-Activator: org.springframework.osgi.test.JUnitTestActivator\"\n```\n\nsince without it, the testing infrastructure cannot function properly. Also, one needs to import JUnit, Spring and Spring-DM specific packages used by the base test suite:\n\n```\nImport-Package: junit.framework,\norg.osgi.framework,\norg.apache.commons.logging,\norg.springframework.util,\norg.springframework.osgi.service,\norg.springframework.osgi.util,\norg.springframework.osgi.test,\norg.springframework.context\n```\n\nFailing to import a package used by the test class will cause the test to fail with a `NoDefClassFoundError` error.\n\n### 9.2.3.2. Customizing test bundle content\n\nBy default, for the on-the-fly bundle, the testing infrastructure uses all the classes, xml and properties files found under `./target/test-classes` folder. This matches the project layout for maven which is used (at the moment by Spring-DM). These settings can be configured in two ways:\n\n1. **programmatically** by overriding `AbstractConfigurableBundleCreatorTests getXXX` methods.\n\n2. **declaratively** by creating a properties file having a similar name with the test case. For example, `test com.xyz.MyTest` will have the properties file named `com/xyz/MyTest-bundle.properties`. If found, the following properties will be read from the file:\n\n<table>\n<thead>\n<tr>\n<th>Property Name</th>\n<th>Default Value</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>root.dir</td>\n<td>file:./target/test-classes</td>\n<td>the root folder considered as the jar root</td>\n</tr>\n<tr>\n<td>include.patterns</td>\n<td>/<strong>/*.class,/</strong>/<em>.xml,/**/</em>.properties</td>\n<td>Comma-separated string of Ant-style patterns</td>\n</tr>\n<tr>\n<td>Property Name</td>\n<td>Default Value</td>\n<td>Description</td>\n</tr>\n<tr>\n<td>---------------</td>\n<td>---------------</td>\n<td>-------------</td>\n</tr>\n<tr>\n<td>manifest</td>\n<td>(empty)</td>\n<td>manifest location given as a String. By default it's empty meaning the manifest will be created by the test framework rather then being supplied by the user.</td>\n</tr>\n</tbody>\n</table>\n\nThis option is handy when creating specific tests that need to include certain resources (such as localization files or images).\n\nPlease consult AbstractConfigurableBundleCreatorTests and AbstractOnTheFlyBundleCreatorTests tests for more customization hooks.\n\n### 9.2.3.3. Understanding the **MANIFEST.MF** generation\n\nA useful feature of the testing framework represents the automatic creation of the test manifest based on the test bundle content. The manifest creator component uses byte-code analysis to determine the packages imported by the test classes so that it can generate the proper OSGi directives for them. Since the generated bundle is used for running a test, the creator will use the following assumptions:\n\n- **No packages will be exported.**\n\n The on-the-fly bundle is used for running a test which (usually) consumes OSGi packages for its execution. This behaviour can be changed by customizing the manifest.\n\n- **Split packages (i.e. classes from the same package can come from different bundles) are not supported.**\n\n This means that packages present in the test framework are considered complete and no `Import-Package` entry will be generated for them. To avoid this problem, consider using sub-packages or moving the classes inside one bundle. Note that split packages are discouraged due to the issues associated with them (see the OSGi Core spec, Chapter 3.13 - Required Bundles).\n\n- **The test bundle contains only test classes.**\n\n The byte-code parser will look only at the test classes hierarchy. Any other class included in the bundle, will not be considered so no imports will be generated for it. To change the default behaviour, override `createManifestOnlyFromTestClass` to `return` false:\n\n ```java\n protected boolean createManifestOnlyFromTestClass() {\n return true;\n }\n ```\n\n**Note**\n\nThe time required to generate the manifest might increase depending on the number and size of classes in the bundle.\n\nAdditionally consider customizing the manifest yourself or attaching the extra code as inner classes to the test class (so it gets parsed automatically).\n\nThe reason behind the lack of such features is the byte-code parser is aimed to be simple and fast at creating test manifests - it is not meant as a general-purpose tool for creating OSGi artifacts.\n9.2.4. Creating an OSGi application context\n\nSpring-DM testing suite builds on top of Spring testing classes. To create an application context (OSGi specific), one should just override `getConfigLocations[]` method and indicate the location of the application context configuration. At runtime, an OSGi application context will be created and cached for the lifetime of the test case.\n\n```java\nprotected String[] getConfigLocations() {\n return new String[] { \"/com/xyz/abc/test/MyTestContext.xml\" };\n}\n```\n\n9.2.5. Specifying the OSGi platform to use\n\nThe testing framework supports out of the box, three OSGi 4.0 implementations namely: Equinox, Knopflerfish and Felix. To be used, these should be in the test classpath. By default, the testing framework will try to use Equinox platform. This can be configured in several ways:\n\n1. **programmatically through `getPlatformName()` method**\n\n Override the aforementioned method and indicate the fully qualified name of the `Platform` interface implementation. Users can use the `Platforms` class to specify one of the supported platforms:\n\n ```java\n protected String getPlatformName() {\n return Platforms.FELIX;\n }\n ```\n\n2. **declaratively through `org.springframework.osgi.test.framework` system property.**\n\n If this property is set, the testing framework will use its value as a fully qualified name of a Platform implementation. It that fails, it will fall back to Equinox after logging a warning message. This option is useful for building tools (such as ant or maven) since it indicates a certain target environment without changing and test code.\n\n9.2.6. Waiting for the test dependencies\n\nA built-in feature of the testing framework is the ability to wait until all dependencies are deployed before starting the test execution. Since the OSGi platforms are concurrent by nature, installing a bundle doesn't mean that all its services are running. By running a test before its dependency services are fully initialized can cause sporadic errors that pollute the test results. By default, the testing framework inspects all bundles installed by the user and, if they are Spring-powered bundles, waits until they are fully started (that is their application context is published as an OSGi service). This behaviour can be disabled by overriding `shouldWaitForSpringBundlesContextCreation` method. Consult `AbstractSynchronizedOsgiTests` for more details.\n\n9.2.7. Testing framework performance\n\nConsidering all the functionality offered by the testing framework, one might wonder if this doesn't become a performance bottleneck. First, it's worth noting that all the work done automatically by the testing infrastructure has to be done anyway (such as creating the manifest or creating a bundle for the test or installing the bundles). Doing it manually simply does not work as it's too error prone and time consuming. In fact, the current\ninfrastructure started as a way to do efficient, automatic testing without worrying about deployment problems and redundancy.\n\nAs for the numbers, the current infrastructure has been used internally for the last half a year - our integration tests (around 120) run in about 3:30 minutes on a laptop. Most of this time is spent on starting and stopping the OSGi platform: the \"testing framework\" takes around 10% (as shown in our profiling so far). For example, the manifest generation has proved to take less than 0.5 seconds in general, while the jar creation around 1 second.\n\nHowever, we are working on making it even faster and smarter so that less configuration options are needed and the contextual information available in your tests is used as much as possible. If you have any ideas or suggestion, feel free to use our issue tracker or/and forum.\n\nHopefully this chapter showed how Spring-DM testing infrastructure can simplify OSGi integration testing and how it can be customized. Consider consulting the javadocs for more information.\nPart III. Other Resources\n\nIn addition to this reference documentation, there are a number of other resources that may help you learn how to use OSGi and Spring Dynamic Modules. These additional, third-party resources are enumerated in this section.\nChapter 10. Useful links\n\n- Spring-DM Home Page - here\n- SpringSource OSGi blog - here\n- Spring-DM Demos - here\n- Getting Started with OSGi - by Neil Bartlett here and here.\n- Equinox Documents - here\n- Felix-related presentations - various presentations hosted by Apache Felix project.\n- Launching Spring Dynamic Modules using pax-runner - screencast\n- OSGi Alliance Blog - here\nPart IV. Appendixes\n\nDocument structure\n\nVarious appendixes outside the reference documentation.\n\nAppendix A, *Compendium Services* describes the support provided for the OSGi Compendium Services, including the Configuration Admin service. While the support is included in the 1.0 distribution, it is not guaranteed (yet) to be maintained in a backward-compatible form in future point releases.\n\nAppendix B, *Extensions* describes extensions that are included in the 1.0 distribution, but are not guaranteed to be maintained in a backward-compatible form in future point releases. We anticipate these features moving into the core specification over time.\n\n\nAppendix E, *Useful OSGi tips* provides some useful OSGi tips, especially meaningful when used along with Spring-DM.\n\nAppendix F, *Roadmap* describes some features that are included in the 1.0 distribution but are still considered early-access. The externals of these features may change in future releases. This appendix also discusses other planned features for which no implementation yet exists.\n\nAppendix G, *Spring-DM OSGi Repository* describes the repository used by Spring-DM for its osgi artifacts.\n\nAppendix H, *Spring Dynamic Modules Schema* defines the schemas provided by Spring Dynamic Modules.\nAppendix A. Compendium Services\n\nThe OSGi Service Platform Service Compendium specification defines a number of additional services that may be supported by OSGi implementations. Spring Dynamic Modules supports an additional \"compendium\" namespace that provides support for some of these services. By convention, the prefix osgix is used for this namespace.\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<beans:beans xmlns=\"http://www.springframework.org/schema/osgi\"\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xmlns:osgix=\"http://www.springframework.org/schema/osgi-compendium\"\n xmlns:beans=\"http://www.springframework.org/schema/beans\"\n xsi:schemaLocation=\"http://www.springframework.org/schema/osgi\n http://www.springframework.org/schema/osgi/spring-osgi.xsd\n http://www.springframework.org/schema/osgi-compendium\n http://www.springframework.org/schema/osgi-compendium/spring-osgi-compendium.xsd\n http://www.springframework.org/schema/beans\n http://www.springframework.org/schema/beans/spring-beans.xsd\">\n <!-- use the OSGi namespace elements directly -->\n <service id=\"simpleServiceOsgi\" ref=\"simpleService\"\n interface=\"org.xyz.MyService\"/>\n <!-- qualify compendium namespace elements -->\n <osgix:property-placeholder persistent-id=\"com.xyz.myapp\"/>\n</beans:beans>\n```\n\nAt present this namespace provides support for the Configuration Admin service. Support for other compendium services may be added in future releases.\n\nA.1. Configuration Admin\n\nA.1.1. Property placeholder support\n\n**Future directions**\n\nPlease note that in future releases, the property-placeholder element will be changed to be properly align with Spring Framework classes and namespace. That is, rather then provide a Spring-DM specific declaration, the traditional Spring Framework declaration can be used.\n\nSpring Dynamic Modules provides support for sourcing bean property values from the OSGi Configuration Administration service. This support is enabled via the property-placeholder element. The property placeholder element provides for replacement of delimited string values (placeholders) in bean property expressions with values sourced from the configuration administration service. The required persistent-id attribute specifies the persistent identifier to be used as the key for the configuration dictionary. The default delimiter for placeholder strings is \"${...}\".\n\nGiven the declarations:\n\n```xml\n<osgix:property-placeholder persistent-id=\"com.xyz.myapp\"/>\n<br:bean id=\"someBean\" class=\"AClass\">\n <property name=\"timeout\" value=\"${timeout}\"/>\n</br:bean>\n```\nThen the timeout property of someBean will be set using the value of the timeout entry in the configuration dictionary registered under the com.xyz.myapp persistent id.\n\nThe placeholder strings are evaluated at the time that the bean is instantiated. Changes to the properties made via Configuration Admin subsequent to the creation of the bean do not result in re-injection of property values. See the managed-service and managed-service-reference elements documented in appendix B if you require this level of integration. The placeholder-prefix and placeholder-suffix attributes can be used to change the delimiter strings used for placeholder values.\n\nIt is possible to specify a default set of property values to be used in the event that the configuration dictionary does not contain an entry for a given key. The defaults-ref attribute can be used to refer to a named bean of Properties or Map type. Instead of referring to an external bean, the default-properties nested element may be used to define an inline set of properties.\n\n```xml\n<osgix:property-placeholder persistent-id=\\\"com.xyz.myapp\\\"> \n <default-properties> \n <property name=\\\"productCategory\\\" value=\\\"E792\\\"/> \n <property name=\\\"businessUnit\\\" value=\\\"811\\\"/> \n </default-properties> \n</osgix:property-placeholder>\n```\n\nThe persistent-id attribute must refer to the persistent-id of an OSGi ManagedService, it is a configuration error to specify a factory persistent id referring to a ManagedServiceFactory.\n\n### A.1.2. Configuration Dictionaries\n\nSupport for directly accessing configuration objects and their associated dictionaries, and for instantiating beans directly from configuration objects is on the Spring Dynamic Modules road map. See Appendix F, Roadmap for more information.\nAppendix B. Extensions\n\nSpring-DM and Spring annotations\n\nThis chapter describes the annotations present in Spring-DM and how to enable/disable them. Spring-DM annotations are separate from the annotation support in Spring framework; enabling or disabling one does not interfere with the other.\n\nThis appendix describes extensions to the core functionality that are shipped with the 1.0 distribution, but are not guaranteed to have backwards compatibility across point releases. We anticipate these features migrating into the core specification in future releases.\n\nB.1. Annotation-based injection\n\nThe org.springframework.osgi.extensions.annotation bundle that ships with Spring Dynamic Modules provides early access to annotation-based support for injecting references to OSGi services. JDK 1.5 or above is required to use this feature.\n\nBean class (setter) methods may be annotated with org.springframework.osgi.extensions.annotation.ServiceReference. By default the property type of the annotated property is used to look up a service with a matching service interface in the OSGi service registry and inject the result. For example, given the configuration:\n\n```xml\n<bean id=\"annotationDriven\" class=\"MyAnnotationDrivenBeanClass\"/>\n```\n\nand the class declaration:\n\n```java\npublic class MyAnnotationDrivenBeanClass {\n @ServiceReference\n public void setMessageService(MessageService aService) { ... }\n}\n```\n\nthen a service lookup for services implementing the MessageService interface will be performed, and the best match (using the same algorithm as documented for the reference element) will be injected.\n\nThe ServiceReference annotation class has a number of attributes that can be used to control the service lookup (for example, to specify a filter string) that mirror the options provided by the reference element. See the javadoc for more information.\n\nB.1.1. Enabling/Disabling annotation processing\n\nBy default, as Spring-OSGi is JDK 1.4 compatible, annotation injection is disabled. There are currently two ways for enabling it:\n\n- through Spring-DM extender (see Section 5.2, “Extender configuration options”).\n\nThis is an extender wide configuration which means all bundles started by the extender will have annotation...\ninjection applied to them.\n\n- by specifying a dedicated bean post processor\n\nBy specifying the Spring-DM annotation extension processor, one can enable *per-bundle* annotation injection. To do that, add the following to your bundle configuration:\n\n```\n<bean class=\"org.springframework.osgi.extensions.annotation.ServiceReferenceInjectionBeanPostProcessor\"/>\n```\n\nAs a reminder, for the annotations to work, the containing bundle needs to import `org.springframework.osgi.extensions.annotation` package, which is available in the `spring-osgi-annotation` bundle.\nAppendix C. Eclipse Plug-in Development integration\n\nEclipse PDE “provides comprehensive OSGi tooling, which makes it an ideal environment for component programming, not just Eclipse plug-in development”. In fact, Eclipse IDE is built on top of OSGi and uses at its core the Equinox OSGi implementation. Moreover, all the Eclipse plug-ins are OSGi bundles. This makes Eclipse with PDE a very attractive tool for creating OSGi bundles. While Spring Dynamic Modules artifacts can be integrated as normal libraries, through Spring IDE, Spring-DM can be installed as a target platform ready to be used with PDE.\n\nThe following steps illustrate how to install Spring IDE extension for OSGi and how to use it in your project. Please see Spring IDE installation page for information on its requirement and install process.\n\n1. **Set up nightly update site**\n\n At the moment, the OSGi extension is available only on Spring-IDE nightly builds update site. Add it to the Eclipse configuration by opening the software update menu:\n\n \n\n and create a new update site pointing to [http://www.springide.org/updatesite_nightly](http://www.springide.org/updatesite_nightly)\n\n2. **Select Spring IDE OSGi extension**\n\n After using the nightly update site and performing the update, Eclipse will show the search results. Unfold the Extension menu and select Spring IDE OSGi Extension:\nand proceed with the installation.\n\n3. **Select Spring Dynamic Modules Target Platform**\n\n Once the plug-in has been installed, Spring Dynamic Modules can be selected as a PDE target platform. Select Window/Preferences/Plug-in Development and then Target Platform.\nSelect the Spring-DM version that you desire from the Pre-defined Target (1) drop box and press Load Target (2). Eclipse will load the target and all bundles defined by it - this includes Spring-DM bundles and all of its dependencies (SLF4J is used for logging). The configuration can be customised appropriately by removing and adding bundles.\n\nIn its current form, the plug-in offers two predefined targets - one for the stable released versions and one for the SNAPSHOT/nightly Spring DM jars. The latter does not contain any jars as it is expected for the user to download them manually. Simply locate the path where the plug-ins should be located (3), enter that folder and do a\n\n```\nmvn install\n```\n\nThe latest Spring-DM SNAPSHOT will be downloaded along with all of its dependencies. Simply click on the reload button (4) and Eclipse will pick up the bundles.\n\n4. Select PDE perspective\n\nOnce the installation is completed just select the PDE perspective:\n\n\n\nand the Spring-DM and its dependencies should be available in the plug-ins view:\nEclipse Plug-in Development integration\n\nSpring Dynamic Modules(1.1.2)\nAppendix D. Spring Dynamic Modules\nMaven Archetype\n\nAs part of the distribution, Spring-DM provides a Maven archetype which creates the basic structure of a Java project that uses Spring DM, especially useful to new users. To run the archetype (and create the new project), simply run the following command line:\n\n```\nmvn archetype:generate\n```\n\nThe maven plugin will display a selection of possible archetype, from which you should pick `spring-osgi-bundle-archetype` (Spring-OSGi archetype) (currently number 32), and will request input regarding the project about to be created. A list of all available archetypes included with the plugin and their versions is available here.\n\nNote that it is still possible to select the osgi archetype directly from the command line (i.e. the old way of using the archetype):\n\n```\nmvn archetype:create \\\n-DarchetypeGroupId=org.springframework.osgi \\\n-DarchetypeArtifactId=spring-osgi-bundle-archetype \\\n-DarchetypeVersion= \\\n-DgroupId=<your-project-groupId> \\\n-DartifactId=<your-project-artifactId> \\\n-Dversion=<your-project-version>\n```\n\n**Note**\nThe command above should be invoked as one line - the \\ is used as a convenience to break the long line into smaller pieces.\n\nIn both cases, the result of the commands is a Maven 2 project that defines two packages (one public and one private) and two Spring configurations: `src/main/resources/META-INF/spring/bundle-context.xml` and `src/main/resources/META-INF/spring/bundle-context-osgi.xml` The project is packaged as an OSGi bundle.\n\nNotice that by default, the project does not contain a MANIFEST.MF for your project. The Maven infrastructure will generate it, through Apache Felix bundle plug-in. To do that, run the following (from the project root):\n\n```\nmvn package\n```\n\n**Note**\nTo avoid the confusion between the generated artifacts and maintained files, the manifest file resides under `META-INF` folder while Spring configuration files under `src/main/resources/META-INF` directory.\n\nThis will compile your project, pack it as a jar and create the OSGi manifest based on your classes under `/META-INF` folder (so that users running Eclipse PDE can use it right away. To generate the manifest, without creating the OSGi bundle, simply run:\n\n```\nmvn org.apache.felix:maven-bundle-plugin:manifest\n```\nD.1. Generated Project Features at-a-glance\n\n- Packaged as an OSGi bundle\n- META-INF/MANIFEST.MF automatically generated\n- src/main/java/<package> public package exported by the bundle\n- src/main/java/<package>/internal private package, not exported by the bundle\n- src/main/resources/META-INF/spring/bundle-context.xml is a Spring configuration file that defines the simple bean.\n- src/main/resources/META-INF/spring/bundle-context-osgi.xml is a Spring configuration file ready for you to add bean definitions from the osgi namespace (services, references etc.)\n- .project, .classpath, and build.properties files created to enable use of this project directly inside eclipse as a PDE plugin project\nAppendix E. Useful OSGi tips\n\nE.1. OSGi Fragments\n\nCheck the target OSGi platform fragment support\n\nBefore using fragments, make sure the target OSGi environment supports them (and to what degree). Out of the OSGi platforms on which Spring-DM is tested upon, at the time of this writing, Apache Felix does not support fragments (it simply ignores them).\n\nPart of the OSGi R4 release, fragments are a very useful and powerful feature. A fragment is “a bundle that is attached to a host bundle”, adding content to the target bundle. A fragment cannot have its own class loader nor a bundle activator and cannot override the information already present in the host. In short, through fragments, bundles can be extender with resources, classes and even manifest entries. To quote the spec again, a “...key use case for fragments is providing translation files for different locales. This allows the translation files to be treated and shipped independently from the main application bundle.”\n\nNote\nFor a full description on fragments, please see the OSGi specification, section 3.14.\n\nIn Spring-DM, fragments are useful for configuring various components such as the extenders. To do that, simply bundle the resources as you normally would and add an extra entry to the bundle manifest:\n\n```\nFragment-Host: <host bundle symbolic name>\n```\n\nThis line indicates that the containing bundle is a fragment and that it should be attached to the host specified by a symbolic name. The fragment and host bundle symbolic name should be different. For example, to attach a fragment (with extra configuration) the Spring-DM extender, one could use the following manifest:\n\n```\nManifest-Version: 1.0\nBundle-ManifestVersion: 2\nFragment-Host: org.springframework.bundle.osgi.extender\nBundle-SymbolicName: org.mydomain.project.fragment\nBundle-Name: my-fragment\nBundle-Description: Fragment attached to Spring-DM extender\n```\n\n1. Manifest version.\n2. OSGi bundle version. A value of 1 (which is also the default) indicates an OSGi Release 3 bundle so it's best to specify 2 to indicate an OSGi Release 4 bundle.\n3. The symbolic name of the bundle to which this fragment should be attached to. In this case, the value org.springframework.bundle.osgi.extender points to the spring-osgi-extender.jar. Fragment-Host is the key entry which tells the OSGi platform that the containing bundle is a of a special kind - it's a fragment.\n4. The fragment symbolic name.\n5. The bundle name - an optional yet useful header.\n6. The bundle description - just like the name, this header is useful for humans not for the OSGi platform itself. However, it is recommended that you define it to help identify the bundle purpose.\n**Note**\nThe Manifest entries order does not matter, but they case sensitive.\n\nWhen multiple bundles with the same symbolic names are present, one can add the bundle version to make sure the proper wiring is done:\n\n```shell\nFragment-Host: org.springframework.bundle.osgi.extender;bundle-version=1.1.0\n```\n\nThe default value for `bundle-version` (when it's not specified) is `[0.0.0, #)`\nAppendix F. Roadmap\n\nThis appendix documents features on the Spring Dynamic Modules roadmap. The design of these features specified here is subject to change. As a most up to date source, please see our issue tracker.\n\nF.1. Enhanced Configuration Admin Support\n\nF.1.1. Managed Services\n\nIt should be possible to easily instantiate a bean from the configuration information stored for a ManagedService, and a set of beans from the configuration information stored for a ManagedServiceFactory. In addition, updates to the configuration information should be propagated to beans created in this way.\n\nThe managed-service element is used to define a bean based on the configuration information stored under a given persistent id. It has two mandatory attributes, class and persistent-id. The persistent-id attribute is used to specify the persistent id to be looked up in the configuration administration service, class indicates the Java class of the bean that will be instantiated.\n\nA simple declaration of a managed service bean would look as follows:\n\n```xml\n<osgix:managed-service id=\"myService\" class=\"com.xyz.MessageService\"\n persistent-id=\"com.xyz.messageservice\"/>\n```\n\nThe properties of the managed-service bean are autowired by name based on the configuration found under the given persistent id. It is possible to declare regular Spring bean property elements within the managed-service declaration. If a property value is defined both in the configuration object stored in the Configuration Admin service, and in a nested property element, then the value from Configuration Admin takes precedence. Property values specified via property elements can therefore be treated as default values to be used if none is available through Configuration Admin.\n\nIt is possible for the configuration data stored in Configuration Admin to be updated once the bean has been created. By default, any updates post-creation will be ignored. To receive configuration updates, the update-strategy attribute can be used with a value of either bean-managed or container-managed.\n\nThe default value of the optional update-strategy attribute is none. If an update strategy of bean-managed is specified then the update-method attribute must also be used to specify the name of a method defined on the bean class that will be invoked if the configuration for the bean is updated. The update method must have one of the following signatures:\n\n```java\npublic void anyMethodName(Map properties); // for Java 5\npublic void anyMethodName(Dictionary properties);\n```\n\nWhen an update strategy of container-managed is specified then the container will autowire the bean instance by name based on the new properties received in the update. For container-managed updates, the bean class must provide setter methods for the bean properties that it wishes to have updated. Container-managed updates cannot be used in conjunction with constructor injection. Before proceeding to autowire based on the new property values, a lock is taken on the bean instance. This lock is released once autowiring has completed. A class may therefore synchronize its service methods or otherwise lock on the bean instance in order to have atomic update semantics.\nF.1.2. Managed Service Factories\n\nThe managed-service-factory element is similar to the managed-service element, but instead defines a set of beans, one instance for each configuration stored under the given factory pid. It has two mandatory attributes, factory-pid and class.\n\nA simple managed-service-factory declaration would look as follows:\n\n```xml\n< osgix:managed-service-factory id= \"someId\" factory-pid= \"org.xzy.services\" class= \"MyServiceClass\" />\n```\n\nThis declaration results in the creation of zero or more beans, one bean for each configuration registered under the given factory pid. The beans will have synthetic names generated by appending \".\" followed by the persistent id of the configuration object as returned by Configuration Admin, to the value of the id attribute used in the declaration of the managed-service-factory. For example, someId-config.admin.generated.pid.\n\nOver time new configuration objects may be added under the factory pid. A new bean instance is automatically instantiated whenever a new configuration object is created. If a configuration object stored under the factory pid is deleted, then the corresponding bean instance will be disposed (this includes driving the DisposableBean callback if the bean implements DisposableBean). The option destroy-method attribute of the managed-service-factory element may be used to specify a destroy callback to be invoked on the bean instance. Such a method must have a signature:\n\n```java\npublic void anyMethodName();\n```\n\nIt is also possible for the configuration of an existing bean to be updated. The same update-strategy and update-method attributes are available as for the managed-service element and with the same semantics (though obviously only the bean instance whose configuration has been updated in Configuration Admin will actually be updated). The same client-locking semantics also apply when using the container-managed update strategy.\n\nF.1.3. Direct access to configuration data\n\nIf you need to work directly with the configuration data stored under a given persistent id or factory persistent id, the easiest way to do this is to register a service that implements either the ManagedService or ManagedServiceFactory interface and specify the pid that you are interested in as a service property. For example:\n\n```xml\n<service interface=\"org.osgi.service.cm.ManagedService\" ref=\"MyManagedService\">\n <service-properties>\n <entry key=\"service.pid\" value=\"my.managed.service.pid\"/>\n </service-properties>\n</service>\n<bean id=\"myManagedService\" class=\"com.xyz.MyManagedService\"/>\n```\n\nand where the class MyManagedService implements org.osgi.service.cm.ManagedService.\n\nF.1.4. Publishing configuration administration properties with exported services\n\nWe intend to provide support for automatic publication of service properties sourced from the Configuration Roadmap Spring Dynamic Modules(1.1.2) 77\nAdmin service under a given persistent id. This support has yet to be designed but may look as follows:\n\n```xml\n<service ref=\"toBeExported\" interface=\"SomeInterface\">\n <osgix:config-properties persistent-id=\"pid\"/>\n</service>\n```\n\nIssues to be considered are scoping of a subset of properties to be published (public/private), and automatic updates to published service properties if the value is updated via config admin.\n\nNote that named properties can easily be published as service properties already without this support, simply by using the property-placeholder support.\n\n**F.2. Access to Service References for Collections**\n\nThe current specification does not provide for access to the `ServiceReference` objects for services in a managed collection (i.e. obtained via a `set` or `list` declaration). A future release of Spring Dynamic Modules will provide an easy means of gaining access to these references.\n\n**F.3. Start level integration**\n\nA future release of Spring Dynamic Modules may offer the following additional guarantee with respect to application context creation and start levels:\n\nApplication context creation happens asynchronously. However, the extender bundle does guarantee that the creation of all application contexts for bundles at start level $n$ will be complete before the creation of any application context at start level $m$, where $m > n$. Care must therefore be taken not to introduce any mandatory dependencies on services exported by bundles with higher start levels or a deadlock will be introduced.\n\nIn a similar vein, when shutting down the extender bundle, application contexts at start level $m$ will be shut down before application contexts at start level $n$, where $m > n$.\n\n**F.4. Web library integration**\n\nWhile support for generic and Spring-MVC web applications is available in 1.1.0, in the future we'd like to provide integration (if needed) with other popular web libraries (such as JSF and Spring Web Flow) in the upcoming releases.\n\n**F.5. ORM/Persistence support**\n\nCare needs to be taken when using JPA or Hibernate under OSGi as the persistence engines must have visibility of the persistent types and mapping files. The Spring Dynamic Modules project will be investigating an extension model to make managing this easier when persistent configuration is split across several bundles. See Peter Krien's blog entry on the topic for an insight into the issues.\n\nAlso, the project aims to simplify deployment of JDBC drivers and pooling libraries that at the moment require special `DynamicImport-Package`. \n\nRoadmap\nF.6. OSGi standards\n\nWhile OSGi 4.0 is currently required, work is underway to take advantage of the new features available in 4.1. SpringSource is an active participant in the OSGi Enterprise Expert Group and we hope to help many of the ideas found in the Spring Dynamic Modules project to make their way into the OSGi R5 specification. Spring Dynamic Modules would obviously seek to support any such standards at that point in time.\nAppendix G. Spring-DM OSGi Repository\n\nAt the moment, most libraries are not released as OSGi bundles which means they cannot be used inside the OSGi space unless they are embedded in other bundles. Though there are tools that make the bundling process easy, it is desirable to have the artifacts prepacked so they can be used immediately for development.\n\nSpringSource Enterprise Bundle Repository (or SpringSource Repository) addresses this problem by providing “a collection of open source libraries commonly used for developing enterprise Java applications with the Spring Framework” (taken from the Repository FAQ). With the availability of the Bundle Repository, the Spring-DM old repository (see below) has been deprecated and it is being used until migrating completely to SpringSource Repository. It is highly recommended that users migrate as well to SpringSource Repository as it provides significantly more libraries and it is intended to be a user-facing infrastructure component.\n\nG.1. Spring-DM temporary OSGi Repository\n\nUnfortunately, not all Spring-DM dependencies are available in SpringSource Repository and thus Spring-DM still needs to maintain some of its own dedicated Maven repository available at http://maven.springframework.org/osgi.\n\n⚠️ Warning\n\nThe repository is provided as-is without any kind of support. The repository structure/content can (and will) change until it becomes stable. Before using Spring-DM repository make sure the needed artifact are not available in SpringSource Repository. These being said, we hope you find it useful and we'd like to know if there are improvement that can be made to it.\n\nG.1.1. Repository conventions\n\nCurrently, all the artifacts published in the repository are marked as SNAPSHOTs meaning that, in time, their content can change. This allows clients to download possible manifest updates made to the libraries. We foresee that, as the library usage increases, several popular items will have the SNAPSHOT marker remove. Additionally, to differentiate the OSGi-enabled artifacts from the original ones, all libraries are placed under org.springframework.osgi group and their names contains a ..osgi suffix.\n\nSo for example, an OSGi version of mx4j-3.0.2.jar is available in the Spring-DM OSGi repository under at: org/springframework/osgi/mx4j.osgi/3.0.2-SNAPSHOT/mx4j.osgi-3.0.2-SNAPSHOT.jar\n\nG.1.2. Browsing the repository content\n\nThe repository is currently hosted at Amazon S3. To browse the repository structure, use a S3 compatible browser (such as this one) since a vanilla web browser will not be suitable.\n\nG.1.3. Using the repository with Maven\n\nThe use the repository, simply add it ot the repositories group; since the repository contains SNAPSHOT artifacts, make sure to mark it accordingly:\n\n```xml\n<repositories>\n <repository>\n <id>spring osgified artifacts</id>\n```\nG.1.4. Using the repository with Ant/Ivy\n\nWhen using Ant consider using the excellent Ivy subproject for retrieving the OSGi dependencies from the Spring-DM repository as Ivy can work with a Maven-style repository. Please see the Ivy tutorial for more information.\nAppendix H. Spring Dynamic Modules\n\nSchema\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<xsd:schema xmlns=\"http://www.springframework.org/schema/osgi\"\n xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"\n xmlns:beans=\"http://www.springframework.org/schema/beans\"\n xmlns:tool=\"http://www.springframework.org/schema/tool\"\n targetNamespace=\"http://www.springframework.org/schema/osgi\"\n elementFormDefault=\"qualified\"\n attributeFormDefault=\"unqualified\"\n version=\"1.1\">\n <xsd:import namespace=\"http://www.springframework.org/schema/beans\"/>\n <xsd:import namespace=\"http://www.springframework.org/schema/tool\"/>\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Namespace support for the core services provided by Spring Dynamic Modules.\n ]]]></xsd:documentation>\n </xsd:annotation>\n <xsd:attributeGroup name=\"defaults\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Defaults for Spring-DM OSGi declarations.\n ]]]></xsd:documentation>\n </xsd:annotation>\n <!-- attributes -->\n <xsd:attribute name=\"default-timeout\" type=\"xsd:long\" default=\"30000\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Default timeout (in milliseconds) for all reference (service importers) elements that do not explicitly specify one.\n Default value is 30000 ms (5 minutes).\n ]]]></xsd:documentation>\n </xsd:annotation>\n </xsd:attribute>\n <xsd:attribute name=\"default-cardinality\" type=\"TdefaultCardinalityOptions\" default=\"1..X\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Default cardinality (of the relationship to the backing service(s)) for all OSGi references elements that do not explicitly specify one.\n Default value is '1..X' (resolved to '1..1' for osgi:reference and '1..N' for osgi:list/set) if a backing service must exist (this is a mandatory service reference). A value of '0..X' (resolved to '0..1' for osgi:reference and '0..N' for osgi:list/set) indicates that it is acceptable to be no backing service (an optional service reference).\n ]]]></xsd:documentation>\n </xsd:annotation>\n </xsd:attribute>\n </xsd:attributeGroup>\n <xsd:simpleType name=\"TdefaultCardinalityOptions\">\n <xsd:restriction base=\"xsd:string\">\n <xsd:enumeration value=\"1..X\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n A backing service must exist (this is a mandatory service reference).\n ]]]></xsd:documentation>\n </xsd:annotation>\n </xsd:enumeration>\n <xsd:enumeration value=\"0..X\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n A backing service can be missing (this is an optional service reference).\n ]]]></xsd:documentation>\n </xsd:annotation>\n </xsd:restriction>\n </xsd:simpleType>\n <!-- reference -->\n <xsd:element name=\"reference\" type=\"TsingleReference\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Defines a reference to a service obtained via the OSGi service registry.\n ]]]></xsd:documentation>\n </xsd:annotation>\n </xsd:element>\n</xsd:schema>\n```\nSpring Dynamic Modules Schema\n\n```xml\n<xs:complexType name=\"Treference\">\n <xs:complexContent>\n <xs:extension base=\"beans:identifiedType\">\n <xs:sequence minOccurs=\"0\" maxOccurs=\"1\">\n <xs:element name=\"interfaces\" type=\"beans:listOrSetType\" minOccurs=\"0\" maxOccurs=\"1\">\n <xs:annotation>\n <xs:documentation><![CDATA[\n The set of service interfaces to advertise in the service registry.\n ]]>]]><xs:documentation/>\n </xs:annotation>\n </xs:element>\n <xs:element name=\"listener\" type=\"Tlistener\" minOccurs=\"0\" maxOccurs=\"unbounded\">\n <xs:annotation>\n <xs:documentation><![CDATA[\n Defines a listener that will receive notification when a service backing this reference is bound or unbound.\n ]]>]]><xs:documentation/>\n </xs:annotation>\n </xs:element>\n </xs:sequence>\n <xs:attribute name=\"interface\" use=\"optional\" type=\"xsd:token\">\n <xs:annotation>\n <xs:documentation><![CDATA[\n The service interface that the services obtained via the registry are required to support.\n By convention this is a Java interface type, but may also be a (non-final) class type.\n ]]>]]><xs:documentation/>\n </xs:annotation>\n </xs:attribute>\n <xs:attribute name=\"filter\" use=\"optional\" type=\"xsd:string\">\n <xs:annotation>\n <xs:documentation><![CDATA[\n Defines an OSGi filter expression that is used to constrain the set of matching services in the service registry.\n ]]>]]><xs:documentation/>\n </xs:annotation>\n </xs:attribute>\n <xs:attribute name=\"depends-on\" type=\"xsd:string\" use=\"optional\">\n <xs:annotation>\n <xs:documentation><![CDATA[\n Used to refer to the name of another bean that this bean depends on. Ensures that the service registry look-up does not happen until after the dependent bean has been created (most commonly used to refer to a bundle bean).\n ]]>]]><xs:documentation/>\n </xs:annotation>\n </xs:attribute>\n <xs:attribute name=\"bean-name\" type=\"xsd:string\" use=\"optional\">\n <xs:annotation>\n <xs:documentation><![CDATA[\n Convenient shortcut for specifying a filter expression that matches on the bean-name property that is automatically advertised for beans published using the service element.\n ]]>]]><xs:documentation/>\n </xs:annotation>\n </xs:attribute>\n <xs:attribute name=\"context-class-loader\" type=\"ReferenceClassLoaderOptions\" default=\"client\">\n <xs:annotation>\n <xs:documentation><![CDATA[\n Defines how the context class loader is managed when invoking operations on a service backing this service reference. The default value is 'client' which means the context class loader has visibility of the resources on this bundle's classpath. Other options are 'service-provider' which means that the context class loader has visibility of the resources on the bundle classpath of the bundle that exported the service; and 'unmanaged' which does not do any management of the context class loader.\n ]]>]]><xs:documentation/>\n </xs:annotation>\n </xs:attribute>\n </xs:extension>\n</xs:complexContent>\n</xs:complexType>\n```\n<xsd:simpleType name=\"TreferenceClassLoaderOptions\">\n <xsd:restriction base=\"xsd:NMTOKEN\">\n <xsd:enumeration value=\"client\"/>\n <xsd:enumeration value=\"service-provider\"/>\n <xsd:enumeration value=\"unmanaged\"/>\n </xsd:restriction>\n</xsd:simpleType>\n\n<xsd:complexType name=\"Tlistener\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Defines a listener that will be notified when the service backing the enclosing service reference is bound or unbound. Use either the 'ref' attribute or a nested bean declaration for the listener bean.\n ]]>></xsd:documentation>\n </xsd:annotation>\n <xsd:sequence minOccurs=\"0\" maxOccurs=\"1\">\n <!-- nested bean declaration -->\n <xsd:any namespace=\"##other\" minOccurs=\"1\" maxOccurs=\"1\" processContents=\"skip\"/>\n </xsd:sequence>\n\n <!-- shortcut for bean references -->\n <xsd:attribute name=\"ref\" type=\"xsd:string\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Refers by name to the bean that will receive bind and unbind events\n ]]>></xsd:documentation>\n </xsd:annotation>\n </xsd:attribute>\n <xsd:attribute name=\"bind-method\" type=\"xsd:token\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n The name of the method to be invoked when a backing service is bound.\n ]]>></xsd:documentation>\n </xsd:annotation>\n </xsd:attribute>\n <xsd:attribute name=\"unbind-method\" type=\"xsd:token\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n The name of the method to be invoked when a backing service is unbound.\n ]]>></xsd:documentation>\n </xsd:annotation>\n </xsd:attribute>\n</xsd:complexType>\n\n<!-- single reference -->\n<xsd:complexType name=\"Tsinglereference\">\n <xsd:complexContent>\n <xsd:extension base=\"Treference\">\n <xsd:attribute name=\"cardinality\" use=\"optional\" type=\"TsingleReferenceCardinality\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Defines the required cardinality of the relationship to the backing service. If not specified, the default-cardinality attribute will apply. A value is '1..1' means that a backing service must exist (this is a mandatory service reference). A value of '0..1' indicates that it is acceptable to be no backing service (an optional service reference).\n ]]>></xsd:documentation>\n </xsd:annotation>\n </xsd:attribute>\n <xsd:attribute name=\"timeout\" use=\"optional\" type=\"xsd:long\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n For a 'reference' element, the amount of time (in milliseconds) to wait for a backing service to be available when an operation is invoked. If not specified, the default-timeout attribute of the osgi element.\n ]]>></xsd:documentation>\n </xsd:annotation>\n </xsd:attribute>\n </xsd:extension>\n </xsd:complexContent>\n</xsd:complexType>\n\n<xsd:simpleType name=\"TsingleReferenceCardinality\">\n <xsd:restriction base=\"xsd:token\">\n <xsd:enumeration value=\"1..1\"/>\n <xsd:enumeration value=\"0..1\"/>\n </xsd:restriction>\n</xsd:simpleType>\n<xsd:element name=\"list\" type=\"TreferenceCollection\">\n <xsd:annotation>\n <xsd:documentation source=\"java:org.springframework.osgi.service.importer.support.OsgiServiceCollectionProxyFactoryBean\"><![CDATA[\nDefines a bean of type 'List' that contains all of the services matching the given criteria. The list members are managed dynamically as matching backing services come and go.]]></xsd:documentation>\n <xsd:appinfo>\n <tool:annotation>\n <tool:exports type=\"java.util.List\"/>\n </tool:annotation>\n </xsd:appinfo>\n </xsd:annotation>\n</xsd:element>\n\n<xsd:element name=\"set\" type=\"TreferenceCollection\">\n <xsd:annotation>\n <xsd:documentation source=\"java:org.springframework.osgi.service.importer.support.OsgiServiceCollectionProxyFactoryBean\"><![CDATA[\nDefines a bean of type 'Set' that contains all of the services matching the given criteria. The set members are managed dynamically as matching backing services come and go.]]></xsd:documentation>\n <xsd:appinfo>\n <tool:annotation>\n <tool:exports type=\"java.util.Set\"/>\n </tool:annotation>\n </xsd:appinfo>\n </xsd:annotation>\n</xsd:element>\n\n<xsd:complexType name=\"TreferenceCollection\">\n <xsd:complexContent>\n <xsd:extension base=\"Treference\">\n <xsd:sequence minOccurs=\"0\" maxOccurs=\"1\">\n <xsd:element name=\"comparator\" type=\"Tcomparator\">\n <xsd:annotation>\n <xsd:documentation source=\"java:java.util.Comparator\"><![CDATA[\nUsed to define an inline bean of type Comparator that will be used to sort the matching services.]]></xsd:documentation>\n <xsd:appinfo>\n <tool:annotation>\n <tool:expected-type type=\"java.util.Comparator\"/>\n </tool:annotation>\n </xsd:appinfo>\n </xsd:annotation>\n </xsd:element>\n </xsd:sequence>\n <xsd:attribute name=\"comparator-ref\" type=\"xsd:string\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\nUsed to refer to a named bean implementing the Comparator interface that will sort the matching services.]]></xsd:documentation>\n </xsd:annotation>\n </xsd:attribute>\n <xsd:attribute name=\"cardinality\" use=\"optional\" type=\"TcollectionCardinality\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\nDefines the required cardinality of the relationship to the backing services. If not specified, the default-cardinality attribute will apply. A value of '1..N' means that at least one backing service must exist (this is a mandatory service reference). A value of '0..N' indicates that it is acceptable for there to be no backing service (an optional service reference).]]></xsd:documentation>\n </xsd:annotation>\n </xsd:attribute>\n <xsd:attribute name=\"greedy-proxying\" use=\"optional\" type=\"xsd:boolean\" default=\"false\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\nIndicates whether the proxies created for the imported OSGi services will be generated using just the classes specified (false) or all the classes exported by the service and visible to the importing bundle (true). The default value is false.]]></xsd:documentation>\n </xsd:annotation>\n </xsd:attribute>\n </xsd:extension>\n </xsd:complexContent>\n</xsd:complexType>\n<xsd:complexType name=\"Tcomparator\">\n <xsd:annotation>\n <xsd:documentation source=\"java:java.util.Comparator\"><![CDATA[\n Used to define an inline bean of type Comparator that will be used to sort the matching services.\n ]]>></xsd:documentation>\n <xsd:appinfo>\n <tool:annotation>\n <tool:exports type=\"java.util.Comparator\"/>\n </tool:annotation>\n </xsd:appinfo>\n </xsd:annotation>\n <xsd:choice>\n <xsd:element name=\"natural\" type=\"TnaturalOrdering\"/>\n <xsd:sequence minOccurs=\"1\" maxOccurs=\"1\">\n <!-- nested bean declaration -->\n <xsd:any namespace=\"##other\" minOccurs=\"1\" maxOccurs=\"1\" processContents=\"skip\"/>\n </xsd:sequence>\n </xsd:choice>\n</xsd:complexType>\n\n<xsd:complexType name=\"TnaturalOrdering\">\n <xsd:attribute name=\"basis\" type=\"TorderingBasis\" use=\"required\"/>\n</xsd:complexType>\n\n<xsd:simpleType name=\"TorderingBasis\">\n <xsd:restriction base=\"xsd:token\">\n <xsd:enumeration value=\"service\"/>\n <xsd:enumeration value=\"service-reference\"/>\n </xsd:restriction>\n</xsd:simpleType>\n\n<xsd:simpleType name=\"TcollectionCardinality\">\n <xsd:restriction base=\"xsd:token\">\n <xsd:enumeration value=\"1..N\"/>\n <xsd:enumeration value=\"0..N\"/>\n </xsd:restriction>\n</xsd:simpleType>\n\n<xsd:element name=\"service\" type=\"Tservice\"/>\n\n<xsd:complexType name=\"Tservice\">\n <xsd:annotation>\n <xsd:documentation source=\"java:org.springframework.osgi.service.exporter.support.OsgiServiceFactoryBean\"><![CDATA[\n Exports the reference bean as a service in the OSGi service registry. The bean defined\n type org.osgi.framework.ServiceRegistration.\n ]]>></xsd:documentation>\n <xsd:appinfo>\n <tool:annotation>\n <tool:exports type=\"org.osgi.framework.ServiceRegistration\"/>\n </tool:annotation>\n </xsd:appinfo>\n </xsd:annotation>\n <xsd:complexContent>\n <xsd:extension base=\"beans:identifiedType\">\n <xsd:sequence minOccurs=\"0\" maxOccurs=\"1\">\n <xsd:element name=\"interfaces\" type=\"beans:listOrSetType\" minOccurs=\"0\" maxOccurs=\"1\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n The set of service interfaces to advertise in the service registry.\n ]]>></xsd:documentation>\n </xsd:annotation>\n </xsd:element>\n <xsd:element name=\"service-properties\" type=\"beans:mapType\" minOccurs=\"0\" maxOccurs=\"1\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Defines the service properties.\n ]]>></xsd:documentation>\n </xsd:annotation>\n </xsd:element>\n <xsd:element name=\"registration-listener\" type=\"TserviceRegistrationListener\" minOccurs=\"0\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Defines a listener that will be notified when this service is registered\n ]]>></xsd:documentation>\n </xsd:annotation>\n </xsd:element>\n </xsd:sequence>\n </xsd:extension>\n </xsd:complexContent>\n</xsd:complexType>\n<xsd:element name=\"TserviceRegistrationListener\">\n <xsd:complexType name=\"TserviceRegistrationListener\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\nDefines a listener that will be notified when the bean is registered or unregistered in the OSGi Service Registry. Use either the 'ref' attribute or a nested bean declaration for the listener bean.\n]]></xsd:documentation>\n </xsd:annotation>\n <xsd:seq minOccurs=\"0\" maxOccurs=\"1\">\n <!-- nested bean declaration -->\n <xsd:all namespace=\"##other\" minOccurs=\"1\" maxOccurs=\"1\" processContents=\"skip\"/>\n </xsd:seq>\n </xsd:complexType>\n</xsd:element>\n<xsd:element name=\"bundle\" type=\"Tbundle\">\n <xsd:annotation>\n <xsd:documentation source=\"java:org.springframework.osgi.bundle.BundleFactoryBean\"><![CDATA[\n Defines a bean representing a Bundle object. May be used to drive bean lifecycle transitions.\n ]]></xsd:documentation>\n <xsd:appinfo>\n <tool:annotation>\n <tool:expected-type type=\"org.osgi.framework.Bundle\"/>\n </tool:annotation>\n </xsd:appinfo>\n </xsd:annotation>\n</xsd:element>\n\n<xsd:complexType name=\"Tbundle\">\n <xsd:complexContent>\n <xsd:extension base=\"beans:identifiedType\">\n <!-- optional nested bean declaration -->\n <xsd:sequence minOccurs=\"0\" maxOccurs=\"1\">\n <xsd:any namespace=\"##other\" minOccurs=\"1\" maxOccurs=\"1\" processContents=\"lax\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n OSGi bundle to work with.\n ]]></xsd:documentation>\n <xsd:appinfo>\n <tool:annotation>\n <tool:expected-type type=\"org.osgi.framework.Bundle\"/>\n </tool:annotation>\n </xsd:appinfo>\n </xsd:annotation>\n </xsd:any>\n </xsd:sequence>\n </xsd:extension>\n </xsd:complexContent>\n</xsd:complexType>\n\n<xsd:complexType name=\"TserviceClassLoaderOptions\">\n <xsd:restriction base=\"xsd:token\">\n <xsd:enumeration value=\"service-provider\"/>\n <xsd:enumeration value=\"unmanaged\"/>\n </xsd:restriction>\n</xsd:complexType>\n\n<xsd:complexType name=\"TautoExportModes\">\n <xsd:restriction base=\"xsd:token\">\n <xsd:enumeration value=\"disabled\"/>\n <xsd:enumeration value=\"interfaces\"/>\n <xsd:enumeration value=\"class-hierarchy\"/>\n <xsd:enumeration value=\"all-classes\"/>\n </xsd:restriction>\n</xsd:complexType>\n\n<!-- shortcut for bean references -->\n<xsd:attribute name=\"ref\" type=\"xsd:string\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n Refers by name to the bean that will receive register and unregister events.\n ]]></xsd:documentation>\n </xsd:annotation>\n</xsd:attribute>\n\n<xsd:attribute name=\"registration-method\" type=\"xsd:token\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n The name of the method to be invoked when the service is registered.\n ]]></xsd:documentation>\n </xsd:annotation>\n</xsd:attribute>\n\n<xsd:attribute name=\"unregistration-method\" type=\"xsd:token\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n The name of the method to be invoked when the service is unregistered.\n ]]></xsd:documentation>\n </xsd:annotation>\n</xsd:attribute>\n\n<!-- bundle -->\n\n<xs:complexType name=\"Tbundle\">\n <xs:complexContent>\n <xs:extension base=\"beans:identifiedType\">\n <!-- optional nested bean declaration -->\n <xs:sequence minOccurs=\"0\" maxOccurs=\"1\">\n <xs:any namespace=\"##other\" minOccurs=\"1\" maxOccurs=\"1\" processContents=\"lax\">\n <xs:annotation>\n <xs:documentation><![CDATA[\n OSGi bundle to work with.\n ]]></xs:documentation>\n <xs:appinfo>\n <tool:annotation>\n <tool:expected-type type=\"org.osgi.framework.Bundle\"/>\n </tool:annotation>\n </xs:appinfo>\n </xs:annotation>\n </xs:any>\n </xs:sequence>\n </xs:extension>\n </xs:complexContent>\n</xs:complexType>\n\n<xsd:complexType name=\"Tbundle\">\n <xsd:complexContent>\n <xsd:extension base=\"beans:identifiedType\">\n <!-- optional nested bean declaration -->\n <xsd:sequence minOccurs=\"0\" maxOccurs=\"1\">\n <xsd:any namespace=\"##other\" minOccurs=\"1\" maxOccurs=\"1\" processContents=\"lax\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\n OSGi bundle to work with.\n ]]></xsd:documentation>\n <xsd:appinfo>\n <tool:annotation>\n <tool:expected-type type=\"org.osgi.framework.Bundle\"/>\n </tool:annotation>\n </xsd:appinfo>\n </xsd:annotation>\n </xs:any>\n </xsd:sequence>\n </xs:extension>\n </xs:complexContent>\n</xsd:complexType>\nThe bundle symbolic name of the bundle object. Normally used when interacting with an already installed bundle.\n\n</xsd:annotation>\n</xsd:attribute>\n\n<xsd:attribute name=\"depends-on\" type=\"xsd:string\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\nIndicates that this bundle object should not be created until the named bundle has been created.\n]]></xsd:documentation>\n </xsd:annotation>\n</xsd:attribute>\n\n<xsd:attribute name=\"location\" type=\"xsd:string\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\nLocation used to install, update or/and identify a bundle.\n]]></xsd:documentation>\n </xsd:annotation>\n</xsd:attribute>\n\n<xsd:attribute name=\"action\" type=\"TbundleAction\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\nLifecycle action to drive on the bundle. 'start' starts the bundle, installing if it is currently uninstalled. 'stop' stops the bundle if it is currently ACTIVE. 'install' installs the bundle if it is currently uninstalled. 'uninstall' stops the bundle if needed, and then uninstalls it. 'update' installs the bundle if needed, and then invokes the Bundle.update() operation.\n]]></xsd:documentation>\n </xsd:annotation>\n</xsd:attribute>\n\n<xsd:attribute name=\"destroy-action\" type=\"TbundleAction\" use=\"optional\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\nLifecycle action to drive on the bundle. 'start' starts the bundle, installing if it is currently uninstalled. 'stop' stops the bundle if it is currently ACTIVE. 'install' installs the bundle if it is currently uninstalled. 'uninstall' stops the bundle if needed, and then uninstalls it. 'update' installs the bundle if needed, and then invokes the Bundle.update() operation.\n]]></xsd:documentation>\n </xsd:annotation>\n</xsd:attribute>\n\n<xsd:attribute name=\"start-level\" type=\"xsd:int\" use=\"optional\" default=\"0\">\n <xsd:annotation>\n <xsd:documentation><![CDATA[\nStart level to set for the bundle.\n]]></xsd:documentation>\n </xsd:annotation>\n</xsd:attribute>\n\n</xsd:extension>\n</xsd:complexContent>\n</xsd:complexType>\n\n<xsd:simpleType name=\"TbundleAction\">\n <xsd:restriction base=\"xsd:token\">\n <xsd:enumeration value=\"start\"/>\n <xsd:enumeration value=\"stop\"/>\n <xsd:enumeration value=\"install\"/>\n <xsd:enumeration value=\"uninstall\"/>\n <xsd:enumeration value=\"update\"/>\n </xsd:restriction>\n</xsd:simpleType>\n\n</xsd:schema>\nAppendix I. Acknowledgments\n\nSpring Dynamic Modules would like to thank (in alphabetical order) to : Bill Gallagher, Olivier Gruber, Richard S. Hall, BJ Hargrave, Peter Kriens, Martin Lippert, Jeff McAffer, Glyn Normington, Gerd Wuetherich for their contributions in the development of this documentation."}}},{"rowIdx":282,"cells":{"id":{"kind":"string","value":"e545a96ff5809928ca2abeb20ac8dbbd4ff86553"},"text":{"kind":"string","value":"On the analysis of random replacement caches using static probabilistic timing methods for multi-path programs\nLesage, B.; Griffin, D.; Altmeyer, S.J.; Cucu-Grosjean, L.; Davis, R.I.\n\nPublished in:\nReal-Time Systems\n\nDOI:\n10.1007/s11241-017-9295-2\n\nCitation for published version (APA):\nOn the analysis of random replacement caches using static probabilistic timing methods for multi-path programs\n\nBenjamin Lesage¹ · David Griffin¹ · Sebastian Altmeyer² · Liliana Cucu-Grosjean³ · Robert I. Davis¹,³\n\n© The Author(s) 2017. This article is an open access publication\n\nAbstract Probabilistic hard real-time systems, based on hardware architectures that use a random replacement cache, provide a potential means of reducing the hardware over-provision required to accommodate pathological scenarios and the associated extremely rare, but excessively long, worst-case execution times that can occur in deterministic systems. Timing analysis for probabilistic hard real-time systems requires the provision of probabilistic worst-case execution time (pWCET) estimates. The pWCET distribution can be described as an exceedance function which gives an upper bound on the probability that the execution time of a task will exceed any given execution time budget on any particular run. This paper introduces a more effective static probabilistic timing analysis (SPTA) for multi-path programs. The analysis estimates the temporal contribution of an evict-on-miss, random replacement cache to the pWCET distribution of multi-path programs. The analysis uses a conservative join function that provides a proper over-approximation of the possible cache contents and the pWCET.\ndistribution on path convergence, irrespective of the actual path followed during execution. Simple program transformations are introduced that reduce the impact of path indeterminism while ensuring sound pWCET estimates. Evaluation shows that the proposed method is efficient at capturing locality in the cache, and substantially outperforms the only prior approach to SPTA for multi-path programs based on path merging. The evaluation results show incomparability with analysis for an equivalent deterministic system using an LRU cache. For some benchmarks the performance of LRU is better, while for others, the new analysis techniques show that random replacement has provably better performance.\n\n**Keywords** Cache analysis · Probabilistic timing analysis · Random replacement policy · Multi-path\n\n**Extensions**\n\nThis paper builds upon previous work published in RTSS 2015 (Lesage et al. 2015a) with the following extensions:\n\n- we introduce and prove additional properties relevant to the comparison of the contribution of different cache states to the probabilistic worst-case execution time of tasks in Sect. 3;\n- an improved join transfer function, used to safely merge states from converging paths, is introduced in Sect. 5 and by construction dominates the simple join introduced in Lesage et al. (2015a);\n- we present and prove the validity of path renaming in Sect. 6 which allows the definition of additional transformations to reduce the set of paths considered during analysis;\n- our evaluation explores new configurations in terms of both the analysis methods used and the benchmarks considered (see Sect. 7).\n\n**1 Introduction**\n\nReal-time systems such as those deployed in space, aerospace, automotive and railway applications require guarantees that the probability of the system failing to meet its timing constraints is below an acceptable threshold (e.g. a failure rate of less than $10^{-9}$ per hour for some aerospace and automotive applications). Advances in hardware technology and the large gap between processor and memory speeds, bridged by the use of cache, make it difficult to provide such guarantees without significant over-provision of hardware resources.\n\nThe use of deterministic cache replacement policies means that pathological worst-case behaviours need to be accounted for, even when in practice they may have a vanishingly small probability of actually occurring. The use of cache with a random replacement policy means that the probability of pathological worst-case behaviours can be upper bounded at quantifiably extremely low levels, for example well below the maximum permissible failure rate (e.g. $10^{-9}$ per hour) for the system. This allows\nthe extreme worst-case behaviours to be safely ignored, instead of always included in the estimated worst-case execution times.\n\nThe random replacement policy further offers a trade-off between performance and cost thanks to a minimal hardware cost (Al-Zoubi et al. 2004). The policy and variants have been implemented in a selection of embedded processors (Hennessy and Patterson 2011) such as the ARM Cortex series (2010), or the Freescale MPC8641D (2008). Randomisation further offers some level of protection against side-channel attacks which allow the leakage of information regarding the running tasks. While methods relying solely on the random replacement policy may still be circumvented (Spreitzer and Plos 2013), the definition of probabilistic timing analysis is a step towards the analysis of other approaches such as randomised placement policies (Wang and Lee 2007; 2008).\n\nThe timing behaviour of programs running on a processor with a cache using a random replacement policy can be determined using static probabilistic timing analysis (SPTA). SPTA computes an upper bound on the probabilistic Worst-Case Execution Time (pWCET) in terms of an exceedance function. This exceedance function gives the probability, as a function of all possible values for an execution time budget $x$, that the execution time of the program will exceed that budget on any single run. The reader is referred to Davis et al. (2013) for examples of pWCET distributions, and to Cucu-Grosjean (2013) for a detailed discussion of what is meant by a pWCET distribution.\n\nThis paper introduces an effective SPTA for multi-path programs running on hardware that uses an evict-on-miss, random replacement cache. Prior work on SPTA for multi-path programs by Davis et al. (2013) used a path merging approach to compute cache hit probabilities based on reuse distances. The analysis derived in this paper builds upon more sophisticated SPTA techniques for the analysis of single path programs given by Altmeyer and Davis (2014, 2015). This new analysis provides substantially improved results compared to the path merging approach. To allow the analysis of the behaviour of caches in isolation, we assume the existence of a valid decomposition of the architecture with regards to cache effects with bounded hit and miss latencies (Hahn et al. 2015).\n\n1.1 Related work\n\nWe now set the work on SPTA in context with respect to related work on both probabilistic hard real-time systems and cache analysis for deterministic replacement policies. The methods introduced in this paper belong to the realm of analyses that estimate bounds on the execution time of a program. These bounds may be classified as either a worst-case probability distribution (pWCET) or a worst-case value (WCET).\n\nThe first class is a more recent research area with the first work on providing bounds described by probability distributions published by Edgar and Burns (2000, 2001). The methods for obtaining such distributions can be categorised into three different families: measurement-based probabilistic timing analyses, static probabilistic timing analyses, and hybrid probabilistic timing analyses.\nThe second class is a mature area of research and the interested reader may refer to Wilhelm et al. (2008) for an overview of these methods. A specific overview of cache analysis for deterministic replacement policies together with a comparison between deterministic and random cache replacement policies is provided at the end of this section.\n\n1.1.1 Probabilistic timing analyses\n\nMeasurement-based probabilistic timing analyses (Bernat et al. 2002; Cucu-Grosjean et al. 2012) collect observations on the execution time of the task under study on the target hardware. These observations are then combined, e.g. through the use of extreme value theory (Cucu-Grosjean et al. 2012), to produce the desired worst-case probabilistic timing estimate. Extreme Value Theory may potentially underestimate the pWCET of a program as shown by Griffin and Burns (2010). The work of Cucu-Grosjean et al. (2012) overcomes this limitation and also introduces the appropriate statistical tests required to treat worst-case execution times as rare events. The soundness of the results produced by such methods is tied to the observed execution times which should be representative of the ones at runtime. This implies a responsibility on the user who is expected to provide input data to exercise the worst-case paths, less the analysis results in unsound estimates (Lesage et al. 2015b). These methods nonetheless exhibit the benefits of time-randomised architectures. The occurrence probability of pathological temporal cases can be bounded and safely ignored provided they meet requirements expressed in terms of failure rates.\n\nPath upper-bounding (Kosmidis et al. 2014) defines a set of program transformations to alleviate the responsibility of the user to provide inputs which cover all execution paths. The alternative paths of conditional constructs are padded with semantic-preserving instructions and memory accesses such that any path followed in the modified program is an upper-bound of any of the original alternatives. Measurement-based analyses can then be performed on the modified program as the paths exercised at runtime upper-bound any alternative in the original application. Hence, upper-bounding creates a distinction between the original code and the measured one. It may also result in paths which are the sum of the original alternatives.\n\nHybrid probabilistic timing analyses are methods that apply measurement-based methods at the level of sub-programs or blocks of code and then operations such as convolution to combine these bounds to obtain a pWCET for the entire program. The main principles of hybrid analysis were introduced by Bernat et al. (2002, 2003) with execution time probability distributions estimated at the level of sub-programs. Here, dependencies may exist among the probability distributions of the sub-programs and copulas are used to describe them (Bernat et al. 2005).\n\nBy contrast, SPTAs derive the pWCET distribution for a program by analysing the structure of the program and modelling the behaviour of the hardware it runs on. Existing work on SPTA has primarily focussed on randomized architectures containing caches with random replacement policies. Initial results for the evict-on-miss (Quinones et al. 2009) and evict-on-access (Cucu-Grosjean et al. 2012; Cazorla et al. 2013) policies were derived for single-path programs. These methods use the reuse distance of each access to determine its probability of being a cache hit. These results...\nwere superseded by later work by Davis et al. (2013) who derived an optimal lower bound on the probability of a cache hit under the evict-on-miss policy, and showed that evict-on-miss dominates evict-on-access. Altmeyer and Davis (2014) proved the correctness of the lower bound derived in Davis et al. (2013), and its optimality with regards to the limited information that it uses (i.e. the reuse distance). They also showed that the probability functions previously given in Kosmidis et al. (2013) and Quinones et al. (2009) are unsound (optimistic) for use in SPTA. In 2013, a simple SPTA for multipath programs was introduced by Davis et al. (2013), based on path merging. With this method, accesses are represented by their reuse distances. The program is then virtually reduced to a single sequence which upper-bounds all possible paths with regards to the reuse distance of their accesses.\n\nIn 2014, more sophisticated SPTA methods for single path programs were derived by Altmeyer and Davis (2014). They introduced the notion of cache contention, which combined with reuse distance enables the computation of a more precise bound on the probability that a given access is a cache hit. Altmeyer and Davis (2014) also introduced a significantly more effective method based on combining exhaustive evaluation of the cache behaviour for a limited number of relevant memory blocks with cache contention. This method provides an effective trade-off between analysis precision and tractability. Griffin et al. (2014a) introduces orthogonal Lossy compression methods on top of the cache states enumeration to improve the trade-off between complexity and precision.\n\nAltmeyer and Davis further refined their approach to SPTA for single path programs in 2015 (Altmeyer et al. 2015), bridging the gap between contention and enumeration-based analyses. The method relies on simulation of the behaviour of a random replacement cache. As opposed to exhaustive state analyses however, focus is set at each step on a single cache state to capture the outcome across all possible states. The resulting approach offers an improved precision over contention-based methods, at a lower complexity than exhaustive state analyses.\n\nIn this paper, we build upon the state-of-the-art approach (Altmeyer and Davis 2014), extending it to multi-path programs. The techniques introduced in the following notably allow for the identification of control flow convergence of relevant cache contents, i.e. the identification of the outcomes in multi-path programs. The approach focuses on the enumeration of possible cache states at each point in the program. To reduce the complexity of such an approach, only a few blocks, identified as the most relevant, are analysed at a given time.\n\n1.1.2 Deterministic architectures and analyses\n\nStatic timing analysis for deterministic caches (Wilhelm et al. 2008) relies on a two step approach with a low-level analysis to classify the cache accesses into hits and misses (Theiling et al. 1999) and a high-level analysis to determine the length of the worst-case path (Li and Malik 2006). The most common deterministic replacement policies are least-recently used (LRU), first-in first-out (FIFO) and pseudo-LRU (PLRU). Due to the high-predictability of the LRU policy, academic research typically focusses on LRU caches—with a well-established LRU cache analysis based on abstract interpretation (Alt et al. 1996; Theiling et al. 1999). Only recently, analyses for FIFO (Grund and\nReineke (2010) and PLRU (Grund and Reineke 2010; Griffin et al. 2014b) have been proposed, both with a higher complexity and lower precision than the LRU analysis due to specific features of the replacement policies. Despite the focus on LRU caches and its analysability, FIFO and PLRU are often preferred in processor designs due to the lower implementation costs which enable higher associativities.\n\nRecently, Reineke (2014) observed that SPTA based on reuse distances (Davis et al. 2013) results, by construction, in less precise bounds than existing analyses based on stack distance for an equivalent system with a LRU cache (Wilhelm et al. 2008). However, this does not hold for the more sophisticated SPTA based on cache contention and collecting semantics given by Altmeyer and Davis (2014). Analyses for deterministic LRU caches are incomparable with these analyses for random replacement caches. This is illustrated by our evaluation results. It can also be seen by considering simple examples such as a repeated sequence of accesses to five memory blocks \\(\\langle a, b, c, d, e, a, b, c, d, e \\rangle\\) with a four-way associative cache. With LRU, no hits can be predicted. By contrast, with a random replacement cache and SPTA based on cache contention, four out of the last five accesses can be assumed to have a non-zero probability of being a cache hit (as shown in Table 1 of Altmeyer and Davis 2014), hence SPTA for a random replacement cache outperforms analysis of LRU in this case.\n\nWe note that in spite of recent efforts (de Dinechin et al. 2014) the stateless random replacement policies have lower silicon costs than LRU, and so can potentially provide improved real-time performance at lower hardware cost.\n\nEarly work (David and Puaut 2004; Liang and Mitra 2008) in the domain of SPTA for deterministic architectures relied for its correctness on knowledge of the probability that a specific path would be taken or that specific input data would be encountered; however, in general such assumptions may not be available. The analysis given in this paper does not require any assumption about the probability distribution of different paths or inputs. It relies only on the random selection of cache lines for replacement.\n\n1.2 Organisation\n\nIn this paper, we introduce a set of methods that are required for the application of SPTA to multi-path programs. Section 2 recaps the assumptions and methods upon which we build. These were used in previous work (Altmeyer and Davis 2014) to upper-bound the pWCET distribution of a trace corresponding to a single path program. We then proceed by defining key properties which allows the ordering of cache states w.r.t. their contribution to the pWCET of a program (Sect. 3). We address the issue of multi-path programs in the context of SPTA in Sect. 4. This includes the definition of conservative (over-approximate) join functions to collect information regarding cache contention, possible cache contents, and the pWCET distribution at each program point, irrespective of the path followed during execution. Further improvements on cache state conservation at control flow convergence are introduced in Sect. 5. Section 6 introduces simple program transformations which improve the precision of the analysis while ensuring that the pWCET distribution of the transformed program remains sound (i.e. upper-bounds that of the original). Multi-path SPTA is applied to a selection of benchmarks in Sect. 7 and the precision and run-time of the different approaches\n2 Static probabilistic timing analysis\n\nIn this section, we recap on state-of-the-art SPTA techniques for single path programs (Altmeyer and Davis 2014). We first give an overview of the system model assumed throughout the paper in Sect. 2.1. We further recap on the existing methods (Altmeyer and Davis 2014) to evaluate the pWCET of a single path trace using a collecting approach (Sect. 2.2) supplemented by a contention one. The pertinence of the model is discussed at the end of this section. The notations introduced in the present contributions have been summarised in Table 1.\n\nWe assume an architecture for which a valid decomposition exists with regards to the cache, such that its timing contribution can be analysed in isolation from other components (Hahn et al. 2015). Further, the overall execution time penalty emanating from cache misses and hits are assumed to be bounded by the latencies assumed by the analysis. Thus a local worst-case, a miss in the context of the cache, can be added to the local worst-case for other components to obtain a bound on the global worst case (Reineke et al. 2006). This enables analysis of the impact of the cache in isolation from other architectural features.\n\n2.1 Cache model\n\nWe assume a single level, private, \\( N \\)-way fully-associative cache with an evict-on-miss random replacement policy. On an access, should the requested memory block be absent from the cache then the contents of a randomly selected cache line are evicted. The requested memory block is then loaded into the selected location. Given that there are \\( N \\) ways, the probability of any given cache line being selected by the replacement policy is \\( \\frac{1}{N} \\). We assume a fixed upper-bound on the hit and miss latencies, denoted by \\( H \\) and \\( M \\) respectively, such that \\( H < M \\). (We note that the restriction to a fully-associative cache can be easily lifted for a set-associative cache through the analysis of each cache set as an independent fully-associative cache.)\n\n2.2 Collecting semantics\n\nWe now recap on the collecting semantics introduced by Altmeyer and Davis (2014) as a more precise but more complex alternative to the contention-based method of computing pWCET estimates. This approach performs exhaustive cache state enumeration for a selection of relevant accesses, hence providing tight analysis results for those accesses. To prevent state explosion, at each point in the program no more than \\( R \\) memory blocks are relevant at the same time. The relevant accesses are ones heuristically identified as benefiting the most from a precise analysis.\n\nA trace \\( t \\) is defined as an ordered sequence \\( [e_1, \\ldots, e_n] \\) of \\( n \\) accesses to memory blocks, such that \\( e_i = e_j \\) if accesses \\( e_i \\) and \\( e_j \\) target the same memory block. If access\n### Table 1 Summary of introduced notations\n\n<table>\n<thead>\n<tr>\n<th>Notation</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>pWCET</td>\n<td>Upper-bound on the execution time distribution of a program over all paths</td>\n</tr>\n<tr>\n<td>$\\mathcal{H}$</td>\n<td>Upper-bound on the latency incurred by a cache hit</td>\n</tr>\n<tr>\n<td>$\\mathcal{M}$</td>\n<td>Upper-bound on the latency incurred by a cache miss</td>\n</tr>\n<tr>\n<td>$N$</td>\n<td>Cache associativity</td>\n</tr>\n<tr>\n<td>$\\mathcal{E}$</td>\n<td>Set of accessed cache blocks</td>\n</tr>\n<tr>\n<td>$\\mathcal{E} \\perp$</td>\n<td>Set of accessed cache blocks including non-relevant elements $\\perp$</td>\n</tr>\n<tr>\n<td>$t = [e_1, \\ldots, e_i]$</td>\n<td>A trace, a sequence of accesses to memory blocks</td>\n</tr>\n<tr>\n<td>$\\mathcal{D}$</td>\n<td>Execution time or cache miss probabilistic distribution</td>\n</tr>\n<tr>\n<td>$\\mathcal{D}(x)$</td>\n<td>Occurrence probability of execution time $x$</td>\n</tr>\n<tr>\n<td>$P(\\mathcal{D} \\geq x)$</td>\n<td>Likelihood that distribution $\\mathcal{D}$ exceeds execution time $x$</td>\n</tr>\n<tr>\n<td>$s \\in \\mathcal{CS}$</td>\n<td>Analysed cache state $(C, P, \\mathcal{D}) = s$</td>\n</tr>\n<tr>\n<td>$\\mathcal{D}_{\\text{init}}$</td>\n<td>Initial, empty execution time distribution</td>\n</tr>\n<tr>\n<td>$S \\in 2^\\mathcal{CS}$</td>\n<td>Set of possible caches states at a specific program point</td>\n</tr>\n<tr>\n<td>$S \\uplus S'$</td>\n<td>Weighted merge on cache states, merge probability and distributions for cache states with identical contents</td>\n</tr>\n<tr>\n<td>$u(s, e)$</td>\n<td>Update cache state $s$ upon access to element $e$, replacing a line and increasing the corresponding distribution $\\mathcal{D}$ upon a miss</td>\n</tr>\n<tr>\n<td>$U(S, e)$</td>\n<td>Update each cache state in set $S$ upon access to element $e$</td>\n</tr>\n<tr>\n<td>$rd(e, t)$</td>\n<td>Reuse distance of element $e$ in trace $t$, upper-bound on the number of evictions since the last access to $e$</td>\n</tr>\n<tr>\n<td>$frd(e, t)$</td>\n<td>Forward reuse distance of element $e$ in trace $t$, upper-bound on the number of evictions before the next access to $e$</td>\n</tr>\n<tr>\n<td>$con(e, t)$</td>\n<td>Cache contention for element $e$ in trace $t$, bound on the number of blocks contending for cache space since the last access to $e$</td>\n</tr>\n<tr>\n<td>$\\mathcal{P}(e_i^{\\text{hit}})$</td>\n<td>Lower-bound on the probability of access $e_i$ to hit in cache</td>\n</tr>\n<tr>\n<td>$\\hat{\\xi}_i$</td>\n<td>Upper-bound on the execution time probability of element $e_i$, expressed as a probability mass function</td>\n</tr>\n<tr>\n<td>$\\hat{\\mathcal{D}}(t)$</td>\n<td>Upper-bound on the execution time distribution of trace $t$</td>\n</tr>\n<tr>\n<td>$\\mathcal{D}(t, s)$</td>\n<td>Execution time distribution of trace $t$ starting from cache state $s$</td>\n</tr>\n<tr>\n<td>$\\mathcal{D}(t, S)$</td>\n<td>Execution time distribution of trace $t$ starting from possible cache states $S$</td>\n</tr>\n<tr>\n<td>$\\mathcal{D} \\otimes \\mathcal{D}'$</td>\n<td>Convolution of distributions $\\mathcal{D}$ and $\\mathcal{D}'$</td>\n</tr>\n<tr>\n<td>$\\mathcal{D} \\otimes \\mathcal{D}'$</td>\n<td>Least upper-bound of distributions $\\mathcal{D}$ and $\\mathcal{D}'$</td>\n</tr>\n<tr>\n<td>$\\mathcal{D} \\leq \\mathcal{D}'$</td>\n<td>Distribution $\\mathcal{D}'$ upper-bounds $\\mathcal{D}$, iif $\\forall x$, $P(\\mathcal{D} \\geq x) \\leq P(\\mathcal{D}' \\geq x)$</td>\n</tr>\n<tr>\n<td>$G = (V, L, v_s, v_e)$</td>\n<td>Control flow graph $G$ capturing possible paths in a program, including:</td>\n</tr>\n<tr>\n<td>$V$</td>\n<td>Set of nodes in the program, each corresponding to an accessed element;</td>\n</tr>\n<tr>\n<td>$L$</td>\n<td>Set of edges between nodes;</td>\n</tr>\n</tbody>\n</table>\nTable 1 continued\n\n<table>\n<thead>\n<tr>\n<th>Notation</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$v_s \\in V$</td>\n<td>Start node in the program;</td>\n</tr>\n<tr>\n<td>$v_e \\in V$</td>\n<td>End node in the program</td>\n</tr>\n<tr>\n<td>$\\pi = [v_1, \\ldots, v_k]$</td>\n<td>Path from node $v_1$ to $v_k$, valid sequence of nodes in a CFG</td>\n</tr>\n<tr>\n<td>$v_i \\to^* v_j$</td>\n<td>Set of paths from $v_i$ to $v_j$</td>\n</tr>\n<tr>\n<td>$\\text{dom}(v_n)$</td>\n<td>Dominators of node $v_n$, nodes guaranteed to be traversed before $v_n$ from the CFG entry $v_s$</td>\n</tr>\n<tr>\n<td>$\\text{post-dom}(v_n)$</td>\n<td>Post-dominators of node $v_n$, nodes guaranteed to be traversed after $v_n$ to the CFG exit $v_e$</td>\n</tr>\n<tr>\n<td>$\\Pi(V)$</td>\n<td>All paths with nodes included exclusively in set of vertices $V$</td>\n</tr>\n<tr>\n<td>$\\Pi(G)$</td>\n<td>All paths from the start to the end of CFG $G$</td>\n</tr>\n<tr>\n<td>$\\hat{D}(\\pi)$</td>\n<td>Upper-bound on the execution time distribution of path $\\pi$</td>\n</tr>\n<tr>\n<td>$\\hat{D}(G)$</td>\n<td>pWCET of $G$, upper-bound on the execution time of its paths</td>\n</tr>\n<tr>\n<td>$\\text{rd}^G(v)$</td>\n<td>Maximum reuse distance of node $v$ across all paths in $G$ leading to $v$</td>\n</tr>\n<tr>\n<td>$\\text{frd}^G(v)$</td>\n<td>Maximum forward reuse distance of node $v$ across all paths in $G$ leading to $v$</td>\n</tr>\n<tr>\n<td>$\\text{con}^G(v)$</td>\n<td>Maximum contention of node $v$ across all paths in $G$ leading to $v$</td>\n</tr>\n<tr>\n<td>$s \\subseteq S$</td>\n<td>Cache state $s$ holds less pessimistic information than the set of cache states $S$</td>\n</tr>\n<tr>\n<td>$S \\subseteq S'$</td>\n<td>The set of cache states $S$ holds less pessimistic information than states in $S'$</td>\n</tr>\n<tr>\n<td>$S \\sqcup S'$</td>\n<td>Upper-bound on cache states $S$ and $S'$, more pessimistic than both $S$ and $S'$</td>\n</tr>\n<tr>\n<td>$C \\preceq_{\\text{rank}} C'$</td>\n<td>Ranking of cache contents $C$, used for heuristic comparison of contents based on their expected contribution to execution time distribution</td>\n</tr>\n<tr>\n<td>$\\text{Flush}(S)$</td>\n<td>Empty the contents of all cache states in $S$</td>\n</tr>\n</tbody>\n</table>\n\n$e_j$ is relevant, the block it accesses will be considered relevant until the next non-relevant access to the same block. The precise approach is only applied for relevant accesses while the contention-based method outlined in Sect. 2.2.1 is used for the others, identified as $\\perp$ in the trace of relevant blocks. The set of elements in a trace becomes $E_{\\perp} = E \\cup \\{\\perp\\}$.\n\nThe abstract domain of the analysis is a set of cache states. A cache state is a triplet $CS = (C, P, D)$ with cache contents $C$, a corresponding probability $P \\in \\mathbb{R}$, $0 < P \\leq 1$, and a miss distribution $D: \\mathbb{N} \\rightarrow \\mathbb{R}$ when the cache is in state $C$. $C$ is a set of at most $N$ memory blocks picked from $E$. A cache state which holds less than $N$ memory blocks represents partial knowledge about the cache contents without any distinction between empty lines or unknown contents. The set of all cache states is denoted by $CS$. Miss distribution $D$ captures for each possible number of misses $n$, the probability that $n$ misses occurred from the beginning of the program up to the current point in the program. The method computes all possible behaviours of the random cache with the associated probabilities. It is thus correct by construction as it simply enumerates all states exhaustively.\n\n1 This suits evict-on-miss caches which do not prioritize empty lines when filling the cache.\nThe analysis starts from the empty cache state \\(\\{(\\emptyset, 1, D_{\\text{init}})\\}\\) where\n\n\\[\nD_{\\text{init}}(x) = \\begin{cases} 1 & \\text{if } x = 0 \\\\ 0 & \\text{otherwise} \\end{cases}\n\\] \n\n(1)\n\nThe update function \\(u\\) describes the update for a single cache state upon access to element \\(e \\in \\mathbb{E}^\\perp\\). Upon accessing a relevant element \\(e \\neq \\perp\\), if \\(e\\) is present in the cache, its contents are left unchanged. Otherwise new cache states need to be generated considering that each element may be evicted with the same probability \\(\\frac{1}{N}\\) (in the \\(\\text{evict}\\) function). A miss is accounted for in the resulting distributions \\(D'\\) only upon misses on a relevant access. Formally:\n\n\\[\nu : \\mathbb{CS} \\times \\mathbb{E}^\\perp \\rightarrow 2^{\\mathbb{CS}}\n\\]\n\n(2)\n\n\\[\nu((C, P, D), e) = \\begin{cases} \\{(C, P, D)\\} & \\text{if } e \\in C \\land e \\neq \\perp \\\\ \\text{evict}((C, P, D), e) & \\text{otherwise} \\end{cases}\n\\]\n\n(3)\n\n\\[\n\\text{evict}((C, P, D), e) = \\begin{cases} \\{(C \\setminus \\{e\\} \\cup \\{e\\}, P \\cdot \\frac{1}{N}, D') \\mid e' \\in C \\} & \\text{if } e \\neq \\perp \\\\ \\{(C \\setminus \\{e\\}, P \\cdot \\frac{N-|C|}{N}, D') \\} & \\text{if } e = \\perp \\\\ \\end{cases}\n\\]\n\n(4)\n\n\\[\nD'(x) = \\begin{cases} D(x) & \\text{if } e = \\perp \\\\ 0 & \\text{if } x = 0 \\\\ D(x-1) & \\text{otherwise} \\end{cases}\n\\]\n\n(5)\n\nThe \\(\\text{evict}(s, e)\\) function creates \\(N\\) different cache states, one per possible evicted element, some of which might represent the same cache contents. To reduce the state space, a merge operation \\(\\bigoplus\\) combines two cache states if they contain exactly the same memory blocks. If merging occurs, each distribution is weighted by its probability:\n\n\\[\n\\bigoplus : 2^{\\mathbb{CS}} \\rightarrow 2^{\\mathbb{CS}}\n\\]\n\n(6)\n\n\\[\n\\bigoplus \\left\\{ \\begin{array}{c} (C_0, P_0, D_0) \\\\ \\vdots \\\\ (C_n, P_n, D_n) \\end{array} \\right\\} = \\left\\{ \\text{Merge} \\left( \\{(C_i, P_i, D_i) \\mid C_i = C_j \\} \\right) \\mid 0 \\leq j \\leq n \\right\\}\n\\]\n\n(7)\n\n\\[\n\\text{Merge} \\left\\{ \\begin{array}{c} (C_0, P_0, D_0) \\\\ \\vdots \\\\ (C_n, P_n, D_n) \\end{array} \\right\\} = \\left( C_0, \\sum_{i=0}^{n} P_i, \\sum_{i=0}^{n} \\frac{P_i}{P_k} \\cdot D_i \\right)\n\\]\n\n(8)\n\nwhere \\(p \\cdot D\\) denotes the multiplication of the elements of distribution \\(D\\), \\((p \\cdot D)(x) = p \\cdot D(x)\\), and \\(D_1 + D_2\\) is the summation of two distributions, \\((D_1 + D_2)(x) = D_1(x) + D_2(x)\\).\n\nThe update function can be defined for a set of cache states using the update function \\(u\\) for a single cache state and the \\(\\bigoplus\\) merge operator as follows:\n\n\\[\nU : 2^{\\mathbb{CS}} \\times \\mathbb{E}^\\perp \\rightarrow 2^{\\mathbb{CS}}\n\\]\n\n(9)\n\n\\[\nU(S, e) = \\bigcup \\{ u(CS, e) \\mid CS \\in S \\}\n\\]\n\n(10)\nGiven $S_{res}$, the set of cache states at the end of the execution of a trace $t$, the miss distribution $\\hat{D}_{miss}$ of the relevant blocks in $t$ is the sum of the individual distributions of each cache state weighted by their probability of occurrence:\n\n$$\\hat{D}_{miss} = \\sum \\{ P \\cdot D \\mid (C, P, D) \\in S_{res} \\}$$ (11)\n\nThe corresponding execution time distribution, $\\hat{D}$, can then be derived, for a trace of $n$ accesses, as follows:\n\n$$\\hat{D}(m \\times M + (n - m) \\times H) = \\hat{D}_{miss}(m)$$ (12)\n\n### 2.2.1 Non-relevant blocks analysis\n\nOne possible naive approach for non-relevant blocks would be to classify them as misses in the cache and add the resulting latency to the previously computed distributions. The collecting approach proposed by Altmeyer and Davis (2014) relies on the application of the contention methods to estimate the behaviour of the non-relevant blocks in a trace. Each access in a trace has a probability of being a cache hit $P(e_i^{hit})$, and of being a cache miss $P(e_i^{miss}) = 1 - P(e_i^{hit})$. These methods rely on different metrics to lower-bound the hit probability of each access such that the derived bound can be soundly convolved.\n\nThe reuse distance $rd(e)$ of element $e$ is the maximum number of accesses to consecutively different blocks since the last access to the same block. It captures an upper-bound on the maximum number of possible evictions between two accesses to the same block, similarly to the stack distance for LRU caches. It differs from the stack distance in that accesses to the same intermediate block may thus be accounted for multiple times if they may have been evicted during the access sequence. Should there be no such prior access to the same block, the reuse distance is defined as $\\infty$. Given the set of all traces $T$ and of all elements $E$, the reuse distance is formally defined as:\n\n$$rd : E \\times T \\to \\mathbb{N} \\cup \\{\\infty\\}$$\n\n$$rd(e_i, [e_1, \\ldots, e_{i-1}]) = \\begin{cases} \\{ \\{k \\mid j < k < i \\land e_k \\neq e_{k-1}\\} \\} & \\text{if } e_i = e_j \\land \\\\\n\\infty & \\forall k : j < k < i, e_i \\neq e_k \\land \\end{cases}$$ (13)\n\nNote that this definition of the reuse distance is a variation of the one proposed in earlier work. The revised equation (13) computes the same property, but has to discard successive accesses to the same block. Successive accesses to the same memory block lead to guaranteed cache hits under an evict-on-miss cache replacement policy. Traces are thus collapsed in Altmeyer et al. (2015) to remove all successive accesses to the same memory block. The number of cache misses is not impacted and cache hits can later be accounted for as an additional contribution to the trace. This last step is not straightforward for multi-path programs as the number of guaranteed hits varies on different paths.\nConversely, we define the forward reuse distance \\( frd(e) \\) of an element \\( e \\) as the maximum number of possible evictions before the next access to the same block. If its block is not reused before the end of the trace, the forward reuse distance of an access is defined as \\( \\infty \\):\n\n\\[\nfrd : E \\times T \\rightarrow \\mathbb{N} \\cup \\{\\infty\\}\nfrd(e_i, [e_{i+1}, \\ldots, e_m]) = \\begin{cases} \n|\\{k | j < k < i \\land e_k \\neq e_{k-1}\\}| & \\text{if } e_i = e_j, \\\\\n\\infty & \\forall k : i < k < j, e_i \\neq e_k \n\\end{cases}\n\\]\n\n(14)\n\nThe probability of \\( e_i \\) being a hit is set to 0 if there are more blocks since the last access to the same block that contend for cache space than the \\( N \\) available lines. This is captured by the cache contention \\( con(e_i, t) \\) (Altmeyer and Davis 2014) of element \\( e_i \\) in trace \\( t \\). The definition of \\( \\hat{P}(e_i^{\\text{hit}}) \\) which denotes a lower bound on the actual probability \\( P(e_i^{\\text{hit}}) \\) of a cache hit is as follows:\n\n\\[\n\\hat{P}(e_i^{\\text{hit}}) = \\begin{cases} \n0 & con(e_i, t) \\geq N \\\\\n\\left(\\frac{N}{N - 1}\\right)^{rd(e_i, t)} & \\text{otherwise}\n\\end{cases}\n\\]\n\n(15)\n\nThe cache contention \\( con(e) \\) (Altmeyer and Davis 2014) of element \\( e \\) captures the number of cache blocks which contend with \\( e \\) for space in the cache. It includes all potential hits and the \\( R \\) relevant blocks, denoted \\( \\text{relevant\\_blocks} \\), since we have to assume they occupy a separate location in the cache. Contention depends on and contributes to the potential hits captured by \\( \\hat{P}(e_i^{\\text{hit}}), j < i \\), and is computed from the first accesses, where \\( rd(e_i, t) = \\infty \\), to the last. The contention also accounts for the first miss \\( e_r \\) which follows the previous access to the same memory block as \\( e_i \\) and hence contends with \\( e_i \\). The replacement policy means that \\( e_r \\) always contends for space. The cache contention is formally defined as:\n\n\\[\ncon : E \\times T \\rightarrow \\mathbb{N} \\cup \\{\\infty\\}\ncon(e_i, t) = \\begin{cases} \n\\infty & \\text{if } rd(e_i, t) = \\infty \\\\\n|\\{e_k | k \\in conS(e_i, t) \\land e_k \\notin \\text{relevant\\_blocks}\\}| + R & \\text{otherwise}\n\\end{cases}\n\\]\n\n(16)\n\nwith\n\n\\[\nconS(e_i, t) = \\{j | e_j \\in t \\land \\hat{P}(e_j^{\\text{hit}}) \\neq 0 \\land k < j < i \\land e_k \\\\\n= e_i \\land \\forall x : k < x < i, e_i \\neq e_x \\}\n\\cup \\{r | rd(e_i, t) \\neq 0 \\land \\\\\nr = \\min\\{x | \\hat{P}(e_x^{\\text{hit}}) = 0 \\land k < x < i \\land e_k \\\\\n= e_i \\land \\forall y : k < y < i, e_i \\neq e_y\\}\\}\n\\]\n\n(17)\nExample We now illustrate the distinction between cache contention and reuse distance in identifying accesses with a null hit probability in (15). Consider the following sequence of accesses, on a 4 line fully-associative cache, where the reuse distance of each access is given as a super-script:\n\n\\[ a, b, c, b^1, d, f, a^5, b^3, c^5, d^4, f^4 \\]\n\nAll second accesses to blocks \\(a, b, c, d,\\) and \\(f\\) have a non-zero chance to hit when considered in isolation. However as highlighted in Altmeyer and Davis (2014), those cannot be simply combined as the hit probability of a block depends on the behaviour of other blocks; the last 5 accesses of the sequence, each accessing a different block, cannot hit at the same time assuming a 4 line cache. The hit probability of an access need to be set to 0 in (15) if enough blocks are inserted in cache since the last access to the same block. Should the reuse distance be considered to identify whether or not an access is a potential hit, the last occurrences of \\(a, c, d,\\) and \\(f\\) would be considered as misses.\n\nUsing cache contention, some accesses are assumed to be potential hits, occupying cache space to the detriment of others. Cache contention captures a specific but potential hit/miss scenario the occurrence of which is bounded using each access hit probability in (15). As proven in Altmeyer and Davis (2014), the estimated hit probability of the overall sequence holds. In our example, contention identifies that \\(a, b,\\) and \\(c\\) can be kept in the cache simultaneously. Using the contention as a super-script, we have:\n\n\\[ a, b, c, b^1, d, f, a^2, b^2, c^3, d^4, f^4 \\]\n\nc\\(^3\\) implies that \\(c\\) may be present in cache, assuming only three other blocks may have been kept alongside it, \\(a\\) and \\(b\\) as potential cache hits, and \\(d\\) then replaced by \\(f\\). This assumption regarding \\(d\\) and \\(f\\) is an important difference between contention and the stack distance metric used in LRU cache analysis. Using the stack distance, i.e. the number of different blocks accessed since the last access to \\(c, d\\) and \\(f\\) would be regarded as occupying a different line in cache, resulting in a guaranteed miss for \\(c, d^4\\) is classified as a miss: \\(a^2, b^2\\) and \\(c^3\\) have been identified as potential misses, and \\(f\\) is a miss resulting in the eviction of the fourth and only cache line where \\(d\\) could be held. \\(f^4\\) is similarly classified as a miss.\n\nNote that this definition of contention is an improvement on the one proposed in earlier work. Instead of accounting for each access independently, we account for their accessed blocks instead. The reasoning behind this optimisation is that if an accessed block hits more than once, it does not occupy additional lines. In the previous example, \\(b\\) is only accounted for once in the contention of \\(a^2\\) and \\(c^3\\). The subtle difference lies in (17) where the blocks \\(e_j\\) are accounted for instead of each access \\(j\\) individually (\\(e_i = e_j\\) if they access the same block).\n\nThe execution time of an element \\(e_i\\) can be approximated with the help of the discrete random variable \\(\\xi_i\\) which has a probability mass function (PMF) defined as:\n\\[\n\\hat{\\xi}_i(x) = \\begin{cases} \n\\hat{P}(e_i^{\\text{hit}}) & \\text{if } x = \\mathcal{H} \\\\\n1 - \\hat{P}(e_i^{\\text{hit}}) & \\text{if } x = \\mathcal{M} \\\\\n0 & \\text{otherwise}\n\\end{cases}\n\\]\n\n(18)\n\nAn estimated pWCET (Cucu-Grosjean 2013) distribution \\(\\hat{D}\\) of a trace, is an upper-bound on the execution time distribution \\(D\\) induced by the randomised cache for the trace,\\(^2\\) such that \\(\\forall v, P(\\hat{D} \\geq v) \\geq P(D \\geq v)\\). In other words, the distribution \\(\\hat{D}\\) is greater than \\(D\\) (López et al. 2008), denoted \\(\\hat{D} \\geq D\\).\n\nThe probability mass functions \\(\\hat{E}_i\\) are independent upper-bounds on the behaviour of corresponding accesses \\(e_i\\). An estimate for trace \\(t\\) can be derived by combining the probability mass function \\(\\hat{\\xi}_i\\) for each of its composing memory accesses \\(e_i\\):\n\n\\[\n\\hat{D}(t) = \\bigotimes_{e_i \\in t} \\hat{\\xi}_i\n\\]\n\n(19)\n\nwhere \\(\\otimes\\) represents the convolution of PMFs:\n\n\\[\n(\\hat{\\xi}_i \\otimes \\hat{\\xi}_j)(x) = \\sum_{k=-\\infty}^{+\\infty} \\hat{\\xi}_i(k) \\cdot \\hat{\\xi}_j(x-k)\n\\]\n\n(20)\n\nThe resulting distribution for non-relevant accesses is independent of the relevant blocks considered in the cache during the collecting analysis step. A worst-case is assumed where the \\(R\\) blocks are always kept in cache. The distributions resulting from the two analysis steps, collecting and contention, can therefore be soundly convolved to estimate the execution time of a trace. The pWCET of a trace can then be derived by convolving the execution time distributions produced by the contention, and collecting approaches, as derived from \\(\\hat{D}^{\\text{miss}}\\).\n\n2.3 Discussion: relevance of the model\n\nThe SPTA techniques described apply whether the contents of the memory block are instruction(s), data or both. While address computation (Huynh et al. 2011) may not be able to pinpoint the exact target of an access, e.g. for data-dependent requests, relational analysis (Hahn and Grund 2012), introduced in the context of deterministic systems, can be used to identify accesses which map to the same or different sets, and access the same or different block. Two accesses which obey the same block relation can then be replaced by accesses to the same unique element, hence improving the precision of the analysis.\n\nThe methods assume that there are no inter-task cache conflicts due to preemption, i.e. a run-to-completion semantics with non-preemptable program execution. Concur-\n\n\\(^2\\) Note the precise execution time distribution is effectively that which would be observed by executing the trace an infinite number of times.\ncurrent cache accesses are also precluded, i.e. we assume a private cache or appropriate isolation (Chiou et al. 2000).\n\nIn practice, detailed analysis could potentially distinguish between different latencies for each access, beyond \\( \\mathcal{M} \\) and \\( \\mathcal{H} \\), but such precise estimation of the miss latency requires additional analysis steps, e.g. analysis of the main memory (Bourgade et al. 2008). Further, to reduce the pessimism inherent in using a simple bound, particularly for the miss latency, events such as memory refresh can be accounted for as part of higher level schedulability analyses (Atanassov and Puschner 2001; Bhat and Mueller 2011).\n\n3 Comparing cache contents\n\nThe execution time distribution of a trace in our model depends solely on the behaviour of the cache. The contribution of a cache state to the execution time of a trace thus solely depends on its initial contents. The characterisation of the relation between the initial contents of different caches allows for a comparison of their temporal contribution to the same trace. This section introduces properties and conditions that allow this comparison. They are used in later techniques to improve the selection of cache contents on path convergence, and identify paths with the worst impact on execution time.\n\nAn \\( N \\)-tuple represents the concrete contents of an \\( N \\)-way cache, such that each element corresponds to the block held by a single line. The symbol \\( \\_ \\) is used to denote an empty line. For each such concrete cache \\( s \\), there is a corresponding abstract cache contents \\( C \\) which holds the exact same set of blocks. \\( C \\) might also capture uncertainty regarding the contents of some lines.\n\nGiven cache state \\( s = \\langle l_1, \\ldots, l_N \\rangle \\),\\(^3\\) \\( s[l_i = b] \\) represents the replacement of memory block or line \\( l_i \\) in cache by memory block \\( b \\). Note that \\( b \\) can only be present once in the cache, \\( b \\in s \\Rightarrow s[l_i = b] = s. s[-l_i] \\) is a shorthand for \\( s[l_i = \\_] \\) and identifies the eviction of memory block \\( l_i \\) from the cache. \\( s[l_i = b][l_j = e] \\) denotes a sequence of replacements where \\( b \\) first replaces \\( l_i \\) in \\( s \\), then \\( e \\) replaces \\( l_j \\). Two cache states \\( s \\) and \\( s' \\) although not strictly identical may exhibit the same behaviour if they hold the exact same contents, e.g. \\( \\langle a, \\_ \\rangle = \\langle \\_, a \\rangle \\) are represented using the same abstract contents \\( \\{a\\} \\). Under the evict-on-miss random replacement policy, there is no correlation between the physical and logical position of a block with respects to the eviction policy.\n\nWe distinguish the execution time distribution of trace \\( t \\) using input cache state \\( s \\) with the notation \\( \\mathcal{D}(t, s) \\). The execution time distribution of the sequence \\( \\left[ [b], t \\right] \\), the concatenation of access \\([b]\\) to trace \\( t \\), can be expressed as follows:\n\n\\[\n\\mathcal{D}([b], t), s = \\langle l_1, \\ldots, l_N \\rangle = \\begin{cases} \n\\mathcal{H} + \\mathcal{D}(t, s) & \\text{if } b \\in s \\\\\n\\mathcal{M} + \\sum_{i \\in [1:N]} 1/N \\cdot \\mathcal{D}(t, s[l_i = b]) & \\text{otherwise}\n\\end{cases}\n\\]\n\n(21)\n\n\\(^3\\) We assume a fully-associative cache, but this restriction can be lifted to set-associative caches through the independent analysis of each set.\nwhere the sum of distributions and the product of a distribution with $\\frac{1}{N}$ are defined as per (6), and $(\\mathcal{L} + \\mathcal{D})(x) = \\mathcal{L} + \\mathcal{D}(x)$ denotes the sum of distribution $\\mathcal{D}$ with latency $\\mathcal{L}$. Upon a hit, the input cache state $s$ is left unchanged, while evictions occur to make room for the accessed block upon a miss.\n\nThe extension of this definition to the concatenation of traces requires the identification of the outcomes of an execution, i.e. the cache state $C$ corresponding to each possible sequence of events, along with its occurrence probability $P$ and execution time distribution $D$:\n\n$$D([t_p, t_3], s) = \\sum_{(C,P,D) \\in \\text{outcomes}(t_p,s)} P \\cdot (\\mathcal{D} \\otimes \\mathcal{D}(t_5, C))$$\n\n(22)\n\nwhere $\\text{outcomes}(t_p, s)$ is the set of cache states produced by the execution of $t_p$ from input cache state $s$ and $\\otimes$ is the convolution of distributions.\n\n**Theorem 1** The eviction of a block from any input cache state $s$ cannot decrease the execution time distribution of any trace $t$, $\\mathcal{D}(t, s) \\leq \\mathcal{D}(t, s[-e])$.\n\n*Proof* See Appendix. □\n\n**Corollary 1** In the context of evict-on-miss randomised caches, for any trace, the empty state is the worst initial state over any other input cache state $s$, $\\mathcal{D}(t, s) \\leq \\mathcal{D}(t, \\emptyset)$.\n\nThe eviction of a block might trigger additional misses, resulting in a distribution that is no less than the one where the cache contents is left untouched. This provides evidence that the assumption upon a non-relevant access that a block in cache is evicted, as per the update function in (3), is sound. Similarly, the replacement of a block in the cache might trigger additional misses but might also result in additional hits instead upon reuse of the replacing block. The impact of such a behaviour is however bounded.\n\n**Theorem 2** The replacement of a random block in cache triggers at most one additional hit.\n\nThe distribution for any trace $t$ from any cache state $s$ is upper-bounded by the distribution for trace $t$ after the replacement of a random block in $s$ and assuming a single hit turns into a miss.\n\n$$\\mathcal{H} + \\mathcal{D}(t, s) \\leq \\mathcal{M} + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t, s[l_i = e])$$\n\n(23)\n\n*Proof* See Appendix. □\n\nThe block selected for eviction impacts the likelihood of those additional latencies suffered during the execution of the subsequent trace. Intuitively, the closer the evicted block is to reuse, the worse the impact of the eviction. We use the forward reuse distance of blocks at the beginning of trace $t$, $\\text{frd}(b, t)$ as defined in (14), to identify the blocks which are closer to reuse than others.\n**Theorem 3** The replacement of a block in input cache state \\( s \\) by one which is reused later in trace \\( t \\) cannot result in a decreased execution time distribution: \\( \\text{frd}(b, t) \\leq \\text{frd}(e, t) \\leq \\infty \\land b \\in s \\land e \\notin s \\Rightarrow D(t, s) \\leq D(t, s[b = e]) \\)\n\n**Proof** See Appendix. \\( \\Box \\)\n\n### 4 Application of SPTA to multi-path programs\n\nIn this section, we improve upon the state-of-the-art SPTA techniques for traces (Alt-meyer and Davis 2014) recapitulated in Sect. 2 and present methods for multi-path programs, that is complete control-flow graphs. A naive approach would be to compute all possible traces \\( T \\) of a task, analyse each independently and combine their distributions. However, there are two significant problems with such an approach.\n\nFirstly, while the merge operation (6) could be used to provide a weighted combination given the probability of each path being taken at runtime, such assumptions about path probability do not hold in general. This issue can however be resolved by taking the maximum distribution of the resulting execution-time distributions for each trace:\n\n\\[\n\\bigcirc_{t \\in T} D(t)\n\\]\n\nwhere we define the \\( \\bigcirc \\) operation as follows\n\n\\[\n\\bigcirc : ((\\mathbb{N} \\rightarrow \\mathbb{R}) \\times (\\mathbb{N} \\rightarrow \\mathbb{R})) \\rightarrow (\\mathbb{N} \\rightarrow \\mathbb{R})\n\\]\n\n\\[\nD_a \\bigcirc D_b := D^H\n\\]\n\nwith\n\n\\[\nD^H(x) = \\max \\left( \\sum_{y \\geq x} D_a(y) - \\sum_{y > x} D^H(y), \\sum_{y \\geq x} D_b(y) - \\sum_{y > x} D^H(y), 0 \\right)\n\\]\n\nThe \\( \\bigcirc \\) operator computes the least upper-bound of the complementary cumulative distribution (1-CDF) of all its operands (similar to the upper-bound depicted in Fig. 1), a maximum of distributions which is valid irrespective of the path executed at runtime. By construction the following properties hold\n\n\\[\nD_a \\bigcirc D_b \\geq D_a \\land D_a \\bigcirc D_b \\geq D_b\n\\]\n\n\\[\nD_a \\leq D_b \\Rightarrow D_a \\bigcirc D_b = D_b\n\\]\n\nSecondly, the number of distinct traces is exponential in the number of control flow divergences, conditional constructs and loop iterations, which means that this naive approach is computationally intractable. A standard data-flow analysis is also problematic, since it is not possible to assign to each instruction a corresponding contribution to the execution time distribution.\n\nOur analysis on control-flow graphs resolves these problems. It relies on the collecting and the contention approaches for relevant and non-relevant blocks respectively, as\nper the cache collecting approach on traces given by Altmeyer and Davis (2014). First, the loops in the control-flow graph are unrolled. This allows the implementation of the following steps, the computation of cache contention, the identification of relevant blocks and the cache collection, to be performed as simple forward traversals of the control flow graph. Approximation of the possible incoming states on path convergence keeps the analysis tractable. Finally, the contention and collecting distributions are combined using convolution.\n\n4.1 Program representation\n\nWe represent the possible paths in a program using a control-flow graph (CFG), that is a directed graph $G = (V, L, v_s, v_e)$ with a finite set $V$ of nodes, a set $L \\subseteq V \\times V$ of edges, a start node $v_s \\in V$ and an end node $v_e \\in V$. Each node $v$ corresponds to an element in $\\mathbb{E}$ accessed at node $v$. A path $\\pi$ from node $v_1$ to node $v_k$ is a sequence of nodes $\\pi = [v_1, v_2, \\ldots, v_{k-1}, v_k]$ where $\\forall i: (v_i, v_{i+1}) \\in L$ and defines a corresponding trace. By extension, $[\\pi, \\pi']$ denotes the path composed of path $\\pi$ followed by path $\\pi'$. Given a set of nodes $V'$, the symbol $\\Pi(V')$ denotes the set of all paths with nodes that are included exclusively in $V'$, and $\\Pi(G) \\subseteq \\Pi(V)$ the set of all paths of CFG $G$ from $v_s$ to $v_e$. Similarly to traces, the pWCET $\\hat{D}(G)$ of a program is the least upper-bound on the execution time distributions (pET) of all possible paths. Hence, $\\forall \\pi \\in \\Pi(G)$, $\\hat{D}(G) \\geq D(\\pi)$. Figure 1 illustrates this relation using the 1-CDF ($F(x) = P(D \\geq x)$) of different execution time distributions and a valid pWCET.\n\nWe say that a node $v_d$ dominates $v_n$ in the control-flow graph $G$ if every path from the start node $v_s$ to $v_n$ goes through $v_d$, $v_s \\rightarrow^* v_n = v_s \\rightarrow^* v_d \\rightarrow^* v_n$, where $v_s \\rightarrow^* v_d \\rightarrow^* v_n$ is the set of paths from $v_s$ to $v_n$ through $v_d$. Similarly, a node $v_p$ post-dominates $v_n$ if every path from $v_n$ to the end node $v_e$ goes through $v_p$, $v_n \\rightarrow^* v_e = v_n \\rightarrow^* v_p \\rightarrow^* v_e$. We refer to the set of dominators and post-dominators of node $v_n$ as $dom(v_n)$ and $post-dom(v_n)$ respectively.\n\nWe assume that the program always terminates. Bounded recursion and loop iterations are requirements to ensure this termination property of the analysed application.\nFig. 2 Simple do-while loop structure with an embedded conditional. \\( b \\) is the loop head, with its body comprising \\( \\{ b, c, d, e \\} \\) and the \\( e \\) to \\( b \\) edge as the back-edge. \\( e \\) and \\( c \\) are both valid exits.\n\nThe additional restrictions described below are for the most part tied to the WCET analysis framework (Wilhelm et al. 2008) and not exclusive to the new method. These are reasonable assumptions for the software in critical real-time systems.\n\nAny cycle in the CFG must be part of a natural loop. We define a natural loop \\( l = (v_h, V_l) \\) in \\( G \\) with a header \\( v_h \\in V \\) and a finite set of nodes \\( V_l \\subseteq V \\). Considering the example in Fig. 2, \\( b \\) is the head of the loop composed of accesses \\( V_l = \\{ b, d, c, e \\} \\). The header is the single entry-point of the loop, \\( \\forall v_n \\in V_l, v_h \\in \\text{dom}(v_n) \\). Conversely, a natural loop may exhibit multiple exits, e.g. as a result of \\textit{break} constructs. Loop \\( l \\) contains at least one back edge to \\( v_h \\), an edge whose end is a dominator of its source \\( \\exists v_b \\in V_l, (v_b, v_h) \\in L \\). All nodes in the loop can reach one of its back edges without going through the header \\( v_h \\). The transition from the header \\( v_h \\) of loop \\( l \\) to one of its nodes \\( v_n \\in V_l \\) begins an iteration of the loop. The maximum number of consecutive iterations of each loop, iterations which are not separated by the traversal of a node outside \\( V_l \\), is assumed to be upper-bounded by \\( \\text{max-iter}(l, \\text{ctx}) \\). The value of \\( \\text{max-iter}(l, \\text{ctx}) \\) might change depending on the context \\( \\text{ctx} \\), call stack and loop iteration, of loop \\( l \\), e.g. to capture triangular loops. This guarantees a finite number of paths in the program.\n\nCalls are also subject to a small set of restrictions to guarantee the termination of the program. Recursion is assumed to be bounded, that is cycles or repetitions in the call graph of the analysed application must have a maximum number of iterations, similarly for loops in the control flow. Function pointers can be represented as multiple targets attached to a single call. Here, the set of target functions must be exact or an over-estimate of the actual ones, so as to avoid unsound estimates which do not take all valid paths into account.\n\n4.2 Complete loop unrolling\n\nIn the first analysis step, we conceptually transform the control-flow graph into a directed acyclic graph by loop unrolling and function inlining (Muchnick 1997). In contrast to the naive approach of enumerating all possible traces, analysis through complete loop unrolling has linear rather than exponential complexity with the number of loop iterations.\n\nLoop unrolling and function inlining are well-known techniques to improve the precision of data-flow analyses. A complete physical unrolling that removes all back-edges significantly increases the size of the control-flow graph. A virtual unrolling and inlining is instead performed during analysis such that calls and iterations are processed as required by the control flow. The analysis then distinguishes the different call and iteration contexts of a vertex. In either case, the size of the graph explored...\nduring analysis and its complexity scales with the number of accesses in the program under consideration.\n\nUnrolling simplifies the analysis and significantly improves the precision. As opposed to state of the art analyses for deterministic replacement policies (Alt et al. 1996), the analysis of random caches through cache state enumeration does not rely on the computation of a fixpoint. The abstract domain for the analysis is by nature growing with every access since it includes the estimated distribution of misses. Successive iterations increase the probability of blocks in the loop’s working set being in the cache, and in turn increase the likelihood of hits in the next iteration. The exhaustive analysis, if not supplemented by other methods, must process all accesses in the program.\n\nWe assume in the following that unrolling is performed on all analysed programs. Section 6.4.2 discusses preliminary work to bypass this restriction. The analysis of large loops, with many predicted iterations, can be broken down into the analysis of a single iteration or groups thereof provided a sound upper-bound of the input state is used. The contributions of different segments are then combined to compute that of the complete loop or program. Such an upper-bound input can be derived as an example using cache state compression (Griffin et al. 2014a) to remove low value information. The definition of techniques to exploit the resulting trade-off between precision and analysis complexity is left as future work.\n\n4.3 Reuse distance/cache contention on CFG\n\nTo extend the concept of reuse distance to control-flow graphs, we lift the definition from a single trace to all traces and take the maximal reuse distance of all possible traces ending in the node \\( v \\):\n\n\\[\nrd^G : \\mathbb{V} \\rightarrow \\mathbb{N} \\cup \\{\\infty\\} \\\\\nrd^G(v) = \\max_{\\pi=[v_s,...,v]} (rd(v, \\pi))\n\\] (30) (31)\n\nThe cache contention is extended accordingly:\n\n\\[\ncon^G : \\mathbb{V} \\rightarrow \\mathbb{N} \\\\\ncon^G(v) = \\max_{\\pi=[v_s,...,v]} (con(v, \\pi))\n\\] (32) (33)\n\nAn upper-bound of both metrics for each access can be computed through a forward data flow analysis. The reuse distance analysis uses the maximum of the possible values on path convergence. Similarly, we lift the definition of the forward reuse distance to control-flow graphs. It can be computed through a backward data flow analysis. The contention for each block at each point in the program is computed through a forward data flow analysis. The computation of the contention relies on the estimation of the set of contending cache blocks. Its analysis domain is more complex than the reuse distance as different sets of contending blocks may arise on different paths. The analysis tracks all such sets from incoming paths, as long as they are conclusive to a\npotential cache hit, i.e. all sets are smaller than the associativity of the cache, and not\nincluded into each other, i.e. one does not upper-bound the other.\n\nWe then traverse the unrolled control-flow graph in reverse post-order, compute the\ndistributions with the contention-based approach, and use the maximum distribution\non path convergence, with the maximum operator \\( \\odot \\) as the join operator.\n\n### 4.4 Selection of relevant blocks\n\nThe selection of relevant blocks in Altmeyer and Davis (2014) also needs to be modified\nto accommodate for a control-flow graph. Cache state enumeration is only performed\nfor relevant accesses, ensuring more precise analysis results for the selected accesses.\nEarlier work (Altmeyer and Davis 2014) relied on an absolute set of \\( R \\) relevant blocks\nfor the whole trace. Instead, we only restrict ourselves to at most \\( R \\) relevant blocks\nat any point in the program. Given a position in the control-flow, the heuristic tracks\nthe \\( R \\) blocks with the shortest lifespan, i.e. the shortest distance between their last\nand next access. Such accesses are among the most likely to be kept in the cache and\nbenefit from a precise estimate of their hit probability through state enumeration. Note\nthat this heuristic relies on a lower bound on the lifespan of blocks instead of an upper\nbound.\n\nThe \\( R \\) blocks with the smallest lifespan are analysed using the collecting semantics,\nas they are the most likely to be kept in cache. For each of these blocks \\( b \\), the access\nprior to \\( b \\) must ensure its insertion in the cache during analysis. As such, the access\nneeds to be marked as relevant, included in the \\textit{relevant accesses} set, and excluded\nfrom accesses contributing to contention. The computation of cache contention is\nmodified to account for relevant accesses instead of blocks:\n\n\\[\n\\text{con}(e_i, t) = \\begin{cases} \\infty & \\text{if } \\text{rd}(e_i, t) = \\infty \\\\ |\\{e_k | k \\in \\text{conS}(e_i, t) \\land k \\notin \\text{relevant accesses}\\}| + R & \\text{otherwise} \\end{cases}\n\\]\n\n### 4.5 Approximation of cache states\n\nWe assume no information about the probability of taking one path or another, hence\nthe join operator must combine cache states in such a way that the resulting state is\nan over-approximation of all incoming paths, i.e. it contains the same or degraded\ninformation. To capture this property, we introduce the partial ordering \\( \\sqsubseteq \\) between a\ncache state and a set thereof such that \\( s \\sqsubseteq S_b \\) implies that \\( S_b \\) holds more pessimistic\ninformation than \\( s \\), resulting in more pessimistic timing estimates. We overload this\noperator to relate sets of cache states where \\( S_a \\sqsubseteq S_b \\) implies that \\( S_b \\) holds more pes-\nsimistic information than \\( S_a \\). More formally, the \\( \\sqsubseteq \\) notation (Peleska and Löding 2008)\nidentifies \\( S_b \\) as an upper-bound of \\( S_a \\) in \\( 2^\\text{CS} \\).\n\nConsider a simple cache state \\( s = ([a, b], 0.5, \\mathcal{D}) \\). Intuitively, the information\nrepresented by \\( s_a = ([a], 0.5, \\mathcal{D}) \\) is more pessimistic than that captured by \\( s, s \\sqsubseteq s_a \\).\n\n\\( \\odot \\) Springer\nConversely, $s_c = (\\{a, c\\}, 0.5, \\mathcal{D})$ holds less pessimistic information regarding $c$, so $s \\not\\subseteq s_c$. The set $S = \\{(a, 0.25, \\mathcal{D}), (b, 0.25, \\mathcal{D})\\}$ also approximates $s$, $s \\subseteq S$; the knowledge that $a$ and $b$ are both present in the cache $(s)$ is reduced to guarantees only about the presence of either $a$ or $b$ in $S$. As a consequence, the sequence of accesses $abab$ will trigger more misses starting from states in $S$, than from state $s$. Assuming $\\mathcal{D} < \\mathcal{D}'$, then $s' = (\\{a, b\\}, 0.5, \\mathcal{D}')$ holds more pessimistic information than $s, s \\subseteq s'$.\n\nThe intuition behind the approximation of a cache state is that the information it captures is further diluted into a single cache state or a set of cache states. The relation $s \\subseteq S$ holds if the set of cache states $S$ approximates cache state $s = (C, P, \\mathcal{D})$. In other words, (i) $S$ is as likely to occur, (ii) all blocks known to be in states of $S$ are present in $s$, and (iii) the contribution of $S$ to the pWCET is greater than or equal to the contribution $\\mathcal{D}$ of $s$. We formally define $s \\subseteq S$ as follows:\n\n$$(C, P, \\mathcal{D}) \\subseteq S \\Rightarrow \\left( P = \\left( \\sum_{(C', P', \\mathcal{D}') \\in S} P' \\right) \\right) \\wedge (\\forall (C', P', \\mathcal{D}') \\in S, C \\supseteq C' \\wedge \\mathcal{D} \\leq \\mathcal{D}')$$\n\n(35)\n\nBy extension, the over-approximation of a set of cache states is the composition of approximations $F(s) \\in 2^{\\mathcal{CS}}$ of each element $s$ in the set. We formally define the $\\subseteq$ partial ordering between sets of cache states $S_a \\in 2^{\\mathcal{CS}}$ and $S_b \\in 2^{\\mathcal{CS}}$ as follows:\n\n$$S_a \\subseteq S_b \\Rightarrow \\exists F: \\mathcal{CS} \\rightarrow 2^{\\mathcal{CS}}, (\\forall s \\in S_a, s \\subseteq F(s)) \\wedge S_b = \\bigcup_{s \\in S_a} F(s)$$\n\n(36)\n\nA join function $\\sqcup$ is valid if given any set of cache states $S_a \\in 2^{\\mathcal{CS}}$ and $S_b \\in 2^{\\mathcal{CS}}$, $S_a \\subseteq (S_a \\cup S_b)$ and $S_b \\subseteq (S_a \\cup S_b)$. An optimal join function $\\sqcup$ should return the least upper-bound of its parameters, i.e. the smallest state which upper-bounds all its inputs. Our definition of the $\\subseteq$ operator is however independent of the executed path: $S_a$ and $S_b$ may admit multiple upper-bounds incomparable to each other. The definition of an optimal join function would require a more complete ordering, taking into account the upcoming sequence of accesses to order sets of cache states depending on the likelihood their contents are reused. Optimality would still be challenged in multiple path applications where different paths stem from the join.\n\nTo prove over-approximation results in more pessimistic timing estimates, we derive the execution time distribution of a trace $t$ using the set of input cache states $S$ from its definition for a single state and the concatenation of traces respectively in (21) and (22):\n\n$$\\mathcal{D}(t, S) = \\sum_{(C', P', \\mathcal{D}') \\in S} P' \\cdot (\\mathcal{D}' \\otimes \\mathcal{D}(t, C'))$$\n\n(37)\n\nwhere the sum of distributions and the product of a distribution with $P$ are defined as per (6), and $\\otimes$ is the convolution of distributions.\n\nThe definition of over-approximations and their contribution to the execution time distribution of a trace relies on the merge $\\sqcup$ and convolution $\\otimes$ operators defined respectively in (6) and (20). Both offer properties used in the evaluation of the con-\ntribution of their operands. The convolution operator preserves the relative ordering between its inputs, and the merge operation adds the contribution of its operands.\n\n**Lemma 1** The convolution operation preserves the ordering between execution time distributions:\n\n\\[ D \\leq D' \\Rightarrow D \\otimes A \\leq D' \\otimes A \\]\n\n**Proof** See Appendix. ∎\n\n**Lemma 2** The contributions of merged sets of cache states \\( S \\) and \\( A \\) is the sum of their individual contributions:\n\n\\[ \\forall t, D(t, S) + D(t, A) = D(t, S \\cup A) \\]\n\n**Proof** See Appendix. ∎\n\n**Theorem 4** The over-approximation \\( S_b \\) of a set of cache states \\( S_a \\) holds more pessimistic information than \\( S_a \\),\n\n\\[ \\forall t, S_a \\subseteq S_b \\Rightarrow D(t, S_a) \\leq D(t, S_b) \\]\n\n**Proof** The relation between \\( S_b \\) and \\( S_a \\), defined in (36), implies the existence of an approximation function \\( F \\) for the cache states in \\( S_a \\) such that:\n\n\\[ (\\forall s \\in S_a, s \\subseteq F(s)) \\land S_b = \\bigcup_{s \\in S_a} F(s) \\quad (38) \\]\n\nFrom (38) and (35), we know that each cache contents \\( C' \\) in the approximation \\( F(s) = (C', P', D') \\) is included in the contents \\( C \\) of cache state \\( s = (C, P, D) \\). \\( C' \\) can thus be derived by evicting blocks from \\( C \\). From Theorem 1 we can infer:\n\n\\[ \\forall(C, P, D) \\in S_a, \\forall(C', P', D') \\in F((C, P, D)), D(t, C) \\leq D(t, C') \\quad (39) \\]\n\nApproximate distributions \\( D' \\) in \\( F(s) \\) are also by definition greater than their counterpart \\( D \\) in \\( s \\). We can similarly factor \\( D(t, C) \\) into both sides of inequality \\( D \\leq D' \\):\n\n\\[ \\forall(C, P, D) \\in S_a, \\forall(C', P', D') \\in F((C, P, D)), D \\otimes D(t, C) \\leq D' \\otimes D(t, C') \\quad (40) \\]\n\nBy transitivity of the \\( \\leq \\) operator, we can compare the contribution to the execution time distribution of \\( s = (C, P, D) \\) and each of the corresponding approximations in...\n\\(F((C, P, D))\\). That is a comparison between the leftmost term in (40) and rightmost term in (41) through \\(\\mathcal{D} \\otimes \\mathcal{D}(t, C')\\):\n\n\\[\n\\forall (C, P, D) \\in S_a, \\forall (C', P', D') \\in F((C, P, D)), \\mathcal{D} \\otimes \\mathcal{D}(t, C) \\leq \\mathcal{D'} \\otimes \\mathcal{D}(t, C')\n\\]\n\nEquation (42)\n\nWe multiply both sides of the inequality by the positive occurrence probability \\(P'\\):\n\n\\[\n\\forall (C, P, D) \\in S_a, \\forall (C', P', D') \\in F((C, P, D)), P' \\cdot (\\mathcal{D} \\otimes \\mathcal{D}(t, C)) \\leq P' \\cdot (\\mathcal{D'} \\otimes \\mathcal{D}(t, C'))\n\\]\n\nEquation (43)\n\nThe property holds for each approximation in \\(F(s)\\) and can be extended to their sum:\n\n\\[\n\\forall (C, P, D) \\in S_a, \\sum_{(C', P', D') \\in F((C, P, D))} P' \\cdot (\\mathcal{D} \\otimes \\mathcal{D}(t, C)) \\leq \\sum_{(C', P', D') \\in F((C, P, D))} P' \\cdot \\mathcal{D'} \\otimes \\mathcal{D}(t, C')\n\\]\n\nEquation (44)\n\nFrom (35) and (38), a state \\(s \\in S_a\\) has the same occurrence probability as its approximation \\(F(s)\\):\n\n\\[\n\\forall (C, P, D) \\in S_a, P \\cdot (\\mathcal{D} \\otimes \\mathcal{D}(t, C)) \\leq \\sum_{(C', P', D') \\in F((C, P, D))} P' \\cdot \\mathcal{D'} \\otimes \\mathcal{D}(t, C')\n\\]\n\nEquation (45)\n\nBoth terms of the inequality correspond to the contribution of a set of cache states to the execution time distribution of trace \\(t\\) as per (37):\n\n\\[\n\\forall (C, P, D) \\in S_a, P \\cdot (\\mathcal{D} \\otimes \\mathcal{D}(t, C)) \\leq \\mathcal{D}(t, F((C, P, D)))\n\\]\n\nEquation (46)\n\nThe property holds for any cache state \\(s \\in S_a\\) and can be extended to their sum such that:\n\n\\[\n\\sum_{(C, P, D) \\in S_a} P \\cdot (\\mathcal{D} \\otimes \\mathcal{D}(t, C)) \\leq \\sum_{s \\in S_a} \\mathcal{D}(t, F(s))\n\\]\n\nEquation (47)\n\nFrom Lemma 2, the inequality also holds for the merge \\(\\sqcup\\) across \\(S_a\\) of the approximations \\(F(s)\\):\n\n\\[\n\\sum_{(C, P, D) \\in S_a} P \\cdot (\\mathcal{D} \\otimes \\mathcal{D}(t, C)) \\leq \\mathcal{D}\\left(t, \\bigcup_{s \\in S_a} F(s)\\right)\n\\]\n\nBy definition of \\(S_b\\) in (38) and the application of (37) to \\(S_a\\), we conclude that:\n\n\\[\n\\forall t \\in T, \\mathcal{D}(t, S_a) \\leq \\mathcal{D}(t, S_b)\n\\]\n\n\\(\\square\\)\nThe ⊆ relation defines a partial ordering between two sets of cache states $S_a$ and $S_b$. Namely, $S_a \\subseteq S_b$ implies that $S_b$ holds more pessimistic information than $S_a$. In other words, the execution of any trace from $S_b$ results in a larger execution time distribution than the execution of the same trace from $S_a$. This provides sufficient ground for the definition of a sound join operation, one that upper-bounds the upcoming contribution of cache states coming from different paths.\n\n### 4.6 Join operation for cache collecting\n\nWe traverse the (directed acyclic) graph in reverse post-order and compute the set of cache states at each program point. The join operator $\\cup$ describes the combination of two data-flow states from two different sub paths.\n\nLet $S_a$ and $S_b$ be the sets of cache states from the two merging paths. We first define the set of common memory blocks $M[S_a \\cap S_b]$, and then restrict $S_a$ and $S_b$ to this set:\n\n$$M[S_a \\cap S_b] = \\left( \\bigcup_{(C_a, P_a, D_a) \\in S_a} C_a \\right) \\cap \\left( \\bigcup_{(C_b, P_b, D_b) \\in S_b} C_b \\right)$$\n\n$$S_a' = \\bigcup \\{(C_a \\cap M[S_a \\cap S_b], P_a, D_a) \\mid (C_a, P_a, D_a) \\in S_a\\}$$\n\n$$S_b' = \\bigcup \\{(C_b \\cap M[S_a \\cap S_b], P_b, D_b) \\mid (C_b, P_b, D_b) \\in S_b\\}$$\n\n$S_a'$ and $S_b'$ are safe over-approximations of $S_a$ and $S_b$ respectively. They only contain memory blocks common to both sets of cache states, which can therefore be included in the joined set of cache states.\n\nThe set $H$ contains all cache states common to both sets $S_a'$ and $S_b'$, with the minimum probability of $P_a$ and $P_b$, and a miss distribution given by the maximum of the individual distributions $D_a$ and $D_b$:\n\n$$H = \\{(C, \\min(P_a, P_b), D_a \\odot D_b) \\mid (C, P_a, D_a) \\in S_a' \\land (C, P_b, D_b) \\in S_b' \\land C \\neq \\emptyset\\}$$\n\nWe need to collect the remaining cache states that are (i) contained in $S_a'$ but not in $S_b'$, or (ii) are common to both sets, but have a higher probability in $S_a'$ than in $S_b'$:\n\n$$\\hat{H}_a = \\{(\\emptyset, P_a, D_a) \\mid (C, P_a, D_a) \\in S_a' \\land C \\neq \\emptyset \\land \\frac{1}{P_a}(P_b, D_b), (C, P_b, D_b) \\in S_b'\\}$$\n\n$$\\cup \\{(\\emptyset, P_a - P_b, D_a) \\mid (C, P_a, D_a) \\in S_a' \\land (C, P_b, D_b) \\in S_b' \\land C \\neq \\emptyset \\land P_a > P_b\\}$$\n\n$$\\cup \\{(\\emptyset, P, D) \\mid (\\emptyset, P, D) \\in S_a'\\}$$\n\n(52)\n\n$$\\hat{H}_b = \\{(\\emptyset, P_b, D_b) \\mid (C, P_b, D_b) \\in S_b' \\land C \\neq \\emptyset \\land \\frac{1}{P_b}(P_a, D_a), (C, P_a, D_a) \\in S_a'\\}$$\n\n$$\\cup \\{(\\emptyset, P_b - P_a, D_b) \\mid (C, P_b, D_b) \\in S_b' \\land (C, P_a, D_a) \\in S_a' \\land C \\neq \\emptyset \\land P_b > P_a\\}$$\n\n$$\\cup \\{(\\emptyset, P, D) \\mid (\\emptyset, P, D) \\in S_b'\\}$$\n\n(53)\n\\[ \\hat{H} = \\{(\\emptyset, P, D_a \\odot D_b) | (\\emptyset, P, D_a) \\in \\hat{H}_a \\land (\\emptyset, P, D_b) \\in \\hat{H}_b \\} \\] (54)\n\n\\( H \\cup \\hat{H} \\) is a safe over-approximation of both \\( S'_a \\) and \\( S'_b \\) with regards to the ordering defined in (36). We can define a function \\( F_a \\), which gives an over-approximation of each element of \\( S_a \\) such that \\( (H \\cup \\hat{H}) = \\bigcup_{s_a \\in S_a} F_a(s_a) \\), as follows:\n\n\\[\nF_a(C, P_a, D_a) = \\begin{cases} \n\\{(\\emptyset, P_a, D_a)\\} & \\text{if } C = \\emptyset \\\\\n\\{(\\emptyset, P_a, D_a)\\} & \\text{if } \\nexists (C, P_b, D_b) \\in S'_b \\\\\n\\{(C, P_a, D_a \\odot D_b)\\} \\cup \\{(\\emptyset, P_a - P_b, D_a)\\} & \\text{if } \\exists (C, P_b, D_b) \\in S'_b \\land P_a > P_b \\\\\n\\{(C, P_a, D_a \\odot D_b)\\} & \\text{if } \\exists (C, P_b, D_b) \\in S'_b \\land P_a \\leq P_b \n\\end{cases}\n\\] (55)\n\nWe define the over-approximation function \\( F_b \\) for elements in \\( S'_b \\) analogously:\n\n\\[\nF_b(C, P_b, D_b) = \\begin{cases} \n\\{(\\emptyset, P_b, D_b)\\} & \\text{if } C = \\emptyset \\\\\n\\{(\\emptyset, P_b, D_b)\\} & \\text{if } \\nexists (C, P_a, D_a) \\in S'_a \\\\\n\\{(C, P_a, D_a \\odot D_b)\\} \\cup \\{(\\emptyset, P_b - P_a, D_b)\\} & \\text{if } \\exists (C, P_a, D_a) \\in S'_a \\land P_b > P_a \\\\\n\\{(C, P_a, D_a \\odot D_b)\\} & \\text{if } \\exists (C, P_a, D_a) \\in S'_a \\land P_b \\leq P_a \n\\end{cases}\n\\] (56)\n\nThe join operation is defined as follows:\n\n\\[\nS_a \\sqcup S_b = H \\cup \\hat{H}\n\\] (57)\n\n**Example 1** As an illustration, let us consider the state of a 4-way associative cache upon the convergence of two paths \\( \\pi_a = [a, b, c] \\) and \\( \\pi_b = [b, c, a, d] \\). The resulting set of cache states are denoted by \\( S_a \\) and \\( S_b \\) respectively.\n\n\\[\n\\begin{array}{c|c}\nS_a & S_b \\\\\n\\hline\n([a, b, c], 24/64, D) & ([a, b, c, d], 6/64, D) \\\\\n([a, b, d], 12/64, D) & ([a, c, d], 18/64, D) \\\\\n([b, c, d], 6/64, D) & ([b, d, c], 6/64, D) \\\\\n([b, c], 12/64, D) & ([b, d], 3/64, D) \\\\\n([c, d], 6/64, D) & ([c], 4/64, D) \\\\\n([d], 1/64, D)\n\\end{array}\n\\]\n\nThe cache states in \\( S_a \\) and \\( S_b \\) can be reduced to only keep their common blocks \\( M_a S_a \\cap S_b = \\{a, b, c\\} \\). Common states are merged together:\nThe set of common cache states \\( H \\), with their minimal, guaranteed probability, is defined as \\( H = \\{([a, b, c], 6/64, D), ([a, c], 12/64, D), ([b, c], 6/64, D), ([c], 4/64, D)\\} \\).\n\nThere is no guarantee about the remaining states in \\( S'_a \\) and \\( S'_b \\) or their occurrence probability, they need to be approximated with the empty cache state:\n\n<table>\n<thead>\n<tr>\n<th>( S'_a )</th>\n<th>( S'_b )</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>([a, b, c], 24/64, D)</td>\n<td>([a, b, c], 6/64, D)</td>\n</tr>\n<tr>\n<td>([a, c], 12/64, D)</td>\n<td>([a, b], 12/64, D)</td>\n</tr>\n<tr>\n<td>([b, c], 24/64, D)</td>\n<td>([a, c], 18/64, D)</td>\n</tr>\n<tr>\n<td>([c], 4/64, D)</td>\n<td>([b, c], 6/64, D)</td>\n</tr>\n<tr>\n<td>([a], 12/64, D)</td>\n<td>([b], 3/64, D)</td>\n</tr>\n<tr>\n<td>([c]), 1/64, D</td>\n<td>([c], 6/64, D)</td>\n</tr>\n</tbody>\n</table>\n\nHence, the result of the join operation on the convergence of paths \\( \\pi_a \\) and \\( \\pi_b \\) is given by:\n\n<table>\n<thead>\n<tr>\n<th>( \\hat{C}_a )</th>\n<th>( \\hat{C}_b )</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>([], 18/64, D)</td>\n<td>([], 12/64, D)</td>\n</tr>\n<tr>\n<td>([], 18/64, D)</td>\n<td>([], 6/64, D)</td>\n</tr>\n</tbody>\n</table>\n\n5 Improving on the join operation\n\nThe basic join operation introduced in the previous section focuses on the conservation of common cache states. Others, because their contents differ or their occurrence is bounded on alternative paths, are merged into the empty state. This results in a safe estimate of the information gathered from different paths. Yet, the method exhibits some limitations with regards to the information it conserves; the probability of occurrence of some blocks in cache, which we refer to as their capacity, is lost during the join process. We introduce a join function based on conserving this additional capacity.\nof cache states. The function degrades the information about the presence of blocks in a cache to allocate, in a sound manner, its occurrence probability to a more pessimistic state. We first present a ranking heuristic used to identify the cache states to which capacity should be allocated to in priority in Sect. 5.1. The improved capacity-conserving join is itself presented in Sect. 5.2.\n\n5.1 Ranking cache states\n\nThe ordering $\\sqsubseteq$ introduced in Sect. 4.5 allows for the comparison of some cache states to each other irrespective of the upcoming trace of memory accesses. It is however a partial ordering and only compares two states with similar or included cache contents. As illustrated in Theorem 3, ordering the contribution of cache contents which do not include each other requires the consideration of future accesses as captured by their forward reuse distance. The definition of an optimal join operation, through the optimal allocation of capacity to cache states, should ideally minimise the execution time on the worst-case path. However, multiple, incomparable paths would need to be considered of which the worst-case is unknown. We instead rely on a heuristic to prioritise the most beneficial cache states through a ranking system.\n\nThe proposed ranking is based on a two sieves approach: (i) the number of useful blocks in cache are first compared with more blocks ranking higher, (ii) cache states are then compared based on their expected hit probability. As a result, we can compare the ranks of two cache states:\n\n$$C \\leq_{\\text{rank}} C' = \\begin{cases} \\text{true} & \\frac{\\sum_{e \\in C} \\hat{P}(e, \\text{hit})}{\\sum_{e \\in C'} \\hat{P}(e, \\text{hit})} \\geq \\sum_{e \\in C} P(e, \\text{hit}) \\land \\frac{\\sum_{e \\in C} P(e, \\text{hit})}{\\sum_{e \\in C'} P(e, \\text{hit})} \\geq \\sum_{e \\in C} \\frac{\\text{frd}^G_{\\text{min}}(e)}{N} \\geq \\sum_{e \\in C'} \\frac{\\text{frd}^G_{\\text{min}}(e)}{N} \\geq \\text{false otherwise} \\\\ \\text{true} & \\sum_{e \\in C} \\frac{\\text{frd}^G_{\\text{min}}(e)}{N} \\geq \\sum_{e \\in C'} \\frac{\\text{frd}^G_{\\text{min}}(e)}{N} \\geq \\text{false otherwise} \\end{cases} (58)$$\n\nThe first sieve prioritises cache states whose contents are likely to include others and hold more information. As per Theorem 1, the loss of information in a cache state cannot decrease the execution time distribution of an upcoming trace of accesses, implicitly $C \\subseteq C' \\Rightarrow C \\leq_{\\text{rank}} C'$. The sum of their blocks’ hit probabilities settles the rank of same-sized cache states, with a higher sum resulting in a higher rank. Each cache state is reduced to the minimum forward reuse distances of the blocks it holds. Those are used to estimate the corresponding hit probabilities of upcoming accesses by adapting the formula proposed in earlier approaches:\n\n$$\\hat{P}(e, \\text{hit}) = \\begin{cases} 0 & \\text{frd}^G_{\\text{min}}(e) \\geq N \\\\ \\frac{N}{N-1} \\cdot \\text{frd}^G_{\\text{min}}(e) & \\text{otherwise} \\end{cases} (59)$$\n\nIt would seem intuitive to rely solely on the reuse distances of the blocks held in a cache to define its rank. Yet, a block in the cache may have a low minimum forward reuse distance, increasing its rank, but be reused solely on a path where no other block is reused. To reduce the complexity of the heuristic, it does not distinguish between\nthe different subsequent paths and so captures and compares only the best possible reuse patterns, even though in some cases these may be optimistic. The forward reuse distances of blocks in the two states might interleave, like the upcoming accesses to these blocks, or vary depending on the considered subsequent path. Theorem 3 on the impact of a replacement on execution time cannot be used in such a context. Some cache states may be beneficial on a specific path, but be outranked on others. This prevents the direct comparison of cache states in the general case.\n\nOur aim is to improve precision in the pWCET estimate, hence the heuristic aims to preserve capacity for cache blocks that will upon their next access result in a high probability of a cache hit. This happens, at least on some forward paths, for blocks with a small forward re-use distance. Preserving capacity for blocks with a larger forward re-use distance would likely result in a smaller probability of a cache hit and a more pessimistic overall pWCET estimate. (Note the ranking is only a heuristic and we do not claim that it makes optimal choices.)\n\n5.2 Capacity conserving join\n\nThe join operator introduced earlier may result in lost capacity if the contents of states on alternative paths do not exactly match. Consider states \\( \\{a, b, e\\} \\) and \\( \\{b, c, e\\} \\) respectively in \\( S'_a \\) and \\( S'_b \\) along with others. They both include states \\( \\{b, e\\}, \\{b\\}, \\{e\\} \\) and \\( \\emptyset \\) and their capacity could be allocated to whichever is the highest ranking one. \\( \\{a, e\\} \\) on the other hand is a valid approximation of \\( \\{a, b, e\\} \\) in which it is included, but does not approximate \\( \\{b, c, e\\} \\).\n\nThe capacity conserving join, to reduce waste, considers the cache states included in states from either incoming path, \\( S'_a \\) and \\( S'_b \\), by decreasing rank. Each considered cache state \\( C \\) is allocated as much of the remaining capacity of the states \\( C_a \\) (respectively \\( C_b \\)) it approximates in \\( S'_a \\) (resp. \\( S'_b \\)) as possible. The capacity that can be allocated to \\( C \\) is bounded by the minimum cumulative capacity of the states it approximates in \\( S'_a \\) and \\( S'_b \\). We also ensure that the overall contribution of a state \\( C_a \\) or \\( C_b \\) to state \\( C \\) does not exceed its capacity. This is a requirement for the resulting \\( C \\) to be a valid approximation as per the \\( \\sqsubseteq \\) operator defined in Sect. 4.5. Algorithm 1 outlines the join process, and we further illustrate it with a simple example.\n\nExample 2 Consider the previous example (Example 1) after the cache states have been reduced to only their common blocks in lines 1–3. All cache states included in \\( S'_a \\) (\\( \\{a, b, c\\}, \\{a, b\\}, \\{b\\}, \\text{etc.} \\)) are present in \\( S'_b \\) (line 4). Assuming the upcoming sequence of accesses is \\( [a, c, b] \\), the considered states ordered by decreasing rank are:\nThe first iteration of the capacity conserving join focuses on \\(\\{a, b, c\\}\\) which no other state can provide capacity to. As a consequence, after the first iteration, \\(states_1 = \\{(a, b, c), 6/64, \\mathcal{D}\\}\\). In \\(S'_a\\), the state has a remaining capacity of \\(\\frac{18}{64}\\) which could be used to accommodate any of the contents of size 2 or less (i.e. \\(\\{a, c\\}, \\{a, b\\}, \\{b, c\\}\\),...\netc.). In particular, during the second loop iteration when contributions to the capacity of \\( \\{a, c\\} \\) are gathered from \\( S'_a \\) and \\( S'_b \\) (lines 7–10), we have:\n\n<table>\n<thead>\n<tr>\n<th>Contribution(_a)</th>\n<th>Contribution(_b)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>([a, b, c], 18/64, \\mathcal{D})</td>\n<td>([a, c], 12/64, \\mathcal{D})</td>\n</tr>\n<tr>\n<td>([a, c], 12/64, \\mathcal{D})</td>\n<td>([a, c], 18/64, \\mathcal{D})</td>\n</tr>\n</tbody>\n</table>\n\nThe presence of both \\( a \\) and \\( c \\), captured by state \\( \\{a, c\\} \\), can therefore be guaranteed with probability \\( \\frac{18}{64} \\) on both paths. The capacity of states in \\( S'_a \\) and \\( S'_b \\) is decreased accordingly (lines 15–21). Capacity is first picked from the lowest ranking states, such that in our example \\( \\{a, b, c\\} \\in S_a \\) still has a remaining capacity of \\( \\frac{12}{64} \\) (the \\( \\frac{18}{64} \\) allocated to \\( \\{a, c\\} \\) minus the contribution of the lower ranking \\( \\{a, c\\} \\) in \\( S_a \\), \\( \\frac{12}{64} \\)).\n\nDuring this step, the execution time distribution obtained through the combination of the contributors’ distributions is also computed in \\( d_a \\) (see line 18) and \\( d_b \\) respectively for \\( S'_a \\) and \\( S'_b \\). An upper-bound of \\( d_a \\) and \\( d_b \\) is used when computing the resulting distribution for the conserved state (line 24). After the second iteration of the algorithm, \\( \\text{states}_2 = \\text{states}_1 \\cup \\{ \\{a, c\\}, 12/64, \\mathcal{D} \\} \\).\n\nOnce all states have been explored, the remaining capacity is gathered into the empty state (line 26). The conserved contents are:\n\n\\[\n\\text{states} = S_a \\sqcup \\text{capa} S_b\n\\]\n\n<table>\n<thead>\n<tr>\n<th>States</th>\n<th>Capacity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>([a, b, c], 6/64, \\mathcal{D})</td>\n<td>([a, c], 18/64, \\mathcal{D})</td>\n</tr>\n<tr>\n<td>([a, b], 12/64, \\mathcal{D})</td>\n<td>([b, c], 6/64, \\mathcal{D})</td>\n</tr>\n<tr>\n<td>([a], 0/64, \\mathcal{D})</td>\n<td>([c], 6/64, \\mathcal{D})</td>\n</tr>\n<tr>\n<td>([b], 3/64, \\mathcal{D})</td>\n<td>([{}], 13/64, \\mathcal{D})</td>\n</tr>\n</tbody>\n</table>\n\nKeeping only states with a non-null occurrence probability, the capacity conserving join results in:\n\n\\[\n\\text{states} = S_a \\sqcup \\text{capa} S_b\n\\]\n\n<table>\n<thead>\n<tr>\n<th>States</th>\n<th>Capacity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>([a, b, c], 6/64, \\mathcal{D})</td>\n<td>([a, c], 18/64, \\mathcal{D})</td>\n</tr>\n<tr>\n<td>([a, b], 12/64, \\mathcal{D})</td>\n<td>([b, c], 6/64, \\mathcal{D})</td>\n</tr>\n<tr>\n<td>([a], 0/64, \\mathcal{D})</td>\n<td>([c], 6/64, \\mathcal{D})</td>\n</tr>\n<tr>\n<td>([b], 3/64, \\mathcal{D})</td>\n<td>([{}], 13/64, \\mathcal{D})</td>\n</tr>\n</tbody>\n</table>\nCompare the resulting contents to that of the previously introduced join operation repeated for convenience:\n\n\\[\nS_a \\sqcup S_b\n\\]\n\n\\[\n(\\{a, b, c\\}, 6/64, D) \\\\\n(\\{a\\}, 12/64, D) \\\\\n(\\{b, c\\}, 6/64, D) \\\\\n(\\{c\\}, 4/64, D) \\\\\n(\\{\\}, 36/64, D)\n\\]\n\nThe solution resulting from the application of \\( \\sqcup^{capa} \\) dominates that of the previously introduced join operation. Indeed, a state \\( C \\) can only accommodate soundly for itself or a state it includes. With the proposed ranking heuristic this corresponds to a lower ranking state which the algorithm explores after \\( C \\) itself. The capacity of \\( C \\) is first used for \\( C \\) in the algorithm. As a consequence, the capacity allocated to a state is at least its minimum capacity in \\( S_a \\) or \\( S_b \\), e.g., \\( 12/64 \\) for \\( \\{a, c\\} \\). This minimum is the capacity that was allocated to the state in the previous join implementation. Different ranking heuristics could potentially lose this dominance relation.\n\nThe capacity join further keeps the same timing information as the standard \\( \\sqcup \\) operation. The combined distributions and their weights are the same, but attached as a result of the operation to different, less pessimistic cache states. The same fragment of distribution in the standard operation will account for fewer or the same amount of misses using the capacity join.\n\n6 Worst-case path reduction\n\nApproximations of the cache contention or the contents of abstract cache states occur on control flow convergence, when two paths in the control flow graph meet. This ensures the validity of the bounds computed by SPTA whatever the exercised path at runtime, while keeping the complexity of the analysis under control. The complete set of possible paths need not be made explicit; however, the loss of information that may occur on flow convergence decreases the tightness of the computed pWCET.\n\nIn most applications, there exists some redundancy among paths with regards to their contribution to the pWCET. If a path can be guaranteed to always perform worse than another \\((D(\\pi_b) \\geq D(\\pi_a))\\), the contribution of the former to the pWCET dominates that of the latter, \\(D(\\pi_b) = D(\\pi_b) \\odot D(\\pi_a)\\). In which case, the latter path can be removed from the set of paths considered by the analysis, hence reducing the complexity of the control flow, while preserving the soundness of the computed upper-bound.\n\nIn this section, we define the notion of inclusion between paths and prove that path inclusion is a sub-case of path redundancy; the execution time distribution of an including path dominates that of any paths it includes. Based on this principle, we introduce program transformations to safely identify and remove from the control-flow paths that are included in others. This improves the precision of the analysis.\nWorst-case execution path (WCEP) reduction includes a set of varied modifications: empty conditions removal, worst-case loop unrolling, and simple path elimination. They apply on the logical level, during analysis, and unlike path upper-bounding approaches (Kosmidis et al. 2014) do not require modifications of the object or source code for pWCET computation.\n\n6.1 Path inclusion\n\nA path is said to include another if it contains at least the same sequence of ordered accesses, possibly interleaved with additional ones. As an example, consider paths \\( \\pi_a = [a, b, c, e] \\) and \\( \\pi_b = [a, b, c, d, a, e] \\) where \\( \\pi_a \\) is included in \\( \\pi_b \\). The former path can be split into sub-paths \\( \\pi_S = [a, b, c] \\) and \\( \\pi_E = [e] \\), such that \\( \\pi_a = [\\pi_S, \\pi_E] \\). \\( \\pi_b \\) can then be expressed as the interleaving of \\( \\pi_S \\) and \\( \\pi_E \\) with \\( \\pi_V = [d, a] \\), i.e. \\( \\pi_b = [\\pi_S, \\pi_V, \\pi_E] \\). Similarly, \\( \\pi_b \\) includes \\( [a, c, d, e] \\), but not \\( [b, a, c] \\).\n\n**Definition 1** *(Including path)* Let \\( \\pi_a \\) and \\( \\pi_b \\) be two paths, such that \\( \\pi_a \\) is the concatenation of two sub-paths \\( \\pi_S \\) and \\( \\pi_E : \\pi_a = [\\pi_S, \\pi_E] \\). The inclusion of \\( \\pi_a \\) in \\( \\pi_b \\), denoted \\( \\pi_a \\preceq \\pi_b \\), is recursively defined as either \\( \\pi_b = [\\pi_S, \\pi_V, \\pi_E] \\) or, \\( \\pi_b = [\\pi_S, \\pi_V, \\pi'_E] \\) where \\( \\pi_E \\preceq \\pi'_E \\) and \\( \\pi_E \\neq \\pi'_E \\).\n\n**Theorem 5** *The execution time distribution of a path \\( \\pi \\) prefixed by an access to block \\( b \\) upper-bounds that of path \\( \\pi \\), \\( D(\\pi, s) + H \\leq D([b], \\pi, s) \\).*\n\n**Proof** As per (21), the property trivially holds if \\( [b] \\) is a hit, \\( \\pi \\) executes starting from the same cache state \\( s \\) in both cases. We focus on the case where \\( [b] \\) is a miss from \\( s \\). This results in \\( N \\) possible cache states \\( s[l_i = b] \\) such that, thanks to Theorem 2:\n\n\\[\nH + D(\\pi, s) \\leq M + \\sum_{i \\in [1, N]} \\frac{1}{N} \\cdot D(\\pi, s[l_i = b]) \\quad (60)\n\\]\n\n\\[\nH + D(\\pi, s) \\leq D([b], \\pi, s) \\quad (61)\n\\]\n\nFor the sake of readability, we omit in the following the cache state \\( s \\) when comparing the execution time distributions of two paths in the following; two paths are always compared using the same input cache state, \\( D(\\pi) \\leq D(\\pi') \\iff D(\\pi, s) \\leq D(\\pi', s) \\).\n\n**Theorem 6** *The execution time distribution of a path \\( \\pi_a \\) prefixed by path \\( \\pi_s \\) upper-bounds that of path \\( \\pi_a \\) alone, \\( \\forall \\pi_s, \\pi_a, D(\\pi_a) \\leq D([\\pi_s, \\pi_a]) \\).*\n\n**Proof** From Theorem 5, we know that \\( D(\\pi_a) \\leq D([v_1, \\pi_a]) \\) which can be extended to \\( D(\\pi_a) \\leq D([v_1, v_2, \\ldots, v_n, \\pi_a]) \\) since \\( D([v_2, \\ldots, v_n, \\pi_a]) \\leq D([v_1, v_2, \\ldots, v_n, \\pi_a]) \\) and so on. The relation holds for prefixes of arbitrary lengths.\n\n**Theorem 7** *(Included path ordering)* If \\( \\pi_a \\) is included in \\( \\pi_b \\), then the execution time distribution of \\( \\pi_b \\) is greater than or equal to that of \\( \\pi_a \\), \\( \\pi_a \\preceq \\pi_b \\Rightarrow D(\\pi_a) \\leq D(\\pi_b) \\)\nFig. 3 Simple if-then conditional structure. The edge from if to fi, through the empty else case, can be removed for pWCET estimation\n\nProof We prove this property by induction.\n\nBase case: We need to prove that if $\\pi_a \\leq \\pi_b$ such that $\\pi_a = [\\pi_S, \\pi_E]$ and $\\pi_b = [\\pi_S, \\pi_V, \\pi_E]$, then $D(\\pi_a) \\leq D(\\pi_b)$. From Theorem 6, we know that $D(\\pi_E) \\leq D([\\pi_V, \\pi_E])$.\n\nThe execution of $\\pi_S$ cannot be impacted by accesses in either $\\pi_E$ or $\\pi_V$. It is therefore the same on both paths $\\pi_a$ and $\\pi_b$. As proved in Theorem 6, whatever cache state is left by the execution of $\\pi_S$, the execution time distribution of $[\\pi_V, \\pi_E]$ is either greater than or equal to that of $\\pi_E$. Therefore, $D(\\pi_a) \\leq D(\\pi_b)$.\n\nInductive step: Let us assume $\\pi_a = [\\pi_S, \\pi_E]$ and $\\pi'_E$ is such that $\\pi_E \\leq \\pi'_E$ and $D(\\pi_E) \\leq D(\\pi'_E)$. We need to prove that for $\\pi_b = [\\pi_S, \\pi_V, \\pi'_E]$, $D(\\pi_a) \\leq D(\\pi_b)$. From Theorem 5, we know that $D([\\pi_V, \\pi'_E]) \\geq D(\\pi'_E)$, and as a consequence $D([\\pi_V, \\pi'_E]) \\geq D(\\pi_E)$. Further, the execution time distribution of $\\pi_S$ is not impacted by accesses in either $\\pi_V$, $\\pi_E$, or $\\pi'_E$ and is the same in $\\pi_a$ and $\\pi_b$, hence $D(\\pi_a) \\leq D(\\pi_b)$.\n\nWe now extend the notion of path inclusion to sets of paths. A set of paths $\\Pi$ is a path-included set of $\\Pi^\\circ$ if each path in $\\Pi$ is included in a corresponding path in $\\Pi^\\circ$, $\\Pi \\leq \\Pi^\\circ \\Rightarrow \\forall \\pi \\in \\Pi, \\exists \\pi^\\circ \\in \\Pi^\\circ, \\pi \\leq \\pi^\\circ$. As a consequence, for each path $\\pi \\in \\Pi$, there is a path in $\\Pi^\\circ$ the actual pWCET of which also upper-bounds the execution time distribution of $\\pi$. The actual pWCET of $\\Pi^\\circ$ is thus an upper-bound on the execution time distributions of all paths in $\\Pi$, $\\forall \\pi \\in \\Pi$, $D(\\Pi^\\circ) \\geq D(\\pi)$. As the estimated pWCET of a path $\\hat{D}(\\pi)$ is an upper-bound on its execution time distribution, $D(\\pi') \\leq \\hat{D}(\\pi')$, it is sufficient to perform the pWCET analysis of a CFG $G$ on a reduced set of paths which path-includes the set $\\Pi(G)$.\n\n6.2 Empty conditions removal\n\nSimple conditional constructs may induce paths that are included in others. In particular, any path that goes through an empty branch or case is included in any alternative branch which triggers memory accesses. The edges in a CFG which represent such cases can be safely removed to reduce path indeterminism during pWCET analysis, improving the precision of the results.\n\nFigure 3 gives an example of this for an if-then construct with an empty else branch. At point fi in the program, the analysis accounts for the eviction by accesses in then of blocks present at the end of if. But if the empty edge is kept, any cache block loaded by the then branch cannot be considered as present by the analysis at fi. This reduces the knowledge of the cache contents, and the precision of the resulting pWCET distribution. By removing the edge corresponding to the empty branch we remove this source of pessimism.\nAn edge from vertex \\( v_p \\) to \\( v_l \\) corresponds to an empty path if there is an alternative exit from \\( v_p \\) through \\( v_j \\) which later reaches \\( v_l \\). The notion of post-dominators, as an example, can be used to simply capture a subset of those empty branches. In Fig. 3, any path to the program exit through \\( if \\) or \\( then \\) will traverse \\( fi \\), which post-dominates both \\( if \\) and \\( then \\). More formally:\n\n\\[\n\\forall v_p \\in V, \\forall v_l \\in \\text{successors}(v_p) \\setminus \\{v_p\\}, \\\\\n\\exists v_j \\in \\text{successors}(v_p) \\setminus \\{v_p\\} \\land v_l \\neq v_j \\land v_l \\in \\text{post-dom}(v_j) \\\\\n\\Rightarrow \\Pi(L) \\subseteq \\Pi(L \\setminus \\{(v_p, v_l)\\})\n\\]\n\nThe collecting approach integrates worst-case path computation and cache contribution estimation, referred to as high and low level analyses respectively in prior WCET estimation approaches (Puschner and Koza 1989), and ignores most feasibility constraints. This may result in unnecessary pessimism if the infeasible paths are expensive. Reduction of the different scenarios in the CFG, e.g. by expanding the CFG to only model feasible paths, allows the capture of some flow constraints at the cost of an increase in the size of the considered flow.\n\n### 6.3 Loop unrolling\n\nNatural loop constructs are a source of path redundancy. In particular, paths which do not exercise the maximum number of iterations of a loop they traverse have an including counterpart. An iteration of loop \\( l = (v_h, V_l) \\) starts with a transition from its header \\( v_h \\) to any of its nodes \\( v_n \\in V_l \\). Conversely, any iteration, with the exception of the last, ends with a transition back to the header \\( v_h \\), through a back-edge. The set of paths \\( \\Pi_{\\text{iter}} = [\\Pi(V_l \\setminus \\{v_h\\}), \\{v_h\\}] \\) captures the paths followed during a complete iteration through loop \\( l \\).\n\nA valid path which captures \\( n \\) iterations can be expressed as \\([\\{v_h\\}, \\pi_1, \\ldots, \\pi_{n-1}, \\pi_{\\text{last}}]\\) with \\( \\forall i, 1 \\leq i < n, \\pi_i \\in \\Pi_{\\text{iter}} \\), and \\( \\pi_{\\text{last}} \\) as the last iteration of the loop. \\( \\pi_{\\text{last}} \\) is a path in \\( \\Pi(V_l \\setminus \\{v_h\\}) \\) followed by a node outside the loop. We denote by \\( \\Pi_n \\), the set of paths which iterate \\( n \\) times through the loop \\( l \\). A path in \\( \\Pi_{n+1} \\) can be expressed as \\([\\{v_h\\}, \\pi_1, \\ldots, \\pi_{n-1}, \\pi_n, \\pi_{\\text{last}}]\\) with \\( \\pi_n \\in \\Pi_{\\text{iter}} \\), i.e. each path in \\( \\Pi_n \\) is included in a path of \\( \\Pi_{n+1} \\). By extension, the set of paths \\( \\Pi_{\\text{max-iter}(l)} \\) path-includes all other sets of paths which iterate over \\( l \\) at least once.\n\nAs an example, consider the loop \\( l = (b, \\{b, c, d, e\\}) \\) in Fig. 4. The path \\( \\pi_1 = [a, b, d, e, f] \\) iterates a single time through \\( l \\), with \\( \\pi_{\\text{last}} = [d, e] \\). The valid iteration sequences in this example are \\([d, e, b]\\) and \\([c, e, b]\\). By inserting one iteration before the last in \\( \\pi_1 \\), we obtain the valid paths \\([a, b], [d, e, b], [d, e, f]\\) and \\([a, b], [c, e, b], [d, e, f]\\) respectively. Both paths do indeed include \\( \\pi_1 \\).\n\nIn our model, we only restrict the maximum number of iterations of a loop. Every iteration may be the last; there is no guarantee that a loop goes always through the same number of iteration when it is executed. The loop unrolling algorithm hence operates without knowledge of the exact number of iterations of the loop. Every unrolled iteration is connected to the successors of the loop. As per Theorem 7 and the inclusion property for consecutive loop iterations, it is sufficient for pWCET estimation to only...\nFig. 4 Simple do-while loop structure with an embedded conditional. The set of paths which iterate \\( x + 1 \\) times through loop \\( l \\) includes all paths with fewer iterations.\n\n\\[\n\\cdots \\cdots \\rightarrow a \\rightarrow b \\rightarrow c \\rightarrow d \\rightarrow e \\rightarrow f \\rightarrow \\cdots\n\\]\n\nFig. 5 Simple do-while loop structure (Fig. 4) unrolled assuming \\( \\text{max-iter}(l) = 3 \\). The unrolled (dashed) back-edges are only kept when a generic loop unrolling algorithm is used. They are removed when \\( \\text{max-iter}(l) \\) iterations are enforced.\n\n\\[\n\\cdots \\cdots \\rightarrow a \\rightarrow b \\rightarrow c \\rightarrow d \\rightarrow e \\rightarrow b \\rightarrow c \\rightarrow d \\rightarrow e \\rightarrow f \\rightarrow \\cdots\n\\]\n\nConsider paths where each loop, when executed, goes through its current maximum number of iterations. The unrolling of loop \\( l \\) assumes \\( \\text{max-iter}(l, \\text{ctx}) \\) as the exact iteration count of loop \\( l \\). In effect, when unrolling any iteration of loop \\( l \\) besides the last, edges from nodes in the loop to nodes outside \\( l \\) are discarded. Conversely, unrolling the last iteration implies conserving only the nodes and edges of \\( l \\) which lead to a loop exit.\n\nThis property holds in natural loops as long as any path taken during an iteration can be taken as well during any other iteration. Complex access patterns or flow constraints, e.g. if a path can only be executed once per execution of a loop, are a challenge to this assumption. As discussed in Sect. 6.2, the collecting approach integrates both worst-case path computation and estimation of the cache contribution, ignoring most path feasibility constraints. Expansion of the CFG to capture those constraints in its flow can be applied at the cost of a more complex flow (Fig. 5).\n\nThe same principles hold for call inlining. Recursion is also a source of path redundancy. Recursive calls manifest as repetitions in the call stack of an application. Here, a single source node is attached to the CFG of each procedure, which identifies its start. The source node therefore behaves similarly to the head of a loop, and is a guaranteed entry to each call. The same logic applies to both natural loops and recursive calls. When performing virtual or physical inlining, the analysis forces recursion up to the defined bound.\n\n6.4 Access renaming\n\nPath inclusion relies on the verbatim sequence of accesses to detect redundancy between paths. Even the slightest dissimilarity between alternative sequences throws off the property. Some accesses are known to perform worse than others at a given point in time. Renaming an access in a sequence to a worse performing target one, i.e. changing the target of the access, can smooth the differences between paths such that the renamed path is included in an alternative path of its original counterpart. The renamed path then acts as an intermediate bound between the original one and...\nthe including alternative, hence providing an argument for the removal of the original path. We now introduce a set of conditions that ensure the dominance of the execution time distribution of a renamed path over its original counterpart. If all transformations from the original validate these properties, the renamed path dominates the original. The renamed path may further be included in an alternative path. The original is then known to be redundant with this alternative and can be omitted during analysis.\n\nLet \\( \\pi = [v_1, v_2, \\ldots, v_k] \\) be a sequence of \\( k \\) accesses. \\( \\pi(e \\rightarrow b) \\) denotes the renaming of all accesses to memory block \\( e \\) to \\( b \\) in \\( \\pi \\), \\( \\pi(e \\rightarrow b) = [v_1', v_2', \\ldots, v_{k-1}', v_k'] \\) where \\( \\forall i \\in [1, k], v_i' = v_i \\) if \\( v_i \\neq e \\) and \\( v_i = b \\) otherwise. By definition, renaming \\( e \\) to \\( b \\) has no impact on \\( \\pi \\) if it does not access \\( e \\). \\( \\pi(e \\rightarrow b)(c \\rightarrow d) \\) identifies a rename from \\( e \\) to \\( b \\) followed by a rename from \\( c \\) to \\( d \\) on the resulting sequence. Note that if no destination block is used as a source block, the order of the renames is irrelevant. For instance \\( \\pi(e \\rightarrow b)(c \\rightarrow d) = \\pi(c \\rightarrow d)(e \\rightarrow b) \\), but \\( \\pi(e \\rightarrow b)(b \\rightarrow c) \\neq \\pi(b \\rightarrow c)(e \\rightarrow b) \\).\n\nWe identified three conditions to ensure the dominance of the pWCET of a renamed sequence \\( \\pi' = [\\pi_S, \\pi_V(e \\rightarrow b), \\pi_E] \\) over its original \\( \\pi = [\\pi_S, \\pi_V, \\pi_E] \\), where \\( \\pi_V = [e] \\) or \\( \\pi_V = [e, v_1, \\ldots, v_j, e] \\), and further prove their impact:\n\n- **No enclosure** There is no access to \\( b \\) over the renamed sequence \\( \\pi_V \\), \\( \\forall v_i \\in \\pi_V, v_i \\neq b \\).\n\n- **Prefix ordering** \\( b \\) is no more likely to be in the cache than \\( e \\) after \\( \\pi_S \\) (before \\( \\pi_V \\)). This occurs when the closest access to \\( e \\) before \\( \\pi_V \\), that is the last access to \\( e \\) in \\( \\pi_S \\), is posterior to the last access to \\( b \\) in \\( \\pi_S, rd(e, \\pi_S) < rd(b, \\pi_S) \\).\n\n- **Suffix ordering** \\( b \\) is no more likely to trigger a hit than \\( e \\) if present in cache after \\( \\pi_V \\) (before \\( \\pi_E \\)). The first access to \\( e \\) after \\( \\pi_V \\), i.e. in \\( \\pi_E \\), is before the first access to \\( b, frd(e, \\pi_E) < frd(b, \\pi_E) \\).\n\nSome inputs may result in lower estimated execution time distributions through analysis for the renamed path over the original one. This is because of the reduced pessimism in its analysis. Nevertheless, the computed pWCET for the renamed path, irrespective of the actual input, upper-bounds the exact pWCET for the original path.\n\n**Theorem 8** (Renamed path ordering) Given a path \\( \\pi \\) divided into three sub-paths \\( \\pi = [\\pi_S, \\pi_V, \\pi_E] \\), where \\( \\pi_V = [e, v_1, \\ldots, v_k, e] \\). The pWCET of \\( \\pi \\) is smaller than or equal to that of the renamed sequence \\( \\pi_r = [\\pi_S, \\pi_V(e \\rightarrow b), \\pi_E], D(\\pi) \\leq D(\\pi_r) \\), if:\n\n- there is no access to \\( b \\) in \\( \\pi_V \\);\n- the reuse distance of \\( e \\) before \\( \\pi_V \\) is smaller than that of \\( b \\) at this point;\n- the forward reuse distance of \\( e \\) at the end of \\( \\pi_V \\) is smaller than that of \\( b \\) at this point.\n\n**Proof** See Appendix. \\( \\square \\)\n\n6.4.1 Simple path elimination\n\nAccess renaming allows for a wide range of transformations between paths within a program. We aim at reducing the set of paths that need to be considered during the\nanalysis of an application without increasing its pWCET. An ideal solution would consider each path individually. Each should then be matched against its larger alternatives to check for inclusion using rename operations. This approach is impractical in practice due to the sheer number of paths and the complexity of the matching problem over large sequences of accesses.\n\nOur initial approach instead matches and eliminates simple paths in conditionals, that is branches which do not exhibit control flow divergence. Consider the example in Fig. 6, the branches of conditional \\( d \\) are simple paths. Only the lower branch of the first enclosing conditional \\( b \\) is a simple path as the upper one diverges at \\( d \\). Focusing on simple paths reduces the exploration space, both in terms of considered paths and their relative size. The considered paths are likely to be similar and match using few rename operations. This simplifies path elimination in the CFG. Figure 6 however illustrates the restrictions of this approach. The topmost branch \\([d, f, b]\\) is redundant with the bottom one \\([e, d, f, b]\\), but is only compared with \\([d, e, a, b]\\) which it does not match.\n\nWe use a simple method outlined in Algorithms 2 and 3 to test inclusion and perform renaming at the same time. The first algorithm illustrates the traversal of a CFG, and the identification of the suitable candidates for simple path elimination through renaming. The successors of each conditional vertex are considered pairwise (lines 5–14). Should there be a simple path starting from each vertex in the pair to the same node (\\( \\text{dom} \\)), the redundant one if any is removed (line 10). Paths may converge inside a simple path, as the simple path definition only restricts flow divergence. The removal of nodes subsequent to such a convergence may result in the removal of other non-redundant paths. The \\( \\text{RemovePath} \\) method removes at least the edge from \\( \\text{vertex} \\) to \\( \\text{renamed} \\) but may need to conserve other nodes. Using the flow depicted in Fig. 7 as an example, the middle path \\([a, b, f, b]\\) is identified as redundant with the top one \\([e, b, f, b]\\), but not \\([b, e, f, b]\\). Only \\([a^0]\\) and \\([b^1]\\) can effectively be removed. Removing vertices \\([f]\\) and \\([b^2]\\) on the lowest branch would remove \\([b, e, f, b]\\) from the set of possible paths which is unsafe.\n\nThe recursive \\( \\text{IsRedundant} \\) method, outlined in Algorithm 3, focuses on asserting the redundancy of two sub-paths of a CFG using renaming. The algorithm progresses access by access, each call to \\( \\text{IsRedundant} \\) considers the first access in the renamed path \\( \\pi_v \\) and possible matches in \\( \\pi_r \\). It explores the following options (i) match the address on the two paths (line 8), (ii) attempt renaming the access on path \\( \\pi_v \\) to one on path \\( \\pi_r \\) (line 12), or (iii) skip an access on the longest trace (on line 7, the operation...\nremoves the head of path $\\pi'_r$). If it reaches the end of path $\\pi_v$, that path is identified as redundant with respect to $\\pi_r$; there is a sequence of renames which results in its inclusion in $\\pi_r$. Conversely, if there are not enough accesses left in $\\pi'_v$ to match the ones in $\\pi'_r$, the algorithm returns false. Hence, renames only occur on the shortest path, as it does not hold enough accesses to include the longer one.\n\nThe two sub-paths compared in the $\\text{IsRedundant}$ method may be reached through multiple paths in the CFG and lead to the execution of different suffixes. To rename block $e$ to $b$, the operation must be valid for all prefixes and suffixes of the considered path $\\pi'_v$. Any access to $b$ prior to the renamed segment should always be followed by an access to $e$ before $\\pi_v$ later in the CFG ($\\text{Prefix ordering}$ condition). Conversely, an access to $e$ must precede the next access to $b$ on all subsequent paths where $b$ is accessed ($\\text{Suffix ordering}$ condition). Using the minimum forward and backward reuse distance of accesses in the CFG does not yield the required guarantee, only a necessary condition. Indeed, $b$ may be accessed on a path where $e$ was not accessed and still have higher minimum reuse and forward reuse distances. However, the reuse distances can be used to speed up the validation process. Similarly, the first met access to either block reduces the search space as it validates the property for the current branch (on $e$) or proves it does not hold (on $b$).\n\n6.4.2 Control flow graph segmentation\n\nWCEP reduction methods aim to remove included paths whose contribution to the execution time distribution is no greater than some alternative worst-case paths. This reduces the number of accesses to be analysed and impacts the complexity of the approach. To further reduce this contribution, we present preliminary work towards the reduction of the analysed program segments through CFG partitioning (Ballabriga and Cassé 2008). This method has been first explored by Pasdeloup (2014) through heuristics tailored for SPTA.\n\nConceptually, the cache is flushed at defined points in the program, on partition boundaries, to reduce the number of in-flight states. Flushing is in that case an abstraction of the analysis, the system is not expected to enforce this behaviour at runtime. Partitions divide the CFG into non-overlapping sections of consecutive nodes. We select flush points such that a minimum number of $M$ misses occurs between two flushes. This allows control over the complexity and precision trade-off for the analysis. The process is sound as the loss of information regarding cache contents cannot decrease the execution time distribution of a trace as per Theorem 1. The flush operation relies on the merge defined in (63):\nAlgorithm 2 Remove redundant simple paths from CFG $G$\n\n1: for vertex in ReversePostOrder($G$) do\n //Skip non conditional vertices\n2: if $|\\text{Successors}(\\text{vertex}, G)| \\leq 1$ then\n3: skip to next vertex\n4: end if\n //Remove redundant simple paths from successors\n5: for src in Successors(vertex, $G$) do\n6: for renamed in Successors(vertex, $G$) do\n7: dom := CommonPostDominator(src, renamed)\n8: if src $\\neq$ renamed and IsSimplePath(src $\\rightarrow^{*}$ dom) and IsSimplePath(renamed $\\rightarrow^{*}$ dom) then\n9: if IsRedundant(renamed $\\rightarrow^{*}$ dom, src $\\rightarrow^{*}$ dom) then\n10: RemovePath(vertex $\\rightarrow$ renamed $\\rightarrow^{*}$ dom)\n11: end if\n12: end for\n13: end for\n14: //Consider enclosing conditional again after path removal.\n15: if $|\\text{Successors}(\\text{vertex}, G)| \\leq 1$ then\n16: reset vertex to closest enclosing conditional\n17: end if\n18: end for\n\nAlgorithm 3 IsRedundant($\\pi_v, \\pi_r$)\n\n1: if $|\\pi_v|$ is empty then\n2: return true\n3: end if\n //Focus on the first access in $\\pi_v$\n4: $[[e], \\pi'_v] := \\pi_v$\n5: $\\pi'_r := \\pi_r$\n //Explore possible matches in $\\pi_r$\n6: while $|\\pi'_r| > |\\pi'_v|$ do\n7: $[[b], \\pi'_r] := \\pi'_r$\n8: if $e = b$ then\n9: if IsRedundant($\\pi'_v, \\pi'_r$) then\n10: return true\n11: end if\n12: else if IsRenameValid($\\pi'_v$, $e \\rightarrow b$) then\n13: return true if IsRedundant($\\pi'_v(e \\rightarrow b), \\pi'_r$)\n14: end if\n15: end while\n16: return false\n\n\\(\\text{Flush} : 2^{CS} \\rightarrow 2^{CS}\\)\n\n\\[\n\\text{Flush} \\left( \\left\\{ \\left( C_0, P_0, D_0 \\right), \\ldots, \\left( C_n, P_n, D_n \\right) \\right\\} \\right) = \\bigcup \\left( \\left\\{ \\left( \\emptyset, P_0, D_0 \\right), \\ldots, \\left( \\emptyset, P_n, D_n \\right) \\right\\} \\right)\n\\] \n\nOur partition of the CFG focuses on consecutive single-entry single-exit (SESE) regions (Ballabriga and Cassé 2008). All control flow enters a SESE region through its single entry and leaves through its exit. Examples of valid SESE regions in a CFG are highlighted in Fig. 8a. Consecutive SESE regions are connected to at most one\nFig. 8 Decomposition of a CFG into single-entry single-exit regions. a Example of single-entry single-exit regions. b Example decomposition into consecutive regions\n\npredecessor and one successor SESE region such that all control flow in the application is captured by a single path through the SESE region. As an example, consider the decomposition in Fig. 8b corresponding to the CFG in Fig. 8a. There is no cache-related dependency during the analysis of consecutive SESE regions, each is analysed assuming an empty initial cache state. Segments can be analysed independently with regards to the cache and their estimated pWCET convolved to compute that of the complete CFG.\n\nFor a decomposition into consecutive SESE regions to be valid, the nodes that delimit the segments have to be executed in all paths in the CFG. Alternative paths stemming from the same branch must be part of the same region. Similarly, all nodes in a loop nest belong to a same region. Such nodes can be captured by the notion of post-dominators: a node \\( v_p \\) post-dominates \\( v_n \\) if every path from \\( v_n \\) to the end node \\( v_e \\) goes through \\( v_p \\). All valid candidate nodes have to be post-dominators of the entry node \\( v_s \\).\n\nAlgorithm 4 outlines the general process of selecting the flush points. The common path of the CFG \\( G \\), post-dominators of its entry \\( v_s \\), is traversed in control flow order from the entry to the end of the graph. A new flush point is set if more than \\( M \\) misses can occur between the current post-dominator and the last selected flush point. The number of potential misses between two nodes, \\( \\text{CountPotentialMisses}(v_n, v_e) \\) is computed similarly to the maximum reuse distance, accounting for all accesses that are not guaranteed hits on paths between \\( v_n \\) and \\( v_e \\).\nAlgorithm 4 Select flush points for CFG $G$ with at least $M$ interleaved misses\n\n1: $\\text{flushes} = \\emptyset$\n2: $v_s = \\text{Entry}(G)$\n3: $\\text{last\\_flush} = v_s$\n4: for $v \\in \\text{SortByFlow}(\\text{post-dom}(v_s))$ do\n5: \\hspace{1em} if $\\text{CountPotentialMisses(}\\text{last\\_flush}, v) > M$ then\n6: \\hspace{2em} $\\text{flushes} = \\text{flushes} \\cup \\{v\\}$\n7: \\hspace{2em} $\\text{last\\_flush} = v$\n8: \\hspace{1em} else\n9: \\hspace{2em} end if\n10: end for\n11: return $\\text{flushes}$\n\n7 Evaluation\n\nIn this section, we examine the precision and runtime behaviour of the multi-path analysis introduced in this paper. In order to study the behaviour of the analysis with respect to different flow constructs, we provide results for a subset of the PapaBench application (Nemer et al. 2006), Debie (Holsti et al. 2000), and the Mälardalen benchmarks (Gustafsson et al. 2010). We present the results for a subset of benchmarks whose behaviour is representative of the ones observed across all experiments or illustrate interesting corner cases. Table 2 includes details for each benchmark on the maximum number of accesses, the distinct number of cache blocks, and the cyclomatic complexity $Y$ of the CFG (without and with WCEP reduction) which lower bounds the number of paths. Also given are the analysis runtimes with 4 and 8 relevant blocks.\n\nThe control-flow graph and address extraction were performed using the Heptane (Colin and Puaut 2001) analyser, from the compiled MIPS R2000/R3000 executable obtained using GCC v4.5.2 without optimisations. We used the various different methods to evaluate the contribution of a 16-way fully-associative instruction cache with 32B lines.\n\nThe miss distribution for different benchmarks was computed using either the contention-based approach, the collection one, using different numbers of relevant blocks $R$, or the reuse distance-based path merging method outlined by Davis et al. (2013). To provide a comparison with methods and replacement policies, a state-of-the-art analysis (Theiling et al. 1999) was used to determine the single, predicted worst-case bound on the number of misses for a LRU cache using the same parameters. We also performed a set of $10^8$ simulations of the random cache behaviour to use as a baseline, effectively providing a lower bound on the pWCET. Here, the successor to each vertex in the simulated path was picked randomly among all of its valid successors, thus exploring the possible paths.\n\nAll of the WCEP reduction techniques described in Sect. 6 were used for analysis of the random replacement cache. LRU caches do not exhibit the properties required by Theorem 7. The pWCET estimates obtained for each configuration of the analysis, estimation method and number of relevant blocks, were always tighter with WCEP reduction. Regarding simulation, WCEP reduction reduces the set of paths to one more representative of the worst-case scenarios, in some cases resulting in a single worst possible execution path. Yet there is no guarantee that these transformations\nare sufficient, here the simulation results are only an indicative means of assessing the pessimism in our approach. Table 2 covers the impact of WCEP reduction on the cyclomatic complexity $Y$ of the analysed benchmarks, an indicative lower bound on the number of paths in a CFG. Table 3 and Figure 9 present the estimated number of misses for the analysis of LRU and random replacement caches with a cutoff probability of $10^{-7}$, i.e. the number of predicted misses exceeded with a probability no greater than $10^{-7}$ at runtime. Of the 48 analysed benchmarks, 17, highlighted in Table 3, show the same or better estimated performance with a random replacement cache while 31 perform better with an LRU cache. Improvements over the LRU analysis tend to be limited. However as further illustrated for Papabench t4 in Fig. 10c, there is a potential margin for improvement in the analysis of the random replacement policy to further tighten its results over the LRU replacement policy.\n\nThe capacity-conserving join heuristic which allocates capacity to the cache states identified as the most valuable dominates the standard implementation. When comparing the precision of the different analysis techniques in Sect. 7.1 we therefore rely on the most favourable configuration, i.e. with WCEP reduction active and using the capacity-conserving join. The impact of the different mechanisms, joins and WCEP reduction, is further considered in Sects. 7.2 and 7.3 respectively. Finally, the complexity and runtime for different analysis configurations is evaluated in Sect. 7.4.\n\n7.1 Relative precision of the analysis techniques\n\nWe first compare the result for different configurations in Fig. 10a–f. The figures show the complementary cumulative miss distributions (1-CDF) for a representative subset of benchmarks and configurations. The contention and path merging approaches are identified by red circles and blue crosses respectively. The number of relevant blocks $R$ for the collecting approach is restricted to values of either 4 or 8 (identified by orange triangles) which is sufficient to capture most of the locality in the considered applications. The distribution obtained through simulation (identified by green squares) is\n\nFig. 9 Estimated number of misses under LRU and Random replacement caches\nTable 2 Properties of the analysed benchmarks and analysis runtime with \\( R \\) relevant blocks\n\n| Benchmark | Longest path (accesses) | \\(|B_0|\\) | Runtime (s) \\( R = 4 \\) | Runtime (s) \\( R = 8 \\) | \\( Y \\) with reduction \\( R = 4 \\) | \\( Y \\) with reduction \\( R = 8 \\) |\n|------------|-------------------------|--------|------------------------|------------------------|--------------------------------|--------------------------------|\n| Mälardalen | | | \\( R = 4 \\) | \\( R = 8 \\) | \\( Off \\) | \\( On \\) |\n| adpcm | 35,010 | 240 | 556 | 3747 | 6281 | 3069 |\n| bsort100 | 108,718 | 20 | 1545 | 31,301 | 9902 | 101 |\n| bs | 42 | 11 | \\(< 1\\) | \\(< 1\\) | 9 | 5 |\n| cnt | 1576 | 27 | 1 | 1 | 201 | 101 |\n| compress | 31,382 | 86 | 151 | 1047 | 3976 | 493 |\n| crc | 27,752 | 44 | 478 | 1023 | 4173 | 4169 |\n| edn | 67,631 | 166 | 549 | 17340 | 5 | 1 |\n| expint | 11,314 | 31 | 10 | 111 | 404 | 104 |\n| fdct | 841 | 106 | \\(< 1\\) | 2 | 1 | 1 |\n| fft | 18,409 | 141 | 78 | 432 | 609 | 587 |\n| fibcall | 125 | 8 | \\(< 1\\) | \\(< 1\\) | 2 | 1 |\n| fir | 992 | 22 | \\(< 1\\) | 2 | 31 | 11 |\n| insertsort | 769 | 16 | \\(< 1\\) | 1 | 1 | 1 |\n| jfdctint | 1059 | 96 | \\(< 1\\) | 4 | 65 | 1 |\n| lcdnum | 233 | 20 | \\(< 1\\) | 1 | 171 | 61 |\n| ludcmp | 3950 | 98 | 1 | 24 | 70 | 8 |\n| matmult | 63,839 | 28 | 481 | 5967 | 801 | 1 |\n| minmax | 26 | 22 | \\(< 1\\) | 1 | 9 | 5 |\n| minver | 726 | 167 | 2 | 1 | 7 | 1 |\n| ndes | 21,377 | 121 | 47 | 355 | 4219 | 1273 |\n| nsichneu | 2944 | 1377 | 107 | 103 | 1249 | 1 |\n| ns | 4349 | 20 | 1 | 33 | 2 | 2 |\n| prime | 5768 | 17 | 3 | 21 | 725 | 5 |\n| qurt | 1526 | 77 | \\(< 1\\) | 4 | 187 | 67 |\n| select | 1721 | 60 | \\(< 1\\) | 1 | 177 | 17 |\n| sqrt | 430 | 26 | \\(< 1\\) | 1 | 59 | 20 |\n| statemate | 1844 | 275 | 49 | 49 | 1841 | 1132 |\n| st | 67,538 | 163 | 127 | 780 | 971 | 221 |\n| ud | 2984 | 75 | 1 | 12 | 82 | 1 |\n| Papabench | | | \\( R = 4 \\) | \\( R = 8 \\) | \\( Off \\) | \\( On \\) |\n| t1 | 150 | 135 | \\(< 1\\) | \\(< 1\\) | 41 | 17 |\n| t2 | 57 | 27 | \\(< 1\\) | \\(< 1\\) | 6 | 5 |\n| t3 | 62 | 57 | \\(< 1\\) | 1 | 20 | 9 |\n| t4 | 215 | 13 | \\(< 1\\) | \\(< 1\\) | 47 | 24 |\n| t5 | 62 | 55 | \\(< 1\\) | \\(< 1\\) | 19 | 13 |\n| t6 | 286 | 272 | \\(< 1\\) | \\(< 1\\) | 103 | 27 |\n| t7 | 52 | 45 | \\(< 1\\) | \\(< 1\\) | 9 | 8 |\n| t8 | 11 | 9 | \\(< 1\\) | \\(< 1\\) | 3 | 2 |\n### Table 2 continued\n\n<table>\n<thead>\n<tr>\n<th>Longest path (accesses)</th>\n<th></th>\n<th>Blocks</th>\n<th>Runtime (s)</th>\n<th>Y with reduction</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td>R = 4</td>\n<td>R = 8</td>\n</tr>\n<tr>\n<td>t9</td>\n<td>472</td>\n<td>324</td>\n<td>< 1</td>\n<td>< 1</td>\n</tr>\n<tr>\n<td>t10</td>\n<td>39,658</td>\n<td>1073</td>\n<td>2500</td>\n<td>4742</td>\n</tr>\n<tr>\n<td>t11</td>\n<td>11</td>\n<td>9</td>\n<td>< 1</td>\n<td>< 1</td>\n</tr>\n<tr>\n<td>t12</td>\n<td>33</td>\n<td>34</td>\n<td>< 1</td>\n<td>< 1</td>\n</tr>\n<tr>\n<td>t13</td>\n<td>581</td>\n<td>675</td>\n<td>< 1</td>\n<td>< 1</td>\n</tr>\n<tr>\n<td>fly_by_wire</td>\n<td>18,723</td>\n<td>229</td>\n<td>293</td>\n<td>358</td>\n</tr>\n</tbody>\n</table>\n\nDebbie\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th></th>\n<th></th>\n<th></th>\n<th>Number of estimated misses</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td>LRU</td>\n<td>Random (10^{-7})</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td>R = 4</td>\n<td>R = 8</td>\n</tr>\n<tr>\n<td>Mälardalen</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>adpcm</td>\n<td>1570</td>\n<td>13,173</td>\n<td>6097</td>\n<td></td>\n</tr>\n<tr>\n<td>bsort100</td>\n<td>39,518</td>\n<td>41,642</td>\n<td>25,319</td>\n<td></td>\n</tr>\n<tr>\n<td>bs</td>\n<td>17</td>\n<td>35</td>\n<td>32</td>\n<td></td>\n</tr>\n<tr>\n<td>cnt</td>\n<td>239</td>\n<td>674</td>\n<td>450</td>\n<td></td>\n</tr>\n<tr>\n<td>compress</td>\n<td>3564</td>\n<td>7808</td>\n<td>4058</td>\n<td></td>\n</tr>\n<tr>\n<td>crc</td>\n<td>248</td>\n<td>7138</td>\n<td>5693</td>\n<td></td>\n</tr>\n<tr>\n<td>edn</td>\n<td>5608</td>\n<td>29,018</td>\n<td>22,546</td>\n<td></td>\n</tr>\n<tr>\n<td>expint</td>\n<td>320</td>\n<td>1253</td>\n<td>1107</td>\n<td></td>\n</tr>\n<tr>\n<td>fdct</td>\n<td>840</td>\n<td>842</td>\n<td>842</td>\n<td></td>\n</tr>\n<tr>\n<td>fft</td>\n<td>16,847</td>\n<td>15,259</td>\n<td>15,050</td>\n<td></td>\n</tr>\n<tr>\n<td>fibcall</td>\n<td>8</td>\n<td>22</td>\n<td>22</td>\n<td></td>\n</tr>\n<tr>\n<td>fir</td>\n<td>33</td>\n<td>291</td>\n<td>161</td>\n<td></td>\n</tr>\n<tr>\n<td>insertsort</td>\n<td>16</td>\n<td>304</td>\n<td>91</td>\n<td></td>\n</tr>\n<tr>\n<td>jfdctint</td>\n<td>739</td>\n<td>800</td>\n<td>748</td>\n<td></td>\n</tr>\n<tr>\n<td>lcdnum</td>\n<td>214</td>\n<td>211</td>\n<td>209</td>\n<td></td>\n</tr>\n<tr>\n<td>lldcmp</td>\n<td>836</td>\n<td>2310</td>\n<td>1990</td>\n<td></td>\n</tr>\n<tr>\n<td>matmult</td>\n<td>30</td>\n<td>17,812</td>\n<td>1665</td>\n<td></td>\n</tr>\n<tr>\n<td>minmax</td>\n<td>24</td>\n<td>27</td>\n<td>27</td>\n<td></td>\n</tr>\n<tr>\n<td>minver</td>\n<td>171</td>\n<td>427</td>\n<td>335</td>\n<td></td>\n</tr>\n<tr>\n<td>ndes</td>\n<td>5524</td>\n<td>13,101</td>\n<td>10,882</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n\\(R = 4\\) and \\(R = 8\\) refer to the number of blocks accessed.\n\n\\(Y\\) with reduction indicates the reduction in runtime when accessing the blocks.\n\n\\(\\text{LRU}\\) and \\(\\text{Random (10^{-7})}\\) refer to the replacement policies.\n\n\\(\\text{Num}\\) of estimated misses refers to the number of estimated misses with LRU and random replacement caches.\nTable 3 continued\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Number of estimated misses</th>\n<th></th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>LRU</td>\n<td>Random (10⁻⁷)</td>\n<td>R = 4</td>\n</tr>\n<tr>\n<td>nsichneu</td>\n<td>2943</td>\n<td>2840</td>\n<td>2844</td>\n</tr>\n<tr>\n<td>ns</td>\n<td>21</td>\n<td>1296</td>\n<td>145</td>\n</tr>\n<tr>\n<td>prime</td>\n<td>17</td>\n<td>1591</td>\n<td>58</td>\n</tr>\n<tr>\n<td>qurt</td>\n<td>1406</td>\n<td>1205</td>\n<td>1193</td>\n</tr>\n<tr>\n<td>select</td>\n<td>856</td>\n<td>856</td>\n<td>856</td>\n</tr>\n<tr>\n<td>sqrt</td>\n<td>392</td>\n<td>355</td>\n<td>351</td>\n</tr>\n<tr>\n<td>statemate</td>\n<td>1802</td>\n<td>1749</td>\n<td>1775</td>\n</tr>\n<tr>\n<td>st</td>\n<td>1740</td>\n<td>27,044</td>\n<td>26,372</td>\n</tr>\n<tr>\n<td>ud</td>\n<td>406</td>\n<td>1435</td>\n<td>1005</td>\n</tr>\n<tr>\n<td>Papabench</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>t1</td>\n<td>150</td>\n<td>137</td>\n<td>137</td>\n</tr>\n<tr>\n<td>t2</td>\n<td>31</td>\n<td>38</td>\n<td>38</td>\n</tr>\n<tr>\n<td>t3</td>\n<td>62</td>\n<td>59</td>\n<td>59</td>\n</tr>\n<tr>\n<td>t4</td>\n<td>79</td>\n<td>188</td>\n<td>158</td>\n</tr>\n<tr>\n<td>t5</td>\n<td>62</td>\n<td>59</td>\n<td>59</td>\n</tr>\n<tr>\n<td>t6</td>\n<td>278</td>\n<td>268</td>\n<td>268</td>\n</tr>\n<tr>\n<td>t7</td>\n<td>51</td>\n<td>49</td>\n<td>49</td>\n</tr>\n<tr>\n<td>t8</td>\n<td>11</td>\n<td>10</td>\n<td>10</td>\n</tr>\n<tr>\n<td>t9</td>\n<td>334</td>\n<td>343</td>\n<td>343</td>\n</tr>\n<tr>\n<td>t10</td>\n<td>7421</td>\n<td>18,825</td>\n<td>14,506</td>\n</tr>\n<tr>\n<td>t11</td>\n<td>11</td>\n<td>11</td>\n<td>11</td>\n</tr>\n<tr>\n<td>t12</td>\n<td>33</td>\n<td>32</td>\n<td>32</td>\n</tr>\n<tr>\n<td>t13</td>\n<td>581</td>\n<td>559</td>\n<td>559</td>\n</tr>\n<tr>\n<td>fly_by_wire</td>\n<td>12,840</td>\n<td>15,126</td>\n<td>13,822</td>\n</tr>\n<tr>\n<td>Debie</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>acquisition_task</td>\n<td>4033</td>\n<td>11,475</td>\n<td>10,147</td>\n</tr>\n<tr>\n<td>hit_trigger_handler</td>\n<td>1345</td>\n<td>2534</td>\n<td>2529</td>\n</tr>\n<tr>\n<td>tc_execution_task</td>\n<td>262</td>\n<td>1432</td>\n<td>1060</td>\n</tr>\n<tr>\n<td>tc_interrupt_handler</td>\n<td>65</td>\n<td>73</td>\n<td>73</td>\n</tr>\n<tr>\n<td>tm_interrupt_handler</td>\n<td>21</td>\n<td>27</td>\n<td>27</td>\n</tr>\n</tbody>\n</table>\n\nalso presented. The number of misses predicted by analyses for the deterministic LRU configuration is identified by a dark purple vertical line.\n\nIn general, the use of the cache collecting method improves the precision of the analysis over the merging or purely contention-based approaches even on complex control flows, as illustrated by papabench t4 in Fig. 10c. On simple control flows, the two approaches behave similarly but the contention method still dominates the path merging method (see Fig. 10e). The merged path is as long as the longest path in the application but keeps the worst behaving accesses from shorter paths. When WCEP\nEstimated miss distribution for qurt, 77 distinct memory blocks, 1526 accesses on the longest path\n\nEstimated miss distribution for insertsort, 16 distinct memory blocks, 769 accesses on the longest path\n\nEstimated miss distribution for papabench t4, 13 distinct memory blocks, 215 accesses on the longest path\n\nFig. 10 Estimated miss distribution of the different analysis methods under LRU or random replacement policies and different analysis configurations (Color figure online)\nEstimated miss distribution for statemate, 275 distinct memory blocks, 1844 accesses on the longest path\n\nEstimated miss distribution for ud, 75 distinct memory blocks, 2984 accesses on the longest path\n\nEstimated miss distribution for jfdctint, 96 distinct memory blocks, 1059 accesses on the longest path\n\nFig. 10 continued\nreduction can mostly extract the worst-case execution path, as with qurt in Fig. 10a, the main difference between the two approaches comes from the more precise estimation of the hit probability of individual accesses using contention methods.\n\nThe precision of the collection methods and the relative performance of LRU and random caches mostly depends on the size of the working set of tasks w.r.t. to the cache size or the number of relevant blocks. Similar behaviours were observed whether WCEP reduction successfully resulted in a single path or not. As the number of relevant blocks increases from 4 to 8, the estimates computed by the analysis improve. The gain is important on benchmarks like insertsort (see Fig. 10b) where some nested loops fit in the number of relevant blocks. However, precision is lost in qurt or ud w.r.t. the simulation results (see Fig. 10a, e) as the loops almost fit inside the cache but not within the number of relevant blocks. This also results in decreased performance w.r.t. LRU. The latter is in this case only subject to cold misses.\n\nAnother general observation is that as expected none of the distributions derived by analysis underestimates simulation. However, the simulation-based distributions cannot be guaranteed to be precise pWCET estimates. The simulations, lacking representational input data, may not exercise the worst-case paths. At best they provide lower bounds on the pWCET. We note that provision of representative input data is a key problem for measurement-based methods. There is no general conclusion regarding the dominance of the analysis of a LRU cache over simulation or analysis results for a randomised cache. When all iterative structures fit in the cache (see Fig. 10b), the LRU analysis outperforms the analysis of the random cache. As intra-loop conflicts grow, the benefits of the random replacement policy emerge and the new methods can capture such locality, resulting in tighter estimates than the analysis for a deterministic platform (see Fig. 10f). WCEP reduction reduces the reuse distance considered during analyses, whereas the stack distance for the LRU analysis remains the same since Theorem 7 does not apply. The path-merging approach under WCEP reduction may result in tighter estimates than the analysis of a deterministic replacement policy (see Fig. 10d).\n\nThe analysis results for the t4 and statemate benchmarks (see Fig. 10c, d) indicate that the cache collecting approach may sometimes compute more pessimistic estimates than the contention method. This behaviour stems from flow divergence in the control flow of both benchmarks. Path indeterminism hinders the relevant block heuristic, different blocks may be deemed as relevant on parallel paths. In such cases, upon flow convergence, the join function cannot keep blocks of either alternative. Further, the R relevant blocks are still considered as occupying cache space from the point of view of the non-relevant ones, effectively reducing the cache size. This illustrates the need for more sophisticated heuristics which take into account the behaviour of the analysis on alternative paths, or vary the number of relevant blocks depending on the expected benefits, and the computational cost.\n\nIn summary, our evaluation results show that the approaches to multi-path SPTA derived in this paper dominate and significantly improve upon the state-of-the-art path merging approach, determining less than one third as many misses in some instances. They were also shown to be incomparable with LRU analysis.\n7.2 Benefits of the join operations to collecting approaches\n\nThe selection of relevant blocks is undoubtedly an important factor in the precision of the cache collecting approach. We compared additional configurations of the analyser, assuming a fixed number of 8 relevant blocks, to examine the impact of the join operations on the precision of the analysis. In particular, the experiments presented from Fig. 11a–f introduce a non state-conserving approach on path convergence. Using configuration empty (identified by blue pentagons) the cache contents are set to $\\emptyset$ on path convergence and the miss distribution is the maximum distribution of the alternative paths. The capacity configuration (identified by orange triangles) on the other hand corresponds to the use of the improved join operator. The intermediate line identifies the simple join operation we first introduced in Sect. 4.6 (purple squares).\n\nBenchmarks which exhibit locality across branches of their conditionals benefit from the join function, as illustrated by crc, lcdnum, expint and compress in Fig. 11a, b, d and e respectively. The combination of both WCEP reduction and capacity conservation on flow convergence leads to tighter pWCET estimates in the case of crc, lcdnum, expint and compress. Reduction cannot remove all branches as they may not fall under the required constraints. The_lcdnum benchmark is composed of a switch statement. The later cases share blocks with the conditions of the earlier ones, but add their own blocks. Hence, the resulting cache states differ but include each other. They can be captured by the capacity conserving heuristic. By construction, the capacity conserving join results in the tightest estimates and provides important improvements over the standard join on the crc application. The benefits of the capacity-conserving join over the standard one are more marginal on the compress benchmark (see Fig. 11e) which exhibits few branches with reused blocks not captured by the WCEP reduction.\n\nSome benchmarks see little benefit from the proposed join function. statemate (see Fig. 11c) is composed of many nested conditional constructs which share few or no blocks. The cache contents diverge with the flow, and the join operation cannot assume any block is present. Locality in the statemate benchmark is captured thanks to the empty conditional approach of WCEP reduction. Some applications like matmult (see Fig. 11f) are reduced to a single path through WCEP reduction. Such scenarios obviously do not benefit from any join operation.\n\n7.3 Impact of WCEP reduction on analysis and simulation\n\nWCEP reduction reduces path redundancy through the elimination of selected paths, such that both the analysis and the simulations are performed on a reduced control flow. We computed the miss distribution of the benchmarks with both families of methods with and without WCEP reduction. We present the result for a fixed probability of $10^{-7}$, i.e. recording the number of predicted misses that will be exceeded at runtime with a probability no greater than $10^{-7}$. For each of the ludcmp, cnt and compress benchmarks in Fig. 12a, b, and c respectively, we present the result using the original CFG, then adding WCEP unrolling (+unroll), empty branch elimination (+branch), and the renaming-based simple branch elimination (+rename).\nEstimated miss distribution for crc, 44 distinct memory blocks, 27,752 accesses on the longest path\n\nEstimated miss distribution for lcdnum, 20 distinct memory blocks, 233 accesses on the longest path\n\nEstimated miss distribution for statemate, 275 distinct memory blocks, 1844 accesses on the longest path\n\nFig. 11 Estimated miss distribution for the random replacement policy under a fixed number of relevant blocks $R = 8$ and WCEP reduction, and different join operations (Color figure online)\nEstimated miss distribution for expint, 31 distinct memory blocks, 11,314 accesses on the longest path\n\nEstimated miss distribution for compress, 86 distinct memory blocks, 31,382 accesses on the longest path\n\nEstimated miss distribution for matmult, 28 distinct memory blocks, 63,839 accesses on the longest path\n\nFig. 11 continued\nFig. 12 Estimated miss counts at a fixed probability of $10^{-7}$ under random replacement using different reduction configurations and $R$ relevant blocks. a Estimated miss count at $10^{-7}$ for the ludcmp benchmark. b Estimated miss count at $10^{-7}$ for the cnt benchmark. c Estimated miss count at $10^{-7}$ for the compress benchmark (Color figure online)\nGiven a fixed configuration of the analysis (identified by a symbol and a colour), the distribution obtained with WCEP reduction is always smaller than the one obtained without it. In other words, the analysis is more precise when all transformations are active. Because of path redundancy, an increase in the number of relevant blocks can sometimes reduce the precision of the resulting estimate. This phenomenon still occurs when WCEP reduction is applied, but it is less prevalent.\n\nThe impact of the different transformations on the precision of the analysis results depends on the characteristics of the application to which they are applied. All transformations can be beneficial to benchmarks for the collecting approach. The contention approach may even benefit from empty path elimination (see Fig. 12a), when a block is accessed only on the non-empty alternative of a conditional its reuse distance gets lowered. For other accesses, such paths impact neither the reuse distance nor the contention as they hold no access. The elimination of redundant paths on the other hand increases the precision of the two methods.\n\nThe cnt benchmark, in Fig. 12b, illustrates an interesting scenario. When the empty branch elimination is used in combination with WCEP unrolling collecting methods get slightly less precise than when using WCEP unrolling on its own. This illustrates a limit of the ranking heuristic used by the capacity-conserving join. Empty branches result in a reduced minimum forward reuse distance for some accesses. This in turn impacts the allocation of capacity to cache states on path convergence, resulting in a better allocation without empty branch elimination.\n\nWe performed a set of $10^8$ simulations on the control flow graphs of benchmarks with and without reduction. WCEP reduction results in greater measured execution time distributions. The transformations proposed in this paper eliminate some but not all redundant paths and reduce the set of possible paths to a set more focussed on worst-case scenarios. As for the analyses methods, the impact of each transformation depends on the benchmark to which it is applied. However, the application of WCEP reduction in the general case is not sufficient to guarantee the representative character of the resulting paths. In the case of the expanded compress benchmark, conditionals within loop structures are kept and there is no guarantee as to which alternation of paths results in the worst-case. On the other hand, the expanded matmult benchmark consists of a single trace of accesses.\n\n7.4 Execution time\n\nThe runtime of the analysis, using a C++ prototype implementation, is presented in Fig. 13 using the WCEP reduction method and 0 to 12 relevant blocks. Measurements were made on an 8-core 64-bit 3.4Ghz CPU using the Ubuntu 12.04 operating system, with 2 instances of the analyser running in parallel. WCEP reduction was used as it increases the precision of the estimated cache states, and also the analysis runtime. We observe a growth in runtime as the number of relevant blocks increases. The runtime of the analysis is also significantly higher for larger benchmarks, edn, compress, and ndes, which contain the largest number of nodes.\n\nThe abstract cache state representation is partially responsible for the high runtime on the largest benchmark. The complexity of the update and join operations is tied\nto both the number of relevant blocks $R$ and the number of potential misses on the longest path. (Fig. 13 combines the impact of both the program length and number of relevant blocks whereas Fig. 14 focuses on the number of instructions.) The number of relevant blocks affects the number of different cache contents which are tracked by the analysis at each step. Further as the number of analysed accesses increases, so does the size of the distributions held in the cache states and therefore the cost of operations such as the merge.\n\nThe complexity of the analysis is of the order of $O(|S| \\times m \\times \\log(m))$, where $m$ is the number of accesses in the program and $|S|$ upper-bounds the number of possible cache states. $|S|$ is the number of combinations of $N$ or less elements picked amongst\nthe $R$ relevant blocks, when $R < N$ then $|S| = 2^R$. As demonstrated in the previous set of experiments, a limited number of relevant blocks is effective for typical cache associativities.\n\n### 7.4.1 Reducing the complexity of the approach\n\nThe complexity of the introduced approach to SPTA for multi-path programs depends on both the number of relevant blocks $R$ and the number of accesses $m$ in the program. This section further examines the contribution of the program size to the runtime of the analyses and presents preliminary work towards its reduction using CFG partitioning as presented in Sect. 6.4.2.\n\nThe results presented in Fig. 13 focussed on the impact of the number of cache states through its ties to the relevant blocks $R$. The number of accesses $m$ in each benchmark is fixed. We evaluate the impact of $m$ on the complexity of the analysis in Fig. 14. It presents the runtime of the analysis of a repeated sequence of $n$ accesses while assuming the same 16-way cache as in our previous experiments. The number of blocks in the repeated sequence $n$, the number of relevant blocks $R$ and the cache associativity $N$ impact the possible number of cache states $|S|$ and therefore the initial growth of the runtime. Once the set of cache states to consider stabilises, the runtime for the different configurations follows a similar $m \\times \\log(m)$ growth curve.\n\nWe defined a simple algorithm to split a program into consecutive SESE with at least $M$ non-guaranteed hits on their longest path (Sect. 6.4.2). Segments are analysed independently assuming an empty input cache, and the resulting pWCET convolved to compute that of the full program. This approach effectively reduces the set of cache states on region boundaries to the empty state, a safe over-approximation as defined in Sect. 4.5. The resulting analysis runtime for the largest benchmarks is presented in Fig. 15 assuming a segment size $M$ of 1000 misses.\n\n\nProgram partitioning reduces the runtime of our method over the analysis of the program as a single segment (see Fig. 13). As the analysis is applied to same-sized regions in all cases, the runtime of all benchmarks follow a similar growth with the number of relevant blocks. The remaining differences in runtime come from several factors. First, the length of the program impacts the complexity of the final convolution operation of the pWCET of each segment. Second, the consecutive segments on a multi-path program may hold more than $M$ misses. Splits can only occur on a restricted set of vertices, namely those which post-dominate the entry of the CFG. Further, as shown in Fig. 14, misses and the working set of each segment impact the number of cache states kept during analysis. Finally, flow complexity also increases analysis time as more paths need to be considered in a single segment.\n\nFigures 16, 17 and 18 present the distributions computed by the analyses for a relevant subset of the considered configurations. They present the analyses results for $R = 8$ relevant blocks using a single or multiple segments (filled or hollow triangles respectively). They also include the results for 12 relevant blocks under partitioning (hollow blue pentagons), as the runtime of this configuration is below that of the $R = 8$ single segment one. Simulations and deterministic LRU analyses results are also included (resp. with green squares and a dark purple line). WCEP reduction is active in all cases, except LRU.\n\nThe approximation of the cache contents on segment boundaries has adverse effects on the precision of the analysis. Indeed, the first few accesses in a segment may be classified as misses while the contents of the cache are being reloaded. This is illustrated for the matmult and edn benchmark respectively in Figs. 16 and 17. matmult exhibits an important locality at runtime, the impact of segment boundaries is such...\nthat it overshadows the increase in the number of relevant blocks. Yet, the segmented analysis with 12 relevant blocks only takes 285 seconds, against more than 7000 for the single segment with $R = 8$. The precision gain from the increase in the number of relevant blocks is much more important for edn, while the runtime of the $R = 12$ segmented analysis remains lower than that of the $R = 8$ full program one (2000s vs. 13,000s).\n\nWe observed that the fft benchmark (Fig. 18) only marginally benefits from an increase in the number of relevant blocks. The approximations on segment boundaries have almost no impact on the precision of the computed estimates given a fixed number of relevant blocks, $R = 8$. There is little reuse between the identified SESE regions in the program.\n8 Conclusion and perspectives\n\nThe main contribution of this paper is the introduction of a more effective approach to multipath SPTA for systems that use a cache with an evict-on-miss random replacement policy. The methods presented in this paper build upon existing approaches for analysing single-path programs. We have pointed out where existing techniques for deterministic or probabilistic analyses could be applied to make improvements (Pasdeloup 2014; Maxim et al. 2012; Wegener 2012; Theiling et al. 1999).\n\nWe introduced conditions for the computation of valid upper-bounds on the possible cache states on control flow convergence and presented a compliant transfer function to illustrate the requirements. We further refined this join operation to improve the precision of the information kept on control flow convergence. This more sophisticated join operation relies on a heuristic ordering of cache states depending on their expected benefits in the upcoming accesses.\n\nWe also defined path redundancy, identifying path inclusion as a sub-case of redundancy. Based on these results, we presented worst-case execution path (WCEP) reduction to reduce the set of paths explored by the analysis, improving the tightness of the resulting timing estimates. We identified and proved the validity of sufficient conditions for the application of access renaming. This transformation allows for the identification of redundant paths beyond simple inclusion.\n\nOur evaluations show that the analysis derived is effective at capturing the cache locality exhibited by different applications. The new methods significantly outperform the existing path merging approaches, predicting less than a third as many misses in one of the benchmarks. More precise results can be attained at the cost of an increased, user-controlled, complexity. They are also incomparable to estimates for deterministic LRU caches. The program transformations introduced proved effective at improving the precision of all SPTA configurations; of the 48 analysed benchmarks, 18 show the same or better estimated performance with a Random replacement cache while 31 perform better with an LRU cache.\n\n8.1 Perspectives\n\nThis research can be extended in many ways. The transfer functions on control flow convergence compute valid bounds with regards to the ordering of cache states. They exhibit pessimism, different but more complex ranking heuristics could spread the capacity of cache states over more appropriate candidates. Second, the complexity of operations on the abstract domain contributes to the increasing runtime of the analysis as it traverses deep flow graphs. Future work could look at the interaction between existing methods to balance the complexity and the precision of the analysis. Another avenue for improvement is the heuristic for the selection of relevant cache blocks. More advanced approaches might improve the tightness of the results, or even introduce a varying number of relevant blocks across the application to focus the analysis effort on a specified area of the code.\n\nOur approach integrates both cache behaviour and worst-case path estimation. Flow facts regarding loop iterations can be taken care of during unrolling. We nevertheless\nintend to take more flow facts into account to increase the applicability of the approach and further improve the WCEP reduction effect on reducing path complexity. We also intend to investigate the use of static methods to improve the representative character of the considered paths, and as a consequence ensure the soundness and improve the precision of the measurement-based approaches. Finally, the application of static probabilistic timing analysis to more complex cache configurations, including multiple levels of cache, remains an open problem (Lesage et al. 2013).\n\n**Appendix: Proofs related to cache contents comparison**\n\nThis appendix provides the mathematical proofs of different properties related to the comparison of cache contents based on their impact on the execution time of an access trace. We also demonstrate the validity of the sufficient conditions for the renaming program transformation. The following lemmas and properties have been first introduced in Sects. 3, 4.5, and 6 and rely on the definition (21) of the contribution of a cache state to the execution time of a trace.\n\n**Theorem 1** The eviction of a block from any input cache state s cannot decrease the execution time distribution of any trace t, $D(t, s) \\leq D(t, s[-e])$.\n\n**Proof** We focus on the case where the evicted block e is in the input cache state s, otherwise $s[-e]$ is equal to s and $D(t, s) = D(t, s[-e])$. We prove the theorem by induction.\n\nBase case $t = [b]$: There are two cases to distinguish when the trace comprises a single access. If $b \\neq e$, then the execution time of [b] from s or $s[-e]$ is the same since the eviction of e does not affect [b]. If $b = e$, the access [b] may either be a hit or a miss starting from s, but is guaranteed to be a miss from $s[-b]$. Hence, $D([b], s) \\leq D([b], s[-e])$.\n\nInductive case $t' = [[b], t]$: Suppose the theorem holds for trace t and any input cache state s, $D(t, s) \\leq D(t, s[-e])$. The cases to consider are:\n\n$b \\neq e$ The behaviour of the first access $[b]$ is the same from both s and $s[-e]$. If $b$ is in cache, the access is a hit, the cache state is left unchanged, and the property holds thanks to the induction hypothesis. Otherwise, this results in $N$ different outcomes corresponding to the eviction of any one of the $N$ different lines $l_i$, $s[-e][l_i = b]$ where e is first evicted from s then b replaces $l_i$. If $l_i$ is the line which held e, $s[-e][l_i = b] = s[l_i = b]$; the behaviour of trace $t'$ is the same from either state. If one of the $N-1$ other lines is selected, then the eviction of e from the cache could take place after or before the replacement by b without any impact on the resulting cache contents, $s[-e][l_i = b] = s[l_i = b][-e]$. As defined by the induction hypothesis, the $N$ resulting cache states from $s[-e]$\ncannot decrease the execution time distributions over their counterparts for $s$ thus:\n\n$$\\mathcal{D}(t, s[l_i = b]) \\leq \\mathcal{D}(t, s[-e][l_i = b])$$ \\quad (65)$$\n\nHence, the sum of these distributions, in (21), cannot result in a decrease of the execution time distributions from $s[-e]$ over $s$:\n\n$$M + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot (\\mathcal{D}(t, s[l_i = b])) \\leq M + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot (\\mathcal{D}(t, s[-e][l_i = b]))$$ \\quad (66)\n\n$b = e$ The first access $[b]$ is a hit in $s$ and $t$ executes from input state $s$. From $s[-e] = s[-b]$, the first access $[b]$ is a miss. As in the previous case, the resulting cache states may be the same should the lines selected for eviction and replacement match, $s[-b][l_j = b] = s$. Alternatively, another block is evicted from the cache to insert $b$ again and the resulting state $s[-b][l_j = b]$ holds the same contents as $s[-l_j]$. From the induction hypothesis, we know that:\n\n$$\\mathcal{D}(t, s) \\leq \\mathcal{D}(t, s[-l_j])$$ \\quad (67)\n\nAs a consequence, for any $j$, $s[-b][l_j = b]$ holds the same contents as either $s$ or $s[-l_j]$ and we have:\n\n$$\\mathcal{D}(t, s) \\leq \\mathcal{D}(t, s[-b][l_j = b])$$ \\quad (68)\n\nThis can be extended to the execution time distribution of $t' = [b], t$. Since the property holds for any $j$, we expand the equation to a weighted sum across values of $j$:\n\n$$\\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t, s) \\leq \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot (\\mathcal{D}(t, s[-b][l_j = b]))$$ \\quad (69)\n\nSince the selection of $j$ has no impact on the left-hand term, we have:\n\n$$\\mathcal{D}(t, s) \\leq \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot (\\mathcal{D}(t, s[-b][l_j = b]))$$ \\quad (70)\n\nBecause of the ordering between the hit and miss latencies, we can expand the equation by adding a hit and miss latencies respectively on the left and right hand-sides:\n\n$$\\mathcal{H} + \\mathcal{D}(t, s) \\leq M + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot (\\mathcal{D}(t, s[-b][l_j = b]))$$ \\quad (71)\n\n$\\mathcal{H} + \\mathcal{D}(t, s)$ corresponds to the execution time of trace $t$ after an initial hit in cache state $s$ as per (21). Similarly the right hand term corresponds to an initial\nfist miss from the state \\(s[-b]\\) before the execution of \\(t\\). An access to \\(b\\) fits these behaviour and can be incorporated into both terms:\n\n\\[\n\\mathcal{D}([[b], t], s) \\leq \\mathcal{D}([[b], t], s[-b])\n\\] \n\n(72)\n\nHence, \\(\\forall t, \\forall s, \\mathcal{D}(t, s) \\leq \\mathcal{D}(t, s[-e])\\) \\(\\Box\\)\n\n**Theorem 2** The replacement of a random block in cache triggers at most one additional hit.\n\nThe distribution for any trace \\(t\\) from any cache state \\(s\\) is upper-bounded by the distribution for trace \\(t\\) after the replacement of a random block in \\(s\\) and assuming a single hit turns into a miss.\n\n\\[\n\\mathcal{H} + \\mathcal{D}(t, s) \\leq \\mathcal{M} + \\sum_{i \\in [1, N]} \\frac{1}{N} \\cdot \\mathcal{D}(t, s[l_i = e])\n\\] \n\n(23)\n\n**Proof** The property trivially holds if \\(e\\) is already present in the cache as the replacement then has no impact on the cache state, \\(s[l_i = e] = s\\). We only consider input states \\(s\\) where \\(e\\) is absent and prove this property by induction.\n\n- Base case \\(t = [b]\\), \\(b \\neq e\\): If \\(l_i \\neq b\\), input caches \\(s\\) and \\(s[l_i = e]\\) result in the same miss latency \\(\\mathcal{M}\\). If \\(e\\) replaces \\(b\\) in the cache, i.e. \\(l_i = b\\), then the execution of \\(t\\) is a miss from \\(s[l_i = e]\\) and a hit from \\(s\\). The property trivially holds.\n- Base case \\(t = [e]\\): The replacement of line \\(l_i\\) by \\(e\\), absent from the cache, implies that the execution of \\(t\\) is a hit from \\(s[l_i = e]\\) and a miss from \\(s\\):\n\n\\[\n\\mathcal{H} + \\mathcal{D}(t, s) = \\mathcal{M} + \\mathcal{D}(t, s[l_i = e])\n\\] \n\n(74)\n\nThe property holds for any \\(i\\) and can be extended to the weighted sum over \\(i\\):\n\n\\[\n\\mathcal{H} + \\sum_{i \\in [1, N]} \\frac{1}{N} \\cdot \\mathcal{D}(t, s) = \\mathcal{M} + \\sum_{i \\in [1, N]} \\frac{1}{N} \\cdot \\mathcal{D}(t, s[l_i = e])\n\\] \n\n(75)\n\nThe same distribution is weighted and summed \\(N\\) times on the left-hand term, it can be simplified as such:\n\n\\[\n\\mathcal{H} + \\mathcal{D}(t, s) = \\mathcal{M} + \\sum_{i \\in [1, N]} \\frac{1}{N} \\cdot \\mathcal{D}(t, s[l_i = e])\n\\] \n\n(76)\n\n- Inductive case \\(t = [[b], t']\\): Assume the property holds for any trace \\(t'\\) and any \\(x\\):\n\n\\[\n\\mathcal{H} + \\mathcal{D}(t', s) \\leq \\mathcal{M} + \\sum_{j \\in [1, N]} \\mathcal{D}(t', s[l_j = x])\n\\] \n\n(77)\nThe execution time distribution of \\( t = [b, t'] \\) from either \\( s \\) or one of the \\( s[l_i = e] \\) depends first on the presence or absence of the first accessed block \\( b \\) in the cache. We consider all alternatives and expand the execution time distribution of the trace as per (21), \\( b = e, b \\neq e \\land b \\in s, \\) and \\( b \\neq e \\land b \\notin s \\).\n\n- \\( b = e \\): The block is absent from the input cache state \\( s \\) and results in a miss and the eviction of a line \\( l_j \\):\n\n\\[\n\\mathcal{H} + \\mathcal{D}(\\{[e], t'\\}, s) = \\mathcal{H} + \\mathcal{M} + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_j = e])\n\\]\n\n(78)\n\nWhen \\( e \\) is randomly inserted in the cache before the execution of the same sequence, its presence in \\( s[l_i = e] \\) results in a guaranteed hit from any of the \\( N \\) possible states. The resulting cache states are left unchanged:\n\n\\[\n\\mathcal{M} + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(\\{[e], t'\\}, s[l_i = e]) = \\mathcal{M} + \\mathcal{H} + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = e])\n\\]\n\n(79)\n\nThe two expanded distributions (78) and (79) obviously have the same behaviour. The additional miss and hit latencies respectively balance the guaranteed hit and miss, while the resulting cache states are the same. Hence:\n\n\\[\n\\mathcal{H} + \\mathcal{D}(\\{[e], t'\\}, s) = \\mathcal{M} + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(\\{[e], t'\\}, s[l_i = e])\n\\]\n\n(80)\n\n- \\( b \\neq e, b \\in s \\): \\( b \\) is present in the input cache state \\( s \\). The corresponding execution time distribution from \\( s \\) can simply be expressed as:\n\n\\[\n\\mathcal{D}(t, s[l_i = e]) = \\mathcal{H} + \\mathcal{D}(t', s)\n\\]\n\n(81)\n\nFrom the input state \\( s[l_i = e] \\), different cases have to be considered depending on whether \\( e \\) replaced \\( b \\) or not, that is respectively a guaranteed miss or a hit. Upon a hit in particular, the cache state is left unchanged and replacement of line \\( l_i \\) can occur after or before the access without incidence:\n\n\\[\n\\mathcal{D}(t, s[l_i = e]) = \\begin{cases} \n\\mathcal{M} + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[b = e][l_j = b]) & \\text{if } l_i = b \\\\\n\\mathcal{H} + \\mathcal{D}(t', s[l_i = e]) & \\text{otherwise}\n\\end{cases}\n\\]\n\n(82)\n\nWe expand the definition (82) of the contribution of \\( t \\) assuming a line \\( l_i \\) was first replaced by \\( e \\) in the cache. We sum the \\( N \\) different terms resulting from the replacement of \\( b \\) or one of the other block, as follows:\n\n\\[\n\\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t, s[l_i = e]) = \\frac{1}{N} \\left( \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot (\\mathcal{M} + \\mathcal{D}(t', s[b = e][l_j = b])) \\right)\n\\]\n\\[ + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot (\\mathcal{H} + \\mathcal{D}(t', s[l_i = e])) \\] (83)\n\nWe deduce from the induction hypothesis (77) an upper bound \\( \\mathcal{U} \\) on the execution time distribution of \\( t' \\) from \\( s \\):\n\n\\[ \\mathcal{H} + \\mathcal{D}(t', s) \\leq \\mathcal{M} + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = e]) \\] (84)\n\nWith the addition of a hit latency \\( \\mathcal{H} \\) on both sides:\n\n\\[ \\mathcal{H} + \\mathcal{H} + \\mathcal{D}(t', s) \\leq \\mathcal{H} + \\mathcal{M} + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = e]) \\] (85)\n\n\\( \\mathcal{H} + \\mathcal{D}(t', s) \\) is equivalent to the execution time of \\( t \\) from \\( s \\) as expressed in (81):\n\n\\[ \\mathcal{H} + \\mathcal{D}(t, s) \\leq \\mathcal{H} + \\mathcal{M} + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = e]) \\] (86)\n\n\\[ \\mathcal{H} + \\mathcal{D}(t, s) \\leq \\mathcal{M} + \\mathcal{U} \\] (87)\n\nWe further distinguish in \\( \\mathcal{U} \\) the cases where \\( e \\) specifically replaces \\( b \\) in the cache or any other line:\n\n\\[ \\mathcal{U} = \\mathcal{H} + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = e]) \\]\n\n\\[ = \\frac{1}{N} \\cdot (\\mathcal{H} + \\mathcal{D}(t', s[b = e])) + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot (\\mathcal{H} + \\mathcal{D}(t', s[l_i = e])) \\]\n\n(88)\n\nThanks to the induction hypothesis (77), we can define an upper-bound on the left-most term, where \\( e \\) replaces \\( b \\) in the cache:\n\n\\[ \\mathcal{H} + \\mathcal{D}(t', s[b = e]) \\leq \\mathcal{M} + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[b = e][l_j = b]) \\] (89)\n\nMultiplying both sides by \\( \\frac{1}{N} \\), we have:\n\n\\[ \\frac{1}{N} (\\mathcal{H} + \\mathcal{D}(t', s[b = e])) \\leq \\frac{1}{N} \\left( \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot (\\mathcal{M} + \\mathcal{D}(t', s[b = e][l_j = b])) \\right) \\] (90)\nWe can then deduce that $U$ is a lower bound on the execution time distribution of $t$ when $e$ first replaces a random line $l_i$ in $s$. From (88) and (90):\n\n$$U \\leq \\frac{1}{N} \\cdot \\left( \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot (M + \\mathcal{D}(t', s[b = e][l_j = b])) \\right)$$\n\n$$+ \\sum_{i \\in [1,N], b \\neq e} \\frac{1}{N} \\cdot (H + \\mathcal{D}(t', s[l_i = e])) \\quad (91)$$\n\nFrom (83), it follows that:\n\n$$U \\leq \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t, s[l_i = e]) \\quad (92)$$\n\nThis can be combined with (87) such that $M + U$ is an intermediate bound between (81) and (82):\n\n$$H + \\mathcal{D}(t, s) \\leq M + U \\leq M + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t, s[l_i = e]) \\quad (93)$$\n\nHence the property holds:\n\n$$H + \\mathcal{D}(t, s) \\leq M + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t, s[l_i = e]) \\quad (94)$$\n\n- $b \\neq e, b \\notin s$: We need to consider two subcases depending on whether the random insertion of $b$ or $e$ results in the higher execution time distribution for $t'$, i.e. the comparison between $D_b$ and $D_e$:\n\n$$D_b = \\sum_{i \\in [1,n]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = b]) \\quad (95)$$\n\n$$D_e = \\sum_{i \\in [1,n]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = e]) \\quad (96)$$\n\n- $D_e \\leq D_b$: We prove the existence of an intermediate bound between $D(t, s)$ and $D(t, s[l_i = e])$ where $t = [[b], t']$. From the induction hypothesis (77), we deduce that:\n\n$$H + \\mathcal{D}(t', s[l_j = b]) \\leq M + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_j = b][l_i = e]) \\quad (97)$$\nLet us define \\( U_j \\) such that:\n\n\\[\nU_j = \\sum_{i \\in [1,N]} ^\\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_j = b][l_i = e]) \\tag{98}\n\\]\n\n\\[\n\\mathcal{H} + \\mathcal{D}(t', s[l_j = b]) \\leq \\mathcal{M} + U_j \\tag{99}\n\\]\n\nThe property further holds for any \\( j \\) and extends to the weighted sum over \\( j \\) of the terms on each side of the inequality:\n\n\\[\n\\mathcal{H} + \\sum_{j \\in [1,N]} ^\\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_j = b]) \\leq \\mathcal{M} + \\sum_{j \\in [1,N]} ^\\frac{1}{N} \\cdot U_j \\tag{100}\n\\]\n\nUsing the definition of \\( U_j \\) (98), the right-hand term can be expanded, by distinguishing the cases where \\( j \\) and \\( i \\) denote the same line, that is when \\( e \\) replaces the randomly inserted \\( b \\), \\( s[l_j = b][l_j = e] = s[l_j = e] \\):\n\n\\[\n\\sum_{j \\in [1,N]} ^\\frac{1}{N} \\cdot U_j = \\sum_{j \\in [1,N]} ^\\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_j = e]) + \\sum_{j \\in [1,N]} \\sum_{i \\in [1,N] \\setminus j} ^\\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_j = b][l_i = e]) \\tag{101}\n\\]\n\nBy substituting \\( \\mathcal{D}_e \\) (96) we have:\n\n\\[\n\\sum_{j \\in [1,N]} ^\\frac{1}{N} \\cdot U_j = \\frac{1}{N} \\cdot \\mathcal{D}_e + \\sum_{j \\in [1,N]} ^\\frac{1}{N} \\cdot \\sum_{i \\in [1,N] \\setminus j} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_j = b][l_i = e]) \\tag{102}\n\\]\n\nSimilarly, we distinguish in \\( \\mathcal{D}([b], t', s[l_i = e]) \\) the same cases where the first access to \\( b \\), a miss, replaces line \\( l_i \\) or not:\n\n\\[\n\\sum_{i \\in [1,N]} ^\\frac{1}{N} \\cdot \\mathcal{D}([b], t', s[l_i = e]) = \\mathcal{M} + \\sum_{j \\in [1,N]} ^\\frac{1}{N} \\cdot \\sum_{i \\in [1,N]} ^\\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = e][l_j = b])\n\\]\n\n\\[\n= \\mathcal{M} + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_j = b])\n\\]\n\n\\[\n+ \\sum_{j \\in [1,N]} ^\\frac{1}{N} \\cdot \\sum_{i \\in [1,N] \\setminus j} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = e][l_j = b]) \\tag{103}\n\\]\nBy substituting \\( D_b \\) (95) in the above equation we get:\n\n\\[\n\\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot D([[b], t'], s[l_i = e])\n= M + \\frac{1}{N} \\cdot D_b + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot \\sum_{i \\in [1,N] \\setminus j} \\frac{1}{N} \\cdot D(t', s[l_i = e][l_j = b])\n\\]\n\n(104)\n\nWhen lines \\( i \\) and \\( j \\) do not match, the ordering of the replacement of \\( l_i \\) and \\( l_j \\) by \\( e \\) and \\( b \\) respectively is irrelevant, \\( s[l_i = e][l_j = b] = s[l_j = b][l_i = e] \\). Hence the difference between (104) and the sum of \\( U_j \\) (102) depends on the ordering between respectively \\( D_b \\) and \\( D_e \\). Since \\( D_e \\leq D_b \\), it follows from (104) and (102) that:\n\n\\[\nM + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot U_j \\leq \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot D([[b], t'], s[l_i = e])\n\\]\n\n(105)\n\nAs a consequence of (105) and (100), it follows that:\n\n\\[\nH + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot D(t', s[l_j = b]) \\leq M + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot U_j\n\\leq \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot D([[b], t'], s[l_i = e])\n\\]\n\n(106)\n\nAdding a miss latency \\( M \\) on both sides of the inequality:\n\n\\[\nM + H + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot D(t', s[l_j = b]) \\leq M + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot D([[b], t'], s[l_i = e])\n\\]\n\n(107)\n\nThe left-hand term collapses to the execution time distribution of \\( t = [[b], t'] \\) from \\( s \\) as per (21) as \\( b \\) is absent from the input cache state \\( s \\). Hence, the property holds:\n\n\\[\nH + D([[b], t'], s) \\leq M + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot D([[b], t'], s[l_i = e])\n\\]\n\n(108)\n\n- \\( D_b \\leq D_e \\): The induction hypothesis (77) gives us the following relationship:\n\n\\[\nH + D(t', s[l_i = e]) \\leq M + \\sum_{j \\in [1,N]} \\frac{1}{N} \\cdot D(t', s[l_i = e][l_j = b])\n\\]\n\n(109)\nWe can reduce the right-hand term as per (21) given that \\( b \\) is absent from the initial cache state \\( s \\):\n\n\\[\nH + \\mathcal{D}(t', s[l_i = e]) \\leq \\mathcal{D}([[b], t'], s[l_i = e]) \\tag{110}\n\\]\n\nThe property, valid for any line \\( l_i \\), holds for summation below:\n\n\\[\nH + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = e]) \\leq \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}([[b], t'], s[l_i = e]) \\tag{111}\n\\]\n\nSubstituting \\( \\mathcal{D}_e \\) (96), we have:\n\n\\[\nH + \\mathcal{D}_e \\leq \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}([[b], t'], s[l_i = e]) \\tag{112}\n\\]\n\nConsidering the ordering \\( \\mathcal{D}_b \\leq \\mathcal{D}_e \\) between \\( \\mathcal{D}_b \\) (95) and \\( \\mathcal{D}_e \\) (96), we conclude that:\n\n\\[\nH + \\mathcal{D}_b \\leq \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}([[b], t'], s[l_i = e]) \\tag{113}\n\\]\n\nThrough the expansion of \\( \\mathcal{D}_b \\) (95) and the addition of a miss latency \\( \\mathcal{M} \\) on both sides of the inequality, we have:\n\n\\[\n\\mathcal{M} + H + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}(t', s[l_i = b]) \\leq \\mathcal{M} + \\sum_{i \\in [1,N]} \\mathcal{D}([[b], t'], s[l_i = e]) \\tag{114}\n\\]\n\nFrom (21) and the absence of \\( b \\) from the input cache state \\( s \\) we know that the left hand term can be expressed as the execution time of \\( t = [[b], t'] \\) from \\( s \\):\n\n\\[\nH + \\mathcal{D}([[b], t'], s) \\leq \\mathcal{M} + \\sum_{i \\in [1,N]} \\frac{1}{N} \\cdot \\mathcal{D}([[b], t'], s[l_i = e]) \\tag{115}\n\\]\n\nThe same distribution might not be the dominant one on the whole input domain; there might be segments where \\( \\mathcal{D}_e \\) is greater than \\( \\mathcal{D}_b \\) and the converse is true on the rest of the input domain. However, the property holds in either case. Hence the theorem still holds on each segment.\n\nThe property holds in all scenarios, whether \\( b = e \\), or block \\( b \\) is absent or present in input cache state \\( s \\). The random replacement of a line \\( l_i \\) by \\( e \\) can trigger an additional hit on the first subsequent access to \\( e \\). The additional miss latency compensates for this potential hit. From the original cache state, this access is a guaranteed miss. The resulting cache states, and the behaviour of the rest of the sequence, match whether this first access to \\( e \\) results in a cache hit (from \\( s[l_i = e] \\)) or a miss (from \\( s \\)).\nLemma 3 The replacement in input cache state $s$ of a block by another one in trace $t$ has no impact, timing and cache contents-wise, up to the first access to either block. The replacement can occur indifferently before trace $t$ or before the first access to either block.\n\n$$frd(b, t) \\leq frd(e, t) \\leq \\infty \\wedge t = [t_p, [b], t_s] \\wedge b \\notin t_p \\Rightarrow$$\n\n$$D(t, s[b = e]) = \\sum_{(C', P', D') \\in \\text{outcomes}(t_p, s[b=e])} P' \\cdot (D' \\otimes D ([[b], t_s], C'))$$\n\n$$= \\sum_{(C, P, D) \\in \\text{outcomes}(t_p, s)} P \\cdot (D \\otimes D ([[b], t_s], C[b = e]))$$\n\n$$D(t, s[e = b]) = \\sum_{(C', P', D') \\in \\text{outcomes}(t_p, s[e=b])} P' \\cdot (D' \\otimes D ([[b], t_s], C'))$$\n\n$$= \\sum_{(C, P, D) \\in \\text{outcomes}(t_p, s)} P \\cdot (D \\otimes D ([[b], t_s], C[e = b])) \\quad (116)$$\n\nProof The property trivially holds if the input cache state $s$ holds both $b$ and $e$ or neither as the replacement are then ineffective. We focus on states which hold either one but not both. $s'$ denotes the input cache where the replacement occurred, $s' = s[b = e]$ or $s' = s[e = b].$\n\nThe trace $t$ can be divided as such $t = [t_p, [b], t_s]$ where $[b]$ is the first reference to $b$ in $t$. The subtrace $t_p$ holds no reference to $b$, nor to $e$ as a consequence of the ordering between their forward reuse distances. The execution time distribution of trace $t$ as per (21) is:\n\n$$D(t, s) = \\sum_{(C, P, D) \\in \\text{outcomes}(t_p, s)} P \\cdot (D \\otimes D ([[b], t_s], C)) \\quad (117)$$\n\nAccesses in $t_p$ are not impacted by the presence of either $b$ or $e$ in the input cache. The sequence of evictions from $s$ which lead to cache state $C$ with probability $P$ and execution time distribution $D$ is matched starting from $s'$. It results in cache state $C'$ with the same probability $P$ and execution time distribution $D$. If the replaced block is absent from $C$, it has been evicted by accesses in $t_p$ and similarly the replacing block has been evicted in $C'$. If the replaced block is still present in $C$, the replacing block is similarly present in $C'$. The other lines hold the same contents since we consider the same fixed sequence of evictions on $t_p$ from $s$ and $s'$.\n\nTheorem 3 The replacement of a block in input cache state $s$ by one which is reused later in trace $t$ cannot result in a decreased execution time distribution: $frd(b, t) \\leq frd(e, t) \\leq \\infty \\wedge b \\in s \\wedge e \\notin s \\Rightarrow D(t, s) \\leq D(t, s[b = e])$\n\nProof If there is no reference to memory block $e$ in the considered trace $t$, the replacement of $b$ by $e$ in input cache state $s$ is equivalent to the eviction of $b$ from the cache, $e \\notin t \\Rightarrow s[b = e] = s[-b]$. The theorem then holds as per Theorem 1. We therefore focus on the case where $e$ is accessed in $t$, $frd(e, t) \\neq \\infty$. \nWe cut the trace $t$ into different segments $t = [t_p, [b], t_m, [e], t_s]$ such that $t_p$ holds no reference to $b$ nor $e$ as a consequence of their forward reuse distances. Similarly, we define $t_m$ such that it holds no reference to $e$. The first reference to $b$ and $e$ in trace $t$ are respectively located after $t_p$ and $t_m$.\n\nBecause of Lemma 3, we know that the replacement has no impact on $t_p$ which holds no reference to either the replaced block $b$ or the replacing one $e$. We focus on the execution time distribution of the trace $t' = [[b], t_m, [e], t_s]$ from a state $C_b$, which holds $b$ but not $e$. We further prove by induction that:\n\n$$\\mathcal{D}(t', C_b) \\leq \\mathcal{D}(t', C_b[b = e])$$ (118)\n\nBase case $t_m = t_s = \\emptyset, t' = [b, e]$: The property trivially holds as the execution of $t'$ from $C_b$ results in a hit then a miss, $\\mathcal{D}(t', C_b) = \\mathcal{H} + \\mathcal{M}$, whereas it misses then may hit or miss from input $C_b[b = e], \\mathcal{D}(t', C_b[b = e]) \\geq \\mathcal{M} + \\mathcal{H}$.\n\nInductive case $t' = [[b], t_m, [e], t_s]$: Suppose the property $\\mathcal{D}(t'', C) \\leq \\mathcal{D}(t'', C[x = y])$ holds for any trace $t'' = [[x], t_m', [y], t_s']$ where $t_m'$ does not access $y$ and any input state $C$ which does not hold $y$. From Lemma 3, this hypothesis applies to arbitrary prefixes $t_p'$ as long as they hold neither $x$ nor $y$:\n\n$$x \\notin t_p' \\wedge y \\notin t_p' \\wedge y \\notin t_m' \\wedge y \\notin C \\Rightarrow \\mathcal{D}([t_p'', [x], t_m'', [y], t_s''], C) \\leq \\mathcal{D}([t_p'', [x], t_m'', [y], t_s''], C[x = y])$$ (119)\n\nThe resulting execution access to $b$ in $t'$ is a guaranteed hit from $C_b$ and a miss from $C_b[b = e]$. The resulting execution time distributions can be expressed as per (21):\n\n$$\\mathcal{D}(t', C_b) = \\mathcal{H} + \\mathcal{D}([t_m, [e], t_s], C_b)$$ (120)\n\n$$\\mathcal{D}(t', C_b[b = e]) = \\mathcal{M} + \\sum_{i \\in [1, N]} \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[b = e][l_i = b])$$ (121)\n\n- If $b$ is present in $t_m$, there is an access to $b$ prior to the first access to $e$ in the remaining trace. $[t_m, [e], t_s]$ can be further split into $[t_m', [b], t_m'', [e], t_s]$ such that $t_m = [t_m', [b], t_m'']$ and $t_m'$ holds no reference to $b$ nor $e$. There is a reference to $b$ before the next access to $e$. From the induction hypothesis (119), substituting $b$ for $x$ and $e$ for $y$, we have:\n\n$$\\mathcal{D}([t_m, [e], t_s], C_b) \\leq \\mathcal{D}([t_m, [e], t_s], C_b[b = e])$$ (122)\n\nFrom Theorem 2, we know that:\n\n$$\\mathcal{H} + \\mathcal{D}([t_m, [e], t_s], C_b[b = e]) \\leq \\mathcal{M} + \\sum_{i \\in [1, N]} \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[b = e][l_i = b])$$ (123)\nHence from (122) and (123) the property trivally holds when \\( b \\) is in \\( t_m \\) using \\( \\mathcal{D}([t_m, [e], t_s], C_b[b = e]) \\) as an intermediate bound:\n\n\\[\n\\mathcal{H} + \\mathcal{D}([t_m, [e], t_s], C_b) \\leq \\mathcal{H} + \\mathcal{D}([t_m, [e], t_s], C_b[b = e]) \\\\\n\\leq \\mathcal{M} + \\sum_{i \\in [1, N]} \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[b = e][l_i = b])\n\\]\n\n(124)\n\nThe leftmost and rightmost terms can be reduced to the property of interest using respectively (120) and (121):\n\n\\[\n\\mathcal{D}(t', C_b) \\leq \\mathcal{D}(t', C_b[b = e])\n\\]\n\n(125)\n\n– Now consider the case where \\( b \\) is absent from the trace \\( t_m \\) as is \\( e \\). We distinguish the case where the first miss from \\( C_b[b = e] \\) in \\( t' = [[b], t_m, [e], t_s] \\) selects the line that originally held \\( b \\), \\( C_b[b = e][l_i = b] = C_b \\), from the ones where a different line is selected. The latter results in a cache state equivalent to \\( C_b[l_i = e] \\). By separating those cases in (21), we have:\n\n\\[\n\\mathcal{D}(t', C_b[b = e]) = \\mathcal{M} + \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b) \\\\\n+ \\sum_{i \\in [1, N] \\setminus b} \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[l_i = e])\n\\]\n\n(126)\n\nThis allows the definition of a lower-bound \\( \\mathcal{U} \\) of the contribution of the complete trace from \\( C_b[b = e] \\):\n\n\\[\n\\mathcal{U} = \\sum_{i \\in [1, N]} \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[l_i = e])\n\\]\n\n(127)\n\nWe further distinguish the case where \\( l_i \\) holds \\( b \\) from the others:\n\n\\[\n\\mathcal{U} = \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[b = e]) + \\sum_{i \\in [1, N] \\setminus b} \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[l_i = e])\n\\]\n\n(128)\n\nSince \\( t_m \\) holds neither \\( b \\) nor \\( e \\), we deduce from the induction hypothesis that replacing \\( b \\) by \\( e \\) in the cache does not degrade the execution time distribution of the trace \\([t_m, [e], t_s]\\) from \\( C_b[b = e] \\):\n\n\\[\n\\mathcal{D}([t_m, [e], t_s], C_b[b = e]) \\leq \\mathcal{D}([t_m, [e], t_s], C_b[b = e][e = b])\n\\]\n\n(129)\n\nReplacing \\( b \\) by \\( e \\) then \\( e \\) by \\( b \\) has no impact on the cache contents, \\( C_b[b = e][e = b] = C_b \\):\n\n\\[\n\\mathcal{D}([t_m, [e], t_s], C_b[b = e]) \\leq \\mathcal{D}([t_m, [e], t_s], C_b)\n\\]\n\n(130)\nDividing both sides by $N$ we get:\n\n$$\\frac{1}{N} \\cdot (\\mathcal{D}([t_m, [e], t_s], C_b[b = e])) \\leq \\frac{1}{N} \\cdot (\\mathcal{D}([t_m, [e], t_s], C_b)) \\quad (131)$$\n\nWe add the same factor, the random replacement of a line other than $b$, on both sides:\n\n$$\\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[b = e]) + \\sum_{i \\in \\{1, \\ldots, N\\} \\setminus b} \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[l_i = e]) \\leq \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b) + \\sum_{i \\in \\{1, \\ldots, N\\} \\setminus b} \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[l_i = e]) \\quad (132)$$\n\nThis equation orders the expanded form of $\\mathcal{M} + \\mathcal{U}$ in (128) and that of $\\mathcal{D}(t', C_b[b = e])$ in (126):\n\n$$\\mathcal{M} + \\mathcal{U} \\leq \\mathcal{D}(t', C_b[b = e]) \\quad (133)$$\n\nFrom Theorem 2, we can compare the bound $\\mathcal{U}$ to the execution time distribution of $t'$ from $C_b$:\n\n$$\\mathcal{H} + \\mathcal{D}([t_m, [e], t_s], C_b) \\leq \\mathcal{M} + \\sum_{i \\in \\{1, \\ldots, N\\}} \\frac{1}{N} \\cdot \\mathcal{D}([t_m, [e], t_s], C_b[l_i = b]) \\quad (134)$$\n\nThe rightmost term collapses to $\\mathcal{M} + \\mathcal{U}$ from (128):\n\n$$\\mathcal{H} + \\mathcal{D}([t_m, [e], t_s], C_b) \\leq \\mathcal{M} + \\mathcal{U} \\quad (135)$$\n\nHence, from this equation and (133) the property holds:\n\n$$\\mathcal{H} + \\mathcal{D}([t_m, [e], t_s], C_b) \\leq \\mathcal{M} + \\mathcal{U} \\leq \\mathcal{D}(t', C_b[b = e]) \\quad (136)$$\n\n$$\\mathcal{D}(t', C_b) \\leq \\mathcal{D}(t', C_b[b = e]) \\quad (137)$$\n\n**Lemma 1** The convolution operation preserves the ordering between execution time distributions:\n\n$$\\mathcal{D} \\leq \\mathcal{D}' \\Rightarrow \\mathcal{D} \\otimes \\mathcal{A} \\leq \\mathcal{D}' \\otimes \\mathcal{A}$$\n\n**Proof** Let us first assume that $\\mathcal{D} \\leq \\mathcal{D}$. This relation implies that $\\mathcal{D}'$ is greater than $\\mathcal{D}$, more formally:\n\n$$\\forall v, \\ P(\\mathcal{D} \\geq v) \\leq P(\\mathcal{D}' \\geq v) \\quad (138)$$\n\nThis property applies to the sum of probabilities for all values greater than $v$:\n\n$$\\forall v, \\sum_{x = v}^{+\\infty} \\mathcal{D}(x) \\leq \\sum_{x = v}^{+\\infty} \\mathcal{D}'(x) \\quad (139)$$\nIt can be in particular extended to any value \\((v - k)\\):\n\n\\[\n\\forall v, \\forall k, \\sum_{x=(v-k)}^{+\\infty} \\mathcal{D}(x) \\leq \\sum_{x=(v-k)}^{+\\infty} \\mathcal{D}'(x) \\tag{140}\n\\]\n\nAs we are considering the sum to infinity of values \\(\\mathcal{D}(x)\\), \\(k\\) can be subtracted indifferently from \\(x\\) or its lower bound \\(v\\):\n\n\\[\n\\forall v, \\forall k, \\sum_{x=(v-k)}^{+\\infty} \\mathcal{D}(x) = \\sum_{x=v}^{+\\infty} \\mathcal{D}(x - k) \\tag{141}\n\\]\n\nFrom the two previous equations, we have:\n\n\\[\n\\forall v, \\forall k, \\sum_{x=v}^{+\\infty} \\mathcal{D}(x - k) \\leq \\sum_{x=v}^{+\\infty} \\mathcal{D}'(x - k) \\tag{142}\n\\]\n\nThe occurrence probability of any element \\(x\\) in a distribution \\(A\\) is by definition a positive number, \\(A(k) \\geq 0\\). We can factor the same both sides of the inequality with the same values \\(A(k)\\):\n\n\\[\n\\forall v, \\forall k, A(k) \\cdot \\sum_{x=v}^{+\\infty} \\mathcal{D}(x - k) \\leq A(k) \\cdot \\sum_{x=v}^{+\\infty} \\mathcal{D}'(x - k) \\tag{143}\n\\]\n\n\\[\n\\forall v, \\forall k, \\sum_{x=v}^{+\\infty} A(k) \\cdot \\mathcal{D}(x - k) \\leq \\sum_{x=v}^{+\\infty} A(k) \\cdot \\mathcal{D}'(x - k) \\tag{144}\n\\]\n\nAs the inequality holds for any element \\(k\\), it holds for their overall sum over \\(k\\):\n\n\\[\n\\forall v, \\sum_{k=-\\infty}^{+\\infty} \\sum_{x=v}^{+\\infty} A(k) \\cdot \\mathcal{D}(x - k) \\leq \\sum_{k=-\\infty}^{+\\infty} \\sum_{x=v}^{+\\infty} A(k) \\cdot \\mathcal{D}'(x - k) \\tag{145}\n\\]\n\nThanks to the commutativity of the sum operands, we have:\n\n\\[\n\\forall v, \\sum_{x=v}^{+\\infty} \\sum_{k=-\\infty}^{+\\infty} A(k) \\cdot \\mathcal{D}(x - k) \\leq \\sum_{x=v}^{+\\infty} \\sum_{k=-\\infty}^{+\\infty} A(k) \\cdot \\mathcal{D}'(x - k) \\tag{146}\n\\]\n\nBoth terms of the inequality correspond to the convolution of distributions as defined in (20):\n\n\\[\n\\forall v, \\sum_{x=v}^{+\\infty} (A \\otimes \\mathcal{D})(x) \\leq \\sum_{x=v}^{+\\infty} (A \\otimes \\mathcal{D}')(x) \\tag{147}\n\\]\nThis defines an order between the result of the convolution of $D$ and $D'$ with distribution $A$:\n\n$$\\forall v, P((A \\otimes D) \\geq v) \\leq P((A \\otimes D') \\geq v) \\tag{148}$$\n\n$$A \\otimes D \\leq A \\otimes D' \\tag{149}$$\n\nPer commutativity of the convolution operator $\\otimes$, we have:\n\n$$D \\leq D' \\Rightarrow D \\otimes A \\leq D' \\otimes A \\tag{150}$$\n\n**Lemma 2** The contributions of merged sets of cache states $S$ and $A$ is the sum of their individual contributions:\n\n$$\\forall t, D(t, S) + D(t, A) = D(t, S \\cup A)$$\n\n**Proof** $S \\cup A$ can be divided into three categories, cache states $C$ that exist only in $S$, only $A$ or in both, denoted respectively $\\text{Only}_S$, $\\text{Only}_A$, $\\text{Com}_{(S,A)}$. The contribution of states in $\\text{Only}_S$ and $\\text{Only}_A$ is unchanged by the merge operation. Only states in $\\text{Com}_{(S,A)}$ are subject to the weighted merge in (6). We focus on proving the equivalence between the contribution of $\\text{Com}_{(S,A)}$ and that of original states from $A$ and $S$ respectively $\\text{Com}_A$ and $\\text{Com}_S$, $\\text{Com}_{(S,A)} = \\text{Com}_S \\cup \\text{Com}_A$.\n\nEach state in $\\text{Com}_{(S,A)}$ is the combination of corresponding states from $\\text{Com}_S$ and $\\text{Com}_A$. Without loss of generality, we assume there is a single matching state in $\\text{Com}_S$ and $\\text{Com}_A$ for each merged one in $\\text{Com}_{(S,A)}$:\n\n$$\\forall (C, P, D) \\in \\text{Com}_{(S,A)}, \\exists (C, P_A, D_A) \\in \\text{Com}_A \\wedge \\exists (C, P_S, D_S) \\in \\text{Com}_S \\wedge P = P_A + P_S \\wedge D = \\left(\\frac{P_A}{P} \\cdot D_A\\right) + \\left(\\frac{P_S}{P} \\cdot D_S\\right) \\tag{151}$$\n\nWe can express the execution time contribution of $\\text{Com}_{(S,A)}$ as per (37):\n\n$$D(t, \\text{Com}_{(S,A)}) = \\sum_{(C, P, D) \\in \\text{Com}_{(S,A)}} P \\cdot (D \\otimes D(t, C)) \\tag{152}$$\n\nBy replacing each merged distribution $D$ with the original distributions and probabilities from $S$ and $A$, we have:\n\n$$D(t, \\text{Com}_{(S,A)}) = \\sum_{(C, P, D) \\in \\text{Com}_{(S,A)}} P \\cdot \\left(\\left(\\frac{P_A}{P} \\cdot D_A\\right) + \\left(\\frac{P_S}{P} \\cdot D_S\\right)\\right) \\otimes D(t, C) \\tag{153}$$\n\nBy definition, the convolution of distributions and the multiplication of a distribution by a constant are associative operations, $P \\cdot (D \\otimes D') = (P \\cdot D) \\otimes D'$. We can therefore factor $P$ inside the merged distributions:\n\\[ \\mathcal{D}(t, \\text{Com}_{(S,A)}) = \\sum_{(C,P,D) \\in \\text{Com}_{(S,A)}} \\left( P \\cdot \\left( \\frac{P_A}{P} \\cdot \\mathcal{D}_A \\right) + P \\cdot \\left( \\frac{P_S}{P} \\cdot \\mathcal{D}_S \\right) \\right) \\otimes \\mathcal{D}(t, C) \\] \n\\[ (154) \\]\n\n\\[ \\mathcal{D}(t, \\text{Com}_{(S,A)}) = \\sum_{(C,P,D) \\in \\text{Com}_{(S,A)}} ((P_A \\cdot \\mathcal{D}_A) + (P_S \\cdot \\mathcal{D}_S)) \\otimes \\mathcal{D}(t, C) \\] \n\\[ (155) \\]\n\nThis equation can be refined into the contribution of states in \\text{Com}_S and \\text{Com}_A as follows:\n\n\\[ \\mathcal{D}(t, \\text{Com}_{(S,A)}) = \\sum_{(C,P,D) \\in \\text{Com}_{(S,A)}} (P_A \\cdot \\mathcal{D}_A) \\otimes \\mathcal{D}(t, C) + (P_S \\cdot \\mathcal{D}_S) \\otimes \\mathcal{D}(t, C) \\] \n\\[ (156) \\]\n\n\\[ \\mathcal{D}(t, \\text{Com}_{(S,A)}) = \\sum_{(C,P_A,D_A) \\in \\text{Com}_A} (P_A \\cdot \\mathcal{D}_A) \\otimes \\mathcal{D}(t, C) \\]\n\\[ + \\sum_{(C,P_S,D_S) \\in \\text{Com}_S} (P_S \\cdot \\mathcal{D}_S) \\otimes \\mathcal{D}(t, C) \\] \n\\[ (157) \\]\n\n\\[ \\mathcal{D}(t, \\text{Com}_{(S,A)}) = \\mathcal{D}(t, \\text{Com}_A) + \\mathcal{D}(t, \\text{Com}_S) \\] \n\\[ (158) \\]\n\n\\[ \\square \\]\n\n**Theorem 8** (Renamed path ordering) Given a path \\( \\pi \\) divided into three sub-paths \\( \\pi = [\\pi_S, \\pi_V, \\pi_E] \\), where \\( \\pi_V = [e, v_1, \\ldots, v_k, e] \\). The pWCET of \\( \\pi \\) is smaller than or equal to that of the renamed sequence \\( \\pi_r = [\\pi_S, \\pi_V (e \\rightarrow b), \\pi_E] \\), \\( \\mathcal{D}(\\pi) \\leq \\mathcal{D}(\\pi_r) \\), if:\n\n- there is no access to \\( b \\) in \\( \\pi_V \\);\n- the reuse distance of \\( e \\) before \\( \\pi_V \\) is smaller than that of \\( b \\) at this point;\n- the forward reuse distance of \\( e \\) at the end of \\( \\pi_V \\) is smaller than that of \\( b \\) at this point.\n\n**Proof** We focus on the behaviour of the execution time distribution of the path \\( \\pi \\) and its renamed alternative starting from the empty cache state, since is known to result in the worst execution time distribution over any other input state. Any valid pWCET must upper-bound this distribution, hence \\( \\mathcal{D}(\\emptyset, \\pi) \\) is a tight pWCET for path \\( \\pi \\).\n\nThe execution of path \\( \\pi_S \\) generates an ensemble \\( \\text{outcomes}(\\pi_S, \\emptyset) \\) of cache states \\( C \\). To each is attached an associated execution time distribution \\( \\mathcal{D} \\), corresponding to the hit and miss latencies of prior accesses, and an occurrence probability \\( P \\). The renaming does not impact the behaviour of accesses in \\( \\pi_S \\), therefore \\( \\text{outcomes}(\\pi_S, \\emptyset) \\) is left unchanged.\n\nThe execution time distribution of the renamed segment \\( \\pi_V (e \\rightarrow b) \\) is no greater nor smaller than that of \\( \\pi_V \\) from those cache states that hold neither \\( b \\) or \\( e \\), or hold both, \\( (e \\in s \\land b \\in s) \\lor (e \\notin s \\land b \\notin s) \\Rightarrow \\mathcal{D}(\\pi_V (e \\rightarrow b), s) = \\mathcal{D}(\\pi_V) \\). States that hold neither \\( b \\) nor \\( e \\) result in the same hit and miss events on both paths except that \\( b \\) replaces \\( e \\) on the renamed path. This also produces the same cache states but where \\( b \\) replaces \\( e \\) after the renamed segment. As for states that hold both \\( b \\) and \\( e \\), events\nwhich impact the line where $b$ is held on the original path are as likely to impact that of $e$ on the renamed one and vice-versa, e.g. the eviction of $b$ on the original corresponds to that of $e$ on the renamed one. This also results in the same cache states where $b$ replaces $e$ on the renamed path. The outcomes on $\\pi_V$ then match the ones on $\\pi_V(e \\to b)$ where $b$ replaces $e$ in the cache.\n\nWhen both blocks $b$ and $e$ are present in the outcomes on $\\pi_V$ they match the ones on the renamed path $\\pi_V(e \\to b)$. The execution time distribution of the last segment $\\pi_S$ is the same in either case. When $e$ is in the cache without $b$ after $\\pi_V$, it is matched by a state after $\\pi_V(e \\to b)$ where $b$ replaces $e$. From the Suffix ordering condition the first access to $e$ in $\\pi_S$ is before the first access to $b$, $frd(e,\\pi_S) < frd(b,\\pi_S)$. Theorem 3 applies; the execution of $\\pi_S$ after $\\pi_V$, when $e$ is in cache but not $b$, results in an execution time distribution that is no greater than the one after $\\pi_V(e \\to b)$ when $b$ replaces $e$ in the cache. Note that $b$ cannot be in cache without $e$ after $\\pi_V$ since the last access in $\\pi_V$ targets $e$.\n\nWe now focus on the contribution of states which hold one of $e$ or $b$ but not both, and prove their contribution to the renamed path outweighs that of the original. $\\mathcal{R}_e$ and $\\mathcal{R}_b$ respectively distinguish between those states of $outcomes(\\pi_S,\\emptyset)$ which hold one of $e$ or $b$.\n\nBase case $\\pi_V = [e]$: Every state in $\\mathcal{R}_b$ shares a common ancestor state with a state in $\\mathcal{R}_e$ such that they hold the same contents but $e$ replaces $b$. Indeed because of the condition on Prefix ordering, all states in $\\mathcal{R}_b$ come from states where $b$ and $e$ were held in the cache simultaneously, after the last access to $e$ in the prefix $\\pi_S$. There is then a sequence of events which evicts $e$ from the cache while conserving $b$, hence resulting in a state belonging to $\\mathcal{R}_b$. There is a matching sequence of events from this common ancestor which conserves $e$ instead of $b$. Simply assume that evictions on the line of $e$ target that of $b$ and vice-versa. The two sequences of events are exactly as likely to occur as there is no other access to either $b$ or $e$ from their common ancestor to the renamed segment.\n\nConsider the following four scenarios for a state $s$ of $\\mathcal{R}_b$:\n\n1. $[e]$ executes from $s$, hence resulting in a miss and $N$ output cache states $s[l_i = e]$.\n2. $[e]$ executes from the as likely $s[b = e]$ of $\\mathcal{R}_e$, hence resulting in a hit and the output cache state $s[b = e]$.\n3. $[b]$, the renamed sequence, executes from $s$, hence resulting in a hit and an output cache state $s$.\n4. $[b]$ executes from $s[b = e]$, hence resulting in a miss and $N$ output cache states $s[b = e][l_i = b]$.\n\nScenarios 3 and 2 balance each other, resulting in a worse behaviour on the renamed sequence. Both suffer from the same execution latency for $\\pi_V$. Because of the Suffix ordering condition on the ordering between the forward reuse distances of $b$ and $e$ and Theorem 3, the execution time distribution of $\\pi_E$ is worse starting from $s$ than from $s[b = e]$.\n\nA similar argument can be made for scenarios 1 and 4. Each line $l_i$ has the same probability to be selected for eviction in each scenario. If $l_i$ is the line that held $b$ in $s$, the output cache states in cases 1 and 4 respectively are $s[b = e]$ and $s[b = e][l_i = b] = s[b = e][e = b] = s$. As per Theorem 3, it results in execution time distributions\nthat are no lower for the renamed path than for the original one. If \\( l_i \\) is another line, the resulting cache states, \\( s[l_i = e] \\) and \\( s[b = e][l_i = b] \\), hold the same contents, \\( s[b = e][l_i = b] = s[l_i = e] \\), and result in the same execution time distribution for \\( \\pi_E \\).\n\nAs for the remaining states \\( C_e \\) in \\( \\mathcal{R}_e \\), the ones which do not mirror a state in \\( \\mathcal{R}_b \\) they respectively result in a hit on the original segment and a miss on the renamed one. On the renamed path, this results in the replacement of a line \\( l_i \\) by \\( e \\). In other words, \\( D([\\pi_V \\in \\pi_E], C_e) = H + D(\\pi_E, s) \\) and \\( D([\\pi_V (e \\to b), \\pi_E], C_e) = M + \\sum_{i \\in [1,N]} D(\\pi_E, C_e[l_i = b]) \\). The execution time distribution of the original path from \\( C_e \\) is therefore no greater than that of the renamed path according to Theorem 2.\n\nOverall the execution of the renamed path \\([b]\\) results in execution time distributions that are no lower than those obtained through the execution of the original one \\([e]\\).\n\nGeneral case \\( \\pi_V = [e, v_1, \\ldots, v_k, e] \\): The arguments for the basic case can be extended to the general case where \\( \\pi_V \\) holds multiple accesses. The key observation is that the renaming has no impact on the reuse distance of accesses within \\( \\pi_V \\) except for the first. As in the base case, we focus on the contribution of states which hold one of \\( b \\) or \\( e \\). Consider the same four scenarios for input state \\( s \\in \\mathcal{R}_b \\) of \\( \\pi_V = [e, v_1, \\ldots, v_k, e] \\):\n\n1. \\([e, v_1, \\ldots, v_k, e]\\) executes from \\( s \\), hence resulting in a first miss and \\( N \\) cache states \\( s[l_i = e] \\).\n2. \\([e, v_1, \\ldots, v_k, e]\\) executes from \\( s[b = e] \\) of \\( \\mathcal{R}_e \\), hence resulting in a first hit and cache state \\( s[b = e] \\).\n3. \\([b, v_1, \\ldots, v_k, b]\\) executes from \\( s \\), hence resulting in a first hit and cache state \\( s \\).\n4. \\([b, v_1, \\ldots, v_k, b]\\) executes from \\( s[b = e] \\), hence resulting in a first miss and \\( N \\) cache states \\( s[b = e][l_i = b] \\).\n\nFrom scenario 1 to 4, and scenario 2 to 3, \\( b \\) simply replaces \\( e \\) in both cache contents and trace of accesses \\( \\pi_V \\). The behaviour of the first access in \\( \\pi_V \\) is the same in either the original or the renamed path, and there is no more misses on the original than on the renamed path since they have the same initial contents and trace where \\( b \\) simply replaces \\( e \\). The reuse distance of all accesses but the first is left unchanged between these pairs of scenarios, \\( D(\\pi_V, s) = D(\\pi_V (e \\to b), s[b = e]) \\) and \\( D(\\pi_V, s[b = e] = D(\\pi_V (e \\to b), s) \\).\n\nThe resulting cache states after \\( \\pi_V (e \\to b) \\) also match the ones after \\( \\pi_V \\) with \\( b \\) replacing \\( e \\) in cache. Because of the Suffix ordering condition, the first access to \\( b \\) in \\( \\pi_E \\) is preceded by an earlier access to \\( e \\). Hence from Theorem 3 we have that the execution of \\( \\pi_E \\) after \\( \\pi_V \\) results in an execution time distribution that is no greater than the one starting from the matching input state \\( s'[e = b] \\) after the renamed path \\( \\pi_V (e \\to b) \\).\n\nFor some cache states \\( C_e \\) in \\( \\mathcal{R}_e \\), the input states of \\( \\pi_V \\) which hold \\( e \\) but not \\( b \\), do not mirror a state in \\( \\mathcal{R}_b \\). The first access in \\( \\pi_V (e \\to b) \\) is a miss from \\( C_e \\). This intuitively increases the reuse distance of the remaining accesses in the renamed \\([\\pi_V (e \\to b), \\pi_E] \\) over the original trace \\([\\pi_V, \\pi_E] \\). We prove by induction that:\n\n\\[\nD([\\pi_V \\in \\pi_E], C_e) \\leq D([\\pi_V (e \\to b), \\pi_E], C_e)\n\\]\n\n(159)\nThe base case, when $\\pi_V$ holds a single access to $e$, has already been proved thanks to Theorem 2. Our induction hypothesis is, assuming $\\pi'_V$ is a subtrace of $\\pi_V$:\n\n$$D([\\pi'_V, \\pi_E], C_e) \\leq D([\\pi'_V(e \\rightarrow b), \\pi_E], C_e) \\quad (160)$$\n\nFrom Theorem 2, we have:\n\n$$H + D([[v_1, \\ldots, v_k, e](e \\rightarrow b), \\pi_E], C_e) \\leq M + \\sum_{i \\in [1,N]} D([[v_1, \\ldots, v_k, e](e \\rightarrow b), \\pi_E], C_e[l_i = b]) \\quad (161)$$\n\nThe left-hand term corresponds to the execution of a trace where the renaming from block $e$ to $b$ occurs on $\\pi'_V = [v_1, \\ldots, v_k, e]$, after the first access to $e$ in $\\pi_V$. The right-hand term simply exhibits the first miss on the execution of the renamed trace $[\\pi_V(e \\rightarrow b), \\pi_E]$ from $C_e$ as per (21):\n\n$$H + D([[v_1, \\ldots, v_k, e](e \\rightarrow b), \\pi_E], C_e) \\leq D([\\pi_V(e \\rightarrow b), \\pi_E], C_e) \\quad (162)$$\n\nFrom the induction hypothesis we have:\n\n$$D([[v_1, \\ldots, v_k, e], \\pi_E], C_e) \\leq D([[v_1, \\ldots, v_k, e](e \\rightarrow b), \\pi_E], C_e) \\quad (163)$$\n\nBy inserting a hit latency on both sides this equation becomes:\n\n$$H + D([[v_1, \\ldots, v_k, e], \\pi_E], C_e) \\leq H + D([[v_1, \\ldots, v_k, e](e \\rightarrow b), \\pi_E], C_e) \\quad (164)$$\n\nThe first access in $\\pi_V = [e, v_1, \\ldots, v_k, e]$ from $C_e$ is a cache hit and leaves the cache state unchanged. The term on the left hand side can be expressed as:\n\n$$D([\\pi_V, \\pi_E], C_e) \\leq H + D([[v_1, \\ldots, v_k, e](e \\rightarrow b), \\pi_E], C_e) \\quad (165)$$\n\nHence, $H + D([[v_1, \\ldots, v_k, e](e \\rightarrow b), \\pi_E], C_e)$ is an intermediate bound between the execution time distributions of $D([\\pi_V, \\pi_E], C_e)$ and $D([\\pi_V(e \\rightarrow b), \\pi_E, C_e])$. From (165) and (162), we have:\n\n$$D([\\pi_V, \\pi_E], C_e) \\leq H + D([[v_1, \\ldots, v_k, e](e \\rightarrow b), \\pi_E], C_e) \\quad \\leq D([\\pi_V(e \\rightarrow b), \\pi_E], C_e) \\quad (166)$$\n\nEach possible input cache state $s'$ to the renamed segment has an as likely match $s$ in the original trace such that the execution time distribution of the renamed segment from $s'$ is no lower than that of the original from $s$. \n\n□\nReferences\n\n\nGriffin D, Burns A (2010) Realism in statistical analysis of worst case execution times. In: 10th International workshop on worst-case execution time analysis (WCET’10), July 2010\n\nLesage B, Griffin D, Altmeyer S, Davis R (2015a) Static probabilistic timing analysis for multi-path programs. In: Real-time systems symposium (RTSS)\nMuchnick SS (1997) Advanced compiler design and implementation. Morgan Kaufmann, San Francisco\n\n\nBenjamin Lesage is a Research Associate in the Real-Time Systems Research Group at the University of York, UK. Benjamin received his PhD in Computer Science in 2013 from the University of Rennes, France. He has since been at the University of York as a Research Associate. He is currently working in the context of a Knowledge Transfer Partnership, in collaboration with industrial partners, to put into practice his knowledge of real-time systems’ timing analyses.\n\nDavid Griffin is currently a member of the Real Time Systems Group at the University of York, UK. His research has primarily been in the application of non-standard techniques to Real-time problems, utilising techniques from various other fields such as lossy compression, statistics and machine learning.\n\nSebastian Altmeyer is Assistant Professor (Universitair Docent) at the University of Amsterdam. He has received his PhD in Computer Science in 2012 from Saarland University, Germany with a thesis on the analysis of preemptively scheduled hard real-time systems. From 2013 to 2015 he has been a postdoctoral researcher at the University of Amsterdam, and from 2015 to 2016 at the University of Luxembourg. In 2015, he has received an NWO Veni grant on the timing verification of real-time multicore systems, and he is program chair of the Euromicro Conference on Real-Time Systems (ECRTS) 2018. His research targets various aspects of the design, analysis and verification of hard real-time systems, with a particular interest in timing verification and multicore architectures.\nRobert I. Davis is a Senior Research Fellow in the Real-Time Systems Research Group at the University of York, UK, and an INRIA International Chair with INRIA, Paris, France. Robert received his PhD in Computer Science from the University of York in 1995. Since then he has founded three start-up companies, all of which have succeeded in transferring real-time systems research into commercial products. Robert’s research interests include the following aspects of real-time systems: scheduling algorithms and analysis for single processor, multiprocessor and networked systems; analysis of cache related pre-emption delays, mixed criticality systems, and probabilistic hard real-time systems."}}},{"rowIdx":283,"cells":{"id":{"kind":"string","value":"8d0719082df8fb9075b338e02eb64bbd9f91bae4"},"text":{"kind":"string","value":"Master Thesis\n\nTranslating Spec# Programs to C# with CodeContracts\n\nAuthor(s):\nEgli, Florian\n\nPublication Date:\n2012\n\nPermanent Link:\nhttps://doi.org/10.3929/ethz-a-007305132\n\nRights / License:\nIn Copyright - Non-Commercial Use Permitted\nTranslating Spec# Programs to C# with CodeContracts\n\nFlorian Egli\n\nMaster's Thesis\n\nChair of Programming Methodology\nDepartment of Computer Science\nETH Zurich\n\nhttp://www.pm.inf.ethz.ch/\n\nFS 2011\nApril 23, 2012\n\nSupervised by:\nValentin Wüstholz\nProf. Dr. Peter Müller\nAbstract\n\nContracts are used to specify the behavior of programs. These contracts can be verified statically, to prove that the program code is correct and the contracts are always satisfied, or they can be asserted during runtime. One programming language that offers support for contracts is Spec#. It implements an ownership model to ensure code correctness. Spec# tool support is limited to SSCBoogie for static verification.\n\nCodeContracts is a project that aims to offer contracts for standard .Net, with a different specification language than Spec# and extended tool support.\n\nThe goal of this thesis is to design an encoding for Spec# programs in C# and CodeContracts. With this, we are able to translate programs written in Spec# to CodeContracts compatible code, extended with ownership states and assertions that would be checked by SSCBoogie, while preserving the programs semantic.\n\nFor the translation, we use an extension of CodeContracts, that provides additional specification constructs, called CodeContracts++.\n\nThese translated programs can then be analyzed and tested with tools that support CodeContracts, such as Pex for automatic test generation and Clousot for code analysis, that otherwise would not be available for Spec#.\nAcknowledgments\n\nI would like to thank Prof. Dr. Peter Müller for the opportunity to do my master’s thesis in such an interesting research area. I would also like to thank my supervisor, Valentin Wüstholz, for his great support during my thesis and for the numerous hours of discussion about subtle details in the Boogie encoding and the Spec# compiler architecture.\nContents\n\n1 Introduction .............................................. 11\n 1.1 Motivation ........................................... 11\n 1.2 Assumptions ......................................... 11\n 1.3 Outline ............................................. 12\n 1.4 Technologies ........................................ 12\n 1.4.1 Spec# and Boogie ................................. 12\n 1.4.2 CodeContracts ................................. 12\n 1.4.3 CodeContracts++ ............................... 13\n 1.4.4 Dafny ........................................ 13\n\n2 Design .................................................. 15\n 2.1 Spec# Runtime Checks ............................... 15\n 2.2 Ownership Model and Invariant Semantics .......... 15\n 2.2.1 State Maintenance ............................. 17\n 2.2.2 Peer Group Placeholder ....................... 19\n 2.2.3 Ownership Assignment ........................ 19\n 2.2.4 Dynamic Frames ............................... 19\n 2.2.5 Method Contracts ............................. 20\n 2.2.6 Consistency Check ............................. 21\n 2.2.7 Frame Condition .............................. 21\n 2.2.8 Ghost Variable Encoding ..................... 22\n 2.2.9 Owner Rep .................................. 23\n 2.3 Translation Rules .................................. 24\n 2.3.1 Dictionary Example ............................ 24\n 2.3.2 Initialization / Construction ................. 25\n 2.3.3 Object Invariants .............................. 26\n 2.3.4 Pre- and Postconditions ....................... 27\n 2.3.5 Modifies Clause ............................... 31\n 2.3.6 Method Calls .................................. 32\n 2.3.7 Expose ....................................... 34\n 2.3.8 Constructor Calls ............................. 36\n 2.3.9 Local Variable Assignment ..................... 37\n 2.3.10 Field Assignment ............................. 37\n 2.3.11 Array Element Assignment ..................... 40\n 2.3.12 Contract Inheritance and Virtual Methods ...... 40\n 2.3.13 Pure Methods .................................. 40\n 2.3.14 Loop Invariants ............................... 40\n 2.3.15 Old .......................................... 41\n 2.3.16 Result ....................................... 41\n 2.3.17 Inline Assertions ............................. 41\n 2.3.18 Inline Assumptions ............................ 41\n 2.3.19 Quantifiers and Reductions ................... 41\n## Implementation\n\n### 3.1 Architecture\n\n- Toolchain\n- Overview\n- Ownership Methodology Model\n- Garbage Collection\n- Nested Calls\n- Translation Output\n- Custom Standard Visitor vs. Generic Visitors and Code Generators\n\n### 3.2 Language Features\n\n- Modopt\n- Runtime Contracts Attribute\n- Compiler Generated Names\n- Delegates\n- Single Point of Return\n- ssc Generated Runtime Checks\n- Attributes\n\n### 3.3 Design Decisions\n\n- Ownership Model\n- Frame Guard\n- Frame Condition Evaluation\n- Inv / Local Inv Modeling\n\n### 3.4 sscBoogie Options\n\n- Spec#\n- CC++ Translation\n\n## Evaluation\n\n### 4.1 Test Suite\n\n### 4.2 Runtime Tests\n\n### 4.3 Pex\n\n### 4.4 Clousot\n\n## Conclusion\n\n### 5.1 State of the Implementation\n\n### 5.2 Future Work\n\n## Encountered Difficulties\n\n### A.1 sscBoogie\n\n- Normalizer\n- Recover Serialized Contracts\n- AST Node Equality\n- sscBoogie and Boogie\n\n### A.2 CodeContracts\n\n- Higher Level Language Features in Contract.OldValue()\n- Contract.OldValue() Deep Copy\n- Contracts before Constructor Base Call\n- Overridden Methods with TypeOf Operator in Contracts\n## CONTENTS\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A.3 Pex</td>\n<td>63</td>\n</tr>\n<tr>\n<td>B Uncovered Bugs</td>\n<td>65</td>\n</tr>\n<tr>\n<td>B.1 sscBoogie</td>\n<td>65</td>\n</tr>\n<tr>\n<td>B.1.1 Quantifiers</td>\n<td>65</td>\n</tr>\n<tr>\n<td>B.2 Boogie</td>\n<td>65</td>\n</tr>\n<tr>\n<td>B.2.1 Lambda Expressions</td>\n<td>65</td>\n</tr>\n<tr>\n<td>C Translation Rules Prototyping in Dafny</td>\n<td>67</td>\n</tr>\n<tr>\n<td>D Dictionary Example</td>\n<td>69</td>\n</tr>\n</tbody>\n</table>\nChapter 1\n\nIntroduction\n\nThis chapter gives an overview of this thesis and the motivation behind it. In the later sections, all technologies involved in this thesis are briefly explained, to ensure a certain background.\n\n1.1 Motivation\n\nThe goal of every programmer is to write correct code. Achieving this is not easy. To help the programmer in finding bugs in the code, static verification and code analysis can be used. It is desired that program verification runs automatically, without user interaction. Spec# [29] and CodeContracts (CC) [7], both languages or language extensions provide such automatic verification and analysis tools. But both use different approaches to analyze the code and to find bugs. Spec# uses Boogie [5] with verification conditions to verify the code, whereas CodeContracts uses Clousot [12] which is based on abstract interpretation. Both methods try to ensure that the program code meets the programs specification. Abstract interpretation is more efficient but less precise than verification conditions. Both approaches have their benefits and disadvantages.\n\nA counterexample that violates the code specifications is one of the most understandable ways for tools to point out bugs to a programmer. Pex is a tool, that generates test cases for CodeContracts code and searches such counterexamples. For Spec# there has no such tool been developed so far.\n\nThe goal of this thesis is to translate Spec# code (and the necessary assertions for ensuring program correctness) into CodeContracts code, so that Spec# users can benefit from the growing number of tools that exist for CodeContracts.\n\nThe translation from Spec# to CodeContracts is not trivial. Spec# implements an ownership model that allows to statically check object invariants and heap modifications. This model must be translated into CodeContracts.\n\nSpec# generates .Net compatible Intermediate Language (IL) code. Runtime checks are only generated for method pre-/postconditions and object invariants. Non-nullable types are checked by the Spec# type system during compilation. All other conditions, such as ownership state, frame conditions etc., are checked by Boogie.\n\nAll assertions Boogie creates, will be added to the IL code, using CodeContracts++ (CC++). The benefit of this approach is, that all tools that support IL can process and verify this translated/extended code, and not only tools that support Boogie.\n\nOur translation will use the dynamic frames theory to specify heap modifications. Therefore, the ownership model and heap model handling must be slightly adapted from Boogie.\n\n1.2 Assumptions\n\nIn this thesis we focus on some core features of Spec#. It is not the goal of this thesis to provide a full translation of all language features offered by Spec#.\n1.3 Outline\n\nThis thesis aims to translate Spec# programs to CC++ programs. Chapter 2 gives an insight in the Spec# ownership model and defines the translation rules, explained on a concrete example. Chapter 3 explains the architecture of the modified Spec# compiler backend and how the translation rules have been implemented. Chapter 4 evaluates the implemented encoding using Pex and Clousot. Chapter 5 concludes this work.\n\n1.4 Technologies\n\nThis section gives a brief overview of the different technologies involved in this thesis and how they are connected. It is not intended to give full background information that is needed to understand the issues discussed in this thesis. For further information, the referenced papers can be consulted.\n\n1.4.1 Spec# and Boogie\n\nSpec# is a research language, developed by Microsoft. It is a superset of C#, .Net 2.0, with additional support for contracts. Some notable language features are: Object invariants, pre-/postconditions, loop invariants, modifies clauses etc.\n\nSpec# implements an ownership model. Every object has a specific state within this model. The ownership states determine if objects are allowed to be modified at a certain point in the program.\n\nsss is the Spec# compiler. It generates annotated IL code. Contracts are compiled into serialized abstract syntax tree (AST) strings and added as method attributes, or as string parameter of marker methods from the Microsoft.Contract namespace. sssBoogie takes this annotated IL code and generates Boogie code (BPL). This Boogie code can then be statically verified.\n\nBoogie takes Boogie code and checks the consistency between a program and its specification by generating verification conditions, that are checked with the Z3 Satisfiability Modulo Theories (SMT) solver [31].\n\nMike Barnett and Manuel Fähndrich have plans to modify the current implementation of Spec# and integrate CodeContracts in it [1]. So that Spec# uses the CodeContracts infrastructure instead of the current custom infrastructure. With this, some of our translation steps would become obsolete and we could focus on extending the generated CodeContracts checks with the ownership model. Currently, this is not the case.\n\n1.4.2 CodeContracts\n\nCodeContracts was developed by Microsoft. It is based on the experience gained by the Spec# project. CodeContracts provides support for pre-/postconditions, object invariants, assertions and assumptions, similar to Spec#. It does not contain an ownership model or provide support for non-null types or loop invariants.\n\nThe CodeContracts specifications consist of empty method declarations (markers) that are not executable. These specifications are turned into runtime checks by the CodeContracts rewriter (ccrewrite).\n\n\\[ ^1 \\text{ssBoogie can only process code that was compiled with the ssc parameter /debug} \\]\n1.4 Technologies\n\n**Pex** Pex is a code analysis tool that automatically finds test cases to achieve high code coverage, using dynamic symbolic execution [30]. It works on the rewritten CodeContracts code.\n\n**Clousot** Clousot is a static contract checker, using abstract interpretation [12, 11]. It works directly on the CodeContracts declarations.\n\n1.4.3 **CodeContracts++**\n\nCodeContracts++, or CC++, was developed by Maria Christakis, Peter Müller and Valentin Wüstholz. It is an (independent) extension of CodeContracts and provides additional framing features, such as writes-, reads- and fresh-clauses and ghost variables. CC++’s language extensions are partially based on Dafny.\n\nIn our thesis, this library acts as an intermediate language between Spec# and CodeContracts. It is used to model the Spec# ownership methodology using dynamic frames.\n\n1.4.4 **Dafny**\n\nDafny provides similar features as Spec#, but uses dynamic frames to specify heap modifications [17, 8]. Code verification is also done with Boogie. Other than Spec#, Dafny does not support inheritance.\n\nTo have a certain confidence that our translation rules are correct, a subset of the rules have been prototyped and tested in Dafny. The results from these tests have been integrated in the CC++ translation. In particular, a simplified version of the ownership model has proven to be useful to develop the encoding of our frame condition rules.\nChapter 2\n\nDesign\n\nThis chapter discusses the design of the translation for the Spec# ownership model and how Spec# programs are translated. Section 2.1 analyzes what kind of runtime checks are generated by Spec# and which runtime checks have to be added during the CC++ translation. Section 2.2 describes the encoding of the ownership model in CC++. Section 2.3 explains the translation rules for the Spec# key language features.\n\n2.1 Spec# Runtime Checks\n\nThe advantage of Spec# over C# is its native support for contracts, which allow to specify programs. Spec# allows interoperability with existing .Net code and turns the specified contracts into runtime checks [4]. While Spec# generates runtime checks for pre- and postconditions, frame conditions are not checked at runtime. They are only checked statically, by sscBoogie. According to Mike Barnett and K. Rustan N. Leino, one reason that frame conditions and ownership states are not checked at runtime by Spec# is, that this could cause programs to fail that otherwise would be correct. Another reason is that these checks can be very expensive and can cause a large runtime overhead, as they compare arbitrarily large portions of the heap. These checks are not in the IL code, but they are added by sscBoogie to the generated Boogie code, to be verified by Boogie. Beneficial would be to have these checks in the IL code, in order to verify them with other tools that work directly on the IL level. Thus, a goal of this thesis is, to convert all assertions that are generated for Boogie into runtime checks.\n\n2.2 Ownership Model and Invariant Semantics\n\nSpec# implements an ownership model, where objects are layered in a forest-shaped hierarchy (no cyclic structures). The invariant semantics of Spec# depends heavily on this ownership model. An object can own other objects and it can be owned by an object. An object that is owned by another object, is called a representation object (rep). Objects that are owned by the same object are called peers. These ownership relations are used to determine the state of objects and which objects are allowed to modify other objects. Depending on the state of an object, its invariants are known to hold or not.\n\nFigure 2.1 shows a possible configuration of object states in the ownership model. Committed objects are not allowed to be modified and their invariants must hold. Consistent objects can be modified as long as their object invariants are satisfied. Mutable objects are allowed to break their object invariants and can be freely modified. In short, object invariants must hold if the object is in a valid state and is not vulnerable to modifications. The ownership states determine at what point in the program it is valid to update the fields of a class. Whereas fields can be read independent from the object state [2].\nField \\( f \\) of an object \\( o \\) may be modified within a method, if:\n\n- \\( o.f \\) is specified (implicitly or explicitly) in the modifies clause of the method.\n\n- object \\( o \\) was newly allocated within the method, which implies that \\( o \\) is in the fresh set of the method.\n\n- object \\( o \\) is committed and (transitively) owned by an object that is allowed to be modified within the method, which implies that \\( o \\) is an element of the rep set of an object that is specified in the modifies clause.\n\nThe state of an object depends on its own invariant state and the state of its owner. Table 2.1 shows all possible ownership states.\n\n<table>\n<thead>\n<tr>\n<th>State</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Committed</td>\n<td>The object is not allowed to be modified. The object invariants of all class frames hold.</td>\n</tr>\n<tr>\n<td>Consistent</td>\n<td>The object is allowed to be modified as long as the object invariants are satisfied. The object is unowned, or the owner is exposed.</td>\n</tr>\n<tr>\n<td>Mutable</td>\n<td>The exposed class frame is allowed to be freely modified. The object invariants of this class frame can be violated. Directly owned objects can be modified, as they are in the state Consistent.</td>\n</tr>\n<tr>\n<td>Valid</td>\n<td>The object’s invariants hold.</td>\n</tr>\n<tr>\n<td>Writable</td>\n<td>The object is allowed to be modified.</td>\n</tr>\n</tbody>\n</table>\n\nTable 2.1: Ownership States\n\nThe states Valid and Writable overlap with the states Committed, Consistent and Mutable. These two states are used to simplify the ownership rules.\n\nObjects can switch between the states Consistent and Mutable with Unpack and Pack. For an object to be in the Committed state, it has to have an owner (we say it must be owned) and the owner must be in the state Consistent or Committed. The states Consistent, Committed and\nValid apply to an object as a whole. The states Mutable and Writable apply to a specific class frame. A class frame is a specific type in the inheritance hierarchy of an object.\n\nFigure 2.2 shows the state transitions of an object from Committed to Mutable. First, to change from Committed to Consistent, the owner of this object is unpacked, then, to change from Consistent to Mutable, the object itself is unpacked.\n\nFigure 2.2: Possible State Transitions of an Object\n\nDue to inheritance, an object can consist of multiple types (or class frames) depending on the inheritance structure. Each class frame can have its own object invariants. An ownership relation is always bound to an object reference and a class frame. Within a method, the method can only modify objects it has a reference to. These are all owned objects, peer objects, objects passed as parameter and object fields (and all transitively reachable fields of these objects). Which of these objects a method is allowed to modify is defined by the frame condition (or modifies clause) of this method. The frame condition defines which objects can change in a method and which objects cannot.\n\nDuring the execution of a method multiple sets have to be maintained, which store the state of the current execution and which are used for checks; e.g., prestate, poststate, modifiable objects, modifiable fields, fresh.\n\nThe described ownership model is called the standard ownership model. ssBoogie supports two additional ownership models, the trivial ownership model and the experimental ownership model. These models are not covered by this thesis.\n\n### 2.2.1 State Maintenance\n\nTo model ownership, the following ghost variable fields are required: _inv, _localinv, _owner, _ownerframe, _rep. All these fields are defined per object instance. A detailed description of some of these fields can be found here [2, 22].\n\nGhost variables are variables that are only used for verification and can be removed from the final program without changing the programs behavior. CC++ offers support for ghost variables. These ghost variables are only used by checks generated by the CC++ translation. They are never accessed by the user code. In CC++, the ∼ unary operator can be used as shortcut for the read operation on ghost variables; e.g., ∼_inv returns the value stored in the _inv ghost variable. This operator will be used in the following chapters.\n\nTable 2.2 shows how the ghost variable fields are related to the ownership states. Where #: denotes the reflexive and transitive subtype operator (e.g., string #: object), and o denotes an object. frame denotes a class frame between the allocated type of object o and the root base class. The Type property returns the allocated type of an object. The BaseType property returns the direct supertype of a type.\n\n### Inv\n\nThe field _inv is of type Type and it represents the most derived class frame of an object which is valid; e.g., if _inv is set to type A, and A is a subtype of base type Object, then the object invariants of all class frames between Object and, including A must hold.\nThe field \\_inv can only be changed by the commands *additive unpack* and *additive pack*.\n\n### Local Inv\n\nThe field \\_localinv is of type Type and represents that all class frames are valid, except the class frame directly below the class frame at which \\_localinv points at; e.g., in an inheritance structure SpecialDictionary <: Dictionary <: CCObject, and \\_localinv points to CCObject, then the class frames SpecialDictionary and CCObject are valid, but Dictionary is not.\n\nThe field \\_localinv can only be changed by the commands *unpack* and *pack*.\n\n### Owner\n\nThe field \\_owner is of type object reference and points to the owner object.\n\nThe field \\_owner can only be changed once in an object’s lifetime, when the object becomes owned by another object. Before the object is owned, the field is null.\n\n### Owner Frame\n\nThe field \\_ownerframe is of type Type and states the class frame of the owner that owns the object.\n\nThe field \\_ownerframe can only be changed once in an object’s lifetime, when the object becomes owned by another object. Before the object is owned, a peer group placeholder is assigned to this field.\n\n### Rep\n\nThe \\_rep field, also known as the rep set/region (rep), contains all objects that are transitively owned by an object instance (including the object itself).\n\nThe \\_rep set is changed if the current object is set as owner of another object, or at the end of an expose statement when the \\_rep sets of transitively owned objects are updated.\n\nThe big difference to the Boogie encoding is, that not only directly owned objects are in the rep set, but all transitively owned objects. Thus, the \\_rep set can be used to check the fresh- and modifies condition.\n\nThe following properties hold:\n\n- If an object is valid, then the rep set of every transitively owned object of this object is a subset of this object’s rep.\n- The object itself is an element of its rep set.\n• An object’s owner can never be an element of the object’s rep set. (This invariant disallows cyclic ownership.)\n\n• If objects in a rep set have the same owner, then the rep sets of these objects are distinct. \n$$\\forall a \\in \\text{this.rep}, \\ b \\in \\text{this.rep} : a.\\_owner = b.\\_owner \\Rightarrow a = b \\lor a.\\_rep \\cap b.\\_rep = \\emptyset$$\n\n• The owner of every object in a rep set must be an element of rep set itself (except the owner of the object whose rep set it is: $\\text{this.}\\_owner \\notin \\text{this.}\\_rep$).\n\n### 2.2.2 Peer Group Placeholder\n\nPeer group placeholders (PGP) are placeholders for missing owners. If an object is unowned, it has a PGP as owner. Every newly allocated object has its own PGP owner and is the only element in the PGP’s rep set. This PGP owner is used, if multiple objects become peers even if they are unowned.\n\nThe object that becomes a peer of another object is added to the rep set of the new peers peer group placeholder and changes the owner reference to this peer group placeholder. If the object that becomes peer already has peers, then all peers are updated and the two peer group placeholder rep sets are merged.\n\nFigure 2.3 shows how two rep sets are merged, if an object in one peer group is assigned as peer of an object in another peer group. Object $c$ has a peer field $f$. If object $d$ is assigned to this field, all objects in the peer group $B$ are merged into $A$’s rep set and become part of peer group $A$.\n\n\n\nThe peer group placeholders are modeled exactly the same as in Boogie.\n\n### 2.2.3 Ownership Assignment\n\nAn object that becomes the new owner of an other object, has to be at least as modifiable as the object itself. Otherwise, this would violate the ownership state rules. Object can only become owned by writable objects.\n\nTable 2.3 shows in what state an object is allowed to become owned and the resulting state; e.g., after the statement `UpdateOwnerForRep(object, owner)`, if the two objects were in the correct state, object is owned by owner and changed its state.\n\nIn the current version of Spec#, the ownership relation can only be assigned once. If an object is owned, it can not be unowned or owned by another object. Therefore, we also prevent this in our model.\n\n### 2.2.4 Dynamic Frames\n\nThe Spec# verifier reasons over the entire heap. This is not possible in CodeContracts, as CodeContracts allows reasoning only over a bounded number of objects. Therefore we must define a method in which we can reason over all objects that can be modified without knowing the states of all objects on the heap. For this we use dynamic frames [16], where all required states and objects are maintained in sets, modeled with ghost variables.\n\nIn dynamic frames, every method has a footprint. This footprint states which already allocated objects are allowed to be modified in a method. In addition, we want to reason over newly allocated\nTable 2.3: Ownership Mapping\n\n<table>\n<thead>\n<tr>\n<th>object</th>\n<th>mutable</th>\n<th>consistent</th>\n<th>committed</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>mutable</td>\n<td>mutable</td>\n<td>Error: RHS and its peers must all be valid</td>\n<td>Error: Target object of assignment is not allowed to be committed</td>\n</tr>\n<tr>\n<td>consistent</td>\n<td>consistent</td>\n<td>committed</td>\n<td>Error: Target object of assignment is not allowed to be committed</td>\n</tr>\n<tr>\n<td>committed</td>\n<td>Error: RHS may already have a different owner</td>\n<td>Error: RHS may already have a different owner</td>\n<td>Error: RHS may already have a different owner</td>\n</tr>\n</tbody>\n</table>\n\nobjects, and to determine which objects are fresh at the end of a method. For pure methods, the footprint is defined as the objects that are allowed to be read in the method [15].\n\nWe will justify the use of dynamic frames and how dynamic frames can be used to model the Spec# ownership methodology in the following sections.\n\n### 2.2.5 Method Contracts\n\nMethod contracts consist of pre- and postconditions. In Spec#, they are specified with the keywords requires and ensures. Contracts are required to be side-effect free. sscBoogie translates these Spec# conditions to Boogie conditions.\n\nIn Boogie, there is a distinction between free and checked conditions [18]. Boogie also contains the notion of free invariant and free modifies, but they are not relevant in our context. Checked conditions are assumed by one party (caller or callee) and asserted by the other. Free conditions are assumed by one party, and ignored by the other. The callee assumes all preconditions (free and checked) of a method. The caller of a method is responsible for establishing the checked preconditions and must establish the checked modifies clauses, as can be seen in Table 2.4. At the end of a method, the caller can assume all postconditions (free and checked). The callee has to establish the checked postconditions. Free postconditions have already been established in the method itself and are not checked again on exit by the callee.\n\n<table>\n<thead>\n<tr>\n<th>Precondition</th>\n<th>Postcondition</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>caller</td>\n<td>ignore</td>\n</tr>\n<tr>\n<td></td>\n<td>checked</td>\n</tr>\n<tr>\n<td></td>\n<td>assert</td>\n</tr>\n<tr>\n<td></td>\n<td>assume</td>\n</tr>\n<tr>\n<td>callee</td>\n<td>assume</td>\n</tr>\n<tr>\n<td></td>\n<td>ignore</td>\n</tr>\n<tr>\n<td></td>\n<td>assert</td>\n</tr>\n</tbody>\n</table>\n\nTable 2.4: Difference between Free and Checked Contracts\n\nBoogie creates several default (free and checked) pre- and postconditions per method, additional to the user specified conditions, which establish the ownership model. The preconditions are checked, whereas the postconditions are free. Boogie creates separate checks for consistency and peer consistency, where peer consistency does not imply consistency.\n\nChecked Boogie default preconditions:\n\n- Target object is consistent\n- Target object is peer consistent\n- Parameters are consistent\n- Parameters are peer consistent\nFree Boogie default postconditions:\n\n- Newly allocated objects are fully valid\n- First consistent owner is unchanged if its `exposeVersion` is\n- Frame condition\n - Inv/localinv change only in blocks (for all already allocated objects, at the end of the method, they are the same as at the beginning of the method)\n\nThe difference between free and checked conditions results from our translation encoding; e.g. fresh and modifies clauses are translated as free conditions, as they are checked directly at the affected program points, and not only at the end a method.\n\nAll postconditions are checked explicitly with runtime checks.\n\n2.2.6 Consistency Check\n\nAt the beginning and at the end of every method, the object whose method is called must be consistent. Consistent means, that the object is fully valid and its owner is writable. Additionally, the object invariants of all class frames of this object must hold.\n\nThe consistency and peer consistency preconditions in CC++ are nearly identical to the preconditions created for Boogie.\n\nBoogie ensures that at the end of a method all newly created objects are fully valid. In our encoding, we ensure this by checking that at the end of the method, all objects that could have been modified (and that could transitively own newly allocated objects) are consistent. This check includes, that if an object is consistent, all transitively owned objects must be committed, and therefore are fully valid. Furthermore, after object construction, the object is consistent (which implies fully valid), and with the constraint that \\(_\\text{inv}/_\\text{localinv}\\) is only allowed to change in blocks, the object must be fully valid at the end of the method, independent of the methods called on this object.\n\n\\(_\\text{inv}\\) and \\(_\\text{localinv}\\) are only allowed to change in blocks, this means that every unpack must be followed by a pack, within the same method. This is ensured by Spec#’s encoding, as every expose keyword is replaced by an unpack and a pack statement.\n\nThe Boogie variable `exposeVersion` (also called snapshot) is declared per object and is used to indicate if the object was modified. If the `exposeVersion` at the end of a method is the same as at the beginning of the method, then the object and all its transitively owned objects were not modified. In our encoding, we replace checks that involve `exposeVersion` with checks over the modifies rep set. So, `exposeVersion` is not longer required in our encoding.\n\n2.2.7 Frame Condition\n\nThe frame condition depends on the modifies clause of the current method. Boogies frame condition ensures, that at the end of a method only objects that have been specified in the modifies clause have been modified. This is ensured in our encoding by frame condition checks before every field update and method call, as done in sscBoogie.\n\nWell-formedness\n\nsscBoogie does not check the well-formedness of modifies clauses. Variables that are stated in modifies clauses are allowed to be null at evaluation time. To ensure the same behavior in our model, non-null checks are added which avoid dereferencing null values to prevent `NullException` exceptions.\n2.2.8 Ghost Variable Encoding\n\nSpec# uses some ghost variables per object for managing ownership states.\n\nThe current version of our model requires all objects to inherit from a custom object class. Figure 2.4 shows the properties and methods of this custom object class. The custom object class acts as base class and contains ghost variables for managing the ownership states, as well as methods that must be overridden by all derived types.\n\n\n\nThe reason for a separate base class is, that the System.Object base class can not be extended. The CCObject custom object class is part of the CodeContractsForSpecSharp library. The library is explained in section 3.1.3.\n\n**Custom Object Class Invariants**\n\nThe custom object class contains the following object invariants:\n\n- The ghost variable fields (_inv, _localinv, _rep, _owner, _ownerframe) are never null\n- The value of _owner is null and the value of _ownerframe is a peer group place holder, or the value of _owner is not null and _ownerframe is not a peer group placeholder.\n- For all transitively owned objects (rep set without the current object) it must be, that:\n - The object’s owner is not null.\n - The object’s ownerframe is not null.\n - The object’s owner is in the rep set of the current object.\n - The object’s owner is not in the rep set of the object itself.\n\nIn Spec#, the System.Object frame can not be exposed. In our methodology we prevent the custom object class frame from being exposed as well. A consequence of this is, that the object invariants of the custom object class frame must always hold. We moved these invariants to a separate method [Pure] public static bool CCSS.Always(), which is called by the method SS_Inv of the custom object class. This method is also called in other places, as we will see in the following sections.\n\n**SS_Inv Method**\n\nThe non-virtual method [Pure] public bool SS_Inv() is overridden by each class frame and contains the object invariants of the specific class frame. The method is public because of visibility requirements [22]. The object invariants must be visible to every object that can potentially violate it.\n\nThere is an essential difference between Spec# object invariants and CodeContracts object invariants. Spec# object invariants have to hold always when an object is valid. This is always when an object is not exposed. On the other hand, CodeContracts object invariants have to hold\nonly at the end of the object’s methods, and they are not checked at all if the fields of this object\nare modified outside of the object. Therefore additional object invariant checks have to be added\nduring the translation.\n\nSS_InvCheck\n\nThe non-virtual method private void SS_InvCheck() is overridden by each class frame and is\ndecorated with the System.Diagnostics.Contracts.ContractInvariantMethodAttribute at-\ntribute. This method is used to tell CC++ what the object invariants are. This method contains\na call to the SS_Inv method of the current class frame. During rewriting with ccrewrite, object\ninvariant checks are added at the end of every method and constructor. This would not be neces-\nsary, the object invariants are already checked in the consistency check. The primary use of this\nobject invariant check method is for other analysis tools that do not depend on rewriting, and\nthat have to know the object invariants.\n\nThe ccrewriter converts the methods decorated with [ContractInvariantMethod] into a\nmethod private void $InvariantMethod$(), that is called at the end of every method, property\nand constructor (except those decorated with [Pure]).\n\nSS_IsConsistent Method\n\nThe virtual method [Pure] public bool SS_IsConsistent() is overridden by each class frame.\nThis method checks the object invariants of the specific class frame, by calling the SS_Inv method,\nand then calls the overridden SS_IsConsistent method of the base class. This ensures, that once\nthis method is called, all object invariants of all class frames, from the most lower subclass up to\nthe custom object class, are checked.\n\nThe SS_IsConsistent method of the custom object class additionally ensures, that the object\nis fully valid (_inv and _localinv point to the allocated type of the object), that the object is\nwritable (the object is unowned or its owner is mutable) and all owned objects are committed.\n\nSS_IsPartiallyConsistent\n\nThe non-virtual method [Pure] public bool SS_IsPartiallyConsistent(Type) is overridden\nby each class frame. This method checks the object invariants of the specify class frame, by calling\nthe SS_Inv method, and then calls the overridden SS_IsPartiallyConsistent method of the base\nclass, up to the custom object class. After calling this method, one can be sure that the object\ninvariants of all class frames between the current frame and the root frame hold.\n\nThis method takes a type as parameter, which must be a supertype of the allocated object\ntype. The SS_IsPartiallyConsistent method of the custom object class ensures that the object\nis valid up to the specified type and that the object is writable.\n\n2.2.9 Owner Rep\n\nSome fresh and modifies clauses reason over the rep set of the owner of an object. For example,\nif the reasoning involves peers of an object. Checks for these clauses normally involve consistent\nor committed objects, for which the rep sets are up to date and include all transitively owned\nobjects, as will be seen in section 2.3.7.\n\nIf reasoning over the owner rep set of an object is required, it is most certain that the owner\nis in the state mutable. Thus, we can not rely on the rep set of the owner to be up to date and\nto include all transitively owned objects. The owner object can be in a state as shown in Figure\n2.7, before the rep update, in which the rep sets of directly owned objects are not subsets of the\nowner’s rep set. But, as the object itself must be at least consistent, all peers of this object are\nconsistent (with up to date rep set) as well.\n\nIn the following, when we reason over the rep set of the owner of an object (e.g., o._owner._rep),\nwe mean the union of all rep sets of all directly owned objects of this owner. Thus, we can be sure\nto reason over all objects, even if the owner is in the state mutable. In our encoding, the method\nGetAllPeerAndRepObjects, in the assembly CCSS, returns the described set.\n\nListing 2.1 shows why we cannot directly take the owner’s rep to reason over fresh objects.\nWithin a method, the current object is consistent and its owner is mutable. After assigning a new\nobject to a [Rep] field f of a [Peer] field peer of this, the newly allocated object is in the rep\nset of the peer object, but it is not in the rep set of the common owner of this and peer as the\nowner’s rep will be updated when it changes its state to consistent (See section 2.3.7). But we will\ngain the new object if we reason over the rep sets of the peers directly.\n\nListing 2.1: Spec#: Owner Rep Example\n\n```csharp\nthis.peer.f = new CCObject();\nthis.peer.f.UpdateOwnersForRep(this.peer, typeof(RepExample));\n// this.peer.f is not in the rep set of this.owner\n```\n\nThe method UpdateOwnersForRep is used for [Rep] fields and updates the owner and the\nowner frame of the specified object. In our example, the object assigned to field f will be owned\nby the object assigned to field peer at the class frame RepExample.\n\n2.3 Translation Rules\n\nThe checks added during the translation are similar, or identical, to the Boogie checks generated\nby sscBoogie. But instead of reasoning over the entire heap as done in Boogie, our checks reason\nover bounded sets. For every assert in the generated Boogie code, there is a corresponding check\nin the CC++ code, adapted to our ownership model encoding.\n\n2.3.1 Dictionary Example\n\nWe define the translation rules, using the Dictionary example, taken from the Spec# tutorial [23].\nListing 2.2 shows the Spec# code of a slightly adapted version, which contains all Spec# language\nfeatures supported by the translation.\n\nListing 2.2: Spec#: Dictionary Example\n\n```csharp\npublic class Dictionary {\n [Rep] Node? head = null;\n [Rep] Node? tail = null;\n invariant head == null <-> tail == null;\n\n public static void InsertTest(Dictionary! d)\n modifies d.*;\n { d.Insert(\"foo\", 123); }\n\n public void Insert(string key, int val)\n modifies head, tail;\n { expose (this) {\n Node? h = head;\n head = new Node(key, val);\n h = null\n tail = head;\n } }\n}\n\ninternal class Node {\n public string key;\n public int val;\n [Peer] public Node? next;\n public Node(string key, int val) {\n this.key = key;\n this.val = val;\n }\n}\n```\nFigure 2.5 shows the class diagram of the Dictionary example. The class Dictionary contains two methods, for inserting new values and finding already inserted values. The method Find will be skipped in the following, because it contains no concepts that are not already used in the Insert method.\n\nFigure 2.5: Dictionary Example Class Diagram\n\nFor every value that is inserted, a new Node is created. Nodes are linked together similar to a linked list. The Dictionary has a reference to the first and the last node in this linked list. These references are declared as [Rep]. Nodes are [Peer] to each other. Therefore, all Nodes are owned by the Dictionary object.\n\nDictionary Instance\n\nFigure 2.6 shows the ghost variables of an instance of the Dictionary class, after inserting two values and packing the TestDriver object. The Dictionary object d is owned by a TestDriver object t. The Dictionary object and both Node objects are committed. The TestDriver object has no owner but is fully valid, so it is in the state consistent. As all objects are valid, all rep sets are strict supersets of their owned object’s rep sets; e.g., the object t’s rep set contains the transitively owned objects d, n1 and n2, and t itself.\n\n2.3.2 Initialization / Construction\n\nConstructors start as mutable. At the end of every constructor, the constructed object must be partially consistent up to the current class frame. The constructor could be in the middle of an initialization hierarchy, therefore it can not be ensured that the object is fully valid. But it can be ensured that all constructors that are higher in the inheritance hierarchy have already been executed and therefore the object is consistent up to (and including) the current constructor.\n\nAt the end of a constructor there is an additive pack [14] to assert partial consistency.\n\nListing 2.3 shows the code that is generated for the Dictionary constructor. At the end of the constructor, the object is partially consistent on class frame Dictionary and the object invariants of class frame Dictionary hold. If a caller creates a new instance of type Dictionary, after the constructor, it can imply that partial consistency implies consistency, as Dictionary is the lowest class frame in the inheritance hierarchy.\n\nListing 2.3: C++: Constructor\n\n```cpp\npublic Dictionary()\n{\n Contract.Ensures(this.SS_IsPartiallyConsistent(typeof(Dictionary)));\n // Initialization & base constructor call...\n Contract.Assert(this.SS_Inv());\n SSC.AdditivePack(this, typeof(Dictionary));\n}\n```\n2.3.3 Object Invariants\n\nSpec objects can specify object invariants with the keyword invariant. Boogie encodes these object invariants with an axiom: The class frame is exposed, or the object invariants of this class frame must hold. CC++ ensures the object invariants with pre- and postconditions and with additional assertions within the methods. Object invariants of valid objects must always hold.\n\nIn ownership-based object invariants, only fields of transitively owned objects of an object (including this) are allowed to be used in the object invariants of this object.\n\nEvery class frame is extended with a method [Pure] public new bool SS_Inv(). This method contains all object invariants defined in the current class frame. In addition to the user defined object invariants, the method CCSS.Always is called. The reason for this is explained in section 2.2.8.\n\nListing 2.4 shows the object invariants of the Dictionary class. The field head is null if and only if field tail is null.\n\n```csharp\n[ContractInvariantMethod]\nprivate new void SS_InvCheck()\n{\n Contract.Invariant(this.SS_Inv());\n}\n\n[Pure]\npublic new bool SS_Inv()\n{\n return (this.Always() && ((this.head == null) <-> (this.tail == null))\n && CCSS.NullOrOwnerIs(this.head, this, typeof(Dictionary))\n && CCSS.NullOrOwnerIs(this.tail, this, typeof(Dictionary)));}\n```\n2.3 Translation Rules\n\nNon-Nullable Fields\n\nIn Spec#, non-nullable fields are specified with the suffix !, nullable types with the suffix ?; e.g., string! nonnullable; string? nullable;. Non-nullable types are checked by the Spec# type system, which outputs a warning for type violations, but are not checked again by Boogie. If non-nullability would be declared as object invariant (e.g., invariant nonnullable != null;), this would be checked by Boogie.\n\nFor every non-nullable field of a class frame, an additional non null check is added to the class frames object invariants during translation; e.g., field != null. This corresponds to the behavior of a non-null check via object invariants in Spec#, but differs slightly from the behavior of non-nullable types, as non-null fields of exposed objects are only checked before packing the object and not after every assignment.\n\nRep Fields\n\nFor all [Rep] fields in a class frame, the object invariants of this class frame are extended with an owner check to assert that the current object is the direct owner if the object that is assigned to this rep field.\n\nListing 2.4 shows that the object invariants of class Dictionary are extended with owner checks for the [Rep] fields head and tail, which assert that this on the class frame Dictionary is the owner of these two fields.\n\nPeer Fields\n\nFor all [Peer] fields of a class frame, the object invariants of this class frame are extended with an owner check to assert that the current object has the same owner as the object that is assigned to this peer field.\n\nListing 2.5 shows that the object invariants of the class Node are extended with an owner check for the peer field next, which asserts that this and next are owned by the same object and the same class frame.\n\nListing 2.5: CC++: Node Object Invariants\n\n```cpp\n[ContractInvariantMethod]\nprivate new void SS_invCheck()\n{\n Contract.Invariant(this.SS_inv());\n}\n\n[Pure]\npublic new bool SS_inv()\n{\n return (this.Always() && CCSS.NullOrOwnerSame(this.next, this));\n}\n```\n\n2.3.4 Pre- and Postconditions\n\nSpec# methods can specify pre- and postconditions. User defined preconditions are translated into Contract.Requires method calls. User defined postconditions are translated into Contract.Ensures method calls.\n\nIn Spec#, objects mentioned in the precondition must be visible to all callers. Objects, mentioned in the postcondition must be visible to all implementations of this method (also to all methods that override the current implementation in subclasses). In CodeContracts, all objects mentioned in a contract, must be at least as visible as the method in which they appear [6].\n\nOwnership- and Invariant-State Checks\n\nBefore an instance method call, the object on which the method is called is required to be consistent and peer consistent. At the end of the method, the object again has to be consistent and peer consistent.\nconsistent. The consistency check is explained in section 2.2.8. The peer consistency check ensures that all peer objects are consistent as well.\n\nListing 2.6 shows the state-check contracts of the instance method `Insert`.\n\n### Listing 2.6: CC++: State Check Pre-/Postconditions\n\n```csharp\npublic void Insert(string key, int val)\n{\n ...\n Contract.Requires(this.SS_IsConsistent());\n Contract.Requires(this.IsPeerConsistent());\n Contract.Ensure(this.SS_IsConsistent());\n Contract.Ensure(this.IsPeerConsistent());\n ...\n}\n```\n\n**Static Methods**\n\nStatic methods have no default state-check pre- and postconditions (as static methods have no `this` instance reference they can refer to). They have no constraints on consistency or peer-consistency. Fresh and modifies clauses are checked for static methods.\n\n**Parameters**\n\nPer default, parameters of type reference are required to be consistent and peer consistent at the beginning of and at the end of a method, due to the requirement that `_inv_/localinv` only changes in blocks. Value type parameters have no special constraints. Depending on whether the parameter is of type nullable or non-nullable, there is a non-null check.\n\nListing 2.7 shows the different contracts for a nullable parameter `a` and a non-nullable parameter `b`. Parameter `a` is allowed to be null, whereas it is required that parameter `b` is not null.\n\n### Listing 2.7: CC++: Parameter State Check Pre-/Postconditions\n\n```csharp\npublic void ParameterTest(CCObject*/?*/ a, CCObject//**/ b)\n{\n ...\n Contract.Requires(a == null | | a.SS_IsConsistent());\n Contract.Requires(a == null | | a.IsPeerConsistent());\n Contract.Requires(b != null & & b.SS_IsConsistent());\n Contract.Ensure(a == null | | a.SS_IsConsistent());\n Contract.Ensure(a == null | | a.IsPeerConsistent());\n Contract.Ensure(b != null & & b.SS_IsConsistent());\n Contract.Ensure(b != null & & b.IsPeerConsistent());\n ...\n}\n```\n\nThe ccrewriter automatically replaces parameter references in `Contract.Ensure` statements with `Contract.OldValue(<reference>)`.\n\n**Captured Parameters**\n\nCaptured parameters are allowed to change ownership within a method. They have an additional precondition that requires that the parameter is unowned. (E.g. `Contract.Requires(CCSS.OwnerNone(par));`) They have a weaker postcondition than normal parameters. They can be consistent or committed at the end of a method, because they are allowed to change ownership during the method.\n\nListing 2.8 shows the contracts for a captured non-nullable parameter `c`. `c` is required to be consistent, peer-consistent and unowned at the beginning of the method. At the end of the method it is ensures that `c` is valid (consistent or committed).\n\n**Out Parameters**\n\nOut parameters have no default state check precondition, as out parameter are assigned within the method. They have default state check postconditions as normal parameters. CodeContracts requires that out parameters in contracts are surrounded with a `ValueAtReturn`\n2.3 Translation Rules\n\nListing 2.8: CC++: Captured Parameter\n\n```c++\nvoid CapturedParameterTest (/\\{ Capture \\} / c)\n{\n ...\n Contract.Requires(c != null && c.SS_IsConsistent());\n Contract.Requires(c != null && c.IsPeerConsistent());\n Contract.Requires(c != null && c.OwnerNone());\n Contract.Ensures(c != null && c.IsValid());\n ...\n}\n```\n\nstatement, because at the beginning of the method, where the contracts access the out variable, the out variable is still unassigned, which is not allowed in C#.\n\nListing 2.9 shows the contracts for a non-nullable out parameter `a`. The method does not require anything about the parameter, but ensures that the parameter is non-null and peer consistent at the end of the method.\n\nListing 2.9: CC++: Out Parameter\n\n```c++\nvoid OutParameterTest (out A a)\n{\n ...\n Contract.Ensures((Contract.ValueAtReturn<A>(out a) != null)\n && Contract.ValueAtReturn<A>(out a).SS_IsConsistent());\n Contract.Ensures((Contract.ValueAtReturn<A>(out a) != null)\n && Contract.ValueAtReturn<A>(out a).IsPeerConsistent());\n ...\n}\n```\n\nReturn Values\n\nIf a method has a return value of type reference, the returned object is ensured to be consistent and peer consistent. For non-nullable return types, there is an additional non-null check.\n\nListing 2.10 shows the contracts for a non-nullable return value of type `A`.\n\nListing 2.10: CC++: Return Value\n\n```c++\nA/\\!*\\!/ ReturnValueTest ()\n{\n ...\n ...\n}\n```\n\nFresh Clause\n\nThe fresh clause checks that all objects that are mentioned in the fresh clause have been newly allocated during the method execution. The reasoning region for fresh objects is always a superset of the methods footprint (modifies region). Every method that has at least one modifies clause (default or user-defined) is extended with a CC++ fresh clause.\n\nListing 2.11 shows how Boogie handles fresh clauses in Dafny: For the expression `ensures fresh(_rep - old(_rep))`, at the end of a method in class `FreshTest`, it is ensured that all objects in the set `_rep` excluding the objects in the set `_rep` at the beginning of the method have not been allocated at the beginning of the method.\n\nListing 2.11: Boogie: Dafny Fresh Condition\n\n```plaintext\nensures (\\forall S: ref \\cdot S \\neq null \\land \\text{read}($Heap, this, FreshTest._rep)[$Box($o)])\n\\land \\neg \\text{read}(\\text{old}($Heap), this, FreshTest._rep)[$Box($o)] \\implies \\neg \\text{read}(\\text{old}($Heap), S, alloc));\n```\nIn C# such an \"is allocated\" information is not available. To overcome this limitation, we store references of newly allocated objects at the point they are created in a fresh set.\n\nIn the Spec# methodology, a caller of a method does not care about objects that are allocated within this method and remain unowned. Therefore, we consider an object fresh, if it is allocated and owned within a method.\n\nThere are two cases in which an object can be fresh at the end of a method: The object was constructed in the method itself (with the keyword new), or the object was constructed in a method that was called by this method and is therefore in the fresh set of the called method.\n\nNew objects can be allocated and returned by a method, but they do not have to be tracked as fresh, as long as they are not owned. The fresh checks are independent from the specified modifies clause. Newly allocated objects can become owned by writable objects. Within a method, the only writable objects that are reachable are the object’s peers and the parameter’s peers. Therefore, the fresh check includes the rep sets of all peers of this object, as described in section 2.2.9.\n\nFor the fresh check, the difference between the new rep set at the end of the method, and the original rep set at the beginning of the method is analyzed. The difference between these two sets must be a subset of all newly allocated objects during the method execution (including all called methods within this method). In CC++ fresh clauses are specified with the statement ContractPP.Fresh. Listing 2.12 shows a fresh condition for the modifies clause modifies this.* with a captured parameter capturedParam. The method GetAllPeerAndRepObjects is defined in the assembly CCSS and returns the union of all rep sets of all peers of the specified object (including the rep set of the object itself).\n\n```\nListing 2.12: CC++: Fresh Condition\nContract.Ensure(ContractPP.Fresh(this.GetAllPeerAndRepObjects()).Except(\n Contract.OldValue<ISet<CCObject>>(this.GetAllPeerAndRepObjects()).Except(capturedParam)\n));\n```\n\nThe fresh condition is a free ensure condition.\n\n**Captured Parameters** Only captured parameters, besides objects that are newly allocated, can be added to an object’s rep set during a method. Therefore, captured parameters have to be excluded from the fresh check.\n\n**Runtime Check** To check the fresh condition during runtime, multiple local ghost variables are required to store all fresh objects and the rep sets at the beginning and at the end of a method. The fresh set with all newly allocated objects is only accessible within the method. It can not be used in a postcondition. The fresh condition must be checked at the end of the method as an assertion.\n\nListing 2.13 show a typical fresh check at the end of every method.\n\n```\nListing 2.13: CC++: Fresh Runtime Check\nContract.Assert(~SS$preStateObjects).Except(~SS$postStateObjects).Except(capturedParam).IsSubsetOf(~SS$fresh));\n```\n\n**Pre-State Objects** The local ghost variable GhostVariable<HashSet<CCObject>> SS$preStateObjects stores all objects of all rep sets that can be extended with fresh objects during the method. This variable is assigned at the beginning of the method.\n\n**Post-State Objects** The local ghost variable GhostVariable<HashSet<CCObject>> SS$postStateObjects is filled with the same rep sets as the pre-state variable, but this variable is set at the end of the method. So, it can contain more objects than the pre-state variable. These additional objects must be objects that have been allocated and owned during the method execution.\nFresh Objects The local ghost variable GhostVariable<HashSet<CCObject>> $fresh$ contains all objects that are newly allocated during the method execution. After every constructor call and method call, the fresh objects are added to this set.\n\n2.3.5 Modifies Clause\n\nThe modifies clause specifies which objects/fields a method is allowed to modify. The objects specified in the modifies clause and the fresh objects must always be a superset of the modifies clauses of all methods called by this method.\n\nModifies clauses for fields have a slightly different semantics in Spec# than in Dafny. The Spec# modifies clause modifies o.f is equivalent with Dafny’s modifies clause modifies o.f, o’f. The Dafny modifies clause o.f allows to modify the object that is assigned to field f in object o, whereas the modifies clause o’f allows to assign a new object to the field f in object o. CC++’s modifies clauses are similar to the Dafny modifies clauses. Therefore, in our encoding, two modifies sets are maintained per method: One set containing modifiable objects and one set containing modifiable fields.\n\nListing 2.14 shows how Boogie handles Dafny modifies clauses: For the modifies clause modifies a in a method of class ModifiesTest, it is (free) ensured that all fields of all objects, that are not equals the object referenced by field a, have not been modified at the end of the method. For this, Boogie reasons over all objects in the heap.\n\nListing 2.14: Boogie: Dafny Modifies Condition\n\nIn our encoding, we use the rep sets of the specified objects to reason over the objects that are allowed to be modified within a method. This is valid, as the rep sets contain all objects that are potentially allowed to be modified by an object.\n\nTable 2.5 shows which regions are affected by the specified modifies clause. If an object is allowed to be modified, also all transitively owned objects of this object are allowed to be modified and must be in the rep set. A detailed proof for this policy is explained in [2].\n\n<table>\n<thead>\n<tr>\n<th>Modifies Clause</th>\n<th>Modifiable Objects/Fields Set</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>o.0</td>\n<td>{}</td>\n</tr>\n<tr>\n<td>o.*</td>\n<td>o.rep</td>\n</tr>\n<tr>\n<td>o.**</td>\n<td>o.owner.rep</td>\n</tr>\n<tr>\n<td>o.f</td>\n<td>o.rep - {o} + field f</td>\n</tr>\n</tbody>\n</table>\n\nTable 2.5: Modifiable Region per Modifies Clause\n\nThe modifies clause o.0 prevents the method from modifying the object o or any transitively owned objects. o.* allows the method to modify the object o and all its transitively owned objects. o.** allows the method to modify the object o, all peers of o and all transitively owned objects of these objects. o.f allows the method to set the field f of object o, and to modify all objects transitively owned by o, but not to modify o itself (except setting field f).\n\nThe modifies clauses are cumulative. If multiple modifies clauses are specified per method, the union of all modifies clauses is built. For example, the resulting superset of modifies this.0, this.f is this.f.\n\nA method can only modify its owned objects, its peers and its method parameters. So, in the frame condition we only have to reason over the rep sets of these objects and not over the entire heap. This is a valid restriction, because an object can not modify any field outside this scope.\n\nModifies clauses in CC++ are specified with the statement ContractPP.Writes. Listing 2.15 shows the modifies clause for method InsertTest. The Spec# modifies clause for this method is\nspecified as `modifies dic.*`. This means, all objects in the `dic` object’s rep set are allowed to be modified within this method.\n\nListing 2.15: CC++: Modifies Clause for Method InsertTest\n\n```cpp\nContractPP.Write(dic.GetRep());\n```\n\nIn comparison to the modifies clauses for method `InsertTest`, Listing 2.16 shows the modifies clause for method `Insert`. The Spec# modifies clause is specified as `modifies this.head, this.tail`. This means, only the fields `head` and `tail` of the current object are allowed to be modified and all transitively owned objects from the current object’s rep set, excluding the current object itself.\n\nListing 2.16: CC++: Modifies Clause for Method Insert\n\n```cpp\nContractPP.Write(this.GetOwnedObjects());\nIField<CCObject>[] locations = new IField<CCObject>[] { Field<CCObject>.Create(this, \"Dictionary.head\"), Field<CCObject>.Create(this, \"Dictionary.tail\") };\nContractPP.Write<CCObject>(locations, ContractPP.VerificationResults.VerifiedUnder());\n```\n\nModifies clauses are checked within the method for every assignment and every method call. It is not necessary to check these conditions again on method exit. Therefore modifies conditions are free, and not checked.\n\n**Runtime Check** To check the modifies condition during runtime, multiple local ghost variables are required to store the rep sets at the beginning of a method and fields mentioned in the modifies clauses.\n\n- **Modifiable Objects** The local ghost variable `GhostVariable<HashSet<CCObject>> SS$modifiableObjects` stores all objects that are allowed to be modified by the current method.\n\n- **Modifiable Fields** The local ghost variable `GhostVariable<HashSet<Field<CCObject>>> SS$modifiableFields` stores all fields that are allowed to be modified by the current method.\n\nThe exact use of these ghost variables is explained in the following sections.\n\n### 2.3.6 Method Calls\n\nMethod calls are surrounded by several checks. Before a method call, the caller must check multiple conditions to ensure that calling this method is valid in the current context. After a method call, the caller has to maintain its sets for keep track of newly allocated objects during the method execution.\n\n**Frame Condition Check**\n\nBefore a method call, the caller must check if the modifies clause of the current method satisfies the modifies clause of the method that is to be called. All objects that can be modified by the called method must also be allowed to be modified in the caller method (as they are in the caller’s modifies set or in the caller’s fresh set).\n\nThe frame condition is satisfied, if:\n\n- For every object in the callee’s modifiable objects set, it is:\n - The object is in the caller’s modifiable objects set\n - Or the object is in the caller’s fresh objects set\n2.3 Translation Rules\n\n- For every field in the callee’s modifiable fields set, it is:\n - The field is in the caller’s modifiable fields set\n - Or the fields object is in the caller’s modifiable objects set\n - Or the fields object is in the caller’s fresh objects set\n\nListing 2.17 shows the frame condition check in the method `InsertTest`, before the method call `dic.Insert`. The modifies clause of the `Insert` method is `modifies this.head, this.tail`. These two fields are filled into the modifiable fields set of the callee. The caller method specifies the modifies clause `modifies dic.*`, which includes all owned objects. Therefore, the object `dic` is in the modifiable objects set of the caller, and the frame condition is satisfied.\n\nListing 2.17: CC++: Method Call Frame Condition Check\n\n```java\nGhostVariable<ISet<CCObject>><SS$methodModifiableObjects_Insert =\nnew GhostVariable<ISet<CCObject>>(new HashSet<CCObject>());\nGhostVariable<ISet<IField<CCObject>>> SS$methodModifiableFields_Insert =\nnew GhostVariable<ISet<IField<CCObject>>>(new HashSet<IField<CCObject>>());\nif (dic != null)\n{\n (SS$methodModifiableObjects_Insert).AddRange(dic.GetOwnedObjects());\n (SS$methodModifiableFields_Insert).Add(Field<CCObject>.Create(this, \"Dictionary.head\"));\n (SS$methodModifiableFields_Insert).Add(Field<CCObject>.Create(this, \"Dictionary.tail\"));\n}\nContract.Assert(CCSS.IsModifiesClauseSatisfied(SS$methodModifiableFields_Insert,\n SS$methodModifiableObjects_Insert, SS$modifiableFields, SS$modifiableObjects,\n SS$fresh));\ndic.Insert(\"foo\", 0);\n```\n\nFresh Set Update\n\nAt the end of a method, new objects could have been allocated and owned during the method execution. To keep the fresh set of the caller method up-to-date, the fresh set of the callee method must be added to the caller method’s fresh set.\n\nRuntime Check Before and after every method call, the objects of all rep sets that can change during the method execution are saved and compared. The difference of the post-state set, without the pre-state and without the captured parameters, are newly allocated objects. These objects are added to the local fresh set. The rep sets are determined similar to the pre-/post-state sets for the fresh check, explained in section 2.3.4.\n\nMethod Pre-State Objects The local ghost variable `GhostVariable<HashSet<CCObject>> SS$methodPreStateObjects` stores all objects of all rep sets that can be extended with fresh objects during the callee method. This variable is assigned before the method is called.\n\nMethod Post-State Objects The local ghost variable `GhostVariable<HashSet<CCObject>> SS$methodPostStateObjects` is filled with the same rep sets as the method pre-state variable, but this variable is set after the method call. So, it can contain more objects than the method pre-state variable.\n\nListing 2.18 shows the fresh set update, after the method call `dic.Insert`. During the method execution, new objects could have been added to the object’s rep set. After the method call, the difference between the pre- and the poststate sets are added to the local fresh set.\n\nIt is possible that references to objects can change within the method call (especially for cascaded objects). Therefore a reference to the original object must be saved to compare the rep sets of the same objects after the method call. The temp variable `SS$dicTemp` would not be necessary in this case, but it is used if sets of method parameters or fields are checked, whose references can change within a method. For instance, if instead of `dic`, the rep set of `dic.head`\nwould be compared, we have to ensure that after the `Insert` method call we keep a reference to the old `dic.head` object.\n\nListing 2.18: CC++: Method Call Fresh Set Update\n\n```cpp\nGhostVariable<ISet<CCObject>> SS$methodPreStateObjects_Insert = new GhostVariable<ISet<CCObject>>(new HashSet<CCObject>());\nGhostVariable<ISet<CCObject>> SS$methodPostStateObjects_Insert = new GhostVariable<ISet<CCObject>>(new HashSet<CCObject>());\nif (dic != null)\n{\n SS$methodPreStateObjects_Insert.AddRange(dic.GetAllPeerAndRepObjects());\n SS$dicTemp = dic;\n}\ndic.Insert(\"foo\", 0);\nif (SS$dicTemp != null)\n{\n SS$methodPostStateObjects_Insert.AddRange(SS$dicTemp.GetAllPeerAndRepObjects());\n}\n(˜SS$fresh).AddRange(˜SS$methodPostStateObjects_Insert).Except(˜SS$methodPreStateObjects_Insert));\n```\n\nThe fresh clause of a method consists of the statement `ContractPP.Fresh(<owner’s rep set> - Contract.OldValue(<owner’s rep set>))`, as described in section 2.3.4. To get the same fresh set outside the method, all sets specified in the `old` statement have to be saved in ghost variables by the caller before the method call, and subtracted from the same sets after the method call. Thus, the caller gets the set of all objects that have been allocated and owned within the called method.\n\n2.3.7 Expose\n\nThe expose statement is used to change the state of an object. An expose consists of the statements unpack and pack. Unpack and pack can only occur in pairs within a method. It is not allowed/possible to unpack an object without packing it again in the same method.\n\nExposing a delayed object is not valid. An object can not be exposed within its delayed constructor or its delayed method, and so can not the object of a delayed parameter.\n\nBefore an unpack, there is a frame condition check to assert that the object is allowed to be unpacked.\n\nThere are two different versions of expose: A local expose and an additive expose.\n\nAdditive Expose\n\nThe additive expose statement allows to un-/pack multiple class frame on the same object. The unpack order must be strictly from the lowest subclass frame up to the base class frame.\n\nAdditive expose uses the statements `public static void AdditiveUnpack(this CCObject obj, Type frame)` and `public static void AdditivePack(this CCObject obj, Type frame)`.\n\nAdditive Unpack The additive unpack statement sets the _inv ghost variable of the specified object to the base type of the specified frame. This means that the object invariants of the specified frame are allowed to be violated, as the specified class frame becomes mutable.\n\nAdditive unpack requires the following:\n\n- The specified object must be writable\n- The specified object’s _inv type is equal to the specified frame type\n- The specified object’s _localinv is equal to the allocated type\n\nAdditive unpack ensures the following:\n\n- The specified object is mutable on the specified frame type\n2.3 Translation Rules\n\n**Additive Pack** The additive pack statement sets the \\_inv ghost variable of the specified object to the specified frame type. This means that the object invariants of the specified frame must hold.\n\nAdditive pack requires the following:\n- All directly owned objects of the specified object are fully valid\n- The specified object’s \\_inv type is equal to the base type of the specified frame\n- The specified object’s \\_localinv is equal to the allocated type\n\nAdditive unpack ensures the following:\n- The specified object is partially consistent up to the specified frame type\n\n**Local Expose**\n\nWith a local expose, at most one class frame of an object can be unpacked. Before another class frame is exposed, all class frames that were exposed before must be packed again.\n\nLocal expose uses the statements `public static void Unpack(this CCObject obj, Type frame)` and `public static void Pack(this CCObject obj, Type frame)`.\n\n**Local Unpack** The local unpack statement sets the \\_localinv ghost variable of the specified object to the base type of the specified frame. This means that the object invariants of the specified frame are allowed to be violated.\n\nLocal unpack requires the following:\n- The specified object must be writable\n- The specified object’s \\_inv type must be a subtype of the specified frame type\n- The specified object’s \\_localinv is equal to the allocated type\n\nLocal unpack ensures the following:\n- The specified object is mutable on the specified frame type\n\n**Local Pack** The local pack statement sets the \\_localinv ghost variable of the specified object to the specified frame type. This means that the object invariants of the specified frame must hold.\n\nLocal pack requires the following:\n- All directly owned objects of the specified object are fully valid\n- The specified object’s \\_inv type must be a subtype of the specified frame type\n- The specified object’s \\_localinv is equal to the base type of the specified frame type\n\nLocal unpack ensures the following:\n- The specified object is fully consistent\n\nListing 2.19 shows the expose statements of the method `Insert`. Before every unpack, there is a check that ensures that the object that is unpacked is allowed to be modified. Before every pack (local or additive), there is a call to the object’s SS_inv method, to ensure that the object invariants are satisfied before the object is packed.\nThe reason why the frame condition check before \\texttt{Unpack} and the object invariants check before \\texttt{Pack} are separate checks and are not part of these method's precondition is, that these checks correspond with the sscBoogie encoding, which has also separate checks. Other reasons are of technical nature. The frame condition check before \\texttt{Unpack} is separate, to simplify the \\texttt{Unpack} signature. The invariant check before \\texttt{Pack} is separate, because the method that is called to check the object invariant depends on exposed class frame. The correct method call must be added statically during compilation, as it is not possible in C\\# to dynamically bind a method call to a dynamic type. (In order to check the object invariant as precondition of the method \\texttt{Pack}, the statement \\((\\texttt{type} \\texttt{obj}).\\texttt{SS}_{\\texttt{Inv}}()\\) must be allowed, where \\texttt{type} is a variable of type \\texttt{Type}. This is not possible in C\\#, without using reflection.)\n\n\\section*{Rep Update}\n\nA difference of our encoding to the Boogie encoding is the handling of owned objects. Boogie only considers directly owned objects, whereas our encoding takes all transitively owned object into account. Thus, we have to do additional work in maintaining the rep sets. The reason for the different rep set handling is the handling of the modifies condition and frame condition.\n\nIf the owner relationship between objects changes, the rep set of the owner object is updated and the rep set of the newly owned object is added to the owner's rep set. The rep sets of the transitive owners (above the direct owner) remain unchanged. The rep set can only change for writable objects, therefore their owners must be exposed. At the end of every expose (local or additive), the rep set of the exposed object is updated. During the update, the rep set is defined as the union of the rep sets of all directly owned objects, which are consistent, and the current object. With this, all valid objects have an up-to-date rep set.\n\nThis method is correct, because only one object in the ownership cone can be in the state consistent. All objects lower in the hierarchy are committed, and have an up-to-date rep set. And all objects higher in the hierarchy are exposed and do not require an up to date rep set.\n\nFigure 2.7 shows how the rep set of an object is updated when the object is packed. After the pack, all directly owned consistent objects become committed, and the rep set of the packed object is a superset of all transitively owned rep sets.\n\n\\subsection*{2.3.8 Constructor Calls}\n\nA constructor's fresh clause is a special case of a normal method call's fresh clause. At creation time of a new object, the object does not own any object, so its rep set's only element is the object itself. At the end of the constructor, the entire rep of the new object must be fresh (except captured parameters). An object in construction can not become owned within its constructor, as it is not in a valid state. Therefore, no rep set of a potential owner can be modified within a constructor and it is sufficient to add the entire newly created object's rep set to the fresh set of the caller method. In a normal method call, the difference of the owner rep set before and after the method call would be added to the fresh set. For constructors, as optimization, the entire rep set of the constructed object can be considered fresh, as after the constructor, the owner of the constructed object is a peer group placeholder and its only rep elements are the object itself and objects that have been newly allocated and owned within the (non-delayed) constructor. No other peer elements can be in the peer group placeholder. Therefore, the owner rep set is equivalent to the object's rep set, and no pre- and poststate comparison must be made.\n2.3 Translation Rules\n\nListing 2.20 shows the creation of a new Node object within the method Insert. After construction, the entire rep set of the Node is added to the fresh set. The method GetRep returns the rep set of an object.\n\nListing 2.20: CC++: Constructor Call\n\n```cpp\nNode SS$nodeTemp = new Node(key, val);\n(~SS$fresh).AddRange(SS$nodeTemp.GetRep());\n```\n\n**Parameters**\n\nIf the constructor has normal parameters, then for these parameters fresh checks with pre-/poststate comparison are required, as newly allocated objects can be owned by the passed objects. Parameters are handled the same as in normal method calls, as described in section 2.3.6.\n\n**Captured Parameters**\n\nThe handling for captured parameters in constructor calls is similar to the handling of captured parameters for normal method calls, as described in section 2.3.4. Captured parameters must be excluded from the method’s fresh set, as the have already been allocated outside the method.\n\n2.3.9 Local Variable Assignment\n\nNo special handling is required for local variable assignments within a method. Even if the local variable is non-null, there is no explicit non-nullness check. The non-null test is done by the type system of the Spec# compiler, which outputs a warning for possible non-null conversions. Non-nullity for local variables is inferred by a data flow analysis of the Spec# compiler and is not checked again in Boogie.\n\n2.3.10 Field Assignment\n\nField assignments are handled differently to normal local variable assignments. Depending on the type of a field ([Rep], [Peer]), the owner relationship of the assigned object can change and different frame conditions must be asserted.\nFrame Condition Checks\n\nFields can be specified in modifies clauses and object invariants. Before a field assignment, there is a frame condition check which asserts that the field is modifiable in the current context.\n\nThe frame condition is satisfied, if:\n\n- The object which declares the field is not null (and also all objects in the transitive field hierarchy are not null; e.g., \\( a \\neq \\text{null} \\land a.b \\neq \\text{null} \\land a.b.c \\neq \\text{null} \\))\n- The field which declares the field is writable\n- The field is in the method’s modifiable fields set\n or the fields declaring object is in the method modifiable objects set\n or the fields declaring object is in the method’s fresh set\n\nListing 2.21 shows the field assignment to this.head in the method Insert. This frame condition check succeeds, because the modifies clause of this method is modifies this.head, this.tail. The head field is element of the modifiable fields set of this method.\n\nObject Invariants Checks\n\nField updates must be restricted as fields can be used in object invariants. After a field assignment, the object invariants must be checked if they are still satisfied, or if not, then the state of the object that defines the field must be mutable.\n\nIn our encoding, after a field update, we check all object invariants of the involved class frame. It would be sufficient to only check the object invariants that depend on the updated field, as done in Boogie. But for this, the object invariants would have to be separated with an own method per object invariant. Checking all object invariants in this case is correct, since, if the object was valid, before the field update the object’s invariants were true, and after the field update only the object invariants that depend on the updated field are possibly violated.\n\nListing 2.22 shows the object invariant check after the field assignment to this.head in the method Insert. This assertion succeeds, because the Dictionary class frame of this is exposed at this point in the program.\n\nAdditive Fields\n\nAfter an assignment to an additive field (fields that are decorated with the attribute [Additive]), it must only be asserted that the object, that declares the field, is additively exposed. An object invariant check here would be invalid, because additive fields can be used in object invariants of subclasses, and the assignment is allowed to break these invariants until the corresponding class frame is additively packed.\n\nInstead of directly after the assignment, the object invariants are checked before the pack. This behavior is valid, as assignments to an additive field require the object to be additively exposed.\n\nListing 2.23 shows the frame condition check, if the head field would be additive. Then, it is asserted the object is additively exposed and the object invariant check is delayed till the additive pack.\n2.3 Translation Rules\n\nListing 2.23: CC++: Additive Rep Field Assignment Object Invariant Check\n\n```csharp\nthis.head = SS$nodeTemp;\nthis.head.UpdateOwnersForRep(this, typeof(Dictionary));\nContract.Assert(this.IsAdditiveMutable(typeof(Dictionary)));\n```\n\nRep Fields\n\nObjects that are assigned to fields, that are decorated with the attribute [Rep], are automatically owned by the object and the class frame that declares the field. Automatic rep owner assignments use the statement public static void UpdateOwnersForRep(this CCObject subject, CCObject owner, Type ownerFrame).\n\nListing 2.22 shows the Node that is assigned to the rep field `this.head` becomes owned by `this`.\n\nRep owner update requires the following:\n- The owner is writable\n- The object is unowned or has already the object as owner that declares the rep field\n- The owner is exposed on the owner frame that the field object is assigned to or the object is peer consistent\n\nRep owner update ensures the following:\n- The object is owned by the object that declares the rep field\n- The owner rep set is a superset of the assigned object’s rep set\n\nPeer Fields\n\nGenerally, in Spec# it is easier to deal with fields that are declared as [Rep]. But if aggregated objects have the same owner and these objects have references to each other, they are declared as [Peer]. Objects that are assigned to fields that are decorated with the attribute [Peer], implicitly become owned by the same object and class frame as the object that declares the field. Automatic peer owner assignments use the statement public static void UpdateOwnersForPeer(this CCObject subject, CCObject peer).\n\nListing 2.24: CC++: Peer Field Assignment Object Invariant Check\n\n```csharp\nthis.head.next = h;\nthis.head.next.UpdateOwnersForPeer(this.head);\nContract.Assert(this.head.IsMutable(typeof(Node)) || this.head.SSInv());\n```\n\nListing 2.24 shows the Node assignment to the peer field `this.head.next` in the method Insert. The owner of `this.head.next` is set to the same owner and the same owner frame as `this.head`.\n\nPeer owner update requires the following:\n- The peer is writable (unowned or the owner is mutable on the owner frame)\n- The object is unowned or has already the same owner as the peer\n\nPeer owner update ensures the following:\n- The object is owned by the same owner as the peer\n- The owner’s rep set is a superset of the assigned object’s rep set\n\nThe preconditions of every method check for peer consistency. If an object is exposed, no method on its peers can be called.\n2.3.11 Array Element Assignment\n\nAssignments to an array element are preceded by a covariance check and a boundary check. The covariance check asserts that the element that is assigned, is a subtype of the arrays element type. The boundary check asserts that the index is within the boundaries of the array.\n\nListing 2.25 shows an assignment to an array arr at index i.\n\nListing 2.25: CC++: Array Element Assignment Boundary and Covariance Check\n\n```cpp\nContract.Assert((0 <= i) && (i < this.arr.Length));\nContract.Assert((SS$elementTemp == null) || CCSS.IsSubtype(SS$elementTemp.GetType(), this.arr.GetType().GetElementType()));\nthis.arr[i] = SS$elementTemp;\n```\n\nThese checks are not necessary during runtime, as both cases would cause a runtime error during execution. The assertions are mainly for the verifier.\n\n2.3.12 Contract Inheritance and Virtual Methods\n\nVirtual methods inherit the preconditions, postconditions and modifies clauses from the overridden method of its base class [10]. An overridden method in Spec# can have stronger postconditions, but it is not allowed to specify any additional precondition.\n\nThe Spec# compiler extends overridden methods with the correct contracts. And ccrewrite automatically inherits pre- and postconditions from virtual base methods. This causes duplicate contracts that are rejected by ccrewrite. To prevent this situation, the CC++ code generator ensures that contracts are specified only once per inheritance structure.\n\n2.3.13 Pure Methods\n\nPure methods are methods without side-effects. Besides in the user code, they are allowed to be used in object invariants and method contracts.\n\nThey have different preconditions than normal methods [9]. They require the declaring object to be peer valid, but do not require anything about its owner.\n\nPure methods are not allowed to modify any fields of old objects (they must be side-effect free) and they are not allowed to have any modifies clause stated. Therefore, they have an empty modifies set.\n\nAllocating new objects within a pure method and returning them is valid. But a newly allocated object can not become owned within the method, therefore pure methods do not require a fresh check at the end of the method. Methods that call pure methods do not have to update their fresh set after a pure method call.\n\nPure methods are allowed to have user defined pre- and postconditions.\n\nListing 2.26 shows the specification for a pure method.\n\nListing 2.26: CC++: Pure Method\n\n```cpp\n[ Pure ]\ninternal void PureMethod()\n{\n Contract.Requires(this.IsPeerValid());\n Contract.Ensures(this.IsPeerValid());\n}\n```\n\nPure methods are decorated with the attribute [Pure].\n\n2.3.14 Loop Invariants\n\nLoop invariants as separate language feature are not supported by CC++. Loop invariants can be derived by Clousot. To support Clousot and to ensure to have the same loop invariants as in Spec#, inline assertion statements with the loop invariants are added to the loop.\nLoop invariants must hold on loop entry and must remain true in every loop iteration and on loop exit.\n\nThere are four types of loops in Spec#: **ForEach**, **For**, **While**, **DoWhile**. The Spec# Compiler (ssc) converts all loops, except **DoWhile**, into **While(true)** loops, represented in the IL as unconditional branch. The jump out of the loop can be conditional (only for **DoWhile**) or unconditional.\n\nLoop invariants can only contain variables that are also available outside of the loop scope. For instance, elements that are returned by the enumerator in **ForEach** loops can not be used in loop invariants, because they are only accessible inside the loop.\n\nUser defined loop invariants are available as serialized IL string parameter of the method **AssertionHelpers.LoopInvariant(string, string)**.\n\nThe loop invariants are translated into assertions. These assertions are checked at the beginning of each loop iteration before the condition check. Given the structure of the loops after compilation these checks are sufficient to prove the invariants.\n\n### 2.3.15 Old\n\nIn Spec# postconditions, the **old** keyword can be used to refer to the method’s pre-state. **old()** statements are replaced with the CodeContracts statement **Contract.OldValue<T>(T value)**, where T is the declared type of the passed value.\n\n### 2.3.16 Result\n\nSpec# **result** statements can be used in postconditions and refer to the method’s return value. They are replaced with the statement **Contract.Result<T>()**, where T is the return type of the method the postcondition is declared in.\n\n### 2.3.17 Inline Assertions\n\nInline assertions are used to specify that the specified condition must hold at a certain program point. These assertions of the form **assert <condition>** are translated into **Contract.Assert(<condition>).**\n\nThe difficulty here is, the condition in the AST is only available as string. The condition is recovered from this string using the **ContractDeserializerContainer** of the Spec# compiler framework.\n\n### 2.3.18 Inline Assumptions\n\nInline assumptions are used to give the program verifier additional conditions it can rely on. These assumptions of the form **assume <condition>** are translated into **Contract.Assume(<condition>)**.\n\nSimilar to inline assertions, the condition has to be recovered from a serialized string.\n\n### 2.3.19 Quantifiers and Reductions\n\nQuantifiers and reductions can be used in pre- and postconditions, invariants, loop invariants and normal code. They work on integer ranges (**e.g., forall(int i in 0: arr.Length); arr[i] > 0**) and on collections (**e.g., forall(int i in arr; i > 0)**).\n\nTable 2.6 shows all quantifiers and reductions supported by Spec# and CC++. These quantifiers and reductions are redirected to static methods in the CCSS class. For all quantifiers and reductions, there are two possible signatures. E.g., **bool ForAll(int fromInclusive, int toExclusive, Predicate<int> predicate)** and **bool ForAll<T>(IEnumerable<T> collection, Predicate<T> predicate)**.\n\nUnlike the quantifier methods in the class **System.Diagnostics.Contracts.Contract**, the CCSS quantifier and reduction methods return **true** for empty sets. (The **Contract** class throws an exception if **fromInclusive > toExclusive**. This behavior is different from the one in Spec#)\n\nQuantifiers and reductions are translated into delegates.\n### Quantifier and Reductions\n\n<table>\n<thead>\n<tr>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ForAll</td>\n</tr>\n<tr>\n<td>Exists</td>\n</tr>\n<tr>\n<td>Count</td>\n</tr>\n<tr>\n<td>Sum</td>\n</tr>\n<tr>\n<td>Product</td>\n</tr>\n<tr>\n<td>Min</td>\n</tr>\n<tr>\n<td>Max</td>\n</tr>\n<tr>\n<td>ExistsUnique</td>\n</tr>\n</tbody>\n</table>\n\n**Table 2.6: Quantifiers and Reductions**\n\n#### 2.3.20 Owner Class\n\nThe class `Microsoft.Contract.Owner` contains pure and non-pure methods that can be used in contracts, invariants and within the code. They are used to change or evaluate an object’s owner relationship. The `Owner` method calls are translated to CCSS method calls with the same signature.\n\nTable 2.7 shows how the `Owner` method calls are mapped to CCSS methods.\n\n<table>\n<thead>\n<tr>\n<th>Spec# Owner Method</th>\n<th>CCSS Method</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Assign</td>\n<td>OwnerAssign</td>\n</tr>\n<tr>\n<td>AssignSame</td>\n<td>OwnerAssignSame</td>\n</tr>\n<tr>\n<td>Different</td>\n<td>OwnerDifferent</td>\n</tr>\n<tr>\n<td>Is</td>\n<td>OwnerIs</td>\n</tr>\n<tr>\n<td>None</td>\n<td>OwnerNone</td>\n</tr>\n<tr>\n<td>Same</td>\n<td>OwnerSame</td>\n</tr>\n<tr>\n<td>ElementProxy</td>\n<td><em>not implemented</em></td>\n</tr>\n<tr>\n<td>New</td>\n<td><em>not implemented</em></td>\n</tr>\n</tbody>\n</table>\n\n**Table 2.7: Owner Call Mapping**\n\nThe methods `ElementProxy` and `New` are not supported. `ElementProxy(arr)` returns an object that is a peer to all elements in an array `arr`. `New` is similar to `None` but slightly stronger, as it requires that the owner of the specified object is a peer group placeholder and the owner frame points to the object itself.\n\n#### 2.3.21 Result Not Newly Allocated Attribute\n\nThe method attribute `[ResultNotNewlyAllocated]` can be used to specify that the object that is returned by a method was not newly allocated within the method. This attribute is only valid for pure methods. The effect of this attribute is a new not-fresh check at the end of the method. For callers of this method, no additional handling is required, because if the result is not a new object, it is not in the fresh set of the method.\n\nListing 2.27 shows how an object `o` is checked for freshness before it is returned from a method that is decorated with the `[ResultNotNewlyAllocated]` attribute. The object was not allocated within the method or any method called by this method if it is not in the method’s fresh set.\n\n**Listing 2.27: CC++: Result Not Newly Allocated**\n\n```c++\nContractAssert(!($fresh).Contains(o));\nreturn o;\n```\n2.3 Translation Rules\n\n2.3.22 Inside Methods\n\nMethods that are decorated with the attribute `[[Inside]]` can be called if the object is exposed on the class frame that declares the method. The attribute `[[Inside]]` removes the default pre- and postconditions. Instead it is required and ensured that the object is exposed on this class frame. Such methods can not assume that the object invariants hold at the beginning of the method, and the caller of this method can not assume the object invariants to hold at the end of the method call.\n\nListing 2.28 shows how the method contracts are adapted if the method `InsideMethod` is decorated with the attribute `[[Inside]]`.\n\nListing 2.28: CC++: Inside Method\n\n```cpp\nclass InsideTest : CCObject\n{ /*[[Inside]]*/\n void InsideMethod()\n {\n Contract.Requires(this.IsMutable(typeof(InsideTest)));\n Contract.Ensures(this.IsMutable(typeof(InsideTest)));\n }\n}\n```\n\n2.3.23 Additive Methods\n\nMethods that are decorated with the attribute `[[Additive]]` have special default contracts which allow the object to be additively exposed within the method. It is required that \\_inv of the current object points to the the class frame in which the method is defined, so an additive expose on the current class frame is valid. The object itself must be writable.\n\nListing 2.29 shows how the method contracts are adapted if the method `AdditiveMethod` is decorated with the attribute `[[Additive]]`.\n\nListing 2.29: CC++: Additive Method\n\n```cpp\nclass AdditiveTest : CCObject\n{ /*[[Additive]]*/\n void AdditiveMethod()\n {\n Contract.Requires(this.IsAdditiveExposable(typeof(AdditiveTest)));\n Contract.Ensures(this.IsAdditiveExposable(typeof(AdditiveTest)));\n }\n}\n```\nChapter 3\n\nImplementation\n\nThis chapter explains the implementation of the translation rules. Section 3.1 describes the architecture of the CC++ code generator as part of the sscBoogie compiler backend and where the translation takes part in the tool chain. Section 3.2 explains how additional Spec# language features, that have not been covered by the previous chapter, are encoded and translated. In section 3.3 we justify important design decisions. The last section 3.4 lists the options available to configure the translation process.\n\n3.1 Architecture\n\nThis section explains the architecture of the CC++ code generator. We focus on the sscBoogie compiler backend and omit the overall structure of sscBoogie.\n\n3.1.1 Toolchain\n\nFigure 3.1 shows the idealized tool chain of the possible translation paths. Besides the existing Boogie code generation path, sscBoogie is extended to generate Pex and Clousot compatible code.\n\nThe Spec# compiler (ssc.exe) generates intermediate language (IL) code, with the contracts encoded as class-/method-attributes, Spec# specific runtime checks and marker method calls.\n\nsscBoogie removes the Spec# runtime checks and meta data and replaces them with CC++ equivalents.\n\nThe CC++ rewriter (ccpprewrite) (which is currently included in sscBoogie, but will be excluded in a separate executable, so it can be used as independent tool) replaces the CC++ declarations, which act as markers and have no intrinsic effects, with runtime checks and CodeContracts method calls.\n\nThe CodeContracts rewriter (ccrewrite) replaces the CodeContracts method calls with runtime checks and rewrites the code so that it can be executed.\n\n![Figure 3.1: Idealized Toolchain (ccpprewrite is currently part of sscBoogie)]\n\nPex requires the code to be rewritten, before it can generate tests. Clousot works on the un-rewritten code.\n3.1.2 Overview\n\nThe CC++ code generator is part of the BytecodeTranslation project, within the sscBoogie solution.\n\nFigure 3.2 shows the class diagram of the sscBoogie compiler backend, especially of the code generation part. The shaded classes are the newly added classes for the CC++ code generation. The white classes are the corresponding Boogie code generation classes. All classes that handle CC++ code are marked with the prefix CC in their name.\n\n\n\nFor the encoding, the compiler backend of sscBoogie was extended. The code generation part of sscBoogie was extracted and abstracted by a common abstract CodeGenerator base class. Both, the Boogie code generator and the newly created CC++ code generator inherit from this CodeGenerator class, which contains shared functionality.\n\nThe structure of the CC++ code generation classes is similar to the Boogie code generator classes. For nearly every Boogie specific class, there is an equivalent class for CC++. The code generation independent classes are shared.\n\nThe CC++ code generator works on the normalized abstract syntax tree (AST). The normalized AST contains only basic language features, that directly correspond to IL statements. High level language constructs, such as logical operators have been replaced during compilation, using short-circuiting. Also, if and while are replaced with conditional and unconditional branches. This causes some additional work in recovering higher level language features to determine the required translation steps.\n\nThe classes CCPreTranslator, CCTranslator and CCPostTranslator inherit from the StandardVisitor class, which operates on the AST and visits all nodes in it. These three visitor\n3.1 Architecture\n\nclasses are called on the AST in the order in which they are listed. The class CCPreTranslator resets properties on specific nodes and removes unused statements. The class CCTranslator does the real translation from Spec# to CC++. At the end of the translation process, class CCPoseTranslator removes Spec# specific methods and attributes that are not required anymore from the translated classes. The class CCTypes is a helper class which contains a reference to all method nodes that are added to the AST during the translation, and is the pendant to the Types class in the compiler framework.\n\n3.1.3 Ownership Methodology Model\n\nThe Spec# ownership methodology is modeled in a separate project, called CodeContractsForSpecSharp. This is a separate assembly, containing the CCObject custom object class, and static methods for manipulating the ownership state ghost variables. All methods that manipulate the CCObject fields are part of the static CCSS class. This class contains the ownership model logic as well as helper methods.\n\nThe main reason why the ownership model is in a separate assembly and is not directly compiled into the translated code is, it is much easier to change methods in a separate C# project than in sscBoogie.\n\nFigure 3.3 shows the dependencies between the assemblies, before and after the translation. The CodeContractsForSpecSharp assembly is referenced, together with the CCPlusPlus assembly, in every assembly that is translated.\n\n\n\nSpec# assemblies depend on the assembly System.Compiler.Runtime, which contains the Microsoft.Contracts namespace. During the translation, all dependencies to this assembly are removed, so it is not longer required after the translation.\n\n3.1.4 Garbage Collection\n\nGhost variables store references to objects. These referenced objects can not be collected by the garbage collector (GC), even if the objects are not used anymore and not referenced anywhere else. To allow the garbage collector to collect objects whose only references exist in ghost variables, weak-references can be used. The _owner reference is not allowed to be weak, because the owner state of an object is required to determine the state of the object itself. Therefore, the owner must always be available, even if it is not referenced anywhere else (and could potentially be collected by the GC).\n\nWeak references are not used in our current implementation, since it is not clear how provers can handle them. Additional work must be done in analyzing provers behavior with weak references.\n\nIn our case garbage collection is not a big issue, because the translated Spec# code is only used for static analysis, and is not executed, or only parts of the code are executed in unit-tests. Therefore, GC was not considered an issue in this thesis.\n3.1.5 Nested Calls\n\nSpec# statements can consist of nested calls, whose method output is the direct input of another method. E.g., `string.IsNullOrEmpty(o.ToString())`. Because every method call requires additional checks, cascaded calls are entangled, aligned according to their execution order and the results of the method calls are stored in temporary variables, which are then passed to the next method call. This partitioning allows to add checks between the method calls and to include the method results in the checks.\n\n3.1.6 Translation Output\n\nsscBoogie takes an assembly that was compiled with the Spec# compiler and outputs the translated assembly. The translated assembly is saved with the suffix `_ccpp` to the same directory as the input assembly.\n\nThe module name of the resulting assembly is also extended with the suffix `_ccpp`. This is required for Pex. Pex can only work with assemblies whose module name is equal to the assembly name.\n\nThe resulting assembly is targeted for the .Net runtime 4.0, even if Spec# assemblies are compiled for .Net 2.0, as the translated assembly uses contract classes from the .Net 4.0 standard libraries.\n\n3.1.7 Custom Standard Visitor vs. Generic Visitors and Code Generators\n\nThe Boogie code generator/translator works on the control flow graph (CFG) or flattened AST [3]. This graph can not be translated back to (useful) IL code. It is for code analysis only. Therefore a separate standard visitor must be used that works on the normal intermediate representation (IR) AST. The consequence and disadvantage of this approach is, the code generation part can not be fully abstracted away from the visitor part. Boogie and CC++ must have their own visitors.\n\n3.2 Language Features\n\nThis section explains the translation of special language features that have not been handled in the previous chapter. The focus of this section is mainly on the implementation of technical details and less on the ownership model itself, as was the focus of the previous chapter.\n\n3.2.1 Modopt\n\nThe Spec# compiler adds `modopt(NonNullType)` statements to the IL code to distinguish between nullable and non-nullable types. These `modopt` statements change the signature of methods [26]. They are replaced by non-null checks and are removed during the translation, as they are not used anymore.\n\n3.2.2 Runtime Contracts Attribute\n\nThe ccrewrite tool uses a `System.Diagnostics.Contracts.RuntimeContractsAttribute` module-attribute to determine if the module was already rewritten. Spec# uses the same attribute to annotate its modules. In order to process the translated module with ccrewrite, these attributes are removed during the translation process.\n\n3.2.3 Compiler Generated Names\n\nThe CC++ code generator generates names for created methods and variables that start with the prefix `SS_` and `SS$. These prefixes should not be used in user code.\n3.2 Language Features\n\n3.2.4 Delegates\n\nFor anonymous delegates, sealed closure classes are generated, which contain a function for each delegate. Because these delegates are used in pre- and postconditions, the closure classes and its methods visibility is changed to public, so they are accessible outside the method.\n\nListings 3.1 and 3.2 show how an exists quantifier is translated into a delegate. A new class closure is generated, which contains a method Function that contains the delegate body.\n\nListing 3.1: Spec#: Exists Quantifier\n\n```csharp\nclass Foo\n{\n public void QuantifierTest(int[] arr)\n {\n requires exists(int i in (0..arr.Length); arr[i] > 0);\n }\n}\n```\n\nListing 3.2: CC++: Exists Quantifier\n\n```csharp\nclass Foo\n{\n public class closure\n {\n int[] arr;\n Foo thisvalue;\n public closure(Foo thisvalue, int[] arr)\n {\n this.thisvalue = thisvalue;\n this.arr = arr;\n base.ctor();\n }\n public bool Function(int i)\n {\n return this.arr[i] > 0;\n }\n }\n void QuantifierTest(int[] arr)\n {\n closure SS$Closure = new closure(this, arr);\n Contract.Requires(CCSS.Exists(0..arr.Length, new Predicate<int>(SS$Closure.Function)));\n }\n}\n```\n\nGenerating delegates in sscBoogie involves all steps of the compilation process, from the Scoper to the Optimizer.\n\n3.2.5 Single Point of Return\n\nEvery method in the normalizer AST contains only a single point of return, which simplifies the task of adding fresh checks and additional assertions that must be checked before the method returns.\n\n3.2.6 ssc Generated Runtime Checks\n\nThe Spec# compiler (ssc) automatically generates runtime checks for user defined pre- and postconditions that throw RequiresExceptions or EnsuresExceptions. These checks are not required after the translation to CC++, as these conditions are moved into Contract.Requires and Contract.Ensures statements during translation. The compiler generated checks (that are the first and the last statement in the method body) are removed by the pre-translator. These checks are surrounded by a try-catch block which handles the ContractMarkerException and rethrow the exception.\n3.2.7 Attributes\n\nAll Spec# attributes are removed from the translated code (e.g., `EnsuresAttribute`, `RequiresAttribute`, `RepAttribute`, `PeerAttribute`, `WitnessAttribute`), or replaced with CodeContracts attributes (e.g., `PureAttribute`), as they are not used anymore.\n\nPure\n\nThe attribute `Microsoft.Contract.PureAttribute` is replaced with the attribute `System.Diagnostics.PureAttribute`.\n\n3.3 Design Decisions\n\nThis section justifies some of our most important design decisions.\n\n3.3.1 Ownership Model\n\nTo model the Spec# ownership methodology in CC++, some ghost variables are required for bookkeeping (e.g., `_owner`, `_ownerframe`, `_inv`, `_localinv`, `_rep`), as explained in the previous chapters.\n\nWhere can these ghost variables be stored?\n\n- Global static dictionary. Advantage: simple implementation. Disadvantage: Pex and Clousot have issues with static references to complex data structures.\n- Require all objects to implement a specific interface that provides properties for accessing the ghost variable fields. Disadvantage: Static type checking gets lost, because objects are never passed between methods of this interface type. Before every check, a cast to the interface would be required.\n- Add the ghost variable fields directly to the default `System.Object` class. Disadvantage: This is not possible without recompiling the .Net standard libraries.\n- Inserting a new custom object class between the default `System.Object` base class and the classes that derive from `System.Object`. Disadvantage: With this approach, all .Net standard libraries have to be recompiled, so that all standard classes derive from the custom object class.\n- Inserting fields to every object dynamically during runtime with the `Reflection.Emit` library. This is not possible, as `Reflection.Emit` just returns a new type with the added fields, but does not modify the original object.\n- Compiler inserts fields to every class statically. This has the same disadvantages as the custom object class approach. Additionally, no helper methods can be used, as all checks have to be statically bound to the object types.\n- Replace objects with proxy objects, as done in Aspect Oriented Programming.\n- Redirect calls at runtime to custom objects, as done in Moles [27].\n\nGenerally, it is much more complicated for a program verifier to reason over dynamically modified code, if not even impossible. Extending classes statically at compile time is always the better approach for software verification.\n\nIn our implementation we use a custom object class which contains the required ghost variables. As a future extension, a hybrid solution with a global static dictionary can be implemented to support already compiled classes.\n3.3.2 Frame Guard\n\nSpec# adds runtime checks for pre-/postconditions, object invariants and expose statements to the IL code. The checks are handled in the class Guard, which is instantiated for each object.\n\nThe Guard class does not consider class frames, invariant levels or frame conditions. Some Guard methods that are added by the Spec# compiler are empty method declarations, which are used as marker for sscBoogie.\n\nThe Guard class cannot be extended or adapted for our needs. Therefore, we remove all references to this Guard class from the code instead of reusing it. All functionality provided by the Guard class is also supported by our CCSS class.\n\n3.3.3 Frame Condition Evaluation\n\nAll ContractPP.Modifies conditions are replaced by frame condition checks before every field assignment or method call. Even though, these frame condition checks can occur somewhere in the code, the sets with modifiable objects and fields are determined at the beginning of the method. It would most probably be sound to determine the sets as they are checked in the frame conditions (and possibly contain more objects; e.g., captured parameters). But this would not represent the behavior of the Boogie encoding, as the frame condition in Boogie uses the state at the beginning of the method (with old($Heap)) to reason over modifiable objects.\n\n3.3.4 Inv / Local Inv Modeling\n\nThe _inv and _localinv ghost variables could have been added to every class frame as boolean, instead of two Type fields. The idea behind this is, that it is easier for the verifier to reason over boolean fields instead of type fields. This would require that all checks have to be added statically to the code during compilation. No helper methods could be used, as is used in the current implementation with the CCSS library.\n\nAlthough, this could be a possible solution for the problem of Pex with creating instances of type Type, as described in section 4.3.\n\nEven if the boolean fields solution has some benefits, we decided to stick to the same approach as is used in Boogie and to use Type fields, to avoid diverging from the original model.\n\n3.4 sscBoogie Options\n\nThis section describes all options that are supported by the the CC++ code generator. Not all available options are supported. Some Spec# options are not relevant for the CC++ code generation. Others have not been implemented due to time restriction.\n\n3.4.1 Spec#\n\nThis section contains all Spec# options that are supported by the CC++ translation process.\n\nmodifiesDefault\n\nThe ModifiesDefault option specifies the modifies clauses that are added to each method by default, in addition to the user specified modifies clauses. (See Table 3.1)\n\n<table>\n<thead>\n<tr>\n<th>Value</th>\n<th>Default CC++ Encoding</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0-4</td>\n<td>no default modifies clause</td>\n</tr>\n<tr>\n<td>5 (default)</td>\n<td>(1) plus modifies this.* (only for mutable classes)</td>\n</tr>\n<tr>\n<td>6</td>\n<td>(5) plus modifies <obj>.* for all declared objects</td>\n</tr>\n</tbody>\n</table>\n\nTable 3.1: modifiesDefault Option\nModifiesDefault values 1 - 4 would allow to modify the variable exposeVersion, which is used in the Boogie encoding to determine if an object is exposable. In our encoding, the separation of exposeVersion is not possible anymore. This is a small limitation of our encoding in terms of granularity of modifies conditions compared to Boogie. In our encoding, specifying a field or an object as modifiable always implies the object to be exposable. Values 1-4 generate the same modifies clauses as value 0, which means \"just what is declared\".\n\n3.4.2 CC++ Translation\n\nThe CC++ translation has some additional options. The options are parsed in the class CCCommandLineOptions.\n\nTable 3.2 shows the supported options for the CC++ translation.\n\n<table>\n<thead>\n<tr>\n<th>Spec# Parameter</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-ccprint</td>\n<td>Translates the specified assemblies to CC++</td>\n</tr>\n<tr>\n<td>-ccrewrite</td>\n<td>Rewrites the translated assemblies with ccrewrite.exe. Includes -ccprint.</td>\n</tr>\n<tr>\n<td>-skipCcpp</td>\n<td>CC++ statements that are not guaranteed to be well-formed, are removed from the code. This parameter is important if the code is going to be executed. Otherwise, null-reference exceptions are possible to occur.</td>\n</tr>\n<tr>\n<td>-pex</td>\n<td>Runs Pex after translation. Includes -ccprint, -ccrewrite and -skipCcpp. The Pex wizard creates a test project and then starts Pex on it</td>\n</tr>\n<tr>\n<td>-disableAssertUI</td>\n<td>Disables the assert user interface. No assertion exception dialog is shown if an assertion fails. This flag is used for the test suite</td>\n</tr>\n<tr>\n<td>-throwException</td>\n<td>Throws an exception if an error occurs during translation. Otherwise, only outputs an error message</td>\n</tr>\n</tbody>\n</table>\n\nTable 3.2: CC++ Translation Options\n\nThe parameter -ccprint is used, if the translated code will be analyzed with Clousot. After translation, all CC++ and CodeContracts markers remain in the code. The code is not executable, as this is prevented by CodeContracts. Because the ccpprewriter is currently part of sscBoogie, CC++ runtime checks are already in the code. They are guaranteed to be well-formed.\n\nThe parameter -ccrewrite translates the assembly to executable code. The code contains CC++ and rewritten CodeContracts declarations. Because parameters passed to CC++ markers are not guaranteed to be well-formed, runtime-exceptions are possible (e.g., ContractPP.Writes(a.b.c.d) where one of these fields is null). To remove the CC++ markers and only leave CC++ runtime checks in the code, which contain well-formedness checks, the parameter -skipCcpp can be used.\n\nPex can be started directly from sscBoogie, with the parameter -pex. This parameter causes sscBoogie, after translation, to call the Pex wizard to create a test project including test methods and to call Pex to analyze these generated test methods.\n\nNormally, if an assertion fails during the translation process in sscBoogie, an error message is shown to the user. This behavior is not desired if the translation is started as part of an automated test suite, for which it is known that certain tests fail, because these specific language features are not supported yet. To deactivate the error message GUI and to allow sscBoogie to continue after a failed assertion, the parameter -disableAssertUI can be used.\n\nExceptions (not to be confused with assertion failures) that happen during the translation are caught and instead, an error message is traced. Sometimes, especially during debugging, it is useful to propagate runtime exceptions up to the user. This can be done with the parameter -throwException.\nChapter 4\n\nEvaluation\n\nTo evaluate the validity of our chosen translation encoding, we wrote a test suite that contains examples for all implemented language features that can be translated. The tests have been tested with Pex and analyzed with Clousot.\n\nIn addition to this new test suite, all test drivers for the old existing sscBoogie tests have been extended, so they translate the Spec# test programs into CC++ code. The IL code of these translated programs is then compared with the IL code of the last known good version of the test and the difference is returned. This allows regression testing of the translation process.\n\n4.1 Test Suite\n\nThe test suite consist of Spec# classes. Every class tests a specific Spec# language feature. All tests can be translated into CC++ code and can be successfully executed. The translated code behaves the same as in Spec#.\n\n4.2 Runtime Tests\n\nSome test suites have been extended with a test driver that compiles the Spec# test code, translates it to CC++ code and then executes the translated code. The most of the Spec# tutorial examples and all of our newly written tests can be executed and checked at runtime with these test drivers.\n\n4.3 Pex\n\nPex first needs to generate parametrized test stubs from the translated code, using Pexwizard.exe. The generated stubs can be automatically tested with Pex. The assembly under test must be rewritten by the ccrewriter before it can be tested.\n\nPex uses a constraint solver to determine new test inputs for parameters to achieve high code coverage. The test inputs are automatically generated, using the object invariants of the created object, to determine the validity of the generated input.\n\nFor most objects, it is necessary to provide factory methods that return instances of more complex classes, for which Pex can not guess how to create new instances. For example, Pex can not create instances of GhostVariable objects. To ensure that the factory methods are correct, object factory tests can be used [28].\n\nFor most of the tests, Pex outputs a path bound exceeded warning. In principal, this issue can be solved by set higher boundaries (i.e., MaxConditions, MaxBranches). To high boundaries, result in long execution time or stack-overflow exceptions.\n\n1The test suites SscBoogie\\Test\\CodeContracts and SscBoogie\\Test\\tutorial have been extended with test drivers that allows the translated programs to be executed.\nWe experienced that Pex can not generate tests for non-trivial cases. Pex crashes because of to high boundaries, which cause a stack overflow exception. A possible reason for this could be that the ownership rules are defined recursively and Pex tries to achieve complete code coverage. Further analysis has to be done in this area.\n\nThe CCSS library uses static delegates with static fields, which cause warnings by Pex. Pex considers them not to be deterministic. Many CCSS methods, which handle the ownership model, contain Type parameters. A known limitation of Pex is, it can not create instances of type Type.\n\n### 4.4 Clousot\n\nClousot is integrated in the CodeContracts cccheck tool. We attempted to verify our test suite with this tool — and failed.\n\nListing 4.1 shows the arguments we used for testing. These arguments are identical to the arguments the CodeContracts Visual Studio plugin uses to verify code.\n\nListing 4.1: Clousot Arguments used for Testing\n\n```\nccheck.exe -nobox -nologo -nopex -remote -warninglevel full -maxwarnings 50\n-nonnull -arrays -wp=true -bounds:typ=subpolyhedra, reduction=simplex,\n-diseq=false -adaptive -arithmetric -enum -check assumptions -suggest requires\n-repro\"-resolvedPaths:<Paths to .Net 4.0> -libPaths:<Paths to .Net 4.0>:\n<Path to CC++ library> <assembly>\n```\n\nThe results were not as good as expected. Clousot can not prove the tests without warnings. One reason is, that our encoding heavily depends on collections from the .Net standard library, which store the sets used for nearly all checks. The specifications provided by Microsoft for these collections are not strong enough to prove the required properties, as can be seen in Listing 4.2.\n\nListing 4.2: C#: Clousot Evaluation\n\n```\nHashSet<int> set = new HashSet<int>();\nset.Add(1);\nContract.Assert(set.Contains(1)); // Warning: assertion unproven\n```\n\nHow the results, achieved with Clousot, can be improved, is an open point for future work.\nChapter 5\n\nConclusion\n\nThis chapter concludes this thesis. Section 5.1 gives an overview of the current state of the implementation, which features are not supported yet and possible future extensions. Section 5.2 summarizes the achievements.\n\n5.1 State of the Implementation\n\nThis section shows the current state of the implementation of the CC++ translation. Due to time constraints, we focused on implementing the core features of Spec#, leaving additional features as future extensions.\n\n5.1.1 Not Implemented Features\n\nThe following features are not or only partially implemented in the current version, due to lack of time.\n\nDelayed Constructors/Methods\n\nAn object is delayed until it is fully initialized, and all non-nullable fields have been assigned. The [Delayed] attribute can be used to call methods on such delayed objects. The [Delayed] attribute is valid for methods, constructors, properties and parameters. The [NonDelayed] attribute is only valid for constructors. Constructors are delayed by default. Non-delayed constructors require that all non-nullable fields of the current class frame are initialized before the base constructor is called [13]. As all non-null checks, this is checked by the sscBoogie type system, and not by Boogie. To encode this behavior in our model, a non-null check for all non-nullable field of the current class frame can be added before the base constructor call.\n\nThe [Delayed]/[NonDelayed] attributes have no influence on the constructors pre- or post-conditions. At the end of a constructor, the constructed object has to be consistent and all its invariants have to hold.\n\nA delayed method does not require the method to be consistent or peer-consistent and it is also not ensured. The method has no default pre- and postconditions. Delayed objects can not rely on their non-nullable field to be non null, so at the beginning of a delayed method it must be assumed that non-nullable field can be null.\n\nThe ccrewriter does not support contracts that stand in a constructor before the constructor base call. They are simply ignored by the rewriter. In Spec# delayed constructor base calls are supported. In order to implement delayed constructor base calls, there must be a way to rewrite such (in normal C# code invalid) contracts.\n\nAn other issue with delayed constructor base calls is, that ghost variables are used before they are initialized in the custom object class constructor.\nVisibility-based Object Invariants\n\nBesides ownership-based object invariants, there is another type of object invariants: visibility-based object invariants. Visibility-based object invariants allow to use fields in object invariants of objects that are not owned (that are not decorated with [Rep]) [22]. For instance, they can be used to state properties of peer objects.\n\nFields that are decorated with [Dependent(Type)] can be used in visibility-based object invariants, whereas Type is the type of the class where the invariant is defined. The [Dependent(Type)] attribute is required to extend the frame condition for field updates with additional checks.\n\nVisibility-based object invariants require to keep track on all objects that use [Dependent(Type)] fields in their object invariants. Every time such a field changes, all object that have a reference to the object whose field changed, have to be checked if their object invariants still hold. This is currently not possible in our implementation, but would be a future extension.\n\nArrays\n\nIn handling arrays, several open points exist in the current implementation.\n\nOwnership of Arrays and Array Elements Array is a special type and can not inherit from the custom object class. In the current implementation it is not possible to set the owner of arrays, but it is possible to set the owner of array elements, using the method Owner.Assign or Owner.AssignSame. The attributes [ElementsRep], [ElementsPeer] can not be used to specify array element ownership. Also, the method Owner.ElementProxy is not supported.\n\nArrays in Modifies Clauses The array indexer arr[*] can not be used in modifies clauses. This modifier could be used to specify that all elements of an array are allowed to be modified by a method.\n\nArrays of Non-Null Elements The marker method NonNullTypes.AssertInitialized, indicating that all non-nullable array elements have been initialized, can not be used.\n\nNoDefaultContract\n\nMethods that are decorated with [NoDefaultContract] have no default pre- and postconditions. This attribute is currently ignored.\n\nRead Clauses\n\nPure methods can be decorated with [Reads(ReadsAttribute.Reads)] to specify what fields a method is allowed to read. Possible read values are Owned, Nothing and Everything. The implementation of this language feature is similar to the implementation of modifies clauses and can use the CC++ feature ContractPP.Reads. To check read clauses, additional checks before every field access are required.\n\nThe current implementation of Spec# does not enforce the reads clause within the method body.\n\nImmutable Types\n\nImmutable types are obsolete in Spec#. A more powerful concept of frozen objects [24] for Spec# is currently in development.\n5.1 State of the Implementation\n\nInvariants for static fields\n\nAccording to Leino and Müller [21, 20], static fields can theoretically be used in invariants. This feature is not fully implemented yet in Spec#. Therefore, static fields and static invariants are not considered in the translation. They could be implemented, using an additional static ghost variable in the custom object class, that keeps track of all instances of certain classes that define such static fields.\n\nRecursion Termination Level\n\nIn order to prove that pure methods terminate, a recursion termination level is used by Spec#. Recursion termination levels are automatically inferred by Spec# or can be specified using the attribute \\[\\text{RecursionTermination}(r)\\]. Recursion termination is directly checked by the Spec# compiler, but the \\[\\text{RecursionTermination}\\] attribute is still available in the IL code, even it is ignored by sscBoogie. This attribute is ignored by the current implementation and removed from the translated code.\n\nModel Fields\n\nModel fields can be used in contracts [19]. They can be read independent from the object’s state and are updated at the end of an expose. Model field satisfy conditions are part of the object invariants.\n\nOut-of-Band Contracts\n\nOut-of-Band contracts allow to specify contracts for already compiled assemblies or Spec# external code. The contracts are stored in a separate repository.\n\nThe pendant of Spec# out-of-band contracts are CodeContracts contract reference assemblies [6]. They contain the public visible interfaces of an assembly along with its contracts.\n\nChecked Exceptions and Exceptional Postconditions\n\nChecked exceptions and exceptional postconditions [25] are not considered in our current implementation, as they are not fully supported by the current implementation of Spec#.\n\nStructs\n\nStructs are not supported, as Structs can not be handled by our current implementation. Structs can not inherit the required ghost variables from the custom object class.\n\nVerify\n\nThe \\[\\text{Verify}\\] attribute can be used to specify method or classes that do not have to be verified. Classes that are decorated with the \\[\\text{Verify(false)}\\] attribute are currently not translated at all. This is due to the sscBoogie design, where the \\[\\text{Verify}\\] attribute is checked, before the code generator visitors are called. This check must be moved within the code generator, as the CC++ code generator has a different behavior than the Boogie code generator.\n\n5.1.2 Future Work\n\nThis section describes some possible extensions to the current implementation. These extensions are not mandatory in order to use our system, but they improve the usability and the functionality of the current implementation.\nSupport for Standard Libraries\n\nAs mentioned in section 3.3.1, the current implementation of our ownership model depends on a custom object class, which all objects must derive from. This restriction is not useful if classes from standard libraries are used (which are already compiled). A future extension will be to overcome this limitation and provide ownership support for all classes, independent from their inheritance structure.\n\nOne solution to this restriction could be, to use a static dictionary which stores the ghost variables for all instances of library classes.\n\nCC++ Rewriter\n\nCurrently, the CC++ rewriter is included in the CC++ code generation part of sscBoogie and all runtime checks are written besides their ContractPP markers in the code. Normally, sscBoogie should only output code with CC++ markers. At a later stage, the CC++ rewriter should replace them with runtime checks.\n\nIn the current implementation, both, the ContractPP markers and the resulting runtime-checks exist in the code. Because some CC++ markers throw exceptions if non-wellformed parameters are passed, they can be skipped via the command line parameter -skipCcPp.\n\nAs a future extension, the runtime check generation out of CC++ markers can be separated from the CC++ code generator and moved to a separate executable.\n\nCC++ markers whose runtime-check generation should be separated: ContractPPWrites, ContractPPReads, ContractPPFresh, GhostVariable.\n\nOptimization for Pex\n\nAdditional test cases are tested with Pex. Interesting examples with good test results are evaluated. The generated CC++ code is optimized for Pex, to achieve better results and to find better test cases. To achieve this, a solution for suitable object creation via factory methods must be found. To overcome the limitation with Pex boundaries (see section 4.3), the translated ownership model must possibly be simplified (without recursive definitions).\n\nOptimization for Clousot\n\nTest cases are analyzed with Clousot. The generated CC++ code is optimized for Clousot, to achieve better results and more meaningful output messages. The issue is, many of the classes in the .Net standard library do not contain specifications, but they are used for the encoded ownership model. Clousot can not verify these parts of the code. Missing specifications must be added to overcome this limitation.\n\nError Handler\n\nThe CC++ translator can save errors that occurred during the translation process with the System.Compiler.ErrorHandler component. These errors can later be used to display a message in the commandbox, or show squiggles in the Visual Studio, if the CC++ translation is run as plug-in.\n\nVerifier Feedback Integration\n\nVerification results can be reintegrated into the CC++ code, so that other tools, such as Pex, can use this additional information; e.g., Methods that have been proven incorrect by sscBoogie can be extended with additional assert statements that help finding suitable test cases to produce an error for the statement whose verification failed.\nVisual Studio Integration\nThe CC++ code generation could be started directly from Visual Studio, to provide a better user experience than the command prompt. When building a Spec# project within Visual Studio, the CC++ code generator is run on the resulting assembly. All available options could be configured via a property panel.\n\n5.2 Conclusion\nIn this paper we presented a way to translate Spec# programs to CC++ programs and implemented the translation rules in the sscBoogie verifier.\n\nThe first task was to define the translation rules and to model the Spec# methodology in CC++. The rules are similar to the Boogie encoding and use similar ghost state annotations. The ghost states specification has been adapted from Boogie. For every Boogie assertion, there is one in our encoding. CC++ uses a different heap model than Spec#. Spec# and Boogie reason over the entire heap, whereas CC++ uses a dynamic frames approach and stores owned objects in rep sets. We translated the Spec# ownership model to dynamic frames.\n\nA subset of the translation rules have been encoded in Dafny, as CC++ contains similar language features as Dafny. The prototype has shown that the chosen ownership model encoding with dynamic frames is suitable for verification of programs.\n\nThe sscBoogie backend was extended with an additional code generator, which implements the defined translation rules and generates CC++ code. Because, extending sscBoogie was harder than expected and Spec# has numerous features, a subset of all Spec# language features was implemented.\n\nThe resulting code for some translated examples was evaluated with Pex and Clousot. The evaluation showed that the current translation rules are too complex to be handled by Pex and Clousot. Further work has to be done to simplify the encoding.\n\nSumming up the project, with the current implementation it is possible to translate simple examples, such as the tutorial examples, from Spec# to CC++ and to execute the translated programs. In order to translate real code, as sscBoogie itself, further work must be done, and more language features have to be supported.\nAppendix A\n\nEncountered Difficulties\n\nThis chapter shows some of the difficulties encountered during this thesis. The difficulties are mainly of technical nature, caused by the limitations of the technologies used.\n\nA.1 sscBoogie\n\nThis section contains difficulties encountered while adding the CC++ code generator to the ssc-Boogie verifier framework.\n\nA.1.1 Normalizer\n\nThe Normalizer can only run on expressions that have not already been normalized. An assembly that is read from the filesystem is normalized. Newly created expressions that are added during the translation process are not normalized. These newly created expressions must be normalized before they can be added to the assembly. The normalizer replaces complex language features with simple language features that can be represented by IL statements.\n\nSome expressions that are not normalized can not be written by the CCI Writer (e.g., TypeOf, LogicalAnd, LogicalNot, LogicalNot).\n\nCalling the Normalizer is not idempotent. If the Normalizer visits an already normalized method, in certain cases, it will change the expression to invalid IL code.\n\nA.1.2 Recover Serialized Contracts\n\nSerialized contracts, as used in assert and loop invariants, are recovered with the ContractDeserializer.ParseContract method. The issue is, this function interprets variables in the contract as class fields and ignores local variables. After recovering the contract the variables in the contract must be checked and, if a corresponding local variable with the same name exists, replaced.\n\nA.1.3 AST Node Equality\n\nIn the Spec# compiler, the AST nodes do not contain an equals method. Thus, in sscBoogie, objects are considered different even if they refer to the same node. This causes some issues during translation and requires some additional checks that otherwise could be skipped.\n\nA.1.4 sscBoogie and Boogie\n\nCurrently, the Boogie and sscBoogie solutions are not compatible. The command line arguments/options used by sscBoogie are part of Boogie, so they can currently not be extended with options used by the CC++ code generator. As long as these options can not be added, ssc can\nnot run scsBoogie as plugin and pass the required arguments to scsBoogie to run the CC++ code generator.\n\nWhen the option handling of scsBoogie switches to the options class in the scsBoogie solution, then scsBoogie can be run as a plugin of ssc.\n\nA.2 CodeContracts\n\nThis section contains difficulties encountered with the current release of CodeContracts. The issues occurred in the ccrewriter.\n\nA.2.1 Higher Level Language Features in Contract.OldValue()\n\nCodeContracts has issues with binary operators, Lambda expressions and Delegates in Contract.OldValue() statements. If these expressions are used in OldValue() statements. CodeContracts rewriting fails, and during runtime the exception \"Common Language Runtime detected an invalid program\" is shown.\n\nListing A.1: C#: Higher Level Language Features in Contract.OldValue() Statements\n\n```csharp\n// Crashes\nContract.Ensures(Contract.OldValue(a || b));\n```\n\n```\n// Works\nContract.Ensures(Contract.OldValue(a) || Contract.OldValue(b));\n```\n\nTernary expressions (e.g., `bool ? val1 : val2`) are not allowed either.\n\nThis bug has already been reported, but it has not been fixed yet: http://social.msdn.microsoft.com/Forums/eu/codecontracts/thread/11fc463f-9dd2-4037-b2d8-5c1eceed4513\n\nIn this thesis we found a workaround for this issue by wrapping the failing statements inside a method.\n\nA.2.2 Contract.OldValue() Deep Copy\n\nThe statement Contract.OldValue() creates a copy of the specified object reference and does not do a deep copy. This means if an original set has to be kept for later use in the postcondition, it has to be copied into a new set that can not be modified outside the OldValue() statement.\n\nListing A.2: C#: Keep Original Set Example\n\n```\nContract.OldValue(new HashSet<CCObject>(˜o .rep ));\n```\n\nA.2.3 Contracts before Constructor Base Call\n\nIssues arise if contracts occur within a constructor before the base constructor call.\n\nBefore Rewriting\n\nThe ccrewrite tool ignores contracts that occur before the base constructor call within a constructor. But, such contracts are required by CC++ to handle delayed base constructor calls.\n\nAfter Rewriting\n\nCodeContracts uses a pragmatic rewriting approach. During rewriting, the references to old values are assigned as first operations in a method. This also happens in constructors where no variables have been allocated yet. So it must be considered that the old values are null, even if they should not be.\nA.3 Pex\n\nA.2.4 Overridden Methods with TypeOf Operator in Contracts\n\nThe Spec# tutorial example Sec2.2-Additive [23] contains an overridden method \\texttt{AddMoney}. This method is decorated with an \\texttt{[Additive]} attribute, which requires the method to be additively exposable. This attribute causes the method contracts to contain a \\texttt{typeof} operator. Because the method is overridden, the contracts require different \\texttt{typeof} calls for each class frame. In the example, there is a \\texttt{typeof(Purse)} statement in the base class and \\texttt{typeof(SwissPurse)} statement in the derived class.\n\nThe \\texttt{[Additive]} attribute requires different preconditions for each class frame of overridden methods. But overridden methods are not allowed to contains additional preconditions. They are rejected by the ccwriter. The Spec# methodology is sound, but in the current version of CodeContracts this can not be implemented.\n\nIt is still an open issue how to add additional preconditions to overridden methods. Overridden methods with \\texttt{[Additive]} attributes can not be handled by the current implementation.\n\nA.3 Pex\n\nPex has issues handling certain main methods. The main method arguments are not allowed to be named \"args\", because this name is used by Pex in the automatically generated test stubs.\n\nError message: error CS0136: A local variable named 'args' can not be declared in this scope because it would give a different meaning to 'args', which is already used in a 'parent or current' scope to denote something else.\n\nAs a workaround, the main method argument that is generated by default by the Visual Studio template must be renamed.\nA Encountered Difficulties\nAppendix B\n\nUncovered Bugs\n\nThis chapter contains the bugs we uncovered in sscBoogie and Boogie during this thesis.\n\nB.1 sscBoogie\n\nB.1.1 Quantifiers\n\nsscBoogie contained a bug which created wrong Boogie code for quantifiers over collections. Boogie was not able to prove the generated code. This bug has been fixed by Valentin Wüstholz in change set 5bcd877b913d.\n\nB.2 Boogie\n\nB.2.1 Lambda Expressions\n\nBoogie crashed for lambda expressions which contained old statements. The old statements were not replaced after lambda expansion. This bug has been fixed by Valentin Wüstholz in change set c4cc0e2cf4ae.\nAppendix C\n\nTranslation Rules Prototyping in Dafny\n\nDafny was used to prototype a subset of the CC++ translation rules, as Dafny supports similar features as CC++. The prototypes raised our confidence in the translation rules.\n\nIn our translation encoding, we depend on a custom object class, that contains all ghost variables and from which all classes must derive from.\n\nDafny does not support inheritance by itself, except that all classes are implicitly direct subclasses of the base class object, which does not contain any members. In order to translate the Spec# ownership model to Dafny, the Dafny compiler had to be modified to allow custom object base classes.\n\nWith the modified version of Dafny, it is possible to declare a custom object class in the code and extend it with fields and methods. These members can then be used by all other classes (that inherit these members from the object class). The name of the class that should be used as object class can be specified via the Dafny command line parameter `-customobjectclass:<class_name>`. Note that object can not be used as class name, because it is a keyword in Dafny. It is recommended to use Object as class name instead. If no custom object class is defined in the code, the built in object class is used by the compiler.\n\nListing C.1 shows a custom object class Object. Class A inherits from this custom object and has access to the field _foo of the custom object class. This was not possible in the original Dafny implementation.\n\n```\nclass Object{\n var _foo : int;\n}\n\nclass A{\n method Bar(){\n this._foo := 1;\n }\n}\n```\n\nListing C.1: Dafny: Custom Object Class\nAppendix D\n\nDictionary Example\n\nListing D.1 shows the complete CC++ code (before rewriting) of the Dictionary example used in section 2.2.\n\nListing D.1: CC++: Dictionary Example\n\n```csharp\nusing System;\nusing System.Collections.Generic;\nusing System.Diagnostics.Contracts;\nusing CodeContractsForSpecSharp;\nusing CCPlusPlus;\nnamespace CodeContractsForSpecSharp.Examples{\n ///\n /// CC++ encoding of the Fig11−Dictionary example in the Spec# tutorial.\n ///\n public class Dictionary : CCObject{\n /// Constructor contracts\n Contract.Ensures(this.SS.IsPartiallyConsistent(typeof(Dictionary)));\n \"This must be partially consistent\");\n Contract.Ensures(ContractPP.Fresh(this.GetAllPeerAndRepObjects()).Except(Contract.OldValue<ISet<CCObject>>)(this.GetAllPeerAndRepObjects())),\n \"Fresh clause violated\");\n ContractPPWrites(this.GetRep());\n // GhostVariable initialization\n GhostVariable<ISet<CCObject>> $S_modifiableObjects =\n new GhostVariable<ISet<CCObject>>(new HashSet<CCObject>(), \"Modifiable_Objects\");\n GhostVariable<IFnField<CCObject>> $S_modifiableFields =\n new GhostVariable<IFnField<CCObject>>(new HashSet<IFnField<CCObject>>(),\n \"Modifiable_Fields\");\n GhostVariable<ISet<CCObject>> $S_fresh =\n new GhostVariable<ISet<CCObject>>(new HashSet<CCObject>(), \"Fresh_Objects\");\n GhostVariable<ISet<CCObject>> $S_preStateObjects =\n new GhostVariable<ISet<CCObject>>(new HashSet<CCObject>(), \"PreState_Objects\");\n (\"$S_modifiableObjects\" AddRange(this.GetRep()));\n (\"$S_preStateObjects\" AddRange(this.GetAllPeerAndRepObjects()));\n // this.head update − frame condition\n Contract.Assert(this.˜null.\", Fieldowner of field 'head' is null.\");\n Contract.Assert(˜this.IsWritable(), \"Fieldowner of field 'head' is not writable\");\n GhostVariable<IFnField<CCObject>> $S_gf0 =\n new GhostVariable<IFnField<CCObject>>(Field<CCObject>.Create(this, \"Dictionary.head\"),\n \"Assigned_Field\");\n Contract.Assert(˜CCSS.IsFieldModifiable(IFnField<CCObject>)$S_gf0, \"$S_modifiableFields,\n \"$S_modifiableObjects, \"$S_fresh\"); Field 'head' is not modifiable.\");\n this.head = null;\n this.head.UpdateOwnersForRep(this, typeof(Dictionary));\n }\n}\n```\n\n69\nD Dictionary Example\n\n```\nContract.Assert(this.IsMutable(typeof(Dictionary)) || this.SS_IsInv(),\n \"Fielddown of field 'head' is not mutable or invariant does not hold.\");\n\n// this.tail update - frame condition\nContract.Assert(this != null, \"Fielddown of field 'tail' is null.\");\nContract.Assert(this.IsWritable(), \"Fielddown of field 'tail' is not writable\");\nGhostVariable<IField<CCObject>><SS_Ss1 = new GhostVariable<CCObject>\"create(this,\"Dictionary.tail\")\",\n \"Assigned_Field\");\nContract.Assert(CCSS.IsFieldModifiable((IField<CCObject>)SS_Ss1, \"SSmodifiableFields, \"SS_modifiableObjects\", \"SS_fresh\", \"Field 'tail' is not modifiable.\");\nthis.tail = null;\nthis.tail.UpdateOwnersForRep(this, typeof(Dictionary));\nContract.Assert(this.IsMutable(typeof(Dictionary)) || this.SS_IsInv(),\n \"Fielddown of field 'tail' is not mutable or invariant does not hold.\");\n\n// Establish postcondition\nContract.Assert(this.SS_IsInv(), \"Object invariant of object 'Dictionary this' does not hold.\");\nthis.AdditivePack(typeof(Dictionary));\n\n// Fresh check\nGhostVariable<ISet<CCObject>> SS_postStateObjects = new GhostVariable<ISet<CCObject>>(\"PostState_Objects\")\n (\"SS_postStateObjects\").AddRange(this.GetAllPeerAndRepObjects());\nContract.Assert(\"SS_postStateObjects\").Except(\"SS_preStateObjects\")\n .IsSubsetOf(\"SS_fresh\", \"Fresh clause violated.\");\n}\n\n[Pure]\npublic bool Find(string key, out int val)\n{\n // Method contracts\n Contract.Requires(this.IsPeerValid(), \"This must be peer valid\");\n Contract.Ensures(this.IsPeerValid(), \"This must be peer valid\");\n bool returnValue;\n Node n = this.head;\n while (true)\n {\n if (n == null)\n break;\n \n if (n.key == key)\n {\n val = n.val;\n returnValue = true;\n goto Label00FA;\n }\n n = n.next;\n }\n val = 0;\n returnValue = false;\n Label00FA:\n return returnValue;\n}\n\npublic void Insert(string key, int val)\n{\n // Method contracts\n Contract.Requires(this.SS_IsConsistent(), \"This must be consistent\");\n Contract.Requires(this.IsPeerConsistent(), \"This must be peer consistent\");\n Contract.Ensures(this.SS_IsConsistent(), \"This must be consistent\");\n Contract.Ensures(this.IsPeerConsistent(), \"This must be peer consistent\");\n Contract.Ensures(ContractPP.Fresh(this.GetAllPeerAndRepObjects()),\n \"Contract. OldValue<CCObject>(this.GetAllPeerAndRepObjects()),\n \"Fresh clause violated\");\n ContractPPWrites<CCObject>(new IField<CCObject>)\n (Field<CCObject>.Create(this,\"Dictionary.head\"),\n Field<CCObject>.Create(this,\"Dictionary.tail\")\n )\n );\n ContractPPWrites(this.GetOwnedObjects());\n\n // GhostVariable initialization\n GhostVariable<ISet<CCObject>> SS_modifiableObjects = new GhostVariable<ISet<CCObject>>(\"Modifiable_Objects\")\n (\"Modifiable_Objects\")\n GhostVariable<ISet<IField<CCObject>>> SS_modifiableFields = new GhostVariable<ISet<IField<CCObject>>(\"Modifiable_Objects\")\n (\"Modifiable_Objects\")\n this.SS_modifiableFields = new GhostVariable<ISet<IField<CCObject>>(\"Modifiable_Objects\")\n (\"Modifiable_Objects\")\n this.SS_modifiableFields = new GhostVariable<ISet<IField<CCObject>>(\"Modifiable_Objects\")\n (\"Modifiable_Objects\")\n```\n\"Modifiable_Fields\";\nGhostVariable<Set<CGameObject>> $S_fresh =\nnew GhostVariable<Set<CGameObject>>(new HashSet<CGameObject>(), \"Fresh_Objects\");\nGhostVariable<Set<CGameObject>> $S_preStateObjects =\nnew GhostVariable<Set<CGameObject>>(new HashSet<CGameObject>(), \"PreState_Objects\");\n($S_modifiableFields).AddRange(this.GetOwnedObjects());\n($S_modifiableFields).Add(Field<CGameObject>.Create(this, \"Dictionary.head\");\n($S_modifiableFields).Add(Field<CGameObject>.Create(this, \"Dictionary.tail\");\n($S_preStateObjects).AddRange(this.GetAllPeerAndRepObjects());\n\n// Local unpack\nContract.Assert($CSS.IsObjectModifiable(this, $S_modifiableFields,\n\"Modifiable_Objects\", $S_fresh), \"Object 'Dictionary this' is not modifiable.\");\nthis.Unpack(typeof(Dictionary));\n\nNode h = this.head;\n\n// this.head update - frame condition\nContract.Assert(this.head == null, \"Fieldowner of field 'head' is null.\");\nContract.Assert(this.head.IsWritable(), \"Fieldowner of field 'head' is not writable.\");\n\nGhostVariable<IField<CGameObject>> $S_gf0 =\nnew GhostVariable<IField<CGameObject>>(Field<CGameObject>.Create(this, \"Dictionary.head\"),\n\"Assigned_Field\");\n\nContract.Assert($CSS.IsFieldModifiable(\"$S_gf0\", $S_modifiableFields,\n\"Modifiable_Objects\", $S_fresh), \"Field 'head' is not modifiable.\");\n\nNode $S_nodeConstructorResult = new Node(key, val);\n\n((Set<CGameObject>).AddRange($S_fresh).AddRange($S_modifiableFields,\n$S_nodeConstructorResult).GetRep());\n\nthis.head = $S_nodeConstructorResult;\nthis.head.UpdateOwnersForRep(this, typeof(Dictionary));\nContract.Assert(this.IsMutable(typeof(Dictionary)) || this.SSInv(),\n\"Fieldowner of field 'head' is not mutable or invariant does not hold.\");\n\n// this.head.next update - frame condition\nContract.Assert(this.head != null, \"Fieldowner of field 'next' is null.\");\nContract.Assert(this.head.IsWritable(), \"Fieldowner of field 'next' is not writable.\");\n\nGhostVariable<IField<CGameObject>> $S_gf2 =\nnew GhostVariable<IField<CGameObject>>(Field<CGameObject>.Create(this, \"Node.next\"),\n\"Assigned_Field\");\n\nContract.Assert($CSS.IsFieldModifiable(\"$S_gf2\", $S_modifiableFields,\n\"Modifiable_Objects\", $S_fresh), \"Field 'next' is not modifiable.\");\n\nthis.head.next = h;\nthis.head.next.UpdateOwnersForPeer(this.head);\nContract.Assert(this.head.IsMutable(typeof(Node)) || this.head.SSInv(),\n\"Fieldowner of field 'next' is not mutable or invariant does not hold.\");\n\nif (this.tail == null)\n{\n// this.tail update - frame condition\nContract.Assert(this.tail == null, \"Fieldowner of field 'tail' is null.\");\nContract.Assert(this.tail.IsWritable(), \"Fieldowner of field 'tail' is not writable.\");\n\nGhostVariable<IField<CGameObject>> $S_gf3 =\nnew GhostVariable<IField<CGameObject>>(Field<CGameObject>.Create(this, \"Dictionary.tail\"),\n\"Assigned_Field\");\n\nContract.Assert($CSS.IsFieldModifiable(\"$S_gf3\", $S_modifiableFields,\n\"Modifiable_Objects\", $S_fresh), \"Field 'tail' is not modifiable.\");\n\nthis.tail = this.head;\nthis.tail.UpdateOwnersForRep(this, typeof(Dictionary));\nContract.Assert(this.IsMutable(typeof(Dictionary)) || this.SSInv(),\n\"Fieldowner of field 'tail' is not mutable or invariant does not hold.\");\n}\n\n// Local pack\nContract.Assert(this.SSInv(), \"Object invariant of object 'Dictionary this' does not hold.\");\nthis.Pack(typeof(Dictionary));\n\n// Fresh check\nGhostVariable<HashSet<CGameObject>> $S_postStateObjects =\nnew GhostVariable<HashSet<CGameObject>>(new HashSet<CGameObject>(), \"PostState_Objects\");\n\n((HashSet<CGameObject>).AddRange(this.GetAllPeerAndRepObjects()));\n\nContract.Assert($S_postStateObjects, \"Subset of \" $S_fresh, \" Fresh clause violated.\");\n}\n\npublic static void InsertTest(Dictionary d)\n{\n// Method contracts\nContract.Requires((d != null) && d.SSIsConsistent(),\n\"Object 'Dictionary d' must be non-null and consistent\");\nContract.Requires((d != null) && d.IsPeerConsistent());\n\"Object 'Dictionary d' must be non-null and peer consistent.\"\nContract.Requires((d != null) && d.SS_IsConsistent(),\n\"Object 'Dictionary d' must be non-null and consistent.\");\nContract.Requires((d != null) && d.IsPeerConsistent(),\n\"Object 'Dictionary d' must be non-null and peer consistent.\");\nContract.Requires(ContractPP.Fresh(d.GetAllPeerAndRepObjects()).Except(Contract.OldValue<HashSet<CCObject>>(d.GetAllPeerAndRepObjects()))),\n\"Fresh clause violated\");\nContractPP.Writes(d.GetRep());\n\n// GhostVariable initialization\nGhostVariable<HashSet<CCObject>> SS_modifiableObjects = new GhostVariable<HashSet<CCObject>>(\"Modifiable_Objects\");\nGhostVariable<HashSet<CCObject>> SS_methodModifiableFields = new GhostVariable<HashSet<CCObject>>(\"Modifiable.Fields\");\nGhostVariable<HashSet<CCObject>> SS_fresh = new GhostVariable<HashSet<CCObject>>(\"Fresh_Objects\");\n\n// Dictionary.Insert method call - frame condition\nGhostVariable<HashSet<CCObject>> SS_methodModifiableObjects_Insert = new GhostVariable<HashSet<CCObject>>(\"Method_Insert_Modifiable_Objects\");\nGhostVariable<HashSet<CCObject>> SS_methodModifiableFields_Insert = new GhostVariable<HashSet<CCObject>>(\"Method_Insert_Modifiable.Fields\");\nGhostVariable<HashSet<CCObject>> SS_methodPreStateObjects_Insert = new GhostVariable<HashSet<CCObject>>(\"Method_Insert_PreState_Objects\");\n\n// Fresh check\nGhostVariable<HashSet<CCObject>> SS_postStateObjects = new GhostVariable<HashSet<CCObject>>(\"PostState_Objects\");\nif (SS_DictionaryOldReference != null)\n{\n if (d != null)\n {\n SS_postStateObjects.AddRange(d.GetOwnedObjects());\n SS_methodModifiableFields_Insert.AddField(d, \"Dictionary.head\");\n SS_methodModifiableFields_Insert.AddField(d, \"Dictionary.tail\");\n SS_postStateObjects.Insert.AddRange(d.GetRep());\n }\n}\nd.Insert(\"foo\", 123);\nif (d != null)\n{\n SS_postStateObjects.Insert.AddRange(d.GetRep());\n SS_fresh.AddRange(\"SS_methodPostStateObjects_Insert.Except(\"SS_methodPreStateObjects_Insert\");\n}\n\n// Fresh check\nGhostVariable<HashSet<CCObject>> SS_postStateObjects = new GhostVariable<HashSet<CCObject>>(\"PostState_Objects\");\nif (SS_DictionaryOldReference != null)\n{\n SS_postStateObjects.AddRange(SS_DictionaryOldReference.GetAllPeerAndRepObjects());\n}\nContract.Assert(\"SS_postStateObjects.Except(\"SS_preStateObjects\").IsSubsetOf(\"SS_fresh\"), \"Fresh clause violated.\");\n\n[Pure]\npublic new bool SS_inv()\n{\n return this.Always()\n && ((this.head != null && this.tail != null) || (this.head != null && this.tail != null))\n && CCSS.NullOrOwners(this.head, this, typeof(Dictionary))\n && CCSS.NullOrOwners(this.tail, this, typeof(Dictionary));\n}\npublic override bool SS_IsConsistent()\n{\n return (this.SS_Init() && base.SS_IsConsistent());\n}\n\npublic new bool SS_IsPartiallyConsistent(Type frame)\n{\n return (this.SS_Init() && base.SS_IsPartiallyConsistent(frame));\n}\n\ninternal class Node : CCObject\n{\n public string key;\n public int val;\n\n public Node(string key, int val)\n {\n // Constructor contracts\n Contract.Requires(this.SS_IsPartiallyConsistent(typeof(Node)));\n \"This must be partially consistent.\");\n Contract.Requires(ContractPP.Fresh(this.GetAllPeerAndRepObjects().Except(Contract.OldValue)(Set<CCObject>>(this.GetAllPeerAndRepObjects()))),\n \"Fresh clause violated\");\n ContractPP.Writes(this.GetRep());\n\n // GhostVariable initialization\n new GhostVariable<Set<CCObject>>() SSmodifiableObjects =\n new GhostVariable<Set<CCObject>>(new HashSet<CCObject>(), \"Modifiable_Objects\");\n new GhostVariable<Set<CCObject>> SSmodifiedFields =\n new GhostVariable<Set<CCObject>>(new HashSet<CCObject>(), \"Modified_Fields\");\n new GhostVariable<Set<CCObject>> SS_fresh =\n new GhostVariable<Set<CCObject>>(new HashSet<CCObject>(), \"Fresh_Objects\");\n new GhostVariable<Set<CCObject>> SS_preStateObjects =\n new GhostVariable<Set<CCObject>>(new HashSet<CCObject>(), \"PreState_Objects\");\n (SS_modifiedObjects).AddRange(this.GetRep());\n (SS_preStateObjects).AddRange(this.GetAllPeerAndRepObjects());\n\n // this.key update - frame condition\n Contract.Assert(this.key == null, \"Fielddowner of field 'key' is null.\");\n Contract.Assert(this.IsWritable(), \"Fielddowner of field 'key' is not writable\");\n (new GhostVariable<Field<CCObject>>() SS_gf0 =\n new GhostVariable<Field<CCObject>>(Field<CCObject>.Create(this, \"Node.key\"),\n \"Assigned_Field\"));\n Contract.Assert(CCSS.IsFieldModifiable(\"SS_gf0\", \"SS_modifiedFields\",\n \"SS_modifiableObjects\", (Set<CCObject>)\"SS_fresh\"), \"Field 'key' is not modifiable.\");\n this.key = key;\n Contract.Assert(this.IsMutable(typeof(Node)) || this.SS_Init(),\n \"Fielddowner of field 'key' is not mutable or invariant does not hold.\");\n\n // this.val update - frame condition\n Contract.Assert(this.val == null, \"Fielddowner of field 'val' is null.\");\n Contract.Assert(this.IsWritable(), \"Fielddowner of field 'val' is not writable\");\n new GhostVariable<Field<CCObject>>() SS_gf1 =\n new GhostVariable<Field<CCObject>>(Field<CCObject>.Create(this, \"Node.val\"),\n \"Assigned_Field\"));\n Contract.Assert(CCSS.IsFieldModifiable(\"SS_gf1\", \"SS_modifiedFields\",\n \"SS_modifiableObjects\", (Set<CCObject>)\"SS_fresh\"), \"Field 'val' is not modifiable.\");\n this.val = val;\n Contract.Assert(this.IsMutable(typeof(Node)) || this.SS_Init(),\n \"Fielddowner of field 'val' is not mutable or invariant does not hold.\");\n\n // Establish postcondition\n Contract.Assert(this.SS_Init(), \"Object invariant of object 'Node this' does not hold.\");\n this.AdditivePack(typeof(Node));\n```\n// Fresh check\nGhostVariable<ISet<CCObject>> SS_postStateObjects =\n new GhostVariable<ISet<CCObject>>(new HashSet<CCObject>(), \"PostState_Objects\");\n( SS_postStateObjects ).AddRange(this.GetAllPeerAndRepObjects());\nContract.Assert(( SS_postStateObjects ).Except(( SS_preStateObjects )).\n IsSubsetOf(\"SS_fresh\", \"Fresh clause violated.\");\n}\n\n[Pure]\npublic new bool SS_inv()\n{\n return this.Always() && CCSS.NullOrOwnerSame(this.next, this);\n}\n\n[ContractInvariantMethod]\nprivate void SS_invCheck()\n{\n Contract.Invariant(this.SS_inv());\n}\n\n[Pure]\npublic override bool SS_isConsistent()\n{\n return (this.SS_inv() && base.SS_isConsistent());\n}\n\n[Pure]\npublic new bool SS_isPartiallyConsistent(Type frame)\n{\n return (this.SS_inv() && base.SS_isPartiallyConsistent(frame));\n}\n```\n## Listings\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Description</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2.1</td>\n<td>Spec#: Owner Rep Example</td>\n<td>24</td>\n</tr>\n<tr>\n<td>2.2</td>\n<td>Spec#: Dictionary Example</td>\n<td>24</td>\n</tr>\n<tr>\n<td>2.3</td>\n<td>CC++: Constructor</td>\n<td>25</td>\n</tr>\n<tr>\n<td>2.4</td>\n<td>CC++: Dictionary Object Invariants</td>\n<td>26</td>\n</tr>\n<tr>\n<td>2.5</td>\n<td>CC++: Node Object Invariants</td>\n<td>27</td>\n</tr>\n<tr>\n<td>2.6</td>\n<td>CC++: State Check Pre-/Postconditions</td>\n<td>28</td>\n</tr>\n<tr>\n<td>2.7</td>\n<td>CC++: Parameter State Check Pre-/Postconditions</td>\n<td>28</td>\n</tr>\n<tr>\n<td>2.8</td>\n<td>CC++: Captured Parameter</td>\n<td>29</td>\n</tr>\n<tr>\n<td>2.9</td>\n<td>CC++: Out Parameter</td>\n<td>29</td>\n</tr>\n<tr>\n<td>2.10</td>\n<td>Boogie: Dafny Fresh Condition</td>\n<td>29</td>\n</tr>\n<tr>\n<td>2.11</td>\n<td>Boogie: Dafny Modified Condition</td>\n<td>30</td>\n</tr>\n<tr>\n<td>2.12</td>\n<td>CC++: Fresh Condition</td>\n<td>30</td>\n</tr>\n<tr>\n<td>2.13</td>\n<td>CC++: Fresh Runtime Check</td>\n<td>31</td>\n</tr>\n<tr>\n<td>2.14</td>\n<td>Boogie: Dafny Modified Condition</td>\n<td>31</td>\n</tr>\n<tr>\n<td>2.15</td>\n<td>CC++: Modifies Clause for Method InsertTest</td>\n<td>32</td>\n</tr>\n<tr>\n<td>2.16</td>\n<td>CC++: Modifies Clause for Method Insert</td>\n<td>32</td>\n</tr>\n<tr>\n<td>2.17</td>\n<td>CC++: Method Call Frame Condition Check</td>\n<td>33</td>\n</tr>\n<tr>\n<td>2.18</td>\n<td>CC++: Method Call Fresh Set Update</td>\n<td>34</td>\n</tr>\n<tr>\n<td>2.19</td>\n<td>CC++: Local Expose</td>\n<td>36</td>\n</tr>\n<tr>\n<td>2.20</td>\n<td>CC++: Constructor Call</td>\n<td>37</td>\n</tr>\n<tr>\n<td>2.21</td>\n<td>CC++: Field Assignment Frame Condition Check</td>\n<td>38</td>\n</tr>\n<tr>\n<td>2.22</td>\n<td>CC++: Rep Field Assignment Object Invariant Check</td>\n<td>38</td>\n</tr>\n<tr>\n<td>2.23</td>\n<td>CC++: Additive Rep Field Assignment Object Invariant Check</td>\n<td>39</td>\n</tr>\n<tr>\n<td>2.24</td>\n<td>CC++: Peer Field Assignment Object Invariant Check</td>\n<td>39</td>\n</tr>\n<tr>\n<td>2.25</td>\n<td>CC++: Array Element Assignment Boundary and Covariance Check</td>\n<td>40</td>\n</tr>\n<tr>\n<td>2.26</td>\n<td>CC++: Pure Method</td>\n<td>40</td>\n</tr>\n<tr>\n<td>2.27</td>\n<td>CC++: Result Not Newly Allocated</td>\n<td>42</td>\n</tr>\n<tr>\n<td>2.28</td>\n<td>CC++: Inside Method</td>\n<td>43</td>\n</tr>\n<tr>\n<td>2.29</td>\n<td>CC++: Additive Method</td>\n<td>43</td>\n</tr>\n<tr>\n<td>3.1</td>\n<td>Spec#: Exists Quantifier</td>\n<td>49</td>\n</tr>\n<tr>\n<td>3.2</td>\n<td>CC++: Exists Quantifier</td>\n<td>49</td>\n</tr>\n<tr>\n<td>4.1</td>\n<td>Clousot Arguments used for Testing</td>\n<td>54</td>\n</tr>\n<tr>\n<td>4.2</td>\n<td>C#: Clousot Evaluation</td>\n<td>54</td>\n</tr>\n<tr>\n<td>A.1</td>\n<td>C#: Higher Level Language Features in Contract.OldValue() Statements</td>\n<td>62</td>\n</tr>\n<tr>\n<td>A.2</td>\n<td>C#: Keep Original Set Example</td>\n<td>62</td>\n</tr>\n<tr>\n<td>C.1</td>\n<td>Dafny: Custom Object Class</td>\n<td>67</td>\n</tr>\n<tr>\n<td>D.1</td>\n<td>CC++: Dictionary Example</td>\n<td>69</td>\n</tr>\n</tbody>\n</table>\nList of Figures\n\n2.1 Ownership States Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16\n2.2 Possible State Transitions of an Object . . . . . . . . . . . . . . . . . . . . . . . . 17\n2.3 Update Owner for Peer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19\n2.4 Custom Object Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22\n2.5 Dictionary Example Class Diagram . . . . . . . . . . . . . . . . . . . . . . . . . . . 25\n2.6 Dictionary Example Instance Diagram . . . . . . . . . . . . . . . . . . . . . . . . . 26\n2.7 Rep Update . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37\n\n3.1 Idealized Toolchain (cpprewrite is currently part of sscBoogie) . . . . . . . . 45\n3.2 Class Diagram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46\n3.3 Dependencies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47\nList of Tables\n\n2.1 Ownership States ........................................... 16\n2.2 Ownership Mapping ........................................ 18\n2.3 Ownership Mapping ........................................ 20\n2.4 Difference between Free and Checked Contracts ............ 20\n2.5 Modifiable Region per Modifies Clause ...................... 31\n2.6 Quantifiers and Reductions ................................ 42\n2.7 Owner Call Mapping ........................................ 42\n\n3.1 modifiesDefault Option .................................... 51\n3.2 CC++ Translation Options ................................... 52\nBibliography\n\n\n"}}},{"rowIdx":284,"cells":{"id":{"kind":"string","value":"861aa64694a72a7d707d874cf7b5f74fedfa0b50"},"text":{"kind":"string","value":"The Oracle Rules Language Reference Guide contains a detailed and complete reference to the Oracle Business Rules RL Language syntax, semantics, and built-in functions. You can create and edit the Oracle Rules language directly but the language is normally generated by high-level tools.\nContents\n\nPreface ........................................................................................................................................................... ix\n Audience ................................................................................................................................................... ix\n Documentation Accessibility .................................................................................................................... ix\n Related Documents................................................................................................................................... ix\n Conventions............................................................................................................................................. x\n Conventions in Text ............................................................................................................................ x\n RL Language Backus-Naur Form Grammar Rules ........................................................................ x\n\nWhat's New in This Guide ........................................................................................................................... xiii\n\n1 Rules Programming Concepts\n 1.1 Starting the Oracle Business Rules RL Language Command-Line ........................................ 1-1\n 1.2 Introducing Rules and Rulesets ................................................................................................. 1-2\n 1.2.1 Rule Conditions ...................................................................................................................... 1-2\n 1.2.2 Rule Actions .......................................................................................................................... 1-2\n 1.3 Introducing Facts and RL Language Classes ............................................................................ 1-3\n 1.3.1 What Are Facts? ...................................................................................................................... 1-3\n 1.3.2 Adding Facts to Working Memory with Assert .............................................................. 1-3\n 1.3.3 Using RL Language Classes as Facts ................................................................................ 1-4\n 1.3.4 Using Java Classes as Facts ................................................................................................ 1-5\n 1.4 Understanding and Controlling Rule Firing ............................................................................... 1-5\n 1.4.1 Rule Activation and the Agenda ........................................................................................... 1-6\n 1.4.2 Watching Facts, Rules, and Rule Activations .................................................................... 1-7\n 1.4.3 Ordering Rule Firing ............................................................................................................. 1-8\n 1.5 Using Effective Dates .................................................................................................................... 1-11\n 1.6 Integrating RL Language Programs with Java Programs ........................................................ 1-11\n 1.6.1 Using Java Beans Asserted as Facts .................................................................................. 1-12\n 1.6.2 Using RuleSession Objects in Java Applications ............................................................. 1-14\n 1.7 Building a Coin Counter Rules Program ...................................................................................... 1-15\n2 Rules Engine Algorithms\n 2.1 Overview................................................................. 2-1\n 2.1.1 Differences between Rete and NRE Algorithm .............. 2-1\n 2.2 Configuring the Non-Rete Algorithm .................................. 2-2\n\n3 Rule Language Reference\n 3.1.1 Ruleset ............................................................. 3-2\n 3.1.2 Types................................................................. 3-3\n 3.1.3 Identifiers .......................................................... 3-6\n 3.1.4 Literals ............................................................... 3-7\n 3.1.5 Definitions ......................................................... 3-7\n 3.1.5.1 Variable Definitions ........................................... 3-8\n 3.1.5.2 Rule Definitions ................................................ 3-9\n 3.1.5.3 Class Definitions .............................................. 3-12\n 3.1.5.4 Function Definitions .......................................... 3-16\n 3.1.6 Fact Class Declarations ........................................... 3-17\n 3.1.7 Import Statement ................................................ 3-20\n 3.1.8 Include Statement ................................................. 3-21\n 3.1.9 Using Expressions ............................................... 3-21\n 3.1.9.1 Boolean Expressions ........................................... 3-22\n 3.1.9.2 Numeric Expressions ........................................... 3-23\n 3.1.9.3 String Expressions ............................................ 3-24\n 3.1.9.4 Array Expressions ............................................. 3-25\n 3.1.9.5 Fact Set Expressions ........................................... 3-25\n 3.1.9.6 Comparable Expression ...................................... 3-30\n 3.1.9.7 Object Expressions ............................................ 3-31\n 3.1.9.8 Primary Expressions ........................................... 3-31\n 3.1.10 Actions and Action Blocks ....................................... 3-34\n 3.1.10.1 If Else Action Block ......................................... 3-35\n 3.1.10.2 While Action Block .......................................... 3-35\n 3.1.10.3 For Action Block .............................................. 3-36\n 3.1.10.4 Try Catch Finally Action Block ............................ 3-36\n 3.1.10.5 Synchronized Action Block ................................. 3-37\n 3.1.10.6 Modify Action ................................................ 3-38\n 3.1.10.7 Return Action ................................................ 3-39\n 3.1.10.8 Throw Action ................................................ 3-40\n 3.1.10.9 Assign Action ................................................ 3-40\n 3.1.10.10 Increment or Decrement Expressions .................. 3-40\n 3.1.10.11 Primary Actions ............................................ 3-41\n 3.1.11 Rulegroup ......................................................... 3-41\n 3.1.12 Built-in Functions ............................................... 3-42\n 3.1.12.1 assert ......................................................... 3-42\n### List of Tables\n\n<table>\n<thead>\n<tr>\n<th>Table</th>\n<th>Description</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>3-1</td>\n<td>Implicit Type Conversions</td>\n<td>3-3</td>\n</tr>\n<tr>\n<td>3-2</td>\n<td>Explicit Type Conversions</td>\n<td>3-4</td>\n</tr>\n<tr>\n<td>3-3</td>\n<td>RL Language Literals</td>\n<td>3-7</td>\n</tr>\n<tr>\n<td>3-4</td>\n<td>xpath Selection Strings</td>\n<td>3-14</td>\n</tr>\n<tr>\n<td>3-5</td>\n<td>Expression Operator Precedence</td>\n<td>3-23</td>\n</tr>\n<tr>\n<td>3-6</td>\n<td>Aggregate Functions</td>\n<td>3-28</td>\n</tr>\n<tr>\n<td>3-7</td>\n<td>Strategy Values for setStrategy and getStrategy Functions</td>\n<td>3-57</td>\n</tr>\n<tr>\n<td>3-8</td>\n<td>Watch Functions Event Descriptions</td>\n<td>3-59</td>\n</tr>\n<tr>\n<td>4-1</td>\n<td>RL Command-Line Options</td>\n<td>4-3</td>\n</tr>\n<tr>\n<td>5-1</td>\n<td>Configuration Parameters for a RuleSession Constructor</td>\n<td>5-1</td>\n</tr>\n<tr>\n<td>5-2</td>\n<td>RL to Java Object Conversion</td>\n<td>5-3</td>\n</tr>\n<tr>\n<td>5-3</td>\n<td>RL Decision Trace Functions</td>\n<td>5-10</td>\n</tr>\n</tbody>\n</table>\nThis guide describes the Oracle Business Rules RL Language.\n\nAudience\n\nRules Language Reference for Oracle Business Process Management is intended for application developers and Oracle Application Server administrators who perform the following tasks:\n\n- Develop rule enabled applications\n- Debug rule enabled applications\n- Deploy and Administer rule enabled applications.\n- Develop rulesets for those who prefer a technical language environment instead of the Oracle Business Rules graphical environment for rule authoring.\n- Need to use Oracle Business Rules RL Language advanced features that are not available in the Oracle Business Rules environment.\n\nTo use this document, you need to be familiar with the Java programming language.\n\nDocumentation Accessibility\n\nFor information about Oracle's commitment to accessibility, visit the Oracle Accessibility Program website at http://www.oracle.com/pls/topic/lookup?ctx=acc&id=docacc.\n\nAccess to Oracle Support\n\nOracle customers that have purchased support have access to electronic support through My Oracle Support. For information, visit http://www.oracle.com/pls/topic/lookup?ctx=acc&id=info or visit http://www.oracle.com/pls/topic/lookup?ctx=acc&id=trs if you are hearing impaired.\n\nRelated Documents\n\nFor more information, see the following Oracle resources:\n\n- Designing Business Rules with Oracle Business Process Management\n- Managing and Monitoring Processes with Oracle Business Process Management\n- Developing SOA Applications with Oracle SOA Suite\nConventions\n\nThis section describes the conventions used in the text and code examples of this documentation set. It describes:\n\n- Conventions in Text\n- RL Language Backus-Naur Form Grammar Rules\n\nConventions in Text\n\n<table>\n<thead>\n<tr>\n<th>Convention</th>\n<th>Meaning</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>boldface</strong></td>\n<td>Boldface type indicates graphical user interface elements associated with an action, or terms defined in text or the glossary.</td>\n</tr>\n<tr>\n<td><em>italic</em></td>\n<td>Italic type indicates book titles, emphasis, or placeholder variables for which you supply particular values.</td>\n</tr>\n<tr>\n<td><em>monospace</em></td>\n<td>Monospace type indicates commands within a paragraph, URLs, code in examples, text that appears on the screen, or text that you enter.</td>\n</tr>\n</tbody>\n</table>\n\nRL Language Backus-Naur Form Grammar Rules\n\nEach RL Language command in the guide is shown in a format description that consists of a variant of Backus-Naur Form (BNF) that includes the symbols and conventions in the following table.\n\n<table>\n<thead>\n<tr>\n<th>Symbol or Convention</th>\n<th>Meaning</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>[ ]</td>\n<td>Brackets enclose optional items.</td>\n</tr>\n<tr>\n<td>{ }</td>\n<td>Braces enclose items only one of which is required.</td>\n</tr>\n<tr>\n<td></td>\n<td>A vertical bar separates alternatives within brackets or braces.</td>\n</tr>\n<tr>\n<td>*</td>\n<td>A star indicates that an element can be repeated.</td>\n</tr>\n<tr>\n<td>delimiters</td>\n<td>Delimiters other than brackets, braces, vertical bars, stars, and ellipses must be entered as shown.</td>\n</tr>\n<tr>\n<td><strong>boldface</strong></td>\n<td>Words appearing in boldface are keywords. They must be typed as shown. (Keywords are case-sensitive in some, but not all, operating systems.) Words that are not in boldface are placeholders for which you must substitute a name or value</td>\n</tr>\n<tr>\n<td><em>underline</em></td>\n<td>When on the left side of a production ( ::= ) indicates a definition for a non-terminal symbol.</td>\n</tr>\n<tr>\n<td><em>underline</em></td>\n<td>When found on the right side of a production, ::= , a link, which is a non-terminal symbol, links to the definition for the non-terminal symbol.</td>\n</tr>\n<tr>\n<td>Symbol or Convention</td>\n<td>Meaning</td>\n</tr>\n<tr>\n<td>----------------------</td>\n<td>---------</td>\n</tr>\n<tr>\n<td><em>italic text</em></td>\n<td>Semantic information about non-terminals, such as the required data type for an expression or a descriptive tag used in following discussion, is in italics.</td>\n</tr>\n</tbody>\n</table>\nWhat's New in This Guide\n\nThis section summarizes the new features and significant product changes for the Oracle Rules Language in the Oracle Fusion Middleware Release 12c.\n\nFollow the pointers into this guide to get more information about the features and how to use them. This document is the new edition of the formerly titled Oracle Fusion Middleware Language Reference Guide for Oracle Business Rules.\n\nThere are no new features added in this release. The guide for the release contains major bug fixes.\n\nScreens shown in this guide might differ from your implementation, depending on the skin used. Any differences are cosmetic.\n\nFor a list of known issues (release notes), see http://www.oracle.com/technetwork/middleware/soasuite/documentation/soaknownissues122120-3111966.html.\nThis chapter introduces Oracle Business Rules RL Language (RL Language) concepts. This chapter includes the following sections:\n\n- Starting the Oracle Business Rules RL Language Command-Line\n- Introducing Rules and Rulesets\n- Introducing Facts and RL Language Classes\n- Understanding and Controlling Rule Firing\n- Using Effective Dates\n- Integrating RL Language Programs with Java Programs\n- Building a Coin Counter Rules Program\n\n### 1.1 Starting the Oracle Business Rules RL Language Command-Line\n\nThe Oracle Business Rules environment is implemented in a JVM or in a J2EE container by the classes supplied with `rl.jar`.\n\nStart the RL Language using command-line interface using the following command:\n\n```\njava -jar $SOA_ORACLE_HOME/soa/modules/oracle.rules_11.1.1.1/rl.jar -p \"RL> \"\n```\n\nWhere ORACLE_HOME is where SOA modules are installed (for example, c:/Oracle/Middleware). The `-p` option specifies the prompt.\n\nThe RL Language command-line interface provides access to an Oracle Business Rules `RuleSession`. The `RuleSession` is the API that allows Java programmers to access the RL Language in a Java application (the command-line interface uses a `RuleSession` internally).\n\nFor more information on command-line options, see Using the Command-line Interface and Using a `RuleSession` for details on Oracle Business Rules `RuleSession` API.\n\nYou can run the program in Example 1-1 using the command-line interface by entering the text shown at the `RL>` prompt.\n\n#### Example 1-1 Using the Command-Line Interface\n\n```\nRL> println(1 + 2);\n3\nRL> final int low = -10;\nRL> final int high = 10;\nRL> println(low + high * high);\n90\nRL> exit;\n```\n1.2 Introducing Rules and Rulesets\n\nAn RL Language ruleset provides a namespace, similar to a Java package, for RL classes, functions, and rules. In addition, you can use rulesets to partially order rule firing. A ruleset may contain executable actions, may include or contain other rulesets, and may import Java classes and packages.\n\nAn RL Language rule consists of rule conditions, also called fact-set-conditions, and an action-block or list of actions. Rules follow an if-then structure with rule conditions followed by rule actions.\n\nExample 1-2 shows a program that prints, “Hello World.” This example demonstrates a program that contains a single top-level action in the default ruleset (named main). Example 1-2 contains only an action, and does not define a rule, so the action executes immediately at the command-line.\n\nExample 1-2 Hello World Programming Example\n\n```\nRL> println(\"Hello World\");Hello World\nRL>\n```\n\n1.2.1 Rule Conditions\n\nA rule condition is a component of a rule that is composed of conditional expressions that refer to facts.\n\nIn the following example the conditional expression refers to a fact (Driver instance d1), followed by a test that the fact’s data member, age, is less than 16.\n\n```\nif (fact Driver d1 && d1.age < 16)\n```\n\nExample 1-3 shows the complete rule, written in RL Language (the rule includes a rule condition and a rule action).\n\nThe Oracle Rules Engine activates a rule whenever there is a combination of facts that makes the rule’s conditional expression true. In some respects, a rule condition is like a query over the available facts in the Oracle Rules Engine, and for every row that returns from the query, the rule activates.\n\nNote:\n\nRule activation is different from rule firing. For more information, see Understanding and Controlling Rule Firing.\n\nExample 1-3 Defining a Driver Age Rule\n\n```\nRL> rule driverAge{\nif (fact Driver d1 && d1.age < 16)\n{\n println(\"Invalid Driver\");\n}\n}\n```\n\n1.2.2 Rule Actions\n\nA rule action is activated if all of the rule conditions are satisfied. There are several kinds of actions that a rule’s action-block might perform. For example, an action in the rule’s action-block can add new facts by calling the assert function or remove facts by\ncalling the \\texttt{retract} function. An action can also execute a Java method or perform an RL Language function (Example 1-3 uses the \\texttt{println} function). Using actions, you can call functions that perform a desired task associated with a pattern match.\n\n1.3 Introducing Facts and RL Language Classes\n\nThis section describes Oracle Business Rules facts. It includes the following sections:\n\n- What Are Facts?\n- Adding Facts to Working Memory with Assert\n- Using RL Language Classes as Facts\n- Using Java Classes as Facts\n\n1.3.1 What Are Facts?\n\nOracle Business Rules facts are asserted objects. For Java objects, a fact is a shallow copy of the object, meaning that each property is cloned, if possible, and if not, then the fact is a copy of the Java object reference.\n\nIn RL Language, a Java object is an instance of a Java class and an RL Object is an instance of an RL Language class. You can use Java classes in the classpath or you can define and use RL Language classes in a ruleset. You can also declare additional properties that are associated with the existing properties or methods of a Java class using a fact class declaration. You can hide properties of a Java class that are not needed in facts using a fact class declaration.\n\nAn RL Language class is similar to a Java Bean without methods. An RL class contains set of named properties. Each property has a type that is either an RL class, a Java object, or a primitive type.\n\nUsing Oracle Business Rules, you typically use Java classes, including JAXB generated classes that support the use of XML, to create rules that examine the business objects in a rule enabled application, or to return results to the application. You typically use RL classes to create intermediate facts that can trigger other rules in the Oracle Rules Engine.\n\n1.3.2 Adding Facts to Working Memory with Assert\n\nOracle Business Rules uses \\textit{working memory} to contain facts (facts do not exist outside of working memory). A RuleSession contains the working memory.\n\nA fact in RL Language is an asserted instance of a class. Example 1-4 shows the \\texttt{assert} function that adds an instance of the RL class \\texttt{enterRoom} as a fact to working memory. A class that is the basis for asserted facts may be defined in Java or in RL Language.\n\nIn Example 1-4 the \\texttt{sayHello} rule matches facts of type \\texttt{enterRoom}, and for each such fact, prints a message. The action \\texttt{new}, shown in the \\texttt{assert} function, creates an instance of the \\texttt{enterRoom} class.\n\nIn Example 1-4 the \\texttt{run} function fires the \\texttt{sayHello} rule.\nNote:\nThe RL Language new keyword extends the Java new functionality with the capability to specify initial values for properties.\n\n**Example 1-4 Matching a Fact Defined by an RL Language Class**\n\n```java\nRL> class enterRoom { String who; }\nRL> assert(new enterRoom(who: \"Bob\"));\nRL> rule sayHello {\n if ( fact enterRoom ) {\n println(\"Hello \" + enterRoom.who);\n }\n}\nRL> run();\nHello Bob\n```\n\n**1.3.3 Using RL Language Classes as Facts**\n\nYou can use RL Language classes in a rules program to supplement a Java application's object model, without having to change the application code for the Java application that supplies Java Objects.\n\nSee Adding Facts to Working Memory with Assert for more details.\n\n**Example 1-5 goldCust Rule**\n\n```java\nrule goldCust {\n if (fact Customer cust && cust.SpentInLastMonths(3) > 500 ){\n assert (new GoldCustomer(cust: cust));\n }\n}\n```\n\n**Example 1-6 goldDiscount Rule**\n\n```java\nrule goldDiscount {\n if (fact Order ord & fact GoldCustomer(cust: ord.customer) )\n {\n ord.discount = 0.1;\n assert(ord);\n }\n}\n```\n\n**Example 1-7** shows the declaration for the GoldCustomer RL class (this assumes that you also have the Customer class available in the classpath).\nExample 1-7 Declaring an RL Language Class\n\nclass GoldCustomer {\n Customer cust;\n}\n\n1.3.4 Using Java Classes as Facts\n\nYou can use asserted Java objects as facts in an RL Language program. You are not required to explicitly define or declare the Java classes. However, you must include the Java classes in the classpath when you run the program. This lets you use the Java classes in rules, and allows a rules program to access and use the public attributes, public methods, and bean properties defined in the Java class (bean properties are preferable for some applications because the Oracle Rules Engine can detect that a Java object supports `PropertyChangeListener`; in this case it uses that mechanism to be notified when the object changes).\n\nIn addition, Fact class declarations can fine tune the properties available to use in an RL program, and may be required for certain multiple inheritance situations.\n\nJava fact types allow methods with and without side effects to be imported. Side effects refer to expensive operations such as I/O, Database Query or web service and so on. When using Java classes as facts, remember the following about side effects.\n\n- Rule and Decision Table conditions do not use methods with side effects.\n- Actions can use all methods. Though side effects are not recommended, are permissible.\n\nWhen you work with Java classes, using the `import` statement lets you omit the package name (see Example 1-8).\n\nExample 1-8 Sample Java Fact with Import\n\n```java\nruleset main\n{\n import example.Person;\n import java.util.*;\n rule hasNickNames\n {\n if (fact Person p && ! p.nicknames.isEmpty())\n {\n // accessing properties as fields:\n println(p.firstName + \" \" + p.lastName + \" has nicknames:\");\n Iterator i = p.nicknames.iterator();\n while (i.hasNext())\n {\n println(i.next());\n }\n }\n }\n}\n```\n\n1.4 Understanding and Controlling Rule Firing\n\nThis section covers the following topics:\n\n- Rule Activation and the Agenda\n- Watching Facts, Rules, and Rule Activations\n- Ordering Rule Firing\n1.4.1 Rule Activation and the Agenda\n\nThe Oracle Rules Engine matches facts against the rule conditions (fact-set-conditions) of all rules as the state of working memory changes. The Oracle Rules Engine only checks for matches when the state of working memory changes, typically when a fact is asserted or retracted. A group of facts that makes a given rule condition true is called a **fact set row**. A **fact set** is a collection of all the fact set rows for a given rule. Thus a fact set consists of the facts that match the rule conditions for a rule. For each fact set row in a fact set, an **activation**, consisting of a fact set row and a reference to the rule is added to the **agenda** (the agenda contains the complete list of activations).\n\n**Figure 1-1** shows a RuleSession with an agenda containing activations in working memory.\n\n**Figure 1-1 RuleSession with Working Memory and the Agenda Containing Activations**\n\nThe **run**, **runUntilHalt**, and **step** functions execute the activations on the agenda, that is, these commands *fire* the rules (use the **step** command to fire a specified number of activations).\n\nRules fire when the Oracle Rules Engine removes activations, by popping the activations off the agenda and performing the rule’s actions.\n\nThe Oracle Rules Engine may remove activations without firing a rule if the rule conditions are no longer satisfied. For example, if the facts change or the rule is cleared then activations may be removed without firing. Further, the Oracle Rules Engine removes activations from the agenda when the facts referenced in a fact set row are modified or the facts are retracted, such that they no longer match a rule condition (and this can also happen in cases where new facts are asserted, when the ! operator applies).\n\nNote the following concerning rule activations:\n\n1. Activations are created, and thus rules fire only when facts are asserted, modified, or retracted (otherwise, the rules would fire continuously).\n2. If a rule asserts a fact that is mentioned in the rule condition, and the rule condition is still true, then a new activation is added back to the agenda and the rule fires again (in this case the rule would fire continuously). This behavior is often a bug.\n3. The actions associated with a rule firing can change the set of activations on the agenda, by modifying facts, asserting facts, or retracting facts, and this can change the next rule to fire.\n\n4. Rules fire sequentially, not in parallel.\n\n---\n\n**See Also:**\n\nOrdering Rule Firing\n\n### 1.4.2 Watching Facts, Rules, and Rule Activations\n\nYou can use the functions `watchActivations`, `watchFacts`, `watchRules`, and `showFacts` to help write and debug RL Language programs.\n\nThis section covers the following topics:\n\n- Watching and Showing Facts in Working Memory\n- Watching Activations and Rule Firing\n\n#### 1.4.2.1 Watching and Showing Facts in Working Memory\n\nThe following code example shows the `watchFacts` function that prints information about facts entering and leaving working memory.\n\nAs shown in the following example, the `watchFacts` function prints `==>` when a fact is asserted. Each fact is assigned a short identifier, beginning with `f-`, so that the fact may be referenced. For example, activations include a reference to the facts that are passed to the rule actions.\n\nNote that the program uses the default ruleset `main`. This ruleset contains the `enterRoom` class.\n\n```ruler\nRL> watchFacts();\nRL> class enterRoom {String who;}\nRL> assert(new enterRoom(who: \"Rahul\"));\n==> f-1 main.enterRoom(who : \"Rahul\")\nRL> assert(new enterRoom(who: \"Kathy\"));\n==> f-2 main.enterRoom(who : \"Kathy\")\nRL> assert(new enterRoom(who: \"Tom\"));\n==> f-3 main.enterRoom(who : \"Tom\")\nRL>\n```\n\nYou can use `showFacts` to show the current facts in working memory. The following sample code example shows the Oracle Rules Engine asserts the initial-fact, `f-0` (the Oracle Rules Engine uses this fact internally).\n\n```ruler\nRL> showFacts();\nf-0 initial-fact()\nf-1 main.enterRoom(who : \"Rahul\")\nf-2 main.enterRoom(who : \"Kathy\")\nf-3 main.enterRoom(who : \"Tom\")\nFor a total of 4 facts.\n```\n\nUse `retract` to remove facts from working memory, as shown in the following example. When `watchFacts` is enabled, the Oracle Rules Engine prints `<==` when a fact is retracted.\n\n```ruler\n```\n1.4.2.2 Watching Activations and Rule Firing\n\nThe `watchActivations` function monitors the Oracle Rules Engine and prints information about rule activations entering and leaving the agenda. The `watchRules` function prints information about rules firing.\n\nExample 1-9 shows how `run` causes the activations to fire. Notice that Rahul is greeted last even though he entered the room first (this is due to the firing order).\n\n---\n\nNote:\n\nActivations may be removed from the agenda before they are fired if their associated facts no longer make the condition true.\n\n---\n\nExample 1-9 Using WatchActivations and WatchRules\n\n```plaintext\nRL> clear;\nRL> class enterRoom {String who;}\nRL> assert(new enterRoom(who: \"Rahul\");\nRL> assert(new enterRoom(who: \"Kathy\");\nRL> assert(new enterRoom(who: \"Tom\");\nRL> watchActivations();\nRL> rule sayHello {\n if (fact enterRoom) {\n println(\"Hello \" + enterRoom.who);\n }\n}\n===> Activation: main.sayHello : f-1\n===> Activation: main.sayHello : f-2\n===> Activation: main.sayHello : f-3\nRL> watchRules();\nRL> run();\nFire 1 main.sayHello f-3\nHello Tom\nFire 2 main.sayHello f-2\nHello Kathy\nFire 3 main.sayHello f-1\nHello Rahul\nRL>\n```\n\n1.4.3 Ordering Rule Firing\n\nTo understand the ordering algorithm for firing rule activations on the agenda, we introduce the ruleset stack. Each RuleSession includes one ruleset stack. The RuleSession's ruleset stack contains the top of the stack, called the focus ruleset, and any non-focus rulesets that are also on the ruleset stack. You place additional rulesets on the ruleset stack using either the `pushRuleset` or `setRulesetStack` built-in functions. You can manage the rulesets on the ruleset stack with the `clearRulesetStack`,\npopRuleset, and setRulesetStack functions. In this case, the focus of the ruleset stack is the current top ruleset in the ruleset stack.\n\nRuleSet Stack\n\nFocus Ruleset --> Top_Ruleset\nNext_down_Ruleset\nLower_Ruleset\nBottom_Ruleset\n\nWhen activations are on the agenda, the Oracle Rules Engine fires rules when run, runUntilHalt, or step executes. The Oracle Rules Engine sequentially selects a rule activation from all of the activations on the agenda, using the following ordering algorithm:\n\n1. The Oracle Rules Engine selects all the rule activations for the focus ruleset, that is the ruleset at the top of the ruleset stack (see the pushRuleset and setRulesetStack built-in functions).\n\n2. Within the set of activations associated with the focus ruleset, rule priority specifies the firing order, with the higher priority rule activations selected to be fired ahead of lower priority rule activations (the default priority level is 0).\n\n3. Within the set of rule activations of the same priority, within the focus ruleset, the most recently added rule activation is the next rule to fire. However, note that in some cases multiple activations may be added to the agenda at the same time, the ordering for such activations is not defined.\n\n4. When all of the rule activations in the current focus fire, the Oracle Rules Engine pops the ruleset stack, and the process returns to Step 1, with the current focus.\n\nIf a set of rules named R1 must all fire before any rule in a second set of rules named R2, then you have two choices:\n\n- Use a single ruleset and set the priority of the rules in R1 higher than the priority of rules in R2.\n- Use two rulesets R1 and R2, and push R2 and then R1 on the ruleset stack.\n\nGenerally, using two rulesets with the ruleset stack is more flexible than using a single ruleset and setting the priority to control when rules fire. For example if some rule R in R1 must trigger a rule in R2 before all rules in R1 fire, a return in R pops the ruleset stack and allows rules in R2 to fire.\n\nIf execution must alternate between two sets of rules, for example, rules to produce facts and rules to consume facts, it is easier to alternate flow with different rulesets than by using different priorities.\n\nThe following code example shows that the priority of the keepGaryOut rule is set to high, this is higher than the priority of the sayHello rule (the default priority is 0). If the activations of both rules are on the agenda, the higher priority rule fires first. Notice that just before calling run, sayHello has two activations on the agenda. Because keepGaryOut fires first, it retracts the enterRoom(who: \"Gary\") fact, which removes the corresponding sayHello activation, resulting in only one sayHello firing.\n\nThe rule shown in the following code example illustrates two additional RL Language features.\n1. The **fact** operator, also known as a fact set pattern, uses the optional **var** keyword to define a variable, in this case the variable `g`, that is bound to the matching facts.\n\n2. You can remove facts in working memory using the **retract** function.\n\n ```\n RL> final int low = -10;\n RL> final int high = 10;\n RL> rule keepGaryOut {\n priority = high;\n if (fact enterRoom(who: \"Gary\") var g) {\n retract(g);\n }\n }\n RL> assert(new enterRoom(who: \"Gary\"));\n ==> f-4 main.enterRoom(who: \"Gary\")\n ==> Activation: main.sayHello : f-4\n ==> Activation: main.keepGaryOut : f-4\n RL> assert(new enterRoom(who: \"Mary\"));\n ==> f-5 main.enterRoom(who: \"Mary\")\n ==> Activation: main.sayHello : f-5\n RL> run();\n Fire 1 main.keepGaryOut f-4\n <== f-4 main.enterRoom(who: \"Gary\")\n <== Activation: main.sayHello : f-4\n Fire 2 main.sayHello f-5\n Hello Mary\n RL>\n ```\n\n**Example 1-10** shows the **sayHello** rule that includes a condition that matches the asserted **enterRoom** fact; this match adds an activation to the agenda. **Example 1-10** demonstrates the following RL Language programming features.\n\n1. The Oracle Rules Engine matches facts against the rule conditions (fact-set-conditions) of all rules as the state of working memory changes. Thus, it does not matter whether facts are asserted before the rule is defined, or after.\n\n2. The **run** function processes any activations on the agenda. No activations on the agenda are processed before calling **run**.\n\n**Example 1-10 enterRoom Class with sayHello Rule**\n\n ```\n RL> class enterRoom { String who; }\n RL> rule sayHello {\n if ( fact enterRoom ) {\n println(\"Hello \" + enterRoom.who);\n }\n }\n RL> assert(new enterRoom(who: \"Bob\"));\n RL> run();\n Hello Bob\n RL>\n ```\n\n**1.4.3.1 Ordering Rule Firing**\n\nNote the important details when ordering rule firing:\n\n- When you use the **return** action, this changes the behavior for firing rules. A **return** action in a rule pops the ruleset stack, so that execution continues with the activations on the agenda that are from the ruleset that is currently at the top of the ruleset stack.\nIf rule execution was initiated with either the run or step functions, and a return action pops the last ruleset from the ruleset stack, then control returns to the caller of the run or step function.\n\nIf rule execution was initiated with the runUntilHalt function, then a return action does not pop the last ruleset from the ruleset stack. The last ruleset is popped with runUntilHalt when there are not any activations left. The Oracle Rules Engine then waits for more activations to appear. When they do, it places the last ruleset on the ruleset stack before resuming ruleset firing.\n\n- Rule priority is only applicable within rules in a given ruleset. Thus, the priority of rules in different rulesets are not comparable.\n\n### 1.5 Using Effective Dates\n\nBy default, the value of the effective date is managed implicitly by the rules engine. In this case, when a run family of built-in functions is invoked, the effective date is updated to the current system date. This is done before any rules fire so that the new effective date is applied before rules begin to fire. In the case of runUntilHalt, this update occurs each time there is a transition from 0 rules on the agenda to > 0 rules on the agenda.\n\nIn Oracle Business Rules RL Language, the effective start and end dates and the active property are only applied to rules (and do not apply for rulesets). The effective start and end date properties of a rule can be specified in the rule.\n\nFor example,\n\n```java\nrule myrule2 {\n active = true;\n effectiveDateForm = Rule.EDFORM_DATETIME;\n effectiveStartDate = JavaDate.fromDateTimeString(\"2008-11-01\");\n effectiveEndDate = JavaDate.fromDateTimeString(\"2008-11-16\");\n\n if (fact Foo)\n |\n |\n }\n}\n```\n\nIf you use the RuleSession Java API, you can access the effective start and end date.\n\nSetting a property from RL Language requires a long expression or several statements.\n\nFor example, given a ruleset:\n\n```java\nruleset MyRules {\n rule myRule { if fact foo { }}\n}\n```\n\nTo set the active property, use the following:\n\n```java\nRule r = getRuleSession().getRuleset(\"MyRules\").getRule(\"myRule\");\nr.setActive(false);\n```\n\n### 1.6 Integrating RL Language Programs with Java Programs\n\nThis section describes integrating RL Language programs with Java programs.\nThis section covers the following topics:\n\n- **Using Java Beans Asserted as Facts**\n- **Using RuleSession Objects in Java Applications**\n\n### See Also:\n\nFor more information, see Working with Rules in Standalone (Non SOA/BPM) Scenarios in the *Designing Business Rules with Oracle Business Process Management*\n\n#### 1.6.1 Using Java Beans Asserted as Facts\n\n**Example 1-11** shows the Java source for a simple bean. Use the `javac` command to compile the bean, `example.Person` shown in **Example 1-11** into a directory tree.\n\nThe following shows how an RL Language command-line can be started that can access this Java bean:\n\n```\njava -classpath $ORACLE_HOME/soa/modules/oracle.rules_11.1.1/rl.jar;BeanPath oracle.rules.rl.session.CommandLine -p \"RL> \"\n```\n\nWhere *BeanPath* is the classpath component to any supplied Java Bean classes.\n\n**Example 1-11 Java Source for Person Bean Class**\n\n```java\npackage example;\nimport java.util.*;\npublic class Person\n{\n private String firstName;\n private String lastName;\n private Set nicknames = new HashSet();\n\n public Person(String first, String last, String[] nick) {\n firstName = first; lastName = last;\n for (int i = 0; i < nick.length; ++i)\n nicknames.add(nick[i]);\n }\n public Person() {} \n public String getFirstName() {return firstName;}\n public void setFirstName(String first) {firstName = first;}\n public String getLastName() {return lastName;}\n public void setLastName(String last) {lastName = last;}\n public Set getNicknames() {return nicknames;}\n}\n```\n\n#### 1.6.1.1 Sample RL Language Program\n\n**Example 1-12** shows how the RL Language command-line can execute an RL Language program that uses `example.Person`. The import statement, as in Java, allows a reference to the `Person` class using \"Person\" instead of \"example.Person\". Rules reference the `Person` bean class and its properties and methods. In order to create a `Person` fact you must assert a Java `Person` bean.\n\n**Example 1-12** uses the `new` operator to create an array of `Person` objects, named `people`. The `people` array is declared final so that `reset` does not create more `people`. The `numPeople` variable is not declared `final` so that `reset` re-invokes the\nassertPeople function and re-asserts the Person facts using the existing Person objects.\n\n**Example 1-12 Ruleset Using Person Bean Class**\n\n```java\nruleset main\n{\n import example.Person;\n import java.util.*;\n rule hasNickNames\n {\n if (fact Person(nicknames: var nns) p && !nns.isEmpty())\n {\n // accessing properties as fields:\n println(p.firstName + \" \" + p.lastName + \" has nicknames:\");\n Iterator i = nns.iterator();\n while (i.hasNext())\n {\n println(i.next());\n }\n }\n }\n rule noNickNames\n {\n if fact Person(nicknames: var nns) p && nns.isEmpty()\n {\n // accessing properties with getters:\n println(p.getFirstName() + \" \" + p.getLastName() + \" does not have nicknames\");\n }\n }\n final Person[] people = new Person[] {\n new Person(\"Robert\", \"Smith\", new String[] { \"Bob\", \"Rob\" }), // using constructor\n new Person(firstName: \"Joe\", lastName: \"Schmoe\") // using attribute value pairs\n };\n function assertPeople(Person[] people) returns int\n {\n for (int i = 0; i < people.length; ++i) {\n assert(people[i]);\n }\n return people.length;\n }\n int numPeople = assertPeople(people);\n run();\n}\n```\n\n**1.6.1.2 Working with Java Beans as Facts**\n\nNote the following points when working with Java beans as facts:\n\n- The `fact` operator can include a pattern that matches or retrieves the bean properties. The properties are defined by getter and setter methods in the bean class.\n- The `new` operator can include a pattern that sets property values after invoking the default no-argument constructor, or can pass arguments to a user-defined constructor.\n- Outside of the `fact` and `new` operators, the bean properties may be referenced or updated using getter and setter methods, or using the property name as if it were a field.\n• If a bean has both a property and a field with the same name, then the field cannot be referenced in RL Language.\n\nIf Example 1-13 executes using the same RuleSession following the execution of Example 1-12, the output is identical to the Example 1-12 results (both person facts are reasserted).\n\nNote:\nThe RL Language command-line interpreter internally creates a RuleSession when it starts (and when you use the clear command).\n\nExample 1-13 Using Reset with a RuleSession\nreset();\nrun();\n\n1.6.2 Using RuleSession Objects in Java Applications\nJava programs can use the RuleSession interface to execute rulesets, invoke RL Language functions passing Java objects as arguments, and redirect RL Language watch and println output. Example 1-14 and Example 1-15 each contain a Java program fragment that uses a RuleSession that prints 'hello world'. Like many Java program fragments, these examples are also legal RL Language programs.\n\nThe RL Language environment provides multiple rule sessions. Each rule session can be used by multiple threads, but rules are fired by a single thread at a time.\n\nEach rule RuleSession has its own copy of facts and rules. To create a fact from a Java Object, use a call such as:\n\nrs.callFunctionWithArgument(\"assert\", Object);\n\nTo create a rule, a function, or an RL Language class, define a string containing a ruleset, and use the executeRuleset method.\n\nExample 1-14 Using a RuleSession Object with callFunctionWithArgument\nimport oracle.rules.rl.*;\ntry {\n RuleSession rs = new RuleSession();\n rs.callFunctionWithArgument(\"println\", \"hello world\");\n} catch (RLException rle) {\n System.out.println(rle);\n}\n\nExample 1-15 Using a RuleSession with ExecuteRuleset\nimport oracle.rules.rl.*;\ntry {\n RuleSession rs = new RuleSession();\n String rset =\n \"ruleset main {\n function myPrintln(String s) {\n println(s);\n }\n }\";\n rs.executeRuleset(rset);\n rs.callFunctionWithArgument(\"myPrintln\", \"hello world\");\n} catch (RLException rle) {\n1.7 Building a Coin Counter Rules Program\n\nThis section shows a sample that uses RL Language to solve a puzzle.\n\nHow many ways can 50 coins add up to $1.50?\n\nThe rules program that solves this puzzle illustrates an important point for rule-based programming: knowledge representation, that is, the fact classes that you select, can be the key design issue. It is often worthwhile to write procedural code to shape your data into a convenient format for the rules to match and process.\n\nTo use this example, first copy the RL Language program shown in Example 1-16 to a file named coins.rl. You can include this from the RL Language command-line using the include command. Before you include the coins program, use the clear; command to erase everything in the current rule session, as follows:\n\nRL> clear;\nRL> include file:coins.rl;\nRL>\n\nThe following code example shows the debugging functions that show the count coins sample facts, activations, and rules for the coin counter. All facts are asserted, and activations for all solutions are placed on the agenda. Notice that the facts are matched to the rule condition as they are generated by populate_facts, and that find_solution prints the matches.\n\nRL> watchFacts();\nRL> watchActivations();\nRL> watchRules();\nRL> reset();\nRL> showActivations();\nRL> run();\n\nThe rule is fired for each activation, printing out the solutions\n\nIn Example 1-16, the keyword final in front of a global variable definition such as coinCount and totalAmount marks that variable as a constant, as in Java. You can reference constants in rule conditions, but you cannot reference variables in rule conditions.\n\nIn RL Language, you must initialize all variables. The initialization expression for a final variable is evaluated once when the variable is defined. The initialization expression for a non-final variable is evaluated when the variable is defined, and again each time the reset function is called. Because the reset function retracts all facts from working memory, it is good practice to assert initial facts in a global variable initialization expression, so that the facts are re-asserted when reset is called.\n\nExample 1-16 illustrates how to use global variable initialization expressions. The initialized global variable is initialized with the populate_facts function. This function is re-executed whenever reset is called. The populate_facts function has a while loop nested within a for loop. The for loop iterates over an array of coin denomination Strings. For each denomination, the while loop asserts a fact that expresses a count and a total that does not exceed the total amount of $1.50. For example, for half dollars:\n\n coin(denomination \"half-dollar\", count:0, amount:0)\n coin(denomination \"half-dollar\", count:1, amount:50)\nWith such facts in working memory, the rule find_solution matches against each denomination with a condition that requires that the counts sum to coinCount and the amounts sum to totalAmt. The run function fires the find_solutions activations.\n\n**Example 1-16 Count Coins Program Source**\n\n```java\nfinal int coinCount = 50;\nfinal int totalAmt = 150;\nfinal String[] denominations = new String[]{\n \"half-dollar\", \"quarter\", \"dime\", \"nickel\", \"penny\" \n};\nclass coin {\n String denomination;\n int count;\n int amount;\n}\nfunction populate_facts() returns boolean {\n for (int i = 0; i < denominations.length; ++i) {\n String denom = denominations[i];\n int count = 0;\n int total = 0;\n int amount = 0;\n if (denom == \"half-dollar\") { amount = 50; }\n else if (denom == \"quarter\") { amount = 25; }\n else if (denom == \"dime\") { amount = 10; }\n else if (denom == \"nickel\") { amount = 5; }\n else { amount = 1; }\n while (total <= totalAmt && count <= coinCount) {\n assert(new coin(denomination: denom,\n count : count,\n amount : total));\n total += amount;\n count ++;\n }\n }\n return true;\n}\nboolean initialized = populate_facts();\nrule find_solution {\n if(fact coin(denomination: \"penny\") p\n && fact coin(denomination: \"nickel\") n\n && fact coin(denomination: \"dime\") d\n && fact coin(denomination: \"quarter\") q\n && fact coin(denomination: \"half-dollar\") h\n && p.count + n.count + d.count + q.count + h.count == coinCount\n && p.amount + n.amount + d.amount + q.amount + h.amount == totalAmt)\n {\n println(\"Solution:\"\n + \" pennies=\" + p.count\n + \" nickels=\" + n.count\n + \" dimes=\" + d.count\n + \" quarters=\" + q.count\n + \" half-dollars=\" + h.count\n );\n }\n```\n} }\nrun();\nThis chapter describes the existing Rete algorithm used by the Rules Engine and introduces a Non-Rete algorithm.\n\nThis chapter includes the following sections:\n\n- Overview\n- Configuring the Non-Rete Algorithm\n\n### 2.1 Overview\n\nThe Rete algorithm was invented by Charles Forgy and was the subject of his 1979 PhD thesis. It was conceived for use with the expert systems of the time and was based on the observation that the facts in the rule engine's working memory change slowly over time through a series of inference cycles. Much of its power is derived from a trade off of increased memory use for improved performance.\n\nCaching previous rule condition evaluation results avoids the re-evaluation of all rule conditions when a small change is made to working memory. Many business rules use cases do not fit this usage profile and thus do not benefit from the use of a Rete algorithm while incurring the overhead of the algorithm's memory consumption characteristics.\n\nThe Non-Rete algorithm (NRE) is an alternative to the Rete algorithm that consumes less memory than the Rete algorithm. For many business rules use cases it will also result in improved performance. The core of NRE algorithm is a new rule condition evaluation approach. The majority of the rules engine is unmodified and shared across the Rete and NRE algorithms. The externally defined semantics of the existing Rete algorithm are preserved by the NRE algorithm. Here are some key points about the new algorithm:\n\n- Simpler internal rule representation.\n- Byte code generated for rule tests, rule actions, and user defined functions.\n- More efficient modify operation.\n- Rule conditions not evaluated until the containing ruleset is on the top of the stack. After initial evaluation, re-evaluation occurs on fact operations as needed.\n- Ability to avoid unnecessary re-evaluation when rulesets are only present on the ruleset stack once during rule execution.\n\n#### 2.1.1 Differences between Rete and NRE Algorithm\n\nThe two main differences between the two algorithms are:\n\n- Rule condition evaluation:\nIn the Rete algorithm, rule conditions are evaluated when fact operations occur (assert, modify, retract).\n\nIn the Non-Rete algorithm, rule conditions are evaluated for the first time when the ruleset is on the top of the stack, then on fact operations after that.\n\n- Rule firing order. There are cases where the rule firing order is not defined, for example when a single fact activates multiple rules at the same time and the priorities are identical. In these cases, the order in which the rule activations fire may be different.\n\nNote:\nIt is possible that an existing set of rules has an implicit dependency on the order in which the rules fire with the Rete algorithm even though that order may not be defined. The order may be different with the Non-Rete algorithm, which may expose a latent bug in the rules as authored.\n\n2.2 Configuring the Non-Rete Algorithm\n\nThe selection of the algorithm to be used must be done when a RuleSession or RuleSessionPool is created.\n\nFor backwards compatibility, the default is the Rete algorithm. The key for the algorithm configuration parameter is RuleSession.CFG_ALGORITHM and the two values are:\n\n- RuleSession.ALGORITHM_RETE\n- RuleSession.ALGORITHM_NRE\n\nAlso, there is a configuration parameter: RuleSession.CFG_ALLOW_ERROR_SUPPRESSION. It is a boolean. The default is true. Setting it to false informs the rule engine that error suppression will not be enabled. In this case, an attempt to enable error suppression will throw an exception. This setting allows the Non-Rete algorithm to realize additional heap savings.\n\nIt is common that multiple rulesets are executed during a rule execution. It is also common that each ruleset is pushed onto the ruleset stack once and after rules in that ruleset have completed firing, it is not pushed onto the stack again during that rule execution. With the Non-Rete algorithm, additional performance gain can be realized for these cases by specifying that the rulesets will only appear on the stack once. This setting can be set and queried with the RL built in functions:\n\n- function setRulesetsOnStackOnce(boolean bv) returns boolean\n- function isRulesetsOnStackOnce() returns boolean\nThis chapter contains a detailed and complete reference to the Oracle Business Rules RL Language (RL Language) syntax, semantics, and built-in functions.\n\nGrammar rules define the RL Language. Each grammar rule defines a non-terminal symbol on the left of the ::= symbol in terms of one or more non-terminal and terminal symbols on the right of the ::= symbol.\n\nReserved Words\n\naggregate, boolean, break, byte, catch, char, class, constant, continue, double, else, exists, extends, fact, factpath, false, final, finally, float, for, function, hide, if, import, include, instanceof, int, long, modify, new, null, property, public, query, return, returns, rule, rulegroup, ruleset, short, supports, synchronized, throw, true, try, while, var\n\nNote:\n\nReserved words in bold apply to the current release. Reserved words that are not shown in bold typeface are planned for a future RL Language release, and include the words: break, continue, and query.\n\nThis chapter includes the following sections:\n\n- Ruleset\n- Types\n- Identifiers\n- Literals\n- Definitions\n- Fact Class Declarations\n- Import Statement\n- Using Expressions\n- Actions and Action Blocks\n- Rulegroup\n- Built-in Functions\n3.1.1 Ruleset\n\nA ruleset groups a set of definitions. A ruleset is a collection of rules and other definitions that are all intended to be evaluated at the same time. A ruleset may also contain executable actions, may include or contain other rulesets, and may import Java classes and packages.\n\nFormat\n\n```\nruleset ::= named-ruleset | unnamed-ruleset\nnamed-ruleset ::= ruleset ruleset-name\n\nunnamed-ruleset ::= ( import | include | named-ruleset | definition | action | fact-class | rulegroup )* ruleset-name ::= identifier\n```\n\nUsage Notes\n\nA named-ruleset creates or adds definitions to the specified ruleset named ruleset-name.\n\nAn unnamed-ruleset adds definitions to the default ruleset named main.\n\nRulesets may be nested, that is they may contain or include other rulesets. Nesting does not affect ruleset naming, but it does affect ruleset visibility in a way similar to Java import's affect on package visibility.\n\nYou can execute a ruleset using the RL Language command-line, or using the Java RuleSession API.\n\nA named-ruleset ruleset-name must be unique within a RuleSession.\n\nExamples\n\nThe following code example contains two definitions, enterRoom and sayHello, and two actions (assert and run).\n\nThe rule shown in the following code example will not fire until:\n\n1. An enterRoom fact is asserted.\n2. The run function executes, which pushes the rule's containing ruleset, hello onto the ruleset stack.\n\n```java\nruleset hello {\n class enterRoom { String who; }\n rule sayHello {\n if (fact enterRoom) {\n println(\"Hello \" + enterRoom.who);\n }\n }\n assert(new enterRoom(who: \"Bob\"));\n run(\"hello\");\n}\n```\n\nIn Example 3-1, if ruleset R2 is nested in ruleset R1, the name R2 must be unique within the rule session. R2 is not named relative to R1. For example, the class C2 defined in R2 is globally named R2.C2, not R1.R2.C2. If R2 is nested in R1, a public class C1 defined in R1 may be referenced in R2 using either the full name R1.C1 or the short name C1 (assuming R2 does not also define C1).\nExample 3-1 Using a Nested Ruleset\n\n```java\nruleset R1 {\n public class C1 {\n public String s;\n }\n C1 apple = new C1(s: \"apple\");\n}\n\nruleset R2 {\n public class C2 {\n public String s;\n }\n C1 c1 = apple; // finds C1 and apple in containing ruleset R1\n c1.s = \"delicious\";\n C2 c2 = new C2(s: \"pear\");\n}\n\nR2.C2 pear = R2.c2; // finds R2.C2 and R2.c2 because they are fully qualified\nprintln(apple.s + \" \" + pear.s); // prints \"delicious pear\"\n\npear = c2; // UndefinedException: c2 not in R1 or a containing ruleset\n```\n\n3.1.2 Types\n\nRL Language is a strongly typed language. Each variable and value has a specified type.\n\nFormat\n\n```\ntype ::= simple-type [] | simple-type ::= primitive | object-type\n\nprimitive ::= boolean\n| numeric numeric ::= int | double | float | long | short | byte | char\n\nobject-type ::= class-definition-name | Java-class-name\n\nclass-definition-name ::= qname\n\nJava-class-name ::= qname\n```\n\nType Conversion\n\nThere are several ways that a value can be converted from one type to another:\n\n1. Conversion from any type to String using the String concatenation operator +.\n2. Implicitly from context. For example, by adding an int to a double first converts\n the int to a double and then adds the 2 doubles.\n3. Casting between 2 numeric types.\n4. Casting between 2 classes related by inheritance.\n5. Invoking a function or method that performs the conversion. For example,\n toString.\n\nTable 3-1 summarizes the implicit conversions for various types. Rows indicate how\nthe type in the From column may be implicitly converted, as shown in the list of types\nshown in the To column.\n\n```\n<table>\n<thead>\n<tr>\n<th>From</th>\n<th>To</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>int</td>\n<td>double, float, long</td>\n</tr>\n</tbody>\n</table>\n```\n### Table 3-1 (Cont.) Implicit Type Conversions\n\n<table>\n<thead>\n<tr>\n<th>From</th>\n<th>To</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>float</td>\n<td>double</td>\n</tr>\n<tr>\n<td>long</td>\n<td>double, float</td>\n</tr>\n<tr>\n<td>short</td>\n<td>int, double, float, long</td>\n</tr>\n<tr>\n<td>byte</td>\n<td>int, double, float, long, short</td>\n</tr>\n<tr>\n<td>char</td>\n<td>int, double, float, long</td>\n</tr>\n<tr>\n<td>String</td>\n<td>Object</td>\n</tr>\n<tr>\n<td>Object</td>\n<td>Object (if the From Object is a subclass of the To Object)</td>\n</tr>\n<tr>\n<td>fact set</td>\n<td>boolean</td>\n</tr>\n<tr>\n<td>array</td>\n<td>Object</td>\n</tr>\n</tbody>\n</table>\n\n**Note:**\nAn Object is an instance of a Java or RL Language class or array. Type conversion is possible only if the classes are related by inheritance (implements or extends).\n\nTable 3-2 summarizes the allowed cast conversions for various types where a cast can be used to convert a primitive with more bits to a primitive with fewer bits, without throwing an exception.\n\nThe type conversions shown in Table 3-2 require an explicit cast operator. For example,\n\n```java\nint i = 1;\nshort s = (short)i;\n```\n\n**Note:**\nType conversions such as those shown in Table 3-2 that involve numeric types may lose high order bits, and such conversions involving Objects may throw a RLClassCastException.\n\n### Table 3-2 Explicit Type Conversions\n\n<table>\n<thead>\n<tr>\n<th>From</th>\n<th>To</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>double</td>\n<td>float, long, int, short, byte, char</td>\n</tr>\n<tr>\n<td>float</td>\n<td>long, int, short, byte, char</td>\n</tr>\n<tr>\n<td>long</td>\n<td>int, short, byte, char</td>\n</tr>\n</tbody>\n</table>\nWhen you use a cast to convert a primitive with more bits, to a primitive with fewer bits, the RL Language discards extra, high order, bits without throwing an exception.\n\nFor example,\n\n```java\nshort s = -134;\nbyte b = (byte)s;\nprintln(\"s = \" + s + \", b = \" + b);\nprints: s = -134, b = 122\n```\n\n### Primitive Types\n\nA primitive type may be any of the following:\n\n- An `int`, which is a 32 bit integer. Literal values are scanned by `java.lang.Integer.parseInt`\n- A `long`. Literal values are scanned by `java.lang.Long.parseLong`\n- A `short`. Literal values are scanned by `java.lang.Short.parseShort`\n- A `byte`. Literal values are scanned by `java.lang.Byte.parseByte`\n- A `char`\n- A `double`. Literal values are scanned by `java.lang.Double.parseDouble`\n- A `float`. Literal values are scanned by `java.lang.Float.parseFloat`\n- A `boolean` `true` or `false`\n\n### Object Types\n\nAn object type may be:\n\n- A `java Object`, identified by the qualified name, `qname`, of its class. For example, `java.lang.String`\n- An RL Language `Object`, identified by the qualified name, `qname` of its class. For example, `ruleset1.Class1`\n\n### String Types\n\nRL Language uses Java strings, where:\n\n- Strings are instances of the class `java.lang.String`\n- A string literal is delimited by double quotes (\"string\")\nUse \" to include the double quote character in a string.\n\n- Strings may be concatenated using the + operator as follows:\n - If any operand of a + operator is a String then the remaining operands are converted to String and the operands are concatenated.\n - An Object is converted to a String using its toString method.\n - An instance of an RL Language class is converted to a String using a built-in conversion.\n\nArray Types\n\nSquare brackets [ ] denote arrays. An array in RL Language has the same syntax and semantics as a Java 1-dimensional array.\n\n---\n\n**Note:**\n\nRL Language does not support multi-dimensional arrays.\n\n---\n\n### 3.1.3 Identifiers\n\nRL Language supports both the Java and the XML variant of identifiers and namespace packages. To use the XML variant, the identifier must be enclosed in back quotes.\n\n**Format**\n\n```\nidentifier ::= java-identifier | xml-identifier\njava-identifier ::= valid-Java-identifier\nxml-identifier ::= `valid-xml-identifier or URI`\n```\n\nWhere:\n\n- **valid-Java-identifier** is: a legal Java identifier, for example, JLD_0.\n- **valid-xml-identifier** is: a legal XML identifier, for example x-1.\n- **URI** is: a legal Uniform Resource Identifier, for example, http://www.oracle.com/rules\n\n**Usage Notes**\n\nAn xml-identifier can contain characters that are illegal Java identifier characters, for example, ' ' and '. The JAXB specification defines a standard mapping of XML identifiers to Java identifiers, and includes preserving the Java conventions of capitalization. The JAXB specification also defines a standard mapping from the schema target namespace URI to a Java package name, and a mapping from anonymous types to Java static nested classes.\n\n**Examples**\n\nRL Language supports both the Java and the XML variant of identifiers and namespaces or packages. Enclose an identifier in back quotes to use the XML variant, as shown in Example 3-2.\n\nYou can use the back quote notation anywhere an identifier or package name is legal in RL Language. To use the XML variant of identifiers in String arguments to assertXPath, back quotes are not needed.\nExample 3-2 Sample Mapping for XML Identifiers Using Back Quotes\n\n'http://www.example.com/po.xsd' -> com.mycompany.po\n'my-attribute' -> myAttribute\n'Items/item' -> Items$ItemType\n\n3.1.4 Literals\n\nTable 3-3 summarizes the RL Language literals. The literals are the same as Java literals.\n\n<table>\n<thead>\n<tr>\n<th>A literal such as</th>\n<th>Can be assigned to variables of these types</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>An integer in range 0..127 or a char with UCS2 encoding in range 0...127</td>\n<td>byte, char, short, int, long, float, double</td>\n</tr>\n<tr>\n<td>An integer in range 0..65535 or a char</td>\n<td>char, int, long, float, double</td>\n</tr>\n<tr>\n<td>An integer in range -128..127</td>\n<td>byte, short, int, long, float, double</td>\n</tr>\n<tr>\n<td>An integer in range -32768..32767</td>\n<td>short, int, long, float, double</td>\n</tr>\n<tr>\n<td>An integer</td>\n<td>int, long, float, double</td>\n</tr>\n<tr>\n<td>An integer with \\ suffix</td>\n<td>long, float, double</td>\n</tr>\n<tr>\n<td>A floating point constant</td>\n<td>double</td>\n</tr>\n<tr>\n<td>A floating point constant with F suffix</td>\n<td>float, double</td>\n</tr>\n<tr>\n<td>A String enclosed in ""</td>\n<td>String, Object</td>\n</tr>\n</tbody>\n</table>\n\n3.1.5 Definitions\n\nWhen a definition within a ruleset is executed, it is checked for correctness and then saved for use later in the rule session.\n\nFormat\n\ndefinition ::= variable | rule | rl-class-definition | function\nname ::= identifier\nqname ::= [ ruleset-or-packagename, ] name ruleset-or-packagename ::= qname\n\nUsage Notes\n\nEvery definition has a unique name within its containing ruleset, and thus a unique qualified name, qname, within the rule session.\n\nVariables defined at the ruleset level are global. Global variables are visible to all expressions contained in the ruleset using the name of the variable and visible to expressions in other rulesets using the variable qname. Functions and public classes may also be referenced from other rulesets using the respective qname.\n\nJava classes and their methods and properties also have qnames.\nExample\n\nThe `qname` of the class definition in Example 3-3 is `hello.enterRoom`.\n\nExample 3-3 Class Definition Within a Named Ruleset\n\n```java\nruleset hello {\n class enterRoom { String who; }\n rule sayHello {\n if (fact enterRoom) {\n println(\"Hello \" + enterRoom.who);\n }\n }\n assert(new enterRoom(who: \"Bob\");\n run(\"hello\");\n}\n```\n\n3.1.5.1 Variable Definitions\n\nVariables are declared as in Java, but initialization is always required.\n\n**Format**\n\n```java\nvariable ::= [ final ] ( numeric name = numeric-expression\n| boolean name = boolean-expression | type ] name = array-expression | null |\nobject-type name = object-expression | null ));\n```\n\n**Usage Notes**\n\nThe type of the array initialized with the `array-expression` must be the same as the type specified for the array elements.\n\nA variable can have a primitive type, a Java class name, or an RL Language class name, and may be an array of elements of the same type.\n\nThe type of the `object-expression` must be the same as the `object-type` of the variable being declared. A class instance or array may be initialized to null.\n\nVariables may be local or global in scope. The initialization expression is required. Local variables may not be final.\n\n3.1.5.1.1 Global Variables\n\nVariables immediately enclosed in a ruleset, that is, in a definition, are global to a rule session in scope. The initialization expression for a final global variable is executed when the global variable is defined.\n\nThe initialization expression for a non-final global variable is executed both:\n\n- When the global variable is defined.\n- Each time the `reset` function is called.\n\nGlobal variables declared as final may not be modified after they are initialized.\n\nGlobal variables referenced in a rule condition (`fact-set-condition`) must be final.\n\n**Examples**\n\nThe following code example shows that the `reset` function performs initialization for the non-final global variable `i`. Thus, this example prints 0, not 1.\nBe careful when initializing global variables with functions that have side effects. If you do not want the side effects repeated when calling `reset`, you should declare the variable `final`. For example, Example 3-4 prints \"once\" twice and Example 3-5 prints \"once\" once.\n\n**Example 3-4 Initializing a Global Variable with Side Effects with Reset**\n\n```java\nRL> clear;\nRL> function once() returns int\n{ \n println(\"once\");\n return 1;\n}\nRL> int i = once();\nonce\nRL> reset();\nonce\n```\n\n**Sample Final Global Variable**\n\n**Example 3-5 Initializing a Final Global Variable to Avoid Side Effects with Reset**\n\n```java\nRL> clear;\nRL> function once() returns int\n{ \n println(\"once\");\n return 1;\n}\nRL> final int i = once();\nonce\nRL> reset();\nonce\n```\n\n### 3.1.5.2 Rule Definitions\n\nThe Oracle Rules Engine matches facts against the fact-set-conditions of all rules in the rule session to build the agenda of rules to execute. A fact set row is a combination of facts that makes the conditions of a rule true. An activation is a fact set row paired with a reference to the action-block of the rule. The agenda is the list of all activations in the rules session. The Oracle Rules Engine matches facts and rules when the state of working memory changes, typically when a fact is asserted or retracted.\n\nThe `run`, `runUntilHalt`, and `step` functions execute activations. Activations are removed from the agenda after they are executed, or if the facts referenced in their fact set row are modified or retracted such that they no longer match the rule's condition.\n\nActivations are executed in order of the ruleset stack. You can manage the ruleset stack with the `getRulesetStack`, `clearRulesetStack`, `pushRuleset`, and `popRuleset` functions.\n\nIn order for a rule to fire, three things must occur:\n\n1. An activation of that rule must be on the agenda.\n2. The containing ruleset must be at the top of the ruleset stack.\n3. You must invoke run, runUntilHalt, or step.\n\nThe fact set produced in a fact-set-condition is available to the rule actions. For each row in the fact set, the action-block is activated as follows:\n\n- The rule's action-block is scheduled for execution at the specified rule priority.\n- References from the action-block to the matched facts are bound to the current row.\n- If a matched fact is retracted before the action-block is executed, the dependent activations are destroyed (removed from the agenda).\n\nFormat\n\n```\nrule ::= rule rule-name { property* fact-set-condition action-block }\n```\n\n```\nrule-name ::= name\nproperty ::= priority | autofocus | logical | active\npriority ::= numeric-expression\nautofocus ::= autofocus = boolean-literal\nlogical ::= logical = ( boolean-literal | positive-integer-literal )\nactive ::= active = boolean-literal\neffectiveDateForm ::= effectiveDateForm = an int restricted to one of values defined in oracle.rules.rl.Rule: EDFORM_DATE, EDFORM_DATETIME, or EDFORM_TIME\neffectiveStartDate ::= effectiveStartDate = expression of type java.util.Calendar\neffectiveEndDate ::= effectiveEndDate = expression of type java.util.Calendar\n```\n\nWhere:\n\n- `positive-integer-literal` is: an integer literal that is > 0\n\nUsage Notes\n\nThe priority property specifies the priority for a rule. Within a set of activations of rules from the same ruleset, activations are executed in priority order (see “Ordering Rule Firing”). When rules have different priorities, the rules with a higher priority are activated before those with a lower priority. The default priority is 0. Within a set of activations of rules of the same priority, the most recently added activations are executed first, but this behavior can be changed (see the getStrategy and setStrategy functions).\n\nA rule with the autofocus property equal to true automatically pushes its containing ruleset onto the ruleset stack whenever it is activated.\n\nA rule with the logical property makes all facts asserted by the rule's action block dependent on some or all facts matched by the rule's condition. An integer value of n for the logical property makes the dependency on the first n top-level &&ed fact set expressions in the rule's condition. A boolean value of true for the logical property makes the dependency on the fact set expression of the condition. Anytime a fact referenced in a row of the fact set changes such that the rule's logical conditions no longer apply, the facts asserted by the activation associated with that fact set row are automatically retracted. A rule with the logical property enabled makes all facts that are asserted by an action block in the rule dependent on facts matched in the rule condition. Anytime a fact referenced in the rule condition changes, such that the rule's conditions no longer apply, the facts asserted by the rule condition are automatically retracted.\n\nThe active property defaults to true.\n\neffectiveStartDate date defaults to null.\neffectiveEndDate date default to null.\neffectiveDateForm defaults to Rule.EDFORM_DATETIME.\nExamples\n\nExample 3-6 shows a rule with the inference, Socrates is mortal, which depends on the fact, Socrates is a man.\n\nExample 3-6 Defining and Using Rule allMenAreMortal\n\n```plaintext\nRL> clear;\nRL> class Man {String name;}\nRL> class Mortal {String name;}\nRL> Mortal lastMortal = null;\nRL> rule allMenAreMortal {\n logical = true;\n if (fact Man)\n {\n assert(lastMortal = new Mortal(name: Man.name));\n }\n}\n```\n\nExample of Same Fact Asserted by Multiple Rules\n\nExample 3-7 shows that it is possible for the same fact to be asserted by multiple rules, or to be asserted by a top-level ruleset action or function. Such a fact will not be automatically retracted unless all asserters have logical clauses that call for automatic retraction. A fact that is asserted by a top level action or function will never be automatically retracted.\n\nNote that the fact that Socrates is mortal is not retracted, because it was asserted by a top level action that is not dependent on the fact that Socrates is a man.\n\nExample 3-7 Asserting Facts Unconditionally\n\n```plaintext\nRL> assert(socrates);\n=> f-3 main.Man(name : \"Socrates\")\n=> Activation: main.allMenAreMortal : f-3\nRL> run();\nFire 1 main.allMenAreMortal f-3\n=> f-4 main.Mortal (name : \"Socrates\")\n<== Focus main, Ruleset stack: {}\nRL> retract(socrates);\n<== f-3 main.Man(name : \"Socrates\")\n<== f-4 main.Mortal (name : \"Socrates\")\nRL> showFacts();\nf-0 initial-fact()\n```\n3.1.5.3 Class Definitions\n\nAll referenced classes must be defined with an RL Language class definition or must be on the Java classpath (Java classes must be imported).\n\nBoth RL Language classes and Java classes can support xpath using the supports keyword, with a supplied xpath.\n\nFormat\n\n\\[\n\\text{rl-class-definition ::= [ public ] [ final ] class name [ extends ] [ supports ] \\{ type-property\\}\\}} \\\\\n\\text{type-property ::= [ public ] type name \\[ = expression \\] ;} \\\\\n\\text{extends ::= extends qname extended-class-name} \\\\\n\\text{extended-class-name ::= qname}\n\\]\n\nUsage Notes\n\nThe type of the optional initialization expression must be the same as the type of the property or implicitly convertible to that type.\n\nA public class is visible from all rulesets. A non-public class is visible only in the containing ruleset.\n\nA final class cannot be extended.\n\nThe extended class must be a defined RL Language class not an imported Java class.\n\nEach property may have an optional initializer. The initializer is evaluated when the class is instantiated by new. If an initial value is also passed to new, the value passed to new overwrites the value computed by the initializer in the class definition.\n\nA public property is visible from all rulesets. A non-public property is visible only within its containing ruleset.\n\nExamples\n\nIn RL Language, the type of an property may be the name of the containing class definition as in the example below showing class definition with type of property:\n\n```java\nclass C0 {\n C0 next;\n}\n```\n\nRL Language, unlike Java, does not support forward references to class definitions (see Example 3-8).\n\n**Example 3-8 Class Definitions with Forward References are Not Allowed**\n\n```java\nclass C1 {\n C2 c2; // causes an UndefinedException\n}\nclass C2 {\n C1 c1;\n}\n```\n3.1.5.3.1 xpath Support\n\nNote:\nxpath support has been deprecated. For more information, see assertTree.\n\nBoth RL Language classes and Java classes support xpath.\n\nAn XML identifier does not need to be surrounded by back quotes within an xpath.\n\nThe built-in assertXPath function supports a simple xpath-like syntax to assert a tree of objects as facts. The nodes in the tree are objects from classes in the same package or ruleset that support xpath. The links between parent and child nodes are instances of the XLink class. All of the properties in a class that supports xpath may be used in the xpath expression.\n\nFormat\n\nsupports ::= supports xpath\n\nxpath ::= first-step next-step* first-step ::= ( . | / | / | [ ] ) ( identifier | * ) ) predicate*\n\npredicate ::= ( identifier xrelop literal ) next-step ::= ( / | // ) ( identifier | * ) predicate*\n\nxrelop ::= eq | lt | gt | le | ge | ne | == | < | > | <= | >= | != literal ::= integer-literal | decimal-literal | double-literal | string-literal | dateTime-literal | date-literal | time-literal\n\nUsage Notes\n\nRL Language xpath support was designed to work with classes that conform to the Java XML Binding (JAXB) 1.0 standard. All JAXB elements from the given root to the elements selected by the xpath, inclusive, are asserted. Additional XLink facts are asserted to aid in writing rules about the parent-child relationships among the asserted elements.\n\nIf a JAXB element is retracted or re-asserted, using assert, then all of its children, and XLinks, are retracted. Instead of re-asserting, use assertXPath again.\n\nNote that RL Language Xpath is not a proper subset of W3C Xpath 2.0. Note the following differences:\n\n- The lt and <, gt and >, are synonymous in RL Language but different in W3C.\n- Date literals must use xs:date() and other constructors in W3C.\n- Constructors are not supported in RL Language, and literals, other than string literals, must not be quoted in RL Language.\n\nExamples\n\nTable 3-4 shows the xpath selection options for use with the built-in assertXPath function. In the descriptions, select means that the element is asserted as a fact, and the selected property of the XLink whose element property refers to the asserted element.\nis true. The ancestors of a selected element, up to and including the root element, are always asserted, but not necessarily selected.\n\n**Table 3-4 xpath Selection Strings**\n\n<table>\n<thead>\n<tr>\n<th>xpath Select String</th>\n<th>Description of Selection</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>/**</td>\n<td>Select all elements including the root</td>\n</tr>\n<tr>\n<td>.//*</td>\n<td>Select all but the root</td>\n</tr>\n<tr>\n<td>.</td>\n<td>Select only the root</td>\n</tr>\n<tr>\n<td>//foo</td>\n<td>Select all objects that are the value of a property named foo.</td>\n</tr>\n<tr>\n<td>.[x==1]/y</td>\n<td>Select children or attributes of root named y only if the root has a child element or attribute named x and equal to 1</td>\n</tr>\n</tbody>\n</table>\n\nThe following example instantiates an RL Language class called Person to build a family tree, as follows:\n\n<table>\n<thead>\n<tr>\n<th>First Generation</th>\n<th>Second Generation</th>\n<th>Third Generation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Ida</td>\n<td>Mary</td>\n<td>Fred</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>John</td>\n</tr>\n<tr>\n<td></td>\n<td>Rachel</td>\n<td>Sally</td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td>Evan</td>\n</tr>\n</tbody>\n</table>\n\nThe above example uses the `assertXPath` function twice, with two xpaths:\n\n```xml\n//kids[male==true]\n//kids[male==false]\n```\n\n**Example 3-9** defines two rules:\n\n- **sibling**: prints all pairs of siblings.\n- **brotherSister**: prints all pairs of brothers and all pairs of sisters.\n\nThe result is:\n\n```java\nf-0 initial-fact()\n```\n\nFor a total of 1 fact.\n\n**Example 3-9 Sample Family Tree Rule Using supports xpath**\n\n```java\nimport java.util.*;\nruleset xp {\n public class Person supports xpath {\n public String name;\n public boolean male;\n public List kids;\n }\n // Build the Family Tree\n Person p = new Person(name: \"Fred\", male: true);\n List k = new ArrayList();\n```\nk.add(p);\np = new Person(name: \"John\", male: true);\nk.add(p);\np = new Person(name: \"Mary\", male: false, kids: k);\nPerson gramma = new Person(name: \"Ida\", male: false, kids: new ArrayList());\ngramma.kids.add(p);\np = new Person(name: \"Sally\", male: false);\nk = new ArrayList();\nk.add(p);\np = new Person(name: \"Evan\", male: true);\nk.add(p);\np = new Person(name: \"Rachel\", male: false, kids: k);\ngramma.kids.add(p);\n// test for siblings.\n// Note the test id(p1) < id(p2) halves the Cartesian product p1 X p2.\nrule sibling {\n if (fact Person p1 && fact Person p2 && id(p1) < id(p2) &&\n exists(fact XLink(element: p1) x &&\n fact XLink(element: p2, parent: x.parent)) { \n println(p1.name + \" is sibling of \" + p2.name);\n }\n}\n\n// test for brothers and sisters, given the following 2 assertXPath() calls\nrule brotherSister {\n if (fact Person p1 && fact Person p2 && id(p1) < id(p2) &&\n exists(fact XLink(element: p1, selected: true) x &&\n fact XLink(element: p2, selected: true,\n parent: x.parent) y &&\n x.samePath(y))) { \n println(p1.name + \" and \" + p2.name + \" are \" +\n (p1.male ? \"brothers\" : \"sisters\");\n }\n}\nassertXPath(\"xp\", gramma, \"//kids[male==true]\");\nassertXPath(\"xp\", gramma, \"//kids[male==false]\");\nrun(\"xp\");\n\nSample Output from Run of Family Tree\n\nExample 3-10 shows the output from running Example 3-9.\n\nExample 3-10 Output from Run of Family Tree Example\n\nMary and Rachel are sisters\nEvan is sibling of Sally\nFred and John are brothers\nFred is sibling of John\nMary is sibling of Rachel\n\nSample Output from Retract Element\n\nExample 3-11 shows that when you retract an element that was asserted with assertXPath, all its descendents are retracted as well.\n\nExample 3-11 Retract the Family Tree\n\nretract(xp.gramma);\nshowFacts();\nSample Output from Print Ancestor Pairs\n\nExample 3-12 prints all pairs of ancestors. First, the family tree is asserted. Example 3-13 shows the output of a run of the code from Example 3-12.\n\n**Example 3-12 Print Ancestor Pairs with Class Ancestor**\n\n```java\nassertXPath(\"xp\", xp.gramma, \"/\\/*\");\nclass Ancestor { Object element; Object ancestor; }\nrule parents {\n if (fact XLink x) {\n assert(new Ancestor(element: x.element, ancestor: x.parent));\n }\n}\nrule ancestors {\n if (fact XLink x && fact Ancestor(ancestor: x.element) a) {\n assert(new Ancestor(element: a.element, ancestor: x.parent));\n }\n}\nrule printAncestor {\n if (fact xp.Person p && fact xp.Person a &&\n fact Ancestor(element: p, ancestor: a) {\n println(a.name + \" is an ancestor of \" p.name);\n }\n}\nrun();\n```\n\nSample Output from Run of Ancestor Example\n\n**Example 3-13 Output from Run of Ancestor Example**\n\nMary is an ancestor of John\nIda is an ancestor of John\nMary is an ancestor of Fred\nIda is an ancestor of Fred\nIda is an ancestor of Mary\nRachel is an ancestor of Evan\nIda is an ancestor of Evan\nRachel is an ancestor of Sally\nIda is an ancestor of Sally\nIda is an ancestor of Rachel\n\n3.1.5.4 Function Definitions\n\nA function is similar to a Java static method.\n\n**Format**\n\n```plaintext\nfunction ::= function name parameters [ returns type ] action-block\nparameters ::= ( [ type identifier ( , type identifier )* ]\n```\n\n**Usage Notes**\n\nThe action-block may invoke the function being defined. However, the action-block may not contain a forward reference to a function that has not already been defined (see Example 3-14 and Example 3-15).\n\nFunctions may be overloaded. For example, the built-in println function is overloaded.\nExamples\n\nExample 3-14 Valid Function Definition Containing Recursive Reference\n\nfunction factorial(long x) returns long {\n if (x <= 1) { return 1; }\n else { return x * factorial(x - 1); }\n}\n\nExample 3-15 Invalid Function Definition Containing Reference to Undefined Function\n\nfunction f1() {\n f2(); // causes an UndefinedException\n}\n\nfunction f2() {\n \n}\n\n3.1.6 Fact Class Declarations\n\nAny Java class can be used as an RL Language fact in a fact context. A fact context is one of:\n\n- The class of a fact-class declaration.\n- The class of a fact-set-pattern.\n- The declared class of an argument to the assert function.\n- The declared class of an argument to the retract function.\n- The declared class of an element argument to the assertXPath function.\n\nIf a class or interface B implements or extends class or interface A, and both A and B appear in fact contexts, then A must appear before B. Failure to follow this rule will result in a FactClassException.\n\nFact class definitions are not required when using RL Language classes. For xpath support, use the supports xpath clause of the RL Language class definition.\n\nFormat\n\nfact-class ::= fact class class-name [ supports ] ( fact-class-body | ; )\nclass-name ::= qname\n\nfact-class-body ::= { [ hidden-properties | properties ]}\n\nhidden-properties ::= hide property *; | ( hide property (( name ,)* name | * ); )+\n\nproperties ::= property *; | ( property (( name ,)* name | * ); )+\n\nUsage Notes\n\nThe fact-class-body is optional in a fact-class declaration. The default fact-class-body is:\n\n{ property *; }\n\nEither the property or hide property keywords can be used in a body, but not both.\nIf `hide` property is used with a list of property names, then those property names are hidden and not available for use in RL Language.\n\nIf `hide` property is used with the wildcard \"*\", then no properties other than those exposed by a superclass or superinterface are available for use in RL Language.\n\nIf `property` is used with a list of property names, then those properties are exposed and available for use in RL Language. If `property` is used with the wildcard *, then all properties other than those hidden by a superclass or superinterface are available for use in RL Language.\n\nA `HiddenPropertyException` will be thrown if a superclass exposes a property that its subclass hides or if a subclass exposes a property that its superclass hides.\n\n**Examples**\n\nSuppose a Java class `Vehicle` has subclasses `Car` and `Truck`. The rule shown in Example 3-16, `matchVehicle`, generates a `TypeCheckException` wrapping a `FactClassException` because the subclasses are referenced before the superclass. Wrapping is used instead of subclassing for both `FactClassException` and `MultipleInheritanceException` because in some fact contexts, these exceptions are not thrown until runtime and then are wrapped by a `RLRuntimeException`.\n\n**Example 3-16 matchVehicle Rule with Subclasses Referenced Before the Superclass**\n\n```java\nassert(new Car()); // fact context for Car\nassert(new Truck()); // fact context for Truck\nrule matchVehicle {\n if (fact Vehicle v) { // fact context for Vehicle - too late!\n if (v instanceof Car) {\n println(\"car\");\n } else {\n println(\"truck\");\n }\n }\n} // generates a TypeCheckException wrapping a FactClassException\n```\n\n**Sample MatchVehicle Rule with References to Superclass First**\n\nIn Example 3-17, the `matchVehicle` rule is the first reference to the superclass, so no exception is thrown.\n\n**Example 3-17 matchVehicle Rule with References to Superclass First**\n\n```java\nclear;\nrule matchVehicle {\n if (fact Vehicle v) {\n if (v instanceof Car) {\n println(\"car\");\n } else {\n println(\"truck\");\n }\n }\n}\nassert(new Car());\nassert(new Truck());\nrune(); // prints \"truck\" then \"car\"\n```\nSample MatchVehicle Rule with First Class Declaration\n\nIn Example 3-18, a fact class declaration is the first reference to the superclass, so no exception is thrown.\n\nExample 3-18 matchVehicle Rule with Fact Class Declaration with Reference to Superclass First\n\nclear;\nfact class Vehicle;\nassert(new Car());\nassert(new Truck());\nrule matchVehicle {\n if (fact Vehicle v) {\n if (v instanceof Car) {\n println(\"car\");\n } else {\n println(\"truck\");\n }\n }\n}\nrun(); // prints \"truck\" then \"car\"\n\nSample Java Class\n\nFacts do not support multiple inheritance. Consider the Java classes and interfaces shown in Example 3-19.\n\nExample 3-19 Java Classes and Sample Multiple Inheritance\n\npackage example;\npublic class Car {}\npublic interface Sporty {}\npublic class SportsCar extends Car implements Sporty {}\n\nSample MultipleInheritance Exception for Facts\n\nExample 3-20 entered at the command-line results in a TypeCheckException that wraps a MultipleInheritanceException. Use the getCause method on the TypeCheckException to retrieve the wrapped MultipleInheritanceException exception.\n\nExample 3-20 MultipleInheritance Exception for Facts\n\nimport example.*;\nfact class Sporty;\nfact class Car;\nfact class SportsCar; // throws TypeCheckException wrapping a MultipleInheritanceException\n\nSample RL Runtime Exception\n\nExample 3-21 illustrates an exception that occurs at runtime when the Oracle Rules Engine attempts to assert the rx8 object and discovers its true type is SportsCar, not Object. To avoid the MultipleInheritanceException, you must choose whether to use Sporty or Car in a fact class context. You cannot use both.\n\nExample 3-21 RLRuntimeException wraps MultipleInheritanceException\n\nimport example.*;\nfact class Sporty;\nfact class Car;\nObject rx8 = new SportsCar();\nassert(rx8); // throws RLRuntimeException wrapping a MultipleInheritanceException\n\nSample FactClassException\n\nExample 3-22 FactClassException Possible Cause\n\noracle.rules.rl.FactClassException: fact class for 'X' should be declared earlier in rule session\n\nFact Context Rule\n\nIf X is a subclass or subinterface, of Y, then Y must appear in a fact context before X. A fact context is a fact-class declaration, a rule fact pattern, or the argument of assert, assertXPath, or retract.\n\nIn some cases you need to consider the fact context. For example, with an XML schema such as the following:\n\n```xml\n<schema>\n <element name=A type=T/>\n <complexType name=T>\n <sequence>\n <element name=B type=T/>\n </sequence>\n </complexType>\n</schema>\n```\n\nJAXB generates:\n\n```java\ninterface T {\n List getB(); // List has TImpl objects\n}\ninterface A extends T;\nclass AImpl implements A extends TImpl;\nclass TImpl implements T;\n```\n\nIn an example with the following order of appearance in fact contexts:\n\n1. fact class T\n2. assertXPath AImpl\n3. assert TImpl (performed internally by the assertXPath implementation)\n\nThe, AImpl precedes TImpl in the ordering, yet AImpl extends TImpl, which would give the exception. The fix for this fact context is to explicitly issue fact class TImpl; anywhere before Step 2.\n\n3.1.7 Import Statement\n\nAn import statement makes it possible to omit the package name qualification when referencing Java classes.\n\n**Format**\n\n```java\nimport ::= import ( Java-class-name | Java-package-name.* )\nJava-package-name ::= qname\n```\nUsage Notes\nImport commands can be placed inside a ruleset, implying that the scope of the import is the ruleset where the import is located, but the import actually applies globally. For example, in the following code if the imports were scoped to the rulesets, then the PrintWriter reference in r2 would not compile.\n\nclass X { }\n\nruleset rl {\n import java.io.*;\n rule A {\n if ( fact X ) {\n @ PrintWriter pw = null;\n }\n }\n}\n\nruleset r2 {\n rule B {\n if ( fact X ) {\n @ PrintWriter pw = null;\n }\n }\n}\n\n3.1.8 Include Statement\n\nInclude the ruleset at the location specified by the URL.\n\nFormat\n\ninclude ::= include URL ;\n\n\nUsage Notes\nThe file: and http: schemes are supported.\n\nExample\n\ninclude file:example.rl;\n\n3.1.9 Using Expressions\n\nExpressions in RL Language use familiar Java syntax (with minor variations as noted). For example,\n\n(a + 1) * (b - 2)\n\nUse expressions in a condition or in an action, with some restrictions. Expressions are strongly typed.\n\nFormat\n\nexpression ::= boolean-expression\n3.1.9.1 Boolean Expressions\n\nBoolean expressions, as in Java, may be either true or false.\n\n**Format**\n\nboolean-expression ::= boolean-assignment\n\n| boolean-expression ? boolean-expression : boolean-expression\n| boolean-expression || boolean-expression\n| boolean-expression && boolean-expression\n| numeric-expression equal-op numeric-expression\n| object-expression equal-op object-expression\n| boolean-expression equal-op boolean-expression\n| object-expression instanceof type-name\n| numeric-expression relop numeric-expression\n| string-expression relop string-expression\n| ! boolean-expression\n| boolean-primary-expression\n\nboolean-assignment ::= boolean-target-expression = boolean-expression\n\nequal-op ::= == != relop ::= < > <= >=\n\ntype-name ::= qname\n\n**Usage Notes**\n\nFor strings, < is Unicode UCS2 code point order.\n\nFor objects, != does not test for inequality of object references, but rather is the negation of the equals methods.\n\nThus, the statement:\n\nif (object1 != object2) {} \n\nIs equivalent to the statement:\n\nif (! (object1.equals(object2))) {} \n\nRL Language, unlike Java, does not support testing for equality of object references.\nExample\n\nExample 3-23 shows use of a boolean expression in RL Language.\n\nExample 3-23 RL Boolean Expression\n\n```java\nif {\n (true ? \"a\" < \"b\" : false)\n && (1 == 0 || 1.0 > 0)\n && \"x\" instanceof Object\n} {\n println(\"all true\");\n};\n```\n\n3.1.9.2 Numeric Expressions\n\nNumeric expressions, as in Java, implicitly convert integer operands to floating point if other operands are floating point. Table 3-1 shows other implicit conversions.\n\nFormat\n\n```\nnumeric-expression ::= numeric-assignment\n| boolean-expression ? numeric-expression : numeric-expression\n| numeric-expression( + | - ) numeric-expression\n| numeric-expression ( * | / | % ) numeric-expression\n| numeric-expression ** numeric-expression\n| ( numeric-cast ) numeric-expression\n| ( + | - ) numeric-expression\n| ( ++ | -- ) numeric-primary-expression\n| numeric-primary-expression [ ++ | -- ]\n```\n\n```\nnumeric-assignment ::= numeric-target-expression ( = | += | -= | *= | /= | %= ) numeric-expression\n```\n\n```\nnumeric-cast ::= numeric\n```\n\nUsage Notes\n\nTable 3-5 shows the precedence order, from highest to lowest, for a numeric-expression.\n\n<table>\n<thead>\n<tr>\n<th>Symbols</th>\n<th>Category</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>++ --</td>\n<td>Post-increment</td>\n<td>numeric-primary-expression [ ++</td>\n</tr>\n<tr>\n<td></td>\n<td>or Post-</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>decrement</td>\n<td></td>\n</tr>\n<tr>\n<td>++ --</td>\n<td>Pre-increment</td>\n<td>( ++</td>\n</tr>\n<tr>\n<td></td>\n<td>or Pre-</td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td>decrement</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n### Table 3-5 (Cont.) Expression Operator Precedence\n\n<table>\n<thead>\n<tr>\n<th>Symbols</th>\n<th>Category</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>- +</td>\n<td>Unary minus or Unary plus</td>\n<td>( +</td>\n</tr>\n<tr>\n<td>(type)</td>\n<td>Type cast</td>\n<td>( numeric cast ) numeric-expression</td>\n</tr>\n<tr>\n<td>**</td>\n<td>Exponentiation</td>\n<td>numeric-expression ** numeric-expression</td>\n</tr>\n<tr>\n<td>*, /, %</td>\n<td>Multiply or Divide or Remainder</td>\n<td>numeric-expression (*</td>\n</tr>\n<tr>\n<td>+, -</td>\n<td>Addition or Subtraction</td>\n<td>numeric-expression( +</td>\n</tr>\n<tr>\n<td>?, :</td>\n<td>Conditional</td>\n<td>boolean-expression ? numeric-expression : numeric-expression</td>\n</tr>\n<tr>\n<td>=</td>\n<td>+=</td>\n<td>-=</td>\n</tr>\n</tbody>\n</table>\n\n#### 3.1.9.3 String Expressions\n\nAs in Java, any expression can be converted to a string using the concatenation `+` operator. In RL Language, unlike Java, when an array is converted to a string, the array contents are converted to a string, with array elements separated by commas and surrounded with curly braces. When an instance of an RL Language class is converted to a string, the class name appears followed by property value pairs separated by commas and surrounded with parentheses. This RL Language feature is useful for logging, tracing, and debugging.\n\nWhen `+` operator is applied to an operand that is a `String`, then all operands are converted to `Strings` and the operands are concatenated.\n\n**Format**\n\n```\nstring-expression ::= string-assignment\n| boolean-expression ? string-expression : string-expression\n| string-expression + expression\n| expression + string-expression\n| string + string-expression\n| string-primary-expression\n|\nstring-assignment ::= string-target-expression ( = | += ) string-expression\n```\n\n**Example**\n\nExample 3-24 shows use of a string expression in RL Language. The example prints \"1 2.0 true {1,2}\"\n\n---\n\nUsing Expressions\nExample 3-24 RL String Expression\n\n```java\nint i = 1;\ndouble f = 2.0;\nboolean b = true;\nint[] v = new int[]{i, 2};\nprintln(i + \" + f + \" + b + \" + v);\n```\n\n3.1.9.4 Array Expressions\n\nRL Language arrays behave just like Java arrays, but are limited to one dimension. The base type of an array is the type of the members of the array. All members must be of the same type. An array element may contain an array but only if the containing array is of type `Object[]`.\n\n**Note:**\n\nRL Language does not directly support multi-dimensional arrays.\n\nFormat\n\n```\narray-expression ::= array-assignment\n| boolean-expression ? array-expression : array-expression\n| ( array-cast ) ( array-expression | object-expression )\n| array-primary-expression\narray-assignment ::= array-target-expression = array-expression\narray-cast ::= type\n```\n\nUsage Notes\n\nThe type of an `array-cast` must be an array type.\n\n3.1.9.5 Fact Set Expressions\n\nA `fact-set-expression` matches, filters, and returns facts from working memory. A `fact-set-expression` is legal only in a rule `fact-set-condition`. The `if` keyword indicates a `fact-set-condition`; however, a `fact-set-condition` is different from an `if` action. A rule's `fact-set-condition` iterates through all the rows in a fact set that match the `fact-set-condition`. The `if` action tests a boolean expression.\n\nFormat\n\n```\nfact-set-condition ::= if fact-set-expression\n\nfact-set-expression ::= fact-set-expression | fact-set-expression\n| fact-set-expression && fact-set-expression\n| fact-set-expression && boolean-expression\n| ! fact-set-expression\n| exists fact-set-expression\n```\n| fact-set-pattern\n| (fact-set-expression)\n\n| aggregate fact-set-pattern ::= fact [ ( property-pattern ( , property-pattern )* ) ] [ var ]\nlocal-object-variable local-object-variable ::= identifier property-pattern ::= property-name : field-pattern field-pattern ::= var local-property-variable [ constraint\n\nlocal-property-variable ::= identifier\n\nsimple-expression ::= string literal | object-target-expression | numeric literal | numeric-target-expression | boolean-literal | boolean-target-expression constraint ::= simple-expression property-name ::= name aggregate ::= aggregate fact-set-expression : aggregate-spec ( , aggregate-spec )* aggregate-spec ::= aggregate-function [ var ] identifier aggregate-function ::= average ( numeric-expression ) | sum ( numeric-expression ) | minimum ( comparable-expression ) | maximum ( comparable-expression ) | count () | collection ( object-expression ) | user-defined ( expression type Tin ) user-defined ::= qname\n\nUsage Notes\n\nA fact-set-expression can limit the facts it returns using either a simple-expression as a constraint in a fact-set-pattern or using a supported operator with the fact-set-expression.\n\nA fact-set-expression may not contain any of the following:\n\n- **assert**\n- **modify**\n- **new**\n- References to non-final global variables.\n\nOperator precedence is as in Java. Use parentheses to force desired precedence. For example,\n\n```\nfact person var p && (p.age < 21 || p.age > 65)\n```\n\nWithout the parentheses, the p in p.age is undefined (see Table 3-5 for more details on operator precedence).\n\nA local-object-variable or local-property-variable is in scope for all expressions following the pattern that are following the pattern and connected with the && operator. If the pattern is not contained in an exists, ||, or ! expression, the variable is also in scope in the rule’s action-block. The &&’ed expressions may filter the returned facts, so that only the facts surviving the filter are returned.\n\nFact Set Pattern - Fetch From Working Memory\n\nThe most primitive fact-set-expression is the fact-set-pattern that returns some or all facts of the given class that have been asserted into working memory. A fact-set-pattern searches working memory for facts of the given class and with the optional constraint on the property values. The returned fact set contains a row for each matching fact. A local row variable can be defined to refer to each row, or local field variables can be defined to refer to fields within a row. If no local row variable is supplied, the name part of the class qname can be used to refer to each row (see Example 3-28).\nJoin Operator\n\nThe \\&\\& operator defines the cross product or join of two fact-set-expression operands. The left-hand-side of a fact-set-expression \\&\\& operator must be a fact set. The right-hand-side of a join operator is another fact-set-expression. The result of applying the \\&\\& operator to two fact sets is the joined fact set.\n\nFilter Operator\n\nThe \\&\\& operator defines a filter operator that rejects facts in its left-hand-side fact-set-expression that do not match the right-hand-side boolean-expression. The left-hand-side of filter must be a fact-set-expression. The right-hand-side of a filter is a boolean-expression.\n\nA filter right-hand-side may include references to variables defined, using the var keyword, in the left-hand-side.\n\nUnion Operator\n\nThe || operator defines the union of two fact-set-expression operands. When the || operator is applied to fact-set-expressions, the following is true:\n\n- The expression's vars cannot be referenced outside the containing expression.\n- The || returns the concatenation of its input fact sets, but the contents of the produced fact set are not accessible. Thus, || is typically used in a ! or exists expression. Rather than a top-level || in a condition, it is usually better to use two or more rules with top-level \\&\\& operators so that vars defined in the condition can be referenced in the action-block.\n\nNote:\n\nIn the following construction:\n\nif (fact X || fact W) {} \n\nIf both an X and a W are asserted, this rule fires twice, one time for each fact.\n\nEmpty Operator\n\nThe ! operator tests if the fact-set-expression is empty. When the ! is applied to the fact-set-expression, the following is true:\n\n- The expression's vars cannot be referenced outside the containing ! expression.\n- The ! operator returns a single row if the fact-set-expression is empty, else the ! operator returns an empty fact set.\n\nExists (Not Empty) Operator\n\nThe exists operator tests if the fact-set-expression is not empty.\n\nWhen the exists operator is applied to the fact-set-expression, the following is true:\n\n- The expression's vars cannot be referenced outside the containing exists expression.\n• The *exists* returns a single row if the expression is not empty, else *exists* returns an empty fact set.\n\n**Var Keyword**\n\nNote that when you use *var*, the fact is only visible using the *var* defined variable (and not using the original name). Thus, the following example works, assuming *action.kind* is defined:\n\n```java\nif (fact action) {\n println(action.kind);\n}\n```\n\nHowever, for the following example, after *var a* is defined, the *action.kind* reference produces a syntax error because you need to use *a.kind* after the *var a* definition.\n\n```java\nif (fact action var a) {\n println(action.kind);\n}\n```\n\n**Aggregate**\n\nAggregates support the following functions:\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>average()</td>\n<td>Provides the average for matching facts. The result is double.</td>\n</tr>\n<tr>\n<td>sum()</td>\n<td>Provides the sum for the matching facts. The result is double or long.</td>\n</tr>\n<tr>\n<td>count()</td>\n<td>The result is long.</td>\n</tr>\n<tr>\n<td>minimum()</td>\n<td>Provides the minimum for the matching facts.</td>\n</tr>\n<tr>\n<td>maximum()</td>\n<td>Provides the maximum for the matching facts.</td>\n</tr>\n<tr>\n<td>collection()</td>\n<td>The result is java.util.List of Facts.</td>\n</tr>\n<tr>\n<td>user defined</td>\n<td>For a user-defined function the result is type Tout.</td>\n</tr>\n</tbody>\n</table>\n\nRL Language supports the aggregate pattern that applies one or more aggregate functions to a *factRowCollection*, and binds the aggregates to pattern variables. The usual SQL set of built-in aggregates is supported, and user-defined aggregates are supported when a user-supplied Java class is supplied.\n\nIf an aggregate function uses primitive wrapper types, for example Long, Double, then these will be unboxed such that the bind variable for the result has the appropriate raw primitive type.\n\nIf the fact expression in an aggregate is empty, then the rule will not fire. This ensures that if there are no matching facts for the expression, the aggregate function does not return a number that is meaningless in this context. For example, the \"sum\" of a property of a zero-size set is not meaningful.\n\nFor example, print the names of employees who are paid better than average:\nPrint the names of employees, who are paid better than the average of employees who\nmake over $100,000:\n\n```java\nif fact Emp emp && aggregate fact Emp(salary: var sal) && Emp.salary > 100000 : average(sal) var avgSal\n&& emp.salary > avgSal {\n println(emp.name);\n}\n```\n\nUser-defined aggregates are supported by providing a public class named `user-defined` with a public 0-arg constructor that implements:\n\n```java\npublic interface IncrementalAggregate<Tin, Tout> extends Serializable\n{\n public void initialize();\n public void add(Tin value);\n public void remove(Tin value);\n public Tout getResult();\n public boolean isValid();\n}\n```\n\nImplementations must support the following invocation sequence:\n\n```java\nnew (initialize (add|remove)+ isValid getResult)*\n```\n\n`isValid` should return `true` when the result of the user defined aggregate is valid and `false` otherwise.\n\n**Examples**\n\n**Example 3-25** shows the action is placed on the agenda for all `Counter` facts with a value of 1.\n\n**Example 3-25 Fact Set Expression for Counter.value**\n\n```java\nclass Counter { int id; int value; }\nrule ex1a {\n if (fact Counter c && c.value == 1)\n { println(\"counter id \" + c.id + \" is 1\"); }\n}\n```\n\n**Sample of Fact Set Constraint**\n\n**Example 3-26** shows an equivalent way to express the rule from **Example 3-25**, using a constraint.\n\n**Example 3-26 Using a Fact Set Constraint**\n\n```java\nrule ex1b {\n if (fact Counter(value: 1) c)\n { println(\"counter id \" + c.id + \" is 1\"); }\n}\n```\n\nassert(new Counter(id: 1, value: 99));\nrun(); // prints twice, once for each rule\nSample Illegal Use of Fact Set\n\nExample 3-27 shows an illegal use of a fact set, because \\( c \\) is used before it is defined.\n\n**Example 3-27 Illegal Use of Fact Set**\n\n```java\nrule ex2 {\n if (c.value == 1 && fact Counter c)\n { println(\"counter id \"+ c.id +\" is 1\"); }\n}\n```\n\nSample Fact Set with && Operator for Counter Fact\n\nExample 3-28 shows an action is placed on the agenda for all \\( \\text{AttFacts} \\) with the property \\( a2==0 \\) and without a matching, equal first elements, Counter.\n\n**Example 3-28 Using a Fact Set with && Operator for Counter Fact**\n\n```java\nclass AttFact {int a1; int a2;}\nrule ex3 {\n if (fact AttFact(a2: 0) && ! fact Counter(id: AttFact.a1))\n { println(AttFact.a1); }\n}\nassert(new AttFact()); // will match because a1=a2=0\nassert(new AttFact(a1: 1, a2: 0)); // will not match\nrun(); // rule fires once\n```\n\nSample Fact Set with && Operator\n\nExample 3-29 shows the condition, if \\( \\text{fact } \\text{Ca } a \\text{ && fact } \\text{Cb}(v: a.v) b \\) is interpreted as follows:\n\n- The \\( \\text{fact } \\text{Ca } a \\) returns a fact set containing \\( a(v: 1), a(v: 2), a(v: 3) \\)\n- The \\&\\& operator returns a fact set containing the two rows \\( \\{a(v: 1), b(v: 1)\\}, \\{a(v: 2), b(v: 2)\\} \\)\n\n**Example 3-29 Using a Fact Set with && Operator**\n\n```java\nclass Ca {int v;}\nassert(new Ca(v: 1));\nassert(new Ca(v: 2));\nassert(new Ca(v: 3));\nclass Cb {int v;}\nassert(new Cb(v: 0));\nassert(new Cb(v: 1));\nassert(new Cb(v: 2));\nrule r {\n if (fact Ca a && fact Cb(v: a.v) b) {\n println(\"row: \" + a + \" + \" + b);\n }\n}\nrun(); // prints 2 rows\n```\n\n### 3.1.9.6 Comparable Expression\n\nComparable expressions allow objects that implement java.lang.Comparable to be compared using the ==, !=, <, <=, >, and >= operators. This allows dates to be easily\ncompared. Also, BigDecimal, often used to represent money, can be compared in such expressions.\n\n**Format**\n\ncomparable-expression ::= \n\nqname variable of type implementing java.lang.Comparable | member of type implementing java.lang.Comparable\n\n### 3.1.9.7 Object Expressions\n\nThe only expression operators for objects are assignment and cast.\n\n**Format**\n\nobject-expression ::= object-assignment | ( ob-cast ) object-expression | boolean-expression ? object-expression : object-expression\n\nobject-assignment ::= object-target-expression = object-primary-expression\n\nob-cast ::= object-type\n\n### 3.1.9.8 Primary Expressions\n\nPrimary expressions include assignment targets such as variables, properties, array elements, class members and other tightly binding expression syntax such as literals, method and function calls, and object and fact construction. The syntax is very similar to Java except where noted.\n\n**Format**\n\nprimary-expression ::= array-primary-expression\n\n| string-primary-expression |\n| numeric-primary-expression |\n| boolean-primary-expression |\n| object-primary-expression |\n\narray-primary-expression ::= \n\narray-constructor\n\n| function-call returning array |\n| method-call returning 1-dim Java array |\n\n| ( array-expression ) |\n| array-target-expression |\n\narray-constructor ::= new ( \n\nsimple-type [ numeric-expression integer ]\n\nUsing Expressions\n\n\\[ \\text{numeric} \\] \\{ \\text{numeric-expression} ( , \\text{numeric-expression} )* \\} \\text{numeric expression must be implicitly convertible to base} \\\\\n\\[ \\text{boolean} \\] \\{ \\text{boolean-expression} ( , \\text{boolean-expression} )* \\} \\\\\n\\[ \\text{object-type} \\] \\{ \\text{object-expression} ( , \\text{object-expression} )* \\} \\\\\n) \\\\\n\narray-target-expression ::= \\\\\nqname \\text{variable of type array} \\\\\n| member \\text{of type array} \\\\\n| array-primary-expression \\text{base type is Object} \\{ \\text{numeric-expression int} \\} \\\\\n\nstring-primary-expression ::= \\\\\nstring literal (see “Literals”) \\\\\n| object-primary-expression \\text{object is java.lang.String} \\\\\n\nstring-target-expression ::= object-target-expression \\text{object is java.lang.String} \\\\\n\nnumeric-primary-expression ::= \\\\\nnumeric literal \\\\\n| function-call \\text{returning numeric} \\\\\n| method-call \\text{returning numeric} \\\\\n| array-primary-expression . length \\\\\n| ( numeric-expression ) \\\\\n| numeric-target-expression \\\\\n\nnumeric-target-expression ::= \\\\\nqname \\text{variable of type numeric} \\\\\n| member \\text{of type numeric} \\\\\n| array-primary-expression \\text{base type is numeric} \\{ \\text{numeric-expression} \\} \\\\\n\nboolean-primary-expression ::= \\\\\nboolean-literal \\\\\n| function-call \\text{returning boolean} \\\\\n| method-call \\text{returning boolean} \\\\\n| ( boolean-expression ) \\\\\n| boolean-target-expression \\\\\n\nboolean-literal ::= true | false \\\\\n\nboolean-target-expression ::=\nqname variable of type boolean\n| member of type boolean\n| array-primary-expression base type is boolean [ numeric-expression int ]\n\nobject-primary-expression ::= \n new class-definition-name ( [ expression (, expression)* ] argument list )\n| new class-definition-name ( [ property-pattern (, property-pattern)* ] property-value pairs )\n| function-call returning Java object\n| method-call returning Java object\n| object-target-expression\n\nobject-target-expression ::= \n qname variable of type object\n| member of type Java object\n| array-primary-expression base type is object [ numeric-expression int ]\n\nfunction-call ::= qname function name ( [ expression (, expression)* ] argument list )\nmethod-call ::= object-primary-expression . identifier method name ( [ expression (, expression)* ] argument list )\n\nmember ::= object-primary-expression . identifier member name\n\nExamples\n\nExample 3-30 shows the RL Language literal syntax (which is the same as Java).\n\nMethods and functions can be overloaded. However, unlike Java, RL Language uses a first fit algorithm to match an actual argument list to the overloaded functions.\n\nExample 3-30 Use of Literals\n\nString s = \"This is a string.\"\nint i = 23;\ndouble f = 3.14;\nboolean b = false;\n\nSample Overloading\n\nExample 3-31 shows an example of overloading\n\nExample 3-31 Overloading\n\nfunction f(int i);\nfunction f(Object o);\nfunction f(String s); // can never be called\n\nf(1); // calls first f\nf(\"a\"); // calls second f, because \"a\" is an Object\n3.1.9.8.1 new\n\nRL Language classes do not have user-defined constructors. The default constructor initializes properties to their default values. The RL Language new operator permits specifying some property values (this works for Java bean properties, too).\n\nA Java bean property may have a getter but no setter. Such a property may not be modified.\n\nExample\n\nExample 3-32 Initialization Using the New Operator\n\nclass C { int i = 1; int j = 2; }\nC c = new C();\nprintln(c); // c.i == 1 and c.j == 2\n\nC c = new C(i: 3);\nprintln(c); // c.i == 3 and c.j == 2\nC c = new C(i: 0, j: 0);\nprintln(c); // c.i == c.j == 0\n\n3.1.10 Actions and Action Blocks\n\nRL Language, unlike Java, requires action blocks and does not allow a single semicolon terminated action.\n\nFormat\n\naction ::= action-block | if | while | for | try | synchronized | return | throw |\n| assign | incr-decr-expression | primary-action\n\naction-block ::= { (variable | action)* }\n\nUsage Notes\n\nAn action block is any number of local variable declarations and actions. The variables are visible to subsequent variable initialization expressions and actions within the same action block.\n\nIn RL Language, unlike in Java, all local variables must be initialized when they are declared. Local variables may not be final.\n\nTo exit, you can invoke the System.exit(int) method from within an action.\n\nExample\n\nExample 3-33 Action Block Sample\n\nRL> {\n int i = 2;\n while (i-- > 0) { println(\"bye\"); }\n}\nbye\nbye\nRL>\n3.1.10.1 If Else Action Block\n\nUsing the if else action, if the test is true, execute the first action block, and if the test is false, execute the optional else part, which may be another if action or an action block.\n\nRL Language, unlike Java, requires action blocks and does not allow a single semicolon terminated action.\n\nFormat\n\nif ::= if if-test action-block [ else if | action-block ]\nif-test ::= boolean-expression\n\nExamples\n\nExample 3-34 shows an RL Language if else action block. Example 3-35 shows that an action block is required.\n\nExample 3-34 Sample If Else Action\n\nString s = \"b\";\nif (s==\"a\") { println(\"no\"); } else if (s==\"b\") { println(\"yes\"); } else { println(\"no\"); }\n\nExample 3-35 Illegal If Action Without an Action Block\n\nif (s==\"a\") println(\"no\");\n\n3.1.10.2 While Action Block\n\nWhile the test is true, execute the action block. A return, throw, or halt may exit the action block.\n\nFormat\n\nwhile ::= while while-test action-block\nwhile-test ::= boolean-expression\n\nUsage Notes\n\nRL Language, unlike Java, requires action blocks and does not allow single semicolon terminated action.\n\nExamples\n\nExample 3-36 prints \"bye\" twice.\n\nExample 3-36 Sample While Action\n\nint i = 2;\nwhile (i-- > 0) {\n println(\"bye\");\n}\nExample 3-37 Illegal While Action Without an Action Block\n\nwhile (i-- > 0) println(\"no\");\n\n3.1.10.3 For Action Block\n\nRL Language, like Java, has a for loop. Using the for action block, the for-init portion executes, then while the boolean-expression is true, first the specified action block is executed then the for-update executes. A return, throw, or halt may exit the action block.\n\nFormat\n\n```\nfor ::= for ( for-init ; boolean-expression ; for-update ) action-block\n```\n\nfor-init ::= variable | for-update for-update ::= incr-decr-expression | assign | primary-expression\n\nUsage Notes\n\nRL Language does not allow a comma separated list of expressions in the for init or for update clauses (Java does allow this).\n\nExample\n\nExample 3-38 shows RL Language code that converts an int[] to a double[].\n\nExample 3-38 For Action\n\n```\nint[] is = new int[]{1,2,3};\ndouble[] fs = is; // error!\ndouble[] fs = new double[3];\nfor (int i = 0; i < is.length; ++i) {\n fs[i] = is[i];\n}\nprintln(fs);\n```\n\n3.1.10.4 Try Catch Finally Action Block\n\nExecute the first action block. Catch exceptions thrown during executions that match the Throwable class in a catch clause. For the first match, execute the associated catch action block. Bind the Throwable class instance to the given identifier and make it available to the catch action block. Whether an exception is thrown in the try action block, execute the finally action block, if given.\n\nUncaught exceptions are printed as error messages when using the RL Language command-line and are thrown as RLExceptions when using a RuleSession's executeRuleset or callFunction methods. The try, catch, and finally in RL Language is like Java both in syntax and in semantics. There must be at least one catch or finally clause.\n\nFormat\n\n```\ntry ::= try action-block\n```\n\n```\n( catch (class-implementing-throwable identifier) action-block )* [ finally action-block ] class-implementing-throwable ::= qname`\nUsage Notes\n\nIn order to fully understand how to catch exceptions in RL Language, one must understand how the stack frames are nested during rule execution. Rules do not call other rules the way that functions or methods may call functions or methods. Therefore, you cannot use a catch block in one rule's action block to catch exceptions in another rule's action block. Exceptions thrown during rule firing must either be handled by the firing rule's action block, or must be handled by a caller to the `run`, `runUntilHalt`, or `step` functions that caused the rule to fire.\n\nExamples\n\nExample 3-39 shows the try catch and finally actions. The output from running this example is:\n\n```\nexception in invoked Java method\nthis is really bad!\nbut at least it's over!\n```\n\nNote that RL Language treats the explicitly thrown `Exception` (\"this is really bad!\") as an exception from an invoked Java method, and wraps the `Exception` in a `JavaException`. The explicitly thrown `Exception` is available as the cause of the `JavaException`.\n\nExample 3-39 Try Catch and Finally Action Blocks\n\n```\ntry {\n throw new Exception(\"this is really bad!\");\n} catch (Exception e) {\n println(e.getMessage());\n println(e.getCause().getMessage());\n} finally {\n println(\"but at least it's over!\");\n}\n```\n\n3.1.10.5 Synchronized Action Block\n\nAs in Java, the synchronized action is useful for synchronizing the actions of multiple threads. The synchronized action block lets you acquire the specified object's lock, then execute the `action-block`, then release the lock.\n\nFormat\n\n```\nsynchronized ::= synchronized object-primary-expression action-block\n```\n\nExample\n\nExample 3-40 changes the name of a `Person` object, adding old names to the nicknames, and synchronizes so that a concurrent reader of the Java object who is also synchronizing will see a consistent view of the `Person` (See Example 3-9 details on the `Person` bean).\n\nExample 3-40 Synchronized Action\n\n```\nimport example.Person; // this Java bean is defined in example J1\nfunction changeName(Person p, String first, String last) {\n synchronized(p) {\n java.util.Set s = p.getNicknames();\n s.add(p.getFirstName());\n }\n}\n```\n```java\ns.add(p.getLastName());\np.setFirstName(first);\np.setLastName(last);\n}\nassert(p);\n}\nPerson person = new Person(\"Elmer\", \"Fudd\", new String[]{\"Wabbit Wuver\"});\nprintln(person.nicknames.toArray());\nchangeName(person, \"Bugs\", \"Bunny\");\nprintln(person.nicknames.toArray());\n```\nif fact Customer c && c.pastYearSpend > 1000 {\n modify(c, status: \"gold\");\n}\n\nThis rule does not loop because the tested properties and modified properties are\ndisjoint. This rule can be used in an inference to fire subsequent rules that test for\nstatus=\"gold\".\n\n**Example 3-41 Example Showing Bad Rules Programming Practice to be Avoided**\n\nif fact Customer c && c.pastYearSpend > 1000 {\n c.status = \"gold\"\n}\n\n**Infinite Looping Rule**\n\nA second rule that illustrates infinite looping is the rule described as follows:\n\nGive Employees earning at least $50,000 a 5% raise.\n\nif Employee emp && emp.sal > 50000 {\n modify(emp, sal: sal * 1.05);\n}\n\nEven using modify, this rule will self-trigger because it is testing the same property\n(sal) that it is modifying, and the test is true after modification. To avoid looping in\nthis case, you could also add a raise property test, as follows:\n\nif Employee emp && emp.sal > 50000 && !emp.raise {\n modify(emp, sal: emp.sal * 1.05, raise: true);\n}\n\nAlternatively, to avoid looping in this case you could also add a fact to handle the\nraise. For example:\n\n```java\npublic class RaiseGiven\n{\n Employee emp; // or possibly just an employee ID\n}\n\nif Employee emp && emp.sal > 50000 && !RaiseGiven(emp: emp) {\n modify(emp, sal: sal * 1.05);\n assert(new RaiseGiven(emp: emp));\n}\n```\n\n### 3.1.10.7 Return Action\n\nThe return action returns from the action block of a function or a rule.\n\nA return action in a rule pops the ruleset stack, so that execution continues with the\nactivations on the agenda that are from the ruleset that is currently at the top of the\nruleset stack.\n\nIf rule execution was initiated with either the `run` or `step` functions, and a return action\npops the last ruleset from the ruleset stack, then control returns to the caller of the `run`\nor `step` function.\n\nIf rule execution was initiated with the `runUntilHalt` function, then a return action will\nnot pop the last ruleset from the ruleset stack. The last ruleset is popped with\n`runUntilHalt` when there are not any activations left. The Oracle Rules Engine then\nwaits for more activations to appear. When they do, it places the last ruleset on the\nruleset stack before resuming ruleset firing.\nFormat\n\n```\nreturn ::= return [ return-value ];\n\nreturn-value ::= expression\n```\n\nIf the function has a `returns` clause, then the `return-value` must be specified and it must be of the type specified by the `returns` clause.\n\nUsage Notes\n\nA return action in a rule or a function without a `returns` clause must not specify a `return-value`.\n\n### 3.1.10.8 Throw Action\n\nThrow an exception, which must be a Java object that implements `java.lang.Throwable`. A thrown exception may be caught by a `catch` in a `try` action block.\n\nFormat\n\n```\nthrow ::= throw throwable;\nthrowable ::= object-primary-expression\n```\n\n### 3.1.10.9 Assign Action\n\nAn assignment in RL Language, as in Java, is an expression that can appear as an action.\n\nFormat\n\n```\nassign ::= assignment-expression;\n\nassignment-expression ::= boolean-assignment | numeric-assignment | string-assignment | object-assignment | array-assignment\n```\n\nExample\n\nExample 3-42 shows the use of the RL Language assignment expression. This prints \"6 5\".\n\n**Example 3-42 Assignment Expression**\n\n```\nclear;\nint i = 1;\nint j = 2;\ni += j += 3;\nprintln(i + \" \" + j);\n```\n\n### 3.1.10.10 Increment or Decrement Expressions\n\nIncrement and decrement in RL Language, as in Java, are expressions that can appear as actions.\n\nFormat\n\n```\nincr-decr ::= incr-decr-expression;\n```\n\n```\nincr-decr-expression ::= ( ++ | -- ) numeric-target-expression | numeric-target-expression ( ++ | -- )\n\nExamples\n\nExample 3-43 shows the use of the RL Language decrement action. This example prints “0”.\n\nExample 3-43 Decrement Action\n\nclear;\nint i = 1;\n--i;\nprintln(i);\n\n3.1.10.11 Primary Actions\n\nA primary action is a primary expression such as a function call, assert, or Java method call executed for its side-effects. For example, the println function is often used as a primary action.\n\nFormat\n\nprimary-action ::= primary-expression ;\n\n3.1.11 Rulegroup\n\nA rulegroup provides support for decision table overrides. This supports the following decision table features: the ability for one rule to override one or more other rules\n\nFormat\n\nrulegroup ::= rulegroup rulegroup-name { rulegroup-property* ( rule | rulegroup )* } rulegroup-name ::= identifier rulegroup-property ::= mutex mutex ::= mutex = boolean-literal ;\n\nUsage Notes\n\nA rulegroup construct is a top level construct in a ruleset. A rulegroup has an optional boolean property:\n\n• mutex: The mutex property enables mutual exclusion between rules. The common case is that the rules reside in the same rulegroup that has set mutex to true. In more complex rulegroup hierarchies, two rules mutually exclude each other if their closest common ancestor rulegroup has mutex set to true. When a rules fires, existing activations for rules which it mutually excludes are removed from the agenda preventing them from firing. Theses activations must be directly related as identified by the set of facts that resulted in the activations being placed on the agenda. This leads to the requirement that the conditions of all rules that mutually exclude each other have the same fact clauses specified in the same order. This occurs naturally for decision tables.\n\nExample\n\nExample 3-44 demonstrates the use of rulegroups with the mutex property. Note that r2 and r3 reference the same set of fact types in the same order in the rule condition.\nThis is required within a mutex group. The tests in the patterns can be different. The restriction on the shape of the rule condition in a mutex group extends to its descendent groups. Thus, rules r4 and r5 also must reference the same set of fact types in the same order. Assume that one instance of A and one instance of B have been asserted and that r1, r2, r3, r4 and r5 have activations on the agenda. r3 will fire since it has a higher priority. The activation of r2 will be removed without firing since r2 is in a group with mutex=true. Since group2 is a member of group1, the activations of r4 and r5 will also be removed without firing. Rule r1 will fire. Now, assume that r2, r4, and r5 have activations on the agenda and assume that r4 fires first. The activation for r2 will be remove without firing since any rule in group2 firing mutually excludes both r2 and r3. r5 will fire. It is not mutually excluded since group2 does not have mutex=true.\n\n**Example 3-44 Ruleset with Rulegroup with Specified Fact Order of Reference**\n\n```\nruleset set1\n{\n rule r1 { ... }\n rulegroup group1\n {\n mutex = true;\n rule r2 { if fact A && fact B ... { ... }}\n rule r3 { priority = 2; if fact A && fact B ... { ... }}\n rulegroup group2\n {\n rule r4 { if fact A && fact B ... { ... }}\n rule r5 { if fact A && fact B ... { ... }}\n }\n }\n}\n```\n\n### 3.1.12 Built-in Functions\n\nThis section covers the following RL Language built-in functions:\n\n- assert, assertTree, assertXPath, clearRule, clearRulesetStack, clearWatchRules,\nclearWatchActivations, clearWatchFacts, clearWatchFocus,\nclearWatchCompilations, clearWatchAll, contains, getCurrentDate, getDecisionTrace,\ngetDecisionTraceLevel, getDecisionTraceLimit, getEffectiveDate, getFactsByType,\ngetRulesetStack, getRuleSession, getStrategy, halt, id,\nisErrorInRuleConditionSuppressedObject, println, popRuleset, pushRuleset, retract,\nreset, run, runUntilHalt, setCurrentDate, setDecisionTraceLevel,\nsetDecisionTraceLimit, setEffectiveDate, setRulesetStack, setStrategy,\nshowActivations, showFacts, step, watchRules, watchActivations, watchFacts,\nwatchFocus, watchCompilations\n\n#### 3.1.12.1 assert\n\nAdds a fact to working memory or updates a fact already in working memory based on the properties of the supplied object `obj`. If the supplied object `obj` is a Java instance, then properties are Java bean properties defined by an associated `BeanInfo` class or by the existence of getter and setter methods. If `obj` is an RL Language class instance, then the properties are the fields of the class.\n\n**Format**\n\n```java\nfunction assert(Object obj);\n```\nUsage Notes\n\nThe fact in working memory is a shadow of the supplied object obj, and this shadow contains a copy, clone, or reference to each property prop. If prop is a primitive type, then prop is copied to the shadow. If prop implements the Java Cloneable interface, then a clone, shallow copy, of prop is shadowed. Otherwise, only the reference to prop is shadowed. The more a shadow can copy its object’s properties, the better a rule with references to several facts can be optimized.\n\nNote that because == and != when applied to an Object in RL Language always invokes the Object equals method, whether a shadow contains copies, clones, or references is transparent to the RL Language program.\n\nAssert may affect the agenda. Rules whose conditions now return a fact set because of a new fact place activations on the agenda. Activations that test for non-existence of facts, using !, may be removed from the agenda. Updates to facts may affect the agenda. Activations whose rule conditions no longer match the changed facts are removed from the agenda. Rules whose conditions return a fact set because of the changed facts have activations placed on the agenda.\n\nAssert should be used to update the fact in working memory if any part of the obj’s state has been updated that could possibly have an effect on a rule condition, unless the obj is a Java bean that supports registering property change listeners, and all that is changed is the value of a bean property.\n\nExamples\n\nExample 3-45 prints, \"Pavi has highest salary 65000.0\" and Example 3-46 prints, \"dept 10 has no employees!\".\n\nExample 3-45 Using Assert Function in the highestSalary Rule\n\nclass Emp { String ename; double salary; }\nrule highestSalary {\n if (fact Emp hi && !(fact Emp e && e.salary > hi.salary))\n println(hi.ename + \" has highest salary \" + hi.salary);\n}\nEmp e1 = new Emp(ename: \"Pavi\", salary: 55000.00);\nassert(e1); // put in working memory\nEmp e2 = new Emp(ename: \"Fred\", salary: 60000.00);\nassert(e2); // put in working memory\ne1.salary += 10000.00; // Pavi is now the highest paid\nassert(e1); // MUST re-assert before allowing rules to fire\nrun();\n\nSample Assert Function\n\nExample 3-46 Using Assert Function in the emptyDept Rule\n\nimport java.util.*;\nclass Dept { int deptno; List emps = new ArrayList(); }\nrule emptyDept {\n if (fact Dept d && d.emps.isEmpty())\n println(\"dept \" + d.deptno + \" has no employees!\");\n}\nDept d = new Dept(deptno: 10);\nd.emps.add(e1);\nassert(d); // put in working memory with 1 employee\n3.1.12.2 assertTree\n\nThe assertTree built-in function asserts object in an object tree as facts.\nThe assertTree built-in function supports JAXB 2.0.\n\nFormat\n\nassertTree(Object root) assertTree(String spec, Object root)\n\nUsage Notes\n\nThere are two assertTree() signatures:\n\n• assertTree(Object root) is necessary with SDK2. This format traverses the object graph and asserts objects as directed by internal metadata generated by SDK2.\n\n• assertTree(String spec, Object root) is necessary when SDK2 is not involved. Similar to assertXPath, spec is a package specification enhanced to allow the specification of multiple packages separated by a colon. This format asserts objects and traverses the bean properties of an object if the object is in one of the specified packages. Typically, the package specification will be the same one used in establishing the JAXBContext.\n\nThe assertTree function does the following:\n\n• asserts objects starting with the root and every fact (object with a visible declared fact type) referenced from the root, recursively.\n\n• assert JAXBElement instances it encounters, extract the value class object it contains and continue.\n\nSee Also\n\nassert\n\n3.1.12.3 assertXPath\n\nThe assertXPath function is deprecated. Use assertTree instead.\n\nAdd a tree of facts to working memory using the specified element as the root and an XML xpath-like expression to define the objects in the tree. The pkg is the Java package or RL Language ruleset that contains the classes of objects in the tree. All objects in the tree must be in the same package or ruleset.\n\nIn addition to asserting \"element\" and selected descendants, XLink facts are asserted that link parent and child objects. The classes of all objects in the tree must use the supports xpath (supports) clause of the RL class (rl-class-definition) or fact-class declaration.\nFormat\nfunction assertXPath(String pkg, Object element, String xpath);\n\nSee Also\nassert, id, object, retract\n\n3.1.12.4 clearRule\nClears the named rule from the rule session. Removes all of the rule's activations from the agenda.\n\nFormat\nfunction clearRule(String name);\n\nSee Also\ngetRuleSession\n\n3.1.12.5 clearRulesetStack\nEmpties the ruleset stack.\n\nFormat\nfunction clearRulesetStack();\n\nSee Also\ngetRulesetStack, getStrategy, popRuleset, pushRuleset, run, setStrategy\n\n3.1.12.6 clearWatchRules, clearWatchActivations, clearWatchFacts, clearWatchFocus, clearWatchCompilations, clearWatchAll\nThe clearWatch functions stop printing debug information.\n\nFormat\nfunction clearWatchRules(); function clearWatchActivations(); function clearWatchFacts(); function clearWatchFocus(); function clearWatchCompilations(); function clearWatchAll();\n\nSee Also\nwatchRules_ watchActivations_ watchFacts_ watchFocus_ watchCompilations\n\n3.1.12.7 contains\nThe contains() function is similar to the contains() method on Java Collection but with includes the ability to handle the presence of JAXBElemen in the collection.\n\nFormat\ncontains(Collection c, Object o) returns boolean\nUsage\nWhen contains() encounters a JAXBElement in the collection c, it obtains the value class from the JAXBElement and compares it to the Object o.\n\nSee Also\nassertTree\n\n3.1.12.8 getCurrentDate\n\nThe getCurrentDate function returns the date associated with the CurrentDate fact.\n\nFormat\ngetCurrentDate() returns Calendar\n\nUsage Notes\nThe effective date and the current date are two orthogonal items. The effective date is used to determine which rules are in affect according to the start and end effective date properties. The CurrentDate fact allows reasoning on a rules engine managed fact representing the \"current\" date.\n\nSetting the current date does not affect the effective date semantics.\n\nIf you want to create rules to reason on the date explicitly in the rules, then use the CurrentDate fact. If you want to assign start and or end effective dates to rules and have the rules in effect determined from a date in the data, then use setEffectiveDate().\n\nSee Also\nsetCurrentDate, getEffectiveDate, setEffectiveDate\n\n3.1.12.9 getDecisionTrace\n\nReturns the current trace and starts a new trace.\n\nFormat\ngetDecisionTrace() returns DecisionTrace\n\nUsage Notes\n\nSee Also\ngetDecisionTraceLevel, getDecisionTraceLevel, watchRules, watchActivations, watchFacts, watchFocus, watchCompilations\n\n3.1.12.10 getDecisionTraceLevel\n\nGets the current decision trace level.\n\nFormat\ngetDecisionTraceLevel() returns int\nUsage Notes\n\nSupported decision trace levels include the following levels:\n\n- Off: decision tracing is disabled. This is defined as RuleSession.DECISION_TRACE_OFF.\n- Production: rules fired are shown in trace. This is defined as RuleSession.DECISION_TRACE_PRODUCTION.\n- Development: full decision tracing similar in detail to watchAll(). This is defined as RuleSession.DECISION_TRACE DEVELOPMENT.\n\nSee Also\n\ngetDecisionTrace, getDecisionTraceLimit, watchRules_ watchActivations_ watchFacts_ watchFocus_ watchCompilations\n\n3.1.12.11 getDecisionTraceLimit\n\nReturns the current limit on the number of events in a trace.\n\nFormat\n\ngetDecisionTraceLimit() returns int\n\nUsage Notes\n\nSee Also\n\ngetDecisionTrace, getDecisionTraceLevel\n\n3.1.12.12 getEffectiveDate\n\nThe getEffectiveDate function returns the current value of the effective date.\n\nFormat\n\ngetEffectiveDate() returns Calendar\n\nUsage Notes\n\nThe effective date and the current date are two orthogonal items. The effective date is used to determine which rules are in affect according to the start and end effective date properties. The CurrentDate fact allows reasoning on a engine managed fact representing the \"current\" date. Both may be set explicitly.\n\nSetting the current date does not affect the effective date semantics. Setting the effective date does not affect the CurrentDate fact.\n\nIf you want to create rules to reason on the date explicitly in the rules, then use the CurrentDate (setCurrentDate()). If you want to assign start and or end effective dates to rules and have the rules in effect determined from a date in the data, then use setEffectiveDate().\n\nSee Also\n\nsetEffectiveDate, getCurrentDate, setCurrentDate\n3.1.12.13 getFactByType\n\nThis function returns an instance of the fact type identified by className if exactly one instance exists in working memory. If no existence exists, null is returned. If more than one instance of the fact type exists in working memory an exception is thrown.\n\nFormat\n\nfunction getFactByType(String className) returns Object\n\nSee Also\n\nshowFacts\n\n3.1.12.14 getFactsByType\n\nReturns a list of all facts in working memory that are instances of a specified class.\n\nFormat\n\nfunction getFactsByType(String className) returns List\n\nSee Also\n\nshowFacts, watchRules, watchActivations, watchFacts, watchFocus, watchCompilations\n\n3.1.12.15 getRulesetStack\n\nReturns the ruleset stack as an array of ruleset names.\n\nFormat\n\nfunction getRulesetStack() returns String[];\n\nUsage Notes\n\nReturns: the ruleset stack as an array of ruleset names.\n\nEntry 0, the top of the stack, is the focus ruleset. The focus ruleset is the ruleset whose activations are fired first by a subsequent run, runUntilHalt, or step function execution.\n\nSee Also\n\nclearRulesetStack, getStrategy, popRuleset, pushRuleset, setRulesetStack, setStrategy\n\n3.1.12.16 getRuleSession\n\nReturns a Java RuleSession object. An RL Language program could use this RuleSession to dynamically define new classes, rules, functions, or variables.\n\nFormat\n\nfunction getRuleSession() returns RuleSession;\nExample\n\nrule learn {\n if (fact f1 & & ...) {\n RuleSession rs = getRuleSession();\n rs.executeRuleset(\"rule newRule { if fact f1 & & fact f2 & & ... { ... } }\");\n }\n}\n\nSee Also\nclearRule\n\n3.1.12.17 getStrategy\n\nReturns the current strategy. Table 3-7 shows the possible strategy values.\n\nFormat\n\nfunction getStrategy() returns String;\n\nSee Also\nclearRulesetStack, getRulesetStack, popRuleset, pushRuleset, setStrategy\n\n3.1.12.18 halt\n\nThe halt function halts execution of the currently firing rule, and returns control to the run, runUntilHalt, or step function that caused the halted rule to run. The agenda is left intact, so that a subsequent run, runUntilHalt, or step can be executed to resume rule firings.\n\nThe halt function has no effect if it is invoked outside the context of a run, runUntilHalt, or step function.\n\nFormat\n\nfunction halt();\n\nSee Also\nreset, run, runUntilHalt, step\n\n3.1.12.19 id\n\nReturn the fact id associated with the object obj. If obj is not associated with a fact, returns -1.\n\nFormat\n\nfunction id(Object obj) returns int;\n\nSee Also\nassert, object, retract\n3.1.12.20 isErrorInRuleConditionSuppressed\n\nError suppression happens at each test in the rule condition. Each test is evaluated separately and if an error happens during the evaluation and error suppression is enabled, the error is suppressed. When an error occurs during the evaluation of a test, it means that the result of the test is unknown. Internally, the rule engine uses three-valued logic to represent this state (true/false/unknown, see http://en.wikipedia.org/wiki/Three-valued_logic). When a true/false value is required, a value of unknown is mapped to false.\n\nErrors in a test can either be in the RL domain (detected by the engine) or in the Java domain (thrown by a Java method invoked in the test). In the RL domain, RLLNullPointerException, an attempt to de-reference a null object reference in an RL expression, is the most common error. RLAithmeticException (integer divide by 0) and RLIlegalArgumentException are infrequent. RLAArrayIndexOutOfBoundsException, RLCastCastException, and RLCCloneNotSupportedException are rare.\n\nJava domain exceptions are those thrown by a Java method invoked from the rule condition. Those exceptions are wrapped in an RL exception, JavaException with the exception thrown by the method available via getCause(). When an exception is thrown by a Java method the engine can not make any further distinction. For example, it is possible that a null value passed to the method caused the method to throw an exception but the rule engine has no way to know whether or not the null was the cause.\n\nError suppression can be controlled by invoking a built-in function. A common place to invoke it is in the initial actions of a decision function.\n\n**Format**\n\nisErrorInRuleConditionSuppressed() returns boolean\n\n**Usage Notes**\n\nThe RL signature is: isErrorInRuleConditionSuppressed() returns boolean.\n\n**See Also**\n\nsetErrorInRuleConditionSuppressed\n\n3.1.12.21 isRulesetsOnStackOnce\n\nReturns the current value of this rule execution setting.\n\n**Format**\n\nfunction isRulesetsOnStackOnce() returns boolean\n\n**See Also**\n\nsetRulesetsOnStack\n\n3.1.12.22 object\n\nReturn the object associated with the given fact id. If there is no such fact id, returns null.\n**Format**\n\nfunction object(int factId) returns Object;\n\n**See Also**\n\nassert, id, retract\n\n### 3.1.12.23 println\n\nPrint the given value to the RuleSession output writer.\n\n**Format**\n\nfunction println(char c);\nfunction println(char[] ca);\nfunction println(int i);\nfunction println(long l);\nfunction println(float f);\nfunction println(double d);\nfunction println(boolean b);\nfunction println(Object obj);\n\n### 3.1.12.24 popRuleset\n\nIf the stack is empty, `popRuleset` throws `RLRuntimeException`. If the stack is not empty, `popRuleset` pops the focus off the stack and returns it.\n\nAll entries are shifted down one position, and the new focus is the new top of stack, entry 0.\n\nEntry 0, the top of the stack, is the focus ruleset. The focus ruleset is the ruleset whose activations are fired first by a subsequent `run`, `runUntilHalt`, or `step` function execution.\n\n**Format**\n\nfunction popRuleset() returns String;\n\n**Example 3-47 Using popRuleset and Throwing RLRuntimeException**\n\n```java\nclearRulesetStack();\npopRuleset(); // RLRuntimeException\n```\n\n**See Also**\n\nclearRulesetStack, getRulesetStack, getStrategy, pushRuleset, setStrategy\n\n### 3.1.12.25 pushRuleset\n\nPush the given ruleset onto the stack and make it the focus. It is an error to push a ruleset that is already the focus (`RLIllegalArgumentException` is thrown for this error).\nEntry 0, the top of the stack, is the focus ruleset. The focus ruleset is the ruleset whose activations are fired first by a subsequent run, runUntilHalt, or step function execution.\n\n**Format**\n\nfunction pushRuleset(String focus);\n\n**Examples**\n\nExample 3-48 shows the RL Language using the pushRuleset function. Example 3-49 shows the RL Language using the popRuleset function.\n\n**Example 3-48 Using pushRuleset - Throws RLIllegalArgumentException**\n\nclearRulesetStack();\npushRuleset(\"main\"); // focus is \"main\"\npushRuleset(\"main\"); // RLIllegalArgumentException\n\n**Example 3-49 Using popRuleset - Throws RLRuntimeException**\n\nclearRulesetStack();\npopRuleset(); // RLRuntimeException\n\n**See Also**\n\nclearRulesetStack, getRulesetStack, getStrategy, popRuleset, setStrategy\n\n### 3.1.12.26 retract\n\nRemove the fact associated with the object obj from working memory.\n\n**Format**\n\nfunction retract(Object obj);\n\n**Usage Notes**\n\nRetract may affect the agenda. Activations that depend on the retracted fact are removed from the agenda.\n\nNote, rules that have conditions that test for non-existence of facts (using !) may place new activations on the agenda.\n\n**See Also**\n\nassert, id, object\n\n### 3.1.12.27 reset\n\nClears all facts from working memory, clears all activations from the agenda, and reevaluates non-final global variable initialization expressions.\n\n**Format**\n\nfunction reset();\n3.1.12.28 run\n\nFire rule activations on the agenda until:\n\n- A rule action calls `halt` directly or indirectly. For example, when `halt` is called by a function called by a rule action.\n- The agenda is empty.\n- The ruleset stack is empty.\n\n**Format**\n\n```plaintext\nfunction run() returns int;\nfunction run(String rulesetName) returns int;\n```\n\n**Usage Notes**\n\n- If the argument, `rulesetName` is supplied, the named ruleset is pushed on the top of the ruleset stack before firing any rules.\n- If a null `rulesetName` is supplied, the ruleset stack is not modified before firing rules.\n- If no `rulesetName` is supplied and the default `main` ruleset is not on the ruleset stack, then the `main` ruleset is placed at the bottom of the ruleset stack before firing any rules.\n\nReturns: `int`, the number of rules fired.\n\n**See Also**\n\n`halt`, `reset`, `runUntilHalt`, `step`\n\n3.1.12.29 runUntilHalt\n\nThis function fires rule activations until `halt` is called. Unlike `run` and `step`, `runUntilHalt` does not return when the agenda is empty. Also, `runUntilHalt` does not pop the bottommost ruleset name from the ruleset stack. Instead, it waits for the agenda to contain activations.\n\n**Format**\n\n```plaintext\nfunction runUntilHalt() returns int;\n```\n\n**Usage Notes**\n\nThe only way for activations to be added to the agenda while the main RuleSession thread is busy executing `runUntilHalt` is for a second thread to either:\n\n1. Modify Java bean facts with `PropertyChangeListeners`.\n2. Execute `assert` or `retract` functions.\n\nRules must be designed carefully when using `runUntilHalt`. For example, a rule that attempts to find a fact with the minimum value of a property will fire when the first\ninstance of the fact is asserted, and then every time another instance is asserted with a lower valued property.\n\n**See Also**\n\nhalt, reset, run, step\n\n### 3.1.12.30 setCurrentDate\n\nThe `setCurrentDate` function sets the date for reasoning on an engine managed fact representing the \"current\" date (with the `CurrentDate` fact).\n\n**Format**\n\n`setCurrentDate(Calendar newDate)`\n\n**Usage Notes**\n\nThe `RLIllegalArgumentException` exception is thrown if the `newDate` argument is null.\n\nIf you need to reason on the date explicitly in the rules, then use the `CurrentDate` fact. If you want to assign start and end effective dates to rules and have the rules in effect determined from a date in the data, then they should use `setEffectiveDate`. The `setEffectiveDate` function does not affect the `CurrentDate` fact.\n\nBy default the value of the current date is managed implicitly by the rules engine. The value of the `CurrentDate` fact is updated to the current system date and (re)asserted internally when a run family of built-in functions is invoked. This is done before any rules fire so that the new current date is evaluated in rule conditions. In the case of `runUntilHalt`, this update occurs each time there is a transition from 0 rules on the agenda to > 0 rules on the agenda.\n\nAfter the user invokes the `setCurrentDate` function, it becomes the responsibility of the user to update the current date as required. The rules engine no longer manages it implicitly. This remains in effect until the reset function is invoked. After the current date is set explicitly with `setCurrentDate`, any invocation of `setCurrentDate` function that would result in time going backward, set to an earlier point in time, is an error and an `RLIllegalArgumentException` is thrown. After the reset function is invoked, the current date may be set to any value.\n\n**See Also**\n\n`getCurrentDate`, `getEffectiveDate`, `setEffectiveDate`\n\n### 3.1.12.31 setDecisionTraceLevel\n\nSets the decision trace level to the specified level.\n\n**Format**\n\n`setDecisionTraceLevel(int level)`\n\n**Usage Notes**\n\nSupported decision trace levels include the following levels:\n• Off: decision tracing is disabled. This is defined as `RuleSession.DECISION_TRACE_OFF`.\n\n• Production: rules fired are shown in trace. This is defined as `RuleSession.DECISION_TRACE_PRODUCTION`.\n\n• Development: full decision tracing similar in detail to `watchAll()`. This is defined as `RuleSession.DECISION_TRACE_DEVELOPMENT`.\n\n**See Also**\n\n`getDecisionTrace`, `getDecisionTraceLevel`, `getDecisionTraceLevel`, `setDecisionTraceLimit`, `watchRules`, `watchActivations`, `watchFacts`, `watchFocus`, `watchCompilations`\n\n### 3.1.12.32 setDecisionTraceLimit\n\nSets the limit on the number of events in a trace.\n\n**Format**\n\n```java\nsetDecisionTraceLimit(int count)\n```\n\n**Usage Notes**\n\nThe default value is 10000.\n\n**See Also**\n\n`getDecisionTrace`, `getDecisionTraceLevel`, `getDecisionTraceLevel`, `setDecisionTraceLimit` \n`watchRules`, `watchActivations`, `watchFacts`, `watchFocus`, `watchCompilations`\n\n### 3.1.12.33 setEffectiveDate\n\nThe `setEffectiveDate` function updates the effective date in the rules engine.\n\nBy default, the value of the effective date is managed implicitly by the rules engine. In this case, when a run family of built-in functions is invoked the effective date is updated to the current system date. This is done before any rules fire so that the new effective date is applied before rules begin to fire. In the case of `runUntilHalt`, this update occurs each time there is a transition from 0 rule activations on the agenda to > 0 rule activations on the agenda.\n\n**Format**\n\n```java\nsetEffectiveDate(Calendar newDate)\n```\n\n**Usage Notes**\n\nInvoking `setEffectiveDate` is the only way that you can alter the effective date. After the reset function is invoked, the effective date may be set to any value.\n\nThe `RLIllegalArgumentException` exception is thrown if the `newDate` argument is null.\n\nAfter you invoke the `setEffectiveDate` function, it becomes the responsibility of the application to update the effective date as required. The rules engine no longer manages it implicitly.\nThis remains in effect until the reset function is invoked. This is useful for debugging, performing rule evaluation at a \"point in time\", or other use cases that require application control of the effective date.\n\nSee Also\ngteEffectiveDate, getCurrentDate, setCurrentDate\n\n3.1.12.34 setErrorInRuleConditionSuppressed\n\nError suppression happens at each test in the rule condition. Each test is evaluated separately and if an error happens during the evaluation and error suppression is enabled, the error is suppressed. When an error occurs during the evaluation of a test, it means that the result of the test is unknown. Internally, the rule engine uses three-valued logic to represent this state (true/false/unknown, see http://en.wikipedia.org/wiki/Three-valued_logic). When a true/false value is required, a value of unknown is mapped to false.\n\nErrors in a test can either be in the RL domain (detected by the engine) or in the Java domain (thrown by a Java method invoked in the test). In the RL domain, RLNullPointerException, an attempt to de-reference a null object reference in an RL expression, is the most common error. RLArithmeticException (integer divide by 0) and RLIllegalArgumentException are infrequent. RLArrayIndexOutOfBoundsException, RLClassCastException, and RLCloneNotSupportedException are rare.\n\nJava domain exceptions are those thrown by a Java method invoked from the rule condition. Those exceptions are wrapped in an RL exception, JavaException with the exception thrown by the method available via getCause(). When an exception is thrown by a Java method the engine can not make any further distinction. For example, it is possible that a null value passed to the method caused the method to throw an exception but the rule engine has no way to know whether or not the null was the cause.\n\nError suppression can be controlled by invoking a built-in function. A common place to invoke it is in the initial actions of a decision function.\n\nFormat\nsetErrorInRuleConditionSuppressed(boolean bv) returns boolean\n\nUsage Notes\nThe RL signature is: setErrorInRuleConditionSuppressed(boolean bv) returns boolean. Passing a value of true will enable error suppression. The return value is the previous setting.\n\nThe current setting can be queried with the isErrorInRuleConditionSuppressed built-in function.\n\nSee Also\nisErrorInRuleConditionSuppressed\n\n3.1.12.35 setRulesetStack\n\nSets the ruleset stack to the given array of ruleset names.\nEntry 0, the top of the stack, is the focus ruleset, which is the ruleset whose activations will be fired first by a subsequent `run, runUntilHalt, or step` function execution.\n\nFormat\n\nfunction setRulesetStack(String[] rulesetStack)\n\nSee Also\n\nclearRulesetStack, getRulesetStack, getStrategy, popRuleset, pushRuleset, setStrategy\n\n3.1.12.36 setRulesetsOnStack\n\nInvoking this function with a value of true indicates that the rulesets pushed onto the stack will only be pushed onto the stack once during a rule execution. The previous value is returned. The default value is false.\n\nFormat\n\nfunction setRulesetsOnStackOnce(boolean bv) returns boolean\n\nSee Also\n\nisRulesetsOnStackOnce\n\n3.1.12.37 setStrategy\n\nStrategy specifies the order in which activations from the same ruleset and with the same priority are executed. Table 3-7 shows the valid strategy values.\n\n<table>\n<thead>\n<tr>\n<th>Strategy</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>queue</td>\n<td>Activations are fired in order from oldest to newest.</td>\n</tr>\n<tr>\n<td>stack</td>\n<td>Activations are fired in order from newest to oldest.</td>\n</tr>\n</tbody>\n</table>\n\nFormat\n\nfunction setStrategy(String strategy);\n\nSee Also\n\nclearRulesetStack, getRulesetStack, getStrategy, popRuleset, pushRuleset\n\n3.1.12.38 showActivations\n\nThe show functions print rule session state to the output Writer. State that can be shown is: Activations all activations on the agenda\n\nFormat\n\nfunction showActivations();\n### See Also\n\nclearWatchRules_ clearWatchActivations_ clearWatchFacts_ clearWatchFocus_\nclearWatchCompilations_ clearWatchAll, showFacts, watchRules_ watchActivations_\nwatchFacts_ watchFocus_ watchCompilations\n\n#### 3.1.12.39 showFacts\n\nThe show functions print rule session state to the output Writer. State that can be shown is: all facts in working memory.\n\n**Format**\n\nfunction showFacts();\n\n**See Also**\n\nclearWatchRules_ clearWatchActivations_ clearWatchFacts_ clearWatchFocus_\nclearWatchCompilations_ clearWatchAll, showActivations, watchRules_ watchActivations_\nwatchFacts_ watchFocus_ watchCompilations\n\n#### 3.1.12.40 step\n\nFire rule activations on the agenda until:\n\n- The specified number of rule activations, `numRulesToFire` have been fired.\n- A rule action calls halt directly or indirectly. For example, by a function called by a rule action.\n- The agenda is empty.\n- The ruleset stack is empty.\n\n**Format**\n\nfunction step(int numRulesToFire) returns int;\n\nfunction step(int numRulesToFire, String rulesetName) returns int;\n\nfunction step(int numRulesToFire, boolean errorIfLimitHit) returns int;\n\nfunction step(int numRulesToFire, String rulesetName, boolean errorIfLimitHit) returns int;\n\n**Usage Notes**\n\nIf no ruleset name is supplied and the main ruleset is not on the ruleset stack, then the main ruleset is placed at the bottom of the ruleset stack before firing any rules.\n\nIf a ruleset named, `rulesetName`, is supplied, the specified ruleset is pushed on the top of the ruleset stack before firing any rules. If a null ruleset name is supplied, the ruleset stack is not modified before firing rules.\n\nReturns the integer number of rules fired.\n\nThe last two signatures allow the caller to specify whether hitting the firing limit (`numRulesToFire`) should be treated as an error condition or not. The default is false, it is not an error condition to hit the limit.\nInvoking the step function with a value of true for the errorIfLimitHit argument can be used to catch infinite rule firing loops that can occur due to a bug in the rules as written.\n\nSee Also\nhalt, reset, run, runUntilHalt\n\n3.1.12.41 watchRules, watchActivations, watchFacts, watchFocus, watchCompilations\n\nThe watch functions turn on printing of information about important rule session events. The information is printed to the output Writer whenever the events occur. Use a clearWatch function to turn off printing.\n\nTable 3-8 describes the available debugging information.\n\n<table>\n<thead>\n<tr>\n<th>Debug Watch</th>\n<th>Rule Session Event Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>watch</td>\n<td>Rule session event description</td>\n</tr>\n<tr>\n<td>Rules</td>\n<td>Information about rule firings (execution of activations)</td>\n</tr>\n<tr>\n<td>Activations</td>\n<td>Addition or removal of activations from the agenda</td>\n</tr>\n<tr>\n<td>Facts</td>\n<td>Assertion, retraction, or modification of facts in working memory</td>\n</tr>\n<tr>\n<td>Focus</td>\n<td>Pushing or popping of the ruleset stack. The top of the ruleset stack is called the focus ruleset, and all activations on the agenda from the focus ruleset will be fired before the focus is popped and the next ruleset on the stack becomes the focus.</td>\n</tr>\n<tr>\n<td>Compilations</td>\n<td>When a rule's conditions are added to the rete network, information about how the condition parts are shared with existing rules is printed. "=" indicates sharing. The order that rules are defined can affect sharing and thus can affect performance.</td>\n</tr>\n<tr>\n<td>All</td>\n<td>Includes information shown with watch Rules, watch Activations, watch Facts, watch Compilations and watch Focus.</td>\n</tr>\n</tbody>\n</table>\n\nFormat\n\nfunction watchRules();\nfunction watchActivations();\nfunction watchFacts();\nfunction watchFocus();\nfunction watchCompilations();\nfunction watchAll();\n\nSee Also\nclearWatchRules, clearWatchActivations, clearWatchFacts, clearWatchFocus, clearWatchCompilations, clearWatchAll, showActivations, showFacts\nThis chapter describes the RL command-line that reads rulesets from System.in and writes output from the functions println, watch, and, show to System.out.\n\nThe chapter includes the following topics:\n\n- Starting and Using the Command-Line Interface\n- RL Command-Line Options\n- RL Command-Line Built-in Commands\n\n4.1 Starting and Using the Command-Line Interface\n\nThe following invocation provides a simple command-line interface, with the prompt, RL>.\n\nExample without Java Beans:\n\n```java\njava -jar SOA_ORACLE_HOME/soa/modules/oracle.rules_11.1.1/rl.jar -p \"RL> \"\n```\n\nWhere SOA_ORACLE_HOME is where SOA modules are installed (for example, c:/Oracle/Middleware). The -p option specifies the prompt.\n\nThe following shows how an RL Language command-line can be started that can access this Java bean:\n\n```java\njava -classpath SOA_ORACLE_HOME/soa/modules/oracle.rules_11.1.1/rl.jar;BeanPath oracle.rules.rl.session.CommandLine -p \"RL> \"\n```\n\nWhere BeanPath is the classpath component to any supplied Java Bean classes.\n\nTo exit the command-line interface, use the special action exit; at the command prompt. The exit; action cannot be in an included ruleset. Alternatively, to exit you can invoke the System.exit(int) method in any action.\n\nThe RL command-line interface accumulates input line by line, and interprets the input when the input stream includes either:\n\n- A complete named ruleset\n- One or more complete import, include, ruleset, definition, action commands within an unnamed ruleset.\nNote:\n\nThe if, else and try, catch, and finally actions require lookahead to determine where they end. In order to execute an if without an else clause, or a try without a finally clause at the RL command-line, you should add a semicolon terminator.\n\nThis is not necessary if you execute RL using include, or using the RuleSession API.\n\nThe following code example shows a sample RL command-line input processing:\n\n```java\nRL> int i = 1;\nRL> if (i > 0) {println(\"i positive\");}\n// nothing happens - waiting for possible \"else\"\n;\ni positive\nRL>\n```\n\nInput must be complete at the end of a line. For example, if an action ends in the middle of a line, then that action is not interpreted until some following action is complete at the end of a line.\n\n**Example 4-1 Sample Command-Line Input Processing - Waiting for End of Line**\n\n```java\nRL> println(\"delayed\"); println(\"hello\"); println(\"world\");\ndelayed\nhello\nworld\nRL>\n```\n\n### 4.1.1 Using Command-Line Input Processing\n\nNotes for using command-line input processing:\n\n1. The command-line segments its input into blocks and then feeds each block to the interpreter. If you never type a closing brace or semicolon, no error is raised because the command line waits for input before it does a full parse of the block.\n\n2. The command-line interpreter, when used interactively or with the –i option, collapses the input, for line numbering purposes, into \"small\" rulesets ending at a newline. Errors are reported with numbers within the ruleset.\n\nFor example, if the input consists of the following:\n\n```java\nint i = 0; i = 1; // this is a ruleset\ni = \"1\"; // this is another ruleset\n```\n\nFor this example, command-line reports an error as follows:\n\n```\nOracle Business Rules RL: type check error\nConversionException: cannot convert from type 'java.lang.String' to type 'int'\nat line 1 column 5 in main\n```\n\nTo avoid this behavior, you can explicitly enclose the input in a ruleset. For example,\nNow, the error is on line 3 or, you can include the input file using an include.\n\n### 4.2 RL Command-Line Options\n\nThe following table provides a description of the RL command line options.\n\n<table>\n<thead>\n<tr>\n<th>Flag</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-i</td>\n<td>Read rulesets from the file named by the next argument, instead of from the default, System.in. For example, -i myInput.rl</td>\n</tr>\n</tbody>\n</table>\n\nNote: the command-line segments its input into blocks and then feeds each block to the interpreter. If the file myInput.rl does not include a closing brace or semicolon at the end, then no error is raised because the command line waits for additional input before it does a full parse of the block. Thus, there are cases where an incomplete input file supplied using the –i option could run and execute the valid part of the code from the file myInput.rl, and exit, while still waiting for command line input.\n\n<table>\n<thead>\n<tr>\n<th>Flag</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-c</td>\n<td>Executes the next argument as the first RL command, then start reading input. This option is useful to include a file of settings and functions for debugging. For example, -c "include file:debugSettings.rl;" If you do not want to read from the input after executing the command, include "exit;" after the command. For example, -c "include file:script.rl; exit;"</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Flag</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-p</td>\n<td>Sets the next argument as the prompt string. For example, -p "RL> "</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Flag</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-o</td>\n<td>Specifies where to write output from println, watch, and show to the file named by the next argument, instead of to System.out. For example: -o debug.log</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Flag</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>-v</td>\n<td>Print version information.</td>\n</tr>\n</tbody>\n</table>\n\n### 4.3 RL Command-Line Built-in Commands\n\nThis section lists commands that are implemented by the RL command-line interface (these commands are not part of RL).\nThus, these commands cannot appear in blocks or be included rulesets.\n\n4.3.1 Clear Command\n\nDiscard the current RuleSession object and allocate a new one. The effect is that all rules, variables, classes, and functions are discarded.\n\nInstead of using `clear;` to restart a command-line you can also type `exit;` and then reissue the Java command to start another command-line.\n\n4.3.2 Exit Command\n\nExit the command-line interface. The command-line interface also exits when end-of-file is reached on its input.\nThis chapter describes how to use a RulesSession object. The chapter includes the following sections:\n\n- RuleSession Constructor Properties\n- RuleSession Methods\n- RL to Java Type Conversion\n- Error Handling\n- RL Class Reflection\n- Obtaining Results from a Rule Enabled Program\n- Debugging an RL Stacktrace\n- Using RuleSession Pooling\n- Using RuleSession Options\n- Using Decision Tracing\n\n5.1 RuleSession Constructor Properties\n\nThis section shows you the steps for creating a rule enabled application and describes using a RuleSession object. The package oracle.rules.rl contains the RuleSession object.\n\nThe RuleSession no argument constructor returns a RuleSession with the default locale and logging options set.\n\nTable 5-1 describes the configuration parameters that can be set in a Map passed to the RuleSession constructor.\n\n<table>\n<thead>\n<tr>\n<th>Parameter Key</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>CFG_LOGGING</td>\n<td>Boolean. True enables logging. False disables logging. The default is true.</td>\n</tr>\n<tr>\n<td>CFG_LOCALE</td>\n<td>The Locale instance for the desired locale. The default is the JVM default locale.</td>\n</tr>\n</tbody>\n</table>\nTable 5-1 (Cont.) Configuration Parameters for a RuleSession Constructor\n\n<table>\n<thead>\n<tr>\n<th>Parameter Key</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>CFG_WATCH</td>\n<td>The desired setting for the watch raw activity trace facility. The setting is restored when the session is reset.</td>\n</tr>\n<tr>\n<td></td>\n<td>WATCH_RULES: watch rules that fire.</td>\n</tr>\n<tr>\n<td></td>\n<td>WATCH_ACTIVATIONS: watch rule activations and deactivations.</td>\n</tr>\n<tr>\n<td></td>\n<td>WATCH_FACTS: watch fact operations assert, modify, retract.</td>\n</tr>\n<tr>\n<td></td>\n<td>WATCH_FOCUS: watch ruleset stack changes.</td>\n</tr>\n<tr>\n<td></td>\n<td>WATCH_COMPILATION: watch rule definition.</td>\n</tr>\n<tr>\n<td></td>\n<td>WATCH_ALL: watch all of the above.</td>\n</tr>\n<tr>\n<td></td>\n<td>The default is that no trace settings are enabled.</td>\n</tr>\n<tr>\n<td>CFG_DECISION_TRACE_LVL</td>\n<td>Sets the decision trace level which controls the rule engine activity traced. This level is restored when the session is reset.</td>\n</tr>\n<tr>\n<td></td>\n<td>DECISION_TRACE_OFF: disables all decision tracing.</td>\n</tr>\n<tr>\n<td></td>\n<td>DECISION_TRACE_PRODUCTION: traces rules that fire.</td>\n</tr>\n<tr>\n<td></td>\n<td>DECISION_TRACE_DEVELOPMENT: detailed decision tracing. Equivalent to WATCH_ALL plus tracing of reset.</td>\n</tr>\n<tr>\n<td></td>\n<td>The default is DECISION_TRACE_OFF.</td>\n</tr>\n<tr>\n<td>CFG_DECISION_TRACE_LIM</td>\n<td>An integer that sets the limit on the number of trace entries that will be kept internally until the trace is retrieved.</td>\n</tr>\n<tr>\n<td></td>\n<td>The default decision trace limit is 10000.</td>\n</tr>\n</tbody>\n</table>\n\n5.2 RuleSession Methods\n\nThe `outputWriter` property determines where `println`, `watch`, and `show` output goes.\n\nThe `rulesetName` property sets the ruleset when RL statements are executed without an explicit named ruleset. The default rulesetName is `main`.\n\nThe `executeRuleset` methods parse and execute the given ruleset text (given as a String or a `java.io.Reader`).\n\nThe `callFunction` method invokes the named RL function (which must either be a built-in RL function or must have been previously defined with no parameters using one of the `executeRuleset` methods) and returns its result. Functions with a single argument can be invoked with the `callFunctionWithArgument` method. Functions taking any number of arguments can be called using the `callFunctionWithArgumentList` or `callFunctionWithArgumentArray` methods. The argument List or array must contain a Java Object for each RL function parameter.\n\n5.3 RL to Java Type Conversion\n\nThe following table describes how Java Object types are be converted to RL types for passing arguments to RL functions.\n\nTable Table 5-2 describes how Java Object types are be converted to RL types for passing arguments to RL functions, and conversely how RL types are converted to Java types for passing the RL function return value to Java.\n### Table 5-2 RL to Java Object Conversion\n\n<table>\n<thead>\n<tr>\n<th>Java Class</th>\n<th>RL Type</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>java.lang.Integer</td>\n<td>int</td>\n</tr>\n<tr>\n<td>java.lang.Character</td>\n<td>char</td>\n</tr>\n<tr>\n<td>java.lang.Byte</td>\n<td>byte</td>\n</tr>\n<tr>\n<td>java.lang.Short</td>\n<td>short</td>\n</tr>\n<tr>\n<td>java.lang.Long</td>\n<td>long</td>\n</tr>\n<tr>\n<td>java.lang.Double</td>\n<td>double</td>\n</tr>\n<tr>\n<td>java.lang.Float</td>\n<td>float</td>\n</tr>\n<tr>\n<td>java.lang.Boolean</td>\n<td>boolean</td>\n</tr>\n<tr>\n<td>Object</td>\n<td>Object</td>\n</tr>\n<tr>\n<td>int[]</td>\n<td>int[]</td>\n</tr>\n<tr>\n<td>char[]</td>\n<td>char[]</td>\n</tr>\n<tr>\n<td>byte[]</td>\n<td>byte[]</td>\n</tr>\n<tr>\n<td>short[]</td>\n<td>short[]</td>\n</tr>\n<tr>\n<td>long[]</td>\n<td>long[]</td>\n</tr>\n<tr>\n<td>double[]</td>\n<td>double[]</td>\n</tr>\n<tr>\n<td>float[]</td>\n<td>float[]</td>\n</tr>\n<tr>\n<td>boolean[]</td>\n<td>boolean</td>\n</tr>\n<tr>\n<td>Object[]</td>\n<td>Object[]</td>\n</tr>\n</tbody>\n</table>\n\n### 5.4 Error Handling\n\nRuleSession method invocations that throw a ParseException or TypeCheckException do not affect the state of the RuleSession. A Java application, for example, an interactive command-line, can catch these exceptions and continue using the RuleSession.\n\nRuleSession method invocations that throw a RLRuntimeException may have affected the state of the RuleSession and the RuleSession may not be in a usable state for the application to proceed. Robust applications should attempt to catch and recover from RLRuntimeExceptions in RL at a point near where the exception is thrown.\n\nOther exceptions likely indicate a serious problem that the application cannot handle.\n\n### 5.5 RL Class Reflection\n\nYou can use an RL class like a Java class in an RL program. The `new`, `instanceof`, and `cast` operators work on both kinds of class.\nHowever, when an instance of an RL class is passed to a Java program, it is actually an instance of `oracle.rules.rl.RLObject`. A Java program can use the following classes: `RLClass`, `RLProperty`, and `RLArray` to examine the `RLObject` in a manner similar to using the `java.lang.Class`, `java.lang.reflect.Field`, and `java.lang.Array` classes to reflect a `java.lang.Object`. The package `oracle.rules.rl` contains `RLClass`, `RLProperty`, and `RLArray`.\n\n### 5.6 Obtaining Results from a Rule Enabled Program\n\nWhen you create a rule enabled program with Oracle Business Rules, a common question is, \"How do I get the results of the evaluation?\"\n\nThis section one approaches to extracting or exposing results of rule evaluation from the rule engine.\n\nThis section covers the following:\n\n- **Overview of Results Examples**\n- **Using External Resources to Obtain Results**\n\n**See Also:**\n\nFor more information, see Working with Rules in Standalone (Non SOA/BPM) Scenarios in the *Designing Business Rules with Oracle Business Process Management*.\n\n### 5.6.1 Overview of Results Examples\n\nThe examples in this section show a highway incident notification system. These examples show the different approaches to access the results of rule engine evaluation. The examples use two Java classes: `traffic.TrafficIncident` and `traffic.IncidentSubscription`.\n\n**Note:**\n\nThe `traffic.*` sample classes are not included in the Oracle Business Rules distribution.\n\nThe `TrafficIncident` class represents information about an incident affecting traffic and contains the following properties:\n\n- Which highway\n- Which direction\n- Type of incident\n- Time incident occurred\n- Estimated delay in minutes\n\nThe `IncidentSubscription` class describes a subscription to notifications for incidents on a particular highway and contains the following properties:\n\n- Subscriber - the name of the subscriber\nThe highway\n\nThe direction\n\nIn the example using these classes, when an incident occurs that affects traffic on a highway, a TrafficIncident object is asserted and rule evaluation determines to whom notifications are sent.\n\nIn the examples, the sess object is a RuleSession and a number of incident subscriptions are asserted. As a simplification, it is assumed that the TrafficIncident objects are short lived. They are effectively an event that gets asserted and only those subscribers registered at that time are notified.\n\nThe classes in these examples are all Java classes. However, it is possible to manipulate instances of RL classes in Java using the RL class reflection.\n\nSee Also:\n\nFor documentation see the Javadoc for the RLClass, RLObject, RLProperty and RLArray classes in the oracle.rules.rl package. Thus, RL objects, or instances of RL classes, can be used to hold rule engine results as well as Java objects.\n\n5.6.2 Using External Resources to Obtain Results\n\nThis approach is similar to asserting a container for results, except that instead of a container, the object is a means to affecting resources external to the rules engine. For example, this could involve queuing up or scheduling work to be done, updating a database, sending a message. Any Java method accessible in the action may be invoked to effect the results. As with the container use case, the objects used in this example to access the external resources are not re-asserted since their content is not being reasoned on.\n\nThe following example shows the IncidentDispatcher object that is asserted and then used to dispatch the notification.\n\n```\nrule incidentAlert\n{\n if (fact TrafficIncident ti &&\n fact IncidentSubscription s &&\n s.highway == ti.highway &&\n s.direction == ti.direction &&\n fact IncidentDispatcher dispatcher)\n {\n dispatcher.dispatch(s.subscriber, ti);\n }\n}\n```\n\nExample 5-1 shows Java code that asserts an IncidentDispatcher and a TrafficIncident, and then invokes the rule engine. This could also be accomplished using an object that is being reasoned on, but this would require a test in the rule condition to avoid an infinite loop of rule firing.\n\n**Example 5-1 Sample Showing Results with External Resources**\n\n```\n sess.callFunctionWithArgument(\"assert\", new IncidentDispatcher());\n // An accident has happened\n TrafficIncident ti = new TrafficIncident();\n```\n5.7 Debugging an RL Stacktrace\n\nThe runtime provides detailed debugging information in an RL stacktrace. When possible, if there is an error, the runtime provides extra context that helps identify the location of a problem. This extra context is useful when working with Rules SDK and Rules Designer.\n\nThe stacktrace includes the extra context showing the information for rule conditions, rule actions, functions, variables, and RL class definitions. The XPath style format consists of an RL construct and, if named, followed by the name enclosed in parentheses. If a number, n, appears in brackets after a construct it indicates the nth item following the previous construct. In combination with Rules SDK, RL generation should significantly assist in identifying a location for an error in Rules Designer.\n\nFor example, consider the ruleset shown in Example 5-2. When this ruleset executes, it gives the following report:\n\n```\nRLNullPointerException: object cannot be null\nat line 12 column 13 in stackTraceContext /Rule(porsche)/Pattern(car)/Test[1]\nat line 17 column 5 in stackTraceContext\n```\n\n**Example 5-2 Test Ruleset**\n\n```java\nruleset stackTraceContext\n{\n class Car\n {\n String make;\n String model;\n }\n\n rule porsche\n {\n if (fact Car car \n car.make.startsWith(\"Porsche\")\n )\n {\n println(car.make + \" \" + car.model);\n }\n }\n\n assert(new Car());\n}\n\ningnore\nruleset stackTraceContext\n{\n class Car\n {\n String make;\n String model;\n }\n rule porsche\n {\n ...\n }\n```\n\nif (fact Car car &&\ncar.make.startsWith(\"Porsche\"))\n{\n\nprintln(car.make + \" \" + car.model);\n}\n}\nassert(new Car());\n\n5.8 Using RuleSession Pooling\n\nA typical application that uses rules evaluates the same rules multiple times, with\ndifferent facts corresponding to separate requests. Initializing a RuleSession typically\ntakes a few seconds depending on the number of rules involved.\n\nIn contrast, the time to execute the rules is typically much less. Therefore, better\nperformance can be achieved by initializing a RuleSession one time and reusing it for\neach new request. Using RuleSession pooling, you can create a pool of RuleSession\ninstances that supports improved performance and scalability of applications that use\nrules.\n\nA RuleSession pool shares common definitions for rules, types, and functions across\nall the sessions in the pool which can significantly reduce memory consumption as\ncompared to the same number of independent sessions. This sharing also greatly\nreduces the cost of creating a new session since it does not need to be created from the\noriginal rule language text.\n\n5.8.1 How to Create a RuleSession Pool\n\nIn order for performance to scale up with increasing load, more than one RuleSession\nis required. A pool of RuleSession instances supports improved performance and\nscalability of applications that use rules. A pool is instantiated with a list of the RL\ncode that is used to initialize each RuleSession created by the pool. The RL code is\nexecuted in the order in which it appears in the list. The number of RuleSession\ninstances to create initially may be specified. In general, this should be a small value\nand usually the default should be sufficient.\n\nIf the rules in use by an application are updated, the application may need to load the\nnew rules so that subsequent rule executions use the new rules. This is supported by\nthe pool by invoking the refreshPool method passing it a list of the new RL. After\nthe pool has been refreshed, RuleSessions returned by getPoolableRuleSession\nwill have been initialized with the new RL code. When RuleSessions that were\nobtained before the refresh are returned using returnPoolableRuleSession, they\nare not placed back in the pool. The refreshed pool will only contain RuleSessions\ninitialized with the new RL code.\n\nTypically, the RL code is generated from a RuleDictionary created with the Rules SDK.\nExample 5-3 demonstrates creating and using a RuleSessionPool with RL code from a\nRuleDictionary.\n\n**Example 5-3 Creating a RuleSession Pool**\n\n```java\nRuleDictionary rd;\n// Code to load rule dictionary not shown\nList rlList = new ArrayList();\nrlList.add(rd.dataModelRL());\nList rulesetAliases = rd.getRuleSetAliases(true);\nfor (String alias : rulesetAliases)\n{\n rlList.add(rd.ruleSetRL(alias));\n```\n5.8.2 How to Use a RuleSession Pool\n\nTo execute rules using a RuleSession, you obtain a RuleSession from the pool and then return it after execution is complete. A poolable RuleSession is acquired by invoking the `getPoolableRuleSession` method. The pool creates new RuleSessions as required. An invocation of `getPoolableRuleSession` will not block waiting for a free RuleSession.\n\nA RuleSessionPool can be created with a Map of RuleSession configuration parameters and all sessions in the pool will be configured as specified.\n\nWhen rule execution has been completed, the poolable RuleSession is returned to the pool by invoking the `returnPoolableRuleSession` method. When a RuleSession is returned to the pool it is reset by the pool by invoking the built-in RL function, `reset()`. This removes all facts from working memory to prepare the RuleSession for the next execution. Every RuleSession that is retrieved from the pool should be returned to the pool. If an error has occurred during rule execution that results in the RuleSession being unfit for further use, the pool detects this and discards it.\n\nBesides clearing working memory, the `reset()` function re-executes the initializers of all non-final global variables. The initializer of a non-final global variable can be used to perform other initialization at reset if this is required.\n\nThe following code example demonstrates using a RuleSession from the pool:\n\n```java\nPoolableObject po = pool.getPoolableRuleSession();\nRuleSession engine = po.getPooledObject();\n// use the RuleSession to execute rules as required here\npool.returnPoolableRuleSession(po);\n```\n\nA soft upper bound on the size of the pool can be specified. This allows the pool to respond to temporary increases in demand by growing the pool while allowing the pool to shrink down to this soft upper bound when demand subsides.\n\nUsing the RuleSession pooling implementation, you create RuleSession instances when the `getPoolableRuleSession` method is invoked and the pool is empty. If the load is heavy enough, this will result in an instance count that is greater than the soft limit.\n\nAs the load subsides, the number of RuleSession instances in the pool will automatically be decreased to the soft limit.\n\n5.9 Using RuleSession Options\n\nThe RL runtime with a RuleSession supports following mentioned options.\n\nIt supports the following options:\n\n- `RuleSession.CFG_LOGGING`\n- `RuleSession.CFG_DECISION_TRACE_LEVEL`\n- `RuleSession.CFG_DECISION_TRACE_LIMIT`\n5.9.1 Using the CFG_LOGGING System Property\n\nRL Language runtime looks for CFG_LOGGING as a system property as well as a Boolean in the config Map passed to the RuleSession constructor. A value in the Map overrides the system property value.\n\n5.9.2 Using the CFG_DECISION_TRACE_LEVEL Option\n\nYou can configure the trace level in a RuleSession or in a RuleSessionPool by including the `RuleSession.CFG_DECISION_TRACE_LEVEL` initialization parameter and specifying a level in the configuration Map passed to the RuleSession or RuleSessionPool constructor. This sets the decision trace level at the time a RuleSession is created; invoking `reset()` guarantees that the level after the `reset()` is returned to the configured value, in case it had been changed during rule execution. For more information, see Using Rule Engine Level Decision Tracing.\n\n5.9.3 Using the CFG_DECISION_TRACE_LIMIT Option\n\nThe size of a trace is limited by limiting the number of entries in a decision trace. This necessary to avoid infinite rule fire loops, due to a possible bug in the rules, from creating a trace that consumes all available heap in the JVM. Set the trace limit with the `setDecisionTraceLimit` function. The limit may also be configured in a RuleSession (or RuleSessionPool) by including the `RuleSession.CFG_DECISION_TRACE_LIMIT` initialization parameter with the desired limit in the configuration Map passed to the RuleSession or RuleSessionPool constructor. For more information, see Using Rule Engine Level Decision Tracing.\n\n5.10 Using Decision Tracing\n\nUsing Oracle Business Rules, a decision trace is a trace of rule engine execution that includes information on the state of the rule engine, including the state of facts when rule fire.\n\nThe Oracle Business Rules rule engine constructs and returns a decision trace using JAXB generated Java classes generated from the decision trace XML schema.\n\n5.10.1 Introduction to Rule Engine Level Decision Tracing\n\nTo provide a business analyst friendly presentation of a decision trace requires that the associated rule dictionary is available. Using the rule dictionary associated with a trace allows for a more flexible and efficient approach, as the trace output does not need to include all of the related dictionary content information in the trace.\n\nThe XML schema is in the file `decisiontrace.xsd` and it is part of the Jar file `rl.jar` as: `oracle/rules/rl/trace/decisiontrace.xsd`. The packages of interest are `oracle.rules.rl.trace`, `oracle.rules.rl.extensions.trace`, and `oracle.rules.sdk2.decisiontrace`. The Java classes packages generated from the decisiontrace XML schema are in the package `oracle.rules.rl.trace` and are included in the Javadoc. For more information, see Oracle Business Rules Java API Reference.\n\n5.10.2 Using Rule Engine Level Decision Tracing\n\nA decision trace is a set of XML elements showing rule engine events that occur during rule evaluation. The types of events that are added to a decision trace depend on the trace level selected, and can include:\n- Fact operations (assert, retract, modify)\n- Rules fired\n- Rule activations added or removed from the agenda\n- Ruleset stack changes\n- Rule compilation\n- Reset (which is needed for maintaining state for decision trace analysis)\n\nEach trace contains information about a particular event. For example, a fact operation event entry consists of:\n\n- The operation type (assert, modify, retract)\n- The ID of the fact in working memory\n- Fact type name (fact classed in RL)\n- Runtime object type name\n- The fact object data, including the property name and value for zero or more fact properties\n- Name of rule, RL name, if the operation was the result of a rule action\n- Millisecond timestamp\n\nIn a fact operation event trace, the fact object content reflects the structure of the object as a Java Bean. If the bean properties are references to other beans the related bean content is included in the trace. The value of a bean property can be one of the following alternatives.\n\n- A string representation of the property. This is the case for primitive types and classes in the java.* and javax.* packages.\n- A nested bean object with its property values.\n- A fact ID. This occurs when the property value is an object which has itself been asserted as a fact. The data for the fact at the time of the trace can be retrieved from the RuleEngineState using the fact ID when analyzing the trace.\n- A collection of values accessed as a List in the trace.\n- An array of values accessed as a List in the trace.\n\nAt runtime, to determine which alternative is included in the trace you can test for null; only the correct alternative has a non-null value.\n\nTable 5-3 shows the RL functions that provide control over decision tracing in the rule engine and provide access to a decision trace.\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>getDecisionTrace</td>\n<td>Returns the current trace and starts a new trace.</td>\n</tr>\n</tbody>\n</table>\n### Table 5-3 (Cont.) RL Decision Trace Functions\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>getDecisionTraceLevel</td>\n<td>Gets the current decision trace level.</td>\n</tr>\n<tr>\n<td>getDecisionTraceLimit</td>\n<td>Returns the current limit on the number of events in a trace.</td>\n</tr>\n<tr>\n<td>setDecisionTraceLevel</td>\n<td>Sets the decision trace level to the specified level.</td>\n</tr>\n<tr>\n<td>setDecisionTraceLimit</td>\n<td>Sets the limit on the number of events in a trace. Default limit value is 10000.</td>\n</tr>\n</tbody>\n</table>\n\n#### 5.10.2.1 Setting Decision Trace Level\n\nThe decision trace level may be set by invoking the `setDecisionTraceLevel` function. You can also configure the initial trace level in a RuleSession or in a RuleSessionPool by including the `RuleSession.CFG_DECISION_TRACE_LEVEL` initialization parameter and specifying a level in the configuration Map passed to the RuleSession or RuleSessionPool constructor. This sets the decision trace level at the time a RuleSession is created.\n\nYou can invoke the `setDecisionTraceLevel` function on a RuleSession or a RuleSessionPool object after initialization. When you invoke `reset()`, this function returns the decision trace level to the configured value (if the level was changed during rule execution). Thus, the `reset()` function resets the decision trace limit to the value set during initialization of a RuleSession or a RuleSessionPool. In these cases, `reset()` restores the values established using the initialization parameters.\n\n**Note:**\n\nThese `reset()` semantics for a RuleSession are only valid for a RuleSession initialized with either or both of the `CFG_DECISION_TRACE_LIMIT` and the `CFG_DECISION_TRACE_LEVEL` initialization parameters (or that is obtained from a RuleSessionPool when the pool is created with either or both of the `CFG_DECISION_TRACE_LIMIT` and the `CFG_DECISION_TRACE_LEVEL` initialization parameters.\n\nThe size of a trace is limited by limiting the number of entries in a decision trace. This necessary to avoid infinite rule fire loops, due to a possible bug in the rules, from creating a trace that consumes all available heap in the JVM. Set the trace limit with the `setDecisionTraceLimit` function. The limit may also be configured in a RuleSession (or RuleSessionPool) by including the `RuleSession.CFG_DECISION_TRACE_LIMIT` initialization parameter with the desired limit in the configuration Map passed to the RuleSession or RuleSessionPool constructor.\n\nFor rules applications that use `runUntilHalt`, it is the responsibility of the application to invoke `getDecisionTrace` before the trace limit is hit.\n\nThe decision trace provides structure to the trace data so that it can be manipulated programmatically. However, the trace by itself can be cumbersome to analyze. A trace analysis class (`oracle.rules.rl.extensions.trace.TraceAnalysis`)\nanalyzes a decision trace and facilitates exploration of the trace. Use this class to construct the state of working memory, the agenda, and the ruleset stack from the trace.\n\nThe TraceAnalysis API supports the following:\n\n- Obtain a list of fact types that appear in the trace.\n- Obtain a list of names of the rules that fired in the trace.\n- Obtain a list of the last fact traces for each instance of a specific fact type.\n- Obtain the last fact trace for a specific fact identified by its fact ID.\n- Obtain all of the fact traces for a fact identified by its fact ID.\n- For a fact trace, if the fact trace was created by a rule action, get the rule trace that rule firing in which the action executed.\n- For a rule trace, get the list of fact traces for each fact that matched and resulted in the rule firing.\n- Get the next or previous trace. Exploration of the trace is typically not an iteration over the trace. For example, obtaining a rule trace from a fact trace is essentially jumping to that rule trace. The traces near the rule trace can be explored directly.\n- Obtain a list of rule traces for a rule identified by its name.\n- Obtain the rule engine state for a trace entry. The rule engine state reflects the state of the rule engine after the activity that generated the trace. This API enables inspecting the rule engine state at the time of each trace. This API is most useful with development level tracing. With production level tracing, only the facts in working memory can be tracked and they will not include any fact contents.\n\nExample 5-4 shows a code sample that uses the decision trace analysis API.\n\n**Example 5-4 Decision Trace Analysis API Usage**\n\n```java\nDecisionTrace trace;\n\n... \nTraceAnalysis ta = new TraceAnalysis(trace);\n// Get all of the last fact traces for a fact type.\nList<FactTrace> factTraces = ta.getLastFactTraces(\"com.example.MyFactType\");\n// From a particular fact trace, how it was arrived at may be explored, first by\n// obtaining the rule that asserted or modified the fact.\n// From the FactRecord, the rule that resulted in the record can be obtained.\nFactTrace factTrace = factTraces.get(0); // assumes there is one\nRuleTrace ruleTrace = ta.whichRule(factTrace);\n// The ruleTrace will be null if the fact operation was not part of a rule action.\nSystem.out.print(\"Fact \" + factTrace.getFactId() + \", a \" + factTrace.getFactType()\n+ \" \" + factRecord.getFactOp());\nif (ruleTrace != null)\n System.out.println(\" by rule \" + ruleTrace.getRuleName());\nelse\n System.out.println(\"\"); \n// The analysis can continue by obtaining the list of FactRecords that matched the \nrule and\n// proceeding to analyze the trace back in time.\nList<FactTrace> matchingFacts = ta.getRuleMatchedFacts(ruleTrace);\n```\n5.10.3 Decision Trace Samples for Production and Development Level Tracing\n\nExample 5-5 shows a sample production level trace document.\n\nExample 5-5 Sample Production Level Decision Trace\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<decision-trace xmlns=\"http://xmlns.oracle.com/rules/decisiontrace\">\n <trace-entries xsi:type=\"rule-trace\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n <timestamp>1248975549890</timestamp>\n <rule-name>OrderDiscount.goldCustomer</rule-name>\n <token-time>0</token-time>\n <sequence-number>1</sequence-number>\n </trace-entries>\n <trace-entries xsi:type=\"rule-trace\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n <timestamp>1248975549893</timestamp>\n <rule-name>OrderDiscount.goldCustomerDiscount</rule-name>\n <token-time>0</token-time>\n <sequence-number>2</sequence-number>\n </trace-entries>\n <trace-entries xsi:type=\"rule-trace\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n <timestamp>1248975549894</timestamp>\n <rule-name>OrderDiscount.applyDiscount</rule-name>\n <token-time>0</token-time>\n <sequence-number>3</sequence-number>\n </trace-entries>\n</decision-trace>\n```\n\n5.10.4 Sample Development Level DecisonTrace\n\nExample 5-6 shows a sample development level decision trace document.\n\nExample 5-6 Sample Development Level DecisionTrace\n\n```xml\n<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<decision-trace xmlns=\"http://xmlns.oracle.com/rules/decisiontrace\">\n <trace-entries xsi:type=\"fact-trace\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n <timestamp>1248975491008</timestamp>\n <fact-id>1</fact-id>\n <operation>assert</operation>\n <fact-type>com.example.Customer</fact-type>\n <object-type>com.example.Customer</object-type>\n <fact-object>\n <properties>\n <name>YTDOrderAmount</name>\n <value>\n <string>2000.0</string>\n </value>\n </properties>\n <properties>\n <name>level</name>\n <value>\n <string>null</string>\n </value>\n </properties>\n <properties>\n <name>name</name>\n <value>\n <string>OneLtd</string>\n </value>\n </properties>\n </fact-object>\n </trace-entries>\n</decision-trace>\n```\n<operation>add</operation>\n</trace-entries>\n<trace-entries xsi:type=\"rule-trace\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n<timestamp>1248975491036</timestamp>\n<rule-name>OrderDiscount.goldCustomerDiscount</rule-name>\n<token-time>5</token-time>\n<fact-ids>2</fact-ids>\n<fact-ids>1</fact-ids>\n<sequence-number>2</sequence-number>\n</trace-entries>\n...\n<trace-entries xsi:type=\"rule-trace\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n<timestamp>1248975491036</timestamp>\n<rule-name>OrderDiscount.applyDiscount</rule-name>\n<token-time>7</token-time>\n<fact-ids>2</fact-ids>\n<sequence-number>3</sequence-number>\n</trace-entries>\n...\n<trace-entries xsi:type=\"ruleset-stack-trace\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n<timestamp>1248975491037</timestamp>\n<operation>pop</operation>\n<ruleset-name>OrderDiscount</ruleset-name>\n</trace-entries>\n</decision-trace>\nSummary of Java and RL Differences\n\nThis appendix includes descriptions of differences between the RL Language and Java languages.\n\nA.1 RL Differences from Java\n\nThis section lists the RL differences from Java.\n\n- RL does not include interfaces or methods.\n- RL global variables are similar to Java static class variables, but there is one instance for each rule session.\n- RL does not have a static keyword.\n- RL has rulesets instead of packages. Rulesets group definitions and actions.\n- Instances of RL and Java classes can be asserted as facts in working memory.\n- RL facts are not garbage collected; they must be explicitly retracted.\n- RL is interpreted. There is no compilation or class loading. Classes and functions must be defined before they are used.\n- RL classes may not contain constructors or methods, only data fields. The data fields behave like Java bean properties.\n- Java bean properties can be accessed as fields in RL.\n- The new operator can explicitly assign values to named properties, regardless of whether a constructor is defined. The fact operator can match values to named properties and retrieve, using the var keyword, values from named properties. A property is either a Java bean property, for Java objects, or a field, for RL objects.\n- RL arrays are limited to one dimension.\n- The if and while actions must be in a block, enclosed in curly braces ({}).\n- RL does not include a switch action, continue statement, break statement, or labeled statements for breaking out of nested loops.\n- An RL for loop cannot contain multiple comma separated initialization or update expressions.\n- RL does not support bitwise & and | operators.\n- RL supports function overloading and Java method overloading using best fit.\n- RL variables must be initialized when they are defined.\nFor RL and Java objects, == always invokes the object equals method. RL does not allow testing for object reference equality. For objects, != does not test for inequality of object references, but rather is the negation of the equals methods.\n\nThus, the statement:\n\n```java\nif (object1 != object2){}\n```\n\nIs equivalent to the statement:\n\n```java\nif (! (object1.equals(object2))){}\n```\n\n- Forward references to classes or functions is not allowed.\n- In Java the Java Bean introspector will include write only properties. RL does not include such properties as Beans, since they cannot be reasoned on in a rule. Thus, in order for Java fact type bean properties to be properly accessed in RL they must have both a getter and setter. Properties which have a setter but not a getter, that is write-only properties, are not allowed in the RL new syntax.\n\nFor example, if a bean `Foo` only has the method `setProp1(int i)`, then you cannot use the following in RL, `Foo f = new Foo(prop1: 0)`"}}},{"rowIdx":285,"cells":{"id":{"kind":"string","value":"afc195f347eaaf785d28ac884c5b49662fac667f"},"text":{"kind":"string","value":"Customer profiles\n\nCitation for published version (APA):\n\nDocument status and date:\nPublished: 01/10/2014\n\nDocument Version:\nPublisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers)\n\nPlease check the document version of this publication:\n• A submitted manuscript is the version of the article upon submission and before peer-review. There can be important differences between the submitted version and the official published version of record. People interested in the research are advised to contact the author for the final version of the publication, or visit the DOI to the publisher’s website.\n• The final author version and the galley proof are versions of the publication after peer review.\n• The final published version features the final layout of the paper including the volume, issue and page numbers.\n\nLink to publication\n\nGeneral rights\nCopyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights.\n\n• Users may download and print one copy of any publication from the public portal for the purpose of private study or research.\n• You may not further distribute the material or use it for any profit-making activity or commercial gain\n• You may freely distribute the URL identifying the publication in the public portal.\n\nIf the publication is distributed under the terms of Article 25fa of the Dutch Copyright Act, indicated by the “Taverne” license above, please follow below link for the End User Agreement:\nwww.tue.nl/taverne\n\nTake down policy\nIf you believe that this document breaches copyright please contact us at:\nopenaccess@tue.nl\nproviding details and we will investigate your claim.\n\nDownload date: 18. Sep. 2019\nCustomer Profiles\nExtracting usage models from log files\n\nMiroslav Janeski\nSeptember 2014\nCustomer Profiles\nExtracting usage models from log files\n\nEindhoven University of Technology\nStan Ackermans Institute / Software Technology\n\nPartners\n\nEmbedded Systems Innovation\nEmbedded Systems Innovation by TNO\n\nSteering Group\nPiërre van de Laar\nJan Schuddemat\nAd Aerts\n\nDate\nSeptember 2014\nAbstract\n\nThis report summarizes the “Customer Profiles” project, which goal was to obtain insight into the actual usage of systems. The approach of the project was to extract and visualize models from log files. The models capture the typical and atypical behavior of different users, both humans and other equipment. The stakeholders need these models to keep in control of the production environment in the high-tech factories that is getting more and more complex. The complexity increases among others due to the automation of the production process and involvement of more systems. The project resulted in a prototype that supports extracting customer profiles, a portable architecture according to which the prototype was implemented, a comprehensive domain analysis that includes solutions to the most common problems in extracting models for the purpose of customer profiles, and a list of suggestions how to achieve better models.\n\nKeywords\n\nlog analysis, process mining, resource tracing, pipeline, model-based testing, MBT, TNO, ESI, ASML, Software Technology, PDEng, Tue, Trace\n\nPreferred reference\n\nForeword\n\nEmbedded Systems Innovation by TNO (TNO-ESI) performs applied research in close cooperation with its industrial and academic partners. Our industrial partners observe a number of trends, such as equipment becoming a node in a network, i.e., an ASML TwinScan in a Fab, a Philips MRI scanner in a hospital, and a Thales radar system on a frigate in a battle fleet; and an increase of complexity needed among others to increase performance and to remove the human from the loop. These industrial trends increase the risk that a development organization loses insight in the customer profiles: the actual context and usage by the different customers of the equipment. Our academic partners have recently developed techniques to increase the insight in the actual usage of a system by analyzing the log files. Examples of these techniques are process mining and extracting of execution views. Based on this industrial problem statement and the available academic expert know-how, we defined, in close cooperation with ASML, a project that resulted in the report you are currently reading. The project was executed by a PDEng candidate of the Stan Ackermans Institute of the Eindhoven University of Technology under supervision of TNO-ESI at ASML. The candidate, Miroslav Janeski developed a pipeline to extract graphs and models from log-files that can be easily adopted to fit the context of the different industrial partners of TNO-ESI, such as Philips, Océ, and NXP. These graphs and models increase the understanding of and ability to communicate how the equipment is actually used. Furthermore, the requirements of a logging architecture that includes multiple nodes in a network, to obtain customer profiles have become clearer. This led amongst others to suggestions for improvement of the ASML’s current architecture. TNO-ESI is pleased with the project’s results and currently is planning the next steps. TNO-ESI hopes that you enjoy reading this report.\n\nAugust 2014\n\nPiërre van de Laar\nResearch Fellow\nEmbedded Systems Innovation by TNO\nPreface\n\nThis report summarizes the “Customer Profiles” project that was executed by Miroslav Janeski under supervision of the Embedded System Innovation by TNO (TNO-ESI) at ASML. The project was a full-time, nine-month graduation assignment in the context of a two-year technological designer program in Software Technology. This post-master program is offered by the Eindhoven University of Technology under the patronage of the Stan Ackermans Institute. The project goal was to obtain insight into the actual usage of systems by analyzing log files.\n\nThis report is intended for anyone who is interested in applying process mining techniques to obtain insight into the actual usage of a system by analyzing log files. The project introduction is stated in the first chapter “1. Introduction.” The significance of the project comes from the fact that the project was executed with a clear business goal: A meaningful overview of the system behavior in a production environment. The core of the project is the comprehensive domain analysis stated in the chapter “4. Domain Analysis.” It is recommended for every reader because it emphasizes the main issues and solutions in applying process mining for extracting customer profiles. For further information in applying process mining should focus on the chapters: “3. Problem Analysis”, “10. Verification & Validation”, and “11. Conclusions.” The results that are elaborating the actual capabilities of the “Customer Profiles” are emphasized in the chapter “10. Verification & Validation.” The recommendations for more efficient logging and process mining are stated in the chapter “11. Conclusions.”\n\nThe readers interested in the proposed portable architecture and the system design should focus on the chapters: “6. System Requirements”, “7. System Architecture”, “8. System Design”, and “9. Implementation.” In these chapters the stakeholder requirements and the requirements from the domain analysis are incorporated into appropriate system architecture and design that result in an implemented prototype.\n\nOne of the challenges in this project was the project management, mostly because of the varieties of stakeholders but also because of the level of the uncertainty in terms of delivering sufficient results. Therefore, the readers interested in the project execution, project management, and project retrospective should focus on the chapters “2. Stakeholder Analysis”, “5. Feasibility Analysis”, “12. Project Management”, and “13. Project Retrospective.”\n\nMiroslav Janeski\nSeptember 2014\nAcknowledgements\n\nThe “Customer Profiles” project altogether was a lifetime experience for me. Leaving my comfort zone for nine months and joining a team of people that daily solves cutting edge problems to deliver better and better results for their customers was an incredible experience. Delivering a successful project in such an environment could not have been successful without the close collaboration and supervision from several persons.\n\nFirst of all, I sincerely appreciate the members of my steering group. I thank Piërre van de Laar for constantly guiding me and supporting me during the project time. Thank you Piërre for your critical thinking, for letting me explore, and for the selfless sharing of your knowledge and experience. I appreciate Jan Schuddemat for his advices how to survive in the nowadays business world. Finally, I thank Ad Aerts for his objective and constructive advices. Ad Arts provided a non TNO-ESI and non ASML feedback, which helped in delivering better and more objective project.\n\nDuring the project I collaborated with the members of the Themis and Magenta projects. Jan Tretmans, Richard Doornbos, and Jack Sleuters thank you for your selfless guidance. Your questions, comments, and feedback helped in defining and delivering a successful project. Our regular lunches and coffee meetings helped me enjoy my internship.\n\nThe project was executed at ASML. A lot of people from ASML were involved in this project directly and indirectly. First of all, I want to thank to Roger Lahaye for his guidance in the world of ASML. I learned a lot from your entrepreneurial attitude. Without your support and help my presence at ASML would not have been possible. During the project time I met a lot of people at ASML. I want to thank to Marc Verdieisen, Denie van Kleef, Sebastian Eigenmann, Lily Janssen – Shen, Hank Donker, Roland de Kruijff, and Jan Brekelmans for answering my questions and sharing their experience and domain knowledge.\n\nThe “Customer Profiles” project is a result of the knowledge and experience that I have gained during the PDEng programme. Therefore, I want to thank to all the people involved in the programme.\n\nLast, but certainly not least, I want to thank to my family and close friends. A special thank you to my fiancé Brankica. Thank you for your love and your patience. I appreciate my sisters Mimi and Viki, their families, and my father for their unquestionable support during the entire programme. I want to thank you to my dear friends Meggie and Wim Doezé for being true friends and providing me a pleasant stay in the Netherlands.\n\nMiroslav Janeski\nSeptember 2014\nExecutive Summary\n\nThe project “Customer Profiles” is executed under supervision of the Embedded System Innovation by TNO (TNO-ESI) at ASML. The project was a full-time, nine-month graduation assignment in the context of a post-master program in Software Technology offered by the Eindhoven University of Technology. The project goal was to obtain insight into the actual usage of systems by analyzing log files. The project resulted with a prototype, a portable architecture, domain analysis, and suggestions how to improve the process of extracting customer profiles.\n\nThe most important project artifact is the prototype that shows the feasibility of applying process mining and resources tracing techniques to obtain insight into the actual usage of a system by analyzing log files. The prototype supports set of different activities such as: data collection, data preprocessing, information extraction, and information aggregation that work together to obtain a customer profile model that express the typical and atypical behavior of the participants in production environment as captured in the log files, which defines the prototype output. The validation phase has shown that the prototype output exceeds the stakeholders’ expectations. ASML profited from the prototype output and TNO-ESI will reuse the approach for different customers.\n\nThe success of the prototype output lead to a new requirement: a portable system architecture. Therefore, as a part of the project a portable system architecture that supports extracting customer profiles was designed. The architecture is based on the Pipes and Filters architectural pattern. The system architecture and design are a result of a broad architectural and system analysis, which balances between the stakeholder requirements and the most common practices in the software architecture and software development. As a part of the architecture, components that support different functionalities such as: Data Source, Event Parser, Event Enricher, and Event Combiner were designed.\n\nA lot of domain knowledge was gained during the project. The domain knowledge was transformed into a comprehensive domain analysis. The domain analysis contains the most common aspects of applying process mining for extracting customer profiles such us: mapping issues, missing information, and the minimal log data requirements. As a part of the domain analysis an evaluation of the process mining algorithms was performed. The evaluation showed that the heuristics miner and the genetic miner are the most appropriate process mining algorithms for extracting customer profiles.\n\nIn order to improve the process of extracting customer profiles a list of suggestions was created. The suggestions focus on the most common problems in the logging infrastructures and in the process mining techniques. One of the suggestions is conscious manufacturer decision on the log file content. The manufacturer should define the ratio, the context (based on the minimal log data requirements), and the scope of the logging infrastructure. Another important suggestion for the logging infrastructure is having unique identifiers across the entire logging domain. The next suggestion advocates logging infrastructure on use case (end user activity) level. The last, but not the least suggestion is consistent accurate and standardized timestamp in the logging infrastructure. During the project experiments it was detected that the maturity level of the process mining tools is not on an appropriate level for industrial usage.\nTable of Contents\n\nForeword .................................................................................................................. i\nPreface ..................................................................................................................... iii\nAcknowledgements .............................................................................................. v\nExecutive Summary .............................................................................................. vii\nTable of Contents ............................................................................................... ix\nList of Figures ....................................................................................................... xiii\nList of Tables ......................................................................................................... xv\n\n1. Introduction ..................................................................................................... 1\n 1.1 Context ....................................................................................................... 1\n 1.2 TNO-ESI ................................................................................................. 1\n 1.3 Customer Profiles ................................................................................... 2\n 1.4 TNO-ESI @ ASML .................................................................................. 3\n 1.5 ASML ...................................................................................................... 3\n 1.6 Outline .................................................................................................... 5\n\n2. Stakeholder Analysis .................................................................................... 7\n 2.1 Main Stakeholders ................................................................................... 7\n 2.2 TU/e ....................................................................................................... 8\n 2.3 TNO-ESI ............................................................................................... 8\n 2.4 TNO-ESI Customers ............................................................................ 8\n 2.5 ASML .................................................................................................... 8\n 2.1 ASML customers .................................................................................. 9\n\n3. Problem Analysis .......................................................................................... 11\n 3.1 Context .................................................................................................... 11\n 3.2 Testing Trends and Customer Profiles ............................................. 11\n 3.3 Customer Profiling .............................................................................. 12\n 3.4 Extracting Customer Profiles .......................................................... 13\n\n4. Domain Analysis ............................................................................................ 15\n 4.1 Process Mining ..................................................................................... 15\n 4.2 Applying Process Mining .................................................................... 18\n 4.3 Process Miner Evaluation ................................................................... 23\n 4.4 Design Opportunities ......................................................................... 26\n11. Conclusions.................................................................61\n 11.1 Results.................................................................61\n 11.2 Suggestions.........................................................62\n 11.3 Lessons Learned...................................................63\n\n12. Project Management..................................................65\n 12.1 Introduction.........................................................65\n 12.2 Work-Breakdown Structure (WBS).........................65\n 12.3 Project Planning....................................................65\n 12.4 Project Management Techniques............................66\n\n13. Project Retrospective..................................................69\n 13.1 Reflection............................................................69\n 13.2 Design opportunities revisited...............................69\n\nGlossary.................................................................71\n\nBibliography...............................................................73\n\nAbout the Author........................................................75\nList of Figures\n\nFigure 1 TNO-ESI Role ......................................................................................... 1\nFigure 2 Envisioned vs. Actual Usage ............................................................... 2\nFigure 3 TNO-ESI Customers ........................................................................... 3\nFigure 4 TNO-ESI @ ASML ............................................................................. 3\nFigure 5 Schematic control loop for on-product overlay improvement .......... 4\nFigure 6 ASML Lithography Evolution ............................................................ 5\nFigure 7 Stakeholder Interests .......................................................................... 7\nFigure 8 Evolution of the Testing Techniques .................................................. 11\nFigure 9 Virtual Fab Concept .......................................................................... 12\nFigure 10 Process Mining ............................................................................... 15\nFigure 11 Process Mining Techniques ............................................................. 16\nFigure 12 Diagnostic Data Categorization ....................................................... 16\nFigure 13 Real Process Model ......................................................................... 17\nFigure 14 Standard Log Model ........................................................................ 17\nFigure 15 Mapping-rule Repository ............................................................... 19\nFigure 16 Missing Information Solution ......................................................... 20\nFigure 17 Complete Event Instances ............................................................. 20\nFigure 18 Missing Information Problem ASML ............................................. 21\nFigure 19 Extended Real Process Model ....................................................... 21\nFigure 20 Extended Standard Log Model ....................................................... 22\nFigure 21 Run-in and run-out effect ................................................................ 23\nFigure 22 Heuristics Net Model Evaluation .................................................... 25\nFigure 23 Scattered Infrastructure Risk Evaluation ....................................... 30\nFigure 24 Project Main Use Case .................................................................... 34\nFigure 25 System Architecture for Extracting Customer Profiles ................ 37\nFigure 26 Multiple Data Source System Architecture .................................... 39\nFigure 27 System Architecture Trace ............................................................. 40\nFigure 28 System Component Classification .................................................. 41\nFigure 29 Component Portability Classification .......................................... 41\nFigure 30 Data Source Variations ................................................................. 44\nFigure 31 Event Extractor Variations .............................................................. 44\nFigure 32 RegExp Event Parser Design ........................................................... 45\nFigure 33 Event Enricher Design ................................................................... 46\nFigure 34 Event Enricher Internal Design ...................................................... 46\nFigure 35 Multiple Incomplete Data Sources ................................................. 47\nFigure 36 Collecting Missing Information Design ......................................... 47\nFigure 37 Mxml Serializer Design .................................................................. 48\nFigure 38 Trace Architecture with Lookup Table .......................................... 48\nFigure 39 Implemented Architecture ............................................................ 50\nFigure 40 Prototype Healthiness ..................................................................... 51\nFigure 41 Dotted Chart - Production Process ............................................... 54\nFigure 42 Dotted Chart - Zoomed In View .................................................... 54\nFigure 43 Dotted Chart - Relative Time View ............................................... 55\nFigure 44 Log File Source A - Process Model .............................................. 55\nFigure 45 Log File Source B - Process Model ............................................... 55\nFigure 46 Log File Source A&B - Process Model .......................................... 56\nFigure 47 Final Data Set Heuristics Net (Sources A,B,&C) ................................ 56\nFigure 48 Complex Heuristic Net Model (Sources A,B,&C) ........................... 57\nFigure 49 Item Usage in the Production Process ........................................... 58\nFigure 50 Customer Profiles - Project Roadmap .......................................... 65\nFigure 51 Analytics Use Case Selection ......................................................... 67\nFigure 52 Burn down Chart - Infrastructure Design ...................................... 67\nList of Tables\n\n<table>\n<thead>\n<tr>\n<th>Table</th>\n<th>Description</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Table 1</td>\n<td>TU/e Stakeholders</td>\n<td>8</td>\n</tr>\n<tr>\n<td>Table 2</td>\n<td>TNO-ESI Stakeholders</td>\n<td>8</td>\n</tr>\n<tr>\n<td>Table 3</td>\n<td>ASML Stakeholders</td>\n<td>9</td>\n</tr>\n<tr>\n<td>Table 4</td>\n<td>Heuristics Net Model Evaluation</td>\n<td>24</td>\n</tr>\n<tr>\n<td>Table 5</td>\n<td>Genetic Miner Results</td>\n<td>26</td>\n</tr>\n<tr>\n<td>Table 6</td>\n<td>Architectural Patterns and Modifiability Tactics</td>\n<td>36</td>\n</tr>\n<tr>\n<td>Table 7</td>\n<td>Event Execution Paths</td>\n<td>58</td>\n</tr>\n<tr>\n<td>Table 8</td>\n<td>Planned Activity Distribution</td>\n<td>66</td>\n</tr>\n<tr>\n<td>Table 9</td>\n<td>Final Activity Distribution</td>\n<td>66</td>\n</tr>\n</tbody>\n</table>\n1. Introduction\n\nA short introduction to the project is given, along with the Embedded Systems Innovation by TNO (TNO-ESI) and ASML in which it took place. The main activities at TNO-ESI and their special role in the industry are elaborated. An introduction to ASML is given, because the project was conducted at ASML, as one of TNO-ESI’s clients. This chapter ends with a short overview of the content of this project.\n\n1.1 Context\n\nThe “Customer Profiles” project is conducted by Miroslav Janeski as a part of his Professional Degree in Engineering (PDEng) in software technology (ST) education. The PDEng in ST is a two-year post-Master technological designer program, which prepares the candidates for an industrial career as a technological designer, and later on, as a software or system architect. The program consists of two parts: in-house and on-site part. The in-house part consists of several intensive training periods and in-house projects and the on-site part is a final operational project in industry. The final project has to challenge the candidate to deliver a high quality solution based on his designing competences.\n\nThe project is initiated by Embedded Systems Innovation by TNO (TNO-ESI), and is part of the current work of TNO-ESI at ASML. One of the project goals is to support the efforts of TNO-ESI at ASML. The high level goal is to provide a general architecture and infrastructure for extracting customer profiles of high-tech equipment running in a production environment.\n\n1.2 TNO-ESI\n\nTNO-ESI collaborates in an open innovation structure with a wide range of industrial and academic partners, helping their partners staying ahead of the innovation curve and lead innovations in embedded systems technology.\nTNO-ESI plays a significant role in building a bridge (Figure 1) between industry and academia. From one side, it brings new practical solutions from the academia to the industry via academic expertise. On the other side, it brings new research drivers from the industry to the academia via industry problem statements. To advance the fundamental basis of high-tech product design and improve on its efficiency, effectiveness, quality, and costs, TNO-ESI (Key Competence Areas, 2014) focuses on the following key professional competencies:\n\n- system architecting\n- system design\n- system integration & testing\n- model-based engineering\n\n1.3 Customer Profiles\n\nThe customer profiles present models of the behavior of particular equipment in a production environment. With customer profiles one can describe the actual usage of particular equipment. In general, the goal of the customer profiles is to minimize the gap between the envisioned usage of the product in the development process and the actual usage of the same product in a production process. By minimizing the gap between the envisioned and the actual usage (Figure 2), the stakeholders can accomplish a variety of benefits. For instance, with better design and architecture evaluation, better testing and validation, better risk reduction and diagnostics, TNO-ESI’s clients can design products that are much closer to the end user needs. At the same time better understanding of the process in the production environment can bring new product and service opportunities.\n\nTNO-ESI will use the expertise of generating customer profiles to provide better services to their customers. In general, wherever there is a high-tech product in a production environment, TNO-ESI can support its customers to get better insight into the actual usage of the products. From this point of view, potential TNO-ESI customers (Figure 3) are: ASML, Philips, Océ, and many more.\n\nThere are many ways to generate a customer profile. One way is by applying process mining (van der Aalst W., 2011). Process mining is a process management technique that performs analysis of processes based on event logs. The basic idea is to extract knowledge from event logs recorded by an information system. In the context of this project, process mining is used to extract knowledge in terms of behavior models from multiple log data sources. In addition, communicating the process mining requirements can provide suggestions for logging mechanism improvement. Thereby more information can be extracted from the logging files in the future.\nThe complexity of applying process mining techniques can be explained with the fact that the customer profiles have to describe a behavior of systems of systems. TNO-ESI clients manufacture a collection of dedicated systems that work together to create a new, more complex system which offers more functionality and performance than simply the sum of the constituent systems. An ASML high-volume manufacturing factory, a hospital running high scale Philips medical systems, and Océ’s complex management systems are examples of complex system of systems where the customer profiles can be applied.\n\n1.4 TNO-ESI @ ASML\n\nOne of the partners where TNO-ESI applies their professional competencies including the customer profiles is ASML. Part of the collaboration between TNO-ESI and ASML related with this project are two ongoing projects: Themis and Magenta. Both projects are conducted at the Architecture, Testing, Integration, and Quality Group, which is a part of the Application Development and Engineering Sector.\n\nFrom the software development point of view these projects support the two directions of the V-model (Figure 4): verification and validation. Magenta is oriented towards system architecting and architecture evaluation, whereas Themis is oriented towards system integration and testing, specifically applying model-based testing.\n\n1.5 ASML\n\n1.5.1 Introduction\n\nASML is the world’s leading provider of lithography systems for the semiconductor industry, manufacturing complex machines that are critical to the production of integrated circuits. ASML designs, develops, integrates, markets, and services advanced systems used by customers – the major global semiconductor manufacturers – to cre-\nate chips that power a wide array of electronic, communications, and information technology products. ASML advanced systems integrate multiple disciplines in the semiconductor manufacturing process such as\n\n- Photolithography\n- Metrology\n- Computational & Holistic Lithography\n\nThe integration of ASML’s vast knowledge of the photolithography and the computational lithography process, and the expertise in metrology and process control with YieldStar, enables comprehensive lithography system set-up for high volume manufacturing.\n\n1.5.2. ASML Holistic Lithography\n\nThe semiconductor industry is driven by “shrink” – the ability to make the features that make up chips ever smaller. Shrink improves chip performance and increases manufacturers’ profitability. However, as chip features get smaller, so do the tolerances that manufacturers must work to. The smaller the tolerances, the harder it is to manufacture chips that work properly.\n\nMoving to 20-nm chip wafers and beyond brings unique challenges for the semiconductor industry. From the production point of view, this means it will no longer be enough to consider Integrated Circuit (IC) design, mask creation, lithography and metrology in isolation. Instead it needs a new integrated approach to IC manufacture. The ability to optimize multiple IC production steps simultaneously is fundamental to ASML’s Holistic Lithography vision. A schematic overview of ASML’s Holistic Lithography approach (Images - ASML’s customer magazine, 2013) is shown in Figure 5. Figure 6 depicts the evolution of the ASML lithography process. The conclusion is that the lithography process is getting more and more complex from pioneering to holistic approach. Based on Figure 6, one can conclude that now ASML is in the phase of implementing a holistic approach. Holistic Lithography is an intelligent integration of ASML’s vast knowledge of the scanner itself, ASML’s expertise in metrology and process control with YieldStar and the Litho Computing Platform, and computational lithography. This enables further shrink by optimizing process windows and lithography system set-up for high volume manufacturing.\n\nASML’s Holistic Lithography approach includes different ASML equipment that supports the holistic approach and that increases the ability to control lithography scanners. Nowadays, the high volume manufacturing process is performed in a fully automated fab environment. A fully automated fab environment consists of different machines from different manufacturers that work together to achieve a high level goal. Putting the end user in full control of the process, but also putting ASML in a full support of the process takes a lot of knowledge and understanding. The understanding of the production process is essential because every customer has its own production process, although they use the same or similar ASML equipment.\n\nUnderstanding the actual process in the customer production environment and modeling the actual customer usage of the ASML equipment is one example where customer profiles can be applied. The new approach in this project is that the extraction\nof the customer profiles is based on analysis of log files created from different equipment (participants) in a production environment.\n\n---\n\n**1.6 Outline**\n\nThe report starts by introducing the reader to the different stakeholders in the project, together with a brief overview of all their motivations and needs. Following this, a problem analysis is elaborated in a top-down approach, from the question “Why do we need customer profiles?” to the question “How to accomplish them?”\n\nAfter the problem analysis, a comprehensive domain analysis is given. The domain analysis is focused on main challenges in applying process mining to a custom domain. This is meant to allow an easier understanding of the content that follows, which focuses on the problem to be solved.\n\nNext, the feasibility analysis is placed. The feasibility analysis focuses on the main issues and challenges expected in the project. This chapter also includes a risk list, along with mitigating measures.\n\nFollowing the feasibility analysis, there are chapters describing the architecture and design of the prototype, including a summary of the system requirements that drive the architecture and the design. The most important design decisions and the architectural reasoning are elaborated in these chapters. After this, more practical issues that arose during development are addressed.\n\nNext, the verification and validation analysis is elaborated. It focuses on the definition of the customer profiles and how the prototype was validated and verified. Finally, there are chapters dealing with the conclusions, where the results and suggestions are elaborated; project retrospective focusing on the personal experience of the author of the project; and an overview of how the project management was handled.\n2. Stakeholder Analysis\n\nA brief overview of all stakeholders in the project is given, and their motivations and needs are explored. An overview of the projects and departments interested in the “Customer Profiles” is presented.\n\n2.1 Main Stakeholders\n\nUnderstanding the stakeholder relations and their concerns is an essential step in managing and implementing a successful project. What makes this project special is the variety of stakeholders, their relations, concerns, and expectations.\n\nBased on their main interests in the project, there are three groups of stakeholders:\n\n- Stakeholders interested in the process of delivering the final artifact\n- Stakeholders interested in the quality attributes of the final artifact\n- Stakeholders interested in the final artifact\n\nEindhoven University of Technology (TU/e) belongs to the first group of stakeholders, TNO-ESI belongs to the second group, and TNO-ESI clients such as ASML, but also their customers belong to the third group of stakeholders.\n\nIn order to better understand the stakeholder stakes a distribution of their interests is shown in Figure 7. It can be concluded that TU/e is mostly interested in the project implementation process and in the quality attributes of the project artifact. TNO-ESI is mostly interested in the coverage of the functional requirements and the quality attributes, whereas ASML and the ASML customers main interest is in the implementation of the functional requirements, which is the project artifact.\n2.2 **TU/e**\n\nTU/e has an interest in the design and in the process of the project execution. Therefore, the TU/e stakeholders include project management, analysis, design, implementation, verification, and validation. Table 1 shows the TU/e stakeholders. Ad Aerts is a general director of the PDEng programme in ST and he is a university supervisor in this project. Miroslav Janeski is the PDEng candidate responsible to implement this project.\n\n<table>\n<thead>\n<tr>\n<th>Stakeholder</th>\n<th>Role</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Ad Aerts</td>\n<td>University Supervisor</td>\n</tr>\n<tr>\n<td>Miroslav Janeski</td>\n<td>PDEng Candidate</td>\n</tr>\n</tbody>\n</table>\n\n2.3 **TNO-ESI**\n\nTNO-ESI has the role of project owner and therefore is directly interested in the project artifacts. Driven by the core idea of open innovation and delivering domain-independent solutions, TNO-ESI expects that the final artifact can be reused in various domains.\n\nThe relation between TNO-ESI and ASML in the context of this project is elaborated in the previous chapter. The motivation of TNO-ESI for this project is to support their two ongoing projects at ASML, Themis and Magenta. The final artifact of this project, a prototype that extracts customer profiles, will be used as input for the model-based testing infrastructure provided with Themis and the architectural evaluation provided with Magenta. The main stakeholders from TNO-ESI are listed in Table 2.\n\n<table>\n<thead>\n<tr>\n<th>Stakeholder</th>\n<th>Position</th>\n<th>Project</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Jan Schuddemat</td>\n<td>Senior Project Manager</td>\n<td>Themis; Magenta</td>\n</tr>\n<tr>\n<td>Jan Tretmans</td>\n<td>Research Fellow</td>\n<td>Themis</td>\n</tr>\n<tr>\n<td>Pierre van de Laar</td>\n<td>Research Fellow</td>\n<td>Themis</td>\n</tr>\n<tr>\n<td>Richard Doornbos</td>\n<td>Research Fellow</td>\n<td>Magenta</td>\n</tr>\n<tr>\n<td>Jack Sleuters</td>\n<td>Senior Software Architect</td>\n<td>Magenta</td>\n</tr>\n</tbody>\n</table>\n\n2.4 **TNO-ESI Customers**\n\nThe largest group of stakeholders that benefits from the project artifact are the TNO-ESI customers (Figure 3). TNO-ESI customers can use the customer profiles for more efficient testing (business wise testing), better design (design optimization), faster diagnostics, and new product opportunities.\n\n2.5 **ASML**\n\nASML is a member of the TNO-ESI Customers stakeholder group. At the same time, ASML is the domain owner and a lot of design stakeholders come from ASML. The main stakeholders from ASML are listed in Table 3. Roger Lahaye, an Interoperability Test Architect, is the main stakeholder for the “Themis” project. Denie van Kleef is a Usability and Interoperability Architect and is involved in the general customer profiling. Lily Janssen Shen is a project leader of the current “Customer profiling” project at ASML. The “Customer profiling” project has the same goal as this project, but uses a different approach based on interviews, machine configuration, and factory specification. Lily Janssen Shen is interested in combining the results from both projects (“Customer Profiles” and “Customer Profiling”). The Software Testing Group at ASML, which is led by Ronnie van't Westeinde, is also interested in the results of this project, mostly for the same reasons, providing business-wise selection of the test cases and test case discovery. Pieter Knelissen is a System Architect and is concerned with the project vision.\nTable 3 - ASML Stakeholders\n\n<table>\n<thead>\n<tr>\n<th>Stakeholder</th>\n<th>Position</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Roger Lahaye</td>\n<td>Interoperability Test Architect</td>\n</tr>\n<tr>\n<td>Denie van Kleef</td>\n<td>Usability and Interoperability Architect</td>\n</tr>\n<tr>\n<td>Lily Janssen Shen</td>\n<td>Project Leader - CSI</td>\n</tr>\n<tr>\n<td>Pieter Knelissen</td>\n<td>System Architect</td>\n</tr>\n<tr>\n<td>Roland de Kruijff</td>\n<td>Cross-sector Structural Improvement</td>\n</tr>\n<tr>\n<td>Hank Donker</td>\n<td>Cross-sector Structural Improvement</td>\n</tr>\n<tr>\n<td>Ronnie van’t Westeinde</td>\n<td>Software Architecture and Integration Test Group Leader</td>\n</tr>\n</tbody>\n</table>\n\n2.1 **ASML customers**\n\nFigure 7 shows one more group of stakeholders. This group consists of the ASML customers. Some of the ASML customers provide the log data for this project have the role of data supplier. They are not directly involved in the project, but they will benefit from the project results in many ways such as factory optimization and more efficient diagnostics.\n3. Problem Analysis\n\nThe problem analysis starts with the question why do we need customer profiles in generic fashion and ends with the problem analysis that answers the question “How to extract customer profiles?”\n\n3.1 Context\n\nAlong with the technology growth, the complexity of the systems that high-tech companies produce grows too. Building large software-intense systems includes high level integration skills and significant development effort. Sometimes, the development of such machines includes a lot of legacy design and backward compatibility which makes the end design very complex.\n\nThe main reasons for profiling the customer usage are to understand the actual usage and to analyze the behavior of the equipment in a factory environment. With the understanding of the ongoing process in the factory environment, the companies can benefit in many ways such as: improved design of its equipment, more efficient diagnostics, factory optimization, and opportunities for new products.\n\nIf we take the ASML products as an example, a factory that uses ASML equipment represents a system of complex systems. Therefore, all the ongoing processes in the factory are complex by default. They are performed by different subsystems and supervised by teams of highly qualified engineers. Based on this, the whole process of profiling the customer usage of the high-tech equipment and particular ASML equipment is not trivial at all.\n\n3.2 Testing Trends and Customer Profiles\n\nTo better understand the need of customer profiles, the trends in the testing models and the Virtual Fab concept are explained.\n\n3.2.1 Model-based Testing\n\nIn Figure 8, the evolution of the testing techniques is given. The latest trend in the testing techniques is model-based testing. Model-based testing is application of model-based design for designing and optionally also executing artifacts to perform software testing or system testing.\n\nFigure 8 Evolution of the Testing Techniques\nThe model-based testing produces test cases as a variation of the model and the data. Not every variation of the test model is relevant and not every variation has the same business value in terms of money and time. The number of test cases can be unlimited. The customer profiles can help in selecting the most useful test cases in a production environment. The reason for including the customer profiles in model-based testing is to support the selection of the most appropriate sequences for testing. This means that the customer profiles will offer more optimized model-based testing. A useful test case is a test case that describes the most frequently used scenarios in the system. At the same time the customer profiles can add a new test case, which describes a usage scenario in a production environment that is not a part of the testing framework. By selecting the most used test cases and by adding new test cases, the customer profiles provide more efficient testing.\n\nApplying model-based testing in a combination with customer profiles to optimize the model-based testing is one of the best practices in the modern testing frameworks. ASML is always using the best practices to develop high-tech equipment and TNO-ESI supports ASML’s application of model-based testing to achieve best practices.\n\n3.2.2. Virtual Fab Concept\n\nAnother trend in the modern testing approaches is virtualization. With virtualization companies can have much cheaper testing of their equipment. For instance, if ASML wants to simulate a typical customer environment, it will cost an enormous amount of money. With the virtualization, a complete system can be simulated at low cost. At the same time the virtualization offers flexibility and more possibilities. Different equipment, virtual or real, can be plugged in and different test cases can be executed in a different test case.\n\nThe combined effort of TNO-ESI and ASML to apply virtualization led to the Virtual Fab concept. Figure 9 shows a part of Virtual Fab concept. The role of “Customer profiles” in the Virtual Fab concept is to extract models of the typical and atypical behavior of different participants in a production environment. With other words, the customer profiles are an abstraction of the fab usage. In addition, the customer profiles can be transformed into virtual fab scenarios. At the same time, virtual fab scenarios can be generated based on the design models of the system. In that case, the customer profiles should provide selection of the most used virtual fab scenarios. The role of the customer profiles in the virtual fab concept is the same as in the model-based testing approach: selecting of the most used virtual fab scenarios, but also adding new virtual fab scenarios that cannot be extracted from the system design models.\n\n3.3 Customer Profiling\n\nCreating customer profiles is not a new activity at ASML. Currently there are a few ongoing projects trying to obtain customer profiles. These projects differ from this project in the input data. In order to obtain customer profiles, they consider different inputs such as: diagnostics, interviews, logging, and machine configurations. The diagnostics approach is only focused on tracing the root cause for the problems. It gives low level (machine level) insight into the problem and is not enough to create the full picture of the customer usage. The interviews give better insight into the customer usage, but they are subjective and incomplete. A lot of engineers are involved in the production environment and they are responsible for different tasks. Their perspective of the production environment often brings inconsistent and incomplete results. The logging approach so far was used to generate a static model of the produc-\n\n---\n\n1 The diagram shows part of the Virtual Fab concept that is relevant for “Customer Profiles”\ntion environment, which does not describe the behavior of the participants in the pro-\nduction environment.\nThe results from the these projects are exceeding the expectations, but the ongoing\nprocess in the production environment is getting more and more complex and looking\nat only one aspect does not give the full picture. At the same time the ASML expec-\ntations are increasing based on their customer needs. In this situation, where other\napproaches have difficulties in obtaining a full description of the process, process\nmining techniques can help. First, because process mining techniques can extract the\nmain ongoing process, which comprises a process structure and a process behavior\nmodel, and second, because the process mining techniques give a more high level\n(use case) view of the problem.\n\n3.4 Extracting Customer Profiles\nThe stakeholders acknowledged that data is available and that gives opportunities to\napply different data analysis techniques to reach a specific business goal. Extracting\ncustomer profiles is such a business goal based on data analysis with process mining.\nExtracting customer profiles based on process mining consists of several sub-\nproblems that make the process challenging. The main challenge is mapping the enti-\nties from the customer specific domain (such as the ASML logging infrastructure) to\na process mining domain. For the purpose of this project the process mining domain\nis presented with the Standard Log Model (elaborated in the following section) and\nan appropriate mapping from the customer specific domain to the Standard Log\nModel. From more abstract point of view, an opportunistic problem solving approach\nis applied in this project.\nThe process mining challenges and solutions are presented in the following chapter.\nExtracting customer profiles consists of intermediate data analysis. It involves analy-\nysis of the implemented logging infrastructure and analysis of the stored historical\ndata. In case of missing data, changes in the data collection strategies have to be pro-\nposed. The data analysis is a process that is driven by the stakeholders and their in-\nterests. In this project is the phase where the process mining techniques and resource\ntracing techniques are applied in the ASML domain. The high uncertainty in terms of\ndifferent business goals, which require different analytical skills, is the main chara-\ncteristic of the data analysis. The results of this step are used as an input for the soft-\n4. Domain Analysis\n\nThe process mining domain is elaborated and an overview of the main challenges in applying process mining is given. In addition, the high level design opportunities in the project are emphasized.\n\n4.1 Process Mining\n\nProcess mining (van der Aalst W., 2011) is a process management technique (Figure 10) that allows for the analysis of processes based on event logs. The basic idea is to extract knowledge from event logs recorded by a set of systems. Process mining provides techniques and tools for discovering process, control, data, organizational, and social structures from event logs. This approach is often used when no formal description of the process can be obtained by other approaches, or when the quality of existing documentation is questionable.\n\nIn the context of customer profiles, we have the same assumptions as process mining, because of the similarity of the problem that we have to solve. The assumptions are that the TNO-ESI clients manufacture high-tech equipment (Figure 5) that is used in a production environment i.e. the real world shown in Figure 10. There is a system that controls the process and records events in log files. In extracting customer profiles, we extract relevant information from the log files and apply process mining techniques to generate process models that abstract the real world.\n\n4.1.1. Process Mining Techniques\n\nThere are three classes (Figure 11) of process mining techniques (van der Aalst W., 2011). This classification is based on whether there is a prior model and, if so, how it is used.\n\na. Discovery: There is no a priori model, i.e., based on an event log, a process model can be discovered.\n\nb. Conformance analysis: There is an a priori model. This model is compared with the event log and discrepancies between the log and the model are analyzed.\n\nc. Enhancement: There is an a priori model. This model is extended with a new aspect or perspective, i.e., the goal is not to check conformance but to enrich the model.\nIn the context of this project, a combination of conformance checking and enhancement is applied to model the customer process and to provide an insight into the customer environment. Therefore, we assume that there is an a priori model that we want:\n\n- to confirm that is in the log files\n- to extend with additional information\n\n### 4.1.2. Process Mining Concepts\n\nThe process mining technique is based on several assumptions (van der Aalst & van Dongen, 2005) about the log files. It assumes that it is possible to record event instances such that the event instance refers to\n\n- an event and\n- a process instance\n\nMost large software systems use logging mechanisms to record and store information of their specific activities into log files. In practice, logging messages are recorded with mechanisms that are designed to collect data for purposes different from process mining. Regardless of the logging mechanisms, it is common that developers, testers, and other specialized users use logging information for understanding, debugging, testing, and corrective maintenance. This immediately shows one of the biggest challenges (van der Aalst & van Dongen, 2005) faced during applying process mining. When trying to use event logs from a different system to do process mining, we need to be able to present the logs in a standardized way, i.e., there is a need for a good description of such a log. Furthermore, for each information system, a mapping to that description has to be provided.\n\nTherefore, the mapping of event logs from one system to the standard format is not a trivial task. The mapping issue can be even more difficult when the development teams adopt different logging formats, naming conventions, and even different log-\nging mechanisms. Another reason that makes the mapping issue a real problem is that the logging data is considered as informal data. Figure 12 shows the classification of the diagnostic data (logging data) at ASML as informal data. The fact that the diagnostic data is informal and unstructured means that it is designed for human analysis, which usually means semi-structured or structureless data that complicates the automated analysis.\n\nMapping any informal data model to a standardized model is a challenging process. In order to understand the challenge, we have to define two models: a Real Process Model and a Standard Log Model. The Real Process Model is shown in Figure 13. It consists of two entities: a process and an event.\n\n- **Process** – A collection of related, structured activities or tasks that produce a specific service or product (serve a particular goal) for a particular customer.\n- **Event** – Activity or a task that was executed in a process.\n\n\n\nThe Standard Log Model, shown in Figure 14, models the data in the log files. There are several relevant models that are used as reference models (Hage, Malaisé, Segers, Hollink, & Schreiber, 2011) (van der Aalst & van Dongen, 2005). The Standard Log Model entities are instances of the Real Process Model entities:\n\n- **Event Instance** is an instance of an Event entity in the real process model.\n- **Process Instance** is an instance of the Process in the real process model. A process instance is an execution of a real process.\n\n\n\nAt the same time the Standard Log Model defines the minimal information that the log data have to have in order to apply process mining. In (Rozinat, Data Requirements for Process Mining, 2012) and (van der Aalst & van Dongen, 2005) different data requirements are discussed. For the purpose of this project and based on the communication with the stakeholders, we had to extend their requirements with additional information required for customer profile extraction. The data requirements for extracting customer profiles with process mining are the following:\n\n- **Event Instance Unique ID**: Each event instance should have a Unique Event Instance Identifier in order to distinguish different event instances.\n- **Process Instance Unique ID**: Is necessary to distinguish different executions of the same process.\n- **Event Instance Class**: Each event instance should have information about the Event Class to which belongs.\n- **Event Instance Originator**: Each event instance should have an originator. An Originator is a participant (user or equipment) in the production environment (a factory). One of the goals of customer profiles is to model the behavior of different participants in the production environment. One way to distinguish events executed by different participants is by **Event Instance Originator**.\n- **Event Instance Timestamp**: At least one timestamp is needed to bring the event instances in the right order. Another way to understand the order of the event instances is by sequence Id.\n- Each **Event Instance** belongs to at least one process instance. This information has to be explicit in the log files in form of **Process Instance Unique ID**.\n\n### 4.2 Applying Process Mining\n\nProcess mining techniques in this project were applied in several steps\n\n1. Identifying a process (and events)\n2. Solving the mapping challenge\n3. Solving the missing information challenge\n4. Solving the Non-Unique IDs problem\n5. Dealing with the run-in and run-out effects\n\nThe first two steps are already recognized as challenges in the literature. In the context of extracting customer profiles, we realized that there are three more important challenges: missing information, having non-unique IDs, and dealing with the run-in and run-out effects. In the following subsections each of these steps is explained.\n\n#### 4.2.1. Identifying Process and Events\n\nAs we already mentioned, feeding process mining algorithms with raw log data usually does not provide sufficient results for the stakeholders. That is only possible when the logging infrastructure design satisfies the process mining requirements, which is almost never the case.\n\nThe first step in applying process mining for customer profiles was selection of a major representative process in the production environment. More precisely, we need to map the real process and events with the Real Process Model (Figure 13). If we take a more abstract view, all of the TNO-ESI clients have a product that has a main use case. These products are used in an automated production environment. In a sense, the products are nodes in a system of systems. These systems pool their resources and capabilities together to create a new, more complex system which offers more functionality and performance. Whether it is the ASML TwinScan, Océ’s printers, or Philips MRI scanners, they all have main use case scenario, they are used in a production environment (respectively: an automated Fab, a document management system, or a hospital), and they are connected with other participants. Therefore, for the purpose of this project, the process that we try to conform to and to enhance with process mining is the main production process. Together with the process that we have to model, we have to identify the events that compose the process. In general, there might be an enormous amount of events, and in that case only the most important for the stakeholders are selected.\n\nThere might be different ongoing processes in the production environment. They might be completely independent or they might be sub-processes of the main production process. For different processes, different data requirements for extracting customer profiles might be needed. For instance, if there is only one selected participant in the production environment the stakeholders might not be interested in the **Event Instance Originator**.\n\nSelecting the main production process as a process that we have to extract or conform to is a design decision made in this project. The main production process is selected because of two reasons. The first reason is the genericity, each TNO-ESI client has a\nproduct that is used in a production environment. The second reason is that is a good starting point for the customer profiling and it confirms to the stakeholder interests. The stakeholders can quickly get an overview of the real usage and they easy detect deviations from the expected usage.\n\n4.2.2. Mapping Rule Repository\n\nAfter identifying the real process and the events that comprise the process, we had to map event instances and their properties from the log files to the entities in the Standard Log Model. The mapping challenge in process mining is already recognized (van der Aalst & van Dongen, 2005) and there are recommendations (Callo Arias, America, & Avgeriou, 2013) on how to solve it. One way to implement this is by using a mapping-rule repository (Callo Arias, America, & Avgeriou, 2013). A Mapping-rule Repository (Figure 15) is a set of formal and informal specifications that describe how event instances from the log files can be mapped to the events in the real process model. The specifications are derived from the domain where the customer profiles are applied. Therefore, in the solution proposed within this project, there has to be an engine to bind domain specific mapping rules. This leads to one of the system design requirements. The proposed architecture must have an Extractor component. The role of the Extractor is to extract event instances that are compliant with the Standard Log Model.\n\n\n\n4.2.3. Missing Information\n\nIn this project we faced an important challenge that goes beyond the complexity of the mapping challenge. The mapping-rule approach assumes that in the log files we have the minimal information necessary for process mining techniques. That means that for each event instance in the log files there is information that can be mapped to the Standard Log Model requirements. By using the mapping-rule approach we use different mapping rules to enable 1:1 mapping between the event instances in the log files and the Event Instance class in the Standard Log Model.\n\nDuring the project, we realized that in the context of ASML there are log files that miss information. There are event instances in the log files but they do not fully satisfy the minimal requirements that we have defined in the subsection “4.1.2. Process Mining Concepts.” Usually, the event instances that do not have 1:1 mapping with the Standard Log Model are considered as incomplete event instances and they are filtered out. In the context of ASML, the incomplete event instances represent significant events in the production process. Filtering out incomplete but significant event instances will affect the quality of the customer profiles. Moreover, filtering out incomplete but significant event instances results in a process model that does not meet the stakeholder expectations. This is explained in the section “10.1. Validation.” Therefore, we searched for a mechanism that enriches these incomplete event instances with additional information and transforms them into event instances that are compliant with the Standard Log Model. The solution we choose is to use an enricher to make this incomplete event instance compliant with the Standard Log Model. The enricher will use the data from a Complementary Information Repository. The repository includes a set of formal and informal specifications (as in the Mapping-rule\nRepository). The procedure is illustrated in Figure 16. Again, this leads to additional system design requirement. In the proposed architecture there must be an Enricher component that by using complementary information will enrich the extracted incomplete event instances. The incomplete event enrichment depends on the missing information. Therefore, the design and implementation of the enricher is rather domain specific than generic.\n\n\n\nIn the case of ASML, we faced event instances without *Process Instance ID*. That means that there are (incomplete) event instances that we do not know to which process instance they belong. From this perspective there are two different log file sources:\n\n- Log files with event instance with minimal information (*Event Instance*)\n- Log files with event instances with missing information (*Event Instance'*)\n\n\n\nFigure 17 shows an example of two data sources at ASML. Log File Source A and Log File Source B have complete event instances that belong to same process instances. This makes the event instances compliant with the Standard Log Model. In the example of ASML, there is one more log file source: Log File Source C. Unlike to Log File Source A & B, Log File Source C does not have complete event instances. The problem is illustrated in Figure 18.\nAs we mentioned above, the logging architecture is designed for a different purpose than process mining. This means that a lot of information is stored in the log files. Fortunately, some of the information in the log files can help us to enrich the incomplete event instances. The Log File Source A in Figure 18 has event instances with minimal information (Event Instance) and for them we only need the Mapping-rule Repository. The relationship between the class Event Instance and the class Process Instance fulfills the requirements from the Standard Log Model. The same reasoning is valid for the Log File Source B. At the same time, in the Log File Source A there is information about the relation between the Event Instance and particular Item Instances that are created by these event instances. This information gives us couples of Item Instance and Process Instance. The Log File Source C in Figure 18 has incomplete event instances (Event Instance’) without Process Instance ID. Moreover, the Log File Source C has extra information about a relation between these incomplete event instances (Event Instance’) and the same Item Instances created by the event instances from the Log File Source A. From the Log File Source A, we get complete event instances that created item instances and from Log File Source C we get incomplete event instances that use the same item instances from Log File Source A. By joining the incomplete event instances from Log File C with the item instances that they use, we enrich the incomplete event instances into complete event instances. The association between the Event Instances and created/used Item Instances is used to enrich the incomplete event instances (Event Instance’) in the Log File Source C. If we summarize, in the example of ASML we miss information about the join between certain event instances and process instances. In order to solve the join problem, we use a lookup table (associations between created/used item instances and process instances). For that reason the Real Process Model and the Standard Log Model are extended with the new entities Item and Incomplete Event and their appropriate instances. The extended Real Process Model is shown in Figure 19. Each Process in the final Real Process Model can have many Events, each Event can create many Items and each Item can be used by many Incomplete Events.\nThe Extended Standard Log Model with incorporated instances of the Item and Incomplete Event is shown in Figure 20. The Log can have Incomplete Event Instances that can be associated with a particular Item Instance. The Item Instances are created by a particular Event Instance.\n\n4.2.4. Non-Unique IDs\n\nOne of the main data requirements stated in the subsection “4.1.2. Process Mining Concepts” is that the event and process instances must have Unique ID property. In the data analysis phase it was discovered that in a certain data set (of log files) there were process instances with same unique ID. In that case, we cannot always uniquely distinguish to which process instances the event instances belong. Therefore, it was necessary to apply an algorithm in order to enable this distinguishment. In the context of the observed data set, we applied a rule that says at the certain point of time only one process instance with a particular ID can be active. In that case, the new event instances are attached to the current active process instance. In order to implement this algorithm we had to introduce a mechanism for activation or deactivation of the process instances. One way to do this is to select significant event instances that activate and deactivate the process instances. With this approach we make sure that the event instances are attached to the correct process instance. This approach is not perfect and does not always guarantee correct answers. For instance, if there is no significant event instance because of the run-in or run-out effects there is no way to deactivate the current active process instance, and each next event instance will be added to one process instance.\n4.2.5. Run-in and run-out effects\n\nRun-in and run-out effects are effects when the analyzed log data represents a timeframe from the lifetime of a particular system. There are a lot of process instances that started before the observed timeframe and a lot of process instances that stopped after the observed timeframe. These process instances are incomplete and if they are not properly handled they add noise to the model. In the context of this project, each extracted process instance is being checked for the number and type of event instances that it has. If the process instance does not meet certain criteria such as: having a start event, having a stop event, and minimal number of events then is filtered out from further analysis. The start event, the stop event, and the minimal number of event instances are domain specific values and have to be defined by domain experts who are familiar with the observed process. Figure 21 depicts an example of the run-in and run-out effects. Based on the algorithm explained above, the process instance A and the process instance F are not a part of further analysis, because they do not meet the criteria. The process instance A does not have a start event instance in the observed timeframe and the process instance F does not have a stop event instance in the observed timeframe.\n\n\n\n4.2.6. Domain Specific Algorithms\n\nIn general, the problem of missing information and the non-unique IDs must be solved with domain specific algorithms. The domain specific algorithms include heuristics. Therefore, they do not always guarantee a correct solution. The algorithms based on a lookup table, like the one described above, guarantee exact matching, whereas others such as the solving the non-unique ID’s problem do not always guarantee exact matching and can introduce an error in the results. For that reason, a mechanism that will validate the results based on domain algorithm has to be provided.\n\n4.3 Process Miner Evaluation\n\nAs a part of the domain analysis, a process miner evaluation was performed. The goal was to evaluate which process miner (process mining algorithm) gives the best results for extracting customer profiles.\n\nIn the process mining there are several process mining algorithms that give different structured process definition. The process mining algorithms considered in this project are: the alpha algorithm, the heuristics miner, the genetic miner, and the fuzzy miner. In the context of “Customer Profiles,” two criteria of the algorithms are the most important:\n\n- Semantics of the output\n- Dealing with noise\n\nSemantics of the output means what is the output of the model. This is important for the stakeholders because it gives them knowledge how to perceive the output. In a case of unclear meaning of the output, the output cannot be reused for further analysis. For instance, the alpha algorithm generates a Petri Net Model, the heuristics min-\ner and the generic miner generate a Heuristics Net Model (with clear logical semantics), and the fuzzy miner does not have a clear semantics of the output.\n\nThe second criterion is dealing with noise. This is important for the purpose of this project, because in all the cases in the data analysis phase, real log files were used. The real log files are often incomplete and contain noise. Therefore, an algorithm that deals with noise is more appropriate for this project than the one that does not deal with noise. One of the requirements of the alpha algorithm is that it requires complete log file. Complete log file is a log file that has all the possible combinations of execution of a particular process. This requirement makes the alpha algorithm not appropriate for extracting customer profiles. The fuzzy miner can deal with noise, but the goal of the fuzzy miner is to provide hierarchical model of large and unstructured processes, which was not the case in the context of “Customer Profiles.” The most suitable algorithms for extracting customer profiles are the heuristics miner and the genetic miner because they can deal with noise and they have clear semantic output.\n\nThe heuristics miner is based on the dependency among the events in the process and has several parameters that influence the algorithm results. The idea behind event dependency is elaborated in (Weijters, van der Aalst, & Alves de Medeiros, 2006) and is not going to be explained in this project. To emphasize the importance of the heuristic miner input parameters, three different Heuristics Net models were generated: Model A, Model B, and Model C. The models have same input log file but have different values for the following input parameters: Relative-to-best Threshold, Dependency Threshold, and the Number of Positive Observation. These parameters are related to the event dependency relation and play significant role in the miner output.\n\nIn order to evaluate the result, the proper completion (PC) fitness type is used as a comparison measurement. Proper completion is one (Rozinat, Alves de Medeiros, Günther, Weijters, & van der Aalst, 2008) of the metrics to evaluate the process mining algorithms. Table 4 shows the values for the input parameters and the proper completion (PC) value for each model. Higher value for the proper completion means that the generated model fits better to the input log file. One can easily conclude that by modifying the values for the input parameters, we can generate a Heuristics Net model that fits better to the input log file.\n\n<table>\n<thead>\n<tr>\n<th>Model</th>\n<th>Relative-to-best threshold</th>\n<th>Dependency Threshold</th>\n<th>Positive Observations</th>\n<th>PC</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Model A</td>\n<td>0.05</td>\n<td>0.9</td>\n<td>10</td>\n<td>95.6%</td>\n</tr>\n<tr>\n<td>Model B</td>\n<td>0.2</td>\n<td>0.85</td>\n<td>10</td>\n<td>98.6%</td>\n</tr>\n<tr>\n<td>Model C</td>\n<td>0.2</td>\n<td>0.8</td>\n<td>4</td>\n<td>99.7%</td>\n</tr>\n</tbody>\n</table>\n\nThe Heuristics Net Models show abstraction of the process in log files based on the heuristics driven process mining algorithm. They can be used to express the main behavior (not all details and exceptions) registered in an event log. Figure 22 depicts the graphical representation of the Heuristics Net Models A, B, and C. The circles in Figure 22 represent events. The different color of the circles and the different numbering format of the event names represent different data source. The arcs in Figure 22 indicate the dependency between the events. The dependency measure indicates how certain we are that there is a dependency relation between two activities. A high value (close to 100%) means that there is a very high dependency relation between the connected events. The events can be generated by one or more participants. The models depicted in Figure 22 show process models generated from same input log files, but with different abstraction level. Model A has proper completion level of 95.6% and only one path, which means that the process model has single execution path:\n\nEvent 1 > Event 1 > Event 2 > Event II > Event 3 > Event III > Event IV > Event V > Event 4\n\nThe execution path covers 95.6% of the process instances in the log file. The difference between the Model A and the Model B & C is that Model B and Model C have fork events. We already emphasized that the Heuristics Net Models have clear semantics of the output. The fork events in this report are interpreted as a logical XOR function.\nBased on this, Model B has proper completion level of 98.6% and two possible paths (XOR), which means that the process model has two execution paths:\nEvent 1 > Event I > Event II > Event 2 > Event III > Event 3 > Event 4 > Event 5 > Event IV\nEvent 1 > Event I > Event II > Event 2 > Event III > Event 3 > Event 4 > Event IV\nAn important thing about the Model B is that there are two numbers on the arcs from Event 4 to Event 5 and Event IV, respectively. The top number, as we already mentioned, describes the dependency measure. The bottom number shows in how many process instances Event 5 follows Event 4, and in how many process instances the Event IV follows Event 4. That means that the Model B has two execution paths with 97% and 3% coverage, respectively. In the same fashion the Model C covers 99.7% of the input log files and has 6 different execution paths with different coverage. The conclusion is that by modifying the input parameters for the heuristics miner, one can generate models with different abstraction level. It depends on the stakeholder to decide which model suits best to their needs. In one case single execution path that covers more than 90% of the input log file might be a sufficient result. In other case when the stakeholders need more detailed model or a model that has better log file\ncoverage then adjusting the input parameters is a necessity. A more detailed elaboration of the Heuristics Net Models is placed in the chapter “10. Verification & Validation.”\n\nThe results from the heuristics miner can be satisfactory for the stakeholders, but the heuristics miner requires process mining domain knowledge. Another way to get similar results without knowing the process mining domain is by using the genetic miner. The genetic miner (de Medeiros, van der Aalst, & Alves de Medeiros, 2007) uses genetic approach to generate multiple models that deal with noise and incompletes. To verify the experiments the same input log file was used for the genetic miner and the proper completion was selected. The experiments showed that by using the genetic miner, a list of different models with different proper completion level can be generated. In that case, the stakeholders have to select the most appropriate results from the generated list. The list is ordered by the proper completion level, with the model with the highest proper completion on the top. The resulting list is shown in Table 5. The top three results from the list correspond to the Model C, Model B, and Model A respectively. The rest of the models have significantly lower proper completion (<5%) that makes them completely inappropriate for the stakeholders. The results show that by using the genetic miner the same results as with the heuristics miner can be obtained without deeper knowledge about the dependency relation and the heuristics miner input parameters.\n\n<table>\n<thead>\n<tr>\n<th>Generated Process Model</th>\n<th>Proper Completion</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Model 0</td>\n<td>99.7%</td>\n</tr>\n<tr>\n<td>Model 1</td>\n<td>98.6%</td>\n</tr>\n<tr>\n<td>Model 2</td>\n<td>95.6%</td>\n</tr>\n<tr>\n<td>Model 3</td>\n<td>4%</td>\n</tr>\n<tr>\n<td>Model 4</td>\n<td>2.9%</td>\n</tr>\n<tr>\n<td>Model 5</td>\n<td>1%</td>\n</tr>\n<tr>\n<td>Model 6</td>\n<td>0%</td>\n</tr>\n</tbody>\n</table>\n\nThe conclusion from the process mining evaluation is that the heuristics and genetic miner that can deal with the noise and incompleteness of the log files and can generate models with different abstraction of the real process. The heuristics miner requires process mining domain knowledge. At the same time the genetic miner requires better understanding of the process that has to be extracted but no extended process mining domain knowledge is necessary.\n\n### 4.4 Design Opportunities\n\nA few characteristics were identified early on as necessary for a good design in the context of this project. First and foremost was the desire for a functional prototype that shows the benefit of extracting customer profiles. The prototype should show models of customer profiles extracted by applying process mining techniques on logged data in a production environment.\n\nThe design opportunities in this project, from a high level point of view, are defined by the problem decomposition and its components: data collection and data analysis. There are two main challenges, which at the same time are the main design opportunities. One of them is mapping the ASML domain based on the current logging infrastructure to the process mining domain. The other one is dealing with the missing information. At the same time, the mapping procedure should be domain independent, so TNO-ESI can reuse it for different clients.\n\nBased on the elaboration above and the design criteria explained in (van Hee & van Overveld, 2012) the following three design criteria were selected as the most appropriate for this project:\n\n- Genericity\n- Realizability\n- Impact\nGenericity – This design criterion refers to the extent to which the prototype can be used in other situations. It has to answer to the question is the prototype reusable and portable in another context. Genericity as a design criterion is related with the TNO-ESI’s core idea of open innovation and delivering portable solutions. Portable solutions are solutions that can be easily ported to another customer or domain. In the context of this project, the genericity of the artifact is described and presented with the portability quality requirement elaborated in the chapter “6. System Requirements.”\n\nRealizability – This design criterion answers to the question can the project artifact be made (technologically and economically)? In the context of this project, the technical realizability is considered. This is important because, the basis of the project is applying process mining techniques in specific domains for the purpose of customer profiles. Applying process mining in a specific domain has a certain amount of issues and challenges that have to be solved. Therefore, the technical realizability is a solid design criterion for this project.\n\nImpact – In the context of this project, this design criterion, describes the impact that it has on the other projects and on the environment where it is executed. Figure 9 shows the position of the “Customer Profiles” in the context of the Virtual Fab concept. As it is explained in the chapter “2. Stakeholder Analysis,” different stakeholders can have different benefits and the benefits depend on the final project artifact.\n\nThese three design criteria are revisited in the chapter Project Retrospective. From the list of design criteria in (van Hee & van Overveld, 2012), two design criteria were selected as not relevant for this project. The first one is the inventiveness design criterion. It answers to the question “How new it is?” In this project we apply academic topic in an industrial context and we extend the academic practice of applying process mining with analyzing and combining multiple log file sources. That means the innovation is present in this project, but is not the main focus. The other design criterion is the complexity. It answers to the question does it acquire a complex structure? In the context of this project, we do not consider the complexity level of the project artifact, mostly because it is a proof-of-concept.\n5. Feasibility Analysis\n\nThe main issues and challenges expected during the project are presented. A few of them are detailed in other chapters as well. This chapter also includes a risk list, along with mitigating measures.\n\n5.1 Issues and Challenges\nA list of reviewed issues that are recognized as the ones with high impact on the resulting artifact are described in this chapter.\n\n5.1.1. Domain Knowledge\nGaining the proper level of domain knowledge in order to deliver successful results is a significant issue and a challenge at the same time. The domain knowledge integrates several scientific disciplines starting from the lithography sub-disciplines and semiconductor production process, to data collection, data preprocessing, and process mining. The resulting artifact is tightly coupled with the amount of domain knowledge gained and the speed of gaining domain knowledge.\n\n5.1.2. Domain Abstraction\nTNO-ESI is driven by the idea of providing portable solutions. That means that this project, as a part of TNO-ESI, should separate domain specific from generic problems and aspects.\n\n5.1.3. Different Output\nIn the chapter “2. Stakeholder Analysis” different groups and types of stakeholders are introduced. Every group of stakeholders has different expectations from the project. For instance, the Themis project expects additional information from customer profiles for test case selection in model-based testing; the Magenta project expects customer profiles as behavior models; the Factory Integration Department wants to use customer profiles to recognize the participant behind the behavior. All these constraints influence the resulting artifact, and the alignment of the stakeholder expectations and requirements is a big challenge.\n\n5.2 Risks\nA list of detected risks that would have high impact on the resulting artifact and mitigating measures that were put into place to limit their impact are described in this chapter.\n\n5.2.1. Log Data Availability\nOne of the main risks in this project is the log data availability. The customer log data is the main input for this project; therefore the log data variety, velocity, and volume have high impact on the project results. There are two possible undesirable scenarios: either the log data is not collected at all or the data is collected but there is no access, due to different reasons. In the first scenario, the main scope of the project would be defining data collection strategy, which means providing infrastructure that will support the collection of the log data necessary for extracting customer profiles. In the second scenario, the main strategy would only consist of providing access to\nthe data, which includes elaborating the benefits to the stakeholders. In both cases, the project will have a different amount of effort spent on different activities.\n\n### 5.2.2. Scattered Infrastructure\n\nIn the context of data analysis, a scattered infrastructure is an infrastructure that supports different business goals without a common basis. In the context of this project, an example of a scattered infrastructure would be an infrastructure that has to support a set of very different use cases that have little in common. In that sense, it is a high risk because the project has a wide scope and the output of the project could be a set of different small and not integrated solutions, instead of a coherent solution.\n\n\n\nFigure 23 shows the risk evaluation and mitigation strategy of the risk of having a scattered infrastructure. The main cause for the risk is having very different use cases. The most appropriate preventive control steps are use case selection and role model use case. These two preventive steps were applied in this project and are elaborated in the chapter “12. Project Management.” On the right side is the main impact of this risk: wide project scope and the recovery steps to be taken if the risk happens. The two main recovery steps are grouping of the common use cases and applying domain-based classification. These two steps can be combined in one or used individually. In general, the idea is to group the use cases based on the domain they belong to, so the project scope has an acceptable size. The result from this recovery step is that instead of a set of many different use cases, there is a smaller set of groups of use cases.\n6. System Requirements\n\nThe requirement analysis applied in this project is explained. The chapter continues with the most important high-level functional and non-functional requirements recognized in this project. The main use case for the system architecture and design is elaborated.\n\n6.1 Requirement Analysis\n\nMost of the results of this project are the basis for future research and application projects at TNO-ESI and TNO-ESI’s customers. The artifacts of this project are going to be reused for different purposes; consequently all the requirements that were discussed with the stakeholders are part of the project backlog. However, because of the limited time budget and different priorities of the requirements, MoSCoW analysis (Brennan, 2009) was performed to prioritize the requirements in the project backlog. The MoSCoW analysis categorizes the requirements in one of the following groups:\n\n• M - MUST: Describes a requirement that must be satisfied in the final solution for the solution to be considered a success.\n\n• S - SHOULD: Represents a high-priority item that should be included in the solution if it is possible. This is often a critical requirement but one that can be satisfied in other ways if strictly necessary.\n\n• C - COULD: Describes a requirement that is considered desirable but not necessary. This will be included if time and resources permit.\n\n• W - WON’T: Represents a requirement that stakeholders have agreed will not be implemented in the current release, but may be considered for the future.\n\nThe requirements from the MUST group have the highest priority and the requirements in the COULD group have the lowest priority. The requirements from the WON’T group are not going to be implemented.\n\nDuring the project, slight adjustments were made to the original requirements, mostly because of the candidate’s and stakeholders’ better understanding of the domain problem, and because of the impact of the initial results on the stakeholders.\n\n6.2 Functional Requirements\n\nBased on the communication with the stakeholders, a list of high level functional requirements was created, which was translated into a list of user stories for the project backlog. The most important high level requirements are described in the following section. These requirements belong to the MUST category if it is not stated otherwise. The rest of the requirements are part of the project wiki page and project backlog available at the project management software tool used in this project (“12.4. Project Management Techniques”).\n\n6.2.1. FR1 - Infrastructure for extracting customer profiles\n\nThe most important high level functional requirement is to design and implement a prototype of an infrastructure that supports extracting customer profiles. Every stakeholder has interests in this requirement, especially the ASML stakeholders because they are the first TNO-ESI clients that are using the tool. The infrastructure has to provide output in the form of processed data. The infrastructure should provide a solution for the process mining issues: mapping issue and missing information are elaborated in the section “4.2. Applying Process Mining.”\n6.2.2. FR2 - Input assumption violation check\nThe infrastructure for extracting customer profiles is designed and implemented on\ncertain input assumptions. The TNO-ESI and ASML stakeholders at any time want to\nknow whether the infrastructure behaves correctly when different input is used. The\nstakeholders want to be informed when the input assumptions are violated. There-\nfore, a mechanism that will check how well the infrastructure behaves on different\ninput is required.\n\n6.2.3. FR3 - Log conformance with a predefined model\nThe Themis project is the main stakeholder for this requirement. The requirement\ninvolves conformance checking of a log file with a predefined model. The require-\nment has to be elaborated with an example from the ASML domain.\n\n6.2.4. FR4 - Evaluation of the process mining algorithms\nThe Themis project is the main stakeholder for this requirement too. This require-\nment involves evaluation of the process mining algorithms for protocol based com-\nmunication. Initially, the process mining technique was developed for business pro-\ncess management, which is slightly different from protocol based machine process\nmanagement. Therefore, an evaluation of the process mining algorithms based on the\nprocess mining knowledge, ASML domain data sets, and candidate’s personal expe-\nrience gained during the project was required. This requirement is covered in the sec-\ntion “4.3. Process Miner Evaluation.”\n\n6.2.5. FR5 - Procedure for process mining model generation\nThe project has to result in a procedure for generating process mining models. This\nprocedure is based on the infrastructure that was developed as a part of the project\nand therefore every stakeholder has an interest in the requirement.\n\n6.2.6. FR6 - Static and dynamic model of the participants\nThe stakeholder for this requirement is the Magenta project. This requirement in-\nvolves a static and a dynamic model of the participants in a production environment.\nBased on these models the Magenta project can generate a state machine (behavioral\nmodel) for each participant.\n\n6.2.7. FR7 – Improvement Opportunities\nAnother high level requirement that has to be delivered is a list of improvements of\nthe used tools and the log files. At the same time it involves a list of improvement of\nthe current logging at ASML and recommendations for designing more appropriate\nlogging mechanisms for process mining. TNO-ESI is the main stakeholder of this\nrequirement, because it shows the feasibility of the project and it gives new project\nopportunities.\n\n6.2.8. FR8 - Participant classification based on their behavior\nSeveral stakeholders from TNO-ESI and ASML are interested in this requirement.\nThis requirement involves classification of the participants in a production environ-\nment based on their behavior. There are several solutions for this requirement, based\non different classification algorithms and on different input variables that describe\nthe participant behavior. This requirement is in the SHOULD category.\n\n6.2.9. FR9 - Analyze resources with TRACE\nIn the observed production process, besides the different participants and the control\nmessages, a set of items is also used. One way of tracing item usage in different ac-\ntivities is by using the Tracing Resource ACtivities by Esi (TRACE) (Trace\nDocumentation, 2014) tool. This requirement involves generating a proper input for\nthe TRACE tool from the developed infrastructure. Themis and Magenta projects are the main stakeholders for this requirement, because it gives another insight (created/used items) in the production process. This requirement is in the SHOULD category.\n\n6.3 Non-functional Requirements\n\nAs it is stated in the chapter “2. Stakeholder Analysis,” the main stakeholder for the non-functional requirements is TNO-ESI. Driven by the core idea of open innovation and delivering portable solutions, TNO-ESI expects that the final artifact can be re-used for various clients (Figure 3). Therefore the main non-functional requirement is the portability of the proposed design, in the sense of how easy it is to reuse the system when the environment is changed. The meaning of portability in the context of this project is described in the following subsection.\n\n6.3.1. NFR1 - Portability\n\nPortability in (Bachmann, Len, & Robert, 2007) is a quality attribute of the software architecture that relates to the ease with which software that was built for one environment can be changed to run on a different environment. The different environment in the sense of this project is a different TNO-ESI customer, which means different logging infrastructures and data sources.\n\n(van de Laar & Punter, Views on Evolvability of Embedded Systems, 2011) defines four categories of “How to respond to a change”:\n\n1) Alter nothing in the system (Generic Component)\n2) Alter the parameters of the system (Parameterized Component)\n3) Alter the system but not the architecture (Domain-specific Component)\n4) Alter the system and its architecture\n\nIn order to measure the level of portability of the proposed system, each component and its variations are classified in one of the above categories. With the classification the stakeholder can understand how much the proposed system is portable and how easy it is to use for another client. In the context of this project, portability addresses the following concerns:\n\n- What kind of change has to be made?\n- Who makes the change, the domain expert or the developer?\n- When is the change made?\n\nIf the proposed architecture has an isolated domain then the change can be made by a domain expert via domain knowledge binding. The same change can be made in the development phase or in a production environment. These concerns are the main driver for the system architecture analysis which is elaborated in the following section.\n\n6.3.2. Secondary Non-functional Requirements\n\nDuring the stakeholder meetings a few more non-functional requirements were recognized, but they were categorized as less important or not applicable for this project.\n\n- NFR2 - Performance – In the context of this project, performance is related with the time demand in the data preprocessing steps. This requirement was partly met in the implemented infrastructure.\n- NFR3 - Interoperability – Interoperability is about the degree to which two or more systems can usefully exchange meaningful information via interfaces in a particular context. In this project the infrastructure for extracting customer profiles should export models to different test frameworks. Due to the time budget limitations this requirement is not implemented.\n- NFR4 - Scalability – In several stakeholder meetings, the scalability of the infrastructure in terms of number of observed processes, machines, and participants was discussed. This requirement was not considered because of the prototype nature of the project.\n6.4 Main Use Case\n\nIn the context of this project the term use case is used in two different contexts. The first one is the customer use case. The “Customer Profiles” are extracting the actual usage of the system in a production environment. This is elaborated in the subsection “4.2.1. Identifying Process and Events.” The second context is the project use case. Figure 24 shows the project main use case, which includes Extracting the Production Process. Extracting the Production Process corresponds to the selection of a process. If we take a look to the functional requirements elaborated above, extract the production process corresponds to FR1 and FR5. The project use case is the main use case for the system design and architecture activities elaborated in the following chapters.\n\n\n7. System Architecture\n\nThe system architecture proposed and developed in this project is elaborated. The architectural reasoning and the design decisions that support the architecture are emphasized.\n\n7.1 Introduction\n\nIn order to develop the most suitable system architecture, the attribute-driven design (Bass, Clements, & Kazman, 2012) methodology was applied. The attribute-driven design is a methodology to create software architectures that takes into account the quality attributes of the software. The methodology consists of the following steps:\n\n1. Choose an element of the system to design\n2. Identify the architecturally significant requirements (ASR) for the chosen element\n3. Generate a design solution for the chosen element\n4. Inventory remaining requirements and select the elements for the next iteration\n5. Repeat steps 1-4 for each element of the system design until all the ASRs have been satisfied\n\nFor the purpose of this project, the attribute-driven design was applied in several iterations in a top-down approach. In the first iteration, the “element” to begin with was the system itself from a high level point of view. The rest of the iterations are related with the design of the system components and they are part of the following chapter.\n\n7.2 Architecturally Significant Requirements\n\nThe second step of attribute-driven design is identifying the architecturally significant requirements for the system under design. Architecturally significant requirements are requirements that drive the architectural design and they are divided in three groups:\n\n- functional requirements\n- quality requirements\n- constraints\n\nThe functional and quality attributes are elaborated in the previous chapter. From a system architecture point of view, the most important functional requirement is providing an infrastructure for extracting customer profiles (FR1) and the most important quality attribute is the portability of the provided infrastructure (NFR1). From functional point of view, the system architecture should realize the main use case depicted in Figure 24. During the design phases and the stakeholders meetings, there was no constraint recognized. The project artifact will be used as a prototype and therefore no particular design constraints were considered.\n\n7.3 Architectural Reasoning\n\nFrom a functional point of view, the system under design receives input, processes the input and produces an output. From a more generic point of view, the system must process or transform a stream of input data. The input is represented by different log data and the output is the actual customer profiles. Before going further with the architectural reasoning, an important step is to review the quality attributes and to select which tactics suit this project the best. The most important quality attribute is the portability of the proposed architecture. In (Bachmann, Len, & Robert, 2007) are elaborated the following tactics of how to design a portable system\n\n- Reducing the cost of modifying a single responsibility\n• Increasing cohesion\n• Reducing coupling\n• Deferred binding\n\nBased on the modifiability tactics analysis, we need an architecture that will reduce the cost of modifying a single component, which means we need a component-based architecture. Further, we need to increase the component cohesion, which means that each component has to be responsible for a semantically different task. For some type of log data, we might need a different preprocessing technique, which means we need one or more intermediate steps. In order to make the architecture generic and suitable for different domains, we need to provide an engine for domain knowledge binding. As we emphasized in section “4.2. Applying Process Mining,” the architecture has to enable integration of a client specific Mapping-rule Repository and a Complementary Information Repository. This constraint leads to the deferred binding tactics, especially the start-up time deferred binding. In that case the customer can inject the domain knowledge in form of parameters, a library, or a repository. The architectural pattern evaluation (Bachmann, Len, & Robert, 2007) in Table 6 shows several architectural patterns that increase cohesion and reduce coupling, but only the Pipes and Filters pattern provides deferred binding time, more precisely Start-up binding. Therefore, the architectural pattern that the most completely satisfies the functional (FR1, FR5) and quality requirements (NFR1), is the Pipe and Filter pattern.\n\n### Table 6 - Architectural Patterns and Modifiability Tactics\n\n<table>\n<thead>\n<tr>\n<th>Pattern</th>\n<th>Increase Cohesion</th>\n<th>Reduce Coupling</th>\n<th>Defer Binding Time</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Maintain Semantic Coherence</td>\n<td>Abstract Common Services</td>\n<td>Use Encapsulation</td>\n</tr>\n<tr>\n<td>Layers</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Pipes and Filter</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Blackboard</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Broker</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Model-View-Controller</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Presentation-Abstraction-Control</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Microkernel</td>\n<td>X</td>\n<td>X</td>\n<td>X</td>\n</tr>\n<tr>\n<td>Reflection</td>\n<td>X</td>\n<td>X</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n### 7.4 Pipes and Filters\n\nThe Pipes and Filters architectural pattern (Buschmann, Meunier, Rohnert, Sommerlad, & Stal, 1996) provides a structure for systems that process a stream of data. It divides the task of a system into several sequential processing steps and each processing step is encapsulated in a filter component. This means that the pattern provides high cohesion by task decomposition (each filter component is responsible for a different subtask). At the same time, the pattern reduces coupling by encapsulating the filter components. The most important benefit of the Pipes and Filters pattern is the start-up time binding. This means that one can easily bind domain knowledge at the moment of the filter component invocation. In the interest of simplicity, from this point, by component in the Pipes and Filters pattern we mean the filter component.\n7.5 System Architecture\n\nThe generic system architecture for extracting customer profiles by using process mining techniques, based on the Pipes and Filters architectural pattern is given in Figure 25.\n\nFigure 25 System Architecture for Extracting Customer Profiles\n\nThe pipeline starts with a Data Source component. Data Source is a special component that has only an output port. In general, a data source component can be anything, a file system, a relational database, or a real time event listener. The role of the data source component is to feed the pipeline with input data. The data stream from the data sources goes to the Event Parser component. The Event Parser compo-\nnent corresponds to the Extractor shown in Figure 15. This component solves the mapping challenge in process mining explained in subsection “4.2.2. Mapping Rule Repository.” The Event Parser component uses customer specific mapping rules from the Mapping-rule Repository to extract event instances (Event Instance). The dependency relation between the Event Parser component and the Mapping-rule Repository explains the deferred binding functionality that the Pipes and Filters pattern offers. The mapping rules can be injected into the repository before the Event Component is executed.\n\nIn the section “4.2.3. Missing Information” we mentioned that the data sources can have additional information that can be used for event instance enrichment. The Item Parser component in Figure 25 has to extract complementary information and to store it in the Complementary Information Repository. In order to perform the extracting, the Item Parser component uses dedicated customer specific mapping rules from the Mapping-rule Repository.\n\nIf the extracted event instances are incomplete they are sent to the Event Enricher. The Event Enricher component corresponds to the Enricher shown in Figure 16. This component solves the missing information problem. The component enriches the incomplete event instance (Event Instance’) object with complementary information and sends Event Instances to the MXML Serializer component. In the case when the extracted event instances are compliant with the Standard Log Model, then the enrichment step is not necessary and the Item Parser and the Event Enricher component can be left out of the architecture.\n\nThe MXML Serializer component has the role of a transformer; it transforms the Event Instances (Figure 14) into the mining xml file, which is input for the Process Miner component.\n\nThe Process Miner filter is part of ProM 5.2 (Process Mining Tools, 2014). ProM 5.2 is a generic open-source framework for implementing process mining tools in a standard environment. The Process Miner component extracts process models out of the input mining xml file by using process mining algorithms.\n\nThe pipeline in the architecture ends with a Process Model Visualizer. The Process Model Visualizer is a component that visualizes the generated process models. This component is also part of ProM 5.2.\n\nThe pipeline in the architecture does not necessarily have to end with a Process Model Visualizer. In general, the last component in the pipeline can transfer the data stream to another system. For instance, the process models extracted with the Process Miner component can be sent to a testing system. This is important, because it shows that the selected architectural pattern supports additional quality attributes such as extensibility and adaptability.\n\nApplying customer profiles based on process mining at ASML showed that in the real production environment, more often there are multiple log data sources (Figure 18). That means that the architecture should provide different Data Source components for different log data sources. In that case, the generic system architecture for extracting customer profiles by using process mining techniques, based on the Pipes and Filters architectural pattern, looks like the one in Figure 26.\n\nOne can easily conclude that if there are multiple different log data sources as input to the system, then separate Data Source and Event Parser component are necessary for each type of log data source. Different Event Parser components have dedicated mapping rules in the Mapping-rule Repository.\n\nIf the event instances are incomplete there is an Event Enricher component for each Event Parser that parsers incomplete event instances. The Event Enricher components use the data stored in the Complementary Information Repository to enrich the incomplete event instances. Further on, the event instances are sent to the next component, Event Combiner. The Event Combiner component role is to collect all of the Event instances extracted from different data sources in a single Log object (Figure 14). In the literature (Buschmann, Meunier, Rohnert, Sommerlad, & Stal, 1996), this variation of the Pipes and Filters pattern where a component has multiple inputs is called Join Pipes and Filters System. The proposed architectures shown in Figure 25 and Figure 26 depend on the data sources. If they contain additional information that can be used for event instance enrichment, then each data source has an Item Parser component (in Figure 26 is shown only one to illustrate the scenario).\nFigure 26 Multiple Data Source System Architecture\nOne of the requirements (FR9) is that the Trace tool should be used to analyze the results. For that purpose the generic system architecture for extracting customer profiles by tracing the used items during the main production process is shown in Figure 27.\n\n\n\nFigure 27 System Architecture Trace\n\nFigure 25, Figure 26, and Figure 27 show UML component diagrams of three variations of the proposed architecture. None of the variations is final, because the final architecture depends on the number of data sources and the output of the system. Before we start designing an architecture for a certain TNO-ESI customer we have to answer the following questions:\n\n- How many data sources does the client have?\n- Do the data sources contain complete or incomplete event instances?\n- Do the data sources contain complementary information?\n- What is the output of the system (Process Models, Tracing Models, or log visualization)?\n\nWith the answers on the questions above, a different implementation of the referenced architecture can be proposed for a different TNO-ESI customer. Based on the recommendations for documenting Pipes and Filters architecture in (Clements, et al., 2010) the filters are represented with UML components and the pipes are UML associations with a «pipe» keyword. For the purpose of this project the pipe elements are left out of the design and implementation. In the proposed architecture we assume that the components exchange event instances in different formats such as text files or memory objects and there is not buffer size limit. In the next chapter, the more specific pipes are presented with information flow association. Further on, each component can have an input, an output, or both ports. Each port can provide or require services to the other component. Whether it requires of provides a service depends on the implementation of the component.\n\n### 7.6 System Component Overview\n\nOne of the benefits of the Pipes and Filters architectural pattern is to maintain the semantic coherence of the components. The semantic coherence is achieved by splitting the responsibilities among the components. Subsequently, each component in the architecture has dedicated responsibilities. The responsibilities are grouped by the way they process the input data. In the pattern definition (Buschmann, Meunier, Rohnert, Sommerlad, & Stal, 1996) there are three types of filters:\n\n- Enricher\n- Refiner\n- Transformer\n\nOne component can be responsible for data enriching by computing and adding information, for data refining by concentrating or extracting information, or for data transforming by delivering data in some other representation. The component operates independently and does not depend on other processing steps. Figure 28 shows classification of the system components in the proposed architecture based on their responsibilities. The Data Source and the Data Sink components have a special responsibility. The Data Source only has an output port and is responsible to provide data input to the system. The Data Sink only has an input port and is responsible to present the final processed data. The Trace and the Process Model Visualizer are Data Sink components in the proposed architecture.\nThe filter component inherits from the Data Source and the Data Sink components and has an input and an output port. The rest of the components inherit from the filter component. Depending on their special responsibilities each component implements a different functional interface. The Event Enricher enriches incomplete event instances and therefore implements the Enricher interface.\n\nThe MXML Serializer and the Trace Transformer transform the event instances from one format to another and therefore they implement the Transformer interface. The Event Parser, Event Combiner, and the Process Miner refine event instances by concentrating (Event Combiner) or by extracting (Event Parser and Process Miner) information. The Item Parser extracts Item instances, and therefore implements the Refiner interface. In the following chapter the design decisions for each component are elaborated.\n\n### 7.7 Component Portability Level\n\nIn order to define how portable (see subsection NFR1 - Portability) are the components, three categories of portability were defined:\n\n1. **Generic Component** – no alternation is needed\n2. **Parameterized Component** – alternation of the component parameter(s) is needed\n3. **Domain-specific Component** – complete alternation of the component is needed\n\nEach category of component portability has a different color (Figure 29) and the same coloring is used for the diagrams in the following chapter. Along with the coloring, appropriate keywords are introduced to state the portability level of the component: «generic», «parameterized», and «domain-specific».\n\n\n\n\n8. System Design\n\nThe design of the components of the system architecture is elaborated. The goal, the variations, and the design decision of the most significant components are emphasized. In order to interpret the portability level of the components the amount of changes per component in case of porting to other TNO-ESI clients is discussed.\n\n8.1 Introduction\n\nAfter the first iteration of the attribute-driven design methodology elaborated in the previous chapter, a few more iterations were executed. The goal of these iterations was to define the design of the most significant components in the proposed architecture. The architecturally significant requirements for each one of the most significant components were defined by the component functional requirements. For instance, the Data Source component has to provide input stream of data, the Event Parser has to extract an event instance from the input data, the Event Enricher has to enrich incomplete event instance into event instance, and the Event Combiner has to combine event instances from multiple sources. In this chapter the component design goes one level deeper in the details.\n\n8.2 Data Source Design\n\nThe main goal of the Data Source component is to provide input data for the system. According to (Buschmann, Meunier, Rohnert, Sommerlad, & Stal, 1996), the data source represents the input to the system, and provides a sequence of data values of the same structure or type. Examples of such data sources are a file consisting of lines of text, or a sensor delivering a sequence of numbers.\n\nTraditionally, the logging mechanisms store the logging data in text files. There are many reasons for that, but one of them (Common Log Format, 2014) is that the plain text format minimizes dependencies on other system processes such as: writing to a database or writing to a cloud storage system. The plain text format assists logging at all phases of computer operation including start-up and shut-down where such processes may be unavailable.\n\nIn the design of the Data Source we made the assumption that the input data is always stored in log files. Therefore, the main function of the Data Source component is to read the log files and to select a certain amount of data that represents a possible event instance. Storing the log data in plain text files gives freedom to the developers to define their own formats and styles. For that reason we assume that there are three types of log file structure:\n\n- Plain Text Structure (including Coma-separated Value Structure)\n- XML Structure\n- Nested Structure\n\nFor the log files with plain text structure, we assume that each line of text represents data for single event instance. With this assumption the Data Source component has to read the log file line by line and send each line of text to the next component. In the Data Source for log files with plain text structure an explicit definition of the amount of data to select is not necessary. That makes the solution domain independent and generic. In the context of ASML, we witnessed log files with “Comma-separated values” (CSV) format. In the design of the Data Source component they are treated the same as the plain text files.\n\nIn case of XML log files, the data source has to read the XML log file and query for the nodes that represent possible relevant event instances. The XML Data Source component is generic and does not require domain specific implementation. For the log files with nested structure, the design and the implementation depend on the domain specification. In general, log files with nested structure can be found in the industry and usually they define nested process instances with multiple event\ninstances. There is no standard specification of the nested structure (like number of nested statements, attributes, properties, etc.) and therefore the design of the data source component for structures like this is not trivial.\n\nIf we take a look at the proposed Pipes and Filter architecture, the data processing direction is from domain specific to generic. That means that the components on the left most side are more domain specific and the components on the right most side are more generic. This observation makes the Data Source component the most domain specific, which corresponds to the analysis elaborated above.\n\nIn order to illustrate the portability of the proposed Data Source components a component diagram is shown in Figure 30. The Text Data Source and the XML Data Source are generic components and can be reused for different TNO-ESI clients’ without any change. The Nested Structure Data Source, because of the complexity of the structure is a domain-specific component.\n\n8.3 Event Parser Design\n\nIn general, the Event Parser component has to extract an event instance from the input data. It has to read all the customer specific mapping rules from the mapping-rule repository and then to check whether the input data confirms to one of the rules. The design of the Event Parser component depends on the design of the corresponding Data Source component.\n\nFor Text Data Source the most common way to extract information from a text is by using regular expressions. For that reason, the customer specific mapping rules are actually an array of regular expressions loaded (Figure 31.a) in the Event Parser component. In this scenario the Event Parser component is named RegExp Event Parser. The RegExp Event Parser component checks whether the input data matches to one of the regular expressions. If there is a match, a new event instance is created and is sent to the next component in the architecture. One way to implement this use case is by using the strategy pattern. The strategy pattern (Gamma, Helm, Johnson, & Vlissides, 1994) is a software design pattern that enables an algorithm's behavior to be selected at runtime. It defines a family of algorithms, encapsulates each algorithm, and makes the algorithms interchangeable within that family. In the context of our problem (Figure 32), the pattern goal is to read the regular expressions at startup and to create encapsulated event parsers from each mapping rule. At the runtime, when the executeStrategy method from the EventParserContext is called, then each Event-\nParserImp is executed on the input string. If there is a match, a new event instance is created and is sent to the next component. If there are multiple matches or no match, statistical data (number of matches per regular expression) is collected for the FR2 - Input assumption violation check requirement (FR2).\n\n\n\nIn the case of XML Data Source, the Event Parser component is actually a XSLT Transformer. It reads the (Figure 31.b) customer specific XSLT Stylesheet from the XSLT Stylesheet Library and transforms the input XML file in Standard Log Format. If the extracted event instances from the RegExp Event Parser or from the XSLT Transformer do not conform to the Standard Log Model, then they have to be enriched with complementary information. For that purpose, the component model looks like the one shown in Figure 35. The RegExp Event Parser and the XSLT Transformer in Figure 35 send incomplete event instances to the Event Enricher. The design of the Event Enricher component is explained in the following section. From this point of view, one can argue whether the Event Parser component has to realize the Refiner or the Transformer interface. In general, it depends on the tasks the component has. In the case of regular expression parsing, the component refines the input data and produces event instance as output. In the case of XML Data Source, the event parser transforms one form of presenting event instances to another.\n\n### 8.4 Event Enricher Design\n\nIn the chapter “4. Domain Analysis” we already emphasized that in applying process mining next to the mapping problem there is one more challenge. The missing information scenario and incomplete event instances is a real and common problem. Therefore, in the proposed architecture we introduced one more component, the Event Enricher. The Event Enricher has simple functionality, to enrich the incomplete event instances with the missing information. After the enrichment process, the event instances will be compliant to the Standard Log Model (Figure 14). The implementation of this functionality can be quite complex, and can consist of several sub functions, because it cannot be foreseen which information is missing for a different TNO-ESI clients. Therefore, the Event Enricher component in general is domain-specific and depends on the missing information.\n\nAn example of missing information is the join problem at ASML (Figure 18). One way to solve the join problem at ASML is by introducing a lookup table. In the design, the lookup table is customer specific and is bound to the Event Enricher component at start-up time. The design of the Event Enricher component in interaction with the rest of the components in the architecture is shown in Figure 33.\nThe functionality of the Event Enricher can be easily solved with the Visitor Pattern (Gamma, Helm, Johnson, & Vlissides, 1994). The visitor design pattern is a way of separating an algorithm from an object structure on which it operates. The Visitor Pattern separates the Event Enricher from the incomplete event instances that have to be enriched. Figure 34 shows the internal design of the Event Enricher component. The ConcreteVisitor class uses information from the Lookup table to enrich the incomplete event instances. For this purpose, the incomplete event instance has to have an accept method that accepts the Visitor class.\n\nFor the join problem illustrated in Figure 18, the ConcreteVisitor class is a generic class, because it knows exactly how to fix the join problem by using information from the lookup Table, which is domain specific. The join problem is only one of the possible missing information challenges. Therefore, the ConcreteVisitor class is not TNO-ESI client specific, but solves only a certain category of problems (Figure 18). For any different problem of missing information a problem specific implementation of the Visitor Interface and the missing information repository is required. There might be a use case in the TNO-ESI clients’ environment with multiple different data sources of incomplete event instances. If we assume that the incompleteness of the event instances is from same category as the join problem, then one possible design is shown in Figure 35.\n\n8.5 Collecting Missing Information\n\nIn the chapter “7. System Architecture,” we mentioned that the additional information that we need to enrich the incomplete event instances can be found in the same log files that we use as an input in the system. Therefore, the architecture has to support additional information extraction from the Data Source components. For that purpose we introduced one more component, the Item Extractor component. The Item Extractor component extracts couples of ItemInstance and ProcessInstance. The couples are stored in the Lookup table. The interaction of the Item Extractor with the rest of the components is shown in Figure 36. The Event Enricher component uses\nthe couples stored in the Lookup table to enrich the incomplete event instances with the missing Process Instance ID.\n\nThe design of the Item Parser component is the same as the design of the Event Parser component (Figure 32). It uses dedicated regular expressions from the regular expression library and uses the Strategy Pattern to read the regular expressions at startup and to create encapsulated item parsers from each mapping rule.\n\n8.6 Event Combiner Design\n\nThe Event Combiner component has domain-specific functionality, which makes the design of the component domain-specific. In general, the role of the Event Combiner component is to collect event instances linked with process instances from different data sources and to group them together. The main challenge is to recognize duplicate process and event instances. Treating duplicate process instances as different can\ninfluence the process model of the observed process. Therefore, definitions of duplicate process instance and event instance are necessary. Usually, the definition of duplication is domain specific and includes heuristics. For instance, within ASML, there were multiple process instances with the same name. Therefore, we introduced a heuristic approach that assumes that there is only one active process instance with that name at one moment at the time.\n\n8.7 Mxml Serializer Design\n\nThe Mxml Serializer component is a transformer. It transforms an array of event instances into a mining xml file. For that purpose, it uses the OpenXES (pronounced as “open excess”) library. OpenXES (Günther & Verbeek, 2014) is a reference implementation of the XES standard for storing and managing event log data. In general, the Mxml Serializer component converts event instances compliant with the Standard Log Model into entities of the OpenXES Model. In this case, there is a transformation from one generic model (the Standard Log Model) to another. Therefore, the design of the component is generic and can be reused for any TNO-ESI customer.\n\n\n\n8.8 Trace Transformer Design\n\nSimilar to the Mxml Serializer component, the Trace Transformer component has to transform a data set from one model to another. The input for the Trace component consists of resources and claims that the resources were used in a certain time period. In the context of the “Customer Profiles,” the resources are item instances used in the process instances (claims). In the case of the join problem, we already have a lookup table (Figure 38) with couples of item instance and process instance. Therefore, the Trace Transformer reads the couples from the lookup table and transforms them into resource and claim. From a more abstract point of view the architecture has to have a dedicated Data Source for item instances used in process instances. In that case, the architecture has dedicated pipeline for extraction and visualization of the item-process dependencies (Figure 27).\n\n\n\n8.9 Ready-made Components\n\nThe Process Miner and the Process Model Visualizer components are part of the ProM 5.2 framework and are used as a ready-made parameterized component. The selection of the most appropriate process mining algorithm and the selection of the input parameters are elaborated in the chapter “4 Domain Analysis.” The Trace component is a product developed by TNO-ESI. In this project is also used as a ready-made component.\n9. Implementation\n\nThe most significant details from the implementation of the project prototype are elaborated. The chapter also focuses on the implementation details and the implemented measurements to check the healthiness of the implemented prototype.\n\n9.1 Introduction\n\nAs a part of this project, a prototype was implemented. The prototype was based on the proposed architecture and it covered the use case from ASML. As we defined, the final architecture of the solution depends on the following aspects:\n\n- How many data sources does the client have?\n- Do they (data sources) contain complete or incomplete event instances?\n- Do they (data sources) contain complementary information?\n- What is the output of the system (Process Models, Tracing Models, or something else?)\n\n9.2 Prototype\n\nThe prototype had to satisfy the functional requirements (FR1, FR2, FR5, and FR9) elaborated in the section “6. System Requirements.” Therefore, based on the project main use case and the functional requirements the architecture of the prototype has three different data sources. Each of the data sources consists of plain text log files with different structure. Sequentially, three different data sources and three different RegEx Event Parsers were implemented. In the use case, only one of the data sources contains complete event instances and the other two data sources have incomplete event instances. For the data sources with incomplete event instances dedicated Event Enricher components were implemented. The multiple data sources impose an Event Combiner component that combines the event instances from the different data sources. The prototype had to generate customer profiles based on process mining and resource tracing. Therefore, appropriate Mxml Serializer and Trace Transformer components were implemented. The final architecture is shown in Figure 39. For the three RegEx Event Parser components a common RegEx Library was implemented. The library contains dedicated classes for each RegEx Event Parser component and each class has a set of methods that represent different regular expressions. In fact, there is a regular expression for each event (complete and incomplete) that can be found in the data source and that belongs to the observed production process.\n\n9.3 Decisions\n\nDuring the implementation, several decisions from technology and component implementation aspect were made. They are elaborated in the next sections.\n\n9.3.1 Technology\n\nFor the first part of the project, the data analysis phase, a set of Python scripts were developed to extract event instances from the log file. This phase contained several analytics use cases (see the chapter “12. Project Management”.) The goal of the analytics use case was to explore information in the available data sets. The Python scripts were used to extract events with regular expressions.\nFigure 39 Implemented Architecture\nThe regular expressions from this phase were used for the Regular Expression Library implemented as a part of the prototype. The prototype is implemented in the Java programming language with Java SE Development Kit 7. There was no constraint from the stakeholders about the programming language selection. Based on candidate’s personal preference the Java development environment was selected. Eclipse Kepler Service Release 2 was used as integrated development environment. This version is selected because it supports the Trace tool (Trace Documentation, 2014).\n\n9.4 Prototype Healthiness\n\nIn order to meet the requirement FR2, a mechanism to collect and to display statistical data was implemented. It is important for the stakeholders to get quick feedback about the prototype healthiness when there is a different input data set. Therefore, during the execution of the prototype two values are collected: the number of event instances and number of process. This information gives a very quick view of the healthiness of the prototype. The stakeholders have quick answer to the question: “Are we extracting the expected number of event instances and process instances from the log files?” The collected statistical data is presented with JFreeChart Library v.10.017, which is a Java chart library. One example output is depicted in Figure 40.\n\nThe horizontal axis represents the number of files and the vertical axis presents the number of event and process instances respectively. The lower (blue) line shows the number of total process instances. The upper (red) line shows the number of event instances.\n\n\n\nOne can easy conclude that there are different slopes in the number of event and process instances extracted from the log files. This can be explained with the fact that as an input to the prototype, three different log files are used (Figure 18.) Each file has its own number of event and process instances. The blue line, in the beginning of the chart, grows till certain value and after that is constant. That means that only in the first type of log files there are process instances. The red line grows all the time, but with different slopes. This means that each log file type has different number of event instances. The result can be used to get quick overview whether the prototype extracts process and event instances or there is a problem.\n\n9.4.1. Component Implementation\n\nThe components in the prototype were implemented according to the component design elaborated in the chapter “8. System Design.” Based on the amount of the data that had to be processed with the prototype it was decided that the components can be implemented in a push pipeline scenario. The push means that after one component is ready then it sends the output to the next component in the pipeline. Another implementation decision is that the components are part of one process; they are not separate execution processes in the operating system. Again, this decision is justified only if the amount of the data that has to be processed is in the same scale as the one that had to be processed with the prototype.\n9.5 Deployment\n\nConsidering the fact that the result of the software development is a prototype, special deployment analysis was not conducted. The prototype is implemented with the Java development environment and in general can be deployed in any production environment that hosts Java Virtual Machine. Next to the prototype, the process mining tool and the Trace tool are also implemented in Java and therefore they can be executed in the same development or deployment environment as the prototype.\n10. Verification & Validation\n\nIn this chapter the verification and validation techniques applied in the project are elaborated. Their goal is to make sure that certain rules are followed at the time of development of the prototype and also to make sure that the prototype fulfills the required specifications.\n\n10.1 Validation\n\nThe validation techniques should answer on the question: are we building the right thing? In a research project, the first thing that has to be done is to perform experiments and to communicate the research results with the stakeholders. This project was executed in two phases. The first phase was research oriented and the second phase was software development oriented. The research results were communicated with the stakeholders. During the stakeholder meetings the results were directed towards reaching the stakeholder business goal: definition of customer profiles that satisfies the requirements. After several iterations the stakeholders agreed on the definition of the customer profiles based on process mining models and different visualization techniques. In the context of this project a customer profile is represented with Heuristics Net Models (Weijters, van der Aalst, & Alves de Medeiros, 2006), which are abstraction of the actual process. To get better understanding of the results, dotted and trace charts were introduced. With the experiment results from the data analysis phase a validation of the project output was performed. All the stakeholders agreed that the customer profiles defined with the charts and models satisfies their expectations.\n\nIn order to validate that the defined approach delivers the same results for different TNO-ESI clients, the approach had to be tested on different use cases. Different use case is use cases from different ASML’s clients and from different customers from the TNO-ESI’s clients. In this project, the validation was only performed on different use cases from different ASML’s clients. Examples of the defined customer profiles extracted from different data sets are elaborated in the following subsections.\n\n10.1.1. Dotted Charts\n\nDotted charts show a spread of event instances of an event log over time. The basic idea of the dotted chart is to plot dots according to the time. There is no abstraction or generalization in the dotted charts. They group event instances by the process instances.\n\nIn general, the dotted charts are used to get a quick overview of the processed log files. The dotted charts show the main process instance flow and can help in detecting deviations from the main production process. Figure 41 shows an example of a dotted chart generated as a part of the experiments executed with a data set from one of the ASML’s clients. The horizontal axis presents the actual time and the vertical axis presents different process instances. The process instances are ordered by the event instance time of their first event instance. Each color presents a different event. Each colored dot presents different event instance. The dots that lie on the same horizontal line present event instances that belong to the same process instance. All the event instances follow the production process (which is presented with the diagonal line in the Figure 41. Therefore, it is easy to detect outliers (event instances that are not part of the expected behavior) or breaks in the production process (like the one in the middle of Figure 41.\nFigure 41 Dotted Chart - Production Process\n\nFigure 42 shows zoomed in view of the Figure 41. Looking at the distribution of the colors it can be easy concluded that the event instances follow a certain pattern. The pattern they follow is extracted with the Process Miner Component. Another conclusion is that there are event instances that occur periodically for every process instance. That shows that in a production environment there are participants with different behavior, which is the first step in participant classification based on their behavior. Some of them are process triggered, and some of them are triggered by an external trigger but still belong to the same process instance.\n\nFigure 42 Dotted Chart - Zoomed In View\n\nFigure 43 shows another view of the same data depicted in Figure 42. Here all the event instances are shown with relative time. It is easy to conclude that each process instance starts with the same event (same color). After that there is some regular distribution of the events, which means that each process instance follows some pattern. For the stakeholders this chart is important because different patterns in the time intervals can be observed. The pattern of event order execution can be extracted with the process mining algorithm, which is elaborated in the following section.\n10.1.2. Heuristics Net Models\n\nBased on the problem depicted in Figure 18, a set of Heuristic Net Models were generated. A description of the Heuristics Net Models is given in the section “4.3. Process Miner Evaluation.” In the Log File Source A, in Figure 18, four complete events that belong to the main production process have been recognized. These events are part of the Extended Log Model (Figure 20), and they are tagged as Event I, Event II, Event III, and Event IV. The model generated by using only the Log File Source A, is shown in Figure 44. One can easy conclude that the Process Model is straightforward from Event I to Event II, then to Event III, and then to Event IV.\n\nFigure 45 illustrates the Process Model generated by using only the Log File Source B from Figure 18. In the Log File Source B, five complete events that belong to the main production process have been recognized. These events are tagged as Event 1, Event 2, Event 3, Event 4, and Event 5. One can conclude that the model depicted in Figure 45 is very similar to the one depicted in Figure 44. The model presents the same Process as in Figure 44, but with different events.\n\nAfter communicating with the stakeholders, it was concluded the models show expected behavior. The stakeholders expect that the events are executed in the same order as the one in the process model. The next step was to combine the Log File Source A and Log File Source B, and to generate a process model that will describe the event execution. The result is depicted in Figure 46. The process model in Figure 46 shows the order of the execution of the events from the two Log File Sources.\nA&B. The high value of the dependency measure among the events tells that the process is executed straightforward and without any significant deviations.\n\n\n\nFor the stakeholders, this model has more value than the previous because of several reasons. First, the model shows multiple participants, the different event color means different log source file, but in this case it also means different participants. Second, the model shows expected event execution order. The stakeholders expect straightforward execution of the events in some order.\n\nThe models elaborated above mostly show expected behavior. During the meetings with the domain experts it was concluded the presented models do not bring new business value. Therefore, in the analysis it was included the Log File Source C. It was expected that there are multiple events that belong to the same process. The data analysis showed that there are multiple events executed by different participants, but they are incomplete events. This problem is depicted in Figure 18. The final data set contains event instances from the three log file sources. In the data set there are different event instances from different events and from different participants. Figure 47 depicts a Heuristics Net model of the events from the three log file sources and three different participants. In this case still different color means different log file source and different participant. From the Log File Source C was recognized only one event, Event A. The most important thing about this model is the deviation from the expected event order execution. The deviation is depicted with the fork branch from Event IV to Event V and Event A. For the purpose of this project, the fork events in the Heuristics Net Models are treated as logical XOR functions, which mean that after the Event IV it can execute Event A or Event V, but not both. The deviation tells that not each process instance has the same execution path. One can notice that there are two numbers on the arcs from Event IV to Event V and Event A, respectively. The top number, as we already mentioned above, describes the dependency measure. The bottom number shows in how many process instances Event 5 follows Event 4, and in how many process instances the Event A follows Event 4. In other words, 75.7% of the process instances have the following execution path, which exclude Event A:\n\nEvent 1 > Event I > Event II > Event 2 > Event III > Event 3 > Event 4 > Event 5 > Event IV\n\nand 24.3% means that 24.3% of the process instances have the following execution path, which include Event A:\n\nEvent 1 > Event I > Event II > Event 2 > Event III > Event 3 > Event 4 > Event 5 > Event A > Event IV\n\n\n\nFor Themis stakeholders the process model actually tells that with two test cases (based on the two execution scenarios) they can simulate the actual usage of the system with the selected participants. One of the test cases covers 75.7% percentage of the process instances (it can be interpreted as 75.7% of the time) and the other test case covers the 24.3% of the process instances.) For Magenta stakeholders the generated process models are important because they satisfy the functional requirement FR6 - Static and dynamic model of the participants. From the process models a Uni-\n\n56\nfied Modeling Language (UML) Sequence Diagram can be extracted and from the Sequence Diagram can be extracted a UML State Machine Diagram for each participant in the model.\n\nThe Heuristics Net Models in practice are far more complex. For instance, Figure 48 depicts a Heuristics Net Model of the same process as in the previous models, but different events (Event B, Event C, Event D, and Event E) from the Log File Source C.\n\n![Figure 48 Complex Heuristic Net Model (Sources A,B,&C)]\n\nBefore we analyze the results from Figure 48, we want to assume that between the Event 4 and the Event 5, any possible permutation of Event B, Event C, Event D, and Event E can happen. If a repetition of the events is allowed then we have infinite number of possible scenarios. If there is no repetition allowed then we have 65 possible scenarios. Similar to the previous observations, from the model depicted in Figure 48, we can create four execution scenarios. The idea is that, when we have the only a\ndesign model, then the number of test scenarios can be 65 and more. By using the customer profiles we can lower that number to four actual test scenarios. Moreover, these four test scenarios have different value for the stakeholders. Table 7 shows the test scenarios with the appropriate percentage of occurrence of the process instances. With the results we can explain the idea of selecting the most appropriate test cases, or business wise test case selection. The test cases with high coverage are more important for the stakeholders than the one with lower coverage. Based on the results, we do not have to create a test case for each possible event sequence order. With only 4 test cases we can reach 100% path coverage. Furthermore, if we select the first and the second test case, then we cover 99.15% of the cases in the log file, which for different purposes can be a sufficient path coverage.\n\nTable 7 - Event Execution Paths\n\n<table>\n<thead>\n<tr>\n<th>Path</th>\n<th>Event Execution Order</th>\n<th>Coverage</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>I</td>\n<td>Event 1 > Event I > Event II > Event 2 > Event III > Event 3 > Event 4 > Event 5 > Event IV</td>\n<td>89.85%</td>\n</tr>\n<tr>\n<td>II</td>\n<td>Event 1 > Event I > Event II > Event 2 > Event III > Event 3 > Event 4 > Event 5 > Event B > Event IV</td>\n<td>9.3%</td>\n</tr>\n<tr>\n<td>III</td>\n<td>Event 1 > Event I > Event II > Event 2 > Event III > Event 3 > Event 4 > Event 5 > Event C > Event D > Event IV</td>\n<td>0.7%</td>\n</tr>\n<tr>\n<td>IV</td>\n<td>Event 1 > Event I > Event II > Event 2 > Event III > Event 3 > Event 4 > Event 5 > Event E > Event IV</td>\n<td>0.15%</td>\n</tr>\n</tbody>\n</table>\n\n10.1.3. Trace Charts\n\nIn the subsection “4.3.2. Missing Information” we already mentioned that in the log files there is additional information that fortunately can be used to enrich the incomplete event instances into event instances that are compliant to the Standard Log Model. In this project we use the item instances used or created in the process instances to connect the incomplete event instances to the process instances. The Heuristics Net models described above show the process execution from control point of view. They do not tell anything about the resources used in the process execution. If the resources present different data that is used in the production process, then with the current data stored in the Lookup table, an overview of the data flow can be created. In our infrastructure, in the Lookup table there are couples of ItemInstance and ProcessInstance. These couples can tell the information which item was used or created as a resource in which process instance. One way to visualize this is by using the Trace Tool. The integration of the Trace Tool in the proposed architecture is elaborated in the subsection “8.8. Trace Transformer Design.” Figure 49 depicts one output of the Trace Tool.\n\n\n\nThe output is very similar to the one depicted in Figure 41. It shows the same production process, but from different perspective (ItemInstance usage/production). The horizontal axis represents the relative time (first process instance) and the vertical\naxis presents the process instances. Each colored rectangle presents different Item Instance. The length of the rectangles shows how long a certain Item Instances was used/ produced. In fact, the length of the rectangle is the time in which the process instance related with that Item Instance was executed. The purpose of this output is to give quick overview to the stakeholder about the production process but from different perspective. For instance, it might be a scenario in which same Process Instance is using/producing multiple Item Instances, or same Item Instance(s) is used/ produced by multiple Process Instance(s).\n\n10.2 Verification\nThe verification techniques should help in answering the questing: Are we building the thing right? In general, verification in a project with a research part is ambitious. It is ambitious because no one can predict the research results and because the results can show that our approach is not feasible for the purpose.\n\nIn this project, the results from the data analysis phase were used as a basis for the verification. In fact, it means that the data analysis and the software development phase should have the same results. The only difference is that the research results are obtained manually and the results in the software development phase were obtained by using the developed infrastructure.\n\n10.2.1. System Testing\nBy using the approach elaborated above system testing was performed. The completely integrated system was tested to verify that it meets its requirements. In a sense, it tests that:\n\n- the data source components are obtaining data from the data sources\n- the Event Extractor components are extracting the expected number and types of events\n- the Event Enricher components are converting incomplete event instances into complete event instances\n- the Event Combiner components are combining event instances\n- the correct Heuristics Net Models are generated from the Process Miner Component\n- the correct visualization is generated from the Process Mining Visualizer\n\nBy getting the final result (visualized Heuristics Net Models) and comparing it with the same one obtained manually in the data analysis phase, one can verify that the system is doing the right thing.\n\n10.2.2. Unit Testing\nAs a part of the development the mapping rule repository was developed. The Mapping-rule Repository was filled with regular expression that extract event instance attribute from a certain text. The number of events that are part of the generated process models was growing during the project and a certain level of assurance that the developed repository supports all the data variations of the event instances among the data sources was necessary. Therefore, unit testing was performed and there were written unit tests for each regular expression in the Mapping-rule Repository.\n\n59\n11. Conclusions\n\nThe results and the lessons learned are elaborated in this chapter. The results are grouped around the developed prototype, the designed architecture that supports extracting customer profiles, and the comprehensive domain analysis. The problems and issues that were faced in the project are transformed into suggestions for improved extracting of customer profiles. The chapter ends with the most important lessons learnt during the project.\n\n11.1 Results\n\nIn the previous chapter we have shown that the process models comply with the stakeholder needs. ASML stakeholders were satisfied with the results because they can model the typical and atypical behavior of different participants in the production environment including the participants manufactured by ASML and by other manufacturers. Based on the interaction between the third party equipment and the ASML equipment, we can model the behavior of the third party equipment, which is an essential step in understanding the production process.\n\n11.1.1. Prototype\n\nThere are multiple project results and they are all relevant from different perspectives. One of the most important results is that the project provided a prototype that shows the feasibility of using process mining to obtain customer profiles. It is validated by the stakeholders that the Dotted chart, Heuristics Net Models, and the Trace Charts give sufficient insight in the customer profiles: the actual context and usage by the different customers of the equipment. For TNO-ESI it is important because it can be used to support model-based testing and architectural reasoning activities for different clients. ASML can use the prototype as a standalone tool to support the ongoing customer profile efforts.\n\n11.1.2. Portable Software Architecture\n\nBased on the positive reception of the prototype, an appropriate software architecture was designed to support extracting customer profiles for different TNO-ESI clients. The architecture provides a solution for the problems in applying process mining such as: mapping domain specific model to Standard Log Model and missing information in the log data. The components in the architecture were designed to require minimal changes in the case of switching to another TNO-ESI customer. The components are categorized based on their level of portability. Based on this categorization, TNO-ESI can calculate the amount of change effort that has to be done to port the architecture to different TNO-ESI clients. The system architecture and design is elaborated in the chapters: “7. System Architecture” and “8. System Design.”\n\n11.1.3. Comprehensive Domain Analysis\n\nFrom the data analysis part, a comprehensive domain analysis was derived. The main issues in applying process mining were emphasized. In order to be able to generate customer profiles based on process mining techniques, data requirements were defined. For that purpose, the log data source has to have the following information for each event instance: Event Instance Unique ID, Event Instance Originator, Event Instance Timestamp, Event Instance Class, and Process Instance Unique ID. These requirements are a basis for the Standard (Figure 14) and the Extended Log Model (Figure 20).\nAs a part of the domain analysis, an evaluation of the process miners for the purpose of customer profiles (FR4) was done. That helps in selecting the most appropriate process mining algorithm for different business goals. For instance, in one case the stakeholders would like to get the most common process structure, and in other case the stakeholders would like to see more exceptional or atypical behavior. The process miner evaluation is elaborated in the section “4.3. Process Miner Evaluation.” The conclusion is that the heuristics and genetic miner are the miners that can deal with the noise and incompleteness of the log files and can generate models with different levels of abstraction of the real process. The heuristics miner requires process mining domain knowledge. At the same time the genetic miner requires better understanding of the process that has to be extracted but no extended process mining domain knowledge is necessary. The selection of the process miner depends on the stakeholder requirements, stakeholder process mining domain knowledge, and stakeholder understanding of the process that has to be extracted.\n\n11.2 Suggestions\n\nBased on the needs and challenged that arose during the architecture design a set of suggestions for the logging infrastructures and for the process mining domain was created. This is one of the main requirements - FR7. The set of suggestions can help in more efficient process mining and can be applied to any TNO-ESI customer.\n\n11.2.1. Logging Infrastructure Suggestions\n\nThe most important suggestions for the logging infrastructure are:\n\n- Conscious manufacturer decision on log file syntax and semantics\n- Global unique identifiers\n- Use case aware event logging\n- More precise time stamp\n- Consistent time zone usage\n\nThe general suggestions start with logging infrastructure redesign. Within ASML we witnessed redundant data with missing information. The same data is logged on multiple locations, but still without relevant information for process mining. One of the suggestions is that the relevant minimal information based on the Standard Log Model should be logged. This leads to a more generic suggestion: conscious manufacturer decision on the log file content. In general, we do not want the customer that uses the equipment to decide what data will be logged. That puts in question the feasibility of the customer profiles. Without data, it is not possible to create customer profiles. Therefore, the suggestion is that the manufacturer, for instance ASML, should have predefined logging settings that cannot be overwritten by their customers.\n\nAnother important suggestion for the logging infrastructure is global unique identifiers across the entire logging domain and not on log file level. Having multiple log files is not a problem if there are unique identifiers for the entities they log. This requires some kind of central agreement, for example a component responsible for system wide unique identifiers or a standard naming schema.\n\nIn order to avoid the join problem there are two suggestions. The first one is using use case aware event logging. The log events should be annotated with a process instance that is part of a customer use case. In a complex system of systems, logging process instances on operating system level will not help in creating customer profiles. System level logging is good for diagnostics, but for customer profiles it must be connected with a customer use case. Use case aware event logging should be used even in a case when the logging infrastructure is spread across multiple log files.\n\nThe more concrete suggestions are based on the problems that were faced in the data sets. Mostly these problems are time stamp related. One recommendation is using standardized time stamp for the events. For instance, 01.05.2014 and 05/01/2014 can represent same date but also different date. Knowing the fact the end users of the ASML products are located all around the world, including the time zone in the time stamp has to be consistent. The last suggestion is for the time stamp accuracy. Most logging infrastructures are part of legacy systems and the time stamp is based on accuracy of one second. That would not be a problem, if we apply process mining for a process executed by humans. In the machine world where the high-tech equipment\nexecutes thousands of operations per second, a higher precision in the time stamp is a necessity.\n\n### 11.2.2. Process Mining Suggestions\n\nNext to the logging infrastructure suggestions there are suggestions for the process mining algorithms and tools. First of all, the tool (Process Mining Tools, 2014) used to generate process model is an academic tool and is not yet mature for industrial use. For instance, importing preprocessed log file with 100k event instances resulted in memory issues with the tool. Performing complex algorithmic operations resulted in freezing tool’s user interface. Therefore, many preprocessing steps were executed before running the process mining tool. These steps implicitly are part of the proposed system architecture (Figure 25.) The suggestion is that for industrial use of the process mining tool, especially in the era of big data, serious optimizations are necessary.\n\nAnother problem that was faced is the order of the event instances with same time stamp. When there are two event instances with same time stamp, the process mining algorithms based on the dependency relation use the order of the event instances in the log file. That might be correct if we only use one log file as a data source and we can assume that only one process writes event instances in the log file. In that case, the event instances are written in a first come – first serve fashion. In our case, we have a fusion of event instances from multiple log files into one log file. The order of the event instances with same time stamp is arbitrary. This leads to various heuristics net models, which are not necessarily semantically correct. Consulting a domain expert was necessary to find out which models are correct. One suggestion is when there are event instances with a same time stamp, the order of the event instances in the log file should be ignored and this should be optional input parameter in the process mining algorithms. Another solution is to implement semantic process mining where appropriate domain knowledge can be injected. For instance, when we have event instances with the same timestamp, then the end user should be able to define the order of the event instances in the file.\n\n### 11.3 Lessons Learned\n\nThe most important lessons from a design point of view are explained in the following subsections.\n\n#### 11.3.1. Building a Bridge between Academia and Industry\n\nOne of the hard lessons that had to be learnt along the way was how to bridge academia and industry. Following the TNO-ESI approach (Figure 1), the goal of this project was to use the process mining as a state-of-art academic discipline to achieve a real business goal in the industry. There is one significant problem in bridging academia and industry. In delivering academic results there are a lot of obstacles such as: missing data, noisy data, amount of data, and many more. One way to deal with the obstacles is to introduce assumptions that simplify the observed problem. The industry results are based on the business goal and often the obstacles have to be solved; they cannot be ignored or assumed. Therefore applying research technique for industrial purpose is not a trivial task. We have shown that the mapping issue in applying process mining, which is already recognized as a challenge, is not the only one. Solving only the mapping issue does not give results that meet the business goal of the customer profiles. We needed more information and we faced the missing information challenge. It is a big challenge because the relevant information is spread among different log file sources. The missing information can be found in different data sources, or it might be known by domain experts. In the worst case scenario the missing information cannot be found at all. That illustrates the complexity of the problems that can be faced in building a bridge between academia and industry.\n\n#### 11.3.2. Providing a Portable Solution\n\nThe goal of TNO-ESI is to develop generic know-how that can be reused in different domains. Abstraction of a certain solution can be a challenging task. Designing and\nimplementing a solution based on a certain example is quite a deterministic activity because we have an input and an output. Trying to get the same output of the system when we have a different input (more often undefined, because of the abstraction) requires high analytical and critical thinking skills. The designer has to oversee all the possible different inputs to the system.\n\n11.3.3. Applying Test Driven Development\n\nTest-driven development (TDD) is a software development process that relies on the repetition of a very short development cycle: first the developer writes an (initially failing) automated test case that defines a desired improvement or new function, then produces the minimum amount of code to pass that test, and finally refactors the new code to acceptable standards. Applying TDD in this project helped in providing assurance to the candidate and to the stakeholders that the project artifacts are consistent. Especially it helped in implementing the Mapping-rule Repository where it was necessary to implement a set of regular expressions for each possible event instance. As the project grew and the data sets were changing the unit tests provided assurance that the proposed solution supports all the data variations.\nAn overview of the project management techniques applied in the project is given.\n\n### 12.1 Introduction\n\nThe current trend in project management is more focused on the business goal (Fowler, 2014). Therefore, a project implementation (Collier, 2011) in an agile fashion is a necessity. At the same time, the risk of log data availability (in sense of unavailable data and inaccessible data) required high level of flexibility in the project management. In order to evaluate the feasibility of the project and to eliminate possible risks, the project was conducted in two parts. The first part was analytical part. It included analytics use cases, whose goal was to define the customer profiles. The first part resulted with few executed analytics use cases that gave sufficient results. The results were used in the second part of the project. The second part also included analytics use cases, but the main accent was on infrastructure design, implementation, and validation. More detailed decomposition is given in the following section.\n\n### 12.2 Work-Breakdown Structure (WBS)\n\nThe project officially started with a kick-off meeting at ASML. For that purpose, a project roadmap (Figure 50) was created. The project roadmap contains different information intended for different groups of stakeholders including the main project phases and their breakdown.\n\n\n\nThe project was decomposed in five phases: Getting Started, Analytics Use Cases, Infrastructure Design, Validation, and Wrap Up. Each phase had different end goal, but some of them had overlapping goals. For instance, the data analysis started in the second phase as a main activity, but also continued in the third phase. The report activity was part of the second, third, and the fourth phase. Each phase consists of several steps. The initial and the actual planning of the steps are elaborated in the following section.\n\n### 12.3 Project Planning\n\n#### 12.3.1 Initial\n\nThe first phase “Getting Started” included Introduction, Stakeholders Analysis, and Risk Analysis. In the second phase “Analytics Use Cases,” a few analytics use cases were planed (Use Case 1 & 2) together with a role model selection. The data analysis continued in the third phase “Infrastructure Design.” For this phase Object-oriented Analysis and Design, a Technology Overview, Implementation, and Integration were planned. The fourth phase “Validation” included Design Review, Valida-\ntion and report writing. The final phase included project artifact delivery and project result presentation. The planned activity distribution in the project phases is shown in Table 8. The numbers represent the percentage of all the available time dedicated to a particular activity. The number calculation is based on planned days per activity with a step of 5%. In general, 5% of the time means 2-3 days.\n\nTable 8 - Planned Activity Distribution\n\n<table>\n<thead>\n<tr>\n<th>Activity</th>\n<th>Data Analysis</th>\n<th>OOAD</th>\n<th>Implementation</th>\n<th>Integration</th>\n<th>Testing</th>\n<th>OOAD Review</th>\n<th>Validation</th>\n<th>Report</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Analytics Use Cases</td>\n<td>90%</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td>10%</td>\n</tr>\n<tr>\n<td>Infrastructure Design</td>\n<td>15%</td>\n<td>25%</td>\n<td>30%</td>\n<td>20%</td>\n<td></td>\n<td></td>\n<td>10%</td>\n<td></td>\n</tr>\n<tr>\n<td>Validation</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td>20%</td>\n<td>10%</td>\n<td>20%</td>\n</tr>\n</tbody>\n</table>\n\n12.3.2. Final\n\nThe project was executed following the planned phases, but the activity distribution was not the same as the planned one. The Integration activity was completely removed from the plan, because it was decided that there is no integration necessary in this project. The time planned for Integration in the “Infrastructure Design” phase was used for Data Analysis, OOAD, and Implementation.\n\nWriting the report activity took more time than the planned time. There are several reasons for that. First of all, a lot of decisions in the domain analysis were made later in the data analysis, and therefore a lot of changes in the report had to be done. At the same time providing an abstract solution that is portable to different TNO-ESI customers challenged the early design decisions. Reviewing the design decisions and updating the report influenced the initial planning. The final activity distribution in the project phases is shown in Table 9.\n\nTable 9 - Final Activity Distribution\n\n<table>\n<thead>\n<tr>\n<th>Activity</th>\n<th>Data Analysis</th>\n<th>OOAD</th>\n<th>Implementation</th>\n<th>Integration</th>\n<th>Testing</th>\n<th>OOAD Review</th>\n<th>Validation</th>\n<th>Report</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Analytics Use Cases</td>\n<td>90%</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td>10%</td>\n</tr>\n<tr>\n<td>Infrastructure Design</td>\n<td>25%</td>\n<td>25%</td>\n<td>45%</td>\n<td>0%</td>\n<td></td>\n<td></td>\n<td>5%</td>\n<td></td>\n</tr>\n<tr>\n<td>Validation</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td>5%</td>\n<td>20%</td>\n<td>5%</td>\n</tr>\n</tbody>\n</table>\n\n12.4 Project Management Techniques\n\nIn different project phases different project management techniques were applied in order to achieve maximum optimization of the available time.\n\n12.4.1. Analytics Use Case Selection\n\nIn the second phase “Analytics Use Cases”, Analytics Use Case Selection was applied. This technique was introduced in the project to mitigate the risk of scattered infrastructure (see subsection “5.2.2. Scattered Infrastructure.”) The technique minimizes the variations of the use cases in the project. It has two conditions that have to be satisfied. The first one is attribute description of the use cases. Each use case was described with the following attributes: analytics that is used (process mining, statistical analysis), log files format, number of aspects per log file, different machines, number of machines, and process reengineering or discovery. The second condition\nis that with every new use case only one attribute change is allowed. Therefore, every next use case will differ by only one attribute. The second condition is illustrated in Figure 51. For example, Figure 51 shows that the Use Case 2 differs from the Use Case 1 only by the log file format and that the Use Case 4 differs from the Use Case 3 by two attributes, but from the Use Case 2 differs only by the type of the machine (equipment). The analytical use cases 1 – 8 in the project roadmap are executed with the Analytics Use Case Selection technique.\n\nFigure 51 Analytics Use Case Selection\n\n12.4.2. Role Model Use Case\n\nRole Model Use Case technique is another technique used in the project to mitigate the risk of scattered infrastructure. This technique was applied at the end of the second phase “Analytics Use Cases.” The goal of this technique is to select the most representative analytics use case as input for the infrastructure design. In this project the role model use case is a customer profile of the main production process (elaborated in “4.2. Applying Process Mining.”)\n\n12.4.3. Agile Development\n\nIn general, the whole project was executed in agile fashion. Every functional requirement for the infrastructure, but also for the analytical part was translated into user story and stored in the Project Backlog. For each sprint a certain amount of user stories was selected and executed. In the second phase “Analytics Use Cases”, the use cases had more research character (meaning more uncertainty) and therefore the sprint length was three weeks. In the third and the fourth phase the sprint length was shortened to two weeks. Figure 52 shows a Burn down chart from one of the sprints executed in the phase “Infrastructure Design”. For the purpose of agile project management, the TNO-ESI project management tool was used. The tool is based on Redmine project management platform that supports a backlog, a wiki, a tracking management, and a source code repository features.\n\nFigure 52 Burn down Chart - Infrastructure Design\n13. Project Retrospective\n\nIn this chapter, a reflection on the candidate work is presented. It comprises the good practices, important moments and decisions, and the things that could have been done better. The chapter ends with revisiting the design criteria relevant for this project.\n\n13.1 Reflection\n\nOne of the main characteristics of this project is the variety of stakeholders. Figure 7 shows the different priorities of the different stakeholders. From one side, TNO-ESI stakeholders are more interested in the portability of the solution and are more oriented towards exploration. They need to explore all the possibilities and to provide the most suitable solution. On the other side, the ASML stakeholders are not concerned with the portability of the solution and are more goal-oriented. They have concrete problems and they need fast and stable solutions. At the same time, TU/e is interested in the project implementation process. Working in an environment like this and keeping all the stakeholders happy is a big challenge. One of the approaches that worked well in this project is the balance between the stakeholder priorities. This approach requires experience and it can bring risks. One of the risks is losing the balance and delivering results closer to one side. Keeping the TNO-ESI non-functional requirements on the top of the list, but at the same time looking at the ASML problem level (functional requirements) has brought satisfactory results. Balancing between the different stakeholder interests is not enough; the balance should lead to homogeneous project. Therefore, next to the balance, for a successful project, a selection of the complementary requirements and project management techniques is necessity.\n\nAnother important aspect in this project is getting the domain knowledge. It is a main precondition to delivering satisfactory results. In the context of this project, the domain knowledge consists of the process mining domain and the ASML domain. The thing that helped in this project is that the first part of the project was completely dedicated to getting the domain knowledge in terms of data analysis and process mining. Based on the results from the first part, a set of requirements was created as input for the infrastructure design and implementation. During the first part of the project, analytics use case selection (“12.4.2. Analytics Use Case Selection”) was applied. The use case selection mitigated the risk of scattered use cases but also provides step by step learning of the domain and the domain problems. There is a lot of material for process mining available online and therefore, a process mining domain expert was consulted in the middle of the first phase. The consultation helped in better understanding of the process mining problems. For instance, it was found out that the ProM tool version 5 is more suitable that the version 6. Moreover, during the consultations a process mining algorithm comparison was performed. The rule of thumb is that in getting the domain knowledge, an iterative learning can be beneficial. Also an early consultation with the domain experts, especially when the domain is a part of academic research is essential. In this context, early consultation means at the time when the candidate has an appropriate level of the domain knowledge, because only then the right questions can be asked.\n\n13.2 Design opportunities revisited\n\nThe design criteria that were selected as relevant for this project are: Genericity, Realizability, and Impact. Genericity in this project is presented by the non-functional requirement NFR1: Portability. There are several design decisions that were made in order to provide a portable solution. The first decision is to provide a modular archi-\ntecture with coherent components based on the Pipes and Filters architectural pattern. The proposed system design is portable to different domains that confirm to the Extended Log Model elaborated in the section “4.2. Applying Process Mining.” In order to measure the portability level of the proposed system an appropriate portability measurement was introduced. Each component in the system, based on the level of changes that has to be made, has a portability level.\n\nRealizability (technical) is related with the feasibility of the project artifact. The implemented prototype showcases the implementation of the functional requirements, but also, what is more important; it shows the realizability of customer profiles based on process mining. During the project there were several design decisions that improved the realizability of the project. For instance, Figure 44, Figure 45, and Figure 46 depict Heuristics Net Models generated from customer log files. These models already show the feasibility of the idea to apply process mining for extracting customer profiles. The question that arises here is whether these models are relevant for the stakeholders or not. Do they provide sufficient business information for the stakeholders or not. The design decisions to include additional log files and to solve the problem with incomplete event instances resulted in delivering more appropriate results for the stakeholders (such as the models depicted in Figure 47 and Figure 48.)\n\nThe third criterion is the impact of the project artifact. In the context of this project it is considered the societal impact of the project artifact. The same design decisions for the previous design criteria are important for this criterion too. The genericity of the project provides higher impact because a larger set of stakeholders are satisfied. Providing generic solution means that the approach can be applied at any TNO-ESI client, not just ASML. With the realizability, the impact of the project is higher because it tells to which extend the project is realizable. The results from this project were accepted with a lot of enthusiasm from the stakeholders, especially within the ASML domain. Additional meetings with a broader group of stakeholders were conducted to share the results. One of the examples of the impact of this project is that the project “Customer profiles” plays a significant role in different activities within TNO-ESI (applying model-based testing) and ASML (Virtual Fab concept.)\n### Glossary\n\n<table>\n<thead>\n<tr>\n<th>Abbreviation</th>\n<th>Full Form</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>PDEng</td>\n<td>Professional Doctorate in Engineering</td>\n</tr>\n<tr>\n<td>TU/e</td>\n<td>Eindhoven University of Technology</td>\n</tr>\n<tr>\n<td>TNO-ESI</td>\n<td>Embedded System Innovation by TNO</td>\n</tr>\n<tr>\n<td>IC</td>\n<td>Integrated Circuit</td>\n</tr>\n<tr>\n<td>ADD</td>\n<td>Attribute driven Design</td>\n</tr>\n<tr>\n<td>MXML</td>\n<td>Mining <em>eXtensible Markup Language</em> - an XML-based syntax for event logs storing</td>\n</tr>\n<tr>\n<td>UML</td>\n<td>Unified Modeling Language</td>\n</tr>\n</tbody>\n</table>\nBibliography\n\n\nGamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.\n\n\nMiroslav Janeski received his Diploma of Engineering (2008) and MSc degree in Intelligent Information Systems (2011) from the Faculty of Electrical Engineering and Information Technologies, Skopje, Macedonia. The main task of his master thesis entitled “Forecasting financial time series” was to find an optimal artificial neural network based model for forecasting Balkan stock exchanges. As a result he published two papers in international conferences, ICT Innovations 2010, Ohrid, Macedonia and ICIC 2011, Zhengzhou, China. After graduation he worked for four years as a software specialist at Neocom, Macedonia. His specialized in design and development of web applications for government agencies. In 2012 he joined the PDEng programme in Software Technology at the Eindhoven University of Technology. His final project as a part of the PDEng programme is entitled “Customer Profiles: Extracting usage models from log files.” The project was executed at ASML under supervision of Embedded System Innovation by TNO.\n3TU. School for Technological Design, Stan Ackermans Institute offers two-year postgraduate technological designer programmes. This institute is a joint initiative of the three technological universities of the Netherlands: Delft University of Technology, Eindhoven University of Technology and University of Twente. For more information please visit: www.3tu.nl/sai."}}},{"rowIdx":286,"cells":{"id":{"kind":"string","value":"63ad02864b9f66a43e224ba6f2169ea81f41a8a2"},"text":{"kind":"string","value":"RADIC: A POWERFUL\nFAULT-TOLERANT\nARCHITECTURE\n\nThesis submitted by Angelo Amancio Duarte in fulfillment of the requirements for the degree of Doctor per the Universitat Autònoma de Barcelona.\n\nBellaterra, May 2007\nRADIC: A POWERFUL FAULT-TOLERANT ARCHITECTURE\n\nThesis submitted by Angelo Amancio Duarte in fulfillment of the requirements for the degree of Doctor per la Universitat Autònoma de Barcelona. This work has been developed in the Computer Architecture and Operating Systems department of the Universitat Autònoma de Barcelona and was advised by Dr. Dolores Isabel Rexachs del Rosario.\n\nBellaterra, May 2007\n\nThesis Advisor\nDr. Dolores Isabel Rexachs del Rosario\nTo Deborah, Amanda and Sarah, the goddesses who offered me all energy to complete this work.\nAcknowledgments\n\nIt is hard to believe that almost four years have gone since the beginning of my Ph.D. course. Now, at the end of this journey, I remember how many people I have known and how important were these people to me. Although I remember all them with kindness, some of them made the difference. Besides helping me, these persons have improved me. The following lines are a tribute for them.\n\nTo my wife Deborah and my daughters Amanda and Sarah, today the most important people in my life, I hope I can compensate the suffering and effort that they have done in the last four years. I thank them to be my emotional pillar and I thank the love they unconditionally give me.\n\nI had luck in having two great tutors in my job: Emilio Luque and Dolores “Lola” Rexachs. The lessons they gave me really made the difference when things did not go as well as I wished. Both always cared about how I was living in Spain and they gave me full support in my decisions. The word “tutor” has gained more significance since I started to work with them.\n\nI am very grateful to my two great Brazilian friends: Eduardo Argollo and Genaro Costa for teaching me most of the technical knowledge that helped me to develop my job.\n\nTo my Brazilian friends Ines Martinez, Guna Santos and Christiane Dalforino, I thank the funny times that made the life easier when I missed my family or when the work was harder.\n\nTo my Catalan friends Carlos Moreno, David Ruiz and Ana Esteves, I thank the lessons about the Catalunya. Because of them, I could better comprehend the Catalan people.\n\nI thank to my Argentine friends Mauricio Hanzich, Diego Mostaccio and Paula Fritzsche, for teaching me about Argentina and for proving that real friendship between Brazilian and Argentine is possible.\nThanks to my Chinese friend Xiao Yang, from whom I have learned a lot about the Chinese culture (and a few Chinese words, too). Because of him, I matured many philosophical concepts at the “Friday's Philosophical Meetings”, mediated by our common friend Mauricio. It was also because of him that I ate the best Chinese food so far.\n\nI express my gratitude to all professors of the Ph.D. program at CAOS Department, for teaching me new matters that have helped me in my job. I also thank to the technicians Daniel Ruiz and Jordi Valls, for maintaining the machines working.\n\nFinally, I thank to Universidade Católica do Salvador (UCSal) by the financial support during these years.\n\nBellaterra, June 2007\n\nAngelo Amancio Duarte\nResumen\n\nLa tolerancia a fallos se ha convertido en un requerimiento importante para los ingenieros informáticos y los desarrolladores de software, debido a que la ocurrencia de fallos aumenta el coste de explotación de un computador paralelo. Por otro lado, las actividades realizadas por el mecanismo de tolerancia de fallo reducen las prestaciones del sistema desde el punto de vista del usuario.\n\nEsta tesis presenta una arquitectura tolerante a fallos para computadores paralelos, denominada RADIC (Redundant Array of Distributed Fault Tolerance Controllers,), que es simultáneamente transparente, descentralizada, flexible y escalable.\n\nRADIC es una arquitectura tolerante a fallos que se basa un controlador distribuido para manejar los fallos. Dicho controlador se basa en procesos dedicados, que comparten los recursos del usuario en el computador paralelo.\n\nPara validar el funcionamiento de la arquitectura RADIC, se realizó una implementación que sigue el estándar MPI-1 y que contiene los elementos de la arquitectura. Dicha implementación, denominada RADICMPI, permite verificar la funcionalidad de RADIC en situaciones sin fallo o bajo condiciones de fallo. Las pruebas se han realizado utilizando un inyector de fallos, involucrado en el código de RADICMPI, de manera que permite todas las condiciones necesarias para validar la operación del controlador distribuido de RADIC.\n\nTambién se utilizó la misma implementación para estudiar las consecuencias de usar RADIC en un ambiente real. Esto permitió evaluar la operación de la arquitectura en situaciones prácticas, y estudiar la influencia de los parámetros de RADIC sobre el funcionamiento del sistema.\n\nLos resultados probaron que la arquitectura de RADIC funciona correctamente y que es flexible, escalable, transparente y descentralizada. Además, RADIC estableció una arquitectura de tolerancia a fallos para sistemas basados en paso de mensajes.\nAbstract\n\nFault tolerance has become a major issue for computer engineers and software developers because the occurrence of faults increases the cost of using a parallel computer. On the other hand, the activities performed by the fault tolerance mechanism reduce the performance of the system from the user point of view.\n\nThis thesis presents RADIC (Redundant Array of Distributed Independent Fault Tolerance Controllers,) a fault-tolerant architecture to parallel computers, which is simultaneously transparent, decentralized, flexible and scalable.\n\nRADIC is a fault-tolerant architecture that implements a fully distributed controller to manage faults. Such controller rests on dedicated processes, which share the user’s resources in the parallel computer.\n\nIn order to validate the operation of RADIC, we created RADICMPI, a message-passing implementation that includes the elements of the RADIC architecture and complies with the MPI-1 standard.\n\nRADICMPI served for to verifying the functionality of RADIC in scenarios with and without failures in the parallel computer. For the tests, we implemented a fault injector in RADICMPI in order to create the scenarios required to validate the operation of the RADIC distributed controller.\n\nWe also used RADICMPI to study the practical aspects of using RADIC in a real environment. This allowed us to evaluate the operation of our architecture in practical situations, and to study the influence of the RADIC parameters over the system performance.\n\nThe results proved that the RADIC architecture operated correctly and that it is flexible, scalable, transparent and decentralized. Furthermore, RADIC established a powerful fault-tolerant architecture model for message-passing systems.\n# Table of Contents\n\n## CHAPTER 1 INTRODUCTION\n\n1.1 THE RADIC KEY FEATURES ................................................................. 23 \n1.2 RADIC FUNDAMENTALS ................................................................. 25 \n1.3 HOW RADIC INCREASES THE AVAILABILITY OF A SYSTEM ............ 27 \n1.4 HOW RADIC INTERACTS WITH THE APPLICATION .......................... 28 \n1.5 RADIC AND MESSAGE-PASSING .................................................... 30 \n1.6 ORGANIZATION OF THIS DISSERTATION ...................................... 31 \n\n## CHAPTER 2 FAULT TOLERANCE IN MESSAGE-PASSING SYSTEMS\n\n2.1 ROLLBACK-RECOVERY FUNDAMENTALS ......................................... 34 \n 2.1.1 Consistent System State ............................................................ 36 \n 2.1.2 Recovery Line ................................................................. 37 \n 2.1.3 In-transit Messages ............................................................. 39 \n 2.1.4 Domino Effect ................................................................. 39 \n 2.1.5 Event Logging ................................................................. 40 \n 2.1.6 Stable Storage ................................................................. 41 \n 2.1.7 Garbage Collection .......................................................... 42 \n2.2 CHECKPOINT BASED PROTOCOLS .............................................. 42 \n 2.2.1 Uncoordinated checkpointing ................................................. 43 \n 2.2.2 Coordinated Checkpointing .................................................. 44 \n 2.2.3 Communication-Induced Checkpointing (CIC) .......................... 45 \n 2.2.4 Comparing the checkpoint protocols ...................................... 47 \n2.3 LOG-BASED PROTOCOLS .............................................................. 47 \n 2.3.1 Pessimistic log-based protocols ............................................. 49 \n 2.3.2 Optimistic log-based protocols ............................................. 50 \n 2.3.3 Causal log-based protocols .................................................. 51 \n2.4 COMPARING THE ROLLBACK-RECOVERY PROTOCOLS .................. 52 \n\n## CHAPTER 3 FAULT TOLERANT MESSAGE-PASSING IMPLEMENTATIONS\n\n3.1 PRACTICAL ASPECTS ......................................................................... 56 \n 3.1.1 Transparency ........................................................................ 56 \n 3.1.2 Operational cost ................................................................. 57 \n 3.1.3 Adaptation to failures .......................................................... 58 \n3.2 RECENT FAULT-TOLERANT MESSAGE-PASSING PLATFORMS ............ 59 \n 3.2.1 CoCheck............................................................................ 60 \n 3.2.2 Starfish MPI....................................................................... 60 \n 3.2.3 Egida............................................................................... 60 \n 3.2.4 FT-MPI............................................................................. 60 \n 3.2.5 MPI/FT............................................................................. 61 \n 3.2.6 MPICH-Vx....................................................................... 61 \n 3.2.7 LA-MPI............................................................................. 62 \n 3.2.8 LAM/MPI........................................................................... 63 \n 3.2.9 MPICH-PCL....................................................................... 63\n6.3 FUNCTIONAL TESTS WITHOUT FAILURES ......................................................... 142\n6.4 FUNCTIONAL TESTS WITH FAILURES .......................................................... 144\n 6.4.1 Failure when a process is just computing .............................................. 146\n 6.4.2 Failure while a process is communicating ............................................ 147\n 6.4.3 Failure when a process starts a communication ..................................... 148\n 6.4.4 Failure when an observer is checkpointing or logging a message .......... 148\n 6.4.5 The protector node fails when the observer is idle .................................. 148\n 6.4.6 The protector node fails when the observer is checkpointing ............. 149\n 6.4.7 The protector fails when the observer is transmitting a message ....... 149\n\nCHAPTER 7 EXPERIMENTS WITH RADIC .......................................................... 151\n7.1 EXPERIMENTS WITH THE WATCHDOG/HEARTBEAT CYCLE ....................... 152\n7.2 EXPERIMENTS WITH THE PROTECTORS STRUCTURE .................................. 154\n7.3 EXPERIMENTS WITH THE CHECKPOINT INTERVAL ..................................... 154\n7.4 EXPERIMENTS WITH FAULTS ................................................................. 158\n\nCHAPTER 8 CONCLUSIONS .............................................................................. 165\n8.1 FUTURE WORKS ....................................................................................... 168\n 8.1.1 The future of the RADIC architecture ............................................... 168\n 8.1.2 The future of RADICMPI .................................................................... 170\nList of Figures\n\nFIGURE 1-1: (A) A FAILURE FREE CLUSTER; (B) THE SAME CLUSTER AFTER THE MANAGEMENT OF A FAILURE IN NODE N_{i+1} ................................................... ...... 27\n\nFIGURE 2-1: TYPES OF ROLLBACK-RECOVERY PROTOCOL FOR MESSAGE-PASSING SYSTEMS .......................................................... ................................................... ...... 34\n\nFIGURE 2-2: AN EXAMPLE OF A DISTRIBUTED APPLICATION USING MESSAGE-PASSING. 36\n\nFIGURE 2-3: EXAMPLES OF INCONSISTENT GLOBAL SYSTEM STATE. A) INCONSISTENCY CAUSED BY A LOST MESSAGE ; B) INCONSISTENCY CAUSED BY AN ORPHAN MESSAGE ................................................... ................................................... ...... 38\n\nFIGURE 2-4: DOMINO EFFECT ................................................... ................................... 40\n\nFIGURE 3-1: PRACTICAL ASPECTS OF FAULT TOLERANCE FOR MESSAGE-PASSING SYSTEMS ................................................... ................................................... ...... 56\n\nFIGURE 4-1: THE RADIC LEVELS IN A PARALLEL SYSTEM ........................................ 66\n\nFIGURE 4-2: AN EXAMPLE OF PROTECTORS (T_0-T_8) IN A CLUSTER WITH NINE NODES. GREEN ARROWS INDICATE THE ANTECESSOR ← SUCCESSOR COMMUNICATION ........................................ 70\n\nFIGURE 4-3: A CLUSTER USING THE RADIC ARCHITECTURE. P_0-P_8 ARE APPLICATION PROCESS. O_0-O_8 ARE OBSERVERS AND T_0-T_8 ARE PROTECTORS. O→T ARROWS REPRESENT THE RELATIONSHIP BETWEEN OBSERVERS AND PROTECTOR AND T→T ARROWS THE RELATIONSHIP BETWEEN PROTECTORS. ........................................ 73\n\nFIGURE 4-4: THE MESSAGE-PASSING MECHANISM IN RADIC ........................................... 75\n\nFIGURE 4-5: RELATION BETWEEN AN OBSERVER AND ITS PROTECTOR ........................ 76\n\nFIGURE 4-6: MESSAGE DELIVERING AND MESSAGE LOG MECHANISM .............................. 78\n\nFIGURE 4-7: PROTECTOR ALGORITHMS FOR ANTECESSOR AND SUCCESSOR TASKS ...... 80\n\nFIGURE 4-8: FOUR PROTECTORS (T_X, T_Y, T_Z AND T_W) AND THEIR RELATIONSHIP TO DETECT FAILURES. SUCCESSORS SEND HEARTBEATS TO ANTECESSORS .......... 81\n\nFIGURE 4-9: T_X IS THE ANTECESSOR OF T_Y, T_Y IS THE ANTECESSOR OF T_Z AND SO ON. (A) COMMUNICATION FAILURE BETWEEN T_Y AND T_Z GENERATES A BYZANTINE PROBLEM. (B) T_Z HAS COMMITTED SUICIDE AND T_W CONNECTS TO T_Y ................. 82\n\nFIGURE 4-10: HOW A PROTECTOR DEALS WITH BYZANTINE PROBLEMS ....................... 83\nFIGURE 4-11: RECOVERING PHASES IN A CLUSTER. (A) FAILURE FREE CLUSTER. (B) FAULT IN NODE N3. (C) PROTECTORS T2 AND T4 DETECT THE FAILURE AND REESTABLISH THE CHAIN, O4 CONNECTS TO T2. (D) T2 RECOVERS P3/O3 AND O3 CONNECTS TO T1.\n\nFIGURE 4-12: (A) A FAILURE FREE CLUSTER; (B) THE SAME CLUSTER AFTER THE MANAGEMENT OF A FAILURE IN NODE N3.\n\nFIGURE 4-13: FAULT DETECTION ALGORITHMS FOR SENDER AND RECEIVER OBSERVERS.\n\nFIGURE 4-14: A CLUSTER USING TWO PROTECTORS’ CHAIN.\n\nFIGURE 4-15: THE MINIMUM STRUCTURE FOR A PROTECTORS’ CHAIN.\n\nFIGURE 5-1: SOFTWARE LEVELS OR THE RADICMPI.\n\nFIGURE 5-2: THREADS OF RADICMPI AND THEIR RELATIONSHIP.\n\nFIGURE 5-3: THE OBSERVER ENGINE AND THE EXTERNAL AND INTERNAL EVENT Generators in RADICMPI.\n\nFIGURE 5-4: HOW THE OBSERVER ENGINE DEALS WITH INCOMING MESSAGES (ERROR SITUATIONS ARE NOT REPRESENTED IN THIS DIAGRAM).\n\nFIGURE 5-5: HOW THE OBSERVER ENGINE Responds TO AN MPI_INIT COMMAND.\n\nFIGURE 5-6: HOW THE OBSERVER ENGINE Responds TO AN MPI_RECV COMMAND.\n\nFIGURE 5-7: HOW THE OBSERVER ENGINE Responds TO AN MPI_SEND COMMAND.\n\nFIGURE 5-8: STEPS OF THE MESSAGE LOG PROCEDURE.\n\nFIGURE 5-9: OBSERVER CHECKPOINT PROCEDURE WITHOUT ERROR CONDITIONS.\n\nFIGURE 5-10: HOW OBSERVER RECOVERS.\n\nFIGURE 5-11: THE PROTECTOR PROGRAM IN RADICMPI.\n\nFIGURE 5-12: THE RADICCC COMMAND.\n\nFIGURE 5-13: INITIAL LINES OF THE MACHINEFILE FOR THE CLUSTER IN FIGURE 4-3.\n\nFIGURE 5-14: THE RADICRUN COMMAND.\n\nFIGURE 6-1: THE TEST PROTOCOL FOR RADIC.\n\nFIGURE 6-2: THE FAULT INJECTION THREAD INSIDE THE OBSERVER PROGRAM.\n\nFIGURE 6-3: THE FAULT INJECTION THREAD INSIDE THE PROTECTOR PROGRAM.\n\nFIGURE 6-4: AN EXAMPLE OF THE DEBUG LOG DATABASE OF A PROTECTOR.\n\nFIGURE 6-5: A TYPICAL SET OF REGISTERS IN THE TIME LOG DATABASE OF AN OBSERVER.\nFIGURE 6-6: MESSAGE PATTERN OF A MATRIX-MULTIPLICATION USING A) M/W PARADIGM AND B) SPMD PARADIGM ................................................................. 135\nFIGURE 6-7: EXECUTION TIME OF THE M/W MATRIX MULTIPLICATION PROGRAMS USING MPICH-1.2.7 FOR 3000X3000 DOUBLE ELEMENT MATRICES .............. 137\nFIGURE 6-8: SPEEDUP OF THE M/W MATRIX MULTIPLICATION PROGRAMS USING MPICH-1.2.7 FOR 3000X3000 DOUBLE ELEMENT MATRICES .................................. 138\nFIGURE 6-9: EXECUTION TIME OF THE M/W MATRIX MULTIPLICATION PROGRAMS USING RADICMPI (WITH FAULT TOLERANCE OFF) FOR 3000X3000 DOUBLE ELEMENT MATRICES ................................................................. 139\nFIGURE 6-10: SPEED-UP OF THE M/W MATRIX MULTIPLICATION PROGRAMS USING RADICMPI (WITH FAULT TOLERANCE OFF) FOR 3000X3000 DOUBLE ELEMENT MATRICES ................................................................. 140\nFIGURE 6-11: RESULTS OF THE SPMD (CANON ALGORITHM) MATRIX MULTIPLICATION PROGRAM USING RADICMPI WITH FAULT TOLERANCE DEACTIVATED AND USING MPICH-1.2.7 ................................................................. 141\nFIGURE 6-12: EXECUTION TIMES FOR THE MATRIX MULTIPLICATION M/W PROGRAM USING DYNAMIC LOAD BALANCE AND RADICMPI WITH DIFFERENT CHECKPOINT INTERVALS ................................................................. 144\nFIGURE 6-13: ALGORITHM OF THE FAULT INJECTION MECHANISM ....................... 146\nFIGURE 7-1: THE MINIMUM STRUCTURE FOR A PROTECTORS’ CHAIN .................... 157\nFIGURE 7-2: IMPACT OF FAULTS OVER THE EXECUTION TIME IN THE M/W MATRIX MULTIPLICATION PROGRAM USING DYNAMIC LOAD BALANCING (1000X1000 ELEMENTS/BLOCK) ................................................................. 161\nFIGURE 7-3: EXECUTION TIMES IN PRESENCE OF FAULTS FOR THE MASTER/WORKER WITH DYNAMIC LOAD BALANCE USING 15 NODES (BLOCKS 600X600) ............ 163\nChapter 1\n\nIntroduction\n\nAny man made machine may fail and the computers are not an exception. Since the beginning of the computational science until our days, the computer designers and computer engineers had to deal with faults.\n\nAs a rule of thumb, all computer engineers know that when a computer system becomes more complex, the system’s susceptibility to faults increases. Such rule is fully applicable to the parallel computers.\n\nThe number of nodes in the parallel computers has steadily increased since the debut of the parallel machines in the computer’s world and, in spite of the quality improvement in each single component of the nodes, one may argue that, as certain as the sun will rise tomorrow, any current large computers will suffer some kind of failure.\n\nA fast look in the current “Top500 Supercomputer Sites” list (November/2006) shows that the Top100 supercomputers have more than 1000 nodes and the top computer has more than 130000 nodes [Top500.Org, 2006]. Currently, there is no signal that the current trend of increasing the number of nodes in parallel computers will stop. Such trend forces the computers engineers and software programmers to increase the amount of effort dedicated to deal with faults.\n\nDealing with fault tolerance has become a major task for computer engineers and software developers because the occurrence of faults increases the cost of using a parallel computer. However, the inclusion of fault tolerance in a system increases the complexity of such system from the user point of view. Furthermore, the operation of the fault tolerance mechanism interferes in the operation of the distributed parallel\napplication and such interference often appears as a performance loss for system’s users.\n\nIn this thesis, we proposed a fault tolerant architecture to parallel computers. In the development of such architecture, we assumed that, in order to attend the user expectations, a fault-tolerant architecture for modern parallel computers must simultaneously be transparent, decentralized, flexible and scalable. Currently no fault tolerance solution satisfies all these requirements simultaneously; because of this, we have developed the RADIC architecture.\n\nRADIC is the acronym for \"Redundant Array of Distributed Independent Fault Tolerance Controllers\". RADIC is a fully distributed fault tolerance architecture that implements a distributed controller to manage faults. The RADIC controller rests on dedicated processes, which run together with the parallel application processes, i.e., they share the resources allocated for the user in the parallel computer. Therefore, the RADIC controller works as a distributed parallel application.\n\nSince RADIC operates in a fully distributed way, without hierarchy or any global coordination between their processes, it is expandable and it mitigates the interference of the fault tolerance mechanism over the application’s scalability.\n\nRADIC is transparent for the system administrators, because its operation does not require any human intervention in order to maintain the parallel application execution in case of a failure in a node of the parallel computer. Furthermore, RADIC also does not require any change in the parallel application’s code, what make it completely transparent from the programmer point of view.\n\nRADIC is flexible because it allows different structures and relationships between its operational elements, facilitating the adaptation of the fault tolerance mechanism to the structure of the parallel computer. The flexibility is also present in adjusting the RADIC parameters, which may be set individually for each process that is been protected, or combined for a group of processes.\n\nThe RADIC operation bases on the classical pessimistic message-log rollback-recovery protocol. We choose this protocol because it allows that the fault\ntolerance mechanism of a process operates without coordination with the fault\ntolerance mechanism of the other processes. This independence between the processes\nis the key feature of the distributed controller.\n\nThe distributed controller for fault tolerance implemented by RADIC executes\nthe major activities of a fault-tolerant architecture based on such protocol. The\nRADIC activities are:\n\n− it stores state information and deterministic events of the parallel application\n while the parallel computer is operating well;\n− it monitors the parallel computer nodes in order to detect faults;\n− it recovers faulty processes in a survivor node;\n− it masks faulty nodes so the processes of the parallel application are not\n affected by the recovering of a faulty process in a different node from the\n one it was originally running.\n\nIn order to test the RADIC architecture in message-passing parallel computers,\nwe implemented a prototype based on the MPI standard [Argonne National\nLaboratory, 2007a] and used it to execute a set of applications under different fault\nconditions. The RADICMPI implementation served also as a test platform to assess\nthe interference of the fault tolerance mechanism on the parallel computer operation\nand to test the robustness of the RADIC concepts in a practical environment.\n\n1.1 The RADIC key features\n\nA fault-tolerant architecture driven by the modern parallel computers\ncharacteristics must simultaneously be transparent, decentralized, flexible and\nscalable. Now, we justify that such features are important because they attend to an\nimportant group of user’s expectations.\n\nThe first user expectation is, of course, that his/her parallel application\ncorrectly finishes independent of faults in the parallel computer. This is obviously\nthe main obligation of any fault-tolerant architecture for parallel computers and\ndemands no further discussion.\nThe next requirement is that the fault-tolerant architecture must be easy to use. Easiness of using indicates that the fault-tolerant architecture must be as transparent as possible, i.e., that the user neither need to change his/her application code in order to use the fault-tolerant architecture nor need to concern about how the fault tolerance mechanism operates.\n\nAny user, or system administrator, wants to pay the lowest price for the best fault-tolerant architecture and such price relates strictly to the efficiency of the fault-tolerant architecture. One important feature that determines the efficiency of a fault-tolerant architecture is the allocation of resources dedicated to implement the fault-tolerance. Architectures that use decentralized resources are more efficient because they avoid the bottleneck caused by centralized resources and allow a better distribution of the fault tolerance activities among the elements of the parallel computer.\n\nAnother interesting feature of a fault-tolerant architecture should be the possibility of sharing the same resources in the nodes that the user uses to compute his/her application, instead of requiring some dedicated or centralized nodes to operate. This feature would facilitate the allocation of the fault tolerance resources and would simplify the construction of the fault tolerance mechanism in the system. Furthermore, by avoiding the using of elements dedicated only to fault tolerance, the architecture will use the computers resources more efficiently.\n\nThe user also wants that the fault tolerance mechanism scales as well as, or better than, his/her parallel application and that the fault-tolerant architecture does not compromise his/her application’s scalability.\n\nFinally, from the point of view of the system administrator, flexible fault-tolerant architecture must allow different combinations of their operational elements, in order to better adapt its operation to the parallel computer structure. Furthermore, the adjusting of the fault tolerance parameters is also an important requirement for systems administrators, since they may tune the fault-tolerant architecture to the system requirements of the parallel computer.\nIn order to support such affirmations, let us suppose that a user needs to execute his/her program in a cluster. Obviously, the user expects that once s/he has started his/her program execution, such program will correctly finish before time bound.\n\nNow let us suppose that a node fails before the end of the program execution. Assuming that the user would detect the failure instantly (let us figure out that s/he is in front of her/his terminal until the end of the program), we may assume two scenarios:\n\n- Scenario 1: Once the user detects the problem, s/he simply either waits that someone fixes the faulty node and restart the program or re-launches the program with a node less.\n\n- Scenario 2: The user loses all his/her work because even if s/he restarts the program immediately after s/he detects the fault the program will not finish in the expected time.\n\nIn spite of the unpredictable reaction that our “friendly” user might have in scenario 2, we may affirm that, in both scenarios, a single node failure has thrown away some working hours of the cluster. It is easy to see that a fault-tolerant architecture is necessary in order to mitigate the cost caused by the loss of the computational time. Furthermore, it is reasonable to assume that the user will prefer a transparent fault-tolerant architecture that does not demand any modification in her/his algorithm, instead of worrying about how to implement fault tolerance in his/hear algorithm.\n\nFinally, such scheme must be flexible in terms of internal structures and operational parameters, in order to offer a wide range of configurations. This would help the users and the system administrators to adjust in the system parameters in order to achieve the best system performance.\n\n1.2 RADIC fundamentals\n\nRADIC is a fault-tolerant architecture that uses a rollback-recovery protocol to assure that a parallel application running can correctly finish in spite of faults in the\nnodes of the parallel computer in which it is running. The core of RADIC is a fully distributed fault-tolerant controller, which bases its operation on two groups of processes: protectors and observers.\n\nProtectors are processes that RADIC creates in order to implement the fault detection mechanism, the stable storage and the recovery mechanism required by the rollback-recovery protocol. There is one protector process running in every node of the parallel computer. Observers are processes that RADIC creates in order to implement checkpoint and message-log mechanisms. There is one observer process attached to every process of the parallel application.\n\nIn Figure 1-1, we depict a brief example of how the elements of the RADIC controller work to manage faults in a parallel computer. The figure represents a draft of four nodes in a cluster. The $P_i$ elements are application processes, the $T_i$ elements are protectors (one for each node $N_i$), the $O_i$ elements are observers (one for each process.)\n\nThe Figure 1-1a depicts some nodes of a typical cluster. We can see that a protector $T_i$ monitors a successor $T_{i+1}$ and is monitored by an antecessor $T_{i-1}$ (the arrows indicate the protection relationship). An observer $O_i$ uses its antecessor protector to store checkpoints and message-logs of its process $P_i$.\n\nIf a failure occurs, the antecessor of the faulty node detects it and recovery the faulty processes in its node. The Figure 1-1b represents cluster the after the completion of the recovery procedure started by the failure in node $N_{i+1}$. The node $N_{i+1}$ has failed; thus, $T_i$ has detected the failure and has recovered $P_{i+1}$ in $N_i$.\n\nIn Figure 1-1, we can see that application processes continue the computation after a failure. The RADIC controller has transparently performed all the fault tolerance procedures required to assure that the application will correctly finish, using the same resources available to the parallel application.\n1.3 How RADIC increases the availability of a system\n\nThe word availability, in terms of computer systems, is a measure of the time that the computer operates correctly. A simple equation serves to calculate the availability of a system [Marcus and Stern, 2003]:\n\n$$A = \\frac{MTBF}{MTBF + MTTR}$$\n\nIn Equation 1, $A$ is the degree of availability expressed as a percentage of the operation time. $MTBF$ is the mean time between failures and $MTTR$ is the maximum time to repair.\n\nAvailability is an important measure for critical systems. A scientific user needs that the computer is fully available to him/her, since his/her program begins until the program completes. In terms of parallel computers, this means that all components of the system must be available for the parallel program while it is executing, i.e., an availability of 100%. Theoretically, there is only one way of assuring an availability of 100%: reducing the MTTR to zero or increasing the MTBF to infinite.\nSince a system with infinite MTBF is unfeasible, we shall focus on the MTTR. We can evaluate the MTTR as the maximum time a failure will exist in the system, i.e., the failure’s lifetime. The lifetime of a failure has two parts: the time required detecting the failure and the time required fixing the failure in order to return the system to a full operational state. Here is where the schemes for fault tolerance play the major role. Does not matter in which level a fault-tolerant architecture is implemented, application level or system level, its more important role is to assure that the parallel application will correctly finishes independent of failures in the nodes of the parallel computer. In other words, the fault tolerance system strongly influences the MTTR.\n\nAny fault-tolerant architecture that can manage failures without human intervention, i.e., automatically and transparently to the user or the system administrator, greatly reduces the MTTR. On the other hand, the MTTR of a non-automatic scheme is unpredictable because it depends on some human intervention.\n\nRADIC operates automatically, i.e., without human intervention, in order to increase the availability by reducing the MTTR. A fault-tolerant system using RADIC has a MTTR lower than a fault-tolerant system using a non-transparent fault tolerance mechanism. Furthermore, because the RADIC mechanism bases on a group of atomic procedures, it is possible to calculate the MTTR of the system based on the specifications of the parallel computer structure.\n\n1.4 How RADIC interacts with the application\n\nTypically, there are two kinds of fault-tolerant architectures for parallel computers: fault tolerance in the application/algorithm level [Geist, 2002], and fault tolerance in the system level [Gropp and Lusk, 2004]. Other solutions mix both approaches, letting a part of the fault tolerance functions for the application and another part to the system.\n\nAny fault-tolerant architecture has advantages and disadvantages according to the target system in which it works. A fault-tolerant architecture implemented in the\napplication level is independent of the cluster structure. However, it forces the programmer to concern about how his/her application will manage faults and demands a large effort in terms of algorithm development and software engineering.\n\nOn the other hand, fault-tolerant architectures implemented in the system level liberate the programmer of the concerning about fault tolerance, but such schemes demand a large effort to integrate them with the cluster architecture.\n\nRADIC uses the system implementation level in order to be fully transparent to the parallel application. On the other hand, since RADIC recovers the faulty processes in the survivor nodes of the parallel computer, the parallel application may collapse if the structure that remains after a fault is insufficient to attend the requirements of the application.\n\nAnother interesting approach is to evaluate the Average Computational Capacity (ACC) of a system using RADIC, as defined by Koren and Krishna [Koren and Krishna, 2007]. The ACC is a function of how good the parallel application uses the available processors in a system. Therefore, the ACC depends on the probability $P_i(t)$ that exactly $i$ processors, from the $N$ total processor of the parallel computer, are operational at time $t$, and of the function $C(i)$ that defines how good the application adapts to the $i$ available processors, as described in equation 2.\n\n$$ACC = \\sum_{i=1}^{N} C(i)P_i(t)$$\n\nRADIC assures that all processes of the application will continue to execute after a failure, i.e., it creates a virtual machine capable to execute all process of the parallel applications in despite of node failures. Therefore, assuming that from the application point of view $P_i(t)=1$, the impact of the fault over the application is consequence of the how good the application adapts to the structure of the parallel computer after a failure.\n1.5 RADIC and Message-passing\n\nIn the world of the parallel computers applied to computational science, the message-passing paradigm is currently the standard paradigm used by programmers in order to create parallel applications. In the last recent years, the MPI standard [Argonne National Laboratory, 2007a] has taken the place of the PVM standard [Oak Ridge National Laboratory, 2007] as the message-passing standard for parallel programming in clusters.\n\nThe MPI standard follows the fail-stop semantic, i.e., if any part of the parallel computer’s structure fails then the application will stop. Therefore, according to the features that we have analyzed in paragraph 1.2, in order to a parallel program using MPI completes the parallel computer must be 100% available during the program’s execution.\n\nNow, let us adapt the concept of availability in order to better relate this concept with parallel applications that use message-passing. The goal of a fault-tolerant architecture is to increase the availability of the parallel computer for the parallel application. MPI programs demands 100% of availability, what means that MTTR (Equation 1) must be null. Therefore, for MPI programs, any fault-tolerant architecture must assure that the MTTR is null.\n\nHowever, a null MTTR is unfeasible since the lifetime of a fault is never null. Therefore, the only way we achieve 100% parallel computer’s availability for a parallel MPI program is masking the fault. To mask the fault means that an automatic fault-tolerant architecture must manage the parallel computer’s structure in such a way that the parallel MPI program is not aware that the failure has occurred.\n\nThe masking mechanism may use two strategies. The first is to regularly save (automatically or not) the parallel application’s state. Therefore, in case of a failure, the user can wait for the repairing of the parallel computer and restart the application from its last state saved. In this solution, the parallel application will always execute with all parallel computer’s structure available. However, one cannot assure how long the execution will take in case of a failure because the MTTR is unpredictable.\nThe second strategy is to endow the fault tolerance mechanism with the capability of adjust the distribution of the parallel application processes to the parallel computer in case of a failure. Such strategy requires an automatic mechanism in order to detect faults, to adapt the parallel application to the new computer’s structure and to assure that the parallel application correctly ends. In such strategy, the parallel programs never stop, but its execution takes a longer time if failures occur.\n\nRADIC implements a fault-masking algorithm so the RADIC processes will calculate the location of a recovered process. The algorithm is part of the distributed controller for fault tolerance implemented by RADIC. With this algorithm, programs using MPI may continue their execution even if some nodes fail, because the RADIC architecture will assure that the faulty processes will recover in a different node and will resume their execution from a previous state.\n\n1.6 Organization of this dissertation\n\nThis dissertation contains seven chapters. In the next chapter, we discuss the fault tolerance strategies for message-passing systems and explain the reasons to select the strategy used in RADIC.\n\nChapter 3 evaluates the recent fault tolerance message-passing implementation, analyzing their strong and weak points. Our idea is to show that none of them is capable to attend simultaneously to the four fundamental features offered by the RADIC.\n\nChapter 4 presents the concepts and describes the operation and the elements of the RADIC Architecture. The Chapter 5 talks about RADICMPI, a practical implementation of the RADIC ideas using the MPI standard. RADICMPI served as a test platform for the functional validation of the RADIC Architecture, which we describe in Chapter 6.\n\nChapter 7 presents the methodology and describes the experiments conducted with RADICMPI in order to evaluate the practical consequences of using RADIC in a system. Finally, in Chapter 8 we state our conclusions and suggest future works with the RADIC architecture.\nChapter 2\n\nFault Tolerance in Message-Passing Systems\n\nAny scheme made to manage faults in parallel computers rests on some kind of redundancy. For message-passing systems, the traditional method used to implement redundancy is rollback-recovery.\n\nThe main difference between the different rollback-recovery protocols is the efficiency that they present in the absence and in the presence of failures. In this chapter, we evaluate such protocols in order to choose one that better adjusts to the requirements of scalability, transparency, flexibility and decentralization.\n\nRollback-recovery is a well known and mature technique used to manage faults in applications using message-passing and running on parallel computers. In this technique, when a failure is detected the application must rollback to a previous consistent state and restarts the execution. The rollback recovery mechanism saves all computation done until the moment in which the fault occurs in order to avoid that the application must restart from its beginning after a failure.\n\nAny rollback-recovery strategy requires a set of activities in order to assure that the system can handle faults and that the application can correctly finishes in spite of faults. Such set of activities differentiates the operational phases of the several rollback-recovery protocols.\n\nThere are two major groups of rollback-recovery protocols for message-passing systems: checkpoint based and log based (Figure 2-1.) The first group uses only checkpoint of the application’s processes. The second group includes the log of\ndeterminant events in order to improve the efficiency of the rollback-recovery mechanism.\n\nIn the search of a rollback-recovery that satisfy our requirements of scalability, transparency, flexibility and decentralization; we first established the fundamentals of rollback-recovery in message-passing systems (paragraph 2.1). Next, we evaluated the two major protocol groups (paragraphs 2.2 and 2.3). Finally, we compared the protocols in order to select the one that best fulfill our requirements.\n\nRollback-recovery protocols for message passing systems\n\nCheckpoint based\n- Uncoordinated\n- Coordinated\n- Communication Induced (CIC)\n\nLog based\n- Pessimistic\n- Optimistic\n- Causal\n\nFigure 2-1: Types of rollback-recovery protocol for message-passing systems\n\nThe theoretical bases of this chapter follows the surveys made by Elnozahy [Elnozahy, et al., 2002] and by Kalaiselvi & Rajaraman [Kalaiselvi and Rajaraman, 2000]. We selected these two texts because they present two complementary ways of describing the rollback-recovery protocols and because they have served as a basic reference in many publications about fault tolerance.\n\nWhen more formal approaches were necessary in order to explain some concepts, we used the classical books of Jalote [Jalote, 1994] and Anderson & Lee [Anderson and Lee, 1981].\n\n2.1 Rollback-Recovery Fundamentals\n\nThe bases of rollback-recovery rely on the periodical recording of the state of the parallel application (represented by the state of every process and every\ncommunication channel). Upon a failure, the system “rolls back” to a previous state and resumes the execution. There are different strategies for deciding how to record the system state and how the system resumes its execution after a failure.\n\nThe key of any rollback-recovery scheme are the checkpoints. Checkpoints are intermediate states of a process that are stored in some memory element. The checkpoints must survive to a fault in the process so such process can restart from a previous state (a previous checkpoint).\n\nOne important matter in rollback-recovery is to decide about which strategy the system should use to take the checkpoints. For example, a fault-tolerant architecture based on rollback-recovery may use coordinated or uncoordinated checkpoints; each strategy has advantages and disadvantages according to the application behavior. Another important matter is how the cluster organization will interact with the fault tolerance strategy. For example, a system that stores all checkpoints in a central server will suffer more performance degradation as the number of nodes increases.\n\nAny rollback-recovery scheme considers a distributed system as a collection of application processes that communicate through a network. Each process achieves fault tolerance by using a stable storage device, which must survive all tolerated failures, to save recovery information periodically during failure-free execution. Upon a failure, a failed process uses its saved information to restart the computation from an earlier state, thereby reducing the amount of lost computation.\n\nA rollback-recover protocol, also called fault-tolerance protocol, manages the rollback-recovery functioning. In simple protocols, the recovery information can include only the states of the participating processes, called checkpoints. More sophisticated recovery protocols may require additional information, such as logs of the interactions with input and output devices, events that occur to each process, and messages exchanged among the processes.\n\nIn this thesis, we define a distributed parallel application based message-passing as a collection of processes that cooperate through messages sent via some network. Figure 2-2 shows a symbolic representation of a parallel application with four\nprocesses. In that figure, a line represents a process execution and the arrow lines between the processes represent messages.\n\n\n\n**Figure 2-2: An example of a distributed application using message-passing**\n\nEach process’s execution is a sequence of state’s intervals triggered by a nondeterministic event. For the sake of the parallel applications used in this thesis, such triggers are the messages that arrive to the process. Inside each state interval the execution is deterministic, i.e., if a process starts from the same state and is subjected to the same nondeterministic events at the same locations within the execution, it will always generate the same output.\n\nA rollback-recovery protocol should assure that the internal state of a system after a failure should be consistent with the observable behavior of the system before the failure [Strom and Yemini, 1985]. In order to satisfy this condition, a rollback-recovery protocol must save information about internal iterations among processes to assure that the system restart from a consistent state after a failure. Consistent system state and other important concepts follow.\n\n### 2.1.1 Consistent System State\n\nThe state (or the global state) of a distributed system is represented by the state of each communication channel and each process in a given time. Therefore, one can model a distributed system as a sequence of system states in which some kind of\nevent triggers the transition from one state to another. Multiple events may occur in a given state and an event’s presence, or its absence, depends on the particular execution of the system. This means that even if we restart a system many times from the same initial state and we give to it the same inputs, the system can follow a different sequence of states, and each sequence is a valid execution of the system. A consistent system state (or consistent global state) is one that may occur during a failure-free correct execution, i.e., one that could occur in one of the possible sequences of states in the system.\n\nCheckpoints correspond just to processes’ states and have no information about the states of the communication channels. Therefore, in order to record a consistent global state of a process, whenever the state of any process indicates that it has sent a message to another process, the state of the receptor must indicate that it has received this message [Chandy and Lamport, 1985]. This requirement is the major condition to the implementation of techniques to record global states of distributed systems.\n\n2.1.2 Recovery Line\n\nFigure 2-3 shows an example of two system’s states. In this figure, the bars indicate the checkpoints of the processes. In Figure 2-3a, the system’s state indicates that process P_2 has sent the message m_3 but process P_0 has not yet received it. In such situation, if P_0 fails and rolls back to the state represented by the checkpoint C_{00}, then the system goes to an inconsistent global state because the state of P_2 indicates that it has sent m_3 to P_0 and the state of P_0 does not indicate that it has received m_3.\n\nThe consistency of the global system’s state depends on how the recovery protocol deals with in-transit messages. If the rollback-recovery protocol assumes that the message channels are reliable, then the global state in Figure 2-3a is inconsistent and m_3 is a lost message. On the other hand, if the rollback-recovery protocol assumes that the message channels are unreliable, this global state is consistent and m_3 is an in-transit message.\nThe example of Figure 2-3b also shows an inconsistent state because the state of process \\( P_0 \\) considers that \\( P_0 \\) has received \\( m_3 \\) but the state of process \\( P_2 \\) does not considers that \\( P_2 \\) has sent \\( m_3 \\). In this case, \\( m_3 \\) is an \\textit{orphan message}.\n\nIf a set of checkpoints of the system, i.e., a system global state, satisfy the following restrictions, then it is a \\textit{recovery-line} and the recovery protocol can use it as a recovery point [Jalote, 1994]:\n\na) The set contains only one checkpoint for each process;\n\nb) For a given set, there is no send-event succeeding the recovery point of a sender process \\( P \\), whose equivalent receive-event in the destination process \\( Q \\) occurs before the recovery point of \\( Q \\) in the set (no orphan messages).\n\nc) For a given set, there is no send-event preceding the recovery point of a sender process \\( P \\), whose equivalent receive-event in the destination process \\( Q \\) occurs after the recovery point of \\( Q \\) in the set (no lost messages).\n\n\\begin{figure}[h]\n\\centering\n\\includegraphics[width=\\textwidth]{figure2-3.png}\n\\caption{Examples of inconsistent global system state. a) Inconsistency caused by a lost message; b) Inconsistency caused by a orphan message}\n\\end{figure}\n2.1.3 In-transit Messages\n\nIn-transit messages are messages registered in the sender’s state but not in the receptor’s state. There are two ways to implement the rollback-recovery protocol in order to deal with in-transit messages.\n\n- **An implementation based on a reliable communication protocol.** In this case, a reliable communication protocol ensures the reliability of message delivery during failure-free executions, but it cannot ensure the reliability of message delivery in the presence of failures. For instance, a conventional communication protocol will generate a timeout and inform to the sender that it cannot deliver the message whenever an in-transit message is lost because the intended receiver has failed. Once the fault tolerance mechanism recovers the receiver process, the system must mask the timeout from the sender process and make the in-transit messages available to the intended receiver process after it recovers.\n\n- **An implementation based on an unreliable communication channel.** In this case, the recovery protocol need not handle in-transit messages in any special way. Indeed, the recovery protocol cannot distinguish the in-transit messages lost because of process failures from those lost because of communication failures in an unreliable communication channel. Therefore, the loss of in-transit messages due to either communication or process failure is an event that can occur in any failure-free, correct execution of the system.\n\n2.1.4 Domino Effect\n\nThe *domino effect* [Randell, 1999; Russell, 1980] appears when the processes of a distributed application take their checkpoints in an uncoordinated manner. Figure 2-4 shows an execution in which processes take their checkpoints (represented by red bars) without coordinating with each other.\n\nEach process starts its execution with an initial checkpoint. Suppose that process $P_0$ fails and rolls back to checkpoint A. The rollback of $P_0$ invalidates the sending of message $m_6$, and so $P_1$ must roll back to checkpoint B in order to “invalidate” the\nreceipt of the message \\( m_6 \\). Thus, the invalidation of message \\( m_6 \\) propagates the rollback of process \\( P_0 \\) to the process \\( P_1 \\), which in turn invalidates message \\( m_5 \\) and forces \\( P_2 \\) to roll back as well. Because of the rollback of process \\( P_2 \\), process \\( P_3 \\) must also rollback to invalidate the reception of \\( m_4 \\). Those cascaded rollbacks may continue and eventually may lead to the \\textit{domino effect}, which forces the system to roll back to the beginning of the computation, in spite of all saved checkpoints.\n\nThe amount of rollback depends on the message pattern and the relation between the checkpoint placements and message events. Typically, the system restarts since the last recovery line. However, depending on the interaction between the message pattern and the checkpoint pattern, the only bound for the system rollback is the initial state, causing the loss of all the work done by all processes. The dashed line shown in Figure 2-4 represents the recovery line of the system in case of a failure in \\( P_0 \\).\n\n\n\n### 2.1.5 Event Logging\n\nEvent logging is the strategy used to avoid the domino effect caused by uncoordinated checkpoints. Log-based rollback-recovery protocol is family’s name of the protocols whose take message logs besides checkpoints. Such protocols base on the \\textit{piecewise deterministic} (PWD) assumption [Strom and Yemini, 1985]. Under this assumption, the rollback recovery protocol can identify all the nondeterministic\nevents executed by each process. For each nondeterministic event, the protocol logs a determinant that contains all needed information to replay the event should it be necessary during recovery. If the PWD assumption holds, a log-based rollback-recovery protocol can recover a failed process and replay the determinants as if they have occurred before the failure.\n\nThe log-based protocols require only that the failed processes roll back. During the recovery, the messages that were lost because of the failure are “resent” to the recovered process in the correct order using the message logs. Therefore, log-based rollback-recovery protocols force the execution of the system to be identical to the one that occurred before the failure. The system always recovers to a state that is consistent with the input and output interactions that occurred up to the fault.\n\n2.1.6 Stable Storage\n\nRollback recovery protocols use stable storage to save checkpoints, message logs, and other recovery-related information. The concept of stable storage in rollback recovery protocols is an abstraction and should not be confused with the disk storage used to implement it. Stable storage must ensure that the recovery data persist through the tolerated failures and their corresponding recoveries. This requirement allows different implementation’s techniques of stable storage according to the number of failures a system can tolerate. A classification of such techniques according to the number of faults follows [Elnozahy, et al., 2002]:\n\nd) For only a single failure, a stable storage may consist of the volatile memory of another process [Borg, et al., 1989];\n\ne) For an arbitrary number of transient failures, stable storage may consist of a local disk in each host;\n\nf) For non-transient failures, stable storage must consist of a persistent medium outside the host on which a process is running. One possibility is to implement this scheme using a network file system or to replicate the recovery information of a node into a different node.\n2.1.7 Garbage Collection\n\nThe amount of recovery information (checkpoints and event logs) increases as the application progresses. Since the amount of storage required to store the recovery information influences the cost of the fault tolerance scheme, some strategy is necessary in order to reduce the amount of storage, i.e., the storage cost, consumed by discarding useless information. From time to time, a subset of the stored information becomes useless for recovery. Garbage collection is the deletion of such useless recovery information from the system.\n\nA typical approach to perform garbage collection is to identify the most recent recovery line, and discard all information relating to the events that occurred before that line. For example, processes that coordinate their checkpoints to form consistent states will always restart from the most recent checkpoint of each process. Therefore, the protocol can discard all previous checkpoints.\n\nGarbage collection is an important pragmatic issue in rollback-recovery protocols for two reasons. First, because running a special algorithm to discard useless information incurs an extra overhead. Second, because the garbage collection reduces the amount of hardware resources used by the fault tolerance mechanism as the parallel application runs.\n\nDifferent rollback-recovery protocols differ in the amount and nature of the recovery information they need to store in the stable storage. Therefore, each protocol differs in the complexity and invocation frequency of its garbage collection algorithm.\n\n2.2 Checkpoint Based Protocols\n\nThe goal of rollback-recovery protocols based on checkpoint is to restore the system to the most recent consistent global state of the system, i.e., the most recent recovery line. Since such protocols do not rely on the PWD assumption, they do not care about nondeterministic events, i.e., they do not need to detect, log or replay nondeterministic events. Therefore, checkpoint-based protocols are simpler to implement and less restrictive than message-log methods.\nThe next topics explain the three categories of the checkpointing strategies used by the checkpoint-based protocols: *uncoordinated*, *coordinated* and *communication-induced*.\n\n### 2.2.1 Uncoordinated checkpointing\n\nIn this method, each process has total autonomy for making its own checkpoints. Therefore, each process chooses to take a checkpoint when it is more convenient to it (for instance, when the process’s state is small) and does not care about the checkpoints of the other processes. Zambonelli [Zambonelli, 1998] make an evaluation of several uncoordinated checkpoint strategies.\n\nThe uncoordinated strategy simplifies the checkpoint mechanism of the rollback-recovery protocol because it gives independence for each process manage its checkpoint without any negotiation with the other processes. However, such independence of each process comes under a cost expressed as follows:\n\n- a) There is the possibility of domino effect and all its consequences;\n- b) A process can take useless checkpoint since it cannot guarantee by itself that a checkpoint is part of a global consistent-state. These checkpoint will overhead the system but will not contribute to advance the recovery line.\n- c) It is necessary to use garbage collection algorithm to free the space used by checkpoints that are not useful anymore.\n- d) It is necessary a global coordination to compute the recovery line, what can be very expensive in application with frequent output commit.\n\nDuring failure-free operation, the processes calculate the interdependencies among theirs checkpoints using a technique explained by Bhargava and Shu-Renn [Bhargava and Shu-Renn, 1988]. In this technique, each process piggyback checkpoint information in each message sent to another process. The destination process uses this information to calculate the dependency between it and the sender. If a failure occurs, the recovering process initiates the rollback by broadcasting a dependency request message to collect all the dependency information maintained by\neach process. Upon a process receives this message, it stops its execution and replies with the dependency information saved on the stable storage as well as with the dependency information, if any, that is associated with its current state. The initiator then calculates the recovery line based on the global dependency information and broadcasts a rollback request message containing the recovery line. Upon receiving this message, a process whose current state belongs to the recovery line simply resumes execution; otherwise, it rolls back to an earlier checkpoint as indicated by the recovery line.\n\nThere are two similar approaches to calculate the recovery line: the rollback-dependency graph [Bhargava and Shu-Renn, 1988] and the checkpoint graph [Wang, 1997]. Both are equivalent in that they always produce the same recovery line. By using such methods, one can determine the most advanced recovery line. This greatly simplifies the implementation of the garbage collection algorithm in order to liberate the space used by checkpoints located before this line.\n\n### 2.2.2 Coordinated Checkpointing\n\nIn this approach, the processes must synchronize their checkpoint in order to create a consistent global state. A faulty process always will restart from its most recent checkpoint, so the recovery is simplified and the domino effect avoided. Furthermore, as each process only needs to maintain one checkpoint in stable storage, there is no the need of a garbage collection scheme and the storage overhead is reduced.\n\nThe main disadvantage is the high latency involved when operating with large systems. Because of this, the coordinated checkpoint protocol is barely applicable to large systems.\n\nTamir & Sequin propose a typical scheme that uses a central coordinator in order to start the checkpoint mechanism [Tamir and Sequin, 1984]. In this scheme, the coordinator broadcasts a request asking to all other process to make a checkpoint. Upon receiving a checkpoint request, the process suspend its execution, takes a tentative checkpoint and sends an acknowledge message to the coordinator. After the\ncoordinator receives the acknowledge messages from all process it broadcast a commit message. Upon receiving a commit message, all processes replace the old checkpoint with the tentative checkpoint and resume the execution.\n\nAlthough straightforward, this scheme can yield in a large overhead. An alternative approach is to use a non-blocking checkpoint scheme like the proposed in [Chandy and Lamport, 1985] and in [Elnozahy, et al., 1992]. However, non-blocking schemes must prevent the processes from receiving application messages that make the checkpoint inconsistent.\n\nAnother alternative is to use loosely synchronized clocks in order to facilitate checkpoint coordination. By using loosely synchronized clocks, all processes can trigger checkpoint actions at approximately the same time without a checkpoint initiator [Cristian and Jahanian, 1991; Tong, et al., 1992].\n\nThe scalability of coordinated checkpointing is weak because all processes must to participate in every checkpoint. A strategy to reduce the number of processes involved is to take new checkpoints for only those processes that have communicated with the checkpoint initiator either directly or indirectly since the last checkpoint [Koo and Toueg, 1987].\n\n2.2.3 Communication-Induced Checkpointing (CIC)\n\nThe communication-induced checkpointing protocols do not require that all checkpoints be coordinated and do avoid the domino effect. There are two kinds of checkpoints for each process: local checkpoints that occur independently and forced checkpoints that must occur in order to guarantee the eventual progress of the recovery line. The CIC protocols take forced checkpoints to prevent the creation of useless checkpoints, i.e., checkpoints that will never be part of a consistent global state (and so they will never contribute to the recovery of the system from failures) although they consume resources and cause performance overhead.\n\nAs opposed to coordinated checkpointing, CIC protocols do not exchange any special coordination messages to determine when forced checkpoints should occur; instead, they piggyback protocol specific information on each application message.\nThe receiver then uses this information to decide if it should take a forced checkpoint. The algorithm to decide about forced checkpoints relies on the notions of Z-path and Z-cycle [Netzer and Jian, 1995]. For CIC protocols, one can prove that a checkpoint is useless if and only if it is part of a Z-cycle.\n\nTwo types of CIC protocols exist: indexed-based coordination protocols and model-based checkpointing protocols. It has been shown that both are fundamentally equivalent [Helary, et al., 1997a], although in practice they have some differences [Alvisi, et al., 1999].\n\n**Indexed-based coordination protocols**\n\nThese protocols assign timestamps to local and forced checkpoints such that checkpoints with the same timestamp at all processes form a consistent state. The timestamps are piggybacked on application messages to help receivers decide when they should force a checkpoint [Elnozahy, et al., 2002]. An implementation can be found in the work of Hélary [Helary, et al., 1997b].\n\nIn CIC, each process has a considerable autonomy in taking checkpoint. Therefore, the use of efficient policies in order to decide when to take checkpoints can lead to a small overhead in the system. Since these protocols do not require processes to participate in a globally coordinated checkpoint, they can, in theory, scale up well in systems with a large number processes [Elnozahy, et al., 2002].\n\n**Model-based protocols**\n\nThese schemes prevent useless checkpoint using structures that avoid patterns of communications and checkpoints that could lead to useless checkpoints or Z-cycles. They use a heuristic in order to define a model for detecting the possibility that such patterns occur in the system. The patterns are detected locally using information piggybacked on application messages. If such a pattern is detected, the process forces a checkpoint to prevent that the pattern occurs [Elnozahy, et al., 2002].\n\nModel-based protocols are always conservative because they force more checkpoints than could be necessary, once each process does not have information about the global system state because there is no explicit coordination between the\n\n### 2.2.4 Comparing the checkpoint protocols\n\nIt is reasonable to say that the major source of overhead in checkpointing schemes is the stable storage latency. Communication overhead becomes a minor source of overhead as the latency of network communication decreases. In this scenario, the coordinated checkpoint becomes worthy since it requires less accesses to stable storage than uncoordinated checkpoints. Furthermore, in practice, the low overhead gain of uncoordinated checkpointing do not justify neither the complexities of finding the recovery line after failure and performing the garbage collection nor the high demand for storage space caused by multiple checkpoints of each process [Elnozahy, et al., 2002].\n\nCIC protocol, in turn, does not scale well as the number of process increases. The required amount of storage space is also difficult to predict because the occurrence of forced checkpoints at random points of the application execution.\n\n### 2.3 Log-based protocols\n\nThese protocols require that only the failed process to roll back. During normal computation, the processes log the messages into a stable storage. If a process fails, it will recover from a previous state and the system will lose the consistency since there may be missed messages or orphan messages related to the recovered process [Elnozahy and Zwaenepoel, 1994]. During the process’s recovery, the logged messages will be recovered properly from the message log, so the process can resume its normal operation and the system will reach a consistent state again [Jalote, 1994].\n\nLog-based protocols consider that a parallel-distributed application is a sequence of deterministic state intervals, each starting with the execution of a nondeterministic event [Strom and Yemini, 1985]. Each nondeterministic event relates to a unique determinant. In distributed systems, the typical nondeterministic event that occurs to a\nprocess is the receipt of a message from another process (message logging protocol is the other name for these protocols.) Sending a message, however, is a deterministic event. For example, in Figure 2-4, the execution of process $P_3$ is a sequence of three deterministic intervals. The first one is the process’ creation and the other two starts with the receipt of $m_2$ and $m_4$. The initial state of the process $P_3$ is the unique determinant for sending $m_1$.\n\nDuring failure-free operation, each process logs the determinants of all the received messages onto stable storage. Additionally, each process also takes checkpoints to reduce the extent of rollback during recovery. After a failure occurs, the failed processes recover by using the checkpoints and logged determinants to replay the corresponding nondeterministic events precisely as they occurred during the pre-failure execution. Because the execution within each deterministic interval depends only on the sequence of received messages that preceded the interval’s beginning, the recovery procedure reconstructs the pre-failure execution of a failed process up to the first received message that have a no logged determinant.\n\nLog-based protocols guarantee that upon recovery of all failed processes, the system does not contain any orphan process. A process is orphan when it does not fail and its state depends on the execution of a nondeterministic event whose determinant cannot be recovered from stable storage or from the volatile memory of a surviving process [Elnozahy, et al., 2002].\n\nThe way a specific protocol implements the no-orphan message condition affects the protocol’s failure-free performance overhead, the latency of output commit, and the simplicity of recovery and garbage collection schemes, as well as its potential for rolling back correct processes. These differences lead to three classes of log-based protocols: pessimistic, optimistic and causal.\n\nAn implementation called $K$-optimistic logging protocol is proposed in [Damani, et al., 2003]. However, instead of a new protocol, the authors propose a new way to use the optimistic protocol by applying a constant $K$ that defines a “grade of optimality”. By varying $K$, one may chose the cost-benefit relationship of the message log protocol in terms of overhead in failure free scenarios and in case of failure.\n2.3.1 Pessimistic log-based protocols\n\nThese protocols assume that a failure can occur after any nondeterministic event in the computation. This assumption is “pessimistic” since in reality, failures are rare. In their most straightforward form, pessimistic protocols log the determinant of each received message before the message influences in the computation. Pessimistic protocols implement a property often referred to as *synchronous logging*, i.e., if an event has not been logged on stable storage, then no process can depend on it [Elnozahy, et al., 2002]. Such condition assures that orphan processes will never exist in systems using pessimistic log-based protocol.\n\nProcesses also take periodic checkpoints in order to limit the amount of work that the faulty process has to repeat during recovery. If a failure occurs, the process restarts from its most recent checkpoint. During the recovering procedure, the process uses the logged determinants to recreate the pre-failure execution.\n\nSynchronous logging enables that the observable state of each process is always recoverable. This property leads to four advantages at the expense of a high computational overhead penalty [Elnozahy, et al., 2002]:\n\na) Recovery is simple because the effects of a failure influences only the processes that fails.\n\nb) Garbage collection is simple because the process can discard older checkpoints and determinants of received messages that are before the most recent checkpoint.\n\nc) Upon a failure, the failed process restarts from its most recent checkpoint what limits the extent of lost computation.\n\nd) There is no need of a special protocol to send messages to outside world.\n\nSome examples of pessimistic log-based rollback-recovery protocols are found in the works described in [Borg, et al., 1989; Elnozahy and Zwaenepoel, 1992; Johnson and Zwaenepoel, 1987; Juang and Venkatesan, 1991]. These implementations differ in the way they try to reduce overhead penalty under failure-free operation.\n2.3.2 Optimistic log-based protocols\n\nThese protocols allow the apparition of orphans because to failures in order to reduce the failure-free performance overhead. However, the possibility of apparition of orphans processes complicates the recovery, garbage collection and output commit [Jalote, 1994]. In optimistic protocols [Sistla and Welch, 1989; Strom and Yemini, 1985] every process take checkpoint and message log asynchronously. Furthermore, a volatile log maintains each determinant meanwhile the application processes continue their execution. There is no concern if the log is in the stable storage or in the volatile memory. The protocol assumes that logging to stable storage will complete before a failure occurs (thence its optimism).\n\nIf a process fails, the determinants in its volatile log will be lost, and the state intervals started by the nondeterministic events corresponding to these determinants are unrecoverable. Furthermore, if the failed process sent a message during any of the state intervals that cannot be recovered, the receiver of the message becomes an orphan process and must roll back to undo the effects of receiving the message. To perform these rollbacks correctly, optimistic logging protocols track causal dependencies during failure-free execution [Elnozahy, et al., 2002; Jalote, 1994]. Upon a failure, the dependency information is used to calculate and recover the latest global state of the pre-failure execution in which no process is in an orphan. Since there is now a dependency between processes, optimistic protocols need to keep multiple checkpoints what complicates the garbage collection policy.\n\nThe recovery mechanism in optimistic protocol can be either synchronous or asynchronous. Each one is explained bellow [Elnozahy, et al., 2002] and detailed bellow:\n\n**Synchronous recovery**\n\nDuring failure free operation, each process updates a state interval index when a new state interval begins. The indexes serve to track the dependency between processes using two distinct strategies: direct or transitive. In synchronous recovery, all processes use this dependency information and the logged information to calculate\nthe maximum recovery line. Then, each process uses the calculated recovery line to\nderide if it must roll back.\n\nIn direct tracking strategy, each outgoing message contains the state interval\nindex of the sender (piggybacked in the message) in order to allow the receiver to\nrecord the dependency directly caused by the message. At recovery time, each process\nassembles its dependencies to obtain the complete dependency information.\n\nIn transitive tracking, each process maintains a size-$N$ vector $V$, where $V[i]$ is the\ncurrent state interval index of the process $P_i$ itself, and $V[j], j \\neq i$, records the highest\nindex of any state interval of a process $P_j$ on which $P_i$ depends. Transitive dependency\ntracking generally incurs a higher failure-free overhead because of piggybacking and\nmaintaining the dependency vectors, but allows faster output commit and recovery.\n\n**Asynchronous recovery**\n\nIn this scheme, a recovery process broadcasts a rollback announcement to start a\nnew incarnation. Every process that receives a rollback announcement checks if it has\nbecome an orphan because of the announcement and then, if necessary, it rolls back\nand broadcasts its own rollback announcement.\n\nAsynchronous recovery can produce a situation called exponential rollbacks.\nExponential rollbacks occur when a process rolls back an exponential number of\ntimes because of a single failure [Sistla and Welch, 1989]. The asynchronous protocol\neliminates exponential rollbacks by either distinguishing failure announcements from\nrollback announcements or piggybacking the original rollback announcement from\nthe failed process on every subsequent rollback announcement that it broadcasts.\n\n2.3.3 **Causal log-based protocols**\n\nThese protocols avoid the creation of orphan processes by ensuring that the\ndeterminant of each received message, which causally precedes a process’s state,\neither is in stable storage or is available locally to that process [Elnozahy, et al.,\n2002]. Such protocols dispense synchronous logging, which is the main disadvantage\nof pessimistic protocols, while maintaining their benefits (isolation of failed\nprocesses, rollback extent limitation and no apparition of orphan processes). However, causal protocols have a complex recovery scheme.\n\nIn order to track causality, each process piggybacks the non-stable determinants that are in its volatile log on the messages it sends to other processes. On receiving a message, a process first adds any piggybacked determinant to its volatile determinant log and then delivers the message to the application.\n\n2.4 Comparing the rollback-recovery protocols\n\nTable 1 summarizes the differences among the rollback-recover protocols. The decision about which one is best suited for a given system than another is not straightforward. It depends on diverse factors like probability of failures, message pattern among application processes, the resources consumed, etc.\n\nUsing the four basic requirements as reference (scalability, transparency, decentralization and flexibility,) we compared the protocols described in Table 2-1 in order to choose the ones that could best attend to these requirements. We immediately discarded the uncoordinated, the CIC and the optimistic protocol because they allow the creation of orphan processes.\n\nWe defined that, in order to be scalable, the number of computational elements of the parallel computer must not influence the operation of the protocol. To satisfy such requirement, the recovery mechanism must be independent of the number of elements present in the system. For this, it is necessary that the process recovering rest only on local information, i.e, it cannot rests on the information about other process.\n\nLooking again at Table 2-1, one can see that the only protocol that allows local decision during the recovery phase is the pessimist message-log. This protocol also increases the efficiency in terms of storage space because each process only needs to store its last checkpoint in order to recover. Additionally, this feature greatly simplifies the implementation of the garbage collection mechanism.\n\nThe pessimistic rollback-recovery protocol does not restrict the other features. It may operate in the system level so the application is not aware about it (transparency).\nIt has an intrinsic decentralization because each process only needs local information to recover from faults.\n\n**Table 2-1: Comparison between rollback recovery protocols [Elnozahy, et al., 2002]**\n\n<table>\n<thead>\n<tr>\n<th></th>\n<th>Uncoord.</th>\n<th>Coordinated</th>\n<th>CIC</th>\n<th>Pessimistic</th>\n<th>Optimistic</th>\n<th>Causal</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>PWD assumed</td>\n<td>No</td>\n<td>No</td>\n<td>No</td>\n<td>Yes</td>\n<td>Yes</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>Checkpoint per process</td>\n<td>Several</td>\n<td>1</td>\n<td>Several</td>\n<td>1</td>\n<td>Several</td>\n<td>1</td>\n</tr>\n<tr>\n<td>Domino effect</td>\n<td>Possible</td>\n<td>No</td>\n<td>No</td>\n<td>No</td>\n<td>No</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Orphan processes</td>\n<td>Possible</td>\n<td>No</td>\n<td>Possible</td>\n<td>No</td>\n<td>Possible</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Rollback extent</td>\n<td>Unbounded</td>\n<td>Last global checkpoint</td>\n<td>Possibly several checkpoints</td>\n<td>Last checkpoint</td>\n<td>Possibly several checkpoints</td>\n<td>Last checkpoint</td>\n</tr>\n<tr>\n<td>Recovery data</td>\n<td>Distributed</td>\n<td>Distributed</td>\n<td>Distributed</td>\n<td>Distributed or Local</td>\n<td>Distributed or Local</td>\n<td>Distributed</td>\n</tr>\n<tr>\n<td>Recovery protocol</td>\n<td>Distributed</td>\n<td>Distributed</td>\n<td>Distributed</td>\n<td>Local</td>\n<td>Distributed</td>\n<td>Distributed</td>\n</tr>\n<tr>\n<td>Output commit</td>\n<td>Not possible</td>\n<td>Global coordination required</td>\n<td>Global coordination required</td>\n<td>Local decision</td>\n<td>Global coordination required</td>\n<td>Local decision</td>\n</tr>\n</tbody>\n</table>\n\nFinally, the pessimistic message log protocol is very flexible because the operation of the fault tolerance mechanism is restricted to each process, allowing the building of several different arrangements in order to attend to the performance or efficiency requirements of the system. For example, each process may have its own checkpoint interval in order to reduce the overall cost of the checkpoint procedure.\n\nIn this chapter, we presented the rollback-recovery protocols for message-passing systems and justified the pessimistic log-based protocol as the only one that simultaneously supports all four requirements for the modern fault tolerance schemes for parallel computers. In the next chapter, we present some recent fault tolerant message-passing implementations and show that, because of their architecture and rollback-recovery protocol, none of them can simultaneously to support the four key features that we have established for a modern fault tolerance solution.\nChapter 3\n\nFault Tolerant Message-passing Implementations\n\nIn the last chapter, we discuss the theoretical aspects of the rollback-recovery protocols for fault tolerance in message-passing systems. We also justified the adoption of the pessimist message-log protocol as the protocol that simultaneously attends to scalability, transparency, flexibility and decentralization.\n\nNow, we are going to evaluate some legacy and current fault-tolerant message-passing implementations in terms of the same features. We analyzed that none of these implementations simultaneously supports these four of features, what creates an opportunity to the development of a new solution.\n\nThe message-passing paradigm is a paradigm largely used for development of parallel programs. The large acceptance of such paradigm has given place to the development of the PVM and MPI standards.\n\nIn the last recent years, the MPI standard has become the de facto standard for the development of distributed parallel applications using the message-passing paradigm. Therefore, we focused our attention in practical MPI implementations.\n\nBecause MPI uses a fail-stop semantic, several fault tolerance MPI implementations based on rollback-recovery have appeared, but we have verified that none of them could simultaneously attend to the four major requirements that we are looking for.\n\nIn this chapter, we first discuss some practical aspects related to the operation of fault tolerance mechanisms in message-passing systems. Then, we present traditional\nand current fault-tolerant MPI implementation and summarize their features in order to show that none of them simultaneously offers the same set of features we are looking for: transparency, decentralization, scalability and flexibility.\n\n3.1 Practical aspects\n\nAny fault-tolerant architecture interacts with the application and the parallel computer structure. Such interaction yields practical consequences we should consider when evaluating a fault tolerance implementation. We divided these practical aspects in three main groups as shown in Figure 3-1.\n\n1) Transparency\n\n2) Operational cost\n\n- Checkpoint overhead\n- Storage\n- Network bandwidth\n- Message latency\n\n3) Adaptation to failures\n\n- Structural changes\n- Load balance\n- Process migration\n\nFigure 3-1: Practical aspects of fault tolerance for message-passing systems\n\n3.1.1 Transparency\n\nAn important concern is how much software development effort is necessary in order to enjoy the fault tolerance benefits.\n\nTo embed fault-tolerance in the application yields the best benefits because the developer will have full control of how fault-tolerance will interact with the application and the cluster architecture. However, the cost of embedding fault tolerance in an application is worthy only when such application executes many times and when it is necessary to achieve the best possible performance for the application.\nTo embed fault-tolerance in the system is very interesting when the application development time is the main requisite. The common approach in such cases is to offer to the user, a library that implements the fault tolerance functionality in the MPI API. The development cost is low because the user just needs to recompile its applications with the library in order to gain access to the fault tolerance. The disadvantage of this method is that the application performance depends on the fault tolerance implementation and the way the fault tolerance interacts with the cluster architecture.\n\n3.1.2 Operational cost\n\nAny fault-tolerant architecture will have some associated costs. These costs relates to the resources consumed by the fault tolerance mechanism. For systems using fault tolerance schemes based on rollback-recovery, the following elements will influence the operational cost:\n\nCheckpoint overhead\n\nCheckpointing strongly contributes for computation time enlargement because of the cost of writing the process’ state into the stable storage. Strategies as concurrent checkpointing [Goldberg, 1990] in combination with incremental checkpointing [Plank, et al., 1995] can greatly reduce the checkpoint overhead. Furthermore, incremental checkpoint also reduces the storage space consumed by checkpoints.\n\nThe problem of determining the optimal checkpointing frequency and placement is a kind of optimization’s problem subjected to constraints [Chandy, 1972]. However, the optimality of checkpoint placement is rarely an concern in practical systems because in practice the overhead of checkpointing is usually negligible, unless the checkpointing interval is relatively small, as observed by Elnozahy at [Elnozahy, et al., 1992].\n\nStable storage and storage space consumed\n\nMagnetic disks are still the preferred media used for logs and checkpoints and are the largest contributor for performance overheads. Communication overhead is much lower in comparison with the disk storage overhead.\nThe amount of space required by checkpoints and message logs strongly influences the efficiency of the fault tolerance scheme. The checkpoint interval and the application behavior (message pattern and processes state sizes) are the major parameters that determine the storage space consumed by the fault tolerance.\n\n**Network bandwidth consumed**\n\nBesides the normal application messages, many control messages will exist because of the rollback-recovery protocol and the fault detection scheme. Furthermore, taking into consideration that checkpoint and message logs of a process are saved outside the machine where the process is, delivering of these new elements also will contribute for a reduction of the total network bandwidth.\n\n**Message latency enlargement**\n\nSchemes using message-log increase the message latency because of the necessity of saving the logs into a stable storage. The total overhead will depend from the message-log protocol and the application’s message pattern.\n\n### 3.1.3 Adaptation to failures\n\nAfter a failure, the whole system changes to a new configuration. This new configuration is consequence of the new the structure of the parallel computer and how the parallel application will interact with such new structure. A fault directly influences three major system’s feature, as explained bellow.\n\n**Structural changing**\n\nAfter a node failure, the cluster configuration will depend of the remaining resources. The user can decide to reserve nodes for faulty node replacement; however, this solution can be inefficient if the probability of failures is small or if there are few nodes in the system, because the spare nodes do not participate in the computation.\n\nA common solution in practical systems is to use all available resources and to recover the faulty processes in the remaining nodes of the cluster. This strategy leads to problems of load balancing and location-independency of the distributed application processes.\nLoad-balancing\n\nThe load-balancing problem depends on the ratio between the number of faulty nodes and the number of total nodes in the cluster. Load-balancing includes an additional overhead and the decision of include it or not in the fault-tolerant architecture is influenced by factors such as total application runtime, cluster MTBF, i.e. probability of failures, and the number of nodes in the cluster.\n\nMigration of recovered processes\n\nRollback-recovery protocols should prevent the application processes from acquiring dependency of any location. The system must mask the actual location of the process (network identity, addresses and ports) for the communication protocol.\n\n3.2 Recent fault-tolerant message-passing platforms\n\nIn the last ten years, several message-passing implementations included fault tolerance capabilities. Because MPI has become the de-facto standard for message-passing systems, we focused our attention in the fault-tolerant MPI implementations (Table 3-1). Some of these implementations do offer the requirements necessary to attend the fault tolerance expectations of the modern parallel computers. Nevertheless, at the end of this chapter we present a comparison that shows that none of them attends simultaneously to the four benefits we have established: transparency, flexibility, scalability and decentralization.\n\n| Table 3-1: Time line of the recent fault-tolerant MPI implementations |\n|---|---|---|---|\n| 1996 | 1999 | 2000 | 2001 |\n| CoCheck | Starfish and Egida | FT-MPI | MPI/FT |\n| 2002 | 2003 | 2005 | 2006 |\n| MPICH-V1 | MPICH-V2 and LA-MPI | LAM/MPI | MPICH-PCL |\n3.2.1 CoCheck\n\nCoCheck tuMPI [Stellner, 1996] addresses fault tolerance application level and was one of the first efforts to incorporate fault tolerance into MPI. CoCheck used the Condor [Litzkow, et al., 1988] library to checkpoint and then, if necessary, restart and rollback all MPI processes. Its main drawback was the need to checkpoint the entire application, which is prohibitively expensive in terms of time and scalability for large applications.\n\n3.2.2 Starfish MPI\n\nUnlike CoCheck that relies on Condor, Starfish [Agbaria and Friedman, 1999] uses its own distributed system to provide built-in checkpointing. The main difference with CoCheck is that Starfish uses strict atomic group communication protocols, built upon the Ensemble system, in order to handle communication and manage state changes. This mechanism avoids the message flush protocol of CoCheck.\n\n3.2.3 Egida\n\nEgida [Rao, et al., 1999] is an object-oriented toolkit designed to support transparent rollback-recovery. Egida specifies a simple language that serves to express arbitrary rollback recovery protocols. From this specification, Egida automatically synthesizes an implementation of the specified protocol by gluing together the appropriate objects from an available library of building blocks.\n\n3.2.4 FT-MPI\n\nFT-MPI [Fagg and Dongarra, 2000] has been developed in the frame of the HARNESS [Micah, et al., 1999] metacomputing framework. The goal of FT-MPI is to offer to the end-user a communication library providing an MPI API, which benefits from the fault-tolerance in the HARNESS system. FT-MPI implements the whole MPI-1.2 specification, some parts of the MPI-2 document and extends some of the semantics of MPI for giving the application the possibility to recover from failed processes.\nFT-MPI claims it survives the crash of n-1 processes in an n-process job. The processes can be re-spawn if required. However, it is still the responsibility of the application to recover the data-structures and the data on the crashed processes. FT-MPI uses collective operation to assure\n\nFT-MPI contains the notion of two classes of participating processes within the recovery: Leaders and Peons. The leader tasks are responsible for synchronization, initiating the Recovery Phase, building and disseminating the new state atomically. The peons just follow orders from the leaders. In the event that a peon dies during the recovery, the leaders will restart the recovery algorithm. If the leader dies, the peons will enter an election controlled by the name service using an atomic test and set primitive. A new leader will restart the recovery algorithm. This process will continue either until the algorithm succeeds or until everyone has died [Fagg, et al., 2005].\n\n3.2.5 MPI/FT\n\nMPI/FT [Batchu, et al., 2001] uses a centralized coordinator that manages the fault tolerance mechanism in a transparent way. The coordinator runs in an nMR (n-Modular Redundancy) mode and has to monitor the application progress, act as a virtual channel routing every message transfer between process (much like the memory channels in MPICH-V1), recover faulty processes and replay messages from log to it until the faulty process reach a consistent state. Because of the centralized coordination scheme, the scalability of MPI/FT is limited.\n\n3.2.6 MPICH-Vx\n\nMPICH-V [Bouteiller, et al., 2006] is composed by a communication library based on MPICH and a runtime environment. MPICH-V runtime environment is a complex environment involving several entities: Dispatcher, Channel memories, Checkpoint servers, and Computing/Communicating nodes. Channel Memories are dedicated nodes providing a service of tunneling and repository. The architecture assumes neither central control nor global snapshots. The fault tolerance bases on an uncoordinated checkpoint protocol that uses centralized checkpoint servers to store communication context and computations independently.\nChapter 3\n\nMPICH-V comes in three flavors. MPICH-V1 [Bosilca, et al., 2002] is designed for very large scale computing using heterogeneous networks. Its fault tolerant protocol uses uncoordinated checkpoint and remote pessimistic message logging. MPICH-V1 well suited for Desktop Grids and Global computing as it can support a very high rate of faults, but requires a larger bandwidth for stable components to reach good performance.\n\nMPICH-V2 [Bouteiller, et al., 2003] is designed for homogeneous network large-scale computing (typically large clusters). Unlike MPICH-V1, it requires a small number of stable components to reach good performance on a cluster. It uses uncoordinated checkpoint protocol associated with sender based pessimistic message logging. Instead of channel memories, MPICH-V2 uses event loggers to assure the correct replace of messages during recovers. The computing node now keeps the message-log.\n\nMPICH-VCL is designed for extra low latency dependent applications. It uses coordinated checkpoint scheme based on the Chandy-Lamport algorithm [Chandy and Lamport, 1985] in order to eliminate overheads during fault free execution. However, it requires restarting all nodes (even non-crashed ones) in the case of a single fault. Consequently, it is less fault resilient than message logging protocols, and is only suited for medium scale clusters.\n\n3.2.7 LA-MPI\n\nLA-MPI [Graham, et al., 2003] has two primary goals: network fault tolerance and high performance. Network fault tolerance is achieved by implementing a checksum/retransmission protocol. The integrity of delivered data is (optionally) verified at the user-level using a checksum or CRC. Data that is corrupt (or never delivered) is retransmitted.\n\nLA-MPI offers a lightweight checksum/retransmission protocol, instead of the classic TCP/IP protocol. Such protocol allows the use of redundant data paths in the network leading to a high network bandwidth since different messages and/or message-fragments can be sent in parallel along different paths.\nCurrently LA-MPI delivers messages in the presence of I/O bus, network card and wire transmission errors, supports network card and path failures and guarantees delivery of in-flight messages after such a failure. Therefore, LA-MPI guarantees of end-to-end network fault tolerance for an MPI application. The fault-tolerance of application processes is not a feature in the current release.\n\n### 3.2.8 LAM/MPI\n\nThe LAM/MPI [Sankaran, et al., 2005] is an MPI implementation that allows MPI applications running to be checkpointed to disk and restarted later. LAM requires a third party single-process checkpoint/restart toolkit for actually checkpointing and restarting a single MPI process. Currently, LAM uses the Berkeley Labs Checkpoint/Restart package (Linux only) in order to implement a coordinated checkpoint protocol.\n\nThe approach adopted in LAM/MPI ensures that all the MPI communication channels between the processes are empty when at the checkpoint time. During restart, all the processes resume execution from their saved states, with the communication channels restored to their known (empty) states.\n\n### 3.2.9 MPICH-PCL\n\nMPICH-PCL is a very recent fault-tolerant MPI implementation that uses MPICH-2 as a standard message-passing platform [Coti, et al., 2006]. MPICH-PCL follows the same architecture model implemented in the MPICH-Vx versions. Therefore, it requires the use of dedicated elements for checkpoint and messaging management.\n\nMPICH2 is the MPI-2 implementation of Argonne National Laboratory [Argonne National Laboratory, 2007c]. MPICH-2 provides a platform to manage dynamic processes in the MPI Communication World. This feature makes MPICH-2 suitable to implement process migration and process recovery mechanisms.\n3.2.10 Open MPI\n\nOpen-MPI [Gabriel, et al., 2004] is a MPI-2 compliant implementation, produced by the combining technologies and resources from FT-MPI, LA-MPI, LAM/MPI, and PACX-MPI, in order to build an open source MPI library. Open-MPI claims to offer a combination of the best features from each one of these platforms, including fault tolerance for distributed parallel applications.\n\nCurrently, no Open-MPI distribution offers fault tolerance capabilities. The authors of Open MPI claim that this feature will be available in parallel projects but not in the trunk implementation [Open-MPI Project, 2007].\n\n3.3 Comparing the fault-tolerant MPI implementations\n\nWe compared the fault-tolerant MPI solutions present in this chapter using the four key features that we have elected for a modern fault tolerance scheme. Table 3-2 presents a summary of the implementation analyzed in this chapter. We use a + signal to indicate that the implementation fully attends and +/- signal to indicate that it partially attends to a requirement.\n\n<table>\n<thead>\n<tr>\n<th>Solution</th>\n<th>Scalable</th>\n<th>Fully Decentralized</th>\n<th>Transparent</th>\n<th>Flexible</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Cocheck</td>\n<td>+</td>\n<td>+/-</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Starfish</td>\n<td>+</td>\n<td>+/-</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Egida</td>\n<td>+</td>\n<td>+/-</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>FT-MPI</td>\n<td>+</td>\n<td>+/-</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>MPI/FT</td>\n<td>+</td>\n<td>+/-</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>MPICH-V1</td>\n<td>+</td>\n<td>+</td>\n<td>+</td>\n<td></td>\n</tr>\n<tr>\n<td>MPICH-V2</td>\n<td>+</td>\n<td>+</td>\n<td>+</td>\n<td></td>\n</tr>\n<tr>\n<td>LA-MPI</td>\n<td>+</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>LAM/MPI</td>\n<td>+</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>MPICH-PCL</td>\n<td>+</td>\n<td>+</td>\n<td>+</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nAs one can see, although all solutions are transparent to the user, none of them simultaneously presents the four features. Such lack of a fault-tolerant solution that could simultaneously present all four features has led us to the development of a new architecture, which we present in the next chapter.\nChapter 4\nThe RADIC Architecture\n\nIn Chapter 3, we analyzed several recent fault-tolerant message-passing implementations. The lack of a solution that simultaneously offers scalability, flexibility, transparency and decentralization has guided us in the development of a new fault-tolerant architecture, the Redundant Array of Independent Fault Tolerance Controllers - RADIC.\n\nAs any fault-tolerant solution for message-passing systems, the main goal of RADIC is to assure that a parallel-distributed application will correctly finish even if faults occur in some nodes of the parallel computer. Additionally, RADIC simultaneously attends to the four key features described in Table 4-1.\n\nIn this chapter, we first present the system model of the RADIC architecture. Then, we describe the RADIC functional phases and functional elements that compose the RADIC fault tolerance distributed controller. Next, we explain the RADIC operation. Finally, we describe the RADIC functional parameters and evaluate the configuration aspects of RADIC.\n\n4.1 RADIC architecture model\n\nRADIC establishes an architecture model that defines the interaction of the fault-tolerant architecture and the parallel computer’s structure. Figure 4-1 depicts how the RADIC architecture interacts with the structure of the parallel computer (in the lower level) and with the parallel application’s structure (in the higher level). RADIC implements two levels between the MESSAGE-PASSING level and the computer structure. The lower level implement the fault tolerance mechanism and the higher level implements the fault masking and message delivering mechanism.\n<table>\n<thead>\n<tr>\n<th>Feature</th>\n<th>How it is achieved</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Transparency</td>\n<td>− No human intervention is required to manage the failure</td>\n</tr>\n<tr>\n<td></td>\n<td>− No change in the application code</td>\n</tr>\n<tr>\n<td>Decentralization</td>\n<td>− No central or fully dedicated resource is required. All nodes</td>\n</tr>\n<tr>\n<td></td>\n<td>may be simultaneously used for computation and protection</td>\n</tr>\n<tr>\n<td>Scalability</td>\n<td>− The operation is not affected by the number of nodes in the parallel computer</td>\n</tr>\n<tr>\n<td>Flexibility</td>\n<td>− Fault tolerance parameters may be adjusted according to application requirements</td>\n</tr>\n<tr>\n<td></td>\n<td>− The fault-tolerant architecture may change for better adapting to the parallel computer structure and to the fault pattern</td>\n</tr>\n</tbody>\n</table>\n\nThe core of the RADIC architecture is a fully distributed controller for fault tolerance that automatically handles faults in the cluster structure. Such controller shares the parallel computers resources used in the execution of the parallel application. The controller is also capable to handle its structure in order to survive to failures.\n\nThe operation of RADIC relies on some operational models: the parallel application model, the parallel computer model and the fault pattern. These models establish the premises that rule the operation of the RADIC fault tolerance mechanism.\n4.1.1 Distributed parallel application model\n\nA distributed parallel application consists of a set of concurrent processes that cooperate with each other to perform a task. The processes communicate only using a message-passing standard. Therefore, since our model considers that received messages are the only nondeterministic event, we model each process as a sequence of state intervals, each interval started by a received message.\n\nExecution inside each interval is deterministic, i.e., if a process starts from the same state and receives the same sequence of messages at the same points within the execution, then this process will always generate the same results.\n\nCommunication channels and process are both synchronous [Jalote, 1994]. By synchronous we mean that whenever an element is working correctly, it always will perform its intended function in a finite and known (or predictable) time bound. Therefore, every communication channel will have a latency bound and every process will execute each of their state intervals in a time bound.\n\n4.1.2 Parallel computer model\n\nThe distributed parallel application has P processes, and runs in a parallel computer with N nodes. In failure-free executions, all the N nodes are available. The application will endure a maximum number of failed nodes without collapsing. Processes from failed nodes will recover in some survivor node.\n\nThe communication network is fully connected, i.e., a process in a node can send a message to any other process. The network delivers messages in FIFO order. A channel represents the logical connection between two processes. A communication failure between two nodes is the event used to define a node failure.\n\nThe minimum structure required to maintain the parallel application running defines the maximum number of failures that the system can bear. Therefore, the requirements of the parallel application, i.e., the user requirements, are determinant to decide the maximum number of failures the system will support. A typical requirement could be the time when the application must complete. In such cases, the\nmaximum number of faults is one that does not reduce the computational power beyond a minimum that neither compromises the application execution time nor compromises the functionality of the fault tolerance controller.\n\n### 4.1.3 Failure pattern\n\nWe assume that the probability of failures in the nodes follows a Poisson distribution. This assumption is accurate if we consider that:\n\n- the chance that a failure occurs in a time interval is proportional to the interval size;\n- the probabilities of failure of each node are independent;\n- the probability of multiple failures in a given interval is much smaller than the probability of a single failure.\n\nBasing on these assumptions, we establish that if a node fails, all elements involved in the recovery of the failed processes will survive until the end of the recovery procedure. In other words, if two or more failures occur concurrently, none of them affects the elements implicated in the recovery of the other failures while the recovering procedure occurs.\n\nSimilarly, any number of failures may occur if each failure does not affect an element implicated in the recovery of a previous failure.\n\n### 4.2 RADIC functional phases\n\nIn the Chapter 2, we explained the theoretical bases that driven the adoption of the pessimistic log-based protocol for the RADIC rollback-recovery mechanism.\n\nAs a transparent fault tolerance system, i.e., a system that can handle faults without human intervention, RADIC automatically performs a group of activities required by its rollback-recovery protocol. Each activity is inside one of the four general procedures required by an automatic fault tolerance mechanism, as described in Table 4-2.\n### Table 4-2: Operational phases of RADIC\n\n<table>\n<thead>\n<tr>\n<th>Functional phase</th>\n<th>Activity</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Sate saving</td>\n<td>− Storage checkpoints</td>\n</tr>\n<tr>\n<td></td>\n<td>− Storage message logs</td>\n</tr>\n<tr>\n<td></td>\n<td>− Garbage collection</td>\n</tr>\n<tr>\n<td>Failure detection</td>\n<td>− Monitor nodes using a heartbeat watchdog mechanism</td>\n</tr>\n<tr>\n<td>Recovering</td>\n<td>− Restart failed processes from their most recent checkpoints</td>\n</tr>\n<tr>\n<td></td>\n<td>− Replay messages from the message log</td>\n</tr>\n<tr>\n<td>Fault masking</td>\n<td>− Assure that survivor processes can reach the recovered processes</td>\n</tr>\n</tbody>\n</table>\n\nSuch phases occur concurrently with the parallel application execution and do not interfere in its results. Actually, the RADIC implementation operates as a parallel-distributed application that runs concurrently and shares the same resources used by the user’s parallel application.\n\n### 4.3 RADIC functional elements\n\nThe structure of the RADIC architecture uses a group of processes that collaborate in order to create a distributed controller for fault tolerance. There are two classes of processes: protectors and observers. Every node of the parallel computer has a dedicated protector and there is a dedicated observer attached to every parallel application’s process.\n\n#### 4.3.1 Protectors\n\nThere is a protector process in each node of the parallel computer. Each protector communicates with two neighbors: an antecessor and a successor. Therefore, all protectors establish a protection chain throughout the nodes of the parallel computer. In Figure 4-2, we depict a simple cluster built using nine nodes (N₀-N₈) and the respective protectors of each node (T₀-T₈). The arrows indicate the antecessor→successor relationship.\nFigure 4-2: An example of Protectors (T₀-T₇) in a cluster with nine nodes. Green arrows indicate the antecessor–successor communication.\n\nThe relationship between neighbor protectors exists because the fault detection procedure. There is a heartbeat/watchdog mechanism between two neighbor protectors: one has the watchdog and receives heartbeats from the other. By definition, the protector who has the watchdog is the antecessor and the protector who sends the heartbeats is the successor.\n\nThe arrows in Figure 4-2 indicate the orientation of the heartbeat signals from the successor to the antecessor. Actually, each successor has a double identity because it acts simultaneously as a successor for a neighbor and as an antecessor for the other\nneighbor. For example, in Figure 4-2, the protector $T_7$ is the antecessor of the protector $T_8$ and the successor of the protector $T_6$.\n\nEach protector executes the following tasks related to the operation of the rollback-recovery protocol:\n\na) It stores checkpoints and message-logs from the application processes those are running in its successor node;\n\nb) It monitors its neighbors in order to detect failures via a heartbeat/watchdog scheme;\n\nc) It reestablishes the monitoring mechanism with a new neighbor after a failure in one of its current neighbors, i.e., it reestablishes the protection chain;\n\nd) It implements the recovery mechanism.\n\n4.3.2 Observers\n\nObservers are RADIC processes attached to each application processes. From the RADIC operational point-of-view, an observer and its application process compose an inseparable pair.\n\nThe group of observers implements the message-passing mechanism for the parallel application. Furthermore, each observer executes the following tasks related to fault tolerance:\n\na) It takes checkpoints and message-logs of its application process and send them to a protector running in another node, namely the antecessor protector;\n\nb) It detects communication failures with another processes and with its protector;\n\nc) In the recovering phase, it manages the messages from the message log of its application process and establishes a new protector;\n\nd) It maintains a mapping table indicating the location of all application processes and their respective protectors and updates this table in order to mask faults.\n4.3.3 The RADIC controller for fault tolerance\n\nThe collaboration between protectors and observers allows the execution of the phases of the RADIC controller. Figure 4-3 depicts the same cluster of Figure 4-2 with all elements of RADIC, as well as their relationships. The arrows in the figure represent only the communications between the fault-tolerance elements. The communications between the application processes does not appear in the figure because they relate to the application behavior.\n\nEach observer has an arrow that connects it to a protector, to whom it sends checkpoints and message logs of its application process. Such protector is the antecessor of the local protector. Therefore, by asking to the local protector who is the antecesor protector, an observer can always know who its protector is.\n\nEach protector has an arrow that connects it to an antecesor protector. Similarly, it receives a connection from its successor. A protector only communicates with their immediate neighbors. For example, in Figure 4-3, the protector $T_5$ communicate only with $T_4$ and $T_6$. It will never communicate with $T_3$, unless $T_4$ fails and $T_3$ becomes its new immediate neighbor.\n\nThe RADIC controller uses the receiver-based pessimistic log rollback-recovery protocol to handle the faults in order to satisfy the scalability requirement. As explained in the end of Chapter 2, this protocol is the only one in which the recover mechanism does not demand synchronization between the in-recovering process and the processes not affected by the fault. Such feature avoids that the scalability suffer with the operation of the fault tolerance mechanism.\nThe RADIC Architecture\n\n\n\nTable 4-3 explains how each RADIC element acts in each functional phase of the RADIC fault-tolerant architecture using the receiver-based pessimistic log rollback-recovery protocol.\n\nBesides the fault tolerance activities, the observers are responsible to manage the message-passing mechanism. This activity rests on a mapping table that contains all\ninformation required to the correct delivery of a message between two processes. Protectors do not participate in the message-passing mechanism.\n\n<table>\n<thead>\n<tr>\n<th>Table 4-3: The role of each RADIC element in the phases of fault tolerance</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>RADIC element</strong></td>\n</tr>\n<tr>\n<td>-------------------</td>\n</tr>\n<tr>\n<td><strong>Functional phase</strong></td>\n</tr>\n<tr>\n<td>State saving</td>\n</tr>\n<tr>\n<td></td>\n</tr>\n<tr>\n<td>Failure detection</td>\n</tr>\n<tr>\n<td></td>\n</tr>\n<tr>\n<td></td>\n</tr>\n<tr>\n<td>Recovery</td>\n</tr>\n<tr>\n<td></td>\n</tr>\n<tr>\n<td>Fault masking</td>\n</tr>\n</tbody>\n</table>\n\n4.4 RADIC operation\n\nThe RADIC distributed controller concurrently executes a set of activities related to the fault tolerance. Besides these fault tolerance activities, the controller also implements the message-passing mechanism for the application processes.\n\n4.4.1 Message-passing mechanism\n\nThe message-passing mechanism is an observers’ attribution. The protectors do not play any role in this mechanism.\n\nIn the RADIC message-passing mechanism, an application process sends a message through its observer. The observer takes care of delivering the message through the communication channel. Similarly, all messages that come to an application process must first pass through its observer. The observer then delivers the message to the application process. Figure 4-4 clarifies this process.\nTo discover the address of a destination process, each observer uses a routing table, called \\textit{radictable}, which relates the identification of the destination process inside the application level with the identification of the destination process inside the communication level. Table 4-4 represents a typical \\textit{radictable}.\n\n<table>\n<thead>\n<tr>\n<th>Process identification</th>\n<th>Address</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>Node 0</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Node 1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Node 2</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Node 3</td>\n</tr>\n<tr>\n<td>...</td>\n<td>...</td>\n</tr>\n</tbody>\n</table>\n\n### 4.4.2 State saving phase\n\nIn this phase, protectors and observers collaborate in order to save snapshots of the parallel application’s state. This phase is the major responsible for resources consumed by the fault tolerance mechanism as well as for the enlargement in the execution time in the absence of failures.\nThe system must supply storage space for the checkpoints and the message-logs required by the rollback-recovery protocol. Furthermore, the checkpoint procedure introduces a time delay in the computation because a process may suspend its operation while the checkpoint occurs.\n\nAdditionally, the message-log interferes in the message latency, because a process only considers a message delivered after the message is stored in the message log.\n\n**Checkpoints**\n\nEach observer takes checkpoints of its application process, as well as of itself, and sends them to the protector located in its ancestor node. Figure 4-5 depicts a simplified scheme to clarify the relationship between an observer and its protector.\n\nA checkpoint is an atomic procedure and a process become unavailable to communicate while a checkpoint procedure is in progress. This behavior demands that the fault detection mechanism differentiates a communication failure caused by a real failure from a communication failure caused by a checkpoint procedure. We explain this differentiation in paragraph 4.4.3.\n\n\n\nThe protectors operate like a distributed reliable storage. The reliability is achieved because the checkpoints and message logs of a process are stored in a\ndifferent node, similar to a RAID-1 scheme [Patterson, *et al.*, 1988]. Therefore, if a process fails, all information required to recover it is in a survivor node.\n\nThe difference between the legacy RAID-1 scheme and the redundant scheme implement in RADIC is that RADIC replicates processes’ states and message logs instead of crude data chunks. Actually, RADIC takes care of saving the computation done by a process until a given time.\n\nThanks to the uncoordinated checkpoint mechanism of the pessimistic message-log rollback-recovery protocol used by RADIC, each observer may establish an individual checkpoint policy for its application process. Such policy may be time-driven or event-driven. The RADIC architecture allows the implementation of any combination of these two policies.\n\nThe time-driven policy is very typical in the fault-tolerant implementations based on rollback-recovery. In this policy, each observer has a checkpoint interval that determines the times when the observer takes a checkpoint.\n\nThe event-driven policy defines a trigger that each observer uses in order to start the checkpoint procedure. A typical event-driven policy occurs when two or more observers coordinate their checkpoints. Such policy is useful when two processes have to exchange many messages. In this case, because the strong interaction between the processes, coordinate the checkpoint is a good way to reduce the checkpoint intrusion over the message exchanging.\n\nWhen an observer takes a checkpoint of its process, this checkpoint represents all computational work done by such process until that moment. Is such computational work that the observer sends to the protector. As the process continues its work, the state saved in the protector becomes obsolete. To make possible the reconstruction of the process’ state in case of failure, the observer also logs in to its protector all messages its process has received since its last checkpoint. Therefore, the protector always has all information required to recover a process in case of a failure, but such state’s information is always older than the current process’ state.\nMessage logs\n\nBecause the pessimistic log-based rollback-recovery protocol, each observer must log all messages received by its application process. As we have explained in Chapter 2, the use of message logs together with checkpoint optimizes the fault tolerance mechanism by avoiding the domino effect and by reducing the amount of checkpoints that the system must maintain.\n\nThe message log mechanism in RADIC is very simple: the observer resends all received messages to its protector, which saves it in a stable storage. The log procedure must complete before the sender process considers the message as delivered. Figure 4-6 depicts the message’s delivery mechanism and message’s log mechanism.\n\nThe log mechanism enlarges the message latency perceived by the sender process, because it has to wait until the protector concludes the message log procedure in order to consider the message as delivered.\n\nGarbage collection\n\nThe pessimistic message log protocol does not require any synchronization between processes. Each observer is free to take checkpoints of its process without caring about what is happening with other parallel application’s process.\nThis feature greatly simplifies the construction of the garbage collector by the protectors. Because each checkpoint represents the current state of a process, whenever a new checkpoint comes from an observer, the protector may discard all prior checkpoints and message-logs related to that process. Therefore, after a protector receives a new checkpoint from a process, it automatically eliminates the older checkpoint of this process.\n\n4.4.3 Failure detection phase\n\nThe failure detection is an activity performed simultaneously by protectors and observers. Each one performs specific activities in this phase, according to its role in the fault tolerance scheme.\n\nHow protectors detect failures\n\nThe failure detection procedure contains two tasks: a passive monitoring task and an active monitoring task. Because of this, each protector has two parts: it is, simultaneously, antecessor of one protector and successor of other.\n\nThere is a heartbeat/watchdog mechanism between two neighbors. The antecessor is the watchdog element and the successor is the heartbeat element. Figure 4-7 represents the operational flow of each protector element.\n\nA successor regularly sends heartbeats to an antecessor. The heartbeat/watchdog cycle determines how fast a protector will detect a failure in its neighbor, i.e., the response time of the failure detection scheme. Short cycles reduce the response time, but also increase the interference over the communication channel. Figure 4-8 depicts three protectors and the heartbeat/watchdog mechanism between them.\n\nA node failure generates events in the node’s antecessor and in the node’s successor. If a successor detects that its antecessor has failed, it immediately starts a search for a new antecessor. The search algorithm is very simple. Each protector knows the address of its antecessor and the address of the current antecessor of its antecessor. Therefore, when an antecessor fails, the protector know exactly who its new antecessor will be.\nAn antecessor, in turns, begins to wait for a new successor detects a failure in its current successor. Furthermore, the antecessor also starts the recovering procedure, in order to recover the faulty processes that were running in the successor node.\n\n**Figure 4-7: Protector algorithms for antecessor and successor tasks**\n\n*How protectors deal with Byzantine problems*\n\nAs explained in the previous topic, when a node fails two neighbor protectors of the faulty node detect such failure: the antecessor and the successor of the failed node. Depending on the network’s topology of the parallel computer, the communication paths from a node to its antecessor may be distinct of the communication path from this node to its successor.\nFor example, in the configuration depicted in Figure 4-8, the protector $T_X$ and $T_Z$ will detect a failure in $T_Y$. If there is a communication problem between $T_Y$ and $T_Z$ but the communication between $T_X$ and $T_Y$ is fine, then $T_Y$ and $T_Z$ will have to agree about the failure (Figure 4-9a.) Such situation can be treated as a Byzantine problem [Lamport, et al., 1982].\n\n\n\nTo deal with such problem, when a protector detects a failure in its antecessor neighbor, it marks this antecessor as a suspect and contacts the suspect’s antecessor in order to confirm the suspect’s status. Then, according to the status received from the suspect’s antecessor, the protector takes one the following actions:\n\na) If there is no answer, then the protector sends a suicide command to the local observers and then terminates, because it assumes that its node has a communication problem;\n\nb) If the suspect’s antecessor answers that the suspect is fine, then the protector assumes that it has a communication problem with its antecessor and does the same as described above in paragraph (a);\n\nc) If the suspect’s antecessor confirms that the suspect failed, then the protector fetches a new antecessor and sends a checkpoint command to the local observers;\n\nFigure 4-9a shows the communication problem between $T_Z$ and its antecessor $T_Y$, but each one keeps communicating with other neighbors. According to what we explained before, $T_Z$ commits suicide because its antecessor is fine (Figure 4-9b.)\nConcurrently, $T_W$ fetches a new antecessor. Figure 4-10 represents the activities a protector performs to deal with the Byzantine problems.\n\n\n\nFigure 4-9: $T_x$ is the antecessor of $T_Y$, $T_Y$ is the antecessor of $T_Z$ and so on. (a) Communication failure between $T_Y$ and $T_Z$ generates a Byzantine problem. (b) $T_Z$ has committed suicide and $T_W$ connects to $T_Y$.\n\n**How the observers detect failures**\n\nEach observer relates with two classes of remote elements: its protector and the other application processes. An observer detects failures either when the communication with other application processes fails or when the communication with its protector fails. However, because an observer just communicates with its protector when it has to do a checkpoint or a message log, an additional mechanism shall exist to certify that an observer will quickly perceive that its protector has failed.\n\nRADIC provides such mechanism using a warning message between the observer and the local protector (the protector that is running in the same node of the observer). Whenever a protector detects a fail in its antecessor, such protector sends a warning message to all observers in its nodes because it knows that the failed antecessor is the protector that the local observers are using to save checkpoints and message logs.\nWhen an observer receives such message, it immediately establishes a new protector and takes a checkpoint.\n\n\n\n**Figure 4-10: How a protector deals with Byzantine problems**\n\n**How the observers confirm a failure**\n\nThere are two situations which create a communication failure between application processes, but that must not indicate a node failure. The first failure situation occurs when an observer is taking a checkpoint of its application process. The second occurs when a process fails and restarts in a different node.\n\nIn this paragraph, we explain how the observers get rid of the first problem. We will explain how the observer gets rid of the second situation in the description of the Fault Masking Phase.\nA process becomes unavailable to communicate inside the checkpoint procedure. Such behavior could cause that a sender process interprets the communication failure caused by the checkpoint procedure as a failure in the destination.\n\nIn order to avoid this fake failure detection, before a sender observer assumes a communication failure with a destination process, the sender observer contacts the destination’s protector and asks about the destination’s status. To allow that each observer knows the location of the protector of the other process, the radictable now includes the address of the destination’s protector, as shown in Table 4-5.\n\n<table>\n<thead>\n<tr>\n<th>Process identification</th>\n<th>Address</th>\n<th>Protector (antecessor address)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>Node 0</td>\n<td>Node 8</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Node 1</td>\n<td>Node 0</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Node 2</td>\n<td>Node 1</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Node 3</td>\n<td>Node 2</td>\n</tr>\n<tr>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n</tr>\n</tbody>\n</table>\n\nAnalyzing Table 4-5, one may see that the protector in node eight protects the processes in node zero, the protector in node zero protects processes in node one and so forth.\n\nUsing its radictable, any sender observer may locate the destination’s protector. Since the destination’s protector is aware about the checkpoint procedure of the destination process, it will inform the destination’s status to the sender observer. Therefore, the sender observers can discover if the communication failure is consequence of a current checkpoint procedure.\n\nThe radictable and the search algorithm\n\nWhenever an observer needs to contact another observer (in order to send a message) or an observer’s protector (in order to confirm the status of a destination), this observer will look for the address of the element in its radictable. However, after\na failure occurs, the radictable of an observer becomes outdated, because the address of the recovered process and their respective protectors changed.\n\nTo face this problem, each observer uses a search algorithm for calculates the address of failed elements. This algorithm relies on the determinism of the protection chain. Each observer knows that the protector of a failed element (observer or protector) is the antecessor of this element. Since a antecessor is always the previous element in the radictable, whenever the observer needs to find an element it simply looks the previous line in its radictable, and finds the address of the element. The observer repeats this procedure until it finds the element it is looking for.\n\n*Practical issues about the heartbeat/watchdog cycle*\n\nThe heartbeat/watchdog mechanism of RADIC transmits information throughout the communication channel and generates a communication traffic that affects the network bandwidth. The solution to reduce the traffic generated by the heartbeats is to enlarge the heartbeat cycle, therefore reducing the amount of information that watchdog/heartbeat mechanism transmits.\n\nHowever, an enlargement in the heartbeat cycle reduces the sensibility of the failure detection mechanism; because the watchdog will take more time to detect a heartbeat missing. For example, if the heartbeat cycle is three seconds, in worst case the watchdog will take three seconds to warn about a problem. If we enlarge the cycle in order to reduce the network implication, let us say to nine seconds, the system will take three times more time to warn about a problem.\n\n4.4.4 Recovery phase\n\nIn normal operation, the protectors are monitoring computer’s nodes, and the observers care about checkpoints and message logs of the distributed application processes. Together, protectors and observers function like a distributed controller for fault tolerance.\n\nWhen protectors and observers detect a failure, both actuate to reestablish the consistent state of the distributed parallel application and to reestablish the structure of the RADIC controller.\nReestablishing the RADIC structure after failures\n\nThe protectors and observers implicated in the failure will take simultaneous atomic actions in order to reestablish the integrity of the RADIC controller’s structure. Table 4-6 explicates the atomic activities of each element.\n\nWhen the recovery phase is finished, the RADIC controller’s structure is reestablished and henceforth is ready to manage new failures. Figure 4-11 presents the configuration of a cluster from a normal situation until the recovery phase has finished.\n\nRecovering failed application processes\n\nThe protector that is the antecessor of the failed node recovers the failed application processes in the same node in which the protector is running. Immediately after the recovery, each observer connects to a new protector. This new protector is the antecessor of the node in which the observer recovers. The recovered observer gets the information about its new protector from the protector in its local node. Indeed, the protector of any observer is always the antecessor of the node in which the observer is running.\n\n<table>\n<thead>\n<tr>\n<th>Table 4-6: Recovery activities performed by each element implicated in a failure.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Protectors</strong></td>\n</tr>\n<tr>\n<td>Successor:</td>\n</tr>\n<tr>\n<td>1) Fetches a new antecessor</td>\n</tr>\n<tr>\n<td>2) Reestablishes the heartbeat mechanism</td>\n</tr>\n<tr>\n<td>3) Commands the local observers to checkpoint</td>\n</tr>\n<tr>\n<td>Antecessor:</td>\n</tr>\n<tr>\n<td>1) Waits for a new successor</td>\n</tr>\n<tr>\n<td>2) Reestablishes the watchdog mechanism</td>\n</tr>\n<tr>\n<td>3) Recovers the failed processes</td>\n</tr>\n</tbody>\n</table>\nFigure 4-11: Recovering phases in a cluster. (a) Failure free cluster. (b) Fault in node N3. (c) Protectors T2 and T4 detect the failure and reestablish the chain, O4 connects to T2. (d) T2 recovers P3/O3 and O3 connects to T1.\nLoad balance after recovering from faults\n\nAfter recovering, the recovered process is running in the same node of its former protector. It means that the computational load increases in such node, because it now contains its original application processes plus the recovered processes. Therefore, the original load balancing of the system changes.\n\nRADIC make possible the implementation of several strategies to face the load balance problem after process recovery. A possible strategy is to implement a heuristic for load balance that could search a node with lesser computational load. Therefore, instead of recovering the faulty process in its own node, a protector could send the checkpoint and the message logs of the faulty processes to be recovered by a protector in a node with less computational load.\n\n4.4.5 Fault masking phase\n\nThe fault masking is an observers’ attribution. The observers assure that the processes continue to correctly communicate through the message-passing mechanism, i.e., the observers create a virtual machine in which failures does not affect the message-passing mechanism.\n\nIn order to perform this task, each observer manages all messages sent and received by its process. An observer maintains, in its private radictable, the address of all logical processes or the parallel application associated with their respective protectors. Using the information in its radictable, each observer uses the search algorithm, explained in paragraph 4.4.3, to locate the recovered processes.\n\nSimilarly, each observer records a logical clock in order to classify all messages delivered between the processes. Using the logical clock, an observer easily manages messages sent by recovered processes.\n\nTable 4-7 represents a typical radictable including the logical clocks. One can see that the observer that owns this table has received three messages from the process zero and has sent two messages to this process. Similarly, the process has received one message and sent one message to process three.\nTable 4-7: The radictable of an observer in the cluster in Figure 4-3.\n\n<table>\n<thead>\n<tr>\n<th>Process id.</th>\n<th>Address</th>\n<th>Protector (antecessor addr.)</th>\n<th>Logical clock for sent messages</th>\n<th>Logical clock for recv. messages</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>Node 0</td>\n<td>Node 8</td>\n<td>2</td>\n<td>3</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Node 1</td>\n<td>Node 0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Node 2</td>\n<td>Node 1</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Node 3</td>\n<td>Node 2</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n<td>...</td>\n</tr>\n</tbody>\n</table>\n\n**Locating recovered process**\n\nWhen a node fails, the antecessor neighbor of the faulty node - which executes the watchdog procedure and stores checkpoints and message-logs of the processes in the faulty node – detects the fail and starts the recovering procedure. Therefore, the faulty processes now restart their execution in the node of the antecessor, resuming since their last checkpoint.\n\nIn order to clarify the behavior of a recovered process, in Figure 4-12 we represent four nodes of Figure 4-3 and the final configuration after a failure in one of these nodes. The process P₃ that was originally in the faulty node N₃ is now running in the node N₂. Therefore, all other processes have to discover the new location of P₃.\n\n\nIn the explanation of the Fault Detection Phase, we defined two situations that create fake fault detection. The first situation occurs when an observer is taking a checkpoint of its application process, making this process unavailable to communicate. We described the solution for this problem in the Fault Detection Phase. Now, we describe the second situation and the solution for it.\n\nAfter a node failure, all future communications to the processes in this node will fail. Therefore, whenever an observer tries to send a message to a process in a faulty node, this observer will detect a communication failure and start the algorithm to discover the new destination location.\n\n\n\nFigure 4-13 describes the algorithms used by an observer if it acts as sender or as a receiver. An observer uses the search algorithm only the communication fails when it is sending a message to another process. If the failure occurs while the process is\nreceiving a message, the observer simply aborts the communication because it knows that the faulty sender we restart the communication after it has recovered.\n\nThe search algorithm used by the sender observer uses the protector of the receiver process to inform the status of the receiver. However, if the receiver has recovered from a fault, its protector now is the antecessor of its original protector, because the recovered observer is now running in the same node of its original protector.\n\nThe example in Figure 4-12 clarifies the location of the recovered process P₃ after a failure in node N₃. The new protector of P₃ is now T₁, because P₃ currently is running in the same node of its original protector T₂.\n\nIf some observer tries to communicate with the faulty process P₃, such observer will obtain a communication error and will ask to the protector T₂ about the status of P₃. In this case, T₂ informs that it is not responsible for P₃ (because T₁ is now the current protector of P₃).\n\nIn order to find who the current protector of P₃ is, the sender observer uses its radictable to follow the protector chain. The sender observer knows that if T₂ is no more protecting P₃, then the probable protector of P₃ shall be the antecessor of T₂ in the protector chain (because a faulty process always recover in the antecessor neighbor node).\n\nTherefore, the sender observer reads its radictable and calculates the protector who is the antecessor of the protector T₂. In our example, the antecessor of the protector T₂ is the protector T₁. In the radictable the order of the protectors in the chain naturally follows the same order of the table index. Therefore, the antecessor of a node is always the node in the previous line of the table, as shown in Table 4-8.\n\n<table>\n<thead>\n<tr>\n<th>Process identification</th>\n<th>Address</th>\n<th>Protector (antecessor address)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Node 1</td>\n<td>Node 0</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Node 2</td>\n<td>Node 1</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Node 3</td>\n<td>Node 2</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Node 4</td>\n<td>Node 3</td>\n</tr>\n</tbody>\n</table>\nNow that the sender observer knows who the probable protector of the receiver process $P_3$ is, it contacts such protector and asks about the status of $P_3$. If the protector confirms the location of $P_3$, the sender observer updates its *radictable* and restarts the communication process. Otherwise, the sender observer continues to follows the protection chain and asks for the next antecessor about $P_3$, until it finds where the process $P_3$ is.\n\n<table>\n<thead>\n<tr>\n<th>Process identification</th>\n<th>Address</th>\n<th>Protector (antecessor address)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Node 1</td>\n<td>Node 0</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Node 2</td>\n<td>Node 1</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Node 2</td>\n<td>Node 1</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Node 4</td>\n<td>Node 3</td>\n</tr>\n</tbody>\n</table>\n\nIn our example, the updated *radictable* of a process who tries to communicate with the recovered process $P_3$ has the information presented in Table 4-9. In this table, the line three of the *radictable* (represent with bold font) represents the update location of process $P_3$ together with its new protector.\n\n*Managing messages of recovered process*\n\nAn application process recovers from its earlier checkpoint and resumes its execution from that point. If the process has received messages since its earlier checkpoint, those messages are in its current message log. The process’ observer uses such message log to deliver the messages required by the recovered process.\n\nIf the recovered process resend messages during the recovery process, the destination observers discard such repeated messages. Such mechanism is simple to implement by using a logical clock. Each sender includes a logical time mark that identifies the message’s sequence for the receiver. The receiver compares the time mark of the received message against the current time mark of the sender. If the\nreceived message is older than the current time mark from the specific sender, the receiver simply discards the message.\n\nThe observers discard the repeated messages received from recovered processes. However, a recovered process starts in a different node from the ones in which it was before the failure. Therefore, it is necessary to make the observers capable to discover the recovered processes’ location.\n\nAn observer starts the mechanism used to discover a process’s location whenever a communication between two processes fails. Each observer involved in the communication uses the mechanism according to its role in the communication. If the observer is a receiver, it simply waits for the sender recovering.\n\nOn the other hand, if the observer is a sender it will have to search for the failed receiver in another node. The searching procedure starts by asking the receiver’s status to the protector of the failed receiver. When the protector answers that the failed receiver is ready, the sender updates the location of the failed process and restart the communication.\n\n4.5 RADIC functional parameters\n\nThe RADIC controller allows the setup of two time parameters: the checkpoint interval and the watchdog/heartbeat cycle.\n\nTo choose the optimal checkpoint interval is a difficult task. The interaction between the application and the checkpoints determines the enlargement of the application execution time. The literature related to checkpoints contains several studies about how to estimate the optimal checkpoint interval in order to minimize the application run time in the absence of failures [Daly, 2006; Duda, 1983; Gelenbe, 1979]. Other works investigated the checkpoints under a practical point of view [Mandal and Mukhopadhyaya, 2003; Plank and Thomason, 2001; Ziv and Bruck, 1996].\n\nUsing the interaction between the observers and the parallel application processes, the RADIC controller allows the implementation of any checkpoint\ninterval policy. Each observer can calculate the optimal checkpoint interval by using a heuristic based in some local or distributed information. Furthermore, the observer may adjust the checkpoint interval during the process’ execution.\n\nThe watchdog/heartbeat cycle, associated with the message latency, defines the sensitivity of the failure detection mechanism. When this cycle is short, the neighbors of the failed node will rapidly detect the failure and the recovery procedure will quickly start. However, a very short cycle is inconvenient because it increases the number of control messages and, consequently, the network overhead. Furthermore, short cycles also increase the system’s sensibility regards the network latency.\n\nThe setting of the RADIC parameters, in order to achieve the best performance of the fault tolerance scheme, is strongly dependent of the application behavior. The application’s computation-to-communication pattern plays a significant role in the interference of the fault-tolerant architecture on the parallel application’s run time. For example, the amount and size of the messages directly define the interference of message log protocols.\n\n4.6 RADIC flexibility\n\nThe impact of each parameter over the overall performance of the distributed parallel application strongly depends of the details of the specific RADIC implementation and the architecture of the parallel computer. Factors like network latency, network topology or storage bandwidth are extremely relevant when evaluating the way the fault-tolerant architecture affects the application.\n\nThe freedom to adjust of the fault tolerance parameters individually for each application process is one of the functional features that contribute to the flexibility of the RADIC architecture. Additionally, two features play an important role for the flexibility of RADIC: the ability to support concurrent failures and the structural flexibility.\n4.6.1 Concurrent failures\n\nIn RADIC, a recover procedure is complete after the recovered process establishes a new protector, i.e., only after the recovered process has a new protector capable to recover it. In other words, the recover procedure is complete when the recovered process has done its first checkpoint in the new protector.\n\nRADIC assumes that the protector that is recovering a failed process never fails before the recovery completion. We have argued in paragraph 4.1.3 that the probability of failure of an element involved in the recovery of a previous failure in other element is negligible. Nevertheless, the RADIC architecture allows the construction of an $N$-protector scheme in order to manage such situation.\n\nIn such scheme, each observer would transmit the process’ checkpoints and the message logs to $N$ different protectors. If a protector fails while it is recovering a failed application process, another protector would assume the recovering procedure.\n\nFor example, in the cluster of Figure 16, if the node $N_2$ fails before the recovery of $P_3$, the system will collapse. To solve this situation using a 2-protector scheme, each observer should store the checkpoints and message-logs of its process in two protectors. In Figure 16, this would mean that $O_3$ should store the checkpoints and message-logs of $P_3$ in $T_2$ and in $T_1$. Therefore, $T_1$ will recover $P_3$ in case of a failure in $T_2$ while it is recovering the process $P_3$.\n\n4.6.2 Structural flexibility\n\nAnother important feature of the RADIC architecture is the possibility of assuming different protection schemes. Such ability allows implementing different fault tolerance structures throughout the nodes, in addition to the classical single protectors’ chain.\n\nTwo immediate advantages of the structural flexibility of RADIC are the possibility of using spare nodes and the clustering of protector’s chain. In the first case, the parallel computer might have one or more spare nodes. Such nodes would assume the faulty processes in order to maintain the same number of computational\nnodes. Therefore, the computational power remains the same the system had before the failure.\n\nIn the second case, the system would have several independent chains of protectors. Therefore, each individual chain would function like an individual RADIC controller and the traffic of fault tolerance information would be restricted to the elements of each chain. Figure 4-14 depicts an example of using two protectors’ chains in our sample cluster.\n\nIn order to implement this feature is necessary to add one column to the radictable, the column that indicates the protector’s chain. An observer uses the\ninformation in such column to search the protector of a faulty node inside each protectors' chain. The bold column in Table 4-10 exemplifies the chain information in a typical radictable.\n\nTable 4-10: The radictable of an observer for a cluster protected by two protectors' chains like in Figure 4-14.\n\n<table>\n<thead>\n<tr>\n<th>Process id.</th>\n<th>Address</th>\n<th>Protector (antecessor addr.)</th>\n<th>Chain</th>\n<th>Logical clock for sent messages</th>\n<th>Logical clock for received messages</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>Node 0</td>\n<td>Node 3</td>\n<td>0</td>\n<td>2</td>\n<td>3</td>\n</tr>\n<tr>\n<td>1</td>\n<td>Node 1</td>\n<td>Node 0</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Node 2</td>\n<td>Node 1</td>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Node 3</td>\n<td>Node 2</td>\n<td>0</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Node 4</td>\n<td>Node 8</td>\n<td>1</td>\n<td>2</td>\n<td>3</td>\n</tr>\n<tr>\n<td>5</td>\n<td>Node 5</td>\n<td>Node 4</td>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>6</td>\n<td>Node 6</td>\n<td>Node 5</td>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n</tr>\n<tr>\n<td>7</td>\n<td>Node 7</td>\n<td>Node 6</td>\n<td>1</td>\n<td>1</td>\n<td>1</td>\n</tr>\n<tr>\n<td>8</td>\n<td>Node 8</td>\n<td>Node 7</td>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n</tr>\n</tbody>\n</table>\n\nThe RADIC architecture requires that, in order to manage at least one fault in the system, the minimum amount of protectors in a chain is four. This constraint occurs because each protector of the RADIC controller for fault tolerance requires two neighbors, an antecessor and a successor (see paragraph 4.3.1.) Therefore, at least three nodes must compose a protector's chain. We depicted such minimal structure in Figure 4-15, in which each protector has an antecessor (to which it sends the heartbeats) and a successor (from which it receives heartbeats.)\nIf we consider that a fault takes out a node of the chain, and that a chain with three nodes is not capable to handle any fault, it is easy to conclude that the minimum number of protectors in a chain defines the maximum number of faults that such chain can handle. Equation 3 expresses this relation; the maximum number of faults that a protector chain can handle is equal to the number of protectors in the chain minus three (the minimum number of protectors required to form a chain.)\n\n\\[ \\text{MaxFaults} = \\text{Number of Protectors} - 3 \\]\n\nIn this chapter, we have defined the fundamentals and explained the operation of the RADIC fault tolerance architecture. In the next chapter, we are going to present a practical implementation of the RADIC architecture, which we used to perform functional and experimental tests.\nChapter 5\n\nAn implementation of the RADIC Architecture\n\nNow that we have presented the functional aspects of the RADIC architecture, it is necessary to describe the method used to validate the concepts of this architecture.\n\nTo assure the correct operation of a fault-tolerant architecture for message-passing systems in the absence of failures is a relatively easy task, because the tests are limited to compare the results generated by parallel applications using the fault-tolerant architecture against the same parallel applications using a legacy message-passing implementation.\n\nOn the other hand, to evaluate the correct operation of a fault-tolerant architecture in the presence of failures is a cumbersome task. Many fault scenarios are possible during a program execution and the exhaustive test of all these scenarios requires a large amount of work. Fault Injection is the best strategy to face such challenge.\n\nFault injection is a strategy to inject faults in a controlled way. Once all fault scenarios are established, a fault injection mechanism, which can create such scenarios, executes inside the system together with the parallel application. With this mechanism, it is possible to create a specific fault scenario and monitor the behavior of the fault-tolerant architecture in such scenario.\n\nThe recent literature about testing fault tolerance architectures presents some works devoted to test fault-tolerant systems. The FAIL-FCI framework [Hoarau and Tixeuil, 2005] is an example of framework for test distributed systems. FAIL is a fault injection language that rests on FAIL-FCI in order to evaluate message-passing implementations [Hoarau, et al., 2006]. Other works dedicate to testing of fault\ntolerance schemes in Grids, like the work published by Sébastien Tixeuil in [Tixeuil, et al., 2006].\n\nThe validation of the RADIC functional requirements depended of a message-passing implementation that could offer a suitable platform to the supporting of the fault tolerance mechanisms of RADIC.\n\nThe first issue was to define a messaging-passing paradigm. The MPI standard was the natural choice for our message-passing implementation, because it has become a widely adopted standard in the modern message-passing applications.\n\nAt the time we started our work, all available MPI implementations had a fail-stop behavior; therefore, we decided to create a new message-passing implementation that could support a node failure without stopping.\n\nThe creation of our own MPI implementation also allowed a better the control of the messaging-passing mechanism. This has facilitated the implementation of the message-log and the recovery mechanisms. Furthermore, we saved many time in software development, because we avoided the typical effort required in the understanding and modification of softwares made by other developers.\n\nWith these issues in mind, we developed a MPI implementation to evaluate the concepts of RADIC. This implementation, called RADICMPI, has served for two purposes: evaluate the functionality of RADIC as a fault-tolerant architecture, and assess the influence of the RADIC fault tolerance mechanism in practice.\n\nIn this chapter, we present the functional tests, i.e., the tests performed in order to evaluate the functional requirements of RADIC. First, we explain RADICMPI and the implementation of the RADIC distributed controller. Next, we define the operation of the fault injection mechanism and our test methodology. We conclude analyzing the results of our tests.\n\n### 5.1 RADICMPI\n\nRADICMPI is a MPI implementation created to test the functional and experimental evaluation of the concepts of the RADIC Architecture.\nFor the development of RADICMPI, we decided to rest only on open source softwares. Such decision has satisfied two requirements: a) it gave us freedom to adapt any software feature and b) it maximized the use of software tools accepted in the research world.\n\nBecause of this, our current RADICMPI implementation rests on the Linux operating system running on Intel IA-32 architectures. Our checkpoint mechanism rests on the popular BLCR, the Berkeley Labs Checkpoint/Restart library [Hargrove and Duell, 2006]. The message-passing mechanism and all messages exchanged between the RADIC elements use legacy TCP/IP sockets.\n\nThe operation of RADICMPI should attend to the fundamental features offered by RADIC: transparency, flexibility, scalability and decentralization. Therefore, these four features drove the design of RADICMPI.\n\nFigure 5-1 depicts the several software levels of a parallel application using RADICMPI. This figure shows the transparent behavior of RADICMPI, because each application process relates only with a classical MPI API and has no contact with the RADIC API. This means that the application does not takes care of any fault tolerance activity.\nIn Table 5-1, we summarized all RADIC fundamental features and how RADICMPI implement them.\n\nIn order to implement the transparency, we have created a software environment in which a programmer would only need to re-compile their application codes in order to use RADICMPI. The software environment has two elements: a software library (RADICMPI library) and an execution environment (RADICMPI scripts).\n\nBesides a transparent operation, RADICMPI also must comply with the other three features of RADIC. The operation of RADICMPI does not require any central or dedicated node. All RADIC functional elements, protectors and observers, which implement the RADIC controller for fault tolerance, execute in the same nodes where the processes of the parallel application are. This behavior complies with the decentralization requirement.\n\nThe number of nodes in the cluster does not modify the functionality of the RADIC controller as well as the messaging passing mechanism. Therefore, only the behavior of the application determines the scalability of the system. The number of cluster's nodes does not compromise the scalability of RADICMPI.\n\n<table>\n<thead>\n<tr>\n<th>Feature</th>\n<th>How it is implemented by RADICMPI</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Transparency</td>\n<td>- A software library implements the fault tolerance and message-passing mechanisms</td>\n</tr>\n<tr>\n<td></td>\n<td>- The programmer only has to re-compile the application code</td>\n</tr>\n<tr>\n<td>Decentralization</td>\n<td>- The protectors and observers execute in the same nodes used by the application processes</td>\n</tr>\n<tr>\n<td></td>\n<td>- No central or special node required</td>\n</tr>\n<tr>\n<td>Scalability</td>\n<td>- The operation is not affected by the number of nodes in the parallel computer</td>\n</tr>\n<tr>\n<td>Flexibility</td>\n<td>- Fault tolerance parameters are defined by the user when it launches the parallel application</td>\n</tr>\n<tr>\n<td></td>\n<td>- It is possible to implement other checkpoint policies</td>\n</tr>\n</tbody>\n</table>\nIt is possible to modify checkpoint interval, the watchdog interval and the structure of the protection chain to comply with the user's requirements. Furthermore, the current RADICMPI implementation uses a typical time-driven checkpoint policy, but it is possible to implement other checkpoint policies, like a policy driven by the message-log size or by process' synchronization.\n\n5.2 RADICMPI library\n\nRADICMPI is a multithread library. Three threads will exist when we execute a program compiled with the RADICMPI library: the program main thread, the observer thread and the checkpoint thread.\n\nFigure 5-2 depicts the threads of RADICMPI and the relationship between them. The main thread executes the user program and sends communication commands to the observer thread, which implements the fault tolerance and the message-passing mechanism. The observer thread sends checkpoint commands to the BLCR thread, which implements the checkpoint mechanism. Because RADICMPI works transparently to the application program, no relation is required between the user program (main thread) and the checkpoint mechanism (BLCR thread).\n\n5.2.1 MPI API\n\nRADICMPI offers a subset of routines and constants defined by the MPI-1 standard. The syntax of all RADICMPI functions strictly follows the MPI-1 specification in order to comply with the transparency requirement.\nThe MPI API level completely isolates the application process from all message delivery activities. RADICMPI contains the blocking communication functions: MPI_Send, MPI_Recv, MPI_Sendrecv; the initialization and finalization functions MPI_Init, MPI_Finalize; and a group of auxiliary functions: MPI_Comm_rank, MPI_Comm_size, MPI_Wtime, MPI_Type_size and MPI_Get_processor_name.\n\n**MPI_Init**\n\nThe MPI_Init creates the observer thread and the BLCR thread. This function also manages the arguments received by the application program in two sets of arguments: the application’s arguments and the observer’s arguments.\n\n**MPI_Finalize**\n\nThe MPI_Finalize routine simply sends a finalize command to the observer. When the observer receives this command, it informs to the local and remote protector that it is going to finish and then it terminates.\n\n**MPI_Send**\n\nMPI_Send drive the observer to send the message stored in a buffer informed by the application process. The process blocks until the observer delivers the message to the communication channel.\n\n**MPI_Recv**\n\nMPI_Recv requests a message to the observer. The observer puts the message in the buffer allocated by the process. The function blocks until it receives the message from the observer.\n\n**MPI_Sendrecv**\n\nThis function is just a sequential calling of the MPI_Send function followed by the MPI_Recv function.\n\n**Auxiliary MPI routines**\n\nMPI_Comm_rank, MPI_Comm_size, MPI_Wtime, MPI_Type_size and MPI_Get_processor_name execute locally, i.e., they do not require any interaction between the local process and other processes.\nMPI_Comm_rank, MPI_Comm_size get their data directly from the observer. The observer receives this information from the RADICMPI environment, at the time the application starts.\n\nMPI_Wtime, MPI_Get_processor_name and MPI_Type_size get their information from the operating system.\n\n5.3 RADICMPI Controller for fault tolerance – Observer\n\nThe RADIC library contains half of the RADIC distributed controller elements: the observers. Each observer works as a thread of the application process. This thread manages the message-passing between the parallel application processes and implements the fault tolerance functionalities.\n\nFigure 5-3 depicts the external and internal sources of the events that drive the observer operation, the elements in the top of the figure are the ones that generate external events and the elements in the figure bottom are the ones that generate internal events.\n\nExternal events correspond to MPI commands sent by the application process; messages, which comes from the remote application processes of the parallel application; and initialization and recovery commands. Internal events are consequence of the operation of the state saving phase of the fault tolerance mechanism (checkpoints and message logs) or of the fault detection mechanism.\nIncoming-messages (Remote application processes events)\n\nThe RADICMPI message-passing mechanism rests on TCP/IP sockets. Each observer sets up a TCP server socket for accepting connections from other observers. The reception of a message is not associated with an MPIRecv command. An observer is always ready to receive messages, unless it is performing a checkpoint of its process.\n\nAfter an observer accepts a connection from other observer, it first waits for a header that identifies the message that is about to come. The header contains the message logical clock (which identifies the message sequence), the sender and receiver identification, the MPI tag of the message and the message's size.\n\nThe receiver then compares the logical clock of the received message against the logical clock that counts the messages received from the sender in this radictable. If the received logical clock is greater than the current counter, it means that the message is new. Then, it returns an ACK message to the sender and prepares to\nreceive the message. Otherwise, it returns an NAK message indicating that the message is old (the sender has recovered and replayed an old message).\n\nIf the message is new, the observer receives it through the TCP socket, puts the message in a temporary buffer, logs the message in its protector, returns a new ACK message to the sender and closes the TCP socket. Then it increments the logical clock, the counts the messages received from the sender, in its radictable. Figure 5-4 represents all sequence of steps followed by the observer in response to an incoming message event.\n\nIn this section, for the sake of simplicity, we did not explain how the fault detection procedure interacts with the message-incoming procedure. We will clarify this interaction in the section that explains the fault detection procedure.\n\n**MPI_command events**\n\nThe application process generates MPI_commands to the observer. The observer deals with each MPI_command as an individual event. For the application process,\nthe messaging-passing mechanism and the fault tolerance mechanism are completely transparent.\n\n- **MPI_Init command**\n\n The MPI_Init function starts the observer thread. The first task of every observer is to create a TCP server socket in order to accept connections of all other application processes.\n\n Next, the observer communicates with the local protector (the protector that is running in its node) in order to ask the information about the location of its remote protector. The remote protector is the one in which the observer stores checkpoints and message-logs of its application process, namely the neighbor antecessor of the node where the observer is running. After discover its remote protector, the observer communicates with it in order to inform that it is ready.\n\n Next, the observer starts the procedure to mount its *radictable*, which contains all information about the location of the other application processes and their respective observers. In the current RADICMPI implementation, the leader observer, i.e., the observer with rank equal to zero, is in charge of requesting the location information and the protector information from all other observers. The leader observer then builds a complete *radictable* and broadcasts it to all other application processes. At the end of the initialization phase, all observers have the same *radictable*.\n\n Is also in the initialization procedure that the observer starts the checkpoint thread using the BLCR API. In Figure 5-5, we represent the steps followed by the observer thread after it starts through an MPI_Init command.\n\n- **MPI_Recv command**\n\n The observer puts all incoming-messages in a temporary buffer. When the application process executes an MPI_Recv command, the observer uses the sender information and the MPI tag of the message to determine if the message is already in its buffer or not.\n\n If the requested message is not in the temporary message buffer (because such message has not arrived yet), then the observer blocks the application process until\nthe message arrives. Otherwise, it immediately delivers the message to the application process. Figure 5-6 depicts the steps followed by an observer after it receives an MPI_Recv command.\n\n\n\n**Figure 5-5: How the observer engine responds to an MPI_Init command**\n\n- **MPI_Send command**\n\n When a process executes an MPI_Send its observer looks for the destination address in its *radictable*.\n\n The sender observer contacts the destination and starts the transmission procedure. First, the sender transmits a header in order to identify the message for the destination. The header contains the message logical clock (which identifies the message sequence), the sender and receiver identification, the MPI tag of the message and the message's size. Then it waits for the confirmation from the destination.\n\n Two kinds of messages may return from the destination: an ACK message or a NAK message. If a NAK message returns, the sender knows that the receiver already\nhas received that message. Then, the sender observer increments the send logical\ncounter related to the respective receiver in its radictable and terminates the\nMPI_Send. This avoid that a recovered observer retransmit old messages through the\ncommunication channel.\n\n\n\nIf the destination returns an ACK message, then the sender knows that it may\nsend the message. Then, it transmits the message and waits for a new ACK message\nfrom the destination. When the ACK comes, the sender observer increments the\nlogical counter for send messages in the correspondent radictable line related to the\ndestination.\n\nFigure 5-7 represents the steps followed because and MPI_Send command. In\nthis figure, for the sake of simplicity, we do not represent the error conditions. We\nexplain such conditions in the fault detection procedure.\n\n- Auxiliary MPI commands\n\nThe management of MPI commands that do not involve communication is very\nsimple. Some functions require the use of services from the operating system in order\nto complete the command.\n\nThe MPI_Wtime and MPI_Get_processor_name functions are the ones that\ndepend of the operating system to get the information required to complete the\ncommand. The observer calls the respective function of the operating system and\nmanipulates the information in order to respond to the command. For example, for the\nMPI_Wtime command, the observer accesses the wall clock of the operating system and adapts the information to the format required by the function.\n\nThe MPI_Comm_size and MPI_Comm_rank use information of the RADICMPI environment, namely the number of process in the communicator and the id of the application process.\n\n\n\n**Figure 5-7: How the observer engine responds to an MPI_Send command**\n\n**State saving events**\n\nThe states saving events are events created by the fault tolerance mechanism. They correspond to message-log events and checkpoint events.\n\n- Message logs\n\nOne of the steps performed by an observer when it is dealing with incoming-messages is to log new received messages in its remote protector, before sending an ACK message to the sender in order to confirm the message reception, as shown in Figure 5-4. Therefore, a message log event is an internal events generated when the observer receives a new message.\n\nThe communication between the observer and its protector is simpler than to the communication between two observers. The observer first establish a communication\nsocket with the protector, sends a message header to identify the message, sends the message, and then waits for an ACK message from the protector, which informs that the message was correctly logged. After the acknowledge message comes, the observer closes the TCP socket and terminate the log procedure. We depict the steps of the message-log procedure in Figure 5-8 without consider the error situations. Such situations are part of the fault detection procedure.\n\n\n\n- Checkpoint events\n\nCheckpoint events are internal events started by time counter in the observer. The interval between two checkpoints is function of the checkpoint interval defined by the user in the system startup. The observer initializes its counter initializes when it starts, when it recovers and after a checkpoint completes.\n\nThe checkpoint mechanism is function of the BLCR checkpoint library. Because this library does not perform checkpoint of opened TCP sockets, a lock mechanism blocks the checkpoint procedure if the observer is communicating with other process. Similarly, the observer never initiates nor accepts communications while a checkpoint is occurring.\n\nBecause the processes in the RADIC architecture do not coordinate their checkpoints, a fake error condition could occur if a process tries to communicate with\na destination that is making a checkpoint. The strategy to deal with this fake error condition is in the fault detection procedure.\n\nIn the first step of the checkpoint procedure, the observer opens a TCP socket with its protector and informs that it is going to checkpoint. Then, the observer closes the TCP server socket that accepts communication of other observers, to avoid new connections from this point, and checks if there are active communications. If some communication is active, the observer waits until it concludes. This checking is necessary to assure that there are no open TCP channels with other observers when the checkpoint mechanism starts.\n\nFollowing the checkpoint procedures steps, the observer orders that the BLCR library take a checkpoint of the whole application process state, including the observer itself. The BLCR checkpoint functions take control of the system, execute the checkpoint and transmit the checkpoint to the protector via the active TCP socket.\n\nWhen the BLCR library concludes the checkpoint, it returns the control to the observer. Then, the observer closes the TCP socket for transmission. This activity signalizes to the protector that the checkpoint has finished. The protector confirms the correct checkpoint reception closing the socket with the observer.\n\nFinally, the protector reopens the TCP server socket for accept new connections from other observers and finalizes the checkpoint procedure. Figure 5-9 represents the steps of the checkpoint procedure without error conditions.\n\nThe recovery event\n\nAccording to the operation of the RADIC architecture, the recovery procedure corresponds to restarting a process since its previous checkpoint. In RADICMPI, when the BLCR checkpoint function takes a checkpoint, the checkpoint contains the states of the observer and of its application process, because their threads share the same memory space.\n\nThe start of recovery mechanism is not an observer attribution, because are the protectors who have to detect the failed nodes and restart faulty processes. The\nrecovery mechanism of RADICMPI rests on the restarting procedure of the BLCR library.\n\n![Diagram showing observer checkpoint procedure without error conditions]\n\n**Figure 5-9: Observer checkpoint procedure without error conditions**\n\nWhen BLCR restarts a process since a checkpoint, it signalizes to the process that it is restarting. An observer relies on such signal in order to identify that it is restarting since a checkpoint, i.e., it is recovering from a fault.\n\nBecause the process is recovering in a node different from the one in which it was before the fault, the first observer concern is to update the information about its remote protector. For this, the observer communicates with the local protector in order to discover who its antecessor neighbor is.\n\nThe observer then informs to its new remote protector that it is recovering and to the local protector that from now on it will use another protector. It is important to warn to the local protector that it is not in charge of the recovered observer anymore, because the observer is now running in the same node. This breaks the relation between a recovered process and its previous protector.\nThe next step is to deal with the message log of its process. The observer copies all messages from the message log to temporary buffer used to store incoming messages. Therefore, when the application process requests those messages again, they already are in the reception buffer.\n\nThe observer then gets the messages from the message log, which is present in the node it has recovered, and copies these messages to the buffer used to store incoming messages. Therefore, when the recovered process requests an old message (MPI_Recv), such message is already in the observer’s buffer. If the recovered application process tries to retransmit messages, the destination observer discards such as we have previously explained in the procedure that deals with incoming messages.\n\nFinally, the observer reopens the TCP server socket in order to communicate with other application processes and informs to its remote protector that it is again ready to communicate. Figure 5-10 represents the recovery procedure. Again, we do not represent error events because they are responsibility of the fault detection mechanism.\n\n5.3.1 How the RADICMPI observers detect and manage faults\n\nAs we depicted in Figure 5-3, the fault detection procedures generate internal events to the observer engine. In RADICMPI, the fault detection procedures are present inside all other procedures, i.e., when the observer engine treats an event, the procedure who deals with the event includes the functions to detect and to deal with the error events. We may define the RADICMPI fault detection procedure as a collection of all the individual fault detection procedures inside the observer engine.\n\nThe fault detection mechanism bases on communication failures and communication timeouts in order to detect a fault. Basing on such assumption, we may define two classes of communication failures that exist in the observer context: failures between two observers and failures between observers and protectors.\n\nBecause the fault detection phase of the RADIC architecture always starts the fault-masking phase, in RADICMPI we coupled the fault masking functions together\nwith the fault detection functions. Therefore, whenever some procedure detects a failure, the fault masking procedure immediately starts to adapt the observer to the new cluster configuration.\n\nFigure 5-10: How observer recovers\n\n**Failures detected when two observers are communicating**\n\nThese failures can occur in two different situations: the observer detects a problem before it starts a communication (valid only for the sender observer) or the observer detects a problem during a communication (valid for both observers implicated in the communication).\n\n- The sender observer detects a failure before it initiates the communication\n\nThis situation occurs when the destination does not accept the sender because one of the following reasons: a) the destination is checkpointing and its TCP server socket is closed; or b) the destination node has failed and the destination process is running in another node.\nIn both cases, the observer first contacts the protector of the destination process in order to discover what is happening. If the destination’s protector answer that the process is checkpointing, the sender observer keeps querying the protector until it answer the nodes is ready. Then it tries to communicate with the destination again.\n\nIf the protector of the destination process responds that it is not responsible by that process, the sender observer admits that the destination process has failed and, using its radictable and the algorithm explained in paragraph 4.4.5, calculates the new address of the destination process and retries the communication.\n\n− An observer detects a failure after the communication has been started\n\nIn this case, the behavior of the observer depends of its role in the communication. If it is receiving the message, it simply aborts the communication because it knows that the sender will restart the communication again. If it is sending the message, it assumes that the destination has failed and uses its radictable, together with the algorithm explained in paragraph 4.4.5, to calculate the new address of the destination process in order to reestablish the communication.\n\nFailures detected when an observer is communicating with a protector\n\nAs for the communication between two observers, the fault detection between a protector and an observer also relies on communication failures and communication timeouts. In this paragraph, we evaluate the mechanism since the observer view.\n\nThe communication between an observer and a protector occurs in two different phases: in the state saving phase and in the fault-masking phase. Therefore, the operation of fault detection mechanism depends of the current operation that the observer is executing.\n\n− An observer detects a failure with its remote protector in the state saving phase\n\nIn this case, the observer immediately communicates with its local protector in order to determine who its new protector is. Then it immediately takes a checkpoint, in order to reestablish the protection, and concludes the communication.\nIn RADICMPI, the observer also detects a failure in its remote protector when the local protector sends a special warning message to it. This mechanism protects the observer of being unaware that its protector has failed, because it has stayed a long period without needing to communicate with the protector, for example inside a checkpoint interval in which no message log occurred.\n\n- An observer detects a failure with a protector of a destination process\n\nThis situation occurs when a sender observer detects a communication error with a destination process, and needs to contact the destination protector to obtain information about the destination status.\n\nIn RADICMPI, the operation fail detection and fault masking functions are the same as with the observer detects a failure in a destination process. The observer uses the \\textit{radictable} and the search algorithm explained in paragraph 4.4.5 to calculate the location of the protector it needs to communicate.\n\nWhen it finds the required protector, it updates the protector information in its \\textit{radictable} and reestablishes the communication.\n\n5.4 RADICMPI Controller for fault tolerance - Protector\n\nThe protectors are the other half of the RADIC controller for fault tolerance. They operate like a distributed stable storage and as a distributed fault tolerance detector.\n\nIn the current implementation of RADICMPI, the protector has three main threads: the successor thread, the antecessor thread and the thread that deals with the observers.\n\nThe protectors execute as separated programs, they do not share the memory space of the application processes. Figure 5-11 depicts the structure of the protection program. The antecessor and the successor threads exist while the observers that relates to the protector are running. In the figure, this dependency corresponds to the\ntwo arrows that connect the successor thread and the antecessor threads with the finalization procedure.\n\n\n\n**Figure 5-11: The protector program in RADICMPI**\n\n### 5.4.1 Initialization\n\nThe initialization procedure starts the all the protectors threads. Each protector receives the address of its neighbor antecessor and the address of its pre-antecessor (the antecessor of its antecessor). The user must design the protector chain and inform to each protector who its antecessor is and who its pre-antecessor is.\n\nAnother parameter that user must define is the watchdog/heartbeat interval, that will be used by the successor and antecessor threads in order to execute the fault detection mechanism.\n\n### 5.4.2 Observers management thread\n\nThis thread creates a TCP server socket exclusively to accept the observers that will send checkpoints and message-logs for the protector or that will query about the status of other processes. The protector maintains a list with the status information of all observers that are using it as stable storage. The protector updates the list\naccording to the activities of the observers that it is protecting. Using this list, the protector answers to the queries about the status of each observer it is protecting.\n\nAll checkpoints and message logs of each observer that is using the protector as a stable storage are stored in the disk of the protector’s node. The pessimistic log protocol used by the RADIC Architecture greatly simplifies the garbage collection procedure. Whenever a protector receives a new checkpoint, it automatically discards any earlier checkpoint and message log of the application process. This occurs because in the pessimistic protocol every checkpoint is a snapshot of the current state of the application process and it is not necessary any other information besides the current checkpoint to recover the process to this current state.\n\nThe observer management thread also accept connection from local observers, i.e., from observers that are running in the same node of the protectors. The thread maintains a list of these observers while they are active, and uses this list to warn the local observers about a failure in the antecessor protector.\n\n5.4.3 Antecessor thread\n\nThe antecessor thread waits for the connection of a successor protector. This thread creates a TCP server socket to accept the connection of the successor protector and to establish the watchdog mechanism. The TCP socket between an antecessor and its successor is always active. It only closes in the finalization procedure.\n\nOnce the successor has connected, the thread establishes a watchdog mechanism based on the heartbeat cycle. The heartbeats sent by the successor reset the watchdog. For each heartbeat signal received the antecessor thread returns an acknowledge message (ACK message) to the successor protector.\n\nIf a heartbeat fails, the antecessor thread starts the fail confirmation function. The confirmation mechanism consists in wait an additional watchdog cycle to assure that the heartbeat is missing.\n\nIf the heartbeat does not arrive, the antecessor thread starts another confirmation mechanism, the one that checks for Byzantine failures. The algorithm in RADICMPI\nAn implementation of the RADIC Architecture\n\nis the one explained in the Failure Detection Phase of the RADIC Architecture, which we depicted in Figure 4-10.\n\nWhen the antecessor thread finally confirms a failure, it takes care of recovering the faulty process from the faulty node. The recovery procedure is a part of the BLCR library API. The protector simply calls the BLCR recovery function passing the name of the checkpoint file of the process that the function has to recover.\n\nConcurrently with the recovery mechanism, the antecessor thread waits for a new successor connects and then restarts the watchdog function.\n\n5.4.4 Successor thread\n\nWhen the successor thread starts, it immediately fetches this antecessor in order to start the heartbeat mechanism. It establishes a TCP socket with the antecessor and keeps this socket opened until it the thread completes.\n\nThe successor threads regularly send heartbeat signals to the antecessor protector via the opened TCP socket in order to reset the antecessor watchdog. For each heartbeat sent the thread waits for an acknowledge message (ACK message). If the ACK message does not come, or if some communication error occurs the successor thread starts the fault confirmation function.\n\nThe fault confirmation mechanism consists in retrying to send the heartbeat to the antecessor protector. If it fails again, successor thread starts another confirmation mechanism, the one that checks for Byzantine failures. The algorithm in RADICMPI is the one explained in the Failure Detection Phase of the RADIC Architecture, which we depicted in Figure 4-10.\n\nWhen the successor thread finally confirms a failure, it warns all local observers that the antecessor protector has failed. Then it connects to the pre-antecessor of the failed antecessor and reestablishes the heartbeat mechanism. The successor thread does not take part of the recovery procedure.\n5.4.5 Finalization procedure\n\nThe finalization procedure initiates when all observers that relate with a protector terminate, i.e., the protector only can terminates after all local observers in this node terminate and all observers in the successor node terminate.\n\nWhen the successor thread is ready to terminate, it sends a STOP signal to the antecessor protector using the heartbeat TCP socket and then terminates. Similarly, the antecessor thread only terminates after it receives the STOP signal in the watchdog TCP socket.\n\n```\nangelo@aoclp9:~/radic/examples> radiccc -help\nThis is a program to compile or link MPI programs using RADICMPI\nIt should be used just like the usual C compiler\nFor example,\n/users/angelo/radic/bin/radiccc -c foo.c\nand\n/users/angelo/radic/bin/radiccc -o foo foo.c\nor by combining compilation and linking in a single command\n/users/angelo/radic/bin/radiccc -o foo foo.c\nIn additional, the following special options are supported\n-show - Show the commands that would be used without running them\n-compile-info - Show how to compile a program\n-link-info - Show how to link a program\n-help - Give this help\n-echo - Show exactly what this program is doing.\n This option should normally not be used.\n```\n\nFigure 5-12: The radiccc command\n\n5.5 Using RADICMPI\n\nTwo scripts help the user to compile and to run his/her MPI applications using RADICMPI. These scripts have a similar syntax to their similes in the MPICH-1.2.7 implementation.\n\n5.5.1 Compiling the sources\n\nThe compilation script is `radiccc`. This script serves to generate binary files from C or C++ source codes. `Radiccc` compiles the application code and links it with the RADICMPI and the BLCR libraries in order to generate a binary file that is ready to use the RADIC functionalities. Figure 5-12 contains a screen copy of the exit of the\nAn implementation of the RADIC Architecture\n\nThe implementation of the RADIC Architecture uses the `–help` option. The figure contains the instructions about how to compile a program and about additional options that help the user in the compilation task.\n\n### 5.5.2 Running the parallel program\n\nThe execution script is `radicrun`. This script spawns the application processes and the protectors throughout the cluster nodes.\n\nFirst, it launches all protectors in order to build the protectors’ chain. The current RADICMPI implementation uses the nodes described in the `machinefile` to form the protector’s chain. Each node antecessor is the node in previous line of the file. To clarify how a protector chooses its antecessor, in Figure 5-13 represents the first lines of the `machinefile` for the cluster depicted in Figure 4-3. Using this information, the `radicrun` script knows that the antecessor of Node 2 is the Node 1; the antecessor of Node 1 is node 0 and so on. The antecessor of Node 0 is the last node used by the parallel application.\n\n\n\nAfter launches all protectors, the `radicrun` scripts launches the application processes. The binary of an application process contains the BLCR and the RADICMPI libraries.\n\nFigure 5-14 contains a screen copy of the exit of the `radicrun` command. The `radicrun` accepts several specific options. The `–ckpt` option is relate to configuring of the RADIC checkpoint interval. The test options where used to activate special event log functions used for functional and debugging purpose (`-i, -olog and –tlog`).\n\nThe `–justprot` option make that `radicrun` only launches the protectors. It served only to debugging purposes. The `–nomlog` option turns off the message log mechanism, in order to assess the impact of message-logs in terms of execution time.\nIn this chapter, we presented and explained RADICMPI. RADICMPI is a practical implementation of the RADIC architecture based on the MPI message-passing standard. We used RADICMPI to perform functional and experimental tests with the RADIC architecture, as we will explain in the next two chapters.\nChapter 6\n\nFunctional Validation of the RADIC Architecture\n\nNow that we have presented the functional aspects of the RADIC architecture, it is necessary to describe the method used to validate the concepts of this architecture in practice.\n\nTesting the functionality of a fault-tolerant architecture includes two major phases: to evaluate the system operation in the absence of failures, and to confirm that the system operates correctly in the presence of failures. To assure the correct operation of a fault-tolerant architecture for message-passing systems in the absence of failures is a relatively easy task, because the tests are limited to compare the results generated by parallel applications using the fault-tolerant architecture against the same parallel applications using a traditional message-passing implementation.\n\nOn the other hand, to evaluate the correct operation of a fault-tolerant architecture in the presence of failures is a cumbersome task. Many fault scenarios are possible during a program execution, and the exhaustive test of all these scenarios requires a large amount of work. In order to face such challenge, we had to develop a Fault Injection mechanism for RADICMPI.\n\nFault injection is a strategy to inject faults in a controlled way. Once all fault scenarios are established, a fault injection mechanism, which can create such scenarios, executes inside the system together with the parallel application. With this mechanism, it is possible to create a specific fault scenario and monitor the behavior of the fault-tolerant architecture in this scenario.\nIn this chapter, we present the tests performed in order to evaluate the functional requirements of RADIC. First, we will explain the theoretical bases of the fault injection mechanism that we have built in order to perform the tests. Next, we define the operation of the fault injection mechanism and explain our test methodology and the tests performed. Finally, we conclude with an analysis of the tests results.\n\n6.1 Test platform\n\nBecause RADIC creates a distributed controller that shares the same cluster structure in which the parallel application is running, failures in nodes affect the operation of the RADIC controller as well as affect the parallel application. Since the RADIC controller must continue to operate after a failure, we had to assure the proper operation of such controller under faults.\n\nSuch requirement imposed an additional evaluation criterion. Now, besides we confirm that the RADIC controller was capable to manage faults and assure the correct ending of the parallel application, we must also assure that the RADIC controller was capable to endure faults in its own structure, and to continue its correct operation until the application completion.\n\nIn order to attend to both criteria: to assure that the RADIC architecture attends to the functional requirements and that the RADIC controller is able to continue its operation after failures, we created a test platform that contains a test protocol, a fault injection mechanism and a test environment.\n\n6.1.1 Test protocol\n\nUsing the fault injection approach, we define a test protocol to rule the test procedures. Such protocol defined the following steps for each test procedure, as depicted in Figure 6-1. The protocol defines the test parameters, the data to measure, and the expected test results. After the execution of the tests, we analyze the data measured and compare them against the expected results.\nIn all tests, we validated the correct operation of the RADIC architecture comparing the results of the programs using RADICMPI against the same programs compiled and executed using the MPICH-1.2.7 MPI implementation, available at Argonne National Laboratory [MPICH, 2007]. If the results were the same, this meant that the application correctly ended in both cases, i.e., our architecture was operating correctly.\n\n### 6.1.2 The Fault Injection mechanism of RADICMPI\n\nFault injection is the artificial generation of faults in a system in order to observer the system operation under fault conditions [Kopetz, 1997]. The fault injection mechanism must be able to generate faults as if they occurred in a real environment so the system acts as it is in a normal operation environment.\n\nThe fault injection approach is used achieve two goals: Testing and Debugging; and Dependability Forecast [Avresky, et al., 1992]. In testing and debugging, the goal is to force fault situations that otherwise will be very difficult to verify in practice since fault are unpredictable events. In dependability forecast, the idea is to collect information about the behavior of the fault-tolerant system and relate them to the\nexpected fault model (types and distribution) of the environment. Such relationship\nserves to model the dependability of the system in the envisioned environment.\n\nThe generation of the faults may be deterministic or probabilistic. In\ndeterministic testing, the tester selects the fault patterns from the domain of possible\nfaults. In probabilistic testing, the tester selects the fault patterns according to the\nprobabilistic distribution of the fault patterns in the domain of possible faults. The\nprobabilistic distribution follows a given fault model or criteria for the system under\ntest [Avizienis, et al., 2004].\n\nA fault injection mechanism may physically actuate over the hardware level or\noperate into the software level. In physical fault-injection, the target system is subject\nto hardware faults or adverse environment behavior that compromises the correct\noperation of the computer hardware. In software fault-injection, a fault injection\nalgorithm interferes (according to a specific fault pattern or randomly) into the state of\nthe system in order to mimic the effects of hardware fault or software design faults.\n\nThe recent literature about testing fault tolerance architectures presents some\nworks that use fault injection in order to test fault-tolerant systems. The FAIL-FCI\nframework [Hoarau and Tixeuil, 2005] is an example of framework for testing\ndistributed systems. FAIL is a fault injection language that rests on FAIL-FCI, a fault-\ntolerant test platform for clusters, in order to evaluate message-passing\nimplementations [Hoarau, et al., 2006]. Other works dedicate to testing of fault\ntolerance schemes in Grids, like the one published by Sébastien Tixeuil in [Tixeuil, et\nal., 2006].\n\nThe mechanism that we implemented to inject faults in RADICMPI served for\ntesting and debugging. The operation of the mechanism was deterministic, i.e., we\nprogrammed the mechanism to force all fault situations required to test the system\nfunctionality.\n\nWe implemented the mechanism in the software level. This allowed a rigorous\ncontrol of the fault injection and greatly facilitated the construction and operation of\nthe fault injection mechanism. In practice, the fault injection code is part of the code\nof the RADICMPI elements.\nIn Figure 6-3, we depict the interaction of the fault injection thread with the observer program. The figure shows that the fault injection mechanism operates as an additional thread, which executes together with the observer threads. The thread appears as a bold object in the figure. In the observer program, the fault injection thread interacts with the observer engine, in order to create the fault scenarios according with the events managed by the observer.\n\n![Image of the fault injection thread inside the observer program.]\n\nIn Figure 6-3, we depict the interaction of the fault injection thread with the protector program. The figure shows that the fault injection mechanism operates as an additional thread that executes together with the antecessor, successor and observer management threads. The thread, which appears as a bold object in the figure, interacts with all other threads in order to create the fault scenarios according with the events managed by the protector.\n6.1.3 The internal event-log mechanism of RADICMPI\n\nTo monitor the correct operation of the RADIC controller for fault tolerance, we implemented an event monitor that registered all activities of the observers and protectors that are the core elements of the RADIC controller. We built the internal event-log mechanism inside the program codes of observers and protectors, in order to monitor every single activity required to confirm the correct operation of the RADIC mechanism.\n\nThere are two types of event log mechanisms: one for debugging purposes and other for time measurement purposes. The user starts these mechanisms using the options of the radicrun command, as described in Figure 5-14. The -i option activates the time log mechanism. The -olog and -tlog options activate the debug log mechanism for observers and protectors, respectively.\n\n**Log Mechanism for Debugging**\n\nAs its name indicates, the debug log mechanism served to help us in the development of the RADICMPI software. The mechanism registers the internal activities in a log database stored in the local disk of each node.\nTable 6-1 describes each field of the debug log database. The database has the same structure for protectors and observers (the Figure 6-4 depicts a database of a protector).\n\n<table>\n<thead>\n<tr>\n<th>Column</th>\n<th>Field name</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Element ID</td>\n<td>Indicate the rank of the element. T# elements are protectors and O# elements are observers</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Event id</td>\n<td>Identifies the event type</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Event time</td>\n<td>Elapsed time in seconds since the program startup</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Function name</td>\n<td>Name of the internal function that generate the event</td>\n</tr>\n<tr>\n<td>5</td>\n<td>Event</td>\n<td>Description of the event</td>\n</tr>\n</tbody>\n</table>\n\nIn Figure 6-4, there is an example of a typical debug log database. Each register has five fields that correspond to the columns in the figure. The figure refers to the log base of the protector 0, identified by T0 in the first column. The following columns correspond to the Event ID, the Event time, the name of the function that generated the event and the name of the event.\n\n**Log Mechanism for Time Measurement**\n\nThe time log mechanism registers the activities of the RADIC elements in a temporary database inside the volatile memory. Each field of the database represents an event data, as described in Table 6-2. Store the log data in the volatile memory reduces the interference caused by the log mechanism over the execution of the program, because these memories are faster than disks.\n\nThe mechanism flushes the buffers to the program standard output immediately before the program ending. Figure 6-5 depicts an example of the output generated by the event log mechanisms. Each line corresponds to a register of the database. Each column corresponds to a field of the register according to the description in Table 6-2.\n6.1.4 Clusters used in the test\n\nTable 6-3 describes the clusters used to execute the tests. The diversity of clusters served to assure that our architecture was capable to adapt to different systems. We present in this thesis the test results obtained with the cluster named Homogeneous II, because it allowed the larger one.\n\n\n6.1.5 Algorithms used in the tests\n\nTo conduct the tests, we needed a collection of algorithms that could help us to validate the functionality of RADIC and to assess the influence of the RADIC controller for fault tolerance over the cluster and the parallel application. For this, the algorithms should attend to two requisites:\n\n- Have a deterministic runtime and communication-to-computation ratio, in order to facilitate the assessment of the influence of the RADIC parameters over the behavior of the parallel application.\n\n- Enable the control of the message pattern, in order to facilitate the configuration of the fault scenarios;\n\n<table>\n<thead>\n<tr>\n<th>Column</th>\n<th>Field name</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Source ID</td>\n<td>Rank of the source element. To differentiate observers from protectors, the rank of protectors appeared increased by 1000</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Event time</td>\n<td>Elapsed time (in seconds) since the program startup</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Event group</td>\n<td>Identifies the events that are part of an atomic operation like, for example, an MPI_Recv or a checkpoint.</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Event type</td>\n<td>Identifies the event type.</td>\n</tr>\n<tr>\n<td>5</td>\n<td>Message</td>\n<td>A brief description of the event</td>\n</tr>\n<tr>\n<td>6</td>\n<td>Destination ID</td>\n<td>Rank of the destination element. To differentiate observers from protectors, the rank of protectors appeared increased by 1000</td>\n</tr>\n<tr>\n<td>7</td>\n<td>Event size</td>\n<td>Event size (in bytes). A -1 indicates that the field is not used</td>\n</tr>\n<tr>\n<td>8</td>\n<td>Checkpoint size</td>\n<td>Protectors: Total size (in bytes) of all checkpoint files in the node Observers: Not used (always -1)</td>\n</tr>\n<tr>\n<td>9</td>\n<td>Message log size</td>\n<td>Protectors: Total size (in bytes) of all message log files in the node Observers: Not used (always -1)</td>\n</tr>\n</tbody>\n</table>\nThe first requirement serves to control the behavior of the parallel application in terms of its execution time, in order to evaluate the impacts of RADIC over the application performance.\n\nTable 6-3: Clusters used in RADIC validation\n\n<table>\n<thead>\n<tr>\n<th>Cluster</th>\n<th>Heterogeneous</th>\n<th>Homogeneous I</th>\n<th>Homogeneous II</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Nodes</td>\n<td>6</td>\n<td>12</td>\n<td>16</td>\n</tr>\n<tr>\n<td>Processors</td>\n<td>Pentium-4 / Pentium-III / Athlon-XP2600+ 1.8GHz/ 512KB L2 cache</td>\n<td>Pentium-4/ 1.8GHz/ 512KB L2 cache</td>\n<td></td>\n</tr>\n<tr>\n<td>Memory</td>\n<td>256 / 128 / 256MB</td>\n<td>256MB</td>\n<td>512MB</td>\n</tr>\n<tr>\n<td>Disk/node</td>\n<td>20 / 10 / 40 GB ATA</td>\n<td>40GB ATA</td>\n<td>30GB ATA</td>\n</tr>\n<tr>\n<td>Network</td>\n<td>100-baseTX hub</td>\n<td>100-baseTX switch</td>\n<td>100-baseTX switch</td>\n</tr>\n<tr>\n<td>Operating System</td>\n<td>Linux Fedora Core 3 Kernel 2.6.9</td>\n<td>Linux Fedora Core 4 Kernel 2.6.17</td>\n<td>Linux Fedora Core 2 Kernel 2.4.18</td>\n</tr>\n<tr>\n<td>Compiler</td>\n<td>gcc v3.4.2</td>\n<td>gcc v4.0.2</td>\n<td>gcc v3.4.5</td>\n</tr>\n<tr>\n<td>Checkpoint library</td>\n<td>BLCR v0.4.2</td>\n<td>BLCR v0.4.2</td>\n<td>BLCR v0.4.2</td>\n</tr>\n</tbody>\n</table>\n\nThe second requirements are necessary to configure the different experiments that will confirm that RADIC is capable to operate as a scalable, decentralized, flexible and transparent fault-tolerant architecture.\nBasing on these requirements, we choose three programs for performing the tests: a simple ping-pong program, a matrix-multiplication program using the MW (Master/Worker) paradigm, and a matrix-multiplication program using the SPMD paradigm (Cannon’s algorithm). The ping-pong program was the better program to evaluate the message-passing scheme, because it allows a complete control of the communication between the application processes. We used this program to simulate different message patterns, in order to confirm the correct operation of message-passing mechanism.\n\nWe choose the matrix-multiplication algorithms because their MW and SPMD algorithms generate distinct message patterns, facilitating the creation of different fault scenarios. As shown in Figure 6-6, the MW algorithm has a 1-to-N message pattern (Figure 6-6a). The master process communicates with all the worker processes. Each worker process only communicates with the master process. The SPMD algorithm has a communication mesh (Figure 6-6b). Each application process communicates with their neighbors.\n\n\n\nThe MW algorithm also offered an additional control over the application behavior; it was possible to use two strategies to balance the computation load between the workers: static and dynamic. In the static strategy, the master first calculates the amount of data that each worker must receive. Next, the master sends the data slice for each worker and waits until all workers return the results. In this strategy, the number of messages is small but each message is large, because the master only communicates at the beginning, to send the matrices blocks to the workers; and at the end, to receive the answers.\nIn the dynamic strategy, the master slices the matrices in small blocks and sends pairs of blocks to the workers. When a worker answered the block multiplication’s results, the master consolidates the result in the final matrix and sends a new pair of blocks to the worker. In this strategy is easy to control the computation-to-communication ratio by changing the block size. Small blocks produce more communication and less computation. Conversely, large blocks produce less communication and more computation.\n\n6.2 Validation of the message-passing mechanism\n\nThe first group of tests served to evaluate the behavior of the of the RADICMPI implementation as if it was a normal MPI implementation. For this, we used MPICH-1.2.7 [Argonne National Laboratory, 2007b] as the reference implementation.\n\nThe current version of RADICMPI contains all ideas to the RADIC architecture in the form of a reduced MPI implementation and the main goal of RADICMPI was to test the RADIC fault tolerance functionalities in a real environment, instead of to operate as a new fault-tolerant MPI implementation. Although it may seem meaningless to test RADICMPI with its fault tolerance capabilities deactivated, these tests served to several purposes:\n\na) To confirm the transparency of RADICMPI, using the same application codes in all tests;\n\nb) To validate the message-passing mechanism of RADICMPI;\n\nc) To serve as reference for calculating the time overheads caused by the operation of the fault tolerance mechanism;\n\nd) To evaluate the applications behavior;\n\nTests with the master/worker matrix multiplication algorithms\n\nFigure 6-7 shows the execution times (in seconds) as a function of the number of nodes in the cluster, required to multiply two 3000x3000 matrices with double-float elements using the Master/Worker matrix multiplication programs with static and dynamic load balance. In all experiments using N nodes, there is a master and N-1\nFunctional Validation of the RADIC Architecture\n\nworkers. We can see that the programs present a similar behavior. As expected, the execution time decreases as the number of nodes increase.\n\nAnalyzing the curves, we see that the program using dynamic balancing scaled better than the program using static load balance. This occurred because the communications in the static program are concentrated by master at the beginning and at the end of computation, causing a slow down of the whole system.\n\nThe difference between the behaviors of the dynamic balance program using different computation-to-communication ratios confirms that the communication with the master greatly influences the scalability of the application.\n\nIn Figure 6-8, we show the speedup curves for the programs, using the execution with four nodes as reference. We can see that the program using blocks with 600x600 elements presents a better performance and a regular increase in the speedup. Blocks with 300x300 elements yield a computation-to-communication ratio worse than blocks with 600x600 elements, because there is more communication between the master and the workers. The master has to attend to several workers at a time, enlarging the communication time between the workers and the master and slowing down the whole system. With blocks of 600x600 elements, there is less\n\n\ncommunication between the master and the workers and the communications become better distributed. This reduces the communication time between the workers and the master and improves the system performance.\n\n\n\n**Figure 6-8: Speedup of the M/W matrix multiplication programs using MPICH-1.2.7 for 3000x3000 double element matrices**\n\nTo test the programs with RADICMPI we simply compiled the same source codes with `radicc` and executed the binaries with `radicrun`. We confirm the correctness of the programs by comparing the results generated using RADICMPI with the results generated using MPICH-1.2.7.\n\nThe behavior of the programs with RADICMPI, in terms of scalability, was completely similar to the behavior of the programs using MPICH-1.2.7. Again, and because the same reasons we have explained for MPICH-1.2.7, the program with static load balance presented the larger execution times. Similarly, the program with dynamic balance using blocks with 300x300 elements had a worse performance than the program using blocks with 600x600 elements.\n\nWe can see the execution times of the programs using RADICMPI in Figure 6-9. For all M/W algorithms, the execution time (in seconds) reduces as the number of nodes increases, according to the same tendency presented by MPICH-1.2.7.\nExecution times for the M/W matrix multiplication using RADICMPI with fault tolerance off\nMatrices with 3000x3000 double float elements\n\nFigure 6-9: Execution time of the M/W matrix multiplication programs using RADICMPI\n(with fault tolerance off) for 3000x3000 double element matrices.\n\nThe similar behavior of RADICMPI with fault tolerance off and MPICH-1.2.7 is also observable in the speedup curves for the matrix multiplication programs. The curves in Figure 6-11 show the speedup for the cluster size since five until sixteen nodes, using the execution time with four nodes as reference. The curves present a similar tendency with the curves for MPICH-1.2.7 (Figure 6-8); however, there are differences between the performance of RADICMPI and MPICH-1.2.7.\n\nComparing the curves in Figure 6-8 against the curves in Figure 6-10, one can see that RADIMPI with fault tolerance off presents a better scalability than MPICH-1.2.7. The better behavior of RADICMPI in this case, is consequence of the message reception engine in the observers (see the observer operation in paragraph 5.3). In the current RADICMPI implementation, there are three threads dedicated to receive messages. Each observer has a temporary buffer that keeps a received message until the application requires it. Therefore, this multi-thread implementation associated with the temporary buffer of RADICMPI, improves the communication efficiency for the blocking MPI functions, because until three senders may communicate with a single observer at same time.\nChapter 6\n\nSpeed up for the M/W matrix multiplication using RADICMPI with fault tolerance off\nMatrices with 3000x3000 double float elements\n\nFigure 6-10: Speed-up of the M/W matrix multiplication programs using RADICMPI (with fault tolerance off) for 3000x3000 double element matrices.\n\nFurthermore, because MPICH-1.2.7 is a full MPI implementation oriented to run in different systems. Because of this, MPICH has to execute several internal activities to assure its correct operation, independent of the structure of the parallel computing in which it runs. On the other hand, RADICMPI without fault tolerance is a partial MPI implementation oriented to a specific parallel computer structure. Therefore, the operation of RADICMPI is simpler than the operation of MPICH-1.2.7.\n\nTests with the SPMD matrix multiplication algorithm\n\nThe communication pattern of the Cannon’s algorithm (SPMD) defines a square mesh topology, as depicted in Figure 6-6b. Because of this restriction, the number of nodes is a square power of the mesh dimension. For instance, a 3-dimensional mesh requires nine nodes; a 4-dimensional mesh requires sixteen nodes and so on. In the Cannon's algorithm, each node starts with blocks of the operand matrices and finishes with a block of the result matrix.\n\nIn order to assure that all blocks would have the same size, the size of the matrices must be an integer multiple of the block size. The number of nodes in the cluster and the requirements of the mesh topology, have allowed us to execute tests\nwith four, nine and sixteen nodes. Basing on these cluster sizes, we selected matrices with size multiple of these numbers for assuring that the blocks had the same size in each node. In this thesis, we present the results for matrices with 3024x3024 elements.\n\nFigure 6-11 shows the results of the tests conducted with the SPMD matrix multiplication program using MPICH-1.2.7 and RADICMPI with the fault tolerance functions deactivated. The figure shows the execution times (in seconds) as a function of the number of nodes in the cluster. We can see that both implementations have the same behavior in terms of scalability. Again, the differences between the message reception mechanism of RADICMPI and of MPICH-1.2.7 cause that the programs using RADICMPI present a better performance than the programs using MPICH-1.2.7.\n\n\n\nWe calculated the speedup of the programs for both implementations as a function of the number of nodes in the cluster, using the execution with four nodes as reference. The results presented in Table 6-4 show that speedup for both implementations have the same magnitude, confirming that RADICMPI does not affect the behavior of the application scalability.\nTable 6-4: Speedup for the SPMD matrix multiplication programs using MPICH-1.2.7 and RADICMPI with fault tolerance off\n\n<table>\n<thead>\n<tr>\n<th>Nodes (Size)</th>\n<th>MPICH-1.2.7</th>\n<th>RADICMPI (fault tolerance off)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>9 (3x3)</td>\n<td>232%</td>\n<td>270%</td>\n</tr>\n<tr>\n<td>16 (4x4)</td>\n<td>400%</td>\n<td>425%</td>\n</tr>\n</tbody>\n</table>\n\n6.3 Functional tests without failures\n\nAfter validating RADICMPI as a common MPI implementation, we started the tests with the fault tolerance mechanism activated. The tests in the absence of failures, served to assure that:\n\na) the fault-tolerant architecture satisfy to the functional requirements of RADIC;\n\nb) the operation of the fault tolerance mechanism implemented in RADICMPI did not interfere in the application’s correctness;\n\nc) the flexibility of RADICMPI allow the configuration of different protector’s structures.\n\nFurthermore, the tests without failure offered the time references in the experiments that we used for studying the impact of the fault tolerance parameters over the system performance. We will comment about such experiments in the next chapter.\n\nTo validate that all applications executed correctly using RADICMPI with the controller for fault tolerance activated, we compared the results obtained using RADICMPI against the results obtained with MPICH-1.2.7. In all cases, the application generated the same results, confirming that the operation of the RADICMPI controller for fault tolerance did not compromise the application correctness.\n\nTo validate if the fault-tolerant architecture attended to the functional requirements of the RADIC architecture, we checked if the system accomplished each\nindividual feature of RADIC. We resume the results for transparency, decentralization and flexibility as the checklist presented in Table 6-5. In this checklist, we represented the feature and the criteria we used to confirm each feature.\n\n<table>\n<thead>\n<tr>\n<th>Feature</th>\n<th>Validation criteria</th>\n</tr>\n</thead>\n</table>\n| Transparency | Same source code used in a common MPI implementation generated the same application results \nFault tolerance operation is automatic |\n| Flexibility | The system allowed the use of different checkpoint intervals and different protector structures |\n| Decentralization | We did use neither a central nor a dedicated node to support the fault tolerance activities |\n\nIn order to validate the scalability criterion, we executed the testing programs and observed two effects: how the operation of the fault tolerance mechanism affected the scalability of the system and how the RADIC controller scaled. In Figure 6-12, we represent the execution times of the M/W program using dynamic load balance and RADICMPI. In order to enlarge the execution times, we modified the algorithms to repeat the number of block multiplication in each node. In these experiments, each node multiplied each matrix block ten times. Therefore, we could better evaluate the effects of the number of checkpoints over the execution time.\n\nThe Figure 6-12 contains the results for three scenarios: without fault tolerance and with fault tolerance using two checkpoint intervals. The enlargement in the execution times increases when the checkpoint interval is shorter because more checkpoints occur during the program execution. We may see that\n6.4 Functional tests with failures\n\nThe main difficulty of these functional tests was to inject faults in the critical points of the system, because the communication state of a process strongly interferes in the behavior of the fault tolerance when the process fails.\n\nFailures occur randomly. Therefore, a failure may occur during any system activity. To assure that RADIC can manage any kind of failure, we had to specify all possible failure scenarios and build a fault injection mechanism that could create each failure scenario. The fault injection mechanism followed the general algorithm described in Figure 6-13.\n\nFor the test scenarios with faults, our unique premise was that in a scenario with multiple faults, a fault never occurred in an element that was involved in the recovery of a previous or simultaneous fault while the recovery process was in progress. In paragraph 4.1.3, we have argued that such premise is indeed less restrictive than it seems a priori.\nWe divided the tests according to the instant when a fault occurs in the system. There are two major types of scenarios: when two elements are communicating and when an observer starts a communication. We summarize these scenarios in Table 6-6.\n\nIn order to explain the tests with failure, we will consider the typical cluster structure depicted in Figure 4-3. This cluster contains nine nodes (N₀-N₈), each one running a RADIC protector process (T₀-T₈) and nine application processes (P₀-P₈), each one attached to an observer (O₀-O₈). The sequence depicted in Figure 4-11 is an example of what happens to the cluster structure if a failure occurs.\n\nFor each scenario, we defined how the elements of the RADIC architecture should operate when a fault occurs, and validate the operation of the elements using the event-log mechanism.\n6.4.1 Failure when a process is just computing\n\nThis is the simplest case because the application process is not interacting with any other application process in the cluster when the fault occurs. The fault detection and the recovery procedure actions are:\n\n1. The protector of the faulty application process detects the fault and mark the process as recovering;\n\n2. The protector starts the recovering procedures for the processes that were in the faulty node.\n\n3. Every recovered observer establishes a new protector and sends the current message log file and checkpoint file to it. The observer now has two protectors:\nthe actual one and the new one. These two protectors mark the status of the application as recovering.\n\n4. Every recovered observer opens the message log file and, for each message requested from its application process during recovering time, delivers the messages from the log file until the application requests a message that is not in the log.\n\n5. When the application requests the last message from the log, the observer communicates to the protectors that the recovery is complete.\n\n6. The recovered observer reopens its communication channel. Henceforth its application process may receive messages from another application processes again.\n\n7. The recovery procedure terminates. The observer terminates its relationship with the old protector and signals to the new protector that the application process is ready.\n\n6.4.2 Failure while a process is communicating\n\nSince there are two observers (source and destination) affected by the fault, we are going to evaluate each one point of view. The destination observer simply discards the incomplete message that it was receiving from the faulty source. The destination observer “knows” that the source will recover and will try to communicate again in the future.\n\nThe source observer should run the following algorithm:\n\n1. Look at the radictable in order to find the destination protector address;\n\n2. Contact the destination protector.\n\n3. If the communication with the protector of the destination process fails, then starts the algorithm to find the new protector of the faulty process and repeats step 2. If the communication is ok, update the radictable to replace the new protector of the destination process.\n4. If the protector answers that the peer is checkpointing or recovering, then wait and repeat step 2;\n\n5. If the protector informs that the peer is ready, update the destination address in the `radictable`.\n\n6. Send the message.\n\nAt the end of this procedure, the `radictable` of the source observer will have the new address of the destination process together with the address of the new protector of the destination process.\n\n### 6.4.3 Failure when a process starts a communication\n\nThis scenario is similar to what happens with a source observer if a fault occurs when two processes are communicating. The only difference is that the source observer will not start the communication, because the destination process is faulty. The source observer will follow the same steps described in paragraph 6.4.2.\n\n### 6.4.4 Failure when an observer is checkpointing or logging a message\n\nIn both cases, the watchdog of the protector must have identified that the node of the observer has failed. Therefore, the protector of the process will start the procedure to recover the observer.\n\n### 6.4.5 The protector node fails when the observer is idle\n\nThis case occurs if no observer is communicating with a protector when it fails, i.e., the observer is neither receiving a message from another process (and hence the observer is not saving a log in the protector) nor performing a checkpoint.\n\nIn this case, the local protector informs to the observer that its neighbor is faulty. When this occurs, the observer must immediately perform a checkpoint. The observer will follow a procedure similar to the procedure it follows when the protector fails during a message log or checkpoint.\n6.4.6 The protector node fails when the observer is checkpointing\n\nIn such case, the observer should execute the following algorithm:\n\n1. Use the radictable to calculate the antecessor address of this current protector. From now on, the observer consider this antecessor as its protector;\n\n2. Connect to the protector;\n\n3. If the connection fails because the protector is faulty, then repeat step 1 to find a new protector. If the protector answers, confirms it as the current protector;\n\n4. Transmit the pending checkpoint;\n\n6.4.7 The protector fails when the observer is transmitting a message log\n\nIf the protector fails while an observer is logging a message, such observer should follow the next sequence:\n\n1. Use the radictable to calculate the antecessor address of this current protector. From now on, the observer consider this antecessor as its protector;\n\n2. Connect to the protector;\n\n3. If the connection fails because the protector is faulty, then repeat step 1 to find a new protector. If the protector answers, confirms it as the current protector;\n\n4. Take a checkpoint, such checkpoint includes the message received, and transmit it to the new protector;\n\nIn this chapter, we validated the fundamental functionalities of the RADIC architecture in a real environment. We used a group of different applications that served to experiment the transparency, the flexibility, the decentralization and the scalability of the RADIC architecture. Each application had different communication-to-computation ratios and generated different message patterns. The evaluation of all scenarios rested on the event-log mechanism of RADICMPI and, of course, on the\ncomparison of the results generated by the applications running in scenarios with failures against the results generated in scenarios without failures.\n\nIn the next chapter, we present experiments that served to better understand the operation of the RADIC controller in terms of the impact of its parameters have over the performance of the application.\nChapter 7\nExperiments with RADIC\n\nIn the last chapter, we validated the RADIC architecture in terms of its functional requirements: decentralization, flexibility, scalability and transparency. We implemented in RADICMPI a fault injection mechanism and an event log mechanism, which helped us to assess the behavior of the system in several scenarios.\n\nNow we will discuss the practical aspects related to the design of RADIC architecture and will analyze how the RADIC parameters may affect the application’s behavior. For this, we focused on the impact of the operation of RADIC over the application performance. This impact is consequence of two factors: the reduction of the cluster structure caused by the resources consumed by the fault tolerance scheme, and the interference caused by the operation of the fault-tolerant architecture over the application.\n\nAny fault-tolerant architecture for message-passing systems consumes resources during its operation. For schemes based on rollback-recovery protocols, these resources consumed are, typically, disk storage, network bandwidth, and computational time. For the final user, the cost of a fault-tolerant architecture is often associated with the enlargement of the execution time of his/her application. On the other hand, for a system administrator, the requirements of disk storage or memory per node are also relevant.\n\nThe operation of the RADIC controller for fault tolerance consumes the cluster’s resources that, originally, would be available for the parallel application. As a result, the application \"sees\" a parallel machine with fewer resources than the resources actually available. Such reduced machine will execute the application in a time larger than it would execute without fault tolerance. Additionally, the checkpoint and message log procedures directly interfere in the application behavior. The\ncomputation of a process stops while the checkpoint procedure occurs, and the message log procedure increases the message latency.\n\nWe studied the interaction between the operation of the RADIC controller and the application using RADICMPI, focusing on how the parameters of the controller could influence the system performance, i.e., how the RADIC parameters influence the overhead caused by the operation of the fault tolerance mechanism.\n\nAs we have already discussed, the effect of such overhead is an enlargement in the execution time of the application and a reduction in the cluster capacity. In the RADIC architecture, the main factors that influence the overhead are:\n\na) The checkpoint’s interval and the checkpoint’s cost;\n\nb) The application’s message pattern and the cost of message log;\n\nc) The interaction between checkpoints and messages with the application processes;\n\nThe combination of all these factors make difficult to model a general function that represents the cost of the RADICMPI fault tolerance mechanism. Nevertheless, it is possible to study the influence of the RADIC parameters for a specific application. Therefore, we conducted experiments in order to evaluate the overall impact of the interaction between checkpoints and messages in our testing programs.\n\nThese experiments consisted in, for a given application, to study the influence of each RADIC parameter over the application behavior. In RADICMPI, these parameters were: a) the watchdog/heartbeat cycle; b) the protector’s structure and c) the checkpoint interval.\n\n### 7.1 Experiments with the watchdog/heartbeat cycle\n\nThe heartbeat mechanism of RADICMPI creates a continuous flow of short messages (the heartbeats) between the nodes. In Figure 4-8, we can see an example of how the protectors communicate using the heartbeats.\nBecause, in our testing system, these short messages passed through the same network structure used by the application processes to communicate, we conducted experiments to measure the influence of the heartbeat over the message latency and the network throughput.\n\nThe tests consisted in use the ping-pong program to create several message patterns between the processes. Then, we execute the program in the system without fault tolerance and measure the message latency and network throughput for each message pattern.\n\nTo assess the influence of the heartbeats, we first executed the ping-pong program without fault tolerance and measured the message latencies and network throughput.\n\nNext, we used the option \\textit{-justprot} available in the command \\textit{radicrun} (see Figure 5-14.) in order to create only the protectors of the RADIC controller for fault tolerance. The protectors started all the threads and the watchdog/heartbeat mechanism, but since there are no observers active, the only network traffic generated by RADIC comes from the heartbeats.\n\nSince the literature about fault tolerance does not make any reference about what should be the best cycle four our architecture, we could base only in practical concerns to guide us in the election of a heartbeat cycle. Considering that the watchdog/heartbeat cycle defines how fast a protector detects a failure in its neighbor, we assumed that heartbeat cycle of one second would be fast enough for systems which intend to execute long-time applications.\n\nWith all heartbeats active, we re-executed the ping-pong program, re-created the same message patterns, and measured again the message latencies and the network throughput for each message pattern. Finally, we compared the results obtained in the executions without fault tolerance against the executions with fault tolerance using only watchdog/heartbeat messages.\n\nThe comparison between the results has shown that, in the testing cluster used for the experiments, the influence of the heartbeats over the message latency or the\nnetwork throughput was imperceptible. This result indicated the heartbeat messages created a negligible influence over the cluster structure.\n\n7.2 Experiments with the protectors structure\n\nIn Chapter 6, we conducted experiments to validate that RADICMPi allowed different protector's structures, like in the example depicted in Figure 4-14. These experiments served to verify the flexibility of the RADIC architecture.\n\nWe used the same experiments to verify if the protectors' structure would influence the performance of the application or the performance of the controller for fault tolerance. Figure 4-14 represents an example of how it is possible to make an arrangement of two chains in a cluster of nine nodes. We used the same strategy to make four distinct structures in a cluster with sixteen nodes: a) two protectors' chains with eight nodes; b) three protectors' chains (two with five nodes and one with six nodes); c) four protectors' chains with four nodes; d) a chain with all nodes.\n\nIn scenarios without failures, we did not perceive any influence of the protectors' structure over the application performance of the RADIC controller performance. Then, using the fault injector, we injected faults individually and simultaneously in the protectors of each chain in order to verify how the fault tolerance mechanism would operate in the different scenarios. In all tests, we respected the limit of faults per chain imposed by Equation 3 and, again, we did not assess any difference between the operations of the systems with different protector structures.\n\nBasing on the test results, we assessed that the protector structure does not cause impact over the performance of the RADIC controller. The only limit that the protector structure causes over the RADIC operation is the maximum number of failures that the system can support.\n\n7.3 Experiments with the checkpoint interval\n\nFrom all parameters of RADIC, the checkpoint interval was, by far, the parameter that has had more influence over the behavior of the system. This great influence of\nthe checkpoint over the system’s behavior is consequence of the interference of the checkpoint over the operation of the parallel application.\n\nIn RADICMPI, such interference comes from three factors: a) a process must stop during a checkpoint; b) a process cannot communicate during a checkpoint and c) a checkpoint increases the network traffic, and interferes on the message latency and on the network throughput.\n\nThe first factor is obvious; a checkpoint is a snapshot of the process state. Therefore, the checkpoint procedure must stop a process in order to take a steady state of it. The process remains stopped until the finish of the checkpoint procedure. The longer the checkpoint procedure takes, the longer the enlargement in the runtime of the process.\n\nThe second factor occurs because of the first one. The process’ state changes when a process communicates. Since a checkpoint is a snapshot of the process’s current state, this state may not change while a checkpoint occurs, i.e., a process may neither receive nor transmit messages while a checkpoint is in progress. Similarly, the checkpoint procedure must retard the beginning of a checkpoint if the process is communicating.\n\nSuch compromise between checkpoints and messages causes a delay in the beginning of the checkpoint procedure if a checkpoint should starts when a process is communicating. Similarly, checkpoints delay message transmissions because of two reasons: a) they retard the process normal execution; b) a process may not receive messages during a checkpoint, therefore any other process that tries to communicate with a “in-checkpoint” process have to wait until the destination concludes its checkpoint.\n\nFinally, the third factor is consequence of the traffic naturally generated by the checkpoint procedure. When an observer takes a checkpoint of its process, it must send this checkpoint throughout the network until its neighbor protector. Therefore, the observers of the RADIC controller for fault tolerance generate a network traffic, which interferes with the messages of the parallel application.\nIn the experiments with the checkpoint interval, we fixed the communication-to-computation ratio and measured the enlargement in the runtime of the application for distinct checkpoint intervals.\n\nFor the tests, we choose the SPMD matrix multiplication program and the master/worker matrix multiplication program with dynamic load balance. We choose these programs because they offered more flexibility to control the communication-to-computation ratio.\n\nIn order to enlarge the execution times, we changed the original algorithms to force that each node multiplied the matrices blocks more than once. This allowed us to take more checkpoints in each experiment.\n\nIn Figure 7-1, we present a summary of some of these tests. The figure represents the execution time (in seconds) for the SPMD matrix multiplication program, obtained for matrices with 3000x3000 double float elements. Each node repeated ten times the multiplication of the matrices’ blocks.\n\nWe used two cluster sizes: nine nodes and sixteen nodes. There are five bars for each cluster in the figure. Each bar corresponds to the execution time using a specific checkpoint interval, measured in seconds. We experiment the system with different checkpoint intervals (240, 300, 360, 420 and 600 seconds) and compared the results with the executions without fault tolerance.\n\nIn this experiment with the SPMD program, the communication-to-computation ratio changed according to the cluster size. In the cluster with nine nodes, each node worked with blocks of 1000x1000 elements, and in the cluster of sixteen nodes, each node worked with blocks of 750x750 elements.\n\nThe lower computational load assigned to each node in the large cluster yielded a lower cost of the fault tolerance in the cluster with sixteen nodes. This is consequence of two factors: a) the checkpoint sizes in the cluster with sixteen nodes were smaller because each process operated with less data; b) the message logs were also smaller because each process had to communicate less data.\nExperiments with RADIC\n\nExecution times for the SPMD matrix multiplication program using RADICMPI\nMatrices of 3000x3000 double float elements (10 loops per block)\n\n<table>\n<thead>\n<tr>\n<th>Number of nodes</th>\n<th>Execution times (seconds)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>9 nodes (3x3 mesh)</td>\n<td>without FT 1278,ckpt 600 s 1351,ckpt 420s 1331,ckpt 360s 1333,ckpt 300s 1388,ckpt 240s 1360</td>\n</tr>\n<tr>\n<td>16 nodes (4x4 mesh)</td>\n<td>without FT 708,ckpt 600 s 728,ckpt 420s 755,ckpt 360s 741,ckpt 300s 730,ckpt 240s 768</td>\n</tr>\n</tbody>\n</table>\n\nFigure 7-1: The minimum structure for a protectors’ chain.\n\nThe combination of these two factors contributed to the different enlargements in the execution times. Using Equation 4, we calculate the time overheads caused by the operation of the fault tolerance mechanism.\n\n\\[\n\\text{Overhead}(\\%) = \\left( \\frac{\\text{Execution time with fault tolerance}}{\\text{Execution time without fault tolerance}} - 1 \\right) \\times 100\\% \\quad 4\n\\]\n\nThe overheads presented in Table 7-1 shows how much the fault tolerance mechanism interferes in the execution time of the application process. This table shows the time overhead calculated with equation 4, as a function of the checkpoint interval, for the experiments represented in Figure 7-1. The checkpoint interval also defined the number of checkpoints taken during the executions, represented in the table together with the overhead information.\n\nWe can see in the table that the maximum time overhead was 8.6%. Furthermore, we see that the overheads are not directly proportional to the checkpoint intervals. For example, in the cluster with 16 nodes, we see that the impact of a single checkpoint is very different depending on the moment in which the checkpoint occurs.\nTable 7-1: Influence of the checkpoints over the execution time.\n\n<table>\n<thead>\n<tr>\n<th>Checkpoint interval</th>\n<th>9 nodes</th>\n<th>16 nodes</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>Time overhead</td>\n<td># checkpoints</td>\n</tr>\n<tr>\n<td>240 s</td>\n<td>6.5%</td>\n<td>5</td>\n</tr>\n<tr>\n<td>300 s</td>\n<td>8.6%</td>\n<td>4</td>\n</tr>\n<tr>\n<td>360 s</td>\n<td>4.3%</td>\n<td>3</td>\n</tr>\n<tr>\n<td>420 s</td>\n<td>4.1%</td>\n<td>3</td>\n</tr>\n<tr>\n<td>600 s</td>\n<td>5.7%</td>\n<td>2</td>\n</tr>\n</tbody>\n</table>\n\nTo analyze this behavior, we used the event log information to assess how much time each checkpoint took. The results confirmed that, as we have explained before, the interaction between checkpoints and the messages modified the communication times between the processes. In practice, the interaction between the checkpoints and the application made that some processes had to spend more time inside an MPI_Recv() function, creating a message pattern different from the original message pattern of the application.\n\n### 7.4 Experiments with faults\n\nIn these tests, our interest was to assess the impact of failures in terms of execution time. The failure's cost is a combination of distinct factors: time elapsed until detecting the fault, time spent to recover failed processes, amount of computation lost because of the failure and impact of the failure on the cluster’s structure.\n\nThe RADIC parameters determine the first three factors. The watchdog/heartbeat cycle defines how long it takes to detect a failure. The recover procedure defines how long it takes to recover failed processes. The instant in which the fault occurs inside the checkpoint interval determines how long a recovered process has to roll back, i.e., how much computation the process must re-execute.\n\nThe last factor, the impact of the failure on the cluster’s structure, strongly depends on the application behavior. A failure causes a reduction in the number of cluster's nodes and creates unbalance in the computational load between the nodes.\nthat has survived after the failure. The impact of such unbalance on the execution time \ndepends on how good the application adapts to the cluster's heterogeneity. \nApplications that naturally balance the computational load among the processes adapt \nbetter to the heterogeneity. Therefore, such applications suffer lower enlargements in \nthe execution time if a failure occurs.\n\nWe have conducted experiments in order to assess the time overhead caused by \nfailures. In these experiments, we defined the instant of the failure in terms of \npercentage of the total application runtime without failures.\n\nWe focused our attention in the impact of failures on the total application \nruntime. We consider that in a system without a fault tolerance mechanism, the \napplication will collapse if a failure occurs in a node. Therefore, the user loses all \nprevious computations and has to re-launch the application again. Furthermore, we \nalso have to consider that a user is not monitoring his/her application during all time it \nis executing, and hence the fault detection phase and the recovery phase are not \ninstantaneous.\n\nUsing such assumptions, we defined that, for a system without fault tolerance, the \ntotal execution time in case of a failure is expressible by Equation 5:\n\n\\[ T_F = T_{\\text{lost}} + T_{\\text{det}} + T_{\\text{re}} + T_{\\text{N-1}} \\]\n\nWhere:\n\n- \\( T_F \\) – Total execution time in case of a single failure\n- \\( T_{\\text{lost}} \\) – Failure time. Indicates the computational time since the \n beginning until the moment when the failure occurs.\n- \\( T_{\\text{det}} \\) – Time required for failure detection\n- \\( T_{\\text{re}} \\) – Time required for application recovery\n- \\( T_{\\text{N-1}} \\) – Total execution time with N-1 nodes\nOur test procedure consisted in measuring the application runtimes in the following scenarios:\n\na) without fault tolerance using \\( N \\) and \\( N-1 \\) nodes;\n\nb) with fault tolerance, with \\( N \\) nodes and different checkpoint intervals, in the absence of failures;\n\nc) with fault tolerance, with \\( N \\) nodes and different checkpoint intervals, in different fault scenarios.\n\nWe calculated the execution time for the application without fault tolerance using Equation 5 and compared the results against the total execution time with fault tolerance. The Table 7-2 presents the results of the experiments in the cluster with 15 nodes, for the matrix multiplication program with 3000x3000 double float elements, using blocks with 1000x1000 float elements.\n\nAt the bottom of the Table 7-2, we inform the execution times for the cluster with 15 nodes in the absence of failures. The “calculated w/o FT” column corresponds to the theoretical execution times according to Equation 5 with \\( T_{14} \\) equals to 1207 seconds and considering \\( T_{det} \\) and \\( T_{re} \\) equal to zero.\n\nWe unconsidered those times because we could not define how long the user would take to detect the failure and to re-start his/her program. Therefore, we assumed the best possible scenario, i.e., automatic instantaneous fault detection and program re-start. Such assumption approximates the behavior of the system without fault tolerance from the system with fault tolerance.\n\n<table>\n<thead>\n<tr>\n<th>Fault time</th>\n<th>calculated w/o FT ( (T_{14}=1207 \\text{ s}) )</th>\n<th>ckpt 600 s</th>\n<th>ckpt 300 s</th>\n<th>ckpt 200 s</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>fault at 250 s</td>\n<td>1457</td>\n<td>n/a</td>\n<td>n/a</td>\n<td>1082</td>\n</tr>\n<tr>\n<td>fault at 350 s</td>\n<td>1557</td>\n<td>n/a</td>\n<td>962</td>\n<td>1079</td>\n</tr>\n<tr>\n<td>fault at 650 s</td>\n<td>1857</td>\n<td>1093</td>\n<td>1089</td>\n<td>1099</td>\n</tr>\n</tbody>\n</table>\n\nObs.: n/a = not applicable\n\n<table>\n<thead>\n<tr>\n<th>Execution time (in seconds) using 15 nodes in the absence of failures</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>w/o FT</td>\n</tr>\n<tr>\n<td>--------</td>\n</tr>\n<tr>\n<td>853</td>\n</tr>\n</tbody>\n</table>\nFigure 7-2 depicts the impact of the failures according to the time in which the failure occur. The bars in the figure represent the execution time in seconds, taller bars indicates larger runtimes.\n\nThe advantage of using the RADIC architecture is evident when we compare the effects of failures in the system with and without fault tolerance in all cases. The bars in the columns “no fault” represent the execution times in the absence of failures. We see that the maximum execution time with fault tolerance (917 seconds for a checkpoint interval of 200s) was 7.5% greater of the execution time without fault tolerance (853 seconds). Larger checkpoint intervals generated a lower impact over the execution time in the absence of failures.\n\nHowever, when failures occurred, the advantage of the fault-tolerant architecture becomes clear. The execution times using RADIC were always inferior to the execution times without fault tolerance. We can see that the best benefits of RADIC architecture appeared when the failure occurs near the end of the application. This occurs because, when the system operates without fault tolerance, if the program fails it wastes all computation done and it must restart since the begging.\n\n\n\n**Figure 7-2: Impact of faults over the execution time in the M/W matrix multiplication program using dynamic load balancing (1000x1000 elements/block)**\nWe repeated the same tests now using blocks of 600x600 elements in order to experiment the system with a different computation-to-communication ratio. Table 7-3 represents the execution times (in seconds) assessed in this experiment. The new communication-to-computation ratio has created a different application behavior because now the checkpoints are lower and the number of message logs increased because there are more messages between processes.\n\n<table>\n<thead>\n<tr>\n<th>Fault time</th>\n<th>calculated w/o FT ($T_{cal}=888$ s)</th>\n<th>ckpt 600 s</th>\n<th>ckpt 300 s</th>\n<th>ckpt 200 s</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>fault at 250 s</td>\n<td>1138</td>\n<td>n/a</td>\n<td>n/a</td>\n<td>970</td>\n</tr>\n<tr>\n<td>fault at 350 s</td>\n<td>1238</td>\n<td>n/a</td>\n<td>957</td>\n<td>928</td>\n</tr>\n<tr>\n<td>fault at 650 s</td>\n<td>1538</td>\n<td>931</td>\n<td>954</td>\n<td>924</td>\n</tr>\n</tbody>\n</table>\n\nObs.: n/a = not applicable\n\nExecution time (in seconds) using 15 nodes in the absence of failures\n\n<table>\n<thead>\n<tr>\n<th>Fault time</th>\n<th>ckpt 600 s</th>\n<th>ckpt 300 s</th>\n<th>ckpt 200 s</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>fault at 250 s</td>\n<td>812</td>\n<td>855</td>\n<td>853</td>\n</tr>\n<tr>\n<td>fault at 350 s</td>\n<td>862</td>\n<td>866</td>\n<td>866</td>\n</tr>\n<tr>\n<td>fault at 650 s</td>\n<td>862</td>\n<td>866</td>\n<td>866</td>\n</tr>\n</tbody>\n</table>\n\nFigure 7-3 compares the total execution times for the experiment. The bars in the columns “no fault” represent the execution times in the absence of failures. The maximum execution time with the fault tolerance (879 seconds for a checkpoint interval of 200 seconds) was 8.3% greater of the execution time without fault tolerance (812 seconds).\n\nComparing the results obtained for the two experiments with the matrix multiplication using dynamic load balance algorithm, we notice that, when the blocks are smaller, the overheads caused by faults are a little greater than when the blocks are larger. The reason for this is the increment in the number of messages during the application execution.\n\nWhen we increased the number of messages two symptoms may occur. First, the cost of message log increased. Second, the influence of the checkpoints over the messages increased. The first factor is obvious, more messages generate more message logs and this creates more interference in the application behavior. The second factor is consequence of we have explained previously in this chapter.\nExperiments with RADIC\n\nIn this chapter, we evaluated the design parameters of the RADIC fault tolerance architecture. We presented several experiments that allowed us to understand better the practical implications of each parameter over the application performance.\n\nBased on these experiments, we concluded that the watchdog/heartbeat mechanism had an imperceptible influence over the application execution time. We also concluded that the protector’s structure did not interfere in the runtime of the application. Nevertheless, we verified that the number of protectors in a chain bounds the number of faults that the system may suffer without crash.\n\nFinally, we assessed the influence of the checkpoint interval together with the application communication-to-computation ratio in different fault scenarios. We concluded that these parameters are the critical factors that determine the impact of the RADIC controller for fault tolerance over the application runtime.\nChapter 8\n\nConclusions\n\nThe current trend for the parallel computers indicates that the size and the complexity of these machines will continue to increase in the near future. In this scenario, users and system administrators will need tools and mechanisms that help them to manage failures transparently, efficiently and with as little influence as possible on the creation and execution of the parallel application.\n\nThese large parallel computers require new fault-tolerant architectures that can manage faults transparently and with little interference over the system performance. Adaptability to the system’s features (like the system’s scalability) and flexibility are also key features that such fault-tolerant architectures must simultaneously attend.\n\nThis thesis describes RADIC (Redundant Array of Distributed Independent Fault Tolerance Controllers), the fault tolerance architecture capable to face the current challenges of fault tolerance for the modern parallel computers. RADIC creates a fully distributed fault tolerance controller based on the collaboration of two types of processes: observers and protectors. Because protectors and observers share the same resources reserved to the parallel application processes, such controller automatically performs all activities required to implement fault tolerance in a parallel computer, without needing dedicated or fully stable elements.\n\nBy putting one protector in each node reserved for the parallel application, RADIC creates a protection chain in which a protector monitors at least one other protector in its neighborhood. Therefore, the system has a fully decentralized fault detector in which a node can detect failures in a neighbor node. The protector’s chain is flexible in order to allow that several protectors monitor a node. Therefore, a survivor protector can always detect and manage simultaneous failures that could affect two or more neighbor nodes. The flexibility of the protector’s chain makes\npossible that the RADIC controller easily adapts to different parallel computer structures.\n\nThe observers monitor the processes of the parallel application and communicate with a protector in a neighbor node, in order to save the information required by the rollback-recovery protocol. Since there is one observer attached to each application process, this structure creates a decentralized storage in which there is no central element involved in the operation of the fault-tolerance mechanism.\n\nThe decentralized operation of our architecture is one of its strongest features. Because the fault tolerance controller does not have any central element, its operation does not compromise the scalability of the parallel application. Although the scalability suffers the interference of the rollback-recovery protocol, because of the overheads caused by checkpoints and message logs, RADIC minimizes such interference using a fully distributed structure. Our tests showed that increasing the number of nodes in the cluster did not influence the behavior of the fault tolerance mechanism.\n\nThe implementation of RADIC in a system requires no modification in the parallel application. The mechanism operates as a layer between the message-passing mechanism and the parallel computer’s structure. The parallel application does not have to concern about the operation of the fault tolerance mechanism; however, thanks to the flexibility of the architecture, it is possible to adjust the parameters of the fault-tolerant architecture in order to attend to particular application requirements.\n\nThe principles and the functional model of the RADIC architecture appeared for the first time in ParCo 2005 conference [Duarte, et al., 2005]. For the experiments, we developed an implementation based on the MPI standard (RADICMPI).\n\nIn the tests, we chose three different parallel applications and compiled their source codes with a legacy MPI implementation (MPICH-1.2.7) and with RADICMPI. The applications generated the same results in all cases (even in the presence of failures) confirming the transparency of the architecture. The test bed was a cluster built with common off-the-shelf IBM-PC machines with no special fault tolerance feature.\nAfter prove that the functionality of the architecture, we redesign RADIC to operate as a layer between the message-passing application and the parallel computer structure. In the 13th EuroPVM/MPI, we demonstrated the results of the new structure [Duarte, et al., 2006b].\n\nThanks to the new structure of observers and protectors, we managed to reduce the overheads caused by the operation of the fault tolerance mechanism. In the 2006 IEEE International Conference on Cluster Computing, we presented the performance results of our new RADICMPI implementation [Duarte, et al., 2006a].\n\nBecause the RADIC controller works as a distributed application, sharing the computer's resources with the parallel application processes, we had to design a test procedure in order to assure that the fault tolerance controller worked correctly in all possible fault scenarios. To perform the tests, we implemented a fault injection mechanism in RADICMPI, which created all fault scenarios required to experiment the system. We explained the test procedure and the failure injection mechanism in the 15th Euromicro Conference on Parallel, Distributed and Network-based Processing [Duarte, et al., 2007].\n\nThe results obtained with different types of parallel applications using RADICMPI shown that that the interference of the fault tolerance operation have not imposed a strong overhead over the execution time in failure free executions. We argue that this is because of the RADIC distributed mechanism, which allows that fault tolerance procedures work concurrently with the parallel application. Nevertheless, it has become clear that the message pattern, and the communication-to-computation ratio, of the parallel application strongly interfere on the overhead caused by the fault tolerance operation.\n\nIn the presence of failures, the overhead is strongly dependent of how the parallel application suffers with the unbalancing caused by the reduction in the parallel computer's structure. Failures have low influence over the total execution time of parallel applications that have a dynamic computational load balancing. Conversely, parallel applications in which the load balance is static greatly suffer the influence of failures.\nWe confirmed this behavior by comparing the matrix-multiplication algorithms in executions with failures. In our tests, the algorithms that used static load balancing (Master/Work with static balancing and Canon) suffered a strong enlargement in the execution time after a failure. Such enlargement occurred because a process recovers in a node that already has another application processes. Because the load balance is rigid, nodes that received recovered processes become slower and the total application execution time enlarged.\n\nOn the other hand, failures produced a low impact on the execution time of the master/worker program using dynamic balancing. This algorithm has a natural mechanism for balancing the computational load between the workers, because the master automatically distributes more workload to faster workers. Therefore, when a node becomes slower because it has to execute its original process together with a recovered process, the master will send less work for the processes that are in this node, balancing the workload between the faster nodes.\n\n8.1 Future Works\n\nThe RADIC architecture relies on a simple and powerful idea: the complete distribution of the fault tolerance mechanism throughout the nodes of the parallel computer. In this thesis, we explained the architecture and presented a RADIC prototype, namely RADICMPI, which served to test the concepts of the architecture in practice.\n\nThere are still many open questions. Some of them relate to theoretical aspects of RADIC, while others refer to the practical issues about RADICMPI. We address such open questions in the next paragraphs.\n\n8.1.1 The future of the RADIC architecture\n\nA major question about the RADIC architecture is how it will operate in large parallel computers. The elements of the fault tolerance controller interact without any global synchronization and are fully distributed throughout the nodes of the parallel computer. The decentralized operation of RADIC a priori does not compromise the\nscalability of the system. So far, our tests indicated that the number of nodes of the computer does not affect the operation of the fault tolerance controller. However, it is necessary to keep researching about how protectors and observers will operate in larger and complex structures, like hypercubes or crossbar topologies.\n\nWe have to develop some strategy to guide the protection mapping for these complex architectures. Because the RADIC controller is a parallel application, the distribution of the protectors must take into consideration the parallel computer structure. The network distance between two neighbor protectors must be as short as possible in order to minimize the effects of the network latency over the heartbeat/watchdog mechanism, and to reduce the traffic of heartbeats throughout the network. For example, processes that have large states or that receive many messages must be placed as near as possible from their protectors in order to reduce the interference of the traffic of checkpoints and message logs over the network.\n\nIn order to study the operation of RADIC in such large and complex systems, we have to develop a simulator to help us in the study of the architecture in such systems. The simulator will is an indispensable tool for studying the interaction between RADIC and the system and for studying the influence of the fault tolerance parameters over the application performance.\n\nIn order to build the simulator, we are developing an analytical model that describes the RADIC operation in terms of its functional parameters. Such model will relate the parameters of the three major elements of the system: the parallel computer (fault distribution, latency and the bandwidth networks, and disk throughputs) the parallel application (computation-to-communication ratio, message sizes and state sizes,) and RADIC (checkpoint intervals, heartbeat frequency,) in order to describe the impact over the system (time overheads, resources consumed).\n\nOne important question is how to adjust the checkpoint in order to reduce the overhead in failure free executions without compromise the fault penalty. The literature about fault tolerance contains several works dedicated to the optimization of the checkpoint interval and we have to verify how to apply this knowledge to RADIC.\nAnother interesting question is how RADIC would operate using a different rollback-recovery protocol. In practice, any observer-protector or protector-protector relationship may exist in order to implement another rollback-recovery protocol. We created RADIC using the receiver-based pessimistic message log protocol because this is the only protocol in which the recovery process is local. Therefore, this protocol does not compromise the scalability, one of the major features of the RADIC architecture. However, we want to investigate how RADIC will function with protocols like causal protocols or sender-based protocols, in order to establish the advantage and disadvantage of these protocols in our scheme.\n\nWe also need to generalize the concept of failures in RADIC by expanding the activities of protectors and observers in order to enlarge the spectrum of failures that the controller may detect. Currently, the fault tolerance controller bases on communication failures in order to detect faults. It assumes that the only way to establish that an element has failed is when such element stops to communicate. Furthermore, if an element has failed, it is “detached” of the system.\n\nTo generalize the fault detection, protectors and observers need to assume new activities as, for example, to create a protocol that manages transient failures. Such protocol could establish that a node is suspicious before of establishing that the node is faulty. Therefore, if the node begins to operate again, the system may reuse it to reestablish the original load balance of the application or as a spare node to recovery the processes that can fail in the future.\n\n8.1.2 The future of RADICMPI\n\nRADICMPI contains a small subset of MPI-1 communication’s functions. The development of a full fault-tolerant MPI implementation demands a huge effort that requires a large amount of resources. Therefore, we have started negotiations with the developers of MPICH, namely the Laboratory for Scalable Parallel System Software of the Argonne National Laboratory in Chicago-USA, in order to integrate the RADIC concepts in the MPICH implementation.\nMeanwhile, we continue the development of RADICMPI. Currently, we are working in two major lines. First, we are including more communication functions in order to test a larger number of parallel applications. The first set of functions are the nonblocking communication functions, which demands that the log protocol consider a new group of determinants created by the MPI_Test() function. At the future, we intend to include the buffered, synchronous and ready modes into the MPI_Send() and MPI_Recv() functions; and to implement the collective communication functions.\n\nThe second line is the utilization of spares in order to mitigate the fault penalty caused by the reduction in the parallel computer’s structure after a failure. We know that the cost of a fault depends on how long the RADIC controller takes to detect the fault, how long it takes to recover the process and how much of computation was lost. This cost relates to the parameters of the fault tolerance controller, namely, the heartbeat cycle and the checkpoint interval.\n\nAdditionally, the load unbalance caused by the redistribution of the recovered processes is another factor that determines the impact of a failure over the execution runtime. The effects of this factor strongly relates to how the parallel application will react to the new structure of the parallel computer.\n\nParallel algorithms with dynamic load balance will better adapt to changes in the cluster structure, mitigating the cost of a fault. However, these algorithms typically generate more messages between the processes than their equivalents using static load balance. This behavior increases the impact of the message log and the checkpoint interval over the application execution.\n\nTo avoid the impact of the load unbalancing, we have to include spare nodes in the system. Therefore, when a node fails, the process in the faulty node will recover in a spare node. In order to face such challenge, we are currently improving RADICMPI to support spare nodes that can recover faulty processes. We have presented the idea of using spares nodes at CACIC’2006 congress [Santos, et al., 2006]. The first results were promising and we believe that this strategy is crucial to satisfy the requirements of time-critical applications. Therefore, we kept the development of the\nidea and obtained new results that are going to appear in the ParCo2007 congress [Santos, et al., 2007].\n\nAdditionally, in the near future we can make two improvements in RADICMPI for mitigating the impact of checkpoints and message logs over the application runtime: to implement a quasi-synchronous checkpoint protocol based on communication failures caused by checkpoints.\n\nIn a quasi-synchronous protocol, whenever a sender process gets a communication error with a receiver process, the sender would evaluate if the error occurred because the receiver was in a checkpoint procedure. If the receiver is making a checkpoint, then the sender may decide to make a checkpoint also, instead of just waiting for the receiver is available again. Therefore, the sender uses the time that it would be waiting for the receiver to take its own checkpoint, reducing the impact of the checkpoints over the execution.\n\nAnother improvement is to use multicast communications in order to reduce the message log cost. In such scheme, the sender observer should simultaneously send the message to the receiver observer and to the protector of the receiver observer, reducing the time of the log procedure. We believe that such multicast communications will be decisive in order to reduce the cost of fault tolerance for the MPI collective communications.\n\nThe RADIC architecture debuted in this thesis and has a large future ahead. As we have shown in the last paragraphs, we are far from complete exploring all theoretical and practical aspects of the architecture. So far, RADIC has demonstrated its great potential as a fault-tolerant architecture for message-passing systems. Nevertheless, we are aware that many aspects need more investigation and that additional works must complement the description we have made in this thesis. In the future, our goal is to establish RADIC as a general fault-tolerant platform for the current and future message-passing implementations. We believe that this work has contributed to achieve this goal.\nReferences\n\n\n[Daly, 2006] - Daly, J. T. *A higher order estimate of the optimum checkpoint interval for restart dumps.* Future Generation Computer Systems, 22(3):303-312 (February 2006)\n\n\n"}}},{"rowIdx":287,"cells":{"id":{"kind":"string","value":"7f8e71531c2b11199ed549f1b8756bcf7a6a6e28"},"text":{"kind":"string","value":"MySQL Connector/ODBC Release Notes\n\nAbstract\n\nThis document contains release notes for the changes in each release of MySQL Connector/ODBC.\n\nFor additional Connector/ODBC documentation, see MySQL Connector/ODBC Developer Guide.\n\nUpdates to these notes occur as new product features are added, so that everybody can follow the development process. If a recent version is listed here that you cannot find on the download page (https://dev.mysql.com/downloads/), the version has not yet been released.\n\nThe documentation included in source and binary distributions may not be fully up to date with respect to release note entries because integration of the documentation occurs at release build time. For the most up-to-date release notes, please refer to the online documentation instead.\n\nFor legal information, see the Legal Notices.\n\nFor help with using MySQL, please visit the MySQL Forums, where you can discuss your issues with other MySQL users.\n\nDocument generated on: 2022-08-10 (revision: 25176)\n\nTable of Contents\n\nPreface and Legal Notices .................................................................................................................. 3\nChanges in MySQL Connector/ODBC Version 8.0 ............................................................................ 4\nChanges in MySQL Connector/ODBC 8.0.31 (Not yet released, General Availability) .......... 4\nChanges in MySQL Connector/ODBC 8.0.30 (2022-07-26, General Availability) .......... 4\nChanges in MySQL Connector/ODBC 8.0.29 (2022-04-26, General Availability) .......... 5\nChanges in MySQL Connector/ODBC 8.0.28 (2022-01-18, General Availability) .......... 6\nChanges in MySQL Connector/ODBC 8.0.27 (2021-10-19, General Availability) .......... 7\nChanges in MySQL Connector/ODBC 8.0.26 (2021-07-20, General Availability) .......... 8\nChanges in MySQL Connector/ODBC 8.0.25 (2021-05-11, General Availability) .......... 9\nChanges in MySQL Connector/ODBC 8.0.24 (2021-04-20, General Availability) .......... 9\nChanges in MySQL Connector/ODBC 8.0.23 (2021-01-18, General Availability) ..........10\nChanges in MySQL Connector/ODBC 8.0.22 (2020-10-19, General Availability) ..........11\nChanges in MySQL Connector/ODBC 8.0.21 (2020-07-13, General Availability) ..........12\nChanges in MySQL Connector/ODBC 8.0.20 (2020-04-27, General Availability) ..........12\nChanges in MySQL Connector/ODBC 8.0.19 (2020-01-13, General Availability) ..........12\nChanges in MySQL Connector/ODBC 8.0.18 (2019-10-14, General Availability) ..........13\nChanges in MySQL Connector/ODBC 8.0.17 (2019-07-22, General Availability) ..........13\nChanges in MySQL Connector/ODBC 8.0.16 (2019-04-25, General Availability) ..........14\nChanges in MySQL Connector/ODBC 8.0.15 (2019-02-01, General Availability) ..........14\nChanges in MySQL Connector/ODBC 8.0.14 (2019-01-21, General Availability) ..........14\nChanges in MySQL Connector/ODBC 8.0.13 (2018-10-22, General Availability) ..........15\nChanges in MySQL Connector/ODBC 8.0.12 (2018-07-27, General Availability) ..........15\nChanges in MySQL Connector/ODBC 8.0.11 (2018-04-19, General Availability) ..........16\nChanges in MySQL Connector/ODBC Version 5.3 ........................................................................16\nChanges in MySQL Connector/ODBC 5.3.14 (2019-10-30, General Availability) ..........16\nChanges in MySQL Connector/ODBC 5.3.13 (2019-04-29, General Availability) ..........16\nChanges in MySQL Connector/ODBC 5.3.12 (2019-01-28, General Availability) ..........17\nChanges in MySQL Connector/ODBC 5.3.11 (2018-07-30, General Availability) ..........17\nChanges in MySQL Connector/ODBC 5.3.10 (2018-01-30, General Availability) ..........17\nChanges in MySQL Connector/ODBC 5.3.9 (2017-07-24, General Availability) ..........18\nChanges in MySQL Connector/ODBC 5.3.8 (2017-04-28, General Availability) ..........19\nChanges in MySQL Connector/ODBC 5.3.7 (2016-12-13, General Availability) ..........19\nChanges in MySQL Connector/ODBC 5.3.6 (2016-03-17, General Availability) ..........20\nChanges in MySQL Connector/ODBC 5.3.5 (2015-5-25, General Availability) ..........21\nChanges in MySQL Connector/ODBC Version 3.51 (2014-07-18, General Availability) .......... 21\nChanges in MySQL Connector/ODBC Version 3.5.3 (2014-04-16, General Availability) ........... 22\nChanges in MySQL Connector/ODBC Version 3.5.2 (2014-04-08, General Availability) .......... 22\nChanges in MySQL Connector/ODBC Version 3.5.1 (2013-11-27, Beta) ........................... 24\nChanges in MySQL Connector/ODBC Version 3.5.0 (2013-10-24, Alpha) ............................ 25\nChanges in MySQL Connector/ODBC Version 5.2 .......................................................... 26\nChanges in MySQL Connector/ODBC Version 5.2.8 (2015-05-06, General Availability) ......... 26\nChanges in MySQL Connector/ODBC Version 5.2.7 (2014-05-13, General Availability) .......... 27\nChanges in MySQL Connector/ODBC Version 5.2.6 (2013-10-09, General Availability) .......... 28\nChanges in MySQL Connector/ODBC Version 5.2.5 (2013-05-02, General Availability) .......... 29\nChanges in MySQL Connector/ODBC Version 5.2.4 (2013-02-05, General Availability) .......... 30\nChanges in MySQL Connector/ODBC Version 5.2.3 (2013-01-04, General Availability) .......... 31\nChanges in MySQL Connector/ODBC Version 5.2.2 (2012-09-20, General Availability) .......... 31\nChanges in MySQL Connector/ODBC Version 5.2.1 (2012-08-10, Beta) ............................ 32\nChanges in MySQL Connector/ODBC Version 5.1 .......................................................... 33\nChanges in MySQL Connector/ODBC Version 5.1.14 (Not yet released) ............................. 33\nChanges in MySQL Connector/ODBC Version 5.1.13 (2013-10-16) .................................... 33\nChanges in MySQL Connector/ODBC Version 5.1.12 (2013-02-05) .................................... 34\nChanges in MySQL Connector/ODBC Version 5.1.11 (2012-04-30) .................................... 35\nChanges in MySQL Connector/ODBC Version 5.1.10 (2012-02-02) .................................... 36\nChanges in MySQL Connector/ODBC Version 5.1.9 (2011-10-06) ..................................... 36\nChanges in MySQL Connector/ODBC Version 5.1.8 (2010-11-07) ..................................... 37\nChanges in MySQL Connector/ODBC Version 5.1.7 (2010-08-24) ..................................... 38\nChanges in MySQL Connector/ODBC Version 5.1.6 (2009-11-09) ..................................... 39\nChanges in MySQL Connector/ODBC Version 5.1.5 (2008-08-18) ..................................... 42\nChanges in MySQL Connector/ODBC Version 5.1.4 (2008-04-15) ..................................... 42\nChanges in MySQL Connector/ODBC Version 5.1.3 (2008-03-26) ..................................... 42\nChanges in MySQL Connector/ODBC Version 5.1.2 (2008-02-13, Beta) ............................ 43\nChanges in MySQL Connector/ODBC Version 5.1.1 (2007-12-13, Beta) ............................ 45\nChanges in MySQL Connector/ODBC Version 5.1.0 (2007-09-10, Beta) ............................ 46\nChanges in MySQL Connector/ODBC Version 5.0 .......................................................... 47\nChanges in MySQL Connector/ODBC Version 5.0.12 (Not released) ................................. 47\nChanges in MySQL Connector/ODBC Version 5.0.11 (2007-01-31, Beta) ......................... 47\nChanges in MySQL Connector/ODBC Version 5.0.10 (2006-12-14, Beta) ......................... 48\nChanges in MySQL Connector/ODBC Version 5.0.9 (2006-11-22, Beta) ......................... 48\nChanges in MySQL Connector/ODBC Version 5.0.8 (2006-11-17, Beta) ......................... 49\nChanges in MySQL Connector/ODBC Version 5.0.7 (2006-11-08, Beta) ......................... 49\nChanges in MySQL Connector/ODBC Version 5.0.6 (2006-11-03, Beta) ......................... 50\nChanges in MySQL Connector/ODBC Version 5.0.5 (2006-10-17, Beta) ......................... 50\nChanges in MySQL Connector/ODBC Version 5.0.3 (2006-06-20) ................................... 51\nChanges in Connector/ODBC 5.0.2 (Never released) .................................................. 51\nChanges in MySQL Connector/ODBC Version 5.0.1 (2006-06-05) ............................... 51\nChanges in MySQL Connector/ODBC Version 3.5.1 ..................................................... 53\nChanges in MySQL Connector/ODBC 3.5.1.30 (2012-02-02) ........................................ 53\nChanges in MySQL Connector/ODBC 3.5.1.29 (2011-10-04) ........................................ 53\nChanges in MySQL Connector/ODBC 3.5.1.28 (2011-02-09) ........................................ 54\nChanges in MySQL Connector/ODBC 3.5.1.27 (2008-11-20) ........................................ 54\nChanges in MySQL Connector/ODBC 3.5.1.26 (2008-07-07) ........................................ 55\nChanges in MySQL Connector/ODBC 3.5.1.25 (2008-04-11) ........................................ 55\nChanges in MySQL Connector/ODBC 3.5.1.24 (2008-03-14) ........................................ 55\nChanges in MySQL Connector/ODBC 3.5.1.23 (2008-01-09) ........................................ 56\nChanges in MySQL Connector/ODBC 3.5.1.22 (2007-11-13) ........................................ 57\nChanges in MySQL Connector/ODBC 3.5.1.21 (2007-10-08) ........................................ 57\nChanges in MySQL Connector/ODBC 3.5.1.20 (2007-09-10) ........................................ 58\nChanges in MySQL Connector/ODBC 3.5.1.19 (2007-08-10) ........................................ 58\nChanges in MySQL Connector/ODBC 3.5.1.18 (2007-08-08) ........................................ 58\nChanges in MySQL Connector/ODBC 3.5.1.17 (2007-07-14) ........................................ 60\nChanges in MySQL Connector/ODBC 3.5.1.16 (2007-06-14) ........................................ 61\nPreface and Legal Notices\n\nThis document contains release notes for the changes in each release of MySQL Connector/ODBC.\n\nLegal Notices\n\nCopyright © 1997, 2022, Oracle and/or its affiliates.\n\nThis software and related documentation are provided under a license agreement containing restrictions on use and disclosure and are protected by intellectual property laws. Except as expressly permitted in your license agreement or allowed by law, you may not use, copy, reproduce, translate, broadcast, modify, license, transmit, distribute, exhibit, perform, publish, or display any part, in any form, or by any means. Reverse engineering, disassembly, or decompilation of this software, unless required by law for interoperability, is prohibited.\n\nThe information contained herein is subject to change without notice and is not warranted to be error-free. If you find any errors, please report them to us in writing.\n\nIf this is software or related documentation that is delivered to the U.S. Government or anyone licensing it on behalf of the U.S. Government, then the following notice is applicable:\n\nU.S. GOVERNMENT END USERS: Oracle programs (including any operating system, integrated software, any programs embedded, installed or activated on delivered hardware, and modifications of such programs) and Oracle computer documentation or other Oracle data delivered to or accessed by U.S. Government end users are \"commercial computer software\" or \"commercial computer software documentation\" pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations. As such, the use, reproduction, duplication, release, display, disclosure, modification, preparation of derivative works, and/or adaptation of i) Oracle programs (including any operating system, integrated software, any programs embedded, installed or activated on delivered hardware, and modifications of such programs), ii) Oracle computer documentation and/or iii) other Oracle data, is subject to the rights and limitations specified in the license contained in the applicable contract. The terms governing the U.S. Government's use of Oracle cloud services are defined by the applicable contract for such services. No other rights are granted to the U.S. Government.\n\nThis software or hardware is developed for general use in a variety of information management applications. It is not developed or intended for use in any inherently dangerous applications, including applications that may create a risk of personal injury. If you use this software or hardware in dangerous applications, then you shall be responsible to take all appropriate fail-safe, backup, redundancy, and other measures to ensure its safe use. Oracle Corporation and its affiliates disclaim any liability for any damages caused by use of this software or hardware in dangerous applications.\n\nOracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners.\n\nIntel and Intel Inside are trademarks or registered trademarks of Intel Corporation. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. AMD, Epyc, and the AMD logo are trademarks or registered trademarks of Advanced Micro Devices. UNIX is a registered trademark of The Open Group.\n\nThis software or hardware and documentation may provide access to or information about content, products, and services from third parties. Oracle Corporation and its affiliates are not responsible for and expressly disclaim all warranties of any kind with respect to third-party content, products,\nand services unless otherwise set forth in an applicable agreement between you and Oracle. Oracle Corporation and its affiliates will not be responsible for any loss, costs, or damages incurred due to your access to or use of third-party content, products, or services, except as set forth in an applicable agreement between you and Oracle.\n\nThis documentation is NOT distributed under a GPL license. Use of this documentation is subject to the following terms:\n\nYou may create a printed copy of this documentation solely for your own personal use. Conversion to other formats is allowed as long as the actual content is not altered or edited in any way. You shall not publish or distribute this documentation in any form or on any media, except if you distribute the documentation in a manner similar to how Oracle disseminates it (that is, electronically for download on a Web site with the software) or on a CD-ROM or similar medium, provided however that the documentation is disseminated together with the software on the same medium. Any other use, such as any dissemination of printed copies or use of this documentation, in whole or in part, in another publication, requires the prior written consent from an authorized representative of Oracle. Oracle and/or its affiliates reserve any and all rights to this documentation not expressly granted above.\n\nDocumentation Accessibility\n\nFor information about Oracle's commitment to accessibility, visit the Oracle Accessibility Program website at https://www.oracle.com/corporate/accessibility/.\n\nAccess to Oracle Support for Accessibility\n\nOracle customers that have purchased support have access to electronic support through My Oracle Support. For information, visit https://www.oracle.com/corporate/accessibility/learning-support.html#support-tab.\n\nChanges in MySQL Connector/ODBC Version 8.0\n\nChanges in MySQL Connector/ODBC 8.0.31 (Not yet released, General Availability)\n\nVersion 8.0.31 has no release notes, or they have not been published because the product version has not been released.\n\nChanges in MySQL Connector/ODBC 8.0.30 (2022-07-26, General Availability)\n\n- Authentication Notes\n- Character Set Support\n- Compilation Notes\n- Functionality Added or Changed\n- Bugs Fixed\n\nAuthentication Notes\n\n- Password parameters escaped with curly braces did not escape right curly braces in the password value. (Bug #106631, Bug #33986051)\n\n- Added callback support to the FIDO Pluggable Authentication mechanism. Use by defining a constant, such as CB_FIDO_GLOBAL to register a global callback function or CB_FIDO_CONNECTION if it's connection-specific. These are used by SQLSetConnectAttr().\nsuch as SQLSetConnectAttr(hdbc, CB_FIDO_GLOBAL, &my_user_callback, SQL_IS_POINTER);. For additional usage details, see Connector/ODBC FIDO Information.\n\nCharacter Set Support\n\n- Added support for the new language-specific utf8mb4 collations added in MySQL Server 8.0.30. (Bug #34109678)\n \n References: See also: Bug #31885256.\n\n- The driver's default character set changed to utf8mb4. Previously it defaulted to utf8, which is an alias to the deprecated utf8mb3. Using utf8mb3 could cause problems, like incorrectly inserting and selecting emojis. (Bug #107698, Bug #34031488, Bug #34350980)\n\nCompilation Notes\n\n- Improved the RPM/DEB/MSI packages. For RPM/DEB: now either GTK2 or GTK3 are prerequisites (previously it required both), and the -setup package is now set to recommended. For Windows: stopped importing libraries (such as myodbc8a.lib) and only include DLLs, and stopped including PDB debug files. Also improved BUNDLE_DEPENDENCIES and MAINTAINER_MODE CMake options to check if the required bundled plugins and 3rd party libraries are present.\n\nFunctionality Added or Changed\n\n- Added the tls-versions connection option to define the allowed TLS protocol versions.\n\n ```plaintext\ntls-versions\n```\n\n accepts TLSv1.2 and/or TLSv1.3. Other values generate an error. Example usage: `tls-versions=TLSv1.2,TLSv1.3`. The value is set by libmysqldclient if not set, and has no effect with `ssl-mode=DISABLED`. The option overrides (disables) the related NO_TLS_X_Y Connector/ODBC connection options, such as NO_TLS_1_2.\n\n Related, TLSv1 and TLSv1.1 support was removed from MySQL Server 8.0.28.\n\nBugs Fixed\n\n- The SQL_C_DOUBLE type could return as an inaccurate result with NO_CACHE enabled. (Bug #107307, Bug #34180568)\n\n- Fixed memory leak caused by ODBC data source reconnects; now mysql_library_end() is called upon the DLL_PROCESS_DETCH event.\n\n The workaround is to reuse ENV for each new connection. (Bug #106886, Bug #34030930)\n\n- SQLCancel() was not thread safe; it and other ODBC API functions are now thread safe. (Bug #91951, Bug #105606, Bug #33884811)\n\nChanges in MySQL Connector/ODBC 8.0.29 (2022-04-26, General Availability)\n\n- Security Notes\n\n- Functionality Added or Changed\n\n- Bugs Fixed\n\nSecurity Notes\n\n- For platforms on which Connector/ODBC utilizes MySQL Server's bundled OpenSSL library (MacOS, Windows, and GenLinux), MySQL Server's linked OpenSSL library was updated to version 1.1.1n. Issues fixed in the new OpenSSL version are described at https://www.openssl.org/news/cl111.txt and https://www.openssl.org/news/vulnerabilities.html. (Bug #33987635)\nFunctionality Added or Changed\n\n- Added the following TLS/SSL option aliases to align with other MySQL connectors: ssl-mode (SSLMODE), ssl-ca (SSLCA), ssl-capath (SSLCAPATH), ssl-cert (SSLCERT), ssl-cipher (SSL_CIPHER), and ssl-key (SSLKEY). The ODBC driver, GUI, and myodbc-installer use these new aliases by default instead of the old option names. For example, setting SSL Key in the GUI now saves it as ssl-key instead of SSLKEY.\n\n- Added FIDO Pluggable Authentication support, an authentication mechanism added in MySQL Enterprise Edition 8.0.27. For additional details, see Authentication Options.\n\nBugs Fixed\n\n- Extended SQLGetTypeInfo() to return results for Unicode wide character type IDs, such as SQL_WCHAR, when before only their corresponding ANSI character type IDs such as SQL_CHAR returned results. (Bug #33772516)\n\n- On Windows, installing the driver to a custom location made setting PLUGIN_DIR required to find bundled plugins. Now the directory location is used to determine the plugin directory unless PLUGIN_DIR is specified. (Bug #33720924)\n\n- The ODBC driver would unexpectedly halt when connecting to accounts that required client-side authentication plugins if those plugins depended on 3rd-party libraries (such as authentication_fido and libfido2.dll) that could not be found or loaded. Now it reports an error instead. (Bug #33702043)\n\n- The SQLColumns() function result included the length qualifier for some types, such as char(16) instead of char. (Bug #33599093)\n\n- With prepared statements and NO_CACHE=1, having a NULL value in a row column would nullify a value in the same column of the next row. This produced an incorrect value giving NULL where a non-value was expected. (Bug #106683, Bug #33951069)\n\n- When a Catalog or Schema is not specified, and if a table with the same name and set of columns existed in another database, SQLColumns() would return data from multiple databases instead of only the current database. In this case, MS Access would yield an error as the database name was not checked for. Now only data from the current database is returned, unless specifically specified. (Bug #106204, Bug #33788407)\n\n- On Windows, the ODBC GUI dialog did not display all available inputs; so the dialog window size was increased accordingly. (Bug #106013, Bug #33624658)\n\nChanges in MySQL Connector/ODBC 8.0.28 (2022-01-18, General Availability)\n\n- Deprecation and Removal Notes\n\n- Functionality Added or Changed\n\n- Bugs Fixed\n\nDeprecation and Removal Notes\n\n- The TLSv1 and TLSv1.1 connection protocols were previously deprecated in Connector/ODBC 8.0.26 and support for them is removed starting with this release. Instead, use TLSv1.2 or TLSv1.3. The associated NO_TLS_1_0 and NO_TLS_1_1 connection parameters were removed.\n\nFunctionality Added or Changed\n\n- Connector/ODBC can now establish connections using Multi-Factor Authentication (MFA), such that up to three passwords can be specified. The new PASSWORD1, PASSWORD2, and PASSWORD3\nconnection options are available for specifying the first, second, and third MFA passwords, respectively. The PASSWORD1 option is a synonym for the existing PASSWORD option. In addition, PWD1, PWD2, and PWD3 aliases were added.\n\nBugs Fixed\n\n- Microsoft Access could unexpectedly halt when browsing MySQL linked tables when columns in the tables had gaps; and for roughly 100+ record tables as the ODBC driver was incorrectly using memory allocating functions from libmysqlclient. (Bug #33557670, Bug #105503)\n\n- For platforms on which Connector/ODBC utilizes MySQL Server's bundled OpenSSL library (MacOS, Windows, and GenLinux), MySQL Server's linked OpenSSL library was updated to version 1.1.1L. Issues fixed in the new OpenSSL version are described at https://www.openssl.org/news/cl111.txt and https://www.openssl.org/news/vulnerabilities.html. (Bug #33309900)\n\n- SQLColumns() now uses INFORMATION_SCHEMA instead of the deprecated COM_FIELD_LIST by default. COM_FIELD_LIST is only used when NO_I_S is set by Connector/ODBC (which disables INFORMATION_SCHEMA usage). (Bug #29476463, Bug #94235)\n\nChanges in MySQL Connector/ODBC 8.0.27 (2021-10-19, General Availability)\n\n- Functionality Added or Changed\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- Applications that use legacy MySQL connections can now establish connections without passwords for accounts that use the authentication_oci server-side authentication plugin, provided that the correct configuration entries are available to map to one unique user in a specific Oracle Cloud Infrastructure tenancy.\n\nTo ensure correct account mapping, the client-side Oracle Cloud Infrastructure configuration must contain a fingerprint of the API key to use for authentication (fingerprint entry) and the location of a PEM file with the private part of the API key (key_file entry). Both entries should be specified in the [DEFAULT] profile of the configuration file.\n\nUnless an alternative path to the configuration file is specified with the new OCI_CONFIG_FILE connection option, the following default locations are used:\n\n- ~/.oci/config on Linux or Posix host types\n- %HOMEDRIVE%\\%HOMEPATH%\\/.oci/config on Windows host types\n\nIf the MySQL user name is not provided as a connection option, then the operating system user name is substituted. Specifically, if the private key and correct Oracle Cloud Infrastructure configuration are present on the client side, then a connection can be made without giving any options.\n\n- In Connector/ODBC 8.0.26, the capability was introduced for applications that use the classic MySQL connections for accounts that use the authentication_kerberos server-side authentication plugin, provided that the correct Kerberos tickets are available or can be obtained from Kerberos. That capability was available on client hosts running Linux only. It is now available on client hosts running Windows.\n\nFor more information about Kerberos authentication, see Kerberos Pluggable Authentication.\nBugs Fixed\n\n- Changed the NO_SCHEMA default value from 0 to 1. It's enabled to behave like in the older versions the ODBC driver to not accept schema parameters and not declare support for schema functions. (Bug #33300344, Bug #32925338)\n\n- The MSI installation package did not install plugin libraries present in the Zip package, such as fido_client, kerberos_client, and ldap_sasl_client. (Bug #33269861)\n\n- Fixed the internal character set conversions of string data inside the driver; some UTF8MB4 characters were not properly converted. (Bug #33241697, Bug #104346)\n\n- The ODBC driver can now load plugins from their default location without need to specify the plugins directory using the PLUGIN_DIR connection option. (Bug #33134373)\n\n- Added logic to correctly detect OUT/INOUT parameters from a stored procedure, as a workaround to a libmysqldclient issue. (Bug #30578291)\n\n- The second call to a stored procedure failed if the statement was closed after the results of the first call had been received. (Bug #29042032, Bug #93378)\n\nChanges in MySQL Connector/ODBC 8.0.26 (2021-07-20, General Availability)\n\n- Deprecation and Removal Notes\n- Functionality Added or Changed\n- Bugs Fixed\n\nDeprecation and Removal Notes\n\n- The TLSv1.0 and TLSv1.1 connection protocols are now deprecated and support for them is subject to removal in a future Connector/ODBC version.\n\n Additionally, a NO_TLS_1_3 connection option was added.\n\n- Deprecated the NO_I_S connection option, an option to get metadata without the information_schema by using SHOW statements. Setting NO_I_S=1 with SQLConnect() or SQLDriverConnect() now return SQL_SUCCESS_WITH_INFO instead of SQL_SUCCESS, and they a deprecation warning retrievable by SQLGetDiagRec().\n\nFunctionality Added or Changed\n\n- Applications that use Connector/ODBC now can define query attribute metadata on a per-query basis, without the use of workarounds such as specially formatted comments included in query strings.\n\n- Added the ability to connect to MySQL server accounts that use the authentication_kerberos plugin, including support for user-less and password-less Kerberos authentications. Connector/ODBC utilizes the MySQL client library for this functionality.\n\nBugs Fixed\n\n- Fixed help (documentation) links in the ODBC Driver GUI. (Bug #32880421)\n\n- Improved Access/VB6 query attribute handling. (Bug #32813838)\n\n- Attempting to update a row with an existing unique key would not emit a diagnostic error that reported the problem, such as \"Duplicate Entry\". (Bug #32763378, Bug #103287)\n• Systems with both GTK versions 2 and 3 could cause the UnixGUI to unexpectedly halt when using the MySQL GUI module. Now, separate GTK modules exist for each version as the two can't co-exist in the same process. (Bug #32623180)\n\n• A buffer overrun inside SQLColumns() caused Connector/ODBC to unexpectedly halt; memory management was optimized to prevent this problem.\n\nA workaround was to either use the NO_I_S=1 connection option or enable \"Don't use INFORMATION_SCHEMA for metadata\" from the ODBC Data Source Administrator. (Bug #32612467, Bug #102891)\n\n• Fixed insert_params() code to use the __LOCALE_SET and __LOCALE_RESTORE macros rather than setlocale directly. (Bug #32610685, Bug #102871)\n\n• Setting NO_CACHE=1 in the ODBC connection string would cause function errors to go undetected. (Bug #27499789, Bug #89542)\n\nChanges in MySQL Connector/ODBC 8.0.25 (2021-05-11, General Availability)\n\nThis release contains no functional changes and is published to align the version number with the MySQL Server 8.0.25 release.\n\nChanges in MySQL Connector/ODBC 8.0.24 (2021-04-20, General Availability)\n\n• Security Notes\n\n• Functionality Added or Changed\n\n• Bugs Fixed\n\nSecurity Notes\n\n• For platforms on which Connector/ODBC utilizes MySQL Server's bundled OpenSSL library (MacOS, Windows, and GenLinux), MySQL Server's linked OpenSSL library was updated to version 1.1.1k. Issues fixed in the new OpenSSL version are described at https://www.openssl.org/news/cl111.txt and https://www.openssl.org/news/vulnerabilities.html. (Bug #32719727)\n\nReferences: See also: Bug #32680637.\n\nFunctionality Added or Changed\n\n• Previously, if the connection to the server was not used within the period specified by the wait_timeout system variable and the server closed the connection, the client received no notification of the reason. Typically, the client would see Lost connection to MySQL server during query (CR_SERVER_LOST) or MySQL server has gone away (CR_SERVER_GONE_ERROR).\n\nIn such cases, the server now writes the reason to the connection before closing it, and the client receives a more informative error message: The client was disconnected by the server because of inactivity. See wait_timeout and interactive_timeout for configuring this behavior. (ER_CLIENT_INTERACTION_TIMEOUT).\n\nThe previous behavior still applies for client connections to older servers and connections to the server by older clients.\n\n• If a classic MySQL protocol connection experiences a server timeout, Connector/ODBC now reports more precise disconnection information from the server.\nBugs Fixed\n\n• Setting PAD_SPACE=1 did not cause CHAR columns to be padded with spaces to their full length, which prevented the MSSQL linked server from working with ENUM and CHAR columns in the MySQL Database. (Bug #32537000)\n\n• The ODBC SQLProcedureColumns function returns incomplete results, fetches after usage would only return the first 40 parameters. The workaround was to increase the group_concat_max_len size, for example 'group-concat-max-len = 1000000' under [mysqld]. (Bug #32504915, Bug #102589)\n\n• MySQL 8.0.24 added a new ER_CLIENT_INTERACTION_TIMEOUT error code, and it caused the ODBC driver to report the wrong SQLSTATE HY000 instead of 08S01 after the connection is terminated on the server by wait/_interactive timeout. The ODBC driver is now linked against libmysqld 8.0.24 to handle this situation. (Bug #32394545)\n\n• Passing a query without parameters to SQLPrepare() would not prepare anything. In some scenarios it would immediately execute such a query, which would be the same as calling the SQLExecDirect() function. In other scenerios it executed without preparing by using the SQLExecute() function. This could lead towards abnormally long query times. Now, the driver enforces preparation of the statement by the SQLPrepare() function even if the query has no parameters. (Bug #32079486)\n\n• Connector/ODBC report ENUM columns as SQL_CHAR as the ODBC standard does not support ENUM, and MS SQL Server expects CHAR data to always be the same fixed length as specified in the column definition. This fixes errors related to new line and tab symbols present in the UNICODE version of the driver. The workaround is to enable SSPS (default) by not setting NO_SSPS=1. (Bug #28783266, Bug #92748)\n\nReferences: See also: Bug #32537000.\n\nChanges in MySQL Connector/ODBC 8.0.23 (2021-01-18, General Availability)\n\n• Functionality Added or Changed\n\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• Previously, Connector/ODBC added client support for the MySQL Enterprise Edition SASL LDAP authentication plugin with SCRAM-SHA-1 as an authentication method. Connector/ODBC now also supports SCRAM-SHA-256 as an alternative authentication method for classic MySQL protocol connections. SCRAM-SHA-256 is similar to SCRAM-SHA-1 but is more secure. SASL-based LDAP authentication does not apply to clients running macOS.\n\nThe SASL module required for LDAP/SCRAM-SHA256 is provided by the cyrus-sasl-scram RPM package and libsasl2-modules-gssapi-mit DEB package (the same package that provides modules for LDAP/GSSAPI/Kerberos).\n\nBugs Fixed\n\n• Using the commercial glib package (authentication_ldap_sasl) with auth using GSSAPI (authentication_ldap_sasl_auth_method_name='GSSAPI') did not function. Added the missing sasl2 modules package. (Bug #32175842)\n\n• On Debian based systems, the post-installation script uses dpkg-architecture ODBC drivers path, so the associated dpkg-dev package was added as a runtime dependency. (Bug #32157740)\n\n• Double and Float values could differ depending if the query was standard or utilized server side prepared statements. Standard used MYSQL_ROW for non-binary data to represent them as\ncharacter strings, whereas server side prepared statements used the MYSQL_BIND structure and the specific MySQL type which could lead towards inconsistent results. Now this is performed in a uniform way to yield the same results. (Bug #32135124, Bug #98946)\n\n• Microsoft Access halted when opening a linked table with only a JSON column. The JSON column type is now supported, and JSON data is only editable if another column is used as a primary key. Because JSON is a long data type with the maximum length of 4GB, it can't be used as a primary key by Microsoft Access and therefore tables having only JSON columns are only available in read-only mode. (Bug #32114901)\n\n• Removed the mysql-client-plugins dependency. It remains required for connections using commercial MySQL server accounts with LDAP authentication, so must be manually installed for that situation. The mysql-client-plugins package has conflicts with MySQL server versions before 8.0.21, so earlier versions (such as MySQL 5.7) require an 8.0 server upgrade to use it. (Bug #31875490)\n\n• On macOS, Connector/ODBC would not report an error if SQL_ATTR_PARAMSET_SIZE was set but not supported; instead the setting was ignored. (Bug #29862441, Bug #95608)\n\nChanges in MySQL Connector/ODBC 8.0.22 (2020-10-19, General Availability)\n\n• Functionality Added or Changed\n\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• For enhanced security of the existing ENABLE_LOCAL_INFILE connection string option, the new ENABLE_LOCAL_DIR option allows restricting LOCAL data loading to files located in this designated directory. Example usage:\n\n```c\n// LOAD LOCAL DATA DIR FROM /tmp\nSQLRETURN rc = SQLDriverConnect(\n hdbc1, NULL,\n \"DSN=myDSN;UID=root;PWD=pwd;DATABASE=test;LOAD_DATA_LOCAL_DIR=/tmp\",\n SQL_NTS, conn_out, sizeof(conn_out), &conn_out_len,\n SQL_DRIVER_NOPROMPT);\n\n// LOAD LOCAL DATA FROM EVERYWHERE\nSQLRETURN rc = SQLDriverConnect(\n hdbc1, NULL,\n \"DSN=myDSN;UID=root;PWD=pwd;DATABASE=test;ENABLE_LOCAL_INFILE=1;\",\n SQL_NTS, conn_out, sizeof(conn_out), &conn_out_len,\n SQL_DRIVER_NOPROMPT);\n```\n\n• Connections made using the MySQL Enterprise Edition SASL LDAP authentication plugin now are supported on Windows and Linux, but not on macOS. Connector/ODBC implements the SCRAM-SHA-1 authentication method of the SASL authentication protocol.\n\nBugs Fixed\n\n• Fixed an issue where a parameterized query could cause memory corruption. (Bug #31678876, Bug #100329)\n\n• Under some circumstances when using server-side prepared statements, the first row of a multi-row match was not returned with the result; while it was returned when using client-side prepared statements instead. (Bug #31373948, Bug #95423)\n\n• Inserting binary data (BLOBs) using SQLPutData() would report a syntax error. (Bug #31349038)\nChanges in MySQL Connector/ODBC 8.0.21 (2020-07-13, General Availability)\n\n- Security Notes\n- Bugs Fixed\n\nSecurity Notes\n\n- For platforms on which OpenSSL libraries are bundled, the linked OpenSSL library for Connector/ODBC has been updated to version 1.1.1g. Issues fixed in the new OpenSSL version are described at https://www.openssl.org/news/cl111.txt and https://www.openssl.org/news/vulnerabilities.html. (Bug #31296688)\n\nBugs Fixed\n\n- The MSI installer now checks for the Visual 2019 C++ runtime, and aborts if this required runtime is not installed.\n \n This is also the first version that requires Visual 2019 C++ runtime, when before the 2017 version was also supported. (Bug #31102234)\n\n- Only a single value was being inserted instead of the array, with SQLParamOptions. (Bug #30591722)\n\n- The SUM aggregate function did not function with ADO. (Bug #30277891, Bug #96642)\n\n- Added a workaround to account for a limitation in the iODBC SQLGetPrivateProfileString() implementation as previously DSN options could be lost. iODBC is most commonly used on macOS. (Bug #27851681)\n\nChanges in MySQL Connector/ODBC 8.0.20 (2020-04-27, General Availability)\n\n- Functionality Added or Changed\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- On Debian, DEB packages are now released instead of TGZ files. The file base names are mysql-connector-odbc-* (driver package) and mysql-connector-odbc-setup (setup package). The setup package contains the GUI configuration widget library (libmyodbc8S.so) and depends on the driver package. The driver package depends on the unixODBC libraries (libodbc, libodbcinst); and does not conflict with the official Debian package (libmyoodbc).\n\nBugs Fixed\n\n- When using SQL_C_WCHAR with SQLGetData, binary data was not returned correctly as its hexacecimal representation. Related, using SQL_C_CHAR with SQLGetData did return binary data as hex. (Bug #28864788, Bug #92429)\n\n- When binding an SQL_BIT type column to the SQL_C_CHAR type, SQLFetchScroll would return the values as an integer instead of a char. (Bug #28484784, Bug #91904)\n\nChanges in MySQL Connector/ODBC 8.0.19 (2020-01-13, General Availability)\n\n- Functionality Added or Changed\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n• Added DNS SRV support.\n\nTo automatically resolve any SRV record available in a target DNS server or service discovery endpoint, specify `ENABLE_DNS_SRV=1` in the DSN; the host is passed for SRV lookup without a port and with a full lookup name. For example: `DRIVER={MySQL ODBC 8.0 Driver};SERVER=_mysql._tcp.foo.abc.com;ENABLE_DNS_SRV=1;USER=user;PWD=passwd;`\n\n• Confirmed support for compiling with VS2019, and for supporting the Visual C++ 2019 redistributable.\n\n• When creating a new connection using the classic MySQL protocol, multiple hosts can be tried until a successful connection is established. A list of hosts can be given in a connection string, along with passing `MULTI_HOST=1` to to enable this functionality. The connection string looks similar to `SERVER=address1[:port1],address2[:port2]...;MULTI_HOST=1;`.\n\nOther notes: the default port is used if port is not specified, the connector randomly picks hosts, and if a host fails then a new host is chosen. An error is returned if `SERVER` contains multiple hosts when `MULTI_HOST` is not enabled.\n\nBugs Fixed\n\n• With prepared SELECT statements the fixed-length numeric types such as INT were set to 0 instead of their stored value, if a textual field was also part of the SELECT statement. (Bug #30428851, Bug #97191)\n\n• Connector/ODBC failed to compile when dynamically linking to the MySQL client library (MYSQLCLIENT_STATIC_LINKING=0); due to a mismatch between an internal copy of the library headers and the version of code implementing the library internals. (Bug #30292290, Bug #96835)\n\n• Improved handling for stored procedures and the INOUT parameter.\n\nFor example, if a stored procedure had one or more parameters then an incomplete result set could be returned. (Bug #29467224, Bug #94623)\n\nChanges in MySQL Connector/ODBC 8.0.18 (2019-10-14, General Availability)\n\nBugs Fixed\n\n• Connector/ODBC is now built with MySQL client library 8.0.18, which includes OpenSSL 1.1.1d. Issues fixed in the new OpenSSL version are described at [http://www.openssl.org/news/vulnerabilities.html](http://www.openssl.org/news/vulnerabilities.html). (Bug #29868815)\n\n• On Linux, memory was leaked on each server connection attempt due to how `mysql_server_end` was implemented and executed. (Bug #26194929)\n\n• On Windows, fixed direct `setlocale()` usage for multi-threaded applications.\n\nThe workaround was to add `;NO_LOCALE=1` to the connection string.\n\nThanks to Jacques Germishuys for the patch. (Bug #24814467, Bug #83297)\n\nChanges in MySQL Connector/ODBC 8.0.17 (2019-07-22, General Availability)\n\n• Functionality Added or Changed\n\n• Bugs Fixed\nFunctionality Added or Changed\n\n- README.md and CONTRIBUTING.md files were created for the convenience of git users. These files are not distributed with binaries, whereas README.txt remains distributed.\n\nBugs Fixed\n\n- The myodbc-installer command line utility did not display all DSN options. (Bug #29753227)\n- On Windows, building and installing from source could yield a binary that would not execute due to a case-sensitivity issue in the CMake logic. (Bug #29210040)\n\nChanges in MySQL Connector/ODBC 8.0.16 (2019-04-25, General Availability)\n\nBugs Fixed\n\n- Connector/ODBC 8.0 is now built with OpenSSL 1.0.2R. Issues fixed in the new OpenSSL version are described at http://www.openssl.org/news/vulnerabilities.html. (Bug #29538143)\n- An exception was emitted when fetching contents of a BLOB/TEXT records after executing a statement as a server-side prepared statement with a bound parameter.\n\nThe workaround is not using parameters or specifying NO_SSPS=1 in the connection string: this allows the driver to fetch the data. (Bug #29282638, Bug #29512548, Bug #28790708, Bug #93895, Bug #94545, Bug #92078)\n\nChanges in MySQL Connector/ODBC 8.0.15 (2019-02-01, General Availability)\n\nThis release contains no functional changes and is published to align version number with the MySQL Server 8.0.15 release.\n\nChanges in MySQL Connector/ODBC 8.0.14 (2019-01-21, General Availability)\n\nFunctionality Added or Changed\n\n- A new ENABLE_LOCAL_INFILE connection option was added to the connection string, DSN, and GUI. Disabled by default, set ENABLE_LOCAL_INFILE=1 to enable LOAD DATA operations. This toggles the MYSQL_OPT_LOCAL_INFILE mysql_options() option.\n\nThe connection string overrides the DSN value if both are set.\n\n- MySQL Connector/ODBC is now compatible with MSVC 2017, while retaining compatibility with MSVC 2015:\n - Previously, Connector/ODBC binary distributions were compatible with projects built using MSVC 2015. Binary distributions now are compatible with projects built using MSVC 2017 or 2015.\n - Previously, Connector/ODBC source distributions could be built using MSVC 2015. Source distributions now can be built using MSVC 2017 or 2015.\n - Previously, the MSI installer accepted the Visual C++ Redistributable for Visual Studio 2015. The MSI installer now accepts the Visual C++ Redistributable for Visual Studio 2017 or 2015.\n - Two informative text files were added: INFO_BIN contains information about the build environment used to produce the distribution, and INFO_SRC provides information about the product version and the source repository from which the distribution was produced. Source distributions include the INFO_SRC file only.\nChanges in MySQL Connector/ODBC 8.0.13 (2018-10-22, General Availability)\n\n- Functionality Added or Changed\n\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- Added dynamic libmysql linking support via the -DMYSQLCLIENT_STATIC_LINKING:BOOL=TRUE/FALSE option; defaults to FALSE to enable dynamic linking.\n\nBugs Fixed\n\n- Fixed column metadata handling with Microsoft Access. (Bug #28670725, Bug #91856)\n\n- The following obsolete options were removed: NO_SCHEMA (use NO_CATALOG instead), DISABLE_SSL_DEFAULT (use SSLMODE instead), and SSL_ENFORCE (use SSLMODE instead). (Bug #28407520)\n\n- The ODBC Driver returned 0 for the SQL_MAX_SCHEMA_NAME_LEN attribute, and now returns 64 as the maximum length for a MySQL schema name. (Bug #28385722)\n\n- Because the MySQL ODBC driver ignored the SQL_RD_OFF value for the SQL_ATTR_RETRIEVE_DATA attribute, it incorrectly kept writing into the data buffers. This led to write access violation errors when data was written into the buffer when the user application explicitly requested not to write there. (Bug #28098219, Bug #91060)\n\nChanges in MySQL Connector/ODBC 8.0.12 (2018-07-27, General Availability)\n\n- Functionality Added or Changed\n\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- Several code issues identified by Fortify were corrected.\n\n- Refactored codebase to remove legacy code and implement general performance improvements. For example, unused ANSI data conversion code and legacy functions were removed. Example improvements affect bookmark handling for bulk operations, handling of memory buffers for prepared statements, and handling of session variables.\n\n- On Windows, 32-bit support was added and 32-bit binaries are now available.\n\n- An RPM package for installing ARM 64-bit (aarch64) binaries of Connector/ODBC on Oracle Linux 7 is now available in the MySQL Yum Repository and for direct download.\n\n Known Limitation for this ARM release: You must enable the Oracle Linux 7 Software Collections Repository (ol7_software_collections) to install this package, and must also adjust the libstdc++7 path. See Yum’s Platform Specific Notes for additional details.\n\nBugs Fixed\n\n- Added checks for unsupported functionality that return SQL_ERROR instead of SQL_SUCCESS, where the error message refers to the unsupported functionality. (Bug #28217387)\n\n- The data source dependent type’s name was not always returned. For example, the ODBC driver reported TEXT as the database type for TINYTEXT, MEDIUMTEXT, and LONGTEXT, and reported BLOB for TINYBLOB, MEDIUMBLOB, and LONGBLOB. (Bug #11761407; Bug #53900)\nMySQL Connectors and other MySQL client tools and applications now synchronize the first digit of their version number with the (highest) MySQL server version they support. This change makes it easy and intuitive to decide which client version to use for which server version.\n\nConnector/ODBC 8.0.11 is the first release to use the new numbering. It was branched from Connector/ODBC 5.3.10.\n\nThe Connector/ODBC 8.0 series also adds full MySQL Server 8.0 support.\n\nFunctionality Added or Changed\n\n- Connector/ODBC now supports a new `GET_SERVER_PUBLIC_KEY` connection option that enables requesting the RSA public key from the server. For accounts that use the `caching_sha2_password` or `sha256_password` authentication plugin, this key can be used during the connection process for RSA key-pair based password exchange with TLS disabled. This capability requires a MySQL 8.0 or higher server, and is supported only for Connector/ODBC built using OpenSSL.\n\n- A new OpenSSL runtime dependency was added that must be present on the target system where the connector is used. For some platforms it is assumed that a system-wide OpenSSL is available, for others, such as Windows and macOS, these required OpenSSL libraries are bundled in the binary packages.\n\n- Packaging was modified for the new MySQL Connector/ODBC 8 series. For example, the Connector/ODBC 5.x ODBC driver has a file named `myodbc5w.dll`, whereas this same ODBC driver is named `myodbc8w.dll` for the Connector/ODBC 8.x series. The sample .ini file also references these new file names.\n\nChanges in MySQL Connector/ODBC Version 5.3\n\nChanges in MySQL Connector/ODBC 5.3.14 (2019-10-30, General Availability)\n\n**Bugs Fixed**\n\n- Connector/ODBC is now built with MySQL client library 5.7.28, which includes OpenSSL 1.1.1d. Issues fixed in the new OpenSSL version are described at [http://www.openssl.org/news/vulnerabilities.html](http://www.openssl.org/news/vulnerabilities.html). (Bug #30340670)\n\n- On EL7, and only when using the generic Linux packages, `SQLSetPos` usage caused an unexpected shutdown. (Bug #29630465)\n\nChanges in MySQL Connector/ODBC 5.3.13 (2019-04-29, General Availability)\n\n**Bugs Fixed**\n\n- Connector/ODBC 5.3 is now built with MySQL client library 5.7.26, which includes OpenSSL 1.0.2R. Issues fixed in the new OpenSSL version are described at [http://www.openssl.org/news/vulnerabilities.html](http://www.openssl.org/news/vulnerabilities.html). (Bug #29489006)\n\n- An exception was emitted when fetching contents of a BLOB/TEXT records after executing a statement as a server-side prepared statement with a bound parameter. The workaround is not using parameters or specifying `NO_SSPS=1` in the connection string; this allows the driver to fetch the data. (Bug #29282638, Bug #29512548, Bug #28790708, Bug #93895, Bug #94545, Bug #92078)\nChanges in MySQL Connector/ODBC 5.3.12 (2019-01-28, General Availability)\n\n- Functionality Added or Changed\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- A new `ENABLE_LOCAL_INFILE` connection option was added to the connection string, DSN, and GUI. Disabled by default, set `ENABLE_LOCAL_INFILE=1` to enable LOAD DATA operations. This toggles the `MYSQL_OPT_LOCAL_INFILE` mysql_options() option.\n\n The connection string overrides the DSN value if both are set.\n\nBugs Fixed\n\n- Dynamic linking (`-DCLIENT_STATIC_LINKING:BOOL=false`) was not functioning, and updating to the most recent MySQL Server 5.7 headers restored this functionality. (Bug #28609434, Bug #92319, Bug #91841)\n\n- Calling SQLBulkOperations with `no_ssp` set to 0 and `cursortype` set to `SQL_CURSOR_DYNAMIC` would cause an unexpected halt when using the generic Linux binaries. (Bug #28289320)\n\nChanges in MySQL Connector/ODBC 5.3.11 (2018-07-30, General Availability)\n\n- Functionality Added or Changed\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- The `caching_sha2_password` authentication mechanism is now supported due to the MySQL client library update to 5.7.23.\n\nBugs Fixed\n\n- The Unicode version now uses the UTF8MB4 character set as a transport character set between the MySQL server and the ODBC driver. Because text conversions requested by the ODBC user with the CHARSET connection option are done inside the ODBC Driver after the data is received from the server, it now converts text data as UTF8MB4 to USER_CHARSET instead of UTF8 to USER_CHARSET. (Bug #28204756)\n\n- Connections to MySQL Server 8.0 could yield \"Source character set not supported by client\" errors during sorting and case-sensitive operations. Now known UTF8MB4 collations are used for these operations, such as `utf8mb4_general_ci` (known to libmysqlclient 5.7) instead of `utf8mb4_tolower_ci`. (Bug #28116892, Bug #90984)\n\n- Connector/ODBC is now built with MySQL client library 5.7.23, and commercial builds also use an updated OpenSSL version (v1.0.2o). Issues fixed in the new OpenSSL version are described at [http://www.openssl.org/news/vulnerabilities.html](http://www.openssl.org/news/vulnerabilities.html). (Bug #27829777)\n\n- Reported errors that occurred while executing multiple statements with a single query were generic and without context. For example, `SQLMoreResults` might return \"unhandled error from mysql_next_result()\" instead of the error reported by MySQL Server. (Bug #11757423, Bug #49466)\n\nChanges in MySQL Connector/ODBC 5.3.10 (2018-01-30, General Availability)\n\n- Functionality Added or Changed\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• SQL query timeout (`SQL_ATTR_QUERY_TIMEOUT`) support was added. (Bug #26474362, Bug #69416)\n\n• When building Connector/ODBC from source, users now have a choice of linking dynamically or statically to the MySQL client library. Dynamic linking is selected by default. See Building Connector/ODBC from a Source Distribution on Windows or Building Connector/ODBC from a Source Distribution on Unix for details.\n\nHowever, the binary distributions of Connector/ODBC from Oracle remain statically linked to the client library.\n\nBugs Fixed\n\n• Fixed an `OpenRecordSet` memory leak due to `get_session_variable()` not freeing a result for errors. (Bug #27155880, Bug #88143)\n\n• Calling `MySQLDriverConnect` with the `pcbConnStrOut` argument set to `NULL` caused an unexpected failure. (Bug #27101767, Bug #88371)\n\n• `SELECT FOR UPDATE` statements could fail with `PREFETCH` set. (Bug #26646688, Bug #87457)\n\nReferences: See also: Bug #87213.\n\n• Connector/ODBC now compiles on MySQL 5.5. Thanks to Vadim Zeitlin for the patch. (Bug #26633971, Bug #87413)\n\nChanges in MySQL Connector/ODBC 5.3.9 (2017-07-24, General Availability)\n\n• Security Notes\n\n• Functionality Added or Changed\n\n• Bugs Fixed\n\nSecurity Notes\n\n• The linked OpenSSL library for MySQL Connector/ODBC 5.3.9 Commercial has been updated to version 1.0.2l.\n\nThis change does not affect the Oracle-produced MySQL Community build of Connector/ODBC 5.3.9, which uses the yaSSL library instead. (Bug #26320994)\n\nFunctionality Added or Changed\n\n• When compiling Connector/ODBC on Windows platforms, it can now be linked statically (equivalent to the `/MT` compiler option in Visual Studio) or dynamically (equivalent to the `/MD` compiler option in Visual Studio) to the Visual C++ runtime. The default option is to link dynamically; if you want to link statically, set the new CMake option, `STATIC_MSVCRT`, to true.\n\nAnother new CMake option, `WITH_NODEFAULTLIB`, has been introduced for specifying the Visual C++ runtime you want to link Connector/ODBC to when using mixed link types (that is, when link type to the Visual C++ runtime differs for Connector/ODBC and the MySQL client library it links to).\n\nSee Building Connector/ODBC from a Source Distribution on Windows for details.\n\nBugs Fixed\n\n• The `SQLForeignKeys()` function returned an empty result set when the information schema was being used. (Bug #26388694)\nMySQL Connector/ODBC Release Notes\n\n• Calling SQLExecute() after calling SQLFreeStmt() with the SQL_RESET_PARAMS option resulted in an assertion failure. With this fix, a proper error is now thrown in the situation. (Bug #19148246)\n\n• A segmentation fault occurred in SQLFetch() when SQL_ATTR_CURSOR_TYPE was set to SQL_CURSOR_DYNAMIC. (Bug #18805392)\n\n• Connector/ODBC quit unexpectedly in SQLForeignKeys() when SQL_MODE was set to ANSI_QUOTES. (Bug #18641824)\n\nChanges in MySQL Connector/ODBC 5.3.8 (2017-04-28, General Availability)\n\n• Security Notes\n\n• Bugs Fixed\n\nSecurity Notes\n\n• The linked OpenSSL library for Connector/ODBC Commercial 5.3.8 has been updated from version 1.0.2j to version 1.0.2k. Versions of OpenSSL prior to 1.0.2k are reported to be vulnerable to CVE-2017-3731, CVE-2017-3732, and CVE-2017-7055.\n\nThis change does not affect the Oracle-produced MySQL Community build of Connector/ODBC 5.3.8, which uses the yaSSL library instead. (Bug #25615448)\n\nBugs Fixed\n\n• When error 2006 (“MySQL server has gone away”) occurred, Connector/ODBC wrongly returned the SQL_NO_DATA error. (Bug #25671389)\n\n• When the SQL_TIMESTAMP_STRUCT was used, if the date portion of a timestamp was populated but the time portion was uninitialized, queries involving the timestamp would fail with a Date overflow error. With this fix, the uninitialized time value is simply ignored. (Bug #25386024)\n\n• Several fixes were made to the packaged README file, including the copyright year. (Bug #22858162)\n\n• Segmentation faults occurred when catalog, column, or table names that were too long were passed as arguments to metadata functions like SQLColumnPrivileges(),SQLColumns(),SQLTablePrivileges() and SQLTables(). With this fix, proper errors are returned in those cases. (Bug #18796005)\n\n• An assertion error occurred when calling SQLSetDescField() with SQL_DESC_COUNT as FieldIdentifier, irrespective of the record number set. (Bug #18641633)\n\n• Connector/ODBC quit unexpectedly when a negative column number was passed as an argument for the SQLGetData() method. (Bug #18636600)\n\n• When server-side prepared statements were enabled, using the prefetch option caused SQL syntax errors to be returned for queries that contained parameter markers. (Bug #17386788)\n\n• After the attribute SQL_ATTR_MAX_ROWS had been set for a certain statement handler, a new statement handler also had the same value set automatically. The fix makes sure a new statement handler returns all rows by default. (Bug #17259397, Bug #69554)\n\n• If the NO_INFORMATION_SCHEMA connection option was set, the SQLTables() function did not return the catalog correctly when a wildcard or SQL_ALL_CATALOGS was used in its arguments. (Bug #14005343)\n\nReferences: See also: Bug #13914518.\n\nChanges in MySQL Connector/ODBC 5.3.7 (2016-12-13, General Availability)\nMySQL Connector/ODBC Release Notes\n\n- Security Notes\n- Functionality Added or Changed\n- Bugs Fixed\n\nSecurity Notes\n\n- The linked OpenSSL library for Connector/ODBC Commercial 5.3.7 has been updated from version 1.0.1q to version 1.0.2j. Versions of OpenSSL prior to 1.0.2j are reported to be vulnerable to CVE-2016-6304.\n\n This change does not affect the Oracle-produced MySQL Community build of Connector/ODBC 5.3.7, which uses the yaSSL library instead. (Bug #24753385)\n\nFunctionality Added or Changed\n\n- A new configuration option, `SSLMODE`, has been introduced for setting the SSL mode of the connection to the server. This option overrides the now deprecated `sslverify` and `SSL_ENFORCE` options. See Connector/ODBC DSN Configuration Options for details. (Bug #23497043)\n\n- Added new configuration option `NO_TLS_1_0`, `NO_TLS_1_1`, and `NO_TLS_1_2` for controlling TLS versions for encrypting connecting. See Connector/ODBC DSN Configuration Options for details. For more information about encryption protocols in MySQL, see Encrypted Connection TLS Protocols and Ciphers. (Bug #23496903)\n\nBugs Fixed\n\n- An assertion failure occurred when `mysql_stmt_close()` was called on a broken connection. (Bug #25109356)\n\n- Connector/ODBC could not be installed on OS X using the installer provided with the `.dmg` file unless unixODBC had been installed on the system. With this fix, Connector/ODBC is now built to work with the iODBC manager instead. Installation now only requires iODBC to be on the system. (Bug #23123503, Bug #81113)\n\n- Connector/ODBC could not be built with CMake 3.0.2 or later. The build script has been fixed to correct the issue. (Bug #22746557)\n\nChanges in MySQL Connector/ODBC 5.3.6 (2016-03-17, General Availability)\n\n- Security Notes\n- Functionality Added or Changed\n- Bugs Fixed\n\nSecurity Notes\n\n- The linked OpenSSL library for Connector/ODBC Commercial 5.3.6 has been updated from version 1.0.1m to version 1.0.1q. Versions of OpenSSL prior to 1.0.1q are reported to be vulnerable to CVE-2015-3195.\n\n This change does not affect the Oracle-produced MySQL Community build of Connector/ODBC 5.3.6, which uses the yaSSL library instead.\n\nFunctionality Added or Changed\n\n- Two new `option` parameters, `DISABLE_SSL_DEFAULT` and `SSL_ENFORCE`, have been introduced for specifying whether the default requirement to use SSL connections is to be followed. See Connector/ODBC DSN Configuration Options for details. (Bug #21027928)\n• The statement attribute `SQL_ATTR_QUERY_TIMEOUT` is now supported. Its value is set by `SQLSetStmtAttr()` and retrieved by `SQLGetStmtAttr()`.\n\n**Bugs Fixed**\n\n• The function `MySQLGetPrivateProfileStringW()` used `malloc()` to allocate memory and then `xfree()` to free the allocated memory for a returned value. That caused some issues when certain third-party versions of MySQL client library (like MariaDB 10.x) was used. The issues have been fixed by replacing `malloc()` with `my_malloc()`.(Bug #21074676, Bug #76984)\n\n• Attempt to build Connector/ODBC from source on a Linux platform against the client library and header files shipped with MySQL server 5.7.6 or newer failed. It was due to the changes made to the client library and the header files, to which Connector/ODBC has now been adapted. (Bug #20685833)\n\n• An application that used ActiveX Data Objects (ADO) and the Connector/ODBC ANSI driver hung after trying to write French characters to a database that used the UTF-8 character set. (Bug #20526062)\n\n• Because Connector/ODBC did not parse comments properly, the parameter markers embedded in comments caused the complaint that `SQLBindParameter` was not used for all parameters. (Bug #16613308, Bug #53891)\n\n• Calling the `SQLGetDiagField` function with the `DiagIdentifier SQL_DIAG_ROW_COUNT` always returned “0,” even if there were updated, deleted, or modified rows. (Bug #11750296)\n\n**Changes in MySQL Connector/ODBC 5.3.5 (2015-5-25, General Availability)**\n\n**Security Notes**\n\n• Connector/ODBC 5.3 Commercial has been updated to use OpenSSL version 1.0.1m, which has been publicly reported as not vulnerable to CVE-2015-0286.\n\nSince the only change in Connector/ODBC 5.3.5 is the inclusion of OpenSSL libraries publicly reported as unaffected by CVE-2015-0286, and since Oracle-produced MySQL Community builds use YaSSL libraries which have been reported as not affected by CVE-2015-0286, Oracle will not produce builds for Connector/ODBC Community for version 5.3.5. This means the Community edition of Connector/ODBC will skip version 5.3.5. (Bug #20747740)\n\n**Changes in MySQL Connector/ODBC 5.3.4 (2014-07-18, General Availability)**\n\n• Security Notes\n\n• Functionality Added or Changed\n\n**Security Notes**\n\n• The linked OpenSSL library for Connector/ODBC Commercial 5.3.4 has been updated from version 1.0.1g to version 1.0.1h. Versions of OpenSSL prior to and including 1.0.1g are reported to be vulnerable to CVE-2014-0224.\n\nThis change does not affect the Oracle-produced MySQL Community build of Connector/ODBC 5.3.4, which uses the yaSSL library instead.\n\n**Functionality Added or Changed**\n\n• Added NULL handle checks in functions exported by Connector/ODBC.\n\n• Introduced a new DSN configuration option, `rsakey`, for specifying the full-path name of the PEM file that contains the RSA public key for using the SHA256 authentication plugin of MySQL. See Connector/ODBC DSN Configuration Options for details.\nChanges in MySQL Connector/ODBC 5.3.3 (2014-04-16, General Availability)\n\nSecurity Notes\n\n- Connector/ODBC 5.3 Commercial has been updated to use OpenSSL version 1.0.1g, which has been publicly reported as not vulnerable to CVE-2014-0160. Please see Oracle Note #1645479.1 for further details.\n\nSince the only change in Connector/ODBC 5.3.3 is the inclusion of OpenSSL libraries publicly reported as unaffected by CVE-2014-0160, and since Oracle-produced MySQL Community builds use yaSSL libraries, which have been reported as not affected by CVE-2014-0160, Oracle will not produce builds for Connector/ODBC Community for version 5.3.3. This means the Community edition of Connector/ODBC will skip version 5.3.3. (Bug #18533200)\n\nChanges in MySQL Connector/ODBC 5.3.2 (2014-04-08, General Availability)\n\nThis is the first GA release for the Connector/ODBC 5.3.x series. The available downloads include both a Unicode driver and an ANSI driver based on the same modern codebase. Please select the driver type you need—Unicode or ANSI—based on the type of your application. Server-side prepared statements are enabled by default. It is suitable for use with any MySQL version since 4.1 (it will not work with 4.0 or earlier releases.)\n\nThis is the third release of the MySQL ODBC driver conforming to the ODBC 3.8 specification. It contains the minimally required implementation of the standard with key ODBC 3.8 features, which include self-identification as a ODBC 3.8 driver, streaming of output parameters (supported for binary types only), and support of the SQL_ATTR_RESET_CONNECTION connection attribute (for the Unicode driver only).\n\nConnector/ODBC 5.3 also introduces a GTK+-based setup library, providing GUI DSN setup dialog on some Unix-based systems. The library is currently included in the Oracle Linux 6 and Debian 6 binary packages. Other new features in the 5.3 series include file DSN and bookmark support.\n\n- Functionality Added or Changed\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- Implemented support for the ODBCINSTGetProperties interface for use by unixODBC GUI dialogs. This allows users to configure a file DSN through a graphical user interface on Unix-like platforms. (Bug #17513175)\n\n- Added support for the connection flag DF_LT_BIGINT_BIND_STR.\n\n- Made the Connector/ODBC GUI on Linux comply with the GNOME Coding Guidelines for Supporting Accessibility.\n\nBugs Fixed\n\n- The functions SQLSetDescField(), SQLGetDiagField(), and SQLGetDiagRec() crashed when a null pointer was passed as a handle for those functions. This fix makes the functions check if the passed pointer is null before using it. (Bug #18431088)\n\n- SQLBulkOperations(SQL_FETCH_BOOKMARK) returned an SQL_NO_DATA error when called after SQLBulkOperations(SQL_UPDATE_BY_BOOKMARK) or SQLBulkOperations(SQL_DELETE_BY_BOOKMARK). (Bug #18287216)\n\n- The order of the control elements was wrong during control selection in Connector/ODBC's Windows GUI. (Bug #18240696)\n\n- Concurrent execution of SQLEndTran() and SQL_HANDLE_ENV resulted in a segmentation fault. (Bug #18166331)\nMySQL Connector/ODBC Release Notes\n\n- Calling SQLNumResultCols() with a NULL parameter resulted in a segmentation fault. (Bug #18165197)\n- Connector/ODBC's GUI dialog could not be opened from within ODBCManageDataSourcesQ4 for editing an existing DSN. (Bug #18046123)\n- myodbc-installer did not initialize the allocated memory. This fix flushes the buffer with “0” for initialization. (Bug #18046120)\n- Connector/ODBC crashed when trying to prepare a query after connecting to the server with an invalid value for CHARSET. This fix checks the CHARSET value and throws an error if it is invalid. (Bug #17999659)\n- At a malloc() failure, Connector/ODBC crashed because in the driver_new() function, driver is being freed before driver->name and driver->lib. This fix corrects the order of the free() calls. (Bug #17992912)\n- Driver and installer crashed when the path lengths supplied were longer than 256 characters or when the option strings were longer than 100 characters. This fix makes Connector/ODBC return the proper errors instead. (Bug #17966018)\n- SQLFetch() crashed when executed using unixodbc versions 2.3.0, 2.3.1, or 2.3.2. (Bug #17857204)\n- A segmentation fault occurred in SQLSpecialColumns() if the table name supplied was too long. This fix makes Connector/ODBC throw a proper error for the situation. (Bug #17854697)\n- When called after SQLParamaData, SQLGetData returned an error. (Bug #17842966)\n- SQLGetData did not return correct length of the data when retrieving data from an output parameter stream. (Bug #17814768, Bug #70946)\n- A segmentation fault occurred in SQLBulkOperations for an SQL_UPDATE_BY_BOOKMARK if the prior fetch returned no records. (Bug #17714358)\n- Data corruption occurred in SQLBulkOperations(), because in the batch_insert() function, ptr_offset_adjust sometimes pointed to an invalid memory location. (Bug #17714172)\n- While doing BULK INSERT into a table's time column using Connector/ODBC, a syntax error was thrown if there was an hour value larger than 99. This fix makes sure the proper error is thrown, and when an hour value is larger than 23. (Bug #17613161)\n- SQLDescribeCol() returned a memory allocation failure error when called without a resultset. This fix makes sure the proper error is returned. (Bug #17588101)\n- If the catalog name given to SQLSetConnectAttr() was too long, calling SQLConnect() or SQLDriverConnect() crashed the connection, and calling SQLGetConnectAttr() returned null for the catalog name. (Bug #17587913)\n- A memory leak occurred in SQLExecute() when the connection was killed by another thread. (Bug #17587617)\n- The DMG installer for Connector/ODBC failed on OS X 10.8 and 10.9. This fix corrects the wrong identification for the drive type, which caused the installation problem. (Bug #17512040, Bug #70422)\n- A memory leak occurred in SQLSetStmtAttr(). (Bug #17441507)\n- A segmentation fault occurred when SQLColumns()'s argument for table name was longer than 256 characters or its argument for column name was longer than 129 characters. This fix makes Connector/ODBC throw a proper error for those situations. (Bug #17358838)\n- An assertion failure occurred in SQLDescribeCol() if the column number used is larger than the number of columns in the result set. (Bug #17311065)\nMySQL Connector/ODBC Release Notes\n\n• A memory leak occurred in SQLProcedureColumns() when no function or procedure column satisfying the selection condition existed. (Bug #17298721)\n\n• A segmentation fault occurred in myodbc_casecmp() when the provided query was empty. (Bug #17085344)\n\n• When using Connector/ODBC in Microsoft Access, sorting a column in the data view might crash the program. (Bug #17071780, Bug #69550)\n\n• When the connection option FLAG_NO_INFORMATION_SCHEMA was used, calling the SQLFetch function after the SQLForeignKeys function returned bad results. (Bug #16920750)\n\n• When building Connector/ODBC on some 64-bit systems other than x86_64 (e.g. ppc64), CMake did not recognize that it was a 64-bit system and incorrectly used lib instead of lib64 as directory name for installing the dynamic library. This fix implements a two-step approach, making CMake check for the system architecture by reading the value of CMAKE_SIZEOF_VOID_P and also by checking the existence of the /usr/lib64 folder. (Bug #16785424)\n\n• The function SQLForeignKeys() did not work if the connection option NO_I_S was set. (Bug #13712420, Bug #64307)\n\n• Implemented a workaround for a control issue with GtkComboBox and GtkComboBoxEntry, in which the dialog control intercepted the keyboard signals, so that focus could be set to other controls using the keyboard.\n\nChanges in MySQL Connector/ODBC 5.3.1 (2013-11-27, Beta)\n\nThis is a beta release for the Connector/ODBC 5.3.x series. The available downloads include both a Unicode driver and an ANSI driver based on the same modern codebase. Please select the driver type you need—Unicode or ANSI—based on the type of your application. Server-side prepared statements are enabled by default. It is suitable for use with any MySQL version since 4.1 (it will not work with 4.0 or earlier releases.)\n\nThis is the second release of the MySQL ODBC driver conforming to the ODBC 3.8 specification. It contains the minimally required implementation of the standard with key ODBC 3.8 features, which include self-identification as a ODBC 3.8 driver, streaming of output parameters (supported for binary types only), and support of the SQL_ATTR_RESET_CONNECTION connection attribute (for the Unicode driver only).\n\nConnector/ODBC 5.3 also introduces a GTK+-based setup library, providing GUI DSN setup dialog on some Unix-based systems. The library is currently included in the Oracle Linux 6 and Debian 6 binary packages. Other new features in the 5.3 series include File DSN and bookmark support.\n\nKeep in mind that this is a beta release and, as with any other pre-production releases, cautions should be taken when installing on production level systems or systems with critical data. Not all of the features planned for the final Connector/ODBC 5.3 release are implemented.\n\n• Functionality Added or Changed\n\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• Implemented the SQL_ATTR_RESET_CONNECTION connection attribute, newly introduced in ODBC 3.8. See the ODBC specifications for details. Currently, the connection attribute is supported by the Unicode driver, but not the ANSI driver.\n\nBugs Fixed\n\n• Calling SQLBulkOperations() without setting SQLSetStmtAttr resulted in a segmentation fault. (Bug #17714290)\nMySQL Connector/ODBC Release Notes\n\n- A memory leak occurred when using Connector/ODBC to update the contents of a row. (Bug #17653461, Bug #70662)\n- A bad memory access occurred in the `ssps_get_out_params` function in `my_prepared_stmt.c`, when a call was made to a stored procedure with any `IN` parameters coming after the last `OUT` or `INOUT` parameter. (Bug #17640929, Bug #70642)\n- A memory leak occurred in `SQLConnect()` when it was invoked after a call of `SQLSetConnectAttr()` that used the parameter `SQL_ATTR_CURRENT_CATALOG`. (Bug #17586844)\n- In ODBCManageDataSourcesQ4, when creating a new DSN with a Unix socket instead of a TCP connection, `NAMED_PIPE` was set to “1” in the created DSN, which caused all connections that used the DSN to fail with the “Wrong or unknown protocol” error. (Bug #17586452)\n\nChanges in MySQL Connector/ODBC 5.3.0 (2013-10-24, Alpha)\n\nThis is an alpha release for the Connector/ODBC 5.3.x series. The available downloads include both a Unicode driver and an ANSI driver within the same package (the two drivers are no longer shipped separately). Server-side prepared statements are enabled by default. It is suitable for use with any MySQL version since 4.1 (it will not work with 4.0 or earlier releases).\n\nThis is the first MySQL ODBC driver series conforming to the ODBC 3.8 specification. It contains the minimally required implementation of the standard with key 3.8 features, which includes driver self-identification and the streaming of output parameters (supported for binary types only) in this alpha release.\n\nConnector/ODBC 5.3 also introduces a GTK+-based setup library, providing GUI DSN setup dialog on some Unix-based systems. The library is currently included in the Oracle Linux 6 and Debian 6 binary packages. Other new features in the 5.3 series include File DSN and bookmark support.\n\nThe release is built against the MySQL server 5.6.14 client library.\n\nKeep in mind that this is an alpha release and, as with any other pre-production releases, cautions should be taken when installing on production level systems or systems with critical data. Not all of the features planned for the final Connector/ODBC 5.3 release are implemented.\n\n- **Functionality Added or Changed**\n- **Bugs Fixed**\n\nFunctionality Added or Changed\n\n- Added a lock in the `ENV` structure against simultaneous accesses to an environment handle’s connection list, in order to avoid memory access issues that might occur when multiple threads share the same environment handle. (Bug #17240611, Bug #69864)\n- Support for File Data Source Names. (Bug #11746219, Bug #24581)\n- Support of ODBC 3.8 standard: driver self-identification and input/output stream parameters\n- Added GUI DSN setup dialog for some Unix-based systems by implementing a GTK+-based setup library.\n- Added a new test module for crash bugs (`my_crash.c`).\n- Added new variable in CMake configuration files `ODBCCP32_LIB` for `odbccpp32.lib` path, and added `MYSQLCLIENT_LIB_NAME` for linking MySQL client library statically or dynamically by specifying the MySQL client library (`libmysql.*`, `mysqlclient.*`, `libmysqlclient_r.*`, `libmysqlclient.*`) to be used. Linkage to MySQL 5.6.4 and later is now by C++, because `libmysqlclient_r` has become a C++ library since.\n- Bookmark support added in Connector/ODBC.\nBugs Fixed\n\n- A memory leak occurred in `fetch_varlength_columns()` while calling `SQLExecDirect()`, because freeing `result_bind` buffers requires `field_count`, which was set to “0” when `mysql_stmt_free_result()` was called. This fix frees `result_bind` buffers before calling `mysql_stmt_free_result()`. (Bug #17441296)\n\n- A program using parameter markers might crash with a segmentation fault. To avoid the problem, this fix changes the argument `length` in the function `convert_c_type2str()` to be a pointer to a long integer. (Bug #17400483, Bug #70113)\n\n- Memory leaks occurred in `SQLPrepare()` and `SQLExecDirect()` when `SQLBindParameter` was used on the SQL statements. This fix frees previous results of `mysql_stmt_result_metadata()` in order to prevent the memory leaks. (Bug #17016839, Bug #69545)\n\n- When `SQL_TIME` data was converted to the `C` data type of `TIMESTAMP`, if the value of the `hour` field is greater than 24, the date fields did not get set to the current date and the `fraction` field for seconds did not get set to zero as required by the ODBC specifications. (Bug #17016839, Bug #69545)\n\n- When trying to create a linked server in Microsoft SQL Server 2008 to a MySQL server set up with Connector/ODBC as a DSN, the Microsoft SQL Server (if it is a 64-bit version) crashed or the linked server suffered a catastrophic failure (if a 32-bit version of the Microsoft SQL Server is used). (Bug #16604346, Bug #63386)\n\n- When reading `TIME` column data using the `SQLGetData` method into the `SQL_C_TYPE_TIME` datatype, errors occurred when the time string contained more than 6-digits (e.g., `120:53:44`). (Bug #16176981, Bug #67793)\n\n- When called after `SQLPrepare`, the function `SQLMoreResults` returned `SQL_ERROR`, instead of `SQL_NO_DATA` as required by the ODBC specification. (Bug #16101282, Bug #67920)\n\n- Connector/ODBC used the “;” character instead of a null byte (“\\0”) to terminate keyword-value pairs in attribute strings. (Bug #15940689, Bug #66548)\n\n- When using the Unicode-enabled version of the Connector/ODBC driver to connect to any MySQL server of version 5.5.2 or older, all statements failed with the error message “Server does not support 4-byte encoded UTF8 characters.” (Bug #14838690, Bug #67428)\n\n- The configured values of a DSN's parameters overrode the values provided through the connection string, instead of the other way round. (Bug #11760574, Bug #52996)\n\nChanges in MySQL Connector/ODBC Version 5.2\n\nMySQL Connector/ODBC offers the choice of a Unicode-enabled or ANSI driver, both built on the same modern, ODBC-compliant codebase. Consider upgrading if you have remained on Connector/ODBC 3.51 because of the performance edge of the ANSI driver.\n\nChanges in MySQL Connector/ODBC 5.2.8 (2015-05-06, General Availability)\n\nSecurity Notes\n\n- Connector/ODBC 5.2 Commercial has been updated to use OpenSSL version 1.0.1m, which has been publicly reported as not vulnerable to CVE-2015-0286.\nSince the only change in Connector/ODBC 5.2.8 is the inclusion of OpenSSL libraries publicly reported as unaffected by CVE-2015-0286, and since Oracle-produced MySQL Community builds use YaSSL libraries which have been reported as not affected by CVE-2015-0286, Oracle will not produce builds for Connector/ODBC Community for version 5.2.8. This means the Community edition of Connector/ODBC will skip version 5.2.8. (Bug #20747740)\n\n**Changes in MySQL Connector/ODBC 5.2.7 (2014-05-13, General Availability)**\n\n- **Heartbleed Bug**\n- **Bugs Fixed**\n\n**Heartbleed Bug**\n\n- Connector/ODBC has been updated to use OpenSSL version 1.0.1g, which has been publicly reported as not vulnerable to CVE-2014-0160. Please see Oracle Note #1645479.1 for further details. (Bug #18533200)\n\n**Bugs Fixed**\n\n- The functions `SQLSetDescField()`, `SQLGetDiagField()`, and `SQLGetDiagRec()` crashed when a null pointer was passed as a handle for those functions. This fix makes the functions check if the passed pointer is null before using it. (Bug #18431088)\n- The order of the control elements was wrong during control selection in Connector/ODBC's Windows GUI. (Bug #18240696)\n- Calling `SQLNumResultCols()` with a NULL parameter resulted in a segmentation fault. (Bug #18165197)\n- Connector/ODBC's GUI dialog could not be opened from within `ODBCManageDataSourcesQ4` for editing an existing DSN. (Bug #18046123)\n- `myodbc-installer` did not initialize the allocated memory. This fix flushes the buffer with “\\0” for initialization. (Bug #18046120)\n- Connector/ODBC crashed when trying to prepare a query after connecting to the server with an invalid value for `CHARSET`. This fix checks the CHARSET value and throws an error if it is invalid. (Bug #17999659)\n- At a `malloc()` failure, Connector/ODBC crashed because in the `driver_new()` function, `driver` is being freed before `driver->name` and `driver->lib`. This fix corrects the order of the free() calls. (Bug #17992912)\n- Driver and installer crashed when the path lengths supplied were longer than 256 characters or when the option strings were longer than 100 characters. This fix makes Connector/ODBC return the proper errors instead. (Bug #17966018)\n- A segmentation fault occurred in `SQLSpecialColumns()` if the table name supplied was too long. This fix makes Connector/ODBC throw a proper error for the situation. (Bug #17854697)\n- A memory leak occurred when using Connector/ODBC to update the contents of a row. (Bug #17653461, Bug #70662)\n- A bad memory access occurred in the `ssps_get_out_params` function in `my_prepared_stmt.c`, when a call was made to a stored procedure with any `IN` parameters coming after the last `OUT` or `INOUT` parameter. (Bug #17640929, Bug #70642)\n- If Connector/ODBC was built from source on Unix/Linux platforms, the tests provided in the distribution (see Testing Connector/ODBC on Unix) could not be run with `make test`. (Bug #17615811, Bug #70634)\nMySQL Connector/ODBC Release Notes\n\n• SQLDescribeCol() returned a memory allocation failure error when called without a resultset. This fix makes sure the proper error is returned. (Bug #17588101)\n\n• If the catalog name given to SQLSetConnectAttr() was too long, calling SQLConnect() or SQLDriverConnect() crashed the connection, and calling SQLGetConnectAttr() returned null for the catalog name. (Bug #17587913)\n\n• A memory leak occurred in SQLExecute() when the connection was killed by another thread. (Bug #17587617)\n\n• A memory leak occurred in SQLConnect() when it was invoked after a call of SQLSetConnectAttr() that used the parameter SQL_ATTR_CURRENT_CATALOG. (Bug #17586844)\n\n• The DMG installer for Connector/ODBC failed on OS X 10.8 and 10.9. This fix corrects the wrong identification for the drive type, which caused the installation problem. (Bug #17512040, Bug #70422)\n\n• A memory leak occurred in SQLSetStmtAttr(). (Bug #17441507)\n\n• A segmentation fault occurred when SQLColumns()'s argument for table name was longer than 256 characters or its argument for column name was longer than 129 characters. This fix makes Connector/ODBC throw a proper error for those situations. (Bug #17358838)\n\n• An assertion failure occurred in SQLDescribeCol() if the column number used is larger than the number of columns in the result set. (Bug #17311065)\n\n• A memory leak occurred in SQLProcedureColumns() when no function or procedure column satisfying the selection condition existed. (Bug #17298721)\n\n• A segmentation fault occurred in myodbc_casecmp() when the provided query was empty. (Bug #17085344)\n\n• When using Connector/ODBC in Microsoft Access, sorting a column in the data view might crash the program. (Bug #17071780, Bug #69550)\n\n• When the connection option FLAG_NO_INFORMATION_SCHEMA was used, calling the SQLFetch function after the SQLForeignKeys function returned bad results. (Bug #16920750)\n\n• When building Connector/ODBC on some 64-bit systems other than x86_64 (e.g. ppc64), CMake did not recognize that it was a 64-bit system and incorrectly used lib instead of lib64 as directory name for installing the dynamic library. This fix implements a two-step approach, making CMake check for the system architecture by reading the value of CMAKE_SIZEOF_VOID_P and also by checking the existence of the /usr/lib64 folder. (Bug #16785424)\n\n• The function SQLForeignKeys() did not work if the connection option NO_I_S was set. (Bug #13712420, Bug #64307)\n\n• Calling the SQLGetDiagField function with the DiagIdentifier SQL_DIAG_ROW_COUNT always returned “0,” even if there were updated, deleted, or modified rows. (Bug #11750296)\n\nChanges in MySQL Connector/ODBC 5.2.6 (2013-10-09, General Availability)\n\n• Functionality Added or Changed\n\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• Added a lock in the ENV structure against simultaneous accesses to an environment handle's connection list, in order to avoid memory access issues that might occur when multiple threads share the same environment handle. (Bug #17240611, Bug #69864)\nBugs Fixed\n\n- A memory leak occurred in `fetch_varlength_columns()` while calling `SQLExecDirect()`, because freeing `result_bind` buffers requires `field_count`, which was set to “0” when `mysql_stmt_free_result()` was called. This fix frees `result_bind` buffers before calling `mysql_stmt_free_result()`. (Bug #17441296)\n\n- A program using parameter markers might crash with a segmentation fault. To avoid the problem, this fix changes the argument `length` in the function `convert_c_type2str()` to be a pointer to a long integer. (Bug #17421620, Bug #69733)\n\n- Memory leaks occurred in `SQLPrepare()` and `SQLExecDirect()` when `SQLBindParameter` was used on the SQL statements. This fix frees previous results of `mysql_stmt_result_metadata()` in order to prevent the memory leaks. (Bug #17400483, Bug #70113)\n\n- The exit condition for a `for` loop in `stringutil.c` is changed to avoid a possible out-of-bounds error and the associated reports by Valgrind. (Bug #17397596, Bug #64105)\n\n- Microsoft Visual Studio 2010 crashed when reading rows from any table in Server Explorer with connections to DSNs made by Connector/ODBC. (Bug #17304031, Bug #69950)\n\n- When SQL `TIME` data was converted to the C data type of `TIMESTAMP`, if the value of the `hour` field is greater than 24, the date fields did not get set to the current date and the `fraction` field for seconds did not get set to zero as required by the ODBC specifications. (Bug #17016839, Bug #69545)\n\n- When trying to create a linked server in Microsoft SQL Server 2008 to a MySQL server set up with Connector/ODBC as a DSN, the Microsoft SQL Server (if it is a 64-bit version) crashed or the linked server suffered a catastrophic failure (if a 32-bit version of the Microsoft SQL Server is used). (Bug #16604346, Bug #69545)\n\n- When reading `TIME` column data using the `SQLGetData` method into the `SQL_C_TYPE_TIME` datatype, errors occurred when the time string contained more than 6-digits (e.g., 120:53:44). (Bug #16176981, Bug #63386)\n\n- When called after `SQLPrepare`, the function `SQLMoreResults` returned `SQL_ERROR`, instead of `SQL_NO_DATA` as required by the ODBC specification. (Bug #16101282, Bug #67920)\n\n- Connector/ODBC used the ‘;’ character instead of a null byte (‘\\0’) to terminate keyword-value pairs in attribute strings. (Bug #15940689, Bug #66548)\n\n- When using the Unicode-enabled version of the Connector/ODBC driver to connect to any MySQL server of version 5.5.2 or older, all statements failed with the error message “Server does not support 4-byte encoded UTF8 characters.” (Bug #14838690, Bug #67428)\n\n- The configured values of a DSN's parameters overrode the values provided through the connection string, instead of the other way round. (Bug #11760574, Bug #52996)\n\nChanges in MySQL Connector/ODBC 5.2.5 (2013-05-02, General Availability)\n\n- **Functionality Added or Changed**\n\n- **Bugs Fixed**\n\n**Functionality Added or Changed**\n\n- Clear text authentication to MySQL servers is now supported by Connector/ODBC. The support is controlled by the new `Enable Cleartext Authentication` connection option (with the flag name `ENABLE_CLEARTEXT_PLUGIN`). (Bug #16445091)\nBugs Fixed\n\n- A data connection could not be opened in Microsoft Word 2010 for mail merges that attempted to use an ODBC DSN. (Bug #16526604, Bug #63844)\n\n- The `query_print()` function could cause a serious error on 32-bit systems due to a 32-bit / 64-bit mismatch in its return value. This error could occur when logging was enabled, for example when using configuration settings such as:\n\n ![Driver]\n option=524292\n\n (Bug #16367440, Bug #68201)\n\n- Trailing zeros for the fractional part of the second for `datetime` and `timestamp` values were not removed for MySQL server version 5.5 or earlier, which do not support fractional second. (Bug #16294197, Bug #65418)\n\n- Microsoft Access could experience a severe error when updating a `BIT` column in view representing a MySQL table, for example through the datasheet interface. (Bug #16287859, Bug #68243)\n\n- When binding text data to a numeric or decimal field with `SQLBindParameter`, Connector/ODBC always used the system locale to determine the thousands and decimal separators. This resulted in errors when, for example, a decimal separator in a number expressed in the British or American notation (\".\") is treated as a thousands separator and removed during the binding because Connector/ODBC was running on a non-English OS. To avoid the error, this fix makes Connector/ODBC use the comma (\",\" ) as the thousands separator and the period (\".\") as the decimal separator for binding if the `FLAG_NO_LOCALE` connection option is set; if the option is not set, Connector/ODBC continues to follow the system locale in interpreting and binding the numbers. (Bug #11766369, Bug #59469)\n\nChanges in MySQL Connector/ODBC 5.2.4 (2013-02-05, General Availability)\n\nThis release fixes any bugs encountered since Connector/ODBC 5.2.3. Its main focus is on compatibility with the latest features of MySQL 5.6.\n\n- Functionality Added or Changed\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- The following reserved words were added to the list returned by the `SQLGetInfo()` ODBC function, for compatibility with the latest MySQL 5.6 syntax:\n - `GET`\n - `IO_AFTER_GTIDS`\n - `IO_BEFORE_GTIDS`\n - `MASTER_BIND`\n - `ONE_SHOT`\n - `PARTITION`\n - `SQL_AFTER_GTIDS`\n - `SQL_BEFORE_GTIDS`\n\n- The new connection option `can_handle_exp_pwd` indicates that your application includes error-handling logic to deal with the error code for an expired password. See Connector/ODBC Connection\nParameters for the details of this connection option and the associated SQL state and native error code. See AL{TER USER Statement for details about password expiration for MySQL server accounts.\n\nThis new option is added to the Windows GUI, through a check box Can Handle Expired Password on the Connection tab of the Details dialog.\n\nBugs Fixed\n\n- When a column with type TINYTEXT, TEXT, MEDIUMTEXT, or LONGTEXT was retrieved from a table with a binary collation, the text fields were converted to a hexadecimal representation, even though these values were not really BLOBs. The unnecessary conversion could expand the data, causing overflow problems when storing the result values. (Bug #11746572, Bug #27282)\n\nChanges in MySQL Connector/ODBC 5.2.3 (2013-01-04, General Availability)\n\nThis release fixes any bugs encountered since Connector/ODBC 5.2.2.\n\nBugs Fixed\n\n- Insert operations could fail if the inserted values contained any bit fields, mapped to table columns declared as bit(1):\n\n Data too long for column 'column_name'\n\n (Bug #15997361, Bug #67702)\n\n- Compilation failure was observed for driver/handle.c on the Oracle Linux platform. This was due to the use of the function bzero(), which could cause problems on some platforms. This fix replaces the bzero() call with a memset() call. (Bug #15939629)\n\n- The is_minimum_version function could return an incorrect result in some cases where the difference was in the third component of the release number. (Bug #15926340)\n\n- An application making extensive use of prepared statements could encounter an error:\n\n Can't create more than max_prepared_stmt_count statements (current value: 16382)\n\n The issue occurred even if SQLFreeStmt() calls were used. The Prepared_stmt_count value grew until it exceeded the internal limit. A workaround was to disable server-side prepared statements. (Bug #14812778, Bug #67340)\n\n- The symbols SQLInstallDriverEx, SQLInstallDriverExW, and SQLRemoveDriverW were exported, causing incompatibility with some commercial ODBC packages such as DataDirect ODBC, and making Connector/ODBC dependent on the unixODBC library libodbcinst.so.1. This issue was first observed in Connector/ODBC 5.1.8. (Bug #11766724, Bug #59900)\n\n- On a 64-bit system, calls to the SQLBindCol function using indicator variables (through the last parameter) could return incorrect results. (Bug #11766437, Bug #59541)\n\nChanges in MySQL Connector/ODBC 5.2.2 (2012-09-20, General Availability)\n\nThis is the first GA release for the Connector/ODBC 5.2.x series. Now the available downloads include both a Unicode driver and an ANSI driver based on the same modern codebase. Server-side stored procedures are enabled by default.\n\n- Functionality Added or Changed\n\n- Bugs Fixed\nFunctionality Added or Changed\n\n- The download page now offers choices of a Unicode driver or an ANSI driver. Now users can get an ANSI driver with the combination of high performance and the latest standard-compliant behavior, rather than staying on the older 3.51 codebase.\n\n- Server-side prepared statements are now enabled by default. To revert to the former behavior, using client-side emulation for prepared statements, specify the `NO_SSPS` option when configuring the DSN.\n\n- The implementation of the `SQLBindParameter()` function was enhanced to support “out” and “inout” parameters when calling stored procedures. Designate the bind parameters intended to hold output values from stored procedures using the type specifiers `SQL_PARAM_OUTPUT` or `SQL_PARAM_INPUT_OUTPUT`.\n\n Note\n Currently, the support for “out” and “inout” parameters does not apply to `LONGTEXT` and `LONGBLOB` columns.\n\nBugs Fixed\n\n- Improved error handling for bad input data, such as an incorrect `SQLSetConnectAttr` length. This fix improves reliability in cases such as an ANSI application using a Unicode driver. (Bug #14620420)\n\n- The string returned by the `SQLNativeSql` function was not null-terminated as it should be. (Bug #14559721)\n\n- After executing a stored procedure returning a combination of resultsets and `OUT` parameters, Connector/ODBC would be disconnected from the server. The issue occurred after fetching the result sets and executing a subsequent query. (Bug #14512187)\n\n- Specifying certain values for the `CHARSET` option in the connection string could cause a serious error when a query was executed. (Bug #14363601)\n\nChanges in MySQL Connector/ODBC 5.2.1 (2012-08-10, Beta)\n\nThis is a beta release for the Connector/ODBC 5.2.x series. Now the available downloads include both a Unicode driver and an ANSI driver based on the same modern codebase. Server-side stored procedures are enabled by default.\n\n- Functionality Added or Changed\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- Built against the MySQL server 5.5.27 client library.\n\n- Support of `INOUT` and `OUT` parameters.\n\n- Driver prepares statements on server.\n\nBugs Fixed\n\n- Close proximity issue when handling OS signals in myodbc. (Bug #14303803)\n\n- Several catalog or info functions could raise an incorrect error `String data, right truncated` when only partial information was requested. For example, if the application called `SQLDescribeCol(hstmt, ColNumber, ColName, BufferLen, ....)`, but did not want the column name (`ColName == NULL` and `BufferLen == 0`). `SQL_SUCCESS_WITH_INFO` could also\nbe returned rather than the correct value `SQL_SUCCESS`. This issue affected many ADO, DAO, and other applications.\n\nAffected functions include:\n\n<table>\n<thead>\n<tr>\n<th>Spurious error and incorrect return code:</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SQLDescribeCol</td>\n</tr>\n<tr>\n<td>SQLDescribeColA</td>\n</tr>\n<tr>\n<td>SQLDescribeColW</td>\n</tr>\n<tr>\n<td>SQLGetInfoA</td>\n</tr>\n<tr>\n<td>SQLGetInfoW</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Incorrect return code:</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SQLColAttribute</td>\n</tr>\n<tr>\n<td>SQLColAttributeW</td>\n</tr>\n<tr>\n<td>SQLGetConnectAttr</td>\n</tr>\n<tr>\n<td>SQLGetConnectAttrW</td>\n</tr>\n<tr>\n<td>SQLGetCursorName</td>\n</tr>\n<tr>\n<td>SQLGetCursorNameW</td>\n</tr>\n<tr>\n<td>SQLGetInfo</td>\n</tr>\n<tr>\n<td>SQLGetInfoW</td>\n</tr>\n<tr>\n<td>SQLNativeSql</td>\n</tr>\n<tr>\n<td>SQLNativeSqlW</td>\n</tr>\n</tbody>\n</table>\n\n(Bug #14285620)\n\n- Long table names crash OBDC driver. (Bug #14085211, Bug #65200)\n\n### Changes in MySQL Connector/ODBC Version 5.1\n\n#### Changes in MySQL Connector/ODBC 5.1.14 (Not yet released)\n\nVersion 5.1.14 has no release notes, or they have not been published because the product version has not been released.\n\n#### Changes in MySQL Connector/ODBC 5.1.13 (2013-10-16)\n\n- **Functionality Added or Changed**\n- **Bugs Fixed**\n\n### Functionality Added or Changed\n\n- Added a lock in the `ENV` structure against simultaneous accesses to an environment handle’s connection list, in order to avoid memory access issues that might occur when multiple threads share the same environment handle. (Bug #17240611, Bug #69864)\n\n- Clear text authentication to MySQL servers is now supported by Connector/ODBC. The support is controlled by the new `Enable Cleartext Authentication` connection option (with the flag name `ENABLE_CLEARTEXT_PLUGIN`). (Bug #16445091)\n\n### Bugs Fixed\n\n- The exit condition for a `for` loop in `stringutil.c` is changed to avoid a possible out-of-bounds error and the associated reports by Valgrind. (Bug #17397596, Bug #64105)\n\n- Microsoft Visual Studio 2010 crashed when reading rows from any table in Server Explorer with connections to DSNs made by Connector/ODBC. (Bug #17304031, Bug #69950)\n\n- When trying to create a linked server in Microsoft SQL Server 2008 to a MySQL server set up with Connector/ODBC as a DSN, the Microsoft SQL Server (if it is a 64-bit version) crashed or the linked server suffered a catastrophic failure (if a 32-bit version of the Microsoft SQL Server is used). (Bug #16604346, Bug #63386)\n• A data connection could not be opened in Microsoft Word 2010 for mail merges that attempted to use an ODBC DSN. (Bug #16526604, Bug #63844)\n\n• Trailing zeros for the fractional part of the second for datetime and timestamp values were not removed for MySQL server version 5.5 or earlier, which do not support fractional second. (Bug #16294197, Bug #65418)\n\n• Connector/ODBC used the “;” character instead of a null byte (“\\0”) to terminate keyword-value pairs in attribute strings. (Bug #15940689, Bug #66548)\n\n• The configured values of a DSN’s parameters overrode the values provided through the connection string, instead of the other way round. (Bug #11760574, Bug #52996)\n\n### Changes in MySQL Connector/ODBC 5.1.12 (2013-02-05)\n\n- **Functionality Added or Changed**\n- **Bugs Fixed**\n\n#### Functionality Added or Changed\n\n• The following reserved words were added to the list returned by the SQLGetInfo() ODBC function, for compatibility with the latest MySQL 5.6 syntax:\n - GET\n - IO_AFTER_GTIDS\n - IO_BEFORE_GTIDS\n - MASTER_BIND\n - ONE_SHOT\n - PARTITION\n - SQL_AFTER_GTIDS\n - SQL_BEFORE_GTIDS\n\n• The new connection option can_handle_exp_pwd indicates that your application includes error-handling logic to deal with the error code for an expired password. See Connector/ODBC Connection Parameters for the details of this connection option and the associated SQL state and native error code. See ALTER USER Statement for details about password expiration for MySQL server accounts.\n\nThis new option is added to the Windows GUI, through a check box Can Handle Expired Password on the Connection tab of the Details dialog.\n\n#### Bugs Fixed\n\n• The string returned by the SQLNativeSql function was not null-terminated as it should be. (Bug #14559721)\n\n• Specifying certain values for the CHARSET option in the connection string could cause a serious error when a query was executed. (Bug #14363601)\n\n• If multiple statements were called using the same statement handle, SQLColumns and possibly other catalog functions could return wrong results. Some field length values were not reset in the descriptor records. The issue occurred even if the statement handle was closed with SQL_CLOSE between the statements. (Bug #14338051)\n• If an application received a `SIGPIPE` signal, then another `SIGPIPE` signal immediately after (before the first signal handler was finished), the application could terminate rather than handling the second signal. (Bug #14303803)\n\n• Several catalog or info functions could raise an incorrect error `String data, right truncated` when only partial information was requested. For example, if the application called `SQLDescribeCol(hstmt, ColNumber, ColName, BufferLen, ...)`, but did not want the column name (`ColName == NULL` and `BufferLen == 0`). `SQL_SUCCESS_WITH_INFO` could also be returned rather than the correct value `SQL_SUCCESS`. This issue affected many ADO, DAO, and other applications.\n\nAffected functions include:\n\n<table>\n<thead>\n<tr>\n<th>Spurious error and incorrect return code:</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SQLDescribeCol</td>\n</tr>\n<tr>\n<td>SQLDescribeColA</td>\n</tr>\n<tr>\n<td>SQLDescribeColW</td>\n</tr>\n<tr>\n<td>SQLGetInfoA</td>\n</tr>\n<tr>\n<td>SQLGetInfoW</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>Incorrect return code:</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SQLColAttribute</td>\n</tr>\n<tr>\n<td>SQLColAttributeW</td>\n</tr>\n<tr>\n<td>SQLGetConnectAttr</td>\n</tr>\n<tr>\n<td>SQLGetConnectAttrW</td>\n</tr>\n<tr>\n<td>SQLGetCursorName</td>\n</tr>\n<tr>\n<td>SQLGetCursorNameW</td>\n</tr>\n<tr>\n<td>SQLGetInfo</td>\n</tr>\n<tr>\n<td>SQLGetInfoW</td>\n</tr>\n<tr>\n<td>SQLNativeSql</td>\n</tr>\n<tr>\n<td>SQLNativeSqlW</td>\n</tr>\n</tbody>\n</table>\n\n(Bug #14285620)\n\n• Calling the `SQLTables` function with a very long database or table name could cause a serious error. This fix allows the `SQLTables` function to accept database and table names with the maximum length of 64 characters. (Bug #14085211)\n\n• The symbols `SQLInstallDriverEx`, `SQLInstallDriverExW`, and `SQLRemoveDriverW` were exported, causing incompatibility with some commercial ODBC packages such as DataDirect ODBC, and making Connector/ODBC dependent on the `unixODBC` library `libodbcinst.so.1`. This issue was first observed in Connector/ODBC 5.1.8. (Bug #11766724, Bug #59900)\n\n• On a 64-bit system, calls to the `SQLBindCol` function using indicator variables (through the last parameter) could return incorrect results. (Bug #11766437, Bug #59541)\n\n• When a column with type `TINYTEXT`, `TEXT`, `MEDIUMTEXT`, or `LONGTEXT` was retrieved from a table with a binary collation, the text fields were converted to a hexadecimal representation, even though these values were not really BLOBs. The unnecessary conversion could expand the data, causing overflow problems when storing the result values. (Bug #11746572, Bug #27282)\n\nChanges in MySQL Connector/ODBC 5.1.11 (2012-04-30)\n\n• Functionality Added or Changed\n\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• A new connection option, `prefetch`, allows applications to scroll through large query result sets, \\( N \\) records at a time. See Connector/ODBC Connection Parameters for details.\nBugs Fixed\n\n- The `SQLTables()` function did not return the catalog correctly if the wildcard or `SQL_ALL_CATALOGS` was used. (Bug #13914518)\n\n- Fractional seconds part of timestamp was ignored in prepared statements that use `SQLBindParameter` and `SQL_C_TIMESTAMP` type. For example, a prepared query comparing two timestamp values that only differed in the fractional part would consider the values identical. (Bug #12767761, Bug #60648)\n\n- The `fraction` member in `SQL_TIMESTAMP_STRUCT` was always set to 0 when a timestamp was retrieved using `SQLGetData()`. The fix causes the `fraction` member to be correctly set, with a value representing nanoseconds. This issue did not occur when a result was retrieved as a string (`SQLGetData()` with `SQL_C_CHAR`). (Bug #12767740, Bug #60646)\n\n- On Windows platforms, some memory was leaked on each connection attempt due to an incorrect response to a `SQLGetDiagRec()` call. (Bug #11766029, Bug #59059)\n\nChanges in MySQL Connector/ODBC 5.1.10 (2012-02-02)\n\nBugs Fixed\n\n- `SQLFetch` has to return error if indicator pointer is `NULL` for `NULL` value. (Bug #13542600)\n\n- In some cases, a `TIMESTAMP` field could be described as `SQL_NO_NULLS`. (Bug #13532987)\n\n- A failure on one statement causes another statement to fail. (Bug #13097201, Bug #62657)\n\nChanges in MySQL Connector/ODBC 5.1.9 (2011-10-06)\n\nOnly the source code and Windows binaries are available with this release.\n\nThe 64-bit MSI installer no longer contains 32-bit and 64-bit builds of the driver, like it did in previous versions. It now only includes 64-bit support.\n\n- Pluggable Authentication Notes\n\n- Bugs Fixed\n\nPluggable Authentication Notes\n\n- The binaries for this distribution of Connector/ODBC can now connect to MySQL server accounts that use the PAM or Windows Native Authentication Plugins for authentication. See PAM Pluggable Authentication, and Windows Pluggable Authentication. These capabilities result from linking the Connector/ODBC binaries against the MySQL 5.5.16 libmysqlclient rather than the MySQL 5.1 libmysqlclient used previously. The newer `libmysqlclient` includes the client-side support needed for the server-side PAM and Windows authentication plugins.\n\nBugs Fixed\n\n- Some catalog functions (such as `SQLColumns()`, `SQLStatistics()`, and `SQLPrimaryKeys()`) would only return one row, when called after pre-execution failed. (Bug #12824839)\n\n- The CLI installer script `mysqlodbc-installer` was missing documentation about how to configure the optional data source parameters. (Bug #12810058)\n\n- The `Install.bat` script contained leftover 3.51 information, and did not properly install the 5.1 Connector/ODBC connector. (Bug #12781039)\n\n- With the option `charset=cp1251` specified in the connection string, the results could be returned as `CP1251` or as `UTF8` depending on the query. For example, these queries could give results in different code pages:\nMySQL Connector/ODBC Release Notes\n\nselect if(1=1,'string in cp1251 code page','') as 'string in cp1251 code page';\nselect 'string in cp1251 code page' as 'string in cp1251 code page';\n\n(Bug #11765110, Bug #58038)\n\n• An off-by-one error, where sqlwcharchr might read one SQLWCHAR after the end of a string. (Bug #61586)\n\n• SQLExecute would return SQL_SUCCESS_WITH_INFO instead of SQL_ERROR, when column parameter binding was enabled. (Bug #59772)\n\n• The Connector/ODBC driver did not call mysql_thread_end() when a thread ended, which caused error messages like: Error in my_thread_global_end(): 1 threads didn't exit. (Bug #57727)\n\n• When using Connector/ODBC to fetch data, if a net_write_timeout condition occurred, the operation returned the standard \"end of data\" status, rather than an error. (Bug #39878)\n\n• MS Access fields with VARCHAR NOT NULL columns could not be altered. (Bug #31067)\n\nChanges in MySQL Connector/ODBC 5.1.8 (2010-11-07)\n\n• Functionality Added or Changed\n\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• Documentation in .CHM and .HLP format has been removed from the distribution. (Bug #56232)\n\nBugs Fixed\n\n• For some procedure and parameter combinations SQLProcedureColumns() did not work correctly. For example, it could not return records for an existing procedure with correct parameters supplied.\n\nFurther, it returned incorrect data for column 7, TYPE_NAME. For example, it returned VARCHAR(20) instead of VARCHAR. (Bug #57182)\n\n• The Connector/ODBC MSI installer did not set the InstallLocation value in the Microsoft Windows registry. (Bug #56978)\n\n• In bulk upload mode, SQLExecute would return SQL_SUCCESS, even when the uploaded data contained errors, such as primary key duplication, and foreign key violation. (Bug #56804)\n\n• SQLDescribeCol and SQLColAttribute could not be called before SQLExecute, if the query was parameterized and not all parameters were bound.\n\nNote, MSDN states that “For performance reasons, an application should not call SQLColAttribute/SQLDescribeCol before executing a statement.” However, it should still be possible to do so if performance reasons are not paramount. (Bug #56717)\n\n• When SQLNumResultCols() was called between SQLPrepare() and SQLExecute() the driver ran SET @sql_select_limit=1, which limited the resultset to just one row. (Bug #56677)\n\n• After installing Connector/ODBC, the system DSN created could not be configured or deleted. An error dialog was displayed, showing the error message “Invalid attribute string”.\n\nIn this case the problem was due to the fact that the driver could not parse the NULL-separated connection string. (Bug #56233)\nMySQL Connector/ODBC Release Notes\n\n- When used after a call to SQLTables(), SQLRowcount() did not return the correct value. (Bug #55870)\n\n- When attempting to install the latest Connector/ODBC 5.1.6 on Windows using the MSI, with an existing 5.1.x version already installed, the following error was generated:\n\n Another version of this product is already installed. Installation of this version cannot continue. To configure or remove the existing version of this product, use Add/Remove Programs on the Control Panel.\n\n Also, the version number displayed in the ODBC Data Source Administrator/Drivers tab did not get updated when removing or installing a new version of 5.1.x. (Bug #54314)\n\nChanges in MySQL Connector/ODBC 5.1.7 (2010-08-24)\n\n- Functionality Added or Changed\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- Connector/ODBC has been changed to support the CLIENT_INTERACTIVE flag. (Bug #48603)\n\nBugs Fixed\n\n- SQLColAttribute(SQL_DESC_PRECISION...) function returned incorrect results for type identifiers that have a negative value:\n\n | #define SQL_LONGVARCHAR (-1) returned 4294967295 |\n | #define SQL_BINARY (-2) returned 4294967294 |\n | #define SQL_VARBINARY (-3) returned 4294967293 |\n | #define SQL_LONGVARBINARY (-4) returned 4294967292 |\n | #define SQL_BIGINT (-5) returned 4294967291 |\n | #define SQL_TINYINT (-6) returned 4294967290 |\n | #define SQL_BIT (-7) returned 4294967289 |\n\n They were returned as 32-bit unsigned integer values. This only happened on 64-bit Linux. (Bug #55024)\n\n- SQLColAttribute for SQL_DESC_OCTET_LENGTH returned length including terminating null byte. It should not have included the null byte. (Bug #54206)\n\n- The SQLColumns function returned the incorrect transfer octet length into the column BUFFER_LENGTH for DECIMAL type. (Bug #53235)\n\n- SQLForeignKeys() did not return the correct information. The list of foreign keys in other tables should not have included foreign keys that point to unique constraints in the specified table. (Bug #51422)\n\n- When executing the SQLProcedureColumns() ODBC function, the driver reported the following error:\n\n MySQL server does not provide the requested information\n\n (Bug #50400)\n\n- In contrast to all other ODBC catalog functions SQLTablePrivileges required the user to have SELECT privilege on MySQL schemata, otherwise the function returned with an error:\n\n SQL Error. Native Code: 1142, SQLState: HY000, Return Code: -1\n [MySQL][ODBC 5.1 Driver][mysqld-5.0.67-community-nt]SELECT command denied to user 'repadmin'@'localhost' for table 'tables_priv'\n [Error][SQL Error]Error executing SQLTablePrivileges for object cat: myrep, object Name: xxxxxxxxxx\nMySQL Connector/ODBC Release Notes\n\n(Bug #50195)\n\n• Connector/ODBC manually added a `LIMIT` clause to the end of certain SQL statements, causing errors for statements that contained code that should be positioned after the `LIMIT` clause. (Bug #49726)\n\n• If `NO_BACKSLASH_ESCAPES` mode was used on a server, escaping binary data led to server query parsing errors. (Bug #49029)\n\n• Bulk upload operations did not work for queries that used parameters. (Bug #48310)\n\n• Retrieval of the current catalog at the moment when a connection was not ready, such as when the connection had been broken or when not all pending results had been processed, resulted in the application crashing. (Bug #46910)\n\n• Describing a view or table caused `SQLPrepare` to prefetch table data. For large tables this created an intolerable performance hit. (Bug #46411)\n\n• If an application was invoked by the root user, `SQLDriverConnect()` was not able to use the username and password in the connection string to connect to the database. (Bug #45378)\n\n• Calling `SQLColAttribute` on a date column did not set `SQL_DESC_DATETIME_INTERVAL_CODE`. `SQLColAttribute` returned `SQL_SUCCESS` but the integer passed in was not set to `SQL_CODE_DATE`. (Bug #44576)\n\n• Conversions for many types were missing from the file `driver/info.c`. (Bug #43855)\n\n• The `SQLTables()` function required approximately two to four minutes to return the list of 400 tables in a database. The `SHOW TABLE STATUS` query used by `SQLTables()` was extremely slow for InnoDB tables with a large number of rows because the query was calculating the approximate number of rows in each table. Further, the results could not be cached due to non-deterministic nature of the result set (the row count was re-calculated every time), impacting performance further. (Bug #43664)\n\n• Executing `SQLForeignKeys` to get imported foreign keys for tables took an excessively long time. For example, getting imported foreign keys for 252 tables to determine parent/child dependencies took about 3 minutes and 14 seconds for the 5.1.5 driver, whereas it took 3 seconds for the 3.5.x.x driver. (Bug #39562)\n\n• `SQLDescribeCol` returned incorrect column definitions for `SQLTables` result. (Bug #37621)\n\n• When opening `ADO.Recordset` from Microsoft Access 2003, a run-time error occurred:\n\n```\nErrNo: -2147467259 ErrMessage: Data provider or other service returned an E_FAIL status.\n```\n\n(Bug #36996)\n\n• `SQLPrimaryKeysW` returned mangled strings for table name, column name and primary key name. (Bug #36441)\n\n• On Windows, the SOCKET parameter to the DSN was used as the named pipe name to connect to. This was not exposed in the Windows setup GUI. (Bug #34477)\n\n• Connector/ODBC returned a value of zero for a column with a nonzero value. This happened when the column had a data type of `BIT`, and any numeric type was used in `SQLBindCol`. (Bug #32821)\n\n• Option for handling bad dates was not available in the GUI. (Bug #30539)\n\nChanges in MySQL Connector/ODBC 5.1.6 (2009-11-09)\n\n• Functionality Added or Changed\n\n• Bugs Fixed\nFunctionality Added or Changed\n\n- In the MySQL Data Source Configuration dialog, an excessive number of tabs were required to navigate to selection of a database. Connector/ODBC has been changed to make the tab order more practical, thereby enabling faster configuration of a Data Source. (Bug #42905)\n\nBugs Fixed\n\n- An error randomly occurred on Windows 2003 Servers (German language Version) serving classic ASP scripts on IIS6 MDAC version 2.8 SP2 on Windows 2003 SP2. The application connected to MySQL Server 5.0.44-log with a charset of UTF-8 Unicode (utf8). The MySQL server was running on Gentoo Linux.\n\n The script error occurred sporadically on the following line of code:\n\n ```javascript\n SET my_conn = Server.CreateObject(\"ADODB.Connection\")\n my_conn.Open ConnString <- ERROR\n ```\n\n The connection was either a DSN or the explicit connection string:\n\n ```javascript\n Driver={MySQL ODBC 5.1 Driver};SERVER=abc.abc.abc.abc;DATABASE=dbname;UID=uidname;PWD=pwdname;PORT=3306;OPTION=67108864;\n ```\n\n The error occurred on connections established using either a DNS or a connection string.\n\n When IISState and Debug Diagnostic Tool 1.0.0.152 was used to analyse the code, the following crash analysis was generated:\n\n (Bug #44971)\n\n- Connector/ODBC overwrote the query log. Connector/ODBC was changed to append the log, rather than overwrite it. (Bug #44965)\n\n- Connector/ODBC failed to build with MySQL 5.1.30 due to incorrect use of the data type `bool`. (Bug #42120)\n\n- Inserting a new record using `SQLSetPos` did not correspond to the database name specified in the `SELECT` statement when querying tables from databases other than the current one. `SQLSetPos` attempted to do the `INSERT` in the current database, but finished with a `SQL_ERROR` result and “Table does not exist” message from MySQL Server. (Bug #41946)\n\n- Calling `SQLDescribeCol()` with a NULL buffer and nonzero buffer length caused a crash. (Bug #41942)\n\n- Connector/ODBC updated some fields with random values, rather than with `NULL`. (Bug #41256)\n\n- When a column of type `DECIMAL` containing `NULL` was accessed, Connector/ODBC returned a 0 rather than a `NULL`. (Bug #41081)\n\n- In Access 97, when linking a table containing a `LONGTEXT` or `TEXT` field to a Connector/ODBC DSN, the fields were shown as `TEXT(255)` in the table structure. Data was therefore truncated to 255 characters. (Bug #40932)\n\n- Calling `SQLDriverConnect()` with a NULL pointer for the output buffer caused a crash if `SQL_DRIVER_NOPROMPT` was also specified:\n\n ```javascript\n SQLDriverConnect(dbc, NULL, \"DSN=myodbc5\", SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT)\n ```\n\n (Bug #40316)\n• Setting the ADO Recordset decimal field value to 44.56 resulted in an incorrect value of 445600.0000 being stored when the record set was updated with the Update method. (Bug #39961)\n\n• The SQLTablesW API gave incorrect results. For example, table name and table type were returned as NULL rather than as the correct values. (Bug #39957)\n\n• Connector/ODBC would crash when a character set was being used on the server that was not supported in the client, for example cp1251:\n\n```\n[MySQL][ODBC 5.1 Driver][mysqld-5.0.27-community-nt]Restricted data type attribute violation\n```\n\nThe fix causes Connector/ODBC to return an error message instead of crashing. (Bug #39831)\n\n• Binding SQL_C_BIT to an INTEGER column did not work.\n\n```\nsql_get_data() function only worked correctly for BOOLEAN columns that corresponded to SQL_C_BIT buffers. (Bug #39644)\n```\n\n• When the SQLTables method was called with NULL passed as the tablename parameter, only one row in the resultset, with table name of NULL was returned, instead of all tables for the given database. (Bug #39561)\n\n• The SQLGetInfo() function returned 0 for SQL_CATALOG_USAGE information. (Bug #39560)\n\n• Connector/ODBC 5.1.5 was not able to connect if the connection string parameters contained spaces or tab symbols. For example, if the SERVER parameter was specified as \"SERVER= localhost\" instead of \"SERVER=localhost\" the following error message will be displayed:\n\n```\n[MySQL][ODBC 5.1 Driver] Unknown MySQL server host ' localhost' (11001).\n```\n\n(Bug #39085)\n\n• The pointer passed to the SQLDriverConnect method to retrieve the output connection string length was one greater than it should have been due to the inclusion of the NULL terminator. (Bug #38949)\n\n• Data-at-execution parameters were not supported during positioned update. This meant updating a long text field with a cursor update would erroneously set the value to null. This would lead to the error Column 'column_name' cannot be null while updating the database, even when column_name had been assigned a valid nonnull string. (Bug #37649)\n\n• The SQLDriverConnect method truncated the OutputConnectionString parameter to 52 characters. (Bug #37278)\n\n• The connection string option Enable Auto-reconnect did not work. When the connection failed, it could not be restored, and the errors generated were the same as if the option had not been selected. (Bug #37179)\n\n• Insertion of data into a LONGTEXT table field did not work. If such an attempt was made the corresponding field would be found to be empty on examination, or contain random characters. (Bug #36071)\n\n• No result record was returned for SQLGetTypeInfo for the TIMESTAMP data type. An application would receive the result return code 100 (SQL_NO_DATA_FOUND). (Bug #30626)\n\n• It was not possible to use Connector/ODBC to connect to a server using SSL. The following error was generated:\n\n```\nRuntime error '2147467259 (80004005)'\n\n[MySQL][ODBC 3.51 Driver]SSL connection error.\n```\n\n(Bug #29955)\n• When the \\texttt{recordSet.Update} function was called to update an \\texttt{adLongVarChar} field, the field was updated but the recordset was immediately lost. This happened with driver cursors, whether the cursor was opened in optimistic or pessimistic mode.\n\nWhen the next update was called the test code would exit with the following error:\n\n\\texttt{-2147467259 : Query-based update failed because the row to update could not be found.}\n\n(Bug #26950)\n\n• Microsoft Access was not able to read \\texttt{BIGINT} values properly from a table with just two columns of type \\texttt{BIGINT} and \\texttt{VARCHAR}. \\texttt{#DELETE} appeared instead of the correct values. (Bug #17679)\n\nChanges in MySQL Connector/ODBC 5.1.5 (2008-08-18)\n\nBugs Fixed\n\n• ODBC \\texttt{TIMESTAMP} string format is not handled properly by Connector/ODBC. When passing a \\texttt{TIMESTAMP} or \\texttt{DATE} to Connector/ODBC, in the ODBC format: \\{d <date>\\} or \\{ts <timestamp>\\}, the string that represents this is copied once into the SQL statement, and then added again, as an escaped string. (Bug #37342)\n\n• The connector failed to prompt for additional information required to create a DSN-less connection from an application such as Microsoft Excel. (Bug #37254)\n\n• \\texttt{SQLDriverConnect} does not return \\texttt{SQL_NO_DATA} on cancel. The ODBC documentation specifies that this method should return \\texttt{SQL_NO_DATA} when the user cancels the dialog to connect. The connector, however, returns \\texttt{SQL_ERROR}. (Bug #36293)\n\n• Assigning a string longer than 67 characters to the \\texttt{TableType} parameter resulted in a buffer overrun when the \\texttt{SQLTables()} function was called. (Bug #36275)\n\n• The ODBC connector randomly uses logon information stored in \\texttt{odbc-profile}, or prompts the user for connection information and ignores any settings stored in \\texttt{odbc-profile}. (Bug #36203)\n\n• After having successfully established a connection, a crash occurs when calling \\texttt{SQLProcedures()} followed by \\texttt{SQLFreeStmt()}, using the ODBC C API. (Bug #36069)\n\nChanges in MySQL Connector/ODBC 5.1.4 (2008-04-15)\n\nBugs Fixed\n\n• Wrong result obtained when using \\texttt{sum()} on a \\texttt{decimal(8,2)} field type. (Bug #35920)\n\n• The driver installer could not create a new DSN if many other drivers were already installed. (Bug #35776)\n\n• The \\texttt{SQLColAttribute()} function returned \\texttt{SQL_TRUE} when querying the \\texttt{SQL_DESC_FIXED_PREC_SCALE} \\texttt{(SQL_COLUMN_MONEY)} attribute of a \\texttt{DECIMAL} column. Previously, the correct value of \\texttt{SQL_FALSE} was returned; this is now again the case. (Bug #35581)\n\n• On Linux, \\texttt{SQLGetDiagRec()} returned \\texttt{SQL_SUCCESS} in cases when it should have returned \\texttt{SQL_NO_DATA}. (Bug #33910)\n\n• The driver crashes ODBC Administrator on attempting to add a new DSN. (Bug #32057)\n\nChanges in MySQL Connector/ODBC 5.1.3 (2008-03-26)\n\nBugs Fixed\n\n• \\textbf{Important Change}: In previous versions, the SSL certificate would automatically be verified when used as part of the Connector/ODBC connection. The default mode is now to ignore the verificate\nof certificates. To enforce verification of the SSL certificate during connection, use the \\texttt{SSLVERIFY}\nDSN parameter, setting the value to 1. (Bug \\#29955, Bug \\#34648)\n\n- **Important Change:** You must uninstall previous 5.1.x editions of Connector/ODBC before installing\n the new version.\n\n- Inserting characters to a UTF8 table using surrogate pairs would fail and insert invalid data. (Bug\n \\#34672)\n\n- Installation of Connector/ODBC failed because it was unable to uninstall a previous installed version.\nThe file being requested would match an older release version than any installed version of the\nconnector. (Bug \\#34522)\n\n- Using \\texttt{SqlGetData} in combination with \\texttt{SQL_C_WCHAR} would return overlapping data. (Bug\n \\#34429)\n\n- Descriptor records were not cleared correctly when calling \\texttt{SQLFreeStmt} (\\texttt{SQL_UNBIND}). (Bug\n \\#34271)\n\n- The dropdown selection for databases on a server when creating a DSN was too small. The list size\n now automatically adjusts up to a maximum size of 20 potential databases. (Bug \\#33918)\n\n- Microsoft Access would be unable to use \\texttt{DBEngine.RegisterDatabase} to create a DSN using\n the Connector/ODBC driver. (Bug \\#33825)\n\n- Connector/ODBC erroneously reported that it supported the \\texttt{CAST()} and \\texttt{CONVERT()} ODBC\n functions for parsing values in SQL statements, which could lead to bad SQL generation during a\n query. (Bug \\#33808)\n\n- Using a linked table in Access 2003 where the table has a \\texttt{BIGINT} column as the first column in the\n table, and is configured as the primary key, shows \\#DELETED for all rows of the table. (Bug \\#24535)\n\n- Updating a \\texttt{RecordSet} when the query involves a \\texttt{BLOB} field failed. (Bug \\#19065)\n\n- The HP-UX 11.23 IA64 binary package does not include the GUI bits because of problems building\n Qt on that platform.\n\n- There is no binary package for OS X on 64-bit PowerPC because Apple does not currently provide a\n 64-bit PowerPC version of iODBC.\n\n- The installer for 64-bit Windows installs both the 32-bit and 64-bit driver. Please note that Microsoft\ndoes not yet supply a 64-bit bridge from ADO to ODBC.\n\n**Changes in MySQL Connector/ODBC 5.1.2 (2008-02-13, Beta)**\n\nMySQL Connector/ODBC 5.1.2-beta, a new version of the ODBC driver for the MySQL database\nmanagement system, has been released. This release is the second beta (feature-complete) release of\nthe new 5.1 series and is suitable for use with any MySQL server version since MySQL 4.1, including\nMySQL 5.0, 5.1, and 6.0. (It will not work with 4.0 or earlier releases.)\n\nKeep in mind that this is a beta release, and as with any other pre-production release, caution should\nbe taken when installing on production level systems or systems with critical data.\n\n- **Functionality Added or Changed**\n\n - Explicit descriptors are implemented. (Bug \\#32064)\n\n - A full implementation of SQLForeignKeys based on the information available from\n \\texttt{INFORMATION_SCHEMA} in 5.0 and later versions of the server has been implemented.\n\n - Changed \\texttt{SQL_ATTR_PARAMSET_SIZE} to return an error until support for it is implemented.\nMySQL Connector/ODBC Release Notes\n\n• Disabled `MYSQL_OPT_SSL_VERIFY_SERVER_CERT` when using an SSL connection.\n\n• SQLForeignKeys uses `INFORMATION_SCHEMA` when it is available on the server, which enables more complete information to be returned.\n\n**Bugs Fixed**\n\n• The `SSLCIPHER` option would be incorrectly recorded within the SSL configuration on Windows. (Bug #33897)\n\n• Within the GUI interface, when connecting to a MySQL server on a nonstandard port, the connection test within the GUI failed. The issue was related to incorrect parsing of numeric values within the DSN when the option was not configured as the last parameter within the DSN. (Bug #33822)\n\n• Specifying a nonexistent database name within the GUI dialog would result in an empty list, not an error. (Bug #33615)\n\n• When deleting rows from a static cursor, the cursor position would be incorrectly reported. (Bug #33388)\n\n• `SQLGetInfo()` reported characters for `SQL_SPECIAL_CHARACTERS` that were not encoded correctly. (Bug #33130)\n\n• Retrieving data from a `BLOB` column failed within `SQLGetData` when the target data type was `SQL_C_WCHAR` due to incorrect handling of the character buffer. (Bug #32684)\n\n• Renaming an existing DSN entry would create a new entry with the new name without deleting the old entry. (Bug #31165)\n\n• Reading a `TEXT` column that had been used to store UTF8 data would result in the wrong information being returned during a query. (Bug #28617)\n\n• SQLForeignKeys would return an empty string for the schema columns instead of `NULL`. (Bug #19923)\n\n• When accessing column data, `FLAG_COLUMN_SIZE_S32` did not limit the octet length or display size reported for fields, causing problems with Microsoft Visual FoxPro.\n\nThe list of ODBC functions that could have caused failures in Microsoft software when retrieving the length of `LONGBLOB` or `LONGTEXT` columns includes:\n\n• `SQLColumns`\n\n• `SQLColAttribute`\n\n• `SQLColAttributes`\n\n• `SQLDescribeCol`\n\n• `SQLSpecialColumns` (theoretically can have the same problem) (Bug #12805, Bug #30890)\n\n• Dynamic cursors on statements with parameters were not supported. (Bug #11846)\n\n• Evaluating a simple numeric expression when using the OLEDB for ODBC provider and ADO would return an error, instead of the result. (Bug #10128)\n\n• Adding or updating a row using `SQLSetPos()` on a result set with aliased columns failed. (Bug #6157)\n\n• The HP-UX 11.23 IA64 binary package does not include the GUI bits because of problems building Qt on that platform.\n• There is no binary package for OS X on 64-bit PowerPC because Apple does not currently provide a 64-bit PowerPC version of iODBC.\n\n• The installer for 64-bit Windows installs both the 32-bit and 64-bit driver. Please note that Microsoft does not yet supply a 64-bit bridge from ADO to ODBC.\n\n• Due to differences with the installation process used on Windows and potential registry corruption, it is recommended that you uninstall any existing versions of Connector/ODBC 5.1.x before upgrading.\n\nReferences: See also: Bug #34571.\n\nChanges in MySQL Connector/ODBC 5.1.1 (2007-12-13, Beta)\n\nMySQL Connector/ODBC 5.1.1-beta, a new version of the ODBC driver for the MySQL database management system, has been released. This release is the first beta (feature-complete) release of the new 5.1 series and is suitable for use with any MySQL server version since MySQL 4.1, including MySQL 5.0, 5.1, and 6.0. (It will not work with 4.0 or earlier releases.)\n\nKeep in mind that this is a beta release, and as with any other pre-production release, caution should be taken when installing on production level systems or systems with critical data.\n\nIncludes changes from Connector/ODBC 3.51.21 and 3.51.22.\n\nBuilt using MySQL 5.0.52.\n\n• Functionality Added or Changed\n\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• **Incompatible Change:** Replaced myodbc3i (now myodbc-installer) with Connector/ODBC 5.0 version.\n\n• **Incompatible Change:** Removed monitor (myodbc3m) and dsn-editor (myodbc3c).\n\n• **Incompatible Change:** Do not permit `SET NAMES` in initial statement and in executed statements.\n\n• A wrapper for the `SQLGetPrivateProfileStringW()` function, which is required for Unicode support, has been created. This function is missing from the unixODBC driver manager. (Bug #32685)\n\n• Added MSI installer for Windows 64-bit. (Bug #31510)\n\n• Implemented support for `SQLCancel()` .(Bug #15601)\n\n• Added support for `SQL_NUMERIC_STRUCT`. (Bug #3028, Bug #24920)\n\n• Removed nonthreadsafe configuration of the driver. The driver is now always built against the threadsafe version of libmysql.\n\n• Implemented native Windows setup library\n\n• Replaced the internal library which handles creation and loading of DSN information. The new library, which was originally a part of Connector/ODBC 5.0, supports Unicode option values.\n\n• The Windows installer now places files in a subdirectory of the Program Files directory instead of the Windows system directory.\n\nBugs Fixed\n\n• The `SET NAMES` statement has been disabled because it causes problems in the ODBC driver when determining the current client character set. (Bug #32596)\nMySQL Connector/ODBC Release Notes\n\n• `SQLDescribeColW` returned UTF-8 column as `SQL_VARCHAR` instead of `SQL_WVARCHAR`. (Bug #32161)\n\n• ADO was unable to open record set using dynamic cursor. (Bug #32014)\n\n• ADO applications would not open a `RecordSet` that contained a `DECIMAL` field. (Bug #31720)\n\n• Memory usage would increase considerably. (Bug #31115)\n\n• SQL statements are limited to 64KB. (Bug #30983, Bug #30984)\n\n• `SQLSetPos` with `SQL_DELETE` advances dynamic cursor incorrectly. (Bug #29765)\n\n• Using an ODBC prepared statement with bound columns would produce an empty result set when called immediately after inserting a row into a table. (Bug #29239)\n\n• ADO Not possible to update a client side cursor. (Bug #27961)\n\n• `Recordset Update()` fails when using `adUseClient` cursor. (Bug #26985)\n\n• Connector/ODBC failed to connect to the server if the password contained certain characters, including the semicolon and other punctuation marks. (Bug #16178)\n\n• The HP-UX 11.23 IA64 binary package does not include the GUI bits because of problems building Qt on that platform.\n\n• There is no binary package for OS X on 64-bit PowerPC because Apple does not currently provide a 64-bit PowerPC version of iODBC.\n\n• The installer for 64-bit Windows installs both the 32-bit and 64-bit driver. Please note that Microsoft does not yet supply a 64-bit bridge from ADO to ODBC.\n\n• Fixed `SQL_ATTR_PARAM_BIND_OFFSET`, and fixed row offsets to work with updatable cursors.\n\n• `SQLSetConnectAttr()` did not clear previous errors, possibly confusing `SQLError()`.\n\n• `SQLError()` incorrectly cleared the error information, making it unavailable from subsequent calls to `SQLGetDiagRec()`.\n\n• NULL pointers passed to `SQLGetInfo()` could result in a crash.\n\n• `SQL_ODBC_SQL_CONFORMANCE` was not handled by `SQLGetInfo()`.\n\n• `SQLCopyDesc()` did not correctly copy all records.\n\n• Diagnostics were not correctly cleared on connection and environment handles.\n\n• Due to differences with the installation process used on Windows and potential registry corruption, it is recommended that you uninstall any existing versions of Connector/ODBC 5.1.x before upgrading.\n\nReferences: See also: Bug #34571.\n\nChanges in MySQL Connector/ODBC 5.1.0 (2007-09-10, Alpha)\n\nThis release is the first of the new 5.1 series and is suitable for use with any MySQL server version since MySQL 4.1, including MySQL 5.0, 5.1, and 6.0. (It will not work with 4.0 or earlier releases.)\n\nKeep in mind that this is a alpha release, and as with any other pre-production release, caution should be taken when installing on production level systems or systems with critical data. Not all of the features planned for the final Connector/ODBC 5.1 release are implemented.\n\nFunctionality is based on Connector/ODBC 3.51.20.\nMySQL Connector/ODBC Release Notes\n\n• Functionality Added or Changed\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• Added support for Unicode functions (SQLConnectW, etc).\n• Added descriptor support (SQLGetDescField, SQLGetDescRec, etc).\n• Added support for SQL_C_WCHAR.\n\nBugs Fixed\n\n• The HP-UX 11.23 IA64 binary package does not include the GUI bits because of problems building Qt on that platform.\n• There is no binary package for OS X on 64-bit PowerPC because Apple does not currently provide a 64-bit PowerPC version of iODBC.\n• There are no installer packages for Microsoft Windows x64 Edition.\n• Due to differences with the installation process used on Windows and potential registry corruption, it is recommended that you uninstall any existing versions of Connector/ODBC 5.1.x before upgrading.\n\nReferences: See also: Bug #34571.\n\nChanges in MySQL Connector/ODBC Version 5.0\n\nChanges in MySQL Connector/ODBC 5.0.12 (Not released)\n\nNote\n\nDevelopment on Connector/ODBC 5.0.x has ceased. New features and functionality will be incorporated into Connector/ODBC 5.1.\n\nBugs Fixed\n\n• Inserting NULL values into a DATETIME column from Access reports an error. (Bug #27896)\n• Tables with TEXT columns would be incorrectly identified, returning an Unknown SQL type - 65535 error. (Bug #20127)\n\nChanges in MySQL Connector/ODBC 5.0.11 (2007-01-31, Beta)\n\n• Functionality Added or Changed\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• Added support for ODBC v2 statement options using attributes.\n• Driver now builds and is partially tested under Linux with the iODBC driver manager.\n\nBugs Fixed\n\n• Connection string parsing for DSN-less connections could fail to identify some parameters. (Bug #25316)\n• Updates of MEMO or TEXT columns from within Microsoft Access failed. (Bug #25263)\n• Transaction support has been added and tested. (Bug #25045)\n• Internal function, `my_setpos_delete_ignore()` could cause a crash. (Bug #22796)\n• Fixed occasional mis-handling of the `SQL_NUMERIC_C` type.\n• Fixed the binding of certain integer types.\n\n**Changes in MySQL Connector/ODBC 5.0.10 (2006-12-14, Beta)**\n\nConnector/ODBC 5.0.10 is the sixth Beta release.\n\n**Functionality Added or Changed**\n\n**Bugs Fixed**\n\n**Functionality Added or Changed**\n\n• Significant performance improvement when retrieving large text fields in pieces using `SQLGetData()` with a buffer smaller than the whole data. Mainly used in Access when fetching very large text fields. (Bug #24876)\n• Added initial unicode support in data and metadata. (Bug #24837)\n• Added initial support for removing braces when calling stored procedures and retrieving result sets from procedure calls. (Bug #24485)\n• Added loose handling of retrieving some diagnostic data. (Bug #15782)\n• Added wide-string type info for `SQLGetTypeInfo()`.\n\n**Bugs Fixed**\n\n• Editing DSN no longer crashes ODBC data source administrator. (Bug #24675)\n• String query parameters are new escaped correctly. (Bug #19078)\n\n**Changes in MySQL Connector/ODBC 5.0.9 (2006-11-22, Beta)**\n\nConnector/ODBC 5.0.9 is the fifth Beta release.\n\nThis is an implementation and testing release, and is not designed for use within a production environment.\n\n**Functionality Added or Changed**\n\n**Bugs Fixed**\n\n• Fixed wildcard handling of and listing of catalogs and tables in `SQLTables`.\n• Added limit of display size when requested using `SQLColAttribute/SQL_DESC_DISPLAY_SIZE`.\n• Fixed buffer length return for `SQLDriverConnect`.\nMySQL Connector/ODBC Release Notes\n\n- ODBC v2 behavior in driver now supports ODBC v3 date/time types (since DriverManager maps them).\n- Catch use of SQL_ATTR_PARAMSET_SIZE and report error until we fully support.\n- Fixed statistics to fail if it couldn't be completed.\n- Corrected retrieval multiple field types bit and blob/text.\n- Fixed SQLGetData to clear the NULL indicator correctly during multiple calls.\n\nChanges in MySQL Connector/ODBC 5.0.8 (2006-11-17, Beta)\n\nConnector/ODBC 5.0.8 is the fourth Beta release.\n\nThis is an implementation and testing release, and is not designed for use within a production environment.\n\n- Functionality Added or Changed\n- Bugs Fixed\n\nFunctionality Added or Changed\n\n- Also made SQL_DESC_NAME only fill in the name if there was a data pointer given, otherwise just the length.\n- Fixed display size to be length if max length isn’t available.\n- Made distinction between CHAR/BINARY (and VAR versions).\n- Wildcards now support escaped chars and underscore matching (needed to link tables with underscores in access).\n\nBugs Fixed\n\n- Fixed binding using SQL_C_LONG.\n- Fixed using wrong pointer for SQL_MAX_DRIVERgetConnections in SQLGetInfo.\n- Set default return to SQL_SUCCESS if nothing is done for SQLSpecialColumns.\n- Fixed MDiagnostic to use correct v2/v3 error codes.\n- Allow SQLDescribeCol to be called to retrieve the length of the column name, but not the name itself.\n- Length now used when handling bind parameter (needed in particular for SQL_WCHAR) - this enables updating char data in MS Access.\n- Updated retrieval of descriptor fields to use the right pointer types.\n- Fixed handling of numeric pointers in SQLColAttribute.\n- Fixed type returned for MYSQL_TYPE_LONG to SQL_INTEGER instead of SQL_TINYINT.\n- Fix size return from SQLDescribeCol.\n- Fixed string length to chars, not bytes, returned by SQLGetDiagRec.\n\nChanges in MySQL Connector/ODBC 5.0.7 (2006-11-08, Beta)\n\nConnector/ODBC 5.0.7 is the third Beta release.\nThis is an implementation and testing release, and is not designed for use within a production environment.\n\n- **Functionality Added or Changed**\n\n- **Bugs Fixed**\n\n### Functionality Added or Changed\n\n- Added support for `SQLStatistics` to `MYODBCShell`.\n\n- Improved trace/log.\n\n### Bugs Fixed\n\n- `SQLBindParameter` now handles `SQL_C_DEFAULT`.\n\n- Corrected incorrect column index within `SQLStatistics`. Many more tables can now be linked into MS Access.\n\n- Fixed `SQLDescribeCol` returning column name length in bytes rather than chars.\n\n### Changes in MySQL Connector/ODBC 5.0.6 (2006-11-03, Beta)\n\nConnector/ODBC 5.0.6 is the second Beta release.\n\nThis is an implementation and testing release, and is not designed for use within a production environment.\n\n- **Features, Limitations, and Notes on this Release**\n\n- **Bugs Fixed**\n\n### Features, Limitations, and Notes on this Release\n\n- Connector/ODBC supports both User and System DSNs.\n\n- Installation is provided in the form of a standard Microsoft System Installer (MSI).\n\n- You no longer have to have Connector/ODBC 3.51 installed before installing this version.\n\n### Bugs Fixed\n\n- You no longer have to have Connector/ODBC 3.51 installed before installing this version.\n\n- Connector/ODBC supports both User and System DSNs.\n\n- Installation is provided in the form of a standard Microsoft System Installer (MSI).\n\n### Changes in MySQL Connector/ODBC 5.0.5 (2006-10-17, Beta)\n\nConnector/ODBC 5.0.5 is the first Beta release.\n\nThis is an implementation and testing release, and is not designed for use within a production environment.\n\nYou no longer have to have Connector/ODBC 3.51 installed before installing this version.\n\n### Bugs Fixed\n\n- You no longer have to have Connector/ODBC 3.51 installed before installing this version.\nChanges in MySQL Connector/ODBC 5.0.3 (2006-06-20)\n\nBugs Fixed\n\n- The following ODBC API functions have been added in this release:\n - SQLBindParameter\n - SQLBindCol\n - SQLBindCol\n - SQLBindParameter\n\nChanges in Connector/ODBC 5.0.2 (Never released)\n\nConnector/ODBC 5.0.2 was an internal implementation and testing release.\n\nChanges in MySQL Connector/ODBC 5.0.1 (2006-06-05)\n\nBugs Fixed\n\n- SQLSetDescField\n- SQLCloseCursor\n- SQLGetTypeInfo\n- SQLExecDirect\n- SQLGetConnectAttr\n- SQLDisconnect\n- SQLColAttribute\n- SQLGetStmtAttr\n- SQLSetEnvAttr\n- SQLExecute\n- Connector/ODBC is currently limited to basic applications. ADO applications and Microsoft Office are not supported.\n- SQLFreeHandle\n- Connector/ODBC must be used with a Driver Manager.\n- SQLTables\n- SQLGetFunctions\n- SQLRowCount\n- SQLGetDiagField\n- SQLConnect\n- SQLGetDescRec\n- SQLFreeStmt\n• SQLSetConnectAttr\n• SQLCopyDesc\n• SQLGetEnvAttr\n• SQLNumResultCols\n• SQLFetch\n• Connector/ODBC 5.0 is Unicode aware.\n• SQLGetData\n• SQLGetDiagRec\n• SQLAllocHandle\n• SQLSetStmtAttr\n• SQLGetDescField\n• SQLPrepare\n• The following ODBC API functions are implemented:\n • SQLAllocHandle\n • SQLCloseCursor\n • SQLColAttribute\n • SQLColumns\n • SQLConnect\n • SQLCopyDesc\n • SQLDisconnect\n • SQLExecDirect\n • SQLExecute\n • SQLError\n • SQLFreeHandle\n • SQLFreeStmt\n • SQLGetConnectAttr\n • SQLGetData\n • SQLGetDescField\n • SQLGetDescRec\n • SQLGetDiagRec\n • SQLGetEnvAttr\n • SQLGetFunctions\nMySQL Connector/ODBC Release Notes\n\n- SQLGetStmtAttr\n- SQLGetTypeInfo\n- SQLNumResultCols\n- SQLPrepare\n- SQLRowcount\n- SQLTables\n\nThe following ODBC API functions are implemented, but not yet support all the available attributes/options:\n- SQLSetConnectAttr\n- SQLSetDescField\n- SQLSetDescRec\n- SQLSetEnvAttr\n- SQLSetStmtAttr\n- SQLColumns\n- SQLSetDescRec\n\nChanges in MySQL Connector/ODBC Version 3.51\n\nChanges in MySQL Connector/ODBC 3.51.30 (2012-02-02)\n\nBugs Fixed\n\n- After downgrading from Connector/ODBC 5.1 to Connector/ODBC 3.51, unrecognized names for connection string parameters caused warning messages about unknown options. (Bug #13647492)\n- SQLFetch has to return error if indicator pointer is NULL for NULL value. (Bug #13542600)\n- In some cases, a TIMESTAMP field could be described as SQL_NO_NULLS. (Bug #13532987)\n- A failure on one statement causes another statement to fail. (Bug #13097201, Bug #62657)\n- Connector/ODBC manually added a LIMIT clause to the end of certain SQL statements, causing errors for statements that contained code that should be positioned after the LIMIT clause. (Bug #49726)\n- Describing a view or table caused SQLPrepare to prefetch table data. For large tables this created an intolerable performance hit. (Bug #46411)\n\nChanges in MySQL Connector/ODBC 3.51.29 (2011-10-04)\n\n- Pluggable Authentication Notes\n- Bugs Fixed\n\nPluggable Authentication Notes\n\n- The binaries for this distribution of Connector/ODBC can now connect to MySQL server accounts that use the PAM or Windows Native Authentication Plugins for authentication. See PAM Pluggable\nAuthentication, and Windows Pluggable Authentication. These capabilities result from linking the Connector/ODBC binaries against the MySQL 5.5.16 libmysqlclient rather than the MySQL 5.1 libmysqlclient used previously. The newer libmysqlclient includes the client-side support needed for the server-side PAM and Windows authentication plugins.\n\nBugs Fixed\n\n- Some catalog functions (such as SQLColumns(), SQLStatistics(), and SQLPrimaryKeys()) would only return one row, when called after pre-execution failed. (Bug #12824839)\n\n- An off-by-one error, where sqlwcharchr might read one SQLWCHAR after the end of a string. (Bug #61586)\n\n- SQLExecute would return SQL_SUCCESS_WITH_INFO instead of SQL_ERROR, when column parameter binding was enabled. (Bug #59772)\n\n- The Connector/ODBC driver did not call mysql_thread_end() when a thread ended, which caused error messages like: Error in my_thread_global_end(): 1 threads didn't exit. (Bug #57727)\n\n- MS Access fields with VARCHAR NOT NULL columns could not be altered. (Bug #31067)\n\nChanges in MySQL Connector/ODBC 3.51.28 (2011-02-09)\n\nBugs Fixed\n\n- SQLColAttribute(...SQL_DESC_CASE_SENSITIVE...) returned SQL_FALSE for binary types and SQL_TRUE for the rest. It should have returned SQL_TRUE for binary types, and SQL_FALSE for the rest. (Bug #54212)\n\n- SQLColAttribute for SQL_DESC_OCTET_LENGTH returned length including terminating null byte. It should not have included the null byte. (Bug #54206)\n\n- If NO_BACKSLASH_ESCAPES mode was used on a server, escaping binary data led to server query parsing errors. (Bug #49029)\n\n- Inserting a new record using SQLSetPos did not correspond to the database name specified in the SELECT statement when querying tables from databases other than the current one. SQLSetPos attempted to do the INSERT in the current database, but finished with a SQL_ERROR result and “Table does not exist” message from MySQL Server. (Bug #41946)\n\n- When using Connector/ODBC to fetch data, if a net_write_timeout condition occurred, the operation returned the standard \"end of data\" status, rather than an error. (Bug #39878)\n\n- No result record was returned for SQLGetTypeInfo for the TIMESTAMP data type. An application would receive the result return code 100 (SQL_NO_DATA_FOUND). (Bug #30626)\n\n- Microsoft Access was not able to read BIGINT values properly from a table with just two columns of type BIGINT and VARCHAR. #DELETE appeared instead of the correct values. (Bug #17679)\n\nChanges in MySQL Connector/ODBC 3.51.27 (2008-11-20)\n\nBugs Fixed\n\n- The client program hung when the network connection to the server was interrupted. (Bug #40407)\n\n- The connection string option Enable Auto-reconnect did not work. When the connection failed, it could not be restored, and the errors generated were the same as if the option had not been selected. (Bug #37179)\nIt was not possible to use Connector/ODBC to connect to a server using SSL. The following error was generated:\n\n```\nRuntime error '2147467259 (80004005)': [MySQL][ODBC 3.51 Driver]SSL connection error.\n```\n\n(Bug #29955)\n\n**Changes in MySQL Connector/ODBC 3.51.26 (2008-07-07)**\n\n- **Functionality Added or Changed**\n- **Bugs Fixed**\n\n**Functionality Added or Changed**\n\n- There is a new connection option, `FLAG_NO_BINARY_RESULT`. When set this option disables charset 63 for columns with an empty `org_table`. (Bug #29402)\n\n**Bugs Fixed**\n\n- When an `ADOConnection` is created and attempts to open a schema with `ADOConnection.OpenSchema` an access violation occurs in `myodbc3.dll`. (Bug #30770)\n- When `SHOW CREATE TABLE` was invoked and then the field values read, the result was truncated and unusable if the table had many rows and indexes. (Bug #24131)\n\n**Changes in MySQL Connector/ODBC 3.51.25 (2008-04-11)**\n\n**Bugs Fixed**\n\n- The `SQLColAttribute()` function returned `SQL_TRUE` when querying the `SQL_DESC_FIXED_PREC_SCALE` (SQL_COLUMN_MONEY) attribute of a DECIMAL column. Previously, the correct value of `SQL_FALSE` was returned; this is now again the case. (Bug #35581)\n- The driver crashes ODBC Administrator on attempting to add a new DSN. (Bug #32057)\n- When accessing column data, `FLAG_COLUMN_SIZE_S32` did not limit the octet length or display size reported for fields, causing problems with Microsoft Visual FoxPro.\n\nThe list of ODBC functions that could have caused failures in Microsoft software when retrieving the length of `LONGBLOB` or `LONGTEXT` columns includes:\n\n- `SQLColumns`\n- `SQLColAttribute`\n- `SQLColAttributes`\n- `SQLDescribeCol`\n- `SQLSpecialColumns` (theoretically can have the same problem)\n\n(Bug #12805, Bug #30890)\n\n**Changes in MySQL Connector/ODBC 3.51.24 (2008-03-14)**\n\n**Bugs Fixed**\n\n- **Security Enhancement:** Accessing a parameter with the type of `SQL_C_CHAR`, but with a numeric type and a length of zero, the parameter marker would get stripped from the query. In addition, an\nSQL injection was possible if the parameter value had a nonzero length and was not numeric, the text would be inserted verbatim. (Bug #34575)\n\n- **Important Change:** In previous versions, the SSL certificate would automatically be verified when used as part of the Connector/ODBC connection. The default mode is now to ignore the verification of certificates. To enforce verification of the SSL certificate during connection, use the `SSLVERIFY DSN` parameter, setting the value to 1. (Bug #29955, Bug #34648)\n\n- When using ADO, the count of parameters in a query would always return zero. (Bug #33298)\n\n- Using tables with a single quote or other nonstandard characters in the table or column names through ODBC failed. (Bug #32989)\n\n- When using Crystal Reports, table and column names would be truncated to 21 characters, and truncated columns in tables where the truncated name was the duplicated would lead to only a single column being displayed. (Bug #32864)\n\n- `SQLExtendedFetch()` and `SQLFetchScroll()` ignored the rowset size if the `Don't cache result` DSN option was set. (Bug #32420)\n\n- When using the ODBC `SQL_TXN_READ_COMMITTED` option, 'dirty' records would be read from tables as if the option had not been applied. (Bug #31959)\n\n- When creating a System DSN using the ODBC Administrator on Mac OS X, a User DSN would be created instead. The root cause is a problem with the iODBC driver manager used on OS X. The fix works around this issue.\n\n **Note**\n\n ODBC Administrator may still be unable to register a System DSN unless the `/Library/ODBC/odbc.ini` file has the correct permissions. You should ensure that the file is writable by the `admin` group.\n\n (Bug #31495)\n\n- Calling `SQLFetch` or `SQLFetchScroll` would return negative data lengths when using `SQL_C_WCHAR`. (Bug #31220)\n\n- `SQLSetParam()` caused memory allocation errors due to driver manager's mapping of deprecated functions (buffer length -1). (Bug #29871)\n\n- Static cursor was unable to be used through ADO when dynamic cursors were enabled. (Bug #27351)\n\n- Using `connection.Execute` to create a record set based on a table without declaring the `cmd` option as `adCmdTable` will fail when communicating with versions of MySQL 5.0.37 and higher. The issue is related to the way that `SQLSTATE` is returned when ADO tries to confirm the existence of the target object. (Bug #27158)\n\n- Updating a `RecordSet` when the query involves a `BLOB` field failed. (Bug #19065)\n\n- With some connections to MySQL databases using Connector/ODBC, the connection would mistakenly report 'user cancelled' for accesses to the database information. (Bug #16653)\n\n### Changes in MySQL Connector/ODBC 3.51.23 (2008-01-09)\n\n#### Bugs Fixed\n\n- Connector/ODBC would incorrectly return `SQL_SUCCESS` when checking for distributed transaction support. (Bug #32727)\n\n- When using unixODBC or directly linked applications where the thread level is set to less than 3 (within `odbcinst.ini`), a thread synchronization issue would lead to an application crash. This\nwas because `SQLAllocStmt()` and `SQLFreeStmt()` did not synchronize access to the list of statements associated with a connection. (Bug #32587)\n\n- Cleaning up environment handles in multithread environments could result in a five (or more) second delay. (Bug #32366)\n\n- Renaming an existing DSN entry would create a new entry with the new name without deleting the old entry. (Bug #31165)\n\n- Setting the default database using the DefaultDatabase property of an ADO Connection object failed with the error Provider does not support this property. The SQLGetInfo() returned the wrong value for SQL_DATABASE_NAME when no database was selected. (Bug #3780)\n\n- The HP-UX 11.23 IA64 binary package does not include the GUI bits because of problems building Qt on that platform.\n\n- There is no binary package for OS X on 64-bit PowerPC because Apple does not currently provide a 64-bit PowerPC version of iODBC.\n\n- There are no installer packages for Microsoft Windows x64 Edition.\n\n### Changes in MySQL Connector/ODBC 3.51.22 (2007-11-13)\n\n- **Functionality Added or Changed**\n\n- **Bugs Fixed**\n\n### Functionality Added or Changed\n\n- The workaround for this bug was removed due to the fixes in MySQL Server 5.0.48 and 5.1.21.\n\n References: This issue is a regression of: Bug #10491.\n\n### Bugs Fixed\n\n- The **English** locale would be used when formatting floating point values. The **C** locale is now used for these values. (Bug #32294)\n\n- When accessing information about supported operations, the driver would return incorrect information about the support for **UNION**. (Bug #32253)\n\n- Unsigned integer values greater than the maximum value of a signed integer would be handled incorrectly. (Bug #32171)\n\n- The wrong result was returned by `SQLGetData()` when the data was an empty string and a zero-sized buffer was specified. (Bug #30958)\n\n- Added the **FLAG_COLUMN_SIZE_S32** option to limit the reported column size to a signed 32-bit integer. This option is automatically enabled for ADO applications to provide a work around for a bug in ADO. (Bug #13776)\n\n### Changes in MySQL Connector/ODBC 3.51.21 (2007-10-08)\n\n### Bugs Fixed\n\n- When using a rowset/cursor and add a new row with a number of fields, subsequent rows with fewer fields will include the original fields from the previous row in the final **INSERT** statement. (Bug #31246)\n\n- Uninitiated memory could be used when C/ODBC internally calls `SQLGetFunctions()`. (Bug #31055)\n MySQL Connector/ODBC Release Notes\n\n- The wrong **SQL_DESC_LITERAL_PREFIX** would be returned for date/time types. (Bug #31009)\n- The wrong **COLUMN_SIZE** would be returned by **SQLGetTypeInfo** for the TIME columns (**SQL_TYPE_TIME**). (Bug #30939)\n- Clicking outside the character set selection box when configuring a new DSN could cause the wrong character set to be selected. (Bug #30568)\n- Not specifying a user in the DSN dialog would raise a warning even though the parameter is optional. (Bug #30499)\n- **SQLSetParam()** caused memory allocation errors due to driver manager's mapping of deprecated functions (buffer length -1). (Bug #29871)\n- When using ADO, a column marked as **AUTO_INCREMENT** could incorrectly report that the column permitted NULL values. This was due to an issue with **NULLABLE** and **IS_NULLABLE** return values from the call to **SQLColumns()**. (Bug #26108)\n- Connector/ODBC would return the wrong error code when the server disconnects the active connection because the configured **wait_timeout** has expired. Previously it would return **HY000**. Connector/ODBC now correctly returns an **SQLSTATE** of **08S01**. (Bug #3456)\n\n**Changes in MySQL Connector/ODBC 3.51.20 (2007-09-10)**\n\n**Bugs Fixed**\n\n- Using **FLAG_NO_PROMPT** doesn't suppress the dialogs normally handled by **SQLDriverConnect**. (Bug #30840)\n- The specified length of the user name and authentication parameters to **SQLConnect()** were not being honored. (Bug #30774)\n- The wrong column size was returned for binary data. (Bug #30547)\n- **SQLGetData()** will now always return **SQL_NO_DATA_FOUND** on second call when no data left, even if requested size is 0. (Bug #30520)\n- **SQLGetConnectAttr()** did not reflect the connection state correctly. (Bug #14639)\n- Removed check box in setup dialog for **FLAG_FIELD_LENGTH** (identified as *Don't Optimize Column Width* within the GUI dialog), which was removed from the driver in 3.51.18.\n\n**Changes in MySQL Connector/ODBC 3.51.19 (2007-08-10)**\n\nConnector/ODBC 3.51.19 fixes a specific issue with the 3.51.18 release. For a list of changes in the 3.51.18 release, see Changes in MySQL Connector/ODBC 3.51.18 (2007-08-08).\n\n**Functionality Added or Changed**\n\n- Because of Bug #10491 in the server, character string results were sometimes incorrectly identified as **SQL_VARBINARY**. Until this server bug is corrected, the driver will identify all variable-length strings as **SQL_VARCHAR**.\n\nReferences: This issue is a regression of: Bug #10491.\n\n**Changes in MySQL Connector/ODBC 3.51.18 (2007-08-08)**\n\n- **Functionality Added or Changed**\n- **Bugs Fixed**\nFunctionality Added or Changed\n\n- **Incompatible Change:** The `FLAG_DEBUG` option was removed.\n\n- When connecting to a specific database when using a DSN, the system tables from the `mysql` database are no longer also available. Previously, tables from the `mysql` database (catalog) were listed as `SYSTEM TABLES` by `SQLTables()` even when a different catalog was being queried. (Bug #28662)\n\n- Installed for OS X has been reinstated. The installer registers the driver at a system (not user) level and makes it possible to create both user and system DSNs using the Connector/ODBC driver. The installer also fixes the situation where the necessary drivers would be installed local to the user, not globally. (Bug #15326, Bug #10444)\n\n- Connector/ODBC now supports batched statements. To enable cached statement support, you must switch enable the batched statement option (`FLAG_MULTI_STATEMENTS`, 67108864, or `Allow multiple statements` within a GUI configuration). Be aware that batched statements create an increased chance of SQL injection attacks and you must ensure that your application protects against this scenario. (Bug #7445)\n\n- The `SQL_ATTR_ROW_BIND_OFFSET_PTR` is now supported for row bind offsets. (Bug #6741)\n\n- The `TRACE` and `TRACEFILE` DSN options have been removed. Use the ODBC driver manager trace options instead.\n\nBugs Fixed\n\n- When using a table with multiple `TIMESTAMP` columns, the final `TIMESTAMP` column within the table definition would not be updatable. Note that there is still a limitation in MySQL server regarding multiple `TIMESTAMP` columns. (Bug #30081)\n\n References: See also: Bug #9927.\n\n- Fixed an issue where the `myodbc3i` would update the user ODBC configuration file (`~/Library/ODBC/odbcinst.ini`) instead of the system `/Library/ODBC/odbcinst.ini`. This was caused because `myodbc3i` was not honoring the `s` and `u` modifiers for the `-d` command-line option. (Bug #29964)\n\n- Getting table metadata (through the `SQLColumns()` failed, returning a bad table definition to calling applications. (Bug #29888)\n\n- `DATETIME` column types would return `FALSE` in place of `SQL_SUCCESS` when requesting the column type information. (Bug #28657)\n\n- The `SQL_COLUMN_TYPE`, `SQL_COLUMN_DISPLAY` and `SQL_COLUMN_PRECISION` values would be returned incorrectly by `SQLColumns()`, `SQLDescribeCol()` and `SQLColAttribute()` when accessing character columns, especially those generated through `concat()`. The lengths returned should now conform to the ODBC specification. The `FLAG_FIELD_LENGTH` option no longer has any affect on the results returned. (Bug #27862)\n\n- Obtaining the length of a column when using a character set for the connection of `utf8` would result in the length being returned incorrectly. (Bug #19345)\n\n- The `SQLColumns()` function could return incorrect information about `TIMESTAMP` columns, indicating that the field was not nullable. (Bug #14414)\n\n- The `SQLColumns()` function could return incorrect information about `AUTO_INCREMENT` columns, indicating that the field was not nullable. (Bug #14407)\n\n- A binary package without an installer is available for Microsoft Windows x64 Edition. There are no installer packages for Microsoft Windows x64 Edition.\n• There is no binary package for OS X on 64-bit PowerPC because Apple does not currently provide a 64-bit PowerPC version of iODBC.\n\n• \\texttt{BIT(n)} columns are now treated as \\texttt{SQL_BIT} data where $n = 1$ and binary data where $n > 1$.\n\n• The wrong value from \\texttt{SQL_DESC_LITERAL_SUFFIX} was returned for binary fields.\n\n• The \\texttt{SQL_DATETIME_SUB} column in \\texttt{SQLColumns()} was not correctly set for date and time types.\n\n• The value for \\texttt{SQL_DESC_FIXED_PREC_SCALE} was not returned correctly for values in MySQL 5.0 and later.\n\n• The wrong value for \\texttt{SQL_DESC_TYPE} was returned for date and time types.\n\n• \\texttt{SQLConnect()} and \\texttt{SQLDriverConnect()} were rewritten to eliminate duplicate code and ensure all options were supported using both connection methods. \\texttt{SQLDriverConnect()} now only requires the setup library to be present when the call requires it.\n\n• Binary packages as disk images with installers are now available for OS X.\n\n• Binary packages for Sun Solaris are now available as \\texttt{PKG} packages.\n\n• The wrong value for \\texttt{DECIMAL_DIGITS} in \\texttt{SQLColumns()} was reported for \\texttt{FLOAT} and \\texttt{DOUBLE} fields, as well as the wrong value for the scale parameter to \\texttt{SQLDescribeCol()}, and the \\texttt{SQL_DESC_SCALE} attribute from \\texttt{SQLColAttribute()}.\n\n• The \\texttt{SQL_DATA_TYPE} column in \\texttt{SQLColumns()} results did not report the correct value for date and time types.\n\n• The HP-UX 11.23 IA64 binary package does not include the GUI bits because of problems building Qt on that platform.\n\n• Binary packages for Sun Solaris are now available as \\texttt{PKG} packages.\n\n• Binary packages as disk images with installers are now available for OS X.\n\n• A binary package without an installer is available for Microsoft Windows x64 Edition. There are no installer packages for Microsoft Windows x64 Edition.\n\nChanges in MySQL Connector/ODBC 3.51.17 (2007-07-14)\n\n• \\textbf{Functionality Added or Changed}\n\n• \\textbf{Bugs Fixed}\n\n\\textbf{Functionality Added or Changed}\n\n• It is now possible to specify a different character set as part of the DSN or connection string. This must be used instead of the \\texttt{SET NAMES} statement. You can also configure the character set value from the GUI configuration. (Bug #9498, Bug #6667)\n\n• Fixed calling convention \\texttt{ptr} and wrong free in \\texttt{myodbc3i}, and fixed the null terminating (was only one, not two) when writing DSN to string.\n\n• Dis-allow null \\texttt{ptr} for null indicator when calling \\texttt{SQLGetData()} if value is null. Now returns SQL\\_ERROR w/state 22002.\n\n• The setup library has been split into its own RPM package, to enable installing the driver itself with no GUI dependencies.\n\n\\textbf{Bugs Fixed}\n\n• \\texttt{myodbc3i} did not correctly format driver info, which could cause the installation to fail. (Bug #29709)\n• Connector/ODBC crashed with Crystal Reports due to a problem with `SQLProcedures()` (Bug #28316)\n\n• Fixed a problem where the GUI would crash when configuring or removing a System or User DSN. (Bug #27315)\n\n• Fixed error handling of out-of-memory and bad connections in catalog functions. This might raise errors in code paths that had ignored them in the past. (Bug #26934)\n\n• For a stored procedure that returns multiple result sets, Connector/ODBC returned only the first result set. (Bug #16817)\n\n• Calling `SQLGetDiagField` with `RecNumber 0, DiagIdentifier NOT 0` returned `SQL_ERROR`, preventing access to diagnostic header fields. (Bug #16224)\n\n• Added a new DSN option (`FLAG_ZERO_DATE_TO_MIN`) to retrieve `XXXX-00-00` dates as the minimum permitted ODBC date `XXXX-01-01`. Added another option (`FLAG_MIN_DATE_TO_ZERO`) to mirror this but for bound parameters. `FLAG_MIN_DATE_TO_ZERO` only changes `0000-01-01` to `0000-00-00`. (Bug #13766)\n\n• If there was more than one unique key on a table, the correct fields were not used in handling `SQLSetPos()`. (Bug #10563)\n\n• When inserting a large BLOB field, Connector/ODBC would crash due to a memory allocation error. (Bug #10562)\n\n• The driver was using `mysql_odbc_escape_string()`, which does not handle the `NO_BACKSLASH_ESCAPES` SQL mode. Now it uses `mysql_real_escape_string()`, which does. (Bug #9498)\n\n• `SQLColumns()` did not handle many of its parameters correctly, which could lead to incorrect results. The table name argument was not handled as a pattern value, and most arguments were not escaped correctly when they contained nonalphabetic characters. (Bug #8860)\n\n• There are no binary packages for Microsoft Windows x64 Edition.\n\n• There is no binary package for OS X on 64-bit PowerPC because Apple does not currently provide a 64-bit PowerPC version of iODBC.\n\n• Correctly return error if `SQLBindCol` is called with an invalid column.\n\nChanges in MySQL Connector/ODBC 3.51.16 (2007-06-14)\n\n• Functionality Added or Changed\n\n• Bugs Fixed\nFunctionality Added or Changed\n\n- Connector/ODBC now supports using SSL for communication. This is not yet exposed in the setup\n GUI, but must be enabled through configuration files or the DSN. (Bug #12918)\n\nBugs Fixed\n\n- Calls to SQLNativeSql() could cause stack corruption due to an incorrect pointer cast. (Bug #28758)\n- Using cursors on result sets with multi-column keys could select the wrong value. (Bug #28255)\n- SQLForeignKeys does not escape _ and % in the table name arguments. (Bug #27723)\n- When using stored procedures, making a SELECT or second stored procedure call after an initial\n stored procedure call, the second statement will fail. (Bug #27544)\n- SQLTables() did not distinguish tables from views. (Bug #23031)\n- Return values from SQLTables() may be truncated. (Bug #22797)\n- Data in TEXT columns failed to be read correctly. (Bug #16917)\n- Strings specified as parameters using the adBSTR or adVarChar types (SQL_WVARCHAR and\n SQL_WLONGVARCHAR) were incorrectly quoted and escaped. (Bug #16235)\n- Using BETWEEN with date values, the wrong results could be returned. (Bug #15773)\n- When using the Don't Cache Results option value 1048576 with Microsoft Access, the\n connection will fail using DAO/VisualBasic. (Bug #4657)\n\nChanges in MySQL Connector/ODBC 3.51.15 (2007-05-07)\n\nBugs Fixed\n\n- Connector/ODBC would incorrectly claim to support SQLProcedureColumns (by returning true\n when queried about SQLPROCEDURECOLUMNS with SQLGetFunctions), but this functionality is not\n supported. (Bug #27591)\n- An incorrect transaction isolation level may not be returned when accessing the connection\n attributes. (Bug #27589)\n- Adding a new DSN with the myodbc3i utility under AIX failed. (Bug #27220)\n- When inserting data using bulk statements (through SQLBulkOperations), the indicators for all\n rows within the insert would not be updated correctly. (Bug #24306)\n- Using SQLProcedures does not return the database name within the returned resultset. (Bug\n #23033)\n- The SQLTransact() function did not support an empty connection handle. (Bug #21588)\n- Using SQLDriverConnect instead of SQLConnect could cause later operations to fail. (Bug\n #7912)\n- When using blobs and parameter replacement in a statement with WHERE CURSOR OF, the SQL is\n truncated. (Bug #5853)\n- Connector/ODBC would return too many foreign key results when accessing tables with similar\n names. (Bug #4518)\n\nChanges in MySQL Connector/ODBC 3.51.14 (2007-03-08)\n\n- Functionality Added or Changed\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• Use of `SQL_ATTR_CONNECTION_TIMEOUT` on the server has now been disabled. If you attempt to set this attribute on your connection the `SQL_SUCCESS_WITH_INFO` will be returned, with an error number/string of `HYC00: Optional feature not supported`. (Bug #19823)\n\n• Added `auto is null` option to Connector/ODBC option parameters. (Bug #10910)\n\n• Added auto-reconnect option to Connector/ODBC option parameters.\n\n• Added support for the `HENV` handlers in `SQLEndTran()`.\n\nBugs Fixed\n\n• On 64-bit systems, some types would be incorrectly returned. (Bug #26024)\n\n• When retrieving `TIME` columns, C/ODBC would incorrectly interpret the type of the string and could interpret it as a `DATE` type instead. (Bug #25846)\n\n• Connector/ODBC may insert the wrong parameter values when using prepared statements under 64-bit Linux. (Bug #22446)\n\n• Using Connector/ODBC, with `SQLBindCol` and binding the length to the return value from `SQL_LEN_DATA_AT_EXEC` fails with a memory allocation error. (Bug #20547)\n\n• Using `DataAdapter`, Connector/ODBC may continually consume memory when reading the same records within a loop (Windows Server 2003 SP1/SP2 only). (Bug #20459)\n\n• When retrieving data from columns that have been compressed using `COMPRESS()`, the retrieved data would be truncated to 8KB. (Bug #20208)\n\n• The ODBC driver name and version number were incorrectly reported by the driver. (Bug #19740)\n\n• A string format exception would be raised when using iODBC, Connector/ODBC and the embedded MySQL server. (Bug #16535)\n\n• The `SQLDriverConnect()` ODBC method did not work with recent Connector/ODBC releases. (Bug #12393)\n\nChanges in MySQL Connector/ODBC 3.51.13 (Not released)\n\nConnector/ODBC 3.51.13 was an internal implementation and testing release.\n\nChanges in MySQL Connector/ODBC 3.51.12 (2005-02-11)\n\n• Functionality Added or Changed\n\n• Bugs Fixed\n\nFunctionality Added or Changed\n\n• N/A\n\nBugs Fixed\n\n• Using stored procedures with ADO, where the `CommandType` has been set correctly to `adCmdStoredProc`, calls to stored procedures failed. (Bug #15635)\n\n• File DSNs could not be saved. (Bug #12019)\nMySQL Connector/ODBC Release Notes\n\n- `SQLColumns()` returned no information for tables that had a column named using a reserved word.\n (Bug #9539)\n\nChanges in MySQL Connector/ODBC 3.51.11 (2005-01-28)\n\nBugs Fixed\n\n- `mysql_list_dbcolumns()` and `insert_fields()` were retrieving all rows from a table. Fixed the queries generated by these functions to return no rows. (Bug #8198)\n- `SQLGetTypeInfo()` returned `tinyblob` for `SQL_VARBINARY` and nothing for `SQL_BINARY`. Fixed to return `varbinary` for `SQL_VARBINARY`, `binary` for `SQL_BINARY`, and `longblob` for `SQL_LONGVARBINARY`. (Bug #8138)\n\nIndex\n\nA\nauthentication, 4\n\nC\ncmake, 4\ncollations, 4\ncompile on Windows, 18\ncompiling, 4\n\nD\ndeprecation, 6, 8, 19, 55, 57\n\nE\nencryption, 4, 5, 6, 9, 12\nerror 2006, 19\n\nF\nFIDO pluggable authentication, 4\nFREAK, 21, 26\n\nH\nHeartbleed, 22, 27\n\nI\nImportant Change, 42, 55\nIncompatible Change, 45, 58\n\nO\nOpenSSL, 5, 6, 9, 12, 18, 19, 19, 20, 21, 22, 26, 27\n\nP\nPREFETCH, 19\n\nS\nSecurity Enhancement, 55\nSQLFetch(), 18\nSQLForeignKeys(), 18\nSQLGetData, 19\nSQL_ATTR_CURSOR_TYPE, 18\nSQL_ATTR_QUERY_TIMEOUT, 20\nSSL, 4, 5, 6, 9, 12\nSTATIC_MSVCRT, 18\n\nT\n\nTLS, 4"}}},{"rowIdx":288,"cells":{"id":{"kind":"string","value":"f049c36329d83b2b188c0a07695a9cc834939cf0"},"text":{"kind":"string","value":"### Revision History\n\n<table>\n<thead>\n<tr>\n<th>Date</th>\n<th>Status</th>\n<th>Notes</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>September 2005</td>\n<td>First printing</td>\n<td>New for Version 3.0.2 (Release 14SP3)</td>\n</tr>\n<tr>\n<td>March 2006</td>\n<td>Online only</td>\n<td>Revised for Version 3.1 (Release 2006a)</td>\n</tr>\n<tr>\n<td>September 2006</td>\n<td>Online only</td>\n<td>Revised for Version 3.1.1 (Release 2006b)</td>\n</tr>\n<tr>\n<td>March 2007</td>\n<td>Online only</td>\n<td>Revised for Version 3.2 (Release 2007a)</td>\n</tr>\n<tr>\n<td>September 2007</td>\n<td>Online only</td>\n<td>Revised for Version 3.3 (Release 2007b)</td>\n</tr>\n<tr>\n<td>March 2008</td>\n<td>Online only</td>\n<td>Revised for Version 3.3.1 (Release 2008a)</td>\n</tr>\n<tr>\n<td>October 2008</td>\n<td>Online only</td>\n<td>Revised for Version 3.3.2 (Release 2008b)</td>\n</tr>\n<tr>\n<td>March 2009</td>\n<td>Online only</td>\n<td>Revised for Version 3.3.3 (Release 2009a)</td>\n</tr>\n<tr>\n<td>September 2009</td>\n<td>Online only</td>\n<td>Revised for Version 3.4 (Release 2009b)</td>\n</tr>\n<tr>\n<td>March 2010</td>\n<td>Online only</td>\n<td>Revised for Version 3.4.1 (Release 2010a)</td>\n</tr>\n<tr>\n<td>September 2010</td>\n<td>Online only</td>\n<td>Revised for Version 3.5 (Release 2010b)</td>\n</tr>\n<tr>\n<td>April 2011</td>\n<td>Online only</td>\n<td>Revised for Version 3.6 (Release 2011a)</td>\n</tr>\n<tr>\n<td>September 2011</td>\n<td>Online only</td>\n<td>Revised for Version 4.0 (Release 2011b)</td>\n</tr>\n<tr>\n<td>March 2012</td>\n<td>Online only</td>\n<td>Revised for Version 4.1 (Release 2012a)</td>\n</tr>\n<tr>\n<td>September 2012</td>\n<td>Online only</td>\n<td>Revised for Version 4.2 (Release 2012b)</td>\n</tr>\n<tr>\n<td>March 2013</td>\n<td>Online only</td>\n<td>Revised for Version 4.3 (Release 2013a)</td>\n</tr>\n<tr>\n<td>September 2013</td>\n<td>Online only</td>\n<td>Revised for Version 5.0 (Release 2013b)</td>\n</tr>\n<tr>\n<td>March 2014</td>\n<td>Online only</td>\n<td>Revised for Version 5.1 (Release 2014a)</td>\n</tr>\n<tr>\n<td>October 2014</td>\n<td>Online only</td>\n<td>Revised for Version 5.2 (Release 2014b)</td>\n</tr>\n<tr>\n<td>March 2015</td>\n<td>Online only</td>\n<td>Revised for Version 5.3 (Release 2015a)</td>\n</tr>\n<tr>\n<td>September 2015</td>\n<td>Online only</td>\n<td>Revised for Version 6.0 (Release 2015b)</td>\n</tr>\n</tbody>\n</table>\nUncertain State-Space Models (uss) ........................................ 1-33\nProperties of uss Objects .................................................. 1-33\n\nCreate Uncertain State-Space Model ................................. 1-36\n\nSample Uncertain Systems ............................................. 1-37\n\nFeedback Around an Uncertain Plant .............................. 1-39\n\nInterpreting Uncertainty in Discrete Time ......................... 1-41\n\nLifting a ss to a uss ..................................................... 1-42\n\nCreate Uncertain Frequency Response Data Models ............ 1-43\nProperties of ufrd Objects ............................................. 1-44\n\nInterpreting Uncertainty in Discrete Time ......................... 1-46\n\nLifting an frd to a ufrd .................................................. 1-47\n\nBasic Control System Toolbox and MATLAB\nInterconnections ......................................................... 1-48\n\nSimplifying Representation of Uncertain Objects ............... 1-49\nEffect of the Autosimplify Property ............................... 1-50\nDirect Use of simplify .................................................. 1-52\n\nGenerate Samples of Uncertain Systems ......................... 1-53\nGenerating One Sample ................................................. 1-53\nGenerating Many Samples ............................................. 1-53\nSampling ultidyn Elements ............................................ 1-54\n\nSubstitution by usubs .................................................. 1-57\nSpecifying the Substitution with Structures .................... 1-58\nNominal and Random Values ........................................... 1-58\n\nArray Management for Uncertain Objects ....................... 1-60\n\nReference Into Arrays .................................................. 1-61\n\nCreate Arrays with stack and cat Functions .................... 1-62\n\nCreate Arrays by Assignment ......................................... 1-64\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Binary Operations with Arrays</td>\n<td>1-65</td>\n</tr>\n<tr>\n<td>Create Arrays with usample</td>\n<td>1-66</td>\n</tr>\n<tr>\n<td>Create Arrays with usubs</td>\n<td>1-68</td>\n</tr>\n<tr>\n<td>Create Arrays with gridureal</td>\n<td>1-69</td>\n</tr>\n<tr>\n<td>Create Arrays with repmat</td>\n<td>1-70</td>\n</tr>\n<tr>\n<td>Create Arrays with repsys</td>\n<td>1-71</td>\n</tr>\n<tr>\n<td>Using permute and ipermute</td>\n<td>1-72</td>\n</tr>\n<tr>\n<td>Decomposing Uncertain Objects</td>\n<td>1-73</td>\n</tr>\n<tr>\n<td>Normalizing Functions for Uncertain Elements</td>\n<td>1-73</td>\n</tr>\n<tr>\n<td>Properties of the Decomposition</td>\n<td>1-74</td>\n</tr>\n<tr>\n<td>Syntax of lftdata</td>\n<td>1-75</td>\n</tr>\n<tr>\n<td>Advanced Syntax of lftdata</td>\n<td>1-77</td>\n</tr>\n<tr>\n<td>Generalized Robustness Analysis</td>\n<td>2-2</td>\n</tr>\n<tr>\n<td>Generalized Robustness Analysis</td>\n<td>2-2</td>\n</tr>\n<tr>\n<td>Robust Stability Margin</td>\n<td>2-4</td>\n</tr>\n<tr>\n<td>Robust Performance Margin</td>\n<td>2-5</td>\n</tr>\n<tr>\n<td>Worst-Case Gain Measure</td>\n<td>2-6</td>\n</tr>\n<tr>\n<td>Introduction to Linear Matrix Inequalities</td>\n<td>3-2</td>\n</tr>\n<tr>\n<td>Linear Matrix Inequalities</td>\n<td>3-2</td>\n</tr>\n<tr>\n<td>LMI Features</td>\n<td>3-2</td>\n</tr>\n</tbody>\n</table>\nLMIs and LMI Problems ........................................... 3-4\nLMI Applications ......................................................... 3-6\n Stability ................................................................. 3-7\n RMS Gain ............................................................... 3-8\n LQG Performance .................................................... 3-8\nFurther Mathematical Background .............................. 3-10\nBibliography ............................................................. 3-11\n\nLMI Lab\n\nTools for Specifying and Solving LMIs ......................... 4-2\n Some Terminology ...................................................... 4-2\n Overview of the LMI Lab .......................................... 4-5\n\nSpecifying a System of LMIs ....................................... 4-7\n\nSpecify LMI System at the Command Line ...................... 4-8\n Specifying LMI System .............................................. 4-8\n Initializing the LMI System ....................................... 4-9\n Specifying the LMI Variables ................................... 4-10\n Specifying Individual LMIs ...................................... 4-12\n\nSpecify LMIs with the LMI Editor GUI ......................... 4-15\n Keyboard Shortcuts ............................................... 4-17\n Limitations .......................................................... 4-17\n\nHow Imlivar and Imiterm Manage LMI Representation ...... 4-18\n\nQuerying the LMI System Description ......................... 4-19\n lmiinfo ............................................................... 4-19\n lminbr and matnbr .................................................. 4-19\n\nLMI Solvers ............................................................ 4-20\n\nMinimize Linear Objectives under LMI Constraints .......... 4-22\nConversion Between Decision and Matrix Variables ............................. 4-26\n\nValidating Results .............................................................................. 4-27\n\nModify a System of LMIs ................................................................. 4-28\n Deleting an LMI .............................................................................. 4-28\n Deleting a Matrix Variable ............................................................. 4-28\n Instantiating a Matrix Variable ....................................................... 4-29\n\nAdvanced LMI Techniques ............................................................... 4-31\n Structured Matrix Variables ......................................................... 4-31\n Complex-Valued LMIs .................................................................... 4-33\n Specifying $c^T x$ Objectives for mincx ........................................ 4-36\n Feasibility Radius .......................................................................... 4-37\n Well-Posedness Issues .................................................................... 4-38\n Semi-Definite $B(x)$ in gevp Problems ......................................... 4-39\n Efficiency and Complexity Issues .................................................. 4-40\n Solving $M + P^T X Q + Q^T X^T P < 0$ ......................................... 4-40\n\nBibliography ...................................................................................... 4-42\n\n5\n\nAnalyzing Uncertainty Effects in Simulink\n\nAnalyzing Uncertainty in Simulink .................................................... 5-2\n\nSimulink Blocks for Analyzing Uncertainty ....................................... 5-3\n\nSpecify Uncertainty Using Uncertain State Space Blocks .......... 5-4\n How to Specify Uncertainty in Uncertain State Space Blocks ........ 5-4\n Next Steps ...................................................................................... 5-6\n\nSimulate Uncertainty Effects ............................................................ 5-7\n How to Simulate Effects of Uncertainty ........................................ 5-7\n How to Vary Uncertainty Values ..................................................... 5-7\n\nVary Uncertainty Values Using Individual Uncertain State\n Space Blocks .................................................................................. 5-8\nVary Uncertainty Values Across Multiple Uncertain State Space Blocks ................................................................. 5-14\n\nComputing Uncertain State-Space Models from Simulink Models ............................................................................... 5-19\n\nObtain Uncertain State-Space Model from Simulink Model ......................................................................................... 5-20\n\nSpecify Uncertain Linearization for Core or Custom Simulink Blocks ........................................................................ 5-21\n\nLinearize Block to Uncertain Model .................................................. 5-24\n\nUsing Uncertain Linearization for Analysis or Control Design .................................................................................... 5-26\n\nAnalyzing Stability Margin of Simulink Models ......................... 5-27\n How Stability Margin Analysis Using Loopmargin Differs Between Simulink and LTI Models ......................... 5-27\n Stability Margin of Simulink Model ............................................. 5-27\n\nStability Margin of a Simulink Model ........................................... 5-29\nBuilding Uncertain Models\n\n- “Introduction to Uncertain Elements” on page 1-3\n- “Uncertain Real Parameters” on page 1-5\n- “Create Uncertain Real Parameters” on page 1-7\n- “Uncertain LTI Dynamics Elements” on page 1-14\n- “Create Uncertain LTI Dynamics” on page 1-17\n- “Uncertain Complex Parameters and Matrices” on page 1-18\n- “Systems with Unmodeled Dynamics” on page 1-22\n- “Uncertain Matrices” on page 1-23\n- “Create Uncertain Matrices from Uncertain Elements” on page 1-24\n- “Access Properties of a umat” on page 1-25\n- “Row and Column Referencing” on page 1-27\n- “Matrix Operation on umat Objects” on page 1-29\n- “Evaluate Uncertain Elements by Substitution” on page 1-31\n- “Uncertain State-Space Models (uss)” on page 1-33\n- “Create Uncertain State-Space Model” on page 1-36\n- “Sample Uncertain Systems” on page 1-37\n- “Feedback Around an Uncertain Plant” on page 1-39\n- “Interpreting Uncertainty in Discrete Time” on page 1-41\n- “Lifting a ss to a uss” on page 1-42\n- “Create Uncertain Frequency Response Data Models” on page 1-43\n- “Interpreting Uncertainty in Discrete Time” on page 1-46\n- “Lifting an frd to a ufrd” on page 1-47\n- “Basic Control System Toolbox and MATLAB Interconnections” on page 1-48\n- “Simplifying Representation of Uncertain Objects” on page 1-49\n- “Generate Samples of Uncertain Systems” on page 1-53\n• “Substitution by usubs” on page 1-57\n• “Array Management for Uncertain Objects” on page 1-60\n• “Reference Into Arrays” on page 1-61\n• “Create Arrays with stack and cat Functions” on page 1-62\n• “Create Arrays by Assignment” on page 1-64\n• “Binary Operations with Arrays” on page 1-65\n• “Create Arrays with usample” on page 1-66\n• “Create Arrays with usubs” on page 1-68\n• “Create Arrays with gridureal” on page 1-69\n• “Create Arrays with repmat” on page 1-70\n• “Create Arrays with repsys” on page 1-71\n• “Using permute and ipermute” on page 1-72\n• “Decomposing Uncertain Objects” on page 1-73\nIntroduction to Uncertain Elements\n\nUncertain elements (also called uncertain Control Design Blocks) are the building blocks used to form uncertain matrix objects and uncertain system objects. There are 5 classes of uncertain elements:\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ureal</td>\n<td>Uncertain real parameter</td>\n</tr>\n<tr>\n<td>ultidyn</td>\n<td>Uncertain, linear, time-invariant dynamics</td>\n</tr>\n<tr>\n<td>ucomplex</td>\n<td>Uncertain complex parameter</td>\n</tr>\n<tr>\n<td>ucomplexm</td>\n<td>Uncertain complex matrix</td>\n</tr>\n<tr>\n<td>udyn</td>\n<td>Uncertain dynamic system</td>\n</tr>\n</tbody>\n</table>\n\nAll of the elements have properties, which are accessed through `get` and `set` methods. This `get` and `set` interface mimics the Control System Toolbox™ and MATLAB® Handle Graphics® behavior. For instance, `get(a,'PropertyName')` is the same as `a.PropertyName`, and `set(b,'PropertyName',Value)` is the same as `b.PropertyName = value`. Functionality also includes tab-completion and case-insensitive, partial name property matching.\n\nFor `ureal`, `ucomplex` and `ucomplexm` elements, the syntax is\n\n```matlab\np1 = ureal(name, NominalValue, Prop1, val1, Prop2, val2,...);\np2 = ucomplex(name, NominalValue, Prop1, val1, Prop2, val2,...);\np3 = ucomplexm(name, NominalValue, Prop1, val1, Prop2, val2,...);\n```\n\nFor `ultidyn` and `udyn`, the `NominalValue` is fixed, so the syntax is\n\n```matlab\np4 = ultidyn(name, ioSize, Prop1, val1, Prop2, val2,...);\np5 = udyn(name, ioSize, Prop1, val1, Prop2, val2,...);\n```\n\nFor `ureal`, `ultidyn`, `ucomplex` and `ucomplexm` elements, the command `usample` will generate a random instance (i.e., not uncertain) of the element, within its modeled range. For example,\n\n```matlab\nusample(p1)\n```\ncreates a random instance of the uncertain real parameter `p1`. With an integer argument, whole arrays of instances can be created. For instance\nusample(p4,100)\n\ngenerates an array of 100 instances of the ultidyn object p4. See “Generate Samples of Uncertain Systems” on page 1-53 to learn more about usample.\nUncertain Real Parameters\n\nAn uncertain real parameter is the Control Design Block that represents a real number whose value is uncertain. Uncertain real parameters have a name (the Name property), and a nominal value (the NominalValue property). Several other properties (PlusMinus, Range, Percentage) describe the uncertainty in parameter values.\n\nAll properties of a ureal can be accessed through get and set. The properties are:\n\n<table>\n<thead>\n<tr>\n<th>Properties</th>\n<th>Meaning</th>\n<th>Class</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Name</td>\n<td>Internal name</td>\n<td>char</td>\n</tr>\n<tr>\n<td>NominalValue</td>\n<td>Nominal value of element</td>\n<td>double</td>\n</tr>\n<tr>\n<td>Mode</td>\n<td>Signifies which description (from 'PlusMinus', 'Range', 'Percentage') of uncertainty is invariant when NominalValue is changed</td>\n<td>char</td>\n</tr>\n<tr>\n<td>PlusMinus</td>\n<td>Additive variation</td>\n<td>scalar or 1x2 double</td>\n</tr>\n<tr>\n<td>Range</td>\n<td>Numerical range</td>\n<td>1x2 double</td>\n</tr>\n<tr>\n<td>Percentage</td>\n<td>Additive variation (% of absolute value of nominal)</td>\n<td>scalar or 1x2 double</td>\n</tr>\n<tr>\n<td>AutoSimplify</td>\n<td>'off'</td>\n<td>{'basic'}</td>\n</tr>\n</tbody>\n</table>\n\nThe properties Range, Percentage and PlusMinus are all automatically synchronized. If the nominal value is 0, then the Mode cannot be Percentage. The Mode property controls what aspect of the uncertainty remains unchanged when NominalValue is changed. Assigning to any of Range/Percentage/PlusMinus changes the value, but does not change the mode.\n\nThe AutoSimplify property controls how expressions involving the real parameter are simplified. Its default value is 'basic', which means elementary methods of simplification are applied as operations are completed. Other values for AutoSimplify are 'off' (no simplification performed) and 'full' (model-reduction-like techniques are applied). See “Simplifying Representation of Uncertain Objects” on page 1-49 to learn more about the AutoSimplify property and the command simplify.\n\nIf no property/value pairs are specified, default values are used. The default Mode is PlusMinus, and the default value of PlusMinus is [-1 1]. Some examples are shown\nbelow. In many cases, the full property name is not specified, taking advantage of the case-insensitive, partial name property matching.\nCreate Uncertain Real Parameters\n\nThis example shows how to create uncertain real parameters, modify properties such as range of uncertainty, and sample uncertain parameters.\n\nCreate an uncertain real parameter, nominal value 3, with default values for all unspecified properties (including plus/minus variability of 1).\n\n```matlab\na = ureal('a',3)\n```\n\n```\na =\n\n Uncertain real parameter \"a\" with nominal value 3 and variability [-1,1].\n```\n\nView the properties and their values, and note that the Range and Percentage descriptions of variability are automatically maintained.\n\n```matlab\nget(a)\n```\n\n```\n Name: 'a'\n NominalValue: 3\n Mode: 'PlusMinus'\n Range: [2 4]\n PlusMinus: [-1 1]\n Percentage: [-33.3333 33.3333]\n AutoSimplify: 'basic'\n```\n\nCreate an uncertain real parameter, nominal value 2, with 20% variability. Again, view the properties, and note that the Range and PlusMinus descriptions of variability are automatically maintained.\n\n```matlab\nb = ureal('b',2,'Percentage',20)\nget(b)\n```\n\n```\nb =\n\n Uncertain real parameter \"b\" with nominal value 2 and variability [-20,20]%. \n Name: 'b'\n```\nChange the range of the parameter. All descriptions of variability are automatically updated, while the nominal value remains fixed. Although the change in variability was accomplished by specifying the Range, the Mode is unaffected, and remains Percentage.\n\n```matlab\nb.Range = [1.9 2.3];\nget(b)\n```\n\nAs mentioned, the Mode property signifies what aspect of the uncertainty remains unchanged when NominalValue is modified. Hence, if a real parameter is in Percentage mode, then the Range and PlusMinus properties are determined from the Percentage property and NominalValue. Changing NominalValue preserves the Percentage property, and automatically updates the Range and PlusMinus properties.\n\n```matlab\nb.NominalValue = 2.2;\nget(b)\n```\n\nCreate an uncertain parameter with an asymmetric variation about its nominal value. Examine the properties to confirm the asymmetric range.\nCreate an uncertain parameter, specifying variability with *Percentage*, but force the *Mode* to be *Range*.\n\n\\[ c = \\text{ureal('c',-5,'Percentage',[-20 30])}; \\]\n\\[ \\text{get(c)} \\]\n\n\\[ \\begin{align*}\n\\text{Name: } & \\text{'c'} \\\\\n\\text{NominalValue: } & -5 \\\\\n\\text{Mode: } & \\text{'Percentage'} \\\\\n\\text{Range: } & \\text{[-6 -3.5000]} \\\\\n\\text{PlusMinus: } & \\text{[-1 1.5000]} \\\\\n\\text{Percentage: } & \\text{[-20 30]} \\\\\n\\text{AutoSimplify: } & \\text{'basic'}\n\\end{align*} \\]\n\nCreate an uncertain parameter, specifying variability with *Percentage*, but force the *Mode* to be *Range*.\n\n\\[ d = \\text{ureal('d',-1,'Mode','Range','Percentage',[-40 60])}; \\]\n\\[ \\text{get(d)} \\]\n\n\\[ \\begin{align*}\n\\text{Name: } & \\text{'d'} \\\\\n\\text{NominalValue: } & -1 \\\\\n\\text{Mode: } & \\text{'Range'} \\\\\n\\text{Range: } & \\text{[-1.4000 -0.4000]} \\\\\n\\text{PlusMinus: } & \\text{[-0.4000 0.6000]} \\\\\n\\text{Percentage: } & \\text{[-40 60]} \\\\\n\\text{AutoSimplify: } & \\text{'basic'}\n\\end{align*} \\]\n\nFinally, create an uncertain real parameter, and set the *AutoSimplify* property to *full*.\n\n\\[ e = \\text{ureal('e',10,'PlusMinus',[-23], 'Mode', 'Percentage', 'AutoSimplify','Full')}; \\]\n\\[ \\text{get(e)} \\]\n\n\\[ e = \\]\n\nUncertain real parameter \"e\" with nominal value 10 and variability [-230,230]%. \n\n\\[ \\begin{align*}\n\\text{Name: } & \\text{'e'} \\\\\n\\text{NominalValue: } & 10 \\\\\n\\text{Mode: } & \\text{'Percentage'} \\\\\n\\text{Range: } & \\text{[-13 33]} \\\\\n\\text{PlusMinus: } & \\text{[-23 23]} \\\\\n\\text{Percentage: } & \\text{[-230 230]}\n\\end{align*} \\]\nAutoSimplify: 'full'\n\nSpecifying conflicting values for **Range/Percentage/PlusMinus** when creating a **ureal** element does not result in an error. In this case, the last specified property is used. This last occurrence also determines the **Mode**, unless **Mode** is explicitly specified, in which case that is used, regardless of the property/value pairs ordering.\n\n```matlab\nf = ureal('f',3,'PlusMinus',[-2 1],'Percentage',40)\ng = ureal('g',2,'PlusMinus',[-2 1],'Mode','Range','Percentage',40)\ng.Mode\n```\n\n```matlab\nf =\n\nUncertain real parameter \"f\" with nominal value 3 and variability [-40,40]%. \n\ng =\n\nUncertain real parameter \"g\" with nominal value 2 and range [1.2,2.8].\n\nans =\nRange\n```\n\nCreate an uncertain real parameter, use **usample** to generate 1000 instances (resulting in a 1-by-1-by-1000 array), reshape the array, and plot a histogram, with 20 bins (within the range of 2 to 4).\n\n```matlab\nh = ureal('h',3);\nhsample = usample(h,1000);\nhist(reshape(hsample,[1000 1]),20);\n```\nCreate Uncertain Real Parameters\n\nMake the range unsymmetric about the nominal value, and repeat the sampling, and histogram plot (with 40 bins over the range of 2-to-6)\n\n```matlab\nh.Range = [2 6];\nhsample = usample(h,1000);\nhist(reshape(hsample,[1000 1]),40);\n```\nNote that the distribution is skewed. However, the number of samples less than the nominal value and the number of samples greater than the nominal value are equal (on average). Verify this.\n\n\\[ \\text{length(find(hsample(:) < h.NominalValue))} \\]\n\n\\[ \\text{ans =} \\]\n\n\\[ 482 \\]\n\n\\[ \\text{length(find(hsample(:) > h.NominalValue))} \\]\nans =\n\n518\n\nThe distribution used in usample is uniform in the normalized description of the uncertain real parameter. See “Decomposing Uncertain Objects” to learn more about the normalized description.\n\nThere is no notion of an empty ureal (or any other uncertain element, for that matter). ureal, by itself, creates an element named 'UNNAMED', with default property values.\nUncertain LTI Dynamics Elements\n\nUncertain linear, time-invariant objects, `ultidyn`, are used to represent unknown linear, time-invariant dynamic objects, whose only known attributes are bounds on their frequency response. Uncertain linear, time-invariant objects have an internal name (the `Name` property), and are created by specifying their size (number of outputs and number of inputs).\n\nThe property `Type` specifies whether the known attributes about the frequency response are related to gain or phase. The property `Type` may be `'GainBounded'` or `'PositiveReal'`. The default value is `'GainBounded'`.\n\nThe property `Bound` is a single number, which along with `Type`, completely specifies what is known about the uncertain frequency response. Specifically, if $\\Delta$ is an `ultidyn` element, and if $\\gamma$ denotes the value of the `Bound` property, then the element represents the set of all stable, linear, time-invariant systems whose frequency response satisfies certain conditions:\n\nIf `Type` is `'GainBounded'`, $\\sigma[\\Delta(\\omega)] \\leq \\gamma$ for all frequencies. When `Type` is `'GainBounded'`, the default value for `Bound` (i.e., $\\gamma$) is 1. The NominalValue of $\\Delta$ is always the 0-matrix.\n\nIf `Type` is `'PositiveReal'`, $\\Delta(\\omega) + \\Delta^*(\\omega) \\geq 2\\gamma$ for all frequencies. When `Type` is `'PositiveReal'`, the default value for `Bound` (i.e., $\\gamma$) is 0. The NominalValue is always $(\\gamma + 1 + 2|\\gamma|)I$.\n\nAll properties of a `ultidyn` are can be accessed with `get` and `set` (although the NominalValue is determined from `Type` and `Bound`, and not accessible with `set`). The properties are\n\n<table>\n<thead>\n<tr>\n<th>Properties</th>\n<th>Meaning</th>\n<th>Class</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Name</td>\n<td>Internal Name</td>\n<td>char</td>\n</tr>\n<tr>\n<td>NominalValue</td>\n<td>Nominal value of element</td>\n<td>See above</td>\n</tr>\n<tr>\n<td>Type</td>\n<td><code>'GainBounded'</code></td>\n<td><code>'PositiveReal'</code></td>\n</tr>\n<tr>\n<td>Bound</td>\n<td>Norm bound or minimum real</td>\n<td>scalar double</td>\n</tr>\n<tr>\n<td>SampleStateDimen</td>\n<td>State-space dimension of random samples of this uncertain element</td>\n<td>scalar double</td>\n</tr>\n</tbody>\n</table>\nUncertain LTI Dynamics Elements\n\n<table>\n<thead>\n<tr>\n<th>Properties</th>\n<th>Meaning</th>\n<th>Class</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SampleMaxFrequency</td>\n<td>Maximum natural frequency for random sampling</td>\n<td>scalar double</td>\n</tr>\n<tr>\n<td>AutoSimplify</td>\n<td>'off'</td>\n<td>{'basic'}</td>\n</tr>\n</tbody>\n</table>\n\nThe `SampleStateDim` property specifies the state dimension of random samples of the element when using `usample`. The default value is 1. The `AutoSimplify` property serves the same function as in the uncertain real parameter.\n\nYou can create a 2-by-3 gain-bounded uncertain linear dynamics element. Verify its size, and check the properties.\n\n```matlab\nf = ultidyn('f',[2 3]);\nsize(f)\nan = [2 3]\nget(f)\n Name: 'f'\n NominalValue: [2x3 double]\n Type: 'GainBounded'\n Bound: 1\n SampleStateDim: 1\n AutoSimplify: 'basic'\n```\n\n**Time Domain of ultidyn Elements**\n\nOn its own, every `ultidyn` element is interpreted as a continuous-time, system with uncertain behavior, quantified by bounds (gain or real-part) on its frequency response. To see this, create a `ultidyn`, and view the sample time of several random samples of the element.\n\n```matlab\nh = ultidyn('h',[1 1]);\nget(usample(h), 'Ts')\nan = 0\nget(usample(h), 'Ts')\nan = 0\nget(usample(h), 'Ts')\nan = 0\n```\nHowever, when a `ultidyn` element is an uncertain element of an uncertain state space model (uss), then the time-domain characteristic of the element is determined from the time-domain characteristic of the system. The bounds (gain-bounded or positivity) apply to the frequency-response of the element. This is explained and demonstrated in “Interpreting Uncertainty in Discrete Time” on page 1-41.\nCreate Uncertain LTI Dynamics\n\nYou can create a 1-by-1 (scalar) positive-real uncertain linear dynamics element, whose frequency response always has real part greater than -0.5. Set the `SampleStateDimension` property to 5. Plot a Nyquist plot of 30 instances of the element.\n\n```matlab\ng = ultidyn('g',[1 1],'Type','Positivereal','Bound','-0.5');\ng.SampleStateDimension = 5;\n\nnyquist(usample(g,30))\nxlim([-2 10])\nylim([-6 6]);\n```\nUncertain Complex Parameters and Matrices\n\nUncertain Complex Parameters\n\nThe `ucomplex` element is the Control Design Block that represents an uncertain complex number. The value of an uncertain complex number lies in a disc, centered at `NominalValue`, with radius specified by the `Radius` property of the `ucomplex` element. The size of the disc can also be specified by `Percentage`, which means the radius is derived from the absolute value of the `NominalValue`. The properties of `ucomplex` objects are\n\n<table>\n<thead>\n<tr>\n<th>Properties</th>\n<th>Meaning</th>\n<th>Class</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Name</td>\n<td>Internal Name</td>\n<td>char</td>\n</tr>\n<tr>\n<td>NominalValue</td>\n<td>Nominal value of element</td>\n<td>double</td>\n</tr>\n<tr>\n<td>Mode</td>\n<td>'Range'</td>\n<td>'Percentage'</td>\n</tr>\n<tr>\n<td>Radius</td>\n<td>Radius of disk</td>\n<td>double</td>\n</tr>\n<tr>\n<td>Percentage</td>\n<td>Additive variation (percent of Radius)</td>\n<td>double</td>\n</tr>\n<tr>\n<td>AutoSimplify</td>\n<td>'off'</td>\n<td>{'basic'}</td>\n</tr>\n</tbody>\n</table>\n\nThe simplest construction requires only a name and nominal value. Displaying the properties shows that the default `Mode` is `Radius`, and the default radius is 1.\n\n```matlab\na = ucomplex('a',2-j)\n```\n\n```matlab\na =\n\n Uncertain complex parameter \"a\" with nominal value 2-1i and radius 1.\n```\n\n```matlab\nget(a)\n```\n\n```\n Name: 'a'\n NominalValue: 2.0000 - 1.0000i\n Mode: 'Radius'\n Radius: 1\n Percentage: 44.7214\n AutoSimplify: 'basic'\n```\nSample the uncertain complex parameter at 400 values, and plot in the complex plane. Clearly, the samples appear to be from a disc of radius 1, centered in the complex plane at the value $2-j$.\n\n```matlab\nasample = usample(a,400);\nplot(asample(:),'o');\nxlim([-0.5 4.5]);\nylim([-3 1]);\n```\n\n**Uncertain Complex Matrices**\n\nThe uncertain complex matrix class, `ucomplexm`, represents the set of matrices given by the formula\n\\[ N + W_L \\Delta W_R \\]\n\nwhere \\( N, W_L, \\) and \\( W_R \\) are known matrices, and \\( \\Delta \\) is any complex matrix with \\( \\sigma(\\Delta) \\leq 1 \\). All properties of a `ucomplexm` are can be accessed with `get` and `set`. The properties are\n\n<table>\n<thead>\n<tr>\n<th>Properties</th>\n<th>Meaning</th>\n<th>Class</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Name</td>\n<td>Internal Name</td>\n<td>char</td>\n</tr>\n<tr>\n<td>NominalValue</td>\n<td>Nominal value of element</td>\n<td>double</td>\n</tr>\n<tr>\n<td>WL</td>\n<td>Left weight</td>\n<td>double</td>\n</tr>\n<tr>\n<td>WR</td>\n<td>Right weight</td>\n<td>double</td>\n</tr>\n<tr>\n<td>AutoSimplify</td>\n<td>'off'</td>\n<td>{'basic'}</td>\n</tr>\n</tbody>\n</table>\n\nThe simplest construction requires only a name and nominal value. The default left and right weight matrices are identity.\n\nYou can create a 4-by-3 `ucomplexm` element, and view its properties.\n\n```\nm = ucomplexm('m', [1 2 3; 4 5 6; 7 8 9; 10 11 12])\n```\n\nUncertain Complex Matrix: Name m, 4x3\n\n```\nget(m)\n```\n\n```\nName: 'm'\nNominalValue: [4x3 double]\n WL: [4x4 double]\n WR: [3x3 double]\nAutoSimplify: 'basic'\n```\n\n```\nm.NominalValue\nans =\n1 2 3\n4 5 6\n7 8 9\n10 11 12\n```\n\n```\nm.WL\nans =\n1 0 0 0\n0 1 0 0\n0 0 1 0\n0 0 0 1\n```\n\nSample the uncertain matrix, and compare to the nominal value. Note the element-by-element sizes of the difference are generally equal, indicative of the default (identity) weighting matrices that are in place.\nabs(usample(m)--m.NominalValue)\nans =\n 0.2948 0.1001 0.2867\n 0.3028 0.2384 0.2508\n 0.3376 0.1260 0.2506\n 0.2200 0.3472 0.1657\n\nChange the left and right weighting matrices, making the uncertainty larger as you move\ndown the rows, and across the columns.\n\nm.WL = diag([0.2 0.4 0.8 1.6]);\nm.WR = diag([0.1 1 4]);\n\nSample the uncertain matrix, and compare to the nominal value. Note the element-by-\nelement sizes of the difference, and the general trend that the smallest differences are\nnear the (1,1) element, and the largest differences are near the (4,3) element, which is\ncompletely expected by choice of the diagonal weighting matrices.\n\nabs(usample(m)--m.NominalValue)\nans =\n 0.0091 0.0860 0.2753\n 0.0057 0.1717 0.6413\n 0.0304 0.2756 1.4012\n 0.0527 0.4099 1.8335\nSystems with Unmodeled Dynamics\n\nThe unstructured uncertain dynamic system Control Design Block, the udyn object, represents completely unknown multivariable, time-varying nonlinear systems.\n\nFor practical purposes, these uncertain elements represent noncommuting symbolic variables (placeholders). All algebraic operations, such as addition, subtraction, multiplication (i.e., cascade) operate properly, and substitution (with usubs) is allowed. However, all of the analysis tools (e.g., robuststab) do not handle these types of uncertain elements. As such, these elements do not provide a significant amount of usability, and their role in the user's guide is small.\n\nYou can create a 2-by-3 udyn element. Check its size, and properties.\n\n```matlab\nm = udyn('m', [2 3])\n```\n\n```matlab\nm =\n\nUncertain dynamics \"m\" with 2 outputs and 3 inputs.\n```\n\n```matlab\nget(m)\n```\n\n```matlab\nNominalValue: [2x3 ss]\nAutoSimplify: 'basic'\nTs: 0\nTimeUnit: 'seconds'\nInputName: {3x1 cell}\nInputUnit: {3x1 cell}\nInputGroup: [1x1 struct]\nOutputName: {2x1 cell}\nOutputUnit: {2x1 cell}\nOutputGroup: [1x1 struct]\nName: 'm'\nNotes: {}\nUserData: []\n```\nUncertain Matrices\n\nUncertain matrices (class `umat`) are built from doubles and uncertain elements, using traditional MATLAB matrix building syntax. Uncertain matrices can be added, subtracted, multiplied, inverted, transposed, etc., resulting in uncertain matrices. The rows and columns of an uncertain matrix are referenced in the same manner that MATLAB references rows and columns of an array, using parenthesis, and integer indices. The `NominalValue` of a uncertain matrix is the result obtained when all uncertain elements are replaced with their own `NominalValue`. The uncertain elements making up a `umat` are accessible through the `Uncertainty` gateway, and the properties of each element within a `umat` can be changed directly.\n\nUsing `usubs`, specific values may be substituted for any of the uncertain elements within a `umat`. The command `usample` generates a random sample of the uncertain matrix, substituting random samples (within their ranges) for each of the uncertain elements.\n\nThe command `wcnorm` computes tight bounds on the worst-case (maximum over the uncertain elements' ranges) norm of the uncertain matrix.\n\nStandard MATLAB numerical matrices (i.e., `double`) naturally can be viewed as uncertain matrices without any uncertainty.\nCreate Uncertain Matrices from Uncertain Elements\n\nYou can create 2 uncertain real parameters, and then a 3-by-2 uncertain matrix using these uncertain elements.\n\n```matlab\na = ureal('a',3);\nb = ureal('b',10,'pe',20);\nM = [-a 1/b; b a+1/b; 1 3]\n```\n\nM =\n\nUncertain matrix with 3 rows and 2 columns.\nThe uncertainty consists of the following blocks:\na: Uncertain real, nominal = 3, variability = [-1,1], 2 occurrences\nb: Uncertain real, nominal = 10, variability = [-20,20]%, 3 occurrences\n\nType \"M.NominalValue\" to see the nominal value, \"get(M)\" to see all properties, and \"M\nAccess Properties of a umat\n\nUse `get` to view the accessible properties of a `umat`.\n\n```matlab\nget(M)\nNominalValue: [3x2 double]\nUncertainty: [1x1 elementlist]\n```\n\nThe `NominalValue` is a `double`, obtained by replacing all uncertain elements with their nominal values.\n\n```matlab\nM.NominalValue\nans =\n -3.0000 0.1000\n 10.0000 3.1000\n 1.0000 3.0000\n```\n\nThe `Uncertainty` property is a structure, whose fields are the uncertain elements (Control Design Blocks) of `M`.\n\n```matlab\nM.Uncertainty\nans =\n a: [1x1 ureal]\n b: [1x1 ureal]\n```\n\n```matlab\nM.Uncertainty.a\nans =\n Uncertain real parameter \"a\" with nominal value 3 and variability [-1,1].\n```\n\nDirect access to the elements is facilitated through `Uncertainty`. Check the `Range` of the uncertain element named 'a' within `M`, then change it.\n\n```matlab\nM.Uncertainty.a.Range\nans =\n 2 4\nM.Uncertainty.a.Range = [2.5 5];\nM\nUMAT: 3 Rows, 2 Columns\n a: real, nominal = 3, variability = [-0.5 2], 2 occurrences\n b: real, nominal = 10, variability = [-20 20]%, 3 occurrences\n```\nThe change to the uncertain real parameter \\( a \\) only took place within \\( M \\). Verify that the variable \\( a \\) in the workspace is no longer the same as the variable \\( a \\) within \\( M \\).\n\n```matlab\nisequal(M.Uncertainty.a,a)\nans =\n 0\n```\n\nNote that combining elements which have a common internal name, but different properties leads to an error. For instance, subtracting the two elements gives an error, not 0.\n\n```matlab\nM.Uncertainty.a - a\n??? Error using ==> ndlft.lftmask\n\nElements named 'a' have different properties.\nRow and Column Referencing\n\nStandard Row/Column referencing is allowed. Note, however, that single-indexing is only allowed if the umat is a column or a row.\n\nReconstruct M (if need be), and make a 2-by-2 selection from M\n\n```matlab\na = ureal('a',3);\nb = ureal('b',10,'pe',20);\nM = [-a 1/b; b a+1/b; 1 3];\nM.Uncertainty.a.Range = [2.5 5];\nM(2:3,:)\n```\n\n```\nans =\n\nUncertain matrix with 2 rows and 2 columns.\nThe uncertainty consists of the following blocks:\n a: Uncertain real, nominal = 3, variability = [-0.5,2], 1 occurrences\n b: Uncertain real, nominal = 10, variability = [-20,20]%, 2 occurrences\n```\n\nType \"ans.NominalValue\" to see the nominal value, \"get(ans)\" to see all properties, and \"ans.Uncertainty\" to interact with the uncertain elements.\n\nMake a single column selection from M, and use single-index references to access elements of it.\n\n```matlab\nh = M([2 1 2 3],2)\n```\n\n```\nh =\n\nUncertain matrix with 4 rows and 1 columns.\nThe uncertainty consists of the following blocks:\n a: Uncertain real, nominal = 3, variability = [-0.5,2], 1 occurrences\n b: Uncertain real, nominal = 10, variability = [-20,20]%, 1 occurrences\n```\n\nType \"h.NominalValue\" to see the nominal value, \"get(h)\" to see all properties, and \"h.Uncertainty\" to interact with the uncertain elements.\n\n```matlab\nh(2)\n```\n\n```\nans =\n\nUncertain matrix with 1 rows and 1 columns.\nThe uncertainty consists of the following blocks:\n b: Uncertain real, nominal = 10, variability = [-20,20]%, 1 occurrences\n```\nFinally, make the (3,2) entry of M uncertain.\n\n\\[\nM(3,2) = \\text{ureal}('c',3, '\\text{perc}', 40)\n\\]\n\n\\[\nM =\n\\]\n\nUncertain matrix with 3 rows and 2 columns.\nThe uncertainty consists of the following blocks:\n a: Uncertain real, nominal = 3, variability = [-0.5, 2], 2 occurrences\n b: Uncertain real, nominal = 10, variability = [-20, 20]%, 2 occurrences\n c: Uncertain real, nominal = 3, variability = [-40, 40]%, 1 occurrences\n\nType \"M.NominalValue\" to see the nominal value, \"get(M)\" to see all properties, and \"M.Uncertainty\" to interact with the uncertain elements.\nMatrix Operation on umat Objects\n\nMany matrix operations are allowed, such as matrix-multiply, transpose, and inverse. Combinations of certain (i.e., not uncertain) matrices and uncertain matrices are allowed.\n\nPremultiply $M$ by a 1-by-3 constant matrix, resulting in a 1-by-2 umat.\n\n$$M1 = [2 \\ 3 \\ 1] * M$$\n\n$M1 =$\n\nUncertain matrix with 1 rows and 2 columns.\nThe uncertainty consists of the following blocks:\n a: Uncertain real, nominal = 3, variability = [-0.5 2], 1 occurrences\n b: Uncertain real, nominal = 10, variability = [20 20]%, 2 occurrences\n c: Uncertain real, nominal = 3, variability = [-40 40]%, 1 occurrences\n\nType \"M1.NominalValue\" to see the nominal value, \"get(M1)\" to see all properties, and \"M1.Uncertainty\" to interact with the uncertain elements.\n\nVerify that the 1st entry of $M1$ is $-2a + 3b + 1$. Direct subtraction yields a umat without any dependence on uncertain elements. Simplifying the class shows that the result has no uncertain elements, as expected.\n\n$$d = M1(1) - (-2*M.Uncertainty.a + 3*M.Uncertainty.b + 1)$$\n\nd =\n\nUncertain matrix with 1 rows, 1 columns, and no uncertain blocks.\n\nType \"d.NominalValue\" to see the nominal value, \"get(d)\" to see all properties, and \"d.Uncertainty\" to interact with the uncertain elements.\n\nsimplify(d,'class');\n\nans =\n\nUncertain matrix with 1 rows, 1 columns, and no uncertain blocks.\n\nTranspose $M$, form a product, an inverse, and sample the uncertain result. As expected, the result is the 2-by-2 identity matrix.\n\n$$H = M.' * M;$$\n$$K = inv(H);$$\n$$usample(K*H,3)$$\n\nans(:,1) =\n\\[\n\\begin{bmatrix}\n1.0000 & -0.0000 \\\\\n-0.0000 & 1.0000 \\\\\n\\end{bmatrix}\n\\]\n\n\\text{ans(:,:,2) =}\n\\[\n\\begin{bmatrix}\n1.0000 & 0.0000 \\\\\n-0.0000 & 1.0000 \\\\\n\\end{bmatrix}\n\\]\n\n\\text{ans(:,:,3) =}\n\\[\n\\begin{bmatrix}\n1.0000 & 0.0000 \\\\\n-0.0000 & 1.0000 \\\\\n\\end{bmatrix}\n\\]\nEvaluate Uncertain Elements by Substitution\n\nUncertain elements can be substituted for using `usubs`. For more information, see “Substitution by usubs” on page 1-57. Here, we illustrate a few special cases.\n\nSubstitute all instances of the uncertain real parameter named `a` with the number 4. This results in a `umat`, with dependence on the uncertain real parameters `b` and `c`.\n\n```matlab\nM2 = usubs(M,'a',4)\n```\n\n```matlab\nM2 =\n\nUncertain matrix with 3 rows and 2 columns.\nThe uncertainty consists of the following blocks:\n b: Uncertain real, nominal = 10, variability = [-20,20]%, 2 occurrences\n c: Uncertain real, nominal = 3, variability = [-40,40]%, 1 occurrences\n```\n\nType \"M2.NominalValue\" to see the nominal value, \"get(M2)\" to see all properties, and \"M2.Uncertainty\" to interact with the uncertain elements.\n\nSimilarly, we can substitute all instances of the uncertain real parameter named `b` with `M.Uncertainty.a`, resulting in a `umat` with dependence on the uncertain real parameters `a` and `c`.\n\n```matlab\nM3 = usubs(M,'b', M.Uncertainty.a)\n```\n\n```matlab\nM3 =\n\nUncertain matrix with 3 rows and 2 columns.\nThe uncertainty consists of the following blocks:\n a: Uncertain real, nominal = 3, variability = [-0.5,2], 4 occurrences\n c: Uncertain real, nominal = 3, variability = [-40,40]%, 1 occurrences\n```\n\nType \"M3.NominalValue\" to see the nominal value, \"get(M3)\" to see all properties, and \"M3.Uncertainty\" to interact with the uncertain elements.\n\nNominal and/or random instances can easily be specified.\n\n```matlab\nM4 = usubs(M,'a','nominal','b','random')\n```\n\n```matlab\nM4 =\n\nUncertain matrix with 3 rows and 2 columns.\nThe uncertainty consists of the following blocks:\n c: Uncertain real, nominal = 3, variability = [-40,40]%, 1 occurrences\n```\nThe command `usample` also generates multiple random instances of a `umat` (and `uss` and `ufrd`). See “Generate Samples of Uncertain Systems” on page 1-53 for details.\n\n**Lifting a double matrix to a umat**\n\nA not-uncertain matrix may be interpreted as an uncertain matrix that has no dependence on uncertain elements. Use the `umat` command to *lift* a double to the `umat` class.\n\n\\[\n\\text{Md} = \\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{bmatrix}; \\\\\nM = \\text{umat}(\\text{Md})\n\\]\n\n\\[\nM = \\text{Uncertain matrix with 2 rows, 3 columns, and no uncertain blocks.}\n\\]\n\nType \"M.NominalValue\" to see the nominal value, \"get(M)\" to see all properties, and \"M.Uncertainty\" to interact with the uncertain elements.\n\nHigh dimensional double matrices can also be lifted. Note from the display that once the matrix is interpreted as a `umat`, the third dimension and beyond are interpreted as array dimensions. See “Array Management for Uncertain Objects” on page 1-60 for more information about how multidimensional arrays of uncertain objects are handled.\n\n\\[\n\\text{Md} = \\text{randn}(4,5,6); \\\\\nM = \\text{umat}(\\text{Md})\n\\]\n\n\\[\nM = \\text{umat}(\\text{Md})\n\\]\n\n\\[\n6x1 \\text{ array of uncertain matrices with 4 rows, 5 columns, and no uncertain blocks.}\n\\]\n\nType \"M.NominalValue\" to see the nominal value, \"get(M)\" to see all properties, and \"M.Uncertainty\" to interact with the uncertain elements.\n\n\\[\n\\text{Md} = \\text{randn}(4,5,6,7); \\\\\nM = \\text{umat}(\\text{Md})\n\\]\n\n\\[\nM = \\text{umat}(\\text{Md})\n\\]\n\n\\[\n6x7 \\text{ array of uncertain matrices with 4 rows, 5 columns, and no uncertain blocks.}\n\\]\n\nType \"M.NominalValue\" to see the nominal value, \"get(M)\" to see all properties, and \"M.Uncertainty\" to interact with the uncertain elements.\nUncertain State-Space Models (uss)\n\nUncertain systems (uss) are linear systems with uncertain state-space matrices and/or uncertain linear dynamics. Like their certain (i.e., not uncertain) counterpart, the ss object, they are often built from state-space matrices using the ss command. In the case where some of the state-space matrices are uncertain elements (uncertain Control Design Blocks), the result will be a uncertain state-space (uss) object.\n\nCombining uncertain systems with uncertain systems (with the feedback command, for example) usually leads to an uncertain system. Not-uncertain systems can be combined with uncertain systems. Usually the result is an uncertain system.\n\nThe nominal value of an uncertain system is a ss object, which is familiar to Control System Toolbox software users.\n\nProperties of uss Objects\n\nCreate a uss object and view the properties.\n\n```matlab\np1 = ureal('p1',10,'pe',50); p2 = ureal('p2',3,'plusm',[-.5 1.2]); p3 = ureal('p3',0); A = [-p1 p2;0 -p1]; B = [-p2;p2+p3]; C = [1 0;1 1-p3]; D = [0;0]; sys = ss(A,B,C,D); % Create uss model\nget(sys)\n```\n\n\\[\n\\begin{align*}\na & : [2x2 \\text{ umat}] \\\\\nb & : [2x1 \\text{ umat}] \\\\\nc & : [2x2 \\text{ umat}] \\\\\nd & : [2x1 \\text{ double}] \\\\\ne & : [\n\\\\\n\\text{StateName} & : [2x1 \\text{ cell}] \\\\\n\\text{StateUnit} & : [2x1 \\text{ cell}] \\\\\n\\text{NominalValue} & : [2x1 \\text{ ss}] \\\\\n\\text{Uncertainty} & : [1x1 \\text{ struct}] \\\\\n\\text{InternalDelay} & : [0x1 \\text{ double}] \\\\\n\\text{InputDelay} & : 0\n\\end{align*}\n\\]\nOutputDelay: [2x1 double]\n Ts: 0\n TimeUnit: 'seconds'\n InputName: {''\n InputUnit: {''\n InputGroup: [1x1 struct]\n OutputName: {2x1 cell}\n OutputUnit: {2x1 cell}\n OutputGroup: [1x1 cell]\n Name: '\n Notes: {}\n UserData: []\n SamplingGrid: [1x1 struct]\n\nThe properties a, b, c, d, and StateName behave in exactly the same manner as in Control System Toolbox ss objects. The properties InputName, OutputName, InputGroup and OutputGroup behave in exactly the same manner as all of the Control System Toolbox objects (ss, zpk, tf, and frd).\n\nThe NominalValue is a Control System Toolbox ss object, and hence all methods for ss objects are available. For instance, compute the poles and step response of the nominal system.\n\n```\npole(sys.NominalValue)\n\nans =\n -10\n -10\n```\n\n```\nstep(sys.NominalValue)\n```\nJust as with the \nemat class, the \nuncertainty property is a structure containing the \nuncertain elements. Direct access to the elements is facilitated through \nuncertainty. \nCheck the Range of the uncertain element named \n'p2' within \nsys, then change its left \nendpoint.\n\nsys.Uncertainty.p2.range\n\nans =\n\n2.5000 4.2000\n\nsys.Uncertainty.p2.range(1) = 2;\nCreate Uncertain State-Space Model\n\nUncertain systems (class `uss`) are built from certain and/or uncertain state-space matrices, usually using the `ss` command.\n\nIn the example below, the A, B and C matrices are made up of uncertain real parameters. Packing them together with the `ss` command results in a continuous-time uncertain system.\n\nYou can create three uncertain real parameters. Then create 3 uncertain matrices A, B and C, and one `double` matrix D.\n\n```matlab\np1 = ureal('p1',10,'pe',50);\np2 = ureal('p2',3,'plusm',[-.5 1.2]);\np3 = ureal('p3',0);\nA = [-p1 p2;0 -p1];\nB = [-p2;p2+p3];\nC = [1 0;1 1-p3];\nD = [0;0];\n```\n\nPack the 4 matrices together using the `ss` command. This results in a continuous-time 2-output, 1-input, 2-state uncertain system.\n\n```matlab\nsys = ss(A,B,C,D)\n```\n\n```\nUSS: 2 States, 2 Outputs, 1 Input, Continuous System\n p1: real, nominal = 10, variability = [-50 50]%, 2 occurrences\n p2: real, nominal = 3, variability = [-0.5 1.2], 2 occurrences\n p3: real, nominal = 0, variability = [-1 1], 2 occurrences\n```\nThe command `usample` randomly samples the uncertain system at a specified number of points. Randomly sample an uncertain system at 20 points in its modeled uncertainty range. This gives a 20-by-1 `ss` array. Consequently, all analysis tools from Control System Toolbox™ are available.\n\n```\np1 = ureal('p1',10,'Percentage',50);\np2 = ureal('p2',3,'PlusMinus',[-.5 1.2]);\np3 = ureal('p3',0);\nA = [-p1 p2; 0 -p1];\nB = [-p2; p2+p3];\nC = [1 0; 1 1-p3];\nD = [0; 0];\n\nsys = ss(A,B,C,D) % Create uncertain state-space model\n```\n\n```\nmanysys = usample(sys,20);\nsize(manysys)\n```\n\n20x1 array of state-space models.\nEach model has 2 outputs, 1 inputs, and 2 states.\n\n```\nstepplot(manysys)\n```\nThe command `stepplot` can be called directly on a `uss` object. The default behavior samples the `uss` object at 20 instances, and plots the step responses of these 20 models, as well as the nominal value.\n\nThe same features are available for other analysis commands such as `bodeplot`, `bodemag`, `impulse`, and `nyquist`. \nFeedback Around an Uncertain Plant\n\nIt is possible to form interconnections of `uss` objects. A common example is to form the feedback interconnection of a given controller with an uncertain plant.\n\nFirst create the uncertain plant. Start with two uncertain real parameters.\n\n```matlab\ngamma = ureal('gamma',4);\ntau = ureal('tau',.5,'Percentage',30);\n```\n\nNext, create an unmodeled dynamics element, `delta`, and a first-order weighting function, whose DC value is 0.2, high-frequency gain is 10, and whose crossover frequency is 8 rad/sec.\n\n```matlab\ndelta = ultidyn('delta',[1 1],'SampleStateDimension',5);\nW = makeweight(0.2,6,6);\n```\n\nFinally, create the uncertain plant consisting of the uncertain parameters and the unmodeled dynamics.\n\n```matlab\nP = tf(gamma,[tau 1])*(1+W*delta);\n```\n\nYou can create an integral controller based on nominal plant parameters. Nominally the closed-loop system will have damping ratio of 0.707 and time constant of `2*tau`.\n\n```matlab\nKI = 1/(2*tau.Nominal*gamma.Nominal);\nC = tf(KI,[1 0]);\n```\n\nCreate the uncertain closed-loop system using the `feedback` command.\n\n```matlab\nCLP = feedback(P*C,1);\n```\n\nPlot samples of the open-loop and closed-loop step responses. As expected the integral controller reduces the variability in the low frequency response.\n\n```matlab\nsubplot(2,1,1); stepplot(P,5)\ntextplot(P,5) subplot(2,1,2); stepplot(CLP,5)\ntextplot(CLP,5)\n```\nBuilding Uncertain Models\n\nStep Response\n\nAmplitude vs. Time (seconds)\n\nStep Response\n\nAmplitude vs. Time (seconds)\nInterpreting Uncertainty in Discrete Time\n\nThe interpretation of a \\texttt{ultidyn} element as a continuous-time or discrete-time system depends on the nature of the uncertain system (\\texttt{uss}) within which it is an uncertain element.\n\nFor example, create a scalar \\texttt{ultidyn} object. Then, create two 1-input, 1-output \\texttt{uss} objects using the \\texttt{ultidyn} object as their “D” matrix. In one case, create without specifying sample-time, which indicates continuous time. In the second case, force discrete-time, with a sample time of 0.42.\n\n\\begin{verbatim}\ndelta = ultidyn('delta',[1 1]);\nsys1 = uss([],[],[],delta);\nUSS: 0 States, 1 Output, 1 Input, Continuous System\ndelta: 1x1 LTI, max. gain = 1, 1 occurrence\nsys2 = uss([],[],[],delta,0.42);\nUSS: 0 States, 1 Output, 1 Input, Discrete System, Ts = 0.42\ndelta: 1x1 LTI, max. gain = 1, 1 occurrence\n\\end{verbatim}\n\nNext, get a random sample of each system. When obtaining random samples using \\texttt{usample}, the values of the elements used in the sample are returned in the 2nd argument from \\texttt{usample} as a structure.\n\n\\begin{verbatim}\n[sys1s,d1v] = usample(sys1);\n[sys2s,d2v] = usample(sys2);\n\\end{verbatim}\n\nLook at \\texttt{d1v.delta.Ts} and \\texttt{d2v.delta.Ts}. In the first case, since \\texttt{sys1} is continuous-time, the system \\texttt{d1v.delta} is continuous-time. In the second case, since \\texttt{sys2} is discrete-time, with sample time 0.42, the system \\texttt{d2v.delta} is discrete-time, with sample time 0.42.\n\n\\begin{verbatim}\nd1v.delta.Ts\nans =\n0\n\nd2v.delta.Ts\nans =\n0.4200\n\\end{verbatim}\n\nFinally, in the case of a discrete-time \\texttt{uss} object, it is not the case that \\texttt{ultidyn} objects are interpreted as continuous-time uncertainty in feedback with sampled-data systems. This very interesting hybrid theory is beyond the scope of the toolbox.\n**Lifting a ss to a uss**\n\nA not-uncertain state space object may be interpreted as an uncertain state space object that has no dependence on uncertain elements. Use the `uss` command to “lift” a `ss` to the `uss` class.\n\n```matlab\nsys = rss(3,2,1);\nusys = uss(sys)\nUSS: 3 States, 2 Outputs, 1 Input, Continuous System\n```\n\nArrays of `ss` objects can also be lifted. See “Array Management for Uncertain Objects” on page 1-60 for more information about how arrays of uncertain objects are handled.\nCreate Uncertain Frequency Response Data Models\n\nUncertain frequency responses (\\textit{ufrd}) arise naturally when computing the frequency response of an uncertain state-space (\\textit{uss}). They also arise when frequency response data (in an \\textit{frd} model object) is combined (added, multiplied, concatenated, etc.) to an uncertain matrix (\\textit{umat}).\n\nThe most common manner in which a \\textit{ufrd} arises is taking the frequency response of a \\textit{uss}. To do this, use the \\textit{ufrd} command.\n\nConstruct an uncertain state-space model \\textit{sys}.\n\n\\begin{verbatim}\np1 = ureal('p1',10,'pe',50);\np2 = ureal('p2',3,'plusm',[-.5 1.2]);\np3 = ureal('p3',0);\nA = [-p1 p2;0 -p1];\nB = [-p2;p2+p3];\nC = [1 0;1 1-p3];\nD = [0;0];\nsys = ss(A,B,C,D)\n\\end{verbatim}\n\n\\begin{verbatim}\nsys =\n\nUncertain continuous-time state-space model with 2 outputs, 1 inputs, 2 states.\nThe model uncertainty consists of the following blocks:\np1: Uncertain real, nominal = 10, variability = [-50,50]%, 2 occurrences\np2: Uncertain real, nominal = 3, variability = [-0.5,1.2], 2 occurrences\np3: Uncertain real, nominal = 0, variability = [-1,1], 2 occurrences\n\nType \"sys.NominalValue\" to see the nominal value, \"get(sys)\" to see all properties, and\n\\end{verbatim}\n\nCompute the uncertain frequency response of the uncertain system. Use the \\textit{ufrd} command, along with a frequency grid containing 100 points. The result is an uncertain frequency response data object, referred to as a \\textit{ufrd} model.\n\n\\begin{verbatim}\nsysg = ufrd(sys,logspace(-2,2,100))\n\\end{verbatim}\n\n\\begin{verbatim}\nsysg =\n\nUncertain continuous-time FRD model with 2 outputs, 1 inputs, 100 frequency points.\n p1: Uncertain real, nominal = 10, variability = [-50,50]%, 2 occurrences\n p2: Uncertain real, nominal = 3, variability = [-0.5,1.2], 2 occurrences\n p3: Uncertain real, nominal = 0, variability = [-1,1], 2 occurrences\n\nType \"sysg.NominalValue\" to see the nominal value, \"get(sysg)\" to see all properties, and\n\\end{verbatim}\nProperties of ufrd Objects\n\nView the properties with the `get` command.\n\n```plaintext\nget(sysg)\n Frequency: [100x1 double]\n FrequencyUnit: 'rad/TimeUnit'\n ResponseData: [4-D umat]\n NominalValue: [2x1 frd]\n Uncertainty: [1x1 struct]\n InputDelay: 0\n OutputDelay: [2x1 double]\n Ts: 0\n TimeUnit: 'seconds'\n InputName: {''\n InputUnit: {''\n InputGroup: [1x1 struct]\n OutputName: {2x1 cell}\n OutputUnit: {2x1 cell}\n OutputGroup: [1x1 struct]\n Name: ''\n Notes: {}\n UserData: []\n```\n\nThe properties `ResponseData` and `Frequency` behave in exactly the same manner as Control System Toolbox `frd` objects, except that `ResponseData` is a `umat`. The properties `InputName`, `OutputName`, `InputGroup` and `OutputGroup` behave in exactly the same manner as all of the Control System Toolbox objects (`ss`, `zpk`, `tf` and `frd`).\n\nThe `NominalValue` is a Control System Toolbox `frd` object, and hence all methods for `frd` objects are available. For instance, plot the Bode response of the nominal system.\n\n```plaintext\nbode(sysg.nom)\n```\nJust as with the `umat` and `uss` classes, the `Uncertainty` property is a structure containing the uncertain elements. Direct access to the elements is facilitated through `Uncertainty`. Change the nominal value of the uncertain element named `'p1'` within `sysg` to 14, and replot the Bode plot of the (new) nominal system.\n\n```matlab\nsysg.unc.p1.nom = 14\n```\n\n**UFRD: 2 Outputs, 1 Input, Continuous System, 100 Frequency points**\n- `p1`: real, nominal = 14, variability = [-50 50]%, 2 occurrences\n- `p2`: real, nominal = 3, variability = [-0.5 1.2], 2 occurrences\n- `p3`: real, nominal = 0, variability = [-1 1], 2 occurrences\nInterpreting Uncertainty in Discrete Time\n\nSee “Interpreting Uncertainty in Discrete Time” on page 1-41. The issues are identical.\nLifting an frd to a ufrd\n\nA not-uncertain frequency response object may be interpreted as an uncertain frequency response object that has no dependence on uncertain elements. Use the ufrd command to “lift” an frd object to the ufrd class.\n\n```matlab\nsys = rss(3,2,1);\nsysg = frd(sys,logspace(-2,2,100));\nusysg = ufrd(sysg)\nUFRD: 2 Outputs, 1 Input, Continuous System, 100 Frequency points\n```\n\nArrays of frd objects can also be lifted. See “Array Management for Uncertain Objects” on page 1-60 for more information about how arrays of uncertain objects are handled.\nBasic Control System Toolbox and MATLAB Interconnections\n\nThis list has all of the basic system interconnection functions defined in Control System Toolbox software or in MATLAB.\n\n• append\n• blkdiag\n• series\n• parallel\n• feedback\n• lft\n• stack\n\nThese functions work with uncertain objects as well. Uncertain objects may be combined with certain objects, resulting in an uncertain object.\nSimplifying Representation of Uncertain Objects\n\nA minimal realization of the transfer function matrix\n\n\\[\nH(s) = \\begin{bmatrix}\n\\frac{2}{s+1} & \\frac{4}{s+1} \\\\\n\\frac{3}{s+1} & \\frac{6}{s+1}\n\\end{bmatrix}\n\\]\n\nhas only 1 state, obvious from the decomposition\n\n\\[\nH(s) = \\begin{bmatrix}\n\\frac{2}{3}s + 1 & 1 \\\\\n1 & 2.\n\\end{bmatrix}\n\\]\n\nHowever, a “natural” construction, formed by\n\n```matlab\nsys11 = ss(tf(2,[1 1]));\nsys12 = ss(tf(4,[1 1]));\nsys21 = ss(tf(3,[1 1]));\nsys22 = ss(tf(6,[1 1]));\nsys = [sys11 sys12;sys21 sys22]\na =\n\\begin{bmatrix}\n\\begin{array}{cccc}\nx1 & x2 & x3 & x4 \\\\\nx1 & -1 & 0 & 0 & 0 \\\\\nx2 & 0 & -1 & 0 & 0 \\\\\nx3 & 0 & 0 & -1 & 0 \\\\\nx4 & 0 & 0 & 0 & -1\n\\end{array}\n\\end{bmatrix}\n\nb =\n\\begin{bmatrix}\n\\begin{array}{cc}\nu1 & u2 \\\\\nx1 & 2 & 0 \\\\\nx2 & 0 & 2 \\\\\nx3 & 2 & 0 \\\\\nx4 & 0 & 2\n\\end{array}\n\\end{bmatrix}\n\nc =\n\\begin{bmatrix}\n\\begin{array}{cccc}\nx1 & x2 & x3 & x4 \\\\\ny1 & 1 & 2 & 0 & 0 \\\\\ny2 & 0 & 0 & 1.5 & 3\n\\end{array}\n\\end{bmatrix}\n\nd =\n\\begin{bmatrix}\n\\begin{array}{cc}\nu1 & u2 \\\\\ny1 & 0 & 0 \\\\\ny2 & 0 & 0\n\\end{array}\n\\end{bmatrix}\n```\nContinuous-time model\n\nhas four states, and is nonminimal.\n\nIn the same manner, the internal representation of uncertain objects built up from uncertain elements can become nonminimal, depending on the sequence of operations in their construction. The command `simplify` employs ad-hoc simplification and reduction schemes to reduce the complexity of the representation of uncertain objects. There are three levels of simplification: off, basic and full. Each uncertain element has an `AutoSimplify` property whose value is one of the strings 'off', 'basic' or 'full'. The default value is 'basic'.\n\nAfter (nearly) every operation, the command `simplify` is automatically run on the uncertain object, cycling through all of the uncertain elements, and attempting to simplify (without error) the representation of the effect of that uncertain object. The `AutoSimplify` property of each element dictates the types of computations that are performed. In the 'off' case, no simplification is even attempted. In 'basic', fairly simple schemes to detect and eliminate nonminimal representations are used. Finally, in 'full', numerical based methods similar to truncated balanced realizations are used, with a very tight tolerance to minimize error.\n\n**Effect of the Autosimplify Property**\n\nCreate an uncertain real parameter, view the `AutoSimplify` property of `a`, and then create a 1-by-2 `umat`, both of whose entries involve the uncertain parameter.\n\n```matlab\na = ureal('a',4);\na.AutoSimplify\nans =\nbasic\nm1 = [a+4 6*a]\nUMAT: 1 Rows, 2 Columns\n a: real, nominal = 4, variability = [-1 1], 1 occurrence\n```\n\nNote that although the uncertain real parameter `a` appears in both (two) entries of the matrix, the resulting uncertain matrix `m1` only depends on “1 occurrence” of `a`.\n\nSet the `AutoSimplify` property of `a` to 'off' (from 'basic'). Recreate the 1-by-2 `umat`. Now note that the resulting uncertain matrix `m2` depends on “2 occurrences” of `a`.\n\n```matlab\na.AutoSimplify = 'off';\nm2 = [a+4 6*a]\n```\nThe 'basic' level of autosimplification often detects (and simplifies) duplication created by linear terms in the various entries. Higher order (quadratic, bilinear, etc.) duplication is often not detected by the 'basic' autosimplify level.\n\nFor example, reset the `AutoSimplify` property of `a` to 'basic' (from 'off'). Create an uncertain real parameter, and a 1-by-2 `umat`, both of whose entries involve the square of the uncertain parameter.\n\n```matlab\na.AutoSimplify = 'basic';\nm3 = [a*(a+4) 6*a*a]\n```\n\nNote that the resulting uncertain matrix `m3` depends on “4 occurrences” of `a`.\n\nSet the `AutoSimplify` property of `a` to 'full' (from 'basic'). Recreate the 1-by-2 `umat`. Now note that the resulting uncertain matrix `m4` depends on “2 occurrences” of `a`.\n\n```matlab\na.AutoSimplify = 'full';\nm4 = [a*(a+4) 6*a*a]\n```\n\nAlthough `m4` has a less complex representation (2 occurrences of `a` rather than 4 as in `m3`), some numerical variations are seen when both uncertain objects are evaluated at (say) 0.\n\n```matlab\nusubs(m3,'a',0)\nan =\n 0 0\nusubs(m4,'a',0)\nan =\n 1.0e-015 *\n 0.4441 0\n```\n\nSmall numerical differences are also noted at other evaluation points. The example below shows the differences encountered evaluating at `a` equal to 1.\n\n```matlab\nusubs(m3,'a',1)\nan =\n 5 6\n```\nDirect Use of simplify\n\nThe `simplify` command can be used to override all uncertain element's `AutoSimplify` property. The first input to the `simplify` command is an uncertain object. The second input is the desired reduction technique, which can either 'basic' or 'full'.\n\nAgain create an uncertain real parameter, and a 1-by-2 `umat`, both of whose entries involve the square of the uncertain parameter. Set the `AutoSimplify` property of `a` to 'basic'.\n\n```matlab\na.AutoSimplify = 'basic';\nm3 = [a*(a+4) 6*a*a]\nUMAT: 1 Rows, 2 Columns\n a: real, nominal = 4, variability = [-1 1], 4 occurrences\n```\n\nNote that the resulting uncertain matrix `m3` depends on four occurrences of `a`.\n\nThe `simplify` command can be used to perform a 'full' reduction on the resulting `umat`.\n\n```matlab\nm4 = simplify(m3,'full')\nUMAT: 1 Rows, 2 Columns\n a: real, nominal = 4, variability = [-1 1], 2 occurrences\n```\n\nThe resulting uncertain matrix `m4` depends on only two occurrences of `a` after the reduction.\nGenerate Samples of Uncertain Systems\n\nThe command `usample` is used to randomly sample an uncertain object, giving a not-uncertain instance of the uncertain object.\n\n**Generating One Sample**\n\nIf $A$ is an uncertain object, then `usample(A)` generates a single sample of $A$.\n\nFor example, a sample of a `ureal` is a scalar `double`.\n\n```matlab\nA = ureal('A',6);\nB = usample(A)\nB =\n 5.7298\n```\n\nCreate a 1-by-3 `umat` with $A$ and an uncertain complex parameter $C$. A single sample of this `umat` is a 1-by-3 `double`.\n\n```matlab\nC = ucomplex('C',2+6j);\nM = [A C A*A];\nusample(M)\nans =\n 5.9785 1.4375 + 6.0290i 35.7428\n```\n\n**Generating Many Samples**\n\nIf $A$ is an uncertain object, then `usample(A,N)` generates $N$ samples of $A$.\n\nFor example, 20 samples of a `ureal` gives a 1-by-1-20 `double` array.\n\n```matlab\nB = usample(A,20);\nsize(B)\nans =\n 1 1 20\n```\n\nSimilarly, 30 samples of the 1-by-3 `umat` $M$ yields a 1-by-3-by-30 array.\n\n```matlab\nsize(usample(M,30))\nans =\n```\nSee “Create Arrays with usample” on page 1-66 for more information on sampling uncertain objects.\n\n**Sampling ultidyn Elements**\n\nWhen sampling an ultidyn element or an uncertain object that contains a ultidyn element, the result is always a state-space (ss) object. The property `SampleStateDimension` of the ultidyn class determines the state dimension of the samples.\n\nCreate a 1-by-1, gain bounded ultidyn object with gain bound 3. Verify that the default state dimension for samples is 1.\n\n```matlab\ndel = ultidyn('del',[1 1],'Bound',3);\ndel.SampleStateDimension\n```\n\n```\nans =\n 1\n```\n\nSample the uncertain element at 30 points. Verify that this creates a 30-by-1 ss array of 1-input, 1-output, 1-state systems.\n\n```matlab\ndelS = usample(del,30);\nsize(delS)\n```\n\n```\n30x1 array of state-space models.\nEach model has 1 outputs, 1 inputs, and 1 states.\n```\n\nPlot the Nyquist plot of these samples and add a disk of radius 3. Note that the gain bound is satisfied and that the Nyquist plots are all circles, indicative of 1st order systems.\n\n```matlab\nnyquist(delS)\nhold on;\ntheta = linspace(-pi,pi);\nplot(del.Bound*exp(sqrt(-1)*theta),'r');\nhold off;\n```\nChange `SampleStateDimension` to 4, and repeat entire procedure. The Nyquist plots satisfy the gain bound and as expected are more complex than the circles found in the 1st-order sampling.\n\n```matlab\ndel.SampleStateDimension = 4;\ndelS = usample(del,30);\nnyquist(delS)\nhold on;\ntheta = linspace(-pi,pi);\nplot(del.Bound*exp(sqrt(-1)*theta),'r');\nhold off;\n```\nNyquist Diagram\n\nImaginary Axis\n\nReal Axis\n\n1 Building Uncertain Models\nSubstitution by usubs\n\nIf an uncertain object (umat, uss, ufrd) has many uncertain parameters, it is often necessary to freeze some, but not all, of the uncertain parameters to specific values. The usubs command accomplishes this, and also allows more complicated substitutions for an element.\n\nusubs accepts a list of element names, and respective values to substitute for them. You can create three uncertain real parameters and use them to create a 2-by-2 uncertain matrix A.\n\ndelta = ureal('delta',2);\neta = ureal('eta',6);\nrho = ureal('rho',-1);\nA = [3+delta+eta delta/eta;7+rho rho+delta*eta]\n\nA =\n\nUncertain matrix with 2 rows and 2 columns.\nThe uncertainty consists of the following blocks:\n delta: Uncertain real, nominal = 2, variability = [-1,1], 2 occurrences\n eta: Uncertain real, nominal = 6, variability = [-1,1], 3 occurrences\n rho: Uncertain real, nominal = -1, variability = [-1,1], 1 occurrences\n\nType \"A.NominalValue\" to see the nominal value, \"get(A)\" to see all properties, and \"A.Uncertainty\" to interact with the uncertain elements.\n\nUse usubs to substitute the uncertain element named delta in A with the value 2.3, leaving all other uncertain elements intact. Note that the result, B, is an uncertain matrix with dependence only on eta and rho.\n\nB = usubs(A,'delta',2.3)\n\nB =\n\nUncertain matrix with 2 rows and 2 columns.\nThe uncertainty consists of the following blocks:\n eta: Uncertain real, nominal = 6, variability = [-1,1], 3 occurrences\n rho: Uncertain real, nominal = -1, variability = [-1,1], 1 occurrences\n\nType \"B.NominalValue\" to see the nominal value, \"get(B)\" to see all properties, and \"B.Uncertainty\" to interact with the uncertain elements.\n\nTo set multiple elements, list individually, or group the values in a data structure. For instance, the following are the same.\nB1 = usubs(A,'\\text{delta}',2.3,'\\text{eta}',A.Uncertainty.rho);\nS.delta = 2.3;\nS.eta = A.Uncertainty.rho;\nB2 = usubs(A,S);\n\nIn each case, \\text{delta} is replaced by 2.3, and \\text{eta} is replaced by A.Uncertainty.rho.\n\nAny superfluous substitution requests are ignored. Hence, the following returns an uncertain model that is the same as A.\n\nB4 = usubs(A,'\\text{fred}',5);\n\n\\textbf{Specifying the Substitution with Structures}\n\nAn alternative syntax for \\texttt{usubs} is to specify the substituted values in a structure, whose fieldnames are the names of the elements being substituted with values.\n\nCreate a structure \\texttt{NV} with 2 fields, \\texttt{delta} and \\texttt{eta}. Set the values of these fields to be the desired substituted values. Then perform the substitution with \\texttt{usubs}.\n\n\\begin{verbatim}\nNV.delta = 2.3;\nNV.eta = A.Uncertainty.rho;\nB6 = usubs(A,NV);\n\\end{verbatim}\n\nHere, B6 is the same as B1 and B2 above. Again, any superfluous fields are ignored. Therefore, adding an additional field \\texttt{gamma} to \\texttt{NV}, and substituting does not alter the result.\n\n\\begin{verbatim}\nNV.gama = 0;\nB7 = usubs(A,NV);\n\\end{verbatim}\n\nHere, B7 is the same as B6.\n\nThe commands \\texttt{wcgain}, \\texttt{robuststab} and \\texttt{usample} all return substitutable values in this structure format. More discussion can be found in “Create Arrays with \\texttt{usubs}” on page 1-68.\n\n\\textbf{Nominal and Random Values}\n\nIf the replacement value is the (partial and case-independent) string ‘Nominal’, then the listed element are replaced with their nominal values. Therefore\n\nB8 = usubs(A,fieldnames(A.Uncertainty),'nom')\nB8 =\n\n\\[\n\\begin{align*}\n11.0000 & \\quad 0.3333 \\\\\n6.0000 & \\quad 11.0000\n\\end{align*}\n\\]\n\nB9 = A.NominalValue\n\nB9 =\n\n\\[\n\\begin{align*}\n11.0000 & \\quad 0.3333 \\\\\n6.0000 & \\quad 11.0000\n\\end{align*}\n\\]\n\nare the same. It is possible to only set some of the elements to NominalValues, and would be the typical use of usubs with the 'nominal' argument.\n\nWithin A, set eta to its nominal value, delta to a random value (within its range) and rho to a specific value, say 6.5\n\nB10 = usubs(A,'eta','nom','delta','rand','rho',6.5)\n\nB10 =\n\n\\[\n\\begin{align*}\n10.5183 & \\quad 0.2531 \\\\\n13.5000 & \\quad 15.6100\n\\end{align*}\n\\]\n\nUnfortunately, the 'nominal' and 'Random' specifiers may not be used in the structure format. However, explicitly setting a field of the structure to an element's nominal value, and then following (or preceding) the call to usubs with a call to usample (to generate the random samples) is acceptable, and achieves the same effect.\nArray Management for Uncertain Objects\n\nAll of the uncertain system classes (uss, ufrd) may be multidimensional arrays. This is intended to provide the same functionality as the LTI-arrays of the Control System Toolbox software. The command `size` returns a row vector with the sizes of all dimensions.\n\nThe first two dimensions correspond to the outputs and inputs of the system. Any dimensions beyond are referred to as the *array dimensions*. Hence, if `szM = size(M)`, then `szM(3:end)` are sizes of the array dimensions of `M`.\n\nFor these types of objects, it is clear that the first two dimensions (system output and input) are interpreted differently from the 3rd, 4th, 5th and higher dimensions (which often model parametrized variability in the system input/output behavior).\n\n`umat` objects are treated in the same manner. The first two dimensions are the rows and columns of the uncertain matrix. Any dimensions beyond are the *array dimensions*. \nReference Into Arrays\n\nSuppose $M$ is a umat, uss or ufrd, and that $Yidx$ and $Uidx$ are vectors of integers. Then\n\n$$M(Yidx,Uidx)$$\n\nselects the outputs (rows) referred to by $Yidx$ and the inputs (columns) referred to by $Uidx$, preserving all of the array dimensions. For example, if $\\text{size}(M)$ equals $[4 \\ 5 \\ 3 \\ 6 \\ 7]$, then (for example) the size of $M([4 \\ 2],[1 \\ 2 \\ 4])$ is $[2 \\ 3 \\ 6 \\ 7]$. If $\\text{size}(M,1)==1$ or $\\text{size}(M,2)==1$, then single indexing on the inputs or outputs (rows or columns) is allowed. If $Sidx$ is a vector of integers, then $M(Sidx)$ selects the corresponding elements. All array dimensions are preserved.\n\nIf there are $K$ array dimensions, and $idx1$, $idx2$, ..., $idxK$ are vectors of integers, then\n\n$$G = M(Yidx,Uidx,idx1,idx2,...,idxK)$$\n\nselects the outputs and inputs referred to by $Yidx$ and $Uidx$, respectively, and selects from each array dimension the “slices” referred to by the $idx1$, $idx2$, ..., $idxK$ index vectors. Consequently, $\\text{size}(G,1)$ equals $\\text{length}(Yidx)$, $\\text{size}(G,2)$ equals $\\text{length}(Uidx)$, $\\text{size}(G,3)$ equals $\\text{length}(idx1)$, $\\text{size}(G,4)$ equals $\\text{length}(idx2)$, and $\\text{size}(G,K+2)$ equals $\\text{length}(idxK)$. If $M$ has $K$ array dimensions, and less than $K$ index vectors are used in doing the array referencing, then the MATLAB convention for single indexing is followed. For instance, suppose $\\text{size}(M)$ equals $[3 \\ 4 \\ 6 \\ 5 \\ 7 \\ 4]$. The expression\n\n$$G = M([1 \\ 3],[1 \\ 4],[2 \\ 3 \\ 4],[5 \\ 3 \\ 1],[8 \\ 10 \\ 12 \\ 2 \\ 4 \\ 20 \\ 18])$$\n\nis valid. The result has $\\text{size}(G)$ equals $[2 \\ 2 \\ 3 \\ 3 \\ 7]$. The last index vector $[8 \\ 10 \\ 12 \\ 2 \\ 4 \\ 20 \\ 18]$ is used to reference into the 7-by-4 array, preserving the order dictated by MATLAB single indexing (e.g., the 10th element of a 7-by-4 array is the element in the $(3,2)$ position in the array).\n\nNote that if $M$ has either one output (row) or one input (column), and $M$ has array dimensions, then it is not allowable to combine single indexing in the output/input dimensions along with indexing in the array dimensions. This will result in an ambiguity in how to interpret the second index vector in the expression (i.e., “does it correspond to the input/output reference, or does it correspond to the first array dimension?”).\nCreate Arrays with stack and cat Functions\n\nAn easy manner to create an array is with \\texttt{stack}. Create a \\([4\\text{-by-1}]\\) \\texttt{umat} array by stacking four \\(1\\text{-by-3}\\) \\texttt{umat} objects with the \\texttt{stack} command. The first argument of \\texttt{stack} specifies in which array dimension the stacking occurs. In the example below, the stacking is done in the 1st array dimension, hence the result is a \\(1\\text{-by-3}\\text{-by-4}\\text{-by-1}\\) \\texttt{umat}, referred to as a \\(4\\text{-by-1}\\) \\texttt{umat} array.\n\n\\begin{verbatim}\na = ureal('a',4);\nb = ureal('b',2);\nM = stack(1,[a b 1],[-a -b 4+a],[4 5 6],[a 0 0])\n\\end{verbatim}\n\n\\texttt{UMAT: 1 Rows, 3 Columns [array, 4 x 1]}\n\\begin{itemize}\n \\item \\texttt{a}: real, nominal = 4, variability = \\([-1 \\quad 1]\\), 1 occurrence\n \\item \\texttt{b}: real, nominal = 2, variability = \\([-1 \\quad 1]\\), 1 occurrence\n\\end{itemize}\n\n\\begin{verbatim}\nsize(M)\n\\end{verbatim}\n\\begin{verbatim}\nans =\n 1 3 4\n\\end{verbatim}\n\n\\begin{verbatim}\narraysize(M)\n\\end{verbatim}\n\\begin{verbatim}\nans =\n 4 1\n\\end{verbatim}\n\nCheck that result is valid. Use referencing to access parts of the \\([4\\text{-by-1}]\\) \\texttt{umat} array and compare to the expected values. The first 4 examples should all be arrays full of 0 (zeros). The last two should be the value 5, and the uncertain real parameter \\texttt{a}, respectively.\n\n\\begin{verbatim}\nsimplify(M(:,:,1) - [a b 1])\n\\end{verbatim}\n\\begin{verbatim}\nsimplify(M(:,:,2) - [-a -b 4+a])\n\\end{verbatim}\n\\begin{verbatim}\nsimplify(M(:,:,3) - [4 5 6])\n\\end{verbatim}\n\\begin{verbatim}\nsimplify(M(:,:,4) - [a 0 0])\n\\end{verbatim}\n\\begin{verbatim}\nsimplify(M(1,2,3)) \\% should be 5\n\\end{verbatim}\n\\begin{verbatim}\nsimplify(M(1,3,2)-4)\n\\end{verbatim}\n\n\\texttt{Uncertain Real Parameter: Name a, NominalValue 4, variability = \\([-1 \\quad 1]\\]}\nYou can create a random 1-by-3-by-4 double matrix and stack this with \\( M \\) along the second array dimension, creating a 1-by-3-by-4-by-2 \\texttt{umat}.\n\n\\[\nN = \\text{randn}(1,3,4);\nM2 = \\text{stack}(2,M,N);\n\\]\n\n\\[\n\\text{size}(M2)\n\\]\n\n\\[\n\\begin{array}{cccc}\n1 & 3 & 4 & 2 \\\\\n\\end{array}\n\\]\n\n\\[\n\\text{arraysize}(M2)\n\\]\n\n\\[\n\\begin{array}{cc}\n4 & 2 \\\\\n\\end{array}\n\\]\n\nAs expected, both \\( M \\) and \\( N \\) can be recovered from \\( M2 \\).\n\n\\[\nd1 = \\text{simplify}(M2(:,:,1)-M);\nd2 = \\text{simplify}(M2(:,:,2)-N);\n\\]\n\n\\[\n\\left[ \\text{max(abs(d1(:))) max(abs(d2(:)))} \\right]\n\\]\n\n\\[\n\\begin{array}{c}\n0 \\\\\n0 \\\\\n\\end{array}\n\\]\n\nIt is also possible to stack \\( M \\) and \\( N \\) along the 1st array dimension, creating a 1-by-3-by-8-by-1 \\texttt{umat}.\n\n\\[\nM3 = \\text{stack}(1,M,N);\n\\]\n\n\\[\n\\text{size}(M3)\n\\]\n\n\\[\n\\begin{array}{ccc}\n1 & 3 & 8 \\\\\n\\end{array}\n\\]\n\n\\[\n\\text{arraysize}(M3)\n\\]\n\n\\[\n\\begin{array}{cc}\n8 & 1 \\\\\n\\end{array}\n\\]\n\nAs expected, both \\( M \\) and \\( N \\) can be recovered from \\( M3 \\).\n\n\\[\nd3 = \\text{simplify}(M3(:,:,1:4)-M);\nd4 = \\text{simplify}(M3(:,:,5:8)-N);\n\\]\n\n\\[\n\\left[ \\text{max(abs(d3(:))) max(abs(d4(:)))} \\right]\n\\]\n\n\\[\n\\begin{array}{c}\n0 \\\\\n0 \\\\\n\\end{array}\n\\]\nCreate Arrays by Assignment\n\nArrays can be created by direct assignment. As with other MATLAB classes, there is no need to preallocate the variable first. Simply assign elements – all resizing is performed automatically.\n\nFor instance, an equivalent construction to\n\n```matlab\na = ureal('a',4);\nb = ureal('b',2);\nM = stack(1,[a b 1],[-a -b 4+a],[4 5 6],[a 0 0]);\nis\nMequiv(1,1,1) = a;\nMequiv(1,2,1) = b;\nMequiv(1,3,1) = 1;\nMequiv(1,:,4) = [a 0 0];\nMequiv(1,:,2:3) = stack(1,[-a -b 4+a],[4 5 6]);\n```\n\nThe easiest manner for you to verify that the results are the same is to subtract and simplify,\n\n```matlab\nd5 = simplify(M-Mequiv);\nmax(abs(d5(:)))\nans =\n0\n```\nBinary Operations with Arrays\n\nMost operations simply cycle through the array dimensions, doing pointwise operations. Assume \\( A \\) and \\( B \\) are umat (or uss, or ufrd) arrays with identical array dimensions (slot 3 and beyond). The operation \\( C = \\text{fcn}(A, B) \\) is equivalent to looping on \\( k1, k2, \\ldots \\), setting\n\n\\[\nC(:,:,k1,k2,\\ldots) = \\text{fcn}(A(:,:,k1,k2,\\ldots), B(:,:,k1,k2,\\ldots))\n\\]\n\nThe result \\( C \\) has the same array dimensions as \\( A \\) and \\( B \\). The user is required to manage the extra dimensions (i.e., keep track of what they mean). Methods such as permute, squeeze and reshape are included to facilitate this management.\n\nIn general, any binary operation requires that the extra-dimensions are compatible. The umat, uss and ufrd objects allow for slightly more flexible interpretation of this. For illustrative purposes, consider a binary operation involving variables \\( A \\) and \\( B \\). Suppose the array dimensions of \\( A \\) are \\( n_1 \\times \\ldots \\times n_{l_A} \\) and that the array dimensions of \\( B \\) are \\( m_1 \\times \\ldots \\times m_{l_B} \\). By MATLAB convention, the infinite number of singleton (i.e., 1) trailing dimensions are not listed. The compatibility of the extra dimensions is determined by the following rule: If \\( l_A = l_B \\), then pad the shorter dimension list with trailing 1's. Now compare the extra dimensions: In the \\( k \\)-th dimension, it must be that one of 3 conditions hold: \\( n_k = m_k \\), or \\( n_k = 1 \\), or \\( m_k = 1 \\). In other words, non-singleton dimensions must exactly match (so that the pointwise operation can be executed), and singleton dimensions match with anything, implicitly through a repmat.\nCreate Arrays with usample\n\nAn extremely common manner in which to generate an array is to sample (in some of the uncertain elements) an uncertain object. Using the ureal objects a and b from above, create a 2-by-3 umat.\n\n\\[\nM = \\begin{bmatrix}\na & b \\\\\nb & a/b \\\\\n1-b & 1+a*b\n\\end{bmatrix}\n\\]\n\nUMAT: 3 Rows, 2 Columns\n a: real, nominal = 4, variability = [-1 1], 3 occurrences\n b: real, nominal = 2, variability = [-1 1], 6 occurrences\n\n\\[\n\\text{size}(M)\n\\]\n\\[\n\\text{ans} =\n\\begin{bmatrix}\n3 & 2\n\\end{bmatrix}\n\\]\n\nSample (at 20 random points within its range) the uncertain real parameter b in the matrix M. This results in a 3-by-2-by-20 umat, with only one uncertain element, a. The uncertain element b of M has been “sampled out”, leaving a new array dimension in its place.\n\n\\[\n[M_s, \\text{bvalues}] = \\text{usample}(M, 'b', 20);\n\\]\n\n\\[M_s\\]\nUMAT: 3 Rows, 2 Columns [array, 20 x 1]\n a: real, nominal = 4, variability = [-1 1], 2 occurrences\n\n\\[\n\\text{size}(M_s)\n\\]\n\\[\n\\text{ans} =\n\\begin{bmatrix}\n3 & 2 & 20\n\\end{bmatrix}\n\\]\n\nContinue sampling (at 15 random points within its range) the uncertain real parameter a in the matrix Ms. This results in a 3-by-2-by-20-by-15 double.\n\n\\[\n[M_{ss}, \\text{avvalues}] = \\text{usample}(M_s, 'a', 15);\n\\]\n\n\\[M_{ss}\\]\nsize(M_{ss})\n\\[\n\\text{ans} =\n\\begin{bmatrix}\n3 & 2 & 20 & 15\n\\end{bmatrix}\n\\]\n\n\\[\n\\text{class}(M_{ss})\n\\]\n\\[\n\\text{ans} =\n\\text{double}\n\\]\n\nThe above 2-step sequence can be performed in 1 step.\n\n\\[\n[M_{ss}, \\text{values}] = \\text{usample}(M, 'b', 20, 'a', 15);\n\\]\n\n\\[M_{ss}\\]\n\\[\n\\text{class}(M_{ss})\n\\]\n\\[\n\\text{ans} =\n\\text{double}\n\\]\nIn this case, `values` is a 20-by-15 struct array, with 2 fields `b` and `a`, whose values are the values used in the random sampling. It follows that `usubs(M,values)` is the same as `Mss`.\n\nRather than sampling the each variable (`a` and `b`) independently, generating a 20-by-15 grid in a 2-dimensional space, the two-dimensional space can be sampled. Sample the 2-dimensional space with 800 points,\n\n```matlab\n[M,values] = usample(M,{'a' 'b'},800);\nsize(M)\nans =\n 3 2 800\nsize(values)\nans =\n 800 1\n```\nCreate Arrays with usubs\n\nSuppose Values is a struct array, with the following properties: the dimensions of Value match the array dimensions of M, as described in “Create Arrays with usample” on page 1-66; the field names of Values are some (or all) of the names of the uncertain elements of M; and the dimensions of the contents of the fields within Values match the sizes of the uncertain elements within M. Then usubs(M,Values) will substitute the uncertain elements in M with the contents found in the respective fields of Values.\n\nYou can create a 3-by-2 uncertain matrix using two uncertain real parameters.\n\n\\[\n\\begin{align*}\na &= \\text{ureal}'a',4; \\\\\nb &= \\text{ureal}'b',2; \\\\\nM &= [a\\ b; b^2 a/b; 1-b 1+a*b];\n\\end{align*}\n\\]\n\nCreate a 5-by-1 struct array with field name a. Make its values random scalars. Create a 1-by-4 struct array with field name b.\n\n\\[\n\\begin{align*}\n&\\text{Avalue} = \\text{struct}'a',\\text{num2cell}.rand(5,1)); \\\\\n&\\text{Bvalue} = \\text{struct}'b',\\text{num2cell}.rand(1,4));\n\\end{align*}\n\\]\n\nSubstitute the uncertain real parameter a in M with the values in Avalue, yielding ma. Similarly substitute the uncertain real parameter b in M with the values in Avalue, yielding mb.\n\n\\[\n\\begin{align*}\n&\\text{ma} = \\text{usubs}(M,Avalue) \\\\\n&\\text{UMAT: 3 Rows, 2 Columns [array, 5 x 1]} \\\\\n&\\quad \\text{b: real, nominal = 2, variability = [1 1], 6 occurrences} \\\\\n&\\text{mb} = \\text{usubs}(M,Bvalue) \\\\\n&\\text{UMAT: 3 Rows, 2 Columns [array, 1 x 4]} \\\\\n&\\quad \\text{a: real, nominal = 4, variability = [1 1], 2 occurrences}\n\\end{align*}\n\\]\n\nContinue, substituting the uncertain real parameter b in ma with the values in Bvalue, yielding mab. Do the analogous operation for mb, yielding mba. Subtract, and note that the difference is 0, as expected.\n\n\\[\n\\begin{align*}\n&\\text{mab} = \\text{usubs}(ma,Bvalue); \\\\\n&\\text{mba} = \\text{usubs}(mb,Avalue); \\\\\n&\\text{thediff} = \\text{mab-mba}; \\\\\n&\\text{max(abs(thediff(:)))} \\\\\n&\\text{ans =} \\\\\n&\\quad 4.4409e-016\n\\end{align*}\n\\]\nCreate Arrays with gridureal\n\nThe command gridureal enables uniform sampling of specified uncertain real parameters within an uncertain object. It is a specialized case of usubs.\n\ngridureal removes a specified uncertain real parameter and adds an array dimension (to the end of the existing array dimensions). The new array dimension represents the uniform samples of the uncertain object in the specified uncertain real parameter range.\n\nCreate a 2-by-2 uncertain matrix with three uncertain real parameters.\n\n\\[\na = \\text{ureal}('a',3, 'Range', [2.5 \\ 4]); \\\\\nb = \\text{ureal}('b',4, 'Percentage', 15); \\\\\nc = \\text{ureal}('c',-2, 'Plusminus', [-1 \\ .3]); \\\\\nM = [a \\ b; b \\ c] \\\\\n\\]\n\nUMAT: 2 Rows, 2 Columns\n- a: real, nominal = 3, range = [2.5 4], 1 occurrence\n- b: real, nominal = 4, variability = [-15 15]%, 2 occurrences\n- c: real, nominal = -2, variability = [-1 0.3], 1 occurrence\n\nGrid the uncertain real parameter \\(b\\) in \\(M\\) with 100 points. The result is a umat array, with dependence on uncertain real parameters \\(a\\) and \\(c\\).\n\n\\[\nM_{\\text{grid1}} = \\text{gridureal}(M, 'b', 100) \\\\\n\\]\n\nUMAT: 2 Rows, 2 Columns [array, 100 x 1]\n- a: real, nominal = 3, range = [2.5 4], 1 occurrence\n- c: real, nominal = -2, variability = [-1 0.3], 1 occurrence\n\nOperating on the uncertain matrix \\(M\\), grid the uncertain real parameter \\(a\\) with 20 points, the uncertain real parameter \\(b\\) with 12 points, and the uncertain real parameter \\(c\\) with 7 points. The result is a 2-by-2-by20-by-12-by7 double array.\n\n\\[\nM_{\\text{grid3}} = \\text{gridureal}(M, 'a', 20, 'b', 12, 'c', 7); \\\\\n\\text{size(Mgrid3)} \\\\\n\\]\n\n\\[\n\\text{ans} = \\\\\n2 \\quad 2 \\quad 20 \\quad 12 \\quad 7\n\\]\nCreate Arrays with repmat\n\nThe MATLAB command `repmat` is used to replicate and tile arrays. It works on the built-in objects of MATLAB, namely `double`, `char`, as well as the generalized container objects `cell` and `struct`. The identical functionality is provided for replicating and tiling uncertain elements (`ureal`, `ultidyn`, etc.) and `umat` objects.\n\nYou can create an uncertain real parameter, and replicate it in a 2-by-3 uncertain matrix. Compare to generating the same uncertain matrix through multiplication.\n\n```matlab\na = ureal('a',5);\nAmat = repmat(a,[2 3])\nUMAT: 2 Rows, 3 Columns\n a: real, nominal = 5, variability = [-1 1], 1 occurrence\nAmat2 = a*ones(2,3);\nsimplify(Amat-Amat2)\nan =\n 0 0 0\n 0 0 0\n```\n\nCreate a [4-by-1] `umat` array by stacking four 1-by-3 `umat` objects with the `stack` command. Use `repmat` to tile this 1-by-3-by-4-by-1 `umat`, into a 2-by-3-by-8-by-5 `umat`.\n\n```matlab\na = ureal('a',4);\nb = ureal('b',2);\nM = stack(1,[a b 1],[-a -b 4+a],[4 5 6],[a 0 0]);\nsize(M)\nan =\n 1 3 4\nMtiled = repmat(M,[2 1 2 5])\nUMAT: 2 Rows, 3 Columns [array, 8 x 5]\n a: real, nominal = 4, variability = [-1 1], 1 occurrence\n b: real, nominal = 2, variability = [-1 1], 1 occurrence\nVerify the equality of M and a few certain tiles of Mtiled.\nd1 = simplify(M-Mtiled(2,:,5:8,3));\nd2 = simplify(M-Mtiled(1,:,1:4,2));\nd3 = simplify(M-Mtiled(2,:,1:4,5));\n[max(abs(d1(:))) max(abs(d2(:))) max(abs(d3(:)))]\nan =\n 0 0 0\n```\n\nNote that `repmat` never increases the complexity of the representation of an uncertain object. The number of occurrences of each uncertain element remains the same, regardless of the extent of the replication and tiling.\nCreate Arrays with repsys\n\nReplicating and tiling uncertain state-space systems (uss, and uncertain frequency response data (ufrd) is done with repsys. The syntax and behavior are the same as the manner in which repmat is used to replicate and tile matrices. The syntax and behavior of repsys for uss and ufrd objects are the same as the traditional repsys which operates on ss and frd objects. Just as in those cases, the uncertain version of repsys also allows for diagonal tiling.\nUsing permute and ipermute\n\nThe commands permute and ipermute are generalizations of transpose, which exchanges the rows and columns of a two-dimensional matrix.\n\npermute(A,ORDER) rearranges the dimensions of A so that they are in the order specified by the vector ORDER. The array produced has the same values of A but the order of the subscripts needed to access any particular element are rearranged as specified by ORDER. The elements of ORDER must be a rearrangement of the numbers from 1 to N.\n\nAll of the uncertain objects are essentially 2-dimensional (output and input) operators with array dependence. This means that the first 2 dimensions are treated differently from dimensions 3 and beyond. It is not permissible to permute across these groups.\n\nFor uss and ufrd, the restriction is built into the syntax. The elements of the ORDER vector only refer to array dimensions. Therefore, there is no possibility of permute across these dimensions. In you need to permute the first two dimensions, use the command transpose instead.\n\nFor umat, the restriction is enforced in the software. The elements of the ORDER vector refer to all dimensions. However, the first two elements of ORDER must be a rearrangement of the numbers 1 and 2. The remaining elements of ORDER must be a rearrangement of the numbers 3 through N. If either of those conditions fail, an error is generated. Hence, for umat arrays, either permute or transpose can be used to effect the transpose operation.\nDecomposing Uncertain Objects\n\nEach uncertain object (umat, uss, ufrd) is a generalized feedback connection (lft) of a not-uncertain object (e.g., double, ss, frd) with a diagonal augmentation of uncertain elements (ureal, ultidyn, ucomplex, ucomplexm, udyn). In robust control jargon, if the uncertain elements are normalized, this decomposition is often called “the M/D form.”\n\nThe purpose of the uncertain objects (ureal, ultidyn, umat, uss, etc.) is to hide this underlying decomposition, and allow the user to focus on modeling and analyzing uncertain systems, rather than the details of correctly propagating the M/D representation in manipulations. Nevertheless, advanced users may want access to the familiar M/D form. The command lftdata accomplishes this decomposition.\n\nSince ureal, ucomplex and ucomplexm do not have their NominalValue necessarily at zero, and in the case of ureal objects, are not symmetric about the NominalValue, some details are required in describing the decomposition.\n\nNormalizing Functions for Uncertain Elements\n\nAssociated with each uncertain element is a normalizing function. The normalizing function maps the uncertain element into a normalized uncertain element.\n\nIf $\\rho$ is an uncertain real parameter, with range $[L \\ R]$ and nominal value $N$, then the normalizing function $F$ is\n\n$$F(\\rho) = \\frac{A + B\\rho}{C + D\\rho}$$\n\nwith the property that for all $\\rho$ satisfying $L \\leq \\rho \\leq R$, it follows that $-1 \\leq F(\\rho) \\leq 1$, moreover, $F(L) = -1$, $F(N) = 0$, and $F(R) = 1$. If the nominal value is centered in the range, then it is easy to conclude that\n\n$$A = \\frac{R + L}{R - L}$$\n$$B = \\frac{2}{R - L}$$\n$$C = 1$$\n$$D = 0.$$\nIt is left as an algebra exercise for the user to work out the various values for A, B, C and D when the nominal value is not centered.\n\nIf $E$ is an uncertain gain-bounded, linear, time-invariant dynamic uncertainty, with gain-bound $\\beta$, then the normalizing function $F$ is\n\n$$F(E) = \\frac{1}{\\beta} E.$$ \n\nIf $E$ is an uncertain positive-real, linear, time-invariant dynamic uncertainty, with positivity bound $\\beta$, then the normalizing function $F$ is\n\n$$F(E) = \\left[I - \\alpha \\left( E - \\frac{\\beta}{2} I \\right) \\right] \\left[I + \\alpha \\left( E - \\frac{\\beta}{2} I \\right) \\right]^{-1}$$\n\nwhere $a = 2|\\beta| + 1$.\n\nThe normalizing function for an uncertain complex parameter $\\xi$, with nominal value $C$ and radius $\\gamma$, is\n\n$$F(\\xi) = \\frac{1}{\\gamma}(\\xi - C).$$\n\nThe normalizing function for uncertain complex matrices $H$, with nominal value $N$ and weights $W_L$ and $W_R$ is\n\n$$F(H) = W_L^{-1}(H - N)W_R^{-1}$$\n\nIn each case, as the uncertain element varies over its range, the absolute value of the normalizing function (or norm, in the matrix case) varies from 0 and 1.\n\n**Properties of the Decomposition**\n\nTake an uncertain object $A$, dependent on uncertain real parameters $\\rho_1,...,\\rho_N$, uncertain complex parameters $\\xi_1,...,\\xi_K$, uncertain complex matrices $H_1,...,H_B$, uncertain gain-bounded linear, time-invariant dynamics $E_1,...,E_D$, and uncertain positive-real linear, time-invariant dynamics $P_1,...,P_Q$. \nWrite $A(\\rho, \\xi, H, E, P)$ to indicate this dependence. Using `lftdata`, $A$ can be decomposed into two separate pieces: $M$ and $\\Delta(\\rho, \\xi, H, E, P)$ with the following properties:\n\n- $M$ is certain (i.e., if $A$ is `uss`, then $M$ is `ss`; if $A$ is `umat`, then $M$ is `double`; if $A$ is `ufrd`, then $M$ is `frd`).\n- $\\Delta$ is always a `umat`, depending on the same uncertain elements as $A$, with ranges, bounds, weights, etc., unaltered.\n- The form of $\\Delta$ is block diagonal, with elements made up of the normalizing functions acting on the individual uncertain elements:\n\n$$\n\\Delta(\\rho, \\xi, H, E, P) = \n\\begin{bmatrix}\nF(\\rho) & 0 & 0 & 0 & 0 \\\\\n0 & F(\\xi) & 0 & 0 & 0 \\\\\n0 & 0 & F(H) & 0 & 0 \\\\\n0 & 0 & 0 & F(E) & 0 \\\\\n0 & 0 & 0 & 0 & F(P)\n\\end{bmatrix}.\n$$\n\n- $A(\\rho, \\xi, H, E, P)$ is given by a linear fractional transformation of $M$ and $\\Delta(\\rho, \\xi, H, E, P)$,\n\n$$\nA(\\rho, \\xi) = M_{22} + M_{21} \\Delta(\\rho, \\xi, H, E, P) \\left[ I - M_{11} \\Delta(\\rho, \\xi, H, E, P) \\right]^{-1} M_{12}.\n$$\n\nThe order of the normalized elements making up $A$ is not the simple order shown above. It is actually the same order as given by the command `fieldnames(M.Uncertainty)`. See “Advanced Syntax of `lftdata`” on page 1-77 for more information.\n\n**Syntax of `lftdata`**\n\nThe decomposition is carried out by the command `lftdata`.\n\nYou can create a 2-by-2 `umat` named $A$ using three uncertain real parameters.\n\n```matlab\ndelta = ureal('delta',2);\ndelta = ureal('eta',6);\nrho = ureal('rho',-1);\nA = [3+delta+eta delta/eta;7+rho rho+delta*eta]\n```\n\n**UMAT: 2 Rows, 2 Columns**\n\n- $\\text{delta: real, nominal = 2, variability = [-1 1], 2 occurrences}$\n- $\\text{eta: real, nominal = 6, variability = [-1 1], 3 occurrences}$\n- $\\text{rho: real, nominal = -1, variability = [-1 1], 1 occurrence}$\nNote that $A$ depends on two occurrences of $\\delta$, three occurrences of $\\eta$ and one occurrence of $\\rho$.\n\nDecompose $A$ into $M$ and $\\Delta$. Note that $A$ is a double, and $\\Delta$ has the same uncertainty dependence as $M$.\n\n$$ [M, \\Delta] = \\text{lftdata}(A); $$\n\n```\nclass(M)\nans =\ndouble\n```\n\nDelta\nUMAT: 6 Rows, 6 Columns\n $\\delta$: real, nominal = 2, variability = [-1 1], 2 occurrences\n $\\eta$: real, nominal = 6, variability = [-1 1], 3 occurrences\n $\\rho$: real, nominal = -1, variability = [-1 1], 1 occurrence\n\nSample $\\Delta$ at 5 points. Things to note are:\n\n- It is diagonal.\n- The values range between -1 and 1.\n- There are three independent values, and duplication of the entries is consistent with the dependence of $\\Delta$ and $A$ on the three uncertain real parameters.\n\n```\nusample(\\Delta, 5)\nans(:, :, 1) =\n -0.7106 0 0 0 0 0\n 0 -0.7106 0 0 0 0\n 0 0 0.6374 0 0 0\n 0 0 0 0.6374 0 0\n 0 0 0 0 0.6374 0\n 0 0 0 0 0 -0.1258\nans(:, :, 2) =\n -0.5850 0 0 0 0 0\n 0 -0.5850 0 0 0 0\n 0 0 -0.3021 0 0 0\n 0 0 0 -0.3021 0 0\n 0 0 0 0 -0.3021 0\n 0 0 0 0 0 0.0803\nans(:, :, 3) =\n 0.7013 0 0 0 0 0\n 0 0.7013 0 0 0 0\n 0 0 -0.6749 0 0 0\n 0 0 0 -0.6749 0 0\n 0 0 0 0 -0.6749 0\n 0 0 0 0 0 0\n```\nDecomposing Uncertain Objects\n\n\\[\n\\begin{bmatrix}\n0 & 0 & 0 & 0 & -0.6749 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 0.3967 \\\\\n\\end{bmatrix}\n\\]\n\n\\[\n\\text{ans(:,4)} = \\\\\n\\begin{bmatrix}\n0.4262 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & 0.4262 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 0.0795 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0.0795 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0.0795 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & -0.9959 \\\\\n\\end{bmatrix}\n\\]\n\n\\[\n\\text{ans(:,5)} = \\\\\n\\begin{bmatrix}\n-0.8392 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & -0.8392 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 0.8467 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0.8467 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0.8467 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 0.6732 \\\\\n\\end{bmatrix}\n\\]\n\nIn fact, verify that the maximum gain of \\( \\Delta \\) is indeed 1\n\n\\[\n\\text{maxnorm} = \\text{wcnorm}(\\Delta)\n\\]\n\\[\n\\text{maxnorm} = \\\\\n\\begin{bmatrix}\n\\text{LowerBound}: 1.0000 \\\\\n\\text{UpperBound}: 1.0004 \\\\\n\\end{bmatrix}\n\\]\n\nFinally, verify that \\( \\text{lft}(\\Delta, M) \\) is the same as \\( \\text{A Subtract} \\) (and use the 'full' option in \\( \\text{simplify} \\))\n\n\\[\n\\text{simplify(lft(\\Delta,M)-A,'full')}\n\\]\n\\[\n\\text{ans} = \\\\\n\\begin{bmatrix}\n0 & 0 \\\\\n0 & 0 \\\\\n\\end{bmatrix}\n\\]\n\nAdvanced Syntax of lftdata\n\nEven for the advanced user, the variable \\( \\Delta \\) will actually not be that useful, as it is still a complex object. On the other hand, its internal structure is described completely using a 3rd (and 4th) output argument.\n\n\\[\n\\text{[M,Delta,BlkStruct,NormUnc]} = \\text{lftdata}(A);\n\\]\n\nThe rows of \\( \\text{BlkStruct} \\) correspond to the uncertain elements named in \\( \\text{fieldnames(A.Uncertainty)} \\). Note that the range/bound information about each uncertain element is not included in \\( \\text{BlkStruct} \\).\nThe elements of \\texttt{BlkStruct} describe the size, type and number-of-copies of the uncertain elements in \\( A \\), and implicitly delineate the exact block-diagonal structure of \\( \\text{Delta} \\).\n\nNote that the range/bound information about each uncertain element is not included in \\texttt{BlkStruct}.\n\n\\begin{verbatim}\nBlkStruct(1)\nans =\n Name: 'delta'\n Size: [1 1]\n Type: 'ureal'\n Occurrences: 2\n\nBlkStruct(2)\nans =\n Name: 'eta'\n Size: [1 1]\n Type: 'ureal'\n Occurrences: 3\n\nBlkStruct(3)\nans =\n Name: 'rho'\n Size: [1 1]\n Type: 'ureal'\n Occurrences: 1\n\\end{verbatim}\n\nTogether, these mean \\( \\text{Delta} \\) is a block diagonal augmentation of the normalized version of 3 uncertain elements.\n\nThe first element is named \\texttt{'delta'}. It is 1-by-1; it is of class \\texttt{ureal}; and there are 2 copies diagonally augmented.\n\nThe second element is named \\texttt{'eta'}. It is 1-by-1; it is of class \\texttt{ureal}; and there are 3 copies diagonally augmented.\n\nThe third element is named \\texttt{'rho'}. It is 1-by-1; it is of class \\texttt{ureal}; and there is 1 copy.\n\nThe 4th output argument contains a cell array of normalized uncertain elements. The cell array contains as many occurrences of each element as there are occurrences in the original uncertain object \\( A \\).\n\n\\begin{verbatim}\nsize(NormUnc)\nans =\n 6 1\n\nNormUnc{1}\nUncertain Real Parameter: Name deltaNormalized, NominalValue 0,\n\\end{verbatim}\nvariability = [-1 1]\nisequal(NormUnc{2},NormUnc{1})\nans =\n 1\nNormUnc{3}\nUncertain Real Parameter: Name etaNormalized, NominalValue 0,\nvariability = [-1 1]\nisequal(NormUnc{4},NormUnc{3})\nans =\n 1\nisequal(NormUnc{5},NormUnc{3})\nans =\n 1\nNormUnc{6}\nUncertain Real Parameter: Name rhoNormalized, NominalValue 0,\nvariability = [-1 1]\n\nEach normalized element has the string 'Normalized' appended to its original name to avoid confusion. By normalized,\n\n- **ureal** objects have nominal value of 0, and range from -1 to 1.\n- **ultidyn** objects are norm bounded, with norm bound of 1.\n- **ucomplex** objects have nominal value of 0, and radius 1.\n- **ucomplexm** objects have nominal value of 0, and identity matrices for each of the WL and WR weights.\n\nThe possible behaviors of **Delta** and **blkdiag(NormUnc{:})** are the same. Consequently, the possible behaviors of **A** and **lft(blkdiag(NormUnc{:}),M)** are the same.\n\nHence, by manipulating **M**, **BlkStruct** and **NormUnc**, a power-user has direct access to all of the linear fractional transformation details, and can easily work at the level of the theorems and algorithms that underlie the methods.\nGeneralized Robustness Analysis\n\n• “Generalized Robustness Analysis” on page 2-2\n• “Robust Stability Margin” on page 2-4\n• “Robust Performance Margin” on page 2-5\n• “Worst-Case Gain Measure” on page 2-6\nGeneralized Robustness Analysis\n\nThe performance of a nominally stable uncertain system model will generally degrade for specific values of its uncertain elements. Moreover, the maximum possible degradation increases as the uncertain elements are allowed to further and further deviate from their nominal values.\n\nThe graph below shows the typical tradeoff curve between allowable deviation of uncertain elements from their nominal values and the worst-case degradation in system performance. Here, system performance is characterized by system gain (e.g., peak magnitude on Bode plot). Interpreting the system as the relationship mapping disturbances/commands to errors, small system gains are desirable, and large gains are undesirable.\n\nWhen all uncertain elements are set to their nominal values (i.e., zero deviation from their nominal values) the input/output gain of the system is its nominal value. In the figure, the nominal system gain is about 0.8. As the uncertainties are allowed to deviate from nominal, the maximum (over the uncertain elements) system gain increases. The\nheavy blue line represents the maximum system gain due to uncertainty of various sizes (the horizontal axis) and is called the system performance degradation curve. It is monotonically increasing.\n\nDetermining specific attributes of the system performance degradation curve are referred to as robustness computations.\n\nGenerally, “robustness computations” refer to determining specific attributes of the system performance degradation curve. The commands robuststab, robustperf and wcgain all compute single scalar attributes of the system performance degradation curve.\n\nRedraw the system performance degradation curve with 3 additional curves: a hyperbola defined by $xy=1$; a vertical line drawn at the uncertainty bound $= 1$; and a vertical line tangent to the asymptotic behavior of the performance degradation curve at large uncertainty bounds. These are used to define three robustness measures, explained next.\nRobust Stability Margin\n\nThe robust stability margin, StabMarg, is the size of the smallest deviation from nominal of the uncertain elements that leads to system instability.\n\nSystem instability is equivalent to the system gain becoming arbitrarily large, and hence characterized by the vertical line tangent to the asymptotic behavior of the performance degradation curve.\nRobust Performance Margin\n\nThe hyperbola is used to define the performance margin. Systems whose performance degradation curve intersects high on the hyperbola curve represent “non-robustly performing systems” in that very small deviations of the uncertain elements from their nominal values can result in very large system gains. Conversely, an intersection low on the hyperbola represent “robustly performing systems.”\n\nThe point where the system performance degradation curve crosses the green line is used as a scalar measure of the robustness of a system to uncertainty. The horizontal coordinate of the crossing point is the robust performance margin, PerfMarg.\nWorst-Case Gain Measure\n\nThe worst-case gain measure is the maximum achievable system gain over all uncertain elements whose normalized size is bounded by 1.\n\nOn the graph, this is the vertical coordinate of the performance degradation curve as it crosses the vertical line drawn at the uncertainty bound = 1.\n\nEach measure captures a single scalar attribute of the system performance degradation curve. Mathematically, they are independent quantities, answering subtly different questions. Consequently, for two uncertain systems, sysA and sysB, it is possible that the StabMarg of sysA is larger than the StabMarg of sysB, though the PerfMarg of sysA is smaller than the PerfMarg of sysB. Nevertheless, they are useful metrics for concise description of the robustness of a system (uss or ufrd) due to various uncertain elements.\nIntroduction to Linear Matrix Inequalities\n\n• “Linear Matrix Inequalities” on page 3-2\n• “LMIs and LMI Problems” on page 3-4\n• “LMI Applications” on page 3-6\n• “Further Mathematical Background” on page 3-10\n• “Bibliography” on page 3-11\nLinear Matrix Inequalities\n\nLinear Matrix Inequalities (LMIs) and LMI techniques have emerged as powerful design tools in areas ranging from control engineering to system identification and structural design. Three factors make LMI techniques appealing:\n\n- A variety of design specifications and constraints can be expressed as LMIs.\n- Once formulated in terms of LMIs, a problem can be solved exactly by efficient convex optimization algorithms (see “LMI Solvers” on page 4-20).\n- While most problems with multiple constraints or objectives lack analytical solutions in terms of matrix equations, they often remain tractable in the LMI framework. This makes LMI-based design a valuable alternative to classical “analytical” methods.\n\nSee [9] for a good introduction to LMI concepts. Robust Control Toolbox™ software is designed as an easy and progressive gateway to the new and fast-growing field of LMIs:\n\n- For users who occasionally need to solve LMI problems, the LMI Editor and the tutorial introduction to LMI concepts and LMI solvers provide for quick and easy problem solving.\n- For more experienced LMI users, LMI Lab, offers a rich, flexible, and fully programmable environment to develop customized LMI-based tools.\n\nLMI Features\n\nRobust Control Toolbox LMI functionality serves two purposes:\n\n- Provide state-of-the-art tools for the LMI-based analysis and design of robust control systems\n- Offer a flexible and user-friendly environment to specify and solve general LMI problems (the LMI Lab)\n\nExamples of LMI-based analysis and design tools include\n\n- Functions to analyze the robust stability and performance of uncertain systems with varying parameters (popov, quadstab, quadperf ...)\n- Functions to design robust control with a mix of $H_2$, $H_\\infty$, and pole placement objectives (h2hinfsyn)\n- Functions for synthesizing robust gain-scheduled $H_\\infty$ controllers (hinfgs)\nFor users interested in developing their own applications, the LMI Lab provides a\ngeneral-purpose and fully programmable environment to specify and solve virtually any\nLMI problem. Note that the scope of this facility is by no means restricted to control-oriented applications.\n\n**Note** Robust Control Toolbox software implements state-of-the-art interior-point LMI solvers. While these solvers are significantly faster than classical convex optimization algorithms, you should keep in mind that the complexity of LMI computations can\ngrow quickly with the problem order (number of states). For example, the number of\noperations required to solve a Riccati equation is $o(n^3)$ where $n$ is the state dimension,\nwhile the cost of solving an equivalent “Riccati inequality” LMI is $o(n^5)$. \nLMIs and LMI Problems\n\nA linear matrix inequality (LMI) is any constraint of the form\n\n\\[ A(x) := A_0 + x_1 A_1 + \\ldots + x_N A_N < 0 \\]\n\nwhere\n\n- \\( x = (x_1, \\ldots, x_N) \\) is a vector of unknown scalars (the decision or optimization variables)\n- \\( A_0, \\ldots, A_N \\) are given symmetric matrices\n- \\( < 0 \\) stands for “negative definite,” i.e., the largest eigenvalue of \\( A(x) \\) is negative\n\nNote that the constraints \\( A(x) > 0 \\) and \\( A(x) < B(x) \\) are special cases of Equation 3-1 since they can be rewritten as \\(-A(x) < 0\\) and \\(A(x) - B(x) < 0\\), respectively.\n\nThe LMI of Equation 3-1 is a convex constraint on \\( x \\) since \\( A(y) < 0 \\) and \\( A(z) < 0 \\) imply that\n\n\\[ A\\left( \\frac{y+z}{2} \\right) < 0 \\]\n\nAs a result,\n\n- Its solution set, called the feasible set, is a convex subset of \\( \\mathbb{R}^N \\)\n- Finding a solution \\( x \\) to Equation 3-1, if any, is a convex optimization problem.\n\nConvexity has an important consequence: even though Equation 3-1 has no analytical solution in general, it can be solved numerically with guarantees of finding a solution when one exists. Note that a system of LMI constraints can be regarded as a single LMI since\n\n\\[\n\\begin{aligned}\nA_1(x) &< 0 \\\\\n\\vdots \\\\\nA_K(x) &< 0\n\\end{aligned}\n\\]\n\nis equivalent to\n\n\\[ A(x) := \\text{diag}(A_1(x), \\ldots, A_K(x)) < 0 \\]\n\nwhere \\( \\text{diag}(A_1(x), \\ldots, A_K(x)) \\) denotes the block-diagonal matrix with\n$A_1(\\alpha), \\ldots, A_K(\\alpha)$ on its diagonal. Hence multiple LMI constraints can be imposed on the vector of decision variables $x$ without destroying convexity.\n\nIn most control applications, LMIs do not naturally arise in the canonical form of Equation 3-1, but rather in the form\n\n$$L(X_1, \\ldots, X_n) < R(X_1, \\ldots, X_n)$$\n\nwhere $L(.)$ and $R(.)$ are affine functions of some structured matrix variables $X_1, \\ldots, X_n$. A simple example is the Lyapunov inequality\n\n$$A^T X + X A < 0$$\n\nwhere the unknown $X$ is a symmetric matrix. Defining $x_1, \\ldots, x_N$ as the independent scalar entries of $X$, this LMI could be rewritten in the form of Equation 3-1. Yet it is more convenient and efficient to describe it in its natural form Equation 3-2, which is the approach taken in the LMI Lab.\nLMI Applications\n\nFinding a solution $x$ to the LMI system\n\n$$A(x) < 0$$\n\nis called the *feasibility problem*. Minimizing a convex objective under LMI constraints is also a convex problem. In particular, the *linear objective minimization problem*:\n\nMinimize $c^T x$ subject to\n\n$$A(x) < 0$$\n\nplays an important role in LMI-based design. Finally, the *generalized eigenvalue minimization problem*:\n\nMinimize $\\lambda$ subject to\n\n$$A(x) < \\lambda B(x)$$\n\n$$B(x) > 0$$\n\n$$C(x) > 0$$\n\nis quasi-convex and can be solved by similar techniques. It owes its name to the fact that is related to the largest generalized eigenvalue of the pencil $(A(x), B(x))$.\n\nMany control problems and design specifications have LMI formulations [9]. This is especially true for Lyapunov-based analysis and design, but also for optimal LQG control, $H^\\infty$ control, covariance control, etc. Further applications of LMIIs arise in estimation, identification, optimal design, structural design [6], [7], matrix scaling problems, and so on. The main strength of LMI formulations is the ability to combine various design constraints or objectives in a numerically tractable manner.\n\nA nonexhaustive list of problems addressed by LMI techniques includes the following:\n\n- Robust stability of systems with LTI uncertainty ($\\mu$-analysis) ([24], [21], [27])\n- Robust stability in the face of sector-bounded nonlinearities (Popov criterion) ([22], [28], [13], [16])\n- Quadratic stability of differential inclusions ([15], [8])\n- Lyapunov stability of parameter-dependent systems ([12])\n• Input/state/output properties of LTI systems (invariant ellipsoids, decay rate, etc.) ([9])\n• Multi-model/multi-objective state feedback design ([4], [17], [3], [9], [10])\n• Robust pole placement\n• Optimal LQG control ([9])\n• Robust $H^\\infty$ control ([11], [14])\n• Multi-objective $H^\\infty$ synthesis ([18], [23], [10], [18])\n• Design of robust gain-scheduled controllers ([5], [2])\n• Control of stochastic systems ([9])\n• Weighted interpolation problems ([9])\n\nTo hint at the principles underlying LMI design, let’s review the LMI formulations of a few typical design objectives.\n\n**Stability**\n\nThe stability of the dynamic system\n\n$$\\dot{x} = Ax$$\n\nis equivalent to the feasibility of the following problem:\n\nFind $P = P^T$ such that $A^T P + PA < 0$, $P > I$.\n\nThis can be generalized to linear differential inclusions (LDI)\n\n$$\\dot{x} = A(t)x$$\n\nwhere $A(t)$ varies in the convex envelope of a set of LTI models:\n\n$$A(t) \\in \\text{Co}\\{A_1, \\ldots, A_n\\} = \\left\\{ \\sum_{i=1}^{n} a_i A_i : a_i \\geq 0, \\sum_{i=1}^{N} a_i = 1 \\right\\}.$$\n\nA sufficient condition for the asymptotic stability of this LDI is the feasibility of\n\nFind $P = P^T$ such that $A_i^T P + PA_i < 0$, $P > I$. \nRMS Gain\n\nThe random-mean-squares (RMS) gain of a stable LTI system\n\n\\[\n\\begin{aligned}\n\\dot{x} &= Ax + Bu \\\\\ny &= Cx + Du\n\\end{aligned}\n\\]\n\nis the largest input/output gain over all bounded inputs \\(u(t)\\). This gain is the global minimum of the following linear objective minimization problem [1], [25], [26].\n\nMinimize \\(\\gamma\\) over \\(X = X^T\\) and \\(\\gamma\\) such that\n\n\\[\n\\begin{pmatrix}\nA^T X + XA & XB & C^T \\\\\nB^T X & -\\gamma I & D^T \\\\\nC & D & -\\gamma I\n\\end{pmatrix} < 0\n\\]\n\nand\n\n\\(X > 0\\).\n\nLQG Performance\n\nFor a stable LTI system\n\n\\[\nG \\begin{cases}\n\\dot{x} = Ax + Bw \\\\\ny = Cx\n\\end{cases}\n\\]\n\nwhere \\(w\\) is a white noise disturbance with unit covariance, the LQG or \\(H_2\\) performance \\(\\|G\\|_2\\) is defined by\n\n\\[\n\\|G\\|_2^2 := \\lim_{T \\to \\infty} \\mathbb{E} \\left\\{ \\frac{1}{T} \\int_0^T y^T(t) y(t) dt \\right\\} = \\frac{1}{2\\pi} \\int_{-\\infty}^{\\infty} G^H(j\\omega)G(j\\omega) d\\omega.\n\\]\nIt can be shown that\n\n$$\\|G\\|_2^2 = \\inf \\left\\{ \\text{Trace} \\left( CPC^T \\right) : AP + PA^T + BB^T < 0 \\right\\}.$$ \n\nHence $\\|G\\|_2^2$ is the global minimum of the LMI problem. Minimize Trace ($Q$) over the symmetric matrices $P,Q$ such that\n\n$$AP + PA^T + BB^T < 0$$\n\nand\n\n$$\\begin{pmatrix} Q & CP \\\\ PC^T & P \\end{pmatrix} > 0.$$ \n\nAgain this is a linear objective minimization problem since the objective Trace ($Q$) is linear in the decision variables (free entries of $P,Q$).\nFurther Mathematical Background\n\nEfficient interior-point algorithms are now available to solve the three generic LMI problems Equation 3-2–Equation 3-4 defined in “LMI Applications” on page 3-6. These algorithms have a polynomial-time complexity. That is, the number $N(\\varepsilon)$ of flops needed to compute an $\\varepsilon$-accurate solution is bounded by\n\n$$M N^3 \\log(V/\\varepsilon)$$\n\nwhere $M$ is the total row size of the LMI system, $N$ is the total number of scalar decision variables, and $V$ is a data-dependent scaling factor. Robust Control Toolbox software implements the Projective Algorithm of Nesterov and Nemirovski [20], [19]. In addition to its polynomial-time complexity, this algorithm does not require an initial feasible point for the linear objective minimization problem Equation 3-3 or the generalized eigenvalue minimization problem Equation 3-4.\n\nSome LMI problems are formulated in terms of inequalities rather than strict inequalities. For instance, a variant of Equation 3-3 is\n\nMinimize $c^T x$ subject to $A(x) < 0$.\n\nWhile this distinction is immaterial in general, it matters when $A(x)$ can be made negative semi-definite but not negative definite. A simple example is:\n\nMinimize $c^T x$ subject to\n\n$$\\begin{pmatrix} x & x \\\\ x & x \\end{pmatrix} \\geq 0.$$ \n\nSuch problems cannot be handled directly by interior-point methods which require strict feasibility of the LMI constraints. A well-posed reformulation of Equation 3-5 would be\n\nMinimize $c^T x$ subject to $x \\geq 0$.\n\nKeeping this subtlety in mind, we always use strict inequalities in this manual.\nBibliography\n\n\nLMI Lab\n\n- “Tools for Specifying and Solving LMIs” on page 4-2\n- “Specifying a System of LMIs” on page 4-7\n- “Specify LMI System at the Command Line” on page 4-8\n- “Specify LMIs with the LMI Editor GUI” on page 4-15\n- “How lmivar and lmiterm Manage LMI Representation” on page 4-18\n- “Querying the LMI System Description” on page 4-19\n- “LMI Solvers” on page 4-20\n- “Minimize Linear Objectives under LMI Constraints” on page 4-22\n- “Conversion Between Decision and Matrix Variables” on page 4-26\n- “Validating Results” on page 4-27\n- “Modify a System of LMIs” on page 4-28\n- “Advanced LMI Techniques” on page 4-31\n- “Bibliography” on page 4-42\nTools for Specifying and Solving LMIs\n\nThe LMI Lab is a high-performance package for solving general LMI problems. It blends simple tools for the specification and manipulation of LMIs with powerful LMI solvers for three generic LMI problems. Thanks to a structure-oriented representation of LMIs, the various LMI constraints can be described in their natural block-matrix form. Similarly, the optimization variables are specified directly as matrix variables with some given structure. Once an LMI problem is specified, it can be solved numerically by calling the appropriate LMI solver. The three solvers feasp, mincx, and gevp constitute the computational engine of the LMI portion of Robust Control Toolbox software. Their high performance is achieved through C-MEX implementation and by taking advantage of the particular structure of each LMI.\n\nThe LMI Lab offers tools to\n\n- Specify LMI systems either symbolically with the LMI Editor or incrementally with the lmivar and lmiterm commands\n- Retrieve information about existing systems of LMIs\n- Modify existing systems of LMIs\n- Solve the three generic LMI problems (feasibility problem, linear objective minimization, and generalized eigenvalue minimization)\n- Validate results\n\nThis chapter gives a tutorial introduction to the LMI Lab as well as more advanced tips for making the most out of its potential.\n\nSome Terminology\n\nAny linear matrix inequality can be expressed in the canonical form\n\n\\[ L(x) = L_0 + x_1L_1 + \\ldots + x_NL_N < 0 \\]\n\nwhere\n\n- \\( L_0, L_1, \\ldots, L_N \\) are given symmetric matrices\n- \\( x = (x_1, \\ldots, x_N)^T \\in \\mathbb{R}^N \\) is the vector of scalar variables to be determined. We refer to \\( x_1, \\ldots, x_N \\) as the decision variables. The names “design variables” and “optimization variables” are also found in the literature.\nEven though this canonical expression is generic, LMIs rarely arise in this form in control applications. Consider for instance the Lyapunov inequality\n\n\\[ A^T X + X A < 0 \\]\n\nwhere\n\n\\[\nA = \\begin{pmatrix} -1 & 2 \\\\ 0 & -2 \\end{pmatrix}\n\\]\n\nand the variable\n\n\\[\nX = \\begin{pmatrix} x_1 & x_2 \\\\ x_2 & x_3 \\end{pmatrix}\n\\]\n\nis a symmetric matrix. Here the decision variables are the free entries \\(x_1, x_2, x_3\\) of \\(X\\) and the canonical form of this LMI reads\n\n\\[\nx_1 \\begin{pmatrix} -2 & 2 \\\\ 2 & 0 \\end{pmatrix} + x_2 \\begin{pmatrix} 0 & -3 \\\\ -3 & 4 \\end{pmatrix} + x_3 \\begin{pmatrix} 0 & 0 \\\\ 0 & -4 \\end{pmatrix} < 0.\n\\]\n\nClearly this expression is less intuitive and transparent than Equation 4-1. Moreover, the number of matrices involved in Equation 4-2 grows roughly as \\(n^2/2\\) if \\(n\\) is the size of the \\(A\\) matrix. Hence, the canonical form is very inefficient from a storage viewpoint since it requires storing \\(o(n^2/2)\\) matrices of size \\(n\\) when the single \\(n\\)-by-\\(n\\) matrix \\(A\\) would be sufficient. Finally, working with the canonical form is also detrimental to the efficiency of the LMI solvers. For these various reasons, the LMI Lab uses a structured representation of LMIs. For instance, the expression \\(A^T X + X A\\) in the Lyapunov inequality Equation 4-1 is explicitly described as a function of the matrix variable \\(X\\), and only the \\(A\\) matrix is stored.\n\nIn general, LMIs assume a block matrix form where each block is an affine combination of the matrix variables. As a fairly typical illustration, consider the following LMI drawn from \\(H^\\infty\\) theory\n\n\\[\nN^T \\begin{pmatrix} A^T X + X A & X C^T & B \\\\ C X & -\\gamma I & D \\\\ B^T & D^T & -\\gamma I \\end{pmatrix} N < 0\n\\]\nwhere A, B, C, D, and N are given matrices and the problem variables are \\( X = X^T \\in \\mathbb{R}^{n \\times n} \\) and \\( \\gamma \\in \\mathbb{R} \\). We use the following terminology to describe such LMIs:\n\n- \\( N \\) is called the outer factor, and the block matrix\n\n\\[\nL(X, \\gamma) = \\begin{pmatrix}\nA^T X + X A & X C^T & B \\\\\nC X & -\\gamma I & D \\\\\nB^T & D^T & -\\gamma I\n\\end{pmatrix}\n\\]\n\nis called the inner factor. The outer factor needs not be square and is often absent.\n\n- \\( X \\) and \\( \\gamma \\) are the matrix variables of the problem. Note that scalars are considered as 1-by-1 matrices.\n\n- The inner factor \\( L(X, \\gamma) \\) is a symmetric block matrix, its block structure being characterized by the sizes of its diagonal blocks. By symmetry, \\( L(X, \\gamma) \\) is entirely specified by the blocks on or above the diagonal.\n\n- Each block of \\( L(X, \\gamma) \\) is an affine expression in the matrix variables \\( X \\) and \\( \\gamma \\). This expression can be broken down into a sum of elementary terms. For instance, the block (1,1) contains two elementary terms: \\( A^T X \\) and \\( X A \\).\n\n- Terms are either constant or variable. Constant terms are fixed matrices like \\( B \\) and \\( D \\) above. Variable terms involve one of the matrix variables, like \\( X A \\), \\( X C^T \\), and \\( -\\gamma I \\) above.\n\nThe LMI (Equation 4-3) is specified by the list of terms in each block, as is any LMI regardless of its complexity.\n\nAs for the matrix variables \\( X \\) and \\( \\gamma \\), they are characterized by their dimensions and structure. Common structures include rectangular unstructured, symmetric, skew-symmetric, and scalar. More sophisticated structures are sometimes encountered in control problems. For instance, the matrix variable \\( X \\) could be constrained to the block-diagonal structure:\n\n\\[\nX = \\begin{pmatrix}\nx_1 & 0 & 0 \\\\\n0 & x_2 & x_3 \\\\\n0 & x_3 & x_4\n\\end{pmatrix}\n\\]\n\nAnother possibility is the symmetric Toeplitz structure:\nSumming up, structured LMI problems are specified by declaring the matrix variables and describing the term content of each LMI. This term-oriented description is systematic and accurately reflects the specific structure of the LMI constraints. There is no built-in limitation on the number of LMIs that you can specify or on the number of blocks and terms in any given LMI. LMI systems of arbitrary complexity can therefore, be defined in the LMI Lab.\n\n**Overview of the LMI Lab**\n\nThe LMI Lab offers tools to specify, manipulate, and numerically solve LMIs. Its main purpose is to\n\n- Allow for straightforward description of LMIs in their natural block-matrix form\n- Provide easy access to the LMI solvers (optimization codes)\n- Facilitate result validation and problem modification\n\nThe structure-oriented description of a given LMI system is stored as a single vector called the *internal representation* and generically denoted by $\\text{LMISYS}$ in the sequel. This vector encodes the structure and dimensions of the LMIs and matrix variables, a description of all LMI terms, and the related numerical data. It must be stressed that you need not attempt to read or understand the content of $\\text{LMISYS}$ since all manipulations involving this internal representation can be performed in a transparent manner with LMI-Lab tools.\n\nThe LMI Lab supports the following functionalities:\n\n**Specification of a System of LMIs**\n\nLMI systems can be either specified as symbolic matrix expressions with the interactive graphical user interface `lmiedit`, or assembled incrementally with the two commands `lmivar` and `lmiterm`. The first option is more intuitive and transparent while the second option is more powerful and flexible.\nInformation Retrieval\n\nThe interactive function lmiinfo answers qualitative queries about LMI systems created with lmiedit or lmivar and lmiterm. You can also use lmiedit to visualize the LMI system produced by a particular sequence of lmivar/lmiterm commands.\n\nSolvers for LMI Optimization Problems\n\nGeneral-purpose LMI solvers are provided for the three generic LMI problems defined in “LMI Applications” on page 3-6. These solvers can handle very general LMI systems and matrix variable structures. They return a feasible or optimal vector of decision variables \\( x^* \\). The corresponding values \\( X_1^*, \\ldots, X_K^* \\) of the matrix variables are given by the function dec2mat.\n\nResult Validation\n\nThe solution \\( x^* \\) produced by the LMI solvers is easily validated with the functions evallmi and showlmi. This allows a fast check and/or analysis of the results. With evallmi, all variable terms in the LMI system are evaluated for the value \\( x^* \\) of the decision variables. The left and right sides of each LMI then become constant matrices that can be displayed with showlmi.\n\nModification of a System of LMIs\n\nAn existing system of LMIs can be modified in two ways:\n\n- An LMI can be removed from the system with dellmi.\n- A matrix variable \\( X \\) can be deleted using delmvar. It can also be instantiated, that is, set to some given matrix value. This operation is performed by setmvar and allows, for example, to fix some variables and solve the LMI problem with respect to the remaining ones.\nSpecifying a System of LMIs\n\nThe LMI Lab can handle any system of LMIs of the form\n\n\\[ N^T L(X_1, \\ldots, X_K) N < MT R(X_1, \\ldots, X_K) M \\]\n\nwhere\n\n- \\( X_1, \\ldots, X_K \\) are matrix variables with some prescribed structure\n- The left and right outer factors \\( N \\) and \\( M \\) are given matrices with identical dimensions\n- The left and right inner factors \\( L(.) \\) and \\( R(.) \\) are symmetric block matrices with identical block structures, each block being an affine combination of \\( X_1, \\ldots, X_K \\) and their transposes.\n\n**Note** Throughout this chapter, “left side” refers to what is on the “smaller” side of the inequality, and “right side” to what is on the “larger” side. Accordingly, \\( X \\) is called the right-hand side and 0 the left side of the LMI\n\n\\[ 0 < X \\]\n\neven when this LMI is written as \\( X > 0 \\).\n\nThe specification of an LMI system involves two steps:\n\n1. Declare the dimensions and structure of each matrix variable \\( X_1, \\ldots, X_K \\).\n2. Describe the term content of each LMI.\n\nThis process creates the so-called internal representation of the LMI system. This computer description of the problem is used by the LMI solvers and in all subsequent manipulations of the LMI system. It is stored as a single vector called LMISYS.\n\nThere are two ways of generating the internal description of a given LMI system: (1) by a sequence of \\texttt{lmivar/lmiterm} commands that build it incrementally, or (2) via the LMI Editor \\texttt{lmiedit} where LMIs can be specified directly as symbolic matrix expressions. Though somewhat less flexible and powerful than the command-based description, the LMI Editor is more straightforward to use, hence particularly well-suited for beginners. Thanks to its coding and decoding capabilities, it also constitutes a good tutorial introduction to \\texttt{lmivar} and \\texttt{lmiterm}. Accordingly, beginners may elect to skip the subsections on \\texttt{lmivar} and \\texttt{lmiterm} and to concentrate on the GUI-based specification of LMIs with \\texttt{lmiedit}.\nSpecify LMI System at the Command Line\n\nThe following tutorial example is used to illustrate the specification of LMI systems with the LMI Lab tools.\n\nSpecifying LMI System\n\nConsider a stable transfer function\n\n\\[ G(s) = C(sI - A)^{-1} B \\]\n\nwith four inputs, four outputs, and six states, and consider the set of input/output scaling matrices \\( D \\) with block-diagonal structure\n\n\\[\nD = \\begin{pmatrix}\nd_1 & 0 & 0 & 0 \\\\\n0 & d_1 & 0 & 0 \\\\\n0 & 0 & d_2 & d_3 \\\\\n0 & 0 & d_4 & d_5\n\\end{pmatrix}.\n\\]\n\nThe following problem arises in the robust stability analysis of systems with time-varying uncertainty [4]:\n\nFind, if any, a scaling \\( D \\) of structure (Equation 4-5) such that the largest gain across frequency of \\( D G(s) D^{-1} \\) is less than one.\n\nThis problem has a simple LMI formulation: there exists an adequate scaling \\( D \\) if the following feasibility problem has solutions:\n\nFind two symmetric matrices \\( X \\in R^{6x6} \\) and \\( S = D^T D \\in R^{4x4} \\) such that\n\n\\[\n\\begin{pmatrix}\nA^T X + XA + C^T S C & XB \\\\\nB^T X & -S\n\\end{pmatrix} < 0\n\\]\n\n\\[ X > 0 \\]\n\n\\[ S > 1. \\]\nThe LMI system (Equation 4-6, Equation 4-7, and Equation 4-8) can be described with the LMI Editor as outlined below. Alternatively, its internal description can be generated with `lmivar` and `lmiterm` commands as follows:\n\n```matlab\nsetlmis([])\nX=lmivar(1,[6 1])\nS=lmivar(1,[2 0;2 1])\n\n% 1st LMI\nlmiterm([1 1 1 X],1,A,'s')\nlmiterm([1 1 1 S],C',C)\nlmiterm([1 1 2 X],1,B)\nlmiterm([1 2 2 S],-1,1)\n\n% 2nd LMI\nlmiterm([-2 1 1 X],1,1)\n\n% 3rd LMI\nlmiterm([-3 1 1 S],1,1)\nlmiterm([3 1 1 0],1)\n\nLMISYS = getlmis\n```\n\nHere the `lmivar` commands define the two matrix variables $X$ and $S$ while the `lmiterm` commands describe the various terms in each LMI. Upon completion, `getlmis` returns the internal representation `LMISYS` of this LMI system. The following subsections give more details on the syntax and usage of these various commands:\n\n- “Initializing the LMI System” on page 4-9\n- “Specifying the LMI Variables” on page 4-10\n- “Specifying Individual LMIs” on page 4-12\n\nMore information on how the internal representation is updated by `lmivar/lmiterm` can also be found in “How lmivar and lmiterm Manage LMI Representation” on page 4-18.\n\n**Initializing the LMI System**\n\nThe description of an LMI system should begin with `setlmis` and end with `getlmis`. The function `setlmis` initializes the LMI system description. When specifying a new system, type\n\n`setlmis([])`\nTo add on to an existing LMI system with internal representation LMIS0, type\n\n\\texttt{setlmis(LMIS0)}\n\n### Specifying the LMI Variables\n\nThe matrix variables are declared one at a time with \\texttt{lmivar} and are characterized by their structure. To facilitate the specification of this structure, the LMI Lab offers two predefined structure types along with the means to describe more general structures:\n\n<table>\n<thead>\n<tr>\n<th>Type</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Type 1</td>\n<td>Symmetric block diagonal structure. This corresponds to matrix variables of the form</td>\n</tr>\n</tbody>\n</table>\n| | \\[\n| | X = \\begin{pmatrix}\n| | D_1 & 0 & \\ldots & 0 \\\\\n| | 0 & D_2 & \\ddots & \\vdots \\\\\n| | \\vdots & \\ddots & \\ddots & 0 \\\\\n| | 0 & \\ldots & 0 & D_r \\\\\n| | \\end{pmatrix}\n| | where each diagonal block \\( D_j \\) is square and is either zero, a full symmetric matrix, or a scalar matrix |\n| | \\( D_j = d \\times I, \\ d \\in \\mathbb{R} \\) |\n| | This type encompasses ordinary symmetric matrices (single block) and scalar variables (one block of size one). |\n| Type 2 | **Rectangular** structure. This corresponds to arbitrary rectangular matrices without any particular structure. |\n| Type 3 | **General** structures. This third type is used to describe more sophisticated structures and/or correlations between the matrix variables. The principle is as follows: each entry of \\( X \\) is specified independently as either 0, \\( x_n \\), or \\(-x_n\\) where \\( x_n \\) denotes the \\( n \\)-th decision variable in the problem. For details on how to use Type 3, see “Structured Matrix Variables” on page 4-31 as well as the \\texttt{lmivar} entry in the reference pages. |\n\nIn “Specifying LMI System” on page 4-8, the matrix variables \\( X \\) and \\( S \\) are of Type 1. Indeed, both are symmetric and \\( S \\) inherits the block-diagonal structure from Equation 4-5 of \\( D \\). Specifically, \\( S \\) is of the form...\nAfter initializing the description with the command `setlmis([]), these two matrix variables are declared by\n\n\\[\nS = \\begin{pmatrix}\n s_1 & 0 & 0 & 0 \\\\\n 0 & s_1 & 0 & 0 \\\\\n 0 & 0 & s_2 & s_3 \\\\\n 0 & 0 & s_3 & s_4\n\\end{pmatrix}.\n\\]\n\nIn both commands, the first input specifies the structure type and the second input contains additional information about the structure of the variable:\n\n- For a matrix variable \\(X\\) of Type 1, this second input is a matrix with two columns and as many rows as diagonal blocks in \\(X\\). The first column lists the sizes of the diagonal blocks and the second column specifies their nature with the following convention:\n \n 1: full symmetric block\n \n 0: scalar block\n \n -1: zero block\n\n In the second command, for instance, \\([2 \\ 0; 2 \\ 1]\\) means that \\(S\\) has two diagonal blocks, the first one being a 2-by-2 scalar block and the second one a 2-by-2 full block.\n- For matrix variables of Type 2, the second input of `lmivar` is a two-entry vector listing the row and column dimensions of the variable. For instance, a 3-by-5 rectangular matrix variable would be defined by\n\n\\[\n\\text{lmivar}(2, [3 \\ 5])\n\\]\n\nFor convenience, `lmivar` also returns a “tag” that identifies the matrix variable for subsequent reference. For instance, \\(X\\) and \\(S\\) in “Specifying LMI System” on page 4-8 could be defined by\n\n\\[\nX = \\text{lmivar}(1, [6 \\ 1]) \\\\\nS = \\text{lmivar}(1, [2 \\ 0; 2 \\ 1])\n\\]\n\nThe identifiers \\(X\\) and \\(S\\) are integers corresponding to the ranking of \\(X\\) and \\(S\\) in the list of matrix variables (in the order of declaration). Here their values would be \\(X=1\\) and \\(S=2\\).\nNote that these identifiers still point to $X$ and $S$ after deletion or instantiation of some of the matrix variables. Finally, \\texttt{lmiVar} can also return the total number of decision variables allocated so far as well as the entry-wise dependence of the matrix variable on these decision variables (see the \\texttt{lmiVar} entry in the reference pages for more details).\n\n### Specifying Individual LMIs\n\nAfter declaring the matrix variables with \\texttt{lmiVar}, we are left with specifying the term content of each LMI. Recall that LMI terms fall into three categories:\n\n- The \\textit{constant terms}, i.e., fixed matrices like $I$ in the left side of the LMI $S > I$\n- The \\textit{variable terms}, i.e., terms involving a matrix variable. For instance, $A^TX$ and $C^TSC$ in Equation 4-6. Variable terms are of the form $PXQ$ where $X$ is a variable and $P$, $Q$ are given matrices called the left and right \\textit{coefficients}, respectively.\n- The \\textit{outer factors}\n\nThe following rule should be kept in mind when describing the term content of an LMI:\n\n\\textbf{Note: } Specify only the terms in the blocks on or above the diagonal. The inner factors being symmetric, this is sufficient to specify the entire LMI. Specifying all blocks results in the duplication of off-diagonal terms, hence in the creation of a different LMI. Alternatively, you can describe the blocks on or below the diagonal.\n\nLMI terms are specified one at a time with \\texttt{lmiterm}. For instance, the LMI\n\n$$\\begin{pmatrix}\nA^TX +XA +C^TSC & XB \\\\\nB^TX & -S\n\\end{pmatrix} < 0$$\n\nis described by\n\n\\texttt{lmiterm([1 1 1 1],1,A,'s')}\n\\texttt{lmiterm([1 1 1 2],C','C')}\n\\texttt{lmiterm([1 1 2 1],1,B)}\n\\texttt{lmiterm([1 2 2 2],-1,1)}\n\nThese commands successively declare the terms $A^TX +XA$, $C^TSC$, $XB$, and $-S$. In each command, the first argument is a four-entry vector listing the term characteristics as follows:\nThe first entry indicates to which LMI the term belongs. The value \\( m \\) means “left side of the \\( m \\)-th LMI,” and \\(-m\\) means “right side of the \\( m \\)-th LMI.”\n\nThe second and third entries identify the block to which the term belongs. For instance, the vector \\([1 \\ 1 \\ 2 \\ 1]\\) indicates that the term is attached to the (1, 2) block.\n\nThe last entry indicates which matrix variable is involved in the term. This entry is 0 for constant terms, \\( k \\) for terms involving the \\( k \\)-th matrix variable \\( X_k \\), and \\(-k\\) for terms involving \\( X_k^T \\) (here \\( X \\) and \\( S \\) are first and second variables in the order of declaration).\n\nFinally, the second and third arguments of \\texttt{lmiterm} contain the numerical data (values of the constant term, outer factor, or matrix coefficients \\( P \\) and \\( Q \\) for variable terms \\( PXQ \\) or \\( PX^TQ \\)). These arguments must refer to existing MATLAB variables and be \\textit{real-valued}. See “Complex-Valued LMIs” on page 4-33 for the specification of LMIs with complex-valued coefficients.\n\nSome shorthand is provided to simplify term specification. First, blocks are zero by default. Second, in diagonal blocks the extra argument ’s’ allows you to specify the conjugated expression \\(AXB + B^TX^T A^T\\) with a single \\texttt{lmiterm} command. For instance, the first command specifies \\( A^T X + X A \\) as the “symmetrization” of \\( X A \\). Finally, scalar values are allowed as shorthand for \\textit{scalar matrices}, i.e., matrices of the form \\( \\alpha I \\) with \\( \\alpha \\) scalar. Thus, a constant term of the form \\( \\alpha I \\) can be specified as the “scalar” \\( \\alpha \\). This also applies to the coefficients \\( P \\) and \\( Q \\) of variable terms. The dimensions of scalar matrices are inferred from the context and set to 1 by default. For instance, the third LMI \\( S > I \\) in “Example: Specifying Matrix Variable Structures” on page 4-31 is described by\n\n\\[\n\\text{\\texttt{lmiterm([[-3 \\ 1 \\ 1 \\ 2],1,1]) \\quad \\% \\ 1*S*1 = S}}\n\\]\n\\[\n\\text{\\texttt{lmiterm([3 \\ 1 \\ 1 \\ 0],1) \\quad \\% \\ 1*I = I}}\n\\]\n\nRecall that by convention \\( S \\) is considered as the right side of the inequality, which justifies the \\(-3\\) in the first command.\n\nFinally, to improve readability it is often convenient to attach an identifier (tag) to each LMI and matrix variable. The variable identifiers are returned by \\texttt{lmivar} and the LMI identifiers are set by the function \\texttt{newlmi}. These identifiers can be used in \\texttt{lmiterm} commands to refer to a given LMI or matrix variable. For the LMI system of “Specifying LMI System” on page 4-8, this would look like:\n\n\\[\n\\text{\\texttt{setlmis([])}}\n\\]\n\\[\n\\text{\\texttt{X = lmivar(1,[6 1])}}\n\\]\n\\[\n\\text{\\texttt{S = lmivar(1,[2 0;2 1])}}\n\\]\nBRL = newlmi\nlmiterm([BRL 1 1 X],1,A,'s')\nlmiterm([BRL 1 1 S],C',C)\nlmiterm([BRL 1 2 X],1,B)\nlmiterm([BRL 2 2 S],-1,1)\n\nXpos = newlmi\nlmiterm([-Xpos 1 1 X],1,1)\n\nSlmi = newlmi\nlmiterm([-Slmi 1 1 S],1,1)\nlmiterm([Slmi 1 1 0],1)\n\nWhen the LMI system is completely specified, type\n\nLMISYS = getlmis\n\nThis returns the internal representation LMISYS of this LMI system. This MATLAB\ndescription of the problem can be forwarded to other LMI-Lab functions for subsequent\nprocessing. The command getlmis must be used only once and after declaring all matrix\nvariables and LMI terms.\n\nHere the identifiers X and S point to the variables X and S while the tags BRL, Xpos, and\nSlmi point to the first, second, and third LMI, respectively. Note that –Xpos refers to\nthe right-hand side of the second LMI. Similarly, –X would indicate transposition of the\nvariable X.\nSpecify LMIs with the LMI Editor GUI\n\nThe LMI Editor \\texttt{lmiedit} is a graphical user interface (GUI) to specify LMI systems in a straightforward symbolic manner. Typing \\texttt{lmiedit}\n\ncalls up a window with several editable text areas and various buttons.\n\nIn more detail, to specify your LMI system,\n\n1. Declare each matrix variable (name and structure) in the upper half of the worksheet. The structure is characterized by its type (S for symmetric block diagonal, R for unstructured, and G for other structures) and by an additional “\n“structure” matrix. This matrix contains specific information about the structure and corresponds to the second argument of \\texttt{lmivar} (see “Specifying the LMI Variables” on page 4-10 for details).\n\nPlease use \\textit{one line per matrix variable} in the text editing areas.\n\n2 Specify the LMIs as MATLAB expressions in the lower half of the worksheet. For instance, the LMI\n\n\\[\n\\begin{pmatrix}\nA^T X + X A & X B \\\\\nB^T X & -I\n\\end{pmatrix} < 0\n\\]\n\nis entered by typing\n\n\\[\n[a'*x+x*a x*b; b'*x -1] < 0\n\\]\n\nif \\(x\\) is the name given to the matrix variable \\(X\\) in the upper half of the worksheet. The left- and right-hand sides of the LMIs should be \\textit{valid} MATLAB expressions.\n\nOnce the LMI system is fully specified, the following tasks can be performed by clicking the corresponding button:\n\n- Visualize the sequence of \\texttt{lmivar}/\\texttt{lmiterm} commands needed to describe this LMI system (\\texttt{view commands} button). Conversely, the LMI system defined by a particular sequence of \\texttt{lmivar}/\\texttt{lmiterm} commands can be displayed as a MATLAB expression by clicking on the \\texttt{describe...} buttons.\n\nBeginners can use this facility as a tutorial introduction to the \\texttt{lmivar} and \\texttt{lmiterm} commands.\n\n- Save the symbolic description of the LMI system as a MATLAB string (\\texttt{save} button). This description can be reloaded later on by clicking the \\texttt{load} button.\n\n- Read a sequence of \\texttt{lmivar}/\\texttt{lmiterm} commands from a file (\\texttt{read} button). You can then click on \\texttt{describe the matrix variables} or \\texttt{describe the LMIs} to visualize the symbolic expression of the LMI system specified by these commands. The file should describe a single LMI system but may otherwise contain any sequence of MATLAB commands.\n\nThis feature is useful for code validation and debugging.\n\nWrite in a file the sequence of \\texttt{lmivar}/\\texttt{lmiterm} commands needed to describe a particular LMI system (\\texttt{write} button).\nSpecify LMIswith the LMI Editor GUI\n\nThis is helpful to develop code and prototype MATLAB functions based on the LMI Lab.\n\n- Generate the internal representation of the LMI system by clicking create. The result is written in a MATLAB variable named after the LMI system (if the “name of the LMI system” is set to mylmi, the internal representation is written in the MATLAB variable mylmi). Note that all LMI-related data should be defined in the MATLAB workspace at this stage.\n\nThe internal representation can be passed directly to the LMI solvers or any other LMI Lab function.\n\n**Keyboard Shortcuts**\n\nAs with lmiterm, you can use various shortcuts when entering LMI expressions at the keyboard. For instance, zero blocks can be entered simply as 0 and need not be dimensioned. Similarly, the identity matrix can be entered as 1 without dimensioning. Finally, upper diagonal LMI blocks need not be fully specified. Rather, you can just type (*) in place of each such block.\n\n**Limitations**\n\nThough fairly general, lmi edit is not as flexible as lmiterm and the following limitations should be kept in mind:\n\n- Parentheses cannot be used around matrix variables. For instance, the expression\n \n \\[(a*x+b)\\cdot c + c\\cdot(a*x+b)\\]\n\n is invalid when x is a variable name. By contrast,\n\n \\[(a+b)\\cdot x + x\\cdot(a+b)\\]\n\n is perfectly valid.\n- Loops and if statements are ignored.\n- When turning lmiterm commands into a symbolic description of the LMI system, an error is issued if the first argument of lmiterm cannot be evaluated. Use the LMI and variable identifiers supplied by newlmi and lmivar to avoid such difficulties.\nHow lmivar and lmiterm Manage LMI Representation\n\nUsers familiar with MATLAB may wonder how `lmivar` and `lmiterm` physically update the internal representation `LMISYS` since `LMISYS` is not an argument to these functions. In fact, all updating is performed through global variables for maximum speed. These global variables are initialized by `setlmis`, cleared by `getlmis`, and are not visible in the workspace. Even though this artifact is transparent from the user's viewpoint, be sure to\n\n- Invoke `getlmis` only once and after completely specifying the LMI system\n- Refrain from using the command `clear global` before the LMI system description is ended with `getlmis`\nQuerying the LMI System Description\n\nRecall that the full description of an LMI system is stored as a single vector called the internal representation. The user should not attempt to read or retrieve information directly from this vector. Robust Control Toolbox software provides three functions called `lmiinfo`, `lminbr`, and `matnbr` to extract and display all relevant information in a user-readable format.\n\n**lmiinfo**\n\n`lminbr` is an interactive facility to retrieve qualitative information about LMI systems. This includes the number of LMIs, the number of matrix variables and their structure, the term content of each LMI block, etc. To invoke `lmiinfo`, enter\n\n```\nlmiinfo(LMISYS)\n```\n\nwhere `LMISYS` is the internal representation of the LMI system produced by `getlmis`.\n\n**lminbr and matnbr**\n\nThese two functions return the number of LMIs and the number of matrix variables in the system. To get the number of matrix variables, for instance, enter\n\n```\nmatnbr(LMISYS)\n```\nLMI Solvers\n\nLMI solvers are provided for the following three generic optimization problems (here $x$ denotes the vector of decision variables, i.e., of the free entries of the matrix variables $X_1, \\ldots, X_K$):\n\n- **Feasibility problem**\n\n Find $x \\in \\mathbb{R}^N$ (or equivalently matrices $X_1, \\ldots, X_K$ with prescribed structure) that satisfies the LMI system\n\n $$A(x) < B(x)$$\n\n The corresponding solver is called `feasp`.\n\n- **Minimization of a linear objective under LMI constraints**\n\n Minimize $c^T x$ over $x \\in \\mathbb{R}^N$ subject to $A(x) < B(x)$\n\n The corresponding solver is called `mincx`.\n\n- **Generalized eigenvalue minimization problem**\n\n Minimize $\\lambda$ over $x \\in \\mathbb{R}^N$ subject to\n\n $$C(x) < D(x)$$\n\n $$0 < B(x)$$\n\n $$A(x) < \\lambda B(x).$$\n\n The corresponding solver is called `gevp`.\n\nNote that $A(x) < B(x)$ above is a shorthand notation for general structured LMI systems with decision variables $x = (x_1, \\ldots, x_N)$.\n\nThe three LMI solvers `feasp`, `mincx`, and `gevp` take as input the internal representation `LMISYS` of an LMI system and return a feasible or optimizing value $x^*$ of the decision variables. The corresponding values of the matrix variables $X_1, \\ldots, X_K$ are derived from $x^*$ with the function `dec2mat`. These solvers are C-MEX implementations of the polynomial-time Projective Algorithm of Nesterov and Nemirovski [3], [2].\nFor generalized eigenvalue minimization problems, it is necessary to distinguish between the standard LMI constraints $C(x) < D(x)$ and the linear-fractional LMIs $A(x) < \\lambda B(x)$ attached to the minimization of the generalized eigenvalue $\\lambda$. When using \\texttt{gevp}, you should follow these three rules to ensure proper specification of the problem:\n\n- Specify the LMIs involving $\\lambda$ as $A(x) < B(x)$ \\textit{(without the $\\lambda$)}\n- Specify them \\textit{last} in the LMI system. \\texttt{gevp} systematically assumes that the last $L$ LMIs are linear-fractional if $L$ is the number of LMIs involving $\\lambda$\n- Add the constraint $0 < B(x)$ or any other constraint that enforces it. This positivity constraint is required for well-posedness of the problem and is not automatically added by \\texttt{gevp}.\n\nAn initial guess $x_{init}$ for $x$ can be supplied to \\texttt{mincx} or \\texttt{gevp}. Use \\texttt{mat2dec} to derive $x_{init}$ from given values of the matrix variables $X_1, \\ldots, X_K$.\n\nThe following example illustrates the use of the \\texttt{mincx} solver.\nMinimize Linear Objectives under LMI Constraints\n\nConsider the optimization problem:\n\nMinimize Trace($X$) subject to\n\n$$A^TX +XA + XBB^TX + Q < 0$$\n\nwith data\n\n$$A = \\begin{pmatrix} -1 & -2 & 1 \\\\ 3 & 2 & 1 \\\\ 1 & -2 & -1 \\end{pmatrix}; \\quad B = \\begin{pmatrix} 1 \\\\ 0 \\\\ 1 \\end{pmatrix}; \\quad Q = \\begin{pmatrix} 1 & -1 & 0 \\\\ -1 & -3 & -12 \\\\ 0 & -12 & -36 \\end{pmatrix}.$$ \n\nIt can be shown that the minimizer $X^*$ is simply the stabilizing solution of the algebraic Riccati equation\n\n$$A^TX +XA + XBB^TX + Q = 0$$\n\nThis solution can be computed directly with the Riccati solver care and compared to the minimizer returned by mincx.\n\nFrom an LMI optimization standpoint, the problem specified in Equation 4-9 is equivalent to the following linear objective minimization problem:\n\nMinimize Trace($X$) subject to\n\n$$\\begin{pmatrix} A^TX +XA + Q & XB \\\\ B^TX & -I \\end{pmatrix} < 0.$$ \n\nSince Trace($X$) is a linear function of the entries of $X$, this problem falls within the scope of the mincx solver and can be numerically solved as follows:\n\n1. Define the LMI constraint of Equation 4-9 by the sequence of commands\n\n```matlab\nsetlmis([])\nX = lmivar(1,[3 1]) % variable X, full symmetric\nlmiterm([1 1 1 X],1,a,'s')\nlmiterm([1 1 0],q)\n```\nlmiterm([1 2 2 0],-1)\nlmiterm([1 2 1 X],b',1)\n\nLMIs = getlmis\n\n2 Write the objective $\\text{Trace}(X)$ as $c^T x$ where $x$ is the vector of free entries of $X$. Since $c$ should select the diagonal entries of $X$, it is obtained as the decision vector corresponding to $X = I$, that is,\n\n$$c = \\text{mat2dec}(\\text{LMIs}, \\text{eye}(3))$$\n\nNote that the function \\text{defcx} provides a more systematic way of specifying such objectives (see “Specifying $c^T x$ Objectives for \\text{mincx}” on page 4-36 for details).\n\n3 Call \\text{mincx} to compute the minimizer $x_{\\text{opt}}$ and the global minimum $c_{\\text{opt}} = c' x_{\\text{opt}}$ of the objective:\n\n$$\\text{options} = [1e-5,0,0,0,0]$$\n$$[c_{\\text{opt}}, x_{\\text{opt}}] = \\text{mincx}(\\text{LMIs}, c, \\text{options})$$\n\nHere $1e-5$ specifies the desired relative accuracy on $c_{\\text{opt}}$.\n\nThe following trace of the iterative optimization performed by \\text{mincx} appears on the screen:\n\nSolver for linear objective minimization under LMI constraints\nIterations : Best objective value so far\n\n<table>\n<thead>\n<tr>\n<th>Iteration</th>\n<th>Objective Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td></td>\n</tr>\n<tr>\n<td>2</td>\n<td>-8.511476</td>\n</tr>\n<tr>\n<td>3</td>\n<td>-13.063640</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound: -34.023978</td>\n</tr>\n<tr>\n<td>4</td>\n<td>-15.768450</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound: -25.005604</td>\n</tr>\n<tr>\n<td>5</td>\n<td>-17.123012</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound: -21.306781</td>\n</tr>\n<tr>\n<td>6</td>\n<td>-17.882558</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound: -19.819471</td>\n</tr>\n<tr>\n<td>7</td>\n<td>-18.339853</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound:</td>\n</tr>\n<tr>\n<td>-----</td>\n<td>-----------------</td>\n</tr>\n<tr>\n<td>8</td>\n<td>-18.552558</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound:</td>\n</tr>\n<tr>\n<td>9</td>\n<td>-18.646811</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound:</td>\n</tr>\n<tr>\n<td>10</td>\n<td>-18.687324</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound:</td>\n</tr>\n<tr>\n<td>11</td>\n<td>-18.705715</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound:</td>\n</tr>\n<tr>\n<td>12</td>\n<td>-18.712175</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound:</td>\n</tr>\n<tr>\n<td>13</td>\n<td>-18.714880</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound:</td>\n</tr>\n<tr>\n<td>14</td>\n<td>-18.716094</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound:</td>\n</tr>\n<tr>\n<td>15</td>\n<td>-18.716509</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound:</td>\n</tr>\n<tr>\n<td>16</td>\n<td>-18.716695</td>\n</tr>\n<tr>\n<td>***</td>\n<td>new lower bound:</td>\n</tr>\n</tbody>\n</table>\n\nResult: feasible solution of required accuracy\n\n- best objective value: -18.716695\n- guaranteed relative accuracy: 9.50e–06\n- f-radius saturation: 0.000% of R = 1.00e+09\n\nThe iteration number and the best value of $c^T x$ at the current iteration appear in the left and right columns, respectively. Note that no value is displayed at the first iteration, which means that a feasible $x$ satisfying the constraint (Equation 4-10) was found only at the second iteration. Lower bounds on the global minimum of $c^T x$ are sometimes detected as the optimization progresses. These lower bounds are reported by the message\n\n*** new lower bound: xxx\nUpon termination, \\texttt{mincx} reports that the global minimum for the objective Trace($X$) is $-18.716695$ with relative accuracy of at least $9.5 \\times 10^{-6}$. This is the value $c_{opt}$ returned by \\texttt{mincx}.\n\n\\texttt{mincx} also returns the optimizing vector of decision variables $x_{opt}$. The corresponding optimal value of the matrix variable $X$ is given by\n\n$$X_{opt} = \\text{dec2mat}(\\text{LMIs}, x_{opt}, X)$$\n\nwhich returns\n\n$$X_{opt} = \\begin{pmatrix} -6.3542 & -5.8895 & 2.2046 \\\\ -5.8895 & -6.2855 & 2.2201 \\\\ 2.2046 & 2.2201 & -6.0771 \\end{pmatrix}.$$ \n\nThis result can be compared with the stabilizing Riccati solution computed by \\texttt{care}:\n\n$$X_{st} = \\text{care}(a,b,q,-1)$$\n$$\\text{norm}(X_{opt} - X_{st})$$\n\n$$\\text{ans} = 6.5390e-05$$\nConversion Between Decision and Matrix Variables\n\nWhile LMIs are specified in terms of their matrix variables $X_1, \\ldots, X_K$, the LMI solvers optimize the vector $x$ of free scalar entries of these matrices, called the decision variables. The two functions `mat2dec` and `dec2mat` perform the conversion between these two descriptions of the problem variables.\n\nConsider an LMI system with three matrix variables $X_1, X_2, X_3$. Given particular values $X_1, X_2, X_3$ of these variables, the corresponding value $x_{\\text{dec}}$ of the vector of decision variables is returned by `mat2dec`:\n\n$$x_{\\text{dec}} = \\text{mat2dec}(\\text{LMISYS}, X_1, X_2, X_3)$$\n\nAn error is issued if the number of arguments following `LMISYS` differs from the number of matrix variables in the problem (see `matnbr`).\n\nConversely, given a value $x_{\\text{dec}}$ of the vector of decision variables, the corresponding value of the $k$-th matrix is given by `dec2mat`. For instance, the value $X_2$ of the second matrix variable is extracted from $x_{\\text{dec}}$ by\n\n$$X_2 = \\text{dec2mat}(\\text{LMISYS}, x_{\\text{dec}}, 2)$$\n\nThe last argument indicates that the second matrix variable is requested. It could be set to the matrix variable identifier returned by `lmivar`.\n\nThe total numbers of matrix variables and decision variables are returned by `matnbr` and `decnbr`, respectively. In addition, the function `decinfo` provides precise information about the mapping between decision variables and matrix variable entries.\nValidating Results\n\nThe LMI Lab offers two functions to analyze and validate the results of an LMI optimization. The function `evallmi` evaluates all variable terms in an LMI system for a given value of the vector of decision variables, for instance, the feasible or optimal vector returned by the LMI solvers. Once this evaluation is performed, the left and right sides of a particular LMI are returned by `showlmi`.\n\nIn the LMI problem considered in “Minimize Linear Objectives under LMI Constraints” on page 4-22, you can verify that the minimizer `xopt` returned by `mincx` satisfies the LMI constraint (Equation 4-10) as follows:\n\n```matlab\nevlmi = evallmi(LMIs,xopt)\n[lhs,rhs] = showlmi(evlmi,1)\n```\n\nThe first command evaluates the system for the value `xopt` of the decision variables, and the second command returns the left and right sides of the first (and only) LMI. The negative definiteness of this LMI is checked by\n\n```matlab\neig(lhs-rhs)\n```\n\n```matlab\nan =\n-2.0387e–04\n-3.9333e–05\n-1.8917e–07\n-4.6680e+01\n```\nModify a System of LMIs\n\nOnce specified, a system of LMIs can be modified in several ways with the functions dellmi, delmvar, and setmvar.\n\nDeleting an LMI\n\nThe first possibility is to remove an entire LMI from the system with dellmi. For instance, suppose that the LMI system of “Specifying LMI System” on page 4-8 is described in LMISYS and that we want to remove the positivity constraint on $X$. This is done by\n\n$$\\text{NEWSYS} = \\text{dellmi}(\\text{LMISYS},2)$$\n\nwhere the second argument specifies deletion of the second LMI. The resulting system of two LMIs is returned in NEWSYS.\n\nThe LMI identifiers (initial ranking of the LMI in the LMI system) are not altered by deletions. As a result, the last LMI\n\n$$S > I$$\n\nremains known as the third LMI even though it now ranks second in the modified system. To avoid confusion, it is safer to refer to LMIs via the identifiers returned by newlmi. If BRL, Xpos, and Slmi are the identifiers attached to the three LMIs, Equation 4-6–Equation 4-8, Slmi keeps pointing to $S > I$ even after deleting the second LMI by\n\n$$\\text{NEWSYS} = \\text{dellmi}(\\text{LMISYS}, \\text{Xpos})$$\n\nDeleting a Matrix Variable\n\nAnother way of modifying an LMI system is to delete a matrix variable, that is, to remove all variable terms involving this matrix variable. This operation is performed by delmvar. For instance, consider the LMI\n\n$$A^TX + XA + BW + W^TB^T + I < 0$$\n\nwith variables $X = X^T \\in R^{4 \\times 4}$ and $W \\in R^{2 \\times 4}$. This LMI is defined by\n\n$$\\text{setlmis}([])$$\n\\( X = \\text{lmivar}(1,[4 1]) \\) % X\n\\( W = \\text{lmivar}(2,[2 4]) \\) % W\n\n\\( \\text{lmiterm}([1 1 1 X],1,A,'s') \\)\n\\( \\text{lmiterm}([1 1 1 W],B,1,'s') \\)\n\\( \\text{lmiterm}([1 1 1 0],1) \\)\n\nLMISYS = getlmis\n\nTo delete the variable \\( W \\), type the command\n\nNEWSYS = \\text{delmvar}(\\text{LMISYS},W)\n\nThe resulting \\( \\text{NEWSYS} \\) now describes the Lyapunov inequality\n\n\\( A^T X + XA + I < 0 \\)\n\nNote that \\text{delmvar} automatically removes all LMIs that depended only on the deleted matrix variable.\n\nThe matrix variable identifiers are not affected by deletions and continue to point to the same matrix variable. For subsequent manipulations, it is therefore advisable to refer to the remaining variables through their identifier. Finally, note that deleting a matrix variable is equivalent to setting it to the zero matrix of the same dimensions with \\text{setmvar}.\n\n**Instantiating a Matrix Variable**\n\nThe function \\text{setmvar} is used to set a matrix variable to some given value. As a result, this variable is removed from the problem and all terms involving it become constant terms. This is useful, for instance, to fix \\text{setmvar} some variables and optimize with respect to the remaining ones.\n\nConsider again “Specifying LMI System” on page 4-8 and suppose we want to know if the peak gain of \\( G \\) itself is less than one, that is, if\n\n\\( \\| G \\|_\\infty < 1 \\)\n\nThis amounts to setting the scaling matrix \\( D \\) (or equivalently, \\( S = D^T D \\)) to a multiple of the identity matrix. Keeping in mind the constraint \\( S > I \\), a legitimate choice is \\( S = 2-\\beta \\psi I \\). To set \\( S \\) to this value, enter\nNEWSYS = setmvar(LMISYS,S,2)\n\nThe second argument is the variable identifier $S$, and the third argument is the value to which $S$ should be set. Here the value 2 is shorthand for $2$-by-$I$. The resulting system NEWSYS reads\n\n$$\n\\begin{pmatrix}\nA^T X + XA + 2C^{TC} & XB \\\\\nB^T X & -2I\n\\end{pmatrix} < 0\n$$\n\nwith $X > 0$ and $2I > I$.\n\nNote that the last LMI is now free of variable and trivially satisfied. It could, therefore, be deleted by\n\nNEWSYS = dellmi(NEWSYS,3)\n\nor\n\nNEWSYS = dellmi(NEWSYS,Slmi)\n\nif Slmi is the identifier returned by newlmi.\nAdvanced LMI Techniques\n\nThis last section gives a few hints for making the most out of the LMI Lab. It is directed toward users who are comfortable with the basics, as described in “Tools for Specifying and Solving LMIs” on page 4-2.\n\nStructured Matrix Variables\n\nFairly complex matrix variable structures and interdependencies can be specified with \\texttt{lmivar}. Recall that the symmetric block-diagonal or rectangular structures are covered by Types 1 and 2 of \\texttt{lmivar} provided that the matrix variables are independent. To describe more complex structures or correlations between variables, you must use Type 3 and specify each entry of the matrix variables directly in terms of the free scalar variables of the problem (the so-called decision variables).\n\nWith Type 3, each entry is specified as either 0 or $\\pm x_n$ where $x_n$ is the $n$-th decision variable. The following examples illustrate how to specify nontrivial matrix variable structures with \\texttt{lmivar}. First, consider the case of uncorrelated matrix variables.\n\n**Example: Specifying Matrix Variable Structures**\n\nSuppose that the problem variables include a 3-by-3 symmetric matrix $X$ and a 3-by-3 symmetric Toeplitz matrix:\n\n$$\nY = \\begin{pmatrix}\n y_1 & y_2 & y_3 \\\\\n y_2 & y_1 & y_2 \\\\\n y_3 & y_2 & y_1 \n\\end{pmatrix}.\n$$\n\nThe variable $Y$ has three independent entries, hence involves three decision variables. Since $Y$ is independent of $X$, these decision variables should be labeled $n + 1$, $n + 2$, $n + 3$ where $n$ is the number of decision variables involved in $X$. To retrieve this number, define the variable $X$ (Type 1) by\n\n\\begin{verbatim}\nsetlmis([])\n[X,n] = lmivar(1,[3 1])\n\\end{verbatim}\n\nThe second output argument $n$ gives the total number of decision variables used so far (here $n = 6$). Given this number, $Y$ can be defined by\n\n\\begin{verbatim}\nY = lmivar(3,n+[1 2 3;2 1 2;3 2 1])\n\\end{verbatim}\nor equivalently by\n\n\\[ Y = \\text{lmivar}(3, \\text{toeplitz}(n+\\[1 \\ 2 \\ 3\\])) \\]\n\nwhere \\text{toeplitz} is a standard MATLAB function. For verification purposes, we can visualize the decision variable distributions in \\(X\\) and \\(Y\\) with \\text{decinfo}:\n\n\\[\n\\text{lmis} = \\text{getlmis} \\\\\n\\text{decinfo(lmis,}X) \\\\\n\\text{ans} = \\\\\n1 \\ 2 \\ 4 \\ \\\\\n2 \\ 3 \\ 5 \\ \\\\\n4 \\ 5 \\ 6 \\\\\n\ndecinfo(lmis,}Y) \\\\\n\\text{ans} = \\\\\n7 \\ 8 \\ 9 \\ \\\\\n8 \\ 7 \\ 8 \\ \\\\\n9 \\ 8 \\ 7 \\\\\n\\]\n\nThe next example is a problem with interdependent matrix variables.\n\n**Example: Specifying Interdependent Matrix Variables**\n\nConsider three matrix variables \\(X\\), \\(Y\\), \\(Z\\) with structure\n\n\\[\nX = \\begin{pmatrix} x & 0 \\\\ 0 & y \\end{pmatrix}, \\quad Y = \\begin{pmatrix} z & 0 \\\\ 0 & t \\end{pmatrix}, \\quad Z = \\begin{pmatrix} 0 & -x \\\\ -t & 0 \\end{pmatrix}\n\\]\n\nwhere \\(x, y, z, t\\) are independent scalar variables. To specify such a triple, first define the two independent variables \\(X\\) and \\(Y\\) (both of Type 1) as follows:\n\n\\[\n\\text{setlmi}([]) \\\\\n[X,n,\\text{sX}] = \\text{lmivar}(1,[1 \\ 0;1 \\ 0]) \\\\\n[Y,n,\\text{sY}] = \\text{lmivar}(1,[1 \\ 0;1 \\ 0])\n\\]\n\nThe third output of \\text{lmivar} gives the entry-wise dependence of \\(X\\) and \\(Y\\) on the decision variables \\((x_1, x_2, x_3, x_4) := (x, y, z, t)\\):\n\n\\[\n\\text{sX} =\n\\]\nUsing Type 3 of `lmivar`, you can now specify the structure of $Z$ in terms of the decision variables $x_1 = x$ and $x_4 = t$:\n\n$$[Z, n, sZ] = \\text{lmivar}(3, [0 \\ -sX(1,1); -sY(2,2) \\ 0])$$\n\nSince $sX(1,1)$ refers to $x_1$ while $sY(2,2)$ refers to $x_4$, this defines the variable $Z$ as:\n\n$$Z = \\begin{pmatrix} 0 & -x_1 \\\\ -x_4 & 0 \\end{pmatrix} = \\begin{pmatrix} 0 & -x \\\\ -t & 0 \\end{pmatrix}$$\n\nas confirmed by checking its entry-wise dependence on the decision variables:\n\n$$sZ = \\begin{pmatrix} 0 & -1 \\\\ -4 & 0 \\end{pmatrix}$$\n\n### Complex-Valued LMIs\n\nThe LMI solvers are written for real-valued matrices and cannot directly handle LMI problems involving complex-valued matrices. However, complex-valued LMIs can be turned into real-valued LMIs by observing that a complex Hermitian matrix $L(x)$ satisfies $L(x) < 0$ if and only if\n\n$$\\begin{pmatrix} \\text{Re}(L(x)) & \\text{Im}(L(x)) \\\\ -\\text{Im}(L(x)) & \\text{Re}(L(x)) \\end{pmatrix} < 0.$$ \n\nThis suggests the following systematic procedure for turning complex LMIs into real ones:\n• Decompose every complex matrix variable $X$ as\n $$X = X_1 + jX_2$$\n where $X_1$ and $X_2$ are real\n\n• Decompose every complex matrix coefficient $A$ as\n $$A = A_1 + jA_2$$\n where $A_1$ and $A_2$ are real\n\n• Carry out all complex matrix products. This yields affine expressions in $X_1, X_2$ for the real and imaginary parts of each LMI, and an equivalent real-valued LMI is readily derived from the above observation.\n\nFor LMIs without outer factor, a streamlined version of this procedure consists of replacing any occurrence of the matrix variable $X = X_1 + jX_2$ by\n\n$$\\begin{pmatrix} X_1 & X_2 \\\\ -X_2 & X_1 \\end{pmatrix}$$\n\nand any fixed matrix $A = A_1 + jA_2$, including real ones, by\n\n$$\\begin{pmatrix} A_1 & A_2 \\\\ -A_2 & A_1 \\end{pmatrix}.$$ \n\nFor instance, the real counterpart of the LMI system\n\n$$M^HXM < X, \\quad X = X^H > I$$\n\nreads (given the decompositions $M = M_1 + jM_2$ and $X = X_1 + jX_2$ with $M_j$, $X_j$ real):\n\n$$\\begin{pmatrix} M_1 & M_2 \\\\ -M_2 & M_1 \\end{pmatrix}^T \\begin{pmatrix} X_1 & X_2 \\\\ -X_2 & X_1 \\end{pmatrix} \\begin{pmatrix} M_1 & M_2 \\\\ -M_2 & M_1 \\end{pmatrix} < \\begin{pmatrix} X_1 & X_2 \\\\ -X_2 & X_1 \\end{pmatrix}$$\n\n$$\\begin{pmatrix} X_1 & X_2 \\\\ -X_2 & X_1 \\end{pmatrix} < I.$$\nNote that \\( X = X^H \\) in turn requires that \\( X_1 = X_1^H \\) and \\( X_2 + X_2^T = 0 \\). Consequently, \\( X_1 \\) and \\( X_2 \\) should be declared as symmetric and skew-symmetric matrix variables, respectively.\n\nAssuming, for instance, that \\( M \\in \\mathbb{C}^{5 \\times 5} \\), the LMI system (Equation 4-11) would be specified as follows:\n\n\\[\nM_1 = \\text{real}(M), \\quad M_2 = \\text{imag}(M) \\\\\nbigM = [M_1 \\ M_2; -M_2 \\ M_1] \\\\\n\\text{setlmis}([])\n\\]\n\n% declare \\( \\text{bigX} = [X_1 \\ X_2; -X_2 \\ X_1] \\) with \\( X_1 = X_1' \\) and \\( X_2 + X_2' = 0 \\):\n\n\\[\n[X_1,n_1,sX_1] = \\text{lmivar}(1, [5 \\ 1]) \\\\\n[X_2,n_2,sX_2] = \\text{lmivar}(3, \\text{skewdec}(5,n_1)) \\\\\nbigX = \\text{lmivar}(3, [sX_1 \\ sX_2; -sX_2 \\ sX_1])\n\\]\n\n% describe the real counterpart of (1.12):\n\n\\[\n\\text{lmiterm}([1 \\ 1 \\ 1 \\ 0],1) \\\\\n\\text{lmiterm}([-1 \\ 1 \\ 1 \\ \\text{bigX}],1,1) \\\\\n\\text{lmiterm}([2 \\ 1 \\ 1 \\ \\text{bigX}],\\text{bigM}',\\text{bigM}) \\\\\n\\text{lmiterm}([-2 \\ 1 \\ 1 \\ \\text{bigX}],1,1)\n\\]\n\n\\[\n\\text{lmis} = \\text{getlmis}\n\\]\n\nNote the three-step declaration of the structured matrix variable \\( \\text{bigX} \\),\n\n\\[\n\\text{bigX} = \\begin{pmatrix} X_1 & X_2 \\\\ -X_2 & X_1 \\end{pmatrix}.\n\\]\n\n1. Specify \\( X_1 \\) as a (real) symmetric matrix variable and save its structure description \\( sX_1 \\) as well as the number \\( n_1 \\) of decision variables used in \\( X_1 \\).\n\n2. Specify \\( X_2 \\) as a skew-symmetric matrix variable using Type 3 of \\text{lmivar} and the utility \\text{skewdec}. The command \\text{skewdec}(5,n_1) creates a 5-by-5 skew-symmetric structure depending on the decision variables \\( n_1 + 1, n_1 + 2, \\ldots \\)\n\n3. Define the structure of \\( \\text{bigX} \\) in terms of the structures \\( sX_1 \\) and \\( sX_2 \\) of \\( X_1 \\) and \\( X_2 \\).\n\nSee “Structured Matrix Variables” on page 4-31 for more details on such structure manipulations.\nSpecifying $c^T x$ Objectives for mincx\n\nThe LMI solver mincx minimizes linear objectives of the form $c^T x$ where $x$ is the vector of decision variables. In most control problems, however, such objectives are expressed in terms of the matrix variables rather than of $x$. Examples include $\\text{Trace}(X)$ where $X$ is a symmetric matrix variable, or $u^T X u$ where $u$ is a given vector.\n\nThe function defcx facilitates the derivation of the $c$ vector when the objective is an affine function of the matrix variables. For the sake of illustration, consider the linear objective\n\n$$\\text{Trace}(X) + x_0^T Px_0$$\n\nwhere $X$ and $P$ are two symmetric variables and $x_0$ is a given vector. If lmisys is the internal representation of the LMI system and if $x_0$, $X$, $P$ have been declared by\n\n```matlab\nx0 = [1;1]\nselmis([])\nX = lmivar(1,[3 0])\nP = lmivar(1,[2 1])\n:\n:\nlmisys = getlmis\n```\n\nthe $c$ vector such that $c^T x = \\text{Trace}(X) + x_0^T Px_0$ can be computed as follows:\n\n```matlab\nn = decnbr(lmisys)\nc = zeros(n,1)\nfor j=1:n,\n [Xj,Pj] = defcx(lmisys,j,X,P)\n c(j) = trace(Xj) + x0'*Pj*x0\nend\n```\n\nThe first command returns the number of decision variables in the problem and the second command dimensions $c$ accordingly. Then the for loop performs the following operations:\n\n1. Evaluate the matrix variables $X$ and $P$ when all entries of the decision vector $x$ are set to zero except $x_j = 1$. This operation is performed by the function defcx. Apart\nfrom `lmisys` and `j`, the inputs of `defcx` are the identifiers `X` and `P` of the variables involved in the objective, and the outputs `Xj` and `Pj` are the corresponding values.\n\n2. Evaluate the objective expression for `X := Xj` and `P := Pj`. This yields the `j`-th entry of `c` by definition.\n\nIn our example the result is\n\n```\nc =\n3\n1\n2\n1\n```\n\nOther objectives are handled similarly by editing the following generic skeleton:\n\n```\nn = decnbr( LMI system )\nc = zeros(n,1)\nfor j=1:n,\n [ matrix values ] = defcx( LMI system,j,\n matrix identifiers)\nc(j) = objective(matrix values)\nend\n```\n\n**Feasibility Radius**\n\nWhen solving LMI problems with `feasp`, `mincx`, or `gevp`, it is possible to constrain the solution `x` to lie in the ball\n\n```\nx^T x < R^2\n```\n\nwhere `R > 0` is called the *feasibility radius*. This specifies a maximum (Euclidean norm) magnitude for `x` and avoids getting solutions of very large norm. This may also speed up computations and improve numerical stability. Finally, the feasibility radius bound regularizes problems with redundant variable sets. In rough terms, the set of scalar variables is redundant when an equivalent problem could be formulated with a smaller number of variables.\n\nThe feasibility radius `R` is set by the third entry of the options vector of the LMI solvers. Its default value is `R = 10^9`. Setting `R` to a negative value means “no rigid bound,” in which case the feasibility radius is increased during the optimization if necessary. This “flexible bound” mode may yield solutions of large norms.\nWell-Posedness Issues\n\nThe LMI solvers used in the LMI Lab are based on interior-point optimization techniques. To compute feasible solutions, such techniques require that the system of LMI constraints be strictly feasible, that is, the feasible set has a nonempty interior. As a result, these solvers may encounter difficulty when the LMI constraints are feasible but not strictly feasible, that is, when the LMI\n\n\\[ L(x) \\leq 0 \\]\n\nhas solutions while\n\n\\[ L(x) < 0 \\]\n\nhas no solution.\n\nFor feasibility problems, this difficulty is automatically circumvented by \\texttt{feasp}, which reformulates the problem:\n\nFind \\( x \\) such that\n\n\\[ L(x) \\leq 0 \\]\n\nas:\n\nMinimize \\( t \\) subject to\n\n\\[ Lx < t \\times I. \\]\n\nIn this modified problem, the LMI constraint is always strictly feasible in \\( x, t \\) and the original LMI Equation 4-12 is feasible if and only if the global minimum \\( t_{\\text{min}} \\) of Equation 4-12 satisfies\n\n\\[ t_{\\text{min}} \\leq 0 \\]\n\nFor feasible but not strictly feasible problems, however, the computational effort is typically higher as \\texttt{feasp} strives to approach the global optimum \\( t_{\\text{min}} = 0 \\) to a high accuracy.\n\nFor the LMI problems addressed by \\texttt{mincx} and \\texttt{gevp}, nonstrict feasibility generally causes the solvers to fail and to return an “infeasibility” diagnosis. Although there is\nno universal remedy for this difficulty, it is sometimes possible to eliminate underlying\nalgebraic constraints to obtain a strictly feasible problem with fewer variables.\n\nAnother issue has to do with homogeneous feasibility problems such as\n\n\\[ A^T P + PA < 0, \\ P > 0 \\]\n\nWhile this problem is technically well-posed, the LMI optimization is likely to produce\nsolutions close to zero (the trivial solution of the nonstrict problem). To compute a\nnontrivial Lyapunov matrix and easily differentiate between feasibility and infeasibility,\nreplace the constraint \\( P > 0 \\) by \\( P > \\alpha I \\) with \\( \\alpha > 0 \\). Note that this does not alter the\nproblem due to its homogeneous nature.\n\n**Semi-Definite B(x) in gevp Problems**\n\nConsider the generalized eigenvalue minimization problem\n\nMinimize \\( \\lambda \\) subject to\n\n\\[ A(x) < \\lambda B(x), \\ B(x) > 0, \\ C(x) < 0. \\]\n\nTechnically, the positivity of \\( B(x) \\) for some \\( x \\in \\mathbb{R}^n \\) is required for the well-posedness of the\nproblem and the applicability of polynomial-time interior-point methods. Hence problems\nwhere\n\n\\[ B(x) = \\begin{pmatrix} B_1(x) & 0 \\\\ 0 & 0 \\end{pmatrix} \\]\n\nwith \\( B_1(x) > 0 \\) strictly feasible, cannot be directly solved with gevp. A simple remedy\nconsists of replacing the constraints\n\n\\[ A(x) < B(x), \\ B(x) > 0 \\]\n\nby\n\n\\[ A(x) < \\begin{pmatrix} Y & 0 \\\\ 0 & 0 \\end{pmatrix}, \\ Y < \\lambda B_1(x), \\ B_1(x) > 0 \\]\n\nwhere \\( Y \\) is an additional symmetric variable of proper dimensions. The resulting problem\nis equivalent to Equation 4-14 and can be solved directly with gevp.\nEfficiency and Complexity Issues\n\nAs explained in “Tools for Specifying and Solving LMIs” on page 4-2, the term-oriented description of LMIs used in the LMI Lab typically leads to higher efficiency than the canonical representation\n\n\\[ A_0 + x_1A_1 + ... + x_NA_N < 0. \\]\n\nThis is no longer true, however, when the number of variable terms is nearly equal to or greater than the number \\( N \\) of decision variables in the problem. If your LMI problem has few free scalar variables but many terms in each LMI, it is therefore preferable to rewrite it as Equation 4-15 and to specify it in this form. Each scalar variable \\( x_j \\) is then declared independently and the LMI terms are of the form \\( x_jA_j \\).\n\nIf \\( M \\) denotes the total row size of the LMI system and \\( N \\) the total number of scalar decision variables, the flop count per iteration for the feasp and mincx solvers is proportional to\n\n- \\( N^3 \\) when the least-squares problem is solved via. Cholesly factorization of the Hessian matrix (default) [2]\n- \\( M \\)-by-\\( N^2 \\) when numerical instabilities warrant the use of QR factorization instead\n\nWhile the theory guarantees a worst-case iteration count proportional to \\( M \\), the number of iterations actually performed grows slowly with \\( M \\) in most problems. Finally, while feasp and mincx are comparable in complexity, gevp typically demands more computational effort. Make sure that your LMI problem cannot be solved with mincx before using gevp.\n\nSolving \\( M + P^TXQ + Q^TX^TP < 0 \\)\n\nIn many output-feedback synthesis problems, the design can be performed in two steps:\n\n2. Given this Lyapunov function, derive the controller state-space matrices by solving an LMI of the form\n\n\\[ M + P^TXQ + Q^TX^TP < 0 \\]\n\nwhere \\( M, P, Q \\) are given matrices and \\( X \\) is an unstructured \\( m \\)-by-\\( n \\) matrix variable.\nIt turns out that a particular solution $X_c$ of Equation 4-16 can be computed via simple linear algebra manipulations [1]. Typically, $X_c$ corresponds to the center of the ellipsoid of matrices defined by Equation 4-16.\n\nThe function `basiclmi` returns the “explicit” solution $X_c$:\n\n$$X_c = \\text{basiclmi}(M,P,Q)$$\n\nSince this central solution sometimes has large norm, `basiclmi` also offers the option of computing an approximate least-norm solution of Equation 4-16. This is done by\n\n$$X = \\text{basiclmi}(M,P,Q,'Xmin')$$\n\nand involves LMI optimization to minimize $\\|X\\|$.\nBibliography\n\n\nAnalyzing Uncertainty Effects in Simulink\n\n- “Analyzing Uncertainty in Simulink” on page 5-2\n- “Simulink Blocks for Analyzing Uncertainty” on page 5-3\n- “Specify Uncertainty Using Uncertain State Space Blocks” on page 5-4\n- “Simulate Uncertainty Effects” on page 5-7\n- “Vary Uncertainty Values Using Individual Uncertain State Space Blocks” on page 5-8\n- “Vary Uncertainty Values Across Multiple Uncertain State Space Blocks” on page 5-14\n- “Computing Uncertain State-Space Models from Simulink Models” on page 5-19\n- “Obtain Uncertain State-Space Model from Simulink Model” on page 5-20\n- “Specify Uncertain Linearization for Core or Custom Simulink Blocks” on page 5-21\n- “Linearize Block to Uncertain Model” on page 5-24\n- “Using Uncertain Linearization for Analysis or Control Design” on page 5-26\n- “Analyzing Stability Margin of Simulink Models” on page 5-27\n- “Stability Margin of a Simulink Model” on page 5-29\nAnalyzing Uncertainty in Simulink\n\nRobust Control Toolbox software provides tools to model uncertainty in Simulink®. Using these tools, you can analyze how the uncertainty impacts the time- and frequency-domain behavior of the Simulink model.\n\nThe Uncertain State Space block, included in the Robust Control Toolbox block library, is a convenient way to incorporate uncertainty information in a Simulink model. For more information, see “Specify Uncertainty Using Uncertain State Space Blocks” on page 5-4. Using this block, you can perform the following types of analysis:\n\n- Vary the uncertainty and see how it affects the time responses (Monte Carlo analysis). See “Simulate Uncertainty Effects” on page 5-7.\n- Analyze the effects of uncertainty on the linearized dynamics:\n - If the operating point does not depend on the parameter uncertainty, use `ulinearize` to obtain an uncertain state-space model. You can then use `usample` to sample the uncertain variables and obtain a family of LTI models.\n - If the operating point depends on the parameter uncertainty, use `usample` to sample the uncertainty and then use the Simulink Control Design™ `linearize` command to compute the linearized dynamics for each uncertainty value.\n\n See “How to Vary Uncertainty Values” on page 5-7 and “Obtain Uncertain State-Space Model from Simulink Model” on page 5-20.\n- Compute an uncertain linearization, i.e., obtain an uncertain state-space model (`uss` object) that combines the uncertain variables with the linearized dynamics. You can use this model to perform worst-case robustness analysis. See “Obtain Uncertain State-Space Model from Simulink Model” on page 5-20.\n\nIf you cannot use Uncertain State Space blocks in the Simulink model because you share the model or generate code, you can still compute an uncertain linearization by specifying a block to linearize to an uncertain variable. For example, you can specify a gain block to linearize to an uncertain real parameter (`ureal`). See “Specify Uncertain Linearization for Core or Custom Simulink Blocks” on page 5-21. You can then use the uncertain state-space model to analyze robustness in the linear operating range.\nSimulink Blocks for Analyzing Uncertainty\n\nRobust Control Toolbox software provides an Uncertain State Space block to model parametric and dynamic uncertainty in Simulink. The block library also contains a MultiPlot Graph block that you use with the Uncertain State Space block to plot and visualize Monte Carlo simulation responses.\n\nTo open the Robust Control Toolbox block library, type the following command at the MATLAB prompt:\n\nRCTblocks\n\nThe block library opens, as shown in the following figure.\n\nAlternatively, on the Home tab, click Simulink Library to launch to Library Browser. In the Library Browser, select Robust Control Toolbox.\nSpecify Uncertainty Using Uncertain State Space Blocks\n\n- “How to Specify Uncertainty in Uncertain State Space Blocks” on page 5-4\n- “Next Steps” on page 5-6\n\nHow to Specify Uncertainty in Uncertain State Space Blocks\n\nSpecifying uncertainty in the Uncertain State Space block makes the uncertainty a part of the Simulink model and affects both simulation and linearization. Use this approach to vary the uncertainty and analyze the effects on simulation or linearization.\n\nTo specify uncertainty in the Uncertain State Space block:\n\n1. Drag and drop an Uncertain State Space block from the Robust Control Toolbox block library into a Simulink model. For more information on how to open the block library, see “Simulink Blocks for Analyzing Uncertainty” on page 5-3.\n2 In the Simulink model, double-click the Uncertain State Space block to open the Function Block Parameters: Uncertain State Space dialog box, as shown in the following figure.\nSpecify an uncertain state-space model in the **Uncertain system variable (uss)** field. The model must be an `uss` object or any other model that can be converted to `uss`, such as `umat`, `ureal` and `ultidyn`. The model depends on a set of uncertain variables (`ureal` or `ultidyn`) and you can specify the model as one of the following:\n\n- Function or expression that evaluates to an `uss` model. For example, `ss(ureal('a',-5),5,1,1)`.\n- Variable, defined in the MATLAB workspace. For example, `unc_sys`, where `unc_sys` is defined as `ss(ureal('a',-5),5,1,1)` in the workspace.\n\nSpecify values for the uncertain variables that the uncertain state-space model you specify in step 3 uses. For example, if you specify the uncertain system as `ureal('g',2)*tf(1,[ureal('tau'),1])`, then you must specify values for the uncertain variables `g` and `tau`. To do so, enter a structure with fields `g` and `tau` in the **Uncertainty value (struct or [] to use nominal value)** field. You can also enter `[]` to use the nominal values of the uncertain parameters `g` and `tau`.\n\nTip: You can also use this field to vary the uncertainty values for performing Monte Carlo simulation. For more information, see “Simulate Uncertainty Effects” on page 5-7.\n\n(Optional) Specify the initial states of the nominal and uncertain dynamics in the **Initial states (nominal dynamics)** and **Initial states (uncertain dynamics)** fields, respectively.\n\nFor more information on the block parameters, see the **Uncertain State Space** block reference page.\n\n**Next Steps**\n\nAfter you specify uncertainty in **Uncertain State Space** blocks, you can perform one of the following:\n\n- Simulate the model using nominal, manually-defined or random values, as described in “Simulate Uncertainty Effects” on page 5-7.\n- Perform an uncertain linearization, as described in “Obtain Uncertain State-Space Model from Simulink Model” on page 5-20.\nSimulate Uncertainty Effects\n\n- “How to Simulate Effects of Uncertainty” on page 5-7\n- “How to Vary Uncertainty Values” on page 5-7\n\nHow to Simulate Effects of Uncertainty\n\nAs described in “Specify Uncertainty Using Uncertain State Space Blocks” on page 5-4, the uncertain state-space model you specify in the Uncertain State Space block depends on a set of uncertain variables (ureal or ultidyn objects.) You can simulate the model using nominal value of these uncertain variables. Additionally, you can sample these uncertain variables and simulate the model for various values in the uncertainty range (Monte Carlo simulation.) For more information, see “How to Vary Uncertainty Values” on page 5-7. You can view and compare the simulation results for various sample values of uncertainty using the MultiPlot Graph block.\n\nHow to Vary Uncertainty Values\n\nThere are two ways to control the uncertainty values using the Uncertainty value (struct or [] to use nominal value) field of the Uncertain State Space block parameters dialog box:\n\n- For simple models with few uncertain variables or one Uncertain State Space block, type the value in the Uncertain State Space block itself. For more information, see “Vary Uncertainty Values Using Individual Uncertain State Space Blocks” on page 5-8.\n- For complex models with large number of uncertain variables or Uncertain State Space blocks, use a single data structure for all uncertain variables referenced by the model. Using this approach, you can collectively control the values of all or a subset of uncertain variables and toggle between nominal and user-defined values from the MATLAB prompt. For more information, see “Vary Uncertainty Values Across Multiple Uncertain State Space Blocks” on page 5-14.\nVary Uncertainty Values Using Individual Uncertain State Space Blocks\n\nThis example shows the workflow for varying uncertainty values using individual Uncertain State Space blocks in a Simulink model. Use this approach for simple models with few uncertain variables or one Uncertain State Space block.\n\nThis section uses a simple Simulink model to provide step-by-step instructions for:\n\n• Toggling between nominal, manually defined and randomly-generated uncertainty values associated with the Uncertain State Space block.\n• Simulating the model's responses for these uncertainty values.\n\n1. Open the Simulink model rct_sim_ex1.\n\n rct_sim_ex1\n\n The model contains an Uncertain State Space block called Uncertain System, as shown in the following figure.\n\n \n\n2. Double-click the Uncertain System block to open the Function Block Parameters dialog box.\nThe Uncertain System block uses the uncertain system variable `unc_sys`. This variable is defined in the Model workspace as `unc_sys=`\nss(ureal('a',-1,'Range',[-2 -.5]),1,5,0)*(1+0.1*input_unc). The uncertain model depends on a single uncertain variable named a. The **Uncertainty value** field specifies to use nominal value of the uncertain variable a.\n\nClick **OK** to close the dialog box.\n\n3 Click to simulate the model.\n\nThe software uses the nominal value of a during simulation. After the simulation completes, the **MultiPlot Graph** shows the following plot.\n\n4 To simulate the model using a manually defined value of a:\n\n a Double-click the **Uncertain State Space** block, and enter `struct('a',-0.3)` in the **Uncertainty value** field.\nClick to simulate the model.\n\nThe MultiPlot Graph shows the following responses, corresponding to the nominal and manually-defined values of $a$. \nPick a random value of \\( a \\) in its uncertainty range. To do so, double-click the Uncertain State Space block, and type `usample(ufind(unc_sys))` in the Uncertainty value field.\n\nAnalyze the uncertainty effects by simulating the model ten times using the following commands:\nfor i=1:10;\n sim('rct_sim_ex1',10);\nend\n\nDuring simulation, the software samples the uncertain variable $a$ in its uncertainty range $[-2, -0.5]$ and shows the simulated response for each sample value. The plots cycle through seven different colors, and the last response appears in red.\n\n**Tip:** You can clear the plots in the MultiPlot Graph block before you run the simulation.\nVary Uncertainty Values Across Multiple Uncertain State Space Blocks\n\nThis example shows the workflow for varying uncertainty values across multiple Uncertain State Space blocks in a Simulink model. Use this approach for complex models with a large number of uncertain variables or Uncertain State Space blocks.\n\nThis section uses a Simulink model to provide step-by-step instructions for toggling between nominal and user-defined uncertainty values at the MATLAB prompt.\n\n1. Open the Simulink model `rct_sim_ex2`.\n\n `rct_sim_ex2`\n\n The model contains two Uncertain State Space blocks, as shown in the following figure.\n\n \n\n The Unmodeled dynamics and First order with uncertain pole blocks depend on the uncertain variables `input_unc` and `a`.\n\n2. Double-click the Unmodeled dynamics block to open the block parameters dialog box. The Uncertainty value field contains the variable `val_all`. Similarly, the Uncertainty value field in the First order with uncertain pole block parameters dialog contains the variable `val_all`. You use this variable to vary the uncertain variable values across both the Uncertain State Space blocks.\nVary Uncertainty Values Across Multiple Uncertain State Space Blocks\n\n**Note** When defining `val_all`, you can enter only a subset of uncertain variables referenced by the model in the structure. When you do not specify some uncertain variables, the software uses their nominal value during simulation.\n\n3 At the MATLAB prompt, specify `val_all = []`; and click  to simulate the model.\n\nThe software uses the nominal values of the uncertain variables `a` and `input_unc` during simulation. After the simulation completes, the MultiPlot Graph block shows the following figure.\n4 Generate random samples of uncertainty values:\n\n- Find all Uncertain State Space blocks and associated uncertain variables in the model.\n\n\\[\n\\text{uvars=ufind('rct_sim_ex2')}\\]\n\nMATLAB returns the following result:\n\n\\[\n\\text{uvars} = \\\\\n\\quad a: [1x1 \\text{ ureal}] \\\\\n\\quad \\text{input_unc: [1x1 ultidyn]}\n\\]\nb Randomly sample the uncertain variables.\n\n\\[\n\\text{val\\_all} = \\text{usample(uvars)}\n\\]\n\nMATLAB returns the following result:\n\n\\[\n\\text{val\\_all} = \\\\\n\\begin{align*}\n\\text{a:} & \\quad -1.1167 \\\\\n\\text{input\\_unc:} & \\quad [1\\times1 \\text{ ss}]\n\\end{align*}\n\\]\n\nThe structure `val_all` contains sample values of the uncertain variables `a` and `input_unc`. The software samples the values within the specified uncertainty ranges for `a` and `input_unc`.\n\n5 Simulate the model for the uncertainty values `val_all`. By repeating the process inside a for-loop, you can assess how uncertainty affects the model responses. For example, perform 10 simulations using random uncertainty values:\n\n```\nfor i=1:10;\n \\text{val\\_all} = \\text{usample(uvars)}\n \\text{sim('rct_sim_ex2',10)};\nend\n```\n\nDuring each simulation, the software samples values of the uncertain variables `input_unc` and `a` and plots the response for the sampled values. The MultiPlot Graph block shows the following responses obtained using random sample values of uncertain variables.\nAnalyzing Uncertainty Effects in Simulink\nComputing Uncertain State-Space Models from Simulink Models\n\nWhen you have the Simulink Control Design software, you can compute an uncertain linearization, i.e., an uncertain state-space model (uss) combining the uncertain variables with linearized dynamics. Use the uss model to perform linear analysis and robust control design.\n\nYou can compute an uncertain linearization in one of the following ways:\n\n- Using the ulinearize command, as described in “Obtain Uncertain State-Space Model from Simulink Model” on page 5-20.\n- Using the Simulink Control Design linearize command, as described in “Specify Uncertain Linearization for Core or Custom Simulink Blocks” on page 5-21.\nObtain Uncertain State-Space Model from Simulink Model\n\nTo obtain an uncertain state-space model from a model that contains Uncertain State Space blocks, use the following steps:\n\n**Note** If you do not have Uncertain State Space blocks in the model but still want to obtain an uncertain state-space model, see “Specify Uncertain Linearization for Core or Custom Simulink Blocks” on page 5-21.\n\n1. (Prerequisite) Create or open the Simulink model.\n2. (Prerequisite) In the Simulink model, specify the linearization input and output points using Simulink Control Design `getlinio` or `linio` commands. For more information, see “Specifying Portion of Model to Linearize” in the Simulink Control Design documentation.\n3. (Prerequisite) If you have not already done so, specify uncertainty in the Simulink model as described in “Specify Uncertainty Using Uncertain State Space Blocks” on page 5-4.\n\n**Note** The software does not evaluate the uncertain variables during linearization. Thus, the value of the uncertainty does not affect the linearization.\n\n4. Run `ulinearize` to compute an uncertain linearization. This command returns an `uss` model.\n\n**Note** If you use the Simulink Control Design `linearize` command, the Uncertain State Space blocks linearize to their nominal value.\n\nFor more information on linearization and how to evaluate the results, see “Linearization Basics” in the Simulink Control Design documentation.\n\nFor an example of how to use the Simulink Control Design `linearize` command, see Linearization of Simulink Models with Uncertainty.\nSpecify Uncertain Linearization for Core or Custom Simulink Blocks\n\nIn some cases, you cannot use Uncertain State Space blocks in the Simulink model because you share the model or generate code. You can still account for uncertainty in your linear analysis without specifying uncertainty using Uncertain State Space blocks. Robust Control Toolbox lets you specify a core or custom Simulink block to linearize to an uncertain variable. The linearization produces an uncertain state-space uss model. The specified uncertainty associates only with the block and does not affect the model simulation. For more information, see “Controlling Block Linearization” in the Simulink Control Design documentation.\n\nNote If you have Uncertain State Space blocks in the model and want to obtain an uncertain state-space model, see “Obtain Uncertain State-Space Model from Simulink Model” on page 5-20.\n\nTo specify blocks to linearize to uncertain variables and obtain an uncertain state-space model:\n\n1 (Prerequisites) Create or open the Simulink model. Specify linearization input and output points using the Simulink Control Design getlinio or linio commands.\n\n For this example, you can open the model rct_ulinearize_builtin.\n\n2 Specify a block to linearize to an uncertain variable:\n\n a Right-click the block and select Linear Analysis > Specify Selected Block Linearization.\nThis action opens the Block Linearization Specification dialog box.\nIn the Block Linearization Specification dialog box, select the **Specify block linearization using one of the following**: check box. Selecting this check box lets you to specify an uncertain variable for linearization.\n\nThis check box defaults to **MATLAB Expression** in the drop-down menu. This option lets you specify the block to linearize to an uncertain variable using a MATLAB expression containing Robust Control Toolbox functions. To learn more about the options, see “Controlling Block Linearization” in the Simulink Control Design documentation.\n\nIn the **Enter an expression to specify the linearization of the Simulink block** field, enter an expression, which must evaluate to an uncertain variable or uncertain model, such as **ureal**, **umat**, **ultidyn** or **uss**.\n\nClick **OK** to save the changes.\n\n**Note** You can also specify a block to linearize to an uncertain variable at the command line. For an example, see “Linearize Block to Uncertain Model” on page 5-24.\n\n3 Run the **linearize** command to compute an uncertain linearization. This command returns an **uss** model.\n\nFor more information on linearization and how to validate linearization results, see “Linearization Basics” in the Simulink Control Design documentation.\n\nFor an example of how to use the **linearize** command to compute an uncertain linearization, see Linearization of Simulink Models with Uncertainty.\nLinearize Block to Uncertain Model\n\nThis example demonstrates how to specify a core Simulink block to linearize to an uncertain variable and compute an uncertain linearization at the command line. To learn how to perform this task using the user interface, see “Specify Uncertain Linearization for Core or Custom Simulink Blocks” on page 5-21.\n\n1. Open the Simulink model.\n ```matlab\n slexAircraftExample\n ```\n\n2. Double-click the Aircraft Dynamics Model block to view the subsystem.\n\n3. Specify uncertain variables for the gain blocks $Z_d$ and $M_w$ in the Aircraft Dynamics Model subsystem.\n ```matlab\n spec.Type = 'Expression';\n spec.Specification = ureal('Zd',-63.9979,'Percentage',20);\n BlockSubs(1) = struct('Name','slexAircraftExample/Aircraft Dynamics Model/Gain5','Value',spec);\n ```\nspec.Specification = ureal('Mw',-63.9979,'Percentage',20);\nBlockSubs(2) = struct('Name','slexAircraftExample/Aircraft Dynamics Model/Gain4','Value',spec);\n\n4 Compute the uncertain linearization.\n\nmdl = 'slexAircraftExample';\nsys = linearize(mdl,BlockSubs)\n\nsys =\n\nUncertain continuous-time state-space model with 1 outputs, 1 inputs, 7 states.\nThe model uncertainty consists of the following blocks:\n- Mw: Uncertain real, nominal = -64, variability = [-20,20]%, 1 occurrences\n- Zd: Uncertain real, nominal = -64, variability = [-20,20]%, 1 occurrences\n\nType \"sys.NominalValue\" to see the nominal value, \"get(sys)\" to see all properties, and \"sys.Uncertainty\" to interact with the uncertain elements.\n\nsys is an uncertain state-space (uss) model.\nUsing Uncertain Linearization for Analysis or Control Design\n\nAfter computing an uncertain linearization, you can perform one of the following:\n\n- Perform robustness analysis.\n- Perform robust control design.\nAnalyzing Stability Margin of Simulink Models\n\nRobust Control Toolbox provides the `loopmargin` command to analyze the stability margins of LTI models created in MATLAB and Simulink models. To use `loopmargin` with Simulink models, you must have the Simulink Control Design software. This section describes the difference between the MATLAB and Simulink approaches of using `loopmargin` and the workflow for computing the stability margin of Simulink models. For more information on how to analyze the stability margins of LTI models, see “MIMO Robustness Analysis”.\n\nHow Stability Margin Analysis Using Loopmargin Differs Between Simulink and LTI Models\n\nWhen analyzing stability margins of LTI models using the syntax `[cm, dm, mm] = loopmargin(P, C)`, the software assumes the input and output of the linear plant `P` as the margin analysis points, as shown in the following figure.\n\nAnalyzing stability margin of Simulink models differs from analyzing stability margin of LTI models because you can enter specific margin analysis points in the Simulink model. For more information on how to assign margin analysis points in Simulink models, see the “Usage with Simulink” section of the `loopmargin` reference page.\n\nStability Margin of Simulink Model\n\nThe `loopmargin` command computes the following types of stability margins:\n• Loop-at-a-time classical gain and phase margins\n• Loop-at-a-time disk margins\n• Multi-loop disk margin\n\nTo learn more about these stability margins, see the “Algorithms” section of the loopmargin reference page.\n\nThe loopmargin command computes the stability margin based on linearization of Simulink models. To compute stability margins of a Simulink model:\n\n1 Specify the block where you want to define a margin analysis point.\n2 Specify the output port of the block where you want the margin analysis point.\n\n The software performs the analysis by opening the loop at all specified margin analysis point.\n3 Use the loopmargin command to compute the stability margins at the margin analysis point.\n\nOptionally, you can compare the classical gain and phase margins obtained using loopmargin with the stability margins computed for the linearized model. The results using the two approaches should match for simple SISO models. For MIMO models, the loopmargin command provides richer robustness information. For an example, see “Stability Margin of a Simulink Model” on page 5-29.\n\nAdditionally, you can compute stability margins by specifying multiple margin analysis points and multiple operating points. For an example, see Loop Margins for an Airframe Autopilot.\nStability Margin of a Simulink Model\n\nThis example illustrates how to compute the stability margins of the `airframemargin` model and compare the results with stability margins computed using the linearized model.\n\n1. Open the Simulink model:\n ```matlab\n airframemargin\n ```\n\n2. Define a margin analysis point at the output of the Airframe Model block.\n ```matlab\n block1 = 'airframemargin/Airframe Model';\n ```\n\n3. Specify the output `az` of the Airframe Model block as a margin analysis point.\n ```matlab\n port1 = 1;\n ```\n\n ```matlab\n [cm, dm, mm] = loopmargin('airframemargin', block1, port1);\n ```\n\n5. View the classical gain and phase margins.\n ```matlab\n cm\n ```\n6 Compare the classical gain and phase margins cm with stability margins of the linearized model computed using allmargin:\n\n```matlab\n% Define linearization I/O points.\nio = linio('airframemargin/Airframe Model',1,'looptransfer');\n% Linearize the model.\nlin_sys = linearize('airframemargin',io);\n% Compute gain and phase margins.\ncm_lin = allmargin(-lin_sys)\n```\n\n```matlab\ncm_lin =\n\nGainMargin: [4.5652 2.5055e+003]\nGMFrequency: [7.1979 314.1593]\nPhaseMargin: 65.1907\nPMFrequency: 2.1463\nDelayMargin: 53.0113\nDMFrequency: 2.1463\nStable: 1\n```\n\nThe gain and phase margins, cm and cm_lin, computed using the two approaches match."}}},{"rowIdx":289,"cells":{"id":{"kind":"string","value":"443d983401b7d2dcb30928bcd491881e6b00672d"},"text":{"kind":"string","value":"Leveraging software product lines engineering in the construction of domain specific languages\n\nDavid Fernando Méndez Acuña\n\nTo cite this version:\n\n\nHAL Id: tel-01427187\nhttps://tel.archives-ouvertes.fr/tel-01427187v2\nSubmitted on 23 Aug 2017\n\nHAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.\n\nL’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.\nLeveraging Software Product Lines Engineering in the Construction of Domain Specific Languages\n## Contents\n\n<table>\n<thead>\n<tr>\n<th>Section</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Introduction en français</strong></td>\n<td>vii</td>\n</tr>\n<tr>\n<td>Contexte scientifique</td>\n<td>vii</td>\n</tr>\n<tr>\n<td>Problématique</td>\n<td>vii</td>\n</tr>\n<tr>\n<td>Contributions</td>\n<td>ix</td>\n</tr>\n<tr>\n<td>Contexte d’application</td>\n<td>xi</td>\n</tr>\n<tr>\n<td><strong>1 Introduction</strong></td>\n<td>1</td>\n</tr>\n<tr>\n<td>1.1 Research Context</td>\n<td>1</td>\n</tr>\n<tr>\n<td>1.2 Problem Statement</td>\n<td>1</td>\n</tr>\n<tr>\n<td>1.3 Contributions</td>\n<td>3</td>\n</tr>\n<tr>\n<td>1.4 Thesis’ Realization Context</td>\n<td>5</td>\n</tr>\n<tr>\n<td>1.5 Outline</td>\n<td>5</td>\n</tr>\n<tr>\n<td><strong>I Preliminaries</strong></td>\n<td>7</td>\n</tr>\n<tr>\n<td><strong>2 Background</strong></td>\n<td>9</td>\n</tr>\n<tr>\n<td>2.1 Domain-Specific Languages (DSLs)</td>\n<td>9</td>\n</tr>\n<tr>\n<td>2.1.1 Implementation Concerns for DSLs</td>\n<td>9</td>\n</tr>\n<tr>\n<td>2.1.2 Technological Spaces for the Implementation of DSLs</td>\n<td>9</td>\n</tr>\n<tr>\n<td>2.1.3 External versus Internal DSLs</td>\n<td>11</td>\n</tr>\n<tr>\n<td>2.1.4 Language Workbenches</td>\n<td>12</td>\n</tr>\n<tr>\n<td>2.2 Software Product Lines Engineering (SPLE)</td>\n<td>12</td>\n</tr>\n<tr>\n<td>2.3 Summary</td>\n<td>13</td>\n</tr>\n<tr>\n<td><strong>3 State of the Art: A Literature Review on Language Product Lines</strong></td>\n<td>15</td>\n</tr>\n</tbody>\n</table>\nContents\n\n3.1 Related Surveys and Literature Reviews ........................................... 16\n3.2 Research Method .................................................................................. 17\n3.3 Results ................................................................................................. 19\n 3.3.1 The Life-Cycle of a Language Product Line ...................................... 20\n 3.3.2 Current Support for the Language Product Lines’ Life-Cycle .......... 27\n 3.3.3 Mapping Approaches and Technological Spaces ......................... 39\n3.4 Open Issues in Language Product Line Engineering ............................. 42\n 3.4.1 Open Issues in Top-Down Language Product Lines .................... 42\n 3.4.2 Open Issues in Bottom-Up Language Product Lines .................... 46\n3.5 Threats to Validity ................................................................................ 47\n3.6 Summary ............................................................................................. 49\n\nII Contributions ....................................................................................... 51\n\n4 Foreword to the Contributions ............................................................... 53\n 4.1 Scientific Scope: Addressed Open Issues ........................................... 53\n 4.2 Technological Scope: Supported Technological Space ....................... 55\n\n5 Facilities to Support Top-Down Language Product Lines ......................... 57\n 5.1 Meta-language Facilities for Language Product Lines ....................... 57\n 5.1.1 Supporting Languages Modularization ....................................... 57\n 5.1.2 Supporting Languages Variability Management .......................... 66\n 5.2 Methodologies for Top-Down Language Product Lines ..................... 71\n 5.2.1 Abstract Syntax Engineering .................................................... 72\n 5.2.2 Semantics Engineering .............................................................. 82\n 5.3 Summary ............................................................................................. 84\n\n6 Reverse Engineering for Bottom-Up Language Product Lines ................... 85\n 6.1 Approach Overview ........................................................................... 87\n 6.2 Recovering a Language Modular Design ........................................... 87\n 6.3 Synthesizing Language Variability Models ......................................... 92\n 6.4 Summary ............................................................................................. 93\n\nIII Implementation and Validation ............................................................. 95\n\n7 Implementation: The Puzzle Toolkit ......................................................... 97\n 7.1 Using EMF, K3, and Mélange to Specify DSLs .................................... 97\n 7.2 Capabilities of Puzzle ........................................................................ 99\n 7.2.1 Capabilities to Support Top-Down Language Product Lines ....... 100\n 7.2.2 Capabilities to Support Bottom-Up Language Product Lines ....... 105\n 7.3 Architecture ....................................................................................... 108\n8 Validation: Case Studies\n\n8.1 Revisiting the Modular Design of UML\n 8.1.1 Problem: UML is a Composition of Several “Language Units”\n 8.1.2 Solution: Language Interfaces\n\n8.2 Logo for Progressive Programming Learning\n 8.2.1 Problem’s Description: Learning Sequences and DSL Variants\n 8.2.2 Solution: A Top-Down Language Product Line\n\n8.3 Reverse-Engineering a Language Product Line for FSMs\n 8.3.1 Problem Description: Several Formalisms for FSMs\n 8.3.2 Solution: Reverse-Engineering a Language Product Line\n\n8.4 Summary\nIntroduction en français\n\nContexte scientifique\n\n\nLa figure 1.1 présente un aperçu du processus de développement logiciel basé sur des langages dédiés [7]. Dans ce cadre, il y a trois types d’acteurs : concepteurs des langages, ingénieurs des systèmes, et utilisateurs finaux [3]. Les concepteurs des langages sont des informaticiens qui possèdent des compétences techniques pour la mise en œuvre de langages dédiés [8]. À travers un processus d’analyse du domaine et conception de langages, ils transforment les connaissances du domaine en forme de concepts de langage. Les ingénieurs des systèmes sont des développeurs de logiciels et du matériel qu’utilisent des langages dédiés pour construire un système concret. Finalement, les utilisateurs finaux sont ceux que profitent des fonctionnalités funis par les systèmes.\n\nLa notion de “systèmes logiciels” n’est pas limitée aux applications purement logicielles. Dans le cadre de cette thèse, nous adoptons une vision plus large de l’ingénierie de systèmes qui inclut aussi des systèmes cyber-physiques tels que les avions ou les trains.\n\nProblématique\n\nMalgré les avantages fournis par l’usage des langages dédiés, cette approche présente des inconvénients qui remettent en question sa pertinence dans des projets réels de développement.\nL’un de ces inconvénients est le coût de la construction des langages dédiés. La définition et l’outillage de ces langages est une tâche complexe qui prend du temps et qui requiert des compétences techniques spécialisées [3]. Les concepteurs des langages doivent maîtriser plusieurs outils et passer beaucoup de temps à définir des artefacts comme la grammaire, interprétateurs ou les compilateurs. Cela vaut-il la peine de construire un langage dédié ? Il s’agit d’une question laquelle il n’est pas toujours facile de répondre [9].\n\nLe processus de développement des langages dédiés devient encore plus complexe lorsque nous prenons en compte le fait que les langages dédiés peuvent avoir plusieurs dialectes. Un dialecte est une variante d’un langage qui introduit des différences au niveau de la syntaxe et/ou de la sémantique [10]. Ce type de variantes apparaît dans deux situations. La première situation est celle dans laquelle un même formalisme est utilisé pour la modélisation de plusieurs domaines. Par exemple, les machines à état ont été utilisées comme formalisme de modélisation dans une grande variété de langages dédiés conçus pour des objectifs différents tels que la définition de règles de navigation dans des interfaces graphiques [4] et la construction des jeux vidéo [11]. Ces langages utilisent les concepts classiques liés aux\nmachines à état comme État ou Transition. Cependant, chaque langage adapte ces concepts pour ses besoins particuliers.\n\nLa deuxième situation qui favorise l’apparition des variantes des langages dédiés est associée aux domaines complexes comprenant plusieurs aspects divergents. Dans ce cas, l’outillage qui supporte le domaine est un ensemble de langages dédiés différents (un langage pour chaque aspect) qui partagent quelques concepts. Par exemple, à cause de sa complexité, le domaine de gestion des lignes de trains requiert plusieurs langages dédiés comme : (1) celui présenté par James et al. [12] que permet la spécification et la vérification de plannings des systèmes de trains, et (2) celui présenté par Iliasov et al. [13] qui facilite la spécification et la validation de la capacité et la sécurité du système. Ces langages dédiés partagent quelques concepts comme la notion de train et du rail. Cependant, chaque langage fournit d’autres concepts liés à son objectif particulier ainsi comme une sémantique spécialisée.\n\nLe phénomène des variantes dans les langages dédiés montre le pouvoir d’abstraction fourni par des formalismes tels que les machines à état ou des réseaux de Petri qui, avec quelques adaptations, peuvent être utiles dans plusieurs domaines. En outre, ce phénomène met en évidence la façon dont l’usage des langages dédiés peut proportionner la séparation des préoccupations dans un domaine, à travers de la définition des langages différents pour traiter chaque aspect du domaine. Néanmoins, la construction d’un ensemble de variantes de langages (a.k.a. une famille de langages) implique deux défis. Le premier défi est la réutilisation des parties communes entre les variantes : les concepteurs des langages doivent réutiliser autant de définitions que possible afin de réduire au maximum la mise en œuvre en partant de zéro dans la construction des variantes [14]. Le deuxième défi est la gestion des différences de chaque variante : les concepteurs des langages doivent garantir que chaque variante fournisse les particularités propres à son contexte d’application.\n\nDans cette thèse, nous proposons une réponse à la question de recherche suivante :\n\n**Question de recherche:** Comment augmenter la réutilisation et gérer la variabilité durant la construction de familles de langages dédiés ?\n\n**Contributions**\n\nAfin de répondre à la question de recherche précédemment énoncée, la communauté de recherche autour de l’ingénierie des langages a proposé l’usage des lignes de produits. En conséquence, la notion de lignes de langages a récemment émergé. Une ligne de langages est une ligne de produits où les produits sont des langages [14, 15]. Le principal but dans les lignes de langages est la définition indépendente de morceaux de langage. Ces morceaux peuvent être combinées de manières différentes pour configurer des langages adaptés aux situations spécifiques.\nD’une manière similaire aux lignes de produits, les lignes de langages peuvent être construites à partir de deux approches différentes: top-down et bottom-up comme illustré par la figure 2. Dans l’approche top-down, les lignes de langages sont conçues et mises en œuvre au travers d’un processus d’analyse du domaine où les connaissances du domaine sont utilisées pour définir un ensemble de modules de langage qui réalisent les caractéristiques de la ligne de langages. En outre, les connaissances du domaine sont aussi utilisées pour représenter la variabilité de la ligne de langages à travers des modèles bien structurés qui, en plus, servent à configurer des langages particuliers. Dans l’approche bottom-up, les lignes des langages sont construites à partir d’un ensemble de variantes des langages existant au travers de techniques d’ingénierie inverse. Ces techniques doivent fournir des mécanismes pour : (1) récupérer un design et une implémentation modulaire qui comprenne tous les concepts de langage existants dans les variantes, et (2) synthétiser les modèles de variabilité qui capturent les différences entre les variantes.\n\nÀ partir des approches précédemment énoncées, nous proposons deux contributions :\n\n1) Des facilités pour supporter l’approche top-down. Comme première contribution, nous proposons un ensemble de facilités pour supporter la construction de lignes de langages à travers de l’approche top-down. En particulier, nous proposons une approche de modularisation des langages qui permet la décomposition des langages dédiés comme modules de langages interdépendants. En plus, nous introduisons une\nstratégie de modélisation pour représenter la variabilité dans une ligne de langages.\n\nCes facilités sont accompagnées d’un ensemble d’outils méthodologiques pour guider le processus de développement.\n\n(2) **Des techniques d’ingénierie inverse pour supporter l’approche bottom-up.** Comme deuxième contribution, nous proposons une technique d’ingénierie inverse pour construire, de manière automatique, une ligne de langages à partir d’un ensemble de variantes de langages existantes. La technique proposée inclut : (1) un mécanisme pour récupérer un design et une implémentation modulaire pour la ligne de produit à partir des concepts de langages existants dans les variantes, et (2) une approche pour synthétiser un modèle de variabilité qui représente les contraintes dont les modules des langages peuvent être combinés.\n\n**Contexte d’application**\n\nCette thèse a été rendu possible grâce à plusieurs partenariats. Les besoins de ces partenariats ont guidé les contributions de la thèse. En outre, ces besoins ont été utiles pour la validation des idées proposées.\n\nLe premier partenariat c’est le projet **VaryMDE**\\(^1\\), qui est une collaboration industrielle entre l’INRIA et Thales. Le but du projet est de concevoir des mécanismes pour gérer la variabilité qui émerge pendant le processus d’ingénierie logicielle chez Thales. En particulier, le projet étude la variabilité au niveau des modèles utilisés pendant le processus de développement logiciel, ainsi que la variabilité au niveau des langages utilisés pour écrire les modèles. Tandis que la thèse de Ferreira [16] propose une solution pour le premier type de variabilité, dans cette thèse nous proposons une solution pour le deuxième.\n\nLe deuxième partenariat c’est le projet **GEMOC**\\(^2\\). Le but du project est de fournir un ensemble d’outils pour supporter la coordination entre les différents langages utilisés dans la construction d’un même système. Notre interaction avec le projet GEMOC nous a permis de partager des idées avec des experts dans le domaine de l’ingénierie des langages.\n\nFinalement, le troisième partenariat c’est le projet **RELATE**\\(^3\\). RELATE est un projet Marie Curie et son but c’est de former des docteurs au tour des technologies d’informatique dans les nouages. La contribution la plus importante de ce partenariat c’était sa plateforme pédagogique qui nous a fourni un environnement assez riche à travers de plusieurs séminaires dans des universités européens différentes.\n\n---\n\n\\(^1\\)Website of the VaryMDE project: [http://varymde.gforge.inria.fr/](http://varymde.gforge.inria.fr/)\n\n\\(^2\\)Website of the GEMOC initiative: [http://gemoc.org/ins/](http://gemoc.org/ins/)\n\n\\(^3\\)Website of the RELATE project: [http://www.relate-itn.eu/](http://www.relate-itn.eu/)\nChapter 1\n\nIntroduction\n\n1.1 Research Context\n\nThe increasing complexity of modern software-intensive systems has motivated the need of raising the level of abstraction at which software is designed and implemented [1]. The use of domain-specific languages (DSLs) has emerged in response to this need as an alternative to express software solutions in relevant domain concepts, thus favoring separation of concerns, and capitalising the knowledge acquired in a particular domain [3]. The adoption of this language-oriented vision has motivated the construction of DSLs for a large variety of purposes such as construction of user interfaces [4], specification of security policies [5], or mobile applications’ prototyping [6].\n\nFig. 1.1 presents an overview of language oriented development [7], which includes three types of stakeholders: language designers, systems engineers, and final users [3]. Language designers are computer scientists who own the technical skills needed in the construction of DSLs. They know the techniques and tools available to conduct language development processes. Through a domain analysis process, language designers materialize the domain knowledge in the form of language constructs [8]. Systems engineers are software and hardware developers who use DSLs to build a particular system. Final users are those who take advantage of the functionalities provided by the systems.\n\nNote that the notion of “system” is larger than just software applications. In this thesis, we adopt a systems engineering perspective where DSLs are used not only to specify software, but also the behavior of cyber physical systems such as aircrafts or trains.\n\n1.2 Problem Statement\n\nDespite the advantages furnished by DSLs in terms of abstraction, separation of concerns, and improvement of productivity, the language-oriented development approach has important drawbacks that put into question its benefits [9]. One of those drawbacks is associated\n1. Introduction\n\nFigure 1.1: Overview of the language-oriented development approach\n\nThe construction of DSLs is a time-consuming activity that requires specialized background [3]. Language designers must own solid modeling skills and technical knowledge to conduct the definition of complex artifacts such as metamodels, grammars, interpreters, or compilers [3]. Is it worth the effort to build a DSL? That question is not always easy to answer [9].\n\nThe development of DSLs becomes even more complex when we consider that DSLs often have different dialects. A language dialect is a variation of a given DSL that introduces certain differences in terms of syntax and/or semantics [10]. This type of variations appear under two situations. The first situation is the use of well-known formalisms through different domains. Consider the case of finite state machines (FSMs), which have been used in the construction of DSLs for a large spectrum of domains such as definition of graphical user interfaces [4] or games prototyping [11]. Those DSLs share typical state machine constructs such as states or transitions. However, each DSL adapt those abstractions to address the particularities of its domain.\n\nThe second situation that favors the existence of DSL variants is when the complexity to the elevated costs of the language development process.\nof a given domain motivates the construction of several DSLs to develop separately the various system concerns. In such a case, the tooling that supports the domain is composed of several DSL variants that share certain domain abstractions. For instance, suppose two DSLs: the former is a DSL for specification and verification of railway scheme plans [12]; the latter is a DSL for modeling and reasoning on railway systems’ capacity and security [13]. These DSL share certain domain abstractions i.e., railway management. However, they both require different semantics and specialized constructs to achieve their purposes.\n\nThe phenomenon of DSL variants reflects the abstraction power of certain well-known formalisms –such as state machines or petri nets– that, with proper adaptations, can fit various domains. Besides, it shows how different concerns in a same domain can be addressed by different and complementary DSLs. However, the construction of a set of DSL variants (a.k.a., a language family) implies two challenges. The first challenge corresponds to the reuse of the commonalities existing among the variants: language designers should reuse, as much as possible, formerly defined language constructs to minimize implementation from scratch [14]. The second challenge corresponds to the management of the differences of each variant: language designers should guarantee that each variant provides the particularities related to their application context.\n\nIn this thesis, we aim to answer the following research question:\n\n**Research Question:** How to increase *reuse* and manage the *variability* during the construction of families of DSLs?\n\n### 1.3 Contributions\n\nThe research community on software language engineering has proposed the use of Software Product Lines Engineering (SPLE) to deal with the phenomenon of DSL variants [17]. This led to the notion of *Language Product Lines (LPL)*, i.e., a software product line where the products are languages [14, 15]. The main principle behind language product lines is to implement DSLs through *language features*. A language feature encapsulates a segment of a language specification that represents certain functionality [18]. Those features can be combined in different manners to produce different DSL variants.\n\nSimilarly to software product lines, language product lines can be built through two different approaches: top-down and bottom-up [19] (see Fig. 1.2). In the top-down approach, a language product line is designed and implemented through a domain analysis process where the knowledge owned by experts and final users is used to define a set of language modules that implement the language features of the product line. Also, the domain knowledge is used to specify variability models capturing the rules that define the way in which the language features can be combined to produce valid DSL variants. In the bottom-up approach, the language product line is built up from a set of existing DSL variants through reverse-engineering techniques. Those techniques should provide mecha-\n1. **Introduction**\n\n\n\nBased on these different approaches for the construction of language product lines, we propose two contributions briefly explained below:\n\n1. **Facilities to support top-down language product lines.** As a first contribution, we introduce a set of facilities to support the development of top-down language product lines. Concretely, we provide a language modularization approach that permits the decomposition of DSLs into interdependent language features. We also introduce a modeling strategy to represent the variability of a language product line.\n\n These facilities are accompanied with a set of methodological insights to guide language designers during the development process.\n\n2. **Reverse-engineering algorithms to support bottom-up language product lines.** As a second contribution, we introduce a reverse-engineering process to automatically build up a language product line from a set of existing DSL variants. This process encompasses: (1) the recovering of a language modular design and implementation that defines the features of the language product line; and (2) the synthesis of variability models that represent the corresponding variability.\n1.4 Thesis’ Realization Context\n\nThe development of this thesis involved the participation of several partnerships. Moreover, the needs of our partnerships have guided the contribution of the thesis and were useful during the corresponding validation.\n\nThe first partnership was the VaryMDE project\\(^1\\), which is an industrial collaboration between INRIA and Thales. This project seeks to provide mechanisms to deal with the variability emerging during the systems engineering processes in Thales. Concretely, the project studies the variability at the level of the models used to represent the systems under construction, and at the level of the modeling languages used to build those models. Whereas the thesis of Ferreira [16] provides an answer to the first level, this thesis provides an answer to the second one.\n\nThe second partnership of this thesis was the GEMOC initiative\\(^2\\). In GEMOC, the participants work to provide a set of tools and methodologies to coordinate the use of several modeling languages in complex application contexts. Our interaction with GEMOC allowed us sharing ideas with experts in the field of software language engineers that are currently seeking solutions to similar problems.\n\nThe third partnership of this thesis was the RELATE project\\(^3\\). It is a Marie Curie project that aims to train doctors on cloud technologies. The stronger contribution of this partnership was its pedagogical infrastructure. RELATE provided a rich scientific environment through different workshops and internships in several universities in Europe that facilitate the exchange of ideas with other PhD students, experienced professors, and industrial stakeholders.\n\n1.5 Outline\n\nThe content of this thesis is structured in four parts.\n\nThe first part, entitled Preliminaries, is dedicated to explain the present of language product line engineering through two chapters. Chapter 2 introduces background knowledge in terms of software product line engineering and domain specific languages. The purpose of his chapter is to introduce the vocabulary that we will use all along the document. Chapter 3 presents a study of the state of the art on the applicability of software product line engineering in the construction of domain specific languages. This chapter is structured in the form of a systematic literature review and closes with a set of open issues that we identified in the area of language product line engineering.\n\nThe second part of this thesis is entitled Contributions. It starts with a brief foreword, presented in Chapter 4, that highlights the subset of the open issues in the state of the art\n\n---\n\n\\(^1\\)Website of the VaryMDE project: [http://varymde.gforge.inria.fr/](http://varymde.gforge.inria.fr/)\n\n\\(^2\\)Website of the GEMOC initiative: [http://gemoc.org/ins/](http://gemoc.org/ins/)\n\n\\(^3\\)Website of the RELATE project: [http://www.relate-itn.eu/](http://www.relate-itn.eu/)\n1. **Introduction**\n\nthat we will address in this thesis. Then, we introduce our contributions structured in two chapters. The first one, Chapter 5, presents a set of facilities for the construction of top-down language product lines. The second one, Chapter 6, presents a reverse-engineering strategy to support bottom-up language product lines.\n\nThe third part of this thesis is entitled **Implementation and Validation**. This part starts by describing the concrete tooling in which we implement our approach. In particular, in Chapter 7 we present Puzzle, an IDE built on top of the Eclipse Modeling Framework where we implemented the ideas introduced in this thesis. Then, in Chapter 8 we introduce three case studies that we use as validation.\n\nFinally, the fourth part of this thesis, entitled **Closure** closes this document by presenting our conclusions and perspectives in Chapter 9.\nPart I\nPreliminaries\nChapter 2\n\nBackground\n\nIn this section, we introduce a unified vocabulary to facilitate the comprehension of the ideas presented in the rest of this document. In particular, we present a brief background in domain-specific languages and software product line engineering.\n\n2.1 Domain-Specific Languages (DSLs)\n\nIn recent years, growing interest in domain-specific languages has led to the proliferation of formalisms, tools, and methods for software language engineering [2]. Hence, numerous techniques for implementing DSLs have emerged.\n\n2.1.1 Implementation Concerns for DSLs\n\nJust as traditional general purpose languages, domain specific languages are typically defined through three implementation concerns: abstract syntax, concrete syntax, and semantics [20]. The abstract syntax of a DSL specifies the set of language constructs that are relevant to its domain and the relationships among them. The concrete syntax of a DSL maps its language constructs to a set of symbols (either graphical or textual) that the users manipulate to create models and programs conforming to its abstract syntax. These representations are usually supported by editors that enable users to write programs using the symbols defined by the concrete syntax acting as the graphical user interface of the DSL. Finally, the semantics of a DSL assigns a precise meaning to each of its language constructs. More precisely, static semantics constrains the sets of valid programs while dynamic semantics specifies how they are evaluated at runtime.\n\n2.1.2 Technological Spaces for the Implementation of DSLs\n\nThere are different technological spaces available for the realization of each of these concerns. The abstract syntax of a DSL can be expressed using grammars or metamodels. This\n2. BACKGROUND\n\ndecision often depends on the culture of language designers. Grammars will most likely be favored by language designers with a strong background in language theory, parsers and compilers, while metamodels will most likely be favored by language designers with a strong background in object-oriented programming and model-driven engineering.\n\nRegarding concrete syntax, DSLs can have either textual or graphical representations (or a mix of both). This decision is usually motivated by the requirements of final users, and the scenarios where the DSL will be used [21]. The implementation of a concrete syntax may for instance rely on the definition of a parser, or a projectional editor [22]. Since concrete syntax and semantics are usually defined as a mapping from the abstract syntax, the choice of the abstract syntax formalism strongly impact the choice of concrete syntax and semantics specification. In particular, the use of grammars to express abstract syntax implies that the DSL have a textual concrete syntax.\n\nRegarding the specification of static semantics, there are not many design decisions to make beyond the constraints language to use. Usually, this selection is based on technological compatibilities with the formalism in which the abstract syntax is defined.\n\nIn turn, there are different methods for the definition of dynamic semantics: operational semantics, denotational semantics, and axiomatic semantics [23]. Operational semantics expresses the meaning of the language constructs of a DSL through the computational steps that will be performed during the execution of a program [23]. The definition of the operational semantics thus consists in an endogenous transformation that changes the execution state of conforming programs. Typically, the implementation of operational semantics corresponds to the definition of an interpreter.\n\nDenotational semantics expresses the meaning of a DSLs through functions that map its constructs to a target formal language where the semantics is well-defined [24, 25]. When the target language is not a formal one (e.g. another programming language with its own semantics), the term translational semantics is favored. The implementation of the translational semantics typically takes the form of a compiler.\n\nAxiomatic semantics offers a mechanism for checking if the programs written in a DSL own certain properties. Examples of such properties are equivalence between programs or functional correctness (e.g. checking if the program is correct with respect to its specification in terms of pre- and post-conditions) [26].\n\nThe different methods for implementing the semantics of software languages are not mutually exclusive. There are authors [27, 26] that suggest that a DSL might own more than one type of semantics according to the needs of the final users.\n\nFigure 2.1 sums up the discussed taxonomy in the form of a feature model [28]. Each feature represents a choice in terms of the technological space of a DSL. The relationships between features represent constraints on the combination of those choices. This taxonomy is consistent with the state of the art of language workbenches presented in [29]. Nevertheless, our taxonomy is more focused on the characteristics of the languages themselves rather than on the characteristics of the language workbenches. Our taxonomy is also con-\n2.1. Domain-Specific Languages (DSLs)\n\nFigure 2.1: Technological spaces for domain-specific languages\n\nconsistent with the classification of DSLs introduced in [30].\n\n2.1.3 External versus Internal DSLs\n\nAnother important decision when designing a DSL concerns the shape of the resulting language and the way to develop it. Language designers can choose to build either an external or an internal DSL. The construction of an external DSL can be viewed as the creation of a new language [2] with its own dedicated infrastructure: editors, compilers and/or interpreters, tools, etc. In such a case, language designers must write a complete specification of their language using dedicated formalisms that offer the suitable expressiveness for defining each implementation concern. Since those formalisms are languages intended to specify languages, they are usually known as meta-languages and vary depending on the technological space chosen for the construction of the DSL.\n\nIn the case of internal DSLs, the principle is to take advantage of the infrastructure already provided by a host language [2]. The high-level domain concepts of the DSLs are implemented using the language constructs offered by the host language. Editors, parsers, or compilers of the host language can be reused as is, thus lowering the development costs compared to external DSLs. However, following this approach also implies that the capabilities of an internal DSL are restricted to the capabilities of the host language. The DSL must work with the programming paradigm, the type system, and the tooling provided by the host language. Besides, it is difficult to forbid the use of the constructs of the host language, as well as providing feedback to the developers in terms of domain specific concepts. Because of all these reasons, an appropriate selection of the host language is of vital importance [32].\n\n1Although the terms “internal” and “embedded” are sometimes used interchangeably, we use the term internal DSL to avoid the confusions sometimes associated with embedding as composition operator [31].\n2. BACKGROUND\n\n2.1.4 Language Workbenches\n\nThe notion of language workbench originates from the seminal work of Martin Fowler [33]. The main intent of language workbenches is to provide a unified environment to assist both the language designers in creating new DSLs. Modern language workbenches typically offer a set of meta-languages that the language designers use to express each of the implementation concerns of a DSL [34], along with tools and methods for composing and analyzing their specifications.\n\n2.2 Software Product Lines Engineering (SPLE)\n\nWhile traditional approaches to software development are intended to build individual software products, the SPLE approach proposes the construction of families of software products through a production lines’ perspective [35]. A software product line is an infrastructure that enables to assembly several software products that share some commonalities with well-defined variations [35].\n\nThe central principle of the SPLE approach relies on the notion of feature. A feature encapsulates a characteristic that might be included in a software product. In that sense, a software product line can be viewed as a set of features available for the construction of a family of software products. Figure 2.2 shows the life-cycle of a software product line; it is divided into two phases: domain engineering and application engineering [35].\n\nDuring the domain engineering phase, the objective is to build the product line itself (i.e., the infrastructure). This process includes the design and implementation of a set of common assets, as well as the explicit representation of the possible variations. The common assets of a software product line correspond to the software artifacts that implement the features. In turn, the possible variations of a software product line correspond to the combination of features that produce valid software products [36].\n\nSince the notion of feature is intrinsically associated with encapsulation of functionality (i.e., characteristics), the implementation of the common assets requires a modular design of software artifacts that allows the definition of interdependent and interchangeable software modules. Those modules should be linked to the features they implement. In turn, the explicit representation of the variations requires a formalism to express the rules defining which are the valid combinations of features. Typically, those rules encode dependencies and/or conflicts between features. Feature models (FMs) [37] became the “de facto” standard to express these rules [38].\n\nDuring the application engineering phase, the objective is to derivate software products according to the needs of specific customer segments [35]. Such derivation process comprises the selection of the features that should be included in the product, i.e., product configuration, as well as the assembly of the corresponding software modules, i.e., modules composition.\n\nIt is worth mentioning that both, the domain engineering and the application engineering\nphases are intended to be complete software development process. Hence, these phases require the typical steps towards the construction of software: requirements analysis, solution design, implementation, and testing [35]. Besides, software product lines are not static in time. The market needs evolve, and software product lines should support changes and adaptations to new business needs [39].\n\n2.3 Summary\n\nIn this chapter, we introduced a unified vocabulary on the software engineering areas related to this thesis. We started by defining the notion of domain specific languages in terms of the implementation concerns and the diverse technological spaces available to conduct the language development process. We also discussed the relationship between languages and language workbenches. Afterwards, we introduced some vocabulary on software product lines engineering. We explained the domain engineering and the application engineering processes and the challenges to overcome during each of them.\nChapter 3\n\nState of the Art: A Literature Review on Language Product Lines\n\nAs aforementioned, there is synergy between software product line engineering and the construction of DSLs [15]. It is possible to use the ideas provided the SPLE approach for systematic management of software variants to build DSL variants [17]. To this end, the life-cycle of software product lines should be adapted to the particularities of the language development process. Besides, language workbenches should provide the facilities that allow language designers to adopt those ideas [3].\n\nNowadays, we can find a number of approaches that directly or indirectly support this vision. Each approach provides certain facilities that can be used during the construction of a language product line. However, it is yet difficult for language designers to realize how those approaches can be used in a concrete language development project. This difficulty has two dimensions.\n\nThe first dimension is the partial coverage of the language product lines life-cycle. Not all the approaches address all the steps of such a life-cycle. Rather, they are often focused on a particular step (such as language modular design) without discussing the other ones. This can be explained by the fact that the approaches that result useful in language product line engineering were not necessarily conceived to this end. For example, not all the approaches in languages modular design are intended to support variability; many of them are motivated by other factors such as domain evolution and maintenance [40].\n\nThe second dimension is the potential misalignment between the technological space supported by each approach and the technological constraints of a particular language development project. Approaches in software language engineering are often conceived for a specific technological space which not always matches the requirements of a specific DSL development project. For example, an approach conceived for grammars-based DSLs with operational semantics may be difficult (or even impossible) to apply in a project where DSLs are meant to be metamodels-based with denotational semantics.\nThis chapter reports on an effort for organizing the literature on language product line engineering through a systematic literature review. The contributions of the chapter are two-fold. On one hand, we propose a definition to the life-cycle of a language product lines; we use it to analyze how current approaches support such a life-cycle. On the other hand, we establish a mapping between each approach and the technological space it supports.\n\nIn this sense, this chapter targets both researchers and practitioners. Researchers will find a comprehensive analysis of the life-cycle of language product lines, as well as a deep study of the strategies used in the state of the art to address such a life-cycle. In turn, practitioners will find in this chapter as a practical guide that they can use to find out the most convenient approach for a particular language development project according to the technological space used in a particular language development process.\n\nScope. In this thesis, we are concerned to the study of the variability in external DSLs. Hence, the study presented in this chapter is restricted to approaches supporting this type of DSLs.\n\n3.1 Related Surveys and Literature Reviews\n\nThere are other literature studies in the field of software language engineering. Perhaps the most notable one is presented by Mernik et. al. [2] which provides a comprehensive analysis of the different development phases in the construction of DSLs: analysis, design, and implementation. Besides, the study introduces insights to identify the situations in which the development of a DSL is a correct decision, and discusses the capabilities of some of the language workbenches available in 2005.\n\nSome years later, Kosar et al., [41] published a new research work in the form of a systematic mapping study which analyzes the trends of the research in DSLs from 2006 to 2012. The conclusions of the study permit to identify the issues that require more attention in the research of DSLs. For example, the authors clearly identify a lack of research on domain analysis and maintenance of DSLs.\n\nA similar study is presented by Marques et al. [42]. In this case, the objective is to provide a systematic mapping study that allows to identify the tools and techniques used in the construction of DSLs. For example, the authors provide a comprehensive list of the host languages used in the development of internal DSLs. Besides, this work permit to understand in which domains the DSLs are being used. One of the conclusions in this regard is that the most popular domain for DSLs is the construction of Web-based systems. Other popular domains are embedded systems and networks.\n\nAnother relevant study on the literature of software language engineering is the one presented by Erdweg et al. [29]. More than studying research trends and techniques, this work focus on the analysis of language workbenches. The authors identify a comprehensive\nset of features provided by the current language workbenches. Then, these features are used to compare the language workbenches among them. The technological spaces are viewed as features of the language workbenches.\n\n**Positioning.** All the studies presented so far are intended to provide a general vision on the field of software language engineering. They analyze a large amount of approaches and offer different perspectives on the past, the present, and the future of the research in software languages. The literature review that we present in this chapter is intended to be more specific. Instead of global perspectives, we propose a detailed study in a localized issue: the use of software product lines techniques to increase reuse in the construction of DSL variants. In that sense, our survey can be compared with other surveys addressing localized issues. For example, the work presented by Ober et. al. [43] surveys different techniques to deal with interoperability between DSLs, and the work presented by Kusel et. al. [44] studies the approaches to leverage reuse in model-to-model transformations.\n\n### 3.2 Research Method\n\nIn this section we provide the details about the methodology that we followed during the conduction of this systematic literature review. Concretely, we describe the search protocol that we used to find and select the articles included in the discussion. The search protocol is illustrated in Fig. 3.1. It was inspired on the guidelines for systematic literature reviews presented by Kitchenham et al [45].\n\n**Perform automatic search.** The first phase of the protocol corresponds to an automatic search that collects a preliminary set of articles potentially interesting for the discussion. It was performed on four digital libraries: ACM-DL, IEEEXplore, SpringerLink, and ScienceDirect. These digital libraries were selected because they are used to publish the articles accepted in the conferences and journals typically targeted by the community of software language engineering. We decided to discard other sources such as GoogleScholar that do not guarantee that the indexed documents have been validated through peer-reviewing processes.\n\nThe automatic search was based on the following boolean expression: \n\n\\[(A \\text{ OR } B \\text{ OR } C) \\text{ AND } (D \\text{ OR } E \\text{ OR } F) \\text{ AND } (G)\\]\n\nwhere the corresponding strings are presented in the Tab\n3.1. There might be several variants of these strings. For example, we can consider plurals and acronyms. However, this current setting retrieve all the all the works that we knew before conducting this literature review, which we consider as a good insight to believe that the automatic search is appropriated. This first phase resulted in 1,018 articles.\n\n<table>\n<thead>\n<tr>\n<th>Research Area</th>\n<th>Challenge</th>\n<th>Scope</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A: language engineering</td>\n<td>D: variability</td>\n<td>G: domain-specific languages</td>\n</tr>\n<tr>\n<td>B: languages implementation</td>\n<td>E: modularity</td>\n<td>-</td>\n</tr>\n<tr>\n<td>C: languages definition</td>\n<td>F: composition</td>\n<td>-</td>\n</tr>\n</tbody>\n</table>\n\nTable 3.1: Strings for the automatic search of the systematic literature review\n\nRemove duplications. There are some cases in which an article is indexed by more than one digital library. As a consequence, some of the entries resulting from the first phase corresponded to the same article. Then, the second phase of our protocol was dedicated to remove those repetitions by checking the title of the paper as well as the target (conference or journal) in which it was published. This phase ends up with a set of 829 unique articles.\n\nApply discarding criteria. The keywords-based automatic search retrieved many articles. However, not all of them were relevant to the scope of the literature review. Therefore, we conducted a discarding process based on a two-fold discarding criteria presented below. Those criteria were applied on titles, abstracts and conclusions. At the end of this phase we obtained 236 articles.\n\n- Discard the articles which do not deal with design and/or implementation of DSLs.\n- Discard the articles which do not target any of the issues that we have identified as relevant languages product line engineering i.e., modularity, composition, and variability management.\n\nApply selection criteria. After applying the discarding criteria, we applied a second filter intended to select the articles will be definitely part of the discussion. To this end, we defined a two-fold selection criteria that we applied on the article’s introductions. This phase resulted in 38 articles.\n\n- Select the articles that have a clear contribution to one or several issues which are relevant on language product line engineering for external DSLs.\n- Select the articles that present case studies if and only if they offer clear insights to address at least one issue of language product line engineering.\n\nFinal result. Fig. 3.2 presents the selected articles classified by year and type of publication. Of the 38 articles, 9 were published in journals, 17 in conferences, 11 in workshops. The figure shows an increasing interest on the subject represented in an increasing number of publications. The list of articles selected and discarded and in each step of the search protocol is available on-line.\n\n1 Survey’s website: http://spltosle-survey.weebly.com/\n3.3. Results\n\nIn this section, we present the results of our analysis of the articles obtained through the systematic process described above. Each article was read and analyzed according to the vocabulary presented in Section 2.\n\nValidation of the searching protocol. Despite the rigorous process that we followed to identify relevant articles, we wanted to reduce the risk of omitting some relevant article during the automatic search. So, we use a three-fold strategy to validate the automatic search.\n\nFirst, before conducting this literature review, we established a set of articles that we knew in advance and that are relevant in this study. Then, we checked if those papers were included by the automatic search. The results were positive, all the papers in the predefined set were included in the automatic search.\n\nSecond, we collected the papers cited by the 38 articles finally included in the literature review. We select the references that we considered as relevant and we checked that they were also included in the automatic search. The results in this second validation strategy were positive as well; all these relevant articles were included in the automatic search.\n\nFinally, we ask a variety of researchers to check our corpus and see if it has some missing works. We obtained several answers pointing out that the main works were considered.\n3. STATE OF THE ART: A LITERATURE REVIEW ON LANGUAGE PRODUCT LINES\n\n3.3.1 The Life-Cycle of a Language Product Line\n\nFig. 3.3 presents the life-cycle of a language product line. It addresses the same issues addressed by the life-cycle of a software product line introduced in section 2.2. However, there are certain particularities that should be considered. Those particularities come out from the specificities of the DSLs development process, and are discussed in several of the articles we selected during the survey protocol.\n\nLanguage Modular Design\n\nLanguage modular design supposes the intersection of two bodies of knowledge: software modularization and software language engineering as shown in Fig. 3.4. Hence, language modularization approaches inherit a combined complexity. On one hand, they have to support the modularization scenarios identified in the literature of software language engineering (i.e., extension, restriction, aggregation, unification, and extension composition). On the other hand, they are supposed to preserve basic principles behind software modularization (e.g., independent development, information hiding, and substitutability).\n\nLanguages modularization scenarios. A modularization scenario describes a situation where two language modules interact each other according to the nature of the dependencies existing between their language constructs. Those scenarios have been largely discussed in the literature [46, 22, 47] under different names. A unified vocabulary is presented in Table 3.3.1 and in the following we provide a brief description of each of them.\n\nThe modularization scenarios called self-extension and referencing, are out of the scope of the paper. The first one, because it is only applicable to the case of internal DSLs that will not be discussed in this paper. The second one because it refers more to the problem of languages integration and coordination than languages modularization.\n\n- **Extension**: Extension is a modularization scenario where a base language module is enhanced with new capabilities provided by an extension language module. Such new capabilities can be either new language constructs or additional behaviors on top of the existing constructs [48].\n3.3. Results\n\nFigure 3.4: The relationship between software modularization and software language engineering\n\nTable 3.2: Language modularization scenarios in the literature. (*) Out of the scope\n\n<table>\n<thead>\n<tr>\n<th>This article</th>\n<th>Erdweg</th>\n<th>Vöelter</th>\n<th>Haber</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Extension</td>\n<td>Extension</td>\n<td>Extension</td>\n<td>Inheritance</td>\n</tr>\n<tr>\n<td>Restriction</td>\n<td>Restriction</td>\n<td>Restriction</td>\n<td>-</td>\n</tr>\n<tr>\n<td>Aggregation</td>\n<td>-</td>\n<td>Combination</td>\n<td>Embedding</td>\n</tr>\n<tr>\n<td>Unification</td>\n<td>Unification</td>\n<td>-</td>\n<td>-</td>\n</tr>\n<tr>\n<td>*Self-Extension</td>\n<td>Self-Extension</td>\n<td>Embedding</td>\n<td>-</td>\n</tr>\n<tr>\n<td>*Referencing</td>\n<td>-</td>\n<td>Referencing</td>\n<td>Aggregation</td>\n</tr>\n<tr>\n<td>Extension Composition</td>\n<td>Extension Composition</td>\n<td>-</td>\n<td>-</td>\n</tr>\n</tbody>\n</table>\n\nFor instance, a language for expressing finite state machines can be extended to support hierarchical state machines by introducing the notion of composite state [49]. In such a case, the extension module introduces a new construct (i.e., CompositeState) completing the specification at the level of the abstract syntax, the concrete syntax, and semantics. The same language can be also extended with a pretty printing operation that returns a string representation of the entire state machine.\n\n- **Restriction**: Unlike extension, restriction refers to the modularization scenario where capabilities of a base language module are reduced by a restriction language module. In other words, some of the constructs offered by the base language are disabled so they cannot longer be used. In [50] the author introduces an illustrative example for restriction where a base language for controlling a robot is restricted by removing some of the movement commands initially provided.\n\nRestriction is commonly identified as a particular case of extension [46, 22]. A language construct can be disabled by either overriding an existing language construct,\nor introducing additional constraints that, in the validation phase, avoid the acceptance of models/programs which include the restricted construct. In this article, we consider extension and restriction as different modularization scenarios – they have not only different but also opposite purposes – that can be addressed by means of similar modularization techniques.\n\n- **Aggregation:** Aggregation refers to the modularization scenario where a *requiring language module* uses (and incorporates) some language constructs provided by a *providing language module*. Consider for example the case where a language for modeling finite state machines uses the functionality provided by a constraint language for expressing guards in the transitions.\n\n- **Referencing:** Similarly than aggregation, in referencing a requiring language module uses some constructs provided by a providing language modules. However, in this case the requiring language constructs are not incorporated by the requiring module but just referenced. Consider for example, the case in which a UML sequence diagram references the entities defined in a UML class diagram.\n\nAlthough this modularization scenario has been discussed in the literature of software language engineering, we did not found evidence that demonstrates its relevance in the language product lines life-cycle. This is because the objective of a language product line is to provide mechanisms to compose complete variants of a DSLs specification and, in this case, composition has a different meaning being more related to orchestration of models/programs.\n\n- **Unification:** Unification refers to the modularization scenario where two independent languages, initially conceived for different purposes, are composed to produce a language with more powerful functionality. The main difference with respect to the other modularization scenarios introduced so far is that in this case there is not dependency between the involved languages. Rather, they are independent one from the other, and some glue code is needed for the composition. Note that in this case, the interface between the involved language modules is specified as a third language module containing the glue code.\n\nAs an example of unification consider the research presented in [4] where a language for state machines is unified with the CSS (Cascading Style Sheets) language. The purpose is to facilitate the definition web interfaces. The work is based on the idea that a state machine can be used to represent user interactions whereas CSS can be used for expressing web pages’ style.\n\nThe modularization scenarios presented so far can be applied in complex situations involving more than two language modules. This case is known as **extension composition**. Consider the case presented in Fig. 3.5 where the web styling language CSS is unified with language for expressing state machines that, in turn, uses the functionality of a constraints language (i.e., aggregation) and that is extended by the notion of composite states.\nPrinciples from software modularization. The literature on software modularization is quite diverse. Many approaches and discussions have been proposed on modular design and implementation of software systems. However, there are three principles which have received special importance in the literature:\n\n- **Independent development.** Independent development has been recognized as one of the advantages software modularization [51]. Software modules can be developed independently of each other even if they have dependencies with other modules [51]. However, this capability is not given for free. To support independent development, a modularization approach should provide a mechanism to express a set of assumptions a module under construction can consider as given. These assumptions are supposed to be fulfilled by other module. Software modules composition is the activity where the assumptions made a certain module are materialized in real functionality providing by another software module.\n\n- **Information hiding.** Information hiding refers to the capability of explicitly selecting the information that a module exposes to other modules. Ideally, the exposed information should represent the functionality provided by the software component. The hidden information should correspond to the implementation details [52]. The importance of this principle relies on reducing the impact of module’s evolution [53]. A module exposes the information which is supposed to be stable along the time (i.e., its functional specification) and hides the information which is more likely to change (i.e., its implementation) [52].\n\n- **Substitutability.** Substitutability refers to the capability of interchange modules that provide the same functionality even if they are implemented differently. For example, there exists substitutability in a software system that can use different modules for LDAP authentication. As long as the modules provide the same functionality, a components model should permit to use any of them according to the needs in a\nspecific situation. The importance of substitutability is to reduce coupling between modules and to increase their potential reuse.\n\n**Language Modules Composition**\n\nOne of the particularities of the DSLs implementation is that the tooling associated to a DSL (e.g., parsers or validators) is rarely built by language designers. Rather, such a tooling is automatically generated from the DSLs specification by language workbenches. For example, the parsers of the DSLs are often generated from a BNF-like grammar; those parsers might include capabilities such as syntax coloring or auto-completion.\n\nAs a consequence of this particularity, language modules composition can be performed either at the level of the specification [46, 50] or at the level of the tooling [54]. In the first case, the principle is to compose the specifications of each language module thus producing one joint specification that is used to automatically generate the tooling of the entire DSL. In doing so, the composition phase should compose the implementation artifacts containing the language modules specifications while clearly defining the semantics of the composition so the language constructs can correctly interact among them. In the second case, the principle is to first generate the tooling corresponding to each language module, and enable mechanisms to support the interaction between those “tooling modules”.\n\n**Multi-Dimensional Variability Modeling**\n\nThe variability existing between DSLs should be explicitly represented in order to identify the combinations of language modules that, once assembled, will produce valid DSLs. The fact that a DSL is specified in different implementation concerns implies different dimensions of variability [55, 56]. Let us summarize each of these dimensions.\n\n- **Abstract syntax variability.** One of the motivations for the construction of language product lines is to offer customized languages that provide only the constructs required by a certain type of users. The hypothesis is that it will be easier for the user to adopt a language if the DSL only offers the constructs he/she needs. If there are additional concepts, the complexity of the DSL (and the associated tooling) needlessly increases and “the users are forced to rely on abstractions that might not be naturally part of the abstraction level at which they are working” [14].\n\n Abstract syntax variability refers to the capability of selecting the desired language constructs for a particular type of user. In many cases, constructs are grouped in *language features* to facilitate the selection. Such grouping is motivated by the fact that selecting constructs can be difficult because a DSL usually has many constructs, so a coarser level of granularity is required.\n\n- **Concrete syntax variability.** Depending on the type of user, the use of certain types of concrete syntax may be more appropriate than another one. Consider, for example, the dichotomy between textual or graphical notations. Empirical studies such as...\nthe one presented in [57] show that, for a specific case, graphical notations are more appropriate than textual notations whereas other evaluation approaches argue that textual notations have advantages in cases where models become large [58]. Concrete syntax variability refers to the capability of supporting different representations for the same language construct.\n\n- **Semantic variability.** Another problem that has gained attention in the literature of software language engineering is the semantic variation points existing in DSLs. A semantic variation point appears where the same construct can have several interpretations. Consider, for example, the semantic differences that exist between state machines languages explored in [59]. In that case, a state machine can either comply with the run-to-completion policy or accept simultaneous events. In the first case, events are processed sequentially (one after the other and one at a time) even if two events arrive at the same time. In the second case, simultaneous events can be attended at the same time. Semantic variability refers to the capability of supporting different interpretations for the same language construct.\n\nThese dimensions of variability are not mutually exclusive. There are cases in which several types of variability appear at the same time in the same language product line. In such cases, an approach for multi dimensional variability modeling [60] is required; it should take into account the fact that decisions taken in the resolution of the abstract syntax variability may affect decisions taken in the both concrete syntax and semantics variability.\n\nFig. 3.6 illustrates multi dimensional variability in the case of state machines. Each dimension of variability is expressed as a sub-tree. In the case of abstract syntax variability, a DSL for state machines is a mandatory feature that requires of an expression language. Timed transitions can be optionally selected as an extension of the DSL for state machines. The semantic variability dimension represents the decisions with respect to the behavior of the state machine. In this example, semantic choices regard to the perfect synchrony hypothesis (an event takes zero time for being executed) and events concurrency. Finally, the concrete syntax variability dimension presents the choice between graphical or textual DSLs for state machines.\n\n**Multi-staged Language Configuration**\n\nOnce the variability of the language product line is correctly specified, and as long as the language features are correctly mapped to language modules, language designers are able to configure and derive DSLs. There are two issues to consider. First, the multi dimensional nature of the variability in language product lines, supposes the existence of a configuration process supporting dependencies between the decisions of different dimensions of variability. For example, decisions in the abstract syntax variability may impact decisions in semantic variability. Second, language product lines often require multi staged languages configuration. That is, the possibility of configuring a language in several stages and by different stakeholders.\nMulti-staged configuration was introduced by Czarnecki et al. [61] for the general case of software product lines, and discussed by Dinkelaker et al. [62] for the particular case of DSLs. The main motivation to support such functionality is to transfer certain configuration decisions to the final user so he/she can adapt the language to exactly fit his/her needs [62]. In that case, the configuration process is as follows: the language designer provides an initial configuration. Then, the configuration is continued by the final user that can use the DSL as long as the configuration is complete. In doing so, it is important to decide what decisions correspond to each stakeholder.\n\nAs an example, suppose the multi-staged configuration scenario presented in Figure 3.7. In that scenario, the language designer configures the abstract and the concrete syntax of a\nDSL for finite state machines. Using those decisions, the language designer can produce a parser and an editor for the DSL. However, the semantics of the DSL remains open so the final user can configure it according to his/her modeling needs. Under the literature, this capability is known as late semantic adaptation [62]. It is important to mention, however, that this configuration scenario is just an example that illustrates the complexity of the configuration process associated to a multi dimensional variability modeling approach.\n\nThe Flow of the Life-Cycle: Top-down vs. Bottom-up\n\nSo far, we have presented the stages that compose the life-cycle of a language product line. We reviewed the main challenges that language designers have to overcome in terms of languages modularization and variability management through the domain engineering and the application engineering phases. Now, we will discuss the order in which those challenges are addressed during the development process, for which there are two different perspectives: top-down and bottom-up [19] as shown in Fig. 3.3.\n\nIn the top-down perspective, the domain engineering phase is performed first. Then, the produced artifacts are used to conduct the application engineering phase. Language engineers use domain analysis to design and implement a set of language modules and variability models from some domain knowledge owned by experts and final users. Those artifacts can be later used to configure and compose particular DSLs. This top-down approach is appropriated when language designers know in advance that they will have to build many variants of a DSL, and they have some clues indicating that the effort of building a language product line will be rewarded.\n\nDifferently, in the bottom-up perspective, the application engineering phase is performed before the domain engineering phase. Language designers start by building different DSLs that address different needs of final users. Then, when language designers realize that there is potential enough to build up a language product line from a set of existing DSLs, these DSLs are analyzed to extract that commonalities and variability that, with appropriated mechanisms, can be used to reverse engineer language modules and variability models.\n\n3.3.2 Current Support for the Language Product Lines’ Life-Cycle\n\nAfter reading the articles obtained from the survey protocol, we identified a set of approaches supporting (partially or completely) the language product line’s life-cycle. Those approaches are listed in table 3.3. In this section, we analyze how the aforementioned approaches support each step of the language product line’s life-cycle.\n\nThere is a clarification to point out in this table. There are two approaches i.e., Neverlang+AiDE and ASF+SDF+FeatureHouse that are more than single approaches are the combination of several approaches. Whereas Neverlang and ASF+SDF are approaches for the construction of DSLs, AiDE and FeatureHouse are tools for variability management. In this literature review, we group those approaches since they have been used together\nSupport for Languages Modular Design\n\nLanguages modularization has been largely discussed in the literature. Indeed, the most part of the approaches we survey in this literature review aim to support languages modularization. As a result of the analysis of those approaches, we have identified two modularization techniques intended to support modular languages design. Those techniques vary with respect to the way in which bindings between language modules are expressed; they are explained below:\n\n- **Endogenous modularity.** In endogenous modularity, bindings between language modules are defined as part of the modules themselves. Usually those bindings are direct references between language modules such as the `import` clause. One important characteristic of endogenous modularity is that, because the modules are linked each other, the importing module has direct access to all the definitions provided by the imported one. As a result, the importing module can easily extend or use these definitions.\n\n This approach results quite useful from the language designer’s point of view because it is straightforward, and it enables IDE facilities such as auto-completion. Contrariwise, the disadvantage of endogenous modularity is that it does not favor language modules substitutability because dependent modules are strongly linked each other. Replacing one language module for another one requires some refactoring to change the direct reference and, in many cases, adapt to the definitions of the\n\n---\n\n### Table 3.3: Current approaches supporting language product lines\n\n<table>\n<thead>\n<tr>\n<th>Name</th>\n<th>Articles</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>LISA</td>\n<td>[63, 64, 65, 66, 50]</td>\n</tr>\n<tr>\n<td>Melange</td>\n<td>[67, 68, 69]</td>\n</tr>\n<tr>\n<td>Keywords-based modularization</td>\n<td>[70]</td>\n</tr>\n<tr>\n<td>Meta Programming System, MPS</td>\n<td>[71, 22]</td>\n</tr>\n<tr>\n<td>Modularization on top of ATL</td>\n<td>[72]</td>\n</tr>\n<tr>\n<td>Modularization on top of MetaDepth</td>\n<td>[73, 74]</td>\n</tr>\n<tr>\n<td>Gromp</td>\n<td>[75]</td>\n</tr>\n<tr>\n<td>Domain-concepts based modularization</td>\n<td>[76, 77]</td>\n</tr>\n<tr>\n<td>Interfaces-based modularization</td>\n<td>[78]</td>\n</tr>\n<tr>\n<td>Components-based LR parsing</td>\n<td>[54]</td>\n</tr>\n<tr>\n<td>Roles-based modularization</td>\n<td>[79, 80]</td>\n</tr>\n<tr>\n<td>MontiCore</td>\n<td>[81, 82, 31, 55]</td>\n</tr>\n<tr>\n<td>Neverlang+AiDE</td>\n<td>[83, 40, 84, 85, 86]</td>\n</tr>\n<tr>\n<td>ASF+SDF+FeatureHouse</td>\n<td>[87, 88, 89, 18]</td>\n</tr>\n</tbody>\n</table>\nnew imported module. This form of modularization favors high coupling between modules.\n\n- **Exogenous modularity.** In exogenous modularity, bindings between language modules are defined externally. Usually, approaches based on exogenous modularity provide mechanisms (for example composition scripting languages) to describe those bindings in third-party artifacts that are the input of the composition process. In this case, language modules do not know the language modules they will be composed with. Hence, they cannot directly use foreign language constructs. To deal with this problem, language modules declare a set of requirements that are intended to be fulfilled in the composition phase. Those requirements are indirect references to language constructs that are defined in another module.\n\n Note that this approach favors language modules substitutability. Since there are not direct references between language modules, the bindings can be changed in the external artifact without modifying the modules themselves. Besides, because the dependencies between language modules are expressed as declarations, modules can be interchanged by any module that provide language constructs compatible with the declarations. The disadvantage of this approach is that it introduces additional complexity in the development process. Language designers need to consider not only the construction of the modules, but also the binding artifacts and manage indirect references.\n\n The importance of these modularization techniques relies in two issues. First, they influence the way in which the approaches support language modularization scenarios and its subsequent composition. Second, they constraint the way in which the approaches address software modularization principles.\n\n**Modularization techniques vs. modularization scenarios.** In the following we discuss how the modularization scenarios are addressed through the modularization techniques. Afterwards, we analyze the composition strategies required in each case. Note that we do not include the modularization scenario called referencing in our analysis because, as we said earlier, we did not find evidence of its relevance in the language product lines life-cycle.\n\n- **Endogenous modularity to support extension and restriction.** Endogenous modularity is useful to support extension and restriction of language modules via the import clause. Base modules are imported by extension modules; then extension modules can access and enhance the definitions of the base modules while introducing new constructs, behavior or constraints.\n\n- **Exogenous modularity to support extension and restriction.** There are approaches based on exogenous modularization to support extension and restriction of language modules. In this case, the extension modules do not import a specific base module. Rather, the binding between the extension and the base module is specified externally, so extension modules have not direct access to the constructs of the base module.\nIn the composition phase, both base and extension modules are composed thus introducing to the base module the constructs, behavior, or constraints defined in the extension module. Following this strategy, the base module can be easily substituted by another one as long as it provides the constructs used as extension points.\n\n- **Endogenous modularity to support aggregation.** Endogenous modularity is also useful to support aggregation of language modules. As we said before, in aggregation of language modules we have a requiring language module that uses the language constructs provided in a providing language module. In the case of endogenous modularity, the requiring language module imports the providing language modules thus having access to all its language constructs.\n\n- **Exogenous modularity to support aggregation.** Aggregation can be supported via exogenous modularity. In this case, the requiring module declares a set of language constructs that are supposed to be implemented in a providing language module.\n\n One might think that there is not difference between endogenous and exogenous aggregation. However, the fact that the requiring language module does not reference directly the providing language module results quite useful for facilitating modules substitutability. Note that the providing language can be replaced for any other language that implements the construct Expression. To do so, language developers need just to change the binding and execute the composition. As a matter of fact, we can find approaches in which the substitutability is even more favored by introducing some mechanisms that permit to declare those requirements in a more abstract way.\n\n- **Endogenous modularity to support unification and extension composition.** Endogenous modularity is also useful to support unification of two language modules (a.k.a., left/right modules). As aforementioned, ideally these language modules should not be modified during the unification process, so the most common solution is to create a third language module (a.k.a., integration module) containing the glue code that specifies the semantics of the integration. In the case of endogenous modularity, the integration module directly imports the left/right modules and uses (or extends) their language constructs to define a unified language.\n\n- **Exogenous modularity to support unification and extension composition.** Exogenous modularity is also useful to support unification of language modules. In this case, the relationship between the third module and the other two is not direct importing but indirect and specified in a composition artifact.\n\n**Support for Language Modules Composition**\n\nAs aforementioned, language modules composition can be performed either at the level of the specification (i.e., specification composition) or at the level of the tooling (i.e., tooling composition). The first strategy is most common; in most of the approaches reviewed in this article language modules composition produces a unified specification from a set of\n3.3. Results\n\nlanguage modules. Differently, tooling composition is rarely mentioned in the literature of software language engineering. Indeed, we found only one approach using tooling composition [54].\n\nThe solution strategy to implement tooling composition can be compared with the classical mechanisms to achieve software composition. After all, parsers, interpreters, or compilers are software tools that can use classical composition strategies such as interfaces. The article presented by Wu et al., [54] introduces a new parsing algorithm that supports modular parsing. In this approach, the parser of a DSL can be defined as a set of interdependent parser modules, and the complete parsing process is supported by the parsing algorithm that can “visit” several parser modules. In the case of specification composition, we found two different techniques used for the composition techniques:\n\n- **Direct linking to compose endogenous modules.** In endogenous modularization, implementation artifacts are physically related via direct linking realized through the import clause. Direct linking corresponds to include all the content of the referenced artifact at the beginning of the referencing one.\n\n- **Artifacts merging to compose exogenous modules.** In exogenous modularization, implementation artifacts are completely independent so they have no direct links between them. Hence, their content should be unified during the composition phase, thus producing a unique artifact containing a joint specification.\n\nMany of the approaches studied in this literature review propose composition strategies based on direct linking exclusively. Indeed, despite the limitation of direct linking with respect to the substitutability principle, it has demonstrated to be useful to support the modularization scenarios presented in Section 3.3.1. This is because the importing language module can access all the language constructs of the imported one, and establish any type of relationship among them. However, there are other approaches whose composition strategy is based on some composition operators, which formally define the semantics of the composition. Such operators are optional in the case of direct linking, but mandatory in the case of artifacts merging. In the following we explain the composition operators that we found during the conduction of this survey.\n\n- **Inheritance.** Inheritance is a mechanism to exploit reuse coming from object oriented programming. It has demonstrated to be useful as composition operator for language modules [50]. Generally, approaches that use inheritance as composition operator are based on endogenous modularity. This can be explained by the nature of the inheritance relationship, which is intended to reuse the specification provided in a concrete implementation artifacts for which direct linking results quite useful.\n\nIn inheritance, the composition rules are based on the notions of extending and overriding, which are useful to compose the interfaces of the modularization scenarios introduced in section 3.3.1. In the case of extension, the extension point is a language construct in the base language that is extended by some language\n\nconstruct in the extension module. In restriction, the restriction point is a language construct in the base language that is overridden by some language construct in the restriction module. In aggregation, the provided module accesses the requiring module through an inheritance relationship. Indeed, if the requiring module inherits the providing one, then it will be permitted to access (and use) all their constructs. In the cases of unification and extension composition, the glue code can be implemented by a language module that inherits all the modules involved in the composition. Naturally, multiple inheritance is needed to support this scenario.\n\n- **Merge.** Merging can be defined as the combination of two artifacts where “the common elements are included only once, and the other ones are preserved” [90]. In the case of language modules composition, merging is an additive operator that sums the constructs provided by the language modules involved in the composition while avoiding repetition. Due to the capability of merging to integrate independent artifacts, it is generally used by approaches based on exogenous modularization.\n\n When using the merge operation, the “common elements” become quite important. They represent the interfaces between the language modules, and can be used to address all the modularization presented in section 3.3.1. In the case of extension, the extension module declares language constructs corresponding to the extension point as part of their definitions. In the composition phase, the declaration of the extension point provided by the extension module is merged with the implementation of those constructs provided by the base module. A similar approach is used in the case of aggregation. The requiring language module declares the language constructs that it uses, and in the composition phase these declarations are merged with the actual implementation of the constructs provided by the providing language module. This idea can be generalized for the composition of more than two language modules to support both unification and extension composition.\n\n- **Superimposition.** Superimposition is a particular case of merging. Indeed, the superimposition operator is defined as the merge of two implementation artifacts. As a result, its applicability for language modules composition is quite similar than the one for merging. The difference between merge and superimposition is that, in the later, the implementation artifacts are intended to be modeled in a tree-based structure. This is because the superimposition operator is recursive, and their semantics are formalized as composition of trees. Similarly than in the case of merging, superimposition is used in approaches based on exogenous modularization.\n\n- **Weaving.** Weaving is another operator has been used in the literature to support languages modularization. It supposes the existence of a base module and an aspect [90]. The base module is enhanced by the features introduced by the aspect. Language designers must define the exact point (i.e., the join cut) in which those features will be injected. The definition of weaving let it open to be applicable in both endogenous and exogenous modularization. That means that the binding between the aspect and\nthe base module can be defined either in the aspect itself or in an external artifact.\n\nThe nature of the weaving operator makes it appropriate to support languages extension and restriction. In that case, the extension point is the point cut which is enhanced with the functionality implemented in the advice. During the conduction of this literature review we did not find any evidence that indicates that weaving can be used to support the other modularization scenarios.\n\nModularization techniques vs. software modularization principles. The modularization technique used by an approach also impacts its capability to address the software modularization scenario. We observed that the support for software modularization principles is deeply associated with the shape of the interfaces between language modules, which differ in the case of endogenous and exogenous modularization. When the approach uses endogenous modularity, this interface is a direct link between the module and the software modularization principles are hardly addressed. Differently, when the approach uses exogenous modularity, it must provide a mechanism to define the dependencies between language modules in a way that favor software modularization principles.\n\n- **Endogenous modularization and independent development.** The use of endogenous modularization constitutes a barrier for addressing independent development. This is because, by definition, direct linking between two language modules implies the existence and accessibility of the imported module. A module \\( A \\) can import a module \\( B \\) if and only if the module \\( B \\) is already implemented and it can be accessed. Hence, the development of module \\( A \\) depends on the development and release of module \\( B \\) so it is not true that the module \\( A \\) can be developed independently.\n\n- **Exogenous modularization and independent development.** Unlike endogenous modularization, exogenous modularization favors independent development. When there is not a direct references between language modules, the modularization approach must provide a mechanism (for example a required interface) to allow language designers the expression of the needs of a language module with other modules. This mechanism permits the development of language modules independently from their needs while assuming that those needs will be eventually fulfilled.\n\n- **Endogenous modularization and information hiding.** The use of endogenous modularization is a potential barrier for addressing independent development. This is because direct linking between language modules often permits to access to all the information of the providing module. To avoid this capability, the modularization approach should provide a mechanism to protect specification elements in the imported module. The protected clause used by Java is an example of such a mechanism.\n\n- **Exogenous modularization and information hiding.** The use of exogenous modularization is neither a barrier to the information hiding principle nor a guaranty of its support. At a first view, the fact that the language modules are not directly referenced between them protects in somehow their specification elements since the interaction\nbetween the modules is expressed through explicit interfaces that define the needs that one module has from others. However, those needs are not necessarily constrained. Hence, a language module could access forbidden information from other modules. To guarantee the information hiding principle, a modularization approach should offer a mechanism (e.g., provided interfaces) to filter out the information that can be accessed by other language modules.\n\n- **Endogenous modularization and substitutability.** To support substitutability, an approach should provide two capabilities. First, the binding between the needs of a requiring module and the functionality offered by the providing one should be expressed in such a way that it can be easily re-directed. In this sense, the use of endogenous modularization is a barrier for addressing substitutability. Replacing one language module for another one requires some refactoring to change the direct reference and, in many cases, adapt to the definitions of the new imported module.\n\n- **Exogenous modularization and substitutability.** It is easier to address substitutability when the approach uses exogenous modularization. The bindings are defined externally and they can be re-directed without modifying the language modules themselves. Ideally, an approach to language modularization that aims to address substitutability should provide a mechanism that permits to compose two language modules even if the requiring and providing constructs are implemented differently.\n\n**Mapping current approaches with language modularization capabilities.** Table 3.4 shows how current approaches support languages modularization. For each approach, the figure indicates the modularization scenarios it supports and the software modularization principle it addresses. Besides, the table shows the modularization techniques and the corresponding composition operator.\n\nNote that endogenous and exogenous modularization are not mutually exclusive. Indeed, in the cases of Modularization on top of MetaDepth, the approaches use endogenous modularization to support language modules extension and restriction and exogenous modularization to support language modules aggregation. In both cases, independent development and substitutability are partially addressed in the sense that they are possible for the case of aggregation but not for the case of extension neither for restriction. Those approaches does not provide any mechanism to express provided interfaces so they do not guarantee the information hiding principle.\n\n**Support for Multi-Dimensional Variability Modeling**\n\nIn contrast to the large amount of articles on languages modularization, we found very few articles addressing languages variability management. In the following we discuss the current advances in this regard.\n\n**Support for multi dimensional variability modeling.** All of the current approaches supporting languages variability modeling are based on feature models. However, they dif-\n3.3. Results\n\n<table>\n<thead>\n<tr>\n<th>Modularization capabilities</th>\n<th>USA</th>\n<th>Mélange</th>\n<th>Keywords-based modularization</th>\n<th>Meta Programming System, MPS</th>\n<th>Modularization on top of ATL</th>\n<th>Modularization on top of MetaDepth</th>\n<th>Grorp</th>\n<th>Domain concept’s-based modularization</th>\n<th>Interfaces-based modularization</th>\n<th>Components-based modularization</th>\n<th>Roles-based modularization</th>\n<th>MontiCore</th>\n<th>Neverlang+AIDE</th>\n<th>ASF+SDF+FeatureHouse</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Extension</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Restriction</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Aggregation</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Unification</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Extension composition</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Software modularization principle</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Independent development</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Information hiding</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Substitutability</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Modularization mechanisms</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Modularization technique</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Endogenous modularization</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Exogenous modularization</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Composition strategy</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Specification composition</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Tool composition</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Composition operator</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Inheritance</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Merge</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Superimposition</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n<tr>\n<td>Weaving</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n<td>YES</td>\n</tr>\n</tbody>\n</table>\n\n**Table 3.4:** Mapping current approaches and language modularization capabilities\n\n...fer in the modeling approach they use to represent the variability. We found three different modeling approaches explained below:\n\n- **Feature models supporting abstract syntax variability.** Wende et al. [79] use feature models as a documentation artifact to present a catalog of language features that can be combined each other to produce DSL variants. This modeling approach is illustrated in Figure 3.8. Each feature is associated to a language module that is completely specified in terms of abstract syntax, concrete syntax, and semantics.\n\nThis approach is useful in language product lines with abstract syntax variability.\nEach language feature can be viewed as a fully specified set of language constructs that will be selected or not according to the needs of the final user. However, support for concrete syntax variability and semantic variability is limited. For example, if a language designer needs to represent semantic variability, he/she will have to define two language modules with the same abstract and concrete syntax but with different semantics. In doing so, language designers would introduce specification clones (repeated segments of specification) all along the language product line, thus increasing maintenance costs.\n\n**Figure 3.8: Boolean feature models for representing abstract syntax variability**\n\n- **Multi-dimensional variability with concern-specific features.** The approach presented in [91] proposes to deal with variability management on top of Neverlang using the COMMON VARIABILITY LANGUAGE. This approach considers not only abstract syntax variability, but also concrete syntax and semantic variability. To this end, the approach proposes to use feature models by following the modeling strategy illustrated in Figure 3.9 where abstract features are used to represent a segment of abstract syntax that may vary in terms of concrete syntax or semantics. The children features represent the possible variations.\n\n Consider, for example, the feature called “Feature 1” that represents a language feature with a variation point in the concrete syntax. The “Feature 1” is mapped to a language module that encapsulates the corresponding abstract syntax and semantics (that do not vary). Besides, there are two children that indicate the different representations of the feature. Each of these children is mapped to a language module that implements the corresponding concrete syntax.\n\n- **Multi-dimensional variability with concern-specific subtrees.** The approach to support variability management is based on feature models to represent multi dimensional variability [55]. In other words, this approach supports not only abstract syntax variability, but also concrete syntax and semantic variability. To support multi dimen-\n3.3. Results\n\nFigure 3.9: Boolean feature models for representing syntactic and semantic variability\n\nOn the other hand, the approach presented in [18] proposes the use of **FEATURE-HOUSE** to deal with languages variability management on top of ASD+SDF. It supports abstract syntax variability, syntactic, and semantic variability. The modeling strategy is the same than the one used by MontiCore (Figure 3.10), and provides facilities to configure and derivate languages from the feature model.\nNote that multi-dimensional variability supposes that the modularization approach supports the definition of each implementation concern (i.e., abstract syntax, concrete syntax, and semantics) in a different language module. In the cases where this separation is not provided, multi dimensional variability is not possible.\n\nThere are some approaches that go further in the study of variability management in language product lines by proposing to automatically infer the variability models. The approach presented in [92] proposes a search-based technique to find a features model that represents the variability existing in a set of language modules while optimizing an objective function. This approach uses an ontology that describes the domain concepts of the language product line. The second approach (presented in [15]) refines the former by removing the ontology. This improvement is motivated by the difficulty behind the construction of such ontology. Then, the authors propose to annotate the BNF-like grammar with certain information that is used to create a variability model.\n\nIt is worth highlighting that these approaches support not only abstract syntax variability but also concrete syntax and semantic variability. In the first case, since the ontology represents the domain from both the syntax and semantic point of view, then it is possible to use it to identify all the existing variation points. In the second case, the annotations provide the expressiveness enough to address all these dimensions of the variability.\n\nSupport for Multi-Staged Language Configuration\n\nThe use of feature modeling to represent the variability of language product lines entails some support for languages configuration. Indeed, the most part of the tools for feature modeling, provide capabilities to create different configurations from a given variability model. Once the variability of a language product line is modeled in a tool-supported feature model, language designers have some facilities to produce configurations that can be used in to select the corresponding language components and start the composition process.\n\nOnce language designers have a tool for configuration of feature models, they should define a multi staged configuration process involving final users if needed. As the reader might imagine, multi staged configuration is more an organizational capability that defines the configuration decisions each stakeholder should make and basic configuration tool support can be used to this end. There are, however, some approaches that enable certain tool features to ease this process. In particular, the approach presented in [55] proposes to express configurations of a feature models configuration files. Each file is a refinement of of the configuration decisions then providing certain traceability and more clear assignation of the configuration decisions. This is relevant when feature models become bigger.\n\nMapping current approaches and capabilities on variability management. Table 3.5 shows how current approaches support languages variability management. In particular, the figure presents a table that, for each approach, indicates the capabilities it provides in terms of multi-dimensional variability modeling and multi staged languages configuration.\n3.3. Results\n\n### Keywords-based modularization\n\n- **Mélange**\n- **Meta Programming System (MPS)**\n- **Modularization on top of ATL**\n- **Modularization on top of MetaDepth**\n- **Gromp**\n- **Domain concepts-based modularization**\n- **Interfaces-based modularization**\n- **Components-based LR parsing**\n- **Roles-based modularization**\n\n### MontiCore\n\n- **Neverlang+AOE**\n- **AS+F+SDF+FeatureHouse**\n\n### Variability modeling\n\n- **Functional variability**\n- **Multi-dimensional variability**\n\n### Languages configuration\n\n- **Features selection**\n- **Multi-staged configuration**\n\n<table>\n<thead>\n<tr>\n<th>Variability modeling</th>\n<th>LISA</th>\n<th>Mélange</th>\n<th>MPS</th>\n<th>ATL</th>\n<th>MetaDepth</th>\n<th>Gromp</th>\n<th>MontiCore</th>\n<th>Neverlang+AOE</th>\n<th>AS+F+SDF+FeatureHouse</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Functional variability</td>\n<td>-</td>\n<td>-</td>\n<td>-</td>\n<td>-</td>\n<td>-</td>\n<td>●</td>\n<td>●</td>\n<td>●</td>\n<td>●</td>\n</tr>\n<tr>\n<td>Multi-dimensional variability</td>\n<td>-</td>\n<td>-</td>\n<td>-</td>\n<td>-</td>\n<td>-</td>\n<td>-</td>\n<td>●</td>\n<td>●</td>\n<td>●</td>\n</tr>\n</tbody>\n</table>\n\nTable 3.5: Mapping current approaches and variability management capabilities\n\n### 3.3.3 Mapping Approaches and Technological Spaces\n\nIn the following, we describe the technological space supported by each of the approaches studied in this survey.\n\n- **LISA.** LISA supports the construction of textual DSLs where the abstract syntax, concrete syntax, and semantics are specified through attribute grammars (which is usually associated to a form of denotational semantics [93]). LISA supports modular language design and language modules composition. To this end, this approach uses ideas from object-oriented programming. In particular, it introduces the notion of inheritance in attribute grammars. In LISA, language modules are defined as attribute grammars that can have inheritance relationships among them.\n\n- **Mélange + Kermeta.** Mélange supports the construction of DSLs where the abstract syntax is specified in metamodels, static semantics are defined as class invariants, and the dynamic semantics is defined operationally as aspects in the Kermeta meta-language [68, 69]. Melange supports modular languages design and language modules composition.\n\n- **Keywords-based modularization.** Keywords-based modularization supports the construction of textual DSLs where the abstract syntax is defined in an object-oriented model (a sort of metamodel) and the semantics is defined denotationally through transformations. Keywords based modularization supports modular languages design and language modules composition. To this end, this approach introduces the notion of *keyword*. A keyword is a language module that contains an object-oriented\nmodel to express abstract syntax, a regular expression to express concrete syntax, and a localized transformation to express semantics.\n\n- **Meta Programming System (MPS).** MPS supports the construction of graphical and textual DSLs whose abstract syntax is defined in metamodels, the concrete syntax is defined through projectional editors, and the semantics is defined operationally in Java programs. This approach supports modular languages design and language modules composition. To this end, MPS enables modularization of the metamodels and provides mechanisms to propagate such modularization at the level of the concrete syntax and semantics.\n\n- **Modularization on top of ATL.** Modularization on top of ATL supports the construction of DSLs where the abstract syntax is defined in metamodels and the semantics is defined denotationally through transformations. The approach supports modular language design and language modules composition by introducing modularization on top of the ATL transformation language [94].\n\n- **Modularization of top of MetaDepth.** MetaDepth supports the construction of textual DSLs where the abstract syntax is defined in metamodels, static semantics is defined in constraints, and dynamic semantics is defined denotationally through transformations. MetaDepth supports modular languages design and language modules composition. To this end, this approach is based on metamodels extensions, and structural concepts.\n\n- **Gromp.** Gromp supports the construction of graphical DSLs whose abstract syntax is defined in metamodels, and the concrete syntax is defined in PICTUR (a platform for the definition of graphical DSLs built on top of EMF). Gromp supports modular languages design and language modules composition. To this end, this approach provides a composition language that allows language designers to manually describe the composition of several language modules.\n\n- **Domain-concepts based modularization.** Domain-concepts based modularization supports the construction of graphical DSLs whose abstract syntax is defined in metamodels and dynamic semantics is defined denotationally through transformations. This approach supports modular design and language modules composition. To this end, the approach provides a pool of composition operators that can be used for expressing the composition of language modules (which are referred to as domain-concepts). This approach is applied to a case study that is presented in [77].\n\n- **Interfaces-based modularization.** Interfaces-based modularization supports the construction of metamodels based DSLs. Neither concrete syntax nor semantics are addressed in this case. This approach supports modular languages design and language modules composition. To this end, the approach follows a principle based\non language interfaces. The authors define metamodel interfaces to metamodel fragments that can be later composed according to some predefined operators.\n\n- **Components-based LR parsing.** Components-based LR parsing is an approach that supports the modular definition of parsers defined through grammars. From all the articles reviewed in this literature review, this is the only one that uses tooling composition as composition strategy. The authors justify their decision by arguing that it favors low coupling in language modular design. Semantics are not addressed by the approach.\n\n- **Roles-based modularization.** Roles-based modularization supports the construction of textual DSLs where the abstract syntax is defined in metamodels, the concrete syntax in BNF-like grammars, and semantics is specified operationally in Java programs. The ideas proposed in this approach are implemented in the LanGems workbench [80]. This approach supports modular languages design and language modules composition. Additionally, the authors propose a first step towards variability modeling. Languages configuration and derivation is not addressed.\n\n- **MontiCore.** MontiCore supports the construction of textual DSLs where the abstract and concrete syntax are defined in BNF-like grammars, and semantics is defined denotationally. MontiCore provides an extended format for grammars that enhances the classical context-free grammar notation with some mechanisms offered by metamodels (e.g., data types, inheritance, interfaces, and associations). This approach supports modular languages design and language modules composition. Additionally, we found an approach to address variability modeling and languages configuration on top of MontiCore [55].\n\n- **Neverlang+AiDE.** Neverlang supports the construction of textual DSLs where the abstract and concrete syntax are specified in BNF-like grammars, static semantics is specified as validation programs, and dynamic semantics is defined operationally in Java programs. This approach provides support for modular languages design and languages composition. Additionally, we found several approaches that support variability management on top of Neverlang.\n\n- **ASF+SDF+FeatureHouse.** ASF+SDF+FeatureHouse supports the construction of textual DSLs where the abstract and concrete syntax are specified in BNF-like grammars, and semantics is specified denotationally through transformations. This approach is a tool chain composed of ASF, SDF, and FeatureHouse. ASF+SDF provides support for modular languages design and languages composition [87, 88, 89]. In turn, the approach presented in [18] proposes the use of FeatureHouse as a languages variability management framework on top of ASD+SDF.\n\nTable 3.6 introduces a summary of the discussion presented in this section.\n3.4 Open Issues in Language Product Line Engineering\n\nDuring the conduction of this literature review, we found an important amount of approaches to support the implementation of language product lines. We provide evidences to state that, with the current meta-languages, it is possible to build a language product line in several technological spaces. Concretely, we analyzed a considerable amount of approaches for languages modularization, and we show that the definition of language modules is possible as well as the use of feature models to represent variability in DSLs. We also presented approaches to automatically generate a first version of those feature models.\n\nDespite all these advances, there are still some open issues on both top-down and bottom-up language product line engineering. Fig. 3.11 shows a mind-map that summarizes those open issues, which are explained in the reminder of this section.\n\n### 3.4.1 Open Issues in Top-Down Language Product Lines\n\nMost of the approaches that we found during the conduction of this literature review are focused in the construction of top-down language product lines. They provide facilities in terms of language modularization and variability management that, in most of the cases, are supported by language workbenches. Using those approaches, a language designer can define a language modular design, as well as represent the corresponding variability.\n3.4. Open Issues in Language Product Line Engineering\n\nHowever, current approaches in language product lines engineering have certain limitations that can be classified in two categories: limitations from the point of view of the meta-language facilities themselves, and limitations from the point of view of the methodology needed to build a language product line.\n\n**Limitations From the Point of View of Meta-Language Facilities**\n\nWe observed that there are still some limitations in terms of meta-languages supporting language product lines, particularly in context of languages modularization. Despite the community on software language engineering has put many attention on modularization issues and that current approaches support very well languages modularization scenarios; very few approaches are successful in addressing software modularization principles (i.e., independent development, information hiding, and substitutability).\n\nThis is due to the fact that not all the language modularization approach propose appropriate interface mechanisms that preserve these principles. We claim that the notion of language interfaces should be better developed to achieve languages modularization approaches that effectively address software modularization principles.\nLimitations From the Point of View of the Methodology\n\nIn terms of methodology, there is a long path to follow. The methodological aspects of the construction of a language product line are rarely mentioned. The analysis, design, testing, evaluation, and evolution of language product lines are open issues that should be addressed to provide appropriate support to language designers. In the reminder of this section, we discuss the open issues and questions that should be addressed to facilitate the construction of language product lines.\n\n**Analysis in language product line engineering.** In the development of software product lines, the requirements analysis phase is dedicated to the identification and documentation of the common and variable requirements of the product line’s final users [35]. Naturally, this analysis is quite important in the case of language product lines as well. Language designers must clearly identify and classify the final users of the products of the DSLs that will be produced by the product line, and define their common and variable requirements.\n\nAn example of this requirements analysis phase in the context of language engineering is presented by Cazzola and Olivares [95]. They identify common and variable requirements for programming languages in the context of education in computer science. In this case, the final users are the students that are classified according to their level in a programming course. The language product line permits to incrementally introduce language features to the students according to their evolution in the learning process.\n\nThe analysis phase in language product lines has certain particularities that should be better investigated, however. For example, the notion of requirements in DSLs should be better defined because there is no consensus about what it means. According to the example mentioned above, a requirement in language engineering is associated to the language constructs. Contrariwise, Kolovos et al. [96] associate DSLs requirements to properties such as supportability, orthogonality, or simplicity. A definition of requirements in DSLs development should be accompanied with methodologies to identify them, as well to documentation well practices.\n\n**Design in language product line engineering.** In the development of software product lines, the design phase is dedicated to the definition of a modular design that establishes the set of software modules provided by the product line and the interfaces between them. Besides, in this phase software engineers perform the construction of variability models that capture the variations required by the product line [35]. To address this activity, software engineers often use design patterns and modularization properties (such as low coupling and high cohesion) [97] to define an appropriate modular design that support the product line’s variability while favoring quality attributes such as extensibility and maintainability.\n\nIn the case of language product lines, however, the definition of an appropriate modular design is rarely discussed. As a matter of fact, current approaches are mostly focused on providing the tooling (i.e., language workbenches) to define and compose language modules, and the design itself has been put aside. As a result, language engineers still have\nproblems at the moment of breaking down a language into interdependent language modules to support variability. More concretely, some of the questions that language designers must face are: What is the current level of granularity at which language modules should be defined? How to modularize a language to support the three different types of variability? Is it possible to define design patterns and modularization principles to facilitate modular languages design? Are the properties of low-coupling and high-cohesion relevant in the development of DSLs? If so, how to realize and measure those properties in a given language product line?\n\n**Testing in language product line engineering.** In the development of software product lines, the testing phase is dedicated to the validation of the implementation artifacts that compose the product line’s infrastructure [35]. To achieve such validation, software engineers must test both the software modules and the variability models.\n\nOn one hand, testing interdependent software modules is usually performed in three phases: unit testing, integration testing, and system testing [98]. In unit testing, each language module is validated independently to guarantee that the functionality it provides is correctly implemented. In integration testing, the interaction between modules is validated to guarantee that the contracts between modules are respected. In system testing, the system as a whole is validated. Naturally, these basic testing steps should be adapted to the fact that language modules are pieces of abstract syntax enhanced with concrete syntax and semantics.\n\nOn the other hand, testing the variability models correspond to verify that the configurations that can be obtained from the feature models produce valid products. To this end, software engineers must design an appropriate set of test scenarios and execute them on the possible configurations. This process can be extremely expensive when variability models become bigger, and prioritization strategies might be required [99].\n\nAll the issues mentioned above are still open in language product lines. Language designers usually face questions such as: How a language module can be tested independently to verify its localized functionality? How to perform integration tests to validate the interaction between several language modules? How to test entire DSLs produced as a composition of language modules? The difficulty of answering those questions relies on the fact that current approaches in languages testing (such as [100], or [101]) are intended to test completely specified languages. When a language is partially identified – a language module is a partial language – it cannot be compiled/interpreted and current testing approaches fail. Some research is needed to find out mechanisms that permit to express the requirements that a language module has with its environment (i.e., the required interface) and artificially simulate these requirements as done by mock objects in object oriented programming. It is worth mentioning that in doing so, researchers should into consideration the different implementation concerns of DSLs; not only the abstract syntax but also concrete syntax and semantics [29].\nEvolution in language product line engineering. Because of the dynamism of business needs, requirements in software products are constantly changing, and evolution is a recurrent concern in software development. The situation is not different in software product line engineering. When the requirements of the stakeholders of a product line change, there is an impact on the product line’s infrastructure, and some adaptations might be needed [102].\n\nEvolution in software product lines supposes several challenges and depending on the nature of the evolution in the requirements the infrastructure might change differently [103]. Those changes can be relatively simple to manage (such as the introduction of a new feature without impacting existing ones), or quite painful (such as split or combination of existing features, which supposes adaptations in the variability model re-modularization of the common assets). Besides, requirements evolution might impact not only the implementation artifacts but also documentation and tests.\n\nEvolution is also a recurrent issue in the development of DSLs due to the domain evolution problem. Changes in the domain rules, or simply improving the domain understanding might an impact on DSLs specifications [104]. As a result, the problem of evolution in language product lines is also a concern that language designers must address. Some of the questions to deal with are: How to re-modularize a components-based DSL? How to capture changes in the domain as evolution in variability models?\n\n3.4.2 Open Issues in Bottom-Up Language Product Lines\n\nDifferently to the case of top-down language product lines, the bottom-up perspective has received little attention. Few works have proposed strategies and algorithms to address such a perspective, most of them are focused on the synthesis of the variability models. We can identify two main limitations of current approaches.\n\nLimitations while Recovering Language Modular Designs\n\nAs largely discussed so far, the very first step towards the construction of a language product line is to achieve a appropriate language modular design. This is not different in the case of bottom-up language product lines. The first challenge of a re-engineering process is to recover the definition of a set of language modules that capture the commonalities and variability existing between the DSLs under study. Indeed, recovering modular designs is one of the main subjects of study when reverse engineering software product lines from software products.\n\nThis particular issue has not received proper attention in the literature. Indeed, the only approach that has proposed something in this direction is the one presented by Kuhn et al., [15]. In that work, each language construct is defined as a language module. That means that the reverse engineering process will result in a language product line containing as many features as language constructs exist in the input DSLs.\n\nNote that this approach permits to exploit the variability in the language product line in\nthe sense that the level of granularity is quite high. Hence, language designers can make decisions with an important level of detail. However, the complexity of the product line might increase unnecessarily. From the point of view of language users, there are clusters of language constructs that always go together thus separation is not needed. For example, in our illustrative scenario on state machines, the concepts of StateMachine, State, and Transition, go always together since they correspond to a commonality of all the input DSLs. Separating these constructs in different features is not necessary in this case and this increases the complexity of the variability models. This can be a real issue if language designers decide to apply automatic analysis operations on those models.\n\nLimitations on Synthesis of Multi Dimensional Variability Models\n\nThe synthesis of variability models has been largely studied in the literature. Some of those approaches have been adapted for the particular case of variability in the context of language product lines engineering. We mentioned those works along this literature review.\n\nThere is, however, an important limitation in those approaches. Although at the modeling level, feature models have shown their capabilities to represent multi dimensional variability and it has been validated for language product lines, there is not support for effectively reverse-engineering such multi dimensional variability in the language product lines. Indeed, the solution provided by current approaches is to synthesize variability models where each feature capture both the abstract syntax of the language constructs and their semantics. Using this strategy, a language construct that has different semantics interpretations is represented as two language features. Those features have the same abstract syntax (a repeated definition of the specification) and their corresponding semantics.\n\nThe problem with this strategy is that it couples abstract syntax variability with semantics variability, which limits multi-staged configuration. The scenario in which language designers configure only the abstract syntax, and final users configure their semantics is not supported since the configuration of the semantics depends also to configure a segment of the abstract syntax. We claim that, in order to support multi staged configuration, the abstract syntax variability should be defined separately from the semantic variability.\n\n3.5 Threats to Validity\n\nIn this section, we discuss the possible threats to validity of the literature review introduced in this chapter. Concretely, we discuss three of the different types of validity proposed by Wohlin et al. [105]: construct validity, internal validity, and external validity.\n\nConstruct validity. Construct validity evaluates the quality of the methodology followed to obtain the income of the study. In the case of this literature review, this process corresponds to the research method we used to obtain the set of articles included in the discussion (described in Section 3.2). Does our study include all the relevant articles existing in the literature on language product line engineering?\nTo answer this question, we used a three-fold strategy intended to validate our research method. Such strategy was explained at the end of Section 3.2; it includes the participation of experienced researchers in the area. Despite such a rigorous process, our methodology could miss some relevant articles. This limitation comes up from four aspects. First, the automatic search phase of our process is based on arbitrary strings. Those strings were carefully selected through a criteria; however there is still a risk of missing some papers that do not fit in the search expression. Second, we performed the automatic search in a set of four digital libraries while excluding other potential sources such as Google Scholar. This decision is also well argued in Section 3.2; however those sources might also contain relevant articles that we are missing in this study. Third, both selection and discarding processes were performed by only one of the authors of this article. Hence, potential errors might appear at the moment of applying the selection/discarding criteria specially due to the large amount of articles provided by the automatic search. Finally, the discarding and selection process where conducted by reading only titles, abstracts, introductions, and conclusion sections. This decision permitted us to deal with the large amount of articles resulting from the automatic search; however, we might be missing some details in the body of the articles that contribute to the discussion.\n\nInternal validity. Internal validity concerns the process used to extract the results from a given income. In the case of this literature review, evaluating internal validity corresponds to evaluate whether our results are consistent with respect to the actual content of the articles included in the discussion.\n\nThe most important risk in terms of internal validity for this study is the low level of agreement in terms of vocabulary used in the articles. The same word is often used in different articles to refer to different concepts. To deal with this issue, we introduced a background section intended to unify the vocabulary that we used in this paper. Besides, we provide equivalences of vocabulary when needed to clarify the concepts (such as the one presented in Table 3.3.1). Still, the vocabulary that we are using might be conflictive with respect to pre-conceived ideas of some of our readers.\n\nExternal validity. External validity evaluates whether the results obtained in the study can be generalized to closely related areas of endeavor. In the case of this literature review, the evaluation of the external validity corresponds to verify whether our methodology and results can be generalized to other areas of application of Software Product Lines Engineering. For example, we might ask us if the life-cycle of Language Product Lines can be generalized to describe the life-cycle of other product lines such as Games Product Lines [106] or Embedded Systems Product Lines [107].\n\nThe study provided in this article is based on an abstraction of the generalities of Software Product Lines Engineering. In section 2.2, we introduced a general life-cycle for software product lines while doing abstraction of the type of products. This permitted to map such a life-cycle to the case in which those products are DSLs. However, while doing such a mapping, we realized that there are certain particularities to consider coming from\nthe specificities of DSLs with respect to other types of software produces. In that sense, we claim that, even if some coarse grained phases of the life-cycle of a software product line can be generalized, there are still some important details to take into consideration coming up from the particularities of each type of software product.\n\n3.6 Summary\n\nThis chapter reports on an effort for organizing the literature on language product line engineering. It provides a detailed study that shows how the ideas on software product lines have been adapted to support the emerging notion of language product lines. To this end, we conducted a literature review, which permitted to select an important amount of articles, that we analyze in a systematic way.\nPart II\n\nContributions\nForeword to the Contributions\n\nIn the last chapter, we presented a literature review on language product lines engineering. It closes with a discussion on the open issues that we found as part of the analysis of the results. In this chapter, we use the definitions and open issues introduced in the literature review to clearly point out the scope of the thesis. Such scope is presented at two levels. On one hand, we present the scientific scope, which corresponds to a subset of open issues that we address. On the other hand, we present the technological scope, which corresponds to the technological space in which our ideas can be applied.\n\n4.1 Scientific Scope: Addressed Open Issues\n\nThis thesis aims to contribute to the field of language product lines engineering by addressing a subset of the open issues identified before. This subset of open issues are shown in Fig. 4.1. Our selection of the open issues is guided by two considerations. First, we aim to contribute in both top-down and bottom-up language product lines. This decision allows us to cover a larger spectrum of development scenarios. Second, we focus on the open issues regarding the design and implementation phases. Evolution and testing are quite complex problems that require a deep reflection. We consider that all those problems are hard to address in a single thesis at the same time. The remainder of this section is dedicated to give a brief summary of how we deal with those open issues.\n\nContributions on top-down language product lines. Chapter 5 presents our contributions in top-down language product lines. In this context, we are focused on extending current meta-languages in order to improve the capabilities in terms of languages modularization. In particular, we aim to provide a modularization approach which not only supports all the language modularization scenarios (i.e., extension, restriction, aggregation, unification, and extension composition), but also addresses the software modularization principles (i.e., independent development, information hiding, and substitutability). The inclusion of these software modularization principles represents our delta with respect to the state of the\n4. Foreword to the Contributions\n\nWe also present an approach to manage languages variability. It proposes the combination of two formalisms —i.e., feature modeling and orthogonal variability modeling— to facilitate variability modeling as well as multi-staged configuration.\n\nWe close our contributions in top-down language product lines with a set of methodological insights to facilitate the phases of analysis and design of language product lines. These insights can be used in the planning of the daily activities of a team of language designers.\n\nContributions on bottom-up language product lines. Chapter 6 presents our contributions on bottom-up language product lines. In particular, we introduce a reverse engineering technique to automatically build up a language product line from a set of existing DSL variants. Our technique consists of an algorithm to recover a language modular design and a mechanism to synthesize language variability models that enable configuration and derivation of concrete DSLs. These variability models include both abstract syntax and semantic variability. Those models are generated in a separate way, thus answering the claim we introduced before in this regard.\n4.2 Technological Scope: Supported Technological Space\n\nTechnological spaces to build DSLs are quite diverse. This diversity is evidenced not only in terms of the amount of existing technological spaces, but also in the differences among them. Although the purpose of all those technological spaces is the construction of DSLs, the concepts and definitions they use is quite different; for instance, the definition of a grammar-based DSL whose semantics is specified denotationally by means of attribute grammars, is quite different from the definition of a metamodel-based DSLs where the semantics are specified in a model-to-model transformation using the ideas of Model-Driven Engineering. This diversity makes it difficult to generalize the ideas of software language engineering to all the technological spaces. As a result, we need to clearly specify the scope of this thesis by indicating the technological space we address.\n\nAll the ideas that we will present in the remainder of this thesis are scoped to executable domain-specific modeling languages (xDMSLs) where the abstract syntax is specified through metamodels, and the dynamic semantics is specified operationally as a set of domain-specific actions [108]. Domain-specific actions are java-like methods that introduce behavior in the meta-classes of a given metamodel. Such injection is performed via weaving as the same as in aspect oriented programming [69]. Concrete syntax, and hence concrete syntax variability, are out of the scope of this thesis.\n\nFig. 4.2 illustrates this type of DSLs through a simple example on finite states machines. In that case, the metamodel that implements the abstract syntax contains three metaclasses: StateMachine, State, and Transition. There are some references among those metaclasses representing the relationships existing among the corresponding language constructs. The domain-specific actions at the right of the Figure 4.2 introduce the operational semantics to\nthe DSL. In this example, there is one domain-specific action for each metaclass. The inter-\nactions among domain-specific actions can be internally specified in their implementation\nby means of the interpreter pattern, or externalized in a model of computation [108].\nThe objective in top-down language product line engineering is to transform the domain knowledge owned by domain experts into a language product line that permits to easily prototype diverse DSL variants. Each variant is intended to address the needs of a group of final users. In this chapter we present some extensions to the existing meta-languages to facilitate the construction of language product lines. Concretely, those facilities support language modularization and variability management. Besides, we introduce some methodological insights that guide language designers through the development process.\n\n5.1 Meta-language Facilities for Language Product Lines\n\n5.1.1 Supporting Languages Modularization\n\nAs aforementioned, current approaches on languages modularization focus on supporting languages modularization scenarios for different technological spaces. However, they fail in satisfying three main principles largely discussed in the literature on software modularization, namely: information hiding, independent development, and substitutability. In this section we revisit modularization of DSLs by proposing an approach that overcomes this limitation. Our approach covers both abstract syntax and semantics.\n\nSupporting the Software Modularization Principles\n\nIn order to support software modularization principles in languages modularization, we propose the definition of certain language interfaces. In particular, we adapt the classical notions of required vs. provided interfaces to the construction of DSLs. As shown in Fig. 5.1, each of the elements of the approach is intended to support one of the software modularization principles.\n5. **Facilities to Support Top-Down Language Product Lines**\n\n\n\n**Required interfaces to support independent development.** The purpose of a required interface is to support independent development of language modules. In that sense, a required interface is a mechanism that allows language designers to declare the needs that a language module has towards other modules while assuming that their needs will be eventually fulfilled. Suppose for example the development of a language module for finite state machines. This language module needs some additional abstractions such as constraints to express guards in the transitions. Using a required interface, language designers can declare those needs as a set of required constructs (e.g., `Constraint`) and focus on the definition of the constructs which are proper to finite state machines (e.g., `State`, `Transition`, `Triggers`).\n\nThe needs of a language module can be materialized in the form of required constructs. In assuming so, a module’s specification would be composed of a set of actual constructs, which are being implemented by the module; and a set of required constructs, which represent needs to other modules. This approach results useful to support the modularization scenario called aggregation where the needs of language modules are entire constructs implemented in foreign modules. However, a finer level of granularity might be necessary to support other modularization scenarios such as extension where the needs are not necessarily entire constructs but finer elements such as properties or operations.\n\nBased on this reasoning, we propose a mechanism to enable the capability to distinguish whether a given language specification element (i.e., meta-class, property, operation, parameter, enumeration, etc.) corresponds to an actual implementation or a required declaration. The proposed mechanism is an extension to the EMOF meta-language that introduces the notion of *virtualization* (see appendix A, section A.1 for further details). Using this extension, language designers can define virtual specification elements expressing needs of the module. Non-virtual specification elements are actual implementations of the language module. The required interface of a language module is the set of virtual elements it contains within its specification.\nFig. 5.2 illustrates the use of required interfaces through the example introduced before regarding a language module for finite state machines that requires a constraint language. In that example, the constructs proper the state machines are non-virtual elements since they correspond to actual implementation of such abstractions. In turn, the constraints to express the guards in the transitions are expressed as a virtual construct called `Constraint` that provides a virtual operation action called `eval()` which is used in the specification of the semantics of the meta-class `Transition`.\n\n**Provided interfaces to support information hiding.** The purpose of provided interfaces is to enable information hiding in modular development of DSLs. That is, to distinguish between the information that specifies the functionality offered by the language module from the information corresponding to the implementation details behind such functionality. Consider a language module that offers the capability to express and evaluate constraints. Using a provided interface, language designers can express the essential functionality of the module i.e., expression and evaluation of constraints; and hide the implementation details and auxiliary concepts needed to achieve such functionality.\n\nTo support the definition of provided interfaces, we propose to extend EMOF with the notion of module visibility (see appendix A, section A.2 for further details). This extension allows to classify a certain specification element as either `public` or `private` according to its nature. For example, a language designer can classify a metaclass as `public` meaning that it represents essential functionality of the module so can be used by external modules.\nand it belongs to the provided interface. Naturally, if the meta-class is classified as private, it cannot be used by external modules and it cannot be considered as part of the provided interface. Note that the notion of module visibility is different from the notion of visibility already defined in EMOF. The later is associated to certain access constraints of model elements with respect to the package in which they are implemented.\n\nFig. 5.3 illustrates the use of provided interfaces through the example introduced before regarding the constraints module. Since the main functionality of the module is to define and evaluate constraints, the meta-classes included in the provided interface (so those one defined as public in terms of module visibility) are: Program and Constraint including the operations that implement their semantics. Note that the references from the metaclass Constraint to other metaclasses (i.e., Constraint.body and Constraint.context) should be defined as public if and only if they represent exposed functionality. In such a case, the target metaclasses should be also defined as public. In our example, those references are not exposed so they remain private as well as their target metaclasses.\n\n**Interfaces binding to support substitutability.** Now we need to establish the way in which those interfaces interact each other at the moment of the composition. In doing so, it is important to conciliate two different (and potentially conflicting) issues. Firstly, safe composition should be guaranteed; we need to check the compatibility between a providing and a requiring language module by verifying that the functionality offered by the former actually fulfills the needs of later. Secondly, there must be some place for substitutability; the compatibility checking mechanism should offer certain flexibility that permits to perform composition despite some differences in their definitions. This is important because when language modules are development independently of each other, their interfaces and\nimplementations not always match [51].\n\nTo deal with the aforementioned issues, we propose an approach for compatibility checking which is strict enough to guarantee safe composition, and at the same time, it is flexible enough to permit substitutability under certain conditions. To this end, we propose to extract both required and provided interfaces in the form of model types [109]. The model type corresponding to the required interface contains the virtual specification elements of a language module, and the model type corresponding to the provided interface the model type contains its public specification elements. The relationship between a model type and a language module is called implements and it is introduced by Degueule et al. [67].\n\nTo perform compatibility checking, we use the sub-typing relationship between the model types corresponding to the provided and the required interfaces [110]. This relationship imposes certain constraints that guarantee safe composition while permitting some freedom degrees thus introducing some flexibility. In particular, under this definition of sub-typing the most obvious manner to guarantee safe composition is to check two conditions: (1) all the needs expressed in the requiring model type are furnished in the providing model type (total sub-typing); and (2) the two model types have exactly the same shape (isomorphic sub-typing). However, this definition of sub-typing also provides two dimensions of flexibility: partial sub-typing and non-isomorphic sub-typing.\n\nThe main principle behind partial sub-typing is that not all the needs expressed in the required model type must be provided by the provided one. In that case, compatibility checking corresponds to verify that the sub-set of elements that match in the model types are compatible. Then, the result of the composition is a third language module with a resulting required interface that contains those needs that have not been satisfied by the providing language module.\n\nAs an example suppose a language module for finite state machines that needs not only constraints for expressing guards in the transitions, but also action scripting constructs to express the behavior of the states. In such a case, a constraint module will fulfill the first need but not the second one. Thanks to partial sub-typing, we can perform compatibility checking only on the constructs associated to the constraints and, if they are compatible, then compose those language modules. The result will be a language module having the constructs for state machines and constraints but that still needs action scripting constructs defined in its required interface.\n\nThe principle behind isomorphic sub-typing is that the needs in the requiring interface are not always expressed exactly as the functionality offered by the providing module is expressed in the providing interface. For example, model type in Fig. 5.2 expresses the needs in terms of constraints of state machines through a class Constraint with an operation eval(). If we want to use OCL to satisfy these needs, then we will find that there is not a class constraint but OclExpr. Besides, the operational semantics might be implemented differently. In this case, we need an adapter that permit to find the correspondences among the elements of the model types.\nAt the implementation level, in the current state of our approach we support partial sub-typing and some particular cases of non-isomorphic sub-typing. We still need some research to fully support non-isomorphic sub-typing.\n\nSupporting the Language Modularization Scenarios\n\nLet us now explain how our approach addresses the language modularization scenarios. To this end, we will use as running example the language for finite state machines that we have used so far. Fig. 5.4 summarizes such example; it is composed of several language modules with some dependencies among them. Each of those dependencies exemplifies a certain modularization scenario.\n\n**Extension.** There are several ways to extend language modules. Our approach supports two of them: *sub-classing* and *open-classes* [111]. They are explained in the following.\n\n**Extension through sub-classing.** In this case, the extension module introduces one or more sub-classes which specialize the metaclasses defined in the base module. Consider a language module called *TimedStateMachines* that extends a base module called *FiniteStateMachineS* with time counters on the transitions. The *TimedStateMachines* module introduces a new metaclass called *TimedTransition* which is a sub-class of the *Transition* metaclass. This new sub-class implements the structural features (i.e., properties) and behavior (i.e., operations) needed to support the time counters’ functionality. To implement this particular case of extension by using our approach, a language designer should:\n\n1. Add the *Transition* metaclass to the provided interface of the *FiniteStateMachines* –i.e., define its module visibility as *public*–, thus indicating that it can be extended\nby foreign modules. The provided interface should also include all the properties and\noperations of the Transition metaclass that represent its functionality.\n\n(2) Add the Transition metaclass to the required interface of the TimedStateMachines\nmodule —i.e., define it as a virtual metaclass—, thus indicating that it corresponds\nto a requirement that should be eventually fulfilled by a certain base module. This\ndeclaration should include not only the metaclass itself, but also the properties and\noperations needed to implement the extension. For example, if the TimedTransition\nmetaclass is intended to override the fire() operation, then it should be declared in\nthe required interface.\n\n(3) Define the TimedTransition metaclass as a subclass of the Transition metaclass de-\ndined in the required interface. Then, implement all the functionality corresponding\nto times counters.\n\nExtension through the open-class pattern. In the case of extension through the open-class\npattern [111], the idea is to enhance a meta-class of the base module by directly injecting\nnew properties and/or operations without adding a new sub-class. The base class is ac-\ntually re-opened and modified according to the needs of the requiring module. Suppose\nfor example a language module called HierarchicalStateMachines that extends the FiniteS-\ntateMachines module to support hierarchical states —i.e., states that contain other states—.\nIn that case, a new containing reference should be added to the State meta-class indicating\nthat it can have sub-states. In addition, the operation eval() should be re-defined in order\nto include the new behavior. To implement this particular case of extension by using our\napproach, a language designer should:\n\n(1) Add the State meta-class to the provided interface of the FiniteStateMachines mod-\nule. Include the properties/operations that represent its functionality.\n\n(2) Declare the State meta-class in the required interface of the HierarchicalStateMa-\nchines module. This declaration should include not only the meta-class itself, but\nalso the properties and operations needed to implement the extension. In particular,\nbecause the behavior of the meta-class State should be re-defined, the eval() opera-\ntion should be included in the required interface.\n\n(3) Complete the virtual meta-class called State with the new functionality correspond-\ning to hierarchical states. The language designer should add a non-virtual containing\nreference to the State meta-class representing the sub-states. Besides, the the eval() op-\neration should be overridden with the enhanced behavior. As we will explain later\nin this paper, in our approach we provide a mechanism based on annotations to over-\nride operations defined in the required interface.\n\nNote that extending a language module through the open-class pattern results in virtual\nmeta-classes containing non-virtual elements. After composition, the resulting meta-class\nwill be a unique State meta-class that contains all the properties already defined by the base\nmodule as well as the elements injected in the extension one.\n5. Facilities to Support Top-Down Language Product Lines\n\n**Restriction.** Language modules restriction can be achieved in several ways. For example, language designers might abuse of the open-class pattern to access an existing metaclass of the base module and then remove some of its elements\\(^1\\). The problem with this approach is that safe composition is not longer guaranteed; deletion of specification elements can introduce some conflicts when composing more than two modules.\n\nSuppose for example that the we want to compose the FiniteStateMachine module with HierarchicalStateMachine and the RestrictedFSM—the later is a restriction to the FiniteStateMachine intended to remove the Fork and Join pseudostates. In that scenario, after the composition of the modules we will have a compilation error in the implementation of the HierarchicalStateMachine if it uses the Fork and Join pseudostates; those pseudostates will not longer exist. As a matter of fact, another problem of allowing deletions of specification elements in a given module is that the results of the composition might be different depending on the order in which the composition is performed.\n\nBased on this reasoning and inspired by the work of Vacchi et al.\\(^8^6\\), we decide to use additive extensions to support restriction of language modules. We propose to support restriction by enhancing the invariant of the metaclasses thus enforcing the validation phase of the language in such a way that all the programs that use the disabled constructs will be rejected. In our example about disabling pseudostates, all the state machines containing Fork and Join will be rejected in the validation phase. Note that in this case there will be no conflicts at the moment of the composition because the pseudostates still existing in the definition of the modules. To implement this particular case of restriction by using our approach, a language designer should:\n\n1. Add the StateMachine metaclass to the provided interface of the FiniteStateMachine module. All the elements relative to the pseudostates we want to remove should be also included: the corresponding enumeration or meta-classes.\n2. Add the StateMachine metaclass to the required interface of the RestrictedFSM module.\n3. Enhance the invariant of the StateMachine metaclass by adding a new constraint that states that there cannot exist pseudostates of type Fork or Join. In doing so, we are using the open-class pattern in an additive way to implement a restriction of the FiniteStateMachine module.\n\n**Aggregation.** As aforementioned, aggregation is the modularization scenario where a requiring language module uses some elements specified in a providing one. As an example of aggregation, we can retake the situation explained in section 5.1.1 when explaining the notions of required and provided interfaces. There is a language module called FiniteStateMachine that implements basic functionality to express finite state machines, and which depends on two other modules: a first one providing constraint language and a\n\n\\(^1\\)We use the expression “abuse of the open-class pattern” because such pattern is typically used to add new elements in the open-class; removals are often forbidden.\nsecond one for action scripting. There are two modules i.e., *Constraints* and *ActionScripting* that provide each of those functionalities but that, in turn, depend on an Expressions module that provides the basic functionality for specify arithmetic and relational expressions as well as to declare variables. To implement this particular case of aggregation by using our approach, a language designer should:\n\n1. Add the *Constraint* meta-class to the provided interface of the *Constraints* module.\n2. Add the *Program* meta-class to the provided interface of the *ActionScripting* module.\n3. Declare the meta-classes *Constraint* and *Program* in the required interface of the *FiniteStateMachine* module. This declaration should include not only the meta-classes themselves, but also the required properties and operations. In particular, in this case we need not only the meta-classes, but also their operational semantics implemented in the `eval()` operation of each of them.\n4. Implement the *FiniteMachinesModule* with the abstractions needed to support the definition of state machines by referencing the meta-classes *Constraints* and *Program* when needed.\n\n**Unification.** Language modules unification is often achieved through the creation of glue modules that implement the behavior of the composition of two initially independent language modules. In order to address the example for unification regarding the integration of finite state machines to CSS to specify final user interfaces, a language designer should:\n\n1. Create a glue-code module (we called it FSM-CSS).\n2. Add the meta-classes *StateMachine* and *State* from the *FiniteStateMachine* module to the required interface of FSM-CSS.\n3. Add the meta-class *StyleSheet* from the *CSS* module to the required interface of FSM-CSS.\n4. Create a meta-class called *StyledStateMachines* in the module FSM-CSS as sub-class of *StateMachine*. A styled state machine implements the navigation of a web-site.\n4. Create a meta-class called *StyledState* in the module FSM-CSS that as a sub-class of *State*. Then, create a containment reference from *StyledState* to *StyleSheet* to indicate that each state of the state machine represents one page in the web-site, and that the corresponding style sheet implements the page’s style.\n\n**Extension composition.** To support extension composition, we need to provide a mechanism to specify a set language modules in terms of their implementation artifacts and interfaces. Doing the parallel with software architecture, what we need to support extension composition is an Architecture Description Language (ADL) [112]. In our approach, we use Melange [67] to this end. Melange is a tool-supported meta-language that can be\nused to model the relationships in the large of a set of artifacts associated to the construction of software languages. The details of the use of Melange to this end will be introduced later in this document when we explain the implementation details of our approach.\n\n**Language modules composition**\n\nSo far, we have explained the way in which language designers can define a set of interdependent language modules. We explained the way in which these dependencies can be expressed to support language modularization scenarios and respecting certain software modularization principles. Now, we explain the composition that permits to unify a set of language modules to produce a unique DSL specification.\n\nLanguage modules composition starts with a preliminary phase of compatibility checking, which guarantees safe composition. It is based in checking the sub-typing relation between the model types representing required and provided interfaces of the involved language modules. Once the compatibility is correctly checked, the next step is to compose the language modules to integrate their functionality i.e., the needs of the requiring module are fulfilled with the services offered by the provided one.\n\nIn our approach, this composition is performed in two phases. First, there is a matching process that identifies one-to-one matches between virtual and public elements from the required and provided interface respectively. This match can be identified automatically by comparing names and types of the elements (where applicable). However, the match can be also specified manually in the case of non-isomorphism. Once the match is correctly established, the composition process continues with a merging algorithm that replaces virtual elements with public ones. That means also to replace all the possible references existing to the virtual element to point out to the corresponding public element.\n\nOnce the process is finished, we re-calculate both provided and required interfaces. The provided interface of the composition is re-calculated as the sum of the public elements of the two modules under composition. In turn, the required interface of the composition is re-calculated as the difference of the required interface of the required module minus the provided interface of the providing module.\n\n**5.1.2 Supporting Languages Variability Management**\n\nAs we said earlier, the challenge towards representing the variability existing in a language product line is that such variability is multi dimensional. Because the specification of a DSL involves several implementation concerns, then there are several dimensions of variability that we must manage: abstract syntax variability, concrete syntax variability, and semantic variability [55, 56]. As the same as our approach to language modularization, our approach to variability management is scoped to abstract syntax and semantics; concrete syntax—and hence, concrete syntax variability— is not being considered in the solution.\nModeling multi-dimensional variability\n\nA solution to represent abstract syntax variability and semantic variability should consider two main issues. Firstly, the definition of the semantics has a strong dependency to the definition of the abstract syntax—the domain-specific actions that implement the semantics of a DSL are weaved in the meta-classes defined in the abstract syntax. Hence, these dimensions of variability are not isolated each other. Rather, the decisions made in the configuration of the abstract syntax variability impact the decisions that can be made in the configuration of the semantic variability.\n\nThe second issue to consider at the moment of dealing with language variability management is that a semantic variation point might be transversal to several meta-classes. Moreover, if the involve meta-classes are introduced by different language modules in the abstract syntax, then the semantic variation point depends of two features. As a result, the relationship between a feature in the abstract syntax and a semantic variation point is not necessarily one-to-one.\n\nCurrently, we can find several approaches to support multi-dimensional variability (e.g., [60]). Moreover, in chapter 3 we show how those approaches have been applied concretely to language product lines. The most common practice is to use feature models to represent all the dimensions of variability. Each dimension is specified in a different tree and dependencies among decisions in those dimensions are expressed as cross-tree constraints. In this thesis, we propose a different approach based on the combination of feature models with orthogonal variability models. Feature models are used to model abstract syntax variability and orthogonal variability models are used to model semantic variability.\n\nFig. 5.5 illustrates our approach. At the top of the figure, there is a feature model in which each feature represents a language module. As aforementioned, each language module is composed of a metamodel and a set of domain-specific actions. Hence, such a feature model is enough for language product lines where there is not semantic variability i.e., each language module has only one set of domain-specific actions. Differently, when there are one or more language modules containing several sets of domain-specific actions, then we have semantic variability that must be represented in the variability model. To represent such a variability, we include an orthogonal variability model as illustrated at the bottom of Fig. 5.5 which contains a variation point for each feature that represents a language module with more than one set of domain-specific actions.\n\nWhy orthogonal variability models? An inevitable question that we need to answer at this point is: why we use orthogonal variability models instead of using feature models as proposed by current approaches? The answer to this questions is three-fold:\n\n(1) The structure of orthogonal variability models is more appropriated. As explained by Roos-Frantz et al. [113], feature models and orthogonal variability models are similar. However, they have some structural differences. One of those differences is that whereas a feature model is a tree that can have many levels, an orthogonal variability model is a set of\ntrees each of which has two levels. Each tree represents one variability point and its children represent variants to that variation point.\n\nSemantic variation points are decisions with respect to a particular segment of the semantics of a language. Although those decisions can have some dependencies among them, they can hardly be organized in a hierarchy. Indeed, we conducted an experiment where we use feature models to represent semantic variation points, and we always obtained two-level trees: the first level corresponds to the name of the variation point and its children represent the possible decisions. This fact suggests that orthogonal variability models are more appropriate than feature models to represent semantic variability.\n\n(2) The meaning of orthogonal variability models is more appropriate. According to [18], a language feature is a characteristic provided by the language which is visible to the final user. This definition can be associated with abstract syntax variability and the use of feature models can be appropriate to represent it. All the approaches on language product line engineering use feature models to this end showing that it is possible and appropriate.\n\nThe case of the semantic variability is different. A semantic decision is not a characteristic of a language that we can select or discard. The semantic of a DSL should be always specified if the DSLs is intended to be executable. Rather, a semantic decision is more a variation point that can have different interpretations captured as variants. This vocabulary\n5.1. Meta-language Facilities for Language Product Lines\n\nfits better in the definitions provided by orthogonal variability models. More than features, we have variation points and variants, which also suggest that the use orthogonal variability models is more appropriate to represent semantic variability.\n\nMulti-staged Language Configuration\n\nThere are two issues to consider to support configuration of DSL variants in language product line engineering. First, the multi-dimensional nature of the variability in language product lines, supposes the existence of a configuration process supporting dependencies between the decisions of different dimensions of variability. For example, decisions in the abstract syntax variability may impact decisions in semantic variability. Second, language product lines often require multi-staged languages configuration. That is, the possibility of configuring a language in several stages and by different stakeholders.\n\nMulti-staged configuration was introduced by Czarnecki et al. [61] for the general case of software product lines, and discussed by Dinkelaker et al. [62] for the particular case of DSLs. The main motivation to support such functionality is to transfer certain configuration decisions to the final user so he/she can adapt the language to exactly fits his/her needs [62]. In that case, the configuration process is as follows: the language designer provides an initial configuration. Then, the configuration is continued by the final user that can use the DSL as long as the configuration is complete. In doing so, it is important to decide what decisions correspond to each stakeholder.\n\nSuppose the scenario introduced in Fig. 5.6 where the language designer is responsible to configure the abstract syntax variability whereas the language user is responsible to configure the semantics. When the language designer finishes its configuration process, the orthogonal variability models will be available so the final user can perform the configuration of the semantics. This orthogonal variability model will only include the variation points that are relevant to the features included in the configuration of the abstract syntax. Moreover, because each of the semantic variation points are represented separately in a different tree, then we can imagine a scenario where the language designer is able to configure not only the abstract syntax but also some semantic variation points, and then delegate to the final user the decisions that he/she can take according to its knowledge.\n\nRunning example\n\nLet us now to illustrate our approach in language variability management with the example of the state machines. Fig. 5.7 summarizes the situation. In that case, we have a language product line for state machines that offers a well-defined set of language features in for the abstract syntax, and two semantic variation points. For the case of the abstract syntax, there is a mandatory feature called Core that contains the main constructs needed to express finite state machines i.e., StateMachine, State, Transition, Region, Trigger, and so on. Then there is a set of features representing the pseudostates. The initial pseudo state is mandatory, all the others are optional and should be included or not according to the level of the\nexpressiveness required for the DSL. We have also a feature called TimedTransitions that introduces the notion of time counters in the transitions. Finally, there is a feature called HierarchicalStateMachine that introduces support for composite states.\n\nIn addition of the abstract syntax variability, the language product line in our example also contains some semantic variability. In particular, there are two semantic variation points both of them deeply explained by Crane et al. \\[59\\]. The first one introduces two different ways of attending simultaneous events in a state machine. It is possible to actually support this simultaneous events in such a way that in a same step the state machine is reacting to two or more different triggers. The other possibility is to prohibit this behavior and comply the run-to-completion policy that states that only one event can be attended in one step. So, it does not matter if two events arrive at the same time to the state machine, there will be always a sequential reaction.\n\nThe second semantic variation point emerges as a result of selecting the feature called HierarchicalStateMachine. In such a case, it is possible to have conflicting transitions since, in the same step, many hierarchical states are activated. All the transitions which are outgoing the hierarchical states and that are associated to the same trigger are considered as conflicting. The first possibility to solve these conflicts is to fire the transition outgoing the state at the top of the hierarchy. The second possibility is to fire the transitions outgoing the state at the bottom of the hierarchy.\n5.2 Methodologies for Top-Down Language Product Lines\n\nAs aforementioned, for the particular case of top-down LPLE, the development process begins with the domain engineering phase. Once it is completed, and the language product line is implemented, then the process moves on to the application engineering phase. As the reader might imagine, the domain engineering phase in LPLE is a complex development activity. Like during domain analysis in classical development of DSLs [114], the success of this phase depends on the expertise and the experience of domain experts and language designers. Whereas domain experts must own a deep understanding of the domain and solid communication skills, language designers should be able to filter relevant information from the domain and transform it into an appropriate design for the language product line.\n\nTypically, the complexity of software development activities is addressed by means of well-defined methodologies that guide software developers through a process which is clearly defined in terms of key activities, inputs and outputs. The objective is to systematize the development activities in such a way that they can be monitored, evaluated, and continuously improved. The success of those methodologies relies on an equilibrium between rigor, which enables systematic development [115], and flexibility, which permits adaptation of the methodology to the particularities of each development process and its participants [116].\n\nThis section provides a methodological toolkit to support the domain engineering phase in top-down LPLE. It is meant to be rigorous enough to enable systematical development during domain engineering, and (at the same time) flexible enough to be easily adapted.\n\nFigure 5.7: An example of multi-dimensional variability in language product lines\n5. Facilities to Support Top-Down Language Product Lines\n\nFigure 5.8: Staged process for domain engineering of language product lines\n\nto the particularities of specific language development projects. In this methodological toolkit, we propose a set of key activities that guide language designers during the domain engineering phase. Each activity is specified in terms of input and outputs and provides some insights that help language designers during the process.\n\nOur process, which is illustrated in Figure 5.8, is composed of two coarse-grained phases each of which is focused on engineering one implementation concern. The process starts with the engineering of the abstract syntax, then it goes through the engineering of the semantics. It should be noted that the proposed process is not monolithic. Rather, it proposes an iterative fashion to perform the activities thus favoring incremental implementation and continuous improvement. Besides, language designers can come back from the semantics engineering to the abstract syntax engineering (and vice-versa) if during the formulation of the semantics they realize that there are some missing elements in the abstract syntax. The reminder of this section is dedicated to deeply explain the process.\n\n5.2.1 Abstract Syntax Engineering\n\nThe first activity of the domain engineering process is dedicated to the abstract syntax of the language product line. The input of this activity is the domain knowledge owned from domain experts and captured in existing DSLs targeting similar domains. The output of the activity is the definition of all the common assets of the language product line that are related to the abstract syntax. Hence, the main challenge during this phase is to transform domain knowledge (usually unstructured and vaguely described) into well-defined models conforming to some technological space appropriated to describe abstract syntax. To do so, language designers must complete a set of activities—described below—focused on structuring and formalizing the domain knowledge, identifying functional variability, and specifying language modules and variability models for abstract syntax.\nStructure Domain Knowledge\n\nThe first step in abstract syntax engineering is to extract and structure the domain knowledge. At this point, language designers should interview domain experts and explore potentially related DSLs in order to identify the concepts that are relevant for the domain targeted by the language product line under construction. The relationships existing among the domain concepts should be also identified. Usually, this process is termed domain analysis [114, 117] which produces a domain model that will be the backbone of the rest of the domain engineering phase [118].\n\nThere are two important aspects to consider while building a domain model. On one hand, the domain model will constitute a communication bridge between domain experts and language designers. Then, it should be expressed in a formalism simple enough so it can be understood by domain experts—which in most of cases have no computer science background—and formal enough so it does not leave place for ambiguities.\n\nOn the other hand, the definition of the domain model should be as precise as possible. That means that the vocabulary used to name the concepts must clearly reflect the elements of the domain they refer to. Besides, the relationships between the concepts should be correctly named and fully specified in terms of multiplicity and direction.\n\nUsing class diagrams to structure domain knowledge. There are very few modeling languages which are simple and formal at the same time. However, class diagrams are becoming a usual choice to this end; several methodologies for domain analysis use class diagrams as modeling formalism (e.g., [119, 120]).\n\nIn the case of language product lines, the use of class diagrams presents interesting advantages to express the abstract syntax. They can be easily mapped to metamodels, and with some effort, they can be also mapped in BNF-like grammars. Hence, we propose to use class diagrams as modeling languages for structuring domain knowledge. If the domain experts are reluctant to use class diagrams, ontologies can be used to communicate with domain experts, and later transformed to class diagrams as proposed by Tairas et al. [117].\n\nConsider for example the construction of a language product line of DSLs for finite state machines. The objective of the product line is to provide diverse DSLs for state machines that can be configured according to the needs of a particular system. To build this language product line, language designers interview the systems engineers and capture the needs they have with respect the state machines. In addition, there are several specification of state machines languages in the literature (e.g., UML state diagrams [121], Rhapsody [122], and Harel’s state charts [123]) that can be used to enhance the domain knowledge.\n\nFigure 5.9 proposes a domain model for state machines. It includes concepts typically associated to state machines (e.g., states, transitions, triggers) and some additional constructs that, although not directly related in the domain, result quite important for completely expressing a state machine. For example, there is the notion of Constraint needed to express guards in the transition, and the some action scripting instructions to express actions in...\n5. FACILITIES TO SUPPORT TOP-DOWN LANGUAGE PRODUCT LINES\n\nFigure 5.9: A domain model for finite state machines\n\nthe states. The purpose of this domain model is to illustrate our methodology. We will reference it in the rest of the chapter.\n\nIdentify Functional Variability\n\nThe second activity in abstract syntax engineering is to identify the functional variability supported by the language product line. The input of this activity is the domain model whereas the output is a second version of the domain model where each of the concepts are marked as mandatory or optional. The challenge of this phase, is to identify what are those concepts that must appear in all the DSLs as well to identify those concepts that are optional. Note that the mandatory concepts correspond to the commonality of the language product line whereas the optional concepts correspond to its variability.\nUsing the notion of “completeness” to identify functional variability. An effective way to define whether a concept is mandatory or not is by clearly establishing the completeness of a model i.e., to identify the minimum set of concepts needed to build model that can be used in the context in which the language product line will serve. In the case of the state machines, for example, the completeness criterion could be that the state machines are executable. Hence, a DSL for state machines is complete if and only if it provides the minimum elements to create state machines that can be executed. Intuitively, we can state that those elements are: (1) entry points (i.e., initial pseudostates) that indicate the initial point of the execution of the state machine; (2) exit points (i.e., final states) that indicate the end of the execution of a state machine; (3) triggers that allow the state machine to react to events in its environment; and (4) actions in the states to express the executability of each state at runtime. Note that if the state machines are meant to be used only as modeling artifacts describing some behavior with no real execution expected, then the completeness criterion for the DSLs would change and the analysis of functional variability would be different.\n\nFigure 5.10 shows the analysis of functional variability for the example of the state machines. In that figure, optional concepts are marked with the (?) symbol. From the analysis above we can state that, to be executable, a state machine needs core concepts such as StateMachine, Region, AbstractState, State, Transition, Trigger, and PseudoStates. In addition, the concepts InitialState and FinalState are mandatory since they represent entry and exit points respectively. In addition, all the concepts associated to action scripting (i.e., Statement, Block, Loop, Literal, etc) are needed to permit the expression of actions on the states. Contrariwise, the different types of triggers (i.e., AndTrigger, NotTrigger, and OrTrigger) have not necessarily to be available for expressing an executable state machine. They can be viewed as facilities that enhance a given functionality. A similar situation occurs for the different types of pseudostates which enhance the expressiveness of a state machine, but are not fundamental for the executability of a state machine. Note also that the completeness criterion does not demand the existence of guards in the transitions. A state machine can be executable even if the transitions are always launched automatically without checking the state of the environment. As a result, we will define constraints as optional even if we suspect that it is a functionality that will be always desired by final users.\n\nIdentify Concept Clusters\n\nThe next activity in the abstract syntax engineering process is to design a first version of the modular design for the language product line. Concretely, during this activity language designers should identify clusters of language concepts each of which will constitute the abstract syntax of a language module in the modular design. Those concept clusters will be enhanced with semantics during the semantics engineering process thus becoming fully specified language modules. The identification of concept clusters is not a trivial task, however. This process should take into account at least three considerations:\n5. Facilities to Support Top-Down Language Product Lines\n\nFigure 5.10: A domain model with optional/mandatory concepts for finite state machines\n\n- **Alignment with the domain knowledge.** Because concept clusters will constitute the abstract syntax of language modules, and those modules implement language features, the identification of concept clusters will be visible in the feature models. In other words, the identification of concept clusters is not only a first step in the definition of the modular design, but also a first step to the identification of language features of the feature model. In turn, in software product lines engineering feature models are intended to capture domain knowledge [37]. Hence, the identification of concept clusters should consider the domain knowledge. Language designers should be sure that concepts grouped in the same cluster have certain relationship among them so they can be conceived as part of the same atomic feature with a well-defined objective.\n\n- **Alignment with components-based design principles.** Besides being aligned with\n5.2. Methodologies for Top-Down Language Product Lines\n\nthe domain knowledge, the modular design of a language product line must own certain quality degree that guarantees its effectiveness to address the needs of final users under real conditions. Concretely, the modular design should be easy to maintain, reuse, and evolve so it can be easily adapted to dynamic domains. As a result, concept clusters should be defined while respecting well-known design principles (such as high-cohesion and low-coupling) that maximize the modular design’ quality [124, 125].\n\n• **Alignment with the functional variability.** Finally, concept clusters should reflect the functional variability previously identified. For example, concepts marked as mandatory should be separated from concepts marked as optional to guarantees that, at configuration time, there are no modules that must be selected because they include a mandatory concept and that includes an optional concept that, in that case, must be always selected so it is not actually optional.\n\nUsing hierarchical domain analysis to identify concept clusters.** So far, we have discussed some considerations that should be taken into account during concept clusters identification. Let us now discuss some insights that language designers can use to conduct this activity. In particular, there is an observation that results quite useful to this end: the domains associated to a DSL are not necessarily isolated and completely independent [126, 22]. Contrariwise, the domain of a DSL is typically composed of several interdependent and self-contained sub-domains.\n\nConsider for example the domain model for the case of the state machines previously introduced in Figure 5.9. Certainly, all the concepts appearing in the model are relevant in the domain of finite state machines. However, one can identify certain sub-domains that can be analyzed independently. For instance, concepts such as Expression, ArithmeticExpression, Literal, Integer, Boolean, or String are useful for expressing finite state machines but they can be grouped in a the sub-domain of the arithmetic expressions which is a complete domain itself. A similar situation occurs for the domain concepts Constraint and Context. Those concepts belong to the domain of the constraints but are also relevant for the domain of state machines since they permit to express guards in the transitions.\n\nThis observation about sub-domains has been previously exploited in software engineering. Indeed, we can find some research works (e.g., [127, 128]) that analyze the hierarchy of the domain associated to a software system to solve problems such as the recovery of software architectures from legacy systems [127] or the construction of software component libraries [128]. The main idea is to define a relatedness metric to quantify the degree at which two domain elements are related each other. Then, this metric is used to group the domain elements in hierarchical clusters that are viewed as sub-domains which provide useful information about the system under study.\n\nWe propose the use hierarchical domain analysis for the identification of concept clusters. If we are able to build a domains hierarchy from the concepts provided in the domain model, then we can identify some atomic sub-domains that can be defined as clusters whose\n5. FACILITIES TO SUPPORT TOP-DOWN LANGUAGE PRODUCT LINES\n\nFigure 5.11: Venn diagram for the hierarchical domain analysis for state machines\n\nconcepts will be highly related. We propose to use cohesion as relatedness metric between language concepts. This makes sense since the notion of cohesion is associated to the “degree to which the elements of a module belong together” [124]. When the software under study is a domain-specific language, cohesion refers to the relatedness of the language constructs composing a language module.\n\nThe result of the hierarchical domain analysis is a Venn diagram such as the shown in Fig. 5.11 for the example of the state machines. Note that it results quite useful to understand the degree of relatedness among the language constructs. Indeed, using this result we can propose a concrete set of language modules. Concretely, we can identify two main sub-domains: the one at the right of Figure 5.11 including all the concepts related to the expression of state machines themselves, and the one at the left of the same figure including all the concepts related to the expression of action scripts. Furthermore, the sub-domain of the state machines can be, in turn, decomposed in several sub-domains. For example, we can see that the pseudostates from a sub-domain as well as the triggers. The constraints are also part of a sub-domain whereas the core concepts of state machines i.e., StateMachine, Region, State, Transition, AbstractState, and FinalState, form another sub-domain. A similar situation occurs for the sub-domain of action scripting. We can identify three sub-domains: literals, expressions, and control structures.\n\nThe details of how to apply hierarchical domain analysis in languages modularization are deeply explained in Appendix B.\n5.2. Methodologies for Top-Down Language Product Lines\n\nBuild Variability Model\n\nThe third step in the abstract syntax engineering is to build a variability model capturing the functional variability of the language product line. As explained before, we use feature models to this end. Hence, the output of this step is a feature model supporting the functional variability identified in section 5.2.1, and which is aligned with the concept clusters identified in section 5.2.1. It is worth noting that, besides supporting functional variability and being aligned with concept clusters, feature models should own quality attributes such as analyzability, changeability, and understandability [129].\n\nTo achieve those quality attributes, there must exist a design process where the knowledge and experience of software engineers (language designers in this case) is of vital importance. Although it is difficult to define a precise methodology or algorithm to build feature models achieving all those quality attributes, we can use hierarchical domain analysis to provide a first version of the feature model that can be later improved/refined by software engineers according to the specific needs. The hypothesis is that if we use the a hierarchical analysis of the domain knowledge, then the hierarchy of the features in the feature models will correspond to a real domain hierarchy, and feature models will be easy to read for the engineers who will configure the DSLs. To this end, we propose to follow the steps below:\n\n1. **Create a root.** We need to start the construction of the variability model by creating a root. To this end, we propose to create an artificial root implemented as an abstract feature that will have the name of the language product line. In our case, we will call it *State Machines*.\n\n2. **Translate the hierarchical domain analysis into a tree-like structure.** The challenge now is to use the information provided by the hierarchical domain analysis to build the a feature model capturing the functional variability of the language product line. To this end, we propose to produce a simple variability model where each concept cluster is represented in one and only one language feature. The idea is to analyze those clusters according to their position on the Venn diagram in figure 5.11, and use that information to find a good position in the hierarchy for the corresponding feature.\n\n Figure 5.12 shows an example of a feature model created from the hierarchical domain analysis. Note that, in the general case, the fact that a sub-domain is contained by another sub-domain is reflected by a parent-children relationship in the hierarchy of the feature model. However, we decide to pull up the feature *Constraints* to the second level of the tree since it seems to be a DSL at the same level of state machines and action scripting.\n\n Note also that we include some abstract features abstract features i.e., *Pseudostates* and *Triggers* to improve the readability of the model.\n\n3. **Obtain the dependencies graph and add the implies constraints.** To finish the\nconstruction of the variability model, we need to be sure that it encodes all the dependencies among the concept clusters. To do so, we need to obtain the dependencies graph from the concept clusters of the language modular design.\n\nIn this graph, each vertex represents a concept cluster and each arc represents a dependency between two concept clusters. Then, we need to check (one by one) if each dependency is encoded by the hierarchy of the feature model—note that a child feature can be selected if and only if its parent feature is selected so hierarchy is a mechanism to encode dependencies—. If there are non-encoded dependencies, they should be included in the model in the form of implies dependencies.\n\nEvaluate\n\nOnce we have a first version of the language product line, we need to evaluate it in order to guarantee their quality and envision possible improvements. As the reader might imagine, such evaluation is as complex as the evaluation of software product lines. It should take into account not only functional aspects of the reusable assets but also quality attributes such as usability, maintainability, and so on.\n\nIn the case of domain specific languages, both functional testing and quality attributes evaluation are still emergent subjects of research. Although there are some advances in the literature for unit testing [100, 130], and debugging [131], the definition of a complete evaluation framework covering all the aspects of testing of DSLs implemented in the technological space used in this work is still an open issue. Naturally, this fact limits the evaluation of language product lines.\n\nFor the scope of this work, however, we propose a simple evaluation of language product\n5.2. Methodologies for Top-Down Language Product Lines\n\nlines based on the *structural soundness* of its modular design. The structural soundness of a modular design is evaluated in terms of the principles of high-cohesion and low-coupling. These principles have demonstrated benefits in terms of understandability, maintainability, and reuse in object oriented software systems [124, 125]. If we admit that there is some synergy between object oriented programming and language engineering (specially when using metamodeling techniques) we may assume that those benefits are also appearing within the development of domain-specific languages. We envision an empirical study to find out evidence that support such statement as part of the future work of this thesis.\n\nTo evaluate cohesion and coupling in a modular design, it is important to define metrics that indicate the level at which each principle is achieved. In such a way, language designers can objectively evaluate their clusters with respect to cohesion and coupling, and then improve their designs. In this work, we propose to measure cohesion and coupling as follows:\n\n- **Measuring cluster cohesion**: A first approach to measure cohesion was introduced in section 5.2.1 for hierarchical domains analysis. That metric, however, is a pairwise measure that computes the cohesion of two language concepts with respect to the domain model they belong to. For the case of modular design’ evaluation, we need to measure the cohesion at the level of the concept clusters. That is, we need to find a measure of cohesion of each cluster in terms of the relationships existing among their concepts. To this end, we define a new metric termed *cluster cohesion*. Using the notion of *inter-connectivity* provided by Mancoridis et al. [132], we propose to compute cohesion the cluster $Cl_i$ as follows:\n\n **Definition** The cohesion of a cluster $Cl_i$ is computed as the quotient between the amount of relationships (references + inheritances) among the concepts of the cluster and the square of the number of concepts of the cluster.\n\n- **Measuring inter cluster coupling**: The notion of coupling is associated to how strong is the dependency between two software modules [125]. When the software under study is a domain-specific language, we propose to measure coupling in terms of the amount of cross-cutting relationships existing between two language clusters. To this end, we adopt the *inter-connectivity* measure introduced by Mancoridis et al. [132]. Concretely, for each a pair of language clusters $(Cl_i, Cl_j)$ we compute coupling as follows:\n\n **Definition** The coupling between two clusters $Cl_i$ and $Cl_j$ is computed as the quotient between the number of cross-cutting relationships and two times the factor between the amount of concepts in the involved clusters.\n\nFigure 5.13 illustrates structural soundness for modular design in terms of coupling and cohesion. An optimal design is one in which the average coupling of its clusters is minimal whereas the average cohesion of its clusters is maximal. During the development process, language designers could refine the design thus improving the metrics and hence optimizing\nthe structural soundness of the modular design. To this end, they can re-define the concept clusters by increasing/decreasing the granularity level in which the hierarchical domain analysis is used. For example, whereas in the current design we decided to define the clusters Literals, Expressions, and ControlStructures separately, we could also define one single cluster called ActionScripting (note that Figure 5.11 shows that these three clusters conform one sub-domain themselves). This decision will reduce the number of modules, and certainly modify the values for cohesion and coupling. This decision, however, will have an impact on the definition of the variability models so they should be co-evolved with the new version of the concept clusters.\n\n5.2.2 Semantics Engineering\n\nThe second activity of the domain engineering process is dedicated to the implementation of the semantics of the language product line. The input of this activity is the domain model annotated with variability, as well as the first version of the language modular design and variability models produced in the abstract syntax engineering. The output of this activity is the language product line enhanced with semantics. The steps we propose to address this activity are roughly presented in Fig. 5.8. In the reminder of this section we explain them in detail.\n\nFormulate Semantics\n\nThe first step in the semantics engineering phase is to formulate the semantics of each language module identified in the abstract syntax engineering phase. This task should be performed by language designers in junction with the domain experts, which are the stakeholders owning a deep understanding of the domain. The work of language designers\nis to fully understand those semantics and formulate them in some concrete artifacts—as formal as possible—that reduce misunderstandings.\n\nBecause of the technological space we are addressing in this thesis, this step of semantics formulation phase can be inspired from object oriented technologies. Indeed, there are many synergies between executable meta-modeling and object-oriented programming; each language construct is represented by a meta-class and the operational semantics of the DSL is implemented in the form of java-like methods in those meta-classes (a.k.a., domain-specific actions). We propose to take advantage of these synergies and use strategies such as design by contracts in the formulation of the semantics for the language modules.\n\nSince design by contracts has been largely discussed in the literature, we are not going to go further in the explanation of such approach. Rather, in the following we will use it to specify the semantics of one language module of our example of state machines as an illustrative exercise.\n\n**Design by contracts for the CoreFSM module.** Let us use design by contracts to formulate the semantics of the CoreFSM module. This module contains the main functionality of a state machine: evaluating a set of input events by activating and deactivating states that are linked each other by transitions. The idea of this exercise is to take this simple functionality and described it in terms of domain-specific actions and contracts.\n\n**Identify Semantic Variability**\n\nAs part of the process of semantics formulation, language designers and domain experts might conclude that there are several interpretations for the semantics of certain constructs. Indeed, in many cases semantics variability is the main motivation to implement a language product line. There are several examples of this; consider the UML specification which is full of what they call ”semantic variation points” that refer to different possible ways to understand the same concept.\n\nThe challenge in this phase is to identify those possible variation points and select those that are potentially interesting for the final users. Once those variability points are identified, language designers need to specify the different versions of the methods and their contracts.\n\n**Language Modules Implementation**\n\nOnce the contracts of the domain-specific actions are well-defined, the next step is to implement them by writing the corresponding code of the body of the methods. Although this task might be considered as straightforward after the definition of the methods, the truth is that is in the coding phase where language designers actually understand the deep details of the semantics. As a result, during this phase might appear more semantic variation points.\n5. Facilities to Support Top-Down Language Product Lines\n\nUpdate the Variability Model\n\nOnce the semantics is implemented and all the variation points are more or less stable, the next step is to update the variability model by enhancing it with the semantic variability. To this end, language designers should build the orthogonal variability model and link it with the corresponding language features corresponding to the modules they depend.\n\n5.3 Summary\n\nIn this section we introduced a strategy to specify a language product line. Our strategy takes into account languages modularization and languages variability management. For the case of languages modularization, we propose a definition for required and provided interfaces that not only supports the modularization scenarios identified in the literature of software language engineering but also addresses some classical principles identified in the literature of software modularization. In the case of languages variability management, our strategy is based on the combination of feature models with orthogonal variability models. It results most convenient in terms of structure and meaning and favors multi-staged configuration. All these ideas are applicable for metamodels-based DSL whose dynamic semantics is specified through domain-specific actions.\nSo far, we have introduced facilities supporting the construction of top-down language product lines. Besides, we proposed a methodology aimed to guide the domain engineering process. These facilities are useful when the scope of the development project is clear and language designers can justify the effort behind the construction of a language product line. Nonetheless, the construction of a language product line is not always a purpose itself at the beginning of a language development project. Rather, language designers are often asked to build an initial DSL with in a well-defined domain and for a specific purpose, and with the evolution of the project, some variants of the DSLs are needed in order to address new requirements. In such a case, language designers have to create a new development branch and perform the corresponding modifications. This process is repeated or each new variant of the DSL. At some point, it becomes impractical and the challenge is to perform a re-engineering process where the different variants of the DSLs are used to build a language product line from a bottom-up perspective.\n\n**The clone-and-own approach.** We aim to contribute with a strategy to reverse engineering language product lines from sets of existing DSL variants which have been built through the clone-and-own approach. Under this approach, the DSL variants are created by cloning existing versions of a DSL and performing the corresponding adaptations. While several research works have shown that such a practice is quite common in software development projects [133, 134], in a recent work [135] we provided some empirical evidence showing that it is also a common practice in language development. We performed an analysis of a large pool of DSLs obtained from GitHub, and we detected a relevant amount of specification clones among them. The details of this study are presented in Appendix C.\n\n**A running example.** Suppose a team of language designers working on the construction of the DSL for finite state machines. To this end, language designers follow the UML specification [121] thus defining language constructs such as states, regions, transitions,\ntriggers, and so on. Those language constructs are specified in terms of their syntax and semantics. So, at the end of the language development process, they release an executable DSL which behavior complies the UML specification.\n\nOnce this first DSL is released, the language designers are asked to build a new variant, which must comply the Rhapsody specification \\cite{122} (i.e., another formalism to finite state machines). This new variant shares many commonalities with UML state machines, but introduces differences at both syntax and semantics levels \\cite{59}. At this point, language designers face the problem of reusing as much as possible the constructs defined in the first DSL during the construction of this new variant.\n\nOne of the possibilities that language designers have is to use the clone-and-own approach by copy-pasting the specification of the first DSL in a new project (or cloning the repository), and then performing the needed adaptations as shown in Fig. 6.1. This approach permits a fast prototyping of the new DSL variant. After this process, language designers obtain two different DSLs implementing different formalisms of state machines. Those DSLs have some commonalities among them—those commonalities are materialized in terms of specification clones—. And at the same time, the DSL have some particularities that make them unique.\n\nSuppose now that the final users need support for other formalisms for state machines. Hence, the team of language designers is asked to implement two more DSL variants: the first one complying the Stateflow specification \\cite{136}, and the second one complying classical Harel state machines \\cite{123}. If the language designers use, again, the clone-and-own approach, then they will obtain set of four DSL variants. Those variants share specification clones, and own certain particularities.\n\nThe problem that language designers face at this point is two fold. First, they will have to produce a new variant for each FSM formalism. This becomes specially challenging when final users need to combine some specifications to define hybrid formalisms. Language designers will have to produce a new version of each DSL for each desired combination, and the clone-and-own approach becomes impractical. Second, the existence of specification clones increases the maintenance costs of the involved DSLs. If language designers detect bugs in one of the specifications; they will have to check all the DSL variants. While several approaches have been proposed to exploit the notion of code clones to produce software product lines from existing product variants \\cite{137, 138, 139}, in this chapter we exploit\n6.1 Approach Overview\n\nIn this section, we present our reverse engineering technique to support the construction of bottom-up language product lines. As shown in Fig. 6.2, the proposed technique is composed of four steps. During the first step, we automatically recover a language modular design for the language product line. Such a modular design is composed of a set of language modules and a set of dependencies among them. During the second step, language modules’ dependencies are used to synthesize a variability model that can be used, during the third step, to configure concrete DSL variants. Finally, during the forth step the DSL variant is assembled by composing the involved language modules.\n\nIn the following, we explain the way in which we perform the first and second steps (i.e., recovering language modular design and synthesis of variability models). Since the resulting language product line is specified in terms of the meta-languages introduced in Chapter 5, the third and fourth steps (i.e., configuration and composition) can be performed as explained in sections 5.1.2 and 5.1.1, and will not be discussed in this section.\n\n6.2 Recovering a Language Modular Design\n\nLet us start the description of our reverse engineering technique by explaining the way in which we identify the set of language modules and dependencies that constitute the language modular design of the product line. Roughly speaking, we propose to take all\n\nFigure 6.2: A reverse-engineering strategy to bottom-up language product lines\n\nthe notion of language specification clones to reverse engineering language product lines from existing DSL variants.\nthe given DSL variants and unify them in a unique DSL. Then, the unified DSL is broken down into several interdependent language modules. This process results in a factorization of the specification clones existing in the DSL variants. The purpose of this strategy is to remove as many specification clones as possible, thus reducing the maintenance costs. Our factorization strategy is based on four principles explained in the following:\n\n**Principle 1: DSL specifications are comparable.** Hence, specification clones can be detected automatically. To detect the specification clones in a given set of DSL variants, we need to compare those specification clones and find out the repeated specification elements. For the technological space discussed in this thesis, specification elements for the abstract syntax correspond to metaclasses whereas specification elements for the semantics correspond to domain specific actions. Hence, comparison of DSL specifications corresponds to compare metaclasses and domain specific actions.\n\n**Comparison of metaclasses.** To compare metaclasses, we need to take into account that a metaclass is specified by a name, a set of attributes, and a set of references to other metaclasses. Two metaclasses are considered as equal (and so, they are clones) if all those elements match. Formally, comparison of metaclasses is defined by the operator $\\equiv$.\n\n$$\\equiv : MC \\times MC \\rightarrow bool$$\n\n$$MC_A \\equiv MC_B = true \\implies MC_A.name = MC_B.name \\land$$\n$$\\forall a_1 \\in MC_A.attr \\mid (\\exists a_2 \\in MC_B.attr \\mid a_1 = a_2) \\land$$\n$$\\forall r_1 \\in MC_A.refs \\mid (\\exists r_2 \\in MC_B.refs \\mid r_1 = r_2) \\land$$\n$$|MC_A.attr| = |MC_B.attr| \\land$$\n$$|MC_A.refs| = |MC_B.refs|$$\n\n**Comparison of domain specific actions.** To compare domain specific actions, we need to consider that –similarly to methods in Java– domain specific actions have a signature that specifies its contract (i.e., return type, visibility, parameters, name, and so on), and a body where the behavior is implemented. Two domain specific actions are equal if their signatures and bodies are equivalent. Whereas comparison of signatures can be performed by syntactic comparison of the signature elements, comparison of bodies can be arbitrary difficult. If we try to compare the behavior of the domain-specific actions, then we will have to address the semantic equivalence problem, which is known to be undecidable [140]. To address this issue, we conceive bodies comparison in terms of its abstract syntax tree as proposed by Biegel et al. [141]. In other words, to compare two bodies, we first parse them to extract their abstract syntax tree, and then we compare those trees. Note that this decision makes sense because\nwe are detecting specification clones more than equivalent behavior. Formally, comparison of domain-specific actions (DSAs) is defined by the operator ≐.\n\n\\[ \\text{\\( DSA_A \\approx DSA_B \\Rightarrow \\text{true} \\)} \\quad (6.3) \\]\n\n\\[ \\begin{align*}\nDS_A \\approx DS_B & = \\text{true} \\\\\n&D S_A . \\text{name} = DS_B . \\text{name} \\land \\\\\n&D S_A . \\text{returnType} = DS_B . \\text{returnType} \\land \\\\\n&D S_A . \\text{visibility} = DS_B . \\text{visibility} \\land \\\\\n&\\forall p_1 \\in DS_A . \\text{params} \\mid (\\exists p_2 \\in DS_B . \\text{params} \\mid p_1 = p_2) \\land \\\\\n&\\lvert DS_A . \\text{params} \\rvert = \\lvert DS_B . \\text{params} \\rvert \\land \\\\\n&D S_A . \\text{AST} = DS_B . \\text{AST} \\\\\n\\end{align*} \\quad (6.4) \\]\n\n**Principle 2:** Specification clones can be viewed as sets’ intersections, which is useful to factorization. A DSL specification can be seen as a set of metaclasses and a set of domain specific actions. In doing so, specification clones correspond to intersections among those sets. Those intersection elements can be specified once and reused in several DSL variants [142, p. 60-61]. Hence, we can factorize specification clones by breaking down the intersections existing among DSL specifications.\n\nFig. 6.3 illustrates this observation through the running example on finite state machines. We show two Venn diagrams to represent both syntax and semantic intersections. The Venn diagram corresponding to the abstract syntax shows that the classical constructs for state machines such as StateMachine, State, and Transition are in the intersection of the three given DSL variants i.e., UML state machines, Rhapsody, and Harel’s state machines. In turn, there are certain particularities for each DSL. For example, the concept AndTrigger is owned by UML and Harel state machines but not for Rhapsody. Concepts such as OrTrigger and NotTrigger are only provided by Harel state machines since the concept of Choice is exclusive of UML state machines.\n\nFor the case of semantic variability, the 3-sets intersection is empty meaning that there is not a common semantic for the three DSL variants. Rather, UML state machines and Rhapsody share the domain specific actions corresponding to the constructs of State Machine, State, and Transition. The implementation of Harel state machines is different.\n\nNote that this way to conceive DSL specifications is useful to factorize specification clones as illustrated in Fig. 6.4. Each different intersection is separated in a separate subset that, as we will explain later, is encapsulated in a language module.\n\n**Principle 3:** Abstract syntax first, semantics afterwards. The abstract syntax is the backbone of the DSL specification; it specifies its structure in terms of metaclasses and relationships among them whereas the domain-specific actions add executability to the metaclasses. Hence, the process of breaking down intersections should be performed for the abstract syn-\ntax first, thus identifying the way in which metaclasses should be grouped into the different language modules. Afterwards, we can do the proper for the semantics. In doing so, we need to take into consideration the phenomenon of semantic variability. That is, two cloned metaclasses might have different domain-specific actions. That occurs when two DSLs share some syntax specification but differ in their semantics.\n\n**Principle 4:** Breaking down a metamodel is a graph partitioning problem. A metamodel can be seen as a directed graph $G = (V, A)$ where:\n\n- $V$: is the set of vertices each of which represents a metaclass.\n- $A$: is the set of arcs each of which represents a relationship between two metaclasses i.e., references, containments, and inheritances.\n\nThis observation is useful for breaking down metamodels, which can be viewed as a graph partitioning problem where the result is a finite set of subgraphs. Each subgraph represents the metamodel of a language module.\n\n**The principles in action.** Fig. 6.5 shows the way in which we recover a language modular design through the principles explained above. It is composed of two steps: unification and breaking down.\n6.2. Recovering a Language Modular Design\n\nUnification: match and merge. The objective of this step is to unify all the DSL variants in a unique specification. To this end, we first produce a graph $G$ for the metamodel of each DSL variant according to the principle 4. Second, we use the comparison operators defined in the principle 1 to match the vertices representing the metaclasses repeated in two or more DSL variants. Third, we create the syntactic intersections defined in principle 2 by merging the matched vertices. In doing so, we remove cloned metaclasses. After this process, we have a unified graph (which is not necessarily a connected graph) including all the metaclasses provided in the DSL variants.\n\nTo identify semantic intersections, we check whether the domain specific actions of the matched metaclasses are equal. If so, they can be considered as semantic specification clones, and they are also merged. If not all the domain specific actions associated to the matched metaclasses are equal, different clusters of domain specific actions are created, thus establishing semantic variation points.\n\nBreaking down: cut and encapsulate. Once intersections among the DSL variants have been identified, we factorize the specification clones. To this end, we break down the unified graph using a graph partitioning algorithm. Our algorithm returns a set of clusters of vertices: one cluster for each intersection of the Venn diagram. Arcs defined between vertices in different clusters can be considered as cross-cutting dependencies between clusters. Finally, we encapsulate each vertex cluster in the form of a language module.\n\nNote that the dependencies between language modules can be viewed through the interfaces introduced in chapter 5. Those interfaces are reverse-engineering from each module.\nRequired interfaces are generated by creating a virtual element for those elements that are required by the module but that are not part of its definition. The provided interface is generated by defining all the specification elements of the language module as public. If there are specification elements that should be hidden, then the language designer should modify the generated definition.\n\n6.3 Synthesizing Language Variability Models\n\nwe define an algorithm to synthesize variability models from a given language modular design. This algorithm produces not only a feature model with the abstract syntax variability, but also an orthogonal variability model representing the semantic variability. An overview of the approach is presented in Fig. 6.6.\n\n**Figure 6.6: Reverse-engineering variability models for language product lines**\n\n*Synthesizing abstract syntax variability.* The first step to represent the variability of a language product line is to extract the feature model that represents the abstract syntax variability. To this end, we need an algorithm that receives the dependencies graph between the language modules, and produces a feature model which includes a set of features representing the given language modules as well as a set of constraints representing the dependencies among those modules. The produced feature model must guarantee that all the valid configurations (i.e., those that respect the constraints) produce correct DSLs.\n\nIn the literature, there are several approaches for reverse engineering feature modules from dependencies graphs (consider for example the approach presented by Assunção et al. [143], or the one presented by She et al., [144]). In our case, we opt for an algorithm\nthat produces a simple feature model where each language module is represented in a concrete feature, and where the dependencies between language modules are encoded either by parent-child relationships or by the classical \\textit{implies} relationship. Our algorithm was inspired from the approach presented by Vacchi et al. [91] which fulfills the aforementioned requirements. Besides, it has been applied for the particular case of languages variability.\n\nThe tooling that supports our algorithms is flexible enough to permit the use of other approaches for synthesis of feature model. To this end, we provide an extension point that language designers can use to add new synthesis algorithms. In addition to the one proposed by Vacchi et al. [91], we have integrated our approach with the one provided by Assunção et al., [143].\n\n\\textbf{Synthesizing semantic variability.} Once the feature model encoding abstract syntax variability is produced, we proceed to do the proper with the orthogonal variability model encoding semantic variability. To this end, we need to analyze the results of the process for extracting the language modules. As explained in Section 6.2, according to the result of the comparison of the semantics, a language module might have more than one cluster of domain specific actions. This occurs when the two DSLs share constructs that are equal in terms of the abstract syntax, but differ in their semantics. Since this is the definition of semantic variation point, we materialize those clusters in semantic variation points of an orthogonal variability model.\n\nTo do this, we scan all the language modules. For each one, we verify if it has more than one cluster of domain specific actions. If so, we create a semantic variation point where each variation references one cluster. Finally, the semantic variation point is associated with the feature that represents the language module owning the clusters.\n\n\\section{Summary}\n\nIn this section we presented a reverse-engineering process that allows to automatically produce a language product line from a set of existing DSLs. Our reverse-engineering process starts by breaking down the DSLs into a set of reusable language modules. Then, the process goes through the synthesis of the models that capture the variability existing among the extracted language modules. Since we use the meta-languages introduced in chapter 5, the generated artifacts can be used to configure and assembly new DSLs.\nPart III\n\nImplementation and Validation\nIn this chapter, we present Puzzle: a toolkit that implements the ideas introduced in the contributions of this thesis. It is implemented on top of the Eclipse Modeling Framework (EMF)\\(^1\\), and it is based on K3\\(^2\\) and Mélange\\(^3\\). Used together, EMF, K3, and Mélange constitute a language workbench to support the definition of executable DSLs where the abstract syntax is specified through metamodels, and the semantics is specified operationally through domain-specific actions. From a high-level perspective, Puzzle can be viewed as a set of extensions to support the construction of language product lines.\n\n### 7.1 Using EMF, K3, and Mélange to Specify DSLs\n\nEMF is a framework provided by Eclipse that offers a set of capabilities focused on facilitate modeling intensive tasks. Probably, the most visible feature provided by EMF—and the one in which we are more interested for the context of this thesis—is the Ecore metamodel language. Such metamodel language is intended to facilitate the definition of the abstract syntax of the DSL by means of metamodels.\n\nOnce we have a mechanism to express metamodels, we need one for the expression of operational semantics. To this end we use K3, which introduces the notion of aspect [69] to facilitate the injection of domain-specific actions to a given metamodel.\n\nThe role of Mélange in this context is to facilitate the integration of metamodels with domain specific actions. To do so, Mélange provides meta-language to enable the description in-the-large of the specification artifacts of a given DSL. Hence, in a Mélange script, a language designer can reference a metamodel, inject it some aspects, and perform the weaving process to obtain a complete and executable DSL. In the remainder of this section, we explain how to use those elements though a set of simple examples.\n\n---\n\n\\(^1\\)EMF website: [https://eclipse.org/modeling/emf/](https://eclipse.org/modeling/emf/)\n\n\\(^2\\)K3 website: [https://github.com/diverse-project/k3](https://github.com/diverse-project/k3)\n\n\\(^3\\)Mélange website: [http://melange-lang.org/](http://melange-lang.org/)\n### Defining aspects in K3\n\nThe very first consideration to keep in mind about K3 is that it is the evolution of Kermeta. Kermeta is a language workbench that provides the notion of aspect for specifying operational semantics, and an action language for implementing those semantics. The difference of K3 with respect to the last versions of Kermeta is that K3 does not provide an action language. Rather, it uses Xtend\\(^4\\) for the definition of semantics, and provides the functionality needed to encapsulate Xtend methods in aspects that can be later weaved in metamodels.\n\nConsider the metamodel introduced at the top of Figure 7.1. It contains two classes X, and Y; The class X contains elements of type Y by means of the containment relation yes. In turn, the code snippet at the bottom of Figure 7.1 introduces some operational semantics to this metamodel by using K3. Note that the main feature of K3 is the notion of aspect that permits to weave the operational semantics defined in a Xtend class to a metamodel defined in Ecore.\n\n```xtext\n@Aspect(className=X)\nclass XAspect{\n def void eval(){\n println(\"Evaluating X\")\n _self.yes.forEach[y|y.eval()]\n }\n}\n\n@Aspect(className=Y)\nclass YAspect{\n def void eval(){\n println(\"Evaluating Y\")\n }\n}\n```\n\n**Figure 7.1:** Simple example of aspects in K3\n\nIn our example, the metaclass X is enriched with the operation `eval()` that contains a loop that sequentially invokes the operation defined for the class Y. This operation is also defined by using one aspect; in this case extending the metaclass Y. Note that the language designer is free to name the aspects as he/she considers correct. In this example, we use the convention `<<metaclass.name>>+Aspect`.\n\nBecause K3 is implemented on the top of the EMF, it is possible to use it in junction with tools such as xText [145] or Sirius [146] for generating textual or graphical editors.\n\n---\n\n\\(^4\\)Xtend website: https://eclipse.org/xtend/\nAs a result, we can completely construct DSLs by using this framework: abstract syntax with metamodels in Ecore, semantics with K3, and concrete syntax with editors generators. However, as we mentioned in the definition of the scientific scope of this thesis, our approach for modularization and variability management does not cover this dimension of the specification of a DSL.\n\n**Integrating abstract syntax and semantics with Mélange.** Let us now to illustrate the integration of a metamodel written in Ecore with the aspects specified in K3. We use Mélange with that purpose as illustrated in Listing 7.1. To do so, we first define the language itself through the keyword `language`. In the example, we define a language called “Example” for which the abstract syntax is defined in a metamodel called `example.ecore` through the keyword `syntax`, line 4. Then, we enhance that metamodel with the two aspects defined in K3 in Fig. 7.1 through the keyword `with`, lines 6 and 7.\n\nNote also that Mélange provides the expressiveness to execute a model conforming to the defined language. To this end, Mélange provides the keyword `transformation`; lines 10-14 exemplify its use on our simple example. The transformation loads a model located in the file `toy.example`, locates the head element (that should by an instance of `X` since it is the root of the containment tree of the metamodel) and calls the method `eval()` defined in the `XAspect`.\n\n**Listing 7.1:** Example for the use of Melange to integrate metamodels and aspects\n\n```java\npackage SimpleExample\n\nlanguage Example{\n syntax \"platform:/resource/example/models/example.ecore\"\n with fr.inria.diverse.examples.XAspect\n with fr.inria.diverse.examples.YAspect\n}\n\ntransformation executeExample{\n var m = SimpleExample.load(\"toy.example\")\n var rootX = m.head as X\n rootX.eval()\n}\n```\n\n### 7.2 Capabilities of Puzzle\n\nIn this section, we describe the capabilities provided by Puzzle to support language product lines engineering, and show how those capabilities can be used in concrete scenarios. As the same as our contributions, those capabilities can be classified into two different types. First, those supporting top-down language product lines engineering; second, those supporting bottom-up language product lines engineering.\n7. IMPLEMENTATION: THE PUZZLE TOOLKIT\n\n7.2.1 Capabilities to Support Top-Down Language Product Lines\n\nLet us start our description of the capabilities of Puzzle by introducing the support that it provides for the construction of top-down language product lines. Puzzle supports the meta-language extensions introduced in Section 5.1, Chapter 5 for the definition of modular DSLs and the expression of variability models for both abstract syntax and semantics.\n\nModular Specification of DSLs\n\nThe first aim of Puzzle is to provide a language modularization approach that supports all the language modularization scenarios while addressing three well known software modularization principles i.e., independent development, information hiding, and substitutability. To do so, we need to enable the definition of language modules with required and provided interfaces. Besides, we need to provide a mechanism to enable the binding between two language modules in order to perform compatibility checking and composition.\n\nSupport for required interfaces in Puzzle. As deeply explained in Section 5.1.1, the definition of a required interface corresponds to the definition of virtual elements within a language module. To support such definitions, Puzzle introduces some modularization annotations on Ecore metamodels. For the concrete case of required interface, we introduce the annotation @Required. By default, a specification is non-virtual –the flag “virtual” is set in false–; a specification element annotated with @Required becomes virtual –the flag “virtual” is set to true– and the element is included to the required interface.\n\nFig. 7.2 illustrates the use of the @Required annotation through the example on state machines (see Fig. 5.2). The example is composed of an Ecore file (at the top of the figure) and a semantics specification (at the bottom of the figure). In the metamodel, the meta-class Constraint is virtual so it is annotated with @Required as well as the eval() operation. It means that the required interface includes not only abstract syntax elements, but also semantic ones. The definition of the eval() operation in the required interface permits its use in the definition of the semantics of the state machines language.\n\nSupport for provided interfaces in Puzzle. The definition of provided interfaces corresponds to explicitly indicate if the specification elements of a language module are either public or private. To support such a capability, we introduce the @Private annotation. By default, all the specification elements are defined as public so they belong the provided interface. If a specification element is annotated with @Private, then its visibility is set to private and it is removed from the provided interface.\n\nFig. 7.3 shows the definition in Puzzle for the language module to express constraints. In that case, we decided to hide all the specification elements of the module except Program and Constraint because, as explained before, one might consider that they represent the functionality of the language module. All the other specification elements are annotated with @Private and they will not appear in the provided interface of the language module.\n7.2. Capabilities of Puzzle\n\nFigure 7.2: Example of required interfaces in Puzzle\nFigure 7.3: Example of provided interfaces in Puzzle\n**Expressing bindings between language modules.** So far, we used required and provided interfaces in the definition of two language modules i.e., one for state machines and another one for constraints. Those modules have a dependency between them: the module for state machines uses some constraints to express guards in the transitions. But... how to define the binding between those modules and perform the corresponding composition?\n\nNote that the binding between two language modules is not defined at the level the modules themselves but at the level of their interfaces. In other words, we do not bind a requiring language module with a providing one, but a required interface to with provided one. We also need to consider that those interfaces should be expressed in terms of model types; currently they are just expressed as annotations in the metamodel. Hence, as a first step we extract the required/provided interfaces from the meta-models by analyzing the annotations; Puzzle provides a service that is able to do this automatically, thus creating the corresponding model types by extracting the elements annotated with @Required and @Private respectively. Once we have the model types corresponding to each interface of language modules, we can proceed to use Mélange to index all these specification artifacts as shown in Listing 7.2.\n\n**Listing 7.2:** Example for the use of Melange to integrate metamodels and aspects\n\n```java\npackage SimpleFSM\n\nlanguage CoreFSM requires RequiredFSM{\n syntax \"platform:/resource/fsm/models/fsm.ecore\"\n with fr.inria.diverse.fsm.StateMachineAspect\n with fr.inria.diverse.fsm.StateAspect\n with fr.inria.diverse.fsm.TransitionAspect\n ...\n}\n\nmodeltype RequiredFSM{\n syntax \"platform:/resource/fsm/models/fsm-req.ecore\"\n}\n\nlanguage Constraints implements ProvidedConstraints{\n syntax \"platform:/resource/constraints/models/const.ecore\"\n with fr.inria.diverse.constraints.ConstraintAspect\n with fr.inria.diverse.constraints.StmtBlockAspect\n with fr.inria.diverse.constraints.BooleanExpressionAspect\n ...\n}\n\nmodeltype ProvidedConstraints{\n syntax \"platform:/resource/constraints/models/const-prov.ecore\"\n}\n```\n7. Implementation: The Puzzle Toolkit\n\nIn this Mélange script, each interface is defined by the keyword `modeltype` that references an Ecore file that contains its definition. Besides, the requiring module—in this case, the CoreFSM module defined in lines 3-10—references its required interface through the keyword `requires`. In turn, the providing module—in this case the Constraints module defined in lines 16-23—references its provided interface through the keyword `implements`. The binding between those interfaces is the verification of the subtyping relationship among them. If such a relationship is respected, then the modules are compatible i.e., the services of the provided interface fulfill (at least partially) the needs of the required one, and the composition can be performed.\n\nExpression of Language Variability Models and Configuration\n\nThe expression of the variability existing in a language product line is performed via a dedicated metamodel that offers the expressiveness enough to define not only the feature models representing the abstract syntax variability, but also the orthogonal variability model to represent semantic variability and the mapping among these dimensions.\n\nFig. 7.4 shows how the editor looks like for the example of the state machines. One of the most important characteristics of this editor is that it allows the configuration of a particular DSL. Each feature and variability point can be selected or deselected in the model. Once the configuration is finished, then language designers can use the a menu option to launch a generation process that will produce a Mélange script describing the involved module and the corresponding aspects. Then, this script can be used to perform the composition and obtain the DSL.\n\nFigure 7.4: Variability management in Puzzle\n7.2.2 Capabilities to Support Bottom-Up Language Product Lines\n\nIn this section, we present the capabilities provided by Puzzle to support bottom-up language product lines. Concretely, Puzzle offers a set of facilities for the analysis of a set of existing DSL variants and the subsequent reverse-engineering process that permit to extract a language product line from the commonalities and particularities existing among them.\n\nThe very first activity we need to perform in the analysis of a given set of DSLs is the identification of their commonalities. As explained in Chapter ??, our definition of commonalities is based on the notion of specification clones. Then, we need to start by detecting the specification clones in a set of DSL variants. Once those clones are detected, Puzzle provides a mechanism to visualize and quantify those clones. The idea is to provide a set of metrics that allow language designers deciding if there is potential reuse enough to justify a reverse-engineering process. If so, Puzzle offers an automatic process to extract the specification clones in the form of reusable language modules. Besides, both commonalities and particularities are captured by synthesizing variability models. The reminder of this section is dedicated to illustrate each of the aforementioned capabilities.\n\nDetection of Specification Clones\n\nIn order to enable detection of specification clones, Puzzle provides a set of comparison operators. These operators take into account not only the names of the constructs, but also the inter-constructs relationships and their semantics. The objective of those operators, is to find out all these segments in the specification that have been introduced through the copy&paste practice. The definition of the composition operators is deeply explained in Section 6.2. However, at implementation level, Puzzle is flexible enough to permit the definition of new comparison operators. Hence, the detection strategy can be easily improved or adapted to particular contexts.\n\nOnce those clones are detected, Puzzle permits to visualize them in the form of a Venn diagram. Using these diagrams, language designers can have an idea about the existing commonalities among the involved DSLs. Fig. 7.5 shows the Venn diagrams generated by Puzzle for the case of the example of state machines. It detects specification clones between UML state machines, Rhapsody, and Harel’s state machines and at the level of abstract syntax and semantics. The reader can also see a video\\(^5\\) that shows the process.\n\nQuantification of Potential Reuse\n\nVisualizing specification clones in terms of Venn diagrams can be useful to get a preliminary idea on the potential reuse existing among a set of DSL variants. However, language designers might need further information to decide if such a potential reuse is enough to justify a reverse-engineering process. To address this issue, Puzzle comes out with a set of\n\n\\(^5\\) Video: Detection of specification clones: https://www.youtube.com/watch?v=uN0tb9TYuyQ\nmetrics (illustrated in Fig. 7.6 and inspired in [147]) to quantify the potential reuse emerging from the existing specification clones. Those metrics are briefly described below. The objective is to provide a mechanism that allows language designers to estimate (in an objective fashion) the benefit of a reverse engineering process intended to remove specification clones in a given set of DSL variants.\n\nNote that all the metrics are presented in the form of charts implemented as HTML reports that can be easily shared and published.\n\n1. **Size of Commonality (SoC)**: The SoC metric measures the amount of specification elements that are common to all the given DSLs. These specification elements are also known as the core of the involved DSLs in the sense that, if we synthesize a language product line, these concepts will be present in all the configurations.\n\n2. **Product-Related Reusability (PRR)**: The PRR metric measures the percentage of common elements of each DSL with respect the core. It provides an idea on how similar is the DSL with respect to the core of the DSLs.\n7.2. Capabilities of Puzzle\n\nSize of Commonality (SoC)\n\nProduct Related Reusability (PRR)\n\nIndividualization Ratio (IR)\n\nPair-wise Relationship Ratio (PWRR_{i,j})\n\nFigure 7.6: Metrics for quantification of potential reuse\n\n(3) **Individualization Ratio** ($IR_i$): The $IR_i$ metric measures the percentage of specification clones of each DSL with respect to the rest of the DSLs. In other words, it shows for each product the amount of конструкtions/methods that are included in at least another DSL.\n\n(4) **Pairwise Relationship Ratio** ($PWRR_{(i,j)}$): The $PWRR_{(i,j)}$ metric measures the percentage of common elements of each DSL with each of the other DSLs. Concretely, it shows, for each DSL, the amount of конструкtions/methods that are included each of the other DSL.\n\nWe provide a video\\(^6\\) that shows the manner in which Puzzle computes and deploys the results of the quantification process described above.\n\n**The Reverse-Engineering Process**\n\nOnce the specification clones existing in a set of DSLs are detected and quantified, then we can proceed to the reverse engineering process that ends up in a language product line. As deeply explained in Section 6.1, this process starts with the recovering of a language modular design, and finishes with the synthesis of the corresponding variability models.\n\nThe support that Puzzle provides to this reverse engineering process is illustrated in video\\(^7\\). At the end of this process, the language designer will have a result as the one presented in the screen-shot introduced in Fig. 7.7. On one hand, the Puzzle creates a visual diagram representing the extracted language modules. Besides, the languages are actually broken down in several projects that can be viewed in the Project Explorer view. The corresponding variability models are generated as part of the process as well.\n\n\\(^6\\)Video: Quantification of spec. clones: [https://www.youtube.com/watch?v=yfkwrk_uF8](https://www.youtube.com/watch?v=yfkwrk_uF8)\n\n\\(^7\\)Video: Extraction of language modules: [https://www.youtube.com/watch?v=sqF2NQMbGxY](https://www.youtube.com/watch?v=sqF2NQMbGxY)\nLet us close this implementation chapter with a brief description of the architecture we designed for Puzzle. It is composed of two parts illustrated in Fig. 7.8: the infrastructure and the superstructure. The *infrastructure* is a set of plug-ins that enable the specification of DSLs according to the technological space that we target in this thesis. Notably, the Puzzle’s infrastructure is composed of EMF, Xtend, K3, and Melange. In turn, the *superstructure* is a set of plug-ins that provides analysis and reverse-engineering techniques on the DSLs specified on top of the infrastructure.\n\nThe plug-ins of the Puzzle’s superstructure can be divided into seven categories according to their functionalities: core, composition, language architecture, language variability, comparison, metrics, and reverse-engineering. Each of those categories are briefly explained below:\n\n1. **Ui.** The plug-ins in this category implement the menu options and editor facilities provided by Puzzle to facilitate the interaction with language designers.\n\n2. **Composition.** These plug-ins implement the composition functionality for language modules. This functionality includes the different strategies for matching and merging of both abstract syntax and semantics.\n\n3. **Language architecture.** These plug-ins implement the metamodel and corresponding editors for the description of a set of language modules and the dependencies among them.\n(4) **Language variability.** These plug-ins implement the metamodel and corresponding editors for the description of language variability models i.e., feature models for abstract syntax variability and orthogonal variability models for semantic variability.\n\n(5) **Comparison.** Comparison plug-ins implement the comparison operators needed to detect specification clones at the level of abstract syntax and semantics (for the case of comparison of semantics, Puzzle uses JCCD [141]).\n\n(6) **Metrics.** The metrics plug-ins compute a set of metrics for the detected specification clones and present the results as a set of HTML reports that display those metrics in the form of charts.\n\n(7) **Reverse-engineering.** The reverse-engineering plug-ins implement the algorithms that extract reusable language modules from the detected specification clones.\n\n## 7.4 Summary\n\nThis chapter presented Puzzle, a tool that implements all the ideas introduced in the contribution of this thesis. Along the chapter, we introduced K3 and Mélange, which used together constitute a language workbench for specification of executable DSLs. Then, we show how we extended this language workbench to support language product lines engineering.\nIn this chapter, we present the validation of this thesis. To this end, we introduce three case studies that show the applicability of our ideas in concrete scenarios. Fig. 8.1 shows an overview of these case studies with respect to the contributions of the thesis; there are two case studies intended to validate our contributions on top-down language product lines, and one case study doing the proper for our contributions on bottom-up language product lines.\nTo validate our contributions on top-down language product lines, we start by validating our languages modularization approach since we consider that it is the backbone of the contribution. This validation is based on revisiting the modularization of UML. In other words, we will show that our language modularization approach is expressive enough to support the modular design used in the specification of UML. Afterwards, we present a case study that focus not only in modularization but also in variability management. This case study corresponds to a language product line for different versions of a basic programming language that can be used for teaching purposes.\n\nTo validate our contributions on bottom-up language product lines, we use the case study of the state machines that we have used all along this thesis as illustrative example. As a matter of fact, this case study comes from an industrial context. It is one of the motivations of the VaryMDE project, a bilateral collaboration between Thales and INRIA.\n\n8.1 Revisiting the Modular Design of UML\n\n8.1.1 Problem: UML is a Composition of Several “Language Units”\n\nThe objective of this first case study is to show the applicability of our language modularization approach in a complex scenario. To this end, we revisit the case of UML, which specification is a divided into different language modules (they use the term language units).\n\nEach module contains the specification of a type of diagram (e.g., use cases, classes, and deployments). Indeed, the UML specification starts with the following statement:\n\n“The modeling concepts of UML are grouped into language units. A language unit consists of a collection of tightly- coupled modeling concepts that provide users with the power to represent aspects of the system under study according to a particular paradigm or formalism. For example, the State Machines language unit enables modelers to specify discrete event-driven behavior using a variant of the well-known statecharts formalism, while the Activities language unit provides for modeling behavior based on a workflow-like paradigm.”\n\nTo validate our approach, we implement the UML specification while respecting its modular design. We want to check whether the complex dependencies among the different types of UML diagrams can be expressed through our approach.\n\n8.1.2 Solution: Language Interfaces\n\nFig. 8.2 introduces a diagram that shows the language modules of UML and the dependencies among them. To implement the case study, the each module has been specified in an Ecore model and the dependencies among them are expressed through the required and provided interfaces defined by our approach. The remainder of this section is dedicated to report on the results that we obtained. However, explaining the entire case study be too long.\n8.1. Revisiting the Modular Design of UML\n\nHence, we chose two language modules i.e., *Classes* and *Deployments* that we consider as representative and we explain them in detail.\n\n\n\n**Figure 8.2:** Modules for the UML case study\n\n**Classes vs. Deployments.** Fig. 8.3 shows the abstract syntax specification for two language modules UML: *Classes* and *Deployments*. The first one offers the functionality to express class diagrams whereas the second one does the proper for deployment components. Note that the *Classes* module provides a number of abstractions that result useful for other modules including the *Deployments* one that uses and extends several of those abstractions. For example, The meta-class called *Artifact* uses the meta-classes *Operation* and *Property*\nFigure 8.3: Modules for the UML case study\n\nas part of its specification. Besides, the Artifact meta-class is a sub-class of the Classifier and NamedElement meta-classes.\n\nThis is probably one of the most important learned lessons that we got from this case study. We can find more than one modularization scenario in the interaction of two language modules: the meta-class Artifact uses (by aggregation) the meta-classes Operation and Property and, at the same time, extends the meta-classes Classifier and NamedElement.\n\nAnother interesting situation is the case of the meta-class called Property which is extended through a new super-class. That means that in languages modularization, the open-class approach should permit not only the injection of new properties and operations but also new super-types. Thanks to the composition algorithm we use and the notion of re-\nquired interface that permits to have non virtual specification elements within virtual meta-\nclasses, we can support such requirement.\n\nThe most challenging issue that we addressed during the implementation of the case\nstudy corresponds to the definition of the provided interfaces for the language modules. It is\ndifficult to realize what are the specification elements that represent the core functionality of\na language module versus the ones that correspond to implementation details. Indeed, one\nof the problems we faced to this definition is that the requirements of the language modules\nare already defined. Hence, we are afraid that the definition of the provided interface is\nbiased. More than the elements that represent core functionality of each language module,\nwe tended to include those that are used by other modules.\n\nWe claim that, as the same as in the general case of software architecture, there is still\nroom to the definition of correct methodologies that provide insights to guide the design\nof both provided and required interfaces. For the case of provided interfaces, we need to\nestablish what is the meaning of ”representing functionality” and evaluating the risk of\nevolution of each of the specification elements. For the case of the required interfaces, we\nneed to have mechanisms that allow us to identify the more general abstractions required\nby a certain language module in order to increase the number of language modules that can\nfulfill those abstractions.\n\nThe source code of this case study can be found on GitHub¹.\n\n8.2 Logo for Progressive Programming Learning\n\nThe objective of this case study is to show the applicability of our contributions on top-\ndown language product lines in a specific domain with well-defined needs. To this end, we\nchose a case study on education in computer science, which has been inspired by previous\nworks in the literature [95, 10]. It focuses on the definition of several DSL variants to\nfacilitate progressive learning of programming skills.\n\nThe main principle is to define a set of incremental learning levels for a group of students,\nand support each level with a dedicated language variant, which contains only the constructs\nthat the students will learn during the level. Once the students master all the constructs in\na given level, they can upgrade to the next one. It will be supported by a new language\nvariant including the new constructs that constitute the next learning challenge.\n\nNote that the notion of progressive learning is not necessarily restricted to the existence of\ndifferent DSL variants. Contrariwise, it can be achieved by using only one version of the\nprogramming language containing all the constructs that the students will learn along the\nentire learning process. In such a case, each learning level is dedicated to explain a subset\nof those constructs and students are asked to omit the other ones.\n\nThe problem with this approach is that students are exposed to many constructs at the\n\n¹https://github.com/damende/puzzle/tree/master/examples/uml\nsame time in the programming tooling (i.e., editors) even if they are learning just a subset of those constructs. This increases the cognitive load for the students making more difficult the learning process [95]. Ideally, each level should be supported with a dedicated tool containing only the constructs for each level [95].\n\n8.2.1 Problem’s Description: Learning Sequences and DSL Variants\n\nA learning sequence is an “ordering of the learning space’s concepts into linear sequences in which those concepts could be learned” [148]. In the context of programming learning, a learning sequence can be concertized as an ordered set of learning levels, each of which contains a well-defined set of programming skills. Once the student achieve the programming skills defined in a given level, then he/she is permitted to advance to the next one. The design of a learning sequence is responsibility of the teacher and it might vary and/or evolve depending of different factors such as the profile of the students [149].\n\nAs aforementioned, the notion of DSL variants can be used to support the design and implementation of learning sequences of programming skills [10]. Each learning level introduces a subset of language constructs that the student should learn, so each level can be supported by a specific DSL variant including those concepts. However, this idea might restrict the flexibility of the teachers to modify their learning sequences. The evolution of the learning sequence might imply the construction of new DSL variants supporting the changes in the levels. For example, if a teacher decides to move a topic from one level to another, then the DSL variant should be modified to remove the constructs that should be added to the DSL variant of the next level.\n\nThere work presented by Cazzola et al. [95] proposes a definition to this problem. In particular, the authors provide a language product line that supports the construction of the tool support for the learning sequences. The language variant supporting each learning level is produced by configuring and assembling a product in the language product line. Fig. 8.4 illustrates this idea. In the figure, there are three incremental learning levels; each level is supported by the DSL variant resulting of a given configuration. Note that the configurations are incremental; level 2 includes more language features than level 1, and level 3 introduces more language features than level 2.\n\nWhen using language product lines for supporting the design and implementation of learning sequences, teachers have more flexibility to define and modify the learning levels since the tool support can be easily prototyped.\n\n8.2.2 Solution: A Top-Down Language Product Line\n\nOnce we have explained the motivation of the case study, we proceed to explain how to apply our approach on top-down language product line to solve the problem. In particular, we will use the meta-language facilitates introduced in Section 5.1 in junction with the methodology proposed in Section 5.2 to build a language product line that supports incremental\n8.2. Logo for Progressive Programming Learning\n\nIn this case study, we will use Logo as programming language. This language has been largely used during the last decades to teach programming skills to high-school students.\n\nStructuring the domain knowledge. According to our methodology for the construction of top-down language product lines, the first step is to structure the domain knowledge. In this case, we want to represent all the language constructs that the students will have to learn along the entire learning process. To this end, we use a class diagram which is introduced in Fig. 8.5. This class diagram corresponds to a complete Logo language including not only the typical movement primitives (i.e., forward, back, left), but also imperative programming concepts such as variables, procedures, control structures, and binary expressions. At the end of the learning process, students are intended to master not only the basic primitives, but also these imperative programming constructs that will facilitate the comprehension of more sophisticated programming languages such as Java or C++.\n\nIdentifying syntax variability. Once we have structure the domain knowledge in a class diagram, we need to understand what are the optional and mandatory concepts of the\nlanguage. This allows us to identify the minimal set of constructs that a DSL variant for Logo must own in order to be fully executable. In the particular case of this case study, this minimal set of constructs can be considered as the constructs introduced in the very first level of the learning sequence.\n\nIn Logo, the minimal set of constructs corresponds to the basic movement primitives and literals. Using those constructs, students will be able to draw simple geometric forms. All the other constructs (marked with (?) in the Fig. 8.5) are optional and the order in which they will be learned by the students will depend on the definition of the learning sequence proposed by the teacher.\n\n**Identifying language modules.** Let us now to find out a good modular design for the language product line. That means, to find an accurate way of grouping the language constructs of Logo that facilitates the definition of learning sequences.\n\nIn order to achieve this modular design, we have the cluster analysis provided in Section 5.2. That means that we can use a hierarchical domain analysis based on the cohesion of the constructs to identify clusters of language constructs that can go well together in the same module. In doing so, our hypothesis is that the hierarchical domain analysis based on cohesion will suggest clusters of language constructs that we can easily teach to the students in the same level.\n\nFig. 8.6 presents the results of applying hierarchical domain analysis on the domain model for the Logo language introduced in Fig. 8.5. These results are quite promising; we can identify certain subsets that, intuitively, can be learned together in a programming course. For example, we have the a first cluster grouping all the basic movement primitives. Similarly, we can see that literals appear to be located in another module as well as control structures and procedures. Indeed, we realize that this grouping fits many of the classical learning sequences that we can find in programming courses. The course starts with simple concepts such as console printing instructions, then the introduction of procedures, and then some control structures.\n\n**Build variability models.** The resulting variability model after applying our algorithm is presented in Fig. 8.7. Such a model contains one feature by each module identified in the last step. There is a mandatory feature including the basic movement primitives. Similarly, there is a mandatory feature representing literals. This is the minimum set of constructs that should be included to obtain a fully executable logo language. The other features are optional. The selection of those features will respond to a configuration process associated to the design of the learning sequence. For example, a possible learning sequence might include the notion of procedures before including control structures. Because this case study does not include semantic variability, there is no orthogonal variability model.\n\nThe source code of this case study can be found on GitHub\\(^2\\).\n\n\\(^2\\)https://github.com/damende/puzzle/tree/master/examples/logo\n8.2. Logo for Progressive Programming Learning\n\n**Figure 8.6:** Venn diagram for the hierarchical domain analysis for logo\n\n**Figure 8.7:** Features model for the variability of the Logo case study\n8. Validation: Case Studies\n\n8.3 Reverse-Engineering a Language Product Line for FSMs\n\nThe objective of our third case study is to show the applicability of our contributions on bottom-up language product lines in a set of DSL variants. To this end, we use as case study the set of DSL variants for finite state machines. Although we already use this case study as running example to illustrate the ideas of this thesis, it is quite complex and rich so we decided to re-use it in the validation of this thesis. In addition, it is inspired from a real industrial problem that we obtain from our collaboration to Thales Research & Technology along the VaryMDE project.\n\nThis case study is inspired from the analysis of variability on languages for finite state machines provided by Crane et al. [59], and it is composed of three different DSLs: UML state diagrams, Rhapsody, and Harel’s state charts. As aforementioned, these DSLs have some commonalities since they are intended to express the same formalism. According to the development scenario we address in this thesis—i.e., bottom-up language product lines where the DSL variants were built through the clone-and-own approach—, these commonalities will be materialized as clones in the DSL specifications. In this section, we summarize both commonalities and differences existing in the case study. Then, we apply our approach and we present the obtained results.\n\n8.3.1 Problem Description: Several Formalisms for FSMs\n\nGenerally speaking, state machines are graphs where nodes represent states and arcs represent transitions between the states [150]. The execution of a state machine is performed in a sequence of steps each of which receives a set of events that the state machine should react to. The reaction of a machine to set of events can be understood as a passage from an initial configuration ($t_i$) to a final configuration ($t_f$). A configuration is the set of active states in the machine.\n\nThe relationship between the state machine and the arriving events is materialized at the level of the transitions. Each transition is associated to one or more events (also called triggers). When an event arrives, the state machine fires the transitions outgoing from the states in the current configuration whose trigger matches with the event. As a result, the source state of each fired transition is deactivated whereas the corresponding target state is activated. Optionally, guards might be defined on the transitions. A transition is fired if and only if the evaluation of the guard returns true at the moment of the trigger arrival.\n\nThe initial configuration of the state machine is given by a set of initial pseudostates. Transitions outgoing from initial pseudosates are fired automatically when the state machine is initialized. In turn, the execution of a state machine continues until the current configuration is composed only by final states (an special type of states without outgoing transitions).\n\nFigure 8.8 illustrates the aforementioned behavior with a simple state machine. It is composed of the states $S_1$, $S_2$, and $S_3$. The state $S_1$ is the entry point of the state machine.\n8.3. Reverse-Engineering a Language Product Line for FSMs\n\nThis is expressed by means of the initial pseudostate (the filled circle) containing a transition towards $S_1$. When the event $e_1$ arrives, the state machine evaluates the guard $g_1$ and, if the evaluation returns true, the transition $T_{12}$ is fired. Then, the state $S_1$ is deactivated and the state $S_2$ is activated. In the second step, event $e_2$ arrives and the final state $S_3$ is activated after firing the transition $T_{23}$.\n\n**Regions.** All of the DSLs for expressing state machines that conform our family support the notion of region. A state machine might be divided in several regions that are executed concurrently. Each region might have its own initial and final (pseudo)states. Figure 8.9 illustrates a state machine with two regions. Note that each region of the state machine contains its proper initial pseudostate.\n\n**Actions.** Note that a state machine has some additional capabilities with respect to the ones introduced so far. States can define entry/do/exit actions. Similarly, transitions can have some effects. States’ actions and transitions’ effects are intended to interact with the environment of the state machine. The environment is a mapping that associates variables with values.\nLet us introduce the syntactic variation points present in the family of DSLs for state machines. These semantic variation points are presented by showing the constructs available in the language and their availability in each of the involved DSLs.\n\n**Triggers: disjunction, conjunction, and negation.** The first syntactic variation point of this case study refers to the relationship between triggers and transitions. As we said earlier, a transition $T$ is associated to certain event $e$. $T$ is fired when $e$ is dispatched. This relation can be more complex, however. The transition $T$ can be associated to the negation of an event i.e., not $e$. As a result, it will be fired in every step where its target state belongs to the current configuration and the associated event does not arrive. Moreover, DSLs for state machine languages often offer the capability of associating multiple events to a transition combined through classical logical operators such as OR and AND.\n\nIn terms of triggers combination, Rhapsody is the more restrictive DSL where transition can be only associated to one event. Conversely, in UML a transition can be triggered by several events associated to the AND logical operator. In Harel’s state charts are even more expressive and allow conjunction and negation of events.\n\n**Pseudostates:** Pseudo-states are special types of states that allow the expression of compound transitions. For example, as illustrated in Fig. ?? the pseudo-state Fork enables the bifurcation of a transition so different states can be executed in parallel. Similarly, the pseudostate Join enables the unification of two transitions outgoing from concurrent states. There are other types of pseudostates such as the history ones that stores a reference to the last sub-state executed in a composite state. Conditional pseudostates are also available enabling different execution paths for the state machine according to the value of the variables in the environment.\n\n**Formalisms configuration:** There are certain differences in the DSLs regarding the pseudostates they support. All the tree DSLs offer the initial pseudo-states, as well as fork, join, junction and deep history. Shallow history is only supported by UML and Harel’s state\n8.3. Reverse-Engineering a Language Product Line for FSMs\n\n<table>\n<thead>\n<tr>\n<th>Language vs. Construct</th>\n<th>StateMachine</th>\n<th>Region</th>\n<th>AbstractState</th>\n<th>State</th>\n<th>Transition</th>\n<th>NotTrigger</th>\n<th>AndTrigger</th>\n<th>OrTrigger</th>\n<th>Pseudostate</th>\n<th>InitialState</th>\n<th>Fork</th>\n<th>DeepHistory</th>\n<th>ShallowHistory</th>\n<th>Junction</th>\n<th>Conditional</th>\n<th>Choice</th>\n<th>FinalState</th>\n<th>Constraint</th>\n<th>Statement</th>\n<th>Program</th>\n<th>NaiveEmail</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>UML</td>\n<td>• • • • • •</td>\n<td>•</td>\n<td>•</td>\n<td>•</td>\n<td>• • • • •</td>\n<td>•</td>\n<td>•</td>\n<td>• • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>•</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Rhapsody</td>\n<td>• • • • • •</td>\n<td>•</td>\n<td>•</td>\n<td>•</td>\n<td>• • • • •</td>\n<td>•</td>\n<td>•</td>\n<td>• • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>•</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>Harel</td>\n<td>• • • • • •</td>\n<td>•</td>\n<td>•</td>\n<td>•</td>\n<td>• • • • •</td>\n<td>•</td>\n<td>•</td>\n<td>• • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>•</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td>• • • • • •</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nFigure 8.10: Diversity of constructs provided by the DSLs for state machines\n\nmachines. A particular pseudo-state for representing dynamic choice is offered by UML. Static choice is supported by Rhapsody and Harel’s state charts.\n\nSummary. Figure 8.10 summarizes the discussion presented above by indicating the language constructs provided by each DSL.\n\nSemantic Variability\n\nThe reminder of this section presents the semantic variation points existing in our family of DSLs for state machines.\n\n**Events dispatching policy:** The first semantic difference in the semantics of state machines refers to the way in which events are consumed by the state machine. In a first interpretation, simultaneous events are supported whereas in a second interpretation the state machine follows the principle of run to completion. Let us discuss each scenario.\n\n- **Simultaneous events:** There are DSLs for state machines that support this capability so a step consumes a subset of the events where the size of the subset can be greater than one and attends all of them at the same time. For example, consider the state machine presented in Fig. 8.11. In that case, the events e₁ e₃ arrive at the same time in the step 1 and they are attended simultaneously. As a result, the configuration of the machine after that step is S₂, S₅.\n\n- **Run-to-completion:** A different interpretation of this variation point is to comply to the run to completion policy. That means that the state machine is able only of supporting one event by time and it cannot consume another one until de execution of the current event is completed. For example, consider the state machine presented in Fig. 8.11. Differently from the later case, in this one the events e₁ e₃ that arrive at the same time in the step 1 are attended one by one. As a result, the configuration of the machine after that step is S₂, S₄ and an automatic additional step is dispatched then. After that second step, the configuration of the machine is S₂, S₅.\n\nNote that in the example we presented for the sequential events interpretation, we show that the state machine executes the events in a given order that corresponds to the order in which the events are listed. However, it is important to clarify that it is not always like that. In fact, there is no notion of order in the consumption of events that arrive in the same\nFigure 8.11: Difference between simultaneous events and run to completion\n\nThese facts have been identified as a potential semantic variation point for state machines. However, it is out of the scope of this document.\n\n**DSLs configuration:** The semantics of UML and Rhapsody fit the run to completion policy for events dispatching whereas Harel’s statecharts support simultaneous events.\n\n**Execution order of transitions’ effects:** It is possible to define actions on the transitions that will affect the execution environment where transitions are fired. These actions are usually known as transitions effects. All the DSLs for state machines support the expression of such effects. However, there are certain differences regarding their execution.\n\n- **Effects executed sequentially:** The first and most common way of executing the effects of a transition is by following the order in which they are defined. This is due to the fact that transitions effects are usually defined by means of imperative action script languages where the order of the instructions is intrinsic. Under this interpretation, once the event $e_0$ is dispatched, the state machine in Fig. 8.12 moves from state $S_1$ to the state $S_3$. This is because the value of the variable $y$ depends on the value of $x$ that has been previously modified in a precedent instruction.\n\n- **Effects executed in parallel:** The second interpretation to the execution of transitions’ effect is to execute them in parallel. In other words, the effects are defined as a set of instructions that will be executed at the same time so no assumptions should be made with respect to the execution order. Under this interpretation, once the event $e_0$ is dispatched, the state machine in Fig. 8.12 moves from the state $S_1$ to the state $S_2$. Although the value of $y$ depends on the value of $x$, the instructions are executed\n8.3. Reverse-Engineering a Language Product Line for FSMs\n\nFigure 8.12: Example of a state machine with effects in the transitions\n\nsimultaneously.\n\n**DSLs configuration:** UML, Rhapsody, and Stateflow execute the transition effects in parallel. Harel’s statecharts execute transition effects simultaneously.\n\n**Priorities in the transitions:** Because several transitions can be associated to the same event, there are cases in which more than one transitions are intended to be fired in the same step. In general, all the DSLs for state machines agree in the fact that all the activated transitions should be fired. However, this is not always possible because conflicts might appear. Consider for example the state machine presented in Fig 8.13. The transitions \\( T_D \\) and \\( T_E \\) are conflictive because they are activated by the same event i.e., \\( e_2 \\), they exit the same state, and they go to different target states. Then, the final configuration of the state machine will be different according to the selected transition.\n\nIn order to tackle such situations, it is necessary to establish policies that permit to solve such conflicts. Specifically, we need to define a mechanism for prioritizing conflicting transitions so the interpreter is able to easily select a transition from a group of conflicting transitions. One of the best known semantic differences among DSLs for state machines is related with these policies. In particular, there are two different mechanisms for solving this kind of conflicts:\n\n- **Priority for deepest transitions:** A first mechanism for solving conflicting transition is to select the transition with the lower scope. That means, the transition that is deeper in the hierarchy of the state machine. In the example presented in Fig 8.13 the dispatched transition according to this policy would be the transition \\( T_E \\) so the state machine would move to the state \\( S_5 \\).\n\n- **Priority for higher transitions:** The second mechanism for solving conflicts in the transition is to select the transition with the higher scope. That is, the transition in the higher level of the hierarchy of the state machine. In the example presented in Fig 8.13 the dispatched transition according to this policy is the transition \\( T_D \\) so the state machine will move to the state \\( S_4 \\).\n\n**DSLs configuration:** The semantics of UML and Rhapsody fits on the first interpretation i.e., deepest transition priority whereas the semantics of Harel’s statecharts fits on the second interpretation i.e., highest transitions priority.\n8.3.2 Solution: Reverse-Engineering a Language Product Line\n\nThe starting point of the applicability of our approach in the case study is a set of DSLs implementing each of the specifications explained above. Hence, at the beginning we have three different DSLs for state machines that can be accessed in a GitHub repository\\(^3\\). Using these specifications as input, we proceed to apply our approach.\n\nThe results are summarized in Fig. 8.14. At the left of the figure we present the set of language modules we obtained as well as the language interfaces existing among them. Those modules group the language constructs according to the heuristic introduced in Section 6.2 on breaking down intersections. At the right of the figure we show the corresponding variability models. Each feature of the feature models is associated to a given language module. In turn, the semantic variability points in the orthogonal model are associated to clusters of domain specific actions.\n\n**Analysis of the results.** Let us now discuss the results of the case study. As expected, we obtained a language product product line from a set of DSL variants for finite state machines. But... Does this product line identify all the variation points and commonalities existing in the DSL variants? Are those variation points properly specified in the language modular design and variability models? Since we know these variation points and commonalities, we can check whether they are appear in the produced language product line. The results of this verification are presented in Table 8.1.\n\nThe results are promising in the case of abstract syntax variability. According to the Table 8.10, the DSL variants share 17 constructs in common. Those constructs are properly factorized in a language module that we named StateMachine. This module is correctly identified during the recovering of the language modular design, and it is properly specified\n\n---\n\n\\(^3\\)GitHub repository for the case study: https://github.com/damende/puzzle/tree/master/examples/state-machines\n8.3. Reverse-Engineering a Language Product Line for FSMs\n\nFigure 8.14: Language product line produced for the case study of the finite state machines.\n\n<table>\n<thead>\n<tr>\n<th>Oracle</th>\n<th>Result</th>\n<th>Properly identified?</th>\n<th>Properly specified?</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Module: [NotTrigger, OrTrigger]</td>\n<td>✓</td>\n<td>✓</td>\n<td></td>\n</tr>\n<tr>\n<td>Module: [AndTrigger]</td>\n<td>✓</td>\n<td>✓</td>\n<td></td>\n</tr>\n<tr>\n<td>Module: [Choice]</td>\n<td>✓</td>\n<td>✓</td>\n<td></td>\n</tr>\n<tr>\n<td>Module: [Conditional]</td>\n<td>✓</td>\n<td>✓</td>\n<td></td>\n</tr>\n<tr>\n<td>Semantic Variability</td>\n<td>Events dispatching policy</td>\n<td>✓</td>\n<td>x</td>\n</tr>\n<tr>\n<td>Execution order of transitions’ effects</td>\n<td>✓</td>\n<td>x</td>\n<td></td>\n</tr>\n<tr>\n<td>Priorities of conflictive transitions</td>\n<td>✓</td>\n<td>x</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nTable 8.1: Analysis of the results of the case study\n\nas a language module in terms of a metamodel enhanced with domain specific actions and offering a provided interface. Besides, the particularities of the DSL variants are also well factorized. There is a module that contains the constructs NotTrigger and OrTrigger that belong only to the variant complying the Harel’ statecharts specification. Besides, there are three additional modules that contain the constructs AndTrigger, Choice, and Conditional respectively. Using this modular design, we can re-compose any of the three initial DSL variants.\n\nThe situation is different for the case of semantic variability. Although our reverse-engineering strategy is able to identify that the domain specific actions are different in the three DSL variants, the level of granularity at which those variation points are detected is coarser than one might expect. At the beginning of this section, we described three semantic variation points and their possible interpretations i.e., events dispatching policy,\nexecution order of transitions’ effects, and priorities of conflicting transitions. Using the proposed technique, we can identify just one semantic variation point indicating that the language module called StateMachines contains three different clusters of domain specific actions, which is reflected in the orthogonal variability model.\n\nThis threat to validity of our technique can be explained by the fact that the analysis of commonalities and variability is conducted by means of static analysis. We can analyze the structure of the metamodels and the domain specific actions, but not their behavior at runtime. Hence, we cannot see how these differences impact the execution of the models. For example, we cannot infer that the differences among the domain specific actions in the StateMachine module impact the way in which conflicting priorities are managed. A next step in this research could be to use also dynamic analysis in the domain specific actions to better specify semantic variation points.\n\nThe source code of this case study can be found on GitHub4.\n\n8.4 Summary\n\nThis chapter was dedicated to the validation of our contributions. To this end, we presented three case studies. In the first one, we show that our approach for languages modularization is complete enough to support the modular design existing behind the specification of UML. The second case study is intended to validate our contributions on top-down language product lines engineering. This case study focuses on the construction of a language product line for facilitating different variants of a DSL used for gradual teaching of programming skills. Finally, the third case study is intended to validate our contributions in bottom-up language product lines. This case study corresponds to the implementation of the example on the different variants for state machines that we have used along this thesis to illustrate our ideas. We implemented each of those variants using the clone-and-own approach; then we use our approach to reverse-engineering the corresponding language product line.\n\n---\n\n4https://github.com/damende/puzzle/tree/master/examples/state-machines\nPart IV\n\nClosure\nChapter 9\n\nConclusion and Perspectives\n\n9.1 Conclusion\n\nA domain-specific language provides a set of abstractions that belong to specific area of endeavor (i.e., the domain) and that serve to a concrete purpose. When the same abstractions are used in different domains, or when the complexity of a certain domain demands various DSLs addressing different purposes, we obtain DSL dialects. As the same as in the case of natural languages, DSL dialects are variants of a given DSL that introduce some changes in terms of syntax and semantics.\n\nThe phenomenon described above supposes an important challenge for language designers. This is specially true in large technology companies that use the language-oriented development approach, and which business is based on providing numerous systems through diverse domains. The construction of a DSL is a complex activity, and it is even more challenging when language designers have to deal not only with DSLs, but also with different variants of the same DSL.\n\nThe community in software language engineering is currently seeking manners to ease-off the construction of DSL variants. The purpose is to increase reuse during the construction of such variants DSL by exploiting the abstractions and definitions they share among them. In that context, the notion of language product lines have recently appeared. Several state-of-the art works have shown how to use the ideas on software product lines engineering in the construction of DSL variants.\n\nIn this thesis, we provided a deep analysis of current approaches supporting language product lines engineering. Our study was conducted in the form of a systematic literature review where we included a large spectrum of approaches published during the last 16 years. The main result of this study was a description of the life-cycle of language product lines based on the discussions provided in the research works included in the literature review. We used such a life-cycle to evaluate current approaches and to identify a set of open issues in the field of language product lines engineering.\nThese open issues can be divided into two categories according to the flow in which the activities of the life-cycle of a language product lines are addressed: top-down and bottom-up. We deeply explained each of those categories and we listed a specific set of limitations of current approaches. Afterwards, we prioritized those limitations and we selected a subset of them to address along these years of research. The contribution of this thesis can be summarized in two points:\n\nFirst, we provided facilities for the construction of top-down language product lines. The facilities are a modularization approach which favors three classical software modularization principles i.e., independent development, substitutability, and information hiding. This approach is accompanied with an strategy to model the variability of a language product line, as well as a set of methodological insights that facilitate the daily basis of language designers.\n\nAs a second contribution of this thesis, we presented a reverse-engineering algorithm to support the construction of bottom-up language product lines. Our approach assumes the existence of a set of DSL variants that have been built through the clone-and-own approach. Based on that, we used static analysis to identify commonalities that we extract as a set of reusable language modules. Then, we provide an algorithm to synthesize the variability models of the language product line.\n\nThe validation of our ideas was conducted through a set of three case studies. In the first one, we revisit the design of UML as modeling language and we replicate its modular design using our modularization approach. This exercise allowed us showing that our approach is complete enough to support the definition of complex and large modeling languages. In the second case study, we provided a case study composing of several DSL variants for incrementally teaching programming skills. This case study allowed us illustrating the construction of language product line using a top-down approach. Finally, in the third case study, we use three different variants of a DSL to express finite state machines to reverse-engineer a language product line by using the bottom-up perspective.\n\n9.2 Perspectives\n\nIn this section, we present different directions in which the work presented in this thesis can be pursued. We start by providing a discussion on how to broaden the spectrum of our contributions to more diverse development scenarios and in other technological spaces. Then, we discuss the open issues that we find during the conduction of the state of the art, and which were not covered in the scope of this thesis i.e., testing and evolution of language product lines.\n\n9.2.1 Broadening the Spectrum of our Contributions\n\nThinking outside executable metamodeling. All along this thesis, we have insisted in the fact that all our ideas are applicable when the DSLs under study are developed by means\nof metamodels enhanced with operational semantics. We have described the particularities of such a technological space, and we provided the tooling enough to support our approach in that context. However, what if during language development the DSL variants are implemented through a different technological space? At which point our approach can be re-used?\n\nWe need to start by admitting that all the implementation part of our approach –i.e., the tooling encapsulated in the Puzzle toolkit–, can be hardly extended to other technological spaces. This is due to the fact, that Puzzle was built on top of a language workbench which is exclusively dedicated to metamodel-based DSLs which semantics is expressed operationally through domain-specific actions. However, many of the ideas that we have developed during this thesis can be reused in other language workbenches dedicated to other technological spaces. We consider that the answer of this question represents a relevant direction for future work.\n\nThinking outside the copy-and-own approach. An important constraint of our approach for bottom-up language product lines is that it is scoped to DSLs that have been built through the clone-and-own approach. This fact permit to assume the existence of specification clones which is the backbone of our strategy for reverse engineering language modules. But... what if we have DSLs that are not necessarily built in those conditions? Suppose for example that we have as input a set of DSLs that share certain commonalities but that have been developed in different development teams. In that case, the probability of finding specification scenarios is quite reduced, and our approach will not be useful. How our strategies can be extended to deal with such a scenario?\n\nAccording to our experience during the development of this thesis, we think that the answer to that question relies on the definition of more complex comparison operators. As we deeply explain in Section 6.1, the very first step of our reverse engineering strategy is to perform a static analysis of the given DSLs and apply two comparison in order to specify specification clones. If what we want is to find commonalities that are not necessarily materialized in specification clones but in \"equivalent functionality\", then we need to enhance the comparison operators in order to detect such as equivalences.\n\nNote the complexity behind the notion of \"equivalent functionality\". In the case of abstract syntax, two meta-classes might provide equivalent functionality by defining different language constructs e.g., using different names for the specification elements and even different relationships among them. In the case of the semantics, two different domain specific actions might provide equivalent functionality through different programs. We claim that further research is needed to establish this notion of equivalence thus supporting more diverse development scenarios.\n\n### 9.2.2 Testing and Evolution of Language Product Lines\n\nTwo of the open issues that we identified during our study of the state of the art are testing and evolution of language product lines. In Section 3.4, we explained the importance of\nthis phases of the life-cycle of a language product line. However, those issues are out of the scope of this thesis. Their complexity demands a deep analysis, which can be the subject of study of future work.\n\nIn addressing these issues, researchers will have to consider some of the aspects we included in this thesis. For example, a testing approach for DSLs might be also quite dependent of the technological space in which the DSLs are specified. For example, the challenges towards testing the operational semantics of a DSL can be different from the ones behind testing denotational semantics. Whereas in the first case, testing corresponds to test imperative programs that describes the execution steps of a given model, in the second case the testing phase corresponds to test declarative rules. Testing declarative programs have different challenges w.r.t testing imperative ones [151].\nPart V\n\nAppendixes\nAppendix A\n\nExtending EMOF to Support Language Interfaces\n\nIn this appendix, we present a mechanism to support the notion of languages interfaces, which is the backbone of approach for modularization of DSLs. This mechanism is based on an extension to EMOF; it introduces the notion of virtualization to support the definition of required interface, as well as the notion of module visibility to support the definition of provided interface.\n\nA.1 Introducing Virtualization in EMOF\n\nFig. A.1 shows our extension to EMOF to introduce the notion of virtualization. We create a new meta-class called VirtualizableElement which is aimed to identify the specification elements that can be defined as virtual in a language module. We consider the following specification elements as virtualizable: (meta-)classes, properties, operations, parameters, enumerations, and enumeration literals.\n\nNote that this extension requires some well-formedness rules rules to avoid inconsistent metamodels. For example, if an operation is defined as virtual, then all their parameters should be defined as virtual as well. Otherwise, we will face a situation that is conceptually wrong. These well-formedness rules are specified in the form of OCL constraints at the bottom of Fig. A.1, and they are explained in the following.\n\n1. All meta-classes containing virtual properties and/or operations must be virtual as well. The existence of a virtual property and/or operation implies that there is an actual property/operation that implements the desired functionality. However, properties and operations are always defined within a certain meta-class. Hence, there is also a virtual vs. actual relationship between the involved meta-classes. As a result, the meta-class containing a virtual property/operation must be virtual so this relationship can be established.\n(2) **Non-primitive types of virtual property must be virtual as well.** Defining a virtual property in a language module A implies that there is a language module B which implements the desired functionality; thus introducing a dependency from the module A to the module B. If the type of the virtual property is not primitive (so it is either a meta-class or an enumeration) and it is defined as non-virtual in the module A, then this type should be defined as virtual in the module B. This implies that there is a second dependency from the module B to the module A thus creating a dependencies loop. As we will discuss later in this chapter, dependencies loops are not supported in our approach. Then, to be well formed a required interface must guarantee that all the types of virtual references are virtual as well.\n\n(3) **All parameters of a virtual operations must be virtual as well.** Defining a virtual operation in a module A implies that there is a language module B that implements defines an actual operation with the desired functionality. The only way to implement the same functionality is to respect the signature of the virtual operation. If one of the parameters of the a virtual operation are defined as non-virtual then that the definition of the virtual operation will be incomplete in the required interface and the signatures will not match.\n\n(4) **The owning operation of a virtual parameter must be virtual as well.** The existence of a virtual parameter implies that there is an actual parameter that implements the desired functionality. However, parameters are always defined within a certain operation. Hence, there is also a virtual vs. actual relationship between the involved operations. As a result, the operation containing a virtual parameter must be virtual so this relationship can be established.\n\n(5) **The owning enumeration of a virtual enumeration literal must be virtual as well.** Similarly than in the case of classes and properties, enumeration literals defined as virtual must be always defined in virtual enumerations so the needs they represent can be fulfilled by an actual enumeration in an external language module.\n\n### A.2 Introducing Module Visibility in EMOF\n\nFig. A.2 shows our extension to EMOF to support module visibility. We create a new meta-class called `ModuleVisibilityElement` that allows two levels of visibility (i.e., **public** and **private**) for the specification elements of a language module. We consider the following specification elements as module visibility elements: (meta-)classes, properties, operations, parameters, enumerations, and enumeration literals.\n\nSimilarly than in the case of virtualization, we need to establish certain well-formedness rules to guarantee the consistency of a provided interface that is extracted from the public elements within a language module. Those rules are formalized at the bottom of Fig. A.2 and deeply explained in the following.\nA.2. Introducing Module Visibility in EMOF\n\nFigure A.1: Extension to the EMOF to support virtualization\n\n1. All meta-classes containing public properties and/or operations must be public as well. As aforementioned, properties and operations are defined within specific meta-classes. Moreover, the only way to access or call a given property/operation is through its containing meta-class. A public property/operation which is defined in a private meta-class cannot be actually accessed. Hence, a first consistency rule for providing interface is that all the meta-classes containing public properties or operations must be public as well.\n\n2. Non-primitive types of public properties must be public as well. Defining a property as public implies that the language module under construction provides navigability towards the instances of a given meta-class. If such meta-class is not public, then the navigability cannot be actually performed and we will face an inconsistency.\n\n3. All the parameters of public operations must be public as well. When defining an operation as public, a language designers is exposing its functionality –notably its signature– to external modules. Naturally, to be consistent all the parameters of a\nA. Extending EMOF to Support Language Interfaces\n\nPublic operation should be public as well so they can be also accessed.\n\n(4) Public parameters always belong to public operations. Because parameters can only be accessed through its owning operation, it makes no sense to specify public parameters in private operations. They will never be actually accessed.\n\n(5) Every enumeration containing at least one public enumeration literal must be public as well. Because enumeration literals can only be accessed through its owning enumeration, it makes no sense to specify public enumeration literals in private enumerations. They will never be actually accessed. The inverse situation is different. A public enumeration might contain private enumeration literals.\n\nFigure A.2: Extension to the EMOF to support module visibility\nHierarchical Domain Analysis\n\nIn this appendix, we explain how to use hierarchical domain analysis to identify concept clusters during the design phase of the construction of language product lines. The input of this process is a domain model representing relevant concepts and relationships among them. In turn, the output of this process is a Venn diagram (such as the one introduced in Fig. 5.11) that guides language designers in the definition of concept clusters that will be later encapsulated as language modules.\n\nWhat is hierarchical domain analysis? Hierarchical domain analysis is a method that allows the extraction of a hierarchy from a given set of elements. Such a hierarchy represents a degree of relatedness between the given elements. The higher level of relatedness the closer relation in the hierarchy. Consider the example introduced in Fig. B.1. In that figure, the fact that A and B are siblings means that they are strongly related. In turn, A and B are also related with C but this relationship is weaker. Similarly, the set composed of A, B, and C is related to D but this relation is even weaker.\n\nUsing cohesion as a measure of relatedness. Since in our case the main objective of the hierarchical domain analysis is to organize the language concepts of a domain model in a hierarchy that shows the existing subdomains, we propose to base the analysis in terms of the degree of cohesion among language concepts. The more degree of cohesion between two language concepts, the bigger probability that they are part of the same sub-domain.\n\nBut, how to measure cohesion between language concepts? Inspired on the notion of intra-connectivity introduced by Mancoridis et al. [132], we propose to measure pair-wise cohesion as the quotient between the amount relationships existing between the language constructs and the total of relationships existing in the domain model. Figure B.2 illustrates this idea through an example. Particularly, Figure B.2a shows a domain model including five concepts: A, B, C, D, and E. In turn, Figure B.2b shows the corresponding pair-wise cohesion values. Note that the total number of relationships in the domain model is 9 (in-\nincluding not only references between classes but also inheritances relationships). Hence, the cohesion between the concepts B, and C (which have 4 relationships among them corresponding to 2 bidirectional references) is $\\frac{4}{9} = 0.44$. Note that this metric for cohesion provides a number between 0 and 1 being 0 less cohesive than 1.\n\nOnce we have defined the cohesion as relatedness metric, we can perform the hierarchical domain analysis. To this end, we use the algorithm introduced by Li et al. [152] on the cohesion matrix. Figure B.3 shows an example of the results for the domain model introduced above including the concepts A, B, C, D, and E. Note that the result of the analysis is a cohesion tree that shows the hierarchies among language concepts shown in Figure B.3a that, in turn, can be viewed as a Venn diagram as shown in Figure B.3b. In this case, the concepts B and C are quite cohesive among them so they form a sub-domain. A similar case occurs for the concepts D and E. Moreover, we can see that A, B, and C form another sub-domain since they are more related each other than with the concepts D and E.\nAppendix C\n\nEmpirical Data on Specification Cloning in DSLs\n\nAlthough our experience indicates that the clone-and-own approach is a real practice in language development processes so it is normal to find specification clones, we still need to verify that it is a phenomenon that appears in other development teams, and industrial contexts. To answer that question, we explored public GitHub repositories in search of DSLs that are built on the same technological space that we used in our approach. The intention is to confirm the existence of specification clones among those DSLs. The results are presented in this section, and all the data and tooling needed to replicate these experiments are available on-line.\n\nData. We conducted an automatic search on GitHub repositories to find Ecore metamodels enriched with operational semantics written as Kermeta aspects in Xtend. As a result of this search, we obtained a data set composed of 2423 metamodels. Nevertheless, because Kermeta 3 and its implementation in Xtend is a quite recent idea, we found very few data for the semantics part. Besides, all of them have been developed in our research team. We decided to conduct the analysis only in the metamodels since we consider that detection of specification clones at the level of the abstract syntax can give us a good insight about the existence of clone-and-own in DSLs development processes.\n\nExperiment. To identify specification clones in the metamodels from our data set, we performed a pair-wise comparison among all the metamodels (w.r.t. the \\( \\equiv \\) operator introduced in section 6.2). Then, we compute the matrix \\( O(i,j) \\) where each cell \\((i,j)\\) contains the number of cloned metaclasses between the metamodels \\( i \\) and \\( j \\). \\( O(i,j) = 0 \\) means that there is no cloned metaclasses between the metamodels \\( i \\) and \\( j \\). We are interested in the cells \\((i,j)\\) such that \\( O(i,j) \\neq 0 \\) and \\( i \\neq j \\). Those cells correspond to a pair of metamodels with some specification clones. Then, we analyze the matrix with two questions in mind: (1) how many metamodels have some specification clones among them?; and (2) how many\n\n\\[1\\text{Website for experiment 2: http://empiricalpuzzle.weebly.com/}\\]\nclasses are cloned from one metamodel to the other?.\n\n**Results.** Figure C.1 shows two charts with the results to the experiment. The chart at the left is intended to answer the first question. In this chart, each entry $x$ of the horizontal axis represents one metamodel of the data set. In turn, the vertical axis i.e., $y(x)$ shows the amount of metamodels with some specification clones for $x$. Formally, $y(x) = (|+k| 0 \\geq k \\geq 2423 \\land O(x, k) > 0 : 1)$. For example, the metamodel with ID $1.053$ has some specification clones with $272$ metamodels. Note that each point located up the zero line of the vertical axis represents a metamodel with some specification clones with one or more metamodels, thus suggesting that specification clones is a real phenomenon.\n\nThe chart at the right of the Figure C.1 is intended to answer the second question. In this chart, each entry $x$ of the vertical axis represents one metamodel of the data set. The vertical axis i.e., $z(x)$ shows the average amount of cloned classes for $x$. Formally, $z(x) = 1/y(x) * (+k| 0 \\geq k \\geq 2423 : O(x, k))$ For example, the metamodel $1.928$ shares, in average, $99.4$ metaclasses with other metamodels. Note that there is an important amount of metamodels whose average overlapping size is between $0$ and $100$ metaclasses. Note also that there are four metamodels that share about $600$ metaclasses. This case corresponds to a set of different versions of a metamodel for UML.\nList of Tables\n\n3.1 Strings for the automatic search of the systematic literature review .......... 18\n3.2 Language modularization scenarios in the literature. (*) Out of the scope ... 21\n3.3 Current approaches supporting language product lines ....................... 28\n3.4 Mapping current approaches and language modularization capabilities ...... 35\n3.5 Mapping current approaches and variability management capabilities ....... 39\n3.6 Mapping current approaches and technological spaces ....................... 42\n\n8.1 Analysis of the results of the case study ....................................... 127\nList of Figures\n\n1. Aperçu du processus de développement logiciel basé sur des langages dédiés ........................................ viii\n2. Deux approches différentes pour faire face à l'ingénierie des lignes des langages ........................................ x\n1.1 Overview of the language-oriented development approach ................................................................. 2\n1.2 Two different approaches for Language Product Line Engineering ..................................................... 4\n2.1 Technological spaces for domain-specific languages ............................................................................ 11\n2.2 Phases of the SPLE’s life cycle .............................................................................................................. 13\n3.1 Protocol used to chose the articles included in the discussion. ......................................................... 17\n3.2 Number of articles per year and type of publication ........................................................................... 19\n3.3 Phases of the life cycle of a language product line .............................................................................. 20\n3.4 The relationship between software modularization and software language engineering ....................... 21\n3.5 Example of extension composition ........................................................................................................ 23\n3.6 Example for multi-dimensional variability in language product lines ................................................. 26\n3.7 Example for multi-staged configuration in language product lines .................................................... 26\n3.8 Boolean feature models for representing abstract syntax variability .................................................. 36\n3.9 Boolean feature models for representing syntactic and semantic variability ......................................... 37\n3.10 Boolean feature models for representing multi-dimensional variability ............................................. 37\n3.11 Open issues in language product line engineering ............................................................................. 43\n4.1 Scientific scope of the thesis: Addressed open issues ........................................................................ 54\n4.2 A simple DSL for finite state machines ................................................................................................ 55\n5.1 Interfaces for languages modularization ................................................................................................ 58\n5.2 Example of the use of required interfaces ............................................................................................. 59\n5.3 Example of the use of provided interfaces ............................................................................................. 60\n5.4 Running example: A modular DSL for finite state machines ............................................................... 62\n<table>\n<thead>\n<tr>\n<th>Figure</th>\n<th>Description</th>\n<th>Page</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>5.5</td>\n<td>Approach to represent multi-dimensional variability in language product lines</td>\n<td>68</td>\n</tr>\n<tr>\n<td>5.6</td>\n<td>Approach to support multi-staged configuration of language product lines</td>\n<td>70</td>\n</tr>\n<tr>\n<td>5.7</td>\n<td>An example of multi-dimensional variability in language product lines</td>\n<td>71</td>\n</tr>\n<tr>\n<td>5.8</td>\n<td>Staged process for domain engineering of language product lines</td>\n<td>72</td>\n</tr>\n<tr>\n<td>5.9</td>\n<td>A domain model for finite state machines</td>\n<td>74</td>\n</tr>\n<tr>\n<td>5.10</td>\n<td>A domain model with optional/mandatory concepts for finite state machines</td>\n<td>76</td>\n</tr>\n<tr>\n<td>5.11</td>\n<td>Venn diagram for the hierarchical domain analysis for state machines</td>\n<td>78</td>\n</tr>\n<tr>\n<td>5.12</td>\n<td>Features model for a language product line of finite state machines</td>\n<td>80</td>\n</tr>\n<tr>\n<td>5.13</td>\n<td>Clusters for a DSL for finite state machines</td>\n<td>82</td>\n</tr>\n<tr>\n<td>6.1</td>\n<td>Example of clone-and-own pattern</td>\n<td>86</td>\n</tr>\n<tr>\n<td>6.2</td>\n<td>A reverse-engineering strategy to bottom-up language product lines</td>\n<td>87</td>\n</tr>\n<tr>\n<td>6.3</td>\n<td>Syntactic and semantic intersections in a set of DSL variants</td>\n<td>90</td>\n</tr>\n<tr>\n<td>6.4</td>\n<td>Breaking down intersections to factorize specification clones</td>\n<td>90</td>\n</tr>\n<tr>\n<td>6.5</td>\n<td>Unifying and breaking down for recovering a language modular design</td>\n<td>91</td>\n</tr>\n<tr>\n<td>6.6</td>\n<td>Reverse-engineering variability models for language product lines</td>\n<td>92</td>\n</tr>\n<tr>\n<td>7.1</td>\n<td>Simple example of aspects in K3</td>\n<td>98</td>\n</tr>\n<tr>\n<td>7.2</td>\n<td>Example of required interfaces in Puzzle</td>\n<td>101</td>\n</tr>\n<tr>\n<td>7.3</td>\n<td>Example of provided interfaces in Puzzle</td>\n<td>102</td>\n</tr>\n<tr>\n<td>7.4</td>\n<td>Variability management in Puzzle</td>\n<td>104</td>\n</tr>\n<tr>\n<td>7.5</td>\n<td>Venn diagrams provided by Puzzle for visualizing specification clones</td>\n<td>106</td>\n</tr>\n<tr>\n<td>7.6</td>\n<td>Metrics for quantification of potential reuse</td>\n<td>107</td>\n</tr>\n<tr>\n<td>7.7</td>\n<td>Metrics for quantification of potential reuse</td>\n<td>108</td>\n</tr>\n<tr>\n<td>7.8</td>\n<td>Software architecture of Puzzle</td>\n<td>109</td>\n</tr>\n<tr>\n<td>8.1</td>\n<td>Modules for the UML case study</td>\n<td>111</td>\n</tr>\n<tr>\n<td>8.2</td>\n<td>Modules for the UML case study</td>\n<td>113</td>\n</tr>\n<tr>\n<td>8.3</td>\n<td>Modules for the UML case study</td>\n<td>114</td>\n</tr>\n<tr>\n<td>8.4</td>\n<td>Learning Sequences and DSL Variants</td>\n<td>117</td>\n</tr>\n<tr>\n<td>8.5</td>\n<td>Domain model for the Logo case study</td>\n<td>117</td>\n</tr>\n<tr>\n<td>8.6</td>\n<td>Venn diagram for the hierarchical domain analysis for logo</td>\n<td>119</td>\n</tr>\n<tr>\n<td>8.7</td>\n<td>Features model for the variability of the Logo case study</td>\n<td>119</td>\n</tr>\n<tr>\n<td>8.8</td>\n<td>Example of a simple state machine and its execution</td>\n<td>121</td>\n</tr>\n<tr>\n<td>8.9</td>\n<td>Example of a simple state machine with two regions</td>\n<td>122</td>\n</tr>\n<tr>\n<td>8.10</td>\n<td>Diversity of constructs provided by the DSLs for state machines</td>\n<td>123</td>\n</tr>\n<tr>\n<td>8.11</td>\n<td>Difference between simultaneous events and run to completion</td>\n<td>124</td>\n</tr>\n<tr>\n<td>8.12</td>\n<td>Example of a state machine with effects in the transitions</td>\n<td>125</td>\n</tr>\n<tr>\n<td>8.13</td>\n<td>Example of a state machine with conflicting priorities</td>\n<td>126</td>\n</tr>\n<tr>\n<td>8.14</td>\n<td>Language product line produced for the case study of the finite state machines</td>\n<td>127</td>\n</tr>\n<tr>\n<td>A.1</td>\n<td>Extension to the EMOF to support virtualization</td>\n<td>139</td>\n</tr>\n<tr>\n<td>A.2</td>\n<td>Extension to the EMOF to support module visibility</td>\n<td>140</td>\n</tr>\n</tbody>\n</table>\n\n147\nLIST OF FIGURES\n\nB.1 Example .................................................................................................................. 141\nB.2 An example of pair-wise cohesion in domain models .................................................. 142\nB.3 Example of hierarchical domains ................................................................................. 142\nC.1 Results for the evaluation of overlapping in GitHub metamodels ................................. 144\nAccepted Publications\n\n\n(6) **(Poster)** David Méndez-Acuña, Benoît Combemale, and Benoît Baudry. *Variability Management in Domain Specific Languages*. Presented during the Inter\n\nPublications Under Review\n\nBibliography\n\n\n[135] David Méndez-Acuña, José A. Galindo, Benoit Combemale, Arnaud Blouin, and Benoit Baudry. Reverse-engineering reusable language modules from legacy\n\n\n[144] Steven She, Uwe Ryssel, Nele Andersen, Andrzej Wąsowski, and Krzysztof Czarnecki. Efficient synthesis of feature models. *Information and Software Technology*, 164\n\n\nThe use of domain-specific languages (DSLs) has become a successful technique in the development of complex systems because it furnishes benefits such as abstraction, separation of concerns, and improvement of productivity. Nowadays, we can find a large variety of DSLs providing support in various domains. However, the construction of these languages is an expensive task. Language designers are intended to invest an important amount of time and effort in the definition of formal specifications and tooling for the DSLs that tackle the requirements of their companies.\n\nThe construction of DSLs becomes even more challenging in multi-domain companies that provide several products. In this context, DSLs should be often adapted to diverse application scenarios, so language development projects address the construction of several variants of the same DSL. At this point, language designers face the challenge of building all the required variants by reusing, as much as possible, the commonalities existing among them. The objective is to leverage previous engineering efforts to minimize implementation from scratch.\n\nAs an alternative to deal with such a challenge, recent research in software language engineering has proposed the use of product line engineering techniques to facilitate the construction of DSL variants. This led the notion of language product lines i.e., software product lines where the products are languages. Similarly to software product lines, language product lines can be built through two different approaches: top-down and bottom-up. In the top-down approach, a language product line is designed and implemented through a domain analysis process. In the bottom-up approach, the language product line is built up from a set of existing DSL variants through reverse-engineering techniques.\n\nIn this thesis, we provide support for the construction of language product lines according to the two approaches mentioned before. On one hand, we propose facilities in terms of language modularization and variability management to support the top-down approach. Those facilities are accompanied with methodological insights intended to guide the domain analysis process. On the other hand, we introduce a reverse-engineering technique\nto support the bottom-up approach. This technique includes a mechanism to automatically recover a language modular design for the language product line as well as a strategy to synthesize a variability model that can be later used to configure concrete DSL variants.\n\nThe ideas presented in this thesis are implemented in a well-engineered language workbench. This implementation facilitates the validation of our contributions in three case studies. The first case study is dedicated to validate our languages modularization approach that, as we will explain later in this document, is the backbone of any approach supporting language product lines. The second and third case studies are intended to validate our contributions on top-down and bottom-up language product lines respectively."}}},{"rowIdx":290,"cells":{"id":{"kind":"string","value":"557e42af36b9ff10e767a7ac5aba1be4d6d7531f"},"text":{"kind":"string","value":"Definitional Functoriality for Dependent (Sub)Types\nThéo Laurent, Meven Lennon-Bertrand, Kenji Maillard\n\nTo cite this version:\nThéo Laurent, Meven Lennon-Bertrand, Kenji Maillard. Definitional Functoriality for Dependent (Sub)Types. 2023. hal-04160858v1\n\nHAL Id: hal-04160858\nhttps://hal.science/hal-04160858v1\nPreprint submitted on 20 Jul 2023 (v1), last revised 8 Apr 2024 (v3)\n\nHAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.\n\nL’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.\n\nDistributed under a Creative Commons Attribution 4.0 International License\nDefinitional Functoriality for Dependent (Sub)Types\n\nTHÉO LAURENT, Inria, France\nMEVEN LENNON-BERTRAND, University of Cambridge, United Kingdom\nKENJI MAILLARD, Gallinette Project Team, Inria, France\n\nDependently-typed proof assistant rely crucially on a definitional equality, identifying the types and terms that are automatically undistinguishable for the underlying type theory. This paper extends type theory with definitional functor laws, two equations satisfied propositionally by a large class of container-like type constructors $F$: Type $\\rightarrow$ Type, equipped with a map$_F$: $(A \\rightarrow B) \\rightarrow FA \\rightarrow FB$, such as lists or trees. Promoting these equations to definitional ones strengthen the theory, enabling slicker proofs and more automation for functorial type constructors. This extension is then used to justify modularly a structural form of coercive subtyping, propagating subtyping through type formers. We show that the resulting notion of coercive subtyping, thanks to the extra definitional equations, is equivalent to a natural and implicit form of subsumptive subtyping. The key result of decidability of type-checking in a dependent type system with functor laws for lists has been entirely mechanized in Coq.\n\nCCS Concepts: • Theory of computation $\\rightarrow$ Type theory.\n\nAdditional Key Words and Phrases: Subtyping, Dependent type system, Bidirectional typing\n\n1 INTRODUCTION\n\nDependent type theory is the foundation of many proof assistants [The Coq Development Team 2022; Moura and Ullrich 2021; Agda Development Team 2023; Brady 2021; Swamy et al. 2016], and at its heart lies definitional equality, an equational theory that is automatically decided by the implementation of these proof systems. For users, a type theory providing a rich definitional equality means less work to prove that things can be identified. However, there is a fundamental tension at play: making the equational theory too rich leads to both practical and theoretical issues, the most prominent one being the undecidability of definitional equality. This default plagues the otherwise appealing Extensional Type Theory (ETT) [Martin-Löf and Sambin 1984], a type theory which makes every provable equality definitional, thus making ETT mostly impractical as a basis for a proof assistant [Castellan et al. 2017]. As a result, to design usable proof assistants, a well-behaved equational theory that strikes the right balance between expressivity and decidability needs to be carved out. In this paper, we show that we can extend type theory with definitional equalities for functor laws, while maintaining this subtle balance. We prove in particular, that definitional equality and type-checking remain decidable in this extension.\n\nFunctors and their laws. The notion of functor is pervasive both in mathematics [MacLane 1971] and functional programming [Lipovača 2010], abstracting the concept of a parametrized construction that whose elements can be transformed. In the setting of a rich type theory, a functor can be seen as a type former $F$: Type $\\rightarrow$ Type equipped with an operation map$_F$: $(A \\rightarrow B) \\rightarrow FA \\rightarrow FB$ propagating any function $f$: $A \\rightarrow B$ between types $A$ and $B$ to a function from $FA$ to $FB$. A functor should also respect the categorical structure exhibited by the category of Types and functions, preserving identities and compositions:\n\n$$\\text{map}_F \\, \\text{id} = \\text{id} \\quad \\text{(id-eq)}$$\n\n$$\\text{map}_F \\, f \\circ \\text{map}_F \\, g = \\text{map}_F \\, (f \\circ g) \\quad \\text{(comp-eq)}$$\n\nThese two equations are known as the functor laws. For many container-like functors, such as List $A$, lists of elements taken in a type $A$, a map function can be defined such that these equations can be shown propositionally, e.g. by induction inside the type theory. Such propositional equations need however to be used explicitly while being careful that all identifications relying on them are\nmade coherently. This is not acceptable from a user perspective: such structural and naturally occurring identifications should hold on the nose, that is, definitionally!\n\n**Example 1.1 (Representation change).** Consider a dataset of pairs of a number and a boolean, represented as a list of numbers. For compatibility purpose, we may need to embed these pairs into a larger dataset using\n\n\\[ \\text{glue} \\left( r : \\{ a: \\mathbb{N}; b: \\mathbb{B} \\} \\right) : \\{ x: \\mathbb{B}; y: \\mathbb{N}; z: \\mathbb{N} \\} \\triangleq \\{ x := r.b; y := r.a; z := \\text{if } r.b \\text{ then } r.a \\text{ else } 42 \\}. \\]\n\nGoing from one dataset to the other amounts to map either glue or its left inverse:\n\n\\[ \\text{map}_{\\text{List}} \\text{glue} : \\text{List} \\{ a: \\mathbb{N}; b: \\mathbb{B} \\} \\rightarrow \\text{List} \\{ x: \\mathbb{B}; y: \\mathbb{N}; z: \\mathbb{N} \\}, \\]\n\n\\[ \\text{map}_{\\text{List}} \\text{glue\\_retr} : \\text{List} \\{ x: \\mathbb{B}; y: \\mathbb{N}; z: \\mathbb{N} \\} \\rightarrow \\text{List} \\{ a: \\mathbb{N}; b: \\mathbb{B} \\}. \\]\n\nIf the functor laws only hold propositionally, each consecutive simplification of back and forth changes of representation needs to be explicitly lifted to lists, and applied. The uncontrolled accumulation of repetitive proof steps, even as simple as these, can quickly burden proof development. In presence of definitional functor laws, instead, any sequence of representation changes will reduce to a single map:\n\n\\[ \\text{map}_{\\text{List}} \\]\n\nthe boilerplate of manipulating explicitly the functor laws is handled directly and transparently by the type theory. Moreover, observe that in this example the retraction \\( \\text{glue\\_retr} \\circ \\text{glue} \\cong \\text{id} \\) is definitional thanks to surjective pairing. Combined with definitional functor laws, the following simplification step is discharged automatically by the type-checker:\n\n\\[ \\text{map}_{\\text{List}} \\text{glue\\_retr} \\left( \\text{map}_{\\text{List}} \\text{glue} \\right) \\cong \\text{map}_{\\text{List}} \\text{id} \\cong l \\]\n\nNote that these equations are valid in any context, in particular under binders, whereas for propositional identifications, rewriting under binders is only possible in presence of the additional axiom of function extensionality.\n\n**Example 1.2 (Coherence of coercions).** Proof assistants may provide the ability for users to declare automatically-inserted functions acting as glue code (coercions in Coq, instance arguments in Agda, has\\_coe typeclass in Lean). Working with natural (\\( \\mathbb{N} \\)), integer (\\( \\mathbb{Z} \\)) and rational (\\( \\mathbb{Q} \\)) numbers, we may want every \\( \\mathbb{N} \\) to be automatically coerced to an integer, and so declare a \\( \\text{natToZ} \\) coercion. Similarly, we can also declare a \\( \\text{ZToQ} \\) coercion. If we write \\( 0 \\) (\\( a: \\mathbb{Q} \\)) where \\( a: \\mathbb{Q} \\) is expected, this is accepted, and \\( 0 \\) is silently transformed to \\( \\text{ZToQ} \\left( \\text{natToZ} \\right) 0 \\).\n\nNow, if we want the same mechanism to apply when we pass the list \\( \\{0 :: 1 :: 2\\} \\) to a function expecting a \\( \\text{List} \\mathbb{Q} \\), we need to provide a way to propagate the coercions on lists. We can expect to solve this problem by declaring \\( \\text{map}\\_\\text{List} \\) as a coercion, too: whenever there is a coercion \\( f: A \\rightarrow B \\), then \\( \\text{map}\\_\\text{List} f \\) should be a coercion from \\( \\text{List} A \\) to \\( \\text{List} B \\). However, by doing so, we actually caused more trouble than we solved, as there are now two coercions from \\( \\text{List} \\mathbb{N} \\) to \\( \\text{List} \\mathbb{Q} \\), \\( \\text{map}\\_\\text{List} \\text{ZToQ} \\circ \\text{natToZ} \\) and \\( \\text{map}\\_\\text{List} \\text{ZToQ} \\circ \\text{map}\\_\\text{List} \\text{natToZ} \\). In the absence of definitional functor laws for \\( \\text{map}\\_\\text{List} \\), these two are not definitionally equal. To add insult to injury, coercions are by default not printed to the user, yielding puzzling error messages like “\\( l \\) and \\( l\\) are not convertible” (!), because one is secretly \\( \\text{map}\\_\\text{List} \\left( \\text{ZToQ} \\circ \\text{natToZ} \\right) l \\) while the other is \\( \\text{map}\\_\\text{List} \\text{ZToQ} \\left( \\text{map}\\_\\text{List} \\text{natToZ} \\right) l \\). This makes functorial operations like map virtually unusable with coercions, because they are too dangerous.\n\n**Structural subtyping.** This last example suggests a connection with subtyping. Subtyping equips the collection of type with a subtyping order \\( \\ll \\) that allows to move seamlessly terms from a subtype to a supertype, i.e. from \\( A \\) to \\( A' \\) when \\( A \\ll A' \\). An important aspect of subtyping is structural subtyping, e.g. how can we propagate an existing subtyping notion structurally through type formers.\n\n---\n\n1We formalize this example, showing that this conversion indeed holds in our system, in file `Example_1_1`. \n\n---\nIn the context of the F\\(^\\star\\) program verification platform that heavily uses refinement subtyping, the inability to propagate subtyping on inductive datatypes has been a long-standing issue that never got solved properly [Hrițcu 2014]. Structural subtyping also has a history of causing difficulties to Agda [Cockx 2020; Escot, Poiret, et al. 2023].\n\n**Definitional equalities for subtyping.** From the perspective of the users of interactive theorem provers, subtyping should be as implicit as possible, transparently providing the expected glue to smoothen the writing of complex statements. From a meta-theoretical perspective, on the other hand, it is useful to explicitly represent all the necessary information of a typing derivation, including where subtyping is used. The first approach is known as subsumptive subtyping, on the left, whereas the latter is embodied by coercive subtyping, on the right:\n\n\\[\n\\frac{\\Gamma \\vdash_{\\text{sub}} t : A}{\\Gamma \\vdash_{\\text{sub}} A \\ll A'} \\quad \\frac{\\Gamma \\vdash_{\\text{coe}} t : A}{\\Gamma \\vdash_{\\text{coe}} \\text{coe}_{A,A'} t : A'}\n\\]\n\nIdeally, we would like to present subsumptive subtyping to users, but ground the meta-theory of the system on the better-behaved coercive subtyping. Informally, an application of \\(\\text{Sub}\\) in the subsumptive type theory MLTT\\(_{\\text{sub}}\\) should correspond to an application of \\(\\text{Coe}\\) in the coercive type theory MLTT\\(_{\\text{coe}}\\). Now, given a derivation \\(\\mathcal{D}\\) of \\(\\Gamma \\vdash_{\\text{sub}} t : A\\) we can apply \\(\\text{Sub}\\) together with a reflexivity proof \\(\\Gamma \\vdash_{\\text{sub}} A \\ll A\\) to yield a new derivation \\(\\mathcal{D}'\\) with the same conclusion \\(\\Gamma \\vdash_{\\text{sub}} t : A\\). \\(\\mathcal{D}\\) and \\(\\mathcal{D}'\\) correspond respectively to terms \\(\\Gamma \\vdash_{\\text{coe}} t' : A\\) and \\(\\Gamma \\vdash_{\\text{coe}} \\text{coe}_{A,A'} t' : A\\) in MLTT\\(_{\\text{coe}}\\). Since \\(t'\\) and \\(\\text{coe}_{A,A'} t'\\) both correspond to the same MLTT\\(_{\\text{sub}}\\) term \\(t\\), they need to be equated if we want both type theories to be equivalent. Similarly, transitivity of subtyping implies that coercions should compose definitionally, that is \\(\\Gamma \\vdash_{\\text{coe}} \\text{coe}_{B,C} (\\text{coe}_{A,B} t') \\cong \\text{coe}_{A,C} t' : C\\) should hold in MLTT\\(_{\\text{coe}}\\).\n\nFrom structural subsumptive subtyping to functorial maps. Z. Luo and Adams [2008] showed that the functorial composition law \\(\\text{comp-eq}\\) is enough to make structural coercive subtyping compose definitionally. Indeed, a structural coercion between lists \\(\\text{coe}_{\\text{List} A, \\text{List} B}\\) behaves exactly as the function obtained by mapping \\(\\text{coe}_{A,B}\\) on every element of the list. We investigate further this bridge between coercive subtyping and functoriality of type formers, in particular the identity functor law \\(\\text{id-eq}\\) needed to handle reflexivity of subtyping. This understanding leads to a modular design of subtyping: structural subtyping for a type former exhibits its functorial nature, and can be considered independently of the other type formers of the theory. Moreover, definitional functors laws are sufficient to make structural coercive subtyping for any type former flexible enough to interpret subsumptive subtyping.\n\nConcretely, we define three different type systems, corresponding to the three ideas encountered so far: MLTT\\(_{\\text{map}}\\), with map constructors for each type former, and their definitional functor laws; MLTT\\(_{\\text{coe}}\\), with coercive subtyping; and MLTT\\(_{\\text{sub}}\\), with subsumptive subtyping. All three type theories extend a standard presentation of Martin-Löf Type Theory (MLTT) [Martin-Löf and Sambin 1984] and are fully dependent, with universes and large eliminations—which Z. Luo and Adams [2008] do not cover. We investigate their relationships, as pictured in fig. 1. Erasing coercions induce an equivalence \\(\\llarrow\\) from MLTT\\(_{\\text{coe}}\\) to MLTT\\(_{\\text{sub}}\\): erasure is type-preserving, and any well-typed MLTT\\(_{\\text{sub}}\\) term can be annotated with coercions to yield back a well-typed MLTT\\(_{\\text{coe}}\\) term. Moreover, we provide a translation from MLTT\\(_{\\text{coe}}\\) to MLTT\\(_{\\text{map}}\\), making explicit the modular nature of coercions, and conjecture that it is an embedding.\n\n**Contributions.** We make the following contributions:\nwe design $\\text{MLTT}_{\\text{map}}$, an extension of Martin-Löf Type Theory exhibiting the functorial nature of standard type formers ($\\Pi$, $\\Sigma$, $\\text{List}$, $W$, $\\text{Id}$) and satisfying definitional functor laws (section 3);\n\n• we mechanize the metatheory of a substantial fragment of $\\text{MLTT}_{\\text{map}}$ in Coq, proving it is normalizing and has decidable type-checking (section 4);\n\n• we develop bidirectional presentations for $\\text{MLTT}_{\\text{sub}}$ and $\\text{MLTT}_{\\text{coe}}$, dependent types systems with respectively subsumptive and coercive subtyping, and leverage these to give back and forth translations between the two systems (section 5);\n\n• we show how to compile the coercions of $\\text{MLTT}_{\\text{coe}}$ down to the functorial maps of $\\text{MLTT}_{\\text{map}}$ (section 5.5).\n\nThe remainder of the paper introduces the necessary technical background, notations and definitions for MLTT in section 2, while section 6 details the related and future work. The supplementary material contains an appendix with detailed proofs and complete typing rules, and the Coq formalization.\n\n2 Type Theory and Its Metatheory\n\nWe work in the setting of dependent type theories à la Martin-Löf (MLTT) [Martin-Löf and Sambin 1984], an ideal abstraction of the type theories underlying existing proof assistants such as Agda, Coq, F* or Lean. The (declarative) typing rules describing MLTT use five categories of judgements, characterizing the well-formed context, types and terms (fig. 2), and providing the equational theory on types and terms (fig. 3). Two terms related by this equational theory are said to be definitionally equal or convertible, to stress on the fact that these terms will be identified by the (kernel of) any proof assistant implementing this theory, without any need for manual equational proofs.\n\nVariables and substitution. Throughout the paper, we use named variables ($x, y$ ...) for readability purposes, but follow the de Bruijn indices discipline employed in the Coq formalization. In particular, we do not bother further with freshness conditions. A substitution $\\sigma$ consists of a list of terms, and we write $t[\\sigma]$ for its parallel substitution in the term $t$. The substitution $(id, u)$ replaces the 0th de Bruijn index by the term $u$, leaving all other variables intact. By a slight abuse of notation, we will sometimes write it simply $u$, so that if $x$ correspond to the 0th de Bruijn index in $t$, $t[u]$ is what would be written $t[x := u]$ in more verbose notation. Typing in all systems is extended pointwise to substitutions in the standard fashion, see appendix B.1 for the rules.\n\nNegative types: dependent products and sums. Dependent function types $\\Pi x : A. B$ are introduced using a $\\lambda$-abstraction $\\lambda x : A.t$ and eliminated with application $t u$. We use braces to indicate arguments that will be left implicit, e.g. $\\lambda \\{ x : A \\}. t$ of type $\\Pi \\{ x : A \\}. B$. We also include dependent (strong) sum types $\\Sigma x : A. B$, introduced with pairs $(t, u)_{x,B}$ and eliminated through projections $\\pi_1 p$ and $\\pi_2 p$. Both of these come with an $\\eta$-law beside their standard $\\beta$-laws.\n\nUniverses of types. Rule SORT introduce a countable hierarchy of universes $\\text{Type}_i$, which are types for types. Any inhabitant of a universe is a well-formed type by $\\text{El}$ and, in order to make the presentation compact, we do not repeat rules applying both for universes and types, implicitly\nDefinitional Functoriality for Dependent (Sub)Types\n\n\\( \\Gamma \\vdash T \\) \\hspace{1cm} Type \\( T \\) is well-formed under context \\( \\Gamma \\)\n\n\\( \\Gamma \\vdash t : T \\) \\hspace{1cm} Term \\( t \\) has type \\( T \\) under context \\( \\Gamma \\)\n\n\\( \\Gamma \\vdash x : A \\) \\hspace{1cm} \\( \\Gamma \\) contains the variable \\( x \\) with type \\( A \\)\n\n\\( \\Gamma, x: A \\vdash B : Type \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( x \\) with type \\( A \\) and \\( B \\) with type \\( Type \\)\n\n\\( \\Gamma \\vdash \\Pi x: A. B : Type \\) \\hspace{1cm} \\( \\Gamma \\) contains all variables and \\( \\Pi x: A. B \\) with type \\( Type \\)\n\n\\( \\Gamma \\vdash \\lambda x: A. t : \\Pi x: A. B \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( \\lambda x: A. t \\) with type \\( \\Pi x: A. B \\)\n\n\\( \\Gamma \\vdash t \\, u : A \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( t \\) with type \\( A \\) and \\( \\Gamma \\) contains \\( u \\) with type \\( A \\)\n\n\\( \\Gamma \\vdash \\epsilon_A : \\text{List} \\; A \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( \\epsilon_A \\) with type \\( \\text{List} \\; A \\)\n\n\\( \\Gamma \\vdash l: \\text{List} \\; A \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( l \\) with type \\( \\text{List} \\; A \\)\n\n\\( \\Gamma \\vdash s : \\text{List} \\; A \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( s \\) with type \\( \\text{List} \\; A \\)\n\n\\( \\Gamma \\vdash P \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( P \\)\n\n\\( \\Gamma \\vdash \\text{ind}_{\\text{List} \\; A} (s; l. P; b_e, a.l.h.b_j) : P[s] \\) \\hspace{1cm} \\( \\Gamma \\) contains all variables and \\( \\text{ind}_{\\text{List} \\; A} \\) with types\n\n\\( \\Gamma \\vdash \\text{Conv} \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( \\text{Conv} \\)\n\n\\( \\Gamma \\vdash t : A \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( t \\) with type \\( A \\)\n\n\\( \\Gamma \\vdash t : B \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( t \\) with type \\( B \\)\n\n\\( \\Gamma \\vdash \\text{Conv} \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( \\text{Conv} \\)\n\n\\( \\Gamma \\vdash T \\) \\hspace{1cm} Type \\( T \\) is well-formed under context \\( \\Gamma \\)\n\n\\( \\Gamma \\vdash t : T \\) \\hspace{1cm} Term \\( t \\) has type \\( T \\) under context \\( \\Gamma \\)\n\n\\( \\Gamma \\vdash x : A \\) \\hspace{1cm} \\( \\Gamma \\) contains the variable \\( x \\) with type \\( A \\)\n\n\\( \\Gamma, x: A \\vdash B : Type \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( x \\) with type \\( A \\) and \\( B \\) with type \\( Type \\)\n\n\\( \\Gamma \\vdash \\Pi x: A. B : Type \\) \\hspace{1cm} \\( \\Gamma \\) contains all variables and \\( \\Pi x: A. B \\) with type \\( Type \\)\n\n\\( \\Gamma \\vdash \\lambda x: A. t : \\Pi x: A. B \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( \\lambda x: A. t \\) with type \\( \\Pi x: A. B \\)\n\n\\( \\Gamma \\vdash t \\, u : A \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( t \\) with type \\( A \\) and \\( \\Gamma \\) contains \\( u \\) with type \\( A \\)\n\n\\( \\Gamma \\vdash \\epsilon_A : \\text{List} \\; A \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( \\epsilon_A \\) with type \\( \\text{List} \\; A \\)\n\n\\( \\Gamma \\vdash l: \\text{List} \\; A \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( l \\) with type \\( \\text{List} \\; A \\)\n\n\\( \\Gamma \\vdash s : \\text{List} \\; A \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( s \\) with type \\( \\text{List} \\; A \\)\n\n\\( \\Gamma \\vdash P \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( P \\)\n\n\\( \\Gamma \\vdash \\text{ind}_{\\text{List} \\; A} (s; l. P; b_e, a.l.h.b_j) : P[s] \\) \\hspace{1cm} \\( \\Gamma \\) contains all variables and \\( \\text{ind}_{\\text{List} \\; A} \\) with types\n\n\\( \\Gamma \\vdash \\text{Conv} \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( \\text{Conv} \\)\n\n\\( \\Gamma \\vdash t : A \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( t \\) with type \\( A \\)\n\n\\( \\Gamma \\vdash t : B \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( t \\) with type \\( B \\)\n\n\\( \\Gamma \\vdash \\text{Conv} \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( \\text{Conv} \\)\n\nassuming that a rule given for terms of some universe \\( Type_i \\) has a counterpart as a type judgement whenever it makes sense. Appendix B provides the full set of rules for reference. For instance, in addition to \\( \\text{FUN} \\), we have a type-level equivalent\n\n\\( \\Gamma \\vdash \\Pi x: A. B : Type \\) \\hspace{1cm} \\( \\Gamma \\) contains \\( \\Pi x: A. B \\) with type \\( Type \\)\n\nPositive types: inductive types and families. As we wish to study the functorial status of type formers, parametrized inductive types will be our main focus. Our running example is the type of lists \\( \\text{List} \\; A \\), parametrized by a single type \\( A \\), and inhabited by the empty list \\( \\epsilon_A \\) and the consing \\( h_d : : A \\; t_l \\) of a head \\( h_d : A \\) onto a tail \\( t_l : \\text{List} \\; A \\).\n\nList are eliminated using the dependent eliminator \\( \\text{ind}_{\\text{List} \\; A} (s; l. P; b_e, a.l.h.b_j) : P[s] \\), which performs recursion on the scrutinee \\( s \\), returning a value in \\( P[s] \\), using the two branches \\( b_e \\) and \\( b_j \\) corresponding to the two constructors \\( \\epsilon \\) and \\( : : \\).\n\nMore generally recursive datatypes are often encoded in MLTT via \\( \\text{W} x: A. B \\), the type of well-founded trees with nodes labelled by \\( a : A \\) of arity \\( B \\; a \\). Finally, Martin-Löf identity types \\( \\text{Id} \\; A \\; x \\; y \\) represents equalities between two elements \\( x, y : A \\) and is introduced with the reflexivity proof \\( \\text{refl}_{A, a} : \\text{Id} \\; A \\; a \\; a \\). A general indexed-inductive type scheme is outside the scope of this paper, however \\( \\text{W} \\) and \\( \\text{Id} \\) are enough to emulate the indexed-inductive types present in various proof assistants together with dependent sums, and the empty 0, unit 1 and boolean B types [Abbott et al. 2005; Altenkirch, Ghani, et al. 2015; Hugunin 2020]. As the latter three are not parametrized, their presentation in our setting is entirely standard.\nTerms $u$ and $v$ are convertible at type $A$ under context $\\Gamma$.\n\nTypes $A$ and $B$ are convertible under context $\\Gamma$.\n\nFig. 3. Declarative conversion for MLTT\n\nRules in the paper and in the appendix. To avoid cluttering the paper with too many rules, we focus in the text on the most interesting ones, and on two types: dependent functions and lists. Together, they cover the technically interesting points of our development: dependent product types have a binder and come with an $\\eta$-law; lists are a parametrized datatype, for which definitional functor laws are challenging. Complete rules for reference are given in appendix B.\n\n2.1 Metatheoretical properties\n\nThis section presents the meta-theoretical properties we seek to establish in this paper in order to show that the extension of MLTT from fig. 1 are well-behaved and suitable for implementations.\n\nConsistency and canonicity. In order to be employed as a logic, a type theory should not allow to derive every statement. This is equivalent to showing that there is no closed term of the empty type, i.e. that $\\vdash t : 0$ is not derivable for any term $t$. This consistency property is satisfied by all our type theories and an easy consequence of the stronger canonicity results, which characterizes the inhabitants of positive types in the empty context as those obtained by repeated applications of constructors, up to conversion. Consistency follows from canonicity, because $0$ has no constructors, and so it cannot have any inhabitant in the empty context.\n\nDecidability of type-checking and conversion. A consistent proof assistant must also be able to check whether a proof is valid or not. This corresponds to the problem of checking whether a typing judgement is derivable in our type theory. In a dependent type system where terms encode\nDefinitional Functoriality for Dependent (Sub)Types\n\n\\[ t \\leadsto t' \\]\nTerm \\( t \\) weak-head reduces in one step to term \\( t' \\)\n\n\\[\n\\begin{align*}\n\\betaRed & \\quad \\lambda x : A.t \\ u \\leadsto t[u] \\\\\n\\iRedNil & \\quad \\text{ind}_{\\text{List}}(\\varepsilon_A; x.P; b ; x.y.z.b) \\leadsto b \\\\\n\\iRedCons & \\quad \\text{ind}_{\\text{List}}(a z_A t; x.P; b ; x.y.z.b) \\leadsto [\\text{id}, a, l, \\text{ind}_{\\text{List}}(l; z.P; b ; x.y.z.b)]\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{RedApp} & \\quad t \\leadsto t' \\\\\n\\text{RedInd} & \\quad \\text{ind}_{\\text{List}}(t; z.P; b ; x.y.z.b) \\leadsto \\text{ind}_{\\text{List}}(t'; z.P; b ; x.y.z.b)\n\\end{align*}\n\\]\n\n\\[ t \\leadsto^* t' \\]\nTerm \\( t \\) weak-head reduces in multiple steps to term \\( t' \\)\n\n\\[\n\\begin{align*}\n\\text{RedBase} & \\quad t \\leadsto^* t \\\\\n\\text{RedStep} & \\quad t \\leadsto^* t' \\quad t' \\leadsto^* t''\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{nf} & \\quad f \\iff n \\mid \\Pi x : t_1. t_2 \\mid \\text{Type}_i \\mid \\text{List} \\mid \\lambda x : A.t \\mid \\varepsilon_A \\mid t_1 z_A t_2 \\\\\n\\text{ne} & \\quad n \\mid n t \\mid \\text{ind}_{\\text{List}}(t; n; t)\n\\end{align*}\n\\]\n\nFig. 4. Weak-head reduction and normal forms (\\( t \\) stands for an arbitrary term)\n\nthe essential structure of derivations, the main obstacle to decidability lie in the conversion of types and terms.\n\nNormal forms for terms and derivations. In order to establish both consistency and decidability of type-checking, we exhibit a function computing normal forms for term. Inspecting the possible normal forms in the empty context entails canonicity and consistency. Moreover, on these normal forms, conversion is easily decidable, and so we can build on normalization to decide conversion. Finally, we can go further, and use normalization to build canonical representatives of typing and conversion derivations, which we rely on to relate our different systems.\n\nInjectivity of type constructors. A more technical, but very important property is injectivity of type constructors, for instance the fact that whenever \\( \\Pi x : A.B \\cong \\Pi x : A'.B' \\), then \\( A \\cong A \\) and \\( B \\cong B' \\). This property typically fails in ETT where the equational theory is too rich. For expressive dependent type theories like ours, injectivity of type constructors is the main obstruction to subject reduction, i.e. that reduction is type-preserving, and included in conversion on typed instances.\n\n2.2 Neutrals, normals, and reduction\nBefore getting to the techniques we use to establish these properties, we must introduce a last element that is missing from fig. 3: computations. Indeed, most of the rules in that figure can be oriented, and thus seen not just as equalities but as computations to be performed. This leads to the definition of weak-head reduction \\( \\leadsto^* \\) in fig. 4, an evaluation strategy for open terms which reduces just as much as needed in order to uncover the head constructor of a term. This means reducing not just at top level, as rule \\( \\betaRed \\) shows: if our term is an application, we might need to reduce the function in order to expose a \\( \\lambda \\)-abstraction and subsequently \\( \\beta \\)-reduce the term with the (call-by-name) rule \\( \\betaRed \\). However, we do not allow reduction in the argument of an application, so that reduction remains deterministic: there is at most one possible reduct for any term. Weak-head reduction is the only reduction that will be used throughout this article.\nThe normal forms (nf) for weak-head reduction, \\textit{i.e.} the terms that cannot reduce, are inductively characterized at the bottom of fig. 4, together with the companion notion of neutral forms (ne). Normal forms can be either a canonical term, starting with a head constructor (for instance, a $\\lambda$-abstraction or $\\varepsilon$), or a neutral term. Neutral terms are stuck computations, blocked by some head variable, \\textit{e.g.} $x \\ u$ cannot reduce further, and will be unstuck once $x$ is substituted by a $\\lambda$-abstraction.\n\n2.3 Proof methods\n\nWith these definitions in hand, we can now go through the main techniques that we will use to establish the meta-theoretical properties we mentioned in section 2.1.\n\n**Logical relations.** Logical relations are our main tool to establish normalization and canonicity results. We follow the approach of Abel et al. \\cite{abel2017}, who formalize a logical relation for MLTT with a single universe in Agda. At a high-level, the logical relation is a model of MLTT ensuring that every denoted term is reducible: it has a weak-head normal form with reducible subterms. Combining this property with the fundamental lemma stating that every well-typed term is reducible, we obtain a first technical property, weak-head normalization.\n\n**Property 2.1 (Weak-head normalization).** If $\\Gamma \\vdash t : T$, then there exists a normal form $t'$ (\\textit{i.e.} a term $t'$ such that $\\text{nf} t'$), such that $t \\leadsto^* t'$.\n\n Moreover, since the subterms of a weak-head normal form are reducible as well, we can iterate this process, obtaining full normal forms for any well-typed term. We use the logical relation not only to characterize the normal forms of the terms but also the conversion between them, showing that a proof of convertibility between two terms can be reduced to a standard canonical shape interleaving weak-head reduction sequences and congruence steps between weak-head normal forms. While the technique is rather standard, it is also fairly involved, and adapting it to handle our new type theory, in particular parametrized inductive types and their new definitional functor laws, requires significant modifications.\n\n**Bidirectional typing and algorithmic conversion.** Our second tool is a presentation of conversion and typing that, while still inductively defined, is as close as possible to an actual implementation. Typing is bidirectional \\cite{pierce2000,lennon-bertrand2021}, \\textit{i.e.} the declarative typing predicate of fig. 2 is decomposed into type inference and type checking shown in fig. 5.\\(^2\\) We use bidirectional typing for its rigid, canonical derivation structure, rather than for its ability to cut down type annotations on terms. As a result, although we use bidirectional judgements, all of our terms infer a type, in contrast to what is common in the bidirectional literature \\cite{dunfield2021,mcbride2022}, where some terms can only be checked.\n\nThe presentation of conversion in fig. 6 combines ideas from both bidirectional typing and the presentation in Abel et al. \\cite{abel2017}. In particular, this presentation gets rid entirely of the generic transitivity rule \\textsc{Trans}, and instead uses term-directed reduction, intertwined with comparison of the heads of weak-head normal forms. Algorithmic conversion is mutually defined with a second relation, dedicated to comparing weak-head neutral forms, which is called when encountering neutrals at positive types. We think of general conversion as “checking”, \\textit{i.e.} as taking a type as input, while neutral comparison is “inferring”, \\textit{i.e.} the type is an output.\n\nUsing the consequences of the logical relation, we can show that this algorithmic presentation has many desirable properties. For instance, while it does not have a dedicated rule for transitivity of conversion, such a rule is nonetheless admissible. Collecting the properties derived from the\n\n\\(^2\\)Following Lennon-Bertrand \\cite{lennon-bertrand2021}, to avoid clashing with Coq’s $\\Rightarrow$ in the formalization, we pick $\\triangleright$ as the symbol for inference, and $\\triangleleft$ as the one for checking, instead of the slightly more standard $\\Rightarrow$ and $\\Leftarrow$. \n\n8\n<definitional functoriality for dependent (sub)types>\n\n$\\Gamma \\vdash t \\triangleright T$ Term $t$ infers type $T$ in context $\\Gamma$\n\n$\\begin{align*}\n\\text{Sort} & & \\Gamma \\vdash \\text{Type}_i \\triangleright \\text{Type}_{i+1} \\\\\n\\text{VAR} & & (x:T) \\in \\Gamma \\quad \\Gamma \\vdash x \\triangleright T \\\\\n\\text{PROD} & & \\Gamma \\vdash A \\triangleright_{h} \\text{Type}_i \\\\\n& & \\Gamma, x : A \\vdash B \\triangleright_{h} \\text{Type}_i \\\\\n& & \\Gamma \\vdash \\Pi x : A. B \\triangleright \\text{Type}_i \\\\\n\\text{LIST} & & \\Gamma \\vdash A \\triangleright_{h} \\text{Type}_i \\\\\n& & \\Gamma \\vdash \\text{List} A \\triangleright \\text{Type}_i \\\\\n\\text{ABS} & & \\Gamma \\vdash A \\triangleright_{h} \\text{Type}_i \\\\\n& & \\Gamma, x : A \\vdash t \\triangleright B \\\\\n& & \\Gamma \\vdash \\lambda x : A. t \\triangleright \\Pi x : A. B \\\\\n\\text{APP} & & \\Gamma \\vdash t \\triangleright_{h} \\Pi x : A. B \\\\\n& & \\Gamma \\vdash u \\triangleright A \\\\\n& & \\Gamma \\vdash t \\ u \\triangleright B[u] \\\\\n\\text{NIL} & & \\Gamma \\vdash A \\triangleright_{h} \\text{Type}_i \\\\\n& & \\Gamma \\vdash \\varepsilon \\triangleright \\text{List} A \\\\\n\\text{CONS} & & \\Gamma \\vdash A \\triangleright_{h} \\text{Type}_i \\\\\n& & \\Gamma, x : A, y : \\text{List} A \\vdash P \\triangleright \\text{Type}_j \\\\\n& & \\Gamma \\vdash \\text{List} A \\vdash P \\triangleright \\text{List} A \\\\\n\\text{LISTIND} & & \\Gamma \\vdash A \\triangleright_{h} \\text{Type}_i \\\\\n& & \\Gamma, x : A, y : \\text{List} A, z : P[y] \\vdash b_z \\triangleright P[x::\\text{List} A y] \\\\\n& & \\Gamma \\vdash \\text{ind}_{\\text{List} A} (s; z. P ; b_z; x. y. z. b_z) \\triangleright P[s] \\\\\n\\end{align*}$\n\n$\\Gamma \\vdash t \\triangleleft T$ Term $t$ checks against type $T$\n\n$\\begin{align*}\n\\text{CHECK} & & \\Gamma \\vdash t \\triangleright T' \\\\\n& & \\Gamma \\vdash T' \\cong T \\triangleleft \\\\\n& & \\Gamma \\vdash t \\triangleleft T \\\\\n\\text{INFRD} & & \\Gamma \\vdash t \\triangleright T' \\\\\n& & T' \\leadsto^* T \\\\\n& & \\Gamma \\vdash t \\triangleright_{h} T \\\\\n\\end{align*}$\n\nFig. 5. Typing rules for algorithmic/bidirectional typing\n\nLogical relation, we can obtain our second main property: equivalence between the algorithmic and declarative presentations.\n\n**Property 2.2 (Equivalence of the Presentations).** If $\\Gamma \\vdash t : T$, then $\\Gamma \\vdash t \\triangleleft T$. Conversely, if $\\vdash \\Gamma, \\Gamma \\vdash T$ and $\\Gamma \\vdash t \\triangleleft T$, then $\\Gamma \\vdash t : T$.\n\nNote that the implication from the bidirectional judgement to the declarative one is not absolute, it only holds if the context and type are well-formed. In general, our algorithmic presentations are “garbage-in, garbage-out”: they maintain well-formation of types and contexts, but do not enforce them. Thus, most properties of the algorithmic derivations only hold if their inputs are well-formed, in the sense of fig. 7. Note that in checking and inference modes, while the term is certainly an input of the judgement, it is of course not assumed to be well-formed, since said judgement fill that role. This algorithmic presentation, being syntax directed, is well suited to design implementations and establish relationships between MLTTmap, MLTTCoe, and MLTTSub.\n\n### 3 A Functorial Type Theory\n\nThe first extension of MLTT we develop is the type theory MLTTmap, which extends the former with primitive map$_F$ operations for each parametrized type former $F$ of MLTT, that is $\\Pi, \\Sigma, \\text{List}, \\text{W}$, and $\\text{Id}$. These operations internalize the functorial character of the type formers. Crucially,\nFig. 6. Algorithmic conversion and comparison of neutral terms\n\n<table>\n<thead>\n<tr>\n<th>Judgement</th>\n<th>Input(s)</th>\n<th>Inputs are well-formed</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$\\Gamma \\vdash t \\triangleright T$</td>\n<td>$\\Gamma$</td>\n<td>$\\vdash \\Gamma$</td>\n</tr>\n<tr>\n<td>$\\Gamma \\vdash t \\triangleleft T$</td>\n<td>$\\Gamma, t$</td>\n<td>$\\vdash \\Gamma$ and $\\Gamma \\vdash T$</td>\n</tr>\n<tr>\n<td>$\\Gamma \\vdash T \\triangleq T'$</td>\n<td>$\\Gamma, T$ and $T'$</td>\n<td>$\\vdash \\Gamma, \\Gamma \\vdash T$ and $\\Gamma \\vdash T'$</td>\n</tr>\n<tr>\n<td>$\\Gamma \\vdash t \\triangleq t'$</td>\n<td>$\\Gamma, t, t'$ and $T$</td>\n<td>$\\vdash \\Gamma, \\Gamma \\vdash T, \\Gamma \\vdash t: T$ and $\\Gamma \\vdash t': T$</td>\n</tr>\n<tr>\n<td>$\\Gamma \\vdash t \\triangleq t'$</td>\n<td>$\\Gamma, t$ and $t'$</td>\n<td>$\\vdash \\Gamma, \\Gamma \\vdash t \\vdash T, \\Gamma \\vdash t': A'$</td>\n</tr>\n</tbody>\n</table>\n\nFig. 7. Well-formed inputs (for $\\equiv_h, \\approx_h, \\triangleright_h$, similar to their non-reduced variants)\nmap will by design satisfy *definitionally* the generic functor laws for each type former $F$: \n\n$$\n\\text{map}_F \\cdot \\text{id} \\equiv \\text{id} \\quad \\text{(id-eq)}\n$$\n\n$$\n\\text{map}_F \\cdot (f \\circ g) \\equiv \\text{map}_F \\cdot f \\circ \\text{map}_F \\cdot g \\quad \\text{(comp-eq)}\n$$\n\nSection 3.1 describes the structure needed on type formers to state their functoriality in $\\text{MLTT}_{\\text{map}}$. Section 3.2 shows that definitionally functorial map $F$ is definable in vanilla MLTT for type formers with an $\\eta$-law. Section 3.3 then introduces the main content of this paper, the extension of the equational theory on neutral terms, required to enforce the functor laws on inductive type formers. We explain the technical design choices needed to define and use the logical relations for $\\text{MLTT}_{\\text{map}}$ and obtain as a consequence that the theory is consistent, enjoys canonicity, decidable conversion and type-checking. We implement these design choices in Coq for a simplified but representative version of $\\text{MLTT}_{\\text{map}}$, with one universe and the $\\Pi$, $\\Sigma$, List and N type formers, with their respective map operators. This formalization is detailed in the following section 4.\n\n### 3.1 Functorial structure on type formers\n\nIn order to state the functor laws for various type formers, such as $\\Pi$, $\\Sigma$, List, W, Id, we equip these with the required categorical structure. To simplify the exposition we directly use our type theory to present these structures. We thus consider type formers as functions $F : \\text{dom}(F) \\rightarrow \\text{cod}(F)$, with $\\text{cod}(F) \\equiv \\text{Type}$ in most cases. In the case of $\\Pi$, $\\Sigma$ or W, this means currying the parameters of the type former as dependent sums.\n\nThe domain $\\text{dom}(F)$ of a type former is then equipped with the structure of a category, that is with a type of morphisms $\\text{Hom}_F(g_1, g_2)$ for any two instances $g_1, g_2$ of $\\text{dom}(F)$, together with associated notions of identity $\\text{id}_F(g, g)$ and composition $\\circ : \\text{Hom}_F(g_2, g_3) \\rightarrow \\text{Hom}_F(g_1, g_2) \\rightarrow \\text{Hom}_F(g_1, g_3)$, associative and unital definitionally. For instance, dependent products have $\\text{dom}(\\Pi) = \\Sigma(A : \\text{Type})(A \\rightarrow \\text{Type})$ and\n\n$$\n\\text{Hom}_\\Pi((A_1, B_1), (A_2, B_2)) \\equiv \\Sigma(f : A_2 \\rightarrow A_1)(\\Pi(a : A_2), B_1 (f a) \\rightarrow B_2 a)\n$$\n\ntogether with componentwise identity and composition:\n\n$$\n\\text{id}_\\Pi : \\text{Hom}_\\Pi((A, B), (A, B)) \\equiv (\\text{id}_A, \\lambda x : A. \\text{id}_{B x})\n$$\n\n$$\n(f, g) \\circ_\\Pi (f', g') : \\text{Hom}_\\Pi((A_1, B_1), (A_3, B_3)) \\equiv (f \\circ f', \\lambda x : A_1. g \\circ g')\n$$\n\nThe domain and type of morphism of the type formers of interest are described in fig. 8. Identities and compositions are given by the standard categorical structure on Type for List and Id, and are defined similarly to $\\Pi$ for $\\Sigma$ and W. For all type formers but Id, the codomain of the functor is the category Type, again with its standard categorical structure. For identity types, the codomain\n\n<table>\n<thead>\n<tr>\n<th>Type former $F$</th>\n<th>Domain $\\text{dom}(F)$</th>\n<th>Morphism type $\\text{Hom}_F(\\cdot_1, \\cdot_2)$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>List</td>\n<td>$A : \\text{Type}$</td>\n<td>$A_1 \\rightarrow A_2$</td>\n</tr>\n<tr>\n<td>$\\Pi$</td>\n<td>$(A, B) : \\Sigma(A : \\text{Type})(A \\rightarrow \\text{Type})$</td>\n<td>$\\Sigma(f : A_2 \\rightarrow A_1)(\\Pi(a : A_2), B_1 (f a) \\rightarrow B_2 a)$</td>\n</tr>\n<tr>\n<td>$\\Sigma$</td>\n<td>idem</td>\n<td>$\\Sigma(f : A_1 \\rightarrow A_2)(\\Pi(a : A_1), B_1 a \\rightarrow B_2 (f a))$</td>\n</tr>\n<tr>\n<td>$W$</td>\n<td>idem</td>\n<td>$\\Sigma(f : A_1 \\rightarrow A_2)(\\Pi(a : A_1), B_2 (f a) \\rightarrow B_1 a)$</td>\n</tr>\n<tr>\n<td>Id</td>\n<td>$A : \\text{Type}$</td>\n<td>$A_1 \\rightarrow A_2$</td>\n</tr>\n</tbody>\n</table>\n\n1 An alternative presentation would use external notions of categorical structures type formers, expressed using a logical framework.\n$A \\to A \\to$ Type depends on the given type $A :$ Type in the domain. The adequate structure for the codomain is not that of a plain category, but of a (split) opfibration [Benabou 1985; Jacobs 2001] or displayed category [Ahrens and Lumsdaine 2019] that provide a notion of morphism in the codomain dependent upon a morphism in the domain.\n\nThe operation $\\text{map}_F$ associated to a type former $F$\n\n$$\\text{map}_F : \\prod(g_1, g_2; \\Gamma), \\text{Hom}_F(g_1, g_2) \\to F g_1 \\to F g_2$$\n\nwitnesses the fact that $F$ is not just a type former, but also has a functorial action with respect to the given category structures on its domain and codomain. Figure 9 presents the generic conversion rules of MLTT$_{\\text{map}}$, extending those of MLTT, and the rules specific to each type formers. For each type former $F$, $\\text{map}_F$ is introduced using $\\text{Map}$ and represents the functorial action through $F$ of a morphism $f : \\text{Hom}_F(X, Y)$ between two parameters $X, Y$ of $F$ left implicit. These mapping operations obey the functor laws as stated by $\\text{MapId}$ and $\\text{MapComp}$, and are congruent with respect to both the morphism and mapped element ($\\text{Map-Cong}$).\n\nThe computational behaviour of maps, as defined by weak-head reduction, depends on the type former. On $\\Pi$ and $\\Sigma$, map is defined by its observation, namely application for $\\Pi$ and first and second projections for $\\Sigma$. On inductive types such as $\\text{List}$, $\\text{W}$ and $\\text{Id}$, map is defined on constructors, propagating by applying itself to recursive arguments and using the provided morphism on the elements of the parameter types. As a result, we recover the usual notion of map on lists. On trees described as $\\text{W}$-types, the map operation relabels the nodes of the trees using its first component, and reorganizes the subtrees according to its second component. On identity types, the reflexivity proof $\\text{refl}_A$ at a point $a : A$ is mapped to the reflexivity proof at $f a : A'$ for $f : A \\to A'$. Each reduction rule has a corresponding conversion rule that can be found in appendix B.3.\n\n3.2 Extensional types and map\n\nA type $A$ has an $\\eta$-law when every element $a : A$ can be characterized by an $\\eta$-expansion, i.e. as an elimination followed by an introduction in an arbitrary context. For type formers with definitional $\\eta$-laws, it is possible to define a map operation satisfying the functor laws. In MLTT and MLTT$_{\\text{map}}$, both (strong) dependent sums $\\Sigma$ and dependent products $\\Pi$ have such extensionality laws, and so their map operations are definable.\n\n$$\\text{map}_\\Pi ((g, f) : \\text{Hom}_\\Pi((A, B), (A', B'))) (h : \\Pi(x : A)B) \\triangleq \\lambda x : A'. f (h (g x))$$\n\n$$\\text{map}_\\Sigma ((g, f) : \\text{Hom}_\\Pi((A, B), (A', B'))) (p : \\Sigma(x : A)B) \\triangleq (g (\\pi_1 p), f (\\pi_2 p))$$\n\nLemma 3.1. $\\text{map}_\\Pi$ and $\\text{map}_\\Sigma$ satisfy the functor laws $\\text{MapId}$ and $\\text{MapComp}$.\n\nAppendix C.1 gives a direct proof and the accompanying artifact also contains a proof that the functor laws hold for Coq’s $\\Pi$ and $\\Sigma$ types. The specific rule of fig. 9 hold by $\\beta$-reduction.\n\n3.3 New equations for neutral terms in dependent type theory\n\nRecursive inductive types such as $\\text{List}$, $\\text{W}$, or $\\text{Id}$ cannot be endowed with a definitional extensionality principle while retaining decidability of the equational theory [Castellan et al. 2017; McBride 2009]. The result of the previous section hence do not apply, and it is instructive to look at the actual obstruction. Consider the case of $\\text{List}$, and the equation for preservation of identities:\n\n$$\\Gamma \\vdash_{\\text{map}} \\text{map}_{\\text{List}} \\text{id}_A l \\cong l : \\text{List} A.$$ (*)&\n\nIf we were to define $\\text{map}_{\\text{List}}$ by induction on lists as is standard, we would get\n\n$$\\text{map}_{\\text{List}} (f : A \\to B) (l : \\text{List} A) \\triangleq \\text{ind}_{\\text{List}} (\\text{List} B ; l ; \\varepsilon_B, h d . t l . i h_{tl} . (f h d) \\varepsilon_B i h_{tl})$$\n\nIn file $\\text{mapPsiSigmaFunctorLaws}$.\nDefinitional Functoriality for Dependent (Sub)Types\n\nFor each type former $F$ ($\\Pi$, $\\Sigma$, List, $W$, $Id$)\n\n**MAP**\n\n\\[\n\\frac{\\Gamma \\vdash_{\\text{map}} X, Y : \\text{dom}(F)}{\\Gamma \\vdash_{\\text{map}} \\text{map}_F f t : F Y} \\quad \\frac{\\Gamma \\vdash_{\\text{map}} t : F X}{\\Gamma \\vdash_{\\text{map}} \\text{map}_F \\text{id}_F X \\ t \\ \\cong \\ t : F X}\n\\]\n\n**MAPCOMP**\n\n\\[\n\\frac{\\Gamma \\vdash_{\\text{map}} X, Y, Z : \\text{dom}(F)}{\\Gamma \\vdash_{\\text{map}} \\text{map}_F f (\\text{map}_F g t) \\ \\cong \\ \\text{map}_F (f \\circ g) t : F Z}\n\\]\n\n**MAP-Cong**\n\n\\[\n\\frac{\\Gamma \\vdash_{\\text{map}} X, Y : \\text{dom}(F) \\quad \\Gamma \\vdash f \\cong f' : \\text{Hom}_F (X, Y) \\quad \\Gamma \\vdash t \\cong t' : F X}{\\Gamma \\vdash_{\\text{map}} \\text{map}_F f t \\ \\cong \\ \\text{map}_F f' t' : F Y}\n\\]\n\n**Specific rules**\n\n\\[\n\\text{map}_{\\text{List}} f (hd :: tl) \\sim^1 f hd :: \\text{map}_{\\text{List}} f tl \\quad \\text{map}_{\\text{List}} f \\varepsilon \\sim^1 \\varepsilon\n\\]\n\n\\[\n\\pi_1 (\\text{map}_\\Sigma f p) \\sim^1 \\pi_1 f (\\pi_1 p) \\quad \\pi_2 (\\text{map}_\\Sigma f p) \\sim^1 \\pi_2 f (\\pi_2 p)\n\\]\n\n\\[\n\\text{map}_\\Pi f h t \\sim^1 (\\pi_2 f) (h ((\\pi_1 f) t))\n\\]\n\n\\[\n\\text{map}_{W \\{T\\} \\{T'\\}} f (\\sup x. a. k) \\sim^1 \\sup x. \\pi_2 T' (\\pi_1 f a) (\\lambda x. (\\pi_2 T' (\\pi_1 f a)). \\text{map}_{W} f (k (\\pi_2 g x))\n\\]\n\n\\[\n\\text{map}_{Id} f \\ \\text{refl}_{A, a} \\sim^1 \\text{refl}_{B, f a} \\quad \\text{REDMAPCOMP} \\quad \\text{map}_{\\text{List}} f (\\text{map}_{\\text{List}} g n) \\sim^1 \\text{map}_{\\text{List}} (f \\circ g) n\n\\]\n\nFig. 9. MLTT$_{\\text{map}}$, conversion rules and reduction rules for each type former (extends figs. 2 to 4)\n\nWe can observe that eq. (⋆) is validated on closed canonical terms of type List:\n\n\\[\n\\text{map}_{\\text{List}} \\text{id}_A \\varepsilon_A \\ \\cong \\ \\varepsilon_A \\quad \\text{map}_{\\text{List}} \\text{id}_A (hd :: tl) \\ \\cong \\ (\\text{id}_A \\ hd) :: \\text{map}_{\\text{List}} \\text{id}_A \\ tl \\ \\cong \\ hd :: tl\n\\]\n\nHowever, on neutral terms, typically variables, we are stuck as long as we stay within the equational theory of MLTT:\n\n\\[\nA : \\text{Type}, \\ \\ell : \\text{List} \\ A \\not\n\\text{map}_{\\text{List}} \\text{id}_A \\ell \\ \\cong \\ \\ell : \\text{List} \\ A\n\\]\n\nIn order to validate eq. (⋆), MLTT$_{\\text{map}}$ must thus at the very least extend the equational theory on neutral terms. Allais et al. [2013] show in the simply-typed case that these equations between neutral terms are actually the only obstruction to functor laws, and in the remainder of this section we discuss design choices needed for this extension in the dependently-typed world.\n\n**Map composition and compacted neutrals.** The first step in order to validate the functor laws is to get as close as possible to a canonical representation for each term. In order to deal with composition of maps, we extend weak head reduction with REDMAPCOMP to fuse consecutive stuck maps. This rule only applies to consecutive map$_F$ for the same type former, which is the only possible case for well-typed terms. Moreover, in order to preserve the deterministic nature of weak-head reduction, map compaction should only apply when no other rule does. To achieve this, the type former $F$ should be an inductive type, because map$_\\Pi$ is already handled through\nthe $\\eta$-expansion of $\\text{CFUN}$, and similarly for $\\text{map}_A$. Moreover, the mapped term should be neither a canonical form where $\\text{map}$ already has a computational behaviour, nor a map itself that could fire the same rule. The mapped element is hence required to be a weak-head neutral term. To separate weak-head normal forms which might contain a map as their head from those which cannot, we split the usual neutral forms from the compacted neutrals, see fig. 10. Allais et al. [2013] also feature a decomposition of normal forms into three different classes rather than two akin to this one, although their normal forms for lists are more complex than ours as they validate more definitional equations than functorial laws.\n\nMaps on identities. For identities, a similar reduction-based approach is difficult: turning the equation $\\Gamma \\vdash \\text{map}_A \\text{List} \\text{id}\\ A \\equiv l : \\text{List} A$ into a reduction raises issues similar to those encountered with $\\eta$-laws. Orienting it as an expansion $l \\rightsquigarrow \\text{map}_A \\text{id}\\ A \\equiv l$ requires knowledge of the type to ensure the expansion only applies to lists, and is potentially non-terminating. But using a typed reduction would require a deep reworking of the structure of our systems, proofs and decision algorithms.\n\nAs a result, just like for $\\eta$ on functions in rule $\\text{CFUN}$, we implement this rule as part of the conversion, rather than as a reduction. We also incorporate it carefully in the notion of reducible conversion in the logical relation, where we do have access to enough properties of the type theories. Since the equation is always validated by canonical forms, we only need to enforce it on compacted neutrals. The logical relation for an inductive type $I(\\text{List}, W, \\text{Id})$ thus specifies that a neutral $n$ is reducibly convertible to a compacted neutral $I(f\\ m)$, whenever the neutrals $n$ and $m$ are convertible and $f$ agree with the identity of $\\text{dom}(I)$ on any neutral term. See $\\text{MAPNECONVREDL}$ in the next section for the exact rule.\n\nEliminators: fusion or not fusion? When considering the interaction between $\\text{map}$ and the eliminator $\\text{ind}_A\\ \\text{List}$, arises a design choice: should we also fuse them, i.e. implement the following reduction rule, which pushes the map from the scrutinee into the branches?\n\n$$\\text{ind}_I(f\\ n; l.P; b_c, a.l.h.b_n) \\rightsquigarrow \\text{ind}_I(n; l.P [\\text{map}_A f l]; b_c, a.l.h.b_n [\\text{id}, f a, \\text{map}_A f l, h])$$\n\nFrom the point of view of functorial equations, this is not necessary. In fig. 10, and the rest of this paper, we thus take the most conservative approach, and do not add this reduction rule.\n\nHowever, from the point of view of a subsumptive bidirectional subtyping, this fusion is necessary if we wish to infer the parameters of the inductive types from the scrutinee (as in $\\text{Fus}$ below), rather than store them in the induction node (as in $\\text{NoFus}$).\n\n$$\\begin{array}{c}\n\\text{Fus} \\quad \\Gamma \\vdash \\text{sub} \\ s \\triangleright \\text{List} A \\\\\n\\Gamma, l: \\text{List} A \\vdash \\text{sub} \\ P \\triangleright \\text{Type} \\\\\n\\Gamma, l: \\text{List} A \\vdash \\text{ind}_A (s; l.P; \\ldots) \\triangleright P [s]\n\\end{array} \\quad \\begin{array}{c}\n\\text{NoFus} \\quad \\Gamma \\vdash \\text{sub} A \\triangleleft \\\\\n\\Gamma, l: \\text{List} A \\vdash \\text{sub} \\ P \\triangleright \\text{Type} \\\\\n\\Gamma, l: \\text{List} A \\vdash \\text{ind}_A (s; l.P; \\ldots) \\triangleright P [s]\n\\end{array}$$\nat which the eliminator is typed, and so this parameter can change, which in a coercive system corresponds to pushing coercions into the branches, as in the fusion equation above.\n\n4 FORMALIZING NEW EQUATIONS FOR NEUTRAL LISTS\n\nIn this section we expose the main components of the accompanying Coq formalization, which covers normalization, equivalence of declarative and algorithmic typing, decidability of type-checking and canonicity for a subset of $\\text{MLTT}_{\\text{map}}$ with $0, \\mathbb{N}, \\Pi, \\Sigma, \\text{List}$ and a single universe. As it is heavily inspired by a previous Agda formalization [Abel et al. 2017], which has already been extended multiple times [Gilbert et al. 2019; Pujet and Tabareau 2022, 2023], we only give a high level overview of our main adaptations here, and direct the reader either to the Coq code or the original paper [Abel et al. 2017] for more details. The formalization spans ~25k lines of code, approximately 8k of which are specific to our extension with lists and definitionally functorial maps.\n\n4.1 A logical relation with functor laws on list\n\nThe Coq development defines both the declarative and algorithmic presentations of $\\text{MLTT}_{\\text{map}}$ and proves their equivalence through a logical relation parametrized by a generic typing interface$^6$ instantiated by both presentations. Beyond generic variants of the typing and conversion judgements, the interface uses two extra judgements: $\\Gamma \\vdash \\text{map } t \\{ * \\} t' : A$ stating that $t$ reduces to $t'$ and that they are both well typed at type $A$ in context $\\Gamma$; and $\\Gamma \\vdash n \\approx n' : A$ stating that $n$ and $n'$ are convertible neutral terms.\n\nDefinition of the logical relation. Because we are dealing with dependent types, the usual strategy of logical relations to define reducibility of terms by induction on their types fails. Rather, we need to define reducibility of types and of terms mutually, the latter depending on a witness of the former. To do so, Abel et al. [2017] first define for each type former $F$ what it means to be a type reducible as $F$, and what it means to be a reducible term and reducibly convertible terms at such a type reducible as $F$. A type is then reducible if it is reducible as $F$ for some $F$. As we extend the logical relation to handle $\\text{List}$ and $\\text{map}_{\\text{List}}$, we focus on a high level description of the reducibility of types as lists and the reducible convertibility of terms of type $\\text{List}$.\n\nA type $X$ is reducible as a list in context $\\Gamma$, noted $\\Gamma \\models_{\\text{List}} X$, if it weak-head reduces to $\\text{List } A$ for some parameter type $A$, itself reducible in any context $\\Delta$ extending $\\Gamma$ through a weakening $\\rho : \\text{Wk}(\\Delta, \\Gamma)$. If $\\mathcal{L} : \\Gamma \\models_{\\text{List}} X$ is a witness that $X$ is reducible as a list, let us write $P(\\mathcal{L})$ for the parameter type $A$ of this witness, and $P(\\mathcal{L}) : \\Pi(\\rho : \\text{Wk}(\\Delta, \\Gamma)). \\Delta \\models P(\\mathcal{L})[\\rho]$ for its witness of reducibility.\n\nReducible convertibility of terms as lists $\\Gamma \\models t \\equiv t' : \\text{List } A \\mid \\mathcal{L}$ is defined in fig. 11. Two terms $t$ and $t'$ are reducibly convertible as lists according to $\\mathcal{L} : \\Gamma \\models_{\\text{List}} X$ ($\\text{ListRED}$) if they reduce to normal forms $v, v'$ that are reducibly convertible as normal forms of type list $\\Gamma \\models_{\\text{nf}} v \\equiv v' : \\text{List } A \\mid \\mathcal{L}$. Straightforwardly, two canonical forms are convertible if they are both $\\varepsilon$ ($\\text{NilRED}$) or both $- : -$ ($\\text{ConsRED}$) with reducibly convertible heads and tails.\n\nFor compacted neutral forms, we need to consider four cases according to whether each of the left or the right hand-side term is a map $\\text{map}_{\\text{List}}$. $\\text{NeRED}$ provides the easy case where both terms are actually neutral, with a single premise requiring that these are convertible as neutrals for the generic typing interface. $\\text{MapMapConvRED}$ gives the congruence rule for stuck map $\\text{map}_{\\text{List}} f n$ and $\\text{map}_{\\text{List}} f' n'$ when the mapped list $n$ and $n'$ are convertible as neutrals and\n\n---\n\n5 The formalization does not provide the eliminator for lists, but does provide it for $\\mathbb{N}$, another inductive type with recursive occurrences.\n\n6 Defined in GenericTyping\n\n7 Available in file LogicalRelation.\n\\[\\Gamma \\vdash_{\\text{map}} t \\leadsto^* v : \\text{List} \\, \\mathcal{P}(\\mathcal{L}) \\quad \\Gamma \\vdash_{\\text{map}} t' \\leadsto^* v' : \\text{List} \\, \\mathcal{P}(\\mathcal{L})\\]\n\n\\[\n\\begin{align*}\n\\text{LISTRED} & \\quad \\Gamma \\parallel_{\\text{nf}} v \\equiv v' : \\text{List} \\, \\mathcal{P}(\\mathcal{L}) \\quad \\Gamma \\parallel_{\\text{nf}} t \\equiv t' : \\text{List} \\, \\mathcal{A} \\mid \\mathcal{L} \\\\\n& \\quad \\Gamma \\parallel t \\equiv t' : \\text{List} \\, \\mathcal{A} \\mid \\mathcal{L} \\\\\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{NILRED} & \\quad \\Gamma \\parallel_{\\text{nf}} n \\equiv n' : \\text{List} \\, \\mathcal{A} \\\\\n& \\quad \\Gamma \\parallel_{\\text{nf}} n \\equiv n' : \\text{List} \\, \\mathcal{A} \\mid \\mathcal{L} \\\\\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{CONSRED} & \\quad \\Gamma \\parallel_{\\text{nf}} n \\equiv n' : \\text{List} \\, \\mathcal{A} \\\\\n& \\quad \\Gamma \\parallel n \\equiv n' : \\text{List} \\, \\mathcal{A} \\mid \\mathcal{L} \\\\\n& \\quad \\Gamma \\parallel_{\\text{nf}} t l \\equiv t l' : \\text{List} \\, \\mathcal{A} \\mid \\mathcal{L} \\\\\n& \\quad \\Gamma \\parallel_{\\text{nf}} h d \\equiv h d' : \\mathcal{A} \\mid \\mathcal{P}(\\mathcal{L}) \\\\\n& \\quad \\Gamma \\parallel h d \\equiv h d' : \\mathcal{A} \\mid \\mathcal{P}(\\mathcal{L}) \\\\\n& \\quad \\Gamma \\parallel_{\\text{nf}} e p \\equiv e p' : \\text{List} \\, \\mathcal{A} \\mid \\mathcal{L} \\\\\n& \\quad \\Gamma \\parallel_{\\text{nf}} e p \\equiv e p' : \\text{List} \\, \\mathcal{A} \\mid \\mathcal{L} \\\\\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{MAPNECONVREDL} & \\quad \\Gamma, x : \\mathcal{X} \\parallel_{\\text{ns}} f x \\equiv x : \\mathcal{A} \\mid \\mathcal{P}_{\\mathcal{P}}(\\mathcal{L}) \\\\\n& \\quad \\Gamma, x : \\mathcal{X} \\parallel_{\\text{ns}} f x \\equiv x : \\mathcal{A} \\mid \\mathcal{P}_{\\mathcal{P}}(\\mathcal{L}) \\\\\n& \\quad \\Gamma \\parallel_{\\text{nf}} \\text{map}_{\\text{List}} f n \\equiv n' : \\text{List} \\, \\mathcal{A} \\mid \\mathcal{L} \\\\\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{NEMAPCONVREDR} & \\quad \\ldots \\\\\n\\end{align*}\n\\]\n\n\\[\n\\begin{align*}\n\\text{MAPMAPCONVRED} & \\quad \\Gamma \\parallel_{\\text{nf}} \\text{map}_{\\text{List}} f n \\equiv n' : \\text{List} \\, \\mathcal{X} \\\\\n& \\quad \\Gamma, x : \\mathcal{X} \\parallel_{\\text{ns}} f x \\equiv f' x : \\mathcal{A} \\mid \\mathcal{P}_{\\mathcal{P}}(\\mathcal{L}) \\\\\n\\end{align*}\n\\]\n\nFig. 11. Reducible convertibility of lists\n\nthe bodies \\(f x\\) and \\(f' x\\) of the functions are reducibly convertible. Note that at this point of the logical relation, we do not know that the domain of the functions \\(f\\) and \\(f'\\) is reducible, only that their codomain is, as provided by \\(\\mathcal{P}_{\\mathcal{P}}(\\mathcal{L})\\). This constraint motivates both the \\(\\eta\\)-expansion of the functions on the fly before comparing them, and the necessity of a Kripke-style quantification on larger contexts for the reducibility of the parameter type \\(\\mathcal{P}_{\\mathcal{P}}(\\mathcal{L})\\), together ensuring that the recursive reducible conversion happens at a reducible type, namely a weakened instance of \\(\\mathcal{A}\\).\n\nFinally, the symmetric rules \\text{NEMAPCONVREDR} and \\text{MAPNECONVREDL} deal with the comparison of a \\text{map}_{\\text{List}} against a neutral \\(n\\), that can be morally thought as \\text{map}_{\\text{List}} \\text{id} \\, n\\, and indeed the premises correspond to what one would obtain with \\text{MAPMAPCONVRED} in that case, up to an inlined \\(\\beta\\)-reduction step.\n\n\\textbf{Validity of the functor laws.} All the expected properties extend to this new logical relation: reflexivity, symmetry, transitivity, irrelevance with respect to reducible conversion, stability by weakening and anti-reduction\\(^8\\). These properties are essential in order to show that the logical relation validates the functor laws on any reducible term. The proof proceeds through a usual argument for logical relations: on canonical forms, the functor laws hold as observed already in section 3.3; on compacted neutrals and neutral forms, we need to show that any compositions of \\text{map}_{\\text{List}} reduce to a single map of a function with a reducible body, which amounts to show that composing reducible functions produces reducible outputs on reducible inputs. This last step in the proof reflect our assumption that the categorical structure equipping domains of type formers should be definitionally associative and unital.\n\n\\(^{8}\\text{Available in the directory LogicalRelation.}\\)\nDefinitional Functoriality for Dependent (Sub)Types\n\n4.2 Equivalence between declarative and algorithmic typing\n\nInstantiating the generic typing interface of the logical relation with declarative typing provides as consequences metatheoretical properties exhibiting the existence of normal forms, among which (weak-head) normalization, injectivity of type constructors and subject reduction. Using those, we can show that algorithmic typing is sound directly by induction, and also that it fits the generic typing interface of the logical relation, which lets us derive that it is complete with respect to declarative typing.\n\nThis part of the proof is close to that of Abel et al. [2017], with two important differences. First, reflecting the addition of compacted neutrals in our definition of normal forms, we must adapt algorithmic conversion accordingly, and introduce a third mutually defined relation to compare compacted neutrals. The main idea is presented in rules LISTNECONV and NEMAPLISTL below: when we need to compare compacted neutrals, we use the new relation \\( \\approx \\), which simulates the behaviour of the logical relation from fig. 11 on compacted neutrals. Second, Abel et al. [2017] stop at conversion, while we also provide algorithmic typing, which is necessary both to show decidability of type-checking and provide the necessary structure for sections 5.3 and 5.5.\n\n\\[\n\\text{LISTNECONV} \\quad \\Gamma \\vdash_{\\text{map}} c \\approx_{\\text{map}} c' \\triangleright \\text{List} \\ A \\\\\n\\quad \\text{NeMAPLISTL} \\quad \\Gamma, x : A \\vdash_{\\text{map}} f x \\equiv x < B \\\\\n\\quad \\Gamma \\vdash_{\\text{map}} \\text{List} \\ n \\approx_{\\text{map}} n' \\triangleright \\text{List} \\ B\n\\]\n\n4.3 Practical algorithms to decide conversion and typing\n\nOur final result is decidability of type checking. This is not merely a theorem obtained by working in a constructive meta-theory. Rather, the Coq formalization defines implementations of type-checking and conversion well-suited for extraction using the EQUATIONS plugin [Sozeau and Mangin 2019]. To separate the definition of these functions from their correctness, we define them as partial functions, building upon a Coq development by Winterhalter [2023] implementing the free recursion monad of McBride [2015]. Then, in a second phase, we separately show soundness, completeness and termination using the structure of algorithmic typing derivations, culminating in the decidability result.\n\n5 SUBTYPING, COERCIVE AND SUBSUMPTIVE\n\nThe main application we develop for our definitional functor laws is structural subtyping. More precisely, we describe two extensions of MLTT. The first is MLTT_sub, whose subtyping is subsumptive: whenever \\( \\vdash_{\\text{sub}} t : A \\preceq A' \\), then also \\( \\vdash_{\\text{sub}} t : A' \\), leaving the use of subtyping implicit. The second is MLTT_coe, which features coercive subtyping, in the form of an operator \\( \\text{coe}_{A,A'} t \\), well-typed whenever \\( \\vdash_{\\text{coe}} t : A \\preceq A' \\) as before, but now explicitly marking where subtyping is used. The computational behaviour of coe on type formers coincides with that of map in MLTT_map.\n\nIn section 5.1, we give both an algorithmic and declarative presentation of MLTT_coe, but only an algorithmic presentation of MLTT_sub. The idea is that the declarative version of MLTT_coe should serves as a specification for MLTT_sub, with the algorithmic MLTT_coe as an intermediate step to relate the two. In the context of a proof assistant or dependently typed programming language, MLTT_sub should serve as the flexible, user-facing system while MLTT_coe would be its well-behaved foundation, making it easier to build meta-theory and semantics.\n\n---\n\n9See file Decidability for the high-level function/theorem.\n10In file Decidability/Functions.\n### The type systems \\(\\text{MLTT}_{\\text{sub}}\\) and \\(\\text{MLTT}_{\\text{coe}}\\)\n\n#### 5.1 Algorithmic \\(\\text{MLTT}_{\\text{sub}}\\)\n\n\\(\\text{MLTT}_{\\text{sub}}\\) replaces \\textsc{Check} in \\textsc{MLTT} from fig. 5 with the following rule, which uses subtyping \\(\\preceq\\) instead of conversion:\n\n\\[\n\\text{CheckSub} \\quad \\frac{\\Gamma \\vdash \\text{sub} \\; t \\triangleright T'}{\\Gamma \\vdash \\text{sub} \\; T \\preceq T'}\n\\]\n\nSubtyping, defined in fig. 12, orients type-level conversion from fig. 6, taking into account co- and contravariance. It relies on neutral comparison and term-level conversion, both of which are not altered compared to fig. 6: subtyping is a type-level concept only.\n\n#### 5.1.2 A type of labels to model records\n\nWhile the rule of fig. 12 let us propagate subtyping structurally through type formers, for the resulting system to be any different from \\(\\text{MLTT}\\), we need some base non-trivial subtyping. Its exact choice is largely orthogonal to the focus of this paper on the structural aspect of subtyping, and indeed the development of this section is relatively independent of that choice. Still, for our subtyping to be of any interest, we must fix something.\n\nWe thus choose a rather simple example, presented in fig. 13. We fix a countable set of labels \\(\\text{Lbl}\\), and for each finite subset \\(L \\in P_f(\\text{Lbl})\\) introduce a type \\(L\\), with inclusion as subtyping between these. For each \\(l \\in \\text{Lbl}\\), there is a term \\(\\{\\{l\\}\\}\\). Finally, \\(L\\) has a dependent eliminator \\(\\text{ind}_L\\) which behaves like that of an inductive enumeration: if we can construct an inhabitant of \\(P: L \\rightarrow \\text{Type}\\) for every \\(l \\in L\\), then we can construct some inhabitant of \\(\\Pi x: L. P\\).\n\nThanks to this eliminator, a function \\(R: L \\rightarrow \\text{Type}\\) can be viewed as a (non-dependent) record type, with \\(R \\; l\\) the type of the field labelled by \\(l\\). A term \\(r: \\Pi x: L. R\\; x\\) is then a record of that type, with field \\(l\\) given by \\(r\\; l\\). Finally, the eliminator lets us construct a record by giving a value for each\n\n---\n\n\\(\\text{coe}\\) denotes a singleton set. Via subtyping, whenever \\(l \\in L\\) we will be able to construct an inhabitant of \\(L\\) corresponding to \\(l\\), either \\(l\\) itself in \\(\\text{MLTT}_{\\text{sub}}\\), or \\(\\text{coe}\\{l\\}, L\\) \\(\\{l\\}\\) in \\(\\text{MLTT}_{\\text{coe}}\\). We abbreviate the latter as \\(\\text{coe}_L\\).\nfield. In this reading, structural subtyping on the domain of function types gives width subtyping of record types, and subtyping on the codomain induces depth subtyping, for free.\n\n5.1.3 Algorithmic MLTT$\\text{coe}$. In contrast with MLTT$\\text{sub}$, in MLTT$\\text{coe}$ rule $\\text{CHECK}$ is crucially not altered. Instead, subtyping is only allowed when explicitly marked by $\\text{coe}$, as follows:\n\n\\[\n\\Gamma \\vdash_{\\text{coe}} \\text{A} \\prec \\quad \\Gamma \\vdash_{\\text{coe}} \\text{A}' \\prec \\quad \\Gamma \\vdash_{\\text{coe}} \\text{t} \\prec \\text{A} \\quad \\Gamma \\vdash_{\\text{coe}} \\text{A} \\lessdot \\text{A}' \\prec \\quad \\Gamma \\vdash_{\\text{coe}} \\text{coe}_{\\text{A,A'}} \\text{t} \\prec \\text{A}'\n\\]\n\nInference rules for all other type and term formers are similar to those of figs. 5 and 13.\n\nReduction must of course be extended to give an operational behaviour to $\\text{coe}$, and is given in fig. 14, together with normal forms. Operationally, $\\text{coe}_{\\text{A,A'}} \\text{t}$ reduces the types $\\text{A}$ and $\\text{A}'$ to head normal forms, then behaves like map according to these, propagating $\\text{coe}$ recursively on subterms. Since $\\text{coe}_{\\text{A,A'}} \\text{t}$ is well-typed only when $\\text{A}$ is a subtype of $\\text{A}'$, the type formers of their head normal forms cannot differ, ensuring that we can always rely on such a map-like behaviour to enact structural subtyping. At base type $\\text{L}$, $\\text{coe}_{\\{\\text{t}\\}} \\text{L}$ $\\text{l}$ works as canonical constructors for the type $\\text{L}$. Finally, just as for map, rule $\\text{COECOE}$ let us compact a succession of stuck $\\text{coe}$.\n\nNeutral conversion is described at the top of fig. 15 and features an additional comparison between compacted neutrals similar to MLTT$\\text{map}$ (LIST$\\text{NeConv}$). Rule $\\text{NCOE}$ is the “congruence rule” for coercions, where the source and target types necessarily agree by typing invariants. Rules $\\text{NCOEL}$ and $\\text{NCOER}$ handle identity coercions.\n\nAccordingly, $\\approx_{\\text{coe}}$ is carefully used whenever normal forms can be compacted neutrals, i.e. at neutral and list types, as shown at the bottom of fig. 15. Apart from this change, conversion at the term and type level and subtyping are similar to those of MLTT$\\text{sub}$.\n\n5.1.4 Declarative MLTT$\\text{coe}$. The declarative presentation of MLTT$\\text{coe}$, noted $\\vdash_{\\text{coe}}$, straightforwardly extends MLTT (figs. 2 and 3) with typing rules for labels and $\\text{coe}$ similar to the inference rules from the algorithmic presentation, as well as reduction and conversion rules for $\\text{ind}_{\\text{L}}$ and $\\text{coe}$ from fig. 14. Most importantly, it satisfies the following two equations of identity and composition of coercions, definitionally.\n\n\\[\n\\begin{align*}\n\\text{CoEIn} & \\quad \\Gamma \\vdash_{\\text{coe}} \\text{t} : \\text{A} \\\\\n\\text{CoETrans} & \\quad \\Gamma \\vdash_{\\text{coe}} \\text{t} : \\text{A} \\quad \\Gamma \\vdash_{\\text{coe}} \\text{A} \\lessdot \\text{A}' \\quad \\Gamma \\vdash_{\\text{coe}} \\text{A}' \\lessdot \\text{A}'' \\\\\n\\end{align*}\n\\]\n\nFig. 13. Labels, typing and conversion (extends figs. 5, 6 and 12)\n\\[\nt \\mapsto^1 \\, t'\n\\]\n\\[\n\\text{coe}_{\\Pi x:A'.B',\\Pi x:A.B}(\\lambda x:A''.t) \\mapsto^1 \\, \\lambda x:A.\\text{coe}_{A,A'}[\\text{coe}_{A',x}]B[x](t[\\text{coe}_{A,A'} x])\n\\]\n\\[\n\\text{RedCoeFunNe}\n\\]\n\\[\n(\\text{coe}_{\\Pi x:A'.B',\\Pi x:A.B} f) \\, a \\mapsto^1 \\, \\text{coe}_{A,A'}[\\text{coe}_{A',a}]B[a](f(\\text{coe}_{A,A'} a))\n\\]\n\\[\n\\text{coe}_{\\text{Type},\\text{Type},t} \\mapsto^1 \\, t\n\\]\n\\[\n\\text{coe}_{\\text{List}\\,\\text{List},A,A'} (h \\, z \\, t) \\mapsto^1 \\, \\text{coe}_{A,A'} h \\, \\text{coe}_{\\text{List}\\,\\text{List},A,A'} t\n\\]\n\\[\n\\begin{align*}\n\\text{CoeR} & \\quad \\text{nf} A \\quad B \\mapsto^1 B' \\quad \\text{coe}_{A,B} t \\mapsto^1 \\text{coe}_{A,B'} t \\\\\n\\text{CoeTM} & \\quad \\text{nf} A \\quad \\text{nf} B \\quad t \\mapsto^1 \\, t' \\quad \\text{coe}_{A,B} t \\mapsto^1 \\text{coe}_{A',B'} t' \\\\\n\\text{CoeCoe} & \\quad \\text{nf} U \\quad \\text{nf} U' \\quad \\text{nf} T \\quad \\text{nf} T' \\quad \\text{ne} n\n\\end{align*}\n\\]\n\nFig. 14. Weak-head reduction rules for coercion (extends fig. 4)\n\n\\[\n\\begin{align*}\n\\Gamma \\vdash_{\\text{coe}} t & \\approx_{\\text{coe}} t' \\triangleleft T \\\\\n\\Gamma \\vdash_{\\text{coe}} n \\approx_{\\text{coe}} n' \\triangleright S'' & \\quad \\text{NCOE} \\quad \\Gamma \\vdash_{\\text{coe}} n \\approx_{\\text{coe}} n' \\triangleleft S'' \\quad \\text{NCOE} \\quad \\Gamma \\vdash_{\\text{coe}} n \\approx_{\\text{coe}} n' \\triangleright T'' \\\\\n\\Gamma \\vdash_{\\text{coe}} n \\approx_{\\text{coe}} n' \\triangleright S'' & \\quad \\text{NCOER} \\quad \\Gamma \\vdash_{\\text{coe}} n \\approx_{\\text{coe}} n' \\triangleleft T'' \\quad \\text{NNoCoE} \\quad \\Gamma \\vdash_{\\text{coe}} n \\approx_{\\text{coe}} n' \\triangleright T'' \\\\\n\\Gamma \\vdash_{\\text{coe}} t \\cong_{\\text{h}} t' \\triangleleft T & \\quad \\text{NEULIST} \\quad \\Gamma \\vdash_{\\text{coe}} n \\cong_{\\text{h}} n' \\triangleleft \\text{List}\\,A \\\\\n\\Gamma \\vdash_{\\text{coe}} n \\cong_{\\text{h}} n' \\triangleright M \\quad \\text{NEUENU} \\quad \\Gamma \\vdash_{\\text{coe}} n \\cong_{\\text{h}} n' \\triangleright M\n\\end{align*}\n\\]\n\nFig. 15. Algorithmic comparison of neutrals, with explicit coercions (extends/replaces fig. 6)\n\n### 5.2 Equivalence of algorithmic and declarative typing\n\nIn order to prove properties of correspondence between MLTT\\textsubscript{coe} and MLTT\\textsubscript{map}, we must first study MLTT\\textsubscript{coe}. All the meta-theoretic properties of MLTT\\textsubscript{map} proved in section 4 carry over to MLTT\\textsubscript{coe}. We highlight the following two.\n\n**Theorem 5.1 (Weak-head normalization).** If \\( \\Gamma \\vdash_{\\text{coe}} t : T \\), then there exists a weak-head normal form \\( t' \\) such that \\( t \\mapsto^* t' \\).\n\n**Theorem 5.2 (Soundness and completeness of algorithmic typing).** If \\( \\Gamma \\vdash_{\\text{coe}} t : T \\) and \\( \\Gamma \\vdash_{\\text{coe}} t \\triangleright T \\) then \\( \\Gamma \\vdash_{\\text{coe}} t : T \\), and similarly for the other judgements. Conversely, if \\( \\Gamma \\vdash_{\\text{coe}} t : T \\), then \\( \\Gamma \\vdash_{\\text{coe}} t \\triangleleft T \\), and similarly for the other judgements.\nMost proof ideas from $\\text{MLTT}_{\\text{map}}$ carry over to $\\text{MLTT}_{\\text{coe}}$, and we did not mechanize this part of the paper, focusing our formalization effort on the most challenging aspect of the theory. Still, we give a sketch of how to extend the logical relation for $\\text{MLTT}_{\\text{map}}$ to $\\text{MLTT}_{\\text{coe}}$ – the proofs of equivalence between the declarative and algorithmic systems from the logical relation then remain mostly unchanged.\n\n**Proof Sketch (Extending the Logical Relation to $\\text{MLTT}_{\\text{coe}}$).** $\\text{MLTT}_{\\text{coe}}$ has three main differences compared to $\\text{MLTT}_{\\text{map}}$, so let us treat them in order.\n\nFirst, we need to extend reducible type-level conversion to handle subtyping. As the structure of the two judgements is exactly the same, apart from the base subtyping case, rather than defining two separate judgements we can factor the two together by using a single judgement parametrized by a conversion problem, a three-valued variant indicating conversion, subtyping, or supertyping, the latter being needed to handle contravariance and the left bias of reducible conversion, which is defined on a proof of reducibility of its left type.\n\nSecond, we need to show that $\\text{coe}_{A,A'} t$ is reducible whenever $A$ is a reducible subtype of $A'$, and $t$ is reducible at $A$. Because $A$ is a reducible subtype of $A'$, both must have normal forms which are either constructed with the same type former $F$, both label types, or both neutrals. In the first case, $\\text{coe}_{A,A'} t$ behaves like $\\text{map}_{F'}$, and so the reducibility proofs from section 4 carry over. In case $A$ and $A'$ are both neutral, $\\text{coe}_{A,A'} t$ might compact if $t$ is a coercion itself, but this is also similar to the case of a neutral map in $\\text{MLTT}_{\\text{map}}$, and so the proof from section 4 carries over again.\n\nWe are left with the type formers $L$, that behave like enumeration types. The formalized proof for $\\mathbb{N}$ adapts, up to an additional case for compacted neutrals of shape $\\text{coe}_{L,L'} n$. The reducibility of $\\text{coe}_{L,L'} t$ uses $\\text{CoeCoe}$ on the compacted neutral case and follows that of the definable term $\\text{ind}_{L}(t; x. L'\\{\\text{coe}_{L'} l\\}_{l\\in L})$ on other canonical forms.\n\n## 5.3 Elaboration and erasure\n\nWe can now turn to the correspondence between $\\text{MLTT}_{\\text{sub}}$ and $\\text{MLTT}_{\\text{coe}}$. The translation in the forward direction, erasure $|\\cdot|$, simply removes coercions $|\\text{coe}_{A,A'} t| = t$ and is otherwise a congruence. It is lifted pointwise to contexts. We first show that erasure is sound, meaning that it preserves typing, and then that it is also invertible, i.e. that any well-typed $\\text{MLTT}_{\\text{sub}}$ term $t'$ elaborates to a well-typed $\\text{MLTT}_{\\text{coe}}$ term $t$ whose erasure is $t' = |t|$.\n\n### 5.3.1 Soundness of erasure\n\nErasure translates from a constrained system to a more liberal one. Establishing its soundness is relatively easy but requires setting up reduction in the right way in fig. 14 so that the lemmas stated in this section hold. The key point is that reduction rules for $\\text{coe}$ do not change the structure of the erased term, and erase to exactly zero steps of reduction.\n\n\\[\n\\text{coe}_{\\Pi x:A'.B',\\Pi x:A.B} f \\leadsto^1 \\lambda x: A. \\text{coe}_{B'[\\text{coe}_{A,A'} x]} B(f \\text{coe}_{A,A'} x)\n\\]\n\nFor instance, the above rule is inadequate, as it would $\\eta$-expand terms at function types more in $\\text{MLTT}_{\\text{coe}}$ than in $\\text{MLTT}_{\\text{sub}}$. It remains nonetheless admissible, as a conversion.\n\n**Lemma 5.3 (Erasure of reduction).** If $t \\leadsto u$, then also $|t| \\leadsto |u|$.\n\n**Proof.** By induction on the number of steps, and then on the derivation of one-step reduction. Coercion reduction in $\\text{MLTT}_{\\text{coe}}$ map to zero steps on the erased terms, while other reduction steps ($\\beta$, $\\iota$, etc.) map to their counterpart after erasure, using that erasure commutes to substitution.\n\n**Theorem 5.4 (Erasure preserves subtyping).** The following implications hold whenever the inputs of the first hypothesis are well-formed:\n\n\\[\\text{This technique is borrowed from the way cumulativity is handled in MetaCoq [Sozeau, Forster, et al. 2023].} \\]\n(1) if \\( \\Gamma \\vdash_{\\text{coe}} t \\approx_{\\text{coe}} u \\triangleleft T \\) then there exists \\( T' \\) such that \\( \\Gamma \\vdash_{\\text{coe}} T' \\approx_{\\text{coe}} T \\triangleleft \\) and \\( |\\Gamma| \\vdash_{\\text{sub}} |t| \\approx_{|\\Gamma|} |u| \\triangleright |T'| \\);\n(2) if \\( \\Gamma \\vdash_{\\text{coe}} T \\triangleleft_{h} U \\triangleleft \\), then \\( |\\Gamma| \\vdash_{\\text{sub}} |T| \\triangleleft_{h} |U| \\triangleleft \\);\n(3) and similarly for the other subtyping and conversion judgements.\n\nProof. By mutual induction, each rule being mapped to their counterpart. Rules for \\( \\Gamma \\vdash_{\\text{coe}} n \\approx_{\\text{coe}} n' \\triangleleft T \\) are simply dropped, as that judgement is replaced by \\( \\Gamma \\vdash_{\\text{sub}} n \\approx_{\\text{sub}} n' \\triangleleft S \\) in \\( \\text{MLTT}_{\\text{sub}} \\). Lemma 5.3 is employed whenever terms and types are reduced to normal forms. □\n\nTheorem 5.5 (Soundness of erasure – induction). The following implications hold, whenever the inputs of the premise are well-formed:\n\n- if \\( \\Gamma \\vdash_{\\text{coe}} t \\triangleright T, \\) then there exists \\( T' \\) such that \\( \\Gamma \\vdash_{\\text{coe}} T' \\approx_{\\text{coe}} T \\triangleleft \\) and \\( |\\Gamma| \\vdash_{\\text{sub}} |t| \\triangleright |T'| \\);\n- if \\( \\Gamma \\vdash_{\\text{coe}} t \\triangleright_{h} T, \\) then there exists \\( T' \\) such that \\( \\Gamma \\vdash_{\\text{coe}} T' \\approx_{h} T \\triangleleft \\) and \\( |\\Gamma| \\vdash_{\\text{sub}} |t| \\triangleright_{h} |T'| \\);\n- if \\( \\Gamma \\vdash_{\\text{coe}} t \\triangleleft T, \\) then there exists \\( T' \\) such that \\( \\Gamma \\vdash_{\\text{coe}} T' \\approx_{\\text{coe}} T \\triangleleft \\) and \\( |\\Gamma| \\vdash_{\\text{sub}} |t| \\triangleright |T'| \\).\n\nProof. By mutual induction. Checking needs transitivity of \\( \\triangleleft \\). Reduced inference relies on lemma 5.3 to handle reduction. Finally, each rule for inference can be mapped to its counterpart, noting that \\( \\Gamma \\vdash_{\\text{coe}} T' \\triangleleft T \\triangleleft \\) and \\( |\\Gamma| \\vdash_{\\text{sub}} |t| \\triangleright |T'| \\) together imply, by theorem 5.4, \\( |\\Gamma| \\vdash_{\\text{sub}} |t| \\triangleleft |T| \\), so that induction hypothesis on checking premises in \\( \\text{MLTT}_{\\text{coe}} \\) can be turned into checking premises in \\( \\text{MLTT}_{\\text{sub}} \\). Finally, for the introduction of \\( \\text{coe}_{A,B} t \\), subtyping between \\( A \\) and \\( B \\) is combined with the subtyping derivation obtained by induction hypothesis on \\( t \\). □\n\nIn the end, we obtain the following high-level corollary, that erasure preserves typing.\n\nCorollary 5.6 (Soundness of erasure). If \\( \\Gamma \\vdash_{\\text{coe}} t : T \\), then \\( |\\Gamma| \\vdash_{\\text{sub}} |t| \\triangleleft |T| \\).\n\n5.3.2 Elaboration. This direction is more challenging: as we add annotations, we must show that these do not hinder conversion checking. We follow the proof strategy of a similar proof of elaboration soundness in Lennon-Bertrand et al. [2022]. The core of the argument are so-called “catch-up lemmas”, which ensure that annotations never block redexes.\n\nLemma 5.7 (Catch up, function type). If \\( \\Gamma \\vdash_{\\text{coe}} f a : B \\) and \\( |f| = \\lambda x : A'. t' \\), then there exists \\( t \\) such that \\( |t| = t' \\) and \\( f a \\leadsto^* t[a] \\).\n\nLemma 5.8 (Catch up, label type). If \\( \\Gamma \\vdash_{\\text{coe}} t : L \\) and \\( |t| = l \\), then \\( t \\leadsto^* \\text{co } L \\text{ } l \\).\n\nLemma 5.9 (Catch up, positive types). If \\( T \\) is a positive type (i.e. it is Type\\(_i\\), N, List) and \\( \\Gamma \\vdash_{\\text{coe}} t : T \\) is such that \\( |t| \\) is a canonical form, then \\( t \\) reduces to a term with the same head constructor, and arguments which erase to those of \\( |t| \\).\n\nProof. The idea is always the same: because \\( t \\) erases to a canonical form, it must be that same canonical form, surrounded by coercions. Because all types in these coercions are related by subtyping to the type of \\( t \\), which is canonical as \\( t \\) is, all these coercions must reduce away. A detailed proof for the most challenging case, that of functions, is given in appendix C.2. □\n\nFrom these catch-up lemmas it follows that erasure is a backward simulation, and therefore that it preserves subtyping and finally that it is type-preserving. Proofs are all by induction, and are given in appendix C.2.\n\nLemma 5.10 (Erasure is a backward simulation). Assume that \\( \\Gamma \\vdash_{\\text{coe}} t : T \\). If \\( |t| \\leadsto^* u' \\), with \\( u' \\) a weak-head normal form, then \\( t \\leadsto^* u \\), with \\( u \\) a weak-head normal form such that \\( |u| = u' \\).\n\nLemma 5.11 (Elaboration preserves subtyping). The following implications hold whenever the inputs of the conclusions are well-formed:\n\n□\nFinally, the main theorem states that we can elaborate terms using implicit subtyping to explicit coercions, in a type-preserving way.\n\n**Theorem 5.12 (Elaboration – Induction).** The following implications hold, whenever inputs to the conclusion are well-formed:\n\n1. If \\( \\Gamma \\vdash_{\\text{sub}} t \\triangleleft T \\) and \\( |\\Gamma| = |T| \\), then \\( \\Gamma \\vdash_{\\text{coe}} t \\triangleleft T \\);\n2. If \\( \\Gamma \\vdash_{\\text{sub}} t \\triangleleft |U| \\), then \\( \\Gamma \\vdash_{\\text{coe}} t \\triangleleft U \\);\n3. If \\( \\Gamma \\vdash_{\\text{sub}} t \\triangleleft |U| \\), then \\( \\Gamma \\vdash_{\\text{coe}} t \\triangleleft u \\triangleleft T \\);\n4. and similarly for the other judgements.\n\n**Proof.** Once again, by mutual induction. Each rule is mapped to its counterpart, but for CHECK-SUB, where we need to insert a coercion in the elaborated term. This coercion is well-typed by lemma 5.11. □\n\nWe can unfold the assumption of input well-formation, to get the following high-level corollary.\n\n**Corollary 5.13 (Elaboration).** If \\( \\Gamma \\vdash_{\\text{coe}} T \\) and \\( |\\Gamma| = |T| \\), then there exists \\( t \\) such that \\( \\Gamma \\vdash_{\\text{coe}} t : T \\), and \\( |t| = t' \\).\n\nNote that, to establish this equivalence we did not need to develop any meta-theory for MLTT\\textsubscript{sub}: having the meta-theory of MLTT\\textsubscript{coe} was enough! Nonetheless, now that the equivalence between the two systems has been established, we can use it to transport meta-theoretic properties, such as normalization, from MLTT\\textsubscript{coe} to MLTT\\textsubscript{sub}.\n\n### 5.4 Coherence\n\nAn important property of elaboration is coherence, stating that the elaboration of a well-typed term should not depend on their typing derivation. In our algorithmic setting, a term has at most one typing derivation and so at most one elaboration. However, multiple well-typed terms in MLTT\\textsubscript{coe} can still erase to the same MLTT\\textsubscript{sub} term. While only one of them is the result of elaboration as defined in corollary 5.13, coherence means in our setting that all these distinct terms should behave similarly. The following is a direct consequence of lemma 5.11, and shows that the equations imposed on coe are enough to give us a very strong form of coherence: it holds up to definitional equality, rather than in a weaker, semantic way.\n\n**Theorem 5.14 (Coherence).** If \\( t, u \\) are such that \\( \\Gamma \\vdash_{\\text{coe}} t : T \\) and \\( \\Gamma \\vdash_{\\text{coe}} u : T \\), and moreover \\( |t| = |u| \\) (i.e. \\( t \\) and \\( u \\) are both “elaborations” of the same MLTT\\textsubscript{sub} term), then \\( \\Gamma \\vdash_{\\text{coe}} t \\equiv u \\triangleleft T \\).\n\n**Proof.** By reflexivity (obtained through the equivalence with the declarative system), \\( \\Gamma \\vdash_{\\text{coe}} t \\equiv t \\triangleleft T \\). Using theorem 5.5 (soundness of erasure), we get \\( |\\Gamma| \\vdash_{\\text{sub}} |t| \\equiv |t| \\triangleleft |T| \\), and so also \\( |\\Gamma| \\vdash_{\\text{sub}} |t| \\equiv |u| \\triangleleft |T| \\). But then by lemma 5.11 (elaboration preserving conversion), we can come back, and obtain \\( \\Gamma \\vdash_{\\text{coe}} t \\equiv u \\triangleleft T \\). □\n\n### 5.5 From Coercions To Functorial Maps\n\nMLTT\\textsubscript{coe} terms contain enough information to capture entirely the subtyping derivations. Figure 16 exploits this information to define a relation \\( \\llbracket t \\rrbracket \\equiv t' \\) relating a MLTT\\textsubscript{coe} term \\( t \\) and a MLTT\\textsubscript{map} term \\( t' \\) that makes explicit the functorial nature of coercions. Most cases of the translation are left to appendix C.3, keeping only the key cases translating of coe on lists. This relation is a partial function containing well-typed terms in its domain. The definition of \\( \\llbracket t \\rrbracket \\equiv t' \\) employs\nan auxiliary relation $[A \\rightsquigarrow B] \\approx x$ to translate coercions from $A$ to $B$, where $x$ is either the special value $\\star$ or a MLTT\\textsubscript{map} term $f$. The value $\\star$ arises in the case of an identity coercion that should be erased by the translation.\n\nSince both MLTT\\textsubscript{coe} and MLTT\\textsubscript{map} share similar conversion rules, we conjecture that the translation not only preserves typing and conversion but also reflects it.\n\n**Conjecture 5.15 (Embedding).** $[-]$ embeds MLTT\\textsubscript{coe} into MLTT\\textsubscript{map}.\n\nThis embedding can be combined with the algorithm deciding type-checking for MLTT\\textsubscript{map}, producing an alternative decision procedure for MLTT\\textsubscript{coe}. In practice, this means that a proof assistant could reuse parts of an implementation of MLTT\\textsubscript{map} in its kernel to provide support for structural coercive subtyping.\n\n6 RELATED AND FUTURE WORK\n\nLogical relations, new equations for neutral terms. Allais et al. [2013] propose to add a variety of fusion laws for lists, including our functor laws, but only in a simply-typed setting, although they sketch how their work could be extended to handle dependency. While we depart from their normalization by evaluation approach, we retain some traces of it, typically in the presence of three classes of normal forms (see figs. 10 and 14) instead of the usual normal/neutral forms.\n\nFormalizing logical relations for MLTT is a difficult exercise, pioneered by Abel et al. [2017] in Agda using inductive-recursive definitions, and Wieczorek and Biernacki [2018] in Coq using impredicativity. We build upon and extend a Coq reimplementation of the former. In particular, we provide an effective algorithm to decide type-checking directly on syntactic terms, getting closer to an actual implementation.\n\nCast and coercion operators. Pujet and Tabareau [2022, 2023] extend Abel et al. [2017] to establish the metatheory of observational type theory [Altenkirch, McBride, et al. 2007]. Their work features a cast operator behaving similarly to coe, guarded by an internal proof of equality. Their cast does not satisfy a definitional transitivity law, and we give some evidence in appendix A showing that an extension in that direction would be difficult. Another primitive with a rather similar operational behaviour also appears in cast calculi for gradual typing [Siek et al. 2015], and indeed our proof that elaboration is type preserving in section 5.3 is inspired by a similar one for GCIC, which combines gradual and dependent types [Lennon-Bertrand et al. 2022].\n\nFunctorial maps for inductive type schemes. Z. Luo and Adams [2008] describe the construction of map for a class of strictly positive operators on paper, but do not implement it. Deriving map-like\nDefinitional Functoriality for Dependent (Sub)Types\n\ncoloration is a typical example of metaprogramming frameworks for proof assistants, e.g. Coq-Elpi [Tassi 2018; Dunchev et al. 2015] in Coq, and the generics Agda library [Escot and Cockx 2022] derives a fold operation, from which map can be easily obtained. In a simply typed setting, Barral and Soloviev [2006] employ rewriting techniques, in particular rewriting postponement, to show that an oriented variant of the functor laws are confluent and normalizing. These techniques rely on normalization, and could not be easily adapted to the dependent setting, however the idea of postponing the reduction step for identity appear in our logical relation as well. In a short abstract, McBride and Nordvall Forsberg [2021] investigate a notion of functorial adapters that generalizes and unifies both the CHECK rule from bidirectional typing and the COE rule from MLTT_{coe}.\n\nSubtyping, dependent types and algorithmic derivations. Aspinall and Compagnoni [2001] investigate the relationship between subtyping and dependent types using algorithmic derivations to control the subtyping derivations for a variant of λP, a logically rather weak type system.\n\nCoherence of coercions in presence of structural subtyping is a challenging problem. To address the issue, Z. Luo and Y. Luo [2005] introduce a notion of weak transitivity, weakening the coherence of the transitivity up to propositional equality. This solution does not interact well with dependency, forcing them to restrict structural subtyping to a class of non-dependent inductives, e.g. excluding Σ. Z. Luo and Adams [2008] show that the transitivity of coercions is admissible in presence of definitional compositions – called χ-rules there – for inductive schemata. They rely on and conjecture that injectivity of type constructors hold in presence of χ-rules, a result that we prove and formalize for List. Both of these papers employ a strict order for subtyping and do not consider the functor law for the identity, nor tackle decidability of type-checking.\n\nLungu and Z. Luo [2018] study an elaboration of a subsumptive presentation into coercive one in presence of a coherent signature of subtyping relations between base types. Assuming normalization, they show that subtyping extends to Π types, setting aside other parametrized types.\n\nIntegration with other forms of subtyping. As we mentioned in section 5, our design of base subtyping was guided by simplicity. Our work on structural subtyping should integrate mostly seamlessly with other, more ambitious forms of subtyping. Coercions between dependent records form the foundation of hierarchical organizations of mathematical structures [Cohen et al. 2020; Affeldt et al. 2020; Wieser 2023] and should be a simple extension of our framework. Refinement subtyping are heavily used in F∗ but also in Russel [Sozeau 2007] to specify the behaviour of programs. Relativizing any result of decidability of type-checking to that of the chosen fragment of refinements, an implementation of refinement subtyping using definitionally irrelevant 13 propositions [Gilbert et al. 2019] to preserve coherence should be within reach.\n\nOur techniques for structural subtyping should also apply well in the context of algebraic approaches to cumulativity between universes [Sterling 2019; Kovác 2022]. Cumulativity goes beyond mere subtyping, as it also involves definitional isomorphisms between two copies of the same type at different universe levels. Our definitional functor laws already allow these to interact well with map operations, but it would be interesting to investigate whether extra definitional equations are needed—and can be realized—to make structural cumulativity work seamlessly.\n\nREFERENCES\n\n\n13With proof-relevant propositions, two different proofs of \\( p \\Rightarrow q \\) would induce different coercions between \\( \\{ x \\mid p \\} \\) and \\( \\{ x \\mid q \\} \\), breaking coherence.\nDefinitional Functionality for Dependent (Sub)Types\n\n\n27\nA INTERNAL SUBTYPING AND UNDECIDABILITY OF CONVERSION\n\nThe goal of the coercive approach is to reflect all the potential ambiguities present in a subtyping derivation. As such, wouldn’t it be easier to just internalize the notion of subtype and let type theory deal with it? The following observation shows that there exists a big obstruction to any decidability result for conversion as long as we want to stay equivalent to the subsumptive presentation of subtyping.\n\n**Observation A.1 (No-go of internal subtyping).** Suppose that \\( \\mathcal{T} \\) is a type theory with a family \\( \\text{sub} \\ A \\ B \\) for any two types \\( A \\) and \\( B \\), equipped with reflexivity witnesses \\( \\text{refl}_A : \\text{sub} \\ A \\ A \\) and transitivity witnesses \\( \\text{trans} \\ w \\ w' : \\text{sub} \\ A \\ C \\) for \\( w : \\text{sub} \\ A \\ B \\) and \\( w' : \\text{sub} \\ B \\ C \\), as well as a coercion function \\( \\text{coe}_{A,B} : \\text{sub} \\ A \\ B \\to A \\to B \\), such that \\( \\text{coe}_{A,A} \\text{refl}_A \\cong \\text{id}_A \\) and \\( \\text{coe}_{B,C} \\circ \\text{coe}_{A,B} \\circ \\text{trans} \\ w \\ w' \\cong \\text{coe}_{A,C} \\). Then \\( \\mathcal{T} \\) embeds definitional models of the untyped \\( \\lambda \\)-calculus, and in particular divergent terms.\n\nIndeed, whenever a context provides inhabitants of both \\( \\text{sub} \\ A \\ B \\) and \\( \\text{sub} \\ B \\ A \\), \\( \\text{coe}_{A,B} \\) and \\( \\text{coe}_{B,A} \\) provide a definitional isomorphism \\( A \\cong B \\). In particular any context inhabiting \\( \\text{sub} \\ A \\ A \\to A \\) and \\( \\text{sub} \\ A \\to A \\ A \\), for instance an inconsistent one, provides a definitional retraction of \\( A \\to A \\) onto \\( A \\), hence a non-trivial model of the untyped \\( \\lambda \\)-calculus with a divergent element \\( \\Omega_A : A \\). This observation motivates our external approach to subtyping with a specific judgement of subtyping that cannot be abstracted upon.\n\nB COMPLETE TYPING RULES\n\n**B.1 Declarative MLTT**\n\n\\( \\Gamma \\vdash \\) Context \\( \\Gamma \\) is well-formed\n\n\\[\n\\begin{array}{c}\n\\Gamma \\vdash \\cdot \\quad \\Gamma \\vdash A : \\text{Type}_{ij} \\\\\n\\Gamma \\vdash \\cdot \\\\\n\\end{array}\n\\]\n\n\\( \\Gamma \\vdash \\sigma : \\Delta \\) \\( \\sigma \\) is a well-typed substitution between contexts \\( \\Gamma \\) and \\( \\Delta \\)\n\n\\[\n\\begin{array}{c}\n\\Gamma \\vdash \\cdot : \\cdot \\quad \\Gamma \\vdash \\sigma : \\Delta \\quad \\Gamma \\vdash t : A[\\sigma] \\\\\n\\Gamma \\vdash (\\sigma, t) : \\Delta, x : A \\\\\n\\end{array}\n\\]\n\n\\( \\Gamma \\vdash T \\) Type \\( T \\) is well-formed in context \\( \\Gamma \\)\n\n\\[\n\\begin{array}{c}\n\\text{El} \\quad \\Gamma \\vdash A : \\text{Type}_{ij} \\\\\n\\Gamma \\vdash A \\\\\n\\text{FunTy} \\quad \\Gamma \\vdash A \\\\\n\\Gamma \\vdash \\Pi x : A. B \\\\\n\\text{ListTy} \\quad \\Gamma \\vdash A \\\\\n\\Gamma \\vdash \\text{List} A \\\\\n\\text{SigTy} \\quad \\Gamma \\vdash A \\\\\n\\Gamma \\vdash \\Sigma x : A. B \\\\\n\\text{TreeTy} \\quad \\Gamma \\vdash A \\\\\n\\Gamma \\vdash W x : A. B \\\\\n\\text{IdTy} \\quad \\Gamma \\vdash A \\\\\n\\Gamma \\vdash a : A \\\\\n\\Gamma \\vdash a' : A \\\\\n\\Gamma \\vdash \\text{Id}_A a a'\n\\end{array}\n\\]\n\n29\n$$\\Gamma \\vdash t : T$$ Term $t$ has type $T$ under context $\\Gamma$\n\n<table>\n<thead>\n<tr>\n<th>Rule</th>\n<th>Statement</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Conv</td>\n<td>$\\Gamma \\vdash t : A \\quad \\Gamma \\vdash A \\cong B$</td>\n</tr>\n<tr>\n<td>FunUni</td>\n<td>$\\Gamma \\vdash A : \\text{Type}_i \\quad \\Gamma, x : A \\vdash B : \\text{Type}_i$</td>\n</tr>\n<tr>\n<td>ListUni</td>\n<td>$\\Gamma \\vdash A : \\text{Type}_i \\quad \\Gamma \\vdash \\text{List} A : \\text{Type}_i$</td>\n</tr>\n<tr>\n<td>ListInd</td>\n<td>$\\Gamma, x : \\text{List} A \\vdash P$</td>\n</tr>\n<tr>\n<td>EmptyUni</td>\n<td>$\\Gamma \\vdash 0 : \\text{Type}_0$</td>\n</tr>\n<tr>\n<td>EmptyInd</td>\n<td>$\\Gamma \\vdash s : 0 \\quad \\Gamma \\vdash P$</td>\n</tr>\n<tr>\n<td>UnitUni</td>\n<td>$\\Gamma \\vdash s : 1 \\quad \\Gamma, z : 1 \\vdash P \\quad \\Gamma \\vdash b_0 : P[()]$</td>\n</tr>\n<tr>\n<td>UnitInd</td>\n<td>$\\Gamma \\vdash s : 1 \\quad \\Gamma, z : 1 \\vdash P \\quad \\Gamma \\vdash b_0 : P[()]$</td>\n</tr>\n<tr>\n<td>SigUni</td>\n<td>$\\Gamma \\vdash A : \\text{Type}_i \\quad \\Gamma, x : A \\vdash B : \\text{Type}_i$</td>\n</tr>\n<tr>\n<td>Proj1</td>\n<td>$\\Gamma \\vdash p : \\Sigma x : A. B \\quad \\Gamma \\vdash \\pi_1 p : A$</td>\n</tr>\n<tr>\n<td>Proj2</td>\n<td>$\\Gamma \\vdash p : \\Sigma x : A. B \\quad \\Gamma \\vdash \\pi_2 p : B[u]$</td>\n</tr>\n<tr>\n<td>TreeUni</td>\n<td>$\\Gamma \\vdash A : \\text{Type}_i \\quad \\Gamma, x : A \\vdash B : \\text{Type}_i$</td>\n</tr>\n<tr>\n<td>SUP</td>\n<td>$\\Gamma \\vdash a : A \\quad \\Gamma \\vdash k : B[a] \\to W x : A. B$</td>\n</tr>\n<tr>\n<td>TreeInd</td>\n<td>$\\Gamma \\vdash A \\quad \\Gamma, x : A \\vdash B \\quad \\Gamma \\vdash s : W x : A. B \\quad \\Gamma, z : W x : A. B \\vdash P \\quad \\Gamma, x : A. y : B[x] \\to W x : A. B, h : \\Pi z : B[x]. P[y z] \\vdash b : P[\\sup_{x,B} x y]$</td>\n</tr>\n<tr>\n<td>BoolUni</td>\n<td>$\\Gamma \\vdash B : \\text{Type}_0$</td>\n</tr>\n<tr>\n<td>BoolInd</td>\n<td>$\\Gamma \\vdash s : B \\quad \\Gamma, z : B \\vdash P \\quad \\Gamma \\vdash b_{\\text{true}} : P[\\text{true}] \\quad \\Gamma \\vdash b_{\\text{false}} : P[\\text{false}]$</td>\n</tr>\n</tbody>\n</table>\nDefinitional Functoriality for Dependent (Sub)Types\n\n\\[\n\\text{IdTy} \\quad \\frac{\\Gamma \\vdash A}{\\Gamma \\vdash \\text{Id}_A \\ a \\ a'}\n\\]\n\n\\[\n\\text{ReflTy} \\quad \\frac{\\Gamma \\vdash a : A}{\\Gamma \\vdash \\text{refl}_{A,a} : \\text{Id}_A \\ a \\ a}\n\\]\n\n\\[\n\\text{IdInd} \\quad \\frac{\\Gamma \\vdash s : \\text{Id}_A \\ a \\ a' \\quad \\Gamma, x : A, y, z : \\text{Id}_A \\ x \\ y \\vdash P \\quad \\Gamma, x : A \\vdash b : P [\\text{id}, x, x, \\text{refl}_{A,x}]}{\\Gamma \\vdash \\text{id}_{\\text{Id}_A} (s ; x . y . z . P ; x . b) : P [\\text{id}, a, a', s]}\n\\]\n\n\\[\n\\text{Ref} \\quad \\frac{\\Gamma \\vdash T \\cong T'}{\\text{Terms } t \\text{ and } t' \\text{ are convertible at type } T \\text{ in context } \\Gamma}\n\\]\n\n\\[\n\\text{TransTy} \\quad \\frac{\\Gamma \\vdash A \\cong B}{\\Gamma \\vdash A \\cong C \\quad \\Gamma \\vdash C \\cong B} \\quad \\frac{\\Gamma \\vdash B \\cong C}{\\Gamma \\vdash A \\cong B}\n\\]\n\n\\[\n\\text{ElC} \\quad \\frac{\\Gamma \\vdash A \\cong A' : \\text{Type}}{\\Gamma \\vdash A \\cong A'}\n\\]\n\n\\[\n\\text{FunTyC} \\quad \\frac{\\Gamma \\vdash A \\cong A' \\quad \\Gamma, x : A \\vdash B \\cong B'}{\\Gamma \\vdash \\Pi x : A . B \\cong \\Pi x : A' . B'}\n\\]\n\n\\[\n\\text{ListTyC} \\quad \\frac{\\Gamma \\vdash A \\cong A'}{\\Gamma \\vdash \\text{List } A \\cong \\text{List } A'}\n\\]\n\n\\[\n\\text{SigTyC} \\quad \\frac{\\Gamma \\vdash A \\cong A' \\quad \\Gamma, x : A \\vdash B \\cong B'}{\\Gamma \\vdash \\Sigma x : A . B \\cong \\Sigma x : A' . B'}\n\\]\n\n\\[\n\\text{TreeTyC} \\quad \\frac{\\Gamma \\vdash A \\cong A' \\quad \\Gamma, x : A \\vdash B \\cong B'}{\\Gamma \\vdash \\text{Tree } x : A . B \\cong \\text{Tree } x : A' . B'}\n\\]\n\n\\[\n\\text{IdTy} \\quad \\frac{\\Gamma \\vdash t \\cong t' : A}{\\Gamma \\vdash \\text{Id}_A \\ t u \\cong \\text{Id}_A \\ t' u'}\n\\]\n\n\\[\n\\text{Refl} \\quad \\frac{\\Gamma \\vdash A \\quad \\Gamma, x : A \\vdash t : B \\quad \\Gamma \\vdash u : A}{\\Gamma \\vdash t \\cong u : A}\n\\]\n\n\\[\n\\text{Trans} \\quad \\frac{\\Gamma \\vdash t \\cong u : A \\quad \\Gamma \\vdash u \\cong v : A}{\\Gamma \\vdash t \\cong v : A}\n\\]\n\n\\[\n\\text{Conv} \\quad \\frac{\\Gamma \\vdash A \\cong B}{\\Gamma \\vdash t \\cong t' : B}\n\\]\n\n\\[\n\\beta\\text{Fun} \\quad \\frac{\\Gamma \\vdash \\lambda x : A . t \\quad \\Gamma \\vdash u : A}{\\Gamma \\vdash (\\lambda x : A . t) \\ u \\cong t[u] : B[u]}\n\\]\n\n\\[\n\\eta\\text{Fun} \\quad \\frac{\\Gamma, x : A \\vdash f x \\cong g x : B}{\\Gamma \\vdash f \\cong g : \\Pi x : A . B}\n\\]\n\n\\[\n\\beta\\text{Sig} \\quad \\frac{\\Gamma \\vdash A \\quad \\Gamma, x : A \\vdash t : B \\quad \\Gamma \\vdash u : B[t]}{\\Gamma \\vdash \\pi_1 (t, u)_{x,B} \\cong t : A}\n\\]\n\n\\[\n\\eta\\text{Sig} \\quad \\frac{\\Gamma \\vdash A \\quad \\Gamma, x : A \\vdash p : \\Sigma x : A . B}{\\Gamma \\vdash p \\cong (\\pi_1 p, \\pi_2 p)_{x,B} : \\Sigma x : A . B}\n\\]\n\n\\[\n\\text{ηNil} \\quad \\frac{\\Gamma \\vdash b : P[\\varepsilon_A]}{\\Gamma \\vdash \\text{id}_{\\text{List } A} (\\varepsilon_A ; z . P ; b) \\cong b : P[\\varepsilon_A]}\n\\]\nB.2 Algorithmic MLTT\n\n<table>\n<thead>\n<tr>\n<th>Rule</th>\n<th>Structure</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>t ∼^1 t′</strong></td>\n<td>Term t weak-head reduces in one step to term t′</td>\n</tr>\n<tr>\n<td><strong>βFun</strong></td>\n<td>(λx:A.t) u ∼^1 t[u]</td>\n</tr>\n<tr>\n<td><strong>βSig1</strong></td>\n<td>π_1(t, u)_{x:B} ∼^1 t</td>\n</tr>\n<tr>\n<td><strong>βSig2</strong></td>\n<td>π_2(t, u)_{x:B} ∼^1 u</td>\n</tr>\n<tr>\n<td><strong>ιRedNil</strong></td>\n<td>ind_{List A}(ε_A; x.P; b_e, x.y.z.b_z) ∼^1 b_e</td>\n</tr>\n<tr>\n<td><strong>ιRedCons</strong></td>\n<td>ind_{List A}(a z_A l; z.P; b_e, x.y.z.b_z) ∼^1 b_e[id, a, l, ind_{List A}(l; z.P; b_e, x.y.z.b_z)]</td>\n</tr>\n<tr>\n<td><strong>ιTree</strong></td>\n<td>ind_{W x:A.B}(sup_{x:B} a k; z.P; x.y.z.b) ∼^1 b[id, a, k, (λz:B[x]. ind_{W x:A.B}(k z; z.P; x.y.z.b))]</td>\n</tr>\n<tr>\n<td><strong>ιFalse</strong></td>\n<td>ind_B(tt; z.P; b_{tt}, b_{ff}) ∼^1 b_{tt}</td>\n</tr>\n<tr>\n<td><strong>ιRedSig</strong></td>\n<td>ind_{Id A}(refl_A, x.y.z.P; x.b) ∼^1 b[a]</td>\n</tr>\n<tr>\n<td><strong>RedApp</strong></td>\n<td>t ∼^1 t′ t u ∼^1 t′ u</td>\n</tr>\n<tr>\n<td><strong>RedSig1</strong></td>\n<td>π_1 t ∼^1 π_1 t′</td>\n</tr>\n<tr>\n<td><strong>RedSig2</strong></td>\n<td>π_2 t ∼^1 π_2 t′</td>\n</tr>\n<tr>\n<td><strong>RedInd</strong></td>\n<td>ind_T(t; P; b) ∼^1 ind_T(t′; P; b)</td>\n</tr>\n</tbody>\n</table>\nDefinitional Functoriality for Dependent (Sub)Types\n\n\\[ t \\leadsto^* t' \\] Term \\( t \\) weak-head reduces in multiple steps to term \\( t' \\)\n\n\\[\n\\text{RedBase} \\quad t \\leadsto^* t \\\\\n\\text{RedStep} \\quad t \\leadsto^* t' \\quad t' \\leadsto^* t''\n\\]\n\n\\[ \\text{nf} \\ f \\defeq n \\mid \\text{Type}_i \\mid \\Pi x: t. t \\mid \\lambda x: t. t \\mid \\text{List} t \\mid \\varepsilon_t \\mid t :: t \\mid \\text{sup}_t t \\mid 0 \\mid 1 \\mid () \\] weak-head normal forms\n\n\\[ \\text{ne} \\ n \\defeq x \\mid n t \\mid \\text{ind}_T(t; n; t) \\mid \\pi_1 n \\mid \\pi_2 n \\] weak-head neutrals\n\n\\[ \\Gamma \\vdash T \\triangleleft \\] \\( T \\) is a type in \\( \\Gamma \\)\n\n\\[\n\\begin{array}{c}\n\\text{FunTy} \\quad \\Gamma \\vdash A \\triangleleft \\quad \\Gamma, x: A \\vdash B \\triangleleft \\\\\n\\text{ListTy} \\quad \\Gamma \\vdash A \\triangleleft \\\\\n\\text{SigTy} \\quad \\Gamma \\vdash A \\triangleleft \\\\\n\\text{TreeTy} \\quad \\Gamma \\vdash W x: A. B \\triangleleft \\\\\n\\text{EMPTYTy} \\quad \\Gamma \\vdash 0 \\triangleleft\n\\end{array}\n\\]\n\n\\[ \\Gamma \\vdash A \\triangleright_h \\text{Type}_i \\] \\( A \\) is not a canonical form\n\n\\[ \\Gamma \\vdash A \\triangleright \\] Term \\( t \\) infers type \\( T \\) in context \\( \\Gamma \\)\n\n\\[\n\\begin{array}{c}\n\\text{SORT} \\quad \\Gamma \\vdash \\text{Type}_i \\triangleright \\text{Type}_{i+1} \\\\\n\\text{VAR} \\quad (x: T) \\in \\Gamma \\quad \\Gamma \\vdash x \\triangleright T \\\\\n\\text{FUN} \\quad \\Gamma, x: A \\vdash B \\triangleright_h \\text{Type}_i \\\\\n\\text{ABS} \\quad \\Gamma \\vdash A \\triangleright \\quad \\Gamma, x: A \\vdash t \\triangleright B \\\\\n\\text{APP} \\quad \\Gamma \\vdash t \\triangleright_h \\Pi x: A. B \\\\\n\\text{NIL} \\quad \\Gamma \\vdash \\varepsilon_A \\triangleright \\text{List} A \\\\\n\\text{CONS} \\quad \\Gamma \\vdash a \\triangleright A \\\\\n\\text{CONSLIST} \\quad \\Gamma \\vdash t \\triangleright \\Pi x: A. B \\\\\n\\text{SORT} \\quad \\Gamma \\vdash P \\triangleright \\text{List} A \\\\\n\\text{NIL'} \\quad \\Gamma \\vdash \\varepsilon_A \\triangleright \\text{List} A \\\\\n\\text{CONS'} \\quad \\Gamma \\vdash a \\triangleright A \\\\\n\\end{array}\n\\]\n\n\\[ \\Gamma \\vdash 0 \\triangleright \\text{Type}_0 \\]\n\n\\[ \\Gamma \\vdash \\text{ind}_0 (s; P) \\triangleright P \\]\nDefinitional Functoriality for Dependent (Sub)Types\n\n\\[ \\Gamma \\vdash T \\equiv T' \\ \\text{\\textless} \\ \\text{Types } T \\text{ and } T' \\text{ are convertible} \\]\n\n\\[ \\begin{array}{c}\nT \\vdash^* U & T' \\vdash^* U' & \\Gamma \\vdash U \\equiv_h U' \\ \\text{\\textless} \\\\\n\\text{TyRed} & \\Gamma \\vdash T \\equiv T' \\ \\text{\\textless} \\\\\n\\end{array} \\]\n\n\\[ \\Gamma \\vdash t \\equiv t' \\ \\text{\\textless} A \\ \\text{Terms } t \\text{ and } t' \\text{ are convertible at type } T \\]\n\n\\[ \\begin{array}{c}\nt \\vdash^* u & t' \\vdash^* u' & T \\vdash^* U & \\Gamma \\vdash u \\equiv_h u' \\ \\text{\\textless} U \\\\\n\\text{TmRed} & \\Gamma \\vdash t \\equiv t' \\ \\text{\\textless} T \\\\\n\\end{array} \\]\n\n\\[ \\Gamma \\vdash T \\equiv_h T' \\ \\text{\\textless} \\ \\text{Reduced types } T \\text{ and } T' \\text{ are convertible} \\]\n\n\\[ \\begin{array}{c}\nC\\text{UniTy} \\quad \\Gamma \\vdash \\text{Type}_i \\equiv_h \\text{Type}_j \\ \\text{\\textless} Type_i \\vdash \\text{\\textless} \\\\\nC\\text{ListTy} \\quad \\Gamma \\vdash A \\equiv A' \\ \\text{\\textless} \\\\\n\\quad \\Gamma \\vdash \\text{List} A \\equiv_h \\text{List} A' \\ \\text{\\textless} \\\\\n\\quad \\Gamma \\vdash A \\equiv A' \\ \\text{\\textless} \\\\\nCT\\text{reeTy} \\quad \\Gamma \\vdash W x : A.B \\equiv_h W x : A'.B' \\ \\text{\\textless} \\\\\nC\\text{Uni} \\quad \\Gamma \\vdash T \\equiv_h T' \\ \\text{\\textless} \\\\\n\\end{array} \\]\n\n\\[ \\Gamma \\vdash t \\equiv_h t' \\ \\text{\\textless} A \\ \\text{Reduced terms } t \\text{ and } t' \\text{ are convertible at type } A \\]\n\n\\[ \\begin{array}{c}\nC\\text{Uni} \\quad \\Gamma \\vdash \\text{Type}_i \\equiv_h \\text{Type}_j \\ \\text{\\textless} Type_i \\vdash \\text{\\textless} \\\\\nC\\text{Fun} \\quad \\Gamma \\vdash x: A \\vdash f x \\equiv f' x : B \\ \\text{\\textless} \\\\\n\\quad \\Gamma \\vdash f \\equiv_h f' \\ \\text{\\textless} \\Pi x: A.B \\ \\text{\\textless} \\\\\nC\\text{FunEta} \\quad \\Gamma \\vdash \\pi_1 p \\equiv \\pi_1 p' \\ \\text{\\textless} A \\ \\text{\\textless} \\\\\n\\quad \\Gamma \\vdash \\pi_2 p \\equiv \\pi_2 p' \\ \\text{\\textless} B[\\pi_1 p] \\ \\text{\\textless} \\\\\nCS\\text{ig} \\quad \\Gamma \\vdash p \\equiv_h p' \\ \\text{\\textless} \\Sigma x: A.B \\ \\text{\\textless} \\\\\nC\\text{Nil} \\quad \\Gamma \\vdash \\varepsilon_A \\equiv_h \\varepsilon_A' \\ \\text{\\textless} \\text{List} A' \\ \\text{\\textless} \\\\\nC\\text{ReflUni} \\quad \\Gamma \\vdash T \\equiv_h T \\vdash \\text{\\textless} Type_0 \\ \\text{\\textless} \\\\\nC\\text{Unik} \\quad \\Gamma \\vdash () \\equiv_h () \\ \\text{\\textless} 1 \\ \\text{\\textless} \\\\\nC\\text{ReflBool} \\quad \\Gamma \\vdash t \\equiv_h t \\ \\text{\\textless} B \\ \\text{\\textless} \\\\\n\\end{array} \\]\nCSup \\[\\Gamma \\vdash a \\equiv a' \\triangleleft A'' \\quad \\Gamma \\vdash k \\equiv k' \\triangleleft B''[a] \\rightarrow \\mathcal{W} x: A''.B''\\]\n\\[\\Gamma \\vdash \\sup_{x:B} a \\ k \\equiv_h \\sup_{x:B} a' \\ k' \\triangleleft \\mathcal{W} x: A''.B''\\]\n\nReflRefl \\[\\Gamma \\vdash \\text{refl}_{A,a} \\equiv \\text{refl}_{A',a'} \\triangleleft \\text{Id}_{A''} \\triangleright u\\]\n\nNeuNeu \\[\\Gamma \\vdash n \\equiv_n' \\triangleright S \\quad n \\equiv_M\\]\n\nNeuPos \\[\\Gamma \\vdash n \\approx_{n'} \\triangleright S \\quad T \\text{ is Type, } 0, 1, \\mathbf{B}, \\text{List } A, \\mathcal{W} x: A.B \\text{ or } \\text{Id}_A \\ a a' \\]\n\\[\\Gamma \\vdash n \\equiv_h n' \\triangleleft T\\]\n\n\\[\\Gamma \\vdash t \\approx_{h} t' \\triangleright T\\] Neutrals \\( t \\) and \\( t' \\) are comparable, inferring the reduced type \\( T \\)\n\n\\[\\Gamma \\vdash n \\equiv_{n'} \\triangleright T \\quad T \\sim^* S\\]\n\n\\[\\Gamma \\vdash n \\equiv_{h} n' \\triangleright S\\]\n\n\\[\\Gamma \\vdash t \\approx_{t'} \\triangleright T\\] Neutrals \\( t \\) and \\( t' \\) are comparable, inferring the type \\( T \\)\n\n\\[\\Gamma \\vdash n \\equiv_{n'} \\triangleright T \\quad T \\sim^* S\\]\n\n\\[\\Gamma \\vdash n \\equiv_{h} n' \\triangleright S\\]\n### B.3 Declarative MLLT\\textsubscript{map}\n\nExtend the rules of appendix B.1.\n\nFor each type former \\( F (\\Pi, X, \\text{List}, W, \\text{Id}) \\)\n\n<table>\n<thead>\n<tr>\n<th>Rule</th>\n<th>Context</th>\n<th>Statement</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>MAP</strong></td>\n<td>( \\Gamma \\vdash \\text{map} X, Y : \\text{dom}(F) ) ( \\Gamma \\vdash f : \\text{Hom}_F(X, Y) ) ( \\Gamma \\vdash t : F X )</td>\n<td>( \\Gamma \\vdash \\text{map}_F f t : F Y )</td>\n</tr>\n<tr>\n<td><strong>MAP\\textsubscript{Id}</strong></td>\n<td>( \\Gamma \\vdash X : \\text{dom}(F) ) ( \\Gamma \\vdash t : F X )</td>\n<td>( \\Gamma \\vdash \\text{map}_F \\text{id}_F X t \\cong t : F X )</td>\n</tr>\n<tr>\n<td><strong>MAP\\textsubscript{COMP}</strong></td>\n<td>( \\Gamma \\vdash X, Y, Z : \\text{dom}(F) ) ( \\Gamma \\vdash f : \\text{Hom}_F(Y, Z) ) ( \\Gamma \\vdash t : F X )</td>\n<td>( \\Gamma \\vdash \\text{map}_F f t \\cong \\text{map}_F f \\circ t : F Z )</td>\n</tr>\n<tr>\n<td><strong>MAP\\textsubscript{CONG}</strong></td>\n<td>( \\Gamma \\vdash X : \\text{dom}(F) ) ( \\Gamma \\vdash f \\cong f' : \\text{Hom}_F(X, Y) ) ( \\Gamma \\vdash t : t' : F X )</td>\n<td>( \\Gamma \\vdash \\text{map}_F f t \\cong \\text{map}_F f' t' : F Y )</td>\n</tr>\n<tr>\n<td><strong>MAP\\textsubscript{FUN}</strong></td>\n<td>( \\Gamma \\vdash (f, g) : \\text{Hom}_\\Pi((A, B), (A', B')) ) ( \\Gamma \\vdash h : \\Pi x : A. B ) ( \\Gamma \\vdash a : A' )</td>\n<td>( \\Gamma \\vdash \\text{map}_\\Pi (f, g) h a \\cong g(h(f a)) : B' )</td>\n</tr>\n<tr>\n<td><strong>MAP\\textsubscript{SIG\\textsubscript{1}}</strong></td>\n<td>( \\Gamma \\vdash (f, g) : \\text{Hom}_\\Sigma((A, B), (A', B')) ) ( \\Gamma \\vdash p : \\Sigma x : A. B )</td>\n<td>( \\Gamma \\vdash \\pi_1 (\\text{map}_\\Sigma (f, g) p) \\cong f \\pi_1 p : A' )</td>\n</tr>\n<tr>\n<td><strong>MAP\\textsubscript{SIG\\textsubscript{2}}</strong></td>\n<td>( \\Gamma \\vdash (f, g) : \\text{Hom}_\\Sigma((A, B), (A', B')) ) ( \\Gamma \\vdash p : \\Sigma x : A. B )</td>\n<td>( \\Gamma \\vdash \\pi_2 (\\text{map}_\\Sigma (f, g) p) \\cong g \\pi_2 p : B'[f \\pi_1 p] )</td>\n</tr>\n<tr>\n<td><strong>MAP\\textsubscript{LIST\\textsubscript{NIL}}</strong></td>\n<td></td>\n<td>( \\Gamma \\vdash \\text{map}<em>\\text{List} f : \\text{Hom}</em>\\text{List}(A, A') )</td>\n</tr>\n<tr>\n<td></td>\n<td>( \\Gamma \\vdash \\text{map}<em>\\text{List} \\varepsilon_A \\cong \\varepsilon</em>{A'} : \\text{List} A' )</td>\n<td></td>\n</tr>\n<tr>\n<td><strong>MAP\\textsubscript{LIST\\textsubscript{CONS}}</strong></td>\n<td>( \\Gamma \\vdash f : \\text{Hom}_\\text{List}(A, A') ) ( \\Gamma \\vdash h : A ) ( \\Gamma \\vdash t : \\text{List} A )</td>\n<td>( \\Gamma \\vdash \\text{map}<em>\\text{List} f (hd \\circ_A t l) \\cong (fh d \\circ_A (\\text{map}</em>\\text{List} f t l)) : \\text{List} A' )</td>\n</tr>\n<tr>\n<td><strong>MAP\\textsubscript{W}</strong></td>\n<td>( \\Gamma \\vdash (f, g) : \\text{Hom}_W((A, B), (A', B')) ) ( \\Gamma \\vdash a : A ) ( \\Gamma \\vdash k : B a \\rightarrow W x : A. B )</td>\n<td>( \\Gamma \\vdash \\text{map}<em>W (f, g) (\\sup</em>{x, B} a k) \\cong \\sup_{x, B'} (f a)(\\lambda x : B'[f a]. \\text{map}_W (f, g) (k (gx))) : W x : A'. B' )</td>\n</tr>\n<tr>\n<td><strong>MAP\\textsubscript{ID}</strong></td>\n<td>( \\Gamma \\vdash f : \\text{Hom}_\\text{Id}(A, A') ) ( \\Gamma \\vdash a : A )</td>\n<td>( \\Gamma \\vdash \\text{map}<em>\\text{Id} f \\text{refl}</em>{A, a} \\cong \\text{refl}_{A', f a} : \\text{Id} A'(f a) (f a) )</td>\n</tr>\n</tbody>\n</table>\nB.4 Algorithmic MLTT\n\nExtend appendix B.2. Replaces the rules already named with the same name in appendix B.2.\n\nΓ ⊨ map t ≈ h t′ ⊨ T\n\nΓ ⊨ map n ≈ map n′ ⊨ T\n\nT is Type, List A, W x: A.B or Id_A a a′\n\nΓ ⊨ map n ≈ h n′ ⊨ T\n\nΓ ⊨ map A ≈ A′ ⊨ Γ, z: List A ⊨ map P ≈ P′ ⊨\n\nΓ ⊨ map b ≈ b′ ⊨ P[x ≈ A y]\n\nΓ ⊨ ind List_A(s; z.P; b, x.y.z.b.) ≈ ind List_A′(s′; z.P′; b′, x.y.z.b.) ⊨ P[s]\n\nΓ ⊨ map A ≈ A′ ⊨ Γ, x: A ⊨ map B ≈ B′ ⊨\n\nΓ ⊨ map s ≈ map s′ ⊨ W x: A.B ⊨ Γ, z: W x: A.B ⊨ map P ≈ P′ ⊨\n\nΓ ⊨ ind_W x: A.B(s; z.P; x.y.z.b) ≈ ind_W x: A.B′(s′; z.P′; x.y.z.b′) ⊨ P[s]\n\nΓ ⊨ map A ≈ A′ ⊨ Γ ⊨ map s ≈ Id_A ▷ a, a′ ⊨\n\nΓ ⊨ map b ≈ b′ ⊨ P[sup_x: B x y]\n\nΓ ⊨ map P ≈ P′ ⊨ Γ, x: A ⊨ map b ≈ b′ ⊨ P[id, x, x, refl_A,x]\n\nΓ ⊨ map ind Id_A(s; x.z.P; b) ≈ ind Id_A′(s′; x.z.P′; b′) ⊨ P[id, a, a′, s]\n\nunmap, unmapfun, unmapfun_W_1, unmapfun_W_2\n\nunmap(map_φ f t) ≜ t unmap(t) ≜ t otherwise\n\nunmapfun(map_φ f t, x) ≜ f x unmapfun(t, x) ≜ x otherwise\n\nunmapfun_W_1(map_φ f t, x) ≜ π_1 f x unmapfun_W_1(t, x) ≜ x otherwise\n\nunmapfun_W_2(map_φ f t, y) ≜ π_2 f y unmapfun_W_2(t, y) ≜ y otherwise\n\nΓ ⊨ map n ≈ map n′ ⊨ T\n\nΓ ⊨ map unmap(n) ≈ h unmap(n′) ▷ List A\n\nΓ, x: A ⊨ map unmap(n, x) ≈ unmapfun(n′, x) ⊨ B\n\nΓ ⊨ map n ≈ map n′ ⊨ List B\n\nΓ, x: A ⊨ map unmap(n, x) ≈ unmapfun_W_1(n, x) ▷ A′\n\nΓ ⊨ map unmapfun_W_1(n, x) ≈ unmapfun_W_1(n′, x) ▷ A′\n\nΓ ⊨ map unmapfun_W_2(n, y) ≈ unmapfun_W_2(n′, y) ▷ B x\n\nΓ ⊨ map unmap(n) ≈ h unmap(n′) ▷ W x: A.B\n\nΓ, x: A, y: B′[unmapfun_W_1(n, x)] ⊨ map unmapfun_W_2(n, y) ≈ unmapfun_W_2(n′, y) ▷ B x\n\nΓ ⊨ map unmap(n) ≈ h unmap(n′) ▷ Id_A a a′\n\nΓ, x: A ⊨ map unmap(n, x) ≈ unmapfun(n′, x) ▷ A′\n\nΓ ⊨ map s ≈ map s′ ▷ Id_A ▷ a, a′\n\\[\nt \\leadsto^1 t'\n\\]\n\n\\[\n\\text{map}_n \\ f \\ h \\ t \\leadsto^1 (\\pi_2 \\ f) (h ((\\pi_1 \\ f) t)) \\quad \\pi_1 (\\text{map}_{\\Sigma} \\ f p) \\leadsto^1 \\pi_1 f (\\pi_1 p)\n\\]\n\n\\[\n\\pi_2 (\\text{map}_{\\Sigma} \\ f p) \\leadsto^1 \\pi_2 f (\\pi_2 p) \\quad \\text{map}_{\\text{List}} \\ f \\in \\leadsto^1 e\n\\]\n\n\\[\n\\text{map}_{\\text{List}} \\ f (hd z tl) \\leadsto^1 f hd z \\text{map}_{\\text{List}} \\ f tl\n\\]\n\n\\[\n\\text{map}_{\\mathcal{W}} \\{T\\} \\{T'\\} f (\\sup a k) \\leadsto^1 \\sup_{x.\\pi_2 T'}(\\pi_1 f a) (\\lambda x: (\\pi_2 T' (\\pi_1 f a)). \\text{map}_{\\mathcal{W}} f (k (\\pi_2 g x)))\n\\]\n\n\\[\n\\text{map}_{\\text{Id}} \\ f \\ \\text{refl}_{A,a} \\leadsto^1 \\text{refl}_{B,f \\ a}\n\\]\n\n\\[\n\\text{REDMAPCOMP} \\quad \\text{ne } n \\quad \\text{map}_{\\text{List}} (\\text{map}_{\\text{List}} g n) \\leadsto^1 \\text{map}_{\\text{List}} (f \\circ g) n\n\\]\n\n\\section*{B.5 Declarative label types}\n\nExtend appendix B.1.\n\n\\[\n\\begin{array}{c}\n\\frac{L_1 \\in \\mathcal{P}_1 (\\text{Lbl})}{\\Gamma \\vdash L_1} & \\quad \\frac{L_1 \\in \\mathcal{P}_1 (\\text{Lbl})}{\\Gamma \\vdash L_1 : \\text{Type}_0} & \\quad \\frac{l \\in \\text{Lbl}}{\\Gamma \\vdash \\{l\\}} \\\\\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{c}\n\\frac{\\Gamma \\vdash s : L \\quad \\Gamma, x : L \\vdash P \\quad \\Gamma \\vdash b_l : P[l] \\text{ for all } l \\in L}{\\Gamma \\vdash \\text{ind}_L (s; x. P; \\vec{b}_l) : P[s]} \\\\\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{c}\n\\frac{\\Gamma \\vdash t \\equiv t' : L \\quad \\Gamma, z : L \\vdash P \\equiv P' \\quad \\Gamma \\vdash b_l \\equiv b'_l : P[l] \\text{ for all } l \\in L}{\\Gamma \\vdash \\text{ind}_L (t; z. P; \\vec{b}_l) \\equiv \\text{ind}_L (t'; z. P'; \\vec{b}'_l) : P[t]} \\\\\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{c}\n\\frac{l \\in L \\quad \\Gamma \\vdash s : L \\quad \\Gamma, x : L \\vdash P \\quad \\Gamma \\vdash b_l : P[l] \\text{ for all } l \\in L}{\\Gamma \\vdash \\text{ind}_{\\{l\\}} (l; x. P; \\vec{b}_l) \\equiv b_l : P[l]} \\\\\n\\end{array}\n\\]\n\n\\section*{B.6 Algorithmic label types}\n\nExtend appendix B.2. The term \\( l \\) is a normal form, and \\( \\text{ind}_L (n; x. P; \\vec{b}) \\) is neutral whenever \\( n \\) is.\n\n\\[\n\\begin{array}{c}\n\\frac{L_1 \\in \\mathcal{P}_1 (\\text{Lbl})}{\\Gamma \\vdash L_1 : \\text{Type}_0} & \\quad \\frac{l \\in \\text{Lbl}}{\\Gamma \\vdash \\{l\\}} & \\quad \\frac{\\Gamma \\vdash l \\equiv_h \\{l\\} < L}{\\text{LbLConv}} \\\\\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{c}\n\\frac{\\Gamma \\vdash s < L \\quad \\Gamma, x : L \\vdash P \\vdash_h \\text{Type}_i \\quad \\Gamma \\vdash b_l < P[l] \\text{ for all } l \\in L}{\\Gamma \\vdash \\text{ind}_L (s; x. P; \\vec{b}_l) \\vdash P[s]} \\\\\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{c}\n\\frac{\\Gamma \\vdash n \\approx n' \\triangleright S \\quad \\Gamma, z : L \\vdash P \\equiv P' \\triangleright \\quad \\Gamma \\vdash b_l \\approx b'_l \\vdash P[l] \\text{ for all } l \\in L}{\\Gamma \\vdash \\text{ind}_L (n; z. P; \\vec{b}_l) \\approx \\text{ind}_L (n'; z. P'; \\vec{b}'_l) \\triangleright P[n]} \\\\\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{c}\n\\frac{\\text{LbLM} \\ {\\text{ind}}_{\\{l\\}} (l; x. P; \\vec{b}_l) \\leadsto^1 b_l}{\\text{LbLMRed}} \\\\\n\\end{array}\n\\]\n\n39\n### B.7 Algorithmic MLTT$_{\\text{sub}}$\n\nExtend appendices B.2 and B.6, with rule CHECKSUB replacing CHECK.\n\n\\[ \\Gamma \\vdash_{\\text{sub}} t <_{\\top} T \\]\n\n**CHECKSUB**\n\n\\[\n\\begin{array}{c}\n\\Gamma \\vdash_{\\text{sub}} t \\triangleright T' \\quad \\Gamma \\vdash_{\\text{sub}} T' \\preceq_{\\bot} T \\\\\n\\hline\n\\Gamma \\vdash_{\\text{sub}} t \\preceq_{\\bot} T\n\\end{array}\n\\]\n\nType $T$ is a subtype of type $T'$\n\n\\[\n\\begin{array}{c}\nT \\rightsquigarrow^* U \\quad T' \\rightsquigarrow^* U' \\quad \\Gamma \\vdash_{\\text{sub}} U \\preceq_{h} U'\n\\end{array}\n\\]\n\n\\[\n\\Gamma \\vdash_{\\text{sub}} T \\preceq_{h} T'\n\\]\n\nReduced type $T$ is a subtype of reduced type $T'$\n\n- **LblSub**\n \\[\n L \\subseteq L' \\quad \\Gamma \\vdash_{\\text{sub}} L \\preceq_{h} L'\n \\]\n\n- **ProdSub**\n \\[\n \\Gamma \\vdash_{\\text{sub}} A' \\preceq A \\quad \\Gamma, x: A \\vdash_{\\text{sub}} B \\preceq B' \\\\\n \\Gamma \\vdash_{\\text{sub}} \\Pi x: A. B \\preceq_{h} \\Pi x: A'. B'\n \\]\n\n- **SigSub**\n \\[\n \\Gamma \\vdash_{\\text{sub}} A \\preceq A' \\quad \\Gamma \\vdash_{\\text{sub}} x: A \\vdash_{\\text{sub}} B \\preceq B' \\\\\n \\Gamma \\vdash_{\\text{sub}} \\Sigma x: A. B \\preceq_{h} \\Sigma x: A'. B'\n \\]\n\n- **SubRef1**\n \\[\n T \\text{ is Type, } 0, 1 \\text{ or } B \\quad \\Gamma \\vdash_{\\text{sub}} T \\preceq_{h} T\n \\]\n\n- **SubRef2**\n \\[\n \\Gamma \\vdash_{\\text{sub}} n \\preceq_{h} n' \\quad \\Gamma \\vdash_{\\text{sub}} n' \\preceq_{h} n\n \\]\n\n- **SubRef3**\n \\[\n \\Gamma \\vdash_{\\text{sub}} A \\preceq A' \\quad \\Gamma \\vdash_{\\text{sub}} A' \\preceq A \\quad \\Gamma \\vdash_{\\text{sub}} A \\preceq A'\n \\]\n\n- **SubRef4**\n \\[\n \\Gamma \\vdash_{\\text{sub}} A \\preceq A' \\quad \\Gamma \\vdash_{\\text{sub}} A' \\preceq A'' \\quad \\Gamma \\vdash_{\\text{sub}} A \\preceq A''\n \\]\n\n**SubRefl**\n\nAdmissible\n\n**ConvSub**\n\n\\[\n\\Gamma \\vdash_{\\text{sub}} A \\equiv A' \\quad \\Gamma \\vdash_{\\text{sub}} A \\preceq A' \\quad \\Gamma \\vdash_{\\text{sub}} A' \\preceq A\n\\]\n\n**SubAntiSym**\n\n\\[\n\\Gamma \\vdash_{\\text{sub}} A \\equiv A' \\quad \\Gamma \\vdash_{\\text{sub}} A' \\equiv A \\quad \\Gamma \\vdash_{\\text{sub}} A \\preceq A'\n\\]\n\n**SubTrans**\n\n\\[\n\\Gamma \\vdash_{\\text{sub}} A \\equiv A' \\quad \\Gamma \\vdash_{\\text{sub}} A' \\equiv A'' \\quad \\Gamma \\vdash_{\\text{sub}} A \\equiv A''\n\\]\n\n### B.8 Algorithmic MLTT$_{\\text{coe}}$\n\nExtend appendix B.2 and appendix B.6.\n\n\\[ \\Gamma \\vdash_{\\text{coe}} t \\triangleright T \\]\n\n**Coe**\n\n\\[\n\\begin{array}{c}\n\\Gamma \\vdash_{\\text{coe}} A \\preceq \\quad \\Gamma \\vdash_{\\text{coe}} A' \\preceq \\quad \\Gamma \\vdash_{\\text{coe}} t \\preceq A \\quad \\Gamma \\vdash_{\\text{coe}} A \\preceq A' \\preceq \\quad \\Gamma \\vdash_{\\text{coe}} \\text{coe}_{A. A'}, t \\triangleright A'\n\\end{array}\n\\]\nDefinitional Functoriality for Dependent (Sub)Types\n\n\\[ t \\leadsto^1 t' \\]\n\n\\[ \\text{coe}_{\\Pi x:A.B,\\Pi x:A'.B'}(\\lambda x:A''t) \\leadsto^1 \\lambda x:A'.\\text{coe}_{B[\\text{coe}_{A'',A}x],B'[x]}(t[\\text{coe}_{A',A}x]) \\]\n\n\\[ \\text{RedCoeFunNe} \\]\n\\[ \\frac{\\text{ne } f}{(\\text{coe}_{\\Pi x:A.B,\\Pi x:A'.B'} f) a \\leadsto^1 \\text{coe}_{B[\\text{coe}_{A',A}a],B'[a]}(f(\\text{coe}_{A',A}a))} \\]\n\n\\[ \\text{coe}_{\\Sigma x:A.B,\\Sigma x:A'.B'}(t, u) \\leadsto^1 ((\\text{coe}_{A,A'}t), (\\text{coe}_{B[t],B'[\\text{coe}_{A',A'}t]}u)) \\]\n\n\\[ \\text{RedCoeSigNe1} \\]\n\\[ \\frac{\\text{ne } p}{\\pi_1(\\text{coe}_{\\Sigma x:A.B,\\Sigma x:A'.B'} p) \\leadsto^1 \\text{coe}_{A,A'}(\\pi_1 p)} \\]\n\n\\[ \\text{RedCoeSigNe2} \\]\n\\[ \\frac{\\text{ne } p}{\\pi_2(\\text{coe}_{\\Sigma x:A.B,\\Sigma x:A'.B'} p) \\leadsto^1 \\text{coe}_{B[\\pi_1 p],B'[\\text{coe}_{A',A'}(\\pi_1 p)]}(\\pi_2 p)} \\]\n\n\\[ \\text{CoER} \\]\n\\[ \\frac{\\text{nf } A}{\\text{nf } B \\quad t \\leadsto^1 t'} \\quad \\text{CoEC} \\quad \\frac{\\text{nf } U}{\\text{nf } U' \\quad \\text{nf } T \\quad \\text{nf } T' \\quad \\text{ne } n} \\]\n\n\\[ \\text{nf } f \\triangleq \\ldots | c \\mid L | \\text{coe}_L L \\quad \\text{weak-head normal forms} \\]\n\\[ \\text{ne } n \\triangleq \\ldots | \\text{ind}_L (t; c; \\bar{t}) \\quad \\text{weak-head neutrals} \\]\n\\[ \\text{cne } c \\triangleq \\ldots | \\text{coe}_f f n \\quad \\text{compacted neutrals} \\]\n\n\\[ \\Gamma \\vdash_{\\text{coe}} t \\approx t' \\vdash T \\]\n\nCompacted neutrals \\( t \\) and \\( t' \\) are comparable at type \\( T \\)\n\n\\[ \\text{NCoER} \\]\n\\[ \\frac{\\Gamma \\vdash_{\\text{coe}} n \\approx n' \\vdash S''}{\\text{NCoEL} \\quad \\frac{\\Gamma \\vdash_{\\text{coe}} n \\approx n' \\vdash S''}{\\text{NNoCoe} \\quad \\frac{\\Gamma \\vdash_{\\text{coe}} n \\approx n' \\vdash S''}{\\text{NNoCoe}} \\quad \\frac{\\Gamma \\vdash_{\\text{coe}} n \\approx n' \\vdash S''}{\\text{NNoCoe}} \\quad \\frac{\\Gamma \\vdash_{\\text{coe}} n \\approx n' \\vdash S''}{\\text{NNoCoe}}} \\]\n\\[ \\Gamma \\vdash \\text{coe } t \\lessapprox_h t' \\triangleleft T \\]\n\n\\[\n\\begin{array}{ll}\n\\text{LblTmConv} & \\Gamma \\vdash \\text{coe } L \\lessapprox_h \\text{coe } L \\triangleleft L \\\\\n\\text{NeuList} & \\Gamma \\vdash \\text{coe } n \\lessapprox \\text{coe } n' \\triangleleft \\text{List } A \\\\\n& \\Gamma \\vdash \\text{coe } n \\lessapprox_h n' \\triangleleft \\text{List } A \\\\\n\\text{NeuTree} & \\Gamma \\vdash \\text{coe } n \\approx \\text{coe } n' \\triangleleft W x : A. B \\\\\n& \\Gamma \\vdash \\text{coe } n \\lessapprox \\text{coe } n' \\triangleleft W x : A. B \\\\\n\\text{NeuId} & \\Gamma \\vdash \\text{coe } n \\approx \\text{coe } n' \\triangleleft M \\triangleleft \\text{ne } M \\\\\n\\text{NeuNeu} & \\Gamma \\vdash \\text{coe } n \\approx \\text{coe } n' \\triangleleft M \\triangleleft \\text{ne } M \\\\\n\\end{array}\n\\]\n\n\\[ \\Gamma \\vdash \\text{coe } T \\lessapprox T' \\triangleleft \\]\n\n\\[\n\\begin{array}{ll}\n\\text{SubRef} & \\Gamma \\vdash \\text{coe } T \\lessapprox_h T' \\triangleleft \\\\\n\\text{TyRed} & T \\mapsto^* U \\quad T' \\mapsto^* U' \\quad \\Gamma \\vdash \\text{coe } U \\lessapprox_h U' \\triangleleft \\\\\n& \\Gamma \\vdash \\text{coe } T \\lessapprox T' \\triangleleft \\\\\n\\end{array}\n\\]\n\n\\[ \\Gamma \\vdash \\text{coe } T \\lessapprox_h T' \\triangleleft \\]\n\n\\[\n\\begin{array}{ll}\n\\text{LbListSub} & L \\subseteq L' \\quad \\Gamma \\vdash \\text{coe } L \\lessapprox_h L' \\triangleleft \\\\\n\\text{ProdSub} & \\Gamma \\vdash A' \\lessapprox A \\triangleleft \\quad \\Gamma, x : A' \\vdash \\text{coe } B[\\text{coe } A, A' x] \\lessapprox B' \\triangleleft \\\\\n& \\Gamma \\vdash \\Pi x : A. B \\lessapprox_h \\Pi x : A'. B' \\triangleleft \\\\\n\\text{ListSub} & \\Gamma \\vdash \\text{List } A \\lessapprox \\text{List } A' \\triangleleft \\\\\n\\text{SigSub} & \\Gamma \\vdash \\Sigma x : A. B \\lessapprox_h \\Sigma x : A'. B' \\triangleleft \\\\\n\\text{TreeSub} & \\Gamma \\vdash A \\lessapprox A' \\triangleleft \\quad \\Gamma \\vdash W x : A : B \\lessapprox_h W x : A'. B' \\triangleleft \\\\\n\\text{IdSub} & \\Gamma \\vdash A \\lessapprox A' \\triangleleft \\quad \\Gamma \\vdash \\text{coe } A, A' t \\lessapprox t' \\triangleleft A' \\quad \\Gamma \\vdash \\text{coe } A, A' u \\lessapprox u' \\triangleleft A' \\\\\n& \\Gamma \\vdash \\text{Id } A t u \\lessapprox \\text{Id } A' t' u' \\triangleleft \\\\\n\\text{SubRef} & T \\text{ is Type, } 0, 1 \\text{ or } B \\\\\n\\end{array}\n\\]\n\nB.9 Declarative MLTT\\text{coe}\nExtend appendix B.1 and appendix B.5.\nCoeId \n\\[ \\Gamma \\vdash_{\\text{coe}} t \\cong t' : T \\]\n\nCoeFun \n\\[ \\Gamma \\vdash_{\\text{coe}} (\\text{coe}_{\\Pi x:A.B, \\Pi x:A'.B'} f) a \\cong \\text{coe}_{B[\\text{coe}_{A',A},a]} B'_x[\\pi f(\\text{coe}_{A',A} a)] : \\Pi x:A'.B' \\]\n\nCoeSig1 \n\\[ \\Gamma \\vdash_{\\text{coe}} A \\prec A' \\quad \\Gamma \\vdash_{\\text{coe}} x:A \\vdash_{\\text{coe}} B'[\\text{coe}_{A',A} x] \\quad \\Gamma \\vdash_{\\text{coe}} \\pi_1(\\text{coe}_{x:A.B, \\Sigma x:A'.B'} p) \\cong \\text{coe}_{A'.A}(\\pi_1 p) : \\Sigma x:A'.B' \\]\n\nCoeSig2 \n\\[ \\Gamma \\vdash_{\\text{coe}} A \\prec A' \\quad \\Gamma \\vdash_{\\text{coe}} x:A \\vdash_{\\text{coe}} B'[\\text{coe}_{A',A} x] \\quad \\Gamma \\vdash_{\\text{coe}} \\pi_2(\\text{coe}_{x:A.B, \\Sigma x:A'.B'} p) \\cong \\text{coe}_{B[\\pi_1 p], B'[\\text{coe}_{A',A}(\\pi_1 p)]}(\\pi_2 p) : \\Sigma x:A'.B' \\]\n\nCoeNil \n\\[ \\Gamma \\vdash_{\\text{coe}} \\text{coe}_{\\text{List}} A \\text{List} A' \\cong \\varepsilon A : \\text{List} A' \\]\n\nCoeCons \n\\[ \\Gamma \\vdash_{\\text{coe}} A \\prec A' \\quad \\Gamma \\vdash_{\\text{coe}} a : A \\quad \\Gamma \\vdash_{\\text{coe}} l : \\text{List} A \\]\n\n\\[ \\Gamma \\vdash_{\\text{coe}} \\text{coe}_{\\text{List}} A \\text{List}(a z A l) \\cong (\\text{coe}_{A',A} a) z A' (\\text{coe}_{\\text{List}} A \\text{List} A' l) : \\text{List} A' \\]\n\nCoeTree \n\\[ \\Gamma \\vdash_{\\text{coe}} \\text{coe}_{\\text{W}} x:A.B, \\text{coe}_{\\text{W}} x:A'.B'(\\sup_{x:A.B}(\\text{coe}_{A',A} a)) (\\lambda x:B'.[\\text{coe}_{A',A} a]. \\text{coe}_{\\text{W}} x:A.B, \\text{coe}_{\\text{W}} x:A'.B'(k (\\text{coe}_{B[\\text{coe}_{A',A},a]} B[a]) x)) : \\text{W} x:A'.B' \\]\n\nCoeId \n\\[ \\Gamma \\vdash_{\\text{coe}} A \\prec A' \\quad \\Gamma \\vdash_{\\text{coe}} a : A \\]\n\n\\[ \\Gamma \\vdash_{\\text{coe}} \\text{refl}_{A,a} \\cong \\text{refl}_{A',a} (\\text{coe}_{A',A} a) : \\text{Id}_{A}(\\text{coe}_{A',A} a) (\\text{coe}_{A',A} a) \\]\n\n\\[ \\Gamma \\vdash_{\\text{coe}} T \\cong T' \\quad \\text{T is a subtype of T'} \\text{ in context } \\Gamma \\]\n\nLbSub \n\\[ \\Gamma \\vdash_{\\text{coe}} L \\subseteq L' \\]\n\nProdSub \n\\[ \\Gamma \\vdash_{\\text{coe}} A' \\prec A \\quad \\Gamma \\vdash_{\\text{coe}} x:A' \\vdash_{\\text{coe}} B[\\text{coe}_{A',A} x] \\prec B' \\quad \\Gamma \\vdash_{\\text{coe}} \\Pi x:A.B \\prec \\Pi x:A'.B' \\]\n\nListSub \n\\[ \\Gamma \\vdash_{\\text{coe}} A \\prec A' \\]\n\n\\[ \\Gamma \\vdash_{\\text{coe}} \\text{List} A \\prec \\text{List} A' \\]\n\nSigSub \n\\[ \\Gamma \\vdash_{\\text{coe}} A \\prec A' \\quad \\Gamma \\vdash_{\\text{coe}} x:A \\vdash_{\\text{coe}} B \\prec B'[\\text{coe}_{A',A} x] \\quad \\Gamma \\vdash_{\\text{coe}} \\Sigma x:A.B \\prec \\Sigma x:A'.B' \\]\nC PROOFS OF LEMMAS\n\nThis section contains additional lemmas and proofs omitted from the body of the paper.\n\nC.1 From section 3.2\n\nmap₁ ((g, f): Hom₁((A, B), (A', B')))) (h: Π(x:A)B) ≜ λx:A'.f (h (g x))\nmap₂ ((g, f): Hom₂((A, B), (A', B'))) (p: Σ(x:A)B) ≜ (g (π₁ p), f (π₂ p))\n\n**Lemma C.1.** map₁ and map₂ satisfy the functor laws MAP_ID and MAP_COMP.\n\n**Proof.** For the preservation of identities, we have:\n\nmap₁ (id₁, λ{x:A}. id₁_Bx) h ≜ λx:A. id₁_Bx (h (id₁_A x)) ≜ λx:A.g x ≡ g\nmap₂ (id₁, λ{x:A}. id₂_Bx) p ≜ (id₂_A (π₁ p), id₂_B(π₁ p) (π₂ p)) ≜ (π₁ p, π₂ p) ≡ p\n\nFor (g, f): Hom₁((A₂, B₂), (A₃, B₃)), (g', f'): Hom₁((A₁, B₁), (A₂, B₂)) and h: Π x:A₁.B₁ x we compute\n\nmap₁ (g, f) (map₁ (g', f') h) ≜ λx:A.f ((λ x':A'.f' (h (g' x'))) (g x))\n\n≡ λx:A, f (f' (h (g' (g x))))\n\n≡ λx:A, f (f' (h ((g' o g) x))) ≜ map₁((g, f) o (g', f')) h\n\nSimilarly, for (g, f): Hom₂((A₂, B₂), (A₃, B₃)), (g', f'): Hom₂((A₁, B₁), (A₂, B₂)) and p: Σ x:A₁.B₁ x :\n\nmap₂ (g, f) (map₂ (g', f') p) ≜ (g (π₁ map₂ (g', f') p), f (π₂ map₂ (g', f') p))\n\n≡ ((g o g') (π₁ p)), (f o f') (π₂ p))\n\n≡ map₂((g, f) o (g', f')) p\n\n□\n\nC.2 From section 5.3\n\n**Lemma C.2 (Catch up, function type (Lemma 5.7)).** If Γ ⊢coe f a : B and |f| = λx:A'. t', then there exists t such that |t| = t' and f a ↠* t[a].\n\n**Proof.** We must have that f = (coe₁₋₀(T₁₋₀ (λ x:Aₐ0)))¹⁴ for some A, t₀ such that |A| = A' and |t₀| = t'. Moreover, by well-typing we know that there exists some B₀ such that Γ, x:A ⊢coe\n\n¹⁴That is, a string of coercions coe₁₋₀(T₁₋₀ (... coe₁₋₀(Tₐ₂ (λ x:Aₐ0))).\nwhere the inputs of the conclusions are well-formed: the structure of normal forms from fig. 14, this can happen in three situations. If the coercions are between label types, then rule \\texttt{LblTmConv} applies. If the coercions are between function types, we do not inspect the terms, and instead eagerly \\( \\eta \\)-expand in a type-directed fashion (which triggers further reduction of the now applied coercions). Finally, compacted neutrals can appear exactly in\n\n\\[\nt_0 \\triangleright B_0, \\Gamma \\vdash_{\\text{coe}} \\Pi x : A. B_0 \\cong T_1 \\cong T_2 \\cong \\ldots \\cong T_n \\triangleleft. \\text{By inversions, we must have } T_i \\rightsquigarrow^* \\Pi x : A_i. B_i, \\text{ with the } A_i \\text{ and } B_i \\text{ again related. But now we can use the reduction rule of } \\text{coe on product types, and get}\n\\]\n\n\\[\nf a \\rightsquigarrow^* \\text{coe}_{B_0', B_1', \\ldots, B_n'}((\\lambda x : A. t_0) (\\text{coe}_{A_n, \\ldots, A_1, A \\ a}))\\]\n\nwhere the \\( B'_i \\) are obtained by adequately substituting coercions in the \\( B_i \\). Now all the \\( B'_i \\) are well-typed by subject reduction, so they must have weak-head normal forms \\( B''_i \\), and once all of them have been reduced to weak-head normal form by a combination of \\texttt{COEL}, \\texttt{CORE} and \\texttt{COETM}, we can finally reduce the inner \\( \\beta \\)-redex, obtaining\n\n\\[\nf a \\rightsquigarrow^* \\text{coe}_{B''_0, B''_1, \\ldots, B''_n}(t_0 [\\text{coe}_{A_n, \\ldots, A_1, A \\ a}])\\]\n\nNow we can conclude, as indeed\n\n\\[\n|\\text{coe}_{B''_0, B''_1, \\ldots, B''_n}(t_0 [\\text{coe}_{A_n, \\ldots, A_1, A \\ a}])| = |t_0 [\\text{coe}_{A_n, \\ldots, A_1, A \\ x}]|\n= |t_0 [\\eta |\\text{coe}_{A_n, \\ldots, A_1, A \\ x}]|\n= |t_0 [\\eta |x]| = |t_0| = t'\n\\]\n\n\\( \\square \\)\n\n**Lemma C.3 (Erasure is a backward simulation (Lemma 5.10)).** Assume that \\( \\Gamma \\vdash_{\\text{coe}} t : T \\). If \\( |t| \\rightsquigarrow^* u' \\), with \\( u' \\) a weak-head normal form, then \\( t \\rightsquigarrow^* u \\), with \\( u \\) a weak-head normal form such that \\( |u| = u' \\).\n\n**Proof.** First, if \\( |t| \\rightsquigarrow^* u' \\), then there exists \\( u \\) such that \\( t \\rightsquigarrow^* u \\) and \\( |u| = u' \\). Indeed, the previous catch-up lemmas ensure that redexes never get blocked by coercions. On function types, the lemma exactly says that a term erasing to a \\( \\beta \\)-redex is able to simulate the \\( \\beta \\)-reduction. On positive types, by the catch-up lemma again, coercions on a constructor reduce away until the constructor is exposed directly to the destructor, and so the reduction can kick in.\n\nSecond, if \\( |u| \\) is a weak-head normal form, then there exists a weak-head normal form \\( v \\) such that \\( u \\rightsquigarrow^* v \\) and \\( |v| = |u| \\). Indeed, if \\( |u| \\) is a weak-head normal form but \\( u \\) is not, it must be because either \\( |u| \\) is a constructor of a positive type, or a neutral. In the first case, the catch-up lemmas let us conclude. In the second, we can iterate \\texttt{COECOE} to fuse coercions until \\( u \\) reduces to a compacted neutral, which is a weak-head normal form. \\( \\square \\)\n\n**Lemma C.4 (Elaboration preserves subtyping (Lemma 5.11)).** The following implications hold whenever the inputs of the conclusions are well-formed:\n\n\\begin{enumerate}\n\\item if \\( \\Gamma \\vdash_{\\text{sub}} T \\triangleleft_{h} U \\triangleleft_{h} |T| \\triangleleft_{h} |U| \\triangleleft_{h} U \\triangleleft_{h} \\), then \\( \\Gamma \\vdash_{\\text{coe}} T \\triangleleft_{h} U \\triangleleft_{h} \\);\n\\item if \\( \\Gamma \\vdash_{\\text{sub}} T \\triangleleft_{h} U \\triangleleft_{h} |T| \\triangleleft_{h} |U| \\triangleleft_{h} U \\triangleleft_{h} \\), then \\( \\Gamma \\vdash_{\\text{coe}} T \\triangleleft_{h} U \\triangleleft_{h} \\);\n\\item if \\( \\Gamma \\vdash_{\\text{sub}} t \\cong_{h} u \\triangleleft |T| \\triangleleft_{h} |T| \\triangleleft_{h} |T| \\triangleleft_{h} u \\triangleleft T \\);\n\\item if \\( \\Gamma \\vdash_{\\text{sub}} t \\cong_{h} u \\triangleleft |T| \\triangleleft_{h} |T| \\triangleleft_{h} |T| \\triangleleft_{h} u \\triangleleft T \\);\n\\item if \\( \\Gamma \\vdash_{\\text{sub}} t \\cong_{h} u \\triangleleft T \\triangleleft_{h} T \\triangleleft_{h} T \\triangleleft_{h} T \\triangleleft_{h} T \\triangleleft_{h} T \\);\n\\item if \\( \\Gamma \\vdash_{\\text{sub}} t \\cong_{h} u \\triangleleft T \\triangleleft_{h} T \\triangleleft_{h} T \\triangleleft_{h} T \\).\n\\end{enumerate}\n\n**Proof.** Lemma 5.10 ensures we can always match reductions to weak-head normal forms in \\texttt{MLTT} and to weak-head normal forms in \\texttt{MLTT} and to weak-head normal forms in \\texttt{MLTT}. As for conversion itself, the key cases are those where the term in \\texttt{MLTT} is a coercion, that gets erased in \\texttt{MLTT}. Given the structure of normal forms from fig. 14, this can happen in three situations. If the coercions are between label types, then rule \\texttt{LblTmConv} applies. If the coercions are between function types, we do not inspect the terms, and instead eagerly \\( \\eta \\)-expand in a type-directed fashion (which triggers further reduction of the now applied coercions). Finally, compacted neutrals can appear exactly in\n\n45\nthe places where $\\text{MLTT}_{\\text{coe}}$ uses the comparison of the compacted neutrals, which strips away the possibly present coercions, as expected.\n\nFinally, the main theorem states that we can elaborate terms using implicit subtyping to explicit coercions, in a type-preserving way.\n\n**Theorem C.5 (Elaboration – Induction).** The following implications hold, whenever inputs to the conclusion are well-formed:\n\n1. If $\\Gamma \\vdash_{\\text{sub}} t \\triangleright T'$, then there exists $t$ and $T'$ such that $t' = |t|, T' = |T|$, and $\\Gamma \\vdash_{\\text{coe}} t \\triangleright T$;\n2. If $\\Gamma \\vdash_{\\text{sub}} t \\triangleright h T'$, then there exists $t$ and $T'$ such that $t' = |t|, T' = |T|$, and $\\Gamma \\vdash_{\\text{coe}} t \\triangleright h T$;\n3. If $\\Gamma \\vdash_{\\text{sub}} t \\lhd |T|$, then there exists $t$ such that $t' = |t|$ and $\\Gamma \\vdash_{\\text{coe}} t \\lhd T$.\n\n**Proof.** Once again, by mutual induction. Each rule is mapped to its counterpart, but for Check-Sub, where we need to insert a coercion in the elaborated term. This coercion is well-typed by lemma 5.11.\n\n### C.3 Translation from $\\text{MLTT}_{\\text{coe}}$ to $\\text{MLTT}_{\\text{map}}$\n\n<table>\n<thead>\n<tr>\n<th>Rule</th>\n<th>Source</th>\n<th>Target</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$\\text{TslTy}$</td>\n<td>$\\text{Type}_i \\simeq \\text{Type}_i$</td>\n<td>$\\text{TslLbl}$</td>\n</tr>\n<tr>\n<td>$\\text{TslPi}$</td>\n<td>$\\Pi x : A. B \\simeq \\Pi x : A'. B'$</td>\n<td>$\\text{TslVar}$</td>\n</tr>\n<tr>\n<td>$\\text{TslApp}$</td>\n<td>$[u] \\simeq u', [v] \\simeq v'$</td>\n<td>$\\text{TslCoEId}$</td>\n</tr>\n<tr>\n<td>$\\text{TslCoENf}$</td>\n<td>$A \\triangleright A' \\text{ nf} \\quad B \\triangleright B' \\text{ nf} \\quad [A' \\triangleright B'] \\simeq x \\quad A \\neq A'$ or $B \\neq B'$</td>\n<td>$\\text{TslCoE}$</td>\n</tr>\n<tr>\n<td>$\\text{TslCoELblId}$</td>\n<td>$[L \\triangleright L] \\simeq \\star$</td>\n<td>$\\text{TslCoELbl}$</td>\n</tr>\n<tr>\n<td>$\\text{TslCoELbl}$</td>\n<td>$[L \\triangleright L] \\simeq \\star$</td>\n<td>$\\text{TslCoList}$</td>\n</tr>\n<tr>\n<td>$\\text{TslCoPiIdBoth}$</td>\n<td>$\\Pi x : A_1. B_1 \\triangleright \\Pi x : A_2. B_2 \\simeq \\star$</td>\n<td>$\\text{TslCoPiIdDom}$</td>\n</tr>\n</tbody>\n</table>\n\n46\nWe note well from pairs of Allother cases are immediate or simple applications of the inductive hypothesis, using the fact that variables, with a similar lemma for \n\n\\[ \\Pi x: A_1.B_1 \\Rightarrow \\Pi x: A_2.B_2 \\approx \\text{map}_\\Pi(f, \\lambda\\{x: A_2^\\prime\\}. \\text{id}_{B_2^\\prime}) \\]\n\n\\[ \\frac{[A_2 \\Rightarrow A_1] \\approx f}{[B_1[\\text{coe}_{A_2.A_1} x] \\Rightarrow B_2] \\approx \\ast} \\]\n\n\\[ [A_2] \\approx A_2 \\quad [B_2] \\approx B_2^\\prime \\]\n\n\\[ \\Pi x: A_1.B_1 \\Rightarrow \\Pi x: A_2.B_2 \\approx \\text{map}_\\Pi(f, \\lambda\\{x: A_2^\\prime\\}. g) \\]\n\nThe translation is extended to contexts pointwise.\n\n\\[ [\\Gamma] \\approx \\Gamma' \\quad [A] \\approx A' \\quad [\\Gamma, x: A] \\approx \\Gamma', x: A' \\]\n\nWe note \\([t]_\\downarrow\\) when \\(t\\) is in the domain of the relation and \\([t]\\) for the image of \\(t\\) when it is defined.\n\n\\textbf{Lemma C.6 (Determinism of Translation).} The translation relation \\([t] \\approx t'\\) is a partial function, i.e. it is deterministic: for any \\(t_1, t_2\\), if \\([t_1] \\approx t'_1 \\) and \\([t_2] \\approx t'_2\\) then \\(t'_1 = t'_2\\).\n\n\\textbf{Proof.} We show by mutual induction on a derivation that \\([A \\Rightarrow B] \\approx x\\) is a partial function as well from pairs of \\(\\text{MLTT}_{\\text{coe}}\\) types to either \\(\\ast\\) or a \\(\\text{MLTT}_{\\text{map}}\\) term. In the key case \\(\\text{TslCoeNE}\\), note that the reduction relation \\(\\approx\\) is deterministic as well, so we can conclude by induction hypothesis. All other cases are immediate or simple applications of the inductive hypothesis, using the fact that at each step, at most one rule apply.\n\n\\textbf{Lemma C.7 (Stability of Translation by Weakening).} If \\(\\rho\\) is a substitution that maps variables to variables then \\([t][\\rho] = [t[\\rho]]\\).\n\n\\textbf{Proof.} Immediate by induction on \\(t\\), the only case interesting case being the translation of variables, with a similar lemma for \\([A \\Rightarrow B] \\approx x\\) using that neutrals are preserved.\n\n\\textbf{Lemma C.8 (Well-typed Terms Translate).} If \\(\\Gamma \\vdash_{\\text{coe}} t : A\\) then \\([\\Gamma]_\\downarrow, [A]_\\downarrow\\) and \\([t]_\\downarrow\\).\n\n\\textbf{Proof.} We prove by a straightforward mutual induction on an algorithmic typing derivation that:\n\n- If \\(\\Gamma \\vdash_{\\text{coe}} \\Gamma\\) then \\([\\Gamma]_\\downarrow;\\)\n- If \\(\\Gamma \\vdash_{\\text{coe}} A \\triangleright \\) and \\([\\Gamma]_\\downarrow\\) then \\([A]_\\downarrow;\\)\n- If \\(\\Gamma \\vdash_{\\text{coe}} t \\triangleright A\\) and \\([\\Gamma]_\\downarrow\\) then \\([t]_\\downarrow;\\)\n- If \\(\\Gamma \\vdash_{\\text{coe}} t \\triangleright A\\) and \\([\\Gamma]_\\downarrow\\) then \\([t]_\\downarrow;\\)\n- If \\(\\Gamma \\vdash_{\\text{coe}} A \\triangleright B\\) or \\(\\Gamma \\vdash_{\\text{coe}} A \\triangleright h B \\triangleright\\) then there exists \\(x\\) such that \\([A \\Rightarrow B] \\approx x\\).\n\n\\textbf{Lemma C.9 (Identity Coercions).} If \\(\\Gamma \\vdash_{\\text{coe}} A \\equiv B \\triangleright or \\Gamma \\vdash_{\\text{coe}} A \\equiv h B \\triangleright\\) then \\([A \\Rightarrow B] \\equiv \\ast\\).\n\n\\textbf{Proof.} Straightforward mutual induction on the bidirectional conversion derivation.\n\n\\textbf{Lemma C.10 (Stability of Translation by Substitution).} If \\(\\Gamma \\vdash_{\\text{coe}} t : A\\) and \\(\\Delta \\vdash_{\\text{coe}} \\sigma : \\Gamma\\) then \\([t][\\sigma] = [t[\\sigma]]\\) and similarly for typing.\n\n\\textbf{Proof.} Straightforward mutual induction on the bidirectional conversion derivation.\n\n\\[ \\frac{[A \\Rightarrow B] \\approx \\ast \\quad \\text{then} \\quad [A[\\sigma] \\Rightarrow B[\\sigma]] \\approx \\ast;}{\\text{If }\\Gamma \\vdash_{\\text{coe}} A \\triangleright B \\triangleright, \\Delta \\vdash_{\\text{coe}} \\sigma : \\Gamma\\} \\]\nProof. Straightforward mutual induction on the bidirectional derivation. \\qed\n\n**Forward simulation.** Following the proof strategy employed for the equivalence between subsumptive and coercive subtyping, the next step would require to prove that the translation is a forward simulate, i.e. if $\\Gamma \\vdash_{\\text{coe}} t : A$ and $t \\leadsto^1 t'$ then $[t] \\leadsto^* [t']$. As stated, this lemma does not hold. Indeed, the rule $\\text{CoeCoe}$ leads to reductions of coercions with type annotations which may be convertible but not reduce correctly. We conjecture that a weaker version of the simulation with respect to conversion in $\\text{MLTT}_{\\text{map}}$ should hold, that is if $\\Gamma \\vdash_{\\text{coe}} t : A$ and $t \\leadsto^1 t'$ then $[\\Gamma] \\vdash_{\\text{map}} [t] \\cong [t'] : [A]$. Such statement should be proved mutually with other properties stating that the translation preserves typing, as follows.\n\n**Conjecture C.11 (Translation preserves typing).**\n\n1. If $\\Gamma \\vdash_{\\text{coe}} t : A$ then $\\Gamma \\vdash_{\\text{map}} [t] : [A]$\n2. If $\\Gamma \\vdash_{\\text{coe}} A \\rightarrow B$ then $\\Gamma \\vdash_{\\text{map}} [A] \\cong [B]$\n3. If $\\Gamma \\vdash_{\\text{coe}} t : A \\rightarrow B$ then $\\Gamma \\vdash_{\\text{map}} f : [A] \\rightarrow [B]$\n\nPreservation of typing, together with catch up lemmas, and a backward simulation lemma, would then allow to lift bidirectional conversion derivations in $\\text{MLTT}_{\\text{map}}$, between the translation of terms from $\\text{MLTT}_{\\text{coe}}$. The use of bidirectional conversion is essential here to remain at each step within the translation of $\\text{MLTT}_{\\text{coe}}$ terms.\n\n**Conjecture C.12 (Embedding).** $[\\cdot]$ embeds $\\text{MLTT}_{\\text{coe}}$ into $\\text{MLTT}_{\\text{map}}$: well-typed $\\text{MLTT}_{\\text{coe}}$ terms translate to well-typed $\\text{MLTT}_{\\text{map}}$ terms, preserving and reflecting conversion."}}},{"rowIdx":291,"cells":{"id":{"kind":"string","value":"342e89f464ce5eaf8b7a63945a0cfae19bdfb2e2"},"text":{"kind":"string","value":"Software Fault Tolerance in Distributed Systems\nUsing Controlled Re-execution\n\nby\n\nAshis Tarafdar, B.Tech., M.S.\n\nDissertation\nPresented to the Faculty of the Graduate School of\nThe University of Texas at Austin\nin Partial Fulfillment\nof the Requirements\nfor the Degree of\n\nDoctor of Philosophy\n\nThe University of Texas at Austin\nAugust 2000\nSoftware Fault Tolerance in Distributed Systems\nUsing Controlled Re-execution\n\nApproved by\nDissertation Committee:\nTo my parents\nI consider myself to have been an extremely fortunate Ph.D. student in having Vijay Garg as my Ph.D. supervisor. It is impossible to fully express the many ways in which he has helped to make my Ph.D. experience a fulfilling and enjoyable phase of my life. He has been a constant source of inspiration, encouragement, and guidance in my research work and, thanks to him, I have been able to freely explore new ideas and work on what is fun. Moreover, he has been a friend, encouraging me in my non-Ph.D. related endeavours as well.\n\nThis dissertation has been shaped by discussions that I have had at various times with fellow students. I am indebted to Rajmohan Rajaraman and Kedar Namjoshi for discussions early in my Ph.D., which inspired me to follow up on my early ideas. Sriram Rao and Om Damani have always been there for me whenever I needed someone to bounce my ideas off of. Neeraj Mittal has helped me at various times by reviewing my papers and providing me with valuable criticism that has greatly improved my work. I am also grateful to Sandip Ray who has helped me by providing a critical ear during the final stages of my dissertation through which I learned the lesson of “not claiming too much”.\n\nMy committee members, Mohamed Gouda, Harrick Vin, Lorenzo Alvisi, Craig Chase, and Keith Marzullo, have also helped to shape my Ph.D. into its current form through their valuable comments and criticisms. Their varied expertise has provided me with different perspectives from which to re-evaluate my work.\nI am grateful to my friends in Austin for making my Ph.D. a very enjoyable experience. My ever-cheerful office-mates, Seldron Geziben and Sandip Ray, have helped to make my working environment not seem like one. Fun evenings, weekend trips, late-night discussions, intense gym workouts are but some of the memorable experiences that I have variously shared with Nandan Nayampally, Om Damani, Seema Damani, Landy Haile, Sriram Rao, Vivek Nagaraj, Elizabeth Tolley, Shalu Srinivasan, Meghan Lessor, Paul Lessor, Tyrell Williams, Noelle Hairston, Madhukar Korupolu, Tushar Parikh, Rajmohan Rajaraman, Pawan Goyal, Prashant Shenoy, Mukesh Khare, Kedar Namjoshi, Anuj Gosalia, Aamir Nawaz, Tarun Anand, and C. Bala Kumar.\n\nThe biggest credit goes to my family for their love and support. My late father, Sankar Tarafdar, an astrophysicist, inspired my interest in research from an early age. My mother, Anima Tarafdar, has kept me going by her never-ending confidence in me. My brother, Shantanu Tarafdar, has helped me with practical advice at various stages. My other brother, Soumen Tarafdar, has helped to keep me smiling through the hard times. Without my family, this dissertation would never have been written.\n\nASHIS TARAFDAR\n\nThe University of Texas at Austin\nAugust 2000\nDistributed applications are particularly vulnerable to synchronization faults. An important approach to tolerating synchronization faults is rollback recovery, which involves restoring a previous state and re-executing. Existing rollback recovery methods depend on chance and cannot guarantee that synchronization faults do not recur during re-execution. We propose a new rollback recovery method, controlled re-execution, based on selectively adding synchronizations during re-execution to ensure that synchronization faults do not recur. The controlled re-execution method gives rise to three interesting questions: How do we determine the synchronizations that ensure a safe re-execution? How do we monitor an application to detect faulty global conditions? How well does controlled re-execution perform in practice?\n\nThe first part of the dissertation addresses the predicate control problem which takes a computation and a global property and adds synchronizations to the computation to maintain the property. We design efficient algorithms to solve the problem for many useful predicates, including disjunctive predicates and various types of mutual exclusion predicates. These predicates correspond to commonly encountered synchronization faults such as races.\nThe second part of the dissertation investigates the *predicate detection* problem which involves determining whether a global property occurs in a computation. We address the problem for the useful class of conjunctive predicates and in the context of an *extended* model of computation that allows improved predicate detection over the conventional model. We show that, in general, the problem is NP-Complete. However, an efficient solution is demonstrated for the useful cases of *receive-ordered* and *send-ordered* computations. Further, this solution can be used to achieve an improved, though exponential, solution for the general problem.\n\nThe third part of the dissertation involves an experimental study of the controlled re-execution method. We evaluate the controlled re-execution method in tolerating race faults and find that the extra tracing costs imposed are within tolerable limits and that it greatly enhanced the likelihood of recovery. We conclude that controlled re-execution is an effective and desirable method for tolerating races in long-running non-interactive distributed applications.\n## Contents\n\nAcknowledgments v \nAbstract vii \n\n### Chapter 1 Introduction 1 \n1.1 The Predicate Control Problem 5 \n1.2 The Predicate Detection Problem 8 \n1.3 Controlled Re-execution: An Experimental Study 11 \n1.4 Summary 12 \n1.5 Overview of the Dissertation 13 \n\n### Chapter 2 Model 14 \n2.1 Computations 14 \n2.2 Cuts 16 \n2.3 Predicates 17 \n2.4 Consistent Cuts 18 \n2.5 More on Consistent Cuts 19 \n2.6 Runs 22 \n2.7 Interval Graphs 23 \n\n### Chapter 3 The Predicate Control Problem 26 \n3.1 Overview 26 \n3.2 Problem Statement 28 \n\nix\nDistributed applications are difficult to write correctly. An important reason is that, in addition to the usual software faults, distributed applications suffer from synchronization faults such as race conditions. Such synchronization faults are particularly hard to detect during testing and, therefore, are responsible for a significant fraction of application failures [IL95]. As a result of these difficulties many critical software packages are not available in distributed form, in spite of potential performance benefits [Pan95].\n\nSoftware fault tolerance \\footnote{We use software fault tolerance to denote software-fault tolerance (the tolerance of software faults) and not software fault-tolerance (tolerance techniques implemented in software).} offers a complementary approach to dealing with software faults. Whereas fault prevention techniques are applied during the design, implementation, and testing phases of the software cycle to prevent faults from persisting in the operation phase, fault tolerance techniques are applied during the operation phase to minimize the damage caused by those faults that do persist.\n\nA software fault tolerance system relates to an application in two ways: as an observer during normal operation, and as a controller during failure recovery. The observation aspect of the fault tolerance system involves monitoring the application for the early detection of a failure. Failure detection depends on the type of failure involved. For example, heartbeat protocols aim at detecting crash failures, and\ndata integrity checks aim at detecting data corruption failures. On the other hand, the control functionality of a fault tolerance system has usually involved general-purpose strategies, such as failing over to a backup process or restarting from a previously stored checkpoint. One of our aims is to show that, using information about the failure and its causes, specialized control schemes can take more effective corrective action than general-purpose schemes. In particular, our focus will be on failures arising from synchronization faults, an important category in the context of distributed applications.\n\nA particular execution of an application is determined by three factors: the application program, the data provided as input, and the environment in which the program is executed. This corresponds to three approaches to tolerating software faults in a given execution. The design diversity approach [AC77, Ran75] uses redundant modules that are independently developed so that a failed execution could be recovered by resorting to an alternative module. The main shortcomings of this approach are the high cost in programming effort and the critical assumption that the same fault will not appear in independently developed implementations for the same function. The data diversity approach [AK88] uses application-specific techniques to re-express the input data in an attempt to provide an alternative failure-free execution. However, this technique is only applicable in cases for which\nthe re-expression of input data is possible and such a re-expression can help bypass a fault. Our focus is on the third approach, *environment diversity* [WHF+97], which rolls back the application to a previous state and re-executes so that changes in environmental conditions may induce a distinct and failure-free re-execution. This approach assumes that a fault may not recur each time an application is re-executed with the same inputs. It has been observed in several studies [Ada84, Cri91, GR93, IL95] that many software faults exhibit such behavior. In particular, synchronization faults belong to this class since they are sensitive to an environmental determinant – the relative timing between processes.\n\nThe environment diversity approach to software fault tolerance is an application of the *rollback recovery* method [EAWJ99] to software faults. Rollback recovery of a failed application occurs in three distinct phases:\n\n- **Detection**: The detection of failures is more difficult in distributed applications because of the challenge of detecting global conditions on distributed state. While it is sometimes sufficient to check for local conditions on a single process, early detection of failures often requires the detection of global conditions. For example, a load imbalance across the distributed application could be an early indicator of potential failures. In particular, detecting synchronization failures, such as races, involves global rather than local detection. The problem of detecting a global condition in a distributed execution has been formalized as the *predicate detection problem* [BM93, Gar96].\n\nPredicate detection is usually specified in a model of distributed computation that consists of a partially ordered set of events with each process viewed as a sequence of events [Lam78]. However, this model causes “false causality” [ACG93, CS93, SBN+97], causing some global states that satisfy the predicate to go undetected. An extended model has been proposed [ACG93] to correct this problem by viewing a process as a partially ordered set of events. In\nChapter 4 of this dissertation, we investigate the predicate detection problem in the framework of this extended model of a distributed computation.\n\n- **Restoration:** The problem of restoring a failed distributed application to a previous state has been the central focus in studies of rollback recovery [EAWJ99]. While this dissertation does not deal with this problem, we briefly note the implications of software faults in the context of general-purpose restoration techniques. It has been observed [CC98b] that failures arising from software faults are not usually *fail-stop*, that is, faulty data may have been written to stable storage before a failure is detected. Therefore, instead of focusing on restoring the *latest* restorable state, the focus is on the important problem of determining *which* state to restore. The interested reader is referred to [WHF+97] and [CC98a] for interesting and extensive studies of this issue.\n\n- **Re-execution:** The re-execution phase involves re-executing the application from a restored state to avoid a recurrence of a failure. In most rollback recovery techniques, this consists of simply restarting the application from the restored state. This method is effective under the assumption that failures are unrelated. While in some failures, such as power outages, this assumption may hold, failures due to software faults are usually not unrelated. Therefore, it is desirable to determine re-execution methods that explicitly attempt to *control* the application during re-execution so as to bypass software faults and avoid the recurrence of a failure.\n\nIn this dissertation, our focus is on the class of synchronization faults. These faults are known to be an important source of failures [IL95]. In the context of synchronization faults, we propose a novel re-execution method, *controlled re-execution*, that uses trace information to appropriately synchronize during re-execution to prevent a recurrence of a synchronization failure. Un-\nlike re-execution methods that depend on chance, controlled re-execution can guarantee in advance that the re-execution will be failure-free. In Chapter 5, we experimentally evaluate the controlled re-execution method in the case of race faults, an important subset of synchronization faults. The controlled re-execution method is based on a general problem, the *predicate control problem*, which involves controlling a given computation by adding synchronizations such that a given global property is maintained. In Chapter 3, we formulate and investigate the predicate control problem.\n\nTo summarize in a different order, our goals are:\n\n- To formulate and investigate the predicate control problem.\n- To investigate the predicate detection problem in a general model.\n- To specify and experimentally evaluate controlled re-execution.\n\nIn the next three sections, we give an introduction to our work towards each of these goals. This is followed by a short summary and an overview of the dissertation.\n\n### 1.1 The Predicate Control Problem\n\nInformally, the predicate control problem is to determine how to add synchronizations to a distributed computation so that it maintains a global predicate (property). As an example, consider the computation shown in Figure 1.2(a) with three processes, P1, P2, and P3. The processes have synchronized by sending messages to one another. Suppose the stated global predicate is the mutual exclusion predicate, so that no two processes are to be in critical sections (labeled CS1, CS2, CS3, and CS4) at the same time. Clearly, the given computation does not maintain mutual exclusion at all times. Figure 1.2(b) shows the same computation with added synchronizations that ensure that mutual exclusion is maintained at all times. We call\nsuch a computation a “controlling computation”. The main difficulty in determining such a controlling computation lies in adding the synchronizations in such a manner as to maintain the given property without causing deadlocks with the existing synchronizations.\n\nThe predicate control problem is given the input computation \\textit{a priori} whereas conventional synchronization problems are given the computation on-line. In this respect, the predicate control problem is the \\textit{off-line variant} of on-line synchronization problems. For example, the mutual exclusion problem has been widely studied in its on-line version [Ray86] but not in its off-line version – mutual exclusion predicate control\\footnote{Note that we do not use the term “off-line” to imply that predicate control must be applied \\textit{before} run-time. It merely means that whenever it is applied, it is given the computation \\textit{a priori}.} It is to be expected that, since the computation is not known before-hand, the on-line synchronization problems are harder to solve than their off-line counterparts. For example, in on-line mutual exclusion, one cannot, in general, avoid deadlocks without making some assumptions (e.g. critical sections do not block). Thus, on-line mutual exclusion is impossible to solve. To understand why this is true, consider the scenario in Figure 1.2(a). Any on-line algorithm, being unaware of the future computation, would have a symmetric choice of entering CS1 or CS2 first. If CS2 is entered first, it would result in a deadlock. An off-line algorithm, being aware of the future computation, could make the correct decision to enter CS1 first and add a synchronization from CS1 to CS2. Thus, while it is often impossible to synchronize on-line, it may be possible to synchronize off-line. Our aim in studying the predicate control problem, is to determine when it is possible to synchronize off-line and how efficiently this can be done.\n\nWhile the main focus in this dissertation is the software fault tolerance application, the predicate control problem has potential applications in other domains. An example application is distributed debugging in which a computation is often known \\textit{a priori} for the purpose of replaying. Applying predicate control in this\ncontext would allow the programmer to observe the replayed computation under various constraints, facilitating the localization of software faults. Another potential application is off-line scheduling, in which a set of parallel tasks are to be executed with inter-task dependencies known before-hand. Predicate control allows automatic scheduling of the tasks to satisfy a given global constraint.\n\n**Contributions**\n\nSince, in its full generality the predicate control problem deals with *any* predicates, it is not surprising that we find the problem to be NP-Complete. It is, therefore, important to study the predicate control problem in the context of specific and useful predicates.\n\nThe first type of predicates that we consider is the class of “disjunctive predicates”. Intuitively, these predicates state that at least one property must be maintained at all times or, in other words, that a bad combination of events does not occur. Some examples of these predicates are: “at least one server is available” and “at least one process has a token”. We determine the necessary and sufficient conditions under which predicate control can be solved for disjunctive predicates.\n\nWe then describe an $O(np)$ algorithm to solve disjunctive predicate control, when possible, where $n$ is the number of processes and $p$ is bounded by the number of events in the computation.\nThe next important class of predicates are “mutual exclusion predicates”. These are particularly important in software fault tolerance since they exactly correspond to bypassing races. (Note: we use the term “race” to denote concurrent accesses of a shared object. This is sometimes called a “data race” and is distinct from other types of races, especially message races and producer-consumer races). We determine the necessary and sufficient conditions for solving predicate control for the mutual exclusion predicate and describe an efficient algorithm. It is interesting that, though the algorithm is very different from the one for disjunctive predicate control, the complexity is similar – $O(np)$, where $p$ is the number of critical sections in the computation.\n\nThe mutual exclusion predicate has two important extensions: “readers writers predicates” and “independent mutual exclusion predicates”. Readers writers predicates correspond to mutual exclusion with the semantics of read and write critical sections. Independent mutual exclusion has the semantics of critical sections that have different types, where only critical sections of the same type are mutually exclusive. We determine the necessary and sufficient conditions for solving for readers writers predicates and construct an $O(np)$ algorithm that generalizes the algorithm for mutual exclusion. Unfortunately, we find that, for independent mutual exclusion predicates, predicate control is NP-Complete. However, we are able to solve it under certain conditions, using an algorithm similar to the one for readers writers predicates.\n\n1.2 The Predicate Detection Problem\n\nThe predicate detection problem [BM93, Gar96] is usually specified in a happened before model of distributed computation that consists of a partially ordered set of events with each process viewed as a sequence of events [Lam78]. Consider a happened-before model representation of a certain distributed computation shown\nin Figure 1.3(i). If mutual-exclusion violation is the predicate that we are trying to detect, it would not be detected because the message ensures that the two critical sections cannot occur at the same time. However, in reality, the message may have been fortuitous and may have induced false causality between the critical sections which leads to missing the violation of mutual exclusion. The sections of execution marked by intervals \\((a, b)\\) and \\((c, d)\\) may be “independent” (for example, independent threads). The scenario in Figure 1.3(i) is just one possible scheduling of events. Figure 1.3(ii) shows another scheduling in which mutual-exclusion would be violated.\n\nThe happened before model was extended \\([ACG93]\\) to a model that partially orders the events in a local process, allow events within a process to be independent. Figure 1.3(iii) shows such a model for the example. This representation models both of the previous schedulings. In general, there would be an exponential number of happened-before representations corresponding to a single representation in the new model. We refer to the new model as the extended model. Thus, the extended model reduces the false causality problem and allows better detection of predicates.\n\nWhile it is desirable to solve the predicate detection problem in the extended model, most of the algorithms for predicate detection have been framed in the hap-\npened before model. What, then, are the implications of solving predicate detection in the extended model?\n\nContributions\n\nWe focus on the important class of “conjunctive predicates” which can be solved efficiently in the happened-before model [GW94]. Conjunctive predicates are specified as conjunctions of local predicates. Thus, they express the combined occurrence of local events. Note that conjunctive predicates are the negations of disjunctive predicates. Some examples of these predicates are: “all servers are unavailable” and “no process has a token”.\n\nWe demonstrate that for general computations (in the extended model), the problem is NP-Complete. This is an indication of how using the extended model makes predicate detection a harder problem. However, for certain restricted, but useful, classes of general computations, the problem may be solved efficiently. These restricted classes correspond to computations that have either the receive events or the send events totally ordered, while allowing all other events to be partially ordered. Some natural programming styles produce computations that fall in these categories. Further, we can decompose a general computation into a set of general computations in these classes, to achieve an improved (though exponential) algorithm.\n\nIt is definitely harder to solve predicate detection in the extended model than in the happened-before model. However, even being able to solve predicate detection efficiently for a restricted class is a great improvement over the alternative of solving predicate detection on an exponential number of corresponding happened-before representations. In the worst case where the general computation does not have either totally ordered sends or totally ordered receives, we may decompose the problem into extended computations each of which belongs to one of these\nclasses and so efficiently solve for each such diagram. Even though this solution is exponential, it still achieves, in general, an exponential reduction as compared to considering all possible happened-before representations.\n\n1.3 Controlled Re-execution: An Experimental Study\n\nIn this study, we focus on long-running, non-interactive applications that communicate using messages and use a common network file system. Such applications are suitable for rollback recovery approaches. Typical examples of such applications are scientific programs and simulations. Further, we focus on a particular type of synchronization fault — “races”. A race occurs when two processes access a file concurrently. Consider an execution that has races, such as the execution shown in Figure 1.2(a) (viewing the file accesses as critical sections). Suppose that a rollback recovery approach is used so that a failure has been detected (the failure could be corrupted data on the file) and the application has been restored to a previous saved state. How should the processes be re-executed so as to avoid a recurrence of the failure?\n\nOne method, which we call “simple re-execution”, is to simply restart all the processes and allow them to execute freely [HK93, WHF+97]. This method relies on chance to change the relative timing between the processes in such a way that races do not recur in the re-execution. Another method, “locked re-execution”, involves locking all the file accesses during re-execution. This method eliminates races but introduces the possibility of deadlocks. Again, it depends on chance to re-execute safely. The “controlled re-execution” method uses traced information from the previous execution as input to the predicate control algorithm (for mutual exclusion predicates). During re-execution, extra synchronization messages are used to enforce the synchronizations added by the predicate control algorithm. This method does not rely on chance, and can give a guarantee that there are neither\nraces nor deadlocks during re-execution. However, this benefit comes at the cost of tracing the computation during normal execution.\n\nIn order to make an evaluation of controlled re-execution, we require a quantitative evaluation of: (1) how much of a disadvantage is posed by the tracing cost, and (2) how much of an advantage is involved in the improved recovery. This is the objective of our experimental study.\n\nContributions\n\nIn our experiments, we used synthetic applications so that we could study controlled re-execution under different parameters. In particular, there were two parameters that are important: the frequency of communication and the frequency of file accesses. Our experiments demonstrate that the tracing overhead is less than 1% even for applications with relatively high communication and file access frequencies (with respect to parameters of real scientific applications). In order to check the relative likelihood of recovery, we executed applications that periodically have races and measured how long it takes before each of the three re-execution methods fails to tolerate races. We varied the applications for various values of communication and file access density. We found that controlled re-execution is significantly better than either locked re-execution or simple re-execution for tolerating races. Thus, since the tracing costs are within tolerable limits and the advantage in recovery is significant, we conclude that the controlled re-execution method is effective and desirable for tolerating races in long-running, non-interactive scientific applications. Further, this case study serves as an indicator for the potential advantages of using controlled re-execution for other types of synchronization faults and in other application domains.\n1.4 Summary\n\n- **Predicate Control:** By designing efficient algorithms for solving the predicate control problem for some important classes of predicates, we make a first step in determining the feasibility of off-line synchronization.\n\n- **Predicate Detection:** Towards understanding the implications of the extended model on the predicate detection problem, we study and design algorithms for the detection of conjunctive predicates.\n\n- **Controlled Re-execution:** As a case study in evaluating controlled re-execution, we demonstrate that it is a desirable and effective method for tolerating race faults in long-running, non-interactive distributed applications.\n\n1.5 Overview of the Dissertation\n\nThe remainder of this dissertation is organized as follows. In Chapter 2, we define our model. Next, we have the three main chapters of the dissertation: Chapter 3 discusses our study of the predicate control problem, Chapter 4 investigates the predicate detection problem, and Chapter 5 describes our experimental evaluation of the controlled re-execution method. In Chapter 6, we give a summary of related work. Finally, we draw conclusions and describe future directions in Chapter 7.\nChapter 2\n\nModel\n\nThe predicate control problem and the predicate detection problem are based on a model of distributed computations and concepts related to distributed computations. Our model is similar to the happened before model [Lam78], described in more detail in [BM93, Gar96] and extended in [ACG93]. However, some of the concepts presented are unique to our requirements, and we will make special note of this where appropriate.\n\n2.1 Computations\n\nSince we are going to be concerned mainly with distributed computations, we drop the qualifier distributed and call them simply computations.\n\n- \\((\\text{computation})\\): A computation is a tuple \\(\\langle E_1, E_2, \\cdots E_n, \\rightarrow \\rangle\\) where the \\(E_i\\)'s are disjoint finite sets of “events” and \\(\\rightarrow\\) (precedes) is an irreflexive partial order on \\(E = \\bigcup_i E_i\\). We abbreviate \\(\\langle E_1, E_2, \\cdots E_n, \\rightarrow \\rangle\\) to \\(\\langle E, \\rightarrow \\rangle\\) with the understanding that \\(n\\) is to be always used to represent the size of the partition of \\(E\\) into \\(E_1, E_2, \\cdots E_n\\).\n\nInformally, each \\(E_i\\) represents a process, and the partial order \\(\\rightarrow\\) represents a partial ordering of events such that \\(e \\rightarrow f\\) means that the event \\(e\\) may have directly or indirectly caused the event \\(f\\). We say \\(e\\) “causally precedes” \\(f\\). Note that, in\ngeneral, the $\\rightarrow$ relation is merely an approximation of causality. An example of approximating causality to obtain a $\\rightarrow$ relation on events is given by the happened before model [Lam78], in which $\\rightarrow$ is defined as the smallest relation satisfying the following: (1) If $e$ and $f$ are events in the same process and $e$ comes before $f$ according to the local process clock, then $e \\rightarrow f$, (2) If $e$ is the send event of a message and $f$ is the receive event for the same message by another process, then $e \\rightarrow f$, and (3) If $e \\rightarrow f$ and $f \\rightarrow g$, then $e \\rightarrow g$. Note that this approximation causes the events in a process to be totally ordered. We define such computations as follows:\n\n- $\\langle \\rightarrow_i \\rangle$: Let $\\rightarrow_i$ denote the relation $\\rightarrow$ restricted to the set of events $E_i$.\n\n- $\\langle$ locally ordered computations $\\rangle$: A computation $\\langle E, \\rightarrow \\rangle$ is a locally ordered computation if, for each $i$, $\\rightarrow_i$ is a total order.\n\nFor now, we assume that all computations are locally ordered. In Chapter 4, we will return to general computations and motivate the distinctions between the models.\n\nAnother special class of computations are runs, defined as:\n\n- $\\langle$ run $\\rangle$: A computation $\\langle E, \\rightarrow \\rangle$ is a run if $\\rightarrow$ is a total order.\n\nA run is an even weaker approximation of causality than locally ordered computations. A run corresponds to an interleaving of all the events in the distributed computation. Finally, we define some notation concerning computations:\n\n- $\\langle \\equiv \\rangle$: $(e \\equiv f) \\equiv (e = f) \\lor (e \\rightarrow f)$\n\n In a similar way, we represent a corresponding reflexive relation for any given relation, e.g.: $(e \\preceq f) \\equiv (e = f) \\lor (e \\prec f)$\n\n- $\\langle e.proc \\rangle$: $(e.proc = i) \\equiv (e \\in E_i)$\n\nInformally, $e.proc$ is the identifier for the process containing $e$. \n2.2 Cuts\n\n- $\\langle \\text{cut} \\rangle$ : A cut is a subset of $E$ containing at most one event from each $E_i$.\n\nA cut corresponds to the intuitive notion of a global state. Sometimes a cut has been defined to correspond to the notion of a history (all events preceding a global state). In such definitions, the frontier of a cut corresponds to our cut. Since, we will be dealing more frequently with the notion of a global state than a history, we formalize the notion of history in terms of global state rather than the other way around.\n\nIf a cut intersects a process at an event $e$, then the local state on that process corresponding to the cut is the one reached by executing event $e$. If the cut does not intersect a process, then the local state on that process corresponding to the cut is the initial state on that process. To represent an initial state explicitly, we augment our model with initialization events:\n\n- $\\langle \\perp_i \\rangle$ : Corresponding to each $E_i$ we define a special event $\\perp_i$ ($\\perp_i \\notin E$).\n- $\\langle \\perp \\rangle$ : Let $\\perp = \\bigcup_i \\{ \\perp_i \\}$.\n\nEach $\\perp_i$ corresponds to a special “dummy” event that initializes the state of process $E_i$. Note that $\\perp_i$ is not a real event. Introducing the dummy events, $\\perp$, allows a one-to-one correspondence between the informal notion of local states corresponding to a process $E_i$ and the formal notion of $E_i \\cup \\{ \\perp_i \\}$, in which an event corresponds to the local state that follows it. We next define a local ordering between events and dummy events:\n\n- $\\langle \\prec_i \\rangle$ : For each $i$, let $\\prec_i$ be the smallest relation on $E_i \\cup \\{ \\perp_i \\}$ such that:\n \\[\n \\forall e \\in E_i : \\perp_i \\prec_i e, \\text{ and } \\\\\n \\forall e, f \\in E_i : e \\rightarrow_i f \\Rightarrow e \\prec_i f.\n \\]\n\n- $\\langle \\prec \\rangle$ : Let $\\prec = \\bigcup_i \\prec_i$.\nThus, the $\\prec$ relation augments the $\\rightarrow_i$ relation by ordering the initialization event $\\bot_i$ before all events in $E_i$. Using the initialization events $\\bot$, we can now define, for any cut, a unique event_INITIALIZATION event corresponding to each process as:\n\n- $\\langle C[i] \\rangle$ : For a cut $C$, define $C[i] \\in E \\cup \\bot$ such that:\n \n $C[i] = e$, if $C \\cap E_i = \\{e\\}$, and \n \n $C[i] = \\bot_i$, if $C \\cap E_i = \\emptyset$.\n\nFinally, we define a relation $\\leq$ on cuts as follows:\n\n- $\\langle \\leq \\rangle$ : For two cuts $C_1$ and $C_2$ define a relation $\\leq$ as:\n\n $C_1 \\leq C_2 \\equiv \\forall i : C_1[i] \\preceq C_2[i]$\n\n### 2.3 Predicates\n\nPredicates represent the informal notion of properties on local or global states:\n\n- $\\langle$local predicate $\\rangle$ : A local predicate of an $E_i$ in a computation is a (polynomial-time computable) boolean function on $E_i \\cup \\{\\bot_i\\}$.\n\n- $\\langle$global predicate $\\rangle$ : A global predicate of a computation $\\langle E, \\rightarrow \\rangle$ is a (polynomial-time computable) boolean function on the set of cuts of the computation.\n\nLocal predicates are used to define properties local to a process, such as: whether the process is in a critical section, whether the process has a token, or whether, for a process variable $x$, $x < 4$. Global predicates define properties across multiple processes, such as: whether two processes are in critical sections, whether at least one process has a token, or whether, for variables $x$ and $y$ on different processes, $(x < 4) \\land (y < 3)$. We use predicate instead of global predicate, when the meaning is clear from the context.\n2.4 Consistent Cuts\n\nAll cuts in a computation do not correspond to global states that may have happened in the computation. To see why this is true, consider the set of events which causally precede any event in a given cut, which we call the causal past of the cut:\n\n- \\( (G.past) \\): The causal past of a set of events \\( G \\subseteq E \\) in a computation \\( \\langle E, \\rightarrow \\rangle \\) is \\( G.past = \\{ e \\in E : \\exists f \\in G : e \\rightarrow f \\} \\)\n\nSuppose there is an event \\( e \\) in the causal past of a cut \\( C \\) and suppose \\( e \\) has not yet occurred in the global state corresponding to \\( C \\). Since a cause must always precede the effect, the cut \\( C \\) does not represent a global state that may have happened. Cuts which represent global states that may have happened are called consistent global states. The reason we say that a consistent global state may have happened is that its occurrence depends on the particular interleaving of the partially ordered set of events that occurred in real time.\n\n- \\( (\\text{consistent cut}) \\): A cut \\( C \\) is consistent if \\( \\forall e \\in C.past : C[e.proc] \\not\\prec e \\).\n\nNote that, in the case of a locally ordered computation, \\( C[e.proc] \\not\\prec e \\) is the same as \\( e \\preceq C[e.proc] \\).\n\nWe now prove two useful results about consistent cuts. The first one allows us to extend a single event to a consistent cut that contains it. This corresponds to the intuition that the local state following the event must have occurred at some time. Therefore, there must be some consistent cut (global state that may have happened) that contains it.\n\n**Lemma 1** (Extensibility) Let \\( \\mathcal{C} \\) be the set of consistent cuts of a computation \\( \\langle E, \\rightarrow \\rangle \\), then:\n\n\\[ \\forall e \\in E : \\exists C \\in \\mathcal{C} : e \\in C \\]\n\n**Proof:** Let \\( e \\) be an event in \\( E \\). Consider a maximal (w.r.t. \\( \\preceq \\)) cut \\( C \\) contained in \\( \\{e\\}.past \\). Since \\( C \\) is maximal, it must contain \\( e \\). Consider any event \\( f \\) in \\( C.past \\).\nSince $C$ is contained in $\\{e\\}.past$, $f$ is also in $\\{e\\}.past$. Suppose $C[f.proc] \\prec f$. Then since $f$ is in $\\{e\\}.past$, $C$ is not maximal and we have a contradiction. Therefore, $C[f.proc] \\not\\prec f$. So, $C$ is consistent. □\n\nThe next result tells us that a cut that is consistent in a computation is also consistent in any computation that is less strict (that is, the partial ordering of events in the latter is less strict than the first).\n\n**Lemma 2** If $\\langle E, \\rightarrow' \\rangle$ and $\\langle E, \\rightarrow \\rangle$ are computations such that $\\rightarrow \\subseteq \\rightarrow'$, then any cut that is consistent in $\\langle E, \\rightarrow' \\rangle$ is also consistent in $\\langle E, \\rightarrow \\rangle$.\n\n**Proof:** Let $C$ be a consistent cut in $\\langle E, \\rightarrow' \\rangle$. Let $e$ be any event in the causal past of $C$ with respect to $\\rightarrow$. Since $\\rightarrow \\subseteq \\rightarrow'$, $e$ is also in the causal past of $C$ with respect to $\\rightarrow'$. Therefore, $C[e.proc] \\not\\prec e$. So, $C$ is consistent in $\\langle E, \\rightarrow \\rangle$. □\n\n### 2.5 More on Consistent Cuts\n\nThis section presents definitions and results related to consistent cuts that only apply to locally ordered computations. In case of locally ordered computations, every event has a unique next event and a unique previous event:\n\n- $\\langle e.next \\rangle$: For $e \\in E \\cup \\{\\bot_i\\}$, $e.next$ denotes the immediate successor to $e$ in the total order defined by the $\\prec_i$ relation. If no successor exists, $e.next = null$, where null does not belong to $E \\cup \\bot$.\n\n- $\\langle e.prev \\rangle$: For $e \\in E \\cup \\{\\bot_i\\}$, $e.prev$ denotes the immediate predecessor to $e$ in the total order defined by the $\\prec_i$ relation. If no predecessor exists, $e.prev = null$, where null does not belong to $E \\cup \\bot$.\n\nNote that null (not an event) should not be confused with $\\bot_i$ (the initialization event). In fact, $\\bot_i.prev = null$.\n\nThe following result shows us an alternative way of proving that a cut is consistent.\nLemma 3 In a computation $\\langle E,\\rightarrow \\rangle$:\n\na cut $C$ is consistent $\\equiv \\forall i,j : C[i].next, C[j] \\in E : C[i].next \\not\\rightarrow C[j]$\n\nProof: (1) Suppose $C$ is consistent. We show by contradiction that:\n\n\\[ \\forall i,j : C[i].next, C[j] \\in E : C[i].next \\not\\rightarrow C[j]. \\]\n\nSuppose there is an $i$ and $j$ such that $C[i].next \\rightarrow C[j]$. Then $C[i].next \\in C.past$. But $C[i] \\prec C[i].next$ contradicting the consistency of $C$.\n\n(2) Suppose $C$ is not consistent. We prove by contradiction that:\n\n\\[ \\exists i,j : C[i].next, C[j] \\in E : C[i].next \\rightarrow C[j]. \\]\n\nSince $C$ is not consistent, there is an event, say $e$, such that $e \\in C.past$ and $C[e.proc] \\prec e$. Therefore, $C[e.proc].next \\preceq e$. By transitivity, $C[e.proc].next \\in C.past$. Therefore, $\\exists j : C[j] \\in E : C[e.proc].next \\rightarrow C[j]$. □\n\nThe next is a well-known result about the set of consistent cuts in a computation [Mat89].\n\nLemma 4 The set of consistent cuts of a computation forms a lattice under $\\leq$.\n\nProof: Let $C_1$ and $C_2$ be any two consistent cuts. Let $C$ be a consistent cut defined such that for each $i$, $C[i]$ is the minimum of $C_1[i]$ and $C_2[i]$. Clearly, this ensures that for any lower bound $C'$ of $C_1$ and $C_2$, $C' \\leq C$. Therefore, to show that $C$ is the greatest lower bound of $C_1$ and $C_2$, it remains to show that $C$ is consistent.\n\nSuppose $C$ is not consistent. Using Lemma 3, there must exist $i$ and $j$ such that $C[i].next \\rightarrow C[j]$. Without loss of generality, suppose $C[i] = C_1[i]$. Clearly, $C[j] \\neq C_1[j]$ since, otherwise, the consistency of $C_1$ is contradicted. Therefore, $C[j] = C_2[j]$. By the definition of $C$, $C_2[j] \\preceq C_1[j]$. Therefore, by transitivity, $C_1[i].next \\rightarrow C_1[j]$. This contradicts the consistency of $C_1$. This shows that $C$ is consistent and, therefore, $C$ is the greatest lower bound of $C_1$ and $C_2$.\n\nIn a similar way, we can demonstrate the existence of the least upper bound of $C_1$ and $C_2$. □\nIt can further be verified that the lattice is a distributive one. This result allows us to define the consistent cut that is the greatest lower bound or least upper bound of a non-empty set of consistent cuts. Consider the set $A$ of consistent cuts containing an event $e$. Lemma 1 tells us that $A$ is non-empty. By Lemma 4, there is a consistent cut that is the greatest lower bound of $A$. Further, it is easy to check that this consistent cut contains $e$. Therefore, we can define the following:\n\n- $\\langle lcc(e) \\rangle$: For each event $e$ in a computation, let $lcc(e)$ denote the least consistent cut that contains $e$.\n\nInformally, $lcc(e)$ represents the earliest global state for which $e$ has occurred. It is verifiable that $lcc(e)$ is the maximum cut contained in $\\{e\\}.past$ (similar to the proof of Lemma 1). Therefore, we have:\n\n**Lemma 5** $lcc(e).past = \\{e\\}.past$.\n\nThis result shows us that $lcc(e)$, which corresponds to the earliest global state for which $e$ has occurred, is formed by the “frontier” of the causal past of $e$ (that is, the set of last events per process in the causal past of $e$).\n\nThere can be only one global state that occurs immediately before $lcc(e)$ and it is represented by the following cut:\n\n- $\\langle lccprev(e) \\rangle$: For each event $e$ in a computation, let $lcc-prev(e)$ denote the cut formed from $lcc(e)$ by deleting $e$, and then by adding $e.prev$ if $e.prev \\notin \\bot$.\n\nTo show that $lcc-prev(e)$ is indeed the global state that occurs immediately before $lcc(e)$, we must show that it is consistent.\n\n**Lemma 6** For any event $e$ in a computation, $lcc-prev(e)$ is consistent.\n\n**Proof:** We prove by contradiction. Let $f$ be any event in $lcc-prev(e).past$ such that $lcc-prev(e)[f.\\text{proc}] \\prec f$. Clearly, by the definition of $lcc-prev(e)$ we have $f.\\text{proc} \\neq e.\\text{proc}$.\nTherefore, \\( lcc-prev(e)[f,proc] = lcc(e)[f,proc] \\) (by the defn. of \\( lcc-prev(e) \\)).\nFurther, since \\( f \\) is in \\( lcc-prev(e).past \\), it is also in \\( lcc(e).past \\). This contradicts the consistency of \\( lcc(e) \\).\n\n2.6 Runs\n\nIn this section we state some definitions and results specific to runs. In the case of a run, we can make a stronger assertion about the set of consistent cuts than the fact that it forms a lattice (Lemma 4):\n\n**Lemma 7** The set of consistent cuts of a run is totally ordered under \\( \\leq \\).\n\n**Proof:** We prove by contradiction. Suppose that \\( C_1 \\) and \\( C_2 \\) are two consistent cuts in a computation \\( (E, \\rightarrow) \\) such that \\( C_1 \\not\\leq C_2 \\) and \\( C_2 \\not\\leq C_1 \\). Therefore, there must exist \\( i \\) and \\( j \\) such that \\( C_1[i] \\prec C_2[i] \\) and \\( C_2[j] \\prec C_1[j] \\). Since \\( \\rightarrow \\) is a total order, without loss of generality, let \\( C_2[i] \\rightarrow C_1[j] \\). Therefore, \\( C_2[i] \\) is in \\( C_1.past \\) contradicting the consistency of \\( C_1 \\).\n\nThis corresponds to the intuition that since the events in a run are totally ordered, the global states must also occur in sequence. Further, for any global state that occurs, there is a unique event that can lead up to it. This unique event is defined as:\n\n- \\( \\langle \\text{ge}(C) \\rangle \\) : For each consistent cut \\( C \\) of a run \\( (E, \\rightarrow) \\), such that \\( C \\neq \\emptyset \\), let the greatest event in \\( C \\) with respect to \\( \\rightarrow \\) be denoted by \\( \\text{ge}(C) \\).\n\nThe next result shows us that there is a one-to-one correspondence between the consistent cuts (excluding \\( \\emptyset \\)) and the events in a run.\n\n**Lemma 8** In a given run, \\( \\text{ge} \\) and \\( lcc \\) are inverses of each other.\n\n**Proof:** Consider a computation, \\( (E, \\rightarrow) \\). It follows directly from Lemma 5 that \\( \\forall e \\in E : \\text{ge}(lcc(e)) = e \\). Therefore, it remains to prove that \\( lcc(\\text{ge}(C)) = C \\),\nfor a consistent cut $C \\neq \\emptyset$. We prove by contradiction. Suppose $lcc(ge(C)) \\neq C$, then there is an $i$ such that $lcc(ge(C))[i] \\neq C[i]$. By the definition of $lcc$, we must have: $lcc(ge(C))[i] \\prec C[i]$. By the definition of $ge$, $C[i] \\rightarrow ge(C)$ and so, $C[i] \\in lcc(ge(C)).past$. This contradicts the consistency of $lcc(ge(C))$. □\n\n2.7 Interval Graphs\n\nLet $\\langle E, \\rightarrow \\rangle$ be a locally ordered computation and let $\\alpha_1, \\alpha_2, \\cdots \\alpha_n$ be a set of local predicates. Each local predicate $\\alpha_i$ defines a partition of the sequence of events $\\langle E_i \\cup \\{\\bot_i\\}, \\prec_i \\rangle$ into “intervals” in which $\\alpha_i$ is alternately true and false. We define this formally as:\n\n- **interval**: An interval $I$ is a non-empty subset of an $E_i \\cup \\{\\bot_i\\}$ corresponding to a maximal subsequence in the sequence of events in $\\langle E_i \\cup \\{\\bot_i\\}, \\prec_i \\rangle$, such that all events in $I$ have the same value for $\\alpha_i$.\n\nWe next introduce a few notations and definitions related to intervals.\n\n- **(I):** Let $I = \\bigcup_i I_i$.\n\n- **(I.proc):** $(I.proc = i) \\equiv (I \\subseteq (E_i \\cup \\{\\bot_i\\}))$\n\n- **(I.first):** For an interval $I$, $I.first$ denotes the minimum event in $I$ with respect to $\\prec_{I.proc}$.\n\n- **(I.last):** For an interval $I$, $I.last$ denotes the maximum event in $I$ with respect to $\\prec_{I.proc}$.\n\n- **($\\prec_i$ (for intervals)):** For any $i$, let the $\\prec_i$ relation on events apply to intervals as well, such that $I_1 \\prec_i I_2 \\equiv I_1.first \\prec_i I_2.first$. \n\n23\n• \\( \\langle I.\\text{next} \\rangle \\): \\( I.\\text{next} \\) denotes the immediate successor interval of interval \\( I \\) with respect to \\( \\prec_{I.\\text{proc}} \\), or \\( \\text{null} \\) if none exists (\\( \\text{null} \\) is distinct from all intervals).\n\n• \\( \\langle I.\\text{prev} \\rangle \\): \\( I.\\text{prev} \\) denotes the immediate predecessor interval of interval \\( I \\) with respect to \\( \\prec_{I.\\text{proc}} \\), or \\( \\text{null} \\) if none exists (\\( \\text{null} \\) is distinct from all intervals).\n\n• \\( \\text{(local predicate (on intervals))} \\): A local predicate \\( \\alpha_i \\) also applies to an interval \\( I \\subseteq E_i \\cup \\{ \\bot_i \\} \\) such that \\( \\alpha_i(I) \\equiv \\alpha_i(I.\\text{first}) \\).\n\n• \\( \\text{(true interval)} \\): An interval \\( I \\) is called a true interval if \\( \\alpha_{I.\\text{proc}}(I) \\).\n\n• \\( \\text{(false interval)} \\): An interval \\( I \\) is called a false interval if \\( \\neg \\alpha_{I.\\text{proc}}(I) \\).\n\nThe following relation on the set of intervals, \\( \\mathcal{I} \\), is defined so that \\( I_1 \\mapsto I_2 \\) represents the intuitive notion that: “\\( I_1 \\) must enter before \\( I_2 \\) can leave”.\n\n• \\( \\langle \\mapsto \\rangle \\): \\( \\mapsto \\) is a relation on intervals defined as:\n\n\\[\nI_1 \\mapsto I_2 \\equiv \\begin{cases} \nI_1.\\text{first} \\rightarrow I_2.\\text{next}.\\text{first} & \\text{if } I_1.\\text{prev} \\neq \\text{null} \\text{ and } I_2.\\text{next} \\neq \\text{null} \\\\\n\\text{true} & \\text{if } I_1.\\text{prev} = \\text{null} \\text{ or } I_2.\\text{next} = \\text{null}\n\\end{cases}\n\\]\n\nNote that, the conditions \\( I_1.\\text{prev} \\neq \\text{null} \\) and \\( I_2.\\text{next} \\neq \\text{null} \\) imply that \\( I_1.\\text{first} \\notin \\bot \\) (so \\( \\mapsto \\) is defined) and \\( I_2.\\text{next}.\\text{first} \\) is defined. If \\( I_1.\\text{prev} = \\text{null} \\) or \\( I_2.\\text{next} = \\text{null} \\), then we define \\( I_1 \\mapsto I_2 \\) to be true. Since the execution starts in the first interval of every process and ends in the last interval of every process, this corresponds to the intuition that \\( I_1 \\) must enter before \\( I_2 \\) can leave. Further, note that the relation \\( \\mapsto \\) is reflexive, corresponding to the intuition that an interval must enter before it can leave. Unlike many of the relations we deal with, it is to be noted that the relation \\( \\mapsto \\) is not a partial order and may have cycles.\n\nThe set of intervals \\( \\mathcal{I} \\) together with the relation \\( \\mapsto \\) forms a graph, called an interval graph.\n- **(interval graph)**: \\( \\langle I, \\rightarrow \\rangle \\) is called the *interval graph* of computation \\( \\langle E, \\rightarrow \\rangle \\) under the set of local predicates \\( \\alpha_1, \\alpha_2, \\ldots, \\alpha_n \\).\n\nThe interval graph represents a higher granularity view of a computation, in which the intervals may be viewed as “large events”. However, there is one important difference — an interval graph may be cyclic, while a computation is partially ordered.\nChapter 3\n\nThe Predicate Control Problem\n\nIn this chapter we describe our results in studying the predicate control problem and design algorithms, some of which will be used in the experimental study of controlled re-execution in Chapter 5.\n\n3.1 Overview\n\nWe first define the predicate control problem formally in Section 3.2. Informally, the predicate control problem is to determine how to add edges to a computation (that is, make the computation stricter) so that it maintains a global predicate.\n\nIn its full generality, the predicate control problem deals with any predicates and it would, therefore, be expected that it is hard to solve. We establish in Section 3.3 that it is NP-Complete. However, as we will see, there are useful predicates for which the problem can be solved efficiently.\n\nThe first class of predicates that we study in Section 3.4 is the class of “disjunctive predicates” that are specified as a disjunction of local predicates. Intuitively, these predicates can be used to express a global condition in which at least one local condition has occurred, or, in other words, in which a bad combination of local conditions has not occurred. For example: “at least one server is available”. First, we show that a necessary condition to solve the problem for disjunctive pred-\nGeneralized Mutual Exclusion\n\nReaders Writers Independent Mutual Exclusion\n\nMutual Exclusion\n\nFigure 3.1: Variants of Mutual Exclusion Predicates\n\nicates is the absence of a clique of \\( n \\) false intervals in the interval graph. Next, we design an algorithm for solving the problem when the necessary condition is satisfied, thus establishing that the condition is also sufficient. The algorithm is of complexity \\( O(np) \\), where \\( n \\) is the number of processes and \\( p \\) is the number of false intervals in the interval graph.\n\nThe next class of predicates is that of “mutual exclusion predicates” which state that no two processes are in critical sections at the same time. Mutual exclusion predicates are particularly useful in software fault tolerance since they correspond to races, a very common type of synchronization faults. In Section 3.5, our two results show that the necessary and sufficient conditions for solving predicate control for mutual exclusion predicates is the absence of a non-trivial cycle of critical sections in the interval graph. We also design an algorithm of complexity \\( O(np) \\), where \\( p \\) is the number of critical sections in the computation.\n\nWe can generalize the mutual exclusion predicates to “readers writers predicates” specifying that only “write” critical sections must be exclusive, while “read” critical sections need not be exclusive. Another generalization is the “independent mutual exclusion predicates” where critical sections have “types” associated with them, such that no two critical sections of the same type can execute simultaneously. Finally, “generalized mutual exclusion predicates” allow read and write critical sections and multiple types of critical sections. Figure 3.1 illustrates the relative generality of the four problems.\n\nIn Section 3.6, we find that the necessary and sufficient conditions for solving\npredicate control for readers writers predicates is the absence of a non-trivial cycle of\ncritical sections with at least one write critical section. For independent mutual ex-\nclusion, however, we discover that the problem is NP-Complete in general. We show\nthis in Section 3.7, and also show that a sufficient condition for solving the problem\nis the absence of a non-trivial cycle of critical sections with two critical sections of\nthe same type. However, in general, this condition is not necessary. The results for\ngeneralized mutual exclusion follow along similar lines. We do not describe individ-\nual algorithms for readers writers and independent mutual exclusion predicates.\nInstead, in Section 3.8, we describe a general $O(np)$ algorithm that solves predicate\ncontrol for general mutual exclusion predicates (under the sufficient conditions).\nThis algorithm can be applied to solving readers writers predicates (in general) and\nindependent mutual exclusion predicates (under the sufficient conditions).\n\n3.2 Problem Statement\n\nIn order to state the problem, we first require the concept of a “controlling computa-\ntion”. Informally, given a predicate and a computation, a controlling computation is\na stricter computation for which all consistent cuts satisfy the predicate. Formally,\nit is defined as:\n\n- **(controlling computation)**: Given a computation $\\langle E, \\rightarrow \\rangle$ and a global\n predicate $\\phi$, a computation $\\langle E, \\rightarrow^c \\rangle$ is called a controlling computation of $\\phi$ in\n $\\langle E, \\rightarrow \\rangle$, if: (1) $\\rightarrow \\subseteq \\rightarrow^c$, and \n (2) for all consistent cuts $C$ in $\\langle E, \\rightarrow^c \\rangle$: $\\phi(C)$\n\nGiven this definition, the predicate control problem is:\n\n**The Predicate Control Problem**: Given a computation $\\langle E, \\rightarrow \\rangle$ and a global\npredicate $\\phi$, is there a controlling computation of $\\phi$ in $\\langle E, \\rightarrow \\rangle$?\n\nThe search problem corresponding to the predicate control problem is to find such\na controlling computation, if one exists.\n\n### 3.3 Predicate Control is NP-Complete\n\nWe prove that predicate control is NP-Complete in two steps. We first define the predicate control problem for runs and show that it is equivalent to the predicate control problem. We next show that the predicate control problem for runs is NP-Complete.\n\n**The Predicate Control Problem for Runs**: Given a computation \\( \\langle E, \\rightarrow \\rangle \\) and a global predicate \\( \\phi \\), is there a controlling run of \\( \\phi \\) in \\( \\langle E, \\rightarrow \\rangle \\)?\n\n**Lemma 9** The Predicate Control Problem is equivalent to the Predicate Control Problem for Runs.\n\n**Proof**: Let \\( \\langle E, \\rightarrow \\rangle \\) be a computation and \\( \\phi \\) be a global predicate. We have to show that a controlling computation of \\( \\phi \\) in \\( \\langle E, \\rightarrow \\rangle \\) exists if and only if a controlling run of \\( \\phi \\) in \\( \\langle E, \\rightarrow \\rangle \\) exists.\n\nSince a run is a special case of a computation, the “if” proposition follows.\n\nFor the “only if” proposition, suppose a controlling computation \\( \\langle E, \\rightarrow^c \\rangle \\) of \\( \\phi \\) in \\( \\langle E, \\rightarrow \\rangle \\) exists. Let \\( <^c \\) be any linearization of \\( \\rightarrow^c \\) (a linearization of a partial order is a totally ordered superset). If \\( C \\) is a consistent cut of \\( \\langle E, <^c \\rangle \\), then \\( C \\) is also a consistent cut of \\( \\langle E, \\rightarrow^c \\rangle \\) (Lemma 2). Since, \\( \\langle E, \\rightarrow^c \\rangle \\) is a controlling computation, we have \\( \\phi(C) \\). Therefore, \\( \\langle E, <^c \\rangle \\) is also a controlling computation of \\( \\phi \\) in \\( \\langle E, \\rightarrow \\rangle \\).\n\n\\( \\square \\)\n\n**Lemma 10** The Predicate Control Problem for Runs is NP-Complete.\n\n**Proof**: First, we show that the problem is in NP. A non-deterministic algorithm need only guess a run \\( \\langle E, <^c \\rangle \\) such that \\( <^c \\) is a linearization of \\( \\rightarrow \\). To check that a run is a controlling computation, we first enumerate all the consistent cuts in the...\nrun. By Lemma 8, each consistent cut is the lcc of some event, and, therefore, we can achieve the enumeration by finding the lcc of each event in the run. Using Lemma 5 and the fact that the causal past of a cut is unique, it can be easily shown that the lcc of an event can be constructed in polynomial time. Further, by definition, it can be checked in polynomial time that the given predicate satisfies each lcc.\n\nTo show that the problem is NP-Hard, we transform SAT. Let \\( U = \\{ u_1, \\cdots, u_m \\} \\) be a set of boolean variables, and \\( D = \\{ d_1, \\cdots, d_k \\} \\) be a set of clauses forming an instance of SAT. Let \\( \\psi \\) be the boolean function over the set of truth assignments such that \\( \\psi(t) \\equiv t \\) satisfies \\( D \\). (\\( \\psi \\) can be represented as a boolean formula in conjunctive normal form).\n\nFor each variable \\( u_i \\in U \\), construct a singleton set of events \\( E_i = \\{ e_i \\} \\). Construct one more set \\( E_{m+1} = \\{ e_{m+1}, e'_{m+1} \\} \\). Let \\( E = \\bigcup_{i \\in \\{1, \\cdots, m+1\\}} E_i \\). Let relation \\( \\rightarrow \\) be defined so that \\( e_{m+1} \\rightarrow e'_{m+1} \\) and no other events are related. Clearly \\( \\rightarrow \\) is a partial order on \\( E \\) and \\( \\rightarrow_i \\) is a total order. Therefore, \\( \\langle E, \\rightarrow \\rangle \\) is a (locally ordered) computation.\n\nFor each \\( i \\), let \\( \\alpha_i \\) be a local predicate on \\( E_i \\cup \\{ \\bot_i \\} \\) as follows. Let \\( \\alpha_{m+1}(\\bot_{m+1}) = true \\), \\( \\alpha_{m+1}(e_{m+1}) = false \\), and \\( \\alpha_{m+1}(e'_{m+1}) = true \\). For each \\( i \\leq m \\) let \\( \\alpha_i(\\bot_i) = false \\) and \\( \\alpha_i(e_i) = true \\). Note that for each cut \\( C \\), there is a truth assignment \\( t_C \\) such that \\( t_C(u_i) \\equiv \\alpha_i(C[i]) \\). Define a global predicate \\( \\phi = \\alpha_{m+1}(C[m+1]) \\lor \\psi(t_C) \\).\n\nThus, we have a polynomial construction from an instance \\( \\langle U, D \\rangle \\) of SAT to an instance \\( \\langle \\langle E, \\rightarrow \\rangle, \\phi \\rangle \\) of the Predicate Control Problem for Runs. We next show that this is indeed a transformation.\n\nPart 1: Suppose that \\( \\langle E, \\leq \\rangle \\) is a controlling run of \\( \\phi \\) in \\( \\langle E, \\rightarrow \\rangle \\). Let \\( C \\) be any consistent cut containing \\( e \\) (by Lemma 1). Since \\( \\phi(C) = true \\) and \\( \\alpha_{m+1}(C[m+1]) = false \\), we must have \\( \\psi(t_C) \\). Therefore, \\( t_C \\) is a truth assignment that satisfies the set of clauses \\( D \\).\n\nPart 2: Suppose that \\( t \\) is a truth assignment of variables in \\( U \\) that satisfies \\( D \\).\nDefine $\\sim^c$ such that $\\rightarrow \\subset \\sim^c$ and $\\sim^c$ contains the following edges in addition to edges in $\\rightarrow$: (1) for each $i \\leq m$ such that $t(u_i) = true$, the edge $e_i \\sim^c e_{m+1}$, and (2) for each $i \\leq m$ such that $t(u_i) = false$, the edge $e_{m+1} \\sim^c e_i$. Let $\\rightarrow^c$ be the transitive closure of $\\sim^c$. Since each $E_i$ except $E_{m+1}$ does not have both incoming and outgoing $\\sim^c$ edges, there can be no cycles in $\\sim^c$, and, therefore, $\\rightarrow^c$ is a partial order and $\\langle E, \\rightarrow^c \\rangle$ is a computation. Let $<^c$ be any linearization of $\\rightarrow^c$.\n\nClaim: The run $\\langle E, <^c \\rangle$ is a controlling run of $\\phi$ in $\\langle E, \\rightarrow \\rangle$.\n\nProof: Let $C$ be a consistent cut of the run $\\langle E, <^c \\rangle$. We show that $\\phi(C) = true$. If $\\alpha_{m+1}(C[m + 1]) = true$, we directly have $\\phi(C) = true$. Therefore, we consider the remaining possibility: $\\alpha_{m+1}(C[m + 1]) = false$. By the definition of $\\alpha_{m+1}$, we have: $C[m + 1] = e_{m+1}$. We next show that $t_C = t$. Consider any $i \\leq m$. We consider two\n\nFigure 3.2: Proof: The Predicate Control Problem for Runs is NP-Complete\ncases depending on the value of $t(u_i)$:\n\n**Case 1**: $t(u_i) = true$:\n\nTherefore, $e_i <^c e_{m+1}$ (by the definition of $\\sim^c$ and $\\sim^c \\subset^c$). Since $C$ is consistent and $C[m+1] = e_{m+1}$, we must have $C[i] = e_i$. By the definition of $\\alpha_i$, we have $\\alpha_i(C[i]) = true$. Therefore, $t_C(u_i) = true$.\n\n**Case 2**: $t(u_i) = false$:\n\nTherefore, $e'_i <^c e_i$ (by the definition of $\\sim^c$ and $\\sim^c \\subset^c$). Since $C$ is consistent and $C[m+1] = e_{m+1}$, we must have $C[i] = \\bot_i$. By the definition of $\\alpha_i$, we have $\\alpha_i(C[i]) = false$ and, therefore, $t_C(u_i) = false$.\n\nThis proves that $t_C = t$. Since $t$ satisfies the set of clauses, $D$, we have $\\psi(t_C) = true$. Therefore, $\\phi(C) = true$. ⟨End: Proof of Claim⟩ □\n\n**Theorem 1** The Predicate Control Problem is NP-Complete.\n\n**Proof**: Follows directly from Lemmas 9 and 10. □\n\n### 3.4 Disjunctive Predicates\n\n- **(disjunctive predicates)**: Given $n$ local predicates $\\alpha_1, \\alpha_2, \\ldots, \\alpha_n$, the disjunctive predicate $\\phi_{\\text{disj}}$ is defined as:\n\n$$\\phi_{\\text{disj}}(C) \\equiv \\bigvee_{i \\in \\{1, \\ldots, n\\}} \\alpha_i(C[i])$$\n\nSome examples of disjunctive predicates are:\n\n1. At least one server is available: $avail_1 \\lor avail_2 \\lor \\ldots \\lor avail_n$\n2. $x$ must happen before $y$: $after \\lor before \\lor y$\n3. At least one philosopher is thinking: $think_1 \\lor think_2 \\lor \\ldots \\lor think_n$\n4. $(n - 1)$-mutual exclusion: $\\neg cs_1 \\lor \\neg cs_2 \\lor \\ldots \\lor \\neg cs_n$\nNote how we can even achieve the fine-grained control necessary to cause a specific event to happen before another as in property (3). This was done using local predicates to check if the event has happened yet. \\((n - 1)\\)-mutual exclusion is a special case of \\(k\\)-mutual exclusion, which states that at most \\(k\\) processes can be in the critical sections at the same time.\n\nWe next determine a necessary condition for solving the predicate control problem for disjunctive predicates.\n\n**Theorem 2** Let \\(\\langle I, \\rightarrow \\rangle\\) be the interval graph of a computation \\(\\langle E, \\rightarrow \\rangle\\) under local predicates \\(\\alpha_1, \\alpha_2, \\ldots, \\alpha_n\\). If \\(\\langle I, \\rightarrow \\rangle\\) contains a clique of \\(n\\) false intervals, then there is no controlling computation of \\(\\phi_{\\text{disj}}\\) in \\(\\langle E, \\rightarrow \\rangle\\).\n\n**Proof:** Let \\(\\langle I, \\rightarrow \\rangle\\) have a clique \\(X\\) of \\(n\\) false intervals. Since for any two distinct false intervals \\(I\\) and \\(I'\\) in \\(X\\), \\(I \\rightarrow I'\\) and \\(I' \\rightarrow I\\), we must have \\(I.\\text{proc} \\neq I'.\\text{proc}\\). Therefore, each of the false intervals in \\(X\\) is on a distinct \\(E_i\\). Let \\(I_1, I_2, \\ldots, I_n\\) be the false intervals of \\(X\\), such that \\(I_i.\\text{proc} = i\\). We prove by contradiction that there is no controlling computation of \\(\\phi_{\\text{disj}}\\) in \\(\\langle E, \\rightarrow \\rangle\\).\n\nSuppose that \\(\\langle E, \\rightarrow^c \\rangle\\) is a controlling computation of \\(\\phi_{\\text{disj}}\\) in \\(\\langle E, \\rightarrow \\rangle\\). Let \\(<^c\\) be any linearization of \\(\\rightarrow\\). Therefore, by Lemma 2, \\(\\langle E, <^c \\rangle\\) is also a controlling computation. We next show that there is a consistent cut \\(C\\) in the run \\(\\langle E, <^c \\rangle\\) such that \\(\\neg \\phi_{\\text{disj}}(C)\\), thus, contradicting the fact that \\(\\langle E, <^c \\rangle\\) is a controlling computation.\n\nConsider two cases:\n\n**Case 1:** \\(\\forall i: I_i.\\text{next} = \\text{null}\\):\n\nLet \\(C\\) be the maximum cut in the run \\(\\langle E, \\rightarrow \\rangle\\). It is easy to verify that \\(C\\) is consistent (as in any computation). Since each \\(I_i\\) is the last interval and is also a false interval, \\(\\neg \\phi_{\\text{disj}}(C)\\).\n\n**Case 2:** \\(\\exists i: I_i.\\text{next} \\neq \\text{null}\\):\n\n33\nLet $e$ be the minimum event in $\\langle E, \\prec \\rangle$ such that $e = I_i.next.first$ for some $i$. Let $C' = lcc(e)$. Consider any $j \\in \\{1, \\cdots n\\}$ such that $j \\neq i$. Consider two cases:\n\n**Case a:** $I_j.prev = null$: In this case $I_j.first = \\perp_j$. Therefore, $I_j.first \\preceq_j C'[j]$.\n\n**Case b:** $I_j.prev \\neq null$: Since $I_j \\mapsto I_i$, we have $I_j.first \\rightarrow e$. Further, since $\\rightarrow \\subseteq \\prec$, we have $I_j.first <^c e$. Therefore, by the consistency of $C'$, we have $I_j.first \\preceq_j C'[j]$.\n\nTherefore, in both cases: $I_j.first \\preceq_j C'[j]$ – [A]\n\nConsider two cases:\n\n**Case a:** $I_j.next = null$: Clearly, $C'[j] \\preceq_j I_j.last$.\n\n**Case b:** $I_j.next \\neq null$: Since $e <^c I_j.next.first$ (by the definition of $e$) and $e = ge(C')$ (by Lemma 8), we have $C'[j] <^c e <^c I_j.next.first$. Therefore, $C'[j] \\preceq_j I_j.last$.\n\nTherefore, in both cases: $C'[j] \\preceq I_j.last$ – [B]\n\nBy [A] and [B], we have $C'[j] \\in I_j$ and therefore $-\\alpha_j(C'[j])$. Let $C = lcc-prev(e)$. Since, $\\forall j : j \\neq i : C[j] = C'[j]$, we have: $-\\alpha_j(C[j])$. Further, since $e = I_i.next.first, C[i] = I_i.last$, and therefore, $-\\alpha_i(C[i])$. So, $-\\phi_{\\text{disj}}(C)$.\n\nAlso, by Lemma 6, $C$ is consistent.\n\n\\[ \\square \\]\n\n**Algorithm Description**\n\nIn order to show that the necessary condition is also sufficient, we design an algorithm that finds a controlling computation whenever the condition is true. The algorithm is shown in Figure 3.3.\nThe algorithm takes as input the $n$ sequences of intervals for each of the processes. The output contains a sequence of added edges. The central idea is that this sequence of added edges links true intervals into a continuous “chain” from the start of the computation to the end. Any cut must either intersect this chain in a true interval, in which case it satisfies the disjunctive predicate, or in an edge, in which case the cut is made inconsistent by the added edge.\n\nThe purpose of each iteration of the main loop in lines L12-L23 is to add one true interval, *anchor*, to the *chain* of true intervals. The intervals $I_1, \\ldots, I_n$ form a “frontier” of intervals that start at the beginning of the computation and continue until one of them reaches the end. In each iteration, a *valid pair*, consisting of a true interval, *anchor*, and a false interval, *crossed*, is selected at line L13, such that *anchor* does not have to leave before *crossed* leaves. If no such *valid pair*, we can (and will) show that the necessary condition must be true so that an $n$-sized clique of false intervals exists in the interval graph. Next, the *anchor* is added to the *chain* of true intervals at line L19. Finally, the frontier advances such that *crossed* is crossed and all intervals which must enter as a result of this are entered (lines L20 - L23). After the loop terminates, the output is constructed from the chain of true intervals by connecting them in reverse order.\n\nThe time complexity of the algorithm is $O(np)$ where $p$ is the number of false-intervals in the computation. The naive implementation of the algorithm would be $O(n^2p)$ because the outer while loop iterates $O(np)$ times and calculating the set $ValidPairs()$ can take $O(n^2)$ time to check every pair of processes. However, an optimized implementation avoids redundant comparisons in computing the set $ValidPairs()$. Since, in this approach, each new false-intervals has to be compared with $n - 1$ existing false-intervals, the time complexity is $O(np)$.\nTypes:\n\n- **event**: (proc: int; v: vector clock) (L1)\n- **interval**: (proc: int; α: boolean; first: event; last: event) (L2)\n\nInput:\n\n- $I_1, I_2, \\cdots, I_n$: list of interval, initially non-empty (L3)\n\nOutput:\n\n- $O$: list of (event, event), initially null (L4)\n\nVars:\n\n- $I_1, I_2, \\cdots, I_n$: interval, initially $\\forall i \\colon I_i = I_i.\\text{head}$ (L5)\n- valid_pairs: set of (interval, interval) (L6)\n- chain: list of interval (L7)\n- anchor, crossed: interval (L8)\n- prev, curr: interval (L9)\n\nNotation:\n\n- $N_i = \\begin{cases} \\min X \\in I_i : I_i \\preceq X \\land X.\\alpha = \\text{false} & \\text{if exists} \\\\ \\text{null} & \\text{otherwise} \\end{cases}$ (L10)\n- $\\text{select}(Z) = \\begin{cases} \\text{arbitrary element of set } Z & \\text{if } Z \\neq \\emptyset \\\\ \\text{null} & \\text{otherwise} \\end{cases}$ (L11)\n\nProcedure:\n\n- while $(\\forall i : N_i \\neq \\text{null})$ do (L12)\n - valid_pairs := $\\{(I_i, N_j) \\mid (I_i.\\alpha = \\text{true}) \\land (N_i \\not\\rightarrow N_j)\\}$ (L13)\n - if (valid_pairs = $\\emptyset$) then (L14)\n - exit(“no controlling computation exists”) (L15)\n - (anchor, crossed) := select(valid_pairs) (L16)\n - if (anchor.\\text{prev} = null) then (L17)\n - chain := null (L18)\n - chain.add.head(\\text{anchor}) (L19)\n - for (i $\\in \\{1, \\cdots, n\\}$: i $\\neq$ crossed.proc) do (L20)\n - while $(I_i.\\text{next} \\neq \\text{null} \\land I_i.\\text{next} \\not\\rightarrow \\text{crossed})$ (L21)\n - $I_i := I_i.\\text{next}$ (L22)\n - $I_{\\text{crossed.proc}} := I_{\\text{crossed.next}}$ (L23)\n - anchor := select($\\{I_i : i \\in \\{1, \\cdots, n\\} \\land N_i = \\text{null}\\}$) (L24)\n - if (anchor.\\text{prev} = \\text{null}) then (L25)\n - chain := null (L26)\n - chain.add.head(\\text{anchor}) (L27)\n - prev := chain.delete.\\text{head}() (L28)\n - while (chain $\\neq$ \\text{null}) do (L29)\n - curr := chain.delete.\\text{head}() (L30)\n - $O.\\text{add.head}(\\text{prev}.\\text{first}, \\text{curr}.\\text{next}.\\text{first})$ (L31)\n - prev := curr (L32)\n\nFigure 3.3: Algorithm for Predicate Control of the Disjunctive Predicate\nWe have assumed, of course, that the algorithm is correct. We now establish this. In doing so, we also prove that the necessary condition – the existence of an \\( n \\)-sized clique of false intervals – is also a sufficient one for solving predicate control for disjunctive predicates.\n\nWe first show that the algorithm is well-specified so that it is indeed an algorithm – all the terms used are well-defined and it terminates.\n\n**Lemma 11** The algorithm in Figure 3.3 is well-specified.\n\n**Proof:** We first check that all terms in the algorithm are well-defined. The second condition, \\( I_i.next \\rightarrow crossed \\), in L21 is well-defined assuming that the first condition, \\( I_i.next \\neq null \\), is checked prior to it. The only remaining non-trivial check is for the term \\( curr.next.first \\) at line L31. To show that it is well-defined, first note that, for all the intervals \\( anchor \\) added to \\( chain \\) at line L19, \\( anchor.next \\neq null \\) since \\( anchor.\\alpha = true \\) (by lines L13 and L16) and \\( N_{anchor.proc} \\neq null \\) (by terminating condition L12). Therefore, immediately after line L27, for all intervals \\( X \\) in \\( chain \\), we have: \\( (X = chain.head) \\lor (X.next \\neq null) \\). Lastly, note that the interval \\( chain.head \\) immediately after line L27 is never assigned to \\( curr \\) (by L28).\n\nWe next check termination. The while loop in lines L21-L22 terminates since \\( I_i \\) advances once per iteration. The while loop in lines L12-L23 terminates since \\( I_{crossed.proc} \\) advances by at least one interval in each iteration. The loop in lines L29-L32 terminates since \\( chain \\) reduces by one interval in each iteration. \\( \\square \\)\n\nNext, we prove two useful invariants maintained by the algorithm.\n\n**Lemma 12** The algorithm in Figure 3.3 maintains the following invariants on \\( I_1, I_2 \\cdots, I_n \\) (except in lines L20-L23 while \\( I_i \\)'s are being updated):\n\n**INV1:** \\( \\forall i, j : \\) if \\( I_i.next \\neq null \\) and \\( I_j.prev \\neq null \\) then \\( I_i.next \\not\\rightarrow I_j.prev \\)\n\n**INV2:** \\( \\forall i : \\) if \\( I_i.prev \\neq null \\) then \\( I_i.\\alpha = true \\) \\( \\lor \\) \\( (\\exists j : I_i \\rightarrow I_j.prev \\land I_j.\\alpha = true) \\)\n\n37\n**Proof:** (structural induction treating L20-L23 as atomic)\n\n**Base Case:** Initially, \\( \\forall j: I_j = I_j\\).head and, therefore, \\( \\forall j: I_j.prev = null \\) and INV1 and INV2 follow.\n\n**Inductive Case:** The only statements that update any \\( I_i \\) are L20-L23. Therefore, we assume that INV1 and INV2 are true before an occurrence of L20-L23. We denote the values of the variables \\( I_i \\) at this point by \\( I_i' \\). We must prove that INV1 and INV2 are true after the occurrence of L20-L23. We denote the values of the variables \\( I_i \\) at this point by \\( I_i \\)\n\nTo prove that INV1 holds, let \\( I_i.next \\neq null \\) and \\( I_j.prev \\neq null \\) and consider two cases:\n\n**Case 1:** \\( I_j \\neq I_j' \\): Therefore, the variable \\( I_j \\) was updated at either L22 or L23.\n\n**Case a:** \\( I_j \\) updated at L23: Therefore, \\( I_j.prev = crossed \\). Also, by the terminating condition of while loop L21 and since \\( I_i.next \\neq null \\), \\( I_i.next \\not\\rightarrow crossed \\). Therefore, \\( I_i.next \\not\\rightarrow I_j.prev \\).\n\n**Case b:** \\( I_j \\) updated at L22: Therefore, \\( I_j \\not\\rightarrow crossed \\). Since \\( I_j.prev \\neq null \\) and \\( crossed.next \\neq null \\) (since anchor \\( \\not\\rightarrow crossed - \\) line L13, L16), we have: \\( I_j.first \\rightarrow crossed.next.first \\). -[A]\n\nAlso, by the terminating condition of loop L21 and since \\( I_i.next \\neq null \\), \\( I_i.next \\not\\rightarrow crossed \\). -[B]\n\nFrom [A] and [B], we have \\( I_i.next \\not\\rightarrow I_j.first \\). Therefore, \\( I_i.next \\not\\rightarrow I_j.prev \\).\n\n**Case 2:** \\( I_j = I_j' \\): We know that \\( I_i'.next \\neq null \\) since \\( I_i.next \\neq null \\) and \\( I_i' \\preceq I_i \\) (since variable \\( I_i \\) is always advanced). We also know that \\( I_j'.prev \\neq null \\) since \\( I_j' = I_j \\). Therefore, by the inductive hypothesis, we have: \\( I_i'.next \\not\\rightarrow I_j'.prev \\).\n\nSince \\( I_j = I_j' \\), we further have: \\( I_i'.next \\not\\rightarrow I_j.prev \\). Therefore, \\( I_i'.next.first \\not\\rightarrow I_j.first \\). Since \\( I_i' \\preceq I_i \\), we have \\( I_i'.next.first \\rightarrow I_i.next.first \\). Therefore, by\ntransitivity, $I_i.next.first \\not\\rightarrow I_j.first$. It follows that $I_i.next \\not\\rightarrow I_j.prev$.\n\nWe next prove that INV2 holds after lines L20-L23. Let $I_i.prev \\neq null$. We have two cases:\n\n**Case 1:** $I_i = I'_i$: By the inductive hypothesis, let $j$ be such that $I_i \\rightarrow I'_j.prev \\land I'_j.\\alpha = true$. If $I_j = I'_j$, then INV2 clearly holds. Suppose $I_j \\neq I'_j$. Therefore, either $I_j$ was updated at L22 or at L23.\n\n**Case a:** $I_j$ updated at L23: Therefore, $I_j = crossed.next$. Since $crossed.\\alpha = false$, we have $I_j.\\alpha = true$. Further, since $I_i \\rightarrow I'_j.prev$ and $I'_j \\preceq_j crossed$, we have: $I_i \\rightarrow I'_j.prev$. Therefore, INV2 holds.\n\n**Case b:** $I_j$ updated at L22: From the terminating condition of the loop at L21, we have:\n\n$I'_j.next \\rightarrow crossed$ and so, $I'_j.next.first \\rightarrow crossed.next.first$. –[A]\n\nSince $I_i \\rightarrow I'_j.prev$ and $I_i.prev \\neq null$, we have:\n\n$I_i.first \\rightarrow I'_j.first$. –[B]\n\nUsing [A] and [B] and transitivity, we have:\n\n$I_i.first \\rightarrow crossed.next.first$ and so, $I_i \\rightarrow crossed$. Further,\n\ncrossed.next.\\alpha = true$ and so INV2 follows (instantiating $crossed.proc$ for $j$).\n\n**Case 2:** $I_i \\neq I'_i$: In this case, either $I_i$ was updated in L23 or L22. If at L23, then $I_i.\\alpha = true$ and INV2 follows. If at L22, then by the loop condition at L21, we have: $I_i \\rightarrow crossed$. Therefore, INV2 follows (instantiating $crossed.proc$ for $j$).\n\nWe next show that if the algorithm exits abnormally at line L15, failing to produce a controlling computation, then no controlling computation exists for the problem instance.\n\n39\nLemma 13 If the algorithm in Figure 3.3 exits at line L15, then no controlling computation exists.\n\nProof: If ∀i, j : \\( N_i \\rightarrow N_j \\) then we have a clique of \\( n \\) false intervals and the result follows from Theorem 2. Therefore, let i and j be such that \\( N_i \\not\\rightarrow N_j \\). Since the set \\( valid\\_pairs = \\emptyset \\) (line L14), we must have \\( I_i.\\alpha = false \\) (from line L13). –[A]\n\nTherefore, by the definition of \\( N_i \\), we have: \\( I_i = N_i \\). So, since \\( N_i \\not\\rightarrow N_j \\), we have: \\( I_i.\\text{prev} \\neq null \\) –[B]\n\nApplying INV2 and using [A] and [B] let k be such that: \\( I_i \\mapsto I_k.\\text{prev} \\land I_k.\\alpha = true \\). Since \\( N_i \\not\\rightarrow N_j \\) and \\( N_i = I_i \\) and \\( I_i \\mapsto I_k.\\text{prev} \\) we have: \\( N_k \\not\\rightarrow N_j \\). This contradicts the fact that \\( valid\\_pairs = \\emptyset \\) (line L14). □\n\nFinally, we show that the output does form a controlling computation.\n\nLemma 14 If the algorithm in Figure 3.3 terminates normally, then \\( \\langle E, \\rightarrow^c \\rangle \\) is a controlling computation of \\( \\phi_{\\text{disj}} \\) in \\( \\langle E, \\rightarrow \\rangle \\), where \\( \\rightarrow^c \\) is the transitive closure of the union of \\( \\rightarrow \\) with the set of edges in \\( O \\).\n\nProof: First, we show that \\( \\langle E, \\rightarrow^c \\rangle \\) is a computation. Just before loop L29-32, we have \\( \\forall I \\in \\text{chain} : I.\\text{prev} \\neq null \\) (by lines L17-L18 and and L25-L26). Therefore, in line L31, \\( \\text{prev.first} \\in E \\) (i.e. \\( \\text{prev.first} \\notin \\bot \\)). Clearly, the same holds for \\( \\text{curr.next.first} \\). Therefore, \\( O \\) determines a set of edges on \\( E \\). Let \\( \\sim^c \\) represent this set of edges.\n\nWe show by contradiction that \\( \\rightarrow^c \\) is an irreflexive partial order. Since \\( \\rightarrow^c \\) is transitive by definition, we assume that it is reflexive. Therefore, \\( \\rightarrow \\cup \\sim^c \\) has a cycle, say \\( \\mathcal{C} \\). Among the edges in \\( \\mathcal{C} \\) let \\( X.\\text{first} \\sim^c Y.\\text{next.first} \\) be the edge such that \\( X \\) is the latest to be added to \\( \\text{chain} \\). Let \\( U.\\text{first} \\sim^c V.\\text{next.first} \\), be the next \\( \\sim^c \\) edge in the cycle \\( \\mathcal{C} \\) (note that \\( U = X \\) if there is only one \\( \\sim^c \\) edge in \\( \\mathcal{C} \\)). Consider the algorithm step in which \\( X \\) is the anchor and added to \\( \\text{chain} \\). Since \\( Y \\) was the anchor immediately before \\( X \\), and since the anchor is not affected by the update to \\( I_i \\)’s in lines L20-L23, we have: \\( I_Y.\\text{proc} = Y \\). –[A]\nSince $U$ cannot be added after $X$ (by the definition of $X$), we have: $U \\preceq I_{U.proc}$. –[B]\n\nSince $U.first \\sim^e V.next.first$ is the next $\\sim^e$ edge in the cycle $C$ following the edge $X.first \\sim^e Y.next.first$, we have: $Y.next.first \\rightarrow U.first$. (Note: $Y.next.first \\neq U.first$ since both $Y$ and $U$ are true intervals). Therefore, using [A] and [B], we have: $I_{Y.proc.next.first} \\rightarrow I_{U.proc.first}$ –[C]\n\nSince $\\sim^e$ is a set of edges on $E$, we know that $U.prev \\neq \\text{null}$. Therefore, using [B], we have: $I_{U.proc.prev} \\neq \\text{null}$ Therefore, applying INV1: $I_{Y.proc.next} \\neq I_{U.proc.first}$, which contradicts [C]. Therefore, $\\rightarrow^e$ is an irreflexive partial order and $\\langle E, \\rightarrow^e \\rangle$ is a computation.\n\nIt remains to prove that $\\langle E, \\rightarrow^e \\rangle$ is a controlling computation. Let $C$ be a consistent cut in $\\langle E, \\rightarrow^e \\rangle$. Let $I$ be the last interval to be added to chain such that: $I.first \\preceq C[I.proc]$ (such an $I$ must exist, since the initial conditions together with lines L17-L18 ensure that for first interval $X$, $X.first \\in \\perp$). Consider two cases:\n\n**Case 1: I is the last interval added to chain:** Since $I$ was added in line L27, $I.next = \\text{null}$ (by L24). Therefore, $C[I.proc] \\preceq I.last$. Together with the definition of $I$, this implies that $C[I.proc] \\in I$. Therefore $\\alpha_{I.proc}(C[I.proc])$ and so, $\\phi_{\\text{disj}}(C)$.\n\n**Case 2: I is not the last interval added to chain:** Let $I'$ be the next interval to be added to chain. Therefore, $I'.first \\sim^e I.next.first$ (by L31). –[A]\n\nBy the definition of $I$, we have: $C[I'.proc] \\prec I'.first$. Therefore, since $C$ is consistent in $\\langle E, \\rightarrow^e \\rangle$, $I'.first \\notin C.past$. In particular, $I'.first \\neq C[I.proc]$. From [A], we must have: $C[I.proc] \\prec I.next.first$. Together with the definition of $I$, we have $C[I.proc] \\in I$. Therefore $\\alpha_{I.proc}(C[I.proc])$ and so, $\\phi_{\\text{disj}}(C)$.\n\n$\\square$\nOur final theorem in this section states the sufficient condition for solving disjunctive predicate control as demonstrated by the correctness of our algorithm.\n\n**Theorem 3** Let \\( \\langle C, \\to \\rangle \\) be the interval graph of a computation \\( \\langle E, \\to \\rangle \\) under local predicates \\( \\alpha_1, \\alpha_2, \\ldots, \\alpha_n \\). If \\( \\langle C, \\to \\rangle \\) does not contain a clique of \\( n \\) false intervals, then there is a controlling computation of \\( \\phi_{\\text{disj}} \\) in \\( \\langle E, \\to \\rangle \\).\n\n**Proof:** By Lemmas 11, 13, and 14, the algorithm in Figure 3.3 determines a controlling computation if \\( \\langle C, \\to \\rangle \\) does not contain a clique of \\( n \\) false intervals. \n\n### 3.5 Mutual Exclusion Predicates\n\n- **(mutual exclusion predicates)**: Let \\( \\text{critical}_1, \\text{critical}_2, \\ldots, \\text{critical}_n \\) be \\( n \\) local predicates and let \\( \\text{critical}(e) \\equiv \\text{critical}_{e, \\text{proc}}(e) \\). The mutual exclusion predicate \\( \\phi_{\\text{mutex}} \\) is defined as:\n\n \\[\n \\phi_{\\text{mutex}}(C) \\equiv \\forall \\text{ distinct } i, j : \\neg ( \\text{critical}(C[i]) \\land \\text{critical}(C[j]) )\n \\]\n\n- **(critical section)**: A critical section (non-critical section) denotes a true (false) interval in \\( \\langle E, \\to \\rangle \\) with respect to \\( \\text{critical}_1, \\text{critical}_2, \\ldots, \\text{critical}_n \\).\n\nMutual exclusion is one of the most common forms of synchronization in distributed applications. In particular, the results for mutual exclusion predicates will be used in the controlled re-execution method in Chapter 5.\n\nThe next two theorems demonstrate the necessary and sufficient conditions for solving predicate control for the mutual exclusion predicates.\n\n**Theorem 4** Let \\( \\langle C, \\to \\rangle \\) be the interval graph of a computation \\( \\langle E, \\to \\rangle \\) under local predicates \\( \\text{critical}_1, \\text{critical}_2, \\ldots, \\text{critical}_n \\). If \\( \\langle C, \\to \\rangle \\) contains a non-trivial cycle of critical sections, then there is no controlling computation of \\( \\phi_{\\text{mutex}} \\) in \\( \\langle E, \\to \\rangle \\).\nProof: We prove the result by contradiction. Let $X$ be a non-trivial cycle of critical sections in $\\langle I, \\rightarrow \\rangle$ and let $\\langle E, \\rightarrow^c \\rangle$ be a controlling computation of $\\phi_{\\text{mutex}}$ in $\\langle E, \\rightarrow \\rangle$. Let $\\longrightarrow^c$ be a linearization of $\\rightarrow^c$ forming a controlling run $\\langle E, \\longrightarrow^c \\rangle$ (by Lemma 2).\n\nWe next show that there is a consistent cut $C$ in the run $\\langle E, \\longrightarrow^c \\rangle$ such that $\\neg \\phi_{\\text{mutex}}(C)$, thus, contradicting the fact that $\\langle E, \\longrightarrow^c \\rangle$ is a controlling computation.\n\nConsider two cases:\n\nCase 1: $\\forall CS \\in X : CS.next = \\text{null} :$\n\nLet $C$ be the maximum cut in the run $\\langle E, \\rightarrow \\rangle$. It is easy to verify that $C$ is consistent (as in any computation). Since $X$ has at least two critical sections, $\\neg \\phi_{\\text{mutex}}(C)$.\n\nCase 2: $\\exists CS \\in X : CS.next \\neq \\text{null} :$\n\nLet $e$ be the minimum event in $\\langle E, \\longrightarrow^c \\rangle$ such that $e = CS.next.first$ for some $CS \\in X$. Let $CS'$ be the critical section preceding $CS$ in the cycle $X$. Therefore, $CS' \\rightarrow CS$. Let $C' = lcc(e)$. Consider two cases:\n\nCase a: $CS'.prev = \\text{null} :$\n\nSince $CS'.first \\in \\bot$, we have $CS'.first \\preceq C'[CS'.proc]$.\n\nCase b: $CS'.prev \\neq \\text{null} :$\n\nSince $CS' \\rightarrow CS$, we have $CS'.first \\rightarrow e$ and so, $CS'.first \\prec e$. Therefore, since $C'$ is consistent, $CS'.first \\preceq C'[CS'.proc]$\n\nIn both cases, $CS'.first \\preceq C'[CS'.proc]$. –[A]\n\nConsider two cases:\n\nCase a: $CS'.next = \\text{null} :$\n\nClearly, $C'[CS'.proc] \\preceq CS'.last$.\n\nCase b: $CS'.next \\neq \\text{null} :$\n\nSince $e \\prec CS'.next.first$ (by the definition of $e$) and since $e = ge(C')$\n(by Lemma 8), we have \\( C'[CS'.proc] <^e e <^c CS'.next.first \\). Therefore, \\( C'[CS'.proc] \\leq CS'.last \\).\n\nIn both cases, \\( C'[CS'.proc] \\leq CS'.last \\) \\(-[B]\\)\n\nBy \\([A]\\) and \\([B]\\), we have \\( C'[CS'.proc] \\in CS' \\) and therefore critical\\((C'[CS'.proc])\\).\n\nLet \\( C = \\text{lcc-prev}(e) \\). Since, \\( \\forall j : j \\neq e\\text{.proc} : C[j] = C'[j] \\), we have: critical\\((C[CS'.proc])\\). Further, since \\( e = CS_.next.first \\), \\( C[CS_.proc] = CS_.last \\), and therefore, critical\\((C[CS_.proc])\\). So, \\( \\neg\\phi_{mutex}(C) \\). Also, by Lemma 6, \\( C \\) is consistent.\n\n\\(\\square\\)\n\n**Theorem 5** Let \\( \\langle I, \\rightarrow \\rangle \\) be the interval graph of a computation \\( \\langle E, \\rightarrow \\rangle \\) under local predicates critical\\(_1\\), critical\\(_2\\), \\ldots, critical\\(_n\\). If \\( \\langle I, \\rightarrow \\rangle \\) does not contain a non-trivial cycle of critical sections, then there is a controlling computation of \\( \\phi_{mutex} \\) in \\( \\langle E, \\rightarrow \\rangle \\).\n\n**Proof:** Since there are no non-trivial cycles of critical sections in \\( \\langle I, \\rightarrow \\rangle \\), we can topologically sort the critical sections to form a sequence: \\( CS_1, CS_2, \\ldots, CS_m \\) such that \\( CS_i \\rightarrow CS_j \\Rightarrow i \\leq j \\) \\(-[A]\\)\n\nDefine a relation \\( \\sim^c \\) on events in \\( E \\) as follows. For each \\( i \\in \\{1, \\ldots, m-1\\} \\), if \\( CS_i.next \\neq \\text{null} \\) and \\( CS_{i+1}.prev \\neq \\text{null} \\), then \\( CS_i.next.first \\sim^c CS_{i+1}.first \\).\n\nFurther, no other events are related by \\( \\sim^c \\).\n\nDefine \\( \\rightarrow^c \\) to be the transitive closure of \\( \\rightarrow \\cup \\sim^c \\). We first show that \\( \\langle E, \\rightarrow^c \\rangle \\) is a computation and next show that it is a controlling computation.\n\nIf \\( \\langle E, \\rightarrow^c \\rangle \\) is not a computation, then \\( \\rightarrow^c \\) is not an irreflexive partial order. Since \\( \\rightarrow^c \\) is transitive by definition, it must be reflexive. Therefore, \\( \\rightarrow \\cup \\rightarrow^c \\) must have a cycle, say \\( X \\). Since \\( \\langle E, \\rightarrow \\rangle \\) is a computation, there can be no cycle that involves no \\( \\sim^c \\) edges. Therefore, let \\( CS_i.next.first \\sim^c CS_{i+1}.first \\) be the \\( \\sim^c \\) edge in \\( X \\) such that \\( i \\) has the maximum value. Let \\( CS_j.next.first \\sim^c CS_{j+1}.first \\) be\nthe next \\( \\sim \\) edge in the cycle \\( X \\) (note that it is possible that \\( i = j \\)). Therefore, \\( CS_{i+1}.first \\rightarrow CS_j.next.first \\). Since by definition two critical sections are not contiguous, the equality cannot hold. Therefore, \\( CS_{i+1}.first \\rightarrow CS_j.next.first \\) and so, \\( CS_{i+1} \\rightarrow CS_j \\). By [A], we have: \\( i + 1 \\leq j \\) and so \\( i < j \\). This contradicts the choice of \\( i \\) as maximum. Therefore, \\( \\langle E, \\rightarrow \\rangle \\) is a computation.\n\nBefore showing that \\( \\langle E, \\rightarrow \\rangle \\) is a controlling computation, we first prove a claim:\n\n**Claim 1:** For all critical sections \\( CS_i \\) and \\( CS_j \\) such that \\( i < j \\), if \\( CS_i.next \\neq null \\) and \\( CS_j.prev \\neq null \\) then \\( CS_i.next.first \\rightarrow^c CS_j.first \\).\n\n**Proof:** (by induction on \\( j - i \\))\n\n*Base Case:* \\( j - i = 1 \\)\n\nDirectly from the definition of \\( \\sim \\).\n\n*Inductive Case:* \\( j - i > 1 \\)\n\nConsider two critical sections \\( CS_i \\) and \\( CS_j \\) such that \\( i < j \\) and \\( CS_i.next \\neq null \\) and \\( CS_j.prev \\neq null \\). We have two cases:\n\n**Case 1:** \\( CS_{j-1}.prev = null \\)\n\nTherefore, by definition, \\( CS_{j-1} \\rightarrow CS_i \\). By [A], we have \\( j - 1 \\leq i \\). Together with \\( i < j \\), this implies \\( j = i + 1 \\), which violates the inductive case assumption.\n\n**Case 2:** \\( CS_{j-1}.prev \\neq null \\)\n\nBy the inductive hypothesis, we have: \\( CS_i.next.first \\rightarrow^c CS_{j-1}.first \\). –[III]\n\nConsider two sub-cases:\n\n**Case a:** \\( CS_{j-1}.next = null \\)\n\nTherefore, by definition, \\( CS_j \\rightarrow CS_{j-1} \\). By [A], we have \\( j \\leq j - 1 \\) giving a contradiction.\n\n**Case b:** \\( CS_{j-1}.next \\neq null \\)\n\nSince by the choice of \\( j \\), \\( CS_j.prev \\neq null \\), we have by the definition of\n\\[ CS_{j-1}.next.first \\sim^c CS_j.first \\]. Together with [III], by transitivity, this gives: \\[ CS_i.next.first \\rightarrow^c CS_j.first \\].\n\n\\(\\square\\) (Proof of Claim)\n\nWe now show that \\( \\langle E, \\rightarrow^c \\rangle \\) is a controlling computation. Suppose it is not. Then, let \\( C \\) be a consistent cut in \\( \\langle E, \\rightarrow^c \\rangle \\) such that \\( \\neg \\phi_{mutex}(C) \\). Therefore, we have distinct \\( i \\) and \\( j \\) such that \\( critical(C[i]) \\) and \\( critical(C[j]) \\).\n\nLet \\( C[i] \\in CS_k \\) and \\( C[j] \\in CS_l \\). Without loss of generality, \\( k < l \\). (Since \\( i \\neq j, k \\neq l \\)).\n\nConsider two cases:\n\n**Case 1:** \\( CS_k.next = null \\lor CS_l.prev = null \\)\n\nTherefore, by definition, \\( CS_l \\rightarrow CS_k \\). By [A], \\( l \\leq k \\), contradicting \\( k < l \\).\n\n**Case 2:** \\( CS_k.next \\neq null \\land CS_l.prev \\neq null \\)\n\nTherefore, by Claim 1, we have: \\( CS_k.next.first \\rightarrow^c CS_l.first \\). Since \\( C[i] \\in CS_k \\), we have: \\( C[i].next \\leq CS_k.next.first \\) and since \\( C[j] \\in CS_j \\), we have: \\( CS_l.first \\leq C[j] \\). Therefore, by transitivity, \\( C[i].next \\rightarrow^c C[j] \\), violating the consistency of \\( C \\).\n\n\\(\\square\\)\n\n**Algorithm Description**\n\nThe proof of the above theorem provides a simple algorithm for finding a controlling computation based on topologically sorting the interval graph of critical sections.\n\nWe provide a more efficient algorithm in Figure 3.4, making use of the fact that the critical sections in a process are totally ordered. The central idea used in the algorithm is to maintain a frontier of critical sections \\( (CS_1, \\cdots, CS_n) \\) that advances from the start of the computation to the end. Instead of finding a minimal critical\nFigure 3.4: Algorithm for Predicate Control of the Mutual Exclusion Predicate\nsection of the whole interval graph, we merely find the minimal critical section in the current frontier. It is guaranteed to be a minimal critical section of the remaining critical sections in the interval graph at that point. Therefore, this procedure achieves a topological sort.\n\nThe main while loop of the algorithm executes $p$ times in the worst case, where $p$ is the number of critical sections in the computation. Each iteration takes $O(n^2)$, since it must compute the $valid_{cs}$. Thus, a simple implementation of the algorithm will have a time complexity of $O(n^2p)$. However, a better implementation of the algorithm would amortize the cost of computing $valid_{cs}$ over multiple iterations of the loop. Each iteration would compare each of the critical sections that has newly reached the head of its list with the existing critical sections. Therefore, each of the $p$ critical section reaches the head of the list just once, when it is compared with $n - 1$ critical sections. The time complexity of the algorithm with this improved implementation is, therefore, $O(np)$. Note that a naive algorithm based directly on the constructive proof of the sufficient condition in Theorem 5 would take $O(p^2)$. We have reduced the complexity significantly by using the fact that the critical sections in a process are totally ordered.\n\nWe next prove the correctness of the algorithm.\n\n**Lemma 15** The algorithm in Figure 3.4 is well-specified.\n\n**Proof:** To prove that the algorithm is well-specified, the only non-trivial check is for the term $curr.next.first$ at line L23. To show that $curr.next \\neq null$ at this point, we prove that, after the termination of loop L13-L19, for all critical sections $c$ in chain : ($c.next = null$) $\\Rightarrow$ ($c = chain.head$). Let $c$ be a critical section in chain such that $c.next = null$. Consider the point when $c$ is about to be added to chain in line L18. Since $c \\in valid_{cs}$, we have $\\forall c' \\in valid_{cs}$ : ($c' \\neq c$) $\\Rightarrow$ ($c' \\not\\rightarrow c$)\n\nHowever, since $c.next = null$, we have $\\forall c' \\in C$ : $c' \\not\\rightarrow c$. Therefore, $c$ is the only\nelement of valid\\textsubscript{cs} at this point. It follows that after line L19, \\( CS = \\emptyset \\) and the loop terminates. Therefore, after the termination of loop L13-L19, \\( c = chain.head \\).\n\nThe algorithm terminates since the loop L13-L19 advances one critical section in each iteration and the loop L20-L24 decreases \\( chain \\) by one critical section in each iteration. □\n\n**Lemma 16** If the algorithm in Figure 3.4 exits at line L16, then no controlling computation exists.\n\n**Proof:** At the point of exit at line 16 \\( valid\\textsubscript{cs} = \\emptyset \\). Therefore, the graph \\( \\langle CS, \\mapsto \\rangle \\) has no minimal element. Since \\( CS \\neq \\emptyset \\) (by the terminating condition at line L13), there must be a non-trivial cycle in \\( \\langle CS, \\mapsto \\rangle \\). Therefore, by Theorem 4, no controlling computation exists. □\n\n**Lemma 17** If the algorithm in Figure 3.4 terminates normally, then \\( \\langle E, \\rightarrow^c \\rangle \\) is a controlling computation of \\( \\phi_{mutex} \\) in \\( \\langle E, \\rightarrow \\rangle \\), where \\( \\rightarrow^c \\) is the transitive closure of the union of \\( \\rightarrow \\) with the set of edges in \\( O \\).\n\n**Proof:** We show that, at the termination of loop L13-L19, \\( chain \\) is a topological sort of the graph \\( \\langle C, \\mapsto \\rangle \\). Then, since lines L20-L24 construct the same \\( \\sim \\rightarrow^c \\) relation as in the proof of Theorem 5, \\( \\langle E, \\rightarrow^c \\rangle \\) is a controlling computation of \\( \\phi_{mutex} \\) in \\( \\langle E, \\rightarrow \\rangle \\).\n\nLet \\( chain.set \\) denote the set of intervals in \\( chain \\). First, we note that the algorithm maintains the following invariant:\n\n\\[ \\text{INV1: } \\forall c \\in C : c \\prec CS_{c,\\text{proc}} \\Rightarrow c \\in chain.set \\]\n\nNext, consider the point just before L17, when \\( crossed \\) is about to be added to \\( chain \\). Let \\( c \\) be any critical section in \\( C - chain.set \\) such that \\( c \\neq crossed \\). By INV1, we have \\( CS_{c,\\text{proc}} \\leq c \\). If \\( c \\mapsto crossed \\) then \\( CS_{c,\\text{proc}} \\mapsto crossed \\), contradicting \\( crossed \\in valid\\textsubscript{cs} \\). Therefore, \\( c \\not\\mapsto crossed \\). Therefore, \\( crossed \\) is minimal in \\( \\langle C - chain.set, \\mapsto \\rangle \\). Therefore, \\( chain \\) is a topological sort of \\( \\langle C, \\mapsto \\rangle \\). □\nTheorem 6 The algorithm in Figure 3.4 solves the predicate control problem for the mutual exclusion predicate.\n\nProof: This follows directly from Lemmas 15, 16, and 17. □\n\n3.6 Readers Writers Predicates\n\nLet critical_1, critical_2, ⋯, critical_n be n local predicates and let critical(e) \\equiv critical_{e, proc}(e) and let a critical section (non-critical section) denote a true (false) interval in ⟨E, →⟩ with respect to critical_1, critical_2, ⋯, critical_n.\n\n- **(read-critical/write-critical)**: A critical section is either read-critical or write-critical.\n\n- **(write-critical(I))**: We define write-critical(I) to be true for a write-critical section I and false for all other intervals. We also say write-critical(e) for all events e in a write-critical section.\n\n- **(read-critical(I))**: We define read-critical(I) to be true for a read-critical section I and false for all other intervals. We also say read-critical(e) for all events e in a read-critical section.\n\n- **(readers writers predicate)**: The readers writers predicate \\(\\phi_{rw}\\) is defined as:\n\n\\[\n\\phi_{rw}(C) \\equiv \\forall \\text{distinct } i, j : \\neg (\\text{critical}(C[i]) \\land \\text{write-critical}(C[j]))\n\\]\n\nThe readers writers predicate is a generalized form of mutual exclusion allowing critical sections to be read or write-critical. Two critical sections cannot enter at the same time if one of them is write-critical. The next two theorems establish the necessary and sufficient conditions for solving the predicate control problem for readers writers predicates. Since the algorithm that will be presented in Section 3.8\nis applied to readers writers predicates without significant simplification, we do not present a specialized algorithm for readers writers predicates.\n\n**Theorem 7** Let \\( \\langle I, \\mapsto \\rangle \\) be the interval graph of a computation \\( \\langle E, \\rightarrow \\rangle \\) under local predicates critical\\(_1\\), critical\\(_2\\), \\ldots, critical\\(_n\\). If \\( \\langle I, \\mapsto \\rangle \\) contains a non-trivial cycle of critical sections containing at least one write-critical section, then there is no controlling computation of \\( \\phi_{rw} \\) in \\( \\langle E, \\rightarrow \\rangle \\).\n\n**Proof:**\nWe prove the result by contradiction. In interval graph \\( \\langle I, \\mapsto \\rangle \\), let \\( X \\) be a non-trivial cycle of critical sections containing a write-critical section \\( W \\). Let \\( \\langle E, \\rightarrow^c \\rangle \\) be a controlling computation of \\( \\phi_{mutex} \\) in \\( \\langle E, \\rightarrow \\rangle \\). Let \\( <^c \\) be a linearization of \\( \\rightarrow^c \\) forming a controlling run \\( \\langle E, <^c \\rangle \\) (by 2).\n\nWe next show that there is a consistent cut \\( C \\) in the run \\( \\langle E, <^c \\rangle \\) such that \\( \\neg \\phi_{rw}(C) \\) contradicting the fact that \\( \\langle E, <^c \\rangle \\) is a controlling computation. Consider two cases:\n\n**Case 1:** \\( W.next = \\text{null} \\):\nLet \\( CS \\) be the critical section following \\( W \\) in \\( X \\). Since \\( X \\) is non-trivial, \\( CS \\neq W \\). Consider two cases:\n\n**Case a:** \\( CS.next = \\text{null} \\): Let \\( C \\) be the maximum cut in the run \\( \\langle E, \\rightarrow \\rangle \\). It is easy to verify that \\( C \\) is consistent (as in any computation). Since \\( W.next = \\text{null} \\) and \\( CS.next = \\text{null} \\), \\( \\neg \\phi_{rw}(C) \\).\n\n**Case b:** \\( CS.next \\neq \\text{null} \\): Let \\( e = CS.next.first \\) and \\( C' = lcc(e) \\). Consider two cases:\n\n\\( W.prev = \\text{null} \\): Since \\( W.first \\in \\bot \\), we have \\( W.first \\preceq C'[W.proc] \\).\n\n\\( W.prev \\neq \\text{null} \\): Since \\( W \\mapsto CS \\), we have \\( W.first \\rightarrow e \\) and so, \\( W.first <^c e \\). Therefore, since \\( C' \\) is consistent, \\( W.first \\preceq C'[W.proc] \\).\nIn both cases, \\( W.first \\preceq C'[W.proc] \\) \\[-A\\]\n\nSince \\( W.next = \\text{null} \\), we have: \\( C'[W.proc] \\preceq W.last \\) \\[-B\\]\n\nBy \\([A]\\) and \\([B]\\), \\( C'[W.proc] \\in W \\) and so \\( \\text{write}_{\\cdot \\text{critical}}(C'[W.proc]). \\) Let \\( C = \\text{lcc-prev}(e) \\). Since, \\( \\forall j : j \\neq e.proc : C[j] = C'[j] \\), we have: \\( \\text{write}_{\\cdot \\text{critical}}(C[W.proc]). \\) Further, since \\( e = CS.next.first \\), we have \\( C[CS.proc] = CS.last \\) and therefore, \\( \\text{critical}(C[CS.proc]). \\) So, \\( \\neg \\phi_{rw}(C). \\)\n\nAlso, by Lemma 6, \\( C \\) is consistent.\n\n**Case 2: \\( W.next \\neq \\text{null} \\):**\n\nLet \\( C' = \\text{lcc-prev}(W.next.first) \\). If there is a \\( CS \\) in \\( X \\) distinct from \\( W \\) such that: \\( CS.first \\preceq C'[CS.proc] \\preceq CS.last \\), then since \\( C' \\) is consistent and \\( \\neg \\phi_{rw}(C), \\) we are done. Therefore, assume that for all critical sections \\( CS \\) in \\( X \\) distinct from \\( W \\): \\( (C'[CS.proc] \\prec CS.first) \\lor (CS.last \\prec C'[CS.proc]). \\) \\[-D\\]\n\nLet \\( CS_1 \\) and \\( CS_2 \\) be any two consecutive critical sections in \\( X \\). Suppose that \\( CS_2.first \\preceq C'[CS_2.proc]. \\) \\[-E\\]\n\nTherefore, applying \\([D]\\), we have: \\( CS_2.last \\prec C'[CS_2.proc]. \\) \\[-F\\]\n\nConsider two cases:\n\n**Case a: \\( CS_1.prev = \\text{null} \\):** In this case, since \\( CS_1.first \\in \\bot \\) we have:\n\n\\( CS_1.first \\preceq C'[CS_1.proc]. \\)\n\n**Case b: \\( CS_1.prev \\neq \\text{null} \\):** Since \\( CS_1 \\mapsto CS_2 \\) and since \\( CS_2.next \\neq \\text{null} \\) (from \\([F]\\)), we have: \\( CS_1.first \\rightarrow CS_2.next.first \\). This, together with \\([F]\\) and transitivity gives us: \\( CS_1.first \\in C'.past \\). Since \\( C' \\) is consistent, \\( CS_1.first \\preceq C'[CS_1.proc]. \\)\n\nTherefore, in both cases: \\( CS_1.first \\preceq C'[CS_1.proc]. \\) Combining this with our supposition \\([E]\\), we have: \\( \\forall CS_1, CS_2 \\in X : CS_2.first \\preceq C'[CS_2.proc] \\Rightarrow \\)\n\\[ CS_1.first \\preceq C'[CS_1.proc]. \\] Therefore, since \\( W.first \\preceq C'[W.proc] \\) (by the definition of \\( C' \\)), we have: \\( \\forall CS \\in X : CS.first \\preceq C'[CS.proc]. \\) Combining this with [D] we have: \\( \\forall CS \\in X : CS = W \\lor CS.next.first \\preceq C'[CS.proc]. \\) –[G]\n\nLet \\( CS \\) be the critical section following \\( W \\) in the cycle \\( X \\).\n\nLet \\( C = lcc-prev(CS.next.first) \\). From [G], \\( CS.next.first \\preceq C'[CS.proc] \\), and so: \\( C[CS.proc] < C'[CS.proc]. \\) Therefore, by Lemma 7 we have: \\( C < C' \\).\n\nSo, we have: \\( C[W.proc] \\preceq C'[W.proc] \\). Using the definition of \\( C' \\): \\( C[W.proc] \\preceq W.last. \\) –[H]\n\nConsider three cases:\n\n**Case a:** \\( W.prev = null \\)\n\nTherefore, \\( W.first \\in \\perp \\) and so \\( W.first \\preceq C[W.proc]. \\)\n\n**Case b:** \\( W.proc = CS.proc \\)\n\nIn this case, \\( W < CS \\) and, therefore, \\( W.first \\preceq C[w.proc]. \\)\n\n**Case c:** \\( W.prev \\neq null \\land W.proc \\neq CS.proc \\)\n\nSince \\( W \\rightarrow CS \\) and \\( CS.next \\neq null \\) (because of [G]), we have: \\( W.first \\rightarrow CS.next.first. \\) Therefore, \\( W.first \\in lcc(CS.next.first).past. \\) By the consistency of \\( lcc(CS.next.first) \\), we have:\n\n\\( W.first \\preceq lcc(CS.next.first)[W.proc]. \\) Since \\( W.proc \\neq CS.proc \\), by the definition of \\( lcc-prev \\):\n\n\\[ lcc-prev(CS.next.first)[W.proc] = lcc(CS.next.first)[W.proc]. \\]\n\nTherefore, \\( W.first \\preceq C[W.proc]. \\)\n\nIn all cases: \\( W.first \\preceq C[W.proc]. \\) This, together with [H], gives us:\n\n\\( C[W.proc] \\in W. \\) Therefore, \\( write.critical(C[W.proc]) \\), and by the definition of \\( C \\), we have \\( critical(C[CS.proc]). \\) Therefore, \\( \\neg \\phi_{rw}(C). \\) Further \\( C \\) is consistent by definition.\n\n53\nTheorem 8 Let $\\langle I, \\rightarrow \\rangle$ be the interval graph of a computation $\\langle E, \\rightarrow \\rangle$ under local predicates critical$_1$, critical$_2$, · · · , critical$_n$. If $\\langle I, \\rightarrow \\rangle$ does not contain a non-trivial cycle of critical sections containing at least one write-critical section, then there is a controlling computation of $\\phi_{rw}$ in $\\langle E, \\rightarrow \\rangle$.\n\nProof: Let $\\mathcal{C}$ be the set of critical sections in $\\mathcal{I}$. Let $\\rightarrow$ denote the relation $\\rightarrow$ restricted to the set $\\mathcal{C}$. Let $\\mathcal{S}$ be the set of strongly connected components of the graph $\\langle \\mathcal{C}, \\rightarrow \\rangle$. Let $\\mapsto$ be a relation defined on strongly connected components as:\n\n$$\\text{SCC } \\mapsto \\text{SCC'} \\equiv \\exists CS \\in \\text{SCC}, CS' \\in \\text{SCC'} : CS \\rightarrow CS'$$\n\nClearly, $\\mapsto$ is a partial order on $\\mathcal{S}$. Therefore, we can topologically sort the graph $\\langle \\mathcal{S}, \\mapsto \\rangle$ to give a sequence of strongly connected components:\n\n$$\\text{SCC}_1, \\text{SCC}_2, \\cdots, \\text{SCC}_l$$\n\nsuch that $\\text{SCC}_i \\mapsto \\text{SCC}_j \\Rightarrow i \\leq j$ – [A]\n\nDefine a relation $\\sim^c$ on events in $E$ as the set of tuples:\n\n$$\\{ (CS_i, \\text{next.first}, CS_j, \\text{first}) \\mid CS_i, \\text{next} \\neq \\text{null} \\land CS_j, \\text{prev} \\neq \\text{null} \\land \\exists k \\in \\{1, \\cdots, l-1\\} : CS_i \\in \\text{SCC}_k \\land CS_j \\in \\text{SCC}_{k+1} \\}$$\n\nDefine $\\rightarrow^c$ to be the transitive closure of $\\rightarrow \\cup \\sim^c$.\n\nWe first show by contradiction that $\\langle E, \\rightarrow^c \\rangle$ is a computation. If it is not, then there must be a cycle, say $X$, in the graph $\\langle E, \\rightarrow \\cup \\sim^c \\rangle$. Since $\\langle E, \\rightarrow \\rangle$ is a computation, $X$ must have at least one $\\sim^c$ edge. Consider the set of $\\sim^c$ edges in $X$, and let $CS_i, \\text{next.first} \\sim^c CS_j, \\text{first}$ be the edge such that $CS_i$ belongs to the maximum strongly connected component (among such edges) in the topological sorted order (i.e. $CS_i \\in \\text{SCC}_k$ and $k$ has the maximum value). Let $CS_i \\in \\text{SCC}_k$, and so, $CS_j \\in \\text{SCC}_{k+1}$. Let $CS_a, \\text{next.first} \\sim^c CS_b, \\text{first}$ be the next $\\sim^c$ edge in the cycle $X$ (note that it is possible that $a = i$). Therefore, $CS_j, \\text{first} \\rightarrow CS_a, \\text{next.first}$. Since, by definition, two critical sections cannot be contiguous, the equality cannot hold. Therefore, $CS_j, \\text{first} \\rightarrow CS_a, \\text{next.first}$, and so, by definition, $CS_j \\rightarrow CS_a$. So, if $CS_a \\in \\text{SCC}_p$, we have: $\\text{SCC}_{k+1} \\rightarrow \\text{SCC}_p$. Therefore, by [A], $k + 1 \\leq p$\nand so $k < p$. This contradicts the choice of $k$ as maximum. Therefore, $\\langle E, \\rightarrow^c \\rangle$ is a computation.\n\nBefore showing that $\\langle E, \\rightarrow^c \\rangle$ is a controlling computation, we first prove a claim:\n\n**Claim 1:** For all critical sections $CS \\in SCC_p$ and $CS' \\in SCC_q$ such that $p < q$, if $CS.next \\neq \\text{null}$ and $CS'.prev \\neq \\text{null}$, then: $CS.next.first \\rightarrow^c CS'.first$.\n\n**Proof:** (by induction on $q - p$)\n\n*Base Case: $(q - p = 1)$:* Directly from the definition of $\\sim^c$.\n\n*Inductive Case: $(q - p \\neq 1)$:* Let $CS \\in SCC_p$ and $CS' \\in SCC_q$ such that $p < q$, if $CS.next \\neq \\text{null}$ and $CS'.prev \\neq \\text{null}$. Let $CS''$ be any critical section in $SCC_{q-1}$.\n\nWe have two cases:\n\n**Case 1:** ($CS''.prev = \\text{null}$):\n\nTherefore, by definition: $CS'' \\mapsto CS$, and so $SCC_{q-1} \\mapsto SCC_p$. Using [A], we have: $(q - 1) \\leq p$. Together with $p < q$, this implies that: $q = p + 1$ which violates the inductive case assumption.\n\n**Case 2:** ($CS''.prev \\neq \\text{null}$):\n\n*Subcase 2.1: ($CS''.next = \\text{null}$)*\n\nTherefore, by definition, $CS' \\mapsto CS''$, and so $SCC_q \\mapsto SCC_{q-1}$. Using [A], it follows that $q \\leq (q - 1)$. Thus, we have a contradiction.\n\n*Subcase 2.2: ($CS''.next \\neq \\text{null}$)*\n\nTherefore, $CS''.next.first \\sim^c CS'.first$. Further, by the inductive hypothesis, $CS.next.first \\rightarrow^c CS''.first$. If follows, by transitivity, that: $CS.next.first \\rightarrow^c CS''.first$.\n\n$\\square$ (Proof of Claim 1)\nWe now show that \\( \\langle E, \\rightarrow \\rangle \\) is a controlling computation. Suppose it is not. Then, let \\( C \\) be a consistent cut of \\( \\langle E, \\rightarrow \\rangle \\) such that \\( \\neg \\phi_{rw}(C) \\). Therefore, we have distinct \\( i \\) and \\( j \\) such that write\\_critical\\( (C[i]) \\) and critical\\( (C[j]) \\). Let \\( C[i] \\in CS \\) and \\( C[j] \\in CS' \\). Further let, \\( CS \\in SCC_p \\) and \\( CS \\in SCC_q \\). Without loss of generality, let \\( p \\leq q \\). Consider two cases:\n\n**Case 1: \\( p = q \\):**\n\nIn this case, both \\( CS \\) and \\( CS' \\) are in the same strongly connected component of \\( \\langle C, \\mapsto \\rangle \\). Further \\( CS \\) is a write-critical section and \\( CS' \\) is a distinct critical section. Therefore, there is a non-trivial cycle of critical sections in \\( \\langle I, \\mapsto \\rangle \\) containing a write-critical section, thus, contradicting the assumptions.\n\n**Case 2: \\( p < q \\):**\n\n**Subcase 2.1:** \\( CS.next = \\text{null} \\lor CS'.prev = \\text{null} \\):\n\nTherefore, by definition, \\( CS' \\mapsto CS \\), and so, \\( SCC_q \\mapsto SCC_p \\). Using [A], we have: \\( q \\leq p \\) which is a contradiction.\n\n**Subcase 2.2:** \\( CS.next \\neq \\text{null} \\land CS'.prev \\neq \\text{null} \\):\n\nTherefore, by Claim 1, we have: \\( CS.next.first \\rightarrow c CS'.first \\). Since \\( C[i] \\in CS \\), we have: \\( C[i].next \\preceq CS.next.first \\) and since \\( C[j] \\in CS' \\), we have: \\( CS'.first \\preceq C[j] \\). Therefore, by transitivity, \\( C[i].next \\rightarrow c C[j] \\) violating the consistency of \\( C \\).\n\n\\( \\square \\)\n\n### 3.7 Independent Mutual Exclusion Predicates\n\nLet \\( \\text{critical}_1, \\text{critical}_2, \\ldots, \\text{critical}_n \\) be \\( n \\) local predicates and let \\( \\text{critical}(e) \\equiv \\text{critical}_{e.proc}(e) \\) and let a critical section (non-critical section) denote a true (false) interval in \\( \\langle E, \\rightarrow \\rangle \\) with respect to \\( \\text{critical}_1, \\text{critical}_2, \\ldots, \\text{critical}_n \\).\n\n- \\( \\langle k\\text{-critical} \\rangle \\): A critical section is \\( k \\)-critical for some \\( k \\in \\{1, \\ldots, m\\} \\).\n• \\langle k_{\\text{critical}}(I) \\rangle : We define \\( k_{\\text{critical}}(I) \\) to be true for a \\( k \\)-critical section \\( I \\) and false for all other intervals. We also say \\( k_{\\text{critical}}(e) \\) for all events \\( e \\) in a \\( k \\)-critical section.\n\n• (independent mutual exclusion predicate) : The independent mutual exclusion predicate \\( \\phi_{\\text{ind}} \\) is defined as:\n\n\\[\n\\phi_{\\text{ind}}(C) \\equiv \\forall \\text{ distinct } i, j : \\forall k : \\neg (k_{\\text{critical}}(C[i]) \\land k_{\\text{critical}}(C[j]))\n\\]\n\nThe independent mutual exclusion predicate is a generalized form of mutual exclusion allowing critical sections to have types in \\( k \\in \\{1, \\cdots m\\} \\). Two critical sections cannot enter at the same time if they are of the same type. The next result shows us that the problem becomes hard for this generalization. However, we will determine sufficient conditions for solving it that allow us to solve the problem efficiently under certain conditions.\n\n**Theorem 9** The predicate control problem for the independent mutual exclusion predicate is NP-Complete.\n\n**Proof:**\n\nLet PC-IND denote the predicate control problem for the independent mutual exclusion predicate. PC-IND is in NP for the same reasons that the general Predicate Control problem is in NP. We prove that PC-IND is NP-Hard by transforming 3SAT.\n\nLet \\( U = \\{u_1, u_2, \\cdots u_w\\} \\) be a set of variables, and \\( C = \\{c_1, c_2, \\cdots c_x\\} \\) be a set of clauses, forming an instance of 3SAT. Let \\( l_{i1}, l_{i2}, l_{i3} \\) be the three literals in clause \\( c_i \\).\n\nTo construct an instance of PC-IND from this instance of 3SAT, we first construct a set of events \\( E \\) as follows:\n\n• For each clause \\( c_i \\) define 6 processes with event sets \\( E_{i1}, E_{i2}, E_{i3}, \\cdots, E_{i6} \\). Each \\( E_{ip} \\) has two events denoted by \\( e_{ip1} \\) and \\( e_{ip2} \\). Let \\( E_i = E_{i1} \\cup E_{i2} \\cup \\cdots \\cup E_{i6} \\).\n• For each variable $u_r$ define 2 processes with event sets $E'_{r1}, E'_{r2}$. Each $E'_{rq}$ has two events denoted by $e'_{rq1}$ and $e'_{rq2}$. Let $E'_r = E'_{r1} \\cup E'_{r2}$.\n\nLet $E = \\bigcup_i E_i \\cup \\bigcup_r E'_r$ and $n = |E| = 2w + 6x$.\n\nLet $\\sim$ be a relation on $E$ defined as follows:\n\n• Within each $E_i$: $e_{i22} \\sim e_{i31}, e_{i42} \\sim e_{i51}, e_{i62} \\sim e_{i11}$\n\n• For each literal $l_{ip} \\in c_i$ such that $l_{ip} = u_r$ for some variable $u_r$:\n $e_{i(2p)1} \\sim e'_{r12}, e'_{r11} \\sim e_{i(2p-1)1}, e_{i(2p-1)1} \\sim e'_{r12}, e'_{r11} \\sim e_{i(2p)1}$\n\n• For each literal $l_{ip} \\in c_i$ such that $l_{ip} = \\overline{u_r}$ for some variable $u_r$:\n $e_{i(2p)1} \\sim e'_{r12}, e'_{r21} \\sim e_{i(2p-1)1}, e_{i(2p-1)1} \\sim e'_{r22}, e'_{r11} \\sim e_{i(2p)1}$\n\nLet $\\prec$ be a relation on $E$ such that the local events in an $E_{ip}$ or an $E'_{rq}$ are totally ordered by $\\prec$ so that: $e_{ip1} \\prec e_{ip2}$ and $e'_{rq1} \\prec e'_{rq2}$.\n\nFigure 3.5: Proof: PC-IND is NP-Complete\n\nLet $\\rightarrow$ be the transitive closure of $\\sim \\cup \\prec$. To show that $\\rightarrow$ is irreflexive, we prove that there are no cycles in the graph $\\langle E, \\sim \\cup \\prec \\rangle$. Any event in an $E'_{rq}$ has either incoming or outgoing edges but not both. Therefore, no event in an $E'_{rq}$ can be involved in a cycle. Since any distinct $E_i$ and $E_j$ have no edges between\nthem, the only remaining possibility is a cycle within an \\( E_i \\). Considering only edges within \\( E_i \\), any \\( E_{ip} \\) has either incoming edges to its events or outgoing edges from its events but not both. Further, there are no cycles within an \\( E_{ip} \\). Therefore, there is no cycle within an \\( E_i \\). Thus, we have shown that \\( \\rightarrow \\) is irreflexive. Clearly, \\( \\rightarrow \\) is also transitive and so, \\( \\langle E, \\rightarrow \\rangle \\) is a computation.\n\nDefine local predicates \\( \\text{critical}_1, \\text{critical}_2, \\ldots, \\text{critical}_n \\), such that each process consists of exactly one critical section containing only its first event. So, for each \\( E_{ip} \\), there is exactly one critical section, \\( CS_{ip} = \\{ e_{ip1} \\} \\) and for each \\( E'_{rq} \\), there is exactly one critical section \\( CS'_{rq} = \\{ e'_{rq1} \\} \\).\n\nThe critical sections in an \\( E_i \\) are \\( i \\text{-critical} \\) and the critical sections in an \\( E'_r \\) are \\( (x + r) \\text{-critical} \\). Therefore, there are \\( m = (x + w) \\) independent types of critical sections. Define global predicate \\( \\phi_{ind} \\) based on these critical section definitions.\n\nThus, we have a polynomial construction from an instance \\((U, C)\\) of 3SAT to an instance \\((\\langle E, \\rightarrow \\rangle, \\phi_{ind})\\) of PC-IND. We next show that the construction is indeed a transformation.\n\n**Part 1:** Let \\( t \\) be a truth assignment on variables in \\( U \\) such that \\( t \\) satisfies the set of clauses in \\( C \\). Define a relation \\( \\sim^{c1} \\) on \\( E \\) as follows:\n\n- For each variable \\( u_r \\):\n - if \\( t(u_r) = true \\) then \\( e'_{r22} \\sim^{c1} e'_{r11} \\)\n - if \\( t(u_r) = false \\) then \\( e'_{r12} \\sim^{c1} e'_{r21} \\)\n\n- For each literal \\( l_{ip} \\) in a clause \\( c_i \\):\n - if \\( l_{ip} \\) is \\( true \\) under \\( t \\) then \\( e_{i(2p)2} \\sim^{c1} e_{i(2p-1)1} \\)\n - if \\( l_{ip} \\) is \\( false \\) under \\( t \\) then \\( e_{i(2p-1)2} \\sim^{c1} e_{i(2p)1} \\)\n\nFor any \\( i \\), let \\( C_i \\) denote the set of 6 critical sections in \\( E_i \\). Define \\( \\sim^{c1}_i \\) relation on \\( C_i \\) as:\n\n\\[\n\\forall j, k \\in \\{1, \\ldots, 6\\} : \\ C S_{ij} \\sim^{c1}_i C S_{ik} \\equiv e_{ij2} \\sim^{c1} e_{ik1} \\lor e_{ij2} \\sim e_{ik1}\n\\]\nDepending on whether each \\( l_i p \\) is true or false under \\( t \\), we have 8 cases (by the definition of \\( \\sim_i^{c1} \\)). Since \\( t \\) satisfies clause \\( c_i \\), at least one of \\( l_{i1}, l_{i2}, l_{i3} \\) must be true under \\( t \\), and one of the cases is not possible. It is easy to verify that for each of the remaining 7 cases, there are no cycles in the graph \\( \\langle C_i, \\rightarrow_i^{c1} \\rangle \\).\n\nTherefore, we can topologically sort \\( \\langle C_i, \\rightarrow_i^{c1} \\rangle \\). Consider a topological sort in which all the maximal critical sections are selected last. Therefore, if \\( p_i \\) is a permutation of \\( \\{1, \\cdots, 6\\} \\) representing the topological sort, then:\n\n**TOP1:** \\( \\forall j, k : CS_{ij} \\rightarrow_i^{c1} CS_{ik} \\Rightarrow p_i(j) < p_i(k) \\), and\n\n**TOP2:** \\( \\forall j : CS_{ij} \\) is maximal in \\( \\langle C_i, \\rightarrow_i^{c1} \\rangle \\) \\( \\Rightarrow (\\forall k : p_i(k) > p_i(j) \\Rightarrow CS_{ik} \\) is maximal in \\( \\langle C_i, \\rightarrow_i^{c1} \\rangle ) \\)\n\nDefine a relation \\( \\sim_i^{c2} \\) on \\( E \\) that orders critical sections in \\( C_i \\) in the topologically sorted order as follows:\n\n- In each \\( E_i \\):\n \\[ \\forall j, k : (p_i(j) = p_i(k) - 1 \\land CS_j \\not\\rightarrow_i^{c1} CS_k) \\Rightarrow e_{ij2} \\sim_i^{c2} e_{ik1} \\]\n\nLet \\( \\rightarrow^c \\) be the transitive closure of \\( \\rightarrow \\cup \\sim_i^{c1} \\cup \\sim_i^{c2} \\). We next prove that \\( \\rightarrow^c \\) is irreflexive. This is equivalent to proving the following:\n\n**Claim 1:** There is no cycle in \\( \\prec \\cup \\sim \\cup \\sim_i^{c1} \\cup \\sim_i^{c2} \\).\n\n**Proof:** We consider three cases for a cycle and prove that each case is not possible.\n\n**Case 1:** A cycle within an \\( E_{ij}^r \\): The cycle cannot be within a single \\( E_{r}^{r'} \\) since there is only one edge (\\( \\prec \\)) between the two events. Since \\( t \\) assigns either true or false to variable \\( u_r \\), there is only one edge (\\( \\sim_i^{c1} \\)) between \\( E_{r}^{r'} \\) and \\( E_{r}^{r'} \\). Therefore, there can be no cycles within an \\( E_{r}^{r'} \\).\n\n**Case 2:** A cycle within an \\( E_i \\): The cycle cannot be within a single \\( E_{ij} \\) since there is only one edge (\\( \\prec \\)) between the two events. We prove by contradiction that there cannot be a cycle intersecting multiple \\( E_{ij} \\)'s. Suppose there is such a cycle \\( X \\). Among all the intersected \\( E_{ij} \\)'s, consider \\( E_{ik} \\) such that \\( p_i(k) = \\)}\n$$\\max\\{p_i(j) : E_{ij} \\cap X \\neq \\emptyset\\}$$ (i.e. $CS_{ik}$ is the last critical section in the topological sort of $\\rightarrow_i^{c1}$ among all intersected $CS_{ij}$'s). Let the cycle $X$ intersect $E_{il}$ immediately after $E_{ik}$. Therefore, there must be an edge ($\\sim$, $\\sim^{c1}$, or $\\sim^{c2}$) from $e_{ik2}$ to $e_{il1}$. Therefore, either it is a $\\sim^{c2}$ edge or $CS_{ik} \\rightarrow_i^{c1} CS_{il}$. So, using the definition of $\\sim^{c2}$ or TOP1, we have $p_i(k) < p_i(l)$. This contradicts the choice of $k$.\n\n**Case 3: All other cycles:** For any distinct $E_i$ and $E_j$ there are no edges between them. Therefore, we have only to consider cycles that intersect at least one $E'_r$.\n\nLet $X$ be such a cycle intersecting $E'_r$. We consider the case when $t(u_r) = true$. The case $t(u_r) = false$ follows along similar lines. By the definition of $\\sim^{c1}$, we have $e'_{r22} \\sim^{c1} e'_{r11}$. If this edge were excluded, no event in $E'_r$ would have both incoming and outgoing edges. Therefore, the cycle $X$ must include this edge. From the definition of $\\sim$, there are two possible cases for the next edge in the cycle $X$:\n\n**Case 1: $e'_{r11} \\sim e_{i(2p-1)1}$ is the next edge in cycle $X$, for some $i$ and $p$:**\n\nIn this case, the literal $l_{ip} = u_r$ and, therefore, is true under $t$. Therefore, by the definition of $\\sim$ and $\\sim^{c1}$, there are no outgoing edges from $E_{i(2p-1)}$ in $\\sim \\cup \\sim^{c1}$. Therefore, $CS_{i(2p-1)}$ is maximal in $\\langle C_i, \\rightarrow_i^{c1} \\rangle$. Since the cycle $X$ contains at least one maximal critical section in $\\langle C_i, \\rightarrow_i^{c1} \\rangle$, consider the critical section $CS_{ik}$ such that: $p_i(k) = \\max\\{p_i(j) : CS_{ij} \\text{ is maximal in } \\langle C_i, \\rightarrow_i^{c1} \\rangle \\land E_{ij} \\cap X \\neq \\emptyset\\}$ (i.e. $CS_{ik}$ is the last maximal critical section in the topological sort of $\\langle C_i, \\rightarrow_i^{c1} \\rangle$ that is intersected by cycle $X$). Since $CS_{ik}$ is maximal in $\\langle C_i, \\rightarrow_i^{c1} \\rangle$, $E_{ik}$ can have no outgoing edges in $\\sim \\cup \\sim^{c1}$. Therefore the outgoing edge from $E_{ik}$ in the cycle must be: $e_{ik2} \\sim^{c2} e_{iq1}$ such that $p(q) = p(k) + 1$. Since, $CS_{iq}$ is also maximal in $\\langle C_i, \\rightarrow_i^{c1} \\rangle$ (by TOP2), this contradicts the choice of $p_i(k)$. 61\nCase 2: \\( e'_{r11} \\sim e_{i(2p)} \\) is the next edge in cycle \\( X \\), for some \\( i \\) and \\( p \\):\n\nIn this case, the literal \\( l_{ip} = \\overrightarrow{w} \\) and, therefore, is false under \\( t \\). Therefore, using \\( CS_{i(2p)} \\) as the maximal critical section in \\( X \\) we arrive at a contradiction in a similar manner to Case 1.\n\nEnd of Proof (Claim 1)\n\nTherefore, \\( \\langle E, \\rightarrow^c \\rangle \\) is a computation. It is easy to verify that for any \\( k \\) such that \\( 1 \\leq k \\leq (x + w) \\), all of the \\( k \\)-critical sections can be arranged in a sequence \\( CS_1, \\ldots, CS_m \\) such that \\( \\forall i : CS_i.next.first \\rightarrow^c CS_{i+1}.first \\) (where \\( m \\) is 6 or 2 depending on whether \\( 1 \\leq k \\leq x \\) or \\( x < k \\leq (x + w) \\)). Therefore, we can prove that \\( \\langle E, \\rightarrow^c \\rangle \\) is a controlling computation along similar lines to the proof of Theorem 5.\n\nPart 2: Let \\( \\langle E, \\rightarrow^c \\rangle \\) be a controlling computation of \\( \\phi_{ind} \\) in \\( \\langle E, \\rightarrow \\rangle \\). Before constructing a truth assignment on \\( U \\), we prove:\n\nClaim 2: For any two distinct \\( k \\)-critical sections \\( CS \\) and \\( CS' \\), either\n\n1. \\( CS.next.first \\rightarrow^c CS'.first \\), or\n2. \\( CS'.next.first \\rightarrow^c CS.first \\),\n\nbut not both.\n\nProof: Clearly both (1) and (2) cannot be true since otherwise there would be a cycle in \\( \\rightarrow^c \\). Suppose both (1) and (2) are false. Let \\( C \\) be the consistent cut that is the least upper bound (lub) of \\( lcc(CS.first) \\) and \\( lcc(CS'.first) \\) (using Lemma 4). Since (1) is false, \\( CS.next.first \\notin lcc(CS'.first).past \\) and since \\( CS.first \\prec CS.next.first \\), we have \\( CS.next.first \\notin lcc(CS.first).past \\) (using Lemma 5). Therefore, \\( CS.next.first \\notin C.past \\) (by the definition of lub). Together with \\( CS.first \\preceq C[CS.proc] \\) (by the definition of lub), we have: \\( C[CS.proc] \\in CS \\). In a similar way, it can be shown that: \\( C[CS'.proc] \\in CS' \\). Therefore,\n\\( k_{critical}(C[CS.proc]) \\land k_{critical}(C[CS'.proc]) \\), and so: \\( \\neg \\phi_{ind}(C) \\). This contradicts the fact that \\( \\langle E, \\rightarrow^c \\rangle \\) is a controlling computation. \\textit{End of Proof (Claim 2)}\n\nWe construct a truth assignment \\( t \\) on \\( U \\) such that for a variable \\( u_r \\):\n\n- \\( t(u_r) = true \\), if \\( CS'_{r_2}.next.first \\rightarrow^c CS'_{r_1}.first \\), and\n- \\( t(u_r) = false \\), if \\( CS'_{r_1}.next.first \\rightarrow^c CS'_{r_2}.first \\)\n\nBy Claim 2, this is a valid truth assignment.\n\nFurther, let \\( x \\) be a boolean function on literals defined as follows:\n\n- \\( x(l_{ip}) = true \\), if \\( CS_{i(2p)}.next.first \\rightarrow^c CS_{i(2p-1)}.first \\), and\n- \\( x(l_{ip}) = false \\), if \\( CS_{i(2p-1)}.next.first \\rightarrow^c CS_{i(2p)}.first \\)\n\nAgain, by Claim 2, this is a valid definition.\n\n\\textit{Claim 3:} ( \\( x(l_{ip}) = true \\) ) \\( \\equiv \\) ( \\( l_{ip} \\) is true under \\( t \\) )\n\n\\textit{Proof:}\n\n\\textbf{Case 1:} \\( x(l_{ip}) = true \\):\n\nTherefore, substituting in the definition of \\( x \\), we get:\n\n\\[ e_{i(2p)2} \\rightarrow^c e_{i(2p-1)1} \\] \\(-[A]\\)\n\n\\textbf{Case a:} \\( l_{ip} = u_r \\) for some \\( r \\):\n\nAssume \\( t(u_r) = false \\), then (substituting):\n\n\\[ e'_{r_{12}} \\rightarrow^c e'_{r_{21}} \\] \\(-[B]\\)\n\nFrom the definition of \\( \\rightarrow \\), we have:\n\n\\[ e'_{r_{21}} \\rightarrow e_{i(2p)1} \\text{ and } e_{i(2p-1)1} \\rightarrow e'_{r_{12}} \\] \\(-[C]\\)\n\nFrom \\([A]\\), \\([B]\\), and \\([C]\\), we have a cycle contradicting the fact that \\( \\langle E, \\rightarrow^c \\rangle \\) is a computation. Therefore, \\( t(u_r) = true \\), and so, \\( l_{ip} \\) is true under \\( t \\).\nCase b: \\( l_l = \\overline{u_r} \\) for some \\( r \\):\n\nAssume \\( t(u_r) = true \\), then (substituting):\n\\[\ne'_{r22} \\rightarrow^c e'_{r11} \\quad -[D]\n\\]\n\nFrom the definition of \\( \\rightarrow \\), we have:\n\\[\ne'_{r11} \\rightarrow e_{i(2p)1} \\quad \\text{and} \\quad e_{i(2p-1)1} \\rightarrow e'_{r22} \\quad -[E]\n\\]\n\nFrom [A], [D], and [E], we have a cycle contradicting the fact that \\( \\langle E, \\rightarrow^c \\rangle \\) is a computation. Therefore, \\( t(u_r) = false \\), and so, \\( l_l \\) is true under \\( t \\).\n\nCase 2: \\( x(l_l) = false \\):\n\nAlong similar lines to Case 1, we can show that \\( l_l \\) is false under \\( t \\).\n\nEnd of Proof (Claim 3)\n\nNow, we show that the truth assignment \\( t \\) satisfies the set of clauses \\( C \\). Consider any clause \\( c_i \\). If all of \\( x(l_{i1}) \\), \\( x(l_{i2}) \\), and \\( x(l_{i3}) \\) are false, then by the definition of \\( x \\), \\( \\prec \\) and \\( \\rightarrow \\), we have a cycle in \\( \\rightarrow^c \\): \\( e_{i12}, e_{i21}, e_{i22}, e_{i31}, e_{i32}, e_{i41}, e_{i42}, e_{i51}, e_{i52}, e_{i61}, e_{i62} \\). Therefore, at least one literal, say \\( x(l_{ip}) \\) is true. It follows from Claim 3 that \\( l_l \\) is true under \\( t \\). Therefore \\( t \\) satisfies \\( c_i \\). \\( \\Box \\)\n\nAlthough the problem is NP-Complete, the next result states a sufficient condition under which it can be solved. The condition is the absence of cycles containing two critical sections of the same type. Under these conditions, we can construct an efficient algorithm. Since the algorithm that will be presented in Section 3.8 is applied to independent mutual exclusion predicates without significant simplification, we do not present a specialized algorithm in this section.\n\n**Theorem 10** Let \\( \\langle I, \\rightarrow^c \\rangle \\) be the interval graph of a computation \\( \\langle E, \\rightarrow^c \\rangle \\) under local predicates critical\\(_1 \\), critical\\(_2 \\), \\ldots \\), critical\\(_n \\). If \\( \\langle I, \\rightarrow^c \\rangle \\) does not contain a non-trivial cycle of critical sections containing two critical section for some \\( k \\), then there is a controlling computation of \\( \\phi_{rw} \\) in \\( \\langle E, \\rightarrow \\rangle \\).\n\n**Proof:** The proof is along similar lines to the proof of Theorem 8. \\( \\Box \\)\n3.8 Generalized Mutual Exclusion Predicates\n\nUsing the definitions of the previous two sections:\n\n- (generalized mutual exclusion predicate) : The generalized mutual exclusion predicate \\( \\phi_{gen\\_mutex} \\) is defined as:\n\n\\[\n\\phi_{gen\\_mutex}(C) \\equiv \\forall \\text{ distinct } i, j:\n\\]\n\n\\[\n\\neg ( \\text{critical}(C[i]) \\land \\text{write\\_critical}(C[j]) ) \\land \\\\\n\\forall k : \\neg ( k\\_\\text{critical}(C[i]) \\land k\\_\\text{critical}(C[j]) )\n\\]\n\nGeneralized mutual exclusion predicates allow critical sections to have types and be read/write-critical. Clearly the predicate control problem is NP-Complete for generalized mutual exclusion predicates. Further, a similar sufficient condition can be proved combining the sufficient conditions for readers writers and independent mutual exclusion predicates.\n\nAlgorithm Description\n\nBased on the proof of the sufficient conditions, we can design a simple algorithm based on determining the strongly connected components in the critical section graph and then topologically sorting them. Instead, we present a more efficient algorithm in Figure 3.6.\n\nIn order to understand how the algorithm operates, we require the concept of a “general interval”. A general interval is a sequence of intervals in a process that belong to the same strongly connected component of the interval graph. For the purposes of the algorithm, it is convenient to treat such sequences of intervals as a single general interval. We now define general intervals and define a few notations.\n\n- (general interval) : Given an interval graph \\( (\\mathcal{I}, \\rightarrow) \\), a general interval is a contiguous sequence of intervals in an \\( (\\mathcal{I}_i, \\prec_i) \\) subgraph.\n• \\langle g.first/g.last \\rangle : For a general interval \\( g \\), let \\( g.first \\) (\\( g.last \\)) represent the first and last intervals in \\( g \\).\n\n• \\langle g.set \\rangle : Let \\( g.set \\) represent the set of intervals in the sequence \\( g \\).\n\n• \\langle \\mapsto \\ (\\text{for general intervals}) \\rangle : Let \\( G \\) denote the set of general intervals in a computation. We define the (overloaded) relation \\( \\mapsto \\) for general intervals as:\n\n\\[\n\\forall g, g' \\in G : g \\mapsto g' \\equiv g.first \\mapsto g'.last\n\\]\n\n• \\langle \\alpha(g) \\rangle : We say that a general interval \\( g \\) is \\textit{true} under a local predicate \\( \\alpha \\) if \\( \\alpha(g.first) \\). In particular, if \\( g \\) is \\textit{true} under a local predicate \\textit{critical}, we call \\( g \\) a general critical section.\n\n• \\langle \\leadsto \\rangle : Let \\( G_1 \\subseteq G \\) be a set of general intervals. Let \\( \\mathcal{S}_{G_1} \\), the set of strongly connected components in the graph \\( \\langle G_1, \\mapsto \\rangle \\). We define a relation \\( \\leadsto \\) on \\( \\mathcal{S}_{G_1} \\) as follows:\n\n\\[\n\\forall s, s' \\in \\mathcal{S}_{G_1} : s \\leadsto s' \\equiv \\exists g \\in s, g' \\in s' : g \\mapsto g'\n\\]\n\nClearly, \\( \\langle \\mathcal{S}_{G_1}, \\leadsto \\rangle \\) has no cycles.\n\nThe algorithm maintains a frontier of general critical sections that advances from the beginning of the computation to the end. In each iteration, the algorithm finds the strongly connected components (scc’s) of the general critical sections in the frontier. Then, it picks a minimal strongly connected component, \\textit{candidate}, from among them (line L22). However, the \\textit{candidate} is not necessarily a minimal scc of the entire critical section graph. In fact, it need not even be an scc of the entire graph. To determine if it is, we find the \\textit{mergeable} set of critical sections that immediately follow the general critical sections and belong to the same scc (line L23). If \\textit{mergeable} is not empty, the critical sections in \\textit{mergeable} are merged with the general critical sections in \\textit{candidate} to give larger general critical sections (line\n### Types:\n- **event**: (proc: int; v: vector clock)\n- **gen_interval**: (proc: int; critical: boolean; first: event; last: event)\n- **str_conn_comp**: set of gen_interval\n\n### Input:\n- \\(I_1, I_2, \\cdots, I_n\\): list of \\(\\text{gen_interval}\\), initially non-empty\n\n### Output:\n- \\(O\\): list of (\\(\\text{event}\\), \\(\\text{event}\\)), initially null\n\n### Vars:\n- \\(I_1, I_2, \\cdots, I_n\\): \\(\\text{gen_interval}\\), initially \\(\\forall i: I_i = I_i.\\text{head}\\)\n- \\(\\text{scc_set}\\): set of \\(\\text{str_conn_comp}\\)\n- \\(\\text{valid_scc}\\): set of \\(\\text{str_conn_comp}\\)\n- \\(\\text{chain}\\): list of \\(\\text{str_conn_comp}\\)\n- \\(\\text{candidate}\\): \\(\\text{str_conn_comp}\\)\n- \\(\\text{prev_scc}, \\text{curr_scc}\\): \\(\\text{str_conn_comp}\\)\n- \\(\\text{prev}, \\text{curr}\\): \\(\\text{gen_interval}\\)\n\n### Notation:\n- \\(CS_i\\) = \\(\\{\\) min \\(X \\in I_i: I_i \\preceq_X X \\wedge X.\\text{critical} = \\text{true}, \\) if exists \\(\\text{null}\\), otherwise\\(\\})\\)\n- \\(CS = \\{CS_i\\mid (1 \\leq i \\leq n) \\wedge (CS_i \\neq \\text{null})\\}\\)\n- \\(\\text{get_scc}(CS) = \\text{set of strongly connected components in } (CS, \\rightarrow)\\)\n- \\(\\text{select}(Z) = \\{\\) arbitrary element of set \\(Z, \\) if \\(Z \\neq \\emptyset \\text{null}, \\) otherwise\\(\\}\\)\n- \\(\\text{not_valid}(X) = X\\) has a non-trivial cycle of critical sections with either one write critical section or two \\(k\\)-critical sections\n- \\(\\text{merge}(c, c') = (c.\\text{last} := c'.\\text{last}; c.\\text{next} := c'.\\text{next})\\)\n\n### Procedure:\n```plaintext\nwhile (CS \\neq \\emptyset) do\n scc_set := get_scc(CS)\n valid_scc := \\{ s \\in scc_set \\mid \\forall s' \\in scc_set: (s' \\neq s) \\Rightarrow (s' \\not\\rightarrow s) \\}\\)\n candidate := select(valid_scc)\n mergeable := \\{ c.next.next \\mid c \\in candidate \\wedge c.next.next \\neq \\text{null} \\wedge \\exists c' \\in candidate: c.next.next \\rightarrow c'\\}\\)\n if (mergeable = \\emptyset)\n if (not_valid(candidate))\n exit(\"cannot find controlling computation\")\n chain.add_head(candidate)\n for (c \\in candidate) do\n l_c.proc := c.next\n else\n for (c \\in mergeable) do\n merge(CS_c.proc, c)\n if (chain \\neq \\text{null})\n prev_scc := chain.delete_head()\n while (chain \\neq \\text{null}) do\n curr_scc := chain.delete_head()\n for (curr \\in curr_scc, prev \\in prev_scc) do\n O.add_head( (curr.next.first, prev.first) )\n prev_scc := curr_scc\n```\n\nFigure 3.6: Algorithm for Generalized Mutual Exclusion Predicate Control\nL32) and the procedure is repeated. If mergeable is empty, then it can be shown that candidate is a minimal scc of the graph. Therefore, we check that it meets the sufficient conditions of validity (line L25), and then append it to the chain (line L27).\n\nFinally, after the main loop terminates, the scc’s in the chain are connected using added edges which define the controlling computation (lines L33-L39). Note how the use of general critical sections allows us to reduce the number of edges that need to connect two consecutive scc’s as compared to the simple algorithm that would be defined by the proof of Theorem 8.\n\nThe main while loop of the algorithm executes $p$ times in the worst case, where $p$ is the number of critical sections in the computation. Each iteration takes $O(n^2)$, since it must compute the scc’s. Thus, a simple implementation of the algorithm will have a time complexity of $O(n^2p)$. However, a better implementation of the algorithm would amortize the cost of computing scc’s over multiple iterations of the loop. Each iteration would compare each of the critical sections that have newly reached the heads of the lists with the existing critical sections. Therefore, each of the $p$ critical section reaches the head of the list just once, when it is compared with $n - 1$ critical sections to determine. The time complexity of the algorithm with this improved implementation is, therefore, $O(np)$. Note that a naive algorithm based directly on the constructive proof of the sufficient condition in Theorem 8 would take $O(p^2)$. We have reduced the complexity significantly by using the fact that the critical sections in a process are totally ordered.\n\nFinally, we prove the correctness of the algorithm.\n\nLemma 18 The algorithm in Figure 3.6 is well-specified.\n\nProof: To prove that the algorithm is well-specified, the only non-trivial check is for the term curr.next.first at line L37. To show that curr.next ≠ null at this point, we prove that, after the termination of loop L13-L19, for each strongly connected\ncomponent (scc) $s$ in chain: $(\\exists c \\in s : c.next = \\text{null}) \\Rightarrow (s = \\text{chain.head})$. Let $s$ be an scc in chain and let $c \\in s$ be a critical section such that $c.next = \\text{null}$. Consider the point when $s$ is about to be added to chain in line L27. Since $s \\in \\text{valid.scc}$, we have $\\forall s' \\in \\text{scc.set} : (s' \\neq s) \\Rightarrow (s' \\not\\rightarrow s)$ However, since $c.next = \\text{null}$, we have $\\forall c' \\in C : c' \\nrightarrow c$. Therefore, $\\forall s' \\in \\text{scc.set} : s' \\leftarrow s$. Therefore, $s$ is the only element of $\\text{valid.scc}$ at this point. It follows that after line L29, $CS = \\emptyset$ and the loop terminates. Therefore, after the termination of loop L19-32, $s = \\text{chain.head}$.\n\nWe next show that the algorithm terminates. The loop L19-L32 terminates since in each iteration either one $I_i$ advances over a critical section (line L29) or two distinct critical sections merge into one (line L32). The loop L34-L38 terminates since $\\text{chain}$ decreases by one critical section in each iteration. $\\square$\n\n**Lemma 19** If the algorithm in Figure 3.6 exits at line L26, then there is a non-trivial cycle of critical sections with:\n\n(1) at least one write-critical, or\n\n(2) two $k$-critical sections for some $k \\in \\{1, \\ldots, m\\}$.\n\n**Proof:** Follows directly from the condition at line L25. $\\square$\n\n**Lemma 20** If the algorithm in Figure 3.6 terminates normally, then $\\langle E, \\rightarrow^c \\rangle$ is a controlling computation of $\\phi_{\\text{genmutex}}$ in $\\langle E, \\rightarrow \\rangle$, where $\\rightarrow^c$ is the transitive closure of the union of $\\rightarrow$ with the set of edges in $O$.\n\n**Proof:**\n\nAt any point in the algorithm, let $C$ denote the set of regular (not general) critical sections in the input computation. Note that $C$ is a constant throughout the algorithm execution. Let $S$ be the set of strongly connected components (scc) in the graph $\\langle C, \\rightarrow \\rangle$. We use the relations $\\leftrightarrow$ and $\\leftarrow$ for both regular and general intervals and scc’s since the usage is clear from context. Let $C_g$ denote the set of\ngeneral critical sections in $I = \\bigcup_i I_i$ at any stage of the algorithm (note that $C_G$ is a variable since it changes at the merge step during the algorithm).\n\nLet $scc$ be a function that maps each critical section in $C$ to the strongly connected component in $S$ that contains it. First, we prove that the following are invariants.\n\nINV1: $\\forall g \\in C_G : \\forall x, y \\in g.set : scc(x) = scc(y)$\n\nINV2: $g$ is reachable from $g'$ in the graph $\\langle C_G, \\to \\rangle \\Rightarrow \\forall x \\in g.set, x' \\in g'.set : x$ is reachable from $x'$ in the graph $\\langle C, \\to \\rangle$\n\nIt is easy to prove that INV2 is a consequence of INV1 (by induction on the length of the reachability path). Therefore, we have only to prove that INV1 is an invariant. We do so by structural induction.\n\nInitially, each general critical section in $C_G$ contains only one critical section and so INV1 holds. The only step at which $C_G$ changes is the merge at line L32. Consider the execution point just before line L32. Since $c \\in mergeable$ we have:\n\n$c.prev.prev \\in candidate$, and $[A]$\n\nlet $c' \\in candidate$ such that $c \\to c'$. $[B]$\n\nSince $candidate$ is an scc of the subgraph $\\langle CS, \\to \\rangle$ of $\\langle C_G, \\to \\rangle$, $c'$ and $c.prev.prev$ are in the same scc, say $s$, of $\\langle C_G, \\to \\rangle$. Clearly, $c.prev.prev \\to c$. Together with $[B]$, this implies that $c$ is also in $s$. Therefore:\n\n$c$ and $c.prev.prev$ are reachable from each other in graph $\\langle C_G, \\to \\rangle$. $[C]$\n\nSince $candidate \\subseteq CS$, using $[A]$, we have $c.prev.prev = CS_{c.proc}$. Let $x$ and $y$ be any two critical sections in $g.set$, where $g$ is the general critical section formed by merging $c.prev.prev$ with $c$. By the inductive hypothesis, the case when both $x$ and $y$ belong to $c$ or to $c.prev.prev$ is trivial. Therefore, without loss of generality, assume that $x \\in c$ and $y \\in c.prev.prev$. By the inductive hypothesis, and since INV2 follows from INV1, we use INV2 and $[C]$ to give: $x$ and $y$ are reachable from each other in graph $\\langle C, \\to \\rangle$. Therefore, $scc(x) = scc(y)$. 70\nNow, consider the point of execution just before line L27 when \\textit{candidate} is added to \\textit{chain}. Let \\textit{chain.set} be the set of general critical sections in the scc’s of the sequence \\textit{chain}. It is easy to show that the following is an invariant:\n\n\\[\n\\text{INV3: } \\forall c \\in \\mathcal{G} : c < \\text{CS}_{c, \\text{proc}} \\Rightarrow c \\in \\text{chain.set}\n\\]\n\nSuppose there is a general critical section \\(c\\) in \\((\\mathcal{G} - (\\text{candidate} \\cup \\text{chain.set}))\\) such that for some \\(c' \\in \\text{candidate}\\), \\(c \\mapsto c'\\). Consider two cases:\n\n\\textbf{Case 1: } \\text{CS}_{c, \\text{proc}} \\in \\text{candidate}: \\text{Since by definition, } c \\notin \\text{candidate}, \\text{we have } c \\neq \\text{CS}_{c, \\text{proc}}. \\text{Using INV3, we have } \\text{CS}_{c, \\text{proc}} < c \\text{ and, since } c \\text{ is a critical section } \\text{CS}_{c, \\text{proc}.\\text{next.next}} \\preceq c. \\text{Together with } c \\mapsto c', \\text{this gives } \\text{CS}_{c, \\text{proc}.\\text{next.next}} \\mapsto c'. \\text{This contradicts the fact that mergeable} = \\emptyset \\text{ just before line L27 (by the check at L25).}\n\n\\textbf{Case 2: } \\text{CS}_{c, \\text{proc}} \\notin \\text{candidate}: \\text{Using INV3, we have } \\text{CS}_{c, \\text{proc}} \\preceq c. \\text{Since } c \\mapsto c', \\text{we have } \\text{CS}_{c, \\text{proc}} \\mapsto c'. \\text{Let } s \\in \\text{scc.set} \\text{ such that } \\text{CS}_{c, \\text{proc}} \\in s. \\text{Therefore } s \\mapsto \\text{candidate} \\text{ and } s \\neq \\text{candidate}. \\text{This contradicts the fact that candidate was selected from valid.scc (lines L21, L22).}\n\nTherefore, \\(\\forall c \\in (\\mathcal{G} - (\\text{candidate} \\cup \\text{chain.set})) : \\forall c' \\in \\text{candidate} : c \\not\\mapsto c' - [D]\\)\n\nThis proves that \\textit{candidate} is an scc in \\((\\mathcal{G} - \\text{chain.set})\\) and, furthermore, that it is a minimal scc in \\((\\mathcal{G} - \\text{chain.set})\\).\n\nLet \\(\\text{reg}(\\text{candidate})\\) be the set of regular critical sections in \\textit{candidate} (i.e. \\(\\{x \\in \\mathcal{C} \\mid \\exists g \\in \\text{candidate} : x \\in g.\\text{set}\\}\\)). Similarly, let \\(\\text{reg}(\\text{chain.set})\\) be the set of regular critical sections in \\textit{chain.set}. By the definition of \\textit{ord} on \\(\\mathcal{G}\\), we have:\n\n\\(\\forall c, c' \\in \\mathcal{G} : (\\exists x \\in c, x' \\in c' : x \\mapsto x') \\Rightarrow (c \\mapsto c')\\). Therefore, by \\([D]\\), we have:\n\n\\(\\forall x \\in (\\mathcal{C} - (\\text{reg}(\\text{candidate}) \\cup \\text{reg}(\\text{chain.set}))) : \\forall x' \\in \\text{reg}(\\text{candidate}) : x \\not\\mapsto x' - [E]\\)\n\nBy INV2, we know that all critical sections in \\(\\text{reg}(\\text{candidate})\\) are reachable from one another. Therefore, using \\([E]\\), \\(\\text{reg}(\\text{candidate})\\) is an scc in \\((\\mathcal{C} - \\text{reg}(\\text{chain.set}), \\mapsto)\\). Further, using \\([E]\\) again, \\(\\text{reg}(\\text{candidate})\\) is a minimal scc in \\((\\mathcal{C} - \\text{reg}(\\text{chain.set}), \\mapsto)\\).\nSince the minimal scc is chosen at each step, \\( \\text{chain} \\) represents a topological sort of the graph \\( \\langle S, \\rightarrow \\rangle \\). Therefore, from the construction of \\( O \\) from \\( \\text{chain} \\) in lines L33-L38 of the algorithm, the \\( \\rightarrow^c \\) relation is the same as that defined in the proof of Theorem 8 (note that the optimization of connecting general critical sections by the \\( \\sim^c \\) edges instead of regular critical sections, as in the proof of Theorem 8, does not affect the equality of \\( \\rightarrow^c \\) defined by each). Therefore, in a very similar way to the proof of Theorem 8, we can prove that \\( \\langle E, \\rightarrow^c \\rangle \\) is a controlling computation of \\( \\phi_{\\text{gen\\_mutex}} \\) in \\( \\langle E, \\rightarrow \\rangle \\). □\n\n**Theorem 11** The algorithm in Figure 3.6 solves the predicate control problem for the generalized mutual exclusion predicate if the input computation has no non-trivial cycles of critical sections containing two \\( k \\)-critical sections for some \\( k \\in \\{1, \\cdots, m\\} \\).\n\n**Proof:** By Lemma 18, the algorithm always terminates, and by Lemma 20, if it terminates normally then it outputs a controlling computation. By Lemma 19, if it terminates at line L26, then there is a non-trivial cycle with:\n\n1. at least one write-critical, or\n2. two \\( k \\)-critical sections for some \\( k \\in \\{1, \\cdots, m\\} \\).\n\nIn case (1), Theorem 7 indicates that no controlling computation exists. Therefore, it is only in case (2) that the algorithm fails to find a controlling computation that does exist, (which is to be expected since the problem is NP-Complete by Theorem 9). □\nChapter 4\n\nThe Predicate Detection Problem\n\nIn this chapter, we present our study of predicate detection in the extended model of computation.\n\n4.1 Overview\n\nThe extended model of computations [ACG93] extends the happened before model by allowing partially ordered events within a process. While this seems like a small difference, it has broad implications. In Section 4.2, we give the background for the extended model of distributed computations and discuss why the extended model should be preferred to the happened before model for certain applications.\n\nWe focus on the important class of “conjunctive predicates” which can be solved efficiently in the happened-before model [GW94]. Conjunctive predicates are specified as conjunctions of local predicates and express the combined occurrence of local events. Some examples of these predicates are: “all servers are unavailable” and “no process has a token”. In Section 4.3, we formally state the problem of conjunctive predicate detection (predicate detection for conjunctive predicates).\n\nUnfortunately, our first result is that the problem is NP-Complete in general. We prove this in Section 4.4. This is an indication of the difficulty of solving predicate detection in the extended model. However, this is to be expected since a general\ncomputation (in the extended model) represents, in general, an exponential number of happened before computations. We call this set of happened before computations as the set of “local linearizations” of the general computations. In Section 4.5, we demonstrate the equivalence between detecting a predicate in a general computation and detecting it in the corresponding set of local linearizations.\n\nThe next results in Section 4.6 show that it is indeed possible to find an efficient algorithm in the special case of “receive-ordered” and “send-ordered” computations. A receive ordered computation has totally ordered receive events, while other events may be partially ordered (and similarly for send-ordered computations). These computations are important since some natural programming styles create computations that fall in these categories. Note that obtaining efficient algorithms under such constraints is a big improvement over the alternative method of detection in an exponential-sized set of local linearizations.\n\nFinally, in Section 4.7, we deal with general computations under no restrictions. Although, the problem is NP-Complete, we show that the algorithms of the previous section can be utilized by first decomposing a general computation into a set of receive-ordered or send-ordered computations. Though exponential in time, by restricting the search to the set of receive-ordered or send-ordered computations, this approach is still a great improvement over the alternative method of detection in the set of all local linearizations.\n\n4.2 A Case for the Extended Model\n\nThe happened before model [Lam78] has been used to model distributed computations, capturing the notions of logical time and potential causality. As a result, these two notions have long been considered the same. In this section, we argue that these two notions are different and, in fact, starkly contradictory in nature. They arise in different applications and require different models. Although happened before\nsuffices to model logical time, it is not good for modeling potential causality.\n\nHistorical Perspective\n\nThe history of modeling distributed computations may be divided into three stages. The first stage started with Lamport’s introduction of happened before to model logical time [Lam78]. The second started with Mattern’s observation that happened before may also be used to model potential causality [Mat89]. The third stage consisted of the gradual discovery that using happened before to model potential causality leads to problems owing to inherent false causality [CS93, SBN+97] and the definition of extended models of computation [ACG93, HW96].\n\nStage 1: Happened Before and Logical Time\n\nMany applications, such as mutual exclusion and deterministic replay, need to know the order in which events happen in time. In a distributed system, events on different processes do not share a common clock. This makes it impossible to determine their order in real time using time-stamping mechanisms. Lamport [Lam78] introduced logical time to order distributed events in a manner that approximates their real time order.\n\nTo model logical time, Lamport defined the happened before relation, denoted by $\\rightarrow$, as the smallest relation satisfying the following: (1) If $a$ and $b$ are events in the same process, and $a$ comes before $b$ according to the total ordering specified by the local clock on that process, then $a \\rightarrow b$. (2) If $a$ is the send event of a message and $b$ is the receipt of the same message by another process, then $a \\rightarrow b$. (3) If $a \\rightarrow b$ and $b \\rightarrow c$, then $a \\rightarrow c$. Further, two events $a$ and $b$ are concurrent, denoted by $a \\parallel b$, if and only if they are incomparable using the happened before relation (i.e. $(a \\not\\rightarrow b) \\land (b \\not\\rightarrow a)$).\n\nLamport went on to define a logical clock mechanism which constructed a\ntotal order of events that is a linearization of the happened before relation. This\ntotal order may be viewed as a possible ordering of events in real time and is sufficient\nfor applications that need a notion of logical time.\n\n**Stage 2: Happened Before and Potential Causality**\n\nIf an event happens before another event, it has the potential for causing that\nevent. Many applications, such as recovery and debugging, require the tracking of\nsuch causal dependencies. Mattern [Mat89] realized that such applications would\nbenefit by a mechanism to quickly determine the happened before relation between\nevents.\n\nThe totally ordered logical clock mechanism that proved useful for applica-\ntions requiring a notion of logical time is not good for applications requiring the\nnotion of potential causality. In Mattern’s own words: “For some applications (like\nmutual exclusion as described by Lamport himself in [Lam78]) this defect is not\nnoticeable. For other purposes (e.g., distributed debugging), however, this is an im-\nportant defect.” Mattern, therefore, proposed a vector clock mechanism that allows\nthe happened before relation between events to be deduced.\n\n**Stage 3: False Causality Problems and Extended Models**\n\nAn event that happens before another event need not necessarily cause it. This is\nimplicit when we say that happened before tracks potential causality. Therefore,\nan inherent problem in using happened before in applications that require causality\ntracking is that sometimes events that are independent are believed to have a causal\ndependency. This phenomenon is called false causality. While any approximation\nof causality must have false causality, the happened before model was found to fall\nparticularly short in this respect. We cite three examples of application domains\nwhere this has happened.\nFirstly, happened before has been used as the basis of causally and totally\nordered communication support. Cheriton and Skeen [CS93] observed that when\ntwo send events have a false causal dependency between them, the resulting effect\nis to make the receipt of one message unnecessarily wait for the receipt of the other.\nThis overhead was mentioned as one of the limitations of causally and totally ordered\ncommunication support.\n\nSecondly, happened before has been used in tools to detect data races in\nmulti-threaded programs. Savage, et al [SBN+97] pointed out that false causality\nbetween events causes some data races to go undetected. This is because if one\nevent happens before another, it may falsely be believed to cause that event and\nthus a potential data race between the independent events may be missed.\n\nThe third application domain is predicate detection, the focus of this chapter.\nAs we noted in Chapter 1, using the happened before model would miss the detection\nof certain predicates owing to the false causality between events. Since predicate\ndetection has applications in distributed debugging and distributed monitoring, this\ntranslates to certain faulty conditions being missed.\n\nThe incidence of the false causality problem in a number of applications was\nnoted by Ahuja, et al [ACG93]. They proposed a passive-space and time view of a\ncomputation that partially orders the events within a process. They also propose\na more general vector clock mechanism than the one proposed by Mattern. These\nvector clocks trade the cost incurred and the accuracy of causality identification.\n\nIn a later study, Hrischuk and Woodside [HW96] also proposed more refined\napproximations of causality than the happened before model. A distinguishing\nfeature of their scenario causality model is the use of typed nodes and typed edges\nin the computation graph.\nLogical Time is not Potential Causality\n\nWe have seen that happened before has come to be used to model both logical time and potential causality in distributed computations. In spite of demonstrations to the contrary [ACG93, HW96], this has led to a wide-spread belief that the two concepts are the same. We now present a brief argument that the concepts are not only different but opposite in nature.\n\nThe applications that motivated Lamport to model logical time were notably different from those that motivated Mattern to model potential causality. The first kind of applications, represented by mutual exclusion, require as close an approximation to real time order as possible. Happened before is, in fact, the best possible approximation of real time order that one can make in a message-passing distributed system without external channels and global clocks. The kind of applications that require potential causality, represented by distributed recovery, require as close an approximation as possible to the true causality between events.\n\nAs illustrated in Figure 4.1, real time and true causality fall at opposite ends of a spectrum of partial orders based on their strictness. While logical time tries to approximate the real time total order that lies on one end of the spectrum, potential causality tries to approximate true causality at the other end. Happened before was initially introduced to model logical time and therefore closely approximates real time. By a historical accident, it was also used to model potential causality. In fact, in attempting to approach real time, the happened before model creates more\nfalse causality than necessary. A better model for potential causality would be a less strict partial order that approaches true causality in the spectrum indicated in Figure 4.1. In both of the studies [ACG93, HW96] on modeling potential causality, the authors describe a spectrum of choices for models that approximate true causality. In [ACG93], flexible models are proposed that allow trading off the cost with the accuracy of the approximation.\n\nClosing Comments\n\nA computation, in the sense that we have used it, is something that has actually happened. It may, therefore, seem peculiar that a single potential causality model may capture multiple possible interleavings of local events (or, multiple possible happened before computations). The same fact may be noticed in the happened before model as compared to the real time ordering model. The happened before model allows multiple possible real time orderings. In both cases, the explanation for this seeming paradox is that what actually happened lies in the eyes of the beholder. If the observer is interested in applications that require logical time, he would pay attention to the ordering of local events based on real time. However, if the observer were interested in applications that require potential causality, he would only pay attention to the causal ordering of local events.\n\nThe crucial deciding factor in choosing the happened before or the potential causality model is the type of application being considered. A litmus test for making this decision would be to ask the following question: Would a global clock help? A “yes” would indicate happened before, while a “no” would indicate potential causality. For example, in mutual exclusion, a global clock would allow the timestamping of critical section requests in real time and lead to a fair granting order. In fact, even without a global clock, if there were multiple threads in a process, we would prefer to treat local events as being totally ordered using the local process clock. In an\napplication like race detection, for example, a global clock would have no advantage because any more ordering would merely induce more false causality and reduce our chances of detecting a race.\n\nThe purpose of this section has been to draw attention to the false causality problem which limits the effectiveness of the happened before model in modeling potential causality. A more effective model of potential causality allows events within a process to be partially ordered. We now present our study of the predicate detection problem in this extended model of computation.\n\n4.3 Problem Statement: Conjunctive Predicate Detection\n\nIn this chapter, we consider general computations corresponding to the extended model of computation. All of the definitions in our model (Chapter 2) apply to general computations, except for those in Sections 2.5, 2.6, and 2.7. The definition of the predicate detection problem in this model is:\n\n**The Predicate Detection Problem:** Given a general computation \\( \\langle E, \\rightarrow \\rangle \\) and a global predicate \\( \\phi \\), is there a consistent cut \\( C \\) such that \\( \\phi(C) \\)?\n\nWe focus on the class of conjunctive predicates defined as:\n\n- **(conjunctive predicates):** Given \\( n \\) local predicates \\( \\alpha_1, \\alpha_2, \\ldots, \\alpha_n \\), the *conjunctive predicate* \\( \\phi_{\\text{conj}} \\) is defined as:\n\n\\[\n\\phi_{\\text{conj}}(C) \\equiv \\bigwedge_{i \\in \\{1, \\ldots, n\\}} \\alpha_i(C[i])\n\\]\n\nThe reason that conjunctive predicates are important is that their detection is sufficient for the detection of any global predicate which can be written as a boolean expression of local predicates [Gar96]. This is true since the boolean expression can be expressed in disjunctive normal form giving rise to the disjunction of conjunctive predicates. Each of the conjunctive predicates can then be detected independently.\nFor example, for a distributed application with $x$, $y$, and $z$ being variables on three processes, the predicate:\n\n$$even(x) \\land ((y < 0) \\lor (z > 6))$$\n\ncan be rewritten as:\n\n$$(even(x) \\land (y < 0)) \\lor (even(x) \\land (z > 6))$$\n\nEach of the disjuncts is a conjunctive predicate. It can also be shown that, even if the global predicate is not a boolean expression of local predicates, but is satisfied by a finite number of consistent cuts, then it can also be expressed as a disjunction of conjunctive predicates.\n\nNote that the reason that we do not solve the predicate detection problem for disjunctive predicates (defined in the Chapter 3) is that it is trivial to do so. One has simply to scan each process to see if the corresponding local predicate is true for any event. If so, the disjunctive predicate is detected. It is interesting to note that the negation of a conjunctive predicate is a disjunctive predicate. As a result, if a conjunctive predicate indicates a failure, then it is its negation, a disjunctive predicate, which must be given as input to the predicate control problem to maintain. Thus, the detection of conjunctive predicates is complementary to the control of disjunctive predicates.\n\nThe problem of conjunctive predicate detection was efficiently (in $O(mn^2)$ time, where $m$ is a bound on the number of events in a process) and optimally solved for locally ordered computations in [GW94]. However, in the extended model, the problem becomes expectedly harder as we establish in the following section.\n\n### 4.4 Conjunctive Predicate Detection is NP-Complete\n\nLet $CPG$ denote the predicate detection problem for the Conjunctive Predicate in General computations.\nTheorem 12 CPG is NP-Complete.\n\nProof: CPG is in NP because, given a cut $C$, $\\phi_{conj}(C)$ can be checked in polynomial time (by the definition of predicates) and a naive check for consistency based directly on its definition can be checked in polynomial time.\n\nTo show that CPG is NP-Hard, we transform 3SAT. Let $U = \\{u_1, u_2, \\cdots u_w\\}$ be a set of variables, and $D = \\{c_1, c_2, \\cdots c_x\\}$ be a set of clauses, forming an instance of 3SAT. Let $l_{i1}, l_{i2}, l_{i3}$ be the three literals in clause $c_i$.\n\nFor each variable $u_r$, define a set of events $E'_r = \\{e'_r1, e'_r2\\}$. For each clause $c_i$, define a set of events $E_i = \\{e_{i11}, e_{i21}, e_{i31}, e_{i12}, e_{i22}, e_{i32}\\}$. Let $E = \\bigcup_i E_i \\cup \\bigcup_r E'_r$.\n\nOn each $E_i$, define a relation $\\prec_i = \\{(e_{i11}, e_{i12}), (e_{i21}, e_{i22}), (e_{i31}, e_{i32})\\}$. let $\\prec = \\bigcup_i \\prec_i$.\n\nDefine $\\rightarrow$ as the smallest relation on $E$ such that:\n\n- for each literal $l_{ip} = u_r$ for some variable $u_r$: $e_{ip2} \\rightarrow e'_r2$.\n- for each literal $l_{ip} = \\overline{u_r}$ for some variable $u_r$: $e_{ip2} \\rightarrow e'_r1$.\n\nLet $\\rightarrow$ be the transitive closure of $\\prec \\cup \\rightarrow$. It is easy to verify that the graph $\\langle E, \\prec \\cup \\rightarrow \\rangle$ has no cycles. Therefore, $\\langle E, \\rightarrow \\rangle$ is a computation.\n\nDefine local predicates $\\alpha_1, \\cdots, \\alpha_x, \\alpha'_1, \\cdots, \\alpha'_w$ such that:\n\n- for each $E_i$: $\\alpha_i(\\bot_i) = \\text{false}$, $\\forall p : \\alpha_i(e_{ip1}) = \\text{true}$, and $\\forall p : \\alpha_i(e_{ip2}) = \\text{false}$.\n- for each $E'_r$: $\\alpha'_r(\\bot'_r) = \\text{false}$, $\\alpha'_r(e'_{r1}) = \\text{true}$, and $\\alpha'_r(e'_{r2}) = \\text{false}$.\n\nDefine $\\phi_{conj}$ based on these local predicates. Thus, we have constructed an instance of CPG, $\\langle\\langle E, \\rightarrow\\rangle, \\phi_{conj}\\rangle$, from an instance of 3SAT, $\\langle U, D \\rangle$. We next show that this is indeed a transformation.\n\nPart 1: Suppose that $t$ is a truth assignment assignment of variables in $U$ that satisfies $C$. We prove that $\\phi_{conj}$ is detected in $\\langle E, \\rightarrow \\rangle$. Define a cut $C$ as follows.\n\nFor each $E_i$, let $l_{ip}$ be a literal which is true under $t$ (since $t$ satisfies $D$) and let $C[i] = e_{ip1}$. For each $E'_r$, if $t(u_r) = \\text{true}$ then $C[r'] = e'_{r1}$, and if $t(u_r) = \\text{false}$ then $C[r'] = e'_{r2}$. Clearly, $\\phi_{conj}(C)$. We next show by contradiction that $C$ is consistent.\n\n82\nSuppose $C$ is not consistent. Let $e$ be an event in $C.past$ such that $C[e.proc] \\prec e$. By the definition of $\\prec$, we know that $e$ must belong to some $E_i$ corresponding to a clause $c_i$. Note that $e$ cannot be a $\\bot_i$ or a $e_{ip1}$ since $C[e.proc] \\prec e$. Therefore, suppose $e = e_{ip2}$ so that $C[i] = e_{ip1}$. Since $e_{ip2} \\in C.past$, let $e'$ be an event in $C$ such that $e_{ip2} \\rightarrow e'$. Consider two cases:\n\n- **Case 1:** $l_{ip} = u_r$ for some variable $u_r$:\n \n By the definition of $\\rightarrow$, we must have: $e' = e_{r2}'$. Since $C[i] = e_{ip1}$, $l_{ip}$ is true under $t$. Therefore, $t(u_r) = true$ and $C[r'] = e_{r1}'$. This contradicts the fact that $e' = e_{r2}'$ belongs to $C$.\n\n- **Case 2:** $l_{ip} = \\overline{u_r}$ for some variable $u_r$:\n \n By the definition of $\\rightarrow$, we must have: $e' = e_{r1}'$. Since $C[i] = e_{ip1}$, $l_{ip}$ is true under $t$. Therefore, $t(u_r) = false$ and $C[r'] = e_{r2}'$. This contradicts the fact that $e' = e_{r1}'$ belongs to $C$.\n\nTherefore, in both cases we get a contradiction. So, $C$ is consistent.\n\n**Part 2:** Suppose $C$ is a consistent cut in $(E, \\rightarrow)$ such that $\\phi_{conj}(C)$. Define a truth assignment $t$ as follows: $t(u_r) = true$ if $C[r'] = e_{r1}'$ and $t(u_r) = false$ if $C[r'] = e_{r2}'$.\n\nConsider a clause $c_i$. We know from the definition of local predicate $\\alpha_i$ that $C[i] = e_{ip1}$ for some $p$. Consider two cases:\n\n- **Case 1:** $l_{ip} = u_r$:\n \n Since $C[i] = e_{ip1}$ and $e_{ip1} \\prec e_{ip2}$ and $e_{ip2} \\rightarrow e_{r2}'$, the consistency of $C$ would be violated if $C[r'] = e_{r2}'$. Therefore, $C[r'] = e_{r1}'$. So, $t(u_r) = true$. Thus, literal $l_{ip}$ is true under $t$, and so, clause $c_i$ is satisfied by $t$.\n\n- **Case 2:** $l_{ip} = \\overline{u_r}$:\n \n Since $C[i] = e_{ip1}$ and $e_{ip1} \\prec e_{ip2}$ and $e_{ip2} \\rightarrow e_{r1}'$, the consistency of $C$ would be violated if $C[r'] = e_{r1}'$. Therefore, $C[r'] = e_{r2}'$. So, $t(u_r) = false$. Thus, literal $l_{ip}$ is true under $t$, and so, clause $c_i$ is satisfied by $t$. \nThus $t$ satisfies $C$. □\n\n4.5 Local Linearizations\n\nIn practice, a computation is formed by the transitive closure of a local ordering relation and a remote ordering relation. We now make these relations explicit.\n\n- $(x)^+$: The notation $(x)^+$ denotes the transitive closure of a relation $x$.\n\n- (locally precedes, remotely precedes): We assume that a computation $\\langle E, \\rightarrow \\rangle$ has associated with it two relations *locally precedes* ($<$) and *remotely precedes* ($\\sim$) such that:\n - $<$ is an irreflexive partial order on $E$ such that $e < f \\implies e.\\text{proc} = f.\\text{proc}$.\n - $\\sim$ is an irreflexive partial order on $E$ such that $e \\sim f \\implies e.\\text{proc} \\neq f.\\text{proc}$.\n - $\\rightarrow = (\\langle \\cup \\sim \\rangle)^+$. Although not required, it is expected that $<$ and $\\sim$ do not contain transitively redundant edges.\n\n- $\\langle E, \\rightarrow, <, \\sim \\rangle$: When the distinction is important, we will use the notation $\\langle E, \\rightarrow, <, \\sim \\rangle$ to denote a computation $\\langle E, \\rightarrow \\rangle$ with locally precedes relation $<$ and remotely precedes relation $\\sim$.\n\n- $\\langle < (\\text{extended}) \\rangle$: We extend $<$ to $E \\cup \\perp$ such that $\\forall e \\in E_i: \\perp_i <_i e$.\n\nWe next define the concept of a “local linearization” of a general computation. Informally, a local linearization is a locally ordered computation that can be obtained by linearizing the partially ordered processes in a general computation. In general, a general computation has an exponential number of local linearizations.\n\n- (linearization): A *linearization* of a partial order is a total order that contains it.\n• \\textbf{(local linearization)} : A \\textit{local linearization} of a (general) computation \\(\\langle E, \\rightarrow^s, <^s, \\sim^s \\rangle\\) is a locally ordered computation \\(\\langle E, \\rightarrow, <, \\sim \\rangle\\) such that \\(\\forall i : <_i\\) is a linearization of \\(<^s_i\\). (Note: an arbitrary choice of linearizations of \\(<^s_i\\)'s may not result in a computation because of possible cycles).\n\n• \\textbf{\\(\\text{Lin}(\\langle E, \\rightarrow^s, <^s, \\sim^s \\rangle)\\)} : Let \\(\\text{Lin}(\\langle E, \\rightarrow^s, <^s, \\sim^s \\rangle)\\) represent the set of local linearizations of a computation \\(\\langle E, \\rightarrow^s, <^s, \\sim^s \\rangle\\)\n\nGeneral computations concisely represents many locally ordered computations, thus allowing improved detection. The following result confirms that solving predicate detection in a general computation is equivalent to solving predicate detection for all of the computation’s local linearizations. First, we define the new problem:\n\nThe Conjunctive Predicate Detection Problem in Local Linearizations (CPL): Given a general computation \\(\\langle E, \\rightarrow \\rangle\\), is there a consistent cut \\(C\\) in any local linearization of \\(\\langle E, \\rightarrow^s, <^s, \\sim^s \\rangle\\) such that \\(\\phi_{\\text{conj}}(C)\\)?\n\n\\textbf{Theorem 13} \\(\\text{CPG}\\) is equivalent to \\(\\text{CPL}\\).\n\n\\textbf{Proof}: Let the general computation \\(\\langle E, \\rightarrow^s, <^s, \\sim^s \\rangle\\) and the conjunctive predicate \\(\\phi_{\\text{conj}}\\) define instances of \\(\\text{CPG}\\) and \\(\\text{CPL}\\).\n\n\\textbf{Part 1}: Suppose the cut \\(C\\) is a solution to \\(\\text{CPL}\\). Then, it follows as a corollary of Lemma 2 that \\(C\\) is consistent in \\(\\rightarrow^s\\), and so, also a solution of \\(\\text{CPG}\\).\n\n\\textbf{Part 2}: Suppose the cut \\(C\\) is a solution to \\(\\text{CPG}\\). We prove that \\(C\\) is also a solution to \\(\\text{CPL}\\). We construct \\(\\langle E, \\rightarrow^s, <^s, \\sim^s \\rangle\\), a local linearization of \\(\\langle E, \\rightarrow^s, <^s, \\sim^s \\rangle\\) as follows. If each \\(\\langle E_i, \\rightarrow^s_i \\rangle\\) is already a total order, then we simply let \\(<_i = \\rightarrow^s_i\\) and we are done. So assume that two events \\(e\\) and \\(f\\) of the same process are incomparable in \\(\\rightarrow^s\\). From \\(\\langle E, \\rightarrow^s, <^s, \\sim^s \\rangle\\), we construct another general computation, \\(\\langle E, \\rightarrow^{s'}, <^{s'}, \\sim \\rangle\\) such that:\n\n\\[ (1) \\quad <^s \\subseteq <^{s'} \\]\n(2) $C$ is consistent in $<^s$, and\n\n(3) $e$ and $f$ are comparable in $\\rightarrow^s$.\n\nBy repeating this procedure, we will eventually obtain a local linearization of\n\\[\\langle E, \\rightarrow^s, <^s, \\sim \\rangle\\] in which $C$ is consistent, thus proving the result. We make $e$ and $f$ comparable in $\\rightarrow^s$ as follows:\n\n- **Case 1:** $e \\rightarrow^s C[k]$ for some $k$:\n \n We add $(e, f)$ to $<^s$ giving $<^s'$. Clearly, no cycles are caused, since $e$ and $f$ were incomparable in $\\rightarrow^s$. We show that $C$ is consistent in $\\rightarrow^s'$. If not, then there must exist an event $g$ in the causal past (w.r.t. $\\rightarrow^s'$) of $C$ such that $C[g.proc] \\prec' g$ (where $\\prec'$ is defined with respect to $\\rightarrow^s'$). Since $C$ is consistent in $\\rightarrow^s$, it cannot be that both of the following are true: $g$ is in the causal past (w.r.t. $\\rightarrow^s$) of $C$ and $C[g.proc] \\prec g$. Therefore, we have two cases:\n\n - **Case a:** $g$ is not in the causal past (w.r.t. $\\rightarrow^s$) of $C$ and $C[g.proc] \\prec g$:\n \n Since $g$ is in the causal past (w.r.t. $\\rightarrow^s$) of $C$, we must have $g \\rightarrow^s e$ and $f \\rightarrow^s h$ for some $h \\in C$. Therefore, by transitivity, $g \\rightarrow^s C[k]$. Since $C[g.proc] \\prec g$, this contradicts the consistency of $C$ in $\\rightarrow^s$.\n\n - **Case b:** $C[g.proc] \\not\\prec g$:\n \n Since $C[g.proc] \\prec' g$, we must have $C[g.proc] \\prec e$ and $f \\prec g$. Since $e \\rightarrow^s C[k]$, this contradicts the consistency of $C$ in $\\rightarrow^s$.\n\n- **Case 2:** $e \\not\\rightarrow^s C[k]$ for all $k$:\n \n We add $(f, e)$ to $<^s$ giving $<^s'$. Clearly, no cycles are caused, since $e$ and $f$ were incomparable in $\\rightarrow^s$. We show that $C$ is consistent in $\\rightarrow^s'$. If not, then there must exist an event $g$ in the causal past (w.r.t. $\\rightarrow^s'$) of $C$ such that $C[g.proc] \\prec' g$ (where $\\prec'$ is defined with respect to $\\rightarrow^s'$). Since $C$ is consistent in $\\rightarrow^s$, it cannot be that both of the following are true: $g$ is in the causal past (w.r.t. $\\rightarrow^s$) of $C$ and $C[g.proc] \\prec g$. Therefore, we have two cases:\n– **Case a:** $g$ is not in the causal past (w.r.t. $\\rightarrow^s$) of $C$:\n\nSince $g$ is in the causal past (w.r.t. $\\rightarrow^{s'}$) of $C$, we must have $g \\rightarrow^s f$ and $e \\rightarrow^s h$ for some $h \\in C$. This contradicts the condition that $e \\not\\rightarrow^* C[k]$ for all $k$.\n\n– **Case b:** $g$ is in the causal past (w.r.t. $\\rightarrow^s$) of $C$ and $C[g,proc] \\not\\prec g$:\n\nSince $C[g,proc] \\prec' g$, we must have $C[g,proc] \\prec f$ and $e \\prec g$. Thus, by transitivity, $e$ is in the causal past (w.r.t. $\\rightarrow^s$) of $C$. This contradicts the condition that $e \\not\\rightarrow^* C[k]$ for all $k$.\n\n$$\\square$$\n\n### 4.6 Solving Conjunctive Predicate Detection Under Constraints\n\nThe result of the previous section tells us that if we exhaustively detect a predicate in each of $\\text{Lin}(\\langle E, \\rightarrow^s, <^s, \\sim \\rangle)$ then we have also done so for the computation $\\langle E, \\rightarrow^s, <^s, \\sim \\rangle$. Since this would be very inefficient, we identify two classes of general computations for which we may apply a special predicate detection algorithm to a specially chosen representative from $\\text{Lin}(\\langle E, \\rightarrow^s, <^s, \\sim \\rangle)$ in order to efficiently detect a predicate.\n\n- **(send/receive events):** In a general computation $\\langle E, \\rightarrow^s, <^s, \\sim \\rangle$, if $s \\sim t$, then we call $s$ a *send* event and we call $t$ a *receive* event.\n\n- **(Snd/Rcv):** Let $\\text{Snd}$ be the set of send events and $\\text{Rcv}$ be the set of receive events in $E$.\n\n- **(Snd$_i$/Rcv$_i$):** $\\text{Snd}_i$ and $\\text{Rcv}_i$ denote the sets of send and receive events, respectively, in $E_i$.\n\n- **(receive-ordered computation):** A computation $\\langle E, \\rightarrow^s, <^s, \\sim \\rangle$ is *receive-ordered* if $\\forall i: \\text{Rcv}_i$ is totally ordered under $(<^s_i)^+$. \n\n87\n(send-ordered computation) : A computation \\((E, \\rightarrow^s, <^s, \\sim)\\) is send-ordered if \\(\\forall i : Snd_i\\) is totally ordered under \\((<^s_i)^+\\).\n\nThe constraint of being send-ordered or receive-ordered is sometimes natural for computations derived from common programming styles. For example, a scenario that arises very often, especially in client-server systems, is:\n\n```plaintext\nrepeat\n receive a request ;\n create a thread to process the request\nuntil done\n```\n\nIt is clear that such a scenario is receive-ordered even though the sends and per-request processing may be independent.\n\nAnother scenario that is often used to model synchronous rounds is:\n\n```plaintext\nrepeat\n receive and process messages\n until time = end-of-round ;\n send messages\nuntil done\n```\n\nIf the sends in a round occur in a fixed order or use the same port, then they are totally ordered while receives and local processing may be independent. Thus, a distributed computation resulting from such a program would be send-ordered.\n\nLet CPR and CPS denote the CPG problem specialized to receive-ordered and send-ordered computations respectively.\n\nFrom the set of local linearizations of a given computation, we pick a special representative that satisfies the following property:\n- \\(P1\\): Let \\(\\langle E, \\rightarrow, <, \\sim \\rangle\\) be a local linearization of \\(\\langle E, \\rightarrow^s, <^s, \\sim \\rangle\\). Then let \\(P1\\) be the following property.\n\n\\[ P1: \\forall i: \\forall e \\in E_i: \\forall f \\in Rcv_i: (f (<)^+ e) \\Rightarrow (f \\rightarrow^s e) \\]\n\nThis ensures that we linearize the partial order \\(<^s\\) on each process such that a receive event is ordered after all the events that are concurrent with it. The property is well-defined because no two receive events are concurrent.\n\nIn order to ensure this property, we apply a special linearization algorithm, RECEIVE-SORT shown in Figure 4.2, for each process. The algorithm is a modification of a standard topological sort algorithm that gives a higher priority to non-receive events so that all events concurrent to a receive event precede it in the total ordering. The algorithm applies this modified topological sort to the graph \\(\\langle E_i, <^s_i \\rangle\\). It is easy to show that this correctly produces a linearization of the partial order for each process. It is also easy to show that the linearizations produced by the algorithm form a local linearization that satisfies Property \\(P1\\):\n\n**Lemma 21** Let \\(\\langle E, \\rightarrow^s, <^s, \\sim \\rangle\\) be a receive-ordered computation and let \\(<= \\bigcup_i <_i\\), where \\(<_i\\) is the linearization of \\(<^s_i\\) produced by applying algorithm RECEIVE-SORT. Then, \\(\\langle E, \\rightarrow, <, \\sim \\rangle\\) is a local linearization of \\(\\langle E, \\rightarrow^s, <^s, \\sim \\rangle\\) satisfying \\(P1\\).\n\n**Proof:** We first show that the graph of \\(\\langle E, \\rightarrow, <, \\sim \\rangle\\) satisfies \\(P1\\). We next show that the graph \\(\\langle E, < \\cup \\sim \\rangle\\) has no cycles and, therefore, \\(\\langle E, \\rightarrow, <, \\sim \\rangle\\) is a computation.\nInput:\n\n\\[ E_i \\] set of events\n\n\\[ Rcv_i \\] set of receive events in \\( E_i \\)\n\nOutput:\n\n\\[ Q_i \\] queue of events in \\( E_i \\), initially \\( \\emptyset \\)\n\nNotation:\n\nselect(\\( Z \\)) arbitrary element from non-empty set \\( Z \\)\n\nVariables:\n\n\\[ F = E_i \\] set of events\n\n\\[ M = \\emptyset \\] set of events\n\n\\[ R = \\emptyset \\] set of events\n\n\\( e, f \\) events\n\n\\( k[E_i] \\) array of integers ranging over events in \\( E_i \\)\n\nAlgorithm:\n\nL1 for each event \\( e \\) in \\( E_i \\) do\nL2 \\[ k[e] := \\text{no. of incoming edges in } <^s_i \\text{ for } e \\]\nL3 if \\( (k[e] = 0) \\) then\nL4 if \\( (e \\in Rcv_i) \\) then \\( R := R \\cup \\{e\\} \\)\nL5 else \\( M := M \\cup \\{e\\} \\)\nL6 while \\( (F \\neq \\emptyset) \\) do\nL7 if \\( (M \\neq \\emptyset) \\) then \\( f := \\text{select}(M) \\)\nL8 else \\( f := \\text{select}(R) \\)\nL9 enqueue(\\( Q_i, f \\))\nL10 \\( F := F - \\{f\\} \\)\nL11 for each event \\( e \\in F \\) such that \\( f <^s_i e \\) do\nL12 \\( k[e] := k[e] - 1 \\)\nL13 if \\( (k[e] = 0) \\) then\nL14 if \\( (e \\in Rcv_i) \\) then \\( R := R \\cup \\{e\\} \\)\nL15 else \\( M := M \\cup \\{e\\} \\)\n\nFigure 4.2: Algorithm RECEIVE-SORT\nThe following four invariants are maintained by the algorithm at line L9:\n\nINV1: \\( \\forall e \\in F : k[e] = \\text{number of events that immediately precede } e \\text{ in } (F, <^s_i) \\).\n\nINV2: \\( M \\) is the set of minimal events in \\( (F, <^s_i) \\) that are not in \\( Rcv_i \\).\n\nINV3: \\( R \\) is the set of minimal events in \\( (F, <^s_i) \\) that are in \\( Rcv_i \\).\n\nINV4: \\( F \\) contains no event in \\( (E_i, <^s_i) \\) that transitively precedes an event in \\( M \\cup R \\).\n\nIt is easy to prove INV1 from the algorithm, and then prove INV2 and INV3 using it. INV4 follows from INV1 by induction on the length of the transitive path.\n\nTo show that \\( \\mathbf{P1} \\) holds, let \\( e \\in E_i \\) and \\( f \\in Rcv_i \\) be two events such that \\( f (<)^+ e \\). Since \\( (E, \\rightarrow^s, <^s, \\sim) \\) is receive-ordered and since \\( < \\) is a linearization of \\( <^s \\), the case when \\( e \\in Rcv_i \\) follows easily. So, consider the case of \\( e \\notin Rcv_i \\).\n\nConsider the iteration of the loop L6-L15 in which \\( f \\) was enqueued in \\( Q_i \\). Since \\( f \\in Rcv_i \\), \\( f \\) must have been chosen at line L8 (using INV2 and INV3). So \\( M = \\emptyset \\).\n\nFurther, \\( R = \\{f\\} \\) (using INV3, INV4, and that the computation is receive-ordered).\n\nWe conclude that \\( f \\) is the minimum event in \\( (F, <^s_i) \\). Since \\( f (<)^+ e \\), \\( e \\) has not been enqueued yet. Therefore, \\( f (<^s)^+ e \\).\n\nWe next prove by contradiction that there are no cycles in the graph \\( (E, < \\cup\\sim) \\). Suppose there is such a cycle, \\( C \\). Clearly \\( C \\) cannot be within a single \\( E_i \\). Therefore, there must be at least one receive event in \\( C \\). Let \\( R \\) be the set of receive events in \\( C \\). Since \\( \\rightarrow^s \\) is an irreflexive partial order \\((E, \\rightarrow^s, <^s, \\sim) \\) is a computation), let \\( r \\) be any maximal event in \\( (R, \\rightarrow^s) \\). Let \\( s \\sim r' \\) be the next \\( \\sim \\) edge in the cycle \\( C \\). Therefore, \\( r (<)^+ s \\). Therefore, by \\( \\mathbf{P1} \\), we have \\( r \\rightarrow^s s \\).\n\nTherefore, \\( r \\rightarrow^s r' \\) contradicting the choice of \\( r \\) as maximal. \\( \\Box \\)\n\nFrom Property \\( \\mathbf{P1} \\), we derive the following useful property:\n\n- (\\( \\mathbf{P2} \\)): Let \\( (E, \\rightarrow, <, \\sim) \\) be a local linearization of \\( (E, \\rightarrow^s, <^s, \\sim) \\). Then let \\( \\mathbf{P2} \\) be the following property.\nLemma 22 Let \\( \\langle E, \\to, <, \\sim \\rangle \\) be a local linearization of a receive-ordered computation \\( \\langle E, \\to^s, <^s, \\sim^s \\rangle \\). Then \\( P_1 \\Rightarrow P_2 \\).\n\nProof: Let \\( i \\neq j \\) and \\( e \\in E_i \\) and \\( f, g \\in E_j \\) and let \\( e \\to^s f \\) and \\( f (\\leq^s) g \\). Since \\( e \\to^s f \\) and \\( e.\\text{proc} \\neq f.\\text{proc} \\), there must be some receive event \\( r \\) in \\( E_j \\) such that \\( e \\to^s r \\) and \\( r (\\leq^s)^+ f \\). Since \\( < \\) is a linearization of \\( <^s \\), we have \\( r (\\leq^s)^+ f \\), and, therefore, \\( r (\\leq^s)^+ g \\). If \\( r = g \\), we are done. If \\( r (>)^+ g \\), \\( P_1 \\) implies that \\( r \\to^s g \\).\n\nTherefore, by transitivity, \\( e \\to^s g \\). \\( \\Box \\)\n\nWe now apply algorithm PRED-DETECT in Figure 4.3 to the special representative local linearization chosen using algorithm RECEIVE-SORT.\n\nOur final result shows that applying PRED-DETECT to the representative local linearization is sufficient for detecting the predicate in the general computation. The main idea of the algorithm is similar to that used in [GW94] to optimally solve the problem for locally ordered computations. We start with the lowest cut and move upwards. If, in a cut \\( C \\), we find that for some \\( i \\) and \\( j \\), \\( C[i].\\text{next} \\to^s C[j] \\) then using Property P2, we are guaranteed that \\( C[i].\\text{next} \\) is ordered before (in \\( \\to^s \\)) every event following \\( C[j] \\) in the total order \\( < \\). So \\( C[i] \\) can never be part of a consistent cut, and can be safely discarded. If no such pair of events can be found, then the cut is consistent. The algorithm discards at least one event in each iteration, and so, must terminate.\n\nTheorem 14 Let \\( \\langle E, \\to, <, \\sim \\rangle \\) be the local linearization of a receive-ordered computation \\( \\langle E, \\to^s, <^s, \\sim^s \\rangle \\) produced by applying algorithm RECEIVE-SORT to each \\( \\langle E_i, <^s_i \\rangle \\). Then applying algorithm PRED-DETECT to \\( \\langle E, \\to, <, \\sim \\rangle \\) and \\( \\phi_{\\text{conj}} \\) solves CPR for \\( \\langle E, \\to^s, <^s, \\sim^s \\rangle \\) and \\( \\phi_{\\text{conj}} \\).\n\nProof: We first show that if PRED-DETECT returns \\( \\text{detected} = \\text{true} \\) then there is a consistent cut in \\( \\langle E, \\to^s, <^s, \\sim^s \\rangle \\) that satisfies \\( \\phi_{\\text{conj}} \\). It is easy to verify that the\nInput:\n\\[ Q_1, Q_2, \\ldots, Q_n \\] event queues (\\( Q_i \\) contains events of \\( E_i \\cup \\{ \\perp_i \\} \\) in \\( <_i \\) order)\n\\( \\alpha_1, \\alpha_2, \\ldots, \\alpha_n \\) local predicates\n\nOutput:\n\\( detected \\) boolean\n\nNotation:\n\\( all = \\{ 1, 2, \\ldots, n \\} \\)\n\nVariables:\n\\( low, newlow \\) subsets of \\( all \\)\n\\( k, l \\) integers in \\( all \\)\n\nAlgorithm:\n\\begin{verbatim}\nL1 low := all\nL2 while ((low ≠ ∅) ∧ (∀k : ¬Q_k.empty)) do\nL3 newlow := ∅\nL4 for k in low do\nL5 if (¬x_k(Q_k.head)) then\nL6 newlow := newlow ∪ \\{ k \\}\nL7 else\nL8 for l in all do\nL9 if ((Q_k.head.next, Q_l.head ∈ E) ∧ (Q_k.head.next → ^* Q_l.head)) then\nL10 newlow := newlow ∪ \\{ k \\}\nL11 else\nL12 newlow := newlow ∪ \\{ l \\}\nL13 low := newlow\nL14 for k in low do\nL15 Q_k.delete_head\nL16 detected := (∀k : ¬Q_k.empty)\n\\end{verbatim}\n\nFigure 4.3: Algorithm PRED-DETECT\nThe following invariants are maintained after line L13:\n\n**INV1:** \\( \\forall k \\notin \\text{low} : \\alpha_k(Q_k.\\text{head}) \\)\n\n**INV2:** \\( \\forall k, l \\notin \\text{low} : (Q_k.\\text{head}.\\text{next}, Q_l.\\text{head} \\in E) \\Rightarrow (Q_k.\\text{head}.\\text{next} \\not\\rightarrow^s Q_l.\\text{head}) \\)\n\nSince, on termination, \\( \\text{detected} = \\text{true} \\), by the terminating condition at L2, we must have \\( \\text{low} = \\emptyset \\) after line 13 of the final iteration. Consider the cut \\( C \\) such that \\( \\forall i : C[i] = Q_i.\\text{head} \\) after line 13 of the final iteration. By INV1, we know that \\( C \\) satisfies \\( \\phi_{\\text{conj}} \\) and by INV2, we know that \\( C \\) is consistent (by Lemma 3) in \\( \\langle E, \\rightarrow, <, \\sim \\rangle \\). Further, by Lemma 2, \\( C \\) is consistent in \\( \\langle E, \\rightarrow^s, <^s, \\sim \\rangle \\).\n\nNext, we show that if PRED-DETECT returns \\( \\text{detected} = \\text{false} \\), then there is no consistent cut in \\( \\langle E, \\rightarrow^s, <^s, t \\rangle \\) that satisfies \\( \\phi_{\\text{conj}} \\). Suppose there is such a consistent cut, \\( C \\). Since \\( \\text{detected} = \\text{false} \\), some queue must be empty at termination. Therefore, at least one of the \\( C[i] \\)'s must have been deleted from its queue. Consider the first iteration in which a \\( C[i] \\) was deleted. Since \\( \\phi_{\\text{conj}}(C) \\), \\( C[i] \\) could not have been added to \\( \\text{newlow} \\) at L6. Therefore, \\( C[i] \\) must have been added in either L10 or L12. In either case, \\( C[i].\\text{next} \\neq \\text{null} \\) and \\( C[i].\\text{next} \\rightarrow^s Q_j.\\text{head} \\) for some \\( j \\). Since \\( C[i] \\) is the first to be deleted, \\( Q_j.\\text{head}(\\leq)^+ C[j] \\). By Lemmas 21 and 22, we know that \\( \\text{P2} \\) holds. Therefore, \\( C[i].\\text{next} \\rightarrow^s C[j] \\) contradicting the consistency of \\( C \\) (by Lemma 3). \\( \\Box \\)\n\nHaving established that CPR can be solved efficiently, it remains to solve CPS. Consider a send-ordered computation \\( \\langle E, \\rightarrow^s, <^s, \\sim \\rangle \\). Let \\( \\langle E, \\rightarrow^{s'}, <^{s'}, \\sim' \\rangle \\) be the computation obtained by inverting all the edges in the computation so that \\( <^{s'} = \\{(e, f)|(f, e) \\in <^s\\} \\) and \\( \\sim' = \\{(e, f)|(f, e) \\in \\sim\\} \\). In this computation, the receive events become send events and vice-versa. Therefore, in order to solve CPS in a send-ordered computation \\( \\langle E, \\rightarrow^s, <^s, \\sim \\rangle \\), we can solve CPR instead in the receive-ordered computation \\( \\langle E, \\rightarrow^{s'}, <^{s'}, \\sim' \\rangle \\). Thus, the algorithms we described for CPR can be used to solve CPS.\n\n94\nIf $m$ is a bound on $|E_i|$ and $e$ is the size of the $<^s$ relation, then we can deduce that the time complexity of applying RECEIVE-SORT to each process is $O(mn + e)$ and the time complexity of PRED-DETECT is $O(mn^2)$. So the time complexity to solve CPR or CPS is $O(mn^2 + e)$.\n\n### 4.7 Solving Conjunctive Predicate Detection Without Constraints\n\nHaving efficiently solved CPR and CPS, we now take another look at the general problem CPG. We know that CPG is NP-Complete. So, a polynomial solution to CPG is unlikely. Two naive exponential solutions are possible. Let $m$ be a bound on $|E_i|$. The first solution enlists every cut and checks if it is consistent, taking $O(m^n n^2)$ time. The second applies a predicate detection algorithm (such as in [GW94]) to every local linearization of the general computation, which takes $O(m^{mn}mn^2)$ time.\n\nHowever, these solutions do not perform any better for general computations which are \"close\" to being send-ordered or receive-ordered. For example, in a general computation which has two possible linearizations of receive events in one process, we would expect not to have to pay the full price of the above naive solutions. We now provide a solution that degrades gracefully for computations that are close to being send-ordered or receive-ordered.\n\nLet $k_i$ be a bound on the number of linearizations of the $<^s$ relation restricted to the set of receive events in $E_i$. If we linearize for each process, we can construct a receive-ordered computation by adding the ordering of receive events imposed by the linearizations. For all such possible combinations of linearizations, there would be $k = k_1 \\times k_2 \\times \\ldots \\times k_n$ possible receive-ordered computations. We know (as in Theorem 13) that applying predicate detection to each such receive-ordered computations would be equivalent to applying predicate detection to the original computation. So we can solve CPG by applying our algorithm for CPR to $k$ receive-ordered computations, taking $O(k(mn^2 + e))$ time. Notice that this degrades to the\nsecond naive approach in the worst case but achieves good results if $k$ is small, or the original computation is close to being receive-ordered. A similar approach could be used if the computation were close to being send-ordered. Further, by decomposing it into receive-ordered computations instead of locally ordered computations, we save an exponential number of applications of a predicate detection algorithm as compared to the second naive approach.\nChapter 5\n\nControlled Re-execution: An\nExperimental Study\n\nIn this chapter, we describe an experimental evaluation of the controlled re-execution method, based on the predicate control algorithms of Chapter 3.\n\n5.1 Overview\n\nFirst, in Section 5.2, we describe the application domain and assumptions for our study.\n\nSection 5.3 describes the controlled re-execution method along with two alternative re-execution methods: simple re-execution and locked re-execution. We also make a qualitative evaluation of controlled re-execution relative to simple and locked re-execution. We conclude that controlled re-execution has the disadvantages of making the “piece-wise determinism” assumption and involving an extra tracing cost during normal operation, and the advantages of being able to give a guarantee of recoverability and it has a higher likelihood of recovery than the other two approaches. It remains to show quantitatively: (1) how much the cost of tracing is, and (2) how much better is controlled re-execution at being able to recover.\n\nSection 5.4 gives the details of our experimental setting, including implementation, environment, benchmarks, and parameters. We used synthetic benchmarks\nto allow flexibility in choosing important parameter values such as frequency of communication and frequency of file accesses.\n\nSection 5.5 presents the experimental results. We conclude that the tracing overhead is less than 1% even for applications with relatively high communication and file access frequencies (with respect to real scientific applications). We also conclude that controlled re-execution has a significantly higher ability to tolerate races than either the simple or the locked re-execution methods under varying values of communication and file access frequencies.\n\nIn Section 5.6, we discuss extending controlled re-execution to other scenarios. This is a discussion of what we would expect if some of the assumptions made in Section 5.2 are weakened. Important extensions that we discuss include extensions to read-write races and various blocking and non-blocking communication primitives.\n\nIn Section 5.7, we give a brief summary.\n\n5.2 The Context\n\nThe targeted application domain consists of long-running, non-interactive distributed applications over a local area network. The applications communicate using messages and share files on a network file system. Some examples of applications in this class include weather forecast systems and fluid dynamics code in aerophysics. Messages are used in these applications both to communicate data and for synchronization. Shared files are used to log intermediate results for persistence, for debugging traces, and as an alternate communication mechanism. We chose this application domain as a starting point for studying the effectiveness of controlled re-execution since their long-running and non-interactive nature make them suitable for rollback recovery in general, and further, their simple and well-defined interfaces for communication and file i/o facilitate controlled re-execution.\nMessage passing is point-to-point and reliable. No assumption is made regarding the order of delivery. We assume, for simplicity, that all send invocations are non-blocking and all receive invocations are blocking. We will consider other blocking/non-blocking semantics in Section 5.6.\n\nFiles in the network file system are accessible from all the processes in the application. While the file system provides a view of basic read and write operations, the programming interface is through higher-granularity file access operations. Each file access consists of a clearly demarcated region of code (e.g. a method of a persistent object in object-oriented programs, or a procedure in procedural programs). A file access consists of reads and writes to the file as well as other operations including communication operations, but excluding other file accesses. A file access is called a write file access if it contains at least one write operation and a read file access otherwise. We assume that all write file accesses are synchronous (i.e. all writes reach the file before the end of the access). This assumption is necessary because adding synchronizations would be unable to prevent races for asynchronous writes since the actual time at which the data reaches the file on disk is indeterminate. Further, we assume that the network file system supports read and write locking. For simplicity, we initially restrict our attention to write-only files (disallowing reads). We will discuss the general case of read-write files in Section 5.6.\n\nThe types of synchronization faults that we are concerned with are races (or data races) on files. A race occurs when two file accesses are concurrent and at least one of them is a write file access. In order to prevent races, file accesses must be synchronized using either messages or file locks.\n\n5.3 Re-execution Methods\n\nIn the context of races, rollback recovery consists of three phases:\n\n1. Detection: detect a race failure.\n2. Restoration: restore a consistent global state.\n\n3. Re-execution: re-execute to avoid a recurrence of the race.\n\nBoth detection and restoration have been widely studied problems. Race detection has been studied in the context of debugging concurrent programs [CL95, FL97, Net91, SBN+97, Tai97]. Restoration has been the central problem of much of the work in rollback recovery for fail-stop faults (as opposed to software faults) [EAWJ99]. Our focus is on the re-execution phase. Before describing the proposed controlled re-execution method, we first describe two natural re-execution methods.\n\n5.3.1 Simple Re-execution\n\nThe simplest re-execution method merely allows the application to execute normally. There are two reasons why a race might not recur if a program is simply re-executed. Firstly, if the relative timing of events in different processes changes (for example, owing to different system and network load conditions) then the two file accesses which caused a race in the previous execution may be separated in time in the re-execution. The second reason is that applications sometimes have non-deterministic events which cause the re-execution to differ from the previous execution. Some examples of such non-deterministic events are message receive events (since a different message may be delivered), thread scheduling events, and signal handler events. Note, however, that the simple re-execution method can give no guarantees that a re-execution will be race-free.\n\n5.3.2 Locked Re-execution\n\nOne method to guarantee that races do not recur is to use file locks to synchronize all file accesses. However, this locked re-execution method may introduce deadlocks, if the added file locks interfere with the synchronizations of the application. A\ndeadlock is due to a cyclic wait-for dependency caused by added file locks and application blocking message receives. A simple wait-for cycle is shown in Figure 5.1.\n\nDeadlock scenarios arise because of file accesses which contain communications that synchronize. The traditional methodology of locking is to follow a discipline of programming that forbids such wait-for synchronizations inside locked critical sections. However, since the imposition of locks during re-execution is adventitious rather than planned, such situations may occur. For example, the file access procedure might involve information gathered from multiple processes. As another example, a file access procedure might make multiple logs for tracing purposes interspersed with communications in the code being traced.\n\nSince the locked re-execution may, in general, have different relative timings and non-deterministic choices than the first execution, it cannot be guaranteed before-hand that the re-execution will be deadlock-free.\n\n5.3.3 Controlled Re-execution\n\nControlled re-execution aims at preventing both races and deadlocks. In controlled re-execution, explicit control messages are used to synchronize the file accesses in a pre-determined order that does not conflict with the existing synchronizations. Further, the previous execution is replayed rather than simply re-executed (i.e. all\nnon-deterministic events, such as message receives, are replayed [NM92]). Thus, the replayed execution together with the added control messages form a *strict partial order* of events than the first execution. In other words, the problem of adding synchronization edges appropriately is a direct application of the predicate control problem for the general mutual exclusion predicate discussed in Chapter 3. File accesses are treated as critical sections for the purposes of the algorithm. All that remains is determine how to: (1) trace during normal execution to obtain the input computation for predicate control, and (2) add control messages corresponding to the extra edges in the output computation of predicate control.\n\n### 5.3.3.1 Tracing\n\nIn order to represent the partial order relationship between events (required as input to the predicate control algorithm), a *vector clock* mechanism [Mat89, Fid91] is used. A vector clock is an $n$-sized vector with one entry per process in the system. We refer the reader to [Gar96] for a detailed discussion on vector clock mechanisms. For our purposes it is sufficient to know that for a computation $\\langle E, \\rightarrow \\rangle$, a vector clock mechanism assigns to each event $e \\in E$ a vector clock $e.v$ such that:\n\n$$\\forall e, f \\in E : e \\rightarrow f \\iff e.v < f.v$$\n\nwhere $e.v < f.v = (\\forall k : e.v[k] \\leq f.v[k]) \\land (\\exists k : e.v[k] < f.v[k])$.\n\nFurther, we can compare two events in constant time using the following property of vector clocks:\n\n$$\\forall e, f \\in E : e \\rightarrow f \\iff (e.v[e.proc] \\leq f.v[e.proc]) \\land (e.v[f.proc] < f.v[f.proc])$$\n\nIn order to trace the file accesses, we must interrupt execution at the begin and end events for the file access. The vector clock value at these events is recorded. By maintaining the sequence of these vector clocks for each process, we have the input interval sequences for the predicate control algorithm in Figure 3.6.\nIn addition to tracing for control, we must also trace all non-deterministic events so that they may be replayed during re-execution. The ability to trace such events is referred to as the piece-wise determinism assumption since it allows a process execution to be divided into deterministic pieces. The same assumption is also made in rollback recovery systems based on message logging [EAWJ99] and trace-replay systems for debugging [CS98, LMC87, NM92, RZ97, Net93]. For the applications under consideration, we assume that receive events, which may receive a different message in a re-execution, are the only non-deterministic events (for now, we are assuming that files are write-only; we deal with reads and other types of non-deterministic events in Section 5.6). Therefore, information to identify a message (e.g. sender’s id and position in sender’s sequence of sent messages) must be traced at each receive event to be used in replaying the same message delivery order during re-execution.\n\nTo summarize the key points of the tracing mechanism, the execution is interrupted at three points: (1) receive events, (2) begin file access events, and (3) end file access events. The traced information allows for replay. Furthermore, the traced information provides the input computation for the predicate control algorithm. An example of such a traced computation is depicted in Figure 5.2(a).\n5.3.3.2 Control\n\nOnce the predicate control algorithm of Figure 3.6 is applied, the output from the algorithm consists of a set of edges that must be added to the original computation to obtain a controlling computation of mutual exclusion. Suppose \\((e, f)\\) is one such added edge. Note that, according to the algorithm, \\(e\\) is the end event for some file access and \\(f\\) is the begin event of some other file access. Therefore, during re-execution, when process \\(e.proc\\) reaches the end file access event \\(e\\) (identifiable by comparing with vector clock \\(e.v\\)), it sends a control message to process \\(f.proc\\). The control message has an empty message body and has a message envelope consisting of sender and receiver identification, vector clock \\(e.v\\), and a message type (tag) value that is distinct from all application messages. When the process \\(f.proc\\) reaches the begin file access event \\(f\\) (identifiable by \\(f.v\\)), it first performs a blocking receive, waiting for a control message from \\(e.proc\\) with vector clock value \\(e.v\\). Once the message is received, it continues normal execution. \\(^1\\)\n\nFigure 5.2 illustrates a simple scenario of controlled re-execution in which all critical sections (file accesses) correspond to a single file. The traced computation in Figure 5.2(a) has races since the application synchronizations do not ensure mutual exclusion. The predicate control algorithm uses the critical section graph shown in Figure 5.2(b) to determine the edges to be added. Based on the added edges, control messages are sent during re-execution as shown in Figure 5.2(c).\n\nThere is a seeming contradiction in replaying the non-deterministic choices of a failed execution in order to prevent a recurrence of a failure. However, it must be stressed that it is only the process executions that are replayed and not the sequence of operations on a file. Since the failure outcome of the race is data interleaving\n\n\\(^1\\)Owing to the manner in which the algorithm orders critical sections, an optimization can be made: the vector clock value \\(e.v\\) need not be sent with the control message. The receiving process \\(f.proc\\) merely blocks waiting for the next message to be received from \\(e.proc\\). It is verifiable that, even without any assumptions on message ordering, this ensures that the message sent from \\(e\\) is received at \\(f\\).\non the write-only files, replaying the execution with added control synchronizations ensures that the files are not corrupted during re-execution. The case of read-write files will be discussed in Section 5.6.\n\n5.3.4 A Qualitative Evaluation\n\nHaving described the operation of the three re-execution methods, we now make a qualitative evaluation of the advantages and disadvantages of controlled re-execution with respect to simple and locked re-execution.\n\n5.3.4.1 Disadvantages of Controlled Re-execution:\n\n1. **Tracing Cost:** Unlike simple and locked re-execution, controlled re-execution requires tracing of information for control and replay. Tracing imposes a cost both in space and in time. This cost is particularly important since it is imposed during failure-free operation.\n\n The cost in time does not involve the cost of writing the traces synchronously to disk. This is because we are not considering failure scenarios, such as power failures, in which volatile storage is lost. The cost in space involves the size of one vector clock value for each receive event, begin file access event, and end file access event. This is in contrast to the cost already imposed in order to implement the restoration phase of recovery, typically involving checkpointing and message logging.\n\n2. **Piece-wise Determinism Assumption:** Controlled re-execution assumes that all non-deterministic events can be identified, traced, and replayed. For example, by assuming that the only source of non-determinism is the receive events and tracing the order of message delivery. This assumption is not required by either simple or locked re-execution.\nWhile maintaining the piece-wise determinism assumption is a challenging problem, the application domain under consideration has fewer sources of non-determinism than more general applications that interact more frequently with their environments. Sources of non-determinism usually arise from message ordering, thread scheduling, interrupts, or system calls. Dealing with such sources of non-determinism has been a widely-studied problem in the context of message logging protocols [EAWJ99]. When the restoration mechanism used for rollback recovery involves message logging, the piece-wise determinism assumption is already made regardless of the re-execution scheme used. Therefore, controlled re-execution imposes no additional assumptions in such cases.\n\n5.3.4.2 Advantages of Controlled Re-execution:\n\n1. Ability to Recover: Suppose an application has failed and restored a consistent global state, which one of the three methods has a greater likelihood of providing a safe re-execution? The likelihood of simple re-execution providing a safe re-execution (no races) depends on timing and the likelihood of file access overlap. For locked re-execution, the likelihood of a safe re-execution (no deadlocks) depends on the likelihood of cyclic file access/communication synchronizations. For controlled re-execution, the likelihood of a safe re-execution (no cycles in the critical section graph) depends on the likelihood of cyclic communication synchronizations.\n\nFor the application domain under consideration, the non-determinism owing to message reordering is expected to be low, since a receive usually corresponds to a unique message. Thus, it is expected that a re-execution has the same synchronization pattern as the failed execution. Therefore, the only situation in which the mutual exclusion predicate control algorithm (for a single file)\nfails is when a safe re-execution is impossible (refer to Section 3.5). Thus, the likelihood of recovery in controlled re-execution is at least as high as that in simple and locked re-execution. It remains to determine how much higher the likelihood actually is.\n\n2. **Guarantee:** Independent of the expected recoverability, controlled re-execution also has the advantage of being able to guarantee before-hand whether it will be able to provide a safe re-execution. In the case of simple and locked re-execution there are no such guarantees and the re-execution must be attempted before its safety is determined. Thus, repeated re-execution - detection - restoration cycles are avoided in the case of controlled re-execution.\n\nThis advantage is especially important in the context of a complementary framework consisting of all three schemes. In such a framework, if one re-execution method fails, another may be attempted. The advantage of an *a priori* guarantee is useful in such a framework, since it is immediately clear whether controlled re-execution should be used.\n\nIn order to make a complete evaluation of controlled re-execution, we require a quantitative evaluation of: (1) how much of a disadvantage is posed by the tracing cost, and (2) how much of an advantage is involved in the improved ability to recover. This is the objective of the experimental study described in the following sections.\n\n### 5.4 Experimental Setting\n\n#### 5.4.1 Implementation and Environment\n\nWe implemented the three re-execution methods in the form of a library that augments the functionality of MPI (Message Passing Interface). The relevant calls – send, receive, begin file access, and end file access – are intercepted by the augmented library before passing control to the normal routines.\nOur implementation was based on mpich 1.1 [GL96], a portable implementation of MPI. To provide synchronous writes over a network, we exported a remote interface to a local Unix file system. Tracing was implemented both in-memory and using asynchronous writes to local files. Control messages were implemented using blocking MPI messages with a unique tag value.\n\nSince our experiments focus on the re-execution phase, we implemented simple strategies for the detection and restoration phases of recovery. For failure detection, we performed an integrity check on the files to check for data corruption. Restoration was implemented by restarting all processes, thus restoring the initial consistent global state. This is valid for our experiments since the synthetic benchmarks we use (described in the next section) are not sensitive to the starting point of the re-executions.\n\nThe experimental environment consists of 4 Sun Ultra 10 Workstations (440 MHz) running Solaris 2.7 and connected by a 100 Mbps Ethernet. Each workstation has 128MB of DRAM and a 4GB local disk.\n\n5.4.2 Synthetic Benchmarks\n\nFor our experiments, we used synthetic benchmarks which allow various critical parameters, such as the frequency of communication and the frequency of file access to be varied independently. Each synthetic application is generated by running a loop, each iteration of which picks an event with a pre-specified probability from among a set of possible events. The possible events are: sends, receives, file access begins, file access ends, file writes, and local events. The file accesses ensure that file writes occur within the context of a file access and, in the default case, file accesses are not nested. The recipient of a message is chosen uniformly at random. Receives are blocking, waiting on a specific process in such a way as not to create communication deadlocks (determined by a sample non-blocking execution). The file\ncorresponding to each file access is selected uniformly at random. Similar synthetic applications have also been used in the study of message logging recovery protocols [ARV98] and logical clock schemes [TRA96].\n\nThe main reason for selecting synthetic benchmarks is because it gives us flexibility in selecting application parameters such as communication and file access frequencies. We selected the parameters values for the synthetic benchmarks based on measurements of the NPB 2.0 Benchmark Suite [BHS+95] consisting of five computational fluid dynamics codes and the NAS Application I/O (BTIO) Benchmark [Fin97] consisting of one of the NPB 2.0 Benchmark codes including file i/o. In a similar manner as the BTIO Benchmark, we instrumented the remaining four NPB 2.0 Benchmark codes with file i/o. Further, we referred to two other studies of scientific application codes: [Rao99] for measurements on the same NPB Benchmark Suite and [AHKM96] for a detailed study of eight scientific applications that use messages and file i/o. Furthermore, we referred to [KN94] for a study of dynamic file-access characteristics of a production parallel scientific workload.\n\nA further advantage of using synthetic benchmarks is that the NPB benchmark applications do not account for possible non-determinism in the application codes. This biases our comparative study of recoverability in favor of controlled re-execution and against simple re-execution. The synthetic benchmarks allow us flexibility in including non-determinism since a different re-execution can be generated based on the same parameters to model a non-deterministic application (alternatively, a single synthetic application can be replayed multiple times to model a deterministic application).\n\n5.4.3 Parameters\n\nThe applications under consideration have two main characteristics: the frequency of communications and the frequency of file accesses. These are represented by the\nfollowing two parameters:\n\n- **mean communication period**: the average time between consecutive communication events (receive or send events) on a process, averaged over all processes.\n\n- **mean file access period**: the average time between consecutive file accesses on a process, averaged over all processes.\n\nNote that the parameters are controlled indirectly by varying the relative probabilities of communication or file access events for the generated synthetic application. Measurements are then made to determine their values.\n\nThere are other parameters for the synthetic applications for which we set default values, unless otherwise specified. These parameters are the message size (default: 100 bytes), the file write size (1 KB), the mean file access time (90 - 110 ms), the mean file-i/o period (30 - 35 ms), the number of files (1), and the fraction of file-i/o that are writes (1). The defaults were chosen based on the real application parameters (from the sources listed above) and the assumptions for the common-case.\n\n### 5.5 Experiments\n\n#### 5.5.1 The Costs of Controlled Re-execution\n\nUnlike simple and locked re-execution, controlled re-execution imposes the extra penalty of tracing during normal execution. First, we give the details of exactly what extra information is traced and at what points. There are three execution points at which a trace needs to be taken:\n\n- **receive events**: At each receive, the following information is traced: the sender’s id, the message tag (used to classify messages into types in MPI), and the sender’s entry in the message’s vector clock.\n• **begin file access events**: At each begin file access event, the following information is traced: the vector clock value, whether it is a read or a write file access (in the general case), and the file id for the file access.\n\n• **end file access events**: At each end file access event, the vector clock value is traced.\n\nTracing may be implemented in-memory or using asynchronous writes to files. We do not use synchronous writes since we assume that a failure is detected in time to save volatile memory to stable storage. The trace may be periodically shortened by a garbage collection mechanism, under the assumption that the execution has progressed far enough that the deleted information will never be required.\n\nTracing has a cost both in time and space. We use two simple metrics for these costs:\n\n• **time overhead**: This is the percentage increase in total application running time when tracing is performed. The time overhead is measured both for in-memory and asynchronous file tracing. Note that the time overhead is for an application that does not incorporate other recovery mechanisms, such as checkpointing and message logging (the overhead calculated in consideration of existing recovery mechanisms is smaller than our measure).\n\n• **space cost**: This is the amount of space required per unit time (in MB/hour).\n\nWe measured the tracing costs for applications with relatively dense communication and file access patterns. Note that mean communication period values are in the range 10 - 200ms for the NPB Benchmarks and mean file access period values are in the range 100 - 10000 ms (based on [Rao99] and our measurements, assuming one file access every iteration). Table 5.1 shows the results.\n\nThe time overheads were under 1% for all applications. Further, this is true for both in-memory tracing and asynchronous file tracing.\n<table>\n<thead>\n<tr>\n<th>Mean comm. period (ms)</th>\n<th>Mean file access period (ms)</th>\n<th>Time overhead</th>\n<th>Space (MB/hour)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td></td>\n<td>In-memory tracing</td>\n<td>Asynch. file tracing</td>\n</tr>\n<tr>\n<td>30</td>\n<td>183</td>\n<td>0.21%</td>\n<td>0.55%</td>\n</tr>\n<tr>\n<td>3</td>\n<td>159</td>\n<td>0.15%</td>\n<td>0.69%</td>\n</tr>\n<tr>\n<td>87</td>\n<td>67</td>\n<td>0.03%</td>\n<td>0.05%</td>\n</tr>\n</tbody>\n</table>\n\nTable 5.1: The Tracing Cost of Controlled Re-execution\n\nThe space cost is small considering that typical scientific applications can require in the order of 1GB of disk space for storing application data [AHKM96]. Further, existing restoration techniques such as checkpointing and message logging would typically have much larger disk space requirements. The space requirements can be further reduced by garbage collection making in-memory tracing feasible. Note that space required in any given period of time is exactly $12r + (8n + 4)f$ bytes where $r$ is the number of receive events, $n$ is the number of processes, and $f$ is the number of file accesses.\n\nWe conclude that the tracing costs for controlled re-execution are very small.\n\n### 5.5.2 The Benefits of Controlled Re-execution\n\nThe benefits of controlled re-execution lie in improved likelihood of recovery. In these experiments we aim at measuring how much of a gain this is. We use synthetic applications with randomly generated communication and file access patterns. Therefore, races are automatically generated periodically. In such a simulated faulty scenario, we test how far an execution can proceed under each of the three methods before a failure occurs. Note that the meaning of a failure is different for the three methods:\n• **simple re-execution:** A failure occurs when a race causes data to be corrupted on the file. We measure the time of failure at the time of the concurrent writes to the file.\n\n• **locked re-execution:** A failure is a deadlock. We measure the time of failure as the minimum time that a process involved in the deadlock starts to wait for a resource.\n\n• **controlled re-execution:** A failure does not really occur. Instead, controlled re-execution can guarantee before-hand whether or not it can execute safely. In cases where it cannot give such a guarantee, there must be a cycle of critical sections in the interval graph. We say that controlled re-execution fails if it cannot guarantee a safe re-execution and we measure the time of failure as the minimum of the times at which a critical section in the cycle is entered. This is fair since controlled re-execution can safely execute up to this point in time.\n\nThe metric we use is:\n\n• **mean time to failure (mttf):** The time from the beginning of the execution, averaged over all processes, up to the time of failure (as defined above).\n\nThe mttf for a re-execution method is an indicator of the ability of that method to tolerate faults in a faulty application. The greater the mttf, the greater is the likelihood of recovery.\n\nFigure 5.3 shows the plot of mttf against mean communication period for simple, locked and controlled re-execution methods. Multiple synthetic applications of the corresponding parameter values were executed to obtain each mttf point. We varied the mean communication period over a range chosen based on applications in the NPB benchmarks (10 - 200 ms). The mean file access period was kept fixed at 200 ms. It is important to note that the scale is logarithmic since the corresponding\nFigure 5.3: Plotting mttf against mean comm. period\n\nFigure 5.4: Plotting mttf against mean comm. period on a linear scale\nlinear-scaled graph shown in Figure 5.5.2 has too great a difference between the three mttf plots for the three methods to be clearly depicted.\n\nFor both locked and controlled re-execution, we expect that the likelihood of a failure (deadlock/cycle of critical sections) is expected to be lower as the mean communication period increases and the communications get less dense. Clearly, simple re-execution remains unaffected by the communication pattern changes since the file access density is fixed.\n\nThe reason that controlled re-execution has a greater mttf than locked re-execution is that for a given communication density, the likelihood of a deadlock is significantly greater than the likelihood of a cycle of critical sections. If there is a cycle of critical sections, there must necessarily be a deadlock. Further, many deadlocks do not involve cycles of critical sections since a deadlock may occur when file locks are acquired in an order that interferes with the messages, whereas a cycle of critical sections depends solely on the messages.\n\nThe reason that controlled re-execution has a greater mttf than simple re-execution is that if there is a cycle of critical sections then two of those critical sections must occur at the same time leading to a race. However, if a race occurs there need not be any synchronization cycles (and the likelihood reduces as the communication density decreases).\n\nNext we plot mttf against mean file access period while keeping the mean communication period fixed. Figure 5.5 shows the results. The parameters for mean file access period were picked based on applications in the NPB benchmark.\n\nThe reason all three graphs rise with increasing mean file access period is as follows. As the file access density decreases, so does the likelihood of two file accesses occurring concurrently. Therefore, races are less likely. Further, deadlocks are also less likely since the file accesses are spaced further apart making it less likely for the locks to interfere with synchronizations. Further as critical sections get spaced\nFigure 5.5: Plotting mttf against mean file access period\n\nfurther apart, the chance of a cycle of synchronizations also diminishes.\n\nThe reason controlled re-execution has a higher mttf than the other two methods is as follows. If there is a cycle of critical sections, then clearly there must be a race since two critical sections in the cycle must occur together. Further, there must necessarily be a deadlock. However, the reverse is not true.\n\nThus, the overall conclusion of these experiments is that the mttf is significantly higher for controlled re-execution than for locked and simple re-execution.\n\n5.6 Extensions\n\nIn this section, we discuss some extensions to the controlled re-execution method. Each of the extensions results from weakening one of the assumptions made in this study.\n\nExtension to other blocking/non-blocking communication primitives\n\nWe assumed that for all communications, sends are non-blocking and receives are blocking. This assumption was made for simplicity and the other combinations can be handled as well. The case of both blocking sends can be modeled by an extra\nmessage (in addition to the one being sent) that is sent by the receiver after the message transfer completes and for which the sender blocks waiting. The case of non-blocking receives can be handled by simply treating them in the same way as blocking receives for the purpose of predicate control. Often, non-blocking receives are made in cases where the relative order of message delivery does not affect the future synchronizations. In such cases, the non-blocking receives need not be traced and the computation input to predicate control consists of only the blocking receives.\n\n**Extension to read-write files**\n\nWe have assumed that files are write-only for the purpose of our study and so the only races are write-write races. If the processes were to read from the file as well, then the reads cause an extra communication channel between processes and also introduce another potential source of non-determinism based on the order of file accesses. There are two scenarios with different requirements for dealing with read-write files.\n\nIn the first scenario, we consider the general case with no assumptions. The reads must be traced for the dependencies they cause just as messages with vector clocks being maintained for the files in addition to the processes. Since controlled re-execution attempts to change the order of accesses at a file, in general, it is impossible to replay the same execution beyond the first recovered race. However, in cases where the change in order of file accesses does not affect the computation, the replay can progress. It is possible to continue execution using controlled re-execution up to the point where a divergence from the previous execution is detected. No guarantees can be made beyond this point.\n\nThe second scenario is applicable to applications whose synchronization patterns do not change with the values read from files. This is often true in the application domain under consideration since, although the values of communication\nmessages often change with the values read from files, the order of synchronizations remains unchanged. Since controlled re-execution is only sensitive to the order and not the content of messages, in such cases it is not necessary to trace and replay read accesses.\n\n**Extension to other non-deterministic events**\n\nIn our study, we make the commonly made assumption that receive events are the only sources of non-determinism. In general, there may be other sources of non-determinism. We have already discussed non-determinism induced by read accesses from files. Some other sources of non-determinism are thread scheduling events in multi-threaded programs, system calls, and asynchronous signals. Much work has been done in the context of rollback recovery [GGL+90, SE96] and in distributed debugging [TCO91, MCL89, RC96] towards tracing and replaying multi-threaded programs. For a detailed discussion of system call and asynchronous signals, we refer the reader to [EAWJ99]. If the recovery system uses message logging, it would already require to trace and replay non-deterministic events. In such cases, the necessary mechanisms would be already available for controlled re-execution.\n\n**5.7 Summary**\n\nTo summarize our evaluation of the controlled re-execution method with respect to simple and locked re-execution methods.\n\n- **Advantages:**\n\n - **Ability to recover:** Our experiments tested the ability of the three re-execution methods to tolerate races in synthetic applications under different values of communication and file access density. The results showed that the mean time to failure was significantly higher in the case of controlled re-execution.\n– **Guarantee**: Controlled re-execution does not depend on chance and can guarantee a race-free re-execution *a priori* while the other two methods cannot.\n\n• **Disadvantages:**\n\n– **Piece-wise Determinism Assumption**: The controlled re-execution method makes the piece-wise determinism assumption while the other two methods do not.\n\n– **Tracing Overhead**: Unlike the other two methods, controlled re-execution involves a tracing cost. However, our experiments on synthetic applications with high communication and file access densities show that the time overhead is less than 1% and the space cost is in the range of 0.5-2.5 MB/hour.\nChapter 6\n\nRelated Work\n\nWe discuss the related research in three sections corresponding to the topics of each of the previous three chapters: the predicate control problem, the predicate detection problem, and controlled re-execution.\n\n6.1 The Predicate Control Problem\n\nThe predicate control results in this dissertation were first published in [TG98c] and [TG99]. We are aware of two previous studies of controlling distributed systems to maintain classes of global predicates. One study [MSWW81] allows global properties within the class of conditional elementary restrictions [MSWW81]. Unlike our model of a distributed system, their model uses an off-line specification of pair-wise mutually exclusive states and does not use causality. [Ray88] and [TG94] study the on-line maintenance of a class of global predicates based on ensuring that a sum or sum-of-product expression on local variables does not exceed a threshold. In contrast to these approaches, our focus is on general global boolean predicates, disjunctive predicates, and mutual exclusion predicates.\n\nSince our results in predicate control were published, some advances in solving predicate control have been made in [MG00]. The authors present an equivalent formulation of the predicate control problem in terms of “admissible sequences”. Based on this, they provide an algorithm for disjunctive predicates that has the\nsame time complexity as the algorithm presented in this dissertation, but has the added advantage of generating the minimum synchronizations. They also solve the predicate control problem for the class of “region predicates” that can express such conditions as deadlock and termination.\n\n**Relation to Predicate Detection**\n\nSince there is a duality between observation and control, it is not surprising that there is a relation between predicate detection, a formalization of observation, and predicate control, a formalization of control. To understand the relationship, consider a computation in which definitely : ¬ϕ is detected, where the modality definitely for a predicate [CM91] implies that the predicate becomes true in any possible execution (run) corresponding to the computation. Clearly, there can be no controlling computation of ϕ in the computation since any execution corresponding to the controlling computation is also an execution corresponding to the original computation. Therefore, a controlling computation of a predicate ϕ in a given computation exists if and only if definitely : ¬ϕ is not detected in the computation. As evidence of this, the necessary and sufficient conditions for detecting definitely : ϕ for conjunctive predicates were demonstrated in [GW96], and are similar to our results in predicate control for disjunctive predicates. An important difference between the two problems is that, though the predicate detection problem for definitely : ¬ϕ can be used to determine whether a controlling computation of ϕ exists, it is not concerned with actually finding the controlling computation. Another interesting conclusion is that all of our predicate control algorithms can be used to solve a corresponding predicate detection problem.\nRelation to On-line Synchronization\n\nThe predicate control problem is an off-line synchronization problem since it assumes that the computation is known *a priori*. In contrast, existing synchronization problems [BA90] such as mutual exclusion, readers writers, and dining philosophers are on-line and require synchronization without such pre-knowledge. The predicate control problem for each of the predicates we have studied has a corresponding on-line synchronization problem, in which the computation is an on-line rather than an off-line input. Predicate control for mutual exclusion predicates corresponds to the widely-studied distributed mutual exclusion problem [Ray86, BA90, Vel93, Sin93]. Predicate control for readers writers predicates corresponds to the readers writers problem [CHP71, Lam77, BA90]. Predicate control for independent mutual exclusion predicates does not correspond to a new on-line problem. Instead, multiple distributed mutual exclusion protocols operate independently assuming that deadlocks are prevented using a programming discipline such as two-phase locking. Predicate control for disjunctive predicates corresponds to a special case of the $k$-mutual exclusion problem [Ray89, SR92, MBB+92, HJK93, BV95] (that allows up to $k$ processes inside a critical section at the same time) in which $k = (n - 1)$.\n\nEach of the on-line problems above make assumptions on the programming discipline, such as non-blocking critical sections or two-phase locking. In a general context without such assumptions, it can be shown that the on-line synchronization problems stated above are impossible to solve [TG98c], and therefore, it is impossible to maintain the predicate while avoiding deadlocks. Our solutions to the predicate control problems do not make such assumptions. Instead, they make use of the pre-knowledge of the computation to maintain the predicate while avoiding deadlocks. Thus, off-line synchronization is, inherently, a more powerful technique than on-line synchronization.\n\nAnother distinction between the on-line and off-line problems is that the\npredicate control problems operate on a single computation of the distributed program. The on-line synchronization problems, on the other hand, operate at the level of the programming language and must, therefore, correctly synchronize for all possible computations of the program.\n\n### 6.2 The Predicate Detection Problem\n\nThe results in predicate detection presented in this dissertation were first published in [TG98a]. Surveys of predicate detection may be found in [BM93, SM94, Gar96]. There have been three approaches to solving predicate detection. The first approach [CL85, SK86, HJPR87, Bou87] is based on periodically computing a consistent cut of the system through a global snapshot protocol and checking whether the cut satisfies the given predicate. This method works only for stable predicates, such as deadlock and termination, which remain true once they become true. However, in general, predicates need not be stable and may become true only between consecutive snapshots. The second approach [CM91, AV94, JMN95] constructs the entire lattice of cuts to detect a given predicate. This approach is able to detect unstable predicates but it has an exponential time complexity of $O(k^n)$ where $k$ is the number of “relevant” local events and $n$ is the number of processes. The third approach [MC88, MI92, AV93, HPR93, TG93, GW94, BR94, FRGT94, JJJR94, CG95, GC95, GTFR95, TG95, VD95, BFR96, GW96, HMRS96, HR96, GCKM97] is based on using the structure of the predicate. Instead of constructing the entire lattice of cuts, the approach uses the computation directly. Thus, efficient algorithms can be constructed, but they are restricted to certain classes of predicates. In this dissertation, our focus has been on the third approach.\n\nWithin the third approach, we focus on predicates that are defined on a single cut. There are two modalities defined for detecting a predicate $\\phi$ defined on a single cut. The first modality, $\\text{possibly:}\\phi$, is defined to be true if the lattice of cuts has a\npath from the initial cut to the final cut containing at least one cut that satisfies $\\phi$. The second modality, \\textit{definitely} $\\phi$, is true if every path from the initial cut to the final cut in the lattice of cuts contains at least one cut that satisfies $\\phi$. Note that our definition of predicate detection corresponds to \\textit{possibly} $\\phi$.\n\nIt has been shown that for the important class of conjunctive predicates, predicate detection can be solved efficiently for both \\textit{possibly} $\\phi$ [GW94] and \\textit{definitely} $\\phi$ [GW96]. Although these solutions are centralized, distributed algorithms have also been designed [GC95, HMRS96]. Further, conjunctive predicates have been extended to “channel predicates” [GCKM97] that consider both the states of the message channels and the states of the processes. The work most closely related to our study is [GW94]. The main difference is that while they use the happened before model of computation, our study uses the extended model of computation which allows improved predicate detection. We use the algorithm presented in [GW94] as part of our solution for detecting conjunctive predicates in the extended model.\n\n\\textbf{The Extended Model of Computation}\n\nIn our study of the predicate detection problem, we used an extended model of computation that partially orders the events both across processes and within a process so as to reduce false causality. Using partial orders to model concurrency avoids the combinatorial explosion involved in the interleaving model. This fact has led to a number of studies of such partial order models [Lam78, Pra86]. Problems in \\textit{false causality} have been observed in application domains other than predicate detection, such as: race detection [SBN+97], causally ordered communication [CS93], and optimistic recovery [DTG99]. Models that extend the happened before model [Lam78] by allowing partially ordered events within a process have also been proposed in [ACG93, HW96, TG98b].\n6.3 Controlled Re-execution\n\nFor a good introduction to the past work in software fault tolerance, the interested reader is referred to [Lyu95]. There are three approaches to tolerating software faults. The “design diversity” approach [AC77, Ran75] uses redundant modules to prevent a single point-of-failure. This method is effective provided the same fault does not appear in different modules. The “data diversity” approach [AK88] use techniques to re-express input data in an attempt to bypass faults. However, such re-expression is effective only for a limited range of applications. This dissertation is concerned with the “environment diversity” approach, first introduced in the progressive retry method [WHF+97] which aims at bypassing a fault by rolling back the application and restarting from a previous state. For certain “transient” faults, the progressive retry method was found to be effective.\n\nThe rollback recovery method used in [WHF+97] involves three distinct phases: detection, restoration, and re-execution. Our focus has been on the detection and re-execution phases. However, much work has been done in the restoration phase in the context of conventional (not software) fault tolerance. For a survey of general rollback recovery methods in distributed systems for global state restoration, the reader is referred to [EAWJ99]. Aspects of restoration peculiar to software fault tolerance have been studied in [WHF+97, CC98a].\n\nWe have already discussed the related work for the detection phase in the previous section on predicate detection. With respect to the re-execution phase, existing approaches [WHF+97] and [CC98a] have targeted general faults and have used a simple re-execution technique based on simply restarting the system from a restored state, with possible message reorderings. These re-execution techniques cannot guarantee a safe re-execution. Our controlled re-execution approach focuses on the class of synchronization faults and can give a guarantee of safe re-execution based on controlling the re-execution with added synchronization messages.\nRelation to Speculative Computing\n\nSpeculative computing is another rollback approach for tolerating synchronization faults in both shared-memory multiprocessor environments [Smi81, SP98, APR99] and distributed shared memory environments [HW94, KCDZ95, KS97, BPA98, Mue99]. Speculative or optimistic computing is more aggressive than conventional fault tolerant computing in that faults are allowed to occur intentionally. This allows greater efficiency by avoiding expensive fault prevention techniques that use locks or barrier synchronizations. Speculative computing methods generally assume a weak consistency model such as release consistency [KCDZ95] or group write consistency [HW94]. Further, they assume that the level of atomicity is at the level of reads and writes to a single object. In contrast, the controlled re-execution method assumes a sequential consistency model [Lam79] and atomicity at the level of multi-object operations [MG98] including sends and receives of messages and reads and writes to files.\n\nAnother distinction is in the re-execution method employed. The forms of control used in speculative methods are distinct from that used by controlled re-execution – controlling the relative timing among processes through synchronization. For example, branch prediction schemes [Smi81, SP98] ensure that a different execution path is followed during re-execution based on the faulty branch choices made during the previous execution. In another example, [KCDZ95] describes a hybrid scheme as a compromise between lazy release consistency and eager release consistency. The protocol operates by optimistically sending only a fraction of the data that would be sent by an eager protocol. On encountering invalid data, the protocol switches to lazy mode, explicitly acquiring the data. Unlike these specialized forms of control, controlled re-execution limits its control to the relative timing among processes.\nChapter 7\n\nConclusions and Future Directions\n\nSoftware fault tolerance has conventionally been perceived as a passive approach consisting of monitoring the system and attempting general purpose techniques such as restarting from a previous checkpoint or failing over to a backup process. In this dissertation we have aimed at demonstrating the benefits of a more active approach to software fault tolerance that involves taking corrective rather than reactive measures based on an understanding of the failure and its causes. This involves a more aggressive approach to the two functions of a run-time environment – observation and control. The observation function must involve monitoring the system not merely to detect failures but also to provide information of the causes that led to the failure. The complementary control function uses this information to decide on appropriate corrective actions.\n\nWe make a first step in this direction by showing how, in the case of synchronization faults, by tracing synchronization information during normal execution, one can take more effective corrective action during re-execution. This led us to the investigation of the little studied off-line synchronization problem – the predicate control problem. We designed algorithms for solving the predicate control problem for some important classes of predicates. This is encouraging, especially in the light of the fact that the corresponding and better studied on-line synchronization problems are impossible to solve.\nIn addition to control, we also worked towards improved observation methods by studying and designing algorithms for detecting conjunctive predicates in an extended model. The extended model is especially important since it allows improved detection, but we find, not surprisingly, that it makes the problem significantly harder to solve.\n\nAn interesting future direction would be to try to apply corrective approaches to tolerate other classes of software faults. This need not be in a transparent manner, but may involve a programming paradigm in which information that is useful for recovery is made explicit. For example, failures that arise from insufficient memory may be recovered using corrective strategies that invoke garbage collection. Failures arising from timeouts may be corrected by reducing the load on the machine through the migration of some processes.\n\nAnother application domain that would benefit greatly from the observation and control paradigm is that of distributed debugging. In fact, since it is more tolerable to incur overhead in debugging than in fault tolerance, more aggressive observation methods could be used to allow improved control. For example, tracing the values of process variables, could allow the control strategy to intelligently reset the variables to test the application under different conditions. It would also be useful to apply predicate control as was done in the controlled re-execution method to test the application under various synchronization conditions.\n\nWe have limited our study of the controlled re-execution method for tolerating synchronization faults to race faults. It is important to study the applicability of a similar technique to other types of synchronization faults, such as deadlocks, disjunctive predicate violations, and violations of load balancing. Another restriction we made was to focus on the application domain of long-running, non-interactive applications that communicate with messages and files. This is a natural first step owing to the nice synchronization and shared resource interfaces. An in-\ninteresting question is whether the same approach could be used in other application domains, such as multi-threaded applications which communicate using wait-notify primitives and share objects in memory. Another interesting application domain is distributed shared memory systems which maintain consistency conditions over distributed shared objects.\n\nIn the study of the predicate control problem, there are some interesting open questions. We have solved predicate control for mutual exclusion predicates and for disjunctive predicates. These are two extreme subcases of the more general \\( k \\)-mutual exclusion predicates. The \\( k \\)-mutual exclusion predicates specify that at most \\( k \\) of the processes can enter critical sections together. Thus, we have solved the cases of \\( 1 \\)-mutual exclusion and \\( (n - 1) \\)-mutual exclusion. We do know of a necessary condition for solving the predicate control problem for \\( k \\)-mutual exclusion. This corresponds to a set of critical sections in which each critical section has at least \\( k \\) incoming \\( \\rightarrow \\) edges from the other critical sections. Note that from this, we can derive the necessary and sufficient conditions for both \\( 1 \\)-mutual exclusion and \\( (n - 1) \\)-mutual exclusion. However, it still remains an open question whether the \\( k \\)-mutual exclusion problem can be efficiently solved.\n\nIt would also be useful to solve the predicate control problem in the context of relational predicates [Gar96]. An example of such a predicate is \\((x_1 + x_2 + \\cdots + x_n > k)\\), where \\( x_i \\)'s are integer variables in different processes and \\( k \\) is a constant. This allows us to express conditions such as the loss of a token and violations of a limited resource.\n\nThe extended model of computation allows events in a process to be locally ordered. This addresses the problem of false causality inherent in the use of the conventional happened before model. In this dissertation, we have studied the implications of the extended model in predicate detection and in another work we have studied the implications in optimistic message logging protocols [DTG99]. Another\napplication of the extended model can be found in predictive performance models of distributed systems [HW96]. In general, the extended model is useful in applications that benefit from improved causality tracking. Another application domain that falls in this class is that of message ordering systems that ensure causal ordering between messages [CS93]. Applying the extended model in causal ordering may result in more efficient implementations by avoiding unnecessary delaying of messages owing to false causality. However, the exact cost-to-benefit trade-offs remain to be studied.\nBibliography\n\n\n[HMRS96] M. Hurfin, M. Mizuno, M. Raynal, and M. Singhal. Efficient distributed detection of conjunction of local predicates in asynchronous computa-\n\n\nthe 14th International Conference on Distributed Computing Systems, pages 396–403, Poznan, Poland, June 1994. IEEE.\n\n\n139\n\n\n[Pan95] C. M. Pancake. The emperor has no clothes: What HPC users need to say and HPC vendors need to hear. In *Supercomputing*, San Diego, USA, December 1995. ACM/IEEE.\n\n\nVita\n\nAshis Tarafdar was born on February 11, 1973 in Howrah, India, the son of Anima Tarafdar and Sankar Prosad Tarafdar. He completed his schooling in Bombay, India in June 1990. He received the Bachelor of Technology degree in Computer Science and Engineering from the Indian Institute of Technology at Bombay in July 1994. Thereafter, he joined graduate school at the University of Texas at Austin where he received the Master of Sciences degree in Computer Sciences in December 1996. He has been employed at Microsoft Corporation, IBM Almaden Research Center, and IBM T. J. Watson Research Center during the summers of 1995, 1996, and 1999, respectively. He was awarded the MCD graduate fellowship in January 1995 by the University of Texas at Austin.\n\nPermanent Address: c/o Mrs. Anima Tarafdar\n606 Vigyan, Scientists’ CHS, Sector-17,\nVashi, New Mumbai - 400703, India\n\nThis dissertation was typeset with $\\LaTeX^2$ by the author.\n\n---\n\n$\\LaTeX^2$ is an extension of $\\LaTeX$. $\\LaTeX$ is a collection of macros for $\\TeX$. $\\TeX$ is a trademark of the American Mathematical Society. The macros used in formatting this dissertation were written by Dinesh Das, Department of Computer Sciences, The University of Texas at Austin."}}},{"rowIdx":292,"cells":{"id":{"kind":"string","value":"515a597b4ce9e3c43ecf4fa41400b20f395561ac"},"text":{"kind":"string","value":"UNISTORE: A fault-tolerant marriage of causal and strong consistency\n\nManuel Bravo Alexey Gotsman Borja de Régil Hengfeng Wei ∗\nIMDEA Software Institute Nanjing University\n\nAbstract\nModern online services rely on data stores that replicate their data across geographically distributed data centers. Providing strong consistency in such data stores results in high latencies and makes the system vulnerable to network partitions. The alternative of relaxing consistency violates crucial correctness properties. A compromise is to allow multiple consistency levels to coexist in the data store. In this paper we present UNISTORE, the first fault-tolerant and scalable data store that combines causal and strong consistency. The key challenge we address in UNISTORE is to maintain liveness despite data center failures: this could be compromised if a strong transaction takes a dependency on a causal transaction that is later lost because of a failure. UNISTORE ensures that such situations do not arise while paying the cost of durability for causal transactions only when necessary. We evaluate UNISTORE on Amazon EC2 using both microbenchmarks and a sample application. Our results show that UNISTORE effectively and scalably combines causal and strong consistency.\n\n1 Introduction\nMany of today’s Internet services rely on geo-distributed data stores, which replicate data in different geographical locations. This improves user experience by allowing accesses to the closest site and ensures disaster-tolerance. However, geo-distribution also makes it more challenging to keep the data consistent. The classical approach is to make replication transparent to clients by providing strong consistency models, such as linearizability [32] or serializability [69]. The downside is that this approach requires synchronization between data centers in the critical path. This significantly increases latency [1] and makes the system unavailable during network partitionings [27]. Thus, even though several commercial geo-distributed systems follow this approach [17, 19, 25, 62, 70], the associated cost has prevented it from being adopted more widely.\n\nAn alternative approach is to relax synchronization: the data store executes an operation at a single data center, without any communication with others, and propagates updates to other data centers in the background [20, 65]. This minimizes the latency and makes the system highly available, i.e., operational even during network partitionings. But on the downside, the systems following this approach provide weaker consistency models: e.g., eventual consistency [65, 68] or causal consistency [2]. The latter is particularly appealing: it guarantees that clients see updates in an order that respects the potential causality between them. For example, assume that in a banking application Alice deposits $100 into Bob’s account (u₁) and then posts a notification about it into Bob’s inbox (u₂). Under causal consistency, if Bob sees the notification (u₃), and then checks his account balance (u₄), he will see the deposit. This is not guaranteed under eventual consistency, which does not respect causality relationships, such as those between u₁ and u₂. In some settings, causal consistency has been shown to be the strongest model that allows availability during network partitionings [7, 44]. It has been a subject of active research in recent years, with scalable implementations [3, 42, 47] and some industrial deployments [54, 66].\n\nHowever, even causal consistency is often too weak to preserve critical application invariants. For example, consider a banking application that disallows overdrafts and thus maintains an invariant that an account balance is always non-negative. Assume that the balance of an account stored at two replicas is 100, and clients concurrently issue two withdraw(100) operations (u₅ and u₆) at different replicas. Since causal consistency executes operations without synchronization, both withdrawals will succeed, and once the replicas exchange the updates, the balance will go negative. To ensure integrity invariants in examples such as this, the programmer has to introduce synchronization between replicas, and, since synchronization is expensive, it pays off to do this sparingly. To this end, several research [9, 40, 41, 64] and commercial [5, 6, 28, 48, 57] data stores allow the programmer to choose whether to execute a particular operation under weak or strong consistency. For example, to preserve the integrity\ninvariant in our banking application, only withdrawals need to use strong consistency, and hence, synchronize; deposits may use weaker consistency and proceed without synchronization.\n\nGiven the benefits of causal consistency, it is particularly appealing to marry it with strong consistency in a geo-distributed data store. But like real-life marriages, to be successful this one needs to hold together both in good times and in bad – when data centers fail due to catastrophic events or power outages. Unfortunately, none of the existing data stores meant for geo-replication combine causal and strong consistency while providing such fault tolerance [9, 40, 41]. In this paper we present UniSTORE – the first fault-tolerant and scalable data store that combines causal and strong consistency. More precisely, UniSTORE implements a transactional variant of Partial Order-Restrictions consistency (PoR consistency) [30, 41]. This guarantees transactional causal consistency by default [3] and allows the programmer to additionally specify which pairs of transactions conflict, i.e., have to synchronize. For instance, to preserve the integrity invariant in our previous example, the programmer should declare that withdrawals from the same account conflict. Then one of the withdrawals $u_5$ and $u_6$ will observe the other and will fail.\n\nThe key challenge we have to address in UniSTORE is to maintain liveness despite data center failures. Just adding a Paxos-based commit protocol for strong transactions [18, 19, 34] to an existing causally consistent protocol does not yield a fault-tolerant data store. In such a data store, a committed strong transaction $t_2$ may never become visible to clients if a causal transaction $t_1$ on which it depends is lost due to a failure of its origin data center. This compromises the liveness of the system, because no transaction $t_3$ conflicting with $t_2$ can commit from now on: according to the PoR model, one of the transactions $t_2$ and $t_3$ has to observe the other, but $t_2$ will never be visible and $t_3$ did not observe $t_3$.\n\nUniSTORE addresses this problem by ensuring that, before a strong transaction commits, all its causal dependencies are uniform, i.e., will eventually become visible at all correct data centers. This adapts the classical notion of uniformity in distributed computing to causal consistency [15]. UniSTORE does so without defeating the benefits of causal consistency. Causal transactions remain highly available at the cost of increasing the latency of strong transactions: a strong transaction may have to wait for some of its dependencies to become uniform before committing. To minimize this cost, UniSTORE executes causal transactions on a snapshot that is slightly in the past, such that a strong transaction will mostly depend on causal transactions that are already uniform before committing. Furthermore, UniSTORE reuses the mechanism for tracking uniformity to let clients make causal transaction durable on demand and to enable consistent client migration.\n\nIn addition to being fault tolerant, UniSTORE scales horizontally, i.e., with the number of machines in each data center; this also goes beyond previous proposals [9, 40, 41]. To this end, UniSTORE builds on Cure [3] – a scalable implementation of transactional causal consistency. Our protocol extends Cure with a novel mechanism that distributes the task of tracking the set of uniform transactions among the machines of a data center. We also add the ability for data centers to forward transactions they receive from others, so that a transaction can propagate through the system even if its origin data center fails. Finally, we carefully integrate an existing fault-tolerant atomic commit for strong transactions [18] into the protocol for causal consistency.\n\nWe have rigorously proved the correctness of the UniSTORE protocol (§7 and §D). We have also evaluated it on Amazon EC2 using both microbenchmarks and a more realistic RUBiS benchmark. Our evaluation demonstrates that UniSTORE scalably combines causal and strong transactions, with the former not affecting the performance of the latter. Under the RUBiS mix workload, causal transactions exhibit a low latency (1.2ms on average), and the overall average latency is $3.7 \\times$ lower than that of a strongly consistent system.\n\n2 System Model\n\nWe consider a geo-distributed system consisting of a set of data centers $D = \\{1, \\ldots, D\\}$ that manage a large set of data items. A data item is uniquely identified by its key. For scalability, the key space is split into a set of logical partitions $P = \\{1, \\ldots, N\\}$. Each data center stores replicas of all partitions, scattered among its servers. We let $p_{m}^{d}$ be the replica of partition $m$ at data center $d$, and we refer to replicas of the same partition as sibling replicas. As is standard, we assume that $D = 2f + 1$ and at most $f$ data centers may fail. We call a data center that does not fail correct. If a data center fails, all partition replicas it stores become unavailable. For simplicity, we do not consider the failures of individual replicas within a data center: these can be masked using standard state-machine replication protocols executing within a data center [37, 55].\n\nReplicas have physical clocks, which are loosely synchronized by a protocol such as NTP. The correctness of UniSTORE does not depend on the precision of clock synchronization, but large drifts may negatively impact its performance. Any two replicas are connected by a reliable FIFO channel, so that messages between correct data centers are guaranteed to be delivered. As is standard, to implement strong consistency we require the network to be eventually synchronous, so that message delays between sibling replicas in correct data centers are eventually bounded by some constant [23].\n\n3 Consistency Model\n\nA client interacts with UniSTORE by executing a stream of transactions at the data center it is connected to. A transaction consists of a sequence of operations, each on a single data item, and can be interactive: the data items it accesses are not known a priori. A transaction that modifies at least one data item is an update transaction; otherwise it is read-only.\nA consistency model defines a contract between the data store and its clients that specifies which values the data store is allowed to return in response to client operations. **UniSTORE** implements a transactional variant of Partial Order Restrictions consistency (PoR consistency) [30, 41], which we now define informally; we give a formal definition in §B. The PoR model enables the programmer to classify transactions as either causal or strong. Causal transactions satisfy transactional causal consistency, which guarantees that clients see transactions in an order that respects the potential causality between them [2, 3]. However, clients can observe causally independent transactions in arbitrary order. Strong transactions give the programmer more control over their visibility. To this end, the programmer provides a symmetric conflict relation on operations that is lifted to strong transactions as follows: two transactions conflict if they perform conflicting operations on the same data item. Then the PoR model guarantees that, out of two conflicting strong transactions, one has to observe the other.\n\nMore precisely, a transaction \\( t_1 \\) precedes a transaction \\( t_2 \\) in the session order if they are executed by the same client and \\( t_1 \\) is executed before \\( t_2 \\). A set of transactions \\( T \\) committed by the data store satisfies PoR consistency if there exists a causal order relation \\( \\prec \\) on \\( T \\) such that the following properties hold:\n\n**Causality Preservation.** The relation \\( \\prec \\) is transitive, irreflexive, and includes the session order.\n\n**Return Value Consistency.** Consider an operation \\( u \\) on a data item \\( k \\) in a transaction \\( t \\in T \\). The return value of \\( u \\) can be computed from the state of \\( k \\) obtained as follows: first execute all operations on \\( k \\) by transactions preceding \\( t \\) in \\( \\prec \\) in an order consistent with \\( \\prec \\); then execute all operations on \\( k \\) that precede \\( u \\) in \\( t \\).\n\n**Conflict Ordering.** For any distinct strong transactions \\( t_1, t_2 \\in T \\), if \\( t_1 \\prec t_2 \\), then either \\( t_1 \\prec t_2 \\) or \\( t_2 \\prec t_1 \\).\n\n**Eventual Visibility.** A transaction \\( t \\in T \\) is either strong or originates at a correct data center eventually becomes visible at all correct data centers: from some point on, \\( t \\) precedes in \\( \\prec \\) all transactions issued at correct data centers. If all transactions are causal, then the above definition specializes to transactional causal consistency [3, 16]. If all transactions are strong and all pairs of operations conflict, then we obtain (non-strict) serializability.\n\nWhen \\( t_1 \\prec t_2 \\), we say that \\( t_1 \\) is a causal dependency of \\( t_2 \\). Return Value Consistency ensures that all operations in a transaction \\( t \\) execute on a snapshot consisting of its causal dependencies (as well as prior operations by \\( t \\)). Transactions are atomic, so that either all of their operations are included into the snapshot or none at all. The transitivity of \\( \\prec \\), mandated by Causality Preservation, ensures that the snapshot a transaction executes on is causally consistent: if a transaction \\( t_1 \\) is included into the snapshot, then so is any other transaction \\( t_2 \\) on which \\( t_1 \\) depends (i.e., \\( t_2 \\prec t_1 \\)). The inclusion of the session order into \\( \\prec \\), also mandated by Causality Preservation, ensures session guarantees such as read your writes [63]. The consistency model disallows the causality violation anomaly from §1. Indeed, since \\( \\prec \\) includes the session order, we have \\( u_1 \\prec u_2 \\) and \\( u_3 \\prec u_4 \\). Moreover, Bob sees Alice’s message, and by Return Value Consistency this can only happen if \\( u_2 \\prec u_3 \\). Then since \\( \\prec \\) is transitive, \\( u_1 \\prec u_4 \\), and by Return Value Consistency, Bob has to see Alice’s deposit.\n\nCausal consistency nevertheless allows the overdraft anomaly from §1: the withdrawals \\( u_5 \\) and \\( u_6 \\) may not be related by \\( \\prec \\), and thus may both execute on the balance 100 and succeed. The Conflict Ordering property can be used to disallow this anomaly by declaring that withdraw operations on the same account conflict and labeling transactions containing these as strong. Then one of the withdrawal transactions will be guaranteed to causally precede the other. The latter will be executed on the account balance 0 and will fail.\n\nFinally, Eventual Visibility ensures that strong transactions and those causal ones that originate at correct data centers are durable, i.e., will eventually propagate through the system.\n\nTo facilitate the use of causal transactions, **UniSTORE** includes replicated data types (aka CRDTs), which implement policies for merging concurrent updates to the same data item [56]. Each data item in the store is associated with a type (e.g., counter, set), which is backed by a CRDT implementation managing updates to it. For example, the programmer can use a counter CRDT to represent an account balance. Then if two clients concurrently deposit 100 and 200 into an empty account using causal transactions, eventually the balance at all replicas will be 300. Using ordinary writes here would yield 100 or 200, depending on the order in which the writes are applied. More generally, CRDTs ensure that two replicas receiving the same set of updates are in the same state, regardless of the receipt order. Together with Eventual Visibility, this implies the expected guarantee of eventual consistency [65]. Due to space constraints, we omit details about the use of CRDTs from our protocol descriptions.\n\n## 4 Key Design Decisions in UNISTORE\n\n**Baseline causal consistency.** A causal transaction in **UniSTORE** first executes at a single data center on a causally consistent snapshot. After this it immediately commits, and its updates are replicated to all other data centers in the background. This minimizes the latency of causal transactions and makes them highly available, i.e., can be executed even when the network connections between data centers fail.\n\nAs is common in causally consistent data stores [3, 22, 42], to ensure that causal transactions execute on consistent snapshots, a data center exposes a remote transaction to clients only after exposing all its dependencies. Then to satisfy the Eventual Visibility property under failures, a data center receiving a remote causal transaction may need to forward it to other data centers, as in reliable broadcast [11] and anti-entropy protocols for replica reconciliation [53].\nFigure 1: Why UniSTORE may need to forward remote causal transactions.\n\nFigure 2: Why UniSTORE needs to ensure that the dependencies of a strong transaction are uniform before committing it.\n\nFigure 1 depicts a scenario that demonstrates how Eventual Visibility could be violated in the absence of this mechanism. Let $t_1$ be a causal transaction submitted at a data center $d_1$ (event 1). Assume that $d_1$ replicates $t_1$ to a correct data center $d_2$ (event 2) and then fails (event 3), so that $t_1$ does not get replicated anywhere else. Let $t_2$ be a transaction submitted at $d_2$ after $t_1$ becomes visible there, so that $t_2$ depends on $t_1$ (event 4). Transaction $t_2$ will eventually be replicated to all correct data centers (event 5). But it will never be exposed at any of them, because its dependency $t_1$ is missing. If data centers can forward remote causal transactions, then $d_2$ can eventually replicate $t_1$ to all correct data centers, preventing this problem.\n\nOn-demand strong consistency. UniSTORE uses optimistic concurrency control for strong transactions: they are first executed speculatively and the results are then certified to determine whether the transaction can commit, or must abort due to a conflict with a concurrent strong transaction [69]. Certifying a strong transaction requires synchronization between the replicas of partitions it accessed, located in different data centers. UniSTORE implements this using an existing fault-tolerant protocol that combines two-phase commit and Paxos [18] while minimizing commit latency. However, just using such a protocol is not enough to make the overall system fault tolerant: for this, before a strong transaction commits, all its causal dependencies must be uniform in the following sense.\n\n**Definition 1.** A transaction is **uniform** if both the transaction and its causal dependencies are guaranteed to be eventually replicated at all correct data centers.\n\nThis adapts the classical notion of uniformity in distributed computing to causal consistency [15]. UniSTORE considers a transaction to be uniform once it is visible at $f + 1$ data centers, because at least one of these must be correct, and data centers can forward causal transactions to others.\n\nThe following scenario, depicted in Figure 2, demonstrates why committing a strong transaction before its dependencies become uniform can compromise the liveness of the system. Assume that a causal transaction $t_1$ and a strong transaction $t_2$ are submitted at a data center $d_1$ in such a way that $t_1$ becomes a dependency of $t_2$ (events 1 and 2). Assume also that $t_2$ is certified, committed, and delivered to all relevant replicas (events 3 and 4) before $t_1$ is replicated to any data center, and thus before it is uniform. Now if $d_1$ fails before replicating $t_1$ (event 5), no remote data center will be able to expose $t_2$, because its dependency $t_1$ is missing. This violates the Eventual Visibility property, and even worse, no strong transaction conflicting with $t_2$ can commit from now on. For instance, let $t_3$ be such a transaction, submitted at $d_3$ (event 6). Because $d_3$ cannot expose $t_2$, transaction $t_3$ executes on a snapshot excluding $t_2$. Hence, $t_3$ will abort during certification (events 7 and 8): committing it would violate the Conflict Ordering property, since transactions $t_2$ and $t_3$ conflict, but neither of them is visible to the other. Ensuring that $t_1$ is uniform before committing $t_2$ prevents this problem, because it guarantees that $t_1$ will eventually be replicated at $d_3$. After this $t_2$ will be exposed to conflicting transactions at this data center, which will allow them to commit.\n\n**Minimizing the latency of strong transactions.** Ensuring that all the causal dependencies of a strong transaction are uniform before committing it may significantly increase its latency, since this requires additional communication between data centers. UniSTORE mitigates this problem by executing causal transactions on a snapshot that is slightly in the past, which is allowed by causal consistency. Namely, UniSTORE makes a remote causal transaction visible to the clients only after it is uniform. This minimizes the latency of a strong transaction, since to commit it only needs to wait for causal transactions originating at the local data center to become uniform. We cannot delay the visibility of the latter transactions due to the need to guarantee read your writes to local clients.\n\n**On-demand durability of causal transactions.** Client applications interacting with the external world require hard durability guarantees; e.g., a banking application has to ensure that a withdrawal is durably recorded before authorizing the operation. UniSTORE guarantees that, once a strong transaction commits, the transaction and its dependencies are durable. However, UniSTORE returns from a causal transaction before it is replicated, and thus the transaction may be lost if its origin data center fails. Ensuring the durability of every single causal transaction would require synchronization between data centers on its critical path, defeating the benefits of causal consistency. Instead, UniSTORE reuses the mechanism for tracking uniformity to let the clients pay the cost of durability only when necessary. Even though UniSTORE replicates causal transactions asynchronously, it allows clients to execute a uniform barrier, which ensures that the transactions they have observed so far are uniform, and thus durable.\nClient migration. Clients may need to migrate between data centers, e.g., because of roaming or for load balancing. UniSTORE also uses the uniformity mechanism to preserve session guarantees during migration. A client wishing to migrate from its local data center \\(d\\) to another data center \\(i\\) first invokes a uniform barrier at \\(d\\). This guarantees that the transactions the client has observed or issued at \\(d\\) are durable and will eventually become visible at \\(i\\), even if \\(d\\) fails. The client then makes an attach call at the destination data center \\(i\\) that waits until \\(i\\) stores all the above transactions. After this, the client can operate at \\(i\\) knowing that the state of the data center is consistent with the client’s previous actions.\n\nCurrently UniSTORE does not support consistent client migration in response to a data center failure: if the data center a client is connected to fails, the client will have to restart its session when connecting to a different data center. As shown in [71], this limitation can be lifted without defeating the benefits of causal consistency. We leave integrating the corresponding mechanisms into UniSTORE for future work.\n\n5 Fault-Tolerant Causal Consistency Protocol\n\nWe first describe the UniSTORE protocol for the case when all transactions are causal. We give its pseudocode in Algorithms 1 and 2: for now the reader should ignore highlighted lines, which are needed for strong transactions. For simplicity, we assume that each handler in the algorithms executes atomically (although our implementation is parallelized). We reference pseudocode lines using the format algorithm#:line#.\n\n5.1 Metadata\n\nMost metadata in our protocol are represented by vectors with an entry per each data center, where each entry stores a scalar timestamp. However, different pieces of metadata use the vectors in different ways, which we now describe.\n\nTracking causality. The first use of the vectors is as vector clocks [26, 46], to track causality between transactions. Given vectors \\(V_1\\) and \\(V_2\\), we write \\(V_1 < V_2\\) if each entry of \\(V_1\\) is no greater than the corresponding entry of \\(V_2\\), and at least one is strictly smaller. Each update transaction is tagged with a commit vector commitVec. The order on these vectors is consistent with the causal order \\(\\prec\\) from §3: if \\(commitVec_1\\) and \\(commitVec_2\\) are the commit vectors of two update transactions \\(t_1\\) and \\(t_2\\) such that \\(t_1 \\prec t_2\\), then \\(commitVec_1 < commitVec_2\\). For a transaction originating at a data center \\(d\\) with a commit vector commitVec, we call \\(commitVec[d]\\) its local timestamp.\n\nEach replica \\(p^m_d\\) maintains a log \\(\\log[k]\\) of update operations performed on each data item \\(k\\) stored at the replica. Each log entry stores, together with the operation, the commit vector of the transaction that performed it. This allows reconstructing different versions of a data item from its log.\n\nRepresenting causally consistent snapshots. The protocol also uses a vector to represent a snapshot of the data store on which a transaction operates: a snapshot vector \\(V\\) represents all transactions with a commit vector \\(\\leq V\\). This snapshot is causally consistent. Indeed, consider a transaction \\(t_1\\) included into it, i.e., \\(commitVec_1 \\leq V\\). Since any causal dependency \\(t_0\\) of \\(t_1\\) is such that \\(commitVec_0 < commitVec_1\\), we have \\(commitVec_0 < V\\), so that \\(t_0\\) is also included into the snapshot. A client also maintains a vector pastVec that represents its causal past: a causally consistent snapshot including the update transactions the client has previously observed.\n\nTracking what is replicated where. Each replica \\(p^m_d\\) maintains three vectors that are used to compute which transactions are uniform. These respectively track the sets of transactions replicated at \\(p^m_d\\), the local data center \\(d\\), and \\(f + 1\\) data centers. Each of these vectors \\(V\\) represents the set of update transactions originating at a data center \\(i\\) with a local timestamp \\(\\leq V[i]\\). Note that this set may not form a causally consistent snapshot. The first vector maintained by \\(p^m_d\\) is knownVec. For each data center \\(i\\), it defines the prefix of update transactions originating at \\(i\\) (in the order of local timestamps) that \\(p^m_d\\) knows about.\n\nProperty 1. For each data center \\(i\\), the replica \\(p^m_d\\) stores the updates to partition \\(m\\) by all transactions originating at \\(i\\) with local timestamps \\(\\leq\\) knownVec\\([i]\\).\n\nOur protocol ensures that knownVec\\([d]\\) \\(\\leq\\) clock at any replica in data center \\(d\\). The vector knownVec at \\(p^m_d\\) records whether the updates to partition \\(m\\) by a given transaction are stored at this replica. In contrast, the next vector stableVec records whether the updates to all partitions by a transaction are stored at the local data center \\(d\\).\n\nProperty 2. For each data center \\(i\\), the data center \\(d\\) stores the updates by all transactions originating at \\(i\\) with local timestamps \\(\\leq\\) stableVec\\([i]\\). More precisely, we are guaranteed that knownVec\\([i]\\) at any replica of \\(d \\geq\\) stableVec\\([i]\\) at any \\(p^m_d\\).\n\nFinally, the last vector uniformVec defines the set of update transactions that \\(p^m_d\\) knows to have been replicated at \\(f + 1\\) data centers, including \\(d\\).\n\nProperty 3. Consider uniformVec\\([i]\\) at \\(p^m_d\\). All update transactions originating at \\(i\\) with local timestamps \\(\\leq\\) uniformVec\\([i]\\) are replicated at \\(f + 1\\) datacenters including \\(d\\). More precisely: knownVec\\([i]\\) at any replica of these data centers \\(\\geq\\) uniformVec\\([i]\\) at \\(p^m_d\\).\n\nWhen uniformVec is reinterpreted as a causally consistent snapshot, it defines transactions that \\(p^m_d\\) knows to be uniform according to Definition 1:\n\nProperty 4. Consider uniformVec at \\(p^m_d\\). All update transactions with commit vectors \\(\\leq\\) uniformVec are uniform.\n\nProof sketch. Consider a transaction \\(t_1\\) that originates at a data center \\(i\\) with a commit vector commitVec\\(_1\\) \\(\\leq\\) uniformVec at \\(p^m_d\\). In particular, commitVec\\(_1\\)[i] \\(\\leq\\) uniformVec[i], and by Property 3, \\(t_1\\) is replicated at \\(f + 1\\) data centers. We as-\nsume at most $f$ failures. Then the transaction forwarding mechanism of our protocol (§4) guarantees that $t_1$ will eventually be replicated at all correct data centers. Consider now any causal dependency $t_2$ of $t_1$ with a commit vector $commitVec_2$. Since commit vectors are consistent with causality, $commitVec_2 < commitVec_1 \\leq uniformVec$. Then as above, we can again establish that $t_2$ will be replicated at all correct data centers, as required by Definition 1.\n\n5.2 Causal Transaction Execution\n\nStarting a transaction. A client can submit a transaction to any replica in its local data center by calling $startTx(V)$, where $V$ is the client’s causal past $pastVec$ (line 1:1, for brevity, we omit the pseudocode of the client). A replica $p_d^m$ receiving such a request acts as the transaction coordinator. It generates a unique transaction identifier $tid$, computes a snapshot $snapVec[tid]$ on which the transaction will execute, and returns $tid$ to the client (we explain lines 1:2-3 and similar ones later). The snapshot is computed by combining uniform transactions from $uniformVec$ (line 1:5) with the transactions from the client’s causal past originating at $d$ (line 1:6). The former is crucial to minimize the latency of strong transactions (§4), while the latter ensures read your writes.\n\nTransaction execution. The client proceeds to execute the transaction $tid$ by issuing a sequence of operations at its coordinator via $do_op$ (line 1:9). When the coordinator receives an operation $op$ on a data item $k$, it sends a $getVersion$ message with the transaction’s snapshot $snapVec[tid]$ to the local replica responsible for $k$ (line 1:11). Upon receiving the message (line 1:18), the replica first ensures that it is as up-to-date as required by the snapshot (line 1:21). It then computes the latest version of $k$ within the snapshot by applying the operations from $opLog[k]$ by all transactions with commit vectors $\\leq snapVec[tid]$. The result is sent to the coordinator in a VERSION message. After receiving it (line 1:12), the coordinator further applies the operations on $k$ previously executed by the transaction, which are stored in a buffer $wbuff[tid]$, this ensures read your writes within the transaction. If the operation is an update, the coordinator then appends it to $wbuff[tid]$. Finally, the coordinator executes the desired operation $op$ and forwards its return value to the client.\n\nCommit. A client commits a causal transaction by calling $commitCausal$ (line 1:26). This returns immediately if the transaction is read-only, since it already read a consistent snapshot (line 1:28). To commit an update transaction, UniStore uses a variant of two-phase commit protocol (recall that for simplicity we only consider whole-data center failures, not those of individual replicas, §2). The coordinator first sends a $prepare$ message to the replicas in the local data center storing the data items updated by the transaction (line 1:29). The message to each replica contains the part of the write buffer relevant to that replica. When a replica receives the message (line 1:36), it computes the transaction’s\n\nAlgorithm 1 Transaction execution at $p_d^m$.\n\n1: function $startTx(V)$\n2: for $i \\in D \\setminus \\{d\\}$ do\n3: uniformVec[i] $\\leftarrow \\max\\{V[i], uniformVec[i]\\}$\n4: var $tid$ $\\leftarrow$ generate_tid()\n5: snapVec[tid] $\\leftarrow$ uniformVec\n6: snapVec[tid][d] $\\leftarrow$ $\\max\\{V[d], uniformVec[d]\\}$\n7: $\\text{commitVec}[strong] \\leftarrow \\max\\{V[strong], stableVec[strong]\\}$\n8: return $tid$\n9: function $do_op(tid, k, op)$\n10: var $l$ $\\leftarrow$ partition($k$)\n11: send $getVersion(snapVec[tid], k)$ to $p_d^l$\n12: wait receive $version(state)$ from $p_d^l$\n13: for all $(k, op') \\in wbuff[tid][l]$ do state $\\leftarrow$ apply($op', state$)\n14: $\\text{reset[tid]} \\leftarrow \\text{set[tid]} \\cup \\{\\{k, op\\}\\}$\n15: if $op$ is an update then\n16: $\\text{wbuff[tid][l]} \\leftarrow \\text{wbuff[tid][l]} \\cdot \\{k, op\\}$\n17: return retval($op$, state)\n18: when received $getVersion(snapVec, k)$ from $p$\n19: for $i \\in D \\setminus \\{d\\}$ do\n20: uniformVec[i] $\\leftarrow \\max\\{snapVec[i], uniformVec[i]\\}$\n21: wait until $\\text{knownVec}[d] \\geq \\text{snapVec}[d] \\land \\text{knownVec[strong]} \\geq \\text{snapVec[strong]}$\n22: var $state$ $\\leftarrow$ $\\perp$\n23: for all $(op', commitVec) \\in opLog[k], commitVec \\leq \\text{snapVec do}$\n24: state $\\leftarrow$ apply($op', state$)\n25: send $version(state)$ to $p$\n26: function $commitCausal(tid)$\n27: var $L$ $\\leftarrow \\{l \\mid wbuff[tid][l] \\neq \\emptyset\\}$\n28: if $L = \\emptyset$ then return $\\text{snapVec[tid]}$\n29: send $prepare(tid, wbuff[tid][l], \\text{snapVec[tid]}$) to $p_d^l, l \\in L$\n30: var $\\text{commitVec} \\leftarrow \\text{snapVec[tid]}$\n31: for all $l \\in L$ do\n32: wait receive $prepare\\_ack(tid, ts)$ from $p_d^l$\n33: $\\text{commitVec}[d] \\leftarrow \\max\\{\\text{commitVec}[d], ts\\}$\n34: send $commit(tid, commitVec)$ to $p_d^l, l \\in L$\n35: return $\\text{commitVec}$\n36: when received $prepare(tid, wbuff, \\text{snapVec})$ from $p$\n37: for $i \\in D \\setminus \\{d\\}$ do\n38: uniformVec[i] $\\leftarrow \\max\\{\\text{snapVec[i]}, uniformVec[i]\\}$\n39: var $ts$ $\\leftarrow$ clock\n40: preparedCausal $\\leftarrow$ preparedCausal $\\cup \\{\\{tid, wbuff, ts\\}\\}$\n41: send $prepare\\_ack(tid, ts)$ to $p$\n42: when received $commit(tid, commitVec)$\n43: wait until clock $\\geq \\text{commitVec}[d]$\n44: $(tid, wbuff, \\_\\_\\_) \\leftarrow \\text{find}(\\text{tid, preparedCausal})$\n45: preparedCausal $\\leftarrow$ preparedCausal $\\setminus \\{(\\text{tid, \\_\\_\\_)}\\}$\n46: for all $(k, op) \\in wbuff$ do\n47: $\\text{opLog[k]} \\leftarrow \\text{opLog[k]} \\cdot \\{\\{op, commitVec\\}$\n48: committedCausal[d] $\\leftarrow$ committedCausal[d] $\\cup$\n49: \\{(tid, wbuff, commitVec)\\}\n50: function $uniform\\_barrier(V)$\n51: wait until $\\text{uniformVec}[d] \\geq V[d]$\n52: function $attach(V)$\n53: wait until $\\forall i \\in D \\setminus \\{d\\}, \\text{uniformVec}[i] \\geq V[i]$\nprepare time $ts$ from its local clock and adds the transaction to preparedCausal, which stores the set of causal transactions that are prepared to commit at the replica. The replica then returns $ts$ to the coordinator in a PREPARE_ACK message.\n\nWhen the coordinator receives replies from all replicas updated by the transaction, it computes the transaction’s commit vector $commitVec$: it sets the local timestamp $commitVec[d]$ to the maximum among the prepare times proposed by the replicas (line 1:33), and it copies the other entries of $commitVec$ from the snapshot vector $snapVec[tid]$ (line 1:30). The latter reflects the fact that the transactions in the snapshot become causal dependencies of $tid$.\n\nAfter computing $commitVec$, the coordinator sends it in a COMMIT message to the relevant replicas at the local data center (line 1:34) and returns it to the client (line 1:35). The client then sets its causal past $pastVec$ to the commit vector. When a replica receives the COMMIT message (line 1:42), it removes the transaction from preparedCausal, adds the transaction’s updates to $opLog$, and adds the transaction to a set $committedCausal[d]$, which stores transactions waiting to be replicated to sibling replicas at other data centers.\n\n5.3 Transaction Replication\n\nEach replica $p^m_i$ periodically replicates locally committed update transactions to sibling replicas in other data centers by executing PROPAGATE_LOCAL_TXS (line 2:1). Transactions are replicated in the order of their local timestamps. The prefix of transactions that is ready to be replicated is determined by $knownVec[d]$; according to Property 1, $p^m_i$ stores updates to $m$ by all transactions originating at $d$ with local timestamps $\\leq$ $knownVec[d]$. Thus, the replica first updates $knownVec[d]$ while preserving Property 1.\n\nThere are two cases of this update. If the replica does not have any prepared transactions ($preparedCausal = \\emptyset$), it sets $knownVec[d]$ to the current value of the clock (line 2:2). This preserves Property 1 because in this case a new transaction originating at $d$ and updating $m$ will get a prepare time at $m$ higher than the current clock (line 1:39), and thus also a higher local timestamp (line 1:33). If the replica has some prepared transactions, then they may end up getting local timestamps lower than the current clock. In this case, the replica sets $knownVec[d]$ to just below the smallest prepared time (line 2:3). This preserves Property 1 because: (i) currently prepared transactions will get a local timestamp no lower than their prepare time; and (ii) as we argued above, new transactions will get a prepare time higher than the current clock and, hence, than the smallest prepare time.\n\nAfter updating $knownVec[d]$, the replica sends a REPPLICATE message to its siblings with the transactions in committedCausal[d] such that $commitVec[d] \\leq knownVec[d]$, and then removes them from committedCausal[d]. In other words, the replica sends all transactions from the snapshot determined by $knownVec[d]$ that it has not yet replicated.\n\nWhen a replica $p^m_i$ receives a REPPLICATE message with a set of transactions $txs$ originating at a sibling replica $p^m_j$ (line 2:9), it iterates over $txs$ in $commitVec[i]$ order. For each new transaction in $txs$ with commit vector $commitVec$, the replica adds the transaction’s operations to its log and sets $knownVec[i] = commitVec[i]$. Since communication channels are FIFO, $p^m_i$ processes all transactions from $p^m_j$ in their local timestamp order. Hence, the above update to $knownVec[i]$ preserves Property 1: $p^m_i$ stores updates originating at $p^m_j$ by all transactions with $commitVec[i] \\leq knownVec[i]$. Finally, the replica adds the transactions to committedCausal[i], which is used to implement transaction forwarding (§4). Due to\nthe forwarding, $p_d^n$ may receive the same transaction from different data centers. Thus, when processing transactions in the REPLICATE message, it checks for duplicates (line 2:11).\n\n5.4 Advancing the Uniform Snapshot\n\nReplicas run a background protocol that refreshes the information about uniform transactions. This proceeds in two stages. First, a replica keeps track of which transactions have been replicated at the replicas of other partitions in the same data center. To this end, replicas in the same data center periodically exchange knownVec_LOCAL messages with their knownVec vectors, which they store in a matrix localMatrix (lines 2:24 and 2:27); in our implementation this is done via a dissemination tree. This matrix is then used to compute the vector stableVec, which represents the set of transactions that have been fully replicated at the local data center as per Property 2. To ensure this, a replica computes an entry stableVec[i] as the minimum of knownVec[i] it received from the replicas of other partitions in the same data center (line 2:29).\n\nIn the second stage of the background protocol, sibling replicas periodically exchange stableVec messages with their stableVec vectors, which they store in a matrix stableMatrix (lines 2:25 and 2:31). This matrix is then used by a replica to compute uniformVec, which characterizes the update transactions that are replicated at $f + 1$ data centers as per Property 3. To this end, a replica first enumerates all groups $G$ of $f + 1$ data centers that include its local data center (line 2:33). For each data center $j$ the replica performs the following computation. First, for each group $g \\in G$, it computes the minimum $j$-th entry in the stable vectors of all data centers $h \\in g$: \\(\\min\\{\\text{stableMatrix}[h][j] \\mid h \\in g\\}\\). By Property 2 all update transactions originating at $j$ with local timestamp $\\leq$ the minimum have been replicated at all data centers in $g$. The replica then sets uniformVec[j] to the maximum of the resulting values computed for all groups $g \\in G$, to cover transactions that are replicated at any such group. According to Property 4, the transactions with commit vectors $\\leq$ uniformVec are uniform, and now become visible to transactions coordinated by $p_d^n$ (§5.2).\n\nReplicas also update uniformVec in lines 1:2-3, 1:19-20 and 1:37-38 by incorporating snapshot[i] for remote data centers $i$. This is safe because a transaction executes on a snapshot that only includes uniform remote transactions.\n\nFinally, if a replica does not receive new transactions for a long time, it sends the value of its knownVec[d] as a heartbeat (lines 2:8 and 2:16). This allows advancing stableVec and uniformVec even under skewed load distributions.\n\n5.5 Transaction Forwarding\n\nAs we explained in §4, to guarantee that a transaction originating at a correct data center eventually becomes exposed at all correct data centers despite failures (Eventual Visibility), replicas may have to forward remote update transactions. To determine which transactions to forward, each replica keeps track of the update transactions that have been replicated at sibling replicas in other data centers. To this end, sibling replicas periodically exchange knownVec_GLOBAL messages with their knownVec vectors, which they store in a matrix globalMatrix (lines 2:26 and 2:37). Thus, $p_d^n$ has received all update transactions from $p_d^n$ with commitVec[j] $\\leq$ globalMatrix[i][j].\n\nA replica $p_d^n$ only forwards transactions when it suspects that a data center $j$ may have failed before replicating all the update transactions originating at it to a data center $i$ (this information is provided by a separate module). In this case, $p_d^n$ executes FORWARD_REMOTE_TXS(i, j) (line 2:19). The function forwards the set of transactions $txs$ received from $p_d^n$ that have not been replicated at $p_d^n$ according to globalMatrix[i][j]. For example, in Figure 1, UniSTORE will eventually invoke FORWARD_REMOTE_TXS($d_1$, $d_3$) at replicas in $d_2$ to forward $r_1$. The replica $p_d^n$ sends the transactions in $txs$ to $p_d^n$ in a REPLICATE message. If there are no update transactions to forward, $p_d^n$ sends a heartbeat to $p_d^n$ with knownVec[j].\n\nUniSTORE periodically deletes from committedCausal transactions that have been replicated at every data center (omitted from the pseudocode for brevity).\n\n5.6 On-Demand Durability and Client Migration\n\nA client may wish to ensure that the transactions it has observed so far are durable. To this end, the client can call UNIFORM_BARRIER(V) at any replica in its local data center $d$, where $V$ is the client’s causal past pastVec (line 1:49). The replica returns to the client only when all the transactions from pastVec that originate at $d$ are uniform, and thus durable. Then the same holds for all transactions from pastVec, because the protocol only exposes remote transactions to clients when they are already uniform (§5.2).\n\nA client wishing to migrate from its local data center $d$ to another data center $i$ first calls UNIFORM_BARRIER(V) at any replica in $d$ with $V$ = pastVec, to ensure that the transactions the client has observed or issued at $d$ will eventually become visible at $i$. The client then calls ATTACH(V) at any replica in $i$ (line 1:51). The replica returns when its uniformVec includes all remote transactions from $V$ (line 1:52). The client can then be sure that its transactions at $i$ will operate on snapshots including all the transactions it has observed before.\n\n6 Adding Strong Transactions\n\nWe now describe the full UniSTORE protocol with both causal and strong transactions. It is obtained by adding the highlighted lines to Algorithms 1-2 and a new Algorithm 3.\n\n6.1 Metadata\n\nThe Conflict Ordering property of our consistency model requires any two conflicting strong transactions to be related one way or another by the causal order $\\prec$ (§3). To ensure this, the protocol assigns to each strong transaction a scalar\nstrong timestamp, analogous to those used in optimistic concurrency control for serializability [69]. Several vectors used as metadata in the causal consistency protocol (§5.1) are then extended with an extra strong entry.\n\nFirst, we extend commit vectors and those representing causally consistent snapshots. Commit vectors are compared using the previous order <, but considering all entries; as before, this order is consistent with the causal order <. Furthermore, conflicting strong transactions are causally ordered according to their strong timestamps.\n\nPROPERTY 5. For any conflicting strong transactions \\( t_1 \\) and \\( t_2 \\) with commit vectors \\( \\text{commitVec}_1 \\) and \\( \\text{commitVec}_2 \\), we have: \\( t_1 \\prec t_2 \\iff \\text{commitVec}_1[\\text{strong}] < \\text{commitVec}_2[\\text{strong}] \\).\n\nA consistent snapshot vector \\( V \\) now defines the set of transactions with a commit vector \\( \\leq V \\), according to the new \\( < \\). The vectors knownVec and stableVec maintained by a replica \\( P_m \\) are also extended with a strong entry. The entries knownVec[strong] and stableVec[strong] define the prefix of strong transactions that have been replicated at \\( P_m \\) and the local data center \\( d \\), respectively:\n\nPROPERTY 6. Replica \\( P_m \\) stores the updates to \\( m \\) by all strong transactions with \\( \\text{commitVec}[\\text{strong}] \\leq \\text{knownVec}[\\text{strong}] \\).\n\nPROPERTY 7. Data center \\( d \\) stores the updates by all strong transactions with \\( \\text{commitVec}[\\text{strong}] \\leq \\text{stableVec}[\\text{strong}] \\).\n\nTo ensure Property 7, the strong entry of stableVec is updated at line 2:30 similarly to its other entries. We do not extend uniformVec, because our commit protocol for strong transactions automatically guarantees their uniformity.\n\n6.2 Transaction Execution\n\nUNISTORE uses optimistic concurrency control for strong transactions, with the same protocol for executing causal and speculatively executing strong transactions. To this end, Algorithm 1 is modified as follows. First, the computation of the snapshot vector snapVec[tid] is extended to compute the strong entry (line 1:7), which is now taken into account when checking that a replica state is up to date (line 1:21). The strong entry of the snapshot vector is computed so as to include all strong transactions known to be fully replicated in the local data center, as defined by stableVec[strong]. To ensure read your writes, the snapshot additionally includes strong transactions from the client’s causal past, as defined by \\( V[\\text{strong}] \\). Finally, the coordinator of a transaction now maintains not only its write set, but also its read set \\( \\text{rset} \\) that records all operations by the transaction, including read-only ones (line 1:14). The latter is used to certify strong transactions.\n\nAfter speculatively executing a strong transaction, the client tries to commit it by calling COMMIT_STRONG at its coordinator (line 3:1). The coordinator first waits until the snapshot on which the transaction operated becomes uniform by calling UNIFORM_BARRIER (line 3:2): as we argued in §4, this is crucial for liveness. The coordinator next submits the transaction to a certification service, which determines whether the transaction commits or aborts (line 3:3; see §6.3). In the former case, the service also determines its commit vector, which the coordinator returns to the client. If the transaction commits, the client sets its causal past pastVec to the commit vector; otherwise, it re-executes the transaction.\n\nThe certification service also notifies replicas in all data centers about updates by strong transactions affecting them via DELIVER_UPDATES upcalls, invoked in an order consistent with strong timestamps of the transactions (line 3:4). A replica receiving an upcall adds the new operations to its log and refreshes knownVec[strong] to preserve Property 6.\n\nFinally, a replica \\( P_m \\) that has not seen any strong transactions updating its partition \\( m \\) for a long time submits a dummy strong transaction that acts as a heartbeat (line 3:9). Similarly to heartbeats for causal transactions, this allows coping with skewed load distributions.\n\n6.3 Certification Service\n\nWe implement the certification service using an existing fault-tolerant protocol from [18], with transaction commit vectors computed using the techniques from [29]. The protocol integrates two-phase commit across partitions accessed by the transaction and Paxos among the replicas of each partition. It furthermore uses white-box optimizations between the two protocols to minimize the commit latency. The use of Paxos ensures that a committed strong transaction is durable and its updates will eventually be delivered at all correct data centers (line 3:4). For each partition, a single replica functions as the Paxos leader. The protocol is described and formally specified elsewhere [18], and here we discuss it only briefly. Its pseudocode and formal specification are given in §A and §C, respectively.\n\nThe certification service accepts the read and write sets of a transaction and its snapshot vector (line 3:3). Even though the service is distributed, it guarantees that commit/abort decisions are computed like in a centralized database with optimistic concurrency control – in a total certification order. To ensure Conflict Ordering, the decisions are computed using a concurrency-control policy similar to that for serializability [69]: a transaction commits if its snapshot includes all\nconflicting transactions that precede it in the certification order. The certification service also computes a commit vector for each committed transaction by copying its per-data center entries from the transaction’s snapshot vector and assigning a strong timestamp consistent with the certification order.\n\n7 Proof of Correctness\n\nWe have rigorously proved that UniStore correctly implements the specification of PoR consistency for the case when the data store manages last-writer-wins registers. The proof uses the formal framework from [13, 14, 16] and establishes Properties 1-7 stated earlier. Due to space constraints, we defer the proof to §D.\n\n8 Evaluation\n\nWe have implemented UniStore and several other protocols (listed in the following) in the same codebase, consisting of 10.3K SLOC of Erlang. We evaluate the protocols on Amazon EC2 using m4.2xlarge VMs from 5 different regions. Each VM has 8 virtual cores and 32GB of RAM. The RTT between regions ranges from 26ms to 202ms. Unless otherwise stated, our experiments deploy 3 data centers, thus tolerating a single data center failure: Virginia (US-East), California (US-West) and Frankfurt (EU-FRA). All Paxos leaders are located in Virginia. By default we use 4 replica machines per data center. Each machine stores replicas of 8 partitions, matching the number of cores. Clients are hosted on separate machines in each data center. We run each experiment for at least 5 minutes, with the first and the last minute ignored. Replicas propagate local update transactions (line 2:1) and broadcast vectors (line 2:23) every 5ms.\n\n8.1 Does UniStore combine causal and strong consistency effectively?\n\nWe start by analyzing the performance of UniStore using RUBiS—a popular benchmark that emulates an online auction website such as eBay [40, 41]. It defines 11 read-only transactions and 5 update transactions, e.g., selling items, bidding on items, and consulting outstanding auctions. As in previous work [41], to make the benchmark more challenging, we add an extra update transaction closeAuction to declare the winner of an auction. We also borrow from [41] a conflict relation between RUBiS transactions that preserves key integrity invariants in the PoR consistency model. This marks four transactions as strong (registerUser, storeBuyNow, storeBid and closeAuction) and declares three conflicts between them. For example, storeBid, which places a bid on an item, conflicts with closeAuction if both act on the same item: this is needed to preserve the invariant that the winner of an auction is the highest bidder. Our RUBiS database is configured according to the benchmark specification: it is populated with 33,000 items for sale and 1 million users; client think times are 500ms. We run the bidding mix workload of RUBiS with 15% of update transactions, which yields 10% of strong transactions.\n\nWe compare UniStore with Strong, RedBlue and Causal. Strong implements serializability [69] as a special case of UniStore where all transactions are strong and all pairs of operations conflict. RedBlue implements red-blue consistency [40], which like PoR, combines causal and strong consistency. However, it declares conflicts between all strong transactions. RedBlue certifies strong transactions at a centralized replicated service, with a replica at each data center. Causal implements causal consistency as a special case of UniStore where all transactions are causal. It cannot preserve the integrity invariants of RUBiS, but gives an upper bound on the expected performance.\n\nThroughput and average latency. Figure 3 evaluates average transaction latency and throughput. As the figure shows, UniStore exhibits a high throughput: 72% and 183% higher than RedBlue and Strong respectively at their saturation point. This is expected, as UniStore implements the consistency model that enables the most concurrency. Strong classifies all transactions as strong. This impacts performance because executing a strong transaction is significantly more expensive than executing a causal one. RedBlue uses a centralized certification service that saturates before the UniStore’s distributed service, creating a bottleneck. UniStore exhibits an average latency of 16.5ms, lower than 80.4ms of Strong. The latency of RedBlue is comparable to that of UniStore. This is because both systems mark the same set of transactions as strong. Still, RedBlue declares conflicts between all strong transaction and thus aborts more transaction than UniStore: 0.12% vs 0.027%. The clients whose transactions abort have to retry them, thus increasing latency. Since the abort rate remains low in both cases, the difference in latency is negligible in our experiment. We expect a more significant difference in workloads with higher contention. Finally, in comparison to Causal, UniStore penalizes throughput by 45%. This is the unavoidable price to pay to preserve application-specific invariants.\n\nLatency of each transaction type. In UniStore, the latency of strong transactions is dominated by the RTT between Virginia (the leader’s region) and California (Virginia’s closest data center) – 61ms. Strong transactions exhibit a latency of 73.9ms on average. The latency varies depending on the\nWe evaluate the peak throughput of UniStore with 16 partitions, the probability of two transactions accessing the same partition can certify per second. The performance strongly depends on the number of partitions. The plot also shows that UniStore is able to mix causal and strong consistency effectively, as the latency of causal transactions remains low regardless of concurrently executing strong transactions.\n\n### 8.2 How does UniStore scale with the number of machines?\n\nWe evaluate the peak throughput of UniStore as we increase the number of machines per each data center from 2 to 8, i.e., the number of partitions from 16 to 64. We use a microbenchmark with 100% of update transactions, where each transaction accesses three data items. We vary the ratio of strong transactions from 0% to 100% to understand their impact on scalability.\n\n**Scalability under low contention.** For this set of experiments, the data items accessed by each transaction are picked uniformly at random. This yields a very low contention: e.g., with 16 partitions, the probability of two transactions accessing the same partition is 0.031. As shown by the top plot of Figure 4, UniStore is able to scale almost linearly even when the workload includes strong transactions: a 9.76% throughput drop compared to the optimal scalability. This is because, with uniform accesses, the task of committing transactions is balanced among partitions. Thus, when the number of partitions increases, so does the system’s capacity. The scalability is not perfect due to the cost of the background protocol that computes stableVec, which grows logarithmically with the number of partitions. The plot also shows that strong transactions are expensive: 25.72% of throughput drop on average with 10% of strong transactions. The performance is dominated by the number of strong transactions that a partition can certify per second.\n\n**Figure 4:** Scalability when varying the ratio of strong transactions with uniform data access (top) and under contention (bottom).\n\n**Figure 5:** Throughput penalty of tracking uniformity.\n\n### Impact of contention.\n\nFor this set of experiments, we set the ratio of strong transactions that access a designated partition to 20% to create contention. As shown by the bottom plot of Figure 4, UniStore is still able to scale fairly well under contention. But, as expected, contention has an impact on scalability: a 17.15% throughput drop from the optimal scalability compared to the 9.76% throughput drop in the experiments without contention.\n\n### 8.3 What is the cost of uniformity?\n\nWe compare CureFT to Uniform. CureFT implements Cure [3], a causally consistent data store, and makes it fault tolerant by adding transaction forwarding (§4). Uniform is a simplified version of UniStore that removes all the mechanisms related to strong transactions. Uniform tracks uniformity and makes remote transactions visible only when these are uniform; CureFT does not. We use a microbenchmark with only causal transactions and 15% of update transactions. Each transaction accesses three data items.\n\n**Throughput penalty.** Figure 5 evaluates the cost of tracking uniformity. It shows the peak throughput when the number of data centers increases from 3 to 5. We first add Ireland and then Brazil. As we do this, the throughput remains almost constant. This is because each data center stores replicas of all partitions and the computational power gained when adding a data center is offset by the cost of replicating update transactions. As the figure shows, the cost of tracking uniformity is small: a 7.97% drop on average. The gap grows as we increase the number of data centers: a 10.61% drop on average with 5 data centers. This is because, to track uniform transactions, sibling replicas exchange messages: the more data centers, the more messages exchanged. The penalty can be reduced by decreasing the frequency at which sibling replicas exchange their stableVec (line 2:25), at the expense of an extra delay in the visibility of remote transactions.\n\n**Reading from a uniform snapshot.** Figure 6 evaluates the delay on the visibility of remote transactions when reading from a uniform snapshot. We deploy four data centers: Virginia, California, Frankfurt and Brazil. We set $f = 2$ to tolerate 2 data center failures (when $f = 1$, UniForm shows no delay). Under such a configuration, a data center makes a transaction visible when it knows that 3 data centers store the transaction and its dependencies (§5.4). The figure shows the cumulative distribution of the delay before updates from\nCalifornia are visible in Brazil and Virginia.\n\nThe extra delay at Brazil is only of 5ms at the 90th percentile. This is the best case scenario for Uniform because Brazil learns that Virginia stores a transaction originating at California only 2ms after receiving it. The worst case scenario for Uniform is when the origin and the destination datacenter are the closest ones. This is why the extra delay at Virginia is 92ms at the 90th percentile: Brazil learns that Frankfurt stores a transaction originating at California 88ms after receiving it. Note that when clients communicate only via the data store, the delay is unnoticeable. Even if clients communicate out of band, as the maximum extra delay is less than a 100ms, it is unlikely that a client will miss an update.\n\n9 Related Work\n\nSystems with multiple consistency levels. A number of data stores have combined weak and strong consistency, including several commercial and academic systems that combine eventual and strong consistency [5, 6, 28, 48, 57, 64, 72]. Several academic data stores combined causal and strong consistency [9, 36, 40, 41, 58, 64]. Pileus [64] funnels all updates through a single data center. In the fault-tolerant version of lazy replication [36], causal operations require synchronization between replicas on its critical path. In both cases, causal operations are not highly available, defeating the benefits of causal consistency. Walter [58] restricts causal operations to a specific type and lacks fault tolerance due to the use of two-phase commit across data centers. The remaining works [9, 40, 41] support highly available causal operations, but are not fault tolerant. First, they do not make causal operations uniform on demand to guarantee the liveness of strong operations. Thus, they suffer from the liveness issue we explained in §4 (Figure 2). In addition, these systems do not use fault-tolerant mechanisms even for strong transactions. They guard the use of strong transactions using mechanisms similar to locks; if the lock holder fails before releasing it, no other data center can execute a strong transaction requiring the same lock. This occurs even when the service handing locks is fault-tolerant, as in [41]. Finally, the above systems either do not include mechanisms for partitioning the key space among different machines in a data center or include per-data center centralized services, which limits their scalability (§8.2).\n\nSome group communication systems mix causal and atomic broadcast [10, 67]. However, these systems do not provide mechanisms for maintaining transactional data consistency.\n\nSeveral papers have proposed tools that use formal verification technology to ensure that consistency choices do not violate application invariants [9, 30, 33, 39, 50, 51]. Such tools can make it easier for programmers to use our system.\n\nCausal consistency implementations. Our subprotocol for causal consistency belongs to a family of highly scalable protocols that avoid using any centralized components or dependency check messages [3, 22, 59–61]; other alternatives are less scalable [4, 8, 12, 21, 31, 42, 43, 47, 71]. While we base our causal consistency subprotocol on an existing one, Cure [3], we have extended it in nontrivial ways, by integrating mechanisms for tracking uniformity (§5.4) and for transaction forwarding (§5.5). Some of the above protocols [31, 60] use hybrid clocks instead of real time [35] to improve performance with large clock skews; this technique can also be integrated into UniSTORE.\n\nSwiftCloud [71] implements k-stability [45], a notion similar to uniformity, to enable client migration. SwiftCloud relies on a single per-data center sequencer, which makes tracking k-stability easy, but the data store less scalable. Our protocol is more sophisticated, since we distribute the responsibility of tracking uniformity among the replicas in a data center.\n\nPaxos variants. Several Paxos variants [24, 38, 49, 52] lower the latency by allowing commutative operations to execute at replicas in arbitrary orders. In contrast to them, UniSTORE implements PoR consistency, which allows causal transactions to execute without any synchronization at all.\n\n10 Conclusion\n\nThis paper presented UniSTORE, the first fault-tolerant and scalable data store that combines causal and strong consistency. UniSTORE carefully integrates state-of-the-art scalable protocols and extends them in nontrivial ways. To maintain liveness despite data center failures, unlike previous work, UniSTORE commits a strong transaction only when all its causal dependencies are uniform. Our results show that UniSTORE combines causal and strong consistency effectively: 3.7× lower latency on average than a strongly consistent system with 1.2ms latency on average for causal transactions. We expect that the key ideas in UniSTORE will pave the way for practical systems that combine causal and strong consistency.\n\nAcknowledgements. We thank our shepherd, Heming Cui, as well as Gregory Chockler, Vítor Enes, Luís Rodrigues and Marc Shapiro for comments and suggestions. This work was partially supported by an ERC Starting Grant RACCOON, the Juan de la Cierva Formación funding scheme (FJC2018-036528-I), the CCF-Tencent Open Fund (CCF-Tencent RAGR20200124) and the AWS Cloud Credit for Research program.\nReferences\n\n\nA The Full UniSTORE Protocol for LWW Registers\n\nAlgorithms A1 – A10 given in this section define the full UniSTORE protocol, including parts omitted from the main text. This version of the protocol is specialized to the case when the data store manages last-writer-wins (LWW) registers.\n\nAlgorithm A1 shows the pseudocode of clients. We assume that each client is associated with a unique client identifier. Each client maintains the following variables:\n\n- lc: The Lamport clock at this client.\n- d: The data center to which this client is currently connected.\n- p: The coordinator partition of the current ongoing transaction.\n- tid: The identifier of the current ongoing transaction.\n- pastVec: The client’s causal past.\n\nA client interacts with UniSTORE via the following procedures:\n\n- \\( \\text{tid} \\leftarrow \\text{START}() \\): Start a transaction and obtain an identifier \\( \\text{tid} \\).\n- \\( v \\leftarrow \\text{READ}(k) \\): Invoke a read operation on key \\( k \\) in the ongoing transaction and obtain a return value \\( v \\).\n- \\( \\text{ok} \\leftarrow \\text{UPDATE}(k, v) \\): Invoke an update operation on key \\( k \\) and value \\( v \\) in the ongoing transaction.\n- \\( \\text{ok} \\leftarrow \\text{COMMIT\\_CAUSAL\\_TX}() \\): Commit a causal transaction.\n- \\( \\text{dec} \\leftarrow \\text{COMMIT\\_STRONG\\_TX}() \\): Try to commit a strong transaction and obtain a decision \\( \\text{dec} \\in \\{\\text{COMMIT}, \\text{ABORT}\\} \\).\n- \\( \\text{ok} \\leftarrow \\text{CL\\_UNIFORM\\_BARRIER}() \\): Execute a uniform barrier.\n- \\( \\text{ok} \\leftarrow \\text{CL\\_ATTACH}(j) \\): Attach to data center \\( j \\).\n\nAlgorithms A2 – A6 show the pseudocode of replicas. The code needed for strong transactions in Algorithms A2, A3, and A5 is highlighted in red. Each replica \\( p^n_d \\) maintains a set of variables as follows:\n\n- clock: The current time at \\( p^n_d \\).\n- rset: The read sets of transactions coordinated by \\( p^n_d \\), indexed by transaction identifier \\( \\text{tid} \\).\n- wbuff: The write buffers of transactions coordinated by \\( p^n_d \\), indexed by transaction identifier \\( \\text{tid} \\).\n- snapVec: The snapshot vectors of transactions coordinated by \\( p^n_d \\), indexed by transaction identifier \\( \\text{tid} \\).\n- opLog: The log of updates performed on keys managed by \\( p^n_d \\), indexed by key \\( k \\).\n- knownVec, stableVec, uniformVec: The vectors used by \\( p^n_d \\) to track what is replicated where.\n- preparedCausal: The set of causal transactions local to \\( p^n_d \\) that are prepared to commit.\n- committedCausal: For each data center \\( i \\), committedCausal[\\( i \\)] stores transactions waiting to be replicated by \\( p^n_d \\) to sibling replicas at other data centers than \\( i \\).\n\n- localMatrix: The set of knownVec received by \\( p^n_d \\) from other partitions in data center \\( d \\). It is used to compute stableVec.\n- stableMatrix: The set of stableVec received by \\( p^n_d \\) from sibling replicas. It is used to compute uniformVec.\n- globalMatrix: The set of knownVec received by \\( p^n_d \\) from sibling replicas. It is used to track what has been replicated at sibling replicas.\n\nWe specialize the UniSTORE protocol to LWW registers in several ways. First, we add code for managing Lamport clocks, highlighted in blue. In particular, each (committed) transaction is associated with a Lamport timestamp, equal to the value of \\( \\text{lc} \\) at its client when the transaction completes (lines A1:14 and A1:23). Lamport timestamps are totally ordered, with client identifiers used for tie-breaking (see also Definition 54).\n\nSecond, in Algorithm A2 we replace \\( \\text{DO\\_OP} \\) by the following two procedures:\n\n- \\( v \\leftarrow \\text{DO\\_READ}(\\text{tid}, k) \\): Execute a read operation on key \\( k \\) in a transaction with identifier \\( \\text{tid} \\) and obtain a return value \\( v \\).\n- \\( \\text{DO\\_UPDATE}(\\text{tid}, k, v) \\): Execute an update operation on key \\( k \\) and value \\( v \\) in a transaction with identifier \\( \\text{tid} \\).\n\nFinally, in Algorithm A3 we modify the handler of message \\( \\text{GET\\_VERSION} \\):\n\n- \\( \\text{GET\\_VERSION}(\\text{snapVec}, k) \\): Read the latest value from key \\( k \\) based on the snapshot vector \\( \\text{snapVec} \\). Specifically, it returns the last update to key \\( k \\) of the transaction with the latest \\( \\text{commitVec} \\) in terms of their Lamport clock order such that \\( \\text{commitVec} \\leq \\text{snapVec} \\) (line A3:5).\n\nAlgorithms A7 – A10 contain the implementation of the transaction certification service (see also §C). The certification service uses an instance of the leader election failure detector \\( \\Omega_m \\) for each partition \\( m \\). This primitive ensures that from some point on, all correct processes nominate the same correct process as the leader. For the case when the data store manages only registers, we assume that any two writes to the same object conflict. Other data types and conflict relations can be easily supported by modifying the certification check in Algorithm A8.\n\n---\n\nAlgorithm A1 Client operations at client \\( cl \\)\n\n1: function START()\n2: \\( p \\leftarrow \\) an arbitrary replica in data center \\( d \\)\n3: \\( \\text{tid} \\leftarrow \\text{remote call} \\text{START}_TX(\\text{pastVec}) \\text{ at } p \\) \\( \\triangleright \\text{ts} (\\text{START}) \\leftarrow \\text{snapVec}_p^d [\\text{tid}] \\)\n4: return \\( \\text{tid} \\)\n\n5: function READ(\\( k \\))\n6: \\( \\langle v, lc \\rangle \\leftarrow \\text{remote call} \\text{DO}_READ(\\text{tid}, k) \\text{ at } p \\)\n7: if \\( lc \\neq \\bot \\) then\n8: \\( lc \\leftarrow \\max \\{lc, lc'\\} \\)\n9: return \\( v \\)\n\n10: function UPDATE(\\( k, v \\))\n11: \\text{remote call} \\text{DO}_UPDATE(\\text{tid}, k, v) \\text{ at } p\n12: return \\( \\text{ok} \\)\n\n13: function COMMIT_CAUSAL_TX()\n14: \\( lc \\leftarrow lc + 1 \\) \\( \\triangleright lc\\text{lock}(\\text{COMMIT}_\\text{CAUSAL}_TX) \\leftarrow lc \\)\n15: \\( \\text{vc} \\leftarrow \\text{remote call} \\text{COMMIT}_\\text{CAUSAL}(\\text{tid}, lc) \\text{ at } p \\)\n16: pastVec \\( \\leftarrow \\text{vc} \\)\n17: return \\( \\text{ok} \\)\n\n18: function COMMIT_STRONG_TX()\n19: \\( lc \\leftarrow lc + 1 \\)\n20: \\( \\langle \\text{dec}, \\text{vc}, lc \\rangle \\leftarrow \\text{remote call} \\text{COMMIT}_\\text{STRONG}(\\text{tid}, lc) \\text{ at } p \\) \\( \\triangleright \\text{ts}(\\text{COMMIT}_\\text{STRONG}_TX) \\leftarrow \\text{pastVec} \\)\n21: if \\( \\text{dec} = \\text{COMMIT} \\) then\n22: pastVec \\( \\leftarrow \\text{vc} \\) \\( \\triangleright \\text{ts}(\\text{COMMIT}_\\text{STRONG}_TX) \\leftarrow \\text{pastVec} \\)\n23: \\( lc \\leftarrow lc \\) \\( \\triangleright lc\\text{lock}(\\text{COMMIT}_\\text{STRONG}_TX) \\leftarrow lc \\)\n24: return \\( \\text{dec} \\)\n\n25: function CL_UNIFORM_BARRIER()\n26: \\( \\text{var } p \\leftarrow \\) an arbitrary replica in data center \\( d \\)\n27: \\text{remote call} \\text{UNIFORM}_BARRIER(\\text{pastVec}) \\text{ at } p \\) \\( \\triangleright \\text{ts}(\\text{CL}_\\text{UNIFORM}_BARRIER) \\leftarrow \\text{pastVec} \\)\n28: \\( lc \\leftarrow lc + 1 \\) \\( \\triangleright lc\\text{lock}(\\text{CL}_\\text{UNIFORM}_BARRIER) \\leftarrow lc \\)\n29: return \\( \\text{ok} \\)\n\n30: function CL_ATTACH(\\( j \\))\n31: \\( \\text{var } p \\leftarrow \\) an arbitrary replica in data center \\( j \\)\n32: \\text{remote call} \\text{ATTACH}(\\text{pastVec}) \\text{ at } p \\) \\( \\triangleright \\text{ts}(\\text{CL}_\\text{ATTACH}) \\leftarrow \\text{pastVec} \\)\n33: \\( lc \\leftarrow lc + 1 \\) \\( \\triangleright lc\\text{lock}(\\text{CL}_\\text{ATTACH}) \\leftarrow lc \\)\n34: \\( d \\leftarrow j \\)\n35: return \\( \\text{ok} \\)\nAlgorithm A2 Transaction coordinator at \\( p_d^\\alpha \\): causal commit\n\n1: function \\( \\text{START\\_TX}(V) \\)\n2: for \\( i \\in \\mathcal{D} \\setminus \\{d\\} \\) do\n3: \\( \\text{uniformVec}[i] \\leftarrow \\max\\{V[i], \\text{uniformVec}[i]\\} \\)\n4: var \\( \\text{tid} \\leftarrow \\text{generate\\_tid()} \\)\n5: \\( \\text{snapVec}[\\text{tid}] \\leftarrow \\text{uniformVec} \\)\n6: \\( \\text{snapVec}[\\text{tid}][d] \\leftarrow \\max\\{V[d], \\text{uniformVec}[d]\\} \\)\n7: \\( \\text{snapVec}[\\text{tid}]_{[\\text{strong}]} \\leftarrow \\max\\{V[\\text{strong}], \\text{stableVec}[\\text{strong}]\\} \\)\n8: return \\( \\text{tid} \\)\n\n9: function \\( \\text{DO\\_READ}(\\text{tid}, k) \\)\n10: var \\( l \\leftarrow \\text{partition}(k) \\)\n11: if \\( \\text{wbuff}[\\text{tid}][l][k] \\neq \\perp \\) then\n12: \\( \\text{return} \\langle \\text{wbuff}[\\text{tid}][l][k], \\perp \\rangle \\)\n13: send \\( \\text{GET\\_VERSION}(\\text{snapVec}[\\text{tid}], k) \\) to \\( p_d^\\alpha \\)\n14: wait receive \\( \\text{VERSION}(v, lc) \\) from \\( p_d^\\alpha \\)\n15: \\( \\text{rset}[\\text{tid}] \\leftarrow \\text{rset}[\\text{tid}] \\cup \\{k\\} \\)\n16: return \\( \\langle v, lc \\rangle \\)\n\n17: function \\( \\text{DO\\_UPDATE}(\\text{tid}, k, v) \\)\n18: var \\( l \\leftarrow \\text{partition}(k) \\)\n19: \\( \\text{wbuff}[\\text{tid}][l][k] \\leftarrow v \\)\n20: \\( \\text{rset}[\\text{tid}] \\leftarrow \\text{rset}[\\text{tid}] \\cup \\{k\\} \\)\n\n21: function \\( \\text{COMMIT\\_CAUSAL}(\\text{tid}, lc) \\)\n22: var \\( L \\leftarrow \\{l \\mid \\text{wbuff}[\\text{tid}][l] \\neq \\emptyset \\} \\)\n23: if \\( L = \\emptyset \\) then\n24: \\( \\text{return} \\text{snapVec}[\\text{tid}] \\)\n25: send \\( \\text{PREPARE}(\\text{tid}, \\text{wbuff}[\\text{tid}][l], \\text{snapVec}[\\text{tid}]) \\) to \\( p_d^\\alpha \\), \\( l \\in L \\)\n26: \\( \\text{var commitVec} \\leftarrow \\text{snapVec}[\\text{tid}] \\)\n27: for all \\( l \\in L \\) do\n28: \\( \\text{wait receive} \\text{PREPARE\\_ACK}(\\text{tid}, ts) \\) from \\( p_d^\\alpha \\)\n29: \\( \\text{commitVec}[d] \\leftarrow \\max\\{\\text{commitVec}[d], ts\\} \\)\n30: send \\( \\text{COMMIT}(\\text{tid}, \\text{commitVec}, lc) \\) to \\( p_d^\\alpha \\), \\( l \\in L \\)\n31: return \\( \\text{commitVec} \\)\nAlgorithm A3 Transaction execution at $p_d^0$\n\n1: when received GET\\_VERSION(snapVec, k) from $p$\n2: for $i \\in D \\setminus \\{ d \\}$ do\n3: \\quad uniformVec[i] $\\leftarrow$ max\\{snapVec[i], uniformVec[i]\\}\n4: wait until knownVec[d] $\\geq$ snapVec[d] $\\land$ knownVec[strong] $\\geq$ snapVec[strong]\n5: $\\langle v, commitVec, lc \\rangle$ $\\leftarrow$ snapshot(opLog[k], snapVec) \\quad $\\triangleright$ returns the last update to key $k$ by a transaction\n6: \\quad $\\triangleright$ with the highest Lamport timestamp such that commitVec $\\leq$ snapVec\n7: send VERSION(v, lc) to $p$\n\n8: when received PREPARE(tid, wbuff, snapVec) from $p$\n9: for $i \\in D \\setminus \\{ d \\}$ do\n10: \\quad uniformVec[i] $\\leftarrow$ max\\{snapVec[i], uniformVec[i]\\}\n11: var ts $\\leftarrow$ clock\n12: preparedCausal $\\leftarrow$ preparedCausal $\\cup$ \\{\\langle tid, wbuff, ts\\rangle\\}\n13: send PREPARE\\_ACK\\langle tid, ts \\rangle to $p$\n\n14: when received COMMIT(tid, commitVec, lc)\n15: wait until clock $\\geq$ commitVec[d]\n16: $\\langle tid, wbuff, _ \\rangle$ $\\leftarrow$ find(tid, preparedCausal)\n17: preparedCausal $\\leftarrow$ preparedCausal $\\setminus$ \\{\\langle tid, _, _\\rangle\\}\n18: for all $\\langle k, v \\rangle$ $\\in$ wbuff do\n19: \\quad opLog[k] $\\leftarrow$ opLog[k] $\\cdot$ $\\langle v, commitVec, lc \\rangle$\n20: committedCausal[d] $\\leftarrow$ committedCausal[d] $\\cup$ \\{\\langle tid, wbuff, commitVec, lc\\rangle\\}\n\n21: function UNIFORM\\_BARRIER(V)\n22: \\quad wait until uniformVec[d] $\\geq$ V[d]\n\n23: function ATTACH(V)\n24: \\quad wait until $\\forall i \\in D \\setminus \\{ d \\}$. uniformVec[i] $\\geq$ V[i]\nAlgorithm A4 Transaction replication at $p^m_d$\n\n1: function PROPAGATE_LOCAL_TXS() \\textcircled{◊} Run periodically\n2: if preparedCausal = $\\emptyset$ then\n3: \\quad knownVec[$d$] $\\leftarrow$ clock\n4: else\n5: \\quad knownVec[$d$] $\\leftarrow$ min\\{ts $|$ $\\langle t, \\_ \\_ , ts \\rangle \\in$ preparedCausal\\} $-$ 1\n6: var txs $\\leftarrow$ \\{ $\\langle t, \\_ \\_ , commitVec, \\_ \\_ \\rangle \\in$ committedCausal[$d$] $|$ commitVec[$d$] $\\leq$ knownVec[$d$]\\}\n7: if txs $\\neq$ $\\emptyset$ then\n8: \\quad send REPLICATE($d$, txs) to $p^m_i$, $i \\in D \\setminus \\{d\\}$\n9: \\quad committedCausal[$d$] $\\leftarrow$ committedCausal[$d$] \\setminus txs\n10: else\n11: \\quad send HEARTBEAT($d$, knownVec[$d$]) to $p^m_i$, $i \\in D \\setminus \\{d\\}$\n\n12: when received REPLICATE($i$, txs)\n13: \\quad for all $\\langle tid, wbuff, commitVec, lc \\rangle \\in$ txs in commitVec[$i$] order do\n14: \\quad \\quad if commitVec[$i$] $>$ knownVec[$i$] then\n15: \\quad \\quad \\quad for all $\\langle k, v \\rangle \\in$ wbuff do\n16: \\quad \\quad \\quad \\quad opLog[$k$] $\\leftarrow$ opLog[$k$] $\\cdot$ $\\langle v, commitVec, lc \\rangle$\n17: \\quad \\quad \\quad committedCausal[$i$] $\\leftarrow$ committedCausal[$i$] $\\cup$ \\{ $\\langle tid, wbuff, commitVec, lc \\rangle \\}$\n18: \\quad \\quad \\quad knownVec[$i$] $\\leftarrow$ commitVec[$i$]\n\n19: when received HEARTBEAT($i$, ts)\n20: \\quad pre: ts $>$ knownVec[$i$]\n21: \\quad knownVec[$i$] $\\leftarrow$ ts\n\n22: function FORWARD_REMOTE_TXS($i$, $j$) \\textcircled{◊} forward transactions received from data center $j \\neq d$ to data center $i \\notin \\{d, j\\}$\n23: var txs $\\leftarrow$ \\{ $\\langle tid, \\_ \\_ , commitVec, \\_ \\_ \\rangle \\in$ committedCausal[$j$] $|$ commitVec[$j$] $>$ globalMatrix[$i$][$j$]\\}\n24: if txs $\\neq$ $\\emptyset$ then\n25: \\quad send REPLICATE($j$, txs) to $p^m_i$\n26: else\n27: \\quad send HEARTBEAT($j$, knownVec[$j$]) to $p^m_i$\nAlgorithm A5 Updating metadata at $p_d^m$\n\n1: function BROADCAST_VECS() \n2: send KNOWNVEC_LOCAL($m$, knownVec) to $p_d^l$, $l \\in \\mathcal{P}$ \n3: send STABLEVEC($d$, stableVec) to $p_i^m$, $i \\in \\mathcal{D}$ \n4: send KNOWNVEC_GLOBAL($d$, knownVec) to $p_i^m$, $i \\in \\mathcal{D}$ \n\n5: when received KNOWNVEC_LOCAL($l$, knownVec) \n6: localMatrix[$l$] ← knownVec \n7: for $i \\in \\mathcal{D}$ do \n8: stableVec[$i$] ← min\\{localMatrix[$n$][$i$] $|$ $n \\in \\mathcal{P}$\\} \n9: stableVec[strong] ← min\\{localMatrix[$n$][strong] $|$ $n \\in \\mathcal{P}$\\} \n\n10: when received STABLEVEC($i$, stableVec) \n11: stableMatrix[$i$] ← stableVec \n12: $G$ ← all groups with $f + 1$ replicas that include $p_d^m$ \n13: for $j \\in \\mathcal{D}$ do \n14: var $ts$ ← max\\{min\\{stableMatrix[$h$][$j$] $|$ $h \\in g$\\} $|$ $g \\in G$\\} \n15: uniformVec[$j$] ← max\\{uniformVec[$j$], $ts$\\} \n\n16: when received KNOWNVEC_GLOBAL($l$, knownVec) \n17: globalMatrix[$l$] ← knownVec\n\nAlgorithm A6 Committing strong transactions at $p_d^m$\n\n1: function COMMIT_STRONG($tid$, $lc$) \n2: UNIFORM_BARRIER(snapVec[$tid$]) \n3: $\\langle$dec, $vc$, $lc$\\rangle ← CERTIFY($tid$, wbuff[$tid$], rset[$tid$], snapVec[$tid$], $lc$) \n4: return $\\langle$dec, $vc$, $lc$\\rangle \n\n5: upon DELIVER_UPDATES(txs) \n6: for ($\\_\\_\\_\\_$, wbuff, commitVec, $lc$) $\\in$ txs in commitVec[strong] order do \n7: for $(k, v) \\in$ wbuff do \n8: opLog[$k$] ← opLog[$k$] $\\cdot$ $\\langle v, commitVec, $lc$\\rangle$ \n9: knownVec[strong] ← commitVec[strong] \n\n10: function HEARTBEAT_STRONG() \n11: return CERTIFY($\\_\\_\\_\\_$, $\\emptyset$, $\\emptyset$, $\\bar{0}$, $\\bot$)\nAlgorithm A7 Certification service at coordinator $p_d^m$\n\n1: function CERTIFY($tid, wbuff, rset, snapVec, lc$)\n2: var $L \\leftarrow \\{l \\mid wbuff[l] \\neq \\emptyset\\} \\cup \\{\\text{partition}(k) \\mid k \\in rset\\}$\n3: repeat\n4: send PREPARE_STRONG($tid, wbuff, rset, snapVec, lc$) to $\\Omega_l, l \\in L$\n5: wait receive ALREADY_DECIDED($tid, decision, commitVec, lc$)$\\lor$ receive ACCEPT_ACK($l, b_l, tid, vote_l, ts_l, lc_l$) from a quorum for all $l \\in L$\n6: until not timeout\n7: if received ALREADY_DECIDED($tid, decision, commitVec, lc$) then\n8: return $\\langle decision, commitVec, lc \\rangle$\n9: else\n10: $commitVec \\leftarrow snapVec$\n11: $commitVec[\\text{strong}] \\leftarrow \\max\\{ts_l \\mid l \\in L\\}$\n12: if $\\exists l \\in L.\\, vote_l = ABORT$ then $decision \\leftarrow ABORT$\n13: else $decision \\leftarrow COMMIT$\n14: $lc \\leftarrow \\max\\{lc_l \\mid l \\in L\\}$\n15: send DECISION($b_l, tid, decision, commitVec, lc$) to $\\Omega_l, l \\in L$\n16: return $\\langle decision, commitVec, lc \\rangle$\n\nAlgorithm A8 Strong transaction certification at $p_d^m$\n\n1: function CERTIFICATION_CHECK($W, rset, snapVec, lc$)\n2: for all $\\langle_, wbuff', rset', _, COMMIT, _, _\\rangle \\in \\text{preparedStrong}$ do\n3: if $(\\exists k, _) \\in wbuff'[m], k \\in rset) \\lor (\\exists k \\in rset'.\\, \\langle k, _\\rangle \\in W)$ then\n4: return $\\langle ABORT, \\perp \\rangle$\n5: for all $\\langle_, wbuff', COMMIT, commitVec, lc'\\rangle \\in \\text{decidedStrong}$ do\n6: if $(\\exists k, _) \\in wbuff'[m], k \\in rset) \\land \\neg(commitVec \\leq snapVec) \\text{ then}$\n7: return $\\langle ABORT, \\perp \\rangle$\n8: if $lc \\leq lc'$ then\n9: $lc \\leftarrow lc' + 1$\n10: return $\\langle COMMIT, lc \\rangle$\nAlgorithm A9 Atomic transaction commit protocol at $p^m_d$\n\n1: when received PREPARE_STRONG($tid, wbuff, rset, snapVec, lc)$ from $p$\n2: pre: status = LEADER\n3: if $\\exists (tid, _, decision, commitVec, lc) \\in$ decidedStrong then\n4: send ALREADY_DECIDED($tid, decision, commitVec, lc)$ to $p$\n5: else if $\\exists (tid, _, snapVec, vote, ts, lc) \\in$ preparedStrong then\n6: send ACCEPT($ballot, tid, wbuff, rset, snapVec, vote, ts, p, lc)$ to REPLICAS($m$)\n7: else\n8: wait until $\\forall clock > snapVec[strong]$\n9: $ts \\leftarrow clock$\n10: $\\langle vote, lc \\rangle \\leftarrow$ CERTIFICATION_CHECK($wbuff[m], rset, snapVec, lc$)\n11: send ACCEPT($ballot, tid, wbuff, rset, snapVec, vote, ts, p, lc)$ to REPLICAS($m$)\n12: when received ACCEPT($b, tid, wbuff, rset, snapVec, vote, p, ts, lc$)\n13: pre: status $\\in \\{ leader, follower \\} \\land ballot = b$\n14: preparedStrong $\\leftarrow$ preparedStrong $\\cup \\{ (tid, wbuff, rset, snapVec, vote, ts, lc) \\}$\n15: send ACCEPT_ACK($m, b, tid, vote, ts, lc)$ to $p$\n16: when received DECISION($b, tid, decision, commitVec, lc$)\n17: pre: status $= LEADER \\land ballot = b$\n18: wait until $\\exists clock > commitVec[strong]$\n19: send LEARN_DECISION($b, tid, decision, commitVec, lc$) to REPLICAS($m$)\n20: when received LEARN_DECISION($b, tid, decision, commitVec, lc$)\n21: pre: status $\\in \\{ leader, follower \\} \\land ballot = b \\land \\exists (tid, wbuff, _, _, _, _, _)$ in preparedStrong\n22: preparedStrong $\\leftarrow$ preparedStrong $\\setminus \\{ (tid, wbuff, _, _, _, _, _) \\}$\n23: decidedStrong $\\leftarrow$ decidedStrong $\\setminus \\{ (tid, wbuff, decision, commitVec, lc) \\}$\n24: upon\n25: $\\exists (_, _, COMMIT, commitVec, _) \\in$ decidedStrong.\n26: $commitVec[strong] > lastDelivered$\n27: $\\land (\\exists (_, _, _, COMMIT, ts, _) \\in$ preparedStrong $\\land$ lastDelivered $< ts \\leq commitVec[strong])$\n28: $\\land (\\exists (_, _, COMMIT, commitVec', _) \\in$ decidedStrong $\\land$ lastDelivered $< commitVec'[strong] < commitVec[strong])$\n29: pre: status = LEADER\n30: send DELIVER($ballot, commitVec[strong]$) to REPLICAS($m$)\n31: when received DELIVER($b, ts$)\n32: pre: status $\\in \\{ leader, follower \\} \\land ballot = b \\land lastDelivered < ts$\n33: lastDelivered $\\leftarrow ts$\n34: var $W \\leftarrow \\{ (tid, wbuff[m], commitVec, lc) \\mid \\exists (tid, wbuff, COMMIT, commitVec, lc) \\in$ decidedStrong.$commitVec[strong] = ts \\}$\n35: upcall DELIVER_UPDATES($W$) to $p^m_d$\nAlgorithm A10 Atomic transaction commit protocol at $p_m^n$: recovery\n\n1. upon $\\Omega_m \\not= \\text{trusted}$\n2. trusted $\\leftarrow \\Omega_m$\n3. if trusted $= p_m^n$ then RECOVER()\n4. else send NACK(ballot) to trusted\n\n5. when received NACK(b)\n6. pre: $b > \\text{ballot}$\n7. ballot $\\leftarrow b$\n8. RECOVER()\n\n9. function RECOVER()\n10. send NEW_LEADER(any ballot $b$ such that $b > \\text{ballot} \\land \\text{leader}(b) = p_m^n$) to REPLICA(m)\n\n11. when received NEW_LEADER(b) from p\n12. if trusted $= p \\land \\text{ballot} < b$ then\n13. status $\\leftarrow \\text{RECOVERING}$\n14. ballot $\\leftarrow b$\n15. send NEW_LEADER_ACK(ballot, j, ballot, decidedStrong) to p\n16. else send NACK(ballot) to p\n\n17. when received \\{NEW_LEADER_ACK(b, j, ballot, decidedStrong, decidedStrong) \\mid p_j \\in Q\\} from a quorum Q\n18. pre: status $= \\text{RECOVERING} \\land \\text{ballot} = b$\n19. var J $\\leftarrow$ the set of $j$ with maximal $\\text{ballot}_j$\n20. decidedStrong $\\leftarrow \\bigcup_{j \\in J} \\text{decidedStrong}_j$\n21. preparedStrong $\\leftarrow \\{\\langle \\text{tid}, \\ldots, \\ldots, \\ldots, \\ldots \\rangle \\in \\bigcup_{j \\in J} \\text{preparedStrong}_j \\mid \\langle \\text{tid}, \\ldots, \\ldots, \\ldots, \\ldots \\rangle \\not\\in \\text{decidedStrong}\\}$\n22. var maxPrep $\\leftarrow \\max\\{t_s \\mid \\langle \\text{..., \\ldots, ts, \\ldots} \\rangle \\in \\text{pre} \\}$\n23. var maxDec $\\leftarrow \\max\\{\\text{commitVec}[\\text{strong}] \\mid \\langle t_s, \\ldots, \\ldots, \\ldots, \\ldots \\rangle \\in \\text{decidedStrong}\\}$\n24. wait until clock $\\geq \\max\\{\\text{maxPrep, maxDec}\\}$\n25. cballot $\\leftarrow b$\n26. send NEW_STATE(ballot, preparedStrong, decidedStrong) to REPLICA(m) \\setminus \\{p_m^n\\}\n\n27. when received NEW_STATE(b, preparedStrong, decidedStrong) from p\n28. pre: status $= \\text{RECOVERING} \\land b \\geq \\text{ballot}$\n29. cballot $\\leftarrow b$\n30. preparedStrong $\\leftarrow \\text{preparedStrong}$\n31. decidedStrong $\\leftarrow \\text{decidedStrong}$\n32. status $\\leftarrow \\text{FOLLOWER}$\n33. send NEW_STATE_ACK(b) to p\n\n34. when received NEW_STATE_ACK(b) from a set of processes that together with $p_m^n$ form a quorum\n35. pre: status $= \\text{RECOVERING} \\land \\text{ballot} = b$\n36. status $\\leftarrow \\text{LEADER}$\n37. var T $\\leftarrow \\{\\text{commitVec}[\\text{strong}] \\mid \\exists\\langle \\text{..., COMMIT, commitVec, \\ldots} \\rangle \\in \\text{decidedStrong}, \\forall\\langle \\text{..., COMMIT, ts, \\ldots} \\rangle \\in \\text{preparedStrong}, t_s > \\text{commitVec}[\\text{strong}]\\}$\n38. for all $t_s \\in T$ in increasing order do\n39. send DELIVER(b, t_s) to REPLICA(m)\n\n40. function RETRY(tid)\n41. pre: $\\exists\\langle \\text{tid, wbuff, rs, snapVec, \\ldots, lc} \\rangle \\in \\text{preparedStrong}$\n42. CERTIFY($\\langle \\text{tid, wbuff, rs, snapVec, \\ldots, lc} \\rangle$)\nB Consistency Model Specification\n\nB.1 Relations\n\nFor a binary relation $\\mathcal{R} \\subseteq A \\times A$ and an element $a \\in A$, we define $\\mathcal{R}^{-1}(a) = \\{b \\mid (b, a) \\in \\mathcal{R}\\}$. For a non-empty set $A$ and a total order $\\mathcal{R} \\subseteq A \\times A$, we let $\\max_{\\mathcal{R}}(A)$ be the maximum element in $A$ according to $\\mathcal{R}$. Formally,\n\n$$\\max_{\\mathcal{R}}(A) = a \\iff A \\neq \\emptyset \\land \\forall b \\in A. a = b \\lor (b, a) \\in \\mathcal{R}.$$ \n\nIf $A$ is empty, then $\\max_{\\mathcal{R}}(A)$ is undefined. We implicitly assume that $\\max_{\\mathcal{R}}(A)$ is defined whenever it is used.\n\nWe call a binary relation a (strict) partial order if it is irreflexive and transitive. We call it a total order if it additionally relates every two distinct elements one way or another.\n\nB.2 Operations and Events\n\nTransactions in UNISTORE can start, read and write keys, and commit. We assume that each transaction is associated with a unique transaction identifier tid from a set TID (corresponding to line A2.8). Besides, clients can issue on-demand barriers and migrate between data centers.\n\nLet Key and Val be the set of keys and values, respectively. We define $O$ as the set of all possible operations\n\n$$O = \\{\\text{start}(\\text{tid}) \\mid \\text{tid} \\in \\text{TID}\\} \\cup \\{\\text{commit}_\\text{causal}(\\text{tid}) \\mid \\text{tid} \\in \\text{TID}\\} \\cup \\{\\text{commit}_\\text{strong}(\\text{tid}, \\text{dec}) \\mid \\text{tid} \\in \\text{TID}, \\text{dec} \\in \\{\\text{commit}, \\text{abort}\\}\\} \\cup \\{\\text{cl}_\\text{uniform}_\\text{barrier}\\} \\cup \\{\\text{cl}_\\text{attach}(j) \\mid j \\in \\mathcal{D}\\} \\cup \\{\\text{read}(\\text{tid}, k, v), \\text{update}(\\text{tid}, k, v) \\mid \\text{tid} \\in \\text{TID}, k \\in \\text{Key}, v \\in \\text{Val}\\}.$$ \n\nWe denote each invocation of such an operation by an event from a set $E$, usually ranged over by $e$. A function $\\text{op}: E \\rightarrow O$ determines the operation a given event denotes. Formally, we use the following notation to denote different types of events.\n\n- $E$: The set of all events.\n- $S$: The set of START events. That is,\n $$S = \\{e \\in E \\mid \\exists \\text{tid} \\in \\text{TID}. \\text{op}(e) = \\text{start}(\\text{tid})\\}.$$ \n\n- $R$: The set of read (read) events. That is,\n $$R = \\{e \\in E \\mid \\exists \\text{tid} \\in \\text{TID}, k \\in \\text{Key}, v \\in \\text{Val}. \\text{op}(e) = \\text{read}(\\text{tid}, k, v)\\}.$$ \n\n- $U$: The set of update (update) events. That is,\n $$U = \\{e \\in E \\mid \\exists \\text{tid} \\in \\text{TID}, k \\in \\text{Key}, v \\in \\text{Val}. \\text{op}(e) = \\text{update}(\\text{tid}, k, v)\\}.$$ \n\n- $C_{\\text{causal}}$: The set of commit_causal_tx events. That is,\n $$C_{\\text{causal}} = \\{e \\in E \\mid \\exists \\text{tid} \\in \\text{TID}. \\text{op}(e) = \\text{commit}_\\text{causal}(\\text{tid})\\}.$$ \n\n- $C_{\\text{strong}}$: The set of commit_strong_tx events with decision $\\text{dec} = \\text{commit}$. That is,\n $$C_{\\text{strong}} = \\{e \\in E \\mid \\exists \\text{tid} \\in \\text{TID}. \\text{op}(e) = \\text{commit}_\\text{strong}(\\text{tid}, \\text{commit})\\}.$$ \n\n- $C = C_{\\text{causal}} \\cup C_{\\text{strong}}$: The set of all commit events.\n- $Q$: The set of cl_uniform_barrier events. That is,\n $$Q = \\{e \\in E \\mid \\text{op}(e) = \\text{cl}_\\text{uniform}_\\text{barrier}\\}.$$ \n\n- $A$: The set of clAttach events. That is,\n $$A = \\{e \\in E \\mid \\exists j \\in \\mathcal{D}. \\text{op}(e) = \\text{cl}_\\text{attach}(j)\\}.$$ \n\n- $R_k$: The set of read events on key $k$. That is,\n $$R_k = \\{e \\in E \\mid \\exists \\text{tid} \\in \\text{TID}, v \\in \\text{Val}. \\text{op}(e) = \\text{read}(\\text{tid}, k, v)\\}.$$ \n\n- $U_k$: The set of update events on key $k$. That is,\n $$U_k = \\{e \\in E \\mid \\exists \\text{tid} \\in \\text{TID}, v \\in \\text{Val}. \\text{op}(e) = \\text{update}(\\text{tid}, k, v)\\}.$$ \n\nFor different types of events, we define\n\n- $\\text{key}(e)$: The key that the read or update event $e \\in R \\cup U$ accesses.\n- $\\text{rval}(e)$: The return value of the read event $e \\in R$.\n- $\\text{uval}(e)$: The value written by the update event $e \\in U$.\n\nB.3 Transactions\n\nDefinition 1 (Transactions). A transaction $t$ is a triple $(\\text{tid}, Y, po)$, where\n\n- $\\text{tid} \\in \\text{TID}$ is a unique transaction identifier;\n- $Y \\subseteq E \\setminus (Q \\cup A)$ is a finite, non-empty set of events;\n- $po \\subseteq Y \\times Y$ is the program order, which is total.\n\nWe only consider well-formed transactions: according to the program order, $t$ starts with a start event, then performs some number of read/update events, and ends with a commit event (commit_causal_tx or commit_strong_tx).\n\nIn the following, we denote components of $t$ as in $t.\\text{tid}$. For simplicity, we assume a dedicated initial transaction $t_0$ which installs initial values to all possible keys before the system launches.\n\nWe use the following notations to denote different types of transactions.\n\n- $T$: The set of all committed transactions.\n• $T_k$: The set of committed transactions that update key $k$. We also use $C_k$ to denote the set of commit events of transactions in $T_k$.\n\n• $T_{\\text{causal}}$: The set of transactions that end with the `COMMIT_CAUSAL_TX` events. We call them causal transactions. Causal transactions will always be committed.\n\n• $T_{\\text{all-strong}}$: The set of transactions that end with the `COMMIT_STRONG_TX` events. We call them strong transactions. Strong transactions can be committed or aborted.\n\n• $T_{\\text{strong}}$: The set of committed strong transactions.\n\nWe have $T = T_{\\text{causal}} \\uplus T_{\\text{strong}}$. For each transaction $t \\in T$, we define\n\n- $\\text{tid}(t) \\in \\text{TID}$: The transaction identifier $t$.tid of $t$.\n- $\\text{events}(t) \\subseteq S \\cup R \\cup U \\cup C$: The set $t$.Y of events in $t$.\n- $\\text{ws}(t) \\subseteq \\text{Key} \\times \\text{Val}$: The write set of $t$. It is the set of keys with their values that $t$ updates, which contains at most one value per key. Formally,\n\n$$\\text{ws}(t) \\triangleq \\{(k(\\text{e}), \\text{uval}(\\text{e})) | e \\in t.Y \\cap U\\}.$$\n\n- $\\text{rs}(t) \\subseteq \\text{Key}$: The read set of $t$. It is the set of keys that $t$ reads. Formally,\n\n$$\\text{rs}(t) \\triangleq \\{k(\\text{e}) | e \\in t.Y \\cap R\\}.$$\n\n- $s(t) \\in S$: The start event of $t$. Formally, it is the unique event in the set $t.Y \\cap S$.\n\n- $c(t) \\in C$: The commit event of $t$. Formally, it is the unique event in the set $t.Y \\cap C$.\n\n- $u(t, k) \\in U_t$: The last update event on key $k$, if any, in transaction $t$. Formally,\n\n$$u(t, k) \\triangleq \\max_{\\text{po}}(\\text{events}(t) \\cap U_k).$$\n\nBesides, we define\n\n$$W(t) \\triangleq \\{k \\in \\text{Key} | (k, \\_ ) \\in \\text{ws}(t)\\},$$\n\n$$R(t) \\triangleq \\text{rs}(t) \\cup W(t).$$\n\nFor a read event $e$ on key $k$ in transaction $t$, if there exist update events on $k$ preceding $e$ in $t$, then $e$ is called an internal read event. Otherwise, $e$ is called an external read event. We denote the sets of internal reads and external reads by $R_{\\text{INT}}$ and $R_{\\text{EXT}}$, respectively. That is, $R = R_{\\text{INT}} \\uplus R_{\\text{EXT}}$.\n\nWe also distinguish commit events for read-only transactions from those for update transactions, and denote their sets by $C_{\\text{RO}}$ and $C_{\\text{RW}}$, respectively. That is, $C = C_{\\text{RO}} \\uplus C_{\\text{RW}}$.\n\nFor notational convenience, for an event $e \\in E \\setminus (Q \\cup A)$, we also define $tx(e)$ to be the transaction containing $e$ and\n\n$$\\text{st}(e) \\triangleq \\text{st}(tx(e)),$$\n\n$$\\text{ct}(e) \\triangleq \\text{ct}(tx(e)).$$\n\n### B.4 Abstract Executions\n\nClients interacts with UniSTORE by issuing transactions and `CL_UNIFORM_BARRIER` and `ATTACH` events. We use histories to record such interactions in a single computation. Note that histories only record committed transactions.\n\n**Definition 2 (Histories).** A history is a tuple\n\n$$H = (X, \\text{client}, dc, so)$$\n\nsuch that\n\n- $X \\subseteq T \\cup Q \\cup A$ is a set of committed transactions and `CL_UNIFORM_BARRIER` and `ATTACH` events;\n- $\\text{client} : X \\rightarrow C$ is a function that returns\n - the client $\\text{client}(t)$ which issues the transaction $t \\in (X \\cap T)$,\n - the client $\\text{client}(q)$ which issues the `CL_UNIFORM_BARRIER` event $q \\in (X \\cap Q)$, or\n - the client $\\text{client}(a)$ which issues the `ATTACH` event $a \\in (X \\cap A)$;\n- $dc : X \\rightarrow D$ is a function that returns the original data center $dc(t)$ of transaction $t \\in (X \\cap T)$, $dc(q)$ of `CL_UNIFORM_BARRIER` event $q \\in (X \\cap Q)$, or $dc(a)$ of `ATTACH` event $a \\in (X \\cap A)$;\n- so $\\subseteq X \\times X$ is the session order on $X$. Consider $s_1, s_2 \\in X$. We say that $s_1$ precedes $s_2$ in the session order, denoted $s_1 \\rightarrow so s_2$, if they are executed by the same client and $s_1$ is executed before $s_2$.\n\nIn the following, we denote components of $H$ as in $H.X$ and often shorten $H.X$ by $X$ when it is clear. Let $V_H \\triangleq (H.X \\cap T).Y$ be the set of transactional events in history $H$.\n\nA consistency model is specified by a set of histories. To define this set, we extend histories with two relations, declaratively describing how the system processes transactions and `CL_UNIFORM_BARRIER` events.\n\n**Definition 3 (Abstract Executions).** An abstract execution is a triple\n\n$$A = ((X, \\text{client}, dc, so), \\text{vis}, \\text{ar})$$\n\nsuch that\n\n- $(X, \\text{client}, dc, so)$ is a history;\n- Visibility $\\text{vis} \\subseteq X \\times X$ is a partial order;\n- Arbitration $\\text{ar} \\subseteq X \\times X$ is a total order.\n\nFor $H = (X, \\text{client}, dc, so)$, we often shorten $(X, \\text{client}, dc, so), \\text{vis}, \\text{ar}$ by $(H, \\text{vis}, \\text{ar})$.\n\n### B.5 Partial Order-Restrictions Consistency\n\nWe aim to show that UniSTORE implements a transactional variant of Partial Order-Restrictions consistency (PoR consistency) [40,41] for LWW registers. A history $H$ of UniSTORE satisfies PoR, denoted $H \\models \\text{PoR}$, if it can be extended to an\nabstract execution that satisfies several axioms, defined in the following:\n\n\\[ H \\models \\text{PO} \\Leftrightarrow \\exists \\text{vis}, \\text{ar}. \\ (H, \\text{vis}, \\text{ar}) \\models \\]\n\\[ \\text{RVAL} \\land \\]\n\\[ \\text{CAUSAL}\\text{CONSISTENCY} \\land \\]\n\\[ \\text{CONFLICTORDERING} \\land \\]\n\\[ \\text{EVENTUALVISIBILITY}. \\]\n\nUniSTORE satisfies PO, denoted UniSTORE \\models \\text{PO}, if all its histories do.\n\nGiven an abstract execution \\( A = (H, \\text{vis}, \\text{ar}) \\), the axioms are defined as follows.\n\n**Definition 4 (RVAL, [16]).** The Return Value Consistency (RVAL) specifies the return value of each read event.\n\n\\( \\text{RVAL} \\triangleq \\text{INTRVAL} \\land \\text{EXTRVAL}. \\)\n\nHere \\text{INTRVAL} requires an internal read event \\( e \\) on key \\( k \\) to read from the last update event on \\( k \\) preceding \\( e \\) in the same transaction. Formally,\n\n\\[ \\text{INTRVAL} \\triangleq \\forall e \\in R_{\\text{INT}} \\cap R_k \\cap V_H. \\]\n\\[ \\text{rval}(e) = uval(\\max_{\\text{po}}(e \\cap U_k)). \\]\n\n\\text{EXTRVAL} requires an external read event \\( e \\) on key \\( k \\) to read from the last update event on \\( k \\) in the last transaction preceding \\( tx(e) \\) in \\( \\text{ar} \\), among the set of transactions visible to \\( tx(e) \\). Formally,\n\n\\[ \\text{EXTRVAL} \\triangleq \\forall e \\in R_{\\text{EXT}} \\cap R_k \\cap V_H. \\]\n\\[ \\text{rval}(e) = uval(\\max_{\\text{ar}}(\\text{vis}^{-1}(tx(e)) \\cap T_k), k)). \\]\n\n**Definition 5 (CAUSALCONSISTENCY, [13]).**\n\n\\( \\text{CAUSALCONSISTENCY} \\triangleq \\text{CAUSALVISIBILITY} \\land \\text{CAUSALARBITRATION}, \\)\n\nwhere\n\n\\( \\text{CAUSALVISIBILITY} \\triangleq (\\omega \\lor \\text{vis})^+ \\subseteq \\text{vis}; \\)\n\n\\( \\text{CAUSALARBITRATION} \\triangleq \\text{vis} \\subseteq \\text{ar}. \\)\n\nThe Conflict Ordering property requires that out of any two conflicting strong transactions, one must be visible to the other. Formally,\n\n**Definition 6 (Conflict Relation).** The conflict relation, denoted by \\( \\triangleright \\), between strong transactions is a symmetric relation defined as follows:\n\n\\[ \\forall t, t' \\in T_{\\text{strong}}, \\ t \\triangleright t' \\iff \\]\n\\[ (R(t) \\cap W(t') \\neq \\emptyset) \\lor (W(t) \\cap R(t') \\neq \\emptyset). \\]\n\n**Definition 7 (CONFLICTORDERING).**\n\n\\( \\text{CONFLICTORDERING} \\triangleq \\forall t_1, t_2 \\in X \\cap T_{\\text{strong}}, \\]\n\\[ t_1 \\triangleright t_2 \\Rightarrow t_1 \\xrightarrow{\\text{vis}} t_2 \\lor t_2 \\xrightarrow{\\text{vis}} t_1. \\]\n\nThe Eventual Visibility property requires that a transaction that originates at a correct data center, that is visible to some \\( \\text{CL}_\\text{UNIFORM}\\_\\text{BARRIER} \\) events, or that is a strong transaction eventually becomes visible at all correct data centers. Let \\( C \\subseteq D \\) be the set of correct data centers. Formally,\n\n**Definition 8 (EVENTUALVISIBILITY).**\n\n\\( \\text{EVENTUALVISIBILITY} \\triangleq \\forall t \\in X \\cap T. \\)\n\\[ \\text{dc}(t) \\in C \\lor (\\exists q \\in Q. \\ t \\xrightarrow{\\text{vis}} q) \\lor t \\in T_{\\text{strong}} \\]\n\\[ \\Rightarrow \\left\\{ t' \\in T \\mid \\neg(t \\xrightarrow{\\text{vis}} t') \\right\\} < \\infty. \\]\n\n**C Transaction Certification Service Specification**\n\n**C.1 Interface**\n\nThe Transaction Certification Service (TCS) [18] is responsible for certifying strong transactions issued by transaction coordinators, computing commit vectors and Lamport clocks for committed transactions, and (asynchronously) delivering committed transactions to replicas.\n\nEach strong transaction \\( t \\in T_{\\text{all\\_strong}} \\) submitted to TCS may be associated with its read set \\( rs(t) \\), write set \\( ws(t) \\), snapshot vector \\( \\text{snapshotVec}(t) \\) (Definition 10), commit vector \\( \\text{commitVec}(t) \\) (Definition 11), and Lamport clock \\( lclock(t) \\) (Definition 52). From \\( rs(t) \\) and \\( ws(t) \\) we can then define \\( W(t) \\) and \\( R(t) \\) according to (1) and (2), respectively. Note that we have \\( W(t) \\subseteq R(t) \\).\n\nTransaction coordinators for strong transactions interact with TCS using two types of actions. Coordinators can make certification requests (corresponding to procedure \\text{CERTIFY} of Algorithm A7) of the form\n\n\\[ \\text{certify}(tid(t), ws(t), R(t), \\text{snapshotVec}(t), C(t)), \\]\n\nwhere \\( t \\in T_{\\text{all\\_strong}} \\) and \\( C(t) \\in \\mathbb{N} \\) denotes the contribution of \\text{client}(t) to the Lamport clock of \\( t \\). The TCS responses are of the form\n\n\\[ \\text{decide}(tid(t), \\text{dec}, \\text{vc}, le), \\]\n\ncontaining a decision \\( \\text{dec} \\) from \\( \\mathbb{D} = \\{ \\text{COMMIT, ABORT} \\} \\) for \\( t \\), a commit vector \\( \\text{vc} \\) from \\( \\mathbb{V} \\) for \\( t \\) if \\( \\text{dec} = \\text{COMMIT} \\), and a Lamport clock \\( le \\) from \\( \\mathbb{N} \\) for \\( t \\) if \\( \\text{dec} = \\text{COMMIT} \\). If \\( \\text{dec} = \\text{ABORT} \\), then \\( \\text{vc} \\) and \\( le \\) are irrelevant.\n\nBesides, TCS can deliver some payload \\( W \\) to a replica via \\text{upcall actions} \\( \\text{deliver}(W) \\) (corresponding to procedure \\text{DELIVER\\_UPDATES} of Algorithm A6). We denote by \\( \\text{deliver}_{\\text{ou}}^a(W) \\) the delivery of the payload \\( W \\) to a replica \\( p^a \\), when the latter is relevant. The payload \\( W \\) in \\( \\text{deliver}_{\\text{ou}}(W) \\)\nis a set of tuples of the form \\((tid, wbuff, commitVec, lc)\\), each of which corresponds to the updates \\(wbuff \\subseteq Key \\times Val\\) performed at a particular partition \\(m\\) by a particular committed strong transaction with transaction identifier \\(tid\\), commit vector \\(commitVec\\), and Lamport clock \\(lc\\).\n\nC.2 Certification Functions\n\nTCS is specified using a certification function\n\n\\[\nF : 2^{T_{all-strong}} \\times T_{all-strong} \\rightarrow \\mathbb{D} \\times \\forall \\times \\mathbb{N}.\n\\]\n\nFor a strong transaction \\(t \\in T_{all-strong}\\) and the set \\(T_c \\subseteq T_{all-strong}\\) of previously committed strong transactions, \\(F(T_c, t)\\) returns not only the decision \\(dec \\in \\mathbb{D}\\), but also the commit vector \\(vc \\in \\forall\\) and Lamport clock \\(lc \\in \\mathbb{N}\\) for \\(t\\). We use \\(F_{dec}(T_c, t), F_{vc}(T_c, t),\\) and \\(F_{lc}(T_c, t)\\) to select the first, second, and third component of \\(F(T_c, t)\\), respectively.\n\nThe decision \\(F_{dec}(T_c, t)\\) should satisfy\n\n\\[\nF_{dec}(T_c, t) = \\text{COMMIT} \\iff \\forall k \\in R(t), \\forall t' \\in T_c, (k \\in W(t') \\implies \\text{commitVec}(t') \\leq \\text{snapshotVec}(t)).\n\\]\n\nThe commit vector \\(F_{vc}(T_c, t)\\) should satisfy\n\n\\[\n(\\forall t' \\in T_{all-strong}, F_{vc}(T_c, t)[i] = \\text{snapshotVec}(t)[i]) \\\\\n\\land F_{vc}(T_c, t)[\\text{strong}] > \\text{snapshotVec}(t)[\\text{strong}] \\\\\n\\land \\forall t' \\in T_c, t \\prec t' \\implies F_{vc}(T_c, t) \\geq \\text{commitVec}(t').\n\\]\n\nThe Lamport clock \\(F_{lc}(T_c, t)\\) should satisfy\n\n\\[\nF_{lc}(T_c, t) \\geq C(t) \\land \\\\\n(\\forall t' \\in T_c, t \\approx t' \\implies F_{lc}(T_c, t) > lclock(t')).\n\\]\n\nC.3 Histories of TCS\n\nTCS executions are represented by histories, which are (possibly infinite) sequences of certify, decide, and deliver actions. For a TCS history \\(h\\), we use \\(act(h)\\) to denote the set of actions in \\(h\\). For actions \\(act, act' \\in act(h)\\), we write \\(act \\prec_h act'\\) when \\(act\\) occurs before \\(act'\\) in \\(h\\). A strong transaction \\(t \\in T_{all-strong}\\) commits in a history \\(h\\) if \\(h\\) contains \\(\\text{commit}(tid(t), \\text{COMMIT}, \\_\\_\\_)\\). We denote by \\(committed(h)\\) the projection of \\(h\\) to actions corresponding to the strong transactions that are committed in \\(h\\).\n\nEach history \\(h\\) needs to meet the following requirements.\n\n(R1) For each strong transaction \\(t \\in T_{all-strong}\\), there is at most one \\(\\text{certify}(tid(t), \\_\\_\\_, \\_\\_\\_)\\) action in \\(h\\).\n\n(R2) For each action \\(\\text{decide}(tid, \\_\\_\\_, \\_\\_\\_) \\in act(h)\\), there is exactly one \\(\\text{certify}(tid, \\_\\_\\_, \\_\\_\\_)\\) action in \\(h\\) such that \\(\\text{certify}(tid, \\_\\_\\_, \\_\\_\\_) \\prec_h \\text{decide}(tid, \\_\\_\\_, \\_\\_\\_)\\).\n\n(R3) For each action \\(\\text{deliver}(W) \\in act(h)\\) and each \\((tid, \\_\\_\\_) \\in W\\), there is no \\(\\text{decide}(tid, \\text{ABORT}, \\_\\_\\_)\\) action in \\(h\\).\n\n(R4) Every committed strong transaction is delivered at most once to each replica.\n\n(R5) For each action \\(\\text{deliver}(W) \\in act(h)\\) and each \\((tid, \\_\\_\\_, \\_\\_\\_) \\in W\\), there is a \\(\\text{certify}(tid, \\_\\_\\_, \\_\\_\\_)\\) action such that \\(\\text{certify}(tid, \\_\\_\\_, \\_\\_\\_) \\prec_h \\text{deliver}(W)\\).\n\n(R6) At each replica \\(p^m\\), committed strong transactions are delivered in the increasing order of their strong timestamps. Formally, for any two distinct actions \\(\\text{deliver}^m(W_1)\\) and \\(\\text{deliver}^m(W_2)\\) with payloads \\(W_1\\) and \\(W_2\\), respectively,\n\n\\[\n\\text{deliver}^m(W_1) \\prec_h \\text{deliver}^m(W_2) \\implies \\\\\n\\forall (\\_\\_\\_, \\text{commitVec}_{1[\\_\\_\\_]}, \\_\\_\\_) \\in W_1, \\\\\n\\forall (\\_\\_\\_, \\text{commitVec}_{2[\\_\\_\\_]}, \\_\\_\\_) \\in W_2, \\\\\n\\text{commitVec}_{1[\\_\\_\\_]} > \\text{commitVec}_{2[\\_\\_\\_]}.\n\\]\n\nA history is complete if every certify action in it has a matching decide action. A complete history \\(h\\) is sequential if it consists of consecutive pairs of certify and matching decide actions. For a complete history \\(h\\), a permutation \\(h'\\) of \\(h\\) is a sequential history such that\n\n- \\(h\\) and \\(h'\\) contain the same actions, i.e., \\(act(h) = act(h')\\).\n- Transactions are certified in \\(h'\\) according to their session order.\n\n\\[\n\\forall t, t' \\in T_{all-strong}, t \\approx t' \\implies \\\\\n\\text{decide}(tid(t), \\_\\_\\_, \\_\\_\\_) \\prec_h \\text{decide}(tid(t'), \\_\\_\\_, \\_\\_\\_).\n\\]\n\nC.4 TCS Correctness: Safety and Liveness\n\nC.4.1 Safety of TCS\n\nA complete sequential history \\(h\\) is legal with respect to a certification function \\(F\\), if its results are computed so as to satisfy (4) – (6) according to \\(F\\):\n\n\\[\n\\forall \\text{act} = \\text{decide}(tid(t), dec, vc, lc) \\in act(h), \\\\\n\\text{dec}(vc, lc) = F((\\_\\_\\_, \\_\\_\\_)), \\\\\n\\text{decide}(tid(t'), \\_\\_\\_, \\_\\_\\_) \\prec_h \\text{act}(tid(t), dec, vc, lc).\n\\]\n\nA history \\(h\\) is correct with respect to \\(F\\) if \\(h\\ | \\text{committed}(h)\\) has a legal permutation. A TCS implementation is correct with respect to \\(F\\) if so are all its histories.\n\nC.4.2 Liveness of TCS\n\nTCS guarantees that every committed strong transaction will eventually be delivered by every correct data center. Formally,\n\n\\[\n\\forall m \\in \\text{partitions}(tid), \\forall c \\in C, \\\\\n\\exists act' = \\text{deliver}^m(W) \\in act(h), \\\\\n\\langle tid, \\_\\_\\_, \\_\\_\\_ \\rangle \\in W \\land \\text{act} \\prec_h act'.\n\\]\nWe take the following assumptions about $U$:\n\nA TCS implementation meets the liveness requirement if every history produced by its maximal execution satisfies (7).\n\nC.5 TCS Correctness\n\nThe proof of TCS correctness is an adjustment of the ones in [18, 29].\n\nTheorem 9. The TCS implementation in UniSTORE (Algorithms A7 – A10) is correct with respect to the certification function $F$ in (3) and meets the liveness requirement in (7).\n\nD The Proof of UniSTORE Correctness\n\nConsider an execution of UniSTORE with a history $H = (X, \\text{client}, dc, so)$. We prove that $H$ satisfies PoR by constructing an abstract execution $A$ (Theorem 84). We also establish the liveness guarantees of UniSTORE (Theorem 86).\n\nD.1 Assumptions\n\nWe take the following assumptions about UniSTORE.\n\nAssumption 1. For any replica $p^m_d$ in data center $d$, clock at $p^m_d$ is strictly increasing until $d$ (may) crash.\n\nAssumption 2. Replicas are connected by reliable FIFO channels: messages are delivered in FIFO order, and messages between correct data centers are guaranteed to be eventually delivered.\n\nAssumption 3. We assume that in an execution of UniSTORE, any clients and up to $f$ data centers may crash and that $D > 2f$.\n\nAssumption 4. We assume fairness of procedures of UniSTORE: In an execution, if a procedure is enabled infinitely often, then it will be executed infinitely often.\n\nAssumption 5. We consider only well-formed executions, in which for each client:\n\n- transactions are issued in sequence; and\n- both CL_UNIFORM_BARRIER and CL_ATTACH events can be issued only outside of transactions.\n\nAssumption 6. We consider only executions where every causal commit event (i.e., COMMIT_CAUSAL_TX) completes and every strong commit event (i.e., COMMIT_STRONG_TX) that calls the TCS completes.\n\nWe make the last assumption to simplify the technical development. The other assumptions come from the system model.\n\nD.2 Notations\n\nWe use $cl$ to range over clients from a finite set $C$. We also use the following notations to refer to different types of variables and their values (below are some typical examples).\n\n- $\\text{snapVec}^m_d$: The variable $\\text{snapVec}$ at replica $p^m_d$.\n- $(\\text{snapVec}^m_d)_c$: The value of $\\text{snapVec}^m_d$ after the event $e$ is performed at replica $p^m_d$.\n- $\\text{snapVec}^m_d(\\tau)$: The value of $\\text{snapVec}^m_d$ at some specific time $\\tau$.\n- $\\text{pastVec}_{cl}$: The variable pastVec at client $cl$.\n- $(\\text{pastVec}_{cl})_e$: The value of variable pastVec$_{cl}$ after the event $e$ is performed at client $cl$.\n- $\\text{snapVec}_{\\text{GET_VERSION},e}$: The actual value of parameter $\\text{snapVec}$ of handler GET_VERSION for event $e$.\n- $\\text{commitVec}_{\\text{COMMIT_CAUSAL},e}$: The value of the local variable $\\text{commitVec}$ in procedure COMMIT_CAUSAL after event $e$ is performed.\n\nBesides, we use $\\text{coord}(t)$ to denote the coordinator partition of transaction $t$.\n\nEach transaction is associated with a snapshot vector and a commit vector.\n\nDefinition 10 (Snapshot Vector). Let $t \\in T$ be a transaction. Let $d \\triangleq dc(t)$ and $m \\triangleq \\text{coord}(t)$. We define its snapshot vector $\\text{snapshotVec}(t)$ as\n\n$$\\text{snapshotVec}(t) \\triangleq (\\text{snapVec}^m_d)_{st(t)}[t].$$\n\nDefinition 11 (Commit Vector). Let $t \\in T$ be a transaction. Let $d \\triangleq dc(t)$ and $m \\triangleq \\text{coord}(t)$. We define its commit vector $\\text{commitVec}(t)$ as follows.\n\n- If $t$ is a read-only causal transaction, then $\\text{commitVec}(t) \\triangleq (\\text{snapVec}^m_d)_{st(t)}[t]$.\n- If $t$ is an update causal transaction, then $\\text{commitVec}(t) \\triangleq \\text{commitVec}_{\\text{COMMIT_CAUSAL},ct(t)}$.\n- If $t$ is a committed strong transaction, then $\\text{commitVec}(t) \\triangleq v_c(\\text{COMMIT_STRONG,ct(t)})$.\n\nLemma 12.\n\n$$\\forall t \\in T. \\text{commitVec}(t) \\geq \\text{snapshotVec}(t).$$\n\nProof. We perform a case analysis according to the type of $t$.\n\n- Case I: $t$ is a read-only causal transaction. By Definition 10 of $\\text{snapshotVec}(t)$, Definition 11 of $\\text{commitVec}(t)$, and Assumption 5, $\\text{commitVec}(t) = \\text{snapshotVec}(t)$.\n\n- Case II: $t$ is an update causal transaction. By lines A2:26 and A2:29, $\\text{commitVec}(t) \\geq \\text{snapshotVec}(t)$.\n• CASE III: \\(t\\) is a strong transaction. By line A6:3 and (5),\n\\[\n\\text{commitVec}(t) \\geq \\text{snapshotVec}(t).\n\\]\n\nFor client \\(cl\\), we use \\(\\text{cur_dc}(cl)\\) to denote the data center to which \\(cl\\) is currently attached. We also use \\(T|_{cl}\\) to denote the set of transactions issued by \\(cl\\). Formally,\n\\[\nT|_{cl} \\triangleq \\{ t \\in T \\mid \\text{client}(t) = cl \\}.\n\\]\n\nFor a transaction \\(t\\) and a partition \\(m\\), we use \\(\\text{ws}(t)[m]\\) to denote the subset of \\(\\text{ws}(t)\\) restricted to partition \\(m\\). Formally,\n\\[\n\\text{ws}(t)[m] \\triangleq \\{ (k,v) \\in \\text{ws}(t) \\mid \\text{partition}(k) = m \\}.\n\\]\n\nFor notational convenience, we also define\n\\[\n\\log(t) \\triangleq \\{ (k,v,\\text{commitVec}(t),\\text{lclock}(t)) \\mid (k,v) \\in \\text{ws}(t) \\},\n\\]\nand\n\\[\n\\log(t)[m] \\triangleq \\{ (k,v,\\text{commitVec}(t),\\text{lclock}(t)) \\mid (k,v) \\in \\text{ws}(t)[m] \\}.\n\\]\n\nFor a key \\(k \\in \\text{Key}\\) and a transaction \\(t \\in T_i\\), let \\((k,v,\\text{commitVec}(t),\\text{lclock}(t))\\) be the unique tuple\n\\[\n(k,v,\\text{commitVec}(t),\\text{lclock}(t))\n\\]\nin \\(\\log(t)\\).\n\nD.3 Metadata for Causal Transactions\n\nA causal transaction is \\textit{committed} when \\textit{COMMIT\\_CAUSAL} for it returns. A causal transaction is \\textit{committed at replica} \\(p_d^m\\) when \\textit{COMMIT} for it at \\(p_d^m\\) returns.\n\nD.3.1 Properties of \\textit{knownVec}\n\n\\textbf{Lemma 13.} For any replica \\(p_d^m\\) in data center \\(d\\), \\(\\text{knownVec}_d^m[d]\\) is non-decreasing.\n\n\\textbf{Proof.} Consider two points of time \\(\\tau_1\\) and \\(\\tau_2\\) such that \\(\\tau_1 < \\tau_2\\).\nWe need to show that\n\\[\n\\text{knownVec}_d^m(\\tau_1)[d] \\leq \\text{knownVec}_d^m(\\tau_2)[d].\n\\]\n\nNote that \\(\\text{knownVec}_d^m[d]\\) is updated only at lines A4:3 or A4:5. We distinguish between the following four cases.\n\n• \\textbf{CASE I:} Both \\(\\text{knownVec}_d^m(\\tau_1)[d]\\) and \\(\\text{knownVec}_d^m(\\tau_2)[d]\\) are set at line A4:3. By line A4:3 and Assumption 1,\n\\[\n\\text{knownVec}_d^m(\\tau_1)[d] = \\text{clock}_d^m(\\tau_1) \\leq \\text{clock}_d^m(\\tau_2) = \\text{knownVec}_d^m(\\tau_2)[d].\n\\]\n\n• \\textbf{CASE II:} \\(\\text{knownVec}_d^m(\\tau_1)[d]\\) is set at line A4:3 and \\(\\text{knownVec}_d^m(\\tau_2)[d]\\) is set at line A4:5. By line A4:3,\n\\[\n\\text{knownVec}_d^m(\\tau_1)[d] = \\text{clock}_d^m(\\tau_1).\n\\]\n\nBy the fact that \\(\\text{preparedCausal}_d^m(\\tau_1) = \\emptyset\\), \\(\\tau_2 > \\tau_1\\), and line A3:11,\n\\[\n\\forall t \\in \\text{preparedCausal}_d^m(\\tau_2).\n\\]\n\\[\n\\text{ts} > \\text{clock}_d^m(\\tau_1) = \\text{knownVec}_d^m(\\tau_1)[d].\n\\]\n\nTherefore, by line A4:5,\n\\[\n\\text{knownVec}_d^m(\\tau_1)[d] \\\n\\leq \\min \\{ \\text{ts} | (\\omega,\\ldots,\\text{ts}) \\in \\text{preparedCausal}_d^m(\\tau_2) \\} - 1 = \\text{knownVec}_d^m(\\tau_2)[d].\n\\]\n\n• \\textbf{CASE III:} \\(\\text{knownVec}_d^m(\\tau_1)[d]\\) is set at line A4:5 and \\(\\text{knownVec}_d^m(\\tau_2)[d]\\) is set at line A4:3. Let \\(t_i\\) be the transaction in \\(\\text{preparedCausal}_d^m(\\tau_1)\\) that has the minimum \\(\\text{ts}\\).\nFormally,\n\\[\nt_i \\triangleq \\arg\\min_t \\{ \\text{ts} | (\\omega,\\ldots,\\text{ts}) \\in \\text{preparedCausal}_d^m(\\tau_1) \\}.\n\\]\n\nBy lines A4:5, A2:29, A3:15, and A4:3,\n\\[\n\\text{knownVec}_d^m(\\tau_1)[d] < \\text{commitVec}(t_i)[d] \\leq \\text{clock}_d^m(\\tau_2) = \\text{knownVec}_d^m(\\tau_2)[d].\n\\]\n\n• \\textbf{CASE IV:} Both \\(\\text{knownVec}_d^m(\\tau_1)[d]\\) and \\(\\text{knownVec}_d^m(\\tau_2)[d]\\) are set at line A4:5. By lines A4:5 and A3:11,\n\\[\n\\text{knownVec}_d^m(\\tau_1)[d] = \\min \\{ \\text{ts} | (\\omega,\\ldots,\\text{ts}) \\in \\text{preparedCausal}_d^m(\\tau_1) \\} - 1 \\leq \\min \\{ \\text{ts} | (\\omega,\\ldots,\\text{ts}) \\in \\text{preparedCausal}_d^m(\\tau_2) \\} - 1 = \\text{knownVec}_d^m(\\tau_2)[d].\n\\]\n\n\\textbf{Lemma 14.} For \\(i \\in D \\setminus \\{d\\}\\), \\(\\text{knownVec}_d^m[i]\\) at any replica \\(p_d^m\\) in data center \\(d\\) is non-decreasing.\n\n\\textbf{Proof.} Note that \\(\\text{knownVec}_d^m[i]\\) at any replica \\(p_d^m\\) in data center \\(d\\) can be updated only at lines A4:18 and A4:21. Therefore, this lemma holds due to lines A4:14 and A4:20.\n\n\\textbf{Lemma 15.} For \\(i \\in D\\), \\(\\text{knownVec}_d^m[i]\\) at any replica \\(p_d^m\\) in data center \\(d\\) is non-decreasing.\n\n\\textbf{Proof.} By Lemmas 13 and 14.\n\n\\textbf{Lemma 16.} For any replica \\(p_d^m\\) in data center \\(d\\),\n\\[\n\\text{knownVec}_d^m[d] \\leq \\text{clock}_d^m.\n\\]\nProof. Note that knownVec\\(d\\) is updated only at lines A4:3 or A4:5.\n\n- **Case I:** knownVec\\(d\\) is updated at line A4:3. By Assumption 1,\n \\[\n \\text{knownVec}_{\\text{m}}(d) \\leq \\text{clock}_{\\text{m}}(\\tau).\n \\]\n\n- **Case II:** knownVec\\(d\\) is updated at line A4:5. By line A3:11, immediately after this update,\n \\[\n \\text{knownVec}_{\\text{m}}(d) < \\text{clock}_{\\text{m}}(\\tau).\n \\]\n\n\\(\\square\\)\n\n**Lemma 17.** Let \\(p_d\\) be a replica in data center \\(d\\). Consider knownVec\\(d\\) at time \\(\\tau\\) and transaction \\(t \\in T_{\\text{causal}}\\) committed at \\(p_d\\) after time \\(\\tau\\). Then\n\\[\n\\text{commitVec}(t)[d] \\geq \\text{knownVec}_{\\text{m}}(\\tau)[d].\n\\]\n\nProof. Suppose that before time \\(\\tau\\), knownVec\\(d\\) is last updated at time \\(\\tau' < \\tau\\). Therefore,\n\\[\n\\text{knownVec}_{\\text{m}}(\\tau)[d] = \\text{knownVec}_{\\text{m}}(\\tau')[d].\n\\]\n\nWe distinguish between two cases according to whether\n\\[\n\\text{preparedCausal}_{\\text{m}}(\\tau') = \\emptyset\n\\]\nwhen knownVec\\(d\\) is updated at time \\(\\tau'\\).\n\n- **Case I:** \\(\\text{preparedCausal}_{\\text{m}}(\\tau') = \\emptyset\\). By line A4:3,\n \\[\n \\text{knownVec}_{\\text{m}}(\\tau')[d] = \\text{clock}_{\\text{m}}(\\tau').\n \\]\n\nBy line A3:11, line A2:29, and Assumption 1,\n\\[\n\\text{commitVec}(t)[d] > \\text{clock}_{\\text{m}}(\\tau').\n\\]\n\nTherefore,\n\\[\n\\text{commitVec}(t)[d] > \\text{knownVec}_{\\text{m}}(\\tau')[d] = \\text{knownVec}_{\\text{m}}(\\tau)[d].\n\\]\n\n- **Case II:** \\(\\text{preparedCausal}_{\\text{m}}(\\tau') \\neq \\emptyset\\). We further distinguish between two cases according to whether\n \\[\n \\langle \\text{tid}(t), \\ldots \\rangle \\in \\text{preparedCausal}_{\\text{m}}(\\tau').\n \\]\n\n - **Case II-1:** \\(\\langle \\text{tid}(t), \\ldots, ts \\rangle \\in \\text{preparedCausal}_{\\text{m}}(\\tau')\\).\n By lines A4:5 and A2:29,\n \\[\n \\text{commitVec}(t)[d] > ts > \\text{knownVec}_{\\text{m}}(\\tau')[d] = \\text{knownVec}_{\\text{m}}(\\tau)[d].\n \\]\n \n - **Case II-2:** \\(\\langle \\text{tid}(t), \\ldots \\rangle \\notin \\text{preparedCausal}_{\\text{m}}(\\tau')\\).\n By Lemma 16, Assumption 1, line A3:11, and line A2:29,\n \\[\n \\text{commitVec}(t)[d] > \\text{knownVec}_{\\text{m}}(\\tau')[d] = \\text{knownVec}_{\\text{m}}(\\tau)[d].\n \\]\n\n\\(\\square\\)\n\n**Lemma 18.** Let \\(t \\in T_{\\text{causal}}\\) be a causal transaction that originates at data center \\(d\\) and accesses partition \\(m\\). If\n\\[\n\\text{commitVec}(t)[d] \\leq \\text{knownVec}_{\\text{m}}(\\tau)[d],\n\\]\nthen\n\\[\n\\text{log}(t)[m] \\subseteq \\text{opLog}\\_m.\n\\]\n\nProof. Suppose that the value knownVec\\(m\\) is set at time \\(\\tau\\).\nBy Lemma 17, \\(t\\) is committed at \\(p_d\\) before time \\(\\tau\\). Therefore, by line A3:19,\n\\[\n\\text{log}(t)[m] \\subseteq \\text{opLog}\\_m.\n\\]\n\nThe following lemmas consider the replication and forwarding of causal transactions.\n\n**Lemma 19.** Let \\(p_d\\) be a replica in data center \\(d\\). Let \\(t_1\\) and \\(t_2\\) be two transactions replicated by \\(p_d\\) to sibling replicas at time \\(\\tau_1\\) and \\(\\tau_2\\) (line A4:8), respectively. Then\n\\[\n\\tau_1 < \\tau_2 \\Rightarrow \\text{commitVec}(t_1)[d] < \\text{commitVec}(t_2)[d].\n\\]\n\nProof. Since \\(t_1\\) is replicated at time \\(\\tau_1\\), by line A4:6,\n\\[\n\\text{commitVec}(t_1)[d] \\leq \\text{knownVec}_{\\text{m}}(\\tau_1)[d].\n\\]\n\nAssume that \\(\\tau_1 < \\tau_2\\). We distinguish between two cases according to whether\n\\[\n\\langle \\text{tid}(t_1), \\ldots \\rangle \\in \\text{committedCausal}_{\\text{m}}(\\tau_1)[d].\n\\]\n\n- **Case I:** \\(\\langle \\text{tid}(t_2), \\ldots \\rangle \\in \\text{committedCausal}_{\\text{m}}(\\tau_1)[d]\\). Since \\(t_2\\) is not replicated at time \\(\\tau_1\\), by line A4:6,\n \\[\n \\text{commitVec}(t_2)[d] > \\text{knownVec}_{\\text{m}}(\\tau_1)[d].\n \\]\n\n- **Case II:** \\(\\langle \\text{tid}(t_2), \\ldots \\rangle \\notin \\text{committedCausal}_{\\text{m}}(\\tau_1)[d]\\). Thus, \\(t_2\\) is committed at \\(p_d\\) after time \\(\\tau_1\\). By Lemma 17,\n \\[\n \\text{commitVec}(t_2)[d] > \\text{knownVec}_{\\text{m}}(\\tau_1)[d].\n \\]\n\nTherefore, in either case,\n\\[\n\\text{commitVec}(t_1)[d] < \\text{commitVec}(t_2)[d].\n\\]\n\n\\(\\square\\)\n\n**Lemma 20.** Let \\(p_d\\) be a replica in data center \\(d\\). Consider a heartbeat knownVec\\(m\\) (line A4:11). Let \\(t\\) be a transaction replicated by \\(p_d\\) at time \\(\\tau_2\\) (line A4:8). Then\n\\[\n\\tau_1 < \\tau_2 \\iff \\text{knownVec}_{\\text{m}}(\\tau_1)[d] < \\text{commitVec}(t)[d].\n\\]\nProof. We first show that\n\\[ \\tau_1 < \\tau_2 \\Rightarrow \\text{knownVec}_d^m(\\tau_1)[d] < \\text{commitVec}(t)[d]. \\]\nAssume that \\( \\tau_1 < \\tau_2 \\). We distinguish between two cases according to whether\n\\[ (\\text{tid}(t),\\ldots) \\in \\text{committedCausal}_d^m(\\tau_1)[d]. \\]\n\n- **CASE I:** \\( (\\text{tid}(t),\\ldots) \\in \\text{committedCausal}_d^m(\\tau_1)[d] \\).\n By line A4:6,\n \\[ \\text{commitVec}(t)[d] > \\text{knownVec}_d^m(\\tau_1)[d]. \\]\n\n- **CASE II:** \\( (\\text{tid}(t),\\ldots) \\notin \\text{committedCausal}_d^m(\\tau_1)[d] \\).\n Thus, \\( t \\) is committed at \\( p_d^m \\) after time \\( \\tau_1 \\). By Lemma 17,\n \\[ \\text{commitVec}(t)[d] > \\text{knownVec}_d^m(\\tau_1)[d]. \\]\n\nNext we show that (note that \\( \\tau_1 \\neq \\tau_2 \\))\n\\[ \\tau_2 < \\tau_1 \\Rightarrow \\text{commitVec}(t)[d] \\leq \\text{knownVec}_d^m(\\tau_1)[d]. \\]\nSince \\( t \\) is replicated by \\( p_d^m \\) at time \\( \\tau_2 \\), by line A4:6,\n\\[ \\text{commitVec}(t)[d] \\leq \\text{knownVec}_d^m(\\tau_2)[d]. \\]\nAssume that \\( \\tau_2 < \\tau_1 \\). By Lemma 13,\n\\[ \\text{knownVec}_d^m(\\tau_2)[d] \\leq \\text{knownVec}_d^m(\\tau_1)[d]. \\]\nPutting it together yields\n\\[ \\text{commitVec}(t)[d] \\leq \\text{knownVec}_d^m(\\tau_1)[d]. \\]\n\n\\[ \\Box \\]\n\n**Lemma 21.** Let \\( p_d^m \\) be a replica in data center \\( d \\). Then\n\\[ \\forall i \\neq d. \\forall (\\text{tid}(t),\\ldots) \\in \\text{committedCausal}_d^m[i], \\text{commitVec}(t)[i] \\leq \\text{knownVec}_d^m[i]. \\]\n\n\n**Lemma 22.** For \\( j \\neq d \\) and \\( i \\notin \\{d,j\\} \\), \\( \\text{globalMatrix}_d^m[i][j] \\) at any replica \\( p_d^m \\) in data center \\( d \\) is non-decreasing.\n\n*Proof.* Note that \\( \\text{globalMatrix}_d^m[i][j] \\) can be updated only at line A5:17. Therefore, by Lemma 14, it is non-decreasing.\n\n**Lemma 23.** Let \\( p_d^m \\) be a replica in data center \\( d \\). Let \\( t_1 \\) and \\( t_2 \\) be two transactions that originate at data center \\( j \\neq d \\) and are forwarded by \\( p_d^m \\) to sibling replica \\( p_d^m \\) in data center \\( i \\notin \\{d,j\\} \\) at time \\( \\tau_1 \\) and \\( \\tau_2 \\) (line A4:25), respectively. Then\n\\[ \\tau_1 < \\tau_2 \\Rightarrow \\text{commitVec}(t_1)[j] < \\text{commitVec}(t_2)[j]. \\]\n\n**Proof.** Since \\( t_1 \\) is forwarded by \\( p_d^m \\) at time \\( \\tau_1 \\), by line A4:23,\n\\[ (\\text{tid}(t_1),\\ldots) \\in \\text{committedCausal}_d^m(\\tau_1)[j]. \\]\nBy Lemmas 21 and 14,\n\\[ \\text{commitVec}(t_1)[j] \\leq \\text{knownVec}_d^m(\\tau_1)[j]. \\]\nAssume that \\( \\tau_1 < \\tau_2 \\). We first argue that\n\\[ (\\text{tid}(t_2),\\ldots) \\notin \\text{committedCausal}_d^m(\\tau_1)[j]. \\]\nOtherwise, by line A4:23,\n\\[ \\text{commitVec}(t_2)[j] \\leq \\text{globalMatrix}_d^m(\\tau_1)[i][j]. \\]\n\n**Proof.** By Lemma 22,\n\\[ \\text{commitVec}(t_2)[j] \\leq \\text{globalMatrix}_d^m(\\tau_2)[i][j]. \\]\nTherefore, by line A4:23, \\( t_2 \\) would not be forwarded by \\( p_d^m \\) to \\( p_d^m \\) at time \\( \\tau_2 \\). Thus, (9) holds. Since \\( t_2 \\) is forwarded by \\( p_d^m \\) to \\( p_d^m \\) at time \\( \\tau_2 \\),\n\\[ (\\text{tid}(t_2),\\ldots) \\in \\text{committedCausal}_d^m(\\tau_2)[j]. \\]\nBy Lemma 14 and line A4:14,\n\\[ \\text{commitVec}(t_2)[j] > \\text{knownVec}_d^m(\\tau_1)[j]. \\]\nPutting (8) and (10) together yields\n\\[ \\text{commitVec}(t_1)[j] < \\text{commitVec}(t_2)[j]. \\]\n\n\\[ \\Box \\]\n\n**Lemma 24.** Let \\( p_d^m \\) be a replica in data center \\( d \\). Consider a heartbeat \\( \\text{knownVec}_d^m(\\tau_1)[j] \\) \\((j \\neq d)\\) sent by \\( p_d^m \\) to sibling replica \\( p_d^m \\) in data center \\( i \\notin \\{d,j\\} \\) at time \\( \\tau_1 \\) (line A4:27). Let \\( t \\) be a transaction that originates at data center \\( j \\) and is forwarded by \\( p_d^m \\) to \\( p_d^m \\) at time \\( \\tau_2 \\) (line A4:25). Then\n\\[ \\tau_1 < \\tau_2 \\Rightarrow \\text{knownVec}_d^m(\\tau_1)[j] < \\text{commitVec}(t)[j]. \\]\n\n*Proof.* We first show that\n\\[ \\tau_1 < \\tau_2 \\Rightarrow \\text{knownVec}_d^m(\\tau_1)[j] < \\text{commitVec}(t)[j]. \\]\nAssume that \\( \\tau_1 < \\tau_2 \\). We first argue that\n\\[ (\\text{tid}(t),\\ldots) \\notin \\text{committedCausal}_d^m(\\tau_1)[j]. \\]\nOtherwise, since \\( t \\) is not forwarded at time \\( \\tau_1 \\), by line A4:23,\n\\[ \\text{commitVec}(t)[j] \\leq \\text{globalMatrix}_d^m(\\tau_1)[i][j]. \\]\nBy Lemma 22,\n\\[ \\text{commitVec}(t)[j] \\leq \\text{globalMatrix}_d^m(\\tau_2)[i][j]. \\]\nTherefore, by line A4:23, \\( t \\) would not be forwarded by \\( p_d^n \\) to \\( p_i^n \\) at time \\( \\tau_2 \\). Thus, (11) holds. Since \\( t \\) is forwarded by \\( p_d^n \\) to \\( p_i^n \\) at time \\( \\tau_2 \\),\n\n\\[\n\\langle tid(t), ..., \\rangle \\in committedCausal_d^n(\\tau_2)[j].\n\\]\n\nBy Lemma 14 and line A4:14,\n\n\\[\nknownVec_d^n(\\tau_1)[j] \\prec commitVec(t)[j].\n\\]\n\nNext we show that (note that \\( \\tau_1 \\neq \\tau_2 \\))\n\n\\[\n\\tau_2 < \\tau_1 \\Rightarrow commitVec(t)[j] \\leq knownVec_d^n(\\tau_1)[j].\n\\]\n\nSince \\( t \\) is forwarded by \\( p_d^n \\) to \\( p_i^n \\) at time \\( \\tau_2 \\), by line A4:23,\n\n\\[\n\\langle tid(t), ..., \\rangle \\in committedCausal_d^n(\\tau_2)[j].\n\\]\n\nBy Lemmas 21 and 14,\n\n\\[\ncommitVec(t)[j] \\leq knownVec_d^n(\\tau_2)[j].\n\\]\n\nAssume that \\( \\tau_2 < \\tau_1 \\). By Lemma 14,\n\n\\[\nknownVec_d^n(\\tau_2)[j] \\leq knownVec_d^n(\\tau_1)[j].\n\\]\n\nPutting it together yields\n\n\\[\ncommitVec(t)[j] \\leq knownVec_d^n(\\tau_1)[j].\n\\]\n\n\\[ \\Box \\]\n\nLemma 25. Let \\( t \\in T_{\\text{causal}} \\) be a causal transaction that originates at data center \\( i \\) and accesses partition \\( m \\). If\n\n\\[\ncommitVec(t)[i] \\leq knownVec_d^n[i]\n\\]\n\nfor replica \\( p_d^n \\) in data center \\( d \\neq i \\), then\n\n\\[\n\\log(t)[m] \\leq opLog_d^n.\n\\]\n\nProof. Note that for \\( i \\in D \\setminus \\{ i \\} \\), \\( knownVec_d^n[i] \\) can be updated only at lines A4:18 or A4:21 due to replication of transactions or heartbeats respectively, either directly from data center \\( i \\) (line A4:1) or indirectly from a third data center \\( j \\neq i \\) (line A4:22).\n\nWe proceed by induction on the length of the execution. In the following, for replica \\( p_d^n \\) in data center \\( d \\in D \\), we denote the value of \\( knownVec_d^n \\) (resp. \\( opLog_d^n \\)) after \\( k \\) steps in an execution by \\( knownVec_d^n(k) \\) (resp. \\( opLog_d^n(k) \\)).\n\n- **Base Case.** \\( k = 0 \\). It holds trivially, since for replica \\( p_d^n \\) in any data center \\( d \\neq i \\),\n\n\\[\nknownVec_d^n(0)[i] = 0.\n\\]\n\n- **Induction Hypothesis.** Suppose that for any execution of length \\( k \\), we have\n\n\\[\n\\forall d \\in D \\setminus \\{ i \\}. \\forall t \\in T_{\\text{causal}},\n\\]\n\n\\[\n(commitVec(t)[i] \\leq knownVec_d^n(k)[i]\n\\]\n\n\\[\n\\Rightarrow \\log(t)[m] \\leq opLog_d^n(k).\n\\]\n\n\\[ \\Box \\]\n\n**D.3.2 Properties of stableVec**\n\nLemma 27. For \\( i \\in D \\), \\( stableVec_d^n[i] \\) at any replica \\( p_d^n \\) in data center \\( d \\) is non-decreasing.\nProof. Note that stableVec\\(m\\)[i] \\((i \\in D)\\) can be updated only at line A5:8. By Lemma 15 and Assumption 2, stableVec\\(m\\)[i] is non-decreasing.\n\nLemma 28 (PROPERTY 2). For any replica \\(p^m\\) in data center \\(d\\),\n\\[\n\\forall i \\in D. \\forall n \\in \\mathcal{P}. \\text{stableVec}_m^n[i] \\leq \\text{knownVec}_m^n[i].\n\\]\n\nProof. Note that stableVec\\(m\\)[i] \\((i \\in D)\\) can be updated only at line A5:8. By the way stableVec\\(m\\)[i] is updated and Lemmas 13 and 14,\n\\[\n\\forall n \\in \\mathcal{P}. \\text{stableVec}_m^n[i] \\leq \\text{knownVec}_m^n[i].\n\\]\n\nLemma 29. Let \\(t \\in T_{causal}\\) be a causal transaction that originates at data center \\(i\\) and accesses partition \\(n\\). If\n\\[\n\\text{commitVec}(t)[i] \\leq \\text{stableVec}_m^n[i]\n\\]\nfor some replica \\(p^m\\) in data center \\(d\\), then\n\\[\n\\log(t)[n] \\subseteq \\text{opLog}_d^n.\n\\]\n\nProof. By Lemma 28,\n\\[\n\\text{stableVec}_m^n[i] \\leq \\text{knownVec}_m^n[i].\n\\]\nTherefore,\n\\[\n\\text{commitVec}(t)[i] \\leq \\text{knownVec}_m^n[i].\n\\]\nBy Lemma 25,\n\\[\n\\log(t)[n] \\subseteq \\text{opLog}_d^n.\n\\]\n\nD.3.3 Properties of uniformVec\n\nLemma 30. For \\(i \\in D\\), uniformVec\\(m\\)[i] at any replica \\(p^m\\) in data center \\(d\\) is non-decreasing.\n\nProof. Note that whenever uniformVec\\(m\\)[i] is updated at lines A2:3, A3:3, A3:10, or A5:15, we take the maximum of it and some scalar value.\n\nLemma 31. Let \\(e \\in E\\) be an event issued by client \\(cl\\) to replica \\(p^m\\) in data center \\(d\\). Then\n\\[\n\\begin{align*}\ne & \\in E \\setminus Q \\Rightarrow \\\\\n& \\forall i \\in D \\setminus \\{d\\}. (\\text{pastVec}_cl)_{e}[i] \\leq (\\text{uniformVec}_m^n)_{e}[i], \\\\\n\\end{align*}\n\\]\nand\n\\[\n\\begin{align*}e & \\in Q \\Rightarrow (\\text{pastVec}_cl)_{e}[d] \\leq (\\text{uniformVec}_m^n)_{e}[d].\n\\end{align*}\n\\]\n\nProof. We perform a case analysis according to the type of event \\(e\\).\n\n- CASE I: \\(e \\in S\\). By line A2:3,\n\\[\n\\forall i \\in D \\setminus \\{d\\}. (\\text{pastVec}_cl)_{e}[i] \\leq (\\text{uniformVec}_m^n)_{e}[i].\n\\]\n\n- CASE II: \\(e \\in R \\cup U\\). In this case,\n\\[\n(\\text{pastVec}_cl)_{e} = (\\text{pastVec}_cl)_{st(e)}.\n\\]\nBy CASE I,\n\\[\n\\forall i \\in D \\setminus \\{d\\}. (\\text{pastVec}_cl)_{st(e)}[i] \\leq (\\text{uniformVec}_m^n)_{st(e)}[i].\n\\]\nBy Lemma 30,\n\\[\n\\forall i \\in D \\setminus \\{d\\}. (\\text{uniformVec}_m^n)_{st(e)}[i] \\leq (\\text{uniformVec}_m^n)_{e}[i].\n\\]\nPutting it together yields\n\\[\n\\forall i \\in D \\setminus \\{d\\}. (\\text{pastVec}_cl)_{e}[i] \\leq (\\text{uniformVec}_m^n)_{e}[i].\n\\]\n\n- CASE III: \\(e \\in C_{causal}\\). By line A1:16,\n\\[\n(\\text{pastVec}_cl)_{e} = \\text{vc}(\\text{commit}\\_\\text{causal}\\_\\text{tx}, e).\n\\]\nBy lines A2:24, A2:26, and A2:31,\n\\[\n\\forall i \\in D \\setminus \\{d\\}. \\text{vc}(\\text{commit}\\_\\text{causal}\\_\\text{tx}, e)[i] = (\\text{snapVec}_m^n)_{e}[\\text{tx}(e)][i].\n\\]\nBy line A2:5,\n\\[\n\\forall i \\in D \\setminus \\{d\\}. (\\text{snapVec}_m^n)_{e}[\\text{tx}(e)][i] = (\\text{uniformVec}_m^n)_{st(e)}[i].\n\\]\nBy Lemma 30,\n\\[\n\\forall i \\in D \\setminus \\{d\\}. (\\text{uniformVec}_m^n)_{st(e)}[i] \\leq (\\text{uniformVec}_m^n)_{e}[i].\n\\]\nPutting it together yields\n\\[\n\\forall i \\in D \\setminus \\{d\\}. (\\text{pastVec}_cl)_{e}[i] \\leq (\\text{uniformVec}_m^n)_{e}[i].\n\\]\n\n- CASE IV: \\(e \\in C_{strong}\\). By line A1:22,\n\\[\n(\\text{pastVec}_cl)_{e} = \\text{vc}(\\text{commit}\\_\\text{strong}\\_\\text{tx}, e).\n\\]\nBy (5),\n\\[\n\\forall i \\in D \\setminus \\{d\\}. \\text{vc}(\\text{commit}\\_\\text{strong}\\_\\text{tx}, e)[i] = (\\text{snapVec}_m^n)_{e}[\\text{tx}(e)][i].\n\\]\nTherefore, similar to CASE III, we have\n\\[\n\\forall i \\in D \\setminus \\{d\\}. (\\text{pastVec}_cl)_{e}[i] \\leq (\\text{uniformVec}_m^n)_{e}[i].\n\\]\n\n- CASE V: \\(e \\in Q\\). By line A3:22,\n\\[\n(\\text{pastVec}_cl)_{e}[d] \\leq (\\text{uniformVec}_m^n)_{e}[d].\n\\]\n• **Case VI:** \\(e \\in A\\). By line A3:24,\n\\[\n\\forall i \\in D \\setminus \\{d\\}, (\\text{pastVec}_{cl})_e[i] \\leq (\\text{uniformVec}^m_e)_e[i].\n\\]\n\n\\(\\square\\)\n\n**Lemma 32.** Let \\(cl\\) be a client and \\(d \\triangleq \\text{cur}_dc(cl)\\). At any time,\n\\[\n\\forall i \\in D \\setminus \\{d\\}, \\text{pastVec}_{cl}[i] \\leq \\text{uniformVec}^m_{cl}[i]\n\\]\nfor some replica \\(p^m_{cl}\\) in data center \\(d\\).\n\n**Proof.** By a simple induction on the number of events that \\(cl\\) issues and Lemmas 31 and 30.\n\n\\(\\square\\)\n\n**Lemma 33.** Let \\(t\\) be a transaction that originates at data center \\(d\\). At any time,\n\\[\n\\forall i \\in D \\setminus \\{d\\}, \\text{snapshotVec}(t)[i] \\leq \\text{uniformVec}^m_{cl}[i]\n\\]\nfor some replica \\(p^m_{cl}\\) in data center \\(d\\).\n\n**Proof.** By line A2:5 and Lemma 30.\n\n\\(\\square\\)\n\n**Lemma 34 (Property 3).** For any replica \\(p^m_{cl}\\) in data center \\(d\\),\n\\[\n\\forall i \\in D, \\exists g \\subseteq D, \\left( |g| \\geq f + 1 \\wedge d \\in g \\wedge \\left( \\forall j \\in g, \\forall n \\in P, \\text{uniformVec}^m_{cl}[i] \\leq \\text{knownVec}^j_{cl}(i) \\right) \\right).\n\\]\n\n**Proof.** Fix \\(i \\in D\\). We proceed by induction on the length of the execution. In the following, we denote the value of \\(\\text{knownVec}^j_{cl}, \\text{stableVec}^j_{cl}, \\text{uniformVec}^j_{cl}, \\text{stableMatrix}^j_{cl}\\), and \\(\\text{pastVec}_{cl}\\) (for some client \\(cl\\)) after \\(k\\) steps of an execution by \\(\\text{knownVec}^j_{cl}(k), \\text{stableVec}^j_{cl}(k), \\text{uniformVec}^j_{cl}(k), \\text{stableMatrix}^j_{cl}(k), \\) and \\(\\text{pastVec}_{cl}(k)\\), respectively.\n\n**Base Case.** \\(k = 0\\). It holds trivially since \\(\\text{uniformVec}^j_{cl}(0)[i] = 0\\).\n\n**Induction Hypothesis.** Suppose that for any execution of length \\(k\\), for any replica \\(p^m_{cl}\\) in data center \\(d\\),\n\\[\n\\exists g \\subseteq D, |g| \\geq f + 1 \\wedge d \\in g \\wedge \\left( \\forall j \\in g, \\forall n \\in P, \\text{uniformVec}^m_{cl}[i] \\leq \\text{knownVec}^j_{cl}(k)[i] \\right).\n\\]\n\n**Induction Step.** Consider an execution of length \\(k + 1\\). If the \\((k + 1)\\)st step of this execution does not update \\(\\text{uniformVec}^m_{cl}[(k + 1)][i]\\) for any replica \\(p^m_{cl}\\) in data center \\(d\\), then by the induction hypothesis and Lemma 15,\n\\[\n\\exists g \\subseteq D, |g| \\geq f + 1 \\wedge d \\in g \\wedge \\left( \\forall j \\in g, \\forall n \\in P, \\text{uniformVec}^m_{cl}[(k + 1)][i] \\leq \\text{knownVec}^j_{cl}(k + 1)[i] \\right).\n\\]\n\nOtherwise, we perform a case analysis according to how \\(\\text{uniformVec}^m_{cl}[(k + 1)][i]\\) is updated.\n\n- **Case I:** \\(\\text{uniformVec}^m_{cl}[(k + 1)][i]\\) is updated at line A5:15.\nBy line A5:12,\n\\[\n\\exists g' \\subseteq D, |g'| \\geq f + 1 \\wedge d \\in g' \\wedge (12)\n\\]\n\\[\n\\text{uniformVec}^m_{cl}(k + 1)[i] = \\max \\{ \\text{uniformVec}^m_{cl}(k)[i], \\text{min stableMatrix}^j_{cl}(k + 1)[j][i] \\}. \\]\n\nBy the induction hypothesis and Lemma 14,\n\\[\n\\exists g'' \\subseteq D, |g''| \\geq f + 1 \\wedge d \\in g'' \\wedge (13)\n\\]\n\\[\n(\\forall j \\in g'', \\forall n \\in P, \\text{uniformVec}^m_{cl}(k)[i] \\leq \\text{knownVec}^j_{cl}(k + 1)[i]). \\]\n\nBy Lemma 27, for the particular \\(g' \\subseteq D\\) in (12),\n\\[\n\\forall j \\in g', \\text{stableMatrix}^j_{cl}(k + 1)[j][i] \\leq \\text{stableVec}^j_{cl}(k + 1)[i]. \\]\n\nBy Lemmas 28 and 14, for any replica \\(p^m_{cl}\\) in data center \\(j\\),\n\\[\n\\forall n \\in P, \\text{stableVec}^n_{cl}(k + 1)[i] \\leq \\text{knownVec}^j_{cl}(k + 1)[i]. \\]\n\nTherefore, for the particular \\(g' \\subseteq D\\) in (12),\n\\[\n\\forall j' \\in g', \\forall n \\in P, \\text{min stableMatrix}^j_{cl}(k + 1)[j'][i] \\leq \\text{knownVec}^j_{cl}(k + 1)[i]. \\]\n\nBy (12), (13), and (16), we can either take \\(g' = g'\\) in (12) or \\(g' = g''\\) in (13) such that\n\\[\n\\forall j \\in g, \\forall n \\in P, \\text{uniformVec}^m_{cl}(k + 1)[i] \\leq \\text{knownVec}^j_{cl}(k + 1)[i]. \\]\n\nTherefore,\n\\[\n\\exists g \\subseteq D, |g| \\geq f + 1 \\wedge d \\in g \\wedge \\left( \\forall j \\in g, \\forall n \\in P, \\text{uniformVec}^m_{cl}(k + 1)[i] \\leq \\text{knownVec}^j_{cl}(k + 1)[i] \\right).\n\\]\n\n- **Case II:** \\(\\text{uniformVec}^m_{cl}[(k + 1)][i] \\in (D \\setminus \\{d\\})\\) is updated at line A2:3. Then there exists some client \\(cl\\) with \\(d = \\text{cur}_dc(cl)\\) such that\n\\[\n\\text{uniformVec}^m_{cl}(k + 1)[i] = \\max \\{ \\text{pastVec}_{cl}(k)[i], \\text{uniformVec}^m_{cl}(k)[i] \\}. \\]\n\nBy the induction hypothesis and Lemma 14,\n\\[\n\\exists g' \\subseteq D, |g'| \\geq f + 1 \\wedge d \\in g' \\wedge (18)\n\\]\n\\[\n(\\forall j \\in g', \\forall n \\in P, \\text{uniformVec}^m_{cl}(k)[i] \\leq \\text{knownVec}^j_{cl}(k + 1)[i]). \\]\nTherefore, the lemma holds due to Lemmas 12 and 38.\n\nProof. By Definition 10 of commitVec and Lemmas 37 and 38.\n\nLemma 36. Let \\( t \\in T_{\\text{causal}} \\) be a causal transaction that originates at data center \\( d \\) and accesses partition \\( n \\). If\n\\[\n\\text{commitVec}(t)[i] \\leq \\text{uniformVec}_d^m[i]\n\\]\nfor some replica \\( p^m_d \\) in data center \\( d \\), then\n\\[\n\\log(t)[n] \\leq \\text{opLog}_d^m.\n\\]\n\nProof. By Lemma 35,\n\\[\n\\text{uniformVec}_d^m[i] \\leq \\text{knownVec}_d^m[i].\n\\]\n\nTherefore,\n\\[\n\\text{commitVec}(t)[i] \\leq \\text{knownVec}_d^m[i].\n\\]\n\nBy Lemma 25,\n\\[\n\\log(t)[n] \\leq \\text{opLog}_d^m.\n\\]\n\nLemma 37. For any replica \\( p^m_d \\) in data center \\( d \\),\n\\[\n\\text{uniformVec}_d^m[d] \\leq \\text{clock}_d^m.\n\\]\n\nProof. By Lemma 35,\n\\[\n\\text{uniformVec}_d^m[d] \\leq \\text{knownVec}_d^m[d].\n\\]\n\nBy Lemma 16,\n\\[\n\\text{knownVec}_d^m[d] \\leq \\text{clock}_d^m.\n\\]\n\nPutting it together yields\n\\[\n\\text{uniformVec}_d^m[d] \\leq \\text{clock}_d^m.\n\\]\n\nD.3.4 Properties of \\( \\text{pastVec} \\)\n\nLemma 38. Let \\( e \\in S \\) be a START event of transaction \\( t \\) issued by client \\( cl \\). Then\n\\[\n(pastVec_{cl})_e \\leq \\text{snapshotVec}(t).\n\\]\n\nProof. By Definition 10 of \\( \\text{snapshotVec}(t) \\) and lines A2:2–A2:7.\n\nLemma 39. For \\( i \\in \\mathcal{D} \\), \\( pastVec_{cl}[i] \\) at any client \\( cl \\) is non-decreasing.\n\nProof. Note that \\( pastVec_{cl}[i] \\) is updated only at lines A1:16 or A1:22 when some transaction is committed. Therefore, the lemma holds due to Lemmas 12 and 38.\nD.4 Metadata for Strong Transactions\n\nLemma 40. For any replica $p^m_d$ in any data center $d$, $\\text{knownVec}^m_d[\\text{strong}]$ is non-decreasing.\n\nProof. By (R6) and line A6:6.\n\nLemma 41. For any replica $p^m_d$ in any data center $d$, $\\text{stableVec}^m_d[\\text{strong}]$ is non-decreasing.\n\n\nLemma 42 (PROPERTY 6). Let $t \\in T_{\\text{strong}}$ be a strong transaction that originates at data center $i$ and accesses partition $m$. If\n\n$$\\text{commitVec}(t)[\\text{strong}] \\leq \\text{knownVec}^m_d[\\text{strong}]$$\n\nfor some replica $p^m_d$ in data center $d$, then\n\n$$\\log(t)[m] \\subseteq \\text{opLog}^m_d.$$\n\nProof. Note that $\\text{knownVec}^m_d[\\text{strong}]$ can be updated only at line A6:9. By (R6), all committed strong transactions with strong timestamps less than or equal to $\\text{knownVec}^m_d[\\text{strong}]$ have been delivered to $p^m_d$. By line A6:8,\n\n$$\\log(t)[m] \\subseteq \\text{opLog}^m_d.$$\n\nD.5 Timestamps\n\nDefinition 43 (Timestamps of Events). Let $e \\in C_{\\text{casual}} \\cup C_{\\text{strong}} \\cup Q \\cup A$ be an event issued by client $cl$. We define its timestamp $ts(e)$ as\n\n$$ts(e) \\triangleq (\\text{pastVec}_cl)_e.$$\n\nLet $e \\in S$ be a START event of transaction $t$. Let $d \\triangleq \\text{dc}(t)$ and $m \\triangleq \\text{coord}(t)$. We define its timestamp $ts(e)$ as\n\n$$ts(e) \\triangleq (\\text{snapVec}^m_d)_e[i].$$\n\n\nDefinition 44 (Timestamps of Transactions). The timestamp $ts(t)$ of a transaction $t$ is that of its commit event, i.e.,\n\n$$\\forall t \\in T. \\ ts(t) \\triangleq ts(\\text{ct}(t)).$$\n\nLemma 45. Let $e \\in S$ be a START event. Let $d \\triangleq \\text{dc}(tx(e))$ and $m \\triangleq \\text{coord}(tx(e))$. Then\n\n$$(\\forall i \\in D. \\ ts(e)[i]) \\geq (\\text{uniformVec}^m_d)_e[i] \\land ts(e)[\\text{strong}] \\geq (\\text{stableVec}^m_d)_e[\\text{strong}].$$\n\n\nLemma 46. Let $e \\in R_{\\text{EXT}}$ be an external read event. Let $d \\triangleq \\text{dc}(tx(e))$ and $m \\triangleq \\text{coord}(tx(e))$. Then\n\n$$ts(st(e)) = \\text{snapshotVec}(tx(e)) = \\text{snapVec}^m_{\\text{GET_VERSION,e}} = (\\text{snapVec}^m_d)_e[tx(e)].$$\n\n\nLemma 47. Let $e \\in R_{\\text{EXT}}$ be an external read event which reads from transaction $t$. Then\n\n$$ts(t) \\leq ts(st(e)).$$\n\nProof. By line A3:5,\n\n$$\\text{commitVec}_{\\text{GET_VERSION,e}} \\leq \\text{snapVec}_{\\text{GET_VERSION,e}}.$$\n\nSince $e$ reads from $t$,\n\n$$ts(t) = \\text{commitVec}_{\\text{GET_VERSION,e}}.$$\n\nBy Lemma 46,\n\n$$ts(st(e)) = \\text{snapVec}_{\\text{GET_VERSION,e}}.$$\n\nTherefore,\n\n$$ts(t) \\leq ts(st(e)).$$\n\nLemma 48.\n\n$$\\forall e \\in (C_{\\text{RW}} \\cap C_{\\text{casual}}) \\cup C_{\\text{strong}}. \\ \\ ts(e) = ts(tx(e)) = \\text{commitVec}(tx(e)).$$\n\nProof. By Definition 43 of timestamps and Definition 11 of $\\text{commitVec}(tx(e))$.\n\nLemma 49.\n\n$$\\forall t \\in T. \\ ts(t) \\geq ts(st(t)).$$\n\n\nLemma 50. Let $s_1, s_2 \\in X$, $s_1 \\xrightarrow{so} s_2 \\Rightarrow (ts(s_1) \\leq ts(s_2)) \\land (s_2 \\in T \\Rightarrow ts(s_1) \\leq ts(st(s_2)) \\leq ts(s_2)).$\n\nProof. By Definitions 43 and 44 of timestamps and Lemma 39,\n\n$$ts(s_1) \\leq ts(s_2),$$\n\nand\n\n$$s_2 \\in T \\Rightarrow ts(s_1) \\leq ts(st(s_2)).$$\n\nBesides, by Lemma 12,\n\n$$s_2 \\in T \\Rightarrow ts(st(s_2)) \\leq ts(s_2).$$\n\nTherefore,\n\n$$s_2 \\in T \\Rightarrow ts(s_1) \\leq ts(st(s_2)) \\leq ts(s_2).$$\nD.7 Lamport Clocks\n\n**Definition 51** (Lamport Clocks of Events). Let \\( e \\in C_{causal} \\cup C_{strong} \\cup Q \\cup A \\) be an event issued by client \\( cl \\). We define its Lamport clock \\( lclock(e) \\) as\n\n\\[\nlclock(e) \\triangleq (lc)_{e}.\n\\]\n\nSee lines A1:14, A1:23, A1:28, and A1:33 for COMMIT\\_CAUSAL\\_TX, COMMIT\\_STRONG\\_TX, CL\\_UNIFORM\\_BARRIER, and CL\\_ATTACH events, respectively.\n\n**Definition 52** (Lamport Clocks of Transactions). The Lamport clock \\( lclock(t) \\) of a transaction \\( t \\) is that of its commit event, i.e.,\n\n\\[\n\\forall t \\in T. \\ lclock(t) \\triangleq lclock(ct(t)).\n\\]\n\n**Lemma 53.** Let \\( e \\in R_{EXT} \\) be an external read event issued by client \\( cl \\). Then\n\n\\[\n(lc)_{e} < lclock(tx(e)).\n\\]\n\n**Proof.** If \\( tx(e) \\) is a causal transaction, by line A1:14,\n\n\\[\nlclock(e) < lclock(ct(e)) = lclock(tx(e)).\n\\]\n\nIf \\( tx(e) \\) is a strong transaction, by line A1:19 and (6),\n\n\\[\nlclock(e) < lclock(ct(e)) = lclock(tx(e)).\n\\]\n\n**Definition 54** (Lamport Clock Order). The Lamport clock order \\( lc \\) on \\( X \\) is the total order defined by their Lamport clocks, with their client identifiers for tie-breaking.\n\n**Lemma 55.**\n\n\\[\ns \\subseteq lc.\n\\]\n\n\n**Lemma 56.** Let \\( e \\in R_{EXT} \\) be an external read event which reads from transaction \\( t \\). Then\n\n\\[\nt \\xrightarrow{lc} tx(e).\n\\]\n\n**Proof.** Suppose that \\( e \\) is issued by client \\( cl \\). By line A1:8,\n\n\\[\nlclock(t) \\leq (lc)_{e}.\n\\]\n\nBy Lemma 53,\n\n\\[\n(lc)_{e} < lclock(tx(e)).\n\\]\n\nTherefore,\n\n\\[\nlclock(t) < lclock(tx(e)).\n\\]\n\nBy Definition 54 of \\( lc \\),\n\n\\[\nt \\xrightarrow{lc} tx(e).\n\\]\n\n**D.8 Visibility Relation**\n\n**Definition 57** (Visibility Relation).\n\n\\[\n\\forall s_1, s_2 \\in X. \\ s_1 \\xrightarrow{vis} s_2 \\iff \\begin{cases} (s_2 \\in T \\Rightarrow ts(s_1) \\leq ts(st(s_2))) \\\\\n\\wedge (s_2 \\in Q \\cup A \\Rightarrow ts(s_1) \\leq ts(s_2)) \\end{cases} \\land s_1 \\xrightarrow{lc} s_2.\n\\]\n\n**Theorem 58.**\n\n\\[\nA \\models \\text{CONFLICTORDERING}.\n\\]\n\n**Proof.** We need to show that\n\n\\[\n\\forall t_1, t_2 \\in T_{\\text{strong}}, t_1 \\xrightarrow{vis} t_2 \\Rightarrow t_1 \\xrightarrow{vis} t_2 \\lor t_2 \\xrightarrow{vis} t_1.\n\\]\n\nConsider the history \\( h \\) of TCS. By Theorem 9, \\( h \\) committed \\( h \\) has a legal permutation \\( \\pi \\). Suppose that\n\n\\[\ncertify(tid(t_1), \\ldots, \\ldots) \\prec_{\\pi} certify(tid(t_2), \\ldots, \\ldots).\n\\]\n\nSince \\( t_1 \\xrightarrow{vis} t_2 \\) and \\( t_2 \\) is committed, by (4),\n\n\\[\n\\text{commitVec}(t_1) \\leq \\text{snapshotVec}(t_2).\n\\]\n\nBy Lemmas 46 and 48,\n\n\\[\nts(t_1) \\leq ts(st(t_2)).\n\\]\n\nOn the other hand, by (6),\n\n\\[\nlclock(t_1) < lclock(t_2).\n\\]\n\nBy Definition 54 of \\( lc \\),\n\n\\[\nt_1 \\xrightarrow{lc} t_2.\n\\]\n\nTherefore, by Definition 57 of \\( vis \\),\n\n\\[\nt_1 \\xrightarrow{vis} t_2.\n\\]\n\n**Lemma 59.**\n\n\\[\ns \\subseteq vis.\n\\]\n\n**Proof.** By Lemmas 50 and 55.\n\n**Lemma 60.** The visibility relation \\( vis \\) is a partial order.\n\n**Proof.** We need to show that\n\n- \\( vis \\) is irreflexive. This holds because \\( lc \\) is irreflexive.\n- \\( vis \\) is transitive. Suppose that \\( s_1 \\xrightarrow{vis} s_2 \\xrightarrow{vis} s_3 \\). By Definition 57 of \\( vis \\),\n\n\\[\ns_1 \\xrightarrow{lc} s_2 \\xrightarrow{lc} s_3.\n\\]\n\nBy Definition 54 of \\( lc \\),\n\n\\[\ns_1 \\xrightarrow{lc} s_3.\n\\]\n\nRegarding timestamps, we distinguish between the following four cases and use Lemma 49.\n\n38\nAssume that \n\nTherefore, \n\nProof. \n\nBy Lemmas 59 and 60, \n\nPutting it together yields \n\nNext we show that \n\nAssume that \n\nSince \\( t_1 \\gg t_2 \\), by Theorem 58, \n\nBy (23) and (24), \n\nTherefore, \n\nD.9 Execution Order\n\nDefinition 63 (Execution Points). Let \\( k \\) be a key. The “execution point” \\( \\text{ep}(e, k) \\) of event \\( e \\in (R_{\\text{EXT}} \\cap R_k) \\cup C_k \\) is defined as follows:\n\n\\begin{itemize}\n \\item If \\( e \\in R_{\\text{EXT}} \\cap R_k \\), then \\( \\text{ep}(e, k) \\) is at line A3:5;\n \\item If \\( e \\in C_k \\cap C_{\\text{casual}} \\), then \\( \\text{ep}(e, k) \\) is at line A3:19 for this particular key \\( k \\);\n \\item If \\( e \\in C_k \\cap C_{\\text{strong}} \\) then \\( \\text{ep}(e, k) \\) is at line A6:8 for delivery of the update of \\( \\text{tx}(e) \\) on this particular key \\( k \\). Note that \\text{DELIVER} is asynchronous with the commit event \\( e \\).\n\\end{itemize}\n\nDefinition 64 (Per-key Execution Order). Let \\( k \\) be a key. Suppose that \\( \\{e_1, e_2\\} \\subseteq (R_{\\text{EXT}} \\cap R_k) \\cup C_k \\). Event \\( e_1 \\) is executed before event \\( e_2 \\), denoted \\( e_1 \\xrightarrow{\\text{eq}} e_2 \\), if \\( \\text{ep}(e_1, k) \\) is executed before \\( \\text{ep}(e_2, k) \\) in real time.\n\nLemma 65. Let \\( k \\in \\text{Key} \\) be a key, \\( t \\in T_k \\) be a transaction, and \\( e \\in R_{\\text{EXT}} \\cap R_k \\) be an external read event. Suppose that \\( d \\triangleq dc(t) = dc(\\text{tx}(e)) \\). Then \n\n\\[ t \\xrightarrow{\\text{vis}} \\text{tx}(e) \\Rightarrow \\text{ct}(t) \\xrightarrow{\\text{eq}} e. \\]\n\nProof. By Definition 57 of \\( \\text{vis} \\), \n\n\\[ ts(t) \\leq ts(st(e)). \\]\n\nSince \\( e \\in R_{\\text{EXT}} \\), by Lemma 46, \n\n\\[ ts(t) \\leq \\text{snapVec}(\\text{GET_VERSION}, e). \\]\n\nIn the following, we distinguish between two cases according to whether \\( t \\in T_{\\text{causal}} \\) or \\( t \\in T_{\\text{strong}} \\). Let \\( m \\triangleq \\text{partition}(k) \\).\n• **CASE I:** \\(t \\in T_{c\\text{ausal}}\\). By Lemma 48,\n\\[\nts(t) = \\text{commit Vec}(t) \\leq \\text{snap Vec}_{e}(\\text{GET\\_VERSION,e})\n\\]\nTherefore, after line A3:4 for \\(e\\),\n\\[\n(\\text{known Vec}_{e}^{d})_{e}[d] \\geq \\text{snap Vec}_{e}(\\text{GET\\_VERSION,e})[d] \\\\\n\\geq \\text{commit Vec}(t)[d]. \\quad (25)\n\\]\nBy Lemma 18, COMMIT of Algorithm A3 for \\(ws(t)[m] \\triangleright \\langle k, \\_ \\rangle\\) finishes before \\(e\\) starts at replica \\(p_{d}^{m}\\). By Definition 66 of eo_{k},\n\\[\nct(t) \\xrightarrow{eo} e.\n\\]\n\n• **CASE II:** \\(t \\in T_{s\\text{trong}}\\). By Lemma 48,\n\\[\nts(t) = \\text{commit Vec}(t) \\leq \\text{snap Vec}_{e}(\\text{GET\\_VERSION,e})\n\\]\nTherefore, after line A3:4 for \\(e\\),\n\\[\n(\\text{known Vec}_{e}^{d})_{e}[\\text{strong}] \\geq \\text{snap Vec}_{e}(\\text{GET\\_VERSION,e})[\\text{strong}] \\geq \\text{commit Vec}(t)[\\text{strong}]. \\quad (26)\n\\]\nBy Lemma 42, DELIVER of Algorithm A6 for \\(ws(t)[m] \\triangleright \\langle k, \\_ \\rangle\\) finishes before \\(e\\) starts at replica \\(p_{d}^{m}\\). By Definition 64 of eo_{k},\n\\[\nct(t) \\xrightarrow{eo} e.\n\\]\n\n\\[\\square\\]\n\nD.10 Arbitration Relation\n\n**Definition 66** (Arbitration Relation). We define the arbitration relation \\(ar\\) on \\(X\\) as the Lamport clock order between them, i.e.,\n\\[\nar = lc.\n\\]\n\n**Theorem 67.**\n\\[\nA \\models \\text{CAUSAL\\_ARBITRATION}.\n\\]\n\n**Proof.** By Definition 57 of vis and Definition 66 of ar,\n\\[\n\\text{vis} \\subseteq lc = ar.\n\\]\n\n\\[\\square\\]\n\nD.11 Return Values\n\nIt is straightforward to show that INTRVAL holds for \\textit{internal} read events.\n\n**Theorem 68.**\n\\[\nA \\models \\text{INTRVAL}.\n\\]\n\n**Proof.** Let \\(e \\in R_{\\text{INT}} \\cap R_{k}\\) be an internal read event. The transaction \\(tx(e)\\) contains update events on \\(k\\). By line A2:12, \\(e\\) reads from the last update event on \\(k\\) preceding \\(e\\) in \\(tx(e)\\). \\[\\square\\]\n\nNow let \\(e\\) be an \\textit{external} read event. For notational convenience, we define \\(V_{r}\\) to be the set of update transactions on \\(k\\) that are visible to \\(tx(e)\\), and \\(S_{e}\\) the set of update transactions on \\(k\\) that are safe to read at line A3:5. By Assumption 6, (R5), and (R3), all transactions in \\(S_{e}\\) are committed. Formally,\n\n**Definition 69** (Visibility Set). Let \\(e \\in R_{\\text{EXT}} \\cap R_{k}\\) be an external read event on key \\(k\\).\n\\[\nV_{e} \\triangleq \\text{vis}^{-1}(tx(e)) \\cap T_{k}.\n\\]\n\n**Definition 70** (Safe Set). Let \\(e \\in R_{\\text{EXT}} \\cap R_{k}\\) be an external read event on key \\(k\\). Suppose that \\(e\\) is issued to replica \\(p_{d}^{m}\\) in data center \\(d\\).\n\\[\nS_{e} \\triangleq \\{ t \\in T_{k} : ts(t) \\leq \\text{snap Vec}_{e}(\\text{GET\\_VERSION,e}) \\land \\text{log}[t][k] \\in (\\text{op Log}_{d}^{m})_{e}[k] \\}.\n\\]\n\n**Lemma 71.** Let \\(e \\in R_{\\text{EXT}} \\cap R_{k}\\) be an external read event on key \\(k\\). Suppose that \\(e\\) is issued to replica \\(p_{d}^{m}\\) in data center \\(d\\). When \\(e\\) returns at \\(p_{d}^{m}\\) (line A3:5), we have\n\\[\nV_{e} \\subseteq S_{e}.\n\\]\n\n**Proof.** For each \\(t \\in V_{e}\\), we need to show that \\(t \\in S_{e}\\). That is,\n\\[\nts(t) \\leq \\text{snap Vec}_{e}(\\text{GET\\_VERSION,e}) \\quad (27)\n\\]\nand\n\\[\n\\text{log}[t][k] \\in (\\text{op Log}_{d}^{m})_{e}[k]. \\quad (28)\n\\]\n\nWe first show that (27) holds. Since \\(t \\in V_{e}\\),\n\\[\nt \\xrightarrow{vis} tx(e).\n\\]\nBy Definition 57 of vis,\n\\[\nts(t) \\leq ts(st(e)).\n\\]\nBy Lemma 46,\n\\[\nts(t) \\leq \\text{snap Vec}_{e}(\\text{GET\\_VERSION,e})\n\\]\nTo show that (28) holds, we perform a case analysis according to whether \\(t\\) is a local transaction in data center \\(d\\) or a remote one in data center \\(i \\neq d\\).\n\n• **CASE I:** \\(t\\) is a local transaction in data center \\(d\\). Since \\(t \\xrightarrow{vis} tx(e)\\), by Lemma 65,\n\\[\nct(t) \\xrightarrow{eo} e.\n\\]\nTherefore,\n\\[\n\\text{log}[t][k] \\in (\\text{op Log}_{d}^{m})_{e}[k].\n\\]\n• **CASE II:** \\(t\\) is a remote transaction in data center \\(i \\neq d\\). We distinguish between two cases according to whether \\(t \\in T_{c\\text{ausal}}\\) or \\(t \\in T_{s\\text{trong}}\\).\nTheorem 72.\n\\[ A \\models \\text{ExtRVal}. \\]\n\nProof. Let \\( e \\in R_{\\text{EXT}} \\cap R_k \\) be an external read event on key \\( k \\). Suppose that \\( e \\) reads from transaction \\( t \\) in \\( S_e \\). Since all transactions in \\( S_e \\) are committed, \\( t \\) is committed. By Lemma 47,\n\\[ ts(t) \\leq ts(st(e)). \\]\nBy Lemma 56,\n\\[ t \\xrightarrow{k} tx(e). \\]\nBy Definition 57 of \\( \\text{vis} \\),\n\\[ i \\xrightarrow{\\text{vis}} tx(e). \\]\nBy Definition 69 of \\( V_e \\),\n\\[ t \\in V_e. \\]\nBoth \\( V_e \\) and \\( S_e \\) are totally ordered by \\( lc \\). Since \\( t \\) is the latest one in \\( S_e \\) and \\( V_e \\subseteq S_e \\) (Theorem 71), \\( t \\) is also the latest one in \\( V_e \\). Thus, \\( e \\) reads from \\( t \\) in \\( V_e \\). That is, \\( e \\) reads from the update event \\( ud(t,k) \\) of \\( V_e \\).\n\nD.12 Uniformity\n\nD.12.1 Uniformity of Causal Transactions Originating at Correct Data Centers\n\nLemma 74. For any replica \\( p^m_d \\) in any correct data center \\( d \\in C \\), \\( \\text{knownVec}^m_d \\) grows without bound.\n\nProof. Since data center \\( d \\) is correct, by Assumption 4, \\( \\text{PROPAGATE}_\\text{LOCAL}_\\text{TXS} \\) of Algorithm A4 will be executed infinitely often.\n\n- CASE I: Line A4:3 is executed infinitely often. By Assumption 1, \\( \\text{knownVec}^m_d \\) grows without bound.\n- CASE II: Line A4:5 is executed infinitely often. That is, it is infinitely often that\n\\[ \\text{preparedCausal}^m_d \\neq \\emptyset. \\]\n\nBy Assumption 4, causal transactions in \\( \\text{preparedCausal}^m_d \\) will eventually be committed and removed from \\( \\text{preparedCausal}^m_d \\) (line A3:17). Thus, it is infinitely often that new causal transactions are prepared and added into \\( \\text{preparedCausal}^m_d \\) (line A3:12) with larger and larger prepare timestamps (line A3:11). Therefore,\n\\[ \\min \\{ ts \\mid \\langle \\_,\\_, ts \\rangle \\in \\text{preparedCausal}^m_d \\} \\]\nand\n\\[ \\text{knownVec}^m_d[d] = \\min \\{ ts \\mid \\langle \\_,\\_, ts \\rangle \\in \\text{preparedCausal}^m_d \\} - 1 \\]\ngrow without bound.\n\nLemma 75. Let \\( p^m_d \\) be a replica in a correct data center \\( d \\in C \\). If for some \\( j \\in D \\) and some value \\( x \\in \\mathbb{N} \\)\n\\[ \\text{knownVec}^m_d[j] \\geq x, \\]\nthen eventually\n\\[ \\forall c \\in C. \\ \\text{knownVec}^m_c[j] \\geq x. \\]\n\nProof. Since data center \\( d \\) is correct, by Assumption 4, for every other data center \\( i \\neq d \\), replica \\( p^m_d \\) will keep\n\n- replicating to data center \\( i \\) the write sets\n\\[ \\langle \\_,\\_, \\text{commitVec}, \\_ \\rangle \\in \\text{committedCausal}^m_d[j] \\]\nthat have not been received by \\( i \\) from the perspective of \\( d \\) (commitVec\\[d] \\leq \\text{knownVec}^m_d[j] \\) at line A4:6 and \\( \\text{commitVec}[j] > \\text{globalMatrix}^m_d[i][j] \\) at line A4:23;\n- or sending heartbeats with up-to-date knownVec\\[d][j] to data center \\( i \\) (lines A4:11 and A4:27).\nBy Assumption 2, knownVec\\textsuperscript{m}_{c}[j] at replica \\( p^m_c \\) of each correct data center \\( c \\in C \\) will eventually be updated (lines A4:18 and A4:21) such that\n\\[\n\\text{knownVec}^m_{c}[j] \\geq \\text{knownVec}^{m'}_{c}[j] \\geq x.\n\\]\n\n**Lemma 76.** Let \\( d \\in C \\) be a correct data center. For any replica \\( p^m_c \\) in any correct data center \\( c \\in C \\), knownVec\\textsuperscript{m}_{c}[d] grows without bound. By line A5:3, Assumptions 2 and 3, and lines A5:12–A5:15, for any replica \\( p^m_c \\) in any correct data center \\( c \\in C \\), knownVec\\textsuperscript{m}_{c}[d] grows without bound.\n\n**Proof.** By Lemmas 74 and 75, for any replica \\( p^m_c \\) in any correct data center \\( c \\in C \\), knownVec\\textsuperscript{m}_{c}[d] grows without bound. By line A5:3, Assumptions 2 and 3, and lines A5:12–A5:15, for any replica \\( p^m_c \\) in any correct data center \\( c \\in C \\), knownVec\\textsuperscript{m}_{c}[d] grows without bound.\n\n**D.12.2 Uniformity of Causal Transactions Visible to CL\\_UNIFORM\\_BARRIER events**\n\n**Lemma 79.** Let \\( t \\in T_{\\text{causal}} \\) be a causal transaction and \\( q \\in Q \\) be a CL\\_UNIFORM\\_BARRIER event. If \\( t \\text{ \\textvis \\ q} \\), then for any replica \\( p^m_{c'} \\) in any correct data center \\( c \\in C \\), eventually\n\\[\n\\forall i \\in \\mathcal{D}, \\text{ts}(t)[i] \\leq \\text{uniformVec}^m_{c'}[i].\n\\]\n\n**Proof.** Since \\( t \\text{ \\textvis \\ q} \\), by Definition 57 of \\textvis,\n\\[\n\\text{ts}(t) \\leq \\text{ts}(q).\n\\]\nSuppose that \\( q \\) is issued by client \\( cl \\) to replica \\( p^m_{d} \\) in data center \\( d \\) and is returned at time \\( \\tau_q \\). By Definition 43 of timestamps and Lemma 31,\n\\[\n\\text{ts}(t)[d] \\leq \\text{ts}(q)[d] \\leq (\\text{uniformVec}_d^m)[d].\n\\]\nBy Lemma 77, there exists some time \\( \\tau' \\) such that\n\\[\n\\text{ts}(t)[d] \\leq (\\text{uniformVec}^m_{c'})[\\tau''][d].\n\\]\nOn the other hand, by Definition 43 of timestamps and Lemma 31 (let \\( n \\triangleq \\text{coord}(t) \\) and \\( cl \\triangleq \\text{client}(t) \\)),\n\\[\n\\forall i \\in \\mathcal{D} \\setminus \\{d\\}, \\text{ts}(t)[i] = (\\text{pastVec}_{cl}[i])_{\\tau(i)}[i] \\leq (\\text{uniformVec}^m_{c'})_{\\tau(i)}[i].\n\\]\nBy Lemma 77, there exists some time \\( \\tau'' \\) such that\n\\[\n\\forall i \\in \\mathcal{D} \\setminus \\{d\\}, \\text{ts}(t)[i] \\leq (\\text{uniformVec}^m_{c'})(\\tau'')[i].\n\\]\nLet\n\\[\n\\tau \\triangleq \\max\\{\\tau', \\tau''\\}.\n\\]\n\n**Lemma 78.** Let \\( d \\in C \\) be a correct data center and \\( t \\in T_{\\text{causal}} \\) be a causal transaction that originates at \\( d \\). Then for any replica \\( p^m_c \\) in any correct data center \\( c \\in C \\), eventually\n\\[\n\\forall i \\in \\mathcal{D}, \\text{ts}(t)[i] \\leq \\text{uniformVec}^m_{c'}[i].\n\\]\n\n**Proof.** Since \\( d \\) is correct, by Lemma 76, there exists some time \\( \\tau' \\) such that\n\\[\n\\text{ts}(t)[d] \\leq (\\text{uniformVec}^m_{c'})[\\tau'][d].\n\\]\nD.12.3 Uniformity of Strong Transactions\n\n**Lemma 80.** For any replica $p^m_c$ in any correct data center $c \\in C$, knownVec$^m_c[strong]$ grows without bound.\n\n*Proof.* By Assumption 4 and Theorem 9, replica $p^m_c$ will either deliver committed strong transactions infinitely often (DELIVER of Algorithm A6) or submit dummy strong transactions infinitely often (HEARTBEAT STRONG of Algorithm A6). Thus, knownVec$^m_c[strong]$ grows without bound.\n\n**Lemma 81.** Let $t \\in T$ be a transaction. Then for any replica $p^m_c$ in any correct data center $c \\in C$, eventually\n\n$$ts(t)[strong] \\leq \\text{stableVec}^m_c[strong].$$\n\n*Proof.* By Lemma 80 and lines A5:2 and A5:9, stableVec$^m_c[strong]$ grows without bound. Therefore, there exists some time $\\tau$ such that\n\n$$ts(t)[strong] \\leq \\text{stableVec}^m_c(\\tau)[strong].$$\n\n**Lemma 82.** Let $t \\in T_{strong}$ be a strong transaction. Then for any replica $p^m_c$ in any correct data center $c \\in C$, eventually\n\n$$\\forall i \\in D. ts(t)[i] \\leq \\text{uniformVec}^m_c[i].$$\n\n*Proof.* Let $d \\triangleq dc(t)$, $n \\triangleq \\text{coord}(t)$, and $cl \\triangleq \\text{client}(t)$. By Definition 43 of timestamps,\n\n$$ts(t) = (\\text{pastVec}_c)[cl(t)].$$\n\nOn the one hand, by Lemma 31,\n\n$$\\forall i \\in D \\setminus \\{d\\}. ts(t)[i] = (\\text{pastVec}_c)[cl(t)][i] \\leq (\\text{uniformVec}_c^n)[cl(t)][i].$$\n\nBy Lemma 77, there exists some time $\\tau'$ such that\n\n$$\\forall i \\in D \\setminus \\{d\\}. ts(t)[i] \\leq (\\text{uniformVec}^m_c)[\\tau'][i].$$\n\nOn the other hand, by Lemma 48,\n\n$$ts(t)[d] = \\text{commitVec}(t)[d].$$\n\nBy (5),\n\n$$\\text{commitVec}(t)[d] = \\text{snapshotVec}(t)[d].$$\n\nBy lines A6:2 and A3:22,\n\n$$\\text{snapshotVec}(t)[d] \\leq (\\text{uniformVec}^m_d)[cl(t)][d].$$\n\nPutting it together yields,\n\n$$ts(t)[d] \\leq (\\text{uniformVec}^m_d)[cl(t)][d].$$\n\nBy Lemma 77, there exists some time $\\tau''$ such that\n\n$$ts(t)[d] \\leq (\\text{uniformVec}^m_c)[\\tau''][d].$$\n\nLet\n\n$$\\tau \\triangleq \\max\\{\\tau', \\tau''\\}.$$\n\nBy Lemma 30,\n\n$$\\forall i \\in D. ts(t)[i] \\leq \\text{uniformVec}^m_c(\\tau)[i].$$\n\nD.13 Eventual Visibility\n\n**Theorem 83.**\n\n$$A \\models \\text{EVENTUALVISIBILITY}.$$ \n\n*Proof.* Consider a transaction $t \\in T$ such that\n\n$$dc(t) \\in C \\lor (\\exists q \\in Q. t \\text{ vis}^q) \\lor t \\in T_{strong}.$$ \n\nBy Lemma 59, it suffices to show that for any client $cl$,\n\n$$|T|_c = \\infty \\Rightarrow \\exists t' \\in T|_c. t \\text{ vis}^q \\rightarrow t'.$$\n\nBy Lemmas 78, 79, 81, and 82, there exists some time $\\tau$ such that\n\n$$\\forall c \\in C. \\forall n \\in \\mathcal{P}.$$ \n\n$$\\forall i \\in D. ts(t)[i] \\leq \\text{uniformVec}^m_c(\\tau)[i] \\land$$\n\n$$ts(t)[strong] \\leq \\text{stableVec}^m_c(\\tau)[strong].$$\n\n(29)\n\nSince $|T|_c = \\infty$, there exists some correct data center $d \\in C$ to which $cl$ issues an infinite number of transactions. Let $t' \\in T$ be the first transaction issued by client $cl$ to data center $d$ which starts after time $\\tau$ such that\n\n$$lclock(t) < lclock(t').$$\n\nThus, by Definition 54 of $lc$,\n\n$$t \\rightarrow_k t'.$$\n\nLet $m \\triangleq \\text{coord}(t')$. Since $d$ is correct, by (29),\n\n$$\\forall i \\in D. ts(t)[i] \\leq \\text{uniformVec}^m_d(\\tau)[i] \\land$$\n\n$$ts(t)[strong] \\leq \\text{stableVec}^m_d(\\tau)[strong].$$\n\nBy Lemma 30,\n\n$$\\forall i \\in D. \\text{uniformVec}^m_d(\\tau)[i] \\leq (\\text{uniformVec}^m_d)_{st(t')}[i].$$\n\nBy Lemma 41,\n\n$$\\text{stableVec}^m_d(\\tau)[strong] \\leq (\\text{stableVec}^m_d)_{st(t')}[strong].$$\nBy Lemma 45,\n\\[\n(\\forall i \\in D. (\\text{uniformVec}_d^m)_{st'(i)}[i] \\leq ts(st'(i))[i]) \\land \\\\\n(\\text{stableVec}_d^m)_{st'(i)}[\\text{strong}] \\leq ts(st'(i))[\\text{strong}],\n\\]\nPutting it together yields\n\\[\nts(t) \\leq ts(st'(i)).\n\\]\nBy Definition 57 of \\( \\text{vis} \\),\n\\[\nt \\xrightarrow{\\text{vis}} t'.\n\\]\n\n**D.14 UNISTORE Correctness**\n\n**Theorem 84.**\n\n\\( \\text{UNISTORE} \\models \\text{POR} \\).\n\n**Proof.** By Theorems 58, 61, 67, 73, and 83.\n\n**D.15 UNISTORE Liveness**\n\n**Lemma 85.** Each client migration \\( \\text{CL_AUX} \\) to a correct data center will eventually terminate, provided that the client managed to complete its \\( \\text{CL_UNIFORM_BARRIER} \\) call at its original data center just before \\( \\text{CL_ATTACH} \\).\n\n**Proof.** Suppose that client \\( cl \\) in its current data center \\( d \\triangleq \\text{cur_dc}(cl) \\) issues a \\( \\text{CL_ATTACH} \\) event at replica \\( p_d^m \\) in correct data center \\( c \\in C \\).\n\nLet \\( e \\in C \\) be the last commit event issued by client \\( cl \\) before \\( a \\). If \\( e \\) does not exist, then\n\\[\n\\forall i \\in D, \\text{pastVec}_{cl,c}[i] = 0.\n\\]\nTherefore, the wait condition\n\\[\n\\forall i \\in D \\setminus \\{ c \\}, \\text{uniformVec}_{c}^m[i] \\geq 0\n\\]\nat line A3:24 at replica \\( p_d^m \\) will eventually hold. Thus, the \\( \\text{CL_ATTACH} \\) event \\( a \\) eventually terminates.\n\nOtherwise, suppose that \\( e \\) is issued to replica \\( p_d^m \\) in data center \\( d' \\). By Lemma 31,\n\\[\n\\forall i \\in D \\setminus \\{ d' \\}, (\\text{uniformVec}_{d'}^m)_e[i] \\geq (\\text{pastVec}_{cl,c})_e[i]. \\tag{30}\n\\]\nNote that it is possible that \\( d' \\neq d \\), since there may exist other \\( \\text{CL_ATTACH} \\) events between \\( e \\) and \\( a \\). Therefore, we distinguish between the following two cases:\n\n- **CASE I:** \\( d' = d \\). By (30),\n \\[\n \\forall i \\in D \\setminus \\{ d' \\}, (\\text{uniformVec}_{d'}^m)_e[i] \\geq (\\text{pastVec}_{cl,c})_e[i]. \\tag{31}\n \\]\n\n- **CASE II:** \\( d' \\neq d \\). Consider the last \\( \\text{CL_ATTACH} \\) event, denoted \\( a' \\), before \\( a \\). Suppose that \\( a' \\) is issued to replica \\( p_d^m \\) in data center \\( d \\). By Lemma 31, when \\( a' \\) terminates,\n \\[\n \\forall i \\in D \\setminus \\{ d' \\}, (\\text{uniformVec}_{d'}^m)_{a'}[i] \\geq (\\text{pastVec}_{cl,c})_{a'}[i] = (\\text{pastVec}_{cl,c})_e[i]. \\tag{32}\n \\]\n\nLet \\( q \\in Q \\) be the \\( \\text{CL_UNIFORM_BARRIER} \\) event issued by client \\( cl \\) just before \\( a \\). Suppose that \\( q \\) is issued to replica \\( p_d^m \\) in data center \\( d \\). By Lemma 31,\n\\[\n(\\text{uniformVec}_{d}^m)_q[d] \\geq (\\text{pastVec}_{cl,c})_e[d]. \\tag{33}\n\\]\nBy (31), (32), (33), and Lemma 77, eventually for the correct data center \\( c \\),\n\\[\n\\forall i \\in D. \\text{uniformVec}_{c}^m[i] \\geq (\\text{pastVec}_{cl,c})_e[i].\n\\]\nTherefore, the wait condition\n\\[\n\\forall i \\in D \\setminus \\{ c \\}, \\text{uniformVec}_{c}^m[i] \\geq (\\text{pastVec}_{cl,c})_e[i]\n\\]\nat line A3:24 at replica \\( p_d^m \\) will eventually hold. Thus, the \\( \\text{CL_ATTACH} \\) event \\( a \\) eventually terminates.\n\n**Theorem 86.** Any client event issued at a correct data center will eventually terminate.\n\n**Proof.** Consider any event \\( e \\) issued by client \\( cl \\) at a correct data center \\( c \\in C \\). It suffices to show that each wait condition in the execution of \\( e \\), if any, will eventually hold. In the following, we perform a case analysis according to the type of event \\( e \\).\n\n- **CASE I:** \\( e \\in S \\). The theorem holds trivially.\n- **CASE II:** \\( e \\in R \\). If \\( e \\in \\mathbf{R}_{\\text{INT}} \\), the theorem holds trivially. Otherwise, \\( e \\in \\mathbf{R}_{\\text{EXT}} \\). By Lemmas 74 and 80, the wait condition at line A3:44 for \\( e \\) will eventually hold.\n- **CASE III:** \\( e \\in U \\). The theorem holds trivially.\n- **CASE IV:** \\( e \\in \\mathbf{C}_{\\text{CAUSAL}} \\). Since data center \\( c \\) is correct, the wait condition at line A3:28 will eventually hold.\n- **CASE V:** \\( e \\in \\mathbf{C}_{\\text{STRONG}} \\). By Lemma 76, the wait condition at line A3:22 will eventually hold. Thus, line A6:2 will eventually terminate. Then, by Assumption 6, the procedure \\( \\text{CERTIFY} \\) and thus the event \\( e \\) will eventually terminate.\n- **CASE VI:** \\( e \\in \\text{CL_UNIFORM_BARRIER} \\). By Lemma 76, the wait condition at line A3:22 will eventually hold.\n- **CASE VII:** \\( e \\in \\text{CL_ATTACH} \\). The theorem holds due to CASE VI and Lemma 85."}}},{"rowIdx":293,"cells":{"id":{"kind":"string","value":"bfca7d2f138c6246deac19a70e907e215b9e7410"},"text":{"kind":"string","value":"Copyright Notice\nCopyright © 2020 Imperas Software Limited. All rights reserved. This software and\ndocumentation contain information that is the property of Imperas Software Limited. The\nsoftware and documentation are furnished under a license agreement and may be used or\ncopied only in accordance with the terms of the license agreement. No part of the\nsoftware and documentation may be reproduced, transmitted, or translated, in any form or\nby any means, electronic, mechanical, manual, optical, or otherwise, without prior written\npermission of Imperas Software Limited, or as expressly provided by the license\nagreement.\n\nRight to Copy Documentation\nThe license agreement with Imperas permits licensee to make copies of the\ndocumentation for its internal use only. Each copy shall include all copyrights,\ntrademarks, service marks, and proprietary rights notices, if any.\n\nDestination Control Statement\nAll technical data contained in this publication is subject to the export control laws of the\nUnited States of America. Disclosure to nationals of other countries contrary to United\nStates law is prohibited. It is the reader’s responsibility to determine the applicable\nregulations and to comply with them.\n\nDisclaimer\nIMPERAS SOFTWARE LIMITED., AND ITS LICENSORS MAKE NO WARRANTY\nOF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS MATERIAL,\nINCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\nMERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.\nTable of Contents\n\n1 Preface ............................................................................................................. 7\n1.1 Notation ........................................................................................................ 7\n1.2 Related Documentation ............................................................................... 7\n1.3 Glossary / Terminology ............................................................................. 8\n2 Introduction .................................................................................................... 9\n 2.1 Prerequisites .............................................................................................. 9\n 2.2 Obtaining & installing the OP API .......................................................... 9\n 2.3 Compiling Examples described in this Document .................................. 9\n 2.4 Shared Objects and executables ............................................................. 10\n 2.5 Platforms, Modules and Shared Objects ................................................ 10\n3 Tracing the API calls and seeing what is happening ................................... 11\n4 Detailed OP API Documentation .................................................................. 12\n5 Structure of Harnesses/Modules & Simulation Phases .................................. 13\n 5.1 A little more complete test harness ......................................................... 13\n 5.1.1 Constructor - moduleConstruct ......................................................... 14\n 5.1.2 Command Line Parsing - cmdParser .................................................. 14\n 5.1.3 Local module persistent data - optModuleObject .............................. 15\n 5.1.4 Initialization - modulePreSimulate ..................................................... 15\n 5.1.5 Simulation - moduleSimulate .............................................................. 15\n 5.1.6 Reporting - modulePostSimulate ...................................................... 15\n 5.1.7 Destructor - moduleDestruct ............................................................... 16\n 5.1.8 modelAttrs table ................................................................................ 16\n 5.1.9 The main() program ........................................................................... 16\n 5.1.10 Complete harness code ..................................................................... 17\n 5.2 Order of Platform construction ............................................................... 18\n6 Modules revisited (using the OP API and C) .............................................. 20\n 6.1 A module in C with all user callbacks .................................................... 20\n 6.2 Simple C module ...................................................................................... 23\n7 Adding C code to a module ......................................................................... 24\n 7.1 Monitoring nets ........................................................................................ 24\n 7.2 Listing of C code for module monitoring its nets .................................... 26\n 7.3 Monitoring Memory locations and Buses using callbacks ....................... 27\n 7.4 Adding behavioral C code in modules ..................................................... 29\n 7.4.1 A mixed TCL and C module ............................................................. 29\n 7.4.2 Advancing time and writing nets in a harness .................................. 33\n 7.4.3 Running the simulation .................................................................... 38\n8 Using Hierarchical Connections ................................................................... 40\n 8.1 Bus ........................................................................................................... 40\n 8.2 FIFO ........................................................................................................... 41\n 8.3 Net ............................................................................................................ 43\n 8.4 Packetnet ................................................................................................. 45\n9 Introducing Basic Processor Introspection .................................................. 49\n 9.1 Reading and Writing Registers ............................................................... 49\n 9.2 Generating Disassembly Output .............................................................. 52\n 9.3 Dumping Registers .................................................................................. 52\n\n9.4 Instruction Counts ................................................................. 52\n9.5 Example Processor Introspection .............................................. 52\n9.6 Example Custom Processor Trace .......................................... 53\n10 Simulating a Design............................................................... 55\n10.1 Simulator Scheduler ............................................................ 55\n 10.1.1 The standard built in (default) simulator scheduler algorithm 55\n 10.1.2 Writing a custom scheduler ............................................. 55\n 10.1.3 Example ........................................................................... 56\n10.2 Custom Simulation Tracing with Harness ............................... 59\n 10.2.1 Controlling Instructions Executed on a Processor ............... 59\n 10.2.2 Generating Disassembly Information ............................... 60\n 10.2.3 Accessing Registers ......................................................... 60\n 10.2.4 Example ........................................................................... 61\n10.3 Interrupt a Running Simulation ............................................. 63\n 10.3.1 Interrupt Simulation (from a Ctrl-C Handler) ....................... 63\n 10.3.2 Interrupt a Specific Processor .......................................... 65\n 10.3.3 Example ........................................................................... 66\n 10.3.4 Important Notes ............................................................... 67\n10.4 Generating External Events to a Processor ............................... 67\n 10.4.1 Processor Reset ............................................................... 68\n 10.4.2 Processor Startup Reset .................................................... 69\n 10.4.3 Processor Reset Example .................................................. 69\n10.5 Processor External Interrupt .................................................. 74\n 10.5.1 Processor External Interrupt Timer Tick Example .................. 77\n10.6 Standard Multiprocessor Scheduling Algorithm ....................... 80\n 10.6.1 Changing the Time Slice Size .......................................... 80\n 10.6.2 Changing Processor Nominal MIPS Rate ........................... 81\n 10.6.3 Writing Custom Scheduling Algorithms ......................... 81\n11 Parallel Simulation: QuantumLeap™ ....................................... 82\n 11.1 License and Runtime for QuantumLeap ............................... 82\n 11.2 Example ............................................................................. 82\n 11.3 QuantumLeap Results ....................................................... 84\n 11.4 QuantumLeap Scheduling Algorithm ................................. 84\n 11.5 QuantumLeap Options ....................................................... 85\n 11.5.1 Option -parallelopt ......................................................... 85\n 11.5.2 Option -parallelthreads .................................................. 86\n 11.5.3 Option -parallelmax ....................................................... 87\n12 Memory Operations ............................................................... 88\n 12.1 Implicit Processor Model Memory ........................................ 88\n 12.1.1 Loading object files ....................................................... 88\n 12.2 Loading by Directly Reading and Writing Data ....................... 90\n 12.2.1 Example Loading Program from Hex format file ............... 90\n 12.2.2 Reading and writing memory without side-effects ............. 96\n 12.2.3 Swapping data to host endian ........................................ 96\n 12.3 Explicit Local and External Memory ..................................... 97\n 12.3.1 Local Memory ............................................................... 97\n12.3.2 External Memory: Mapping an address region to a callback ................... 99\n12.3.3 External Memory: Using Native Memory .............................................. 103\n12.3.4 External Memory: Combining Callbacks and Native Memory .......... 106\n12.3.5 Debugging Bus Connections............................................................... 106\n12.4 Adding Memory Access Callbacks................................................................. 107\n12.4.2 Adding a Memory Watchpoint ............................................................... 113\n13 Simulation Optimization........................................................................................ 114\n13.1 Example .......................................................................................................... 114\n14 Enabling Peripheral Diagnostics............................................................................ 116\n14.1 Model Diagnostics ......................................................................................... 116\n14.2 Intercept Library Diagnostics ...................................................................... 116\n14.3 Peripheral Debug Support ............................................................................ 117\n14.4 Controlling peripheral model diagnostics ................................................... 117\n14.4.1 From Command Line ...................................................................... 117\n14.4.2 From Harness ......................................................................................... 118\n15 Model and Intercept Object Additional Commands .............................................. 119\n16 Introspecting and Querying Platforms & Components........................................ 123\n16.1 Platform Introspecter: Examples/PlatformConstruction/walker ................... 123\n16.2 Running the platform & component introspecting harness: walker ............ 125\n16.3 Using the walkers command line ................................................................. 126\n17 Save / Restore ........................................................................................................ 129\n17.1 Introduction ..................................................................................................... 129\n17.2 Checking Supported ....................................................................................... 129\n17.3 Validating Processor Model Save and Restore ............................................. 130\n17.4 Using Save and Restore in simulation ......................................................... 132\n18 Encapsulating Models for use in other Environments ........................................ 136\n18.1 SystemC .......................................................................................................... 136\n19 Integration with Client Debuggers................................................................. 137\n19.1 Memory Access ............................................................................................. 137\n19.2 Register Query .............................................................................................. 137\n19.3 Register Group Query .................................................................................. 137\n19.4 Mode State Query ......................................................................................... 138\n19.5 Exception State Query .................................................................................. 139\n19.6 Processor Freezing ....................................................................................... 139\n19.7 Address Breakpoints .................................................................................... 140\n19.8 Instruction Count Breakpoints ..................................................................... 140\n19.9 Memory, Bus and Processor Watchpoints .................................................... 140\n19.9.1 Watchpoint Creation and Deletion ......................................................... 141\n19.9.2 Semantics of Physical and Virtual Watchpoints ..................................... 144\n19.9.3 Watchpoint Attribute Query ................................................................. 145\n19.9.4 Handling Triggered Watchpoints ......................................................... 146\n19.10 Handling Simultaneous Debug Events ...................................................... 146\n19.11 Debugger Integration Examples ................................................................. 147\n19.11.1 Multi Processor Debugger Integration Example ................................. 147\n19.11.2 Mode and Exception Debugger Integration Example ......................... 158\n19.12 Scheduler Notification .................................................................................. 162\n1 Preface\n\nThe Imperas simulators can use models described in C or C++ and the models can be exported to be used in simulators and platforms using C, C++, SystemC or SystemC TLM2.\n\nThis document describes detailed information of how the simulator is controlled, how virtual platforms are loaded and simulated, how test benches and harnesses are written.\n\nThis is an advanced user guide.\n\nThis document specifically describes how the OVP OP C API is used in C programs for use with Imperas and OVP virtual platform simulators and tools.\n\n1.1 Notation\n\n<table>\n<thead>\n<tr>\n<th>Code</th>\n<th>Text representing code, a command or output.</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>keyword</td>\n<td>A word with special meaning.</td>\n</tr>\n</tbody>\n</table>\n\n1.2 Related Documentation\n\nThere are several documents available as PDF:\n\nGetting Started\n- Imperas Installation and Getting Started Guide\n\nInterface, API, and iGen related\n- OVP Peripheral Modeling Guide\n- OVPsim Using OVP Models in SystemC TLM2.0 Platforms\n- iGen Model Generator Introduction\n- iGen Platform and Module Creation User Guide\n- Imperas Peripheral Generator Guide (using iGen)\n\nUsage of Modules and Peripherals created using iGen\n- Simulation Control of Platforms and Modules User Guide\n- Advanced Simulation Control of Platforms and Modules User Guide\n\nAlso, in your installation there is also the online OP API Function Reference documentation. This is correct-by-construction Doxygen-like API documentation available at:\n\nIMPERAS_HOME/doc/api/op/html/index.html\n1.3 Glossary / Terminology\n\n**OP API** - OVP Platforms API - C API used for creating and controlling virtual platforms. OP is a 2nd generation API and replaces ICM API. iGen creates modules/platforms in C using this API.\n\n**iGen** - Imperas productivity tool that has a powerful script based function API that is used to create C/C++/SystemC models and templates. Described in the iGen Model Generator Introduction, and for platforms, in the iGen Platform and Module Generator User Guide.\n\n**OVPsim** - Simulator for Open Virtual Platforms that executes platforms and models coded in the OVP APIs\n\n**CpuManager** - Imperas commercial simulator\n\n**Platform / Module** (used interchangeably) - a collection of components connected together into a level of hierarchy in a system to be simulated. This is a program in C/C++ making calls into OP API and normally compiled into a shared object/dynamically linked library and loaded by the simulator at run time.\n\n**Testbench / Harness** - program in C/C++ making calls into OP API to connect and control OVP components. Normally linked to the simulator to provide an .exe binary that can be executed. Used to instantiate one or more platforms/modules and controls their execution. The main difference, from a platform/module, is that a testbench or harness includes a call to the function main(), may include a command line parser and is linked to create an executable binary (.exe) file.\n\n**Root Module** - used to describe the initial platform/module that instantiates one or more platforms/modules and controls their execution. Used in the testbench / harness.\n2 Introduction\n\nImperas simulation technology enables very high performance simulation, debug and analysis of platforms containing multiple processors and peripheral models. The technology is designed to be extensible: you can create your own platforms, new models of processors, and other platform components using interfaces and libraries supplied by Imperas. Platform models developed using this technology can be used both with Imperas simulation products and the freely-available OVPsim platform simulator.\n\nSimulations are controlled by using the provided harness.exe program, or for more sophisticated control, and bespoke harness or test bench is written in C/C++ using the OVP OP API.\n\nThis document explains advanced usage of the OP API to write harnesses / test benches. It explains the structure of modules and the different simulator phases, and how they are controlled.\n\n2.1 Prerequisites\n\nSince harnesses and test benches for use with Imperas and OVP tools are written in C, an important prerequisite is that you must be proficient in the C language. If you want to use C++ then it is expected that you are proficient in the use of C++ and how it uses a C API.\n\nThis document includes usage of iGen which uses the TCL scripting language, so it is beneficial to have some basic understanding of TCL.\n\nThis is the advanced usage guide, so please ensure you have read and worked through Simulation Control of Platforms and Modules User Guide before reading this advanced guide.\n\n2.2 Obtaining & installing the OP API\n\nThe OP API is part of all Imperas / OVP installations and thus you should already have it installed and be ready for use.\n\n2.3 Compiling Examples described in this Document\n\nThe examples use processor and component models and toolchains, available to download from the www.OVPworld.org website or as part of an Imperas installation.\n\nThe compilation of the examples makes use of Makefiles and GNU make. The instructions indicate the use of the command make on Linux systems and MinGW mingw32-make command on Windows systems.\n\nThe Makefiles referred to in this document are written for GNU make. Standard Makefiles supplied by Imperas support compilation and linking using GNU tools on both Windows and Linux.\nExample scripts will be referred to, for example, as *example.sh*. The shell (extension *sh*) script files may be used on Linux and in Windows MSYS shells. The batch (extension *bat*) files may be used in Windows explorer or in a Windows command shell.\n\nSystemC TLM2.0 models can be used on Linux with gcc or on Windows with MinGW/MSys (since SystemC release v2.3.0) or MSVC (Imperas/OVP has been used with version MSVC 8.0). It is assumed that users of this environment will be familiar with SystemC, TLM2.0 and will have obtained this software from www.systemc.org or similar.\n\n### 2.4 Shared Objects and executables\n\nThe shared objects referred to in this document are either Linux shared objects, with suffix `.so` or Windows dynamic link libraries with suffix `.dll`.\n\nThe executables referred to in this document are either Linux or Windows programs and both have the suffix `.exe`.\n\n### 2.5 Platforms, Modules and Shared Objects\n\nModules are created by writing scripts using iGen API calls and then using iGen to generate C code that calls functions from the OP API. A Makefile is provided that will take as input a file *module.op.tcl* and execute iGen and the host compiler and linker to create the *model.so/dll* shared objects.\n\nThe *model.so/dll* shared object can then be loaded and simulated using the *harness.exe* program (provided in the installation binary directory), or by writing a bespoke test harness in C using the OP API.\n\nIn this document we will either use binary modules and components form the Imperas provided library, or we will provide them as source in the example directories.\n3 Tracing the API calls and seeing what is happening\n\nSometime it is not clear what is happening and what order things are happening.\n\nSet the environment variable `IMPERAS_OP_TRACE=1` to turn on tracing of entry to and exit from OP API functions. Output is to the standard output of the console or shell that invokes the simulator.\n\nIn the process of converting some platforms from use of the deprecated ICM API to the OP API we found it very useful to be able to trace the API calls used in platform/module creation.\n4 Detailed OP API Documentation\n\nFor a definition of each function call, macro, and structure that make up the OP API, please refer to the OP function definition documentation that is part of the doxygen generated documentation located as part of an installation at:\n\n```\nIMPERAS_HOME/doc/api/op/html/index.html\n```\n\nFor example:\n\nA good place to start is with the 'Phases and the functions that can be called from them' link. This provides a list of the phases, with links to those API functions that can be used in that phase:\n\n```\nFunctions usable in Constructor Phase\n\nIn the constructor callback or in main()\n```\n\nAnd then clicking on the 'op.h' link shows you detailed documentation on that function:\n5 Structure of Harnesses/Modules & Simulation Phases\n\nThe document Simulation_Control_of_Platforms_and_Modules_User_Guide explained a simple test harness. It includes a `main()` function with several simple sections: command line parser, module instantiation, simulation, and was bounded with a couple of session control calls.\n\n```c\n#include <string.h>\n#include <stdlib.h>\n#include \"op/op.h\"\n\nint main(int argc, const char *argv[]) {\n opSessionInit(OP_VERSION);\n opCmdParseStd (argv[0], OP_AC_ALL, argc, argv);\n optModuleP mi = opRootModuleNew(0, \"top\", 0);\n opModuleNew(mi, \"module\", \"u1\", 0, 0);\n opRootModuleSimulate(mi);\n opSessionTerminate();\n return 0;\n}\n```\n\nIt has a `main()` that makes the calls to the API calls of interest. This was a very simplistic introduction to the power and possibilities that are possible with the OP API related to test benches and harnesses to control simulation.\n\n5.1 A little more complete test harness\n\nIn the `Example/SimulationControl/minimalHarness`, we saw a really minimal harness, now we will look at one that has placeholders for all the full capabilities that are available. Subsequent examples will add code into these placeholders.\n\n```bash\n> cp -r $IMPERAS_HOME/Examples/SimulationControl/simpleHarness .\n> cd simpleHarness\n> ls\napplication harness module\n```\n\nAgain we see the application and module directories. We discussed those previously. They have not changed in this example. We will focus on the harness code.\nLooking at `harness/harness.c` we see there are several callbacks with some being empty. Being empty at this stage they are just 'placeholders' for us to put code in later.\n\nThese callbacks are defined using macros, are also defined in the `modelAttrs` table, and are called at different stages of the simulation process.\n\nFor example:\n\n```c\nOP_CONSTRUCT_FN(static OP_CONSTRUCT_FN(moduleConstruct) {\n```\n\ndeclares a function `moduleConstruct` that will be called by the simulator in the phase of constructing all the modules.\n\nThe simulator has five main phases:\n- Construction\n- Pre Simulation\n- Simulation\n- Post Simulation\n- Destruction\n\n5.1.1 Constructor - moduleConstruct\n\nIn the `OP_CONSTRUCT_FN(moduleConstruct)` callback function declaration we instance the design to be simulated. In this example it is a single module instance:\n\n```c\nstatic OP_CONSTRUCT_FN(moduleConstruct) {\n const char *u1_path = \"module\";\n opModuleNew(\n mi, // parent module\n u1_path, // modelfile\n \"u1\", // name\n 0,\n 0\n );\n}\n```\n\nThe constructor call back function is the only *mandatory* callback function and it constructs the structural contents of this harness including creation of component instances, buses, nets etc. and connection to components\n\n5.1.2 Command Line Parsing - cmdParser\n\nThere is then the declaration of a function we can edit that will process the command line arguments. It is here will put any processing that is specific for our design / test bench.\n\n```c\nstatic void cmdParser(optCmdParserP parser) {\n```\nThe OP standard parser gives a consistent method of parsing standard data types, but also allows the user to specify any of the rich set of options accepted by the simulator. Please refer to the OVP Control File User Guide to see the standard options.\n\n### 5.1.3 Local module persistent data - optModuleObject\n\nOften we will need to hold local data for our testbench that can be called at different times in the simulation. This is in the optModuleObject structure.\n\n```c\ntypedef struct optModuleObjectS {\n // insert module persistent data here\n} optModuleObject;\n```\n\n### 5.1.4 Initialization - modulePreSimulate\n\nThis is followed by several more declarations of callback functions. You can put bespoke code into these callbacks knowing that they will be called at the appropriate times or phases of the simulation.\n\n```c\nstatic OP_PRE_SIMULATE_FN(modulePreSimulate) {\n // insert modulePreSimulate code here\n}\n```\n\nThe `OP_PRE_SIMULATE_FN(modulePreSimulate)` callback function is called when simulation is about to begin.\n\n### 5.1.5 Simulation - moduleSimulate\n\n```c\nstatic OP_SIMULATE_STARTING_FN(moduleSimulate) {\n // insert moduleSimulate code here\n}\n```\n\nGets called every time `opRootModuleSimulate()` is called. Called every time the simulator starts simulating.\n\n### 5.1.6 Reporting - modulePostSimulate\n\n```c\nstatic OP_POST_SIMULATE_FN(modulePostSimulate) {\n // insert modulePostSimulate code here\n}\n```\n\nCalled when simulation has finished, but before any destructors are called.\n5.1.7 Destructor - moduleDestruct\n\nstatic OP_DESTRUCT_FN(moduleDestruct) {\n // insert moduleDestruct code here\n}\n\nIf required, code to close files, free memory etc.\n\n5.1.8 modelAttrs table\n\nA complete modelAttrs table is:\n\n```c\noptModuleAttr modelAttrs = {\n .versionString = OP_VERSION,\n .type = OP_MODULE,\n .name = MODULE_NAME,\n .objectSize = sizeof(optModuleObject),\n .releaseStatus = OP_UNSET,\n .purpose = OP_PP_BAREMETAL,\n .visibility = OP_VISIBLE,\n .constructCB = moduleConstruct,\n .preSimulateCB = modulePreSimulate,\n .simulateCB = moduleSimulate,\n .postSimulateCB = modulePostSimulate,\n .destructCB = moduleDestruct,\n};\n```\n\nIt defines this module and provides the relevant data and pointers that are needed. Some items like versionString, type, releaseStatus, purpose, visibility should be accepted and left alone.\n\nThe others are only required if they are being used in your module. There is no performance issue in just leaving them as above. The simulator looks up the modelAttrs table to find which callbacks are defined and then calls them as it needs to.\n\n5.1.9 The main() program\n\nLastly, by convention at the bottom of the file, the main() program entry point:\n\n```c\nint main(int argc, const char *argv[]) {\n opSessionInit(OP_VERSION);\n```\n5.1.10 Complete harness code\n\nThe complete harness is:\n\n```c\n#include <string.h>\n#include <stdlib.h>\n#include \"op/op.h\"\n\n#define MODULE_NAME \"top\"\n\nstruct optionsS {\n} options = {\n};\n\nstatic OP_CONSTRUCT_FN(moduleConstruct) {\n const char *u1_path = \"module\";\n opModuleNew(\n mi, // parent module\n u1_path, // modelfile\n \"u1\", // name\n 0,\n 0\n );\n}\n\nstatic void cmdParser(optCmdParserP parser) {\n}\n\ntypedef struct optModuleObjectS {\n // insert module persistent data here\n} optModuleObject;\n```\nstatic OP_PRE_SIMULATE_FN(modulePreSimulate) {\n // insert modulePreSimulate code here\n}\n\nstatic OP_SIMULATE_STARTING_FN(moduleSimulate) {\n // insert moduleSimulate code here\n}\n\nstatic OP_POST_SIMULATE_FN(modulePostSimulate) {\n // insert modulePostSimulate code here\n}\n\nstatic OP_DESTRUCT_FN(moduleDestruct) {\n // insert moduleDestruct code here\n}\n\noptModuleAttr modelAttrs = {\n .versionString = OP_VERSION,\n .type = OP_MODULE,\n .name = MODULE_NAME,\n .objectSize = sizeof(optModuleObject),\n .releaseStatus = OP_UNSET,\n .purpose = OP_PP_BAREMETAL,\n .visibility = OP_VISIBLE,\n .constructCB = moduleConstruct,\n .preSimulateCB = modulePreSimulate,\n .simulateCB = moduleSimulate,\n .postSimulateCB = modulePostSimulate,\n .destructCB = moduleDestruct,\n};\n\nint main(int argc, const char *argv[]) {\n opSessionInit(OP_VERSION);\n optCmdParserP parser = opCmdParserNew(MODULE_NAME, OP_AC_ALL);\n cmdParser(parser);\n opCmdParseArgs(parser, argc, argv);\n optModuleP mi = opRootModuleNew(&modelAttrs, MODULE_NAME, 0);\n opRootModuleSimulate(mi);\n opSessionTerminate();\n return 0;\n}\n\n5.2 Order of Platform construction\n\nIn the above section we saw that a harness can have several callbacks defined in the modelAttrs table. These callbacks are called at different phases of the simulation.\nFor a test bench this might seem like overkill to specify different phases and callbacks.\n\nThis approach comes into its own when you realize that in fact all modules can have callbacks and that all callbacks of one type are called in one phase. Thus all construction callbacks from all modules are called before all pre-simulate callbacks etc. This allows extremely sophisticated and complex platforms to be model relatively easily.\n\nThis section summarizes the operation of a hierarchical platform.\n\n- Host computer calls the program entry point: main\n - start opSessionInit\n - construct a command line parser opCmdParserNew, opCmdParserAdd (with added arguments) or use the standard command line parser opCmdParseArgs\n - create instance of root module opRootModuleNew\n - call the constructor moduleConstruct\n - create instance of the design opModuleNew\n - call parameter iterator\n - call interface iterators\n - call module constructor moduleConstruct\n - create model instances opProcessorNew\n - create module instances opModuleNew\n - run the simulator opRootModuleSimulate (maybe more than once)\n - call pre-simulate functions in all modules (first time only)\n - run the simulator\n - finish opSessionTerminate\n - call post-simulation functions for all modules\n - call destructors\n\nHigher-level modules are constructed before lower modules.\n\nLeaf components (processors, memories etc) can be created at any level.\n\nA module can instance itself (so long as there is code to prevent infinite recursion).\n\nThe simulator can determine the interface to a module without constructing it.\n6 Modules revisited (using the OP API and C)\n\nIn the document *iGen Platform and Module Creation User Guide* we saw the creation of modules using iGen from a tcl script input. When iGen is run on a `module.op.tcl` for the first time it creates two main files:\n\n- **module.c** file - this is the code you can edit\n- **module.igen.h** - this is code you should not edit - it is the structure of the module and will be generated each time from the `module.op.tcl` iGen run\n\nthere is also a file\n\n- **module.c.igen.stubs** - this is a template of `module.c` - this is written each time, and is used for comparison purposes - you can ignore it for now\n\n### 6.1 A module in C with all user callbacks\n\nLet’s look at the process of running iGen on a module and look at the generated C:\n\n```\n> cd Examples/SimulationControl/simpleHarness/module\n> cat module.op.tcl\n\nihwnew -name simpleCpuMemory\n\nihwaddbus -instancename mainBus -addresswidth 32\n\nihwaddprocessor -instancename cpu1 -vendor ovpworld.org -library processor -type or1k -version 1.0 -semihostname or1kNewlib -variant generic\n\nihwconnect -bus mainBus -instancename cpu1 -busmasterport INSTRUCTION\n\nihwconnect -bus mainBus -instancename cpu1 -busmasterport DATA\n\nihwaddmemory -instancename ram1 -type ram\n\nihwconnect -bus mainBus -instancename ram1 -busslaveport sp1 -loaddress 0x0 -hiaddress 0xffffffff\n```\n\n```\n> make\n# iGen Create OP MODULE module\n# Host Compiling Module obj/Linux32/module.o\n# Host Linking Module object model.so\n```\n\nand let’s look at the generated C files, first the one defining the structure that we don't edit:\n\n```\n> cat module.igen.h\n\n#define MODULE_NAME \"simpleCpuMemory\"\n\nstatic OP_CONSTRUCT_FN(moduleConstruct) {\n\n // Bus mainBus\n\n```\noptBusP mainBus_b = opBusNew(mi, \"mainBus\", 32, 0, 0);\n\n// Processor cpu1\n\nconst char *cpu1_path = opVLNVString(\n 0, // use the default VLNV path\n \"ovpworld.org\",\n \"processor\",\n \"or1k\",\n \"1.0\",\n OP_PROCESSOR,\n 1 // report errors\n);\n\noptProcessorP cpu1_c = opProcessorNew(\n mi,\n cpu1_path,\n \"cpu1\",\n OP_CONNECTIONS(\n OP_BUS_CONNECTIONS(\n OP_BUS_CONNECT(mainBus_b, \"INSTRUCTION\"),\n OP_BUS_CONNECT(mainBus_b, \"DATA\")\n ),\n OP_PARAMS(\n OP_PARAM_STRING_SET(\"variant\", \"generic\")\n )\n );\n\nconst char *or1kNewlib_0_expath = opVLNVString(\n 0, // use the default VLNV path\n 0,\n 0,\n \"or1kNewlib\",\n 0,\n OP_EXTENSION,\n 1 // report errors\n);\n\nopProcessorExtensionNew(\n cpu1_c,\n or1kNewlib_0_expath,\n \"or1kNewlib_0\",\n0\n); \n\n// Memory ram1\n\nopMemoryNew(mi,\n \"ram1\",\n OP_PRIV_RWX,\n (0xffffffff) - (0x0),\n OP_CONNECTIONS(\n OP_BUS_CONNECTIONS(\n OP_BUS_CONNECT(mainBus_b, \"sp1\", .slave=1,\n .addrLo=0x0, .addrHi=0xffffffff)\n ),\n 0\n );\n}\n\noptModuleAttr modelAttrs = {\n .versionString = OP_VERSION,\n .type = OP_MODULE,\n .name = MODULE_NAME,\n .objectSize = sizeof(optModuleObject),\n .releaseStatus = OP_UNSET,\n .purpose = OP_PP_BAREMETAL,\n .visibility = OP_VISIBLE,\n .constructCB = moduleConstruct,\n .preSimulateCB = modulePreSimulate,\n .simulateCB = moduleSimulate,\n .postSimulateCB = modulePostSimulate,\n .destructCB = moduleDestruct,\n};\n\nand then look at the module.c file we can edit:\n\n> cat module.c\n\n#include <string.h>\n#include <stdlib.h>\n#include \"op/op.h\"\n\n#include \"op/op.h\"\ntypedef struct optModuleObjectS {\n // insert module persistent data here\n} optModuleObject;\n\nhashtags USER FUNCTIONS hashtags\n\nstatic OP_PRE_SIMULATE_FN(modulePreSimulate) {\n // insert modulePreSimulate code here\n}\n\nstatic OP_SIMULATE_STARTING_FN(moduleSimulate) {\n // insert moduleSimulate code here\n}\n\nstatic OP_POST_SIMULATE_FN(modulePostSimulate) {\n // insert modulePostSimulate code here\n}\n\nstatic OP_DESTRUCT_FN(moduleDestruct) {\n // insert moduleDestruct code here\n}\n\n#include \"module.igen.h\"\n\nWe can see it is just the placeholders of the callbacks and then it includes the iGen generated constructor code we don't edit.\n\n6.2 Simple C module\n\nAbove we saw a module with all its callbacks, modelAttrs etc.\n\nIt is possible to write more simplistic modules with just a main(), in the same way that the Examples/SimulationControl/minimalHarness was structured, just creating instances of buses, memories, processors etc.\n\nUnless there is a specific reason, our suggestion is\n a) use iGen from module.op.tcl, and then\n b) if you need to, edit only the generated module.c file.\n7 Adding C code to a module\n\nIn this chapter we will create a module using a tcl iGen script, and then edit the C to add some specific C code to add some behaviors that are not possible to add using iGen from tcl.\n\nThere will be examples of adding a monitor to detect changes on nets, adding watchpoints to see memory accesses, and adding behavior using C.\n\n7.1 Monitoring nets\n\nMonitoring nets from C code in the modules will be shown using the following example:\n\nExamples\\SimulationControl\\monitoringNetsInModule\n\nIt is a copy of:\n\nPlatformConstruction/simpleCpuMemoryUart\n\nWhich creates a module using iGen from tcl, and has a simple application that writes to a UART and logs the output to a file. It also has two nets that the UART can configure to use. There is no need for our own C harness, so we use the provided harness.exe.\n\nSo let’s follow the process we used:\n\n> cp Examples\\ PlatformConstruction/simpleCpuMemoryUart .\n\nand run:\n\n./example.sh\n\nInitializing KinetisUART\nWriting to uart.\n\nand then see the output:\n\n> cat uartTTY0.log\nHello UART0 world\n\nSo now let’s make some very simple changes in module.c. First add the call back declaration:\n\nstatic OP_NET_WRITE_FN(netCallback) {\n optNetP net = userData;\n opPrintf(\"netCallback(%s) = %c\\n\", opObjectName(net), value);\n}\nand in the pre-simulate callback add our callback on all nets in the module:\n\n```c\nstatic OP_PRE_SIMULATE_FN(modulePreSimulate) {\n // set up net monitoring\n optNetP net = 0;\n while ((net = opNetNext(mi, net))) {\n opPrintf(\"monitorNets(%s)\\n\", opObjectHierName(net));\n opNetWriteMonitorAdd(net, netCallback, net);\n }\n\n // and put UART into 'using nets' mode, using local hierarchical path\n opParamBoolOverride(mi, \"periph0/directReadWrite\", 1);\n}\n```\n\nNOTE that we have to set the periph0/directReadWrite parameter of the UART, or we get the callbacks registered, but it just writes to the logfile and not the nets.\n\nand then we get:\n\n```\n./example.sh\nOVPsim started: Wed Jan 13 15:35:10 2016\n\nmonitorNets(harness/simpleCpuMemoryUart/directWrite)\nmonitorNets(harness/simpleCpuMemoryUart/directRead)\nInitializing KinetisUART\nWriting to uart.\n\nnetCallback(directWrite) = H\nnetCallback(directWrite) = e\nnetCallback(directWrite) = l\nnetCallback(directWrite) = l\nnetCallback(directWrite) = o\nnetCallback(directWrite) = U\nnetCallback(directWrite) = A\nnetCallback(directWrite) = R\nnetCallback(directWrite) = T\nnetCallback(directWrite) = 0\nnetCallback(directWrite) = w\nnetCallback(directWrite) = o\nnetCallback(directWrite) = r\nnetCallback(directWrite) = l\n```\n7.2 Listing of C code for module monitoring its nets\n\n```c\n#include <string.h>\n#include <stdlib.h>\n#include \"op/op.h\"\n\ntypedef struct optModuleObjectS {\n // insert module persistent data here\n} optModuleObject;\n\nstatic OP_NET_WRITE_FN(netCallback) {\n optNetP net = userData;\n opPrintf(\"netCallback(%s) = %c\\n\", opObjectName(net), value);\n}\n\n// USER FUNCTIONS\nstatic OP_PRE_SIMULATE_FN(modulePreSimulate) {\n // set up net monitoring\n optNetP net = 0;\n while ((net = opNetNext(mi, net))) {\n opPrintf(\"monitorNets(%s)\\n\", opObjectHierName(net));\n opNetWriteMonitorAdd(net, netCallback, net);\n }\n\n // and put UART into 'using nets' mode, using local hierarchical path\n opParamBoolOverride(mi, \"periph0/directReadWrite\", 1);\n}\n\nstatic OP_SIMULATE_STARTING_FN(moduleSimulate) {\n // insert moduleSimulate code here\n}\n\nstatic OP_POST_SIMULATE_FN(modulePostSimulate) {\n // insert modulePostSimulate code here\n}\n\nstatic OP_DESTRUCT_FN(moduleDestruct) {\n // insert moduleDestruct code here\n}\n\n#include \"module.igen.h\"\n```\n7.3 Monitoring Memory locations and Buses using callbacks\n\nA previous example Examples/SimulationControl/monitoringMemory/harness added monitoring for memory and buses into the harness.\n\nTo add this code to a module is very simple. We have created an example in Examples/SimulationControl/monitoringMemoryInModule and then copied in the relevant code from monitoringMemory/harness/harness.c into module/module.c with very few changes.\n\nThe code in SimulationControl/monitoringMemoryInModule/module/module.c now looks like:\n\n```c\n#include <string.h>\n#include <stdlib.h>\n#include \"op/op.h\"\n\ntypedef struct optModuleObjectS {\n // insert module persistent data here\n UnS32 count;\n} optModuleObject;\n\n#define PREFIX \"BUS_MON\"\n#define MIN_ADDRESS 0x0\n#define MAX_ADDRESS 0xffffffff\n\n// triggered when registered access happens and prints information of access\nstatic OP_MONITOR_FN(monitorCallback) {\n opMessage(\"I\", PREFIX \"_MT\", \"Monitor triggered: \":\n \"callback '%s': processor '%s': \"\n \"type '%s': bytes %u: \"\n \"address Physical 0x\" FMT_A0Nx \" Virtual 0x\" FMT_A0Nx,\n FUNCTION_,\n processor ? opObjectName(processor) : \"artifact\", // if no processor this is an artifact access\n (const char*)userData,\n bytes,\n addr,\n VA);\n}\n\n// iterate across the buses found in the module and register callbacks\n// for read, write and fetch\nstatic void monitorBus(optModuleP mi) {\n // iterate across all busses found in module\n optBusP bus = 0;\n while ((bus = opBusNext(mi, bus))) {\n Addr max = MAX_ADDRESS; // TODO: should be call to opBusMaxAddress(bus);\n opMessage(\"I\", PREFIX \"_BM\", \"Add monitor for '%s' (0x\" FMT_A0Nx \" to 0x\" FMT_A0Nx \")\", \"a\",\n```\nopObjectHierName(bus), (Addr)0, max);\n opBusFetchMonitorAdd(bus, 0, MIN_ADDRESS, max, monitorCallback, \"bus-fetch\");\n opBusReadMonitorAdd (bus, 0, MIN_ADDRESS, max, monitorCallback, \"bus-read\");\n opBusWriteMonitorAdd(bus, 0, MIN_ADDRESS, max, monitorCallback, \"bus-write\");\n}\n}\n\n// iterate across the memories found in the module and register callbacks for read, write and fetch\n//\nstatic void monitorMemory(optModuleP mi) {\n // iterate across all memories found in module\n optMemoryP memory = 0;\n while ((memory = opMemoryNext(mi, memory))) {\n Addr max = opMemoryMaxAddress(memory);\n opMessage(\"I\", PREFIX \"_BM\", \"Add monitor for '\" opObjectHierName(memory) \"\" (0x\" FMT_A0Nx \" to 0x\" FMT_A0Nx \" )\\n\", (Addr)0, max);\n opMemoryFetchMonitorAdd(memory, 0, MIN_ADDRESS, max, monitorCallback, \"memory-fetch\");\n opMemoryReadMonitorAdd (memory, 0, MIN_ADDRESS, max, monitorCallback, \"memory-read\");\n opMemoryWriteMonitorAdd(memory, 0, MIN_ADDRESS, max, monitorCallback, \"memory-write\");\n }\n}\n\nstatic OP_PRE_SIMULATE_FN(modulePreSimulate) {\n // insert modulePreSimulate code here\n // Setup bus monitors\n monitorBus(mi);\n // Setup memory monitors\n monitorMemory(mi);\n}\n\nstatic OP_SIMULATE_STARTING_FN(moduleSimulateStart) {\n // insert moduleSimulate code here\n}\n\nstatic OP_POST_SIMULATE_FN(modulePostSimulate) {\n // insert modulePostSimulate code here\n}\n\nstatic OP_DESTRUCT_FN(moduleDestruct) {\n // insert moduleDestruct code here\n}\n\n#include \"module.igen.h\"\n\nNote the use of the module instance 'mi' in the two iterators:\n\n```c\nwhile ((bus = opBusNext(mi, bus))) {\n```\n\n```c\nwhile ((memory = opMemoryNext(mi, memory))) {\n```\n\nAnd when it is run we get:\n\n```\n> ./example.sh\n```\n\n```\n\nInfo (BUS_MON_BM) Add monitor for 'harness/simpleCpuMemory/mainBus' (0x0000000000000000 to 0xffffffff)\n```\n7.4 Adding behavioral C code in modules\n\nThe examples above showed the use of C code to monitor objects in a module.\n\nIn this very small example there is a small amount of behavioral C code in the middle of the module. It reads a net value and writes it to another net inverted. Yes a behavioral not gate...\n\n> cp -r Examples/SimulationControl/behavioralCcodeInModule .\n\nThere is no harness for this example, we will use the provided harness.exe.\n\n7.4.1 A mixed TCL and C module\n\nThere is a simple module with net in, net out and some C code, and harness that instantiates it.\nNet Hierarchy and use of behavioral C code in module\n\nThe module is created from two files:\n- `module/module.op.tcl` - the structural definition of the module\n- `module/module.c` - the C code that is called by the structural code\n\nThe iGen tcl input script should need no discussion:\n\n```\n> cat module/module.op.tcl\nihwnew -name module\n\nihwaddnet -instancename netIn\nihwaddnet -instancename netOut\n\nihwaddnetport -instancename slavePort\nihwaddnetport -instancename masterPort\n\nihwconnect -netport slavePort -net netIn\nihwconnect -netport masterPort -net netOut\n```\n\nWe initially wrote the `module.op.tcl`, and then ran `make -C module` and this generated the initial copy of `module.c`, which now it exists, the make system will not overwrite so it is safe for us to edit and change.\n\nThe C code we write in `module/module.c` needs a little explanation. Let’s first look at it in its entirety, and then explain each section:\n\n```\n> cat module/module.c\n\n#include <assert.h>\n#include <string.h>\n#include <stdlib.h>\n#include \"op/op.h\"\n```\n\ntypedef struct optModuleObjectS {\n // insert module persistent data here\n optNetP netIn;\n optNetP netOut;\n} optModuleObject;\n\n// This function is called when the input net is written\n// It writes the same value to the output net\n//\nstatic OP_NET_WRITE_FN(netCallback) {\n optModuleObjectP object = userData;\n\n Uns32 newValue = (value) ? 0 : 1;\n opPrintf(FMT_TIME \" : sub_netCallback: \\%s = \\%u\\n\",\n opModuleCurrentTime(opObjectRootModule(object->netOut)),\n opObjectHierName(object->netOut), newValue);\n\n opNetWrite(object->netOut, newValue);\n}\n\nstatic OP_PRE_SIMULATE_FN(modulePreSimulate) {\n // Get handles to the two nets\n //\n opPrintf(\"modulePreSimulate: \\%s setting up callback on netIn\\n\",\n opObjectHierName(mi));\n\n object->netIn = opObjectByName(mi, \"netIn\", OP_NET_EN).Net;\n object->netOut = opObjectByName(mi, \"netOut\").Net;\n assert(object->netIn != NULL && object->netOut != NULL);\n\n opNetWriteMonitorAdd(object->netIn, netCallback, object);\n\n opPrintf(\"modulePreSimulate: \\%s done\\n\", opObjectHierName(mi));\n}\n\nstatic OP_SIMULATE_STARTING_FN(moduleSimulate) {\n // insert moduleSimulate code here\n}\n\nstatic OP_POST_SIMULATE_FN(modulePostSimulate) {\n // insert modulePostSimulate code here\n}\nstatic OP_DESTRUCT_FN(moduleDestruct) {\n// insert moduleDestruct code here\n}\n\n#include \"module.igen.h\"\n\nThe declaration of:\n\ntypedef struct optModuleObjectS {\n optNetP netIn;\n optNetP netOut;\n} optModuleObject;\n\nis declaring module persistent variables to hold references to the nets in the harness.\n\nThe declaration of the pre-simulate callback:\n\nstatic OP_PRE_SIMULATE_FN(modulePreSimulate) {\n\nobtains handles to the nets and saves them in the module persistent data\n\n object->netIn = opObjectByName(mi, \"netIn\", OP_NET_EN).Net;\n object->netOut = opObjectByName(mi, \"netOut\", OP_NET_EN).Net;\n assert(object->netIn != NULL && object->netOut != NULL);\n\nNote the use of assert. This is to check that we have got the correct names of our nets. We don't want to change them in the module.op.tcl and forget to update the C. The good thing about assert is it tells us file and line numbers so it is easy to see what has gone wrong;\n\nAnd then we need to register the netCallback function to be called back when the object->netIn is written to. This is a net callback and will be triggered when the net is written to:\n\n opNetWriteMonitorAdd(object->netIn, netCallback, object);\n\nThe 3rd argument is passing the object in so that when the callback is called it has access to the module persistent data, in this case the handles to the nets.\n\nThe definition of the netCallback is where we write some behavior:\n\nstatic OP_NET_WRITE_FN(netCallback) {\n optModuleObjectP object = userData;\n Uns32 newValue = (value) ? 0 : 1;\nThe callback is defined using a macro that provides several variables for our use. \n\n- `userData` is the 3rd argument of the call that registers the callback \n- `value` is the value being written to the net \n\nWith:\n\n```\nUns32 newValue = (value) ? 0 : 1;\n```\n\nwe are creating a simple inverter or not gate function.\n\nAnd:\n\n```\nopNetWrite(object->netOut, newValue);\n```\n\nwrites the new value to the output net.\n\nNote that the call back was registered on the input net.\n\n```\nopNetWriteMonitorAdd(object->netIn, netCallback, object);\n```\n\nThen there are the declarations of the other user callback functions - and these are left as doing nothing.\n\nThis is compiled with the normal make command:\n\n```\n> make -C module\n# Igen Create OP MODULE module\n# Host Depending obj/Linux32/module.d\n# Host Compiling Module obj/Linux32/module.o\n# Host Linking Module object model.so\n```\n\n### 7.4.2 Advancing time and writing nets in a harness\n\nThe harness has in it a main() which creates the top module and an instance of our submodule. It then calls a function we have written to monitor the nets, and a function to control the simulation:\n\n```\nint main(int argc, const char *argv[]) {\n...\n optModuleP mi = opRootModuleNew(0, \"top\", 0);\n constructModule(mi);\n```\nmonitorNets(mi);\n\nopRootModulePreSimulate(mi);\nsimulate(mi);\n...\n}\n\nThe `constructModule` creates the sub module instance:\n\noptNetP topNetDrive;\noptNetP topNetRecv;\n...\nstatic void constructModule(optModuleP mi) {\n topNetDrive = opNetNew(mi, \"topNetDrive\", 0, 0);\n topNetRecv = opNetNew(mi, \"topNetRecv\", 0, 0);\n\n opModuleNew(\n mi, // parent module\n \"module/model\", // modelfile\n \"u1\", // name\n OP_CONNECTIONS(\n OP_NET_CONNECTIONS(\n OP_NET_CONNECT(topNetDrive, \"slavePort\"),\n OP_NET_CONNECT(topNetRecv, \"masterPort\")\n ),\n 0\n );\n }\n}\n\nNoting that it creates two global nets (topNetDrive, topNetRecv), and then connects them up to the slave and master ports of the module. The sub module file will be located at: `module/model`.\n\nAs in other examples, in this harness we are going to register a callback on the output net to see any writes to it:\n\nstatic void monitorNets(optModuleP mi) {\n opPrintf(\"monitorNets: %s setting up callback on nets\\n\", opObjectHierName(mi));\n\n assert(topNetDrive != NULL && topNetRecv != NULL);\n\n opNetWriteMonitorAdd(topNetRecv, netCallback, topNetRecv);\n\n opPrintf(\"monitorNets: %s : done\\n\", opObjectHierName(mi));\nNote the use of `assert`:\n\n```c\nassert(topNetDrive != NULL && topNetRecv != NULL);\n```\n\nThis is to check that we have in fact located the nets in our global persistent data.\n\nWe are registering a call back on the net `topNetRecv` being written to and when it is, we want our function, `netCallback` to be called. We will pass in the handle of the net that has changed (`topNetRecv`).\n\nAnd when the net is written to, our function:\n\n```c\nstatic OP_NET_WRITE_FN(netCallback) {\n optNetP net = userData;\n opPrintf(FMT_TIME\": top_netCallback: %s = %d\n\",\n opModuleCurrentTime(opObjectRootModule(net)),\n opObjectHierName(net), value);\n}\n```\n\nwill be called. It just writes out that the net was written to, and its new value, and the time of the write.\n\nAll that remains is to have some stimulus in our harness. This is in our simulate function:\n\n```c\nstatic void simulate(optModuleP mi) {\n opPrintf(\"\\n\");\n opPrintf(FMT_TIME\": simulate: %s starting\\n\",\n opModuleCurrentTime(mi), opObjectHierName(mi));\n opRootModuleSetSimulationStopTime(mi, 0.001);\n opRootModuleSimulate(mi);\n opPrintf(\"\\n\");\n opPrintf(FMT_TIME\": simulate: %s writing 0\\n\",\n opModuleCurrentTime(mi), opObjectHierName(topNetDrive));\n opNetWrite(topNetDrive, 0);\n opRootModuleSetSimulationStopTime(mi, 0.002);\n opRootModuleSimulate(mi);\n opPrintf(\"\\n\");\n opPrintf(FMT_TIME\": simulate: %s writing 1\\n\",\n opModuleCurrentTime(mi), opObjectHierName(topNetDrive));\n opNetWrite(topNetDrive, 1);\n opRootModuleSetSimulationStopTime(mi, 0.003);\n```\nAdvanced Simulation Control of Platforms and Modules User Guide\n\n```c\nopRootModuleSimulate(mi);\nopPrintf(\"\\n\");\nopPrintf(FMT_TIME \": simulate: %s done\\n\\n\",\n opModuleCurrentTime(mi), opObjectHierName(mi));\n}\n```\n\nthe key bit is:\n\n```c\nopRootModuleSetSimulationStopTime(mi, 0.001) ;\nopRootModuleSimulate(mi);\n...\nopNetWrite(topNetDrive, 0);\n```\n\nwhich sets a time in the future at which the simulator should stop and then, when stopped (return from opRootModuleSimulate), write to the net.\n\nIn other words:\n\n```\nrun\nset value\nrun\nset value\n...\n```\n\ni.e. very simple stimulus.\n\n### 7.4.2.1 The full harness listing\n\n```bash\n> cat harness/harness.c\n```\n\n```c\n#include <assert.h>\n#include <string.h>\n#include <stdlib.h>\n#include \"op/op.h\"\n\noptNetP topNetDrive;\noptNetP topNetRecv;\n\nstatic OP_NET_WRITE_FN(netCallback) {\n optNetP net = userData;\n opPrintf(FMT_TIME \": top_netCallback: %s = %d\\n\",\n opModuleCurrentTime(opObjectRootModule(net)),\n opObjectHierName(net), value);\n}\n\nstatic void monitorNets(optModuleP mi) {\n```\nopPrintf(\"monitorNets: %s setting up callback on nets\\n\",\n opObjectHierName(mi));\n\nassert(topNetDrive != NULL && topNetRecv != NULL);\n\nopNetWriteMonitorAdd(topNetRecv, netCallback, topNetRecv);\n\nopPrintf(\"monitorNets: %s : done\\n\", opObjectHierName(mi));\n}\n\nstatic void constructModule(optModuleP mi) {\n topNetDrive = opNetNew(mi, \"topNetDrive\", 0, 0);\n topNetRecv = opNetNew(mi, \"topNetRecv\", 0, 0);\n\n opModuleNew(\n mi, // parent module\n \"module/model\", // modelfile\n \"u1\", // name\n OP_CONNECTIONS(\n OP_NET_CONNECTIONS(\n OP_NET_CONNECT(topNetDrive, \"slavePort\"),\n OP_NET_CONNECT(topNetRecv, \"masterPort\")\n ),\n 0\n );\n }\n\nstatic void simulate(optModuleP mi) {\n opPrintf(\"\\n\");\n opPrintf(FMT_TIME \": simulate: %s starting\\n\",\n opModuleCurrentTime(mi), opObjectHierName(mi));\n\n opRootModuleSetSimulationStopTime(mi, 0.001) ;\n opRootModuleSimulate(mi);\n opPrintf(\"\\n\");\n opPrintf(FMT_TIME \": simulate: %s writing 0\\n\",\n opModuleCurrentTime(mi), opObjectHierName(topNetDrive));\n opNetWrite(topNetDrive, 0);\n\n opRootModuleSetSimulationStopTime(mi, 0.002); \n opRootModuleSimulate(mi);\n opPrintf(\"\\n\");\n opPrintf(FMT_TIME \": simulate: %s writing 1\\n\",\n opModuleCurrentTime(mi), opObjectHierName(topNetDrive));\n opNetWrite(topNetDrive, 1);\nopRootModuleSetSimulationStopTime(mi, 0.003);\nopRootModuleSimulate(mi);\n\nopPrintf(\"\\n\");\nopPrintf(FMT_TIME \": simulate: %s done\\n\\n\",\n opModuleCurrentTime(mi), opObjectHierName(mi));\n}\n\nint main(int argc, const char *argv[]) {\n opSessionInit(OP_VERSION);\n \nopCmdParseStd (argv[0], OP_AC_ALL, argc, argv);\n \n optModuleP mi = opRootModuleNew(0, \"top\", 0);\n constructModule(mi);\n \n monitorNets(mi);\n opRootModulePreSimulate(mi);\n simulate(mi);\n opSessionTerminate();\n return 0;\n}\n\n7.4.3 Running the simulation\n\n> ./example.sh\n...\nOVPsim started: Thu Jan 14 15:01:23 2016\n\nmonitorNets: top setting up callback on nets\nmonitorNets: top : done\nmodulePreSimulate: top/u1 setting up callback on netIn\nmodulePreSimulate: top/u1 done\n\n0: simulate: top starting\n\n0.001: simulate: top/topNetDrive writing 0\n0.001: sub_netCallback: top/u1/netOut = 1\n0.001: top_netCallback: top/topNetRecv = 1\n\n0.002: simulate: top/topNetDrive writing 1\n0.002: sub_netCallback: top/u1/netOut = 0\n0.002: top_netCallback: top/topNetRecv = 0\n0.003: simulate: top done\n\nOVPsim finished: Thu Jan 14 15:01:23 2016\n8 Using Hierarchical Connections\n\nWhen hierarchy is used there are specific connection types that can be made between the different levels. These can be a bus, a FIFO, a net or a packetnet. The following examples show the use of each.\n\n8.1 Bus\n\nThere is an example provided as Examples/PlatformConstruction/busHierarchy that shows the connection of busses between levels of hierarchy.\n\nThis example contains a simple module that has a two bus ports connected by a bridge. The bridge maps an address range on the input (slave) port from 0x10000000 to 0x10001fff to an address range on the output (master) port from 0x00000000 to 0x00001fff. So, for example, an access at 0x10000004 will be translated to an access at 0x00000004.\n\n```\nstatic OP_BUS_SLAVE_READ_FN(readCallback) {\n const char *bus = userData;\n opPrintf(\"readCallback: %s, \" FMT_Ax \"\\n\", bus, addr);\n}\n\nstatic OP_BUS_SLAVE_WRITE_FN(writeCallback) {\n const char *bus = userData;\n opPrintf(\"writeCallback: %s, \" FMT_Ax \"\\n\", bus, addr);\n}\n```\n\nThe module is instanced in a test harness and the bus connections from the module are connected to buses instanced in the harness. Monitors are added to the bus to detect read or write accesses on the buses.\nchar *busName = \"topBusS\";\noptBusP bus = opObjectByName(mi, busName, OP_BUS_EN).Bus;\nopBusSlaveNew(bus, \"all\", 0, OP_PRIV_RWX, 0, 0xffffffff,\n readCallback, writeCallback, 0, busName);\n\nThe harness performs bus read/writes accesses on the bus to test the connections. These will be debug artifact accesses, as there is no processor specified in the read/write calls. [Note that the last argument to the calls is the debugAccess bit, and when set to 1 means that the read/write should not perturb the platform state - and in this case as there is no processor that is the case anyway.]\n\n Bool okRead = opBusRead (bus, 0, base, &b, sizeof(b), 1);\n Bool okWrite = opBusWrite (bus, 0, base, &b, sizeof(b), 1);\n\nWhen the example script is executed the example is built and then executed. The following shows the expected output:\n\n... modulePreSimulate: top setting up callbacks on slave bus\nmodulePreSimulate: top done\nmoduleSimulate: top starting\nmoduleSimulate: top reading and writing to 0\nmoduleSimulate: top read: 0, write: 0\nmoduleSimulate: top reading and writing to 1000\nreadCallback: topBusS, 10000000\nwriteCallback: topBusS, 10000000\nmoduleSimulate: top read: 1, write: 1\nmoduleSimulate: top reading and writing to 2000\nreadCallback: topBusS, 10001000\nwriteCallback: topBusS, 10001000\nmoduleSimulate: top read: 1, write: 1\nmoduleSimulate: top reading and writing to 3000\nmoduleSimulate: top read: 0, write: 0\nmoduleSimulate: top done\n...\n\n8.2 FIFO\n\nThere is an example provided as Examples/PlatformConstruction/FIFOHierarchy that shows the connection of buses between levels of hierarchy.\n\nThis example contains two modules.\n\nThe first module ‘submodule’ instances an OR1K processor and two FIFOs instances connected between the OR1K processor FIFO ports and ports on the module.\nThe second module ‘topmodule’ is used to instance ‘submodule’ twice and to connect the two modules FIFO out ports to the other modules FIFO in ports, as shown in the diagram.\n\nAnd as shown in the following extract from topmodule/module.op.tcl\n\n```\n# Create two modules that will communicate via the FIFO\nihwaddmodule -instancename mod0 -modelfile submodule/model\nihwaddmodule -instancename mod1 -modelfile submodule/model\n\nihwaddfifo -instancename fifo0 -width 32\nihwaddfifo -instancename fifo1 -width 32\n```\n\nWhen the example is run the processors within each ‘submodule’, that is ‘mod0’ and ‘mod1’, execute the application messageIn and a messageOut respectively to transfer a message using the FIFO connections between them.\n\nThe application makes use of inline assembler in order to generate the correct instruction/operation. There is a special purpose register added to the OR1K processor that allows access to the read and write FIFOs.\n\nMessage out application messageout.c\n\n```\n#include <stdio.h>\n\nconst char *message = \"This is the Imperas simulator communicating with FIFOs\\n\";\n\nstatic void writeToFifo(unsigned int value) {\n asm volatile(\"l.mtspr r0,%0,0x123\" :: \"r\"(value));\n}\n\nint main() {\n```\nunsigned int i = 0;\nunsigned int c;\n\nwhile((c=message[i++])) {\n writeToFifo(c);\n}\n\nwriteToFifo(0);\nreturn 0;\n}\n\nMessage in application messagein.c\n\n#include <stdio.h>\n\nstatic unsigned int readFromFifo(void) {\n unsigned int result;\n asm volatile(\"l.mfspr %0,r0,0x123\" : \"=r\"(result));\n return result;\n}\n\nint main() {\n unsigned int c;\n\n while((c=readFromFifo())) {\n printf(\"%c\", c);\n }\n\n return 0;\n}\n\nWhen the applications are executed in the virtual platform the output message is displayed when reception is complete as shown.\n\nThis is the Imperas simulator communicating with FIFOs\n\n8.3 Net\n\nThere is an example provided as Examples/PlatformConstruction/netHierarchy that shows the connection of buses between levels of hierarchy.\n\nThis example contains a module and a test harness.\nThe module has hardware generated that contains two net ports and connected nets, ‘netIn’ and ‘netOut’.\n\nThe module C file installs a net callback function on the input net to transfer the value to the output net.\n\nNet callback function, writes value from netIn onto netOut\n\n```c\nstatic OP_NET_WRITE_FN(netCallback) {\n optModuleObjectP object = userData;\n opPrintf(\"netRepeater: netCallback: set '%s' to %u\\n\",\n opObjectName(object->netOut),\n value);\n opNetWrite(object->netOut, value);\n}\n```\n\nInstall callback onto the net netIn\n\n```c\nopNetWriteMonitorAdd(object->netIn, netCallback, object);\n```\n\nthe harness instantiates the module and adds a callback onto netOut to monitor any changes to its value.\n\nDefining callback\n\n```c\nstatic OP_NET_WRITE_FN(netCallback) {\n opPrintf(\"uut: netCallback: topNetRecv = %u\\n\", value);\n}\n```\nAdding callback\n\n```c\nopNetWriteMonitorAdd(topNetRecv, netCallback, 0);\n```\n\nrunning the example script builds and then executes the simulation which should provide the following output\n\n```text\nuut: setting up callback on net 'topNetRecv'\nnetRepeater: setting up net repeater 'uut/netIn' to 'uut/netOut'\nuut: simulate: writing net 'topNetRecv' to 0\nnetRepeater: netCallback: set 'netOut' to 0\nuut: netCallback: topNetRecv = 0\nuut: simulate: writing net 'topNetRecv' to 1\nnetRepeater: netCallback: set 'netOut' to 1\nuut: netCallback: topNetRecv = 1\nuut: simulate: done\n```\n\n### 8.4 Packetnet\n\nThere is an example provided as Examples/PlatformConstruction/packetnetHierarchy that shows the connection of buses between levels of hierarchy.\n\nThis example contains a module, a test harness and a peripheral using a packetnet.\n\nThe module instances an OR1K processor and two packetnet peripherals whose registers are based at locations 0x80000000 and 0x80000010 in the processor memory space.\n\nThe application running on the OR1K processor starts a transfer by the first packetnet peripheral and then on the second.\nint main(int argc, char **argv)\n{\n LOG(\"PACKETNET TEST Application\\n\\n\");\n delay(1000);\n\n // Write to the transmit register of the first instance, causing the model\n // to transmit. The value 0x77 goes in the packet header, so we can see which\n // instance was triggered.\n writeReg8(0x80000000, 0, 0x77);\n\n delay(1000);\n // Write to the transmit register of the second instance, causing the model\n // to transmit. The value 0x88 goes in the packet header, so we can see which\n // instance was triggered.\n writeReg8(0x80000010, 0, 0x88);\n\n delay(1000);\n LOG(\"PACKETNET TEST Application DONE\\n\\n\");\n return 1;\n}\n\nThe packetnet ports are instanced in the harness which allows them to be monitored and\nwritten to.\n\nThe harness installs a callback on the packetnet input to monitor packets being received\n\nstatic OP_PACKETNET_WRITE_FN(packetnetFunction) {\n netPacketP p = data;\n if(p && bytes) {\n opMessage(\"I\", HARNESS_NAME \" _PKT_RXD\",\n \"Platform PKT testbench Trigger bytes=%u {%02x}, {%s}, {%02x}\nUD=0x%hx\\n\",\n bytes,\n p->head,\n p->data,\n p->tail,\n (Uns32)(UnsPS)userData\n );\n\n // increment this tail value. In our simple protocol this tells anyone\n // watching the packet that we received it.\n p->tail++;\n }\n}\nUsing\n\n```\n// Add callback onto the packetnet connection\n//\nopPacketnetWriteMonitorAdd(pktnet_pkn, packetnetFunction, 0);\n```\n\nand writes a frame of data to the packetnet interface\n\n```\n// Send a packetnet and reports the fact\n//\nstatic void packetWrite(optModuleP mi) {\n optPacketnetP pkn = opObjectByName(mi, \"pktnet\",\n OP_PACKETNET_EN).Packetnet;\n\n netPacket p = { 1, {'I', 'C', 'M', 0, 0, 0 }, 0 };\n opMessage(\"I\", HARNESS_NAME \"_PKT_TXS\",\n \"%s: writePkt START {%02x}, {%s}, {%02x}\",\n opObjectHierName(pkn),\n p.head,\n p.data,\n p.tail\n );\n\n // This is the function that triggers the packetnet.\n // All models with a callback installed on this packetnet\n // will be notified while this function is active.\n opPacketnetWrite(pkn, &p, sizeof(netPacket));\n\n // Now that the function has returned, we are certain that all\n // models have been notified. Their notifier callbacks have finished,\n // and if they chose to modify the data in the packet, we can see the\n // modification here.\n opMessage(\"I\", HARNESS_NAME \"_PKT_TXE\",\n \"%s: writePkt DONE {%02x}, {%s}, {%02x}\"\n ,\n opObjectHierName(pkn),\n p.head,\n p.data,\n p.tail\n );\n opPrintf(\"\\n\");\n}\nThe example is built and executed with the example script, the execution should provide output similar to the following:\n\n```\nInfo PACKETNET TEST Application\n\nInfo PACKETNET TEST Application\nInfo (PKT_PSETXS) testpacketnet/pktModel1: PSE to packetnet START {77} {PSETX} {00}\nInfo (PKT_PSERXD) testpacketnet/pktModel2: Peripheral PKT model Trigger bytes=8 {77}, {PSETX}, {00} UD=33\nInfo (testpacketnet_PKT_RXD) Platform PKT testbench Trigger bytes=8 {77}, {PSETX}, {01} UD=0x0\nInfo (PKT_PSETXE) testpacketnet/pktModel1: PSE to packetnet DONE {77} {PSETX} {02}\n\nInfo (PKT_PSETXS) testpacketnet/pktModel2: PSE to packetnet START {88} {PSETX} {00}\nInfo (PKT_PSERXD) testpacketnet/pktModel1: Peripheral PKT model Trigger bytes=8 {88}, {PSETX}, {00} UD=33\nInfo (testpacketnet_PKT_RXD) Platform PKT testbench Trigger bytes=8 {88}, {PSETX}, {01} UD=0x0\nInfo (PKT_PSETXE) testpacketnet/pktModel2: PSE to packetnet DONE {88} {PSETX} {02}\n\nInfo PACKETNET TEST Application DONE\n\nInfo (testpacketnet_PKT_TXS) testpacketnet/pktNet: writePkt START {01}, {APITX}, {00}\nInfo (PKT_PSERXD) testpacketnet/pktModel1: Peripheral PKT model Trigger bytes=8 {01}, {APITX}, {00} UD=33\nInfo (PKT_PSERXD) testpacketnet/pktModel2: Peripheral PKT model Trigger bytes=8 {01}, {APITX}, {01} UD=33\nInfo (testpacketnet_PKT_TXE) testpacketnet/pktNet: writePkt DONE {01}, {APITX}, {02}\n\n...\n9 Introducing Basic Processor Introspection\n\nPreviously, we saw an example which used standard instantiation attributes to enable tracing. The trace file output was generated in a fixed order. Occasionally, it might be necessary to generate trace information in a different format: for example, if a platform is being used to generate trace output to compare with the output from another tool, comparison is much easier if the format from the platform can be made to exactly match the other tool.\n\nThe OP API contains a number of functions allowing processor instance registers to be read and written. These can be used to construct test platforms that generate trace output from a simulation run in whatever format required. These access functions allow:\n\n- Access to instance program counter;\n- Access to any processor register by name;\n- Dump of processor registers;\n- Disassembly of the current instruction;\n- Access to the count of instructions executed by the processor.\n\nThere is also a function available that allows a processor model to be stepped by a single instruction, opProcessorSimulate, which will be used in this example.\n\n9.1 Reading and Writing Registers\n\nThere are a set of functions that allow access to the current program counter and to access the program counter while determining if the current instruction is being executed in the delay slot (for processors that support delay slot instructions) of a processor.\n\nThe processor can be found using the opProcessorNext function applied to a module, for example to get the first processor in a module (mi), use the following:\n\n```c\noptProcessorP processor = opProcessorNext(mi, NULL);\n```\n\nTo access the current program counter, use opProcessorPC:\n\n```c\nAddr currentpc = opProcessorPC(processor); // get current PC\n```\n\nThe return value from opProcessorPC is of type Addr, which is a 64-bit unsigned integer. For processors with address widths less than 64 bits, this value should be cast to an appropriate sized value if it is to be used subsequently in an arithmetic expression; for example:\n\n```c\nUns32 currentpc = (Uns32)opProcessorPC(processor); // get current PC as 32-bit value\n```\n\nFor processors with delay slot instructions, it is sometimes useful to know whether the current instruction is a delay slot instruction. To do this, use opProcessorPCDS:\n\n```c\nUns8 delaySlotOffset;\n```\nUns32 branchPC = opProcessorPCDS(processor, &delaySlotOffset);\n\n*opProcessorPCDS* behaves as follows:\n\n1. If the current instruction is not a delay slot instruction, it returns the current program counter and sets the *byref* value *delaySlotOffset* to 0;\n2. If the current instruction is a delay slot instruction, it returns the address of the preceding branch instruction and sets the *byref* value *delaySlotOffset* to the current instruction byte offset from the branch instruction. For example, if there is a branch instruction at 0x1000 with a delay slot instruction at 0x1004, then if *opProcessorPCDS* is called when the processor is executing the delay slot instruction at 0x1004, it will return 0x1000 and set *delaySlotOffset* to 4.\n\nThe current value of any processor register can be found using *opProcessorRegRead*, which fills a *byref* argument buffer with the current value of a named register:\n\n```c\nBool opProcessorRegRead (optProcessorP processor, optRegP reg, void *buffer);\n```\n\nTo write a processor register, there is a similar function *opProcessorRegWrite*:\n\n```c\nBool opProcessorRegWrite(optProcessorP processor, optRegP reg, void *buffer);\n```\n\nThe following code snippet shows how a processor register called *R1* can be masked with a bitmask *REG_FLAG_MASK* in a platform:\n\n```c\n#define REG_FLAG_MASK 0x00f0000f\n...\nUns32 regR1;\noptRegP reg = opProcessorRegByName(processor, \"R1\");\nif(reg) {\n if (opProcessorRegRead(processor, reg, regR1)) {\n regR1 = regR1 & REG_FLAG_MASK;\n opProcessorRegWrite(processor, reg, regR1);\n }\n}\n```\n\nIt is the responsibility of the calling function to ensure that the buffer value is the correct size to hold the register data. For example, the above example implicitly requires that register *R1* is a 32-bit register which will fit in a value of type *Uns32*. The *opRegBits* function may be used to verify this.\n\nThe function *opProcessorPCSet* can be used to set the processor's start-address without knowing the name of the PC in the particular model being used (not everyone calls it 'PC').\nIt is also possible within a platform to iterate over all the registers in a processor instance to determine their names and sizes (in bits) using three functions: \\texttt{opProcessorRegNext}, \\texttt{opRegName} and \\texttt{opRegBits}.\n\n\\texttt{opProcessorRegNext} returns an opaque pointer of type \\texttt{optRegP}, which describes a single processor register. It takes as an argument the previously-returned \\texttt{optRegP} value; when passed a \\texttt{NULL} pointer, it returns the first \\texttt{optRegP} pointer for a processor mode. It can therefore be used to iterate over all register descriptions for a processor in a simple loop:\n\n\\begin{verbatim}\noptRegP info = 0; // initiate loop with NULL pointer\nwhile((info=opProcessorRegNext(processor, info))) {\n . . .\n}\n\\end{verbatim}\n\nGiven an \\texttt{optRegP} pointer, the name of the register it corresponds to can be found using \\texttt{opRegName} and the register size in bits can be found using \\texttt{opRegBits}:\n\n\\begin{verbatim}\noptRegP info = 0; // initiate loop with NULL pointer\nwhile((info=opProcessorRegNext(processor, info))) {\n const char *name = opRegName(info);\n Uns32 bits = opRegBits(info);\n\n opPrintf(\"Found %u-bit register %s\\n\", name, bits);\n}\n\\end{verbatim}\n\nThe \\texttt{optRegP} returned by \\texttt{opProcessorRegNext} can be used, if required, to identify the register to read or write using \\texttt{opProcessorRegRead} or \\texttt{opProcessorRegWrite}. Alternatively the register can be read or written directly using its name using \\texttt{opProcessorRegReadByName} and \\texttt{opProcessorRegWriteByName} respectively.\n\n\\texttt{opRegUsageEnum} returns an enumeration and \\texttt{opRegUsageString} returns a string describing if the register has special use. Extending the above example to show this information\n\n\\begin{verbatim}\noptRegP info = 0; // initiate loop with NULL pointer\nwhile((info=opProcessorRegNext(processor, info))) {\n const char *name = opRegName(info);\n Uns32 bits = opRegBits(info);\n\n opPrintf(\"Found %u-bit register %s: usage (%d) %s\\n\", name,\n name,\nbits,\n opRegUsageEnum(info),\n opRegUsageString(info));\n\n9.2 Generating Disassembly Output\n\nProcessor models contain instruction disassembly functionality that can be accessed from a platform using opProcessorDisassemble, which returns a string disassembly of an instruction at a passed address. For example, to print the disassembled instruction at the current program counter:\n\n opPrintf(\"%s\", opProcessorDisassemble(processor, opProcessorPC(processor)));\n\n9.3 Dumping Registers\n\nProcessor models also contain functionality to dump all processor register values in a standard format. This can done using opProcessorRegDump:\n\n opProcessorRegDump(processor);\n\n9.4 Instruction Counts\n\nEvery processor also maintains a count of the number of instructions that it has executed (as a 64-bit unsigned integer). This can be accessed using the OP function opProcessorICount; for example, to print the number of instructions executed at the end of simulation:\n\n opPrintf(\"Simulation finished, “FMT_64u” instructions executed...\\n\",\n opProcessorICount(processor));\n\nNOTE: The macro FMT_64u defines a format string that will correctly print a 64-bit unsigned integer on both Linux and Windows hosts. It is defined with other similar macros in ImpPublic/include/host/impTypes.h.\n\n9.5 Example Processor Introspection\n\nAn example is provided in Examples/SimulationControl/basicProcessorIntrospection that utilizes the functions described above.\n\nTake a copy of the example and run the script which will build both the test application, the hardware definition in the module and the test harness.\n\n> cp -r Examples/SimulationControl/basicProcessorIntrospection .\n> cd basicProcessorIntrospection\n> example.sh\n\n# Compiling application.c\n# Linking application.OR1K.elf\nrm application.o\n# iGen Create OP MODULE module\n# Copying STUBS module.c igen.stubs to module.c\n# Host Depending obj/Linux32/module.d\n# Host Compiling Module obj/Linux32/module.o\n# Host Linking Module object model.so\n# Host Depending obj/Linux32/harness.d\n# Host Compiling Platform obj/Linux32/harness.o\n# Host Linking Platform harness/Linux32.exe\n# Host Linking Platform object model.so\n...\nInfo (MODULE) Introspect processor ‘cpu1’\nFound 32-bit register R0: usage (0) general\nFound 32-bit register R1: usage (2) stack pointer\nFound 32-bit register R2: usage (3) frame pointer\nFound 32-bit register R3: usage (0) general\n...\nFound 32-bit register TTCR: usage (0) general\nFound 32-bit register TTMR: usage (0) general\nFound 32-bit register EXCPT: usage (0) general\n\n9.6 Example Custom Processor Trace\n\nAn example is provided in Examples/SimulationControl/customProcessorTrace that utilizes the functions described above\n\nTake a copy of the example and run the script which will build both the test application, the hardware definition in the module and the test harness.\n\n> cp -r Examples/SimulationControl/customProcessorTrace .\n> cd customProcessorTrace\n> example.sh\n\nWhen the simulation executes, the following should be observed:\n\nInfo (MODULE) Trace processor 'cpu1'\n1 : 0x104 : l.addi r3,r0,0x0\n2 : 0x108 : l.addi r4,r0,0x0\n3 : 0x10c : l.addi r5,r0,0x0\n4 : 0x110 : l.addi r6,r0,0x0\n5 : 0x114 : l.addi r7,r0,0x0\n6 : 0x118 : l.addi r8,r0,0x0\n...\n2100 : 0x177c : l.j 0x0000176c\n2101 : 0x1780 : l.nop 0x0\n2102 : 0x176c : l.jal 0x00004674\n2103 : 0x1770 : l.ori r3,r10,0x0\n2104 : 0x4674 : l.addi r1,r1,0xfffffffc\n2105 : 0x1774 : l.jalr r4\nSimulation finished, stop reason 'CPU has exited' after 2105 instructions executed\n10 Simulating a Design\n\n10.1 Simulator Scheduler\n\nThe scheduler controls the execution of instructions on each of the processor models that may be in the platform and also when peripheral models timed events occur. It is the recommended approach to use the simulator internal built-in scheduler to execute simulation. However, in circumstances when you wish to control how the processor models instruction execution are scheduled and how time is moved forward OP API functions can be used in its place.\n\nHow processors execute instructions and how time is moved forward may be controlled when using the standard scheduler by setting the processor MIPS rate and the platform quantum. When using a custom scheduler it is the combination of the arguments passed to the functions that determine how instructions executed and time are related.\n\nIt is possible to create the same execution with both the standard and custom schedulers as shown in the example in section 10.1.3 Example below.\n\n10.1.1 The standard built in (default) simulator scheduler algorithm\n\nThe platforms/modules created using iGen and the OP API would normally be simulated using the default scheduling algorithm. By using the default algorithm the harness/modules can be directly imported into the Imperas professional tools without any modification.\n\nThe default scheduling is performed by a call to the `opRootModuleSimulate` function. This runs all processor and peripheral instances in the platform. There is one argument, a root module.\n\n```\n opRootModuleSimulate( myRootModule )\n```\n\nThe default scheduling algorithm described in section 10.6 is used in `harness.exe`, and all the examples in the documents up to this point.\n\n10.1.2 Writing a custom scheduler\n\nExamples of when a custom scheduler would be useful are:\n\n1. in co-simulation to allow explicit control of components\n2. when fine grain control of the interaction between components in a system is required\n\nA custom scheduling algorithm is created using the `opProcessorSimulate` and `opRootModuleTimeAdvance` functions in place of the `opRootModuleSimulate` function.\nThe function \\textit{opProcessorSimulate} is applied to only one processor instance. To simulate the platform all processors and peripherals in the platform must be scheduled. The function \\textit{opProcessorSimulate} is used for each processor instance in turn to make them execute a fixed number of instructions. The number of instructions a processor can execute in a given slice of time is a product of the performance of the processor and the length of time the time slice occupies.\n\nThe sequence to simulate a platform is to schedule each processor to execute the number of instructions it can nominally achieve in the time slice. Once all processors have executed any instructions they should perform in a time slice the platform time is moved forward in time by the appropriate amount using the \\textit{opRootModuleTimeAdvance} function. In moving time forward any peripheral functionality that is waiting for an amount of time to expire within this time slice will execute its behavior. \\textit{opRootModuleTimeAdvance} returns \\textit{False} if the new time is at or beyond a requested stop time (see \\textit{opRootModuleSetSimulationStopTime}).\n\n10.1.3 Example\n\nThis example is found in the customScheduler directory.\n\n```\n$IMPERAS_HOME/Examples/SimulationControl/customScheduler\n```\n\nThe example shows how a custom scheduler is used to control the execution of an application on a processor while moving time forward so that events within peripheral models occur at the correct rate.\n\n```\n#define INSTRUCTIONS_PER_SECOND 10000000\n#define QUANTUM_TIME_SLICE 0.00001\n#define INSTRUCTIONS_PER_TIME_SLICE (INSTRUCTIONS_PER_SECOND * QUANTUM_TIME_SLICE)\n\n// must advance to next phase for the API calls that follow\nopRootModulePreSimulate(mi);\n\nif (options.custom) {\n\n // run simulation with custom scheduling\n optTime myTime = QUANTUM_TIME_SLICE;\n optStopReason stopReason = OP_SR_SCHED;\n do {\n\n // move time forward by time slice on root module\n // NOTE: This matches the standard scheduler which moves time forward in\n // the system and then executes instructions on all processors\n opRootModuleTimeAdvance(mi, myTime);\n\n```\nopMessage(\n \"I\", HARNESS_NAME,\n \"Advance Time to %g seconds\",\n (double)myTime\n);\n\n// run processor for number of instructions calculated for time slice\nstopReason = opProcessorSimulate(proc,\n INSTRUCTIONS_PER_TIME_SLICE);\nif ((stopReason!=OP_SR_SCHED) && (stopReason!=OP_SR_HALT)) {\n opMessage(\n \"I\", HARNESS_NAME,\n \"Simulation Complete (%s)\",\n opStopReasonString(stopReason)\n );\n break; // finish simulation loop\n}\n\nmyTime += QUANTUM_TIME_SLICE;\n}\n\nwhile (1);\n}\n\nelse {\n\n // run with built in standard scheduler\n opRootModuleSimulate(mi);\n}\n\nCompile the test harness, example module and application as before using the following commands in the memory directory:\n\n> make –C harness\n> make –C module\n> make –C application CROSS=OR1K\n\nTo run the simulation, in the customScheduler directory, run:\n\n# run with custom scheduler\n> harness/harness.{IMPERAS_ARCH}.exe \\\n --program application/application.{CROSS}.elf \\\n --output custom.log \\\n --custom \\\n\nYou should see the following output:\n\nInfo (harness) Running with custom scheduler\nInfo (16550_BRS) u1/uartTTY0: baud rate=1152000 parity=N data bits=5 total bits=7 character delay=6usec\nInfo (harness) Advance Time to 1e-05 seconds\nInfo (harness) Advance Time to 2e-05 seconds\nInfo (16550_UWR) u1/uartTTY0: Write to Data register: data=0x48 ('H')\nInfo (harness) Advance Time to 3e-05 seconds\nInfo (16550_UWR) u1/uartTTY0: Write to Data register: data=0x65 ('e')\nInfo (harness) Advance Time to 4e-05 seconds\n...\nInfo (16550_UWR) u1/uartTTY0: Write to Data register: data=0x6c ('l')\nInfo (harness) Advance Time to 0.00085 seconds\nInfo (harness) Advance Time to 0.00086 seconds\nInfo (16550_UWR) u1/uartTTY0: Write to Data register: data=0x6f ('o')\nInfo (harness) Advance Time to 0.00087 seconds\nInfo (16550_UWR) u1/uartTTY0: Write to Data register: data=0x20 (' ') Info (harness) Advance Time to 0.00088 seconds\nInfo (16550_UWR) u1/uartTTY0: Write to Data register: data=0x38 ('8')\nInfo (harness) Advance Time to 0.00089 seconds\nInfo (16550_UWR) u1/uartTTY0: Write to Data register: data=0x0a (' ') Info (harness) Advance Time to 0.0009 seconds\nInfo (harness) Simulation Complete (CPU has exited)\nInfo (harness) Time at Completion 0.0009 seconds\n\nTo run the simulation, with the standard scheduler, in the customScheduler directory, run:\n\n```\n# run with standard scheduler\n> harness/harness.$\\{IMPERAS_ARCH\\}.exe \\n --program application/application.$\\{CROSS\\}.elf \\n --output standard.log \\n $@\n```\n\nYou should see the similar output i.e. the same but without the time advance information\n\nInfo (harness) Running with standard scheduler\nInfo (16550_BRS) u1/uartTTY0: baud rate=1152000 parity=N data bits=5 total bits=7 character delay=6usec\nInfo (16550_UWR) u1/uartTTY0: Write to Data register: data=0x48 ('H')\nInfo (16550_UWR) u1/uartTTY0: Write to Data register: data=0x65 ('e')\n10.2 Custom Simulation Tracing with Harness\n\n10.2.1 Controlling Instructions Executed on a Processor\n\nPrevious examples have used the function opRootModuleSimulate, which simulates a design using a built-in scheduling algorithm that simulates each processor for many instructions, or until the simulation is finished, before returning to the harness. For this example, we instead want to simulate a processor one instruction at a time, performing custom instruction tracing after each one completes. To do this, use opProcessorSimulate:\n\n```c\noptStopReason opProcessorSimulate (optProcessorP processor, Uns64 instructions);\n```\n\nopProcessorSimulate runs the passed processor for up to `instructions` more instructions and then returns. The precise reason why simulation stopped is indicated by the return code provided by the enumerated type `optStopReasonE`:\n\n<table>\n<thead>\n<tr>\n<th>Stop Reason</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>OP_SR_SCHED</td>\n<td>Scheduler expired.</td>\n</tr>\n<tr>\n<td>OP_SR_YIELD</td>\n<td>Yield encountered.</td>\n</tr>\n<tr>\n<td>OP_SR_HALT</td>\n<td>CPU is halted.</td>\n</tr>\n<tr>\n<td>OP_SR_EXIT</td>\n<td>CPU has exited.</td>\n</tr>\n<tr>\n<td>OP_SR_FINISH</td>\n<td>Simulation finish.</td>\n</tr>\n<tr>\n<td>OP_SR_RD_PRIV</td>\n<td>Read privilege exception.</td>\n</tr>\n<tr>\n<td>OP_SR_WR_PRIV</td>\n<td>Write privilege exception.</td>\n</tr>\n<tr>\n<td>OP_SR_RD_ALIGN</td>\n<td>Read align exception.</td>\n</tr>\n<tr>\n<td>OP_SR_WR_ALIGN</td>\n<td>Write align exception.</td>\n</tr>\n<tr>\n<td>OP_SR_FE_PRIV</td>\n<td>Fetch privilege exception.</td>\n</tr>\n<tr>\n<td>OP_SR_ARITH</td>\n<td>Arithmetic exception.</td>\n</tr>\n<tr>\n<td>OP_SR_INTERRUPT</td>\n<td>Interrupt simulation.</td>\n</tr>\n<tr>\n<td>OP_SR_FREEZE</td>\n<td>Frozen (by opProcessorFreeze).</td>\n</tr>\n<tr>\n<td>OP_SR_WATCHPOINT</td>\n<td>Memory watchpoint is pending.</td>\n</tr>\n<tr>\n<td>OP_SR_BP_ICOUNT</td>\n<td>Instruction count breakpoint is pending.</td>\n</tr>\n<tr>\n<td>OP_SR_BP_ADDRESS</td>\n<td>Address breakpoint is pending.</td>\n</tr>\n<tr>\n<td>OP_SR_RD_ABORT</td>\n<td>Read abort exception.</td>\n</tr>\n<tr>\n<td>OP_SR_WR_ABORT</td>\n<td>Write abort exception.</td>\n</tr>\n</tbody>\n</table>\nOP_SR_FE_ABORT | Fetch abort exception.\n\nThe three most common return codes are:\n\n**OP_SR_SCHED**: processor successfully simulated the required number of instructions and returned\n\n**OP_SR_EXIT**: processor has exited (but in a multiprocessor platform, other processors may still be running)\n\n**OP_SR_FINISH**: simulation has finished\n\nIn practice, it is usually sufficient to continue simulation while the return code from `opProcessorSimulate` is `OP_SR_SCHED`, for example:\n\n```c\nwhile(opProcessorSimulate(processor, 1)==OP_SR_SCHED) {\n \n} \nopPrintf( \n \"Simulation finished, “FMT_64u” instructions executed\\n\", \n opProcessorICount(processor) \n);\n```\n\nNote that simulating one instruction at a time is much less efficient than simulating for a larger number of instructions, so this should only be used when needed, such as when tracing each instruction as we are doing here.\n\n### 10.2.2 Generating Disassembly Information\n\nThe disassembly information is normally generated when the built-in tracing is enabled, using `--trace`. However, API functions are also available to allow some custom tracing to be generated within the harness.\n\nThe disassembly output can be obtained as a string using the `opProcessorDisassemble` function and providing the processor and the address of interest\n\n```c\nopPrintf(\"0x%08x : %s\\n\", thisPC, opProcessorDisassemble (processor, thisPC);\n```\n\n### 10.2.3 Accessing Registers\n\nThe registers of a processor can each be individually accessed using the either an iterator function `opProcessorRegNext` or by name using `opProcessorRegByName`. These can then be queried and values or other information provided.\n\nAll of the standard core registers may also be displayed directly from the model as a listing using the `opProcessorRegDump` function. This will format the registers as dictated by the model or if there is no model function as 4 registers per line.\n### 10.2.4 Example\n\nThe following example uses the functions described above to control the order of instruction disassembly, register dumping and instruction execution.\n\nThis example is found in the processorRegisterAccess directory.\n\n```\n$IMPERAS_HOME/Examples/ControlSimulation/processorRegisterAccess\n```\n\nThe module is defined in module/module.op.tcl as a platform with a single processor and memory. The harness that instantiate the module and controls the simulation is in harness/harness.c, is as follows:\n\n```c\nint main(int argc, const char *argv[]) {\n opSessionInit(OP_VERSION);\n\n opCmdParseStd(MODULE_NAME, OP_AC_ALL, argc, argv);\n\n optModuleP mr = opRootModuleNew(0, MODULE_NAME, 0);\n\n const char *u1_path = \"module\";\n optModuleP mi = opModuleNew(\n mr, // parent module\n u1_path, // modelfile\n MODULE_INSTANCE, // name\n 0,\n 0\n );\n\n // get the handle for the processor in the module\n optProcessorP processor = opObjectByName(mi, \"cpu1\", OP_PROCESSOR_EN).Processor;\n\n // construction complete\n opRootModulePreSimulate(mr);\n\n Bool done = False;\n while(!done) {\n Uns32 currentPC = (Uns32)opProcessorPC(processor);\n\n // disassemble instruction at current PC\n opPrintf(\"** Instruction Disassemble\\n\");\n opPrintf(\"0x%08x : %s\\n\", currentPC,\n opProcessorDisassemble(processor, currentPC)\n```\n// execute one instruction and check for none scheduler return \nopPrintf(\"** Instruction Execution\\n\"); \ndone = (opProcessorSimulate(processor, 1) != OP_SR_SCHED);\n\n// dump registers \nopPrintf(\"** Register Dump\\n\"); \nopProcessorRegDump(processor);\n}\n\n// print number of instructions executed at end of simulation and reason simulation stopped \nopPrintf( \n\"Simulation finished, \"FMT_64u\" instructions executed, StopReason is \"%s\\n\", \nopProcessorICount(processor), \nopStopReasonString(opProcessorStopReason(processor)) \n);\n\nopSessionTerminate(); \nreturn 0;\n}\n\nCompile the module, test harness and application using the following commands in the \nprocessorRegisterAccess directory:\n\nmake -C module \nmake -C harness \nmake -C application\n\nTo run the simulation, in the processorRegisterAccess directory, run:\n\n./harness/harness.Linux32.exe --program application/asmtest.OR1K.elf\n\nYou should see the following output:\n\n** Instruction Disassemble\n0x01000074 : l.addi r1,r0,0x0\n** Instruction Execution\n** Register Dump\n----------------- ----------------- ----------------- ----------------- \nR0 : 00000000 R1 : 00000000 R2 : deadbeef R3 : deadbeef \nR4 : deadbeef R5 : deadbeef R6 : deadbeef R7 : deadbeef \n**Instruction Disassemble**\n0x01000120 : l.addi r1,r0,0x0\n\n**Instruction Execution**\n\n**Register Dump**\n\n---\nR0 : 00000000 R1 : 00000000 R2 : 00000001 R3 : ffffffff\nR4 : 80000000 R5 : 7fffffff R6 : deadbeef R7 : deadbeef\nPC : deadbeef SR : 00008801 ESR: deadbeef EPC: deadbeef\nTCR: 00000000 TMR: 00000000 PSR: 00000000 PMR: 00000000\nBF:0 CF:0 OF:1\n---\nSimulation finished, 44 instructions executed, StopReason is 'CPU has exited'\n\n### 10.3 Interrupt a Running Simulation\n\nNormally, opProcessorSimulate and opRootModuleSimulate will run until they have completed the requested number of simulated instructions (for opProcessorSimulate) or time has advanced until the time specified by opRootModuleSetSimulationStopTime (for opRootModuleSimulate), or until a processor model has performed some explicit action that terminates the simulation loop early (for example, halting or exiting) or the simulation completes and all processors have finished execution.\n\n#### 10.3.1 Interrupt Simulation (from a Cntrl-C Handler)\n\nOccasionally, it may be required that the opProcessorSimulate or opRootModuleSimulate call be terminated early by some external event. For example, the harness may implement an interrupt handler so that when a user presses Ctrl-C the simulation loop should\nimmediately terminate. This can be done using the opInterrupt\\(^1\\) API call from within a signal handler, shown in the following code snippet (Linux only):\n\n```c\n#include <signal.h> \n\n// LINUX signal handler to interrupt the running simulation\n// static void ctrlCHandler(Int32 nativeSigNum, siginfo_t *sigInfo, void *context) {\n// opInterrupt();\n//}\n\n// Install a LINUX signal handler to trap any CtrlC\n// static void installCtrlCHandler(void) {\n//\n// struct sigaction sa = {{0}};\n// sa.sa_sigaction = ctrlCHandler;\n// sa.sa_flags = SA_SIGINFO;\n// sigfillset(&sa.sa_mask);\n// sigaction(SIGINT, &sa, NULL);\n//}\n```\n\nWithin the main function, the Ctrl-C handler is installed:\n\n```c\nint main(int argc, char ** argv) {\n\n ... \n\n // install a signal handler to trap any CtrlC\n installCtrlCHandler();\n\n ... \n}\n```\n\nWhen the user presses Ctrl-C, while this example is running, a call to the ctrlCHandler occurs which calls opInterrupt. This will cause any active opProcessorSimulate or opRootModuleSimulate call to return, and the stopReason for the processor that stops will be set to OP_SR_INTERRUPT.\n\nThis needs to be handled in the main routine, for example:\n\n---\n\n\\(^1\\) The API function opInterrupt is the only API call that can be made when a simulation is running. This causes the simulator to return when it reaches a stable state from which it can do so.\noptProcessorP stoppedProcessor;\n\n// simulate until done or ctrl-C\nwhile((stoppedProcessor=opRootModuleSimulate(mr))) {\n if(opProcessorStopReason(stoppedProcessor)==OP_SR_INTERRUPT) {\n opPrintf(\n \"%s: interrupt after \" FMT_64u \" instructions...\n\", \n opObjectName ((optObjectP)stoppedProcessor), \n opProcessorICount(stoppedProcessor)\n );\n } else {\n break;\n }\n}\n\nIn this example, when an interrupt occurs, the platform prints a message and continues simulation by calling opRootModuleSimulate again (which will continue from where it was interrupted). In real cases, applications will typically enter a command interpreter instead at this point.\n\nIn the common case that simulation needs to be interrupted on a Ctrl-C event, The API provides a method that does not require OS-specific signal handler code: simply specify OP_FP_STOPONCONTROLC, either applied to the root module as an override\n\n opParamBoolOverride(0, OP_FP_STOPONCONTROLC, 1);\n optModuleP mr = opRootModuleNew(0, 0, 0);\n\nor applied as parameters to the root module\n\n optModuleP mr = opRootModuleNew(\n 0,\n 0,\n OP_PARAMS(\n OP_PARAM_BOOL_SET(OP_FP_STOPONCONTROLC, 1)\n )\n );\n\nThis will have exactly the same effect as an OS-specific interrupt handler calling opInterrupt.\n\n### 10.3.2 Interrupt a Specific Processor\n\nIt may be required that a specific processor is interrupted when it accesses an area of memory. This can be achieved using the opProcessorYield API call. This will cause the simulator to return from the opProcessorSimulate or opRootModuleSimulate function after the instruction in which the opProcessorYield was called has completed.\nIn this example `opProcessorYield` is called when one of the processors makes a write to a specific address range that triggers the memory watchpoint callback.\n\n```c\nOP_BUS_SLAVE_WRITE_FN(extMemoryWrite) {\n opMessage(\"I\", \"EXTERNAL_MEMORY_WRITE\",\n \"%s access at address 0x\" FMT_Ax \" data 0x%08x\",\n processor ? opObjectHierName(processor) : \"artifact\", addr, *(Uns32 *)data);\n\n // Calling this API function will interrupt the simulator\n opProcessorYield(processor);\n}\n```\n\n### 10.3.3 Example\n\nThis example is found in the interruptSimulation directory.\n\n```\n$IMPERAS_HOME/Examples/SimulationControl/interruptSimulation\n```\n\nCompile the test harness, module and application using the following commands in the interruptSimulation directory:\n\n```\n> make -C harness\n> make -C module\n> make -C application\n```\n\nTo run the simulation, in the interruptSimulation directory, run:\n\n```\n> ./harness/harness.Linux32.exe --program application/application.OR1K.elf\n```\n\nYou should see output as in example multiprocessor as the two processors execute the application.\n\nAfter a number of iterations the application will make a write that will cause a call to `opInterrupt`, when data written is 610. This will cause the simulator to return from the `opRootModuleSimulate` and a message will be generated of the form:\n\n```\nCPU (writer): fib(15) = 610\nInfo (MEMORY_ACCESS) top/u1/cpu1 Write at address 0xe0001004 (0xe0001004) data 0x00000262 (610)\nInfo (HARNESS) cpu1: interrupt after 1504523 instructions 'Interrupt simulation'\nInfo (MEMORY_ACCESS) top/u1/cpu2 Read at address 0xe0001004 (0xe0001004) data 0x00000262 (610)\nInfo (HARNESS) cpu2: interrupt after 1600036 instructions 'Interrupt simulation'\nCPU (reader): munge(610) = 185745\n```\nThe application will make a write that will cause a call to opProcessorYield, when the data written is 6765. This will cause the simulator to return from opRootModuleSimulate and a message will be generated of the form:\n\n```\nCPU (writer): fib(20) = 6765\nInfo (MEMORY_ACCESS) top/u1/cpu1 Write at address 0xe0001004 (0xe0001004) data 0x00001a6d (6765)\nInfo (HARNESS) cpu1: interrupt after 3147106 instructions 'Yield was encountered'\nInfo (MEMORY_ACCESS) top/u1/cpu2 Read at address 0xe0001004 (0xe0001004) data 0x00001a6d (6765)\nInfo (HARNESS) cpu2: interrupt after 3200018 instructions 'Yield was encountered'\nCPU (reader): munge(6765) = 22879230\n```\n\nYou may also press Ctrl-C repeatedly while the application runs; each time, a line will be generated of the form:\n\n```\nInfo (HARNESS) cpu1: interrupt after <ins count> instructions 'Interrupt simulation'\nor:\nInfo (HARNESS) cpu2: interrupt after <ins count> instructions 'Interrupt simulation'\n```\n\ndepending which processor is running when the Ctrl-C is hit.\n\n### 10.3.4 Important Notes\n\n#### 10.3.4.1 API Usage in Ctrl-C Handler\nWhen in a Ctrl-C or other similar handler and you want to cause the simulation to be interrupted i.e. return from the opProcessorSimulate or opRootModuleSimulate functions the opInterrupt may be used. However, it is important that no other API calls should be made from within a handler of this type. To do so may result in unexpected behavior.\n\n#### 10.3.4.2 opInterrupt Usage\nOne important point about opInterrupt is that it is not intended to be asynchronously thread-safe. In other words, it is not appropriate to asynchronously call opInterrupt when the simulation thread is not suspended. In virtual platform simulations with multiple asynchronous threads, the interrupting thread should be designed to work as follows:\n\n1. It should suspend the simulating thread using any appropriate means;\n2. It should call opInterrupt to notify the suspended thread that an interrupt has been requested;\n3. It should restart the simulating thread so that the interrupt request can be acted on.\n\nIf this sequence is not followed, simulator data structures may become corrupted.\n\n### 10.4 Generating External Events to a Processor\n\nProcessor models written using the VMI interface can be made to react to external interrupt events on named ports. For example, a processor model can be made to perform\na hard reset on an event on its ‘reset’ port or take an exception and execute from an\nexception vector on a change to an interrupt or exception port input.\n\nThese types of ‘interrupt’ and ‘exception’ events are signaled to processor models using\nnets. A net is a hardware connection that can signal state; typically asserted and de-asserted are\nsignaled but a net can be used to pass an unsigned 32bit value.\n\n10.4.1 Processor Reset\n\nThe processor ‘reset’ port can be connected to a net that can be driven from the test\nharness or from another component (typically a peripheral) in the design.\n\nWhen the ‘reset’ is asserted\\(^2\\) by writing a ‘1’ to the net the processor is held in a reset\nstate until the ‘reset’ is de-asserted by writing a ‘0’ to the net.\n\nThe following illustrates controlling the ‘reset’ connection from a test harness.\n\nThe net object ‘reset’ must be found in the module. This can be done by searching for the\nobject by name, as shown, or the net could be exported from the module using net ports\nand connected in the harness\n\n```c\n optNetP reset = opObjectByName(mi, \"reset\", OP_NET_EN).Net;\n```\n\nand then may be used to assert the reset\n\n```c\n opNetWrite(reset, 1);\n```\n\nor de-assert the reset\n\n```c\n opNetWrite(reset, 0);\n```\n\nthe reset is connected to the processor in the module (module.op.tcl snippet):\n\n```c\n # connect reset to cpu1\n ihwconnect -instancename cpu1 -netport reset -net reset\n```\n\nand may be driven from a peripheral in the module, as well as from the harness\n\n```c\n ihwaddperipheral -instancename resetControlPeripheral \\ \n -type resetControl \\ \n -modelfile peripheral/pse.pse\n```\n\n\\(^2\\) All OVP/Imperas processor models use a high ‘1’ written to the ‘reset’ net to cause the assertion of the\nreset; this may not be representative of the true hardware signal polarity.\nihwconnect -instancename resetControlPeripheral -netport resetOut -net reset\n\n10.4.2 Processor Startup Reset\n\nThe processors in a design can be brought out of reset under control of other components, for example an application on one processor can write a peripheral register which releases the reset on a second processor which allows it to start execution.\n\nThe mechanism used can be modeled to match the same mechanism in the hardware definition.\n\nThe startup reset can also be controlled from the harness. For example the following code extract shows a two processor system in which the second processor, cpu2, is brought out of reset 0.1 seconds after the first processor, cpu1, using the cpu2 reset connection, reset2.\n\nObtain the reset connections in the design\n\n```c\n// get reset nets\noptNetP reset2 = opObjectByName(mi, \"reset2\", OP_NET_EN).Net;\n```\n\nassert the reset on processor cpu2\n\n```c\n// Hold processor cpu2 in reset\nopNetWrite(reset2, 1);\n```\n\nsimulate for the required amount of time\n\n```c\nopRootModuleSetSimulationStopTime(mr, 0.1);\nopRootModuleSimulate(mr);\n```\n\nrelease processor cpu2 reset\n\n```c\n// Release processor2\nopNetWrite(reset2, 0);\n```\n\nsimulate until both processors complete\n\n```c\nopRootModuleSimulate(mr);\n```\n\n10.4.3 Processor Reset Example\n\nThis example is found in the processorResetControl directory.\nThis example includes a design that instantiates two processors and one peripheral model. Two reset lines connect from the peripheral one to each of the processors and is driven by the peripheral, as shown in the following diagram.\n\nThe application on processor cpu1 is controlling the reset of processor cpu2 the application of which is running a fibonacci application which includes the generation of code at the reset vector so that on a reset it jumps back to the initial entry point at 'start'.\n\nThe peripheral model has a control register that can be accessed by either processor that is used to toggle the value of one or both of the reset connections. It also opens a socket, using the support included in the BHM API calls, and monitors characters received over the socket. If an ‘r’ character is received both reset lines are driven high then low to generate a reset, if a ‘q’ character is received the simulation is terminated. The simulation will also terminate if the socket is disconnected (terminal window closed).\n\nThe control register behavioral code of the peripheral, peripheral/user.c, is as follows:\n\n```c\n// Control Register Write\nPPM_REG_WRITE_CB(controlRegisterWrite) {\n\n // if bit one set toggle reset1\n if (SWAP4(data) & 1) {\n if(ppmReadNet(handles.resetOut1)) {\n bhmMessage(\"I\", PSENNAME \"_CRWC1\",\n \" Control Register Write: Release reset1\");\n }\n }\n\n // if bit zero set toggle reset2\n if (SWAP4(data) & 2) {\n if(ppmReadNet(handles.resetOut2)) {\n bhmMessage(\"I\", PSENNAME \"_CRWC2\",\n \" Control Register Write: Release reset2\");\n }\n }\n}\n```\nppmWriteNet(handles.resetOut1, 0);\n\n} else {\n bhmMessage(\"I\", PSENAME \"_CRWS1\",\n \" Control Register Write: Reset reset1\");\n ppmWriteNet(handles.resetOut1, 1);\n}\n}\n\n// if bit two set toggle reset2\nif (SWAP4(data) & 2) {\n if (ppmReadNet(handles.resetOut2)) {\n bhmMessage(\"I\", PSENAME \"_CRWC2\",\n \" Control Register Write: Release reset2\");\n ppmWriteNet(handles.resetOut2, 0);\n } else {\n bhmMessage(\"I\", PSENAME \"_CRWS2\",\n \" Control Register Write: Reset reset2\");\n ppmWriteNet(handles.resetOut2, 1);\n }\n}\n\n// store current write value\n*(Uns32*)user = data;\n}\n\nNote that the data value written is byte swapped. This is because the OR1K processor\nbeing used uses big endian data ordering, the PSE uses host endian data ordering and on\nthe x86 this is little endian.\n\nThe main routine of the peripheral, is as follows:\n\nif (channel) {\n\n bhmSerWriteN(channel, startMessage, sizeof(startMessage));\n\n while (1) {\n //\n // Non Blocking read\n //\n Uns8 buffer[MAXREAD];\n Uns8 bytes = bhmSerReadN(channel, buffer, 1);\n\n if (bytes) {\n // echo value back to terminal\n bhmSerWriteN(channel, buffer, 1);\n\n if (buffer[0] == 'r') {\n\n }\n\n```\n```\nbhmMessage(\"I\", PSENAME \"_MT\", \"generate reset on reset1\");\nppmWriteNet(handles.resetOut1, 1);\nppmWriteNet(handles.resetOut1, 0);\nbhmMessage(\"I\", PSENAME \"_MT\", \"generate reset on reset2\");\nppmWriteNet(handles.resetOut2, 1);\nppmWriteNet(handles.resetOut2, 0);\nif (buffer[0] == 'q') {\nbhmMessage(\"I\", PSENAME \"_MT\", \"Force Finish Simulation\");\nbhmFinish();\n}\n// polling delay\nbhmWaitDelay(100);\n\nOpen a socket, waiting for a connection to be made\nbhmSerOpenAuto();\n\nAttempt to read a single character from the socket. This is a non-blocking read (there is an equivalent blocking read, bhmSerReadN) so if nothing is available it returns with result 0.\nbhmSerReadN(channel, buffer, 1);\n\nIf a character is available and it is ‘r’ the peripheral toggles the ‘reset’ net (handles.resetOut is the handle to the opened port on the peripheral to which the reset line is connected) to generate a reset signal causing the processor to reset.\nppmWriteNet(handles.resetOut1, 1);\nppmWriteNet(handles.resetOut1, 0);\n\nCompile the test harness, module, peripheral and application using the following commands in the processorResetControl directory:\n\n> make –C harness\n> make –C module\n> make –C peripheral\n> make –C application CROSS=OR1K\n\nTo run the simulation, in the processorResetControl directory, run:\n\n> ./harness/harness.Linux32.exe \\\n --program top/u1/cpu1=application/application1.OR1K.elf\\\nYou should see output as follows:\n\nSimulator log, showing the following.\n\nInitially both processors are held in reset (reset lines active)\n\nAfter 0.001 seconds of simulation time processor cpu1 reset line, reset1, is released and the processor starts executing application1. This application executes a delay before writing to the resetControl peripheral to release the reset to processor cpu2 which then starts executing application2 which executes the fibonacci sequence several times.\n\nAfter a delay, coded within application 1, processor cpu1 performs a reset on processor cpu2, which we see starts re-executing from the reset vector\n10.5 Processor External Interrupt\n\nIn the same way that a ‘reset’ can be signaled to a processor so too can interrupts, that cause the processor to take an exception i.e. to change execution to an exception vector.\n\nTypically a processor interrupt port will be driven by an interrupt controller and the interrupt will remain active until acknowledged by interrupt handler software included in the application that is executing on the processor.\n\nThe processor interrupt port, e.g.: ‘intr0’ can be connected to a net that can be driven from the test harness or from another component (typically a peripheral) in the design.\n\nWhen the net connected to the ‘intr0’ port is written the processor model will be invoked to process the interrupt. The processor model may react to an edge i.e. a change in the level on the port or it may react to a level i.e. it will continue to process the interrupt while the level is in an active state.\n\nThe following illustrates controlling the interrupt pin ‘intr0’ on the processor from a test harness which can be found in the processorExternalInterruptControl directory.\n\n$IMPERAS_HOME/Examples/SimulationControl/processorExternalInterruptControl\n\nFirst we need to find the name of the net, if any, connected to the net port on the processor in the module (mi)\n\n// get the handle for the processor in the module (only one)\noptProcessorP processor = opProcessorNext(mi, 0);\n\n// get interrupt port connection on processor (if made)\noptNetPortConnP intNC = opObjectByName(processor,\n INTERRUPT_PORT_NAME,\n OP_NETPORTCONN_EN).NetPortConn;\n\nNOTE: When we know that an object returned by opObjectByName can only be a certain type we can extract the correct union member. To determine the object, if it is not a certain type, the function opObjectType can be used.\n\nIf there is no net connection we can create our own new net in the harness and make the connection otherwise we can obtain the current net already connected:\n\n```c\noptNetP intr0 = 0;\nif(!intNC) {\n intr0 = opNetNew(mi, INTERRUPT_PORT_NAME \"_net\", 0, 0);\n opObjectNetConnect( processor, intr0, INTERRUPT_PORT_NAME);\n} else {\n intr0 = opNetPortConnNet(intNC);\n}\n```\n\nand then we can use the net to write and assert the interrupt (we show writing ‘1’ to assert but this could equally well be any other value)\n\n```c\nopNetWrite(intr0, 1);\n```\n\nand similarly the interrupt can be de-asserted\n\n```c\nopNetWrite(intr0, 0);\n```\n\nThe above example can be compiled and run.\n\nInitially instructions are executed to enable interrupts on the processor\n\n```\nInfo (HARNESS) Creating net connection to 'intr0' on 'cpu'\nInfo (HARNESS) Simulate 20 instructions\nInfo 'top/u1/cpu', 0x0000000000001000: l.ori r30,r0,0x0\nInfo 'top/u1/cpu', 0x0000000000001004: l.ori r1,r0,0x7\n...\nInfo 'top/u1/cpu', 0x0000000000001020: l.nop 0x0\nInfo 'top/u1/cpu', 0x0000000000001018: l.sfeq r1,r30\nInfo 'top/u1/cpu', 0x000000000000101c: l.bnf 0x00001018\n```\n\nThe harness generates the interrupt and runs one instruction to ensure that the processor will see the interrupt line active.\nNOTE: If the interrupt is level sensitive and the simulation is not executed the processor may not see the interrupt ever being active.\n\nThe processor is enabled to simulate exceptions so when the interrupt line becomes active the interrupt exception, at address 0x00000800, is executed.\n\n```\nInfo (HARNESS) Generate Interrupt on 'intr0'\nInfo (HARNESS) Simulate 1 instruction\nInfo 'top/u1/cpu', 0x00000000000001020: *** FETCH EXCEPTION ***\nInfo (HARNESS) Release Interrupt on 'intr0'\nInfo (HARNESS) Simulate 20 instructions\nInfo 'top/u1/cpu', 0x0000000000000800: l.addi r30, r30, 0x1\nInfo 'top/u1/cpu', 0x0000000000000804: l.addi r2, r0, 0xffffe000\nInfo 'top/u1/cpu', 0x0000000000000808: l.slli r2, r2, 0x10\nInfo 'top/u1/cpu', 0x000000000000080c: l.sw 0x0(r2), r30\nInfo 'top/u1/cpu', 0x0000000000000810: l.rfe\n```\n\nOne the return from exception is executed the processor continues from the instruction that was executed.\n\n```\nInfo 'top/u1/cpu', 0x000000000000101c: l.bnf 0x00001018\nInfo 'top/u1/cpu', 0x0000000000001020: l.nop 0x0\nInfo 'top/u1/cpu', 0x0000000000001018: l.sfeq r1, r30\n...\nInfo 'top/u1/cpu', 0x0000000000001020: l.nop 0x0\nInfo 'top/u1/cpu', 0x0000000000001018: l.sfeq r1, r30\nInfo 'top/u1/cpu', 0x000000000000101c: l.bnf 0x00001018\nInfo 'top/u1/cpu', 0x0000000000001020: l.nop 0x0\nInfo 'top/u1/cpu', 0x0000000000001018: l.sfeq r1, r30\nInfo (HARNESS) Simulation finished\nInfo (HARNESS) cpu executed 41 instructions, StopReason 'Scheduler has expired'\n```\n**10.5.1 Processor External Interrupt Timer Tick Example**\n\nThis example is found in the `processorExternalInterrupt` directory.\n\n```\n$IMPERAS_HOME/Examples/PlatformConstruction/processorExternalInterrupt\n```\n\nThis example includes a design that instantiates a processor and a peripheral model (a simple timer generating a regular interrupt tick), as shown in the following diagram.\n\nThe interrupt line, `intr0`, is connected to the processor in the module definition:\n\n```\n# interrupt connection\nihwaddnet -instancename tickInterrupt\n# connect tickInterrupt to cpu1 intr0\nihwconnect -instancename cpu1 -netport intr0 -net tickInterrupt\n```\n\nand may be driven from a peripheral in the module (as well as from the harness):\n\n```\nihwaddperipheral -instancename timerPeripheral \\ \n -type simpleTimer \\ \n -modelfile peripheral/pse.pse\n```\n\n```\n# timer tick interrupt\nihwconnect -instancename timerPeripheral -netport tickOut -net tickInterrupt\n```\n\nThe application on the processor is a simple assembler routine that enables interrupts on the processor and installs reset and interrupt handler software at the vector addresses 0x0000 and 0x0800 respectively. The assembler routine is compiled and loaded without setting the initial PC, so the processor will start execution from its reset vector.\n\nThe peripheral model can be configured for a tick rate using the parameter ‘rate’, in the example the default is used to generate a tick every 0.01 seconds. A register, when\nwritten, is used by the processor application to acknowledge and clear the generated tick interrupt.\n\nThe regular tick is generated within a loop delayed using bhmWaitDelay in the behavioral code of the peripheral, peripheral/user.c, as follows:\n\n```c\nwhile (1) {\n // delay for tick rate\n bhmWaitDelay(delayRate);\n if(PSE_DIAG_LOW)\n bhmMessage(\"I\", \"TIMER_PSE\", \"Generating tick at %g seconds\", (double) (bhmGetCurrentTime()/1000000));\n ppmWriteNet(handles.tickOut, 1);\n}\n```\n\nAnd the behavior of the interrupt acknowledge register, in the register write callback of the peripheral, is as follows:\n\n```c\n// interrupt acknowledge (used to clear interrupt)\nPPM_REG_WRITE_CB(intAck) {\n *(Uns32*)user = data;\n if(ppmReadNet(handles.tickOut)) {\n if(PSE_DIAG_HIGH)\n bhmMessage(\"I\", \"TIMER_PSE\", \"Interrupt Acknowledge, clear interrupt\");\n ppmWriteNet(handles.tickOut, 0);\n }\n}\n```\n\nThe application enables the interrupts on the OR1K processor and then waits in a loop for 8 interrupts to be generated. The main loop is\n\n```assembly\n.ori r1,r0,8 // r1 = 8 (loop count)\nloop1:\n l.sfaq r1,r30 // r1==r30?\n l.bnf loop1 // go to loop if not true\n l.nop // (delay slot)\n```\n\nwhich tests the value in register r30 and r1 (r1 is initialized to 8) and r30 is incremented in the interrupt handler code\n\n```assembly\n.global interruptVector\n```\n.org 0x800\n\n// EXTERNAL INTERRUPT HANDLER (AT 0x800)\n\ninterruptVector:\n l.addi r30, r30, 1 // increment count of external exceptions\n l.addi r2, r0, 0xe000 // set r2\n l.slli r2, r2, 16 // shift to 0xe0000000\n l.sw 0(r2), r30 // write interrupt Acknowledge register\n l.rfe // return from exception\n\nwhich also write to the interrupt acknowledge register of the peripheral to clear down the interrupt.\n\nNOTE: The OR1K processor interrupt line is level sensitive so if the interrupt source is not cleared immediately on the OR1K executing the return from exception routine the interrupt will become active once again and the exception routine executed again.\n\nCompile the module, peripheral and application using the following commands in the processorExternalInterrupt directory:\n\n> make –C module\n> make –C peripheral\n> make –C application CROSS=OR1K\n\nTo run the simulation, in the processorExternalInterrupt directory, run:\n\n> harness.exe --modulefile module \\ \n --objfilenoentry application/asmtest.OR1K.elf \\ \n --override processorExternalInterrupt /timerPeripheral/diagnosticlevel=3 \\ \n --output imperas.log\n\n1) We are using –objfilenoentry to load the program without changing the initial PC of the processor so that we start execution from the reset vector (0x0000)\n2) We are turning on diagnostics on the peripheral so that we can see messages generated when the interrupt is generated and when it is acknowledged by the processor application\n\nYou should see output as follows:\n\nInfo (TIMER_PSE) ...Interrupt/timerPeripheral: Generating tick at 0.01 seconds\nInfo (TIMER_PSE) ...Interrupt/timerPeripheral: Interrupt Acknowledge, clear interrupt\nInfo (TIMER_PSE) ...Interrupt/timerPeripheral: Generating tick at 0.02 seconds\nInfo (TIMER_PSE) ...Interrupt/timerPeripheral: Interrupt Acknowledge, clear interrupt\nInfo (TIMER_PSE) ...Interrupt/timerPeripheral: Generating tick at 0.03 seconds\nInfo (TIMER_PSE) ...Interrupt/timerPeripheral: Interrupt Acknowledge, clear interrupt\n10.6 Standard Multiprocessor Scheduling Algorithm\n\nThis example uses the standard multiprocessor scheduling algorithm built-in to the simulator that is used when the `opRootModuleSimulate` function is called. The standard scheduling algorithm works as follows:\n\n1. Simulation time is broken into *time slices*. By default, each time slice is 0.001 seconds (one millisecond).\n2. The simulator selects the first processor and simulates it for one time slice. It in fact does this by calculating the *number of instructions* that should be executed by that processor in a time slice, and then simulating for that number of instructions. The number of instructions in a time slice is:\n \n \\[(\\text{processor nominal MIPS rate}) \\times 1\\text{e}6 \\times (\\text{time slice duration})\\]\n \n In this example, each processor has the default nominal MIPS rate of 100 MIPS. This means that each processor will execute \\(100 \\times 1\\text{e}6 \\times 0.001 = 100,000\\) instructions per time slice.\n3. When the first processor has simulated for 100,000 instructions, it is suspended and the next processor is simulated for the time slice.\n4. When all processors have simulated the time slice, simulated time is moved on and the next slice is started.\n\nThis algorithm is an approximation designed to give realistic simulation results with very high simulator performance: the simulator is not designed to be cycle accurate.\n\nThe simulation algorithm is configurable in several ways:\n\n10.6.1 Changing the Time Slice Size\n\nThe size of the time slice (in seconds) can be set with:\n\n\\[\n\\text{Bool opRootModuleSetSimulationTimeSlice(optTime newSliceSize)};\n\\]\n\nwhere type `optTime` is a `long double`. Shorter time slices may approximate real system behavior more closely, but degrade simulator performance.\n10.6.2 Changing Processor Nominal MIPS Rate\n\nThe nominal MIPS rate for each processor can be set with a parameter on the processor instance. See the section titled MIPS Parameter in the Simulation Control of Platforms and Modules User Guide for an example of this.\n\n10.6.3 Writing Custom Scheduling Algorithms\n\nIf the standard multiprocessor scheduling algorithm does not do what is required, a custom algorithm can be built around calls to opProcessorSimulate for each processor. This function will simulate a specified processor for an exact number of instructions.\n\nPlease note:\n\n1) The user must ensure that the appropriate number of instructions are executed on each processor, in a multicore platform.\n\n2) When a platform also includes peripheral models time must be updated at an appropriate rate.\n11 Parallel Simulation: QuantumLeap™\n\nAs of VMI version 6.0.0, Imperas Professional Simulation products implement a parallel simulation algorithm called QuantumLeap™, which enables multicore platform simulation to be distributed over separate threads on multiple cores of the host machine for improved performance.\n\nQuantumLeap allows for the parallel execution of both processor and peripheral models on host processors. This section describes its use with processors; refer to the OVP Peripheral Modeling Guide for information about parallelization of peripherals.\n\n11.1 License and Runtime for QuantumLeap\n\nNote that QuantumLeap is only supported as a licensed feature of the Imperas Professional Tools. The Imperas professional simulator, CpuManager, is selected using the IMPERAS_RUNTIME environment variable:\n\n```\nexport IMPERAS_RUNTIME=CpuManager\n```\n\nYou will need a license for QuantumLeap™. This will be one of IMP_SIMPARALLEL or IMP_SIMPARALLEL_MAX (see below for difference). Contact Imperas for more information.\n\n11.2 Example\n\nA number of examples are found in the Demo/Processors tree in directories ‘many_core’ and ‘multi_core’ that instance a number of processors and run the same standard application on each of them. These examples utilize the Imperas ISS product which allows the selection of the processor type, the number of processors and what memory is included.\n\nIn this section we will use the example found at\n\n```\n$IMPERAS_HOME/Demo/Processors/OPENCORES/or1k/generic/many_core\n```\n\nThe QuantumLeap algorithm can be enabled by appending the commands (\\textit{--parallel} or \\textit{--parallelmax}) to the command line, when the command line parser has been included. If no command line parser is available a control file can be used (control files are described in the \\textit{document doc/ovp/OVP_Control_File_User_Guide}).\nTo run the simulation, with QuantumLeap enabled, in the many_core directory, run:\n\n```bash\n> iss.exe --verbose \\\n --program ../../../Applications/dhrystone/dhrystone.OR1K-O3-g.elf\\ \n --processorvendor ovpworld.org --processorname or1k --variant generic \\ \n --numprocessors 4 --output ql.log --parallel -argv 400000\n```\n\nWhich is based upon the Run_QL_AMP4_Dhrystone.sh script. Note The argument --argv must be the last argument on the command line. All arguments following this argument are passed to the applications argc argv.\n\nYou should see the following output as the four processors execute the Dhrystones application on parallel host processors:\n\n```\n... \nCpuManagerMulti Parallel started: Tue Feb 23 09:18:42 2016 \n... \nDhrystone Benchmark, Version 2.1 (Language: C) \n... \nInfo TOTAL \nInfo Simulated instructions: 16,496,458,632 \nInfo Simulated MIPS : 7199.9 \nInfo --------------------------------------------------- \nInfo --------------------------------------------------- \nInfo SIMULATION TIME STATISTICS \nInfo Simulated time : 41.24 seconds \nInfo User time : 8.76 seconds \nInfo System time : 0.28 seconds \nInfo Elapsed time : 2.29 seconds \nInfo Real time ratio : 18.00x faster \nInfo --------------------------------------------------- \nCpuManagerMulti Parallel finished: Tue Feb 23 09:18:45 2016\n... \n```\n\nNote that the banners emitted at the start and end of simulation include an indication that QuantumLeap parallel simulation is now enabled.\n\nThese results show a marked improvement in performance over the non QuantumLeap run that can be performed by removing the --parallel argument\n\n```bash\n> iss.exe --verbose \\\n --program ../../../Applications/dhrystone/dhrystone.OR1K-O3-g.elf\\ \n --processorvendor ovpworld.org --processorname or1k --variant generic \\ \n --numprocessors 4 --output non-ql.log --argv 400000\n```\n11.3 QuantumLeap Results\n\nThe actual performance reported may vary and depends on the performance of the native host. In this example (run on a 3.4Ghz Dell Quad Core i7-3770 desktop machine) the overall simulation speed is about 7200 simulated OR1K MIPS, approximately a quarter for each processor. This is almost four times as fast as the same application run without QuantumLeap.\n\n11.4 QuantumLeap Scheduling Algorithm\n\nThe QuantumLeap scheduling algorithm is similar in many respects to the standard multiprocessor scheduling algorithm. The exact details of the algorithm are proprietary, but some general characteristics are given here.\n\nTime moves forward in quanta which are calculated in exactly the same way as for the standard algorithm. During each quantum, processors may run in parallel in independent native threads, but they are all synchronized at the quantum end before the next quantum is started. Any processor may also cause the simulation to revert to synchronous mode during a quantum if the simulator detects that synchronous operation is required (for example, execution of a test-and-set instruction). In such a case, all other processors are safely stopped while the atomic action is carried out on the processor requiring synchronization.\n\nProvided that synchronizing instructions and accesses to shared registers are correctly described, the simulation is deterministic in the absence of unguarded spin locks (demonstrate this by running this example simulation several times: instruction counts for\neach processor will remain the same from run to run). See the OVP Processor Modeling Guide for a detailed description of how to make processor models compatible with QuantumLeap.\n\nThe actual simulation results can differ between the normal multiprocessor algorithm and the QuantumLeap algorithm, because of detailed scheduling differences. In the normal multiprocessor algorithm, preceding processors in the schedule list for this quantum will all have finished the quantum before an intermediate processor runs, and subsequent processors will not have run any instructions at all. In the QuantumLeap algorithm, all other processors can be in some deterministic intermediate state between the start and end of the quantum when an intermediate processor interacts with them. This usually affects instruction counts and sometimes program results, but in a correctly-designed program the standard and QuantumLeap results represent alternative legal paths through the parallel program. If you examine instruction counts for this example program running with and without QuantumLeap, you will see that they differ slightly, but the results are the same.\n\nAny instruction that is intercepted is guaranteed to be run in synchronous mode with all other processors stopped. This means that legacy intercept libraries can be used with QuantumLeap without modification.\n\nSometimes QuantumLeap results are non-deterministic. This can either be due to legal constructs such as unguarded spin locks (often used to defer expensive synchronization instructions) or by real program synchronization bugs. QuantumLeap determinism can be a useful tool for validating parallel algorithm correctness.\n\n### 11.5 QuantumLeap Options\n\nCommand line arguments `--parallelopt`, `--parallelthreads` and `--parallelmax` can be used to control details of the simulation, as described below.\n\n#### 11.5.1 Option -parallelopt\n\nQuantumLeap algorithm behavior can be modified using command line option `--parallelopt`. This option is a bitfield, which currently defines the following bits:\n\n- **Bit 0: enable nice scheduling behavior**\n When this bit is 0, QuantumLeap operates in a greedy mode, in which the algorithm assumes that it can freely use all resources of the host to achieve the fastest possible simulation. Setting this bit enables nice mode, which suspends native threads more frequently so that more resources are available to other processes on the host machine.\n\n The effect of nice mode depends on the operating system type and version. Often, QuantumLeap simulation runs little or no slower; on some operating system versions, the effect may be to slow simulation more significantly. Validate performance on your operating system before deciding whether it is appropriate to use this option.\n**Bit 1: don’t fix affinity**\nWhen this bit is 0, QuantumLeap attempts to fix the affinity of a simulated core to a particular host core to avoid costs involved in synchronizing host caches that can occur when host processes are moved from one host core to another. Setting this bit disables affinity fixing so that simulated core processes can migrate between host cores.\n\n**Bit 2: use legacy thread allocation algorithm**\nWhen the number of host threads available for parallel simulation is less than the number of simulated cores, QuantumLeap has to share the limited host resources amongst the simulated cores. There are two algorithms available: the default algorithm statically allocates simulated cores to fixed host cpus (or sets of host cpus) and relies upon the host operating system to schedule those threads fairly; the alternative algorithm schedules host threads *explicitly* so that no more than a specified limit execute concurrently (see the --parallelthreads option below). Setting this bit enables the alternative algorithm.\n\nThe default value of –parallelopt is 0, specifying greedy mode simulation, fixed affinities and static thread allocation without explicit scheduling.\n\n**Example**\nTo rerun the previous simulation with greedy scheduling behavior and no fixed affinities:\n\n```\n> iss.exe --verbose \\\n --program ../../../Applications/dhrystone/dhrystone.OR1K-O3-g.elf \\\n --processorvendor ovpworld.org --processorname or1k --variant generic \\\n --numprocessors 4 --output ql.log --parallel --parallelopt 2 -argv 400000\n```\n\n**11.5.2 Option -parallelthreads**\nQuantumLeap option --parallelthreads can be used to specify the maximum number of parallel threads that should execute at once. This option can be useful in (for example) regression test runs, to restrict a particular simulation to use of a smaller-than-normal set of the available processor resources, to ensure that some resources are available for other runs that might be occurring in parallel on the same machine.\n\n**11.5.2.1 Example**\nTo run a simulation in which no more than three parallel threads execute at once:\n\n```\n> iss.exe --verbose \\\n --program ../../../Applications/dhrystone/dhrystone.OR1K-O3-g.elf \\\n --processorvendor ovpworld.org --processorname or1k --variant generic \\\n --numprocessors 4 --output ql.log --parallel --parallelthreads 3 -argv 400000\n```\n\nNote that standard QuantumLeap supports up to 4 parallel threads. To specify more than this, a separate license is required; contact Imperas for details.\n11.5.3 Option -parallelmax\n\nQuantumLeap option --parallelmax can be used in a control file to specify that a simulation should run as many threads as possible in parallel for maximum performance. This option requires a separate license; contact Imperas for details.\n\n11.5.3.1 Example\n\nTo run a simulation using maximum parallelization:\n\n```\n> iss.exe --verbose \\\n --program ../././Applications/dhrystone/dhrystone.OR1K-O3-g.elf\\ \n --processorvendor ovpworld.org --processorname or1k --variant generic \\ \n --numprocessors 4 --output ql.log --parallel --parallelmax -argv 400000\n```\n12 Memory Operations\n\n12.1 Implicit Processor Model Memory\n\nWhen a new processor instance is created, and no specific memories are created, then by default an implicit RAM memory that covers the entire addressable memory by the processor type is also created.\n\nThis memory can be directly accessed within the harness using the following functions: `opProcessorRead` and `opProcessorWrite`. In addition, these functions can also be used to read and write memory without causing side effects in the processor model, or in any TLM2.0 models connected to the processor. The function `opProcessorApplicationLoad` can be used to load an object file.\n\n12.1.1 Loading object files\n\nAn object file can be loaded into processor memory using the `opProcessorApplicationLoad` function:\n\n```c\noptApplicationP opProcessorApplicationLoad(\n optProcessorP processor,\n const char *objectFile,\n optLoaderControls controls,\n Addr loadOffset\n);\n```\n\nThe `optLoaderControls` are used to control how the file is loaded into memory and is defined as:\n\n- `OP_LDR_DEFAULT`: No special features\n- `OP_LDR_PHYSICAL`: Use object file physical addresses if available\n- `OP_LDR_VERBOSE`: Report each section as it is loaded\n- `OP_LDR_NO_ZERO_BSS`: Do not zero the extent of the BSS section if present\n- `OP_LDR_SET_START`: Set the PC to the code start address\n- `OP_LDR_SYMBOLS_ONLY`: Read the symbols but do not load the code or data\n- `OP_LDR_ELF_USE_VMA`: Load ELF files using VMA addresses instead of LMA.\n- `OP_LDR_FAIL_IS_ERROR`: Failure to load will prevent the simulation from running\n\nFor ELF files, the Load Memory Address (LMA) is used as the load address by default. Setting `OP_LDR_ELF_USE_VMA` in the `attrs` argument will cause the Virtual Memory Address (VMA) to be used instead.\n\nIn the following example the memory is loaded from file `hello.OR1K.elf` using physical address information, and the PC will be set to the entry address defined in the object file:\n\n```c\nopProcessorApplicationLoad(processor, \"hello.OR1K.elf\", OP_LDR_PHYSICAL, 0);\n```\n\nThe algorithm used is as follows:\n1. Find the processor passed in argument #1.\n2. Find the bus connected to the instruction or data port\\(^3\\) on that processor.\n3. Load the specified object file into memory on that bus.\n\nThe loader takes each section address from the object file and looks for memory which decodes at that address. An error is raised if no memory is mapped at a load address. The loader uses any address decoding available on the bus, even if the decoded memory is shared with other processors.\n\nIf more than one processor is using the same code memory, the program need be loaded only once; When OVPsim starts a processor with no explicitly loaded program, it will look for any other processors of the same architecture with common program memory and, if one is found, use the start address associated with that processor.\n\nAn object file which is not directly related to a processor (e.g. a data file) can be loaded into memory on a bus using `opBusApplicationLoad`.\n\nThe functions `opProcessorApplicationLoad` and `opBusApplicationLoad` return an `optApplicationP` which can be interrogated using `opApplicationControls`, `opApplicationElfCode`, `opApplicationEndian` and `opApplicationEntry` to find respectively the control features used when the application was loaded, the 16-bit processor architecture code, endianness and the executable start address.\n\n12.1.1.1 Supported object formats\n\nThe simulator currently supports:\n- ELF Used by all GNU tool chains\n- TI COFF An extended version of the COFF format, used by compilers supplied by Texas Instruments\n\n12.1.1.2 Loading Symbols in object files\n\nWhen `opProcessorApplicationLoad` loads an object file into simulated memory it also reads the symbol tables included in the object file, and records the address-to-symbol mappings. These mapping can then be used:\n- When issuing tracing information\n- When intercepting a function by name (see `opProcessorExtensionNew`)\n\nSometimes object code might be loaded by another route (e.g. using a boot-loader running on a simulated processor) in which case the simulator has no opportunity to read the symbols. In this situation the function `opProcessorApplicationLoad` can be used with the controls set for `OP_LDR_SYMBOLS_ONLY` to associate symbols addresses within a processor without loading the code. In this example, instruction tracing will include code labels found in `program.elf`, though the code came from another source:\n\nIn `module.op.tcl` the `bootloader.elf` file is specified as part of the hardware i.e. it is always present and loaded into the processor memory. This may then execute and re-locate the\n\n\\(^3\\) The port used is dependent upon the processor model and the attributes of the section being loaded.\ncode to a different memory space, for example to copy from a ROM area to a RAM area for execution.\n\n```\nihwaddprocessor -instancename cpu1 \\\\\n -vendor ovpworld.org -library processor -type or1k -version 1.0 \\\\\n -semihostname or1kNewlib -variant generic \\\\\n -imagefile bootloader.elf\n```\n\nIn the module C code callback the program symbol file can be loaded separately that contains the symbol information at the execution addresses.\n\n```\nstatic OP_PRE_SIMULATE_FN(modulePreSimulate) {\n opProcessorApplicationLoad(processor, \"program.elf\", OP_LDR_SYMBOLS_ONLY, 0);\n}\n```\n\n### 12.2 Loading by Directly Reading and Writing Data\n\nThe memory space can also be read and written directly using the `opProcessorRead` and `opProcessorWrite` functions. These functions transfer N bytes of data between a local buffer and the simulated memory space using the simulated memory address.\n\n#### 12.2.1 Example Loading Program from Hex format file\n\nThis example is found in the `loadingApplicationProgramHexFormatFile` directory.\n\n```\n$IMPERAS_HOME/Examples/SimulationControl/loadingApplicationProgramHexFormatFile\n```\n\nThe example shows the use of the write memory and read memory functions to perform the loading of a program. The program is provided in the form of a hex file with address and data pairs.\n\nThe file loader is written in standard C code as part of the harness. In the same way any file format can be supported by either incorporating available C code of a reader or creating a new one.\n\nThe hex file format used in this example is based upon a simple sequence of address and data, with comments marked using ‘#’ and symbols marked with ‘:’ (note symbols will only be loaded if the Imperas professional simulator is being used), for example:\n\n```\n:01000074 _start\n01000074 0000209c ;\n01000078 0100409c ;\n```\n\nIn this example the loader is implemented so that multiple consecutive addresses can be written with the same value.\nFollowing is the loader, found in the file `harness/harness.c`, which takes the name of the file containing the data to be loaded and a switch to control the byte swapping. The initial code is responsible for opening the file, reading it a line at a time and parsing the line.\n\n```c\nstatic int loadHexFile(optProcessorP processor, const char *fileName) {\n FILE *fp;\n char inBuf[MAX_LINE_LENGTH + 1];\n int address, endAddress, data, dataCheck;\n\n fp = fopen(fileName, \"r\");\n\n if (!fp) {\n opMessage(\"E\", HARNESS_NAME \"_HEX_LDR\",\n \"Failed to open Memory Initialization File \"%s\",\n fileName);\n return -1;\n }\n\n opMessage(\"I\", HARNESS_NAME \"_HEX_LDR\",\n \"Loading Hex file \"%s\",\n fileName);\n\n while ( fgets( inBuf,MAX_LINE_LENGTH, fp) != 0 ) {\n\n if ( inBuf[0] == '#') {\n // ignore header\n } else if ( inBuf[0] == ':') {\n\n // symbol\n Uns32 symbolAddress;\n char symbol[16];\n if ( sscanf(inBuf, \":%08x %s\", &symbolAddress, symbol) == 2 ) {\n opMessage(\"I\", HARNESS_NAME \"_HEX_LDR_SYM\",\n \"Found symbol \"%s' at address 0x%08x\",\n symbol,\n symbolAddress);\n\n }\n\n }\n}\n```\n\nIf the initial character is a ‘:’ this indicates that the line is defining a symbol to be loaded.\nThe following section of code checks the IMPERAS_RUNTIME environment variable to check for the Imperas Professional simulator. If it is being used the symbols of the application can be loaded. If the symbol is the ‘_start’ symbol this is also used to set the PC.\n\n```c\nconst char *runTime=getenv(\"IMPERAS_RUNTIME\");\nif(strcmp(runTime, \"CpuManager\") == 0) {\n opProcessorApplicationSymbolAdd(processor,\n symbol,\n symbolAddress,\n 4,\n ORD_SYMBOL_TYPE_FUNC,\n ORD_SYMBOL_BIND_GLOBAL);\n} else {\n opMessage(\"W\", HARNESS_NAME \"_HEX_LDR_SF\",\n \"Symbols cannot be loaded with this product runtime (%s),\n \"supported in Imperas Professional simulator\",\n runTime);\n}\nif(strcmp(symbol, \"_start\") == 0) {\n opMessage(\"I\", HARNESS_NAME \"_HEX_LDR_START\",\n \"Set start address to 0x%08x\",\n symbolAddress);\n opProcessorPCSet(processor, symbolAddress);\n}\n} else {\n opMessage(\"W\", HARNESS_NAME \"_HEX_LDR_SND\",\n \"Found symbol line '%s' but not decoded\",\n inBuf);\n}\n} else {\n}\n```\n\nThe address and data information is used to write the data to the correct address in the processor memory space. A read back of the same address is carried out to see that it was correctly written. The data word will be swapped if the Host endian does not match the endian of the simulated processor because of the use of OP_HOSTENDIAN_TARGET in the opProcessorWrite and opProcessorRead functions.\n\n```c\nif ( sscanf(inBuf, \"%08x-%08x %08x ;\", &address, &endAddress, &data) != 3 ) {\n sscanf(inBuf, \"%08x %08x ;\", &address, &data);\n endAddress = address;\n}\n```\ndo {\n //\n // Access the memory through the processor memory space\n //\n if(!opProcessorWrite(\n processor, // processor\n address, // memory address\n &data, // data buffer of data to write\n 4, // number of bytes in one object\n 1, // number of objects\n True, // debug access (not a true processor access)\n OP_HOSTENDIAN_TARGET\n )) {\n opMessage(\"E\", HARNESS_NAME \"_HEX_LDR_FW\",\n \"Failed Data Write at 0x%08x\",\n (Uns32)address);\n\n return -1;\n }\n\n opProcessorRead(\n processor,\n address,\n &dataCheck,\n 4,\n 1,\n True,\n OP_HOSTENDIAN_TARGET\n );\n\n if(data != dataCheck) {\n opMessage(\"E\", HARNESS_NAME \"_HEX_LDR_FRB\",\n \"Failed Data Read Back at 0x%08x (0x%08x 0x%08x)\",\n (Uns32)address, data, dataCheck);\n\n return -1;\n }\n\n opMessage(\"I\", HARNESS_NAME \"_HEX_LDR_LD\",\n \"Load address 0x%08x : 0x%08x\",\n address, data);\n\n } while ( address++ < endAddress);\n\n}\n\nopMessage(\"I\", HARNESS_NAME \"_HEX_LDR\",\n \"Load Complete\");\n```c\nif (fclose(fp)!=0) {\n opMessage(\"E\", HARNESS_NAME \" _HEX_LDR_CF\",\n \"Failed to close Memory Initialization File\");\n return -1;\n}\nreturn 0;\n}\n```\n\n⇒ Note if the processor uses virtual addressing the address of the `opProcessorWrite` and `opProcessorRead` functions will be translated to a physical memory address using the current virtual address mapping.\n\nThe main() routine in the platform file, creates a platform with a single OR1K processor and a region of memory from 0x00100000 to 0xffffffff. The memory is loaded by a call to the hexLoader routine that has been described above. If the load fails an error message is generated.\n\n```\n// Loading application hex file\n// Load Hex file into Processor Memory\nif (loadHexFile(proc, options.hexfile, False)) {\n opMessage(\"E\", HARNESS_NAME, \"Load of Hex File '%s' Failed\", options.hexfile);\n}\n```\n\nTo run the example, take a copy of the example and compile the test harness and the module hardware definition using the following command in the copied `loadingApplicationProgramHexFormatFile` directory:\n\n```\nmake -C harness\nmake -C module\n```\n\nIn the application directory you will find an assembler file, asmtest.S, and the same file as hex, asmtest.hex. To run the simulation, type:\n\n```\n./harness/harness.Linux32.exe --hexfile application/asmtest.hex\n```\n\nIf you are using the Imperas professional simulator, you should see output similar to the following:\n\n```\nInfo (harness_HEX_LDR) Loading Hex file 'application/asmtest.hex'\nInfo (harness_HEX_LDR_SYM) Found symbol '_start' at address 0x01000074\nInfo (harness_HEX_LDR_START) Set start address to 0x01000074\nInfo (harness_HEX_LDR_LD) Load address 0x01000074 : 0x0000209c\nInfo (harness_HEX_LDR_LD) Load address 0x01000078 : 0x0100409c\nInfo (harness_HEX_LDR_LD) Load address 0x0100007c : 0xffff609c\nInfo (harness_HEX_LDR_LD) Load address 0x01000080 : 0x0008809c\n```\nif you are using the OVPsim simulator, you should see output similar to the following:\n\n```plaintext\nInfo (harness_HEX_LDR) Loading Hex file 'application/asmtest.hex'\nInfo (harness_HEX_LDR_SYM) Found symbol '_start' at address 0x01000074\nWarning (harness_HEX_LDR_SF) Symbols cannot be loaded with this product runtime (OVPsim), supported in Imperas Professional simulator\nInfo (harness_HEX_LDR_START) Set start address to 0x01000074\nInfo (harness_HEX_LDR_LD) Load address 0x01000074 : 0x0000209c\nInfo (harness_HEX_LDR_LD) Load address 0x01000078 : 0x1000409c\nInfo (harness_HEX_LDR_LD) Load address 0x0100007c : 0xffff609c\nInfo (harness_HEX_LDR_LD) Load address 0x01000080 : 0x0008809c\nInfo (harness_HEX_LDR_LD) Load address 0x01000084 : 0x000884b0\nInfo (harness_HEX_LDR_LD) Load address 0x01000088 : 0x0000a484\nInfo (harness_HEX_LDR_LD) Load address 0x0100008c : 0xffffa3a0\nInfo (harness_HEX_LDR_LD) Load address 0x01000090 : 0x0000a4a0\nInfo (harness_HEX_LDR_LD) Load address 0x01000094 : 0x0100a5a0\nInfo (harness_HEX_LDR_LD) Load address 0x01000098 : 0x002804d4\nInfo (harness_HEX_LDR_LD) Load address 0x0100009c : 0x0000c084\nInfo (harness_HEX_LDR_LD) Load address 0x010000a0 : 0x0000209c\nInfo (harness_HEX_LDR_LD) Load address 0x010000a1 : 0x0000209c\n\nWarning (harness_HEX_LDR_SF) Symbols cannot be loaded with this product runtime (OVPsim), supported in Imperas Professional simulator\nInfo (harness_HEX_LDR_SYM) Found symbol '__exit' at address 0x0100009c\n```\n\n```plaintext\nWarning (harness_HEX_LDR_SF) Symbols cannot be loaded with this product runtime (OVPsim), supported in Imperas Professional simulator\n```\n\n```plaintext\nif you are using the OVPsim simulator, you should see output similar to the following:\n```\nInfo (harness_HEX_LDR) Load Complete\nInfo 'u1/cpu1', 0x0000000001000074: l.addi r1,r0,0x0\nInfo 'u1/cpu1', 0x0000000001000078: l.addi r2,r0,0x1\nInfo 'u1/cpu1', 0x000000000100007c: l.addi r3,r0,0xffffffff\nInfo 'u1/cpu1', 0x0000000001000080: l.addi r4,r0,0x800\nInfo 'u1/cpu1', 0x0000000001000084: l.muli r4,r4,0x800\nInfo 'u1/cpu1', 0x0000000001000088: l.lwz r5,0x0(r4)\nInfo 'u1/cpu1', 0x000000000100008c: l.addic r5,r3,0xffffffff\nInfo 'u1/cpu1', 0x0000000001000090: l.addic r5,r4,0x0\nInfo 'u1/cpu1', 0x0000000001000094: l.addic r5,r5,0x1\nInfo 'u1/cpu1', 0x0000000001000098: l.sw 0x0(r4),r5\nInfo 'u1/cpu1', 0x000000000100009c: l.lwz r6,0x0(r0)\nProcessor Exception (PC_PRX) Processor 'u1/cpu1' 0x100009c: l.lwz r6,0x0(r0)\nProcessor Exception (PC_RPX) No read access at 0x0\n\nNote that:\n1. When using the Imperas professional simulator the symbols are loaded and the semihost library (or1kNewlib, loaded in the module) intercepts ‘__exit’ and terminates the simulation.\n2. When using the OVPsim simulator, no symbols are loaded, the code in ‘__exit’, loads from address 0x00000000 which causes an exception – this is because there is no memory mapped at this address.\n3. The simulator reports the exception and returns from opRootModuleSimulate (using opRootModuleStopReason or opProcessorStopReason would show the status was OP_SR_RD_PRIV although this isn’t shown in this example). The OP_FP_SIMULATEEXCEPTIONS instance parameter could be used to cause the exception to be simulated by the processor instead.\n\n12.2.2 Reading and writing memory without side-effects\n\nThe functions opProcessorRead and opProcessorWrite can be used to access processor memory without making any change to the processor state, for example if used with a debugger, rather than as part of a platform model. This table compares their behavior with the debugAccess argument, True and False:\n\n<table>\n<thead>\n<tr>\n<th>Function</th>\n<th>debugAccess</th>\n<th>TLM2.0</th>\n<th>Effect on tlb</th>\n<th>Bad access</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>opProcessorRead</td>\n<td>True</td>\n<td>transport_dbg</td>\n<td>None</td>\n<td>returns 'False'</td>\n</tr>\n<tr>\n<td>opProcessorWrite</td>\n<td>True</td>\n<td>transport_dbg</td>\n<td>None</td>\n<td>returns 'False'</td>\n</tr>\n<tr>\n<td>opProcessorRead</td>\n<td>False</td>\n<td>b_transport</td>\n<td>might update</td>\n<td>bus err if supported</td>\n</tr>\n<tr>\n<td>opProcessorWrite</td>\n<td>False</td>\n<td>b_transport</td>\n<td>might update</td>\n<td>bus err if supported</td>\n</tr>\n</tbody>\n</table>\n\n12.2.3 Swapping data to host endian\n\nThe functions opProcessorRead and opProcessorWrite can be used to convert the data endianness between that of the simulated processor and the host.\nThe *endian* argument controls the treatment of byte order in the host memory pointed to by *buffer*:\n\n<table>\n<thead>\n<tr>\n<th>Endian</th>\n<th>Effect</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>OP_HOSTENDIAN_HOST</td>\n<td>Byte swapped, if necessary, to be host endian</td>\n</tr>\n<tr>\n<td>OP_HOSTENDIAN_TARGET</td>\n<td>No swapping; result will be same as target processor</td>\n</tr>\n<tr>\n<td>OP_HOSTENDIAN_BIG</td>\n<td>Byte swapped, if necessary, to be big endian</td>\n</tr>\n<tr>\n<td>OP_HOSTENDIAN_LITTLE</td>\n<td>Byte swapped, if necessary, to be little endian</td>\n</tr>\n</tbody>\n</table>\n\nIf required, the bytes in each group of *objectSize* bytes, will be reversed, throughout the whole buffer (if *objectSize* = 1 byte, there can be no swapping).\n\nA request to read or write can cross boundaries between different types of memory, or regions where no device exists. The functions return *True* if the entire buffer was read or written successfully, *False* if any part failed.\n\nThe *processor* argument refers to the target processor for the read or write. The required endianness is that of the *data* endian of the processor, which might differ from the *code* endian.\n\n### 12.3 Explicit Local and External Memory\n\nThe previous example in this section “Memory Operations” has used an implicit RAM memory that covers the entire address space that can be accessed by the processor type. Instead of doing this, processor address spaces can be explicitly specified to contain separate RAMs and ROMs, with some perhaps shared between processors in a multiprocessor system. This is typically created in the module iGen definition, see the document [*iGen_Platform_and_Module_Creation_User_Guide*](#). It is also possible to specify that certain address ranges will be modeled by callback functions, which is useful for modeling simple memory-mapped devices such as uarts.\n\n#### 12.3.1 Local Memory\n\nThe following would normally be generated as part of the module definition using iGen but is shown here to provide the complete methodology for hardware definition.\n\nIn order to use an explicit address space mapping, it is first necessary to create a bus to which all address-mapped components will be connected. A bus is defined using the function `opBusNew`, which takes a bus name and bit width as arguments, for example:\n\n---\n\n4 But note that in general, it is much better to use Imperas PSE objects to model peripherals, instead of coding them directly in OP, for many reasons:\n\n1. PSE models run in a protected address space and cannot crash the simulator;\n2. PSE models allow concepts such as simulation time and threading to be handled elegantly;\n3. A platform consisting of processor models and PSEs is ideally suited to debug with the Imperas debugger;\n4. PSEs can be analyzed using tools built with Imperas intercept technology without having to modify and recompile the platform.\n\nSee the [*OVP Peripheral Modeling Guide*](#) for detailed information on PSEs.\n\n---\noptBusP bus = opBusNew(\"bus\", 32);\n\nThis example defines a new bus called ‘bus’ which is 32 bits wide.\n\nThe bus must be connected to any processor that uses it by defining the optConnectionsP in the opProcessorNew function using the OP_BUS_CONNECTIONS and OP_BUS_CONNECT macros. The processor connects by two busses, the instruction bus and the data bus (the simulator permits processors to have distinct data and instruction busses). Most processors use the same address space for both data and instruction accesses, so often the bus arguments have the same value:\n\noptProcessorP cpu1_c = opProcessorNew(\n mi,\n cpu1_path,\n \"cpu1\",\n OP_CONNECTIONS(\n OP_BUS_CONNECTIONS(\n OP_BUS_CONNECT(mainBus_b, \"INSTRUCTION\"),\n OP_BUS_CONNECT(mainBus_b, \"DATA\")\n )\n ),\n 0\n);\n\nAny number of memory objects can then be defined and connected to the bus. A memory is defined using opMemoryNew, which takes a memory name, access privileges, address range and connections as arguments, for example:\n\nopMemoryNew(\n mi,\n \"mem1\",\n OP_PRIV_RWX,\n 0x003fffff,\n OP_CONNECTIONS(\n OP_BUS_CONNECTIONS(\n OP_BUS_CONNECT(mainBus_b, \"sp1\", .slave=1,\n .addrLo=0x01000000, .addrHi=0x013fffff)\n )\n ),\n 0\n);\n\nThis example defines a new memory called mem1 which has an address range 0:0x3fffff (i.e. it is of size 0x400000). The access privileges for the memory are defined by the enumeration type optPrivE in op.h.\nOP_PRIV_NONE No access permitted.\nOP_PRIV_R Read permitted.\nOP_PRIV_W Write permitted.\nOP_PRIV_RW Read and write permitted.\nOP_PRIV_X Execute permitted.\nOP_PRIV_RX Read and execute permitted.\nOP_PRIVWX Write and execute permitted.\nOP_PRIV_RWX Read, write and execute permitted.\nOP_PRIV_ALIGN Force accesses to be aligned.\n\n⇒ Note that the address argument to opMemoryNew is the memory upper bound, not the memory size. This is so that it is possible to define a memory of size 2^64 bytes, i.e. to cover the full range of a 64-bit address space.\n\n⇒ The highAddr is the high address within the memory, it is NOT the address at which the memory is decoded when connected onto a bus. The decoded address range for the memory is bus base address to bus base address + highAddr.\n\nThe memory is connected to a bus in this example using port sp1 of the memory (memories may be multiport, and can be connected to several busses using different port names, however, it is usual to use one or more bridges to connect memory regions from multiple busses onto a single bus on which the memory resides). The memory is connected with memory address 0 mapped to bus address 0x01000000.\n\nMemories defined with opMemoryNew use the simulator’s internal memory modeling capabilities. It is possible as an alternative to specify that a memory range should be modeled using a callback function instead. This is done using opBusSlaveNew:\n\n12.3.2 External Memory: Mapping an address region to a callback\n\nIn this example, an address region is mapped to read and write callbacks supplied by a user's functions.\n\ntypedef struct extMemDescS {\n void *localSource;\n void *localSink;\n} extMemDesc;\n\n// called when a read occurs in the range 0x00400000, 0x00400fff,\n// copies data from localSource;\n\nOP_BUS_SLAVE_READ_FN(extMemReadCB) {\n extMemDesc *p = userData;\n memcpy(data, p->localSource, bytes)\n}\n// called when a write occurs in the range 0x00400000, 0x00400fff,\n// copies data to localSink;\n\nOP_BUS_SLAVE_WRITE_FN(extMemWriteCB) {\n extMemDesc *p = userData;\n memcpy(p->localSink, data, bytes)\n}\n\nstatic extMemDesc extMem;\n\nopBusSlaveNew(\n bus, \"external\", 0, OP_PRIV_RWX, 0x00400000, 0x00400fff,\n extMemReadCB, extMemWriteCB, 0, &extMem\n);\n\nThis example specifies that the range 0x400000:0x400fff on the bus should not be\nmodeled using simulated memory, but should instead be implemented using two callback\nfunctions, extMemReadCB and extMemWriteCB. These callback functions are specified\nusing the OP_BUS_SLAVE_READ_FN and OP_BUS_SLAVE_WRITE_FN macros. Any time a\nsimulated processor or device performs a memory read or write in this address range, the\nappropriate callback function will be called. The write callback will be passed the value\nbeing written in the data argument. The read callback should fill the data buffer with\nbytes bytes of data (the required contents for a read at the passed address).\n\n12.3.2.1 Generating an Invalid access\n\nDuring the read or write callback functions, defined by OP_BUS_SLAVE_READ_FN\nand OP_BUS_SLAVE_WRITE_FN only, the client might decide that the access cannot\nbe completed. To signal this, either function opProcessorReadAbort or\nopProcessorWriteAbort should be called by the client in the read or write callback\nrespectively.\n\nUse opProcessorReadAbort when the callback was initiated by either of these functions:\n\nopProcessorRead\nopBusRead\n\nUse opProcessorWriteAbort when the callback was initiated by either of these\nfunctions:\n\nopProcessorWrite\nopBusWrite\n\nIn no other context should opProcessorReadAbort or opProcessorWriteAbort be\ncalled.\nIf the initiating processor model implements `rdAbortExceptCB` or `wrAbortExceptCB` callback functions in its `vmiAttrs` structure, then the appropriate callback will be invoked to allow the processor model to handle the abort. Otherwise, simulation will be terminated with a memory abort error message.\n\n### 12.3.2.2 Processor Instruction Execution\n\nWhen the memory represented by or accessed through an external memory callback is used to store the executable binary to be executed by the processor, the external memory callback will be called for the processor instruction fetch access but also as an artifact of simulation.\n\nIn order to distinguish between a real instruction fetch and a simulation artifact, the `optProcessorP` processor argument should be used within the callback. If the read is a processor instruction fetch, the `processor` argument will be a pointer to the processor making the access. If the read is a simulation artifact, then the `processor` argument will be NULL, indicating that it is not a processor making this access.\n\n### 12.3.2.3 Example\n\nThis example is found in the `usingExternalMemory` directory:\n\n```\n$IMPERAS_HOME/Examples/PlatformConstruction/usingExternalMemory\n```\n\nThe example shows how a region of memory could be mapped externally in the module to simulate an area memory with read only privileges.\n\nModule iGen defines the fixed memory\n\nAnd the module C file is used to define the dynamic memory added using callbacks\n\n```c\n// map the address range 0x00400000:0x004000ff externally to the processor,\nopBusSlaveNew ( \n bus, \"externalRW\", OP_PRIV_R, 0x00400000, 0x004000ff,\n extMemReadCB, extMemWriteCB, 0\n);\n// map the address range 0x00400110:0x0040010f externally to the processor,\n// generate abort\nopBusSlaveNew ( \n bus, \"externalRW\", OP_PRIV_R, 0x00400100, 0x0040010f,\n extMemReadCB, extMemWriteCB, 0\n);\n// map the address range 0x00400110:0x004001ff externally to the processor,\n// read only\nopBusSlaveNew ( \n```\nThe callbacks are defined using the macros as:\n\n```c\nstatic OP_BUS_SLAVE_READ_FN(extMemReadCB) {\n *(Uns32 *)data = (Uns32)0xcefaedfe;\n opMessage(\"I\", \"EXTERNAL MEMORY\", \"Reading 0x%08x from 0x%08x\\n\", data, (Uns32)address);\n}\nstatic OP_BUS_SLAVE_WRITE_FN(extMemWriteCB) {\n opMessage(\"I\", \"EXTERNAL MEMORY\", \"Writing 0x%08x to 0x%08x\\n\", (Int32)value, (Int32)address);\n}\n```\n\nThis very simple ROM implementation returns the fixed pattern 0xcefaedfe for any read from the ROM area and ignores any write (obviously a real example can do something much more sophisticated than this if required).\n\nCompile the test platform and application as before using the following commands in the memory directory:\n\n```bash\nmake –C module\nmake –C application\n```\n\nTo run the simulation, in the memory directory, run:\n\n```bash\nharness.exe –modulefile module –--program application/asmttest.OR1K.elf –trace –tracechange –--traceshowicount\n```\n\nYou should see the following output:\n\n```\n... lines deleted ...\nProcessor Exception (PC_PRX) Processor 'platform/cpu1' 0x1000098: l.sw 0x0(r4),r5\nProcessor Exception (PC_WPX) No write access at 0x400000\n```\nNote that:\n\n1. The load and store to the external memory region ‘externalRW’ are performed correctly.\n2. The load to the external memory region ‘externalR’ is performed correctly but the store causes an exception – this is because the external region was specified to have read access permission only.\n3. Although the read memory callback returns the value 0xcefaedfe, the value that gets loaded into register R5 of the OR1K processor is 0xfeedface. This is because the native host (x86) is little-endian, whereas the OR1K processor is big-endian. Depending on the processor being used, memory callbacks may be required to perform endian swapping to get the desired results.\n4. The simulator reports the exception (and returns OP_SR_WR_PRIV from opRootModuleSimulate, although this isn’t explicitly shown in this example). The OP_FP_SIMULATEEXCEPTIONS instance attribute could be used to cause the exception to be simulated instead.\n\n12.3.3 External Memory: Using Native Memory\n\nSome usages of the OP API require that simulated memory be allocated by the program rather than using opMemoryNew and allowing the simulator to allocate and maintain the memory. The function opMemoryNativeDynamic enables such use of native memory in a platform.\n\nNote that since each call to opMemoryNativeDynamic requires a contiguous block of memory, this method is not suitable for modeling memory whereby the size is similar to, or larger than the memory of the host machine. Conversely, memories created using opMemoryNew can be specified to be as large as desired, and backing the store for such memories is allocated on demand, using a sparse implementation.\n\n12.3.3.1 Example\n\nThis example is found in the nativeMemory directory.\n\n$IMPERAS_HOME/Examples/PlatformConstruction/nativeMemory\n\niGen definition of static module components\n\nihwnew -name simpleCpuMemory\n\nihwaddbus -instancename mainBus -addresswidth 32\n\nihwaddprocessor -instancename cpu1 \\\n -vendor ovpworld.org -library processor -type or1k -version 1.0 \\\n -semihostname or1kNewlib -variant generic\nihwconnect -bus mainBus -instancename cpu1 -busmasterport INSTRUCTION\nihwconnect -bus mainBus -instancename cpu1 -busmasterport DATA\n\nihwaddmemory -instancename mem1 -type ram\nihwconnect -bus mainBus -instancename mem1 \\ \n -busslaveport sp1 -loaddress 0xf0000000 -hiaddress 0xffffffff\n\nthis creates the following fixed definition\n\n optBusP bus_b = opBusNew(mi, \"bus\", 32, 0, 0);\n \n opMemoryNew(\n mi,\n \"mem1\",\n OP_PRIV_RWX,\n (0xffffffff) - (0xf0000000),\n OP_CONNECTIONS(\n OP_BUS_CONNECTIONS(\n OP_BUS_CONNECT(bus_b, \"sp1\", .slave=1,\n .addrLo=0xf0000000, .addrHi=0xffffffff)\n )\n ),\n 0\n );\n\nIn the generated module C file we can then add the dynamic memory\n\ntypedef struct optModuleObjectS {\n Uns32 msize; // size of allocated memory\n void *mem; // allocated memory\n} optModuleObject;\n\n// forward declaration of component constructor\nstatic OP_CONSTRUCT_FN(instantiateComponents);\n\nstatic OP_CONSTRUCT_FN(moduleConstructor) {\n\n // instantiate module components\n instantiateComponents(mi, object);\n\n // create native memory (64K)\n object->msize = 0x10000;\n object->mem = STYPE_ALLOC_N(Uns8, object->msize);\n\n // terminate if memory allocation failed\n if (!object->mem)\nopMessage(\"F\", \"MODULE\", \"Failed to allocate native memory\");\n\n// get first bus in module\noptBusP bus = opBusNext(mi, NULL);\nif (!bus)\n opMessage(\"F\", \"MODULE\", \"Did not find a bus in module \",\n opObjectName(mi));\n\n// connect memory to bus at address range 0x0000:0xffff\nopMemoryNativeNew(\n mi, \"native\", OP_PRIV_RWX, object->msize-1, object->mem,\n OP_CONNECTIONS(\n OP_BUS_CONNECTIONS(\n OP_BUS_CONNECT(bus, \"sp1\", .addrLo=0x0, .addrHi=object->msize-1)\n ),\n ),\n);\n\n⇒ NOTE the use of STYPE_ALLOC_N which is an Imperas provided wrapped\n function (see ImpPublic/include/hostapi/impAlloc.h) with the same result as\n malloc.\n\nA processor connected to 'bus' will see memory mapped at 0x0 to 0xFFFF and\n0xF0000000 to 0xFFFFFFFF, however the command line argument --showbuses will\nonly show the statically defined areas\n\nBUS CONNECTIONS: nativeMemory/mainBus (0:ffffffff)\n sp1 on nativeMemory/mem1 (f0000000:ffffffff)\nDATA on nativeMemory/cpu1 (0:0)\nINSTRUCTION on nativeMemory/cpu1 (0:0)\n\nTo see all the regions the command line argument --showdomains can be used\n\nBUS simpleCpuMemory/mainBus: DOMAIN simpleCpuMemory/mainBus REGIONS:\n 1: 0x00000000:0x00000fff type:RAM priv:rwx raw:rwx list:0 opt:RW flags:MD..... \n blocks:0 device:.. (master -,native,0x08e76230:0x08e7722f)\n 2: 0xf0000000:0xffffffff type:RAM priv:rwx raw:rwx list:0 opt:.. flags:....... blocks:0 device:\n\n⇒ Making the native memory smaller than the boundaries described by\nopMemoryNativeDynamic can cause memory corruptions, because the simulator\nmay attempt to write beyond the bounds of the allocated space.\n\nThe allocated region of memory should be freed in the post simulation callback\n12.3.4 External Memory: Combining Callbacks and Native Memory\n\nOccasionally, it can be useful to specify memory regions that combine aspects of mapping using external callbacks and mapping using native memory pointers (in other words, a combination of the effects of `opBusSlaveNew` and `opMemoryNativeDynamic`). For example, it might be the case that a memory region should be mapped natively for read accesses, but use a callback for write accesses. In such cases, function `opBusSlaveNew` can be used:\n\n```c\nvoid opBusSlaveNew ( \n optBusP bus, \n const char* portName, \n optProcessorP processor, \n optPriv priv, \n Addr lowAddr, \n Addr highAddr, \n optBusSlaveReadFn readCB, \n optBusSlaveWriteFn writeCB, \n void* nativeMemory, \n void* userData );\n```\n\nTo specify how the memory is used, three arguments may be used in various combinations:\n\n1. **readCB**: if non-NULL, this indicates that read accesses to the memory should use this callback. If NULL, then read accesses should be performed directly using pointer memory.\n2. **writeCB**: if non-NULL, this indicates that write accesses to the memory should use this callback. If NULL, then write accesses should be performed directly using pointer memory.\n3. **memory**: this is a native pointer to be used for read or write accesses when either the read or write callback function is NULL.\n\n12.3.5 Debugging Bus Connections\n\nWhen there are many connections to a bus, visualizing the connections can be difficult, to help, there are functions to help show what is connected on a bus or all busses in a module:\n\n```c\nvoid opBusShow(optBusP bus); \nvoid opModuleBusShow(optModuleP module); \n```\nGiven a bus, the opBusShow function prints details of all the master (e.g. processors) and slaves (e.g. memories) currently connected to that bus. As an example, the output might look like this:\n\n**BUS MASTERS: 2**\n- PORT 'DATA' of 'cpu1'\n- PORT 'INSTRUCTION' of 'cpu1'\n\n**BUS SLAVES: 2**\n- 0x00000000:0x003fffff: PORT 'mp1' of 'mem1'\n- 0x00400000:0x00400fff: MAPPED r-- RCB:0x8048808 WCB:0x8048857\n- 0x00401000:0xffffffff: PORT 'mp2' of 'mem2'\n\nGiven a module, the opModuleBusShow function prints details of all the master and slaves currently connected to each of the busses in the module. As an example, the output might look like this:\n\n**BUS MASTERS: 2**\n\nThe same output can also be obtained using the command line argument `--showbusses`.\n\nThe opBusShow, opModuleBusShow and `--showbuses` provide a static view of the platform bus connections, they do not show any dynamic bus connections. The command line arguments are processed as the initial platform construction has been completed and so they also cannot show any dynamic changes during execution.\n\nThe memories have a dynamic view using the memory domains. These can be displayed using the opModuleDomainDebug function or the command line argument `--showdomains`. The command line argument provides the initial view after construction, the opModuleDomainDebug could be called at any time to provide the current dynamic memory mappings.\n\n### 12.4 Adding Memory Access Callbacks\n\nAdding monitor or watchpoint callbacks across address regions allows address accesses to be observed. A monitor or watchpoint callback can be executed whenever there is either a read, a write or a fetch access to a specified range of memory addresses.\n\nThe monitoring of address accesses can show the behavior of a processor as it runs an application.\n\nThe watchpoint callback can be used to stop the simulation i.e. return from the opRootModuleSimulate or opProcessorSimulate functions.\n\nThe monitors or watchpoints can be placed on a processor access, a bus access or a memory access.\n12.4.1.1 Adding a Memory Monitor\n\nThe monitor callbacks can be created for address ranges accessed by a processor, on a bus or to a memory.\n\n12.4.1.2 Monitoring Processor Accesses\n\nThe access, read, write or instruction fetch, from a specific processor can be monitored using `opProcessorReadMonitorAdd`, `opProcessorWriteMonitorAdd` and `opProcessorFetchMonitorAdd` functions respectively.\n\n```c\n// watch read accesses to the address range 0x01000000:0x01000fff\nopProcessorReadMonitorAdd(processor, 0x01000000, 0x01000fff, readCallback, 0);\n\n// watch write accesses to the address range 0x01000000:0x01000fff\nopProcessorWriteMonitorAdd(processor, 0x01000000, 0x01000fff, writeCallback, 0);\n\n// watch instruction fetch accesses to the address range 0x01000000:0x01000fff\nopProcessorFetchMonitorAdd(processor, 0x01000000, 0x01000fff, fetchCallback, 0);\n```\n\n12.4.1.3 Monitoring Accesses Over a Bus\n\nAn access, read, write or instruction fetch, on a specific bus can be monitored using `opBusReadMonitorAdd`, `opBusWriteMonitorAdd` and `opBusFetchMonitorAdd` functions respectively.\n\n```c\n// watch read accesses to the address range 0x01000000:0x01000fff\nopBusReadMonitorAdd(bus, proc, 0x01000000, 0x01000fff, readCallback, 0);\n\n// watch write accesses to the address range 0x01000000:0x01000fff\nopBusWriteMonitorAdd(bus, proc, 0x01000000, 0x01000fff, writeCallback, 0);\n\n// watch instruction fetch accesses to the address range 0x01000000:0x01000fff\nopBusFetchMonitorAdd(bus, proc, 0x01000000, 0x01000fff, fetchCallback, 0);\n```\n\nThe second argument (`proc`) is an optional processor argument that may be provided, if set to a processor handle the bus access monitor will only be triggered on an access by the specific processor, for monitoring any bus access this argument should be set to NULL.\n\n12.4.1.4 Monitoring Accesses to a Memory\n\nAn access, read, write or instruction fetch, on a specific memory can be monitored using `opMemoryReadMonitorAdd`, `opMemoryWriteMonitorAdd` and `opMemoryFetchMonitorAdd` functions respectively.\n\n```c\n// watch read accesses to the address range 0x01000000:0x01000fff\nopMemoryReadMonitorAdd(memory, 0x01000000, 0x01000fff, readCallback, 0);\n\n// watch write accesses to the address range 0x01000000:0x01000fff\nopMemoryWriteMonitorAdd(memory, 0x01000000, 0x01000fff, writeCallback, 0);\n\n// watch instruction fetch accesses to the address range 0x01000000:0x01000fff\nopMemoryFetchMonitorAdd(memory, 0x01000000, 0x01000fff, fetchCallback, 0);\n```\n// watch read accesses to the address range 0x01000000:0x01000fff\nopMemoryReadMonitorAdd(mem, proc, 0x01000000, 0x01000fff, readCallBack, 0);\n\n// watch write accesses to the address range 0x01000000:0x01000fff\nopMemoryWriteMonitorAdd(mem, proc, 0x01000000, 0x01000fff, writeCallBack, 0);\n\n// watch instruction fetch accesses to the address range 0x01000000:0x01000fff\nopMemoryFetchMonitorAdd(mem, proc, 0x01000000, 0x01000fff, fetchCallBack, 0);\n\nThe second argument (proc) is an optional processor argument that may be provided, if set to a processor handle the Memory access monitor will only be triggered on an access by the specific processor, for monitoring any Memory access this argument should be set to NULL.\n\n12.4.1.5 Example\n\nThis example is found in the monitorAccesses directory.\n\n$IMPERAS_HOME/Examples/SimulationControl/monitorAccesses\n\nThis example shows the use of a monitor to trap a write to a specific address. In the main function of the harness a callback on a write to a word at 0x00400000 is added. The userData field is used to pass a name of the watch point to the callback function.\n\n// triggered when registered access happens and prints information of access\n//\nstatic OP_MONITOR_FN(monitorCallback) {\n opMessage(\"I\", PREFIX \"_MT\",\n \"Monitor triggered: \",\n \"callback '%s': processor '%s': \",\n \"type '%s': bytes %u : \",\n \"address Physical 0x\" FMT_A0Nx \" Virtual 0x\" FMT_A0Nx,\n __FUNCTION__,\n processor ? opObjectName(processor) : \"artifact\", // if no processor this is an artifact access\n (const char*)userData,\n bytes,\n addr,\n VA\n );\n}\n// iterate across the processors found in the module and register callbacks for read, write and fetch\n//\nstatic void monitorProcessor(optModuleP mi) {\n\n optModuleP mod;\n\n if (!(mod = opObjectByName(mi, MODULE_INSTANCE, OP_MODULE_EN).Module)) {\n opMessage(\"F\", PREFIX \"_NFW\", \"Can not find module(%s)\", MODULE_INSTANCE);\n }\n\n // iterate across all processors found in module\n optProcessorP processor = 0;\n while ((processor = opProcessorNext(mod, processor))) {\n\n Addr max = 0;\n optBusPortConnP bpc = opObjectByName(processor, \"DATA\", OP_BUSPORTCONN_EN).BusPortConn;\n if(bpc) {\n optBusP bus = opBusPortConnBus(bpc);\n max = opBusMaxAddress(bus);\n }\n Addr min = 0;\n\n opMessage(\"I\", PREFIX \"_BM\", \"Add monitor for '%s' (0x\" FMT_A0Nx \" to 0x\" FMT_A0Nx \")n\", opObjectHierName(processor), (Addr)0, max);\n\n opProcessorFetchMonitorAdd(processor, 0, min, max, monitorCallback, \"processor-fetch\");\n opProcessorReadMonitorAdd(processor, 0, min, max, monitorCallback, \"processor-read\");\n opProcessorWriteMonitorAdd(processor, 0, min, max, monitorCallback, \"processor-write\");\n\n }\n}\n\n//\n// iterate across the busses found in the module and register callbacks for read, write and fetch\n//\nstatic void monitorBus(optModuleP mi) {\n\n\n```c\noptModuleP mod;\n\nif (!(mod = opObjectByName (mi, MODULE_INSTANCE,\nOP_MODULE_EN).Module)) {\n opMessage (\"F\", PREFIX \"_NFW\", \"Can not find module(%s)\",\nMODULE_INSTANCE);\n}\n\n// iterate across all busses found in module\noptBusP bus = 0;\nwhile ((bus = opBusNext(mod, bus))) {\n\n Addr max = opBusMaxAddress(bus);\n Addr min = 0;\n\n if (options.busshow) {\n opBusShow(bus); // print the bus connections for each bus found\n } else {\n\n opMessage(\"I\", PREFIX \"_BM\", \"Add monitor for '%s' (0x\" FMT_A0Nx \" to 0x\"\nFMT_A0Nx \")\\n\",\n opObjectHierName(bus), (Addr)0, max);\n\n opBusFetchMonitorAdd(bus, 0, min, max, monitorCallback, \"bus-fetch\");\n opBusReadMonitorAdd (bus, 0, min, max, monitorCallback, \"bus-read\");\n opBusWriteMonitorAdd(bus, 0, min, max, monitorCallback, \"bus-write\");\n }\n}\n}\n\n// iterate across the memories found in the module and register callbacks for read, write and fetch\n//\nstatic void monitorMemory(optModuleP mi) {\n\n optModuleP mod;\n\n if (!(mod = opObjectByName (mi, MODULE_INSTANCE,\nOP_MODULE_EN).Module)) {\n opMessage (\"F\", PREFIX \"_NFW\", \"Can not find module(%s)\",\nMODULE_INSTANCE);\n }\n```\n\n// iterate across all memories found in module\noptMemoryP memory = 0;\nwhile ((memory = opMemoryNext(mod, memory))) {\n\n Addr max = opMemoryMaxAddress(memory);\n Addr min = 0;\n\n opMessage(\"I\", PREFIX \"_BM\", \"Add monitor for '%s' (0x\" FMT_A0Nx \" to 0x\" FMT_A0Nx \")n\",\n opObjectHierName(memory), (Addr)0, max);\n\n opMemoryFetchMonitorAdd(memory, 0, min, max, monitorCallback, \"memory-fetch\");\n opMemoryReadMonitorAdd (memory, 0, min, max, monitorCallback, \"memory-read\");\n opMemoryWriteMonitorAdd(memory, 0, min, max, monitorCallback, \"memory-write\");\n}\n\nThe callback functions used for a read, a write or a fetch should be defined using the macro OP_MONITOR_FN. The callback function is defined below.\n\n//\n// triggered when registered access happens and prints information of access\n//\nstatic OP_MONITOR_FN(monitorCallback) {\n opMessage (\"I\", PREFIX \"_MT\",\n \"Monitor triggered: \":\n \"callback '%s': processor '%s' : \":\n \"type '%s': bytes %u : \":\n \"address Physical 0x\" FMT_A0Nx \" Virtual 0x\" FMT_A0Nx,\n __FUNCTION__,\n processor ? opObjectName(processor) : \"artifact\", // if no processor this is an artifact access\n (const char*)userData,\n bytes,\n addr,\n VA\n );\n}\nTo run the example, compile the test harness, the module and the application using the following commands in the `monitorAccess` point directory:\n\n```\nmake –C harness\nmake –C module\nmake –C application CROSS=OR1K\n```\n\nTo run the simulation, in the `monitorAccess` directory, run:\n\n```\n./ # run the harness\n./harness/harness.Linux32.exe \\\n --program application/application.OR1K.elf\n```\n\nYou should see output similar to the following:\n\n---\n\n12.4.2 Adding a Memory Watchpoint\n\nUnlike the Memory Monitor a Memory Watchpoint can cause the simulation to return to the harness and so return control.\n\n`OP_ADDR_WATCHPOINT_CONDITION_FN`\n\nNote that:\n\n1. The load from address 0x00400000 is captured by the write callback.\n2. The simulation is set to finish before the next instruction, which is not executed.\n3. The status code passed as the second argument to `opModuleFinish` is printed just before the simulation exits.\n13 Simulation Optimization\n\nA simulator using the OP interface is at liberty to pre-read code that is going to simulate, then make internal optimization to run that code as quickly as possible. If that code is then modified by another processor or PSE model, or by an OP API call (e.g., opProcessorWrite()), then the simulator must discard and re-generate its optimizations. If however, the code is stored in memory created using opMemoryNativeNew() and modified by an agent external to OP, the simulator will not know its code is invalid. The Programmer must therefore notify the simulator using opProcessorFlush().\n\n13.1 Example\n\nIn the module creation a native memory is created and connected onto the bus that has been found in the module. If multiple busses are contained in the module an alternative function, opObjectByName, could be used to find a specific bus or processor.\n\n```c\n// assume single bus, so first is the one we want\noptBusP bus = opBusNext(mi, NULL);\nif (!bus)\n opMessage(\"F\", \"MOD\", \"No bus in module \", .objName(mi));\n\n// An area of native memory\nUns32 memsize = 0x03E07FFF - 0x03E00000+1;\nvoid *nativePointer = STYPE_ALLOC_N(memsize, char);\nmemset(nativePointer, 0, memsize);\n\n// connect memory\nopMemoryNativeNew(mi,\n \"Native\",\n OP_PRIV_RWX,\n memsize-1,\n nativePointer,\n OP_CONNECTIONS(\n OP_BUS_CONNECTIONS(\n OP_BUS_CONNECT(bus1, \"sp1\", slave=1,\n .addrLo=0x03E00000, .addrHi=0x03E07FFF)\n )\n ),\n 0\n);\n```\nDuring simulation it is possible that the memory may be changed, for example an update from an external source as shown in this example code using a memcpy to modify the memory region\n\n```c\n... // assume single processor, so first is the one we want\n optProcessorP proc = opProcessorNext(mi, NULL);\n if (!proc)\n opMessage(\"F\", \"MOD\", \"No processor in module \"%s\"\", opObjectName(mi));\n\n // copy newData into the native memory region\n memcpy(nativePointer, newData, memsize);\n\n // flush processor for the modified address range\n opProcessorFlush(proc, 0x03E00000, 0x03E00000+memsize -1);\n```\n\nWhen the processor is now allowed to continue simulation, it will re-optimize any code that has been executed from this memory region.\n14 Enabling Peripheral Diagnostics\n\nA peripheral model can be written to provide diagnostics information during its execution. The diagnostics can be defined by the model developer using the modeling equivalent of printf within the model (model diagnostics) or provided from the simulation system (system diagnostics).\n\n14.1 Model Diagnostics\n\nThe model diagnostics are controlled by setting the diagnostic level of the peripheral model. This is enabled in the platform after the PSE has been instantiated using the `opPeripheralDiagnosticLevelSet` function call.\n\nIt is standard to provide 3 levels of diagnostics within the model diagnostics, each higher level providing a super set of lower level diagnostics.\n\nFor a PSE based peripheral the diagnostics would be controlled by values of 0, 1, 2, or 3 being written.\n\n0 No diagnostics\n1 Low diagnostics\n2 Medium diagnostics\n3 High diagnostics\n\nBy setting a value higher than 16 System level diagnostics may also be enabled and displayed in conjunction with the model based diagnostics level set.\n\n16 System diagnostics. At this level (and above) the simulator automatically reports net and register callbacks, without the addition of code to the model.\n\nThe example code below would set the diagnostics to the highest level and so provide the most verbose output. This could provide details down to the individual register level.\n\n```c\nopPeripheralDiagnosticLevelSet(vga, 3);\n```\n\n14.2 Intercept Library Diagnostics\n\nWhen the peripheral's behavior is created using native code within an interception library the diagnostics must be passed through the PSE part of the model using the same mechanism as for the model diagnostics, mentioned earlier.\n\nThe recommended approach is to use high order bits in the diagnostic level for the intercept library. So, for example, to turn on the highest diagnostics level for both the PSE and Native elements of a peripheral model, we can use bits 0 and 1 for the PSE and 4 and 5 for the Native.\n... #define PSE_DIAG_HIGH 3\n#define PSE_DIAG_MEDIUM 2\n#define PSE_DIAG_LOW 1\n#define INT_DIAG_HIGH (3<<4)\n#define INT_DIAG_MEDIUM (2<<4)\n#define INT_DIAG_LOW (1<<4)\n...\n\n```\n opPeripheralDiagnosticLevelSet(vga, INT_DIAG_HIGH | PSE_DIAG_HIGH);\n```\n\n### 14.3 Peripheral Debug Support\n\nWhen simulating a platform with the Imperas professional simulator (CpuManager) full symbolic debug is available for each peripheral (PSE) model within the integrated debug environment, iGui or eGui.\n\n### 14.4 Controlling peripheral model diagnostics\n\nThe diagnostics generated by a peripheral model can be individually controlled by the use of overrides either applied on the command line or in the harness. Alternatively, the diagnostic level can be set for all the peripheral models in the entire design on the command line.\n\n#### 14.4.1 From Command Line\n\nThe overrides that can be applied in a design from the command line can be found using the `--showoverrides` argument.\n\nThis will provide a listing similar to that shown (a small extract generated for the MIPS Malta platform) which will show the available overrides:\n\n```\n--override MipsMalta/debugpseconstructors\n--override MipsMalta/idebug\n--override MipsMalta/mi\n...\n--override MipsMalta/PCI_PM/diagnosticlevel\n--override MipsMalta/PCI_PM/trace\n--override MipsMalta/PCI_PM/enabletoolspse\n--override MipsMalta/PCI_PM/PCIslot\n--override MipsMalta/PCI_PM/PCIfunction\n--override MipsMalta/PCI_NET/diagnosticlevel\n--override MipsMalta/PCI_NET/trace\n...\n--override MipsMalta/intCtrlMaster/diagnosticlevel\n```\n--override MipsMalta/intCtrlMaster/trace\n--override MipsMalta/intCtrlMaster/enabletoolspse\n--override MipsMalta/intCtrlMaster/spen\n--override MipsMalta/intCtrlSlave/diagnosticlevel\n--override MipsMalta/intCtrlSlave/trace\n--override MipsMalta/intCtrlSlave/enabletoolspse\n--override MipsMalta/intCtrlSlave/spen\n\nThese may then be applied to the command line to set the diagnostics level for one or more of the peripherals\n\n```\n./harness/harness.Linux32.exe --program application/application.OR1K.elf \\ \n --override MipsMalta/PCI_NET/diagnosticlevel=2 \\ \n --override MipsMalta/intCtrlSlave/diagnosticlevel=2\n```\n\nBy using the command line argument `--modeldiags` the diagnostics level can be set for ALL the peripheral models in the design.\n\nFor example, the following will set all peripheral model diagnostic levels to 2\n\n```\n./harness/harness.Linux32.exe --program application/application.OR1K.elf \\ \n --modeldiags 2\n```\n\n### 14.4.2 From Harness\n\nA diagnostics level may be controlled from the test harness using overrides during the construction phase using the Uns32 parameter override for the peripheral instance as shown below\n\n```\nopParamUns32Override(mi, \"top/u1/peripheral1/\" OP_FP_DIAGNOSTICLEVEL, 2);\n```\n15 Model and Intercept Object Additional Commands\n\nA processor model or an intercept object can install its own commands to be executed as required during simulation. Commands are typically used to enable or disable functionality in the model or intercept object or to extract analysis data that the model or intercept object has been accumulating.\n\nCommands are installed in a processor model using vmirtAddCommand(). See OVP_VMI_Run_Time_Function_Reference.doc.\n\nCommands are installed in a intercept object using vmiosAddCommand(). See OVP_VMI_OS_Support_Function_Reference.doc, and opProcessorExtensionNew() in this document.\n\nCommands are called, from a harness, using opCommandCall(). A command can be called any time after it has been installed and before the simulation terminates, but the user needs to be aware of when installation occurs. Models and intercept objects are recommended to install their commands in their constructors, in which case the earliest 'safe' time to call a command is immediately before opRootModuleSimulate() or opProcessorSimulate().\n\nThis example calls a command that is installed by a processor model and lists all the available commands on the processor using an iterator function\n\n```c\nint main(int argc, const char *argv[]) {\n opSessionInit(OP_VERSION);\n\n opCmdParseStd (argv[0], OP_AC_ALL, argc, argv);\n\n optModuleP mr = opRootModuleNew(0, 0, 0);\n optModuleP mi = opModuleNew(mr, \"module\", \"u1\", 0, 0);\n\n opRootModulePreSimulate(mr);\n\n // get processor, assumes only a single processor\n optProcessorP processor = opProcessorNext(mi, NULL);\n\n // Run the processor for 100 instructions\n opProcessorSimulate(processor, 100);\n\n // Call a command that had been created in a processor model\n // Pointer to the call command result string. This could be any string\n const char *result;\n\n opPrintf(\"Call Model Commands\\n\\n\");\n```\n// Setup command for reading MIPS COP0 registers\nconst char* cmdToExecute = \"u1/cpu1/mipsCOP0\";\noptCommandP cmd = opObjectByName(mr,\n cmdToExecute,\n OP_COMMAND_EN).Command;\nif(!cmd)\n opMessage(\"F\", \"harness\", \"Command '%s' not found\", cmdToExecute);\n\n// Setup calling arguments to read COP0 'Config' register\nconst char *cmd1Argv[] = {\"0\", \"16\", \"0\"};\nresult = opCommandCall( cmd,\n 3,\n cmd1Argv);\n\nopPrintf(\"Call Command result \"%s\"\\n\", result);\n\n// Setup calling arguments to read COP0 'PrId' register\nconst char *cmd2Argv[] = {\"0\", \"15\", \"0\"};\nresult = opCommandCall( cmd,\n 3,\n cmd2Argv);\n\nopPrintf(\"Call Command result \"%s\"\\n\", result);\n\nopPrintf(\"Discover installed commands\\n\");\n\n// iterates over all commands on all processor instances\nopModuleCommandsShow(mi);\n\nconst char *procName = \"cpu1\";\nopPrintf(\"Commands for %s\\n\", procName);\noptProcessorP proc = opObjectByName(mi, procName,\n OP_PROCESSOR_EN).Processor;\n\n// iterates over all commands on this processor instance\nopProcessorCommandIterAll(proc, printCommand, 0);\n\nopPrintf(\"Complete Simulation\\n\\n\");\n\n// run simulation to completion\nopRootModuleSimulate(mr);\nopSessionTerminate();\nreturn 0;\n}\nNote that although each command can use its arguments in any way, it is normal practice to use the Unix convention of passing the command name as the first argument. Thus argv[0] is the command name and argv[1] is the first true argument.\n\nAn example of calling commands that are created within a processor model is in\n\n$IMPERAS_HOME/Examples/SimulationControl/callingInstalledCommands.\n\nThis uses the MIPS32 model commands.\n\nIn harness/harness.c an array is defined for the arguments for the command. This is a Linux like argv, argc array; with argument zero the name of the command\n\n```c\nconst char *cmd1Argv[] = {\"mipsCOP0\", \"-register\", \"16\", \"-select\", \"0\"};\n```\n\nWhen calling the command this array is passed to the opCallCommand function.\n\n```c\nresult = opCommandCall( cmd,\n 5,\n cmd1Argv);\n```\n\nThe result returned from the opCommandCall function is a string passed back from the command itself after execution. It can represent success or failure of the command or it can be an information string; this is command dependent.\n\nAn OP API harness can discover what commands are available, for a module or for a particular processor model.\n\nThe example uses the MIPS32 model commands.\n\nAll the installed commands can be shown for a module using\n\n```c\n// iterates over all commands on all processor instances\nopModuleCommandsShow(mi);\n```\n\nThis provides the output in a form that can be used on the command line to call the command, with the help message provided in brackets\n\nDiscover installed commands\n--callcommand u1/cpu1/mipsCOP0 [query a COP0 register value using <register> <select>]\n--callcommand u1/cpu1/mipsWriteRegister [Write to a processor register using <resource> <offset> <value>]\n--callcommand u1/cpu1/mipsReadRegister [Read a processor register using <resource> <offset>]\nAdvanced Simulation Control of Platforms and Modules User Guide\n\n--callcommand u1/cpu1/mipsCacheEnable [enable tag or full cache model]\n--callcommand u1/cpu1/mipsCacheDisable [Disables tag or full cache model]\n--callcommand u1/cpu1/mipsCacheReport [Report current cache statistics]\n--callcommand u1/cpu1/mipsCacheReset [reset the cache model]\n--callcommand u1/cpu1/mipsCacheRatio [Report current hit ratio for selected cache]\n--callcommand u1/cpu1/mipsCacheTrace [Control the tracing of cache accesses]\n--callcommand u1/cpu1/mipsDebugFlags [Set the processor model debug flags to <value>]\n--callcommand u1/cpu1/itrace [enable or disable instruction tracing]\n--callcommand u1/cpu1/isync [specify instruction address range for synchronous execution]\n\nAlternatively, the commands of a specific processor instance can be extracted and printed by an command function defined using the macro OP_COMMAND_FN. The function is declared using the provided prototype macro. Arguments to the function are the command name and user data.\n\n```c\nstatic OP_COMMAND_FN(printCommand) {\n opPrintf(\"Command %s\\n\", opObjectHierName(command));\n}\n```\n\nThe function printCommand will be called for every installed command on a particular processor:\n\n```c\noptProcessorP proc = opObjectByName(mi, procName, OP_PROCESSOR_EN).Processor;\n\n // iterates over all commands on this processor instance\n opProcessorCommandIterAll(proc, printCommand, 0);\n```\n\nthat provides the output listing the command only\n\nCommands for cpu1\nCommand u1/cpu1/isync\nCommand u1/cpu1/itrace\nCommand u1/cpu1/mipsCOP0\nCommand u1/cpu1/mipsCacheDisable\nCommand u1/cpu1/mipsCacheEnable\nCommand u1/cpu1/mipsCacheRatio\nCommand u1/cpu1/mipsCacheReport\nCommand u1/cpu1/mipsCacheReset\nCommand u1/cpu1/mipsCacheTrace\nCommand u1/cpu1/mipsDebugFlags\nCommand u1/cpu1/mipsReadRegister\nCommand u1/cpu1/mipsWriteRegister\n16 Introspecting and Querying Platforms & Components\n\nAs we have seen in many of the previous examples the OP API provides a large set of functions to allow objects to be found in a simulation and for these objects then to be queried for information.\n\nWhen wishing to obtain information from objects in a design it is possible to search for the object using its name with the opObjectByName function which, using a union of object types, allows the correct type to be returned. The following shows how a bus object named ‘busMain’ would be found within the module instance mi using this function.\n\n```c\noptBusP bus = opObjectByName(mi, “busMain”, OP_BUS_EN).Bus;\n```\n\nAn alternate way of finding the an object is to use a combination of an iterator function and the query functions. The following shows how we could iterate within the same module, mi for the bus named ‘busMain’.\n\n```c\noptBusP bus = 0;\nwhile ((bus = opBusNext(mi, bus))) {\n const char *busName = opObjectHierName(bus);\n if (strcmp(busName,”busMain”)== 0) {\n opPrintf(“Found bus ‘busMain’\n”);\n break;\n }\n}\n```\n\nEach object type has its own iterator and query functions available.\n\n16.1 Platform Introspector: Examples/PlatformConstruction/walker\n\nThe full set of iterator and query functions will not be listed in this document but the example found in IMPERAS_HOME/Examples/PlatformConstruction/walker makes use of all the introspection and query functions in the harness (harness/harness.c) to find objects for each type and fully iterate across them and print their respective information.\n\nThe harness instances a module that contains a processor, bus, peripheral and memory\n\n```c\noptModuleP mi = opRootModuleNew(0, 0, 0);\nif(!options.modulepath) {\n options.modulepath = MODULE_DIR;\n}\nopModuleNew(mi, options.modulepath, MODULE_INSTANCE, 0, 0);\n```\nopRootModulePreSimulate(mi);\n\nand then for this module it calls a ‘walker’ function that given the name of an object from\nwhich to start (obtained from the custom command line argument ‘objectname) iterates\nall the objects\n\n```\n optObjectP startObject = opObjectByName(mi, options.objectname, 0);\n ...\n walkObject(0, startObject);\n ...\n```\n\nThe walkObject function obtains, using the opObjectType(), the optStrType from the\nenumeration optStrTypeE so that it can call the correct object iterator\n\nThe enumeration of object types is\n\n<table>\n<thead>\n<tr>\n<th>Enumeration</th>\n<th>Object Type Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>OP_APPLICATION_EN</td>\n<td>Application program object file.</td>\n</tr>\n<tr>\n<td>OP_BRIDGE_EN</td>\n<td>Instance of a bridge.</td>\n</tr>\n<tr>\n<td>OP_BUS_EN</td>\n<td>Bus interconnect instance.</td>\n</tr>\n<tr>\n<td>OP_BUSSLAVE_EN</td>\n<td>Pair of read/write callbacks on a bus region.</td>\n</tr>\n<tr>\n<td>OP_BUSPORT_EN</td>\n<td>Bus port specification.</td>\n</tr>\n<tr>\n<td>OP_BUSPORTCONN_EN</td>\n<td>Bus port instance.</td>\n</tr>\n<tr>\n<td>OP_COMMAND_EN</td>\n<td>Model or plugin command.</td>\n</tr>\n<tr>\n<td>OP_EXTENSION_EN</td>\n<td>Instance of an extension applied to a model.</td>\n</tr>\n<tr>\n<td>OP_EXTELAB_EN</td>\n<td>An elaborated extension.</td>\n</tr>\n<tr>\n<td>OP_FIFO_EN</td>\n<td>The FIFO instance.</td>\n</tr>\n<tr>\n<td>OP_FIFOPORT_EN</td>\n<td>FIFO port definition.</td>\n</tr>\n<tr>\n<td>OP_FIFOPORTCONN_EN</td>\n<td>FIFO port instance.</td>\n</tr>\n<tr>\n<td>OP_FORMAL_EN</td>\n<td>The formal parameter specifying a legal parameter of a model.</td>\n</tr>\n<tr>\n<td>OP_FORMALENUM_EN</td>\n<td>A name and value pair.</td>\n</tr>\n<tr>\n<td>OP_MEMORY_EN</td>\n<td>Instance of a memory.</td>\n</tr>\n<tr>\n<td>OP_MMC_EN</td>\n<td>Instance of an MMC.</td>\n</tr>\n<tr>\n<td>OP_MMREGISTER_EN</td>\n<td>Memory Mapped Register.</td>\n</tr>\n<tr>\n<td>OP_MODULE_EN</td>\n<td>Instance of a module.</td>\n</tr>\n<tr>\n<td>OP_NET_EN</td>\n<td>Net instance.</td>\n</tr>\n<tr>\n<td>OP_NETMONITOR_EN</td>\n<td>Net callback installed before the platform is built.</td>\n</tr>\n<tr>\n<td>OP_NETPORT_EN</td>\n<td>Net port definition, used when querying the model.</td>\n</tr>\n<tr>\n<td>OP_NETPORTCONN_EN</td>\n<td>Net port connection instance.</td>\n</tr>\n<tr>\n<td>OP_PACKETNET_EN</td>\n<td>Interconnect used to model packet networks such as Ethernet or CAN bus.</td>\n</tr>\n<tr>\n<td>OP_PACKETNETMONITOR_EN</td>\n<td>Packetnet callback installed before the platform is built.</td>\n</tr>\n</tbody>\n</table>\nOnce the object type is known a specific function is called to iterate.\n\nAt a low level we could be walking over a bus instance as shown in the following:\n\n```c\nstatic void walkBus(Uns32 indent, optBusP o){\n indentText(indent++);\n opPrintf(\"Bus: \", opObjectHierName(o));\n indentText(indent);\n opPrintf(\"addrBits : %d\\n\", opBusAddrBits(o));\n walkBusSlaveList(indent, o);\n walkParamList(indent, o);\n walkFormalList(indent, o);\n walkApplicationList(indent, o);\n}\n```\n\nFor this bus instance we walk over and display query information for the objects that are related to the bus, for example the walkBusSlaveList will iterate across all the bus slaves connected to this bus and provide information of that object\n\n```c\nstatic void walkBusSlaveList(Uns32 indent, optBusP o){\n optBusSlaveP ch = 0;\n while((ch = opBusSlaveNext(o, ch))) {\n walkBusSlave(indent, ch);\n }\n}\n```\n\n### 16.2 Running the platform & component introspecting harness: walker\n\nTake a copy of the introspection and query example in\n\n```\n$IMPERAS_HOME/Examples/SimulationControl/walker\n```\n\nThe introspection and query harness and the example module can be built with the following commands\n\n```\n> make –C harness\n> make –C module\n```\nand then executed with\n\n```\n> ./harness/harness.Linux32.exe\n```\n\nThe following output has been reduced to show some of the information that would be observed:\n\n```\nModule: \"\"\n . path : \"(null)\"\n . Formal: \"debugpseconstructors\"\n . Type: \"Boolean\"\n . Desc: \"Start the debugger BEFORE PSE constructors have run\"\n . default:0\n\n...\n\n . Module: \"u1\"\n . path : \"module\"\n . Bus: \"u1/mainBus\"\n . addrBits : 32\n . Parameter: (cursor)\n . Memory: \"u1/ram1\"\n . priv : 7\n . maxAddress : ffffffff\n . BusPort: \"u1/ram1/sp1\"\n . description : \"(null)\"\n . type : 2\n . domainType : 0\n . addrHi : 0\n . addrBitsMin : 0\n . addrBitsMax : 0\n . mustConnect : 0\n . isDynamic : 0\n\n...\n\n . Peripheral: \"u1/periph0\"\n . path :\n \"Imperas/lib/Linux32/ImperasLib/freescale.ovpworld.org/peripheral/KinetisUART/1.0/pse.pse\"\n . BusPort: \"u1/periph0/bport1\"\n```\n\n### 16.3 Using the walkers command line\n\nYou can use the command line options to specify the module to load and the object to walk (introspect):\n> ./harness/harness.Linux32.exe \\\n --modulepath module \\ \n --objectname u1/periph0\n\nThis will load the module from the path 'module', and will start the walking from the \nobject named 'u1/periph0' and will introspect the peripheral:\n\nOVPsim started: Mon Mar 14 12:56:57 2016\n\nPeripheral;u1/periph0'\n . path : ImperasLib/freescale.ovpworld.org/peripheral/KinetisUART/1.0/pse.pse\" \n . BusPort;u1/periph0/bport1'\n . description : \"(null)\"\n . type : 2\n . domainType : 0\n . addrHi : 0xff\n . addrBitsMin : 0\n . addrBitsMax : 0\n . mustConnect : 0\n . isDynamic : 0\n . BusPortConn;u1/periph0/bport1'\n . type : 2\n . addrHi : 0x100013f7\n . addrLo : 0x100003f8\n . isDynamic : 0\n . Bus: u1/mainBus\n . NetPort;u1/periph0/DirectWrite'\n . description : \"(null)\"\n . type : 2\n . mustConnect : 0\n . NetPort;u1/periph0/DirectRead'\n . description : \"(null)\"\n . type : 1\n . mustConnect : 0\n . NetPort;u1/periph0/Interrupt'\n . description : \"(null)\"\n . type : 2\n . mustConnect : 0\n . NetPort;u1/periph0/Reset'\n . description : \"(null)\"\n . type : 1\n . mustConnect : 0\n . NetPortConn;u1/periph0/DirectWrite'\n . type : 0\n . Net: u1/directWrite\n . NetPortConn;u1/periph0/DirectRead'\n . type : 0\n . Net: u1/directRead\n Parameter: (cursor)\n Parameter: \"u1/periph0/outfile\" uartTTY0.log\n Formal: \"u1/periph0/diagnosticlevel\" (system)\n . Type: \"Uns32\"\n . Desc: \"Set the peripheral model diagnostic level to this value\"\nmin:0 max:4294967295 default:0\n\n17 Save / Restore\n\n17.1 Introduction\n\nThe Imperas simulator supports save and restore. This allows a simulation to be run to a specific time or event in the future, stopped and the current state saved. This state may then be restored into the simulator and execution continued which allows multiple simulations to be carried out from a known state without having to re-execute any of the previous simulation.\n\nThe simulator automatically performs save and restore on known internal state of a component, for example defined register structures in processors and peripherals. Where the component has additional specific internal state callback functions are used to define how this state should be saved and restored.\n\n17.2 Checking Supported\n\nFor any object in a design the `opObjectSaveRestoreSupported` can be used to determine if that object supports save and restore.\n\nAll components used within a design should support save and restore. Each component can be interrogated to see if it supports save and restore, for example to find the processors and peripherals status in a module\n\n```c\n// function to report and return save / restore status of an object\n//\nstatic Bool reportSupported(optObjectP obj) {\n Bool ok = opObjectSaveRestoreSupported((optObjectP) obj);\n\n opMessage(\"I\", \"SAVE_RESTORE_CHECK\", \"%s' ('%s/%s/%s/%s') : %s\", \n opObjectName(obj),\n opVlnvVendor(opObjectVlnv(obj)),\n opVlnvLibrary(opObjectVlnv(obj)),\n opVlnvName(opObjectVlnv(obj)),\n opVlnvVersion(opObjectVlnv(obj)),\n ok ? \"supported\" : \"not supported\");\n\n return ok;\n}\n\n//\n// iterate across components and check they all support save/restore\n```\n//\nstatic void checkSupported(optModuleP mi) {\n Bool allSupport = True;\n opMessage(\"I\", \"SAVE_RESTORE_CHECK\",\n \"Check all components support save/restore\");\n\n // Processors\n optProcessorP proc = 0;\n while ( (proc = opProcessorNext(mi, proc))) {\n Bool ok = reportSupported(proc);\n allSupport &= ok;\n }\n // Peripherals\n optPeripheralP per = 0;\n while ( (per = opPeripheralNext(mi, per))) {\n Bool ok = reportSupported(per);\n allSupport &= ok;\n }\n\n if (!allSupport) {\n opMessage(\"W\", \"SAVE_RESTORE_CHECK\",\n \"Not all components fully support save/restore: may not work in all operation modes!\");\n }\n}\n\n### 17.3 Validating Processor Model Save and Restore\n\nThere are a set of OP API functions that can be used to verify that save and restore is correctly working in a processor model.\n\nNOTE: These functions are not intended to be used for the save and restore of a design. They allow the state of a processor and its associated memory to be saved and restored for the purpose of verifying the save and restore capabilities of a processor module during development. The save and restore for a design is controlled using the Imperas M*SDK product interactive interfaces, see section 17.4 “Using Save and ”.\n\nThe processor and memory state can be saved and restored locally within the harness to allow a verification harness to be created using the set of functions\n\n```c\nopMemoryStateSave\nopProcessorStateSave\nopMemoryStateRestore\nopProcessorStateRestore\n```\nThe state can also be saved to and restored from a file using the following:\n\n- `opMemoryStateSaveFile`\n- `opProcessorStateSaveFile`\n- `opMemoryStateRestoreFile`\n- `opProcessorStateRestoreFile`\n\nTake a copy of the processor model validation save and restore example in:\n\n```\n$IMPERAS_HOME/Examples/SimulationControl/processorSaveRestoreValidation\n```\n\nThe example module can be built with the following commands:\n\n```\n> make –C harness\n> make –C module\n```\n\nand then executed with:\n\n```\n> harness/harness.Linux32.exe\n```\n\nThis executes 100 instructions on the processor, saves state and then runs a further 1000 instructions. At this point the processor and memory state is restored and the simulation runs until completion. Instruction tracing is performed to verify that the instructions executed after the save/restore point are the same in each case.\n\nThe following shows an extract from the simulation output on the initial execution of instructions 101 onwards:\n\n```\nInfo 99: 'top/u1/cpu1', 0x00000000000017d4(_strlen+3c): l.and r4,r4,r5\nInfo 100: 'top/u1/cpu1', 0x00000000000017d8(_strlen+40): l.movhi r5,0x8080\nSimulator StopReason = Instruction count breakpoint is pending\nOP_SR_BP_ICOUNT @ST1 : Save State\nInfo 101: 'top/u1/cpu1', 0x00000000000017dc(_strlen+44): l.ori r4,r4,0x8080\nInfo 102: 'top/u1/cpu1', 0x00000000000017e0(_strlen+48): l.and r4,r4,r5\nInfo 103: 'top/u1/cpu1', 0x00000000000017e4(_strlen+4c): l.sfnei r4,0x0\nInfo 104: 'top/u1/cpu1', 0x00000000000017e8(_strlen+50): l.bnf 0x000017bc\nInfo 105: 'top/u1/cpu1', 0x00000000000017ec(_strlen+54): l.nop 0x0\nInfo 106: 'top/u1/cpu1', 0x00000000000017f0(_strlen+24): l.addi r3,r3,0x4\nInfo 107: 'top/u1/cpu1', 0x00000000000017f4(_strlen+28): l.lwz r4,0x0(r3)\n```\n\nSubsequently after the simulation is stopped and restored at instruction 1100 we get the same instruction execution sequence:\n\n```\n...\nInfo 1098: 'top/u1/cpu1', 0x00000000000019f0(__sfvwrite+1d0): l.ori r4,r18,0x0\nInfo 1099: 'top/u1/cpu1', 0x00000000000019f4(__sfvwrite+1d4): l.sfgts r7,r6\n```\n17.4 Using Save and Restore in simulation\n\nThe save and restore is controlled from the Imperas M*SDK command line interface using the ‘save’ and ‘restore’ commands. These commands save and restore respectively the complete state of the design to a file.\n\nThis can be illustrated using the example:\n\n```\nIMPERAS_HOME/Examples/PlatformConstruction/simpleCpuMemoryUart\n```\n\nTake a copy of the example and run the example script so that the application, harness and module are generated and compiled.\n\nThe following requires that a valid installation of M*SDK is available.\n\nStart the platform with Imperas MPD using command line (integrated or remote), iGui or eGui. This example will show the use of the integrated command line version with tracing enabled to show the instruction execution of the processor and also the UART console enabled to see the UART output.\n\n```\nharness.exe \\n --modulefile module \\n --program application/application.OR1K.elf \\n --idebug \\n --trace --traceshowicount \\n --override simpleCpuMemoryUart/periph0/console=1\n```\n\nThis will bring up the interactive command line mode with tracing enabled.\n\nFirst let us set a breakpoint after 3500 instructions have been executed and run the simulation:\n\n```\nidebug (cpu1) > ::isetecountpoint -icount 3500\nidebug (cpu1) > continue\n```\nWe will see the output\n\n```\nCpuManagerMulti started: Mon Feb 29 14:48:19 2016\n...\nInfo 1: 'simpleCpuMemoryUart/cpu1', 0x0000000000000100(start): l.addi r2,r0,0x0\nInfo 2: 'simpleCpuMemoryUart/cpu1', 0x0000000000000104(start+4): l.addi r3,r0,0x0\nInfo 3: 'simpleCpuMemoryUart/cpu1', 0x0000000000000108(start+8): l.addi r4,r0,0x0\nInfo 4: 'simpleCpuMemoryUart/cpu1', 0x000000000000010c(start+c): l.addi r5,r0,0x0\nInfo 5: 'simpleCpuMemoryUart/cpu1', 0x0000000000000110(start+10): l.addi r6,r0,0x0\nInfo 6: 'simpleCpuMemoryUart/cpu1', 0x0000000000000114(start+14): l.addi r7,r0,0x0\nInfo 7: 'simpleCpuMemoryUart/cpu1', 0x0000000000000118(start+18): l.addi r8,r0,0x0\nInfo 8: 'simpleCpuMemoryUart/cpu1', 0x000000000000011c(start+1c): l.addi r9,r0,0x0\n...\nInfo 3498: 'simpleCpuMemoryUart/cpu1', 0x0000000000001924(_strlen+78): l.sub r11,r3,r6\nInfo 3499: 'simpleCpuMemoryUart/cpu1', 0x0000000000001914(_strlen+68): l.addi r3,r3,0x1\nInfo 3500: 'simpleCpuMemoryUart/cpu1', 0x0000000000001918(_strlen+6c): l.lbs r4,0x0(r3)\n\nIcountpoint 1 for cpu1 triggered at 3500\n0x0000191c in strlen (str=0x4afb \"0 world\\n\\n\") at ../../../../../../src/gcc-3.4.2/newlib/libc/string/strlen.c:88\n88 in ../../../../../../src/gcc-3.4.2/newlib/libc/string/strlen.c\n```\n\nThe console of the UART will show the text\n\n```\nHello\n```\n\nWe will now save the state of the design into a file ‘file.sav’\n\n```\nidebug (cpu1) > save file.sav\n```\n\nand then set a new breakpoint after 5000 instructions have been executed and continue the simulation:\n\n```\nidebug (cpu1) > ::iseticountpoint -icount 5000\nidebug (cpu1) > continue\n```\n\nwhich will execute further instructions from 3501 to the next break at 5000\nAnd the UART console now shows\n\nHello UART0 world\n\nWe can now restore the simulation state back to the point at which we stopped at 3500 instructions, and then run the simulation to completion\n\nidebug (cpu1) > restore file.sav\nidebug (cpu1) > continue\n\nwe see that the simulation starts from instruction 3501 once again\n\nUntil it terminates on reaching _exit (which was intercepted by the loaded semihosting library)\n\nThe UART console is now showing the additional output generated when the application program is re-executed from the restored state.\n\nHello UART0 world\nUART0 world\n\nNOTE: In this example the save / restore is not fully implemented in the components used but the automatic simulator save and restore is sufficient.\n18 Encapsulating Models for use in other Environments\nAn essential purpose of the OP API is to allow Imperas simulation models to be exported to other environments (for example, SystemC).\n\n18.1 SystemC\nIntegration with SystemC using OP is available and is described in the document *OVPsim Using OVP Models in SystemC TLM2.0 Platforms*. \n19 Integration with Client Debuggers\n\nIt is a common requirement to be able to integrate OP platforms with client debuggers. To support this requirement, additional capabilities are supported in the Imperas Professional Tools product (not OVPsim), as described in the following sections.\n\n19.1 Memory Access\n\nThe functions `opProcessorRead` and `opProcessorWrite` with the `debugAccess` argument equal to `True` should be used to examine or modify memory without causing side effects. See section 12 on Memory Operations.\n\n19.2 Register Query\n\nDebuggers often need to know the processor registers supported, so that they can be presented to the user and watchpoints can be set on register value changes (see section 19.9.1 for more information about watchpoints). The supported processor registers can be found using the processor register iterator:\n\n```c\noptRegP opProcessorRegNext ( \n optProcessorP processor, \n optRegP reg \n);\n```\n\nThe iterator should be passed `NULL` as the `reg` argument on the first call. On subsequent calls, it should be passed the value returned on the previous call. For each non-`NULL` value returned, the register name, width in bits, usage and group can be found using these functions:\n\n```c\nconst char *opRegName (optRegP reg);\nUns32 opRegBits (optRegP reg);\noptRegUsage opRegUsageEnum (optRegP reg);\nconst char *opRegUsageString (optRegP reg);\noptRegGroupP opRegGroup (optRegP reg);\n```\n\nThe `register group (optRegGroupP)` allows allocation of registers into model-specific sets, to ease presentation for processors that contain many registers (see the next section).\n\n19.3 Register Group Query\n\nDebuggers often need to know the processor register groups supported. Register groups are model-specific sets into which registers are allocated to ease presentational problems when a processor model contains a large number of registers. The supported processor register groups can be found using the processor register group iterator:\noptRegGroupP opProcessorRegGroupNext ( \n optProcessorP processor, \n optRegGroupP group \n); \n\nThe iterator should be passed NULL as the group argument on the first call. On \nsubsequent calls, it should be passed the value returned on the previous call. For each \nnon-NULL value returned, the group name can be found using:\n\nconst char *opRegGroupName(optRegGroupP group);\n\nThe registers within a group can be found using the by-group register iterator:\n\noptRegP opRegGroupRegNext ( \n optProcessorP processor, \n optRegGroupP group, \n optRegP reg \n); \n\nLike the other iterators, the iterator should be passed NULL as the reg argument on the \nfirst call. On subsequent calls, it should be passed the value returned on the previous call.\n\n19.4 Mode State Query\n\nDebuggers often need to know the processor modes supported, so that they can be \npresented to the user and watchpoints can be set on mode changes (see section 19.9.1 for \nmore information about watchpoints). The supported processor modes can be found using \nthe processor mode iterator:\n\noptModeP opProcessorModeNext ( \n optProcessorP processor, \n optModeP mode \n); \n\nThe iterator should be passed NULL as the mode argument on the first call. On subsequent \ncalls, it should be passed the value returned on the previous call. For each non-NULL value \nreturned, a string name, processor-specific code and description string can be found using \nthese functions:\n\nconst char *opModeName (optModeP mode);\n\nUns32 opModeCode (optModeP mode);\n\nconst char * opModeDescription (optModeP mode);\n\nThe current processor mode info can be found using:\n19.5 Exception State Query\n\nDebuggers often need to know the processor exceptions supported, so that they can be presented to the user and watchpoints can be set on exception events (see section 19.9.1 for more information about watchpoints). The supported processor exceptions can be found using the processor exception iterator:\n\n```c\noptExceptionP opProcessorExceptionNext (optProcessorP processor, optExceptionP exception);\n```\n\nThe iterator should be passed NULL as the exception argument on the first call. On subsequent calls, it should be passed the value returned on the previous call. For each non-NULL value returned, a string name, processor-specific code and description string can be found using these functions:\n\n```c\nconst char * opExceptionName (optExceptionP exception);\nUns32 opExceptionCode (optExceptionP exception);\nconst char * opExceptionDescription (optExceptionP exception);\n```\n\nThe current processor exception description can be found using:\n\n```c\noptExceptionP opProcessorExceptionCurrent (optProcessorP processor);\n```\n\n19.6 Processor Freezing\n\nTwo routines allow specific processors in a multiprocessor platform to be frozen and unfrozen:\n\n```c\nvoid opProcessorFreeze (optProcessorP processor);\nvoid opProcessorUnfreeze (optProcessorP processor);\n```\n\nWhen in a frozen state, a processor in a multiprocessor simulation will not be scheduled when `opRootModuleSimulate` is called. It is therefore possible to restrict simulation to a subset of processors in a multiprocessor platform by freezing those processors that should not be run. A function is also available to test the frozen state of a specific processor:\n\n```c\nBool opProcessorFrozen (optProcessorP processor);\n```\n19.7 Address Breakpoints\nTwo routines allow breakpoints to be set and cleared for a specific processor and address:\n\n```c\nvoid opProcessorBreakpointAddrSet ( \n optProcessorP processor,\n Addr addr\n);\n\nvoid opProcessorBreakpointAddrClear ( \n optProcessorP processor,\n Addr addr\n);\n```\n\nWhen a breakpoint has been set for a specific address, any attempt by the processor to execute at that address will cause `opRootModuleSimulate` or `opProcessorSimulate` to return with the processor’s `optStopReason` set to `OP_SR_BP_ADDRESS`.\n\n19.8 Instruction Count Breakpoints\nTwo routines allow a breakpoint to be set and cleared that causes a processor to stop executing after a specific number of instructions:\n\n```c\nvoid opProcessorBreakpointICountSet ( \n optProcessorP processor,\n Uns64 delta\n);\n\nvoid opProcessorBreakpointICountClear ( \n optProcessorP processor\n);\n```\n\nOnce the specified number of instructions has elapsed, `opRootModuleSimulate` or `opProcessorSimulate` will return with the processor’s `optStopReason` set to `OP_SR_BP_ICOUNT`.\n\nThere is only one active ICount breakpoint on any processor; a second call to `opProcessorBreakpointICountSet` (before the count is reached) will replace the previous value. When the ICount breakpoint is reached, the breakpoint deletes itself.\n\n19.9 Memory, Bus and Processor Watchpoints\nA powerful watchpoint API is implemented specifically aimed at debugger integration.\n19.9.1 Watchpoint Creation and Deletion\n\nThree routines are available to set read, write or access (both read and write) watchpoints on a range of memory addresses in a memory:\n\n```c\noptWatchpointP opMemoryReadWatchpointNew (\n optMemoryP memory,\n Addr addrLo,\n Addr addrHi,\n void* userData,\n optAddrWatchpointConditionFn notifierCB\n);\n```\n\n```c\noptWatchpointP opMemoryWriteWatchpointNew (\n optMemoryP memory,\n Addr addrLo,\n Addr addrHi,\n void* userData,\n optAddrWatchpointConditionFn notifierCB\n);\n```\n\n```c\noptWatchpointP opMemoryAccessWatchpointNew (\n optMemoryP memory,\n Addr addrLo,\n Addr addrHi,\n void* userData,\n optAddrWatchpointConditionFn notifierCB\n);\n```\n\nThree more routines allow watchpoints to be specified on a bus range:\n\n```c\noptWatchpointP opBusReadWatchpointNew (\n optBusP bus,\n Addr addrLo,\n Addr addrHi,\n void* userData,\n optAddrWatchpointConditionFn notifierCB\n);\n```\n\n```c\noptWatchpointP opBusWriteWatchpointNew (\n optBusP bus,\n Addr addrLo,\n Addr addrHi,\n void* userData,\n optAddrWatchpointConditionFn notifierCB\n);\n```\nThree routines allow watchpoints to be specified on a processor address range. For each, a physical argument specifies whether the address range is in processor physical memory (if True) or virtual memory (if False): \n\n```c\noptWatchpointP opBusAccessWatchpointNew (\n optBusP bus,\n Addr addrLo,\n Addr addrHi,\n void* userData,\n optAddrWatchpointConditionFn notifierCB\n);\n```\n\n```c\noptWatchpointP opProcessorReadWatchpointNew ( \n optProcessorP processor, \n Bool physical, \n Addr addrLo, \n Addr addrHi, \n void* userData, \n optProcWatchpointConditionFn notifierCB\n);\n```\n\n```c\noptWatchpointP opProcessorWriteWatchpointNew ( \n optProcessorP processor, \n Bool physical, \n Addr addrLo, \n Addr addrHi, \n void* userData, \n optProcWatchpointConditionFn notifierCB\n);\n```\n\n```c\noptWatchpointP opProcessorAccessWatchpointNew ( \n optProcessorP processor, \n Bool physical, \n Addr addrLo, \n Addr addrHi, \n void* userData, \n optProcWatchpointConditionFn notifierCB\n);\n```\n\nOne routine allows a watchpoint to be established on a register in a processor:\n\n```c\noptWatchpointP opProcessorRegWatchpointNew ( \n optProcessorP processor, \n optRegP reg, \n void* userData,\n```\n\n---\n\n5 See the section 19.9.2 for a definition of what exactly virtual and physical mean in this context.\noptProcWatchpointConditionFn notifierCB\n);\n\nOne routine allows a watchpoint to be established on a processor *mode switch*:\n\n```c\noptWatchpointP opProcessorModeWatchpointNew ( \n optProcessorP processor, \n void* userData, \n optProcWatchpointConditionFn notifierCB\n);\n```\n\nFinally, one routine allows a watchpoint to be established on a processor *exception*:\n\n```c\noptWatchpointP opProcessorExceptionWatchpointNew ( \n optProcessorP processor, \n void* userData, \n optProcWatchpointConditionFn notifierCB\n);\n```\n\nEach function returns an `optWatchpointP` opaque type pointer for the watchpoint that was created. The `userData` argument allows a client-specific data pointer to be associated with the watchpoint object for later use (see below). A previously-created watchpoint can be deleted using:\n\n```c\nvoid opWatchpointDelete (optWatchpointP watchpoint);\n```\n\nThe `notifierCB` arguments to the watchpoint addition functions above allow a notifier callback function to be associated with each watchpoint that decides whether the watchpoint should be triggered or not (i.e., it allows the specification of *conditional* watchpoints).\n\nFor memory watchpoints, the prototype of the notifier is:\n\n```c\n#define OP_ADDR_WATCHPOINT_CONDITION_FN(_name) \\\n Bool _name ( \\\n optProcessorP processor, \\\n optWatchpointP watchpoint, \\\n Addr PA, \\ \n Addr VA, \\ \n Uns32 bytes, \\ \n void* (userData, \\ \n void* value)\n\ntypedef OP_ADDR_WATCHPOINT_CONDITION_FN ((* optAddrWatchpointConditionFn));\n```\nIn this case, the notifier is passed the physical and virtual addresses of the memory access, the number of bytes being accessed and a pointer to a buffer containing those bytes.\n\nFor other watchpoint types, the prototype of the notifier is:\n\n```c\n#define OP_PROC_WATCHPOINT_CONDITION_FN (_name) \n Bool _name ( \n optWatchpointP watchpoint, \n optProcessorP processor, \n void* userData)\n\ntypedef OP_PROC_WATCHPOINT_CONDITION_FN ((* optProcWatchpointConditionFn));\n```\n\nIn both cases, if the notifier is NULL or returns False then any processor triggering the watchpoint will stop before it executes its next instruction with optStopReason OP_SR_WATCHPOINT. Otherwise, if the notifier returns True, the triggering processor will not stop but instead continue executing normally.\n\n### 19.9.2 Semantics of Physical and Virtual Watchpoints\n\nThe functions `opProcessorReadWatchpointNew`, `opProcessorWriteWatchpointNew` and `opProcessorAccessWatchpointNew` each take an argument `physical` which indicates whether the watch point should be physical or virtual. The semantics of these are as follows:\n\n#### 19.9.2.1 Physical Watchpoints\n\nPhysical watchpoints are created on the externally-connected processor bus. Creating a physical watchpoint is therefore equivalent to creating a bus watchpoint on the processor data bus.\n\nWhen a physical memory watch point is set, it applies to the addressed physical memory irrespective of the route by which that is accessed. For example, if you set a physical watch point on address 0x10000, the watch point will trigger if the processor is in a non-TLB mapped mode and accesses address 0x10000, or if it is a TLB mapped mode where VA=0x50000 (say) maps to 0x10000 and an access is made to VA=0x50000.\n\n#### 19.9.2.2 Virtual Watchpoints\n\nWhen a virtual memory watch point is set, it applies to the memory addressed by the virtual address range as viewed from the current processor mode. As a contrived example:\n\n1. Suppose that a processor is currently in TLB-mapped kernel mode, and that virtual address 0x50000 maps to physical address 0x10000.\n2. A watch point is set using `opProcessor*WatchPointNew` for virtual address VA=0x50000.\n3. The watch point is triggered by any accesses to VA=0x50000 in TLB-mapped kernel mode (as expected), or any aliased access to PA=0x10000.\n\n4. The mapping for VA=0x50000 in TLB-mapped kernel mode is changed to PA=0x20000.\n\n5. The watch point is still triggered by any accesses to 0x50000 in TLB-mapped kernel mode (as expected). Note that the physical memory for the watch point has changed from 0x10000 to 0x20000. Accesses that change memory at PA=0x10000 by any route no longer trigger the watch point.\n\n6. The processor enters TLB-mapped user mode. Say that in this mode VA=0x50000 is mapped to PA=0x60000 and VA=0x70000 is mapped to PA=0x20000.\n\n7. The processor accesses VA=0x50000 in TLB-mapped user mode. The watch point does not trigger because VA=0x50000 maps to PA=0x60000, which does not correspond to VA=0x50000/PA=0x20000 in TLB-mapped kernel mode.\n\n8. The processor accesses VA=0x70000 in TLB-mapped user mode. The watch point triggers because VA=0x70000 maps to PA=0x20000.\n\nThese semantics avoid much spurious watch point triggering when processors switch modes. When a user places a memory watch point at virtual address 0x20000, he almost always means virtual address 0x20000 in the current mode.\n\n### 19.9.3 Watchpoint Attribute Query\n\nThere are various functions that allow watchpoint attributes to be queried. The type of a watchpoint can be found using:\n\n```c\ntypedef enum optWatchpointTypeE {\n OP_WP_MEM_READ , // Memory read watchpoint\n OP_WP_MEM_WRITE , // Memory write watchpoint\n OP_WP_MEM_ACCESS , // Memory access watchpoint\n OP_WP_REG , // Register watchpoint\n OP_WP_MODE , // Mode change watchpoint\n OP_WP_EXCEPTION // Exception watchpoint\n} optWatchpointType;\n```\n\n```c\noptWatchpointType opWatchpointType (optWatchpointP watchpoint);\n```\n\nThe client data pointer that was associated with the watchpoint when it was created can be found using:\n\n```c\nvoid* opWatchpointUserData (optWatchpointP watchpoint);\n```\n\nFor memory address range watchpoints, the bounding addresses can be found using:\n\n```c\nAddr opWatchpointAddressLo (optWatchpointP watchpoint);\nAddr opWatchpointAddressHi (optWatchpointP watchpoint);\n```\nThese functions return zero for other watchpoint types. For processor register watchpoints, the register which is being watched can be found using:\n\n```c\noptRegP opWatchpointReg (optWatchpointP watchpoint);\n```\n\nThis function returns `NULL` for other watchpoint types or if the watchpoint has not been triggered.\n\nFor processor register watchpoints, there are query functions which return pointers to the current and previous value of the register being watched:\n\n```c\nvoid* opWatchpointRegCurrentValue (optWatchpointP watchpoint);\nvoid* opWatchpointRegPreviousValue (optWatchpointP watchpoint);\n```\n\n### 19.9.4 Handling Triggered Watchpoints\n\nWhen a watchpoint triggers (because a read or write occurs to the address range over which it is sensitive, or because the processor register or mode it is watching changes, or an exception occurs), `opRootModuleSimulate` or `opProcessorSimulate` will return with the processor’s `optStopReason` set to `OP_SR_WATCHPOINT`. Because watchpoints can be specified with overlapping ranges and on multiple registers and other events simultaneously, it is possible for *multiple watchpoints to be triggered by a single processor instruction*. To enable these all to be handled, an iterator function is available that returns the next triggered watchpoint or `NULL` if there are no currently triggered watchpoints:\n\n```c\noptWatchpointP opRootModuleWatchpointNext (optModuleP module);\n```\n\nOnce the returned watchpoint has been handled by the debugger, it must be reset using:\n\n```c\nvoid opWatchpointReset (optWatchpointP watchp);\n```\n\nThen a subsequent call to `opRootModuleWatchpointNext` will return the next triggered watchpoint that has not been reset, and so on until all watchpoints have been handled by the client debugger and a `NULL` is returned. For each triggered watchpoint, the processor which triggered it can be found using:\n\n```c\noptProcessorP opWatchpointTriggeredBy (optWatchpointP watchpoint);\n```\n\n### 19.10 Handling Simultaneous Debug Events\n\nIt is possible that execution of a single processor instruction could potentially cause an address breakpoint, an instruction count breakpoint and a watchpoint all to trigger. In this case, the priority order is as follows:\n1. The instruction count breakpoint is triggered first, causing the processor to be stopped for `optStopReason OP_SR_BP_ICOUNT` before the instruction is executed;\n2. When simulation is resumed by `opRootModuleSimulate` or `opProcessorSimulate`, the address breakpoint is triggered next, causing the processor to be stopped for `optStopReason OP_SR_BP_ADDRESS`, again before the instruction is executed;\n3. When simulation is resumed by `opRootModuleSimulate` or `opProcessorSimulate`, the instruction completes. After completion, the processor is stopped for `optStopReason OP_SR_WATCHPOINT`, at which point the triggered watchpoints can be found and reset using `opRootModuleWatchpointNext` and `opWatchpointReset`.\n\n### 19.11 Debugger Integration Examples\n\nThere are two examples using the address breakpoint, instruction count breakpoint and watchpoint constructs in the `debuggerIntegration` directory:\n\n```\n$IMPERAS_HOME/Examples/DebuggerIntegration/multiProcessor\n$IMPERAS_HOME/Examples/DebuggerIntegration/modeAndException\n```\n\nThe first example uses the two processor shared memory application first seen in the `iGen Platform and Module Creation User Guide`. We will add a custom harness to exercise the breakpoint and memory watchpoint debugger integration commands (see section 19.11.1).\n\nThe second example uses a simpler single processor assembler example to exercise the mode change and exception watchpoints (see section 19.11.2).\n\n### 19.11.1 Multi Processor Debugger Integration Example\n\nThe following sections refer to the example which may be found in:\n\n```\n$IMPERAS_HOME/Examples/DebuggerIntegration/multiProcessor\n```\n\n#### 19.11.1.1 Establishing Watchpoints\n\nThe simulation harness for this example is `harness.c` in the example `harness` directory.\n\nOnce the simulation module has been instantiated and the applications loaded into simulated memory, the platform establishes a write watchpoint on the first word of the shared memory between the two processors as follows:\n\n```\napplyWatchpoint(processor0, SHARED_LOW, 4, OP_WP_MEM_WRITE);\n```\n\nFunction `applyWatchpoint` is as follows:\n\n```c\nstatic void applyWatchpoint(\n```\noptProcessorP proc, \nAddr address, \nAddr size, \nWatchType type \n) {\n\nif (type == OP_WP_MEM_ACCESS) {\n\n // create access watchpoint\n optWatchpointP rwp = opProcessorAccessWatchpointNew(\n proc, False, address, address+size-1, (void *)(id++), 0\n );\n opPrintf( \n \"%s: ACCESS watchpoint is %u\\n\", opObjectName(proc), getWatchpointId(rwp) \n );\n}\nelse if (type == OP_WP_MEM_READ) {\n\n // create read watchpoint\n optWatchpointP rwp = opProcessorReadWatchpointNew(\n proc, False, address, address+size-1, (void *)(id++), 0\n );\n opPrintf( \n \"%s: READ watchpoint is %u\\n\", opObjectName(proc), getWatchpointId(rwp) \n );\n}\nelse if (type == OP_WP_MEM_WRITE) {\n\n // create write watchpoint\n optWatchpointP wwp = opProcessorWriteWatchpointNew(\n proc, False, address, address+size-1, (void *)(id++), 0\n );\n opPrintf(\"%s: WRITE watchpoint is %u\\n\", opObjectName(proc), getWatchpointId(wwp));\n\n}\n}\n\nThe function adds access, read or write watchpoints for the specified address range, as specified by the type enum.\n\nIn our call, a write watchpoint is made on the first four bytes of shared memory which corresponds to the address specified by the ENCRYPT_INDEX macro in the application. Whenever this address is written control will be returned to the debugger.\nIn a real debugger, the address and object size would of course be found by the debugger from the object file, typically in response to a user command.\n\nThe platform also establishes some register watchpoints for processor0 only using:\n\n```c\napplyRegWatchpoints(processor0);\n```\n\nFunction `applyRegWatchpoints` is as follows:\n\n```c\nstatic void applyRegWatchpoints(optProcessorP processor) {\n optWatchpointP rwp1 = opProcessorRegWatchpointNew(\n processor, opProcessorRegByName(processor, \"r3\"), (void *)(id++), 0\n );\n\n optWatchpointP rwp2 = opProcessorRegWatchpointNew(\n processor, opProcessorRegByName(processor, \"r9\"), (void *)(id++), 0\n );\n\n optWatchpointP rwp3 = opProcessorRegWatchpointNew(\n processor, opProcessorRegByUsage(processor, OP_REG_SP), (void *)(id++), 0\n );\n\n opPrintf(\"REGISTER watchpoint 1 is %u\\n\", getWatchpointId(rwp1));\n opPrintf(\"REGISTER watchpoint 2 is %u\\n\", getWatchpointId(rwp2));\n opPrintf(\"REGISTER watchpoint 3 is %u\\n\", getWatchpointId(rwp3));\n}\n```\n\nThis function establishes register change watchpoints on three registers; two are found by name (r3 and r9) and the third is found by usage (the OR1K stack register, r1). In a real debugger, the registers would of course be selected dynamically.\n\nThe platform also demonstrates how to query the registers by register group. Function `queryRegisters` lists all registers found on the processor, by group:\n\n```c\nstatic void queryRegisters(optProcessorP processor) {\n opPrintf(\"%s REGISTERS\\n\", opObjectName(processor));\n optRegGroupP group = 0;\n while((group=opProcessorRegGroupNext(processor, group))) {\n opPrintf(\" GROUP %s\\n\", opRegGroupName(group));\n }\n}\n```\noptRegP reg = 0;\n\nwhile((reg=opRegGroupRegNext(processor, group, reg))) {\n opPrintf(\" REGISTER %s\n\", opRegName(reg));\n}\n}\n\n19.11.1.2 Running the Simulator\n\nThe simulator is run in a loop which calls opRootModuleSimulate. There are two modes of operation: a normal mode (which runs to the next debug event or termination) and an instruction step mode (used to single-step past an address breakpoint):\n\n```c\nBool stepOver = False;\nBool finished = False;\noptProcessorP stopProcessor = 0;\n\n// Simulation loop\nwhile(!finished) {\n\n // Simulate the platform using the default scheduler\n // All breakpoints are set and cleared together, ala gdb behavior\n if(stepOver) {\n opProcessorBreakpointICountSet(stopProcessor, 1);\n stopProcessor = opRootModuleSimulate (root);\n stepOver = False;\n } else {\n applyBreakpoints(processor0, breakpoints0);\n applyBreakpoints(processor1, breakpoints1);\n stopProcessor = opRootModuleSimulate(root);\n clearBreakpoints(processor0, breakpoints0);\n clearBreakpoints(processor1, breakpoints1);\n }\n\n optStopReason sr = stopProcessor ? opProcessorStopReason(stopProcessor) : OP_SR_EXIT;\n … actions depending on stopReason here\n}\n```\n\nIn the single step mode, an instruction count breakpoint is set for one instruction and then the platform is simulated:\n\n```c\nopProcessorBreakpointICountSet(stopProcessor, 1);\nstopProcessor = opRootModuleSimulate (root);\n```\nstepOver = False;\n\nIn the normal mode, address breakpoints are established, the simulation is run until the next debug event or termination and then address breakpoints are removed:\n\napplyBreakpoints(processor0, breakpoints0);\napplyBreakpoints(processor1, breakpoints1);\nstopProcessor = opRootModuleSimulate(root);\nclearBreakpoints(processor0, breakpoints0);\nclearBreakpoints(processor1, breakpoints1);\n\nThe approach of resetting the breakpoints every time the debugger retains control used here is consistent with the approach taken by GDB.\n\nEach processor has its own table of breakpoints which are specified in a NULL terminated static array:\n\n// List of breakpoint addresses for processor 0 (encrypt)\nconst static Addr breakpoints0[] = {\n 0xf2c, // main\n 0 // terminator\n};\n\n// List of breakpoint addresses for processor 1 (decrypt)\nconst static Addr breakpoints1[] = {\n 0x0f2c, // waitForFrame\n 0x1000, // main\n 0 // terminator\n};\n\nThe addresses of routines in the application were obtained by examining the objdump output for the application executable. If the application is modified these tables may need to be updated. Again, a real debugger would read these from the application ELF file and not rely on fixed addresses:\n\nThe routines to set and clear breakpoints are as follows:\n\nstatic void applyBreakpoints(optProcessorP processor, const Addr breakpoints[]) {\n Uns32 i;\n\n for(i=0; breakpoints[i]; i++) {\n opProcessorBreakpointAddrSet(processor, breakpoints[i]);\n }\n}\n\nstatic void clearBreakpoints(optProcessorP processor, const Addr breakpoints[]) {\n\nUns32 i;\n\nfor(i=0; breakpoints[i]; i++) {\n opProcessorBreakpointAddrClear(processor, breakpoints[i]);\n}\n\nEach time opRootModuleSimulate returns, the loop decides what to do next depending on the system state.\n\n1. If the optStopReason was OP_SR_EXIT or OP_SR_FINISH, the simulation has terminated.\n case OP_SR_EXIT:\n case OP_SR_FINISH:\n finished = True;\n break;\n\n2. Otherwise, if the optStopReason was OP_SR_BP_ICOUNT an instruction count breakpoint has been hit (the debugger is single-stepping over an address breakpoint location):\n case OP_SR_BP_ICOUNT:\n opPrintf(\n \"Processor %s icount %u stopped at icount\\n\",\n opObjectName (stopProcessor),\n (Uns32)opProcessorICount(stopProcessor)\n );\n break;\n\n3. Otherwise, if the optStopReason was OP_SR_BP_ADDRESS an address breakpoint has been hit. In this case, the simulation switches mode to step for one instruction to get past the breakpoint address:\n case OP_SR_BP_ADDRESS:\n opPrintf(\n \"Processor %s icount %u breakpoint at address 0x%08x\\n\",\n opObjectName (stopProcessor),\n (Uns32)opProcessorICount(stopProcessor),\n (Uns32)opProcessorPC(stopProcessor)\n );\n stepOver = True;\n break;\n\n4. Otherwise, if the optStopReason was OP_SR_WATCHPOINT a watchpoint has triggered. In this case, the triggered watchpoints are scanned and reported:\n case OP_SR_WATCHPOINT:\n opPrintf(\n \"Processor %s icount %u stopped at watchpoint\\n\",\n opObjectName (stopProcessor),\n (Uns32)opProcessorICount(stopProcessor),\n (Uns32)opProcessorPC(stopProcessor)\n );\n break;\n(Uns32)opProcessorICount(stopProcessor);\nhandleWatchpoints(root);\nbreak;\n\n5. Otherwise, the optStopReason is reported and simulation continues (no other optStopReason value is expected in this simulation).\n\ndefault:\n opPrintf(\"Processor %s icount %u stopped with unexpected reason 0x%x (%s)n\", \n opObjectName(stopProcessor),\n (Uns32)opProcessorICount(stopProcessor),\n sr,\n opStopReasonString(sr)\n );\n break;\n\nFunction handleWatchpoints reports and resets all triggered watchpoints. The function iterates over all triggered but unhandled watchpoints, finding the watchpoint id and the processor that caused the watchpoint to trigger:\n\nstatic void handleWatchpoints(optModuleP mi) {\n optWatchpointP wp;\n while((wp=opRootModuleWatchpointNext(mi))) {\n Uns32 id = getWatchpointId(wp);\n optProcessorP processor = opWatchpointTriggeredBy(wp);\n optWatchpointType type = opWatchpointType(wp);\n\n The userData associated with a watchpoint is used to record an arbitrary watchpoint id number:\n\n static Uns32 getWatchpointId(optWatchpointP watchpoint) {\n return (UnsPS)opWatchpointUserData(watchpoint);\n }\n\n The watchpoint type is used to disambiguate the register and address watchpoint cases. If this is a register watchpoint, details about it are printed, together with the old and new values of the register:\n\n switch (type) {\n case OP_WP_REG: {\n// a register watchpoint was triggered\noptRegP reg = opWatchpointReg(wp);\nUns32 *newValueP = (Uns32 *)opWatchpointRegCurrentValue(wp);\nUns32 *oldValueP = (Uns32 *)opWatchpointRegPreviousValue(wp);\n\n// indicate old and new value of the affected register\nopPrintf(\n \" Register watchpoint %u (processor %s:%s) triggered 0x%08x-\n>0x%08x\\n\",\n id,\nopObjectName(processor),\nopRegName(reg),\n *oldValueP,\n *newValueP\n);\n\nIf register watchpoints have fired more than 100 times, any one that fires is deleted the\nnext time it is triggered, otherwise it is reset:\n\n // delete watchpoint after 100 triggers\n if(regWatchPointCount++>100) {\n opWatchpointDelete(wp);\n } else {\n opWatchpointReset(wp);\n }\n\n break;\n\n(This behavior would not be required in a real debugger integration – it is done here\nsimply so that the example output is not swamped by register change callback messages).\n\nIf the watchpoint is a memory read, write or access, information about the address range\nis printed and the watchpoint reset:\n\ncase OP_WP_MEM_READ:\ncase OP_WP_MEM_WRITE:\ncase OP_WP_MEM_ACCESS: {\n\n // a memory watchpoint was triggered\n opPrintf(\n \" %s watchpoint %u (range 0x%08x:0x%08x) triggered by processor %s\\n\",\n (type==OP_WP_MEM_READ) ? \"Read\" :\n (type==OP_WP_MEM_WRITE) ? \"Write\" :\n \"Access\",\n id,\nopObjectName(processor),\nopRegName(reg),\n *newValueP,\n *oldValueP\n );\n\n break;\n}\n(Uns32)opWatchpointAddressLo(wp),\n(Uns32)opWatchpointAddressHi(wp),\nopObjectName(processor)\n);\n\nopWatchpointReset(wp);\n\nbreak;\n}\n\nIf the watchpoint type is not recognized then a message is issued and the watchpoint reset:\n\ndefault: {\n opPrintf(\n \" unknown watchpoint type %u triggered by processor %s\\n\",\n type,\n opObjectName (processor)\n );\n\n opWatchpointReset(wp);\n\n break;\n}\n\nNote that if a watchpoint is not reset then the next call to opRootModuleWatchpointNext will return the same watchpoint, resulting in an infinite loop.\n\n19.11.1.3 Compiling and Running the Example\nFirst, take a copy of the example:\n\n> cp -r $IMPERAS_HOME/Examples/DebuggerIntegration/multiProcessor .\n> cd multiProcessor\n\nBuild the test platform and application with the following commands:\n\n> make -C module\n> make -C application\n> make -C harness\n\nTo run the simulation:\n\n> harness/harness.Linux32.exe --argv application/constitution.txt\nAlternatively, an example.sh script (example.bat for Windows) has been provided which will do the build and run as a single command:\n\n```\n> ./example.sh\n```\n\nYou should see the following output:\n\n```\nP0: WRITE watchpoint is 0\nREGISTER watchpoint 1 is 1\nREGISTER watchpoint 2 is 2\nREGISTER watchpoint 3 is 3\nP0 REGISTERS\n GROUP GPR\n REGISTER R0\n REGISTER R1\n REGISTER R2\n\n . . . many similar lines deleted . . .\n\n REGISTER R29\n REGISTER R30\n REGISTER R31\n GROUP System\n REGISTER PC\n REGISTER SR\n REGISTER EPCR\n REGISTER EEAR\n REGISTER ESR\n REGISTER PICMR\n REGISTER PCSR\n REGISTER TTCR\n REGISTER TTMR\n GROUP Integration_Support\n REGISTER EXCPT\n REGISTER EXCPT\nProcessor P1 icount 45 breakpoint at address 0x00001000\nProcessor P1 icount 46 stopped at icount\nProcessor P1 icount 90 breakpoint at address 0x00000f2c\nProcessor P1 icount 91 stopped at icount\nProcessor P0 icount 2 stopped at watchpoint\n Register watchpoint 1 (processor P0:R3) triggered 0xdeadbeef->0x00000000\nProcessor P0 icount 8 stopped at watchpoint\n Register watchpoint 2 (processor P0:R9) triggered 0xdeadbeef->0x00000000\nProcessor P0 icount 31 stopped at watchpoint\n\n . . . many similar lines deleted . . .\n```\nRegister watchpoint 2 (processor P0:R9) triggered 0x000055f4->0x0000582c \nProcessor P0 icount 578 stopped at watchpoint \nRegister watchpoint 3 (processor P0:R1) triggered 0xfffffe10->0xfffffe0c \nProcessor P0 icount 153361 stopped at watchpoint \nWrite watchpoint 0 (range 0x11000000:0x11000003) triggered by processor P0\n\n**** FRAME 0 ****\n\nTHE CONSTITUTION OF THE UNITED STATES OF AMERICA\n\nPreamble\nWe the People of the United States, in Order to form a more perfect Union, establish justice, insure domestic Tranquility, provide for the common defense, promote the . . . many similar lines deleted . . .\n\nNo person shall be a Representative who shall not have attained to the age of twenty five years, and been seven years a citizen of the United States, and who shall not, when elected, be an inh \nProcessor P1 icount 374775 breakpoint at address 0x00000f2c \nProcessor P1 icount 374776 stopped at icount \nProcessor P0 icount 305408 stopped at watchpoint \nWrite watchpoint 0 (range 0x11000000:0x11000003) triggered by processor P0 \nProcessor P0 icount 457455 stopped at watchpoint \nWrite watchpoint 0 (range 0x11000000:0x11000003) triggered by processor P0\n\n**** FRAME 1 ****\n\nabitant of that state in which he shall be chosen. \n. . . many similar lines deleted . . . \nProcessor P1 icount 4523854 breakpoint at address 0x00000f2c \nProcessor P1 icount 4523855 stopped at icount\n\n**** FRAME 25 ****\n\ntution between the states so ratifying the same. \n\nDone in convention by the unanimous consent of the states present the seventeenth day of September in the year of our Lord one thousand seven hundred and eighty seven and of \n. . . many similar lines deleted . . . \n\nVirginia: John Blair, James Madison Jr.\nThe example first shows the result of the register group iterator and the by-group register iterator: there are two groups (GPR and System) containing the OR1K GPRs and system registers, respectively.\n\nEach address breakpoint that is encountered is reported with lines of this form:\n\nProcessor P1 icount 45 breakpoint at address 0x00001000\n\nInstruction count breakpoints are reported with lines of this form:\n\nProcessor P1 icount 46 stopped at icount\n\nRegister watchpoints are reported by a pair of lines of this form, giving the old and new values of the affected register:\n\nProcessor P0 icount 2 stopped at watchpoint\n Register watchpoint 1 (processor P0:R3) triggered 0xdeadbeef->0x00000000\n\nMemory watchpoints are reported by a pair of lines of this form:\n\nProcessor P0 icount 153361 stopped at watchpoint\n Write watchpoint 0 (range 0x11000000:0x11000003) triggered by processor P0\n\n19.11.2 Mode and Exception Debugger Integration Example\n\nThe following sections refer to the example which may be found in:\n\n$IMPERAS_HOME/Examples/DebuggerIntegration/modeAndException\n\n19.11.2.1 Establishing Watchpoints\n\nThe simulation harness for this example is harness.c in the example harness directory.\nThe harness has a similar structure to the previous example, `multiProcessor`, but instances only a single processor and adds watchpoints for mode changes and exceptions.\n\nOnce processor memory has been loaded, the platform establishes processor *mode change* and *exception* watchpoints as follows:\n\n```c\n// Apply watchpoints on mode switches and exceptions\napplyWatchpoint(processor, 0, 0, OP_WP_MODE);\napplyWatchpoint(processor, 0, 0, OP_WP_EXCEPTION);\n```\n\nFunction `applyWatchpoint` has been enhanced from the version in the previous example to add mode and exception watchpoints as follows:\n\n```c\nswitch(type) {\n...\n case (OP_WP_MODE):\n wp = opProcessorModeWatchpointNew(\n proc, (void *)(id++), 0\n );\n typeName = \"MODE\";\n break;\n\n case (OP_WP_EXCEPTION):\n wp = opProcessorExceptionWatchpointNew(\n proc, (void *)(id++), 0\n );\n typeName = \"EXCEPTION\";\n break;\n...\n}\n```\n\n```c\nopPrintf(\"%s: %s watchpoint is %u\\n\", opObjectName(proc), typeName,\n getWatchpointId(wp));\n```\n\n### 19.11.2.2 Running the Simulator\n\nThe simulator loop is similar to that in `multiProcessor`. The only significant difference is in function `handleWatchpoints`. The function once more iterates over all triggered but unhandled watchpoints, finding the watchpoint id and the processor that caused the watchpoint to trigger:\n\n```c\nstatic void handleWatchpoints(optModuleP mi) {\n optWatchpointP wp;\n while((wp=opRootModuleWatchpointNext(mi))) {\n```\nUns32 id = getWatchpointId(wp);\nopProcessorP processor = opWatchpointTriggeredBy(wp);\nopWatchpointType type = opWatchpointType(wp);\n\nIn this platform, it uses the watchpoint type to disambiguate the *mode* and *exception* watchpoint cases. If this is a mode change watchpoint, details about it are printed, together with the mode's code and name, and the watchpoint is reset:\n\n```c\nswitch(type) {\n case OP_WP_MODE: {\n // a mode switch watchpoint was triggered\n optModeP mode = opProcessorModeCurrent(processor);\n Uns32 modeCode = mode ? opModeCode(mode) : 0;\n const char *modeName = mode ? opModeName(mode) : \"none\";\n\n // report new mode\n opPrintf(\"watchpoint %u (processor %s:MODE) triggered mode -> %d (%s)\\n\",\n id,\n opObjectName(processor),\n modeCode,\n modeName ?: \"\");\n\n opWatchpointReset(wp);\n break;\n }\n\n If this is an exception watchpoint, information about the exception type is printed and the watchpoint reset:\n\n case OP_WP_EXCEPTION: {\n\n // an exception watchpoint was triggered\n optExceptionP except = opProcessorExceptionCurrent(processor);\n Uns32 exceptCode = except ? opExceptionCode(except) : 0;\n const char *exceptName = except ? opExceptionName(except) : \"none\";\n const char *exceptDesc = except ? opExceptionDescription(except) : \"\";\n\n // report current exception\n opPrintf(\n```\n19.11.2.3 Compiling and Running the Example\n\nFirst, take a copy of the example:\n\n```\n> cp -r $IMPERAS_HOME/Examples/DebuggerIntegration/multiProcessor .\n> cd multiProcessor\n```\n\nBuild the test platform and application with the following commands:\n\n```\n> make -C module\n> make -C application\n> make -C harness\n```\n\nTo run the simulation:\n\n```\n> harness/harness.Linux32.exe --argv application/constitution.txt\n```\n\nAlternatively, an example.sh script (example.bat for Windows) has been provided which will do the build and run as a single command:\n\n```\n> ./example.sh\n```\n\nYou should see the following output:\n\ncpu1: MODE watchpoint is 0\ncpu1: EXCEPTION watchpoint is 1\nProcessor cpu1 icount 26 stopped at watchpoint\n watchpoint 0 (processor cpu1:MODE) triggered mode -> 1 (USER)\nProcessor cpu1 icount 29 stopped at watchpoint\n watchpoint 0 (processor cpu1:MODE) triggered mode -> 0 (SUPERVISOR)\n watchpoint 1 (processor cpu1:EXCEPTION) triggered exception -> 1792 ILL: Illegal instruction\nProcessor cpu1 icount 36 stopped at watchpoint\nwatchpoint 0 (processor cpu1:MODE) triggered mode -> 1 (USER)\nProcessor cpu1 icount 38 stopped at watchpoint\n watchpoint 0 (processor cpu1:MODE) triggered mode -> 0 (SUPERVISOR)\n watchpoint 1 (processor cpu1:EXCEPTION) triggered exception -> 1792 ILL: Illegal instruction\nProcessor cpu1 icount 45 stopped at watchpoint\n watchpoint 0 (processor cpu1:MODE) triggered mode -> 1 (USER)\nProcessor cpu1 icount 48 stopped at watchpoint\n watchpoint 0 (processor cpu1:MODE) triggered mode -> 0 (SUPERVISOR)\n watchpoint 1 (processor cpu1:EXCEPTION) triggered exception -> 1792 ILL: Illegal instruction\nProcessor cpu1 icount 55 stopped at watchpoint\n watchpoint 0 (processor cpu1:MODE) triggered mode -> 1 (USER)\n\nEach mode change watchpoint that is encountered is reported with lines of this form:\n\nProcessor cpu1 icount 26 stopped at watchpoint\n watchpoint 0 (processor cpu1:MODE) triggered mode -> 1 (USER)\n\nException watchpoints are reported with lines of this form:\n\nProcessor cpu1 icount 29 stopped at watchpoint\n watchpoint 0 (processor cpu1:MODE) triggered mode -> 0 (SUPERVISOR)\n watchpoint 1 (processor cpu1:EXCEPTION) triggered exception -> 1792 ILL: Illegal instruction\n\nNote that exceptions that occur in USER mode cause both an exception and mode watchpoint trigger at the same time, as the exception causes a switch from user to supervisor mode.\n\n19.12 Scheduler Notification\n\nWithout changing the platform or the scheduler, an integrated debugger can be notified when significant actions occur that might require debugger intervention. This is useful when calls to opRootModuleSimulate or opProcessorSimulate are made in code that is not accessible to the debugger - for example from a SystemC platform.\n\nUse the function opSessionDebuggerNotifiersAdd to install callbacks on these actions. This function accepts a pointer to the root module and a struct containing pointers to callbacks for specific phases of simulation:\n\nvoid opSessionDebuggerNotifiersAdd (optModuleP root, optDebuggerNotifiersP notifiers);\nThe \\texttt{optDebuggerNotifiers} structure is defined as:\n\n\\begin{verbatim}\ntypedef struct optDebuggerNotifiersS {\n // Callback into a debugger at the start of simulation\n optSimulateStartFn start;\n // Callback into a debugger before PSE constructors have run\n optSimulateStartFn endPeripheralCons;\n // Callback into a debugger after platform constructor has run\n optSimulateStartFn endPlatformCons;\n // Callback into a debugger after all constructors have run\n optSimulateStartFn endCons;\n // Callback into a debugger after processor has executed a slice\n optSimulatePostProcessorFn postProcessor;\n // Callback into a debugger after peripheral has completed a callback or thread\n optSimulatePostPeriphFn postPeripheral;\n // Callback into a debugger when time advances\n optSimulateTimeAdvanceFn advance;\n // Callback into a debugger at end of simulation\n optSimulateEndFn end;\n // User data, passed to each callback\n void* userData;\n} optDebuggerNotifiers;\n\\end{verbatim}\n\nMacros are provided that define each of the function prototypes for the callbacks:\n\n\\begin{verbatim}\n#define OP_SIMULATE_START_FN(_name) \\\n void _name (\\ \n optModuleP module, \\ \n void* userData) \\\n typedef OP_SIMULATE_START_FN(*optSimulateStartFn));\n\n#define OP_SIMULATE_POST_PROCESSOR_FN(_name) \\\n Bool _name (\\ \n optProcessorP processor, \\ \n void* userData) \\\n typedef OP_SIMULATE_POST_PROCESSOR_FN(*optSimulatePostProcessorFn));\n\\end{verbatim}\n#define OP_SIMULATE_POST_PERIPH_FN(_name) \\\nBool _name ( \\\n optPeripheralP peripheral, \\\n void* userData) typedef \\\nOP_SIMULATE_POST_PERIPH_FN((*optSimulatePostPeriphFn));\n\n/// opSessionDebuggerNotifiersAdd\n#define OP_SIMULATE_END_FN(_name) \\\nvoid _name ( \\\n optProcessorP processor, \\\n void* userData)\ntypedef OP_SIMULATE_END_FN((*optSimulateEndFn));\n\n#define OP_SIMULATE_TIME_ADVANCE_FN(_name) \\\nBool _name ( \\\n optAdvanceTimeInfo info, \\\n void* userData)\ntypedef OP_SIMULATE_TIME_ADVANCE_FN((*optSimulateTimeAdvanceFn));\n\nA typical use of these callbacks might look like (note that not all callbacks need be used -\nunneeded ones may be set to 0):\n\nstatic OP_SIMULATE_START_FN (startSim) {\n // called once:\n // Before at the start of simulation\n ...\n}\n\nstatic OP_SIMULATE_START_FN (endConstructors) {\n // called once\n // after all constructors have run\n ...\n}\n\nstatic OP_SIMULATE_POST_PROCESSOR_FN (debugProc) {\n // called after processor has executed a slice\n optStopReason reason = opProcessorStopReason(processor);\n if (debuggerNeedsToActOnThisReason(reason)) {\n ...\n } else {\n return False;\n }\n}\nstatic OP_SIMULATE_TIME_ADVANCE_FN (advanceTime) {\n // called when (and only when) time is advanced\n ...\n return True;\n}\n\nstatic OP_SIMULATE_END_FN (finishSim) {\n // called when no more instructions to execute, but before destruction.\n ...\n}\n\nint main(...) {\n optDebuggerNotifiers notify = {\n .start = startSim,\n .endPeripheralCons = 0,\n .endPlatformCons = 0,\n .endCons = endConstructors,\n .postProcessor = debugProc,\n .postPeripheral = 0,\n .advance = advanceTime,\n .finish = finishSim,\n .userData = myPointer\n };\n\n // Load the design\n optModuleP root = opRootModuleNew(0, 0, 0);\n\n // request callbacks.\n opSessionDebuggerNotifiersAdd (root, ¬ify);\n\n ...\n}\n\nopSessionDebuggerNotifiersAdd must be called during the construction phase after opRootModuleNew is called. There will be one call to startSim, then a call to debugProc each time a processor core stops executing. This might be because the simulator has executed all the instructions requested of this processor or it might be that a breakpoint, watchpoint or other simulator event has occurred. debugProc will be called if either opRootModuleSimulate(root) or opProcessorSimulate(processor) are used. If the processor has multiple cores, there will be callbacks for each core.\nThe function `debugProc` should return `True` if the simulation can continue after the callback or `False` if the simulation should finish, in which case end of simulation events will be triggered but no more instructions will be simulated.\n\nThe function `finishSim` will be called once, before the platform is destroyed.\n\nThe function `postPeripheral` is required only if you wish to debug PSE code. Leave the callback pointer null if not required. It should return `True` if the simulation can continue after the callback or `False` if the simulation should finish.\n\nThe function `advanceTime` will be called when the simulator moves simulated time forwards. It should return `True` if the simulation can continue after the callback or `False` if the simulation should finish.\n\nThe `userData` value set in the `optDebuggerNotifiers` struct will be passed to every callback.\n\n###"}}},{"rowIdx":294,"cells":{"id":{"kind":"string","value":"312ee83764227adf59d7cef7bfc6b2d40a123da7"},"text":{"kind":"string","value":"MySQL and Windows\nAbstract\n\nThis is the MySQL extract for Microsoft Windows from the MySQL 8.0 Reference Manual.\n\nFor legal information, see the Legal Notices.\n\nFor help with using MySQL, please visit the MySQL Forums, where you can discuss your issues with other MySQL users.\n\nDocument generated on: 2022-06-26 (revision: 73586)\n# Table of Contents\n\nPreface and Legal Notices .......................................................................................................................... v\n\n1 Installing MySQL on Microsoft Windows ................................................................................................. 1\n 1.1 MySQL Installation Layout on Microsoft Windows .............................................................................. 3\n 1.2 Choosing an Installation Package ........................................................................................................ 4\n 1.3 MySQL Installer for Windows .............................................................................................................. 5\n 1.3.1 MySQL Installer Initial Setup ...................................................................................................... 7\n 1.3.2 Setting Alternative Server Paths with MySQL Installer .......................................................... 10\n 1.3.3 Installation Workflows with MySQL Installer ........................................................................... 11\n 1.3.4 MySQL Installer Product Catalog and Dashboard ................................................................... 19\n 1.3.5 MySQLInstallerConsole Reference ......................................................................................... 25\n 1.4 Installing MySQL on Microsoft Windows Using a noinstall ZIP Archive ........................................... 29\n 1.4.1 Extracting the Install Archive ...................................................................................................... 29\n 1.4.2 Creating an Option File .............................................................................................................. 29\n 1.4.3 Selecting a MySQL Server Type .................................................................................................. 31\n 1.4.4 Initializing the Data Directory .................................................................................................... 31\n 1.4.5 Starting the Server for the First Time ......................................................................................... 31\n 1.4.6 Starting MySQL from the Windows Command Line ................................................................ 32\n 1.4.7 Customizing the PATH for MySQL Tools ................................................................................... 33\n 1.4.8 Starting MySQL as a Windows Service ....................................................................................... 34\n 1.4.9 Testing The MySQL Installation ................................................................................................ 36\n 1.5 Troubleshooting a Microsoft Windows MySQL Server Installation .................................................... 37\n 1.6 Windows Postinstallation Procedures .................................................................................................... 38\n 1.7 Windows Platform Restrictions ........................................................................................................... 40\n\n2 Upgrading MySQL on Windows .................................................................................................................... 43\n\n3 Connection to MySQL Server Failing on Windows .................................................................................... 45\n\n4 Reseting the Root Password: Windows Systems .......................................................................................... 47\n\n5 MySQL for Visual Studio ............................................................................................................................ 49\n 5.1 General Information ............................................................................................................................ 49\n 5.1.1 New in Version 1.2 ....................................................................................................................... 50\n 5.1.2 New in Version 2.0 (Development Release) ............................................................................... 51\n 5.2 Installing MySQL for Visual Studio ...................................................................................................... 55\n 5.3 Enabling the MySQL Toolbar ............................................................................................................... 57\n 5.4 Making a Connection ........................................................................................................................... 58\n 5.4.1 Connect Using Server Explorer .................................................................................................. 60\n 5.4.2 Connect Using MySQL Connections Manager ........................................................................... 62\n 5.5 Editing .................................................................................................................................................. 63\n 5.5.1 MySQL SQL Editor ....................................................................................................................... 64\n 5.5.2 Code Editors .................................................................................................................................. 65\n 5.5.3 Editing Tables .................................................................................................................................. 67\n 5.5.4 Editing Views ................................................................................................................................... 72\n 5.5.5 Editing Indexes .............................................................................................................................. 74\n 5.5.6 Editing Foreign Keys .................................................................................................................... 75\n 5.5.7 Editing Stored Procedures and Functions ..................................................................................... 76\n 5.5.8 Editing Triggers ............................................................................................................................ 78\n 5.6 MySQL Project Items ............................................................................................................................... 79\n 5.6.1 MySQL ASP.NET MVC Items ....................................................................................................... 79\n 5.6.2 MySQL Windows Forms Items ...................................................................................................... 86\n 5.7 MySQL Application Configuration Tool ................................................................................................... 88\n 5.7.1 Entity Framework .......................................................................................................................... 89\n 5.7.2 Web Providers .................................................................................................................................. 91\n 5.7.3 Using the MySQL Connection String Editor ................................................................................ 95\n 5.8 MySQL Data Export Tool ....................................................................................................................... 96\n 5.9 DDL T4 Template Macro ....................................................................................................................... 102\n 5.10 Debugging Stored Procedures and Functions ....................................................................................... 103\n 5.11 MySQL for Visual Studio Frequently Asked Questions ....................................................................... 113\nPreface and Legal Notices\n\nThis is the MySQL extract for Microsoft Windows from the MySQL 8.0 Reference Manual.\n\n**Licensing information—MySQL 8.0.** This product may include third-party software, used under license. If you are using a Commercial release of MySQL 8.0, see the MySQL 8.0 Commercial Release License Information User Manual for licensing information, including licensing information relating to third-party software that may be included in this Commercial release. If you are using a Community release of MySQL 8.0, see the MySQL 8.0 Community Release License Information User Manual for licensing information, including licensing information relating to third-party software that may be included in this Community release.\n\n**Licensing information—MySQL NDB Cluster 8.0.** If you are using a Commercial release of MySQL NDB Cluster 8.0, see the MySQL NDB Cluster 8.0 Commercial Release License Information User Manual for licensing information, including licensing information relating to third-party software that may be included in this Commercial release. If you are using a Community release of MySQL NDB Cluster 8.0, see the MySQL NDB Cluster 8.0 Community Release License Information User Manual for licensing information, including licensing information relating to third-party software that may be included in this Community release.\n\n**Licensing information—MySQL for Visual Studio.** This product may include third-party software, used under license. If you are using a Commercial release of MySQL for Visual Studio, see the MySQL for Visual Studio Commercial License Information User Manual for licensing information, including licensing information relating to third-party software that may be included in this Commercial release. If you are using a Community release of MySQL for Visual Studio, see the MySQL for Visual Studio Community License Information User Manual for licensing information, including licensing information relating to third-party software that may be included in this Community release.\n\n**Legal Notices**\n\nCopyright © 1997, 2022, Oracle and/or its affiliates.\n\nThis software and related documentation are provided under a license agreement containing restrictions on use and disclosure and are protected by intellectual property laws. Except as expressly permitted in your license agreement or allowed by law, you may not use, copy, reproduce, translate, broadcast, modify, license, transmit, distribute, exhibit, perform, publish, or display any part, in any form, or by any means. Reverse engineering, disassembly, or decompilation of this software, unless required by law for interoperability, is prohibited.\n\nThe information contained herein is subject to change without notice and is not warranted to be error-free. If you find any errors, please report them to us in writing.\n\nIf this is software or related documentation that is delivered to the U.S. Government or anyone licensing it on behalf of the U.S. Government, then the following notice is applicable:\n\n**U.S. GOVERNMENT END USERS:** Oracle programs (including any operating system, integrated software, any programs embedded, installed or activated on delivered hardware, and modifications of such programs) and Oracle computer documentation or other Oracle data delivered to or accessed by U.S. Government end users are \"commercial computer software\" or \"commercial computer software documentation\" pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations. As such, the use, reproduction, duplication, release, display, disclosure, modification, preparation of derivative works, and/or adaptation of i) Oracle programs (including any operating system, integrated software, any programs embedded, installed or activated on delivered hardware, and modifications of such programs), ii) Oracle computer documentation and/or iii) other Oracle data, is subject to the rights and limitations specified in the license contained in the applicable contract. The terms governing the U.S. Government's use of Oracle cloud services are defined by the applicable contract for such services. No other rights are granted to the U.S. Government.\n\nThis software or hardware is developed for general use in a variety of information management applications. It is not developed or intended for use in any inherently dangerous applications, including\napplications that may create a risk of personal injury. If you use this software or hardware in dangerous applications, then you shall be responsible to take all appropriate fail-safe, backup, redundancy, and other measures to ensure its safe use. Oracle Corporation and its affiliates disclaim any liability for any damages caused by use of this software or hardware in dangerous applications.\n\nOracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners.\n\nIntel and Intel Inside are trademarks or registered trademarks of Intel Corporation. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. AMD, Epyc, and the AMD logo are trademarks or registered trademarks of Advanced Micro Devices. UNIX is a registered trademark of The Open Group.\n\nThis software or hardware and documentation may provide access to or information about content, products, and services from third parties. Oracle Corporation and its affiliates are not responsible for and expressly disclaim all warranties of any kind with respect to third-party content, products, and services unless otherwise set forth in an applicable agreement between you and Oracle. Oracle Corporation and its affiliates will not be responsible for any loss, costs, or damages incurred due to your access to or use of third-party content, products, or services, except as set forth in an applicable agreement between you and Oracle.\n\nThis documentation is NOT distributed under a GPL license. Use of this documentation is subject to the following terms:\n\nYou may create a printed copy of this documentation solely for your own personal use. Conversion to other formats is allowed as long as the actual content is not altered or edited in any way. You shall not publish or distribute this documentation in any form or on any media, except if you distribute the documentation in a manner similar to how Oracle disseminates it (that is, electronically for download on a Web site with the software) or on a CD-ROM or similar medium, provided however that the documentation is disseminated together with the software on the same medium. Any other use, such as any dissemination of printed copies or use of this documentation, in whole or in part, in another publication, requires the prior written consent from an authorized representative of Oracle. Oracle and/or its affiliates reserve any and all rights to this documentation not expressly granted above.\n\n**Access to Oracle Support for Accessibility**\n\nOracle customers that have purchased support have access to electronic support through My Oracle Support. For information, visit https://www.oracle.com/corporate/accessibility/learning-support.html#support-tab.\nChapter 1 Installing MySQL on Microsoft Windows\n\nTable of Contents\n\n1.1 MySQL Installation Layout on Microsoft Windows ........................................................................... 3\n1.2 Choosing an Installation Package ........................................................................................................ 4\n1.3 MySQL Installer for Windows ................................................................................................................ 5\n 1.3.1 MySQL Installer Initial Setup ........................................................................................................... 7\n 1.3.2 Setting Alternative Server Paths with MySQL Installer ................................................................. 10\n 1.3.3 Installation Workflows with MySQL Installer .................................................................................. 11\n 1.3.4 MySQL Installer Product Catalog and Dashboard .......................................................................... 19\n 1.3.5 MySQLInstallerConsole Reference ................................................................................................. 25\n1.4 Installing MySQL on Microsoft Windows Using a noninstall ZIP Archive ............................................ 29\n 1.4.1 Extracting the Install Archive .......................................................................................................... 29\n 1.4.2 Creating an Option File ...................................................................................................................... 29\n 1.4.3 Selecting a MySQL Server Type ....................................................................................................... 31\n 1.4.4 Initializing the Data Directory .......................................................................................................... 31\n 1.4.5 Starting the Server for the First Time ............................................................................................... 31\n 1.4.6 Starting MySQL from the Windows Command Line ........................................................................ 32\n 1.4.7 Customizing the PATH for MySQL Tools ......................................................................................... 33\n 1.4.8 Starting MySQL as a Windows Service ............................................................................................ 34\n 1.4.9 Testing The MySQL Installation ...................................................................................................... 36\n1.5 Troubleshooting a Microsoft Windows MySQL Server Installation ...................................................... 37\n1.6 Windows Postinstallation Procedures .................................................................................................. 38\n1.7 Windows Platform Restrictions ............................................................................................................. 40\n\nImportant\nMySQL 8.0 Server requires the Microsoft Visual C++ 2019 Redistributable Package to run on Windows platforms. Users should make sure the package has been installed on the system before installing the server. The package is available at the Microsoft Download Center. Additionally, MySQL debug binaries require Visual Studio 2019 to be installed.\n\nMySQL is available for Microsoft Windows 64-bit operating systems only. For supported Windows platform information, see https://www.mysql.com/support/supportedplatforms/database.html.\n\nThere are different methods to install MySQL on Microsoft Windows.\n\nMySQL Installer Method\n\nThe simplest and recommended method is to download MySQL Installer (for Windows) and let it install and configure a specific version of MySQL Server as follows:\n\n\n Note\n Unlike the standard MySQL Installer, the smaller web-community version does not bundle any MySQL applications, but downloads only the MySQL products you choose to install.\n\n2. Determine the setup type to use for the initial installation of MySQL products. For example:\n\n • **Developer Default**: Provides a setup type that includes the selected version of MySQL Server and other MySQL tools related to MySQL development, such as MySQL Workbench.\n \n • **Server Only**: Provides a setup for the selected version of MySQL Server without other products.\nAdditional Installation Information\n\n• **Custom**: Enables you to select any version of MySQL Server and other MySQL products.\n\n3. Install the server instance (and products) and then begin the server configuration by following the onscreen instructions. For more information about each individual step, see Section 1.3.3.1, “MySQL Server Configuration with MySQL Installer”.\n\nMySQL is now installed. If you configured MySQL as a service, then Windows automatically starts the MySQL server every time you restart the system. Also, this process installs the MySQL Installer application on the local host, which you can use later to upgrade or reconfigure MySQL server.\n\nNote\n\nIf you installed MySQL Workbench on your system, consider using it to check your new MySQL server connection. By default, the program automatically start after installing MySQL.\n\nAdditional Installation Information\n\nIt is possible to run MySQL as a standard application or as a Windows service. By using a service, you can monitor and control the operation of the server through the standard Windows service management tools. For more information, see Section 1.4.8, “Starting MySQL as a Windows Service”.\n\nTo accommodate the `RESTART` statement, the MySQL server forks when run as a service or standalone, to enable a monitor process to supervise the server process. In this case, there are two `mysqld` processes. If `RESTART` capability is not required, the server can be started with the `--no-monitor` option. See `RESTART Statement`.\n\nGenerally, you should install MySQL on Windows using an account that has administrator rights. Otherwise, you may encounter problems with certain operations such as editing the `PATH` environment variable or accessing the `Service Control Manager`. When installed, MySQL does not need to be executed using a user with Administrator privileges.\n\nFor a list of limitations on the use of MySQL on the Windows platform, see Section 1.7, “Windows Platform Restrictions”.\n\nIn addition to the MySQL Server package, you may need or want additional components to use MySQL with your application or development environment. These include, but are not limited to:\n\n• To connect to the MySQL server using ODBC, you must have a Connector/ODBC driver. For more information, including installation and configuration instructions, see MySQL Connector/ODBC Developer Guide.\n\n Note\n\n MySQL Installer installs and configures Connector/ODBC for you.\n\n• To use MySQL server with .NET applications, you must have the Connector/.NET driver. For more information, including installation and configuration instructions, see MySQL Connector/.NET Developer Guide.\n\n Note\n\n MySQL Installer installs and configures MySQL Connector/.NET for you.\n\nMySQL distributions for Windows can be downloaded from [https://dev.mysql.com/downloads/](https://dev.mysql.com/downloads/). See How to Get MySQL.\n\nMySQL for Windows is available in several distribution formats, detailed here. Generally speaking, you should use MySQL Installer. It contains more features and MySQL products than the older MSI,\nis simpler to use than the compressed file, and you need no additional tools to get MySQL up and running. MySQL Installer automatically installs MySQL Server and additional MySQL products, creates an options file, starts the server, and enables you to create default user accounts. For more information on choosing a package, see Section 1.2, “Choosing an Installation Package”.\n\n- A MySQL Installer distribution includes MySQL Server and additional MySQL products including MySQL Workbench, and MySQL for Visual Studio. MySQL Installer can also be used to upgrade these products in the future (see https://dev.mysql.com/doc/mysql-compat-matrix/en/).\n\nFor instructions on installing MySQL using MySQL Installer, see Section 1.3, “MySQL Installer for Windows”.\n\n- The standard binary distribution (packaged as a compressed file) contains all of the necessary files that you unpack into your chosen location. This package contains all of the files in the full Windows MSI Installer package, but does not include an installation program.\n\nFor instructions on installing MySQL using the compressed file, see Section 1.4, “Installing MySQL on Microsoft Windows Using a noinstall ZIP Archive”.\n\n- The source distribution format contains all the code and support files for building the executables using the Visual Studio compiler system.\n\nFor instructions on building MySQL from source on Windows, see Installing MySQL from Source.\n\nMySQL on Windows Considerations\n\n- Large Table Support\n\nIf you need tables with a size larger than 4GB, install MySQL on an NTFS or newer file system. Do not forget to use `MAX_ROWS` and `AVG_ROW_LENGTH` when you create tables. See CREATE TABLE Statement.\n\n- MySQL and Virus Checking Software\n\nVirus-scanning software such as Norton/Symantec Anti-Virus on directories containing MySQL data and temporary tables can cause issues, both in terms of the performance of MySQL and the virus-scanning software misidentifying the contents of the files as containing spam. This is due to the fingerprinting mechanism used by the virus-scanning software, and the way in which MySQL rapidly updates different files, which may be identified as a potential security risk.\n\nAfter installing MySQL Server, it is recommended that you disable virus scanning on the main directory (`datadir`) used to store your MySQL table data. There is usually a system built into the virus-scanning software to enable specific directories to be ignored.\n\nIn addition, by default, MySQL creates temporary files in the standard Windows temporary directory. To prevent the temporary files also being scanned, configure a separate temporary directory for MySQL temporary files and add this directory to the virus scanning exclusion list. To do this, add a configuration option for the `tmpdir` parameter to your `my.ini` configuration file. For more information, see Section 1.4.2, “Creating an Option File”.\n\n1.1 MySQL Installation Layout on Microsoft Windows\n\nFor MySQL 8.0 on Windows, the default installation directory is `C:\\Program Files\\MySQL\\MySQL Server 8.0` for installations performed with MySQL Installer. If you use the ZIP archive method to install MySQL, you may prefer to install in `C:\\mysql`. However, the layout of the subdirectories remains the same.\n\nAll of the files are located within this parent directory, using the structure shown in the following table.\nChoosing an Installation Package\n\nTable 1.1 Default MySQL Installation Layout for Microsoft Windows\n\n<table>\n<thead>\n<tr>\n<th>Directory</th>\n<th>Contents of Directory</th>\n<th>Notes</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>bin</td>\n<td>mysqld server, client and utility programs</td>\n<td></td>\n</tr>\n<tr>\n<td>%PROGRAMDATA%\\MySQL \\MySQL Server 8.0\\</td>\n<td>Log files, databases</td>\n<td>The Windows system variable %PROGRAMDATA% defaults to C:\\ProgramData.</td>\n</tr>\n<tr>\n<td>docs</td>\n<td>Release documentation</td>\n<td>With MySQL Installer, use the Modify operation to select this optional folder.</td>\n</tr>\n<tr>\n<td>include</td>\n<td>Include (header) files</td>\n<td></td>\n</tr>\n<tr>\n<td>lib</td>\n<td>Libraries</td>\n<td></td>\n</tr>\n<tr>\n<td>share</td>\n<td>Miscellaneous support files, including error messages, character set files, sample configuration files, SQL for database installation</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n1.2 Choosing an Installation Package\n\nFor MySQL 8.0, there are multiple installation package formats to choose from when installing MySQL on Windows. The package formats described in this section are:\n\n- MySQL Installer\n- MySQL noinstall ZIP Archives\n- MySQL Docker Images\n\nProgram Database (PDB) files (with file name extension pdb) provide information for debugging your MySQL installation in the event of a problem. These files are included in ZIP Archive distributions (but not MSI distributions) of MySQL.\n\nMySQL Installer\n\nThis package has a file name similar to mysql-installer-community-8.0.29.0.msi or mysql-installer-commercial-8.0.29.0.msi, and utilizes MSIs to install MySQL server and other products automatically. MySQL Installer downloads and applies updates to itself, and to each of the installed products. It also configures the installed MySQL server (including a sandbox InnoDB cluster test setup) and MySQL Router. MySQL Installer is recommended for most users.\n\nMySQL Installer can install and manage (add, modify, upgrade, and remove) many other MySQL products, including:\n\n- Connectors – MySQL Connector/C++, MySQL Connector/NET, Connector/ODBC, MySQL Connector/Python, MySQL Connector/J, MySQL Connector/Node.js\n- Documentation – MySQL Manual (PDF format), samples and examples\n\nMySQL Installer operates on all MySQL supported versions of Windows (see https://www.mysql.com/support/supportedplatforms/database.html).\nMySQL noinstall ZIP Archives\n\nNote\n\nBecause MySQL Installer is not a native component of Microsoft Windows and depends on .NET, it does not work with minimal installation options like the Server Core version of Windows Server.\n\nFor instructions on how to install MySQL using MySQL Installer, see Section 1.3, “MySQL Installer for Windows”.\n\nMySQL noinstall ZIP Archives\n\nThese packages contain the files found in the complete MySQL Server installation package, with the exception of the GUI. This format does not include an automated installer, and must be manually installed and configured.\n\nThe noinstall ZIP archives are split into two separate compressed files. The main package is named mysql-VERSION-winx64.zip. This contains the components needed to use MySQL on your system. The optional MySQL test suite, MySQL benchmark suite, and debugging binaries/information components (including PDB files) are in a separate compressed file named mysql-VERSION-winx64-debug-test.zip.\n\nIf you choose to install a noinstall ZIP archive, see Section 1.4, “Installing MySQL on Microsoft Windows Using a noinstall ZIP Archive”.\n\nMySQL Docker Images\n\nFor information on using the MySQL Docker images provided by Oracle on Windows platform, see Deploying MySQL on Windows and Other Non-Linux Platforms with Docker.\n\nWarning\n\nThe MySQL Docker images provided by Oracle are built specifically for Linux platforms. Other platforms are not supported, and users running the MySQL Docker images from Oracle on them are doing so at their own risk.\n\n1.3 MySQL Installer for Windows\n\nMySQL Installer is a standalone application designed to ease the complexity of installing and configuring MySQL products that run on Microsoft Windows. It supports the following MySQL products:\n\n• MySQL Servers\n\nMySQL Installer can install and manage multiple, separate MySQL server instances on the same host at the same time. For example, MySQL Installer can install, configure, and upgrade a separate instance of MySQL 5.6, MySQL 5.7, and MySQL 8.0 on the same host. MySQL Installer does not permit server upgrades between major and minor version numbers, but does permit upgrades within a release series (such as 8.0.21 to 8.0.22).\n\nNote\n\nMySQL Installer cannot install both Community and Commercial releases of MySQL server on the same host. If you require both releases on the same host, consider using the ZIP archive distribution to install one of the releases.\n\n• MySQL Applications\n\nMySQL Workbench, MySQL Shell, MySQL Router, and MySQL for Visual Studio.\n\n• MySQL Connectors\nInstallation Requirements\n\nMySQL Connector.NET, MySQL Connector/Python, MySQL Connector/ODBC, MySQL Connector/J, and MySQL Connector/C++. To install MySQL Connector/Node.js, see https://dev.mysql.com/downloads/connector/nodejs/.\n\n• Documentation and Samples\n\nMySQL Reference Manuals (by version) in PDF format and MySQL database samples (by version).\n\nInstallation Requirements\n\nMySQL Installer requires Microsoft .NET Framework 4.5.2 or later. If this version is not installed on the host computer, you can download it by visiting the Microsoft website.\n\nAn internet connection is required to download a manifest containing metadata for the latest MySQL products that are not part of a full bundle. MySQL Installer attempts to download the manifest when you start the application for the first time and then periodically in configurable intervals (see MySQL Installer options). Alternatively, you can retrieve an updated manifest manually by clicking Catalog in the MySQL Installer dashboard.\n\nNote\n\nIf the first-time or subsequent manifest download is unsuccessful, an error is logged and you may have limited access to MySQL products during your session. MySQL Installer attempts to download the manifest with each startup until the initial manifest structure is updated. For help finding a product, see Locating Products to Install.\n\nMySQL Installer Community Release\n\nDownload software from https://dev.mysql.com/downloads/installer/ to install the Community release of all MySQL products for Windows. Select one of the following MySQL Installer package options:\n\n• Web: Contains MySQL Installer and configuration files only. The web package option downloads only the MySQL products you select to install, but it requires an internet connection for each download. The size of this file is approximately 2 MB. The file name has the form mysql-installer-community-web-VERSION.N.msi in which VERSION is the MySQL server version number such as 8.0 and N is the package number, which begins at 0.\n\n• Full or Current Bundle: Bundles all of the MySQL products for Windows (including the MySQL server). The file size is over 300 MB, and the name has the form mysql-installer-community-VERSION.N.msi in which VERSION is the MySQL Server version number such as 8.0 and N is the package number, which begins at 0.\n\nMySQL Installer Commercial Release\n\nDownload software from https://edelivery.oracle.com/ to install the Commercial release (Standard or Enterprise Edition) of MySQL products for Windows. If you are logged in to your My Oracle Support (MOS) account, the Commercial release includes all of the current and previous GA versions available in the Community release, but it excludes development-milestone versions. When you are not logged in, you see only the list of bundled products that you downloaded already.\n\nThe Commercial release also includes the following products:\n\n• Workbench SE/EE\n• MySQL Enterprise Backup\n• MySQL Enterprise Firewall\n\nThe Commercial release integrates with your MOS account. For knowledge-base content and patches, see My Oracle Support.\n1.3.1 MySQL Installer Initial Setup\n\n- Choosing a Setup Type\n- Path Conflicts\n- Check Requirements\n- MySQL Installer Configuration Files\n\nWhen you download MySQL Installer for the first time, a setup wizard guides you through the initial installation of MySQL products. As the following figure shows, the initial setup is a one-time activity in the overall process. MySQL Installer detects existing MySQL products installed on the host during its initial setup and adds them to the list of products to be managed.\n\nFigure 1.1 MySQL Installer Process Overview\n\nMySQL Installer extracts configuration files (described later) to the hard drive of the host during the initial setup. Although MySQL Installer is a 32-bit application, it can install both 32-bit and 64-bit binaries.\n\nThe initial setup adds a link to the Start menu under the MySQL group. Click Start, All Programs, MySQL, MySQL Installer to open MySQL Installer.\n\nChoosing a Setup Type\n\nDuring the initial setup, you are prompted to select the MySQL products to be installed on the host. One alternative is to use a predetermined setup type that matches your setup requirements. By default, both GA and pre-release products are included in the download and installation with the Developer Default, Client only, and Full setup types. Select the Only install GA products option to restrict the product set to include GA products only when using these setup types.\n\nNote\n\nCommercial-only MySQL products, such as MySQL Enterprise Backup, are available to select and install if you are using the Commercial version of MySQL Installer (see MySQL Installer Commercial Release).\n\nChoosing one of the following setup types determines the initial installation only and does not limit your ability to install or update MySQL products for Windows later:\n\n- **Developer Default**: Install the following products that compliment application development with MySQL:\n - MySQL Server (Installs the version that you selected when you downloaded MySQL Installer.)\n - MySQL Shell\n - MySQL Router\n - MySQL Workbench\nMySQL Installer Initial Setup\n\n- MySQL for Visual Studio\n- MySQL Connectors (for .NET, Python, ODBC, Java, and C++)\n- MySQL Documentation\n- MySQL Samples and Examples\n\n- **Server only**: Only install the MySQL server. This setup type installs the general availability (GA) or development release server that you selected when you downloaded MySQL Installer. It uses the default installation and data paths.\n\n- **Client only**: Only install the most recent MySQL applications and MySQL connectors. This setup type is similar to the Developer Default type, except that it does not include MySQL server or the client programs typically bundled with the server, such as `mysql` or `mysqladmin`.\n\n- **Full**: Install all available MySQL products.\n\n- **Custom**: The custom setup type enables you to filter and select individual MySQL products from the MySQL Installer catalog.\n\n**Note**\n\nFor MySQL Server versions 8.0.20 (and earlier), 5.7, and 5.6, the account you use to run MySQL Installer may not have adequate permission to install the server data files and this can interrupt the installation because the ExecSecureObjects MSI action cannot be executed. To proceed, deselect the Server data files feature before attempting to install the server again. For help, see Product Features To Install.\n\nThe Server data files check box was removed from the feature tree for MySQL Server 8.0.21 (and higher).\n\nUse the Custom setup type to install:\n\n- A product or product version that is not available from the usual download locations. The catalog contains all product releases, including the other releases between pre-release (or development) and GA.\n\n- An instance of MySQL server using an alternative installation path, data path, or both. For instructions on how to adjust the paths, see Section 1.3.2, “Setting Alternative Server Paths with MySQL Installer”.\n\n- Two or more MySQL server versions on the same host at the same time (for example, 5.6, 5.7, and 8.0).\n\n- A specific combination of products and features not offered as a predetermine setup type. For example, you can install a single product, such as MySQL Workbench, instead of installing all client applications for Windows.\n\n**Path Conflicts**\n\nWhen the default installation or data folder (required by MySQL server) for a product to be installed already exists on the host, the wizard displays the Path Conflict step to identify each conflict and enable you to take action to avoid having files in the existing folder overwritten by the new installation. You see this step in the initial setup only when MySQL Installer detects a conflict.\n\nTo resolve the path conflict, do one of the following:\n\n- Select a product from the list to display the conflict options. A warning symbol indicates which path is in conflict. Use the browse button to choose a new path and then click **Next**.\nMySQL Installer Initial Setup\n\n- Click **Back** to choose a different setup type or product version, if applicable. The **Custom** setup type enables you to select individual product versions.\n\n- Click **Next** to ignore the conflict and overwrite files in the existing folder.\n\n- Delete the existing product. Click **Cancel** to stop the initial setup and close MySQL Installer. Open MySQL Installer again from the Start menu and delete the installed product from the host using the Delete operation from the MySQL Installer dashboard.\n\n**Check Requirements**\n\nMySQL Installer uses entries in the `package-rules.xml` file to determine whether the prerequisite software for each product is installed on the host. When the requirements check fails, MySQL Installer displays the **Check Requirements** step to help you update the host. Requirements are evaluated each time you download a new product (or version) for installation. The following figure identifies and describes the key areas of this step.\n\n---\n\n**Description of Check Requirements Elements**\n\n1. Shows the current step in the initial setup. Steps in this list may change slightly depending on the products already installed on the host, the availability of prerequisite software, and the products to be installed on the host.\n\n2. Lists all pending installation requirements by product and indicates the status as follows:\n - A blank space in the **Status** column means that MySQL Installer can attempt to download and install the required software for you.\n - The word **Manual** in the **Status** column means that you must satisfy the requirement manually. Select each product in the list to see its requirement details.\n\n3. Describes the requirement in detail to assist you with each manual resolution. When possible, a download URL is provided. After you download and install the required software, click **Check** to verify that the requirement has been met.\n4. Provides the following set operations to proceed:\n\n- **Back** – Return to the previous step. This action enables you to select a different the setup type.\n\n- **Execute** – Have MySQL Installer attempt to download and install the required software for all items without a manual status. Manual requirements are resolved by you and verified by clicking **Check**.\n\n- **Next** – Do not execute the request to apply the requirements automatically and proceed to the installation without including the products that fail the check requirements step.\n\n- **Cancel** – Stop the installation of MySQL products. Because MySQL Installer is already installed, the initial setup begins again when you open MySQL Installer from the Start menu and click **Add** from the dashboard. For a description of the available management operations, see **Product Catalog**.\n\n### MySQL Installer Configuration Files\n\nAll MySQL Installer files are located within the `C:\\Program Files (x86)` and `C:\\ProgramData` folders. The following table describes the files and folders that define MySQL Installer as a standalone application.\n\n#### Note\n\nInstalled MySQL products are neither altered nor removed when you update or uninstall MySQL Installer.\n\n<table>\n<thead>\n<tr>\n<th>File or Folder</th>\n<th>Description</th>\n<th>Folder Hierarchy</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>MySQL Installer for Windows</strong></td>\n<td>This folder contains all of the files needed to run MySQL Installer and <code>MySQLInstallerConsole.exe</code>, a command-line program with similar functionality.</td>\n<td><code>C:\\Program Files (x86)</code></td>\n</tr>\n<tr>\n<td><strong>Templates</strong></td>\n<td>The <code>Templates</code> folder has one file for each version of MySQL server. Template files contain keys and formulas to calculate some values dynamically.</td>\n<td><code>C:\\ProgramData\\MySQL\\MySQL Installer for Windows\\Manifest</code></td>\n</tr>\n<tr>\n<td><strong>package-rules.xml</strong></td>\n<td>This file contains the prerequisites for every product to be installed.</td>\n<td><code>C:\\ProgramData\\MySQL\\MySQL Installer for Windows\\Manifest</code></td>\n</tr>\n<tr>\n<td><strong>produts.xml</strong></td>\n<td>The <code>produts.xml</code> file (or product catalog) contains a list of all products available for download.</td>\n<td><code>C:\\ProgramData\\MySQL\\MySQL Installer for Windows\\Manifest</code></td>\n</tr>\n<tr>\n<td><strong>Product Cache</strong></td>\n<td>The <code>Product Cache</code> folder contains all standalone <code>.msi</code> files bundled with the full package or downloaded afterward.</td>\n<td><code>C:\\ProgramData\\MySQL\\MySQL Installer for Windows</code></td>\n</tr>\n</tbody>\n</table>\n\n### 1.3.2 Setting Alternative Server Paths with MySQL Installer\n\nYou can change the default installation path, the data path, or both when you install MySQL server. After you have installed the server, the paths cannot be altered without removing and reinstalling the server instance.\nStarting with MySQL Installer 1.4.39, if you move the data directory of an installed server manually, MySQL Installer identifies the change and can process a reconfiguration operation without errors.\n\nTo change paths for MySQL server\n\n1. Identify the MySQL server to change and enable the Advanced Options link as follows:\n a. Navigate to the Select Products page by doing one of the following:\n i. If this is an initial setup of MySQL Installer, select the Custom setup type and click Next.\n ii. If MySQL Installer is installed on your computer, click Add from the dashboard.\n b. Click Edit to apply a filter on the product list shown in Available Products (see Locating Products to Install).\n c. With the server instance selected, use the arrow to move the selected server to the Products To Be Installed list.\n d. Click the server to select it. When you select the server, the Advanced Options link is enabled below the list of products to be installed (see the following figure).\n\n2. Click Advanced Options to open a dialog box where you can enter alternative path names. After the path names are validated, click Next to continue with the configuration steps.\n\nFigure 1.3 Change MySQL Server Path\n\n1.3.3 Installation Workflows with MySQL Installer\n\nMySQL Installer provides a wizard-like tool to install and configure new MySQL products for Windows. Unlike the initial setup, which runs only once, MySQL Installer invokes the wizard each time you download or install a new product. For first-time installations, the steps of the initial setup proceed directly into the steps of the installation. For assistance with product selection, see Locating Products to Install.\nInstallation Workflows with MySQL Installer\n\nNote\n\nFull permissions are granted to the user executing MySQL Installer to all generated files, such as my.ini. This does not apply to files and directories for specific products, such as the MySQL server data directory in %ProgramData% that is owned by SYSTEM.\n\nProducts installed and configured on a host follow a general pattern that might require your input during the various steps. If you attempt to install a product that is incompatible with the existing MySQL server version (or a version selected for upgrade), you are alerted about the possible mismatch.\n\nMySQL Installer provides the following sequence of actions that apply to different workflows:\n\n- **Select Products.** If you selected the Custom setup type during the initial setup or clicked Add from the MySQL Installer dashboard, MySQL Installer includes this action in the sidebar. From this page, you can apply a filter to modify the Available Products list and then select one or more products to move (using arrow keys) to the Products To Be Installed list.\n\n Select the check box on this page to activate the Select Features action where you can customize the products features after the product is downloaded.\n\n- **Download.** If you installed the full (not web) MySQL Installer package, all .msi files were loaded to the Product Cache folder during the initial setup and are not downloaded again. Otherwise, click Execute to begin the download. The status of each product changes from Ready to Download, to Downloading, and then to Downloaded.\n\n- **Select Features To Install (disabled by default).** After MySQL Installer downloads a product’s .msi file, you can customize the features if you enabled the optional check box previously during the Select Products action.\n\n To customize product features after the installation, click Modify in the MySQL Installer dashboard.\n\n- **Installation.** The status of each product in the list changes from Ready to Install, to Installing, and lastly to Complete. During the process, click Show Details to view the installation actions.\n\n If you cancel the installation at this point, the products are installed, but the server (if installed) is not yet configured. To restart the server configuration, open MySQL Installer from the Start menu and click Reconfigure next to the appropriate server in the dashboard.\n\n- **Product configuration.** This step applies to MySQL Server, MySQL Router, and samples only. The status for each item in the list should indicate Ready to Configure. Click Next to start the configuration wizard for all items in the list. The configuration options presented during this step are specific to the version of database or router that you selected to install.\n\n Click Execute to begin applying the configuration options or click Back (repeatedly) to return to each configuration page.\n\n- **Installation complete.** This step finalizes the installation for products that do not require configuration. It enables you to copy the log to a clipboard and to start certain applications, such as MySQL Workbench and MySQL Shell. Click Finish to open the MySQL Installer dashboard.\n\n1.3.3.1 MySQL Server Configuration with MySQL Installer\n\nMySQL Installer performs the initial configuration of the MySQL server. For example:\n\n- It creates the configuration file (my.ini) that is used to configure the MySQL server. The values written to this file are influenced by choices you make during the installation process. Some definitions are host dependent. For example, query_cache is enabled if the host has fewer than three cores.\nInstallation Workflows with MySQL Installer\n\nNote\nQuery cache was deprecated in MySQL 5.7 and removed in MySQL 8.0 (and later).\n\n• By default, a Windows service for the MySQL server is added.\n\n• Provides default installation and data paths for MySQL server. For instructions on how to change the default paths, see Section 1.3.2, “Setting Alternative Server Paths with MySQL Installer”.\n\n• It can optionally create MySQL server user accounts with configurable permissions based on general roles, such as DB Administrator, DB Designer, and Backup Admin. It optionally creates a Windows user named MysqlSys with limited privileges, which would then run the MySQL Server. User accounts may also be added and configured in MySQL Workbench.\n\n• Checking Show Advanced Options enables additional Logging Options to be set. This includes defining custom file paths for the error log, general log, slow query log (including the configuration of seconds it requires to execute a query), and the binary log.\n\nDuring the configuration process, click Next to proceed to the next step or Back to return to the previous step. Click Execute at the final step to apply the server configuration.\n\nThe sections that follow describe the server configuration options that apply to MySQL server on Windows. The server version you installed will determine which steps and options you can configure. Configuring MySQL server may include some or all of the steps.\n\nType and Networking\n\n• Server Configuration Type\n\nChoose the MySQL server configuration type that describes your setup. This setting defines the amount of system resources (memory) to assign to your MySQL server instance.\n\n• Development: A computer that hosts many other applications, and typically this is your personal workstation. This setting configures MySQL to use the least amount of memory.\n\n• Server: Several other applications are expected to run on this computer, such as a web server. The Server setting configures MySQL to use a medium amount of memory.\n\n• Dedicated: A computer that is dedicated to running the MySQL server. Because no other major applications run on this server, this setting configures MySQL to use the majority of available memory.\n\n• Connectivity\n\nConnectivity options control how the connection to MySQL is made. Options include:\n\n• TCP/IP: This option is selected by default. You may disable TCP/IP Networking to permit local host connections only. With the TCP/IP connection option selected, you can modify the following items:\n\n • Port for classic MySQL protocol connections. The default value is 3306.\n\n • X Protocol Port shown when configuring MySQL 8.0 server only. The default value is 33060.\n\n • Open Windows Firewall port for network access, which is selected by default for TCP/IP connections.\n\nIf a port number is in use already, you will see the information icon (⚠️) next to the default value and Next is disabled until you provide a new port number.\n• **Named Pipe**: Enable and define the pipe name, similar to setting the `named_pipe` system variable. The default name is MySQL.\n\nWhen you select **Named Pipe** connectivity, and then proceed to the next step, you are prompted to set the level of access control granted to client software on named-pipe connections. Some clients require only minimum access control for communication, while other clients require full access to the named pipe.\n\nYou can set the level of access control based on the Windows user (or users) running the client as follows:\n\n- **Minimum access to all users (RECOMMENDED)**. This level is enabled by default because it is the most secure.\n\n- **Full access to members of a local group**. If the minimum-access option is too restrictive for the client software, use this option to reduce the number of users who have full access on the named pipe. The group must be established on Windows before you can select it from the list. Membership in this group should be limited and managed. Windows requires a newly added member to first log out and then log in again to join a local group.\n\n- **Full access to all users (NOT RECOMMENDED)**. This option is less secure and should be set only when other safeguards are implemented.\n\n• **Shared Memory**: Enable and define the memory name, similar to setting the `shared_memory` system variable. The default name is MySQL.\n\n• **Advanced Configuration**\n\n Check **Show Advanced and Logging Options** to set custom logging and advanced options in later steps. The Logging Options step enables you to define custom file paths for the error log, general log, slow query log (including the configuration of seconds it requires to execute a query), and the binary log. The Advanced Options step enables you to set the unique server ID required when binary logging is enabled in a replication topology.\n\n• **MySQL Enterprise Firewall (Enterprise Edition only)**\n\n The **Enable MySQL Enterprise Firewall** check box is deselected by default. Select this option to enable a security list that offers protection against certain types of attacks. Additional post-installation configuration is required (see **MySQL Enterprise Firewall**).\n\n **Important**\n\n There is an issue for MySQL 8.0.19 that prevents the server from starting if MySQL Enterprise Firewall is selected during the server configuration steps. If the server startup operation fails, click **Cancel** to end the configuration process and return to the dashboard. You must uninstall the server.\n\n The workaround is to run MySQL Installer without MySQL Enterprise Firewall selected. (That is, do not select the **Enable MySQL Enterprise Firewall** check box.) Then install MySQL Enterprise Firewall afterward using the instructions for manual installation (see **Installing or Uninstalling MySQL Enterprise Firewall**).\n\n**Authentication Method**\n\nThe **Authentication Method** step is visible only during the installation or upgrade of MySQL 8.0.4 or higher. It introduces a choice between two server-side authentication options. The MySQL user accounts that you create in the next step will use the authentication method that you select in this step.\nMySQL 8.0 connectors and community drivers that use libmysqlclient 8.0 now support the mysql_native_password default authentication plugin. However, if you are unable to update your clients and applications to support this new authentication method, you can configure the MySQL server to use mysql_native_password for legacy authentication. For more information about the implications of this change, see caching_sha2_password as the Preferred Authentication Plugin.\n\nIf you are installing or upgrading to MySQL 8.0.4 or higher, select one of the following authentication methods:\n\n- Use Strong Password Encryption for Authentication (RECOMMENDED)\n MySQL 8.0 supports a new authentication based on improved, stronger SHA256-based password methods. It is recommended that all new MySQL server installations use this method going forward.\n\n Important\n The caching_sha2_password authentication plugin on the server requires new versions of connectors and clients, which add support for the new MySQL 8.0 default authentication.\n\n- Use Legacy Authentication Method (Retain MySQL 5.x Compatibility)\n Using the old MySQL 5.x legacy authentication method should be considered only in the following cases:\n - Applications cannot be updated to use MySQL 8.0 connectors and drivers.\n - Recompilation of an existing application is not feasible.\n - An updated, language-specific connector or driver is not available yet.\n\n### Accounts and Roles\n\n- **Root Account Password**\n Assigning a root password is required and you will be asked for it when performing other MySQL Installer operations. Password strength is evaluated when you repeat the password in the box provided. For descriptive information regarding password requirements or status, move your mouse pointer over the information icon (⚠️) when it appears.\n\n- **MySQL User Accounts (Optional)**\n Click Add User or Edit User to create or modify MySQL user accounts with predefined roles. Next, enter the required account credentials:\n - **User Name:** MySQL user names can be up to 32 characters long.\n - **Host:** Select localhost for local connections only or <All Hosts (%)> when remote connections to the server are required.\n - **Role:** Each predefined role, such as DB Admin, is configured with its own set of privileges. For example, the DB Admin role has more privileges than the DB Designer role. The Role drop-down list contains a description of each role.\n - **Password:** Password strength assessment is performed while you type the password. Passwords must be confirmed. MySQL permits a blank or empty password (considered to be insecure).\n\n**MySQL Installer Commercial Release Only:** MySQL Enterprise Edition for Windows, a commercial product, also supports an authentication method that performs external authentication on Windows. Accounts authenticated by the Windows operating system can access the MySQL server without providing an additional password.\nTo create a new MySQL account that uses Windows authentication, enter the user name and then select a value for **Host** and **Role**. Click **Windows** authentication to enable the `authentication_windows` plugin. In the Windows Security Tokens area, enter a token for each Windows user (or group) who can authenticate with the MySQL user name. MySQL accounts can include security tokens for both local Windows users and Windows users that belong to a domain. Multiple security tokens are separated by the semicolon character (`;`) and use the following format for local and domain accounts:\n\n- **Local account**\n \n Enter the simple Windows user name as the security token for each local user or group; for example, `finley;jeffrey;admin`.\n\n- **Domain account**\n \n Use standard Windows syntax (`domain\\domainuser`) or MySQL syntax (`domain\\domainuser`) to enter Windows domain users and groups.\n\n For domain accounts, you may need to use the credentials of an administrator within the domain if the account running MySQL Installer lacks the permissions to query the Active Directory. If this is the case, select **Validate Active Directory users with** to activate the domain administrator credentials.\n\n Windows authentication permits you to test all of the security tokens each time you add or modify a token. Click **Test Security Tokens** to validate (or revalidate) each token. Invalid tokens generate a descriptive error message along with a red `X` icon and red token text. When all tokens resolve as valid (green text without an `X` icon), you can click **OK** to save the changes.\n\n**Windows Service**\n\nOn the Windows platform, MySQL server can run as a named service managed by the operating system and be configured to start up automatically when Windows starts. Alternatively, you can configure MySQL server to run as an executable program that requires manual configuration.\n\n- **Configure MySQL server as a Windows service** (Selected by default.)\n \n When the default configuration option is selected, you can also select the following:\n\n - **Start the MySQL Server at System Startup**\n \n When selected (default), the service startup type is set to Automatic; otherwise, the startup type is set to Manual.\n\n - **Run Windows Service as**\n \n When **Standard System Account** is selected (default), the service logs on as Network Service.\n\n The **Custom User** option must have privileges to log on to Microsoft Windows as a service. The **Next** button will be disabled until this user is configured with the required privileges.\n\n A custom user account is configured in Windows by searching for \"local security policy\" in the Start menu. In the Local Security Policy window, select **Local Policies. User Rights Assignment**, and then **Log On As A Service** to open the property dialog. Click **Add User or Group** to add the custom user and then click **OK** in each dialog to save the changes.\n\n- **Deselect the Windows Service option**\nLogging Options\n\nThis step is available if the Show Advanced Configuration check box was selected during the Type and Networking step. To enable this step now, click Back to return to the Type and Networking step and select the check box.\n\nAdvanced configuration options are related to the following MySQL log files:\n\n- Error Log\n- General Log\n- Slow Query Log\n- Bin Log\n\nNote\n\nThe binary log is enabled by default for MySQL 5.7 and higher.\n\nAdvanced Options\n\nThis step is available if the Show Advanced Configuration check box was selected during the Type and Networking step. To enable this step now, click Back to return to the Type and Networking step and select the check box.\n\nThe advanced-configuration options include:\n\n- Server ID\n\nSet the unique identifier used in a replication topology. If binary logging is enabled, you must specify a server ID. The default ID value depends on the server version. For more information, see the description of the server_id system variable.\n\n- Table Names Case\n\nYou can set the following options during the initial and subsequent configuration the server. For the MySQL 8.0 release series, these options apply only to the initial configuration of the server.\n\n- Lower Case\n\nSets the lower_case_table_names option value to 1 (default), in which table names are stored in lowercase on disk and comparisons are not case-sensitive.\n\n- Preserve Given Case\n\nSets the lower_case_table_names option value to 2, in which table names are stored as given but compared in lowercase.\n\nApply Server Configuration\n\nAll configuration settings are applied to the MySQL server when you click Execute. Use the Configuration Steps tab to follow the progress of each action; the icon for each toggles from white to green (with a check mark) on success. Otherwise, the process stops and displays an error message if an individual action times out. Click the Log tab to view the log.\n\nWhen the installation completes successfully and you click Finish, MySQL Installer and the installed MySQL products are added to the Microsoft Windows Start menu under the MySQL group. Opening MySQL Installer loads the dashboard where installed MySQL products are listed and other MySQL Installer operations are available.\n1.3.3.2 MySQL Router Configuration with MySQL Installer\n\nMySQL Installer downloads and installs a suite of tools for developing and managing business-critical applications on Windows. The suite consists of applications, connectors, documentation, and samples.\n\nDuring the initial setup, choose any predetermined setup type, except Server only, to install the latest GA version of the tools. Use the Custom setup type to install an individual tool or specific version. If MySQL Installer is installed on the host already, use the Add operation to select and install tools from the MySQL Installer dashboard.\n\nMySQL Router Configuration\n\nMySQL Installer provides a configuration wizard that can bootstrap an installed instance of MySQL Router 8.0 to direct traffic between MySQL applications and an InnoDB Cluster. When configured, MySQL Router runs as a local Windows service.\n\n**Note**\n\nYou are prompted to configure MySQL Router after the initial installation and when you reconfigure an installed router explicitly. In contrast, the upgrade operation does not require or prompt you to configure the upgraded product.\n\nTo configure MySQL Router, do the following:\n\n1. Set up InnoDB Cluster.\n\n2. Using MySQL Installer, download and install the MySQL Router application. After the installation finishes, the configuration wizard prompts you for information. Select the Configure MySQL Router for InnoDB Cluster check box to begin the configuration and provide the following configuration values:\n\n - **Hostname**: Host name of the primary (seed) server in the InnoDB Cluster (localhost by default).\n - **Port**: The port number of the primary (seed) server in the InnoDB Cluster (3306 by default).\n - **Management User**: An administrative user with root-level privileges.\n - **Password**: The password for the management user.\n - **Classic MySQL protocol connections to InnoDB Cluster**\n\n - **Read/Write**: Set the first base port number to one that is unused (between 80 and 65532) and the wizard will select the remaining ports for you.\n\nThe figure that follows shows an example of the MySQL Router configuration page, with the first base port number specified as 6446 and the remaining ports set by the wizard to 6447, 6448, and 6449.\n3. Click **Next** and then **Execute** to apply the configuration. Click **Finish** to close MySQL Installer or return to the MySQL Installer dashboard.\n\nAfter configuring MySQL Router, the root account exists in the user table as `root@localhost` (local) only, instead of `root@%` (remote). Regardless of where the router and client are located, even if both are located on the same host as the seed server, any connection that passes through the router is viewed by server as being remote, not local. As a result, a connection made to the server using the local host (see the example that follows), does not authenticate.\n\n```bash\n$> \\c root@localhost:6446\n```\n\n### 1.3.4 MySQL Installer Product Catalog and Dashboard\n\nThis section describes the MySQL Installer product catalog, the dashboard, and other actions related to product selection and upgrades.\n\n- Product Catalog\n- MySQL Installer Dashboard\n- Locating Products to Install\n- Upgrading MySQL Server\n- Removing MySQL Server\n- Upgrading MySQL Installer\n\n**Product Catalog**\n\nThe product catalog stores the complete list of released MySQL products for Microsoft Windows that are available to download from MySQL Downloads. By default, and when an Internet connection is...\npresent, MySQL Installer attempts to update the catalog at startup every seven days. You can also\nupdate the catalog manually from the dashboard (described later).\n\nAn up-to-date catalog performs the following actions:\n\n• Populates the **Available Products** pane of the Select Products page. This step appears when you\n select:\n • The **Custom** setup type during the **initial setup**.\n • The **Add** operation from the dashboard.\n• Identifies when product updates are available for the installed products listed in the dashboard.\n\nThe catalog includes all development releases (Pre-Release), general releases (Current GA), and\nminor releases (Other Releases). Products in the catalog will vary somewhat, depending on the\nMySQL Installer release that you download.\n\n**MySQL Installer Dashboard**\n\nThe MySQL Installer dashboard is the default view that you see when you start MySQL Installer after\nthe **initial setup** finishes. If you closed MySQL Installer before the setup was finished, MySQL Installer\nresumes the initial setup before it displays the dashboard.\n\n**Note**\n\nProducts covered under Oracle Lifetime Sustaining Support, if installed, may\nappear in the dashboard. These products, such as MySQL for Excel and\nMySQL Notifier, can be modified or removed only.\n\n**Figure 1.5 MySQL Installer Dashboard Elements**\n\n**Description of MySQL Installer Dashboard Elements**\n\n1. MySQL Installer dashboard operations provide a variety of actions that apply to installed products\n or products listed in the catalog. To initiate the following operations, first click the operation link and\n then select the product or products to manage:\n- **Add**: This operation opens the Select Products page. From there you can adjust the filter, select one or more products to download (as needed), and begin the installation. For hints about using the filter, see Locating Products to Install.\n\nUse the directional arrows to move each product from the **Available Products** column to the **Products To Be Installed** column. To enable the Product Features page where you can customize features, click the related check box (disabled by default).\n\n**Note**\n\nFor MySQL Server versions 8.0.20 (and earlier), 5.7, and 5.6, the account you use to run MySQL Installer may not have adequate permission to install the server data files and this can interrupt the installation because the ExecSecureObjects MSI action cannot be executed. To proceed, deselect the **Server data files** feature before attempting to install the server again.\n\nThe **Server data files** check box was removed from the feature tree for MySQL Server 8.0.21 (or higher).\n\n- **Modify**: Use this operation to add or remove the features associated with installed products. Features that you can modify vary in complexity by product. When the **Program Shortcut** check box is selected, the product appears in the Start menu under the **MySQL** group.\n\n- **Upgrade**: This operation loads the Select Products to Upgrade page and populates it with all the upgrade candidates. An installed product can have more than one upgrade version and the operation requires a current product catalog. MySQL Installer upgrades all of the selected products in one action. Click **Show Details** to view the actions performed by MySQL Installer.\n\n- **Remove**: This operation opens the Remove Products page and populates it with the MySQL products installed on the host. Select the MySQL products you want to remove (uninstall) and then click **Execute** to begin the removal process. During the operation, an indicator shows the number of steps that are executed as a percentage of all steps.\n\nTo select products to remove, do one of the following:\n\n- Select the check box for one or more products.\n- Select the **Product** check box to select all products.\n\n2. The **Reconfigure** link in the Quick Action column next to each installed server loads the current configuration values for the server and then cycles through all configuration steps enabling you to change the options and values. You must provide credentials with root privileges to reconfigure these items. Click the **Log** tab to show the output of each configuration step performed by MySQL Installer.\n\nOn completion, MySQL Installer stops the server, applies the configuration changes, and restarts the server for you. For a description of each configuration option, see Section 1.3.3.1, “MySQL Server Configuration with MySQL Installer”. Installed **Samples and Examples** associated with a specific MySQL server version can be also be reconfigured to apply new feature settings, if any.\n\n3. The **Catalog** link enables you to download the latest catalog of MySQL products manually and then to integrate those product changes with MySQL Installer. The catalog-download action does not perform an upgrade of the products already installed on the host. Instead, it returns to the\ndashboard and adds an arrow icon to the Version column for each installed product that has a newer version. Use the **Upgrade** operation to install the newer product version.\n\nYou can also use the **Catalog** link to display the current change history of each product without downloading the new catalog. Select the **Do not update at this time** check box to view the change history only.\n\n4. The MySQL Installer About icon (️) shows the current version of MySQL Installer and general information about MySQL. The version number is located above the **Back** button.\n\n **Tip**\n\n Always include this version number when reporting a problem with MySQL Installer.\n\nIn addition to the About MySQL information (️), you can also select the following icons from the side panel:\n\n- License icon (️) for MySQL Installer.\n\n This product may include third-party software, used under license. If you are using a Commercial release of MySQL Installer, the icon opens the MySQL Installer Commercial License Information User Manual for licensing information, including licensing information relating to third-party software that may be included in this Commercial release. If you are using a Community release of MySQL Installer, the icon opens the MySQL Installer Community License Information User Manual for licensing information, including licensing information relating to third-party software that may be included in this Community release.\n\n- Resource links icon (️) to the latest MySQL product documentation, blogs, webinars, and more.\n\n5. The MySQL Installer Options icon (️) includes the following tabs:\n\n - **Product Catalog**: Manages the automatic catalog updates. By default, MySQL Installer checks for catalog updates at startup every seven days. When new products or product versions are available, MySQL Installer adds them to the catalog and then inserts an arrow icon (️) next to the version number of installed products listed in the dashboard.\n\n Use the product catalog option to enable or disable automatic updates and to reset the number of days between automatic catalog downloads. At startup, MySQL Installer uses the number of days you set to determine whether a download should be attempted. This action is repeated during next startup if MySQL Installer encounters an error downloading the catalog.\n\n - **Connectivity Settings**: Several operations performed by MySQL Installer require internet access. This option enables you to use a default value to validate the connection or to use a different URL, one selected from a list or added by you manually. With the **Manual** option selected, new URLs can be added and all URLs in the list can be moved or deleted. When the **Automatic** option is selected, MySQL Installer attempts to connect to each default URL in the list (in order) until a connection is made. If no connection can be made, it raises an error.\n\n**Locating Products to Install**\n\nMySQL products in the catalog are listed by category: MySQL Servers, Applications, MySQL Connectors, and Documentation. Only the latest GA versions appear in the **Available Products** pane.\nby default. If you are looking for a pre-release or older version of a product, it may not be visible in the default list.\n\n**Note**\n\nKeep the product catalog up-to-date. Click **Catalog** on the MySQL Installer dashboard to download the latest manifest.\n\nTo change the default product list, click **Add** in the dashboard to open the Select Products page, and then click **Edit** to open the dialog box shown in the figure that follows. Modify the settings and then click **Filter**.\n\n**Figure 1.6 Filter Available Products**\n\n\n\nReset one or more of the following fields to modify the list of available products:\n\n- **Text**: Filter by text.\n- **Category**: All Software (default), MySQL Servers, Applications, MySQL Connectors, or Documentation (for samples and documentation).\n- **Maturity**: Current Bundle (appears initially with the full package only), Pre-Release, Current GA, or Other Releases. If you see a warning, confirm that you have the most recent product manifest by clicking **Catalog** on the MySQL Installer dashboard. If MySQL Installer is unable to download the manifest, the range of products you see is limited to bundled products, standalone product MSIs located in the **Product Cache** folder already, or both.\n\n**Note**\n\nThe Commercial release of MySQL Installer does not display any MySQL products when you select the Pre-Release maturity filter. Products in development are available from the Community release of MySQL Installer only.\n\n- **Already Downloaded** (the check box is deselected by default). Permits you to view and manage downloaded products only.\n- **Architecture**: Any (default), 32-bit, or 64-bit.\n\n**Upgrading MySQL Server**\n\nImportant server upgrade conditions:\n\n- MySQL Installer does not permit server upgrades between major release versions or minor release versions, but does permit upgrades within a release series, such as an upgrade from 5.7.18 to 5.7.19.\n- Upgrades between milestone releases (or from a milestone release to a GA release) are not supported. Significant development changes take place in milestone releases and you may encounter compatibility issues or problems starting the server.\n- For upgrades to MySQL 8.0.16 server and higher, a check box enables you to skip the upgrade check and process for system tables, while checking and processing data dictionary tables normally.\nMySQL Installer does not prompt you with the check box when the previous server upgrade was skipped or when the server was configured as a sandbox InnoDB Cluster. This behavior represents a change in how MySQL Server performs an upgrade (see What the MySQL Upgrade Process Upgrades) and it alters the sequence of steps that MySQL Installer applies to the configuration process.\n\nIf you select **Skip system tables upgrade check and process. (Not recommended)**, MySQL Installer starts the upgraded server with the **--upgrade=MINIMAL** server option, which upgrades the data dictionary only. If you stop and then restart the server without the **--upgrade=MINIMAL** option, the server upgrades the system tables automatically, if needed.\n\nThe following information appears in the **Log** tab and log file after the upgrade configuration (with system tables skipped) is complete:\n\n---\n\n**WARNING:** The system tables upgrade was skipped after upgrading MySQL Server. The server will be started now with the **--upgrade=MINIMAL** option, but then each time the server is started it will attempt to upgrade the system tables, unless you modify the Windows service (command line) to add **--upgrade=MINIMAL** to bypass the upgrade.\n\n**FOR THE BEST RESULTS:** Run mysqld.exe **--upgrade=FORCE** on the command line to upgrade the system tables manually.\n\n---\n\nTo choose a new server version:\n\n1. Click **Upgrade**. Confirm that the check box next to product name in the **Upgradeable Products** pane has a check mark. Deselect the products that you do not intend to upgrade at this time.\n\n **Note**\n \n For server milestone releases in the same release series, MySQL Installer deselects the server upgrade and displays a warning to indicate that the upgrade is not supported, identifies the risks of continuing, and provides a summary of the steps to perform a logical upgrade manually. You can reselect server upgrade at your own risk. For instructions on how to perform a logical upgrade with a milestone release, see Logical Upgrade.\n\n2. Click a product in the list to highlight it. This action populates the **Upgradeable Versions** pane with the details of each available version for the selected product: version number, published date, and a **Changes** link to open the release notes for that version.\n\n**Removing MySQL Server**\n\nTo remove a local MySQL server:\n\n1. Determine whether the local data directory should be removed. If you retain the data directory, another server installation can reuse the data. This option is enabled by default (removes the data directory).\n\n2. Click **Execute** to begin uninstalling the local server. Note that all products that you selected to remove are also uninstalled at this time.\n\n3. (Optional) Click the **Log** tab to display the current actions performed by MySQL Installer.\n\n**Upgrading MySQL Installer**\n\nMySQL Installer remains installed on your computer, and like other software, MySQL Installer can be upgraded from the previous version. In some cases, other MySQL software may require that you upgrade MySQL Installer for compatibility. This section describes how to identify the current version of MySQL Installer and how to upgrade MySQL Installer manually.\n\n**To locate the installed version of MySQL Installer:**\n\n1. Start MySQL Installer from the search menu. The MySQL Installer dashboard opens.\n2. Click the MySQL Installer About icon (️). The version number is located above the Back button.\n\nTo initiate an on-demand upgrade of MySQL Installer:\n\n1. Connect the computer with MySQL Installer installed to the internet.\n2. Start MySQL Installer from the search menu. The MySQL Installer dashboard opens.\n3. Click Catalog on the bottom of the dashboard to open the Update Catalog window.\n4. Click Execute to begin the process. If the installed version of MySQL Installer can be upgraded, you will be prompted to start the upgrade.\n5. Click Next to review all changes to the catalog and then click Finish to return to the dashboard.\n6. Verify the (new) installed version of MySQL Installer (see the previous procedure).\n\n1.3.5 MySQLInstallerConsole Reference\n\nMySQLInstallerConsole.exe provides command-line functionality that is similar to MySQL Installer. It is installed when MySQL Installer is initially executed and then available within the MySQL Installer for Windows directory. By default, that is in C:\\Program Files (x86)\\MySQL\\MySQL Installer for Windows, and the console must be executed with administrative privileges.\n\nTo use, invoke the command prompt with administrative privileges by choosing Start, Accessories, then right-click on Command Prompt and choose Run as administrator. And from the command line, optionally change the directory to where MySQLInstallerConsole.exe is located:\n\n```\nC:\\> cd Program Files (x86)\\MySQL\\MySQL Installer for Windows\nC:\\Program Files (x86)\\MySQL\\MySQL Installer for Windows> MySQLInstallerConsole.exe help\n```\n\nMySQL Installer is running in Community mode\n\n```\nAttempting to update manifest.\nInitializing product requirements\nLoading product catalog\nChecking for product catalog snippets\nChecking for product packages in the bundle\nCategorizing product catalog\nFinding all installed packages.\nYour product catalog was last updated at 11/1/2016 4:10:38 PM\n=================== End Initialization ===================\n```\n\nThe following commands are available:\n\n- **Configure** - Configures one or more of your installed programs.\n- **Help** - Provides list of available commands.\n- **Install** - Install and configure one or more available MySQL programs.\n- **List** - Provides an interactive way to list all products available.\n- **Modify** - Modifies the features of installed products.\n- **Remove** - Removes one or more products from your system.\n- **Status** - Shows the status of all installed products.\n- **Update** - Update the current product catalog.\n- **Upgrade** - Upgrades one or more of your installed programs.\n\nMySQL Product Names\n\nMany of the MySQLInstallerConsole commands accept one or more keywords that represent a MySQL product (or products) in the catalog. The current set of valid keywords for use with commands is shown in the following table.\n\n### Table 1.3 MySQL Product Keywords for MySQLInstallerConsole\n\n<table>\n<thead>\n<tr>\n<th>Keyword</th>\n<th>MySQL Product</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>server</td>\n<td>MySQL Server</td>\n</tr>\n</tbody>\n</table>\nMySQLInstallerConsole Command Options\n\nMySQLInstallerConsole.exe supports the following command options:\n\n- **configure [product1]:[setting]=value; [product2]:[setting]=value; [...]**\n Configures one or more MySQL products on your system. Multiple setting=value pairs can be configured for each product.\n Swtiches include:\n - **-showsettings** Displays the available options for the selected product, by passing in the product name after -showsettings.\n - **-silent** Disables confirmation prompts.\n\n ```\n C:\\> MySQLInstallerConsole configure -showsettings server\n C:\\> MySQLInstallerConsole configure server:port=3307\n ```\n\n- **help [command]**\n Displays a help message with usage examples and then exits. Pass in an additional command to receive help specific to that command.\n\n ```\n C:\\> MySQLInstallerConsole help\n C:\\> MySQLInstallerConsole help install\n ```\n\n- **install [product]:[features]:[config block]:[config block]:[config block]; [...]**\n Installs one or more MySQL products on your system. If pre-release products are available, both GA and pre-release products are installed when the value of the -type switch is Developer, Client, or Full. Use the -only_ga_products switch to restrict the product set to GA products only when using these setup types.\n Switches and syntax options include:\nMySQLInstallerConsole Reference\n\n- `only_ga_products` Restricts the product set to include GA products only.\n\n- `type=[SetupType]` Installs a predefined set of software. The setup type can be one of the following:\n \n - **Developer**: Installs a complete development environment.\n - **Server**: Installs a single MySQL server\n - **Client**: Installs client programs and libraries\n - **Full**: Installs everything\n - **Custom**: Installs user-selected products. This is the default option.\n\n **Note**\n \n Non-custom setup types are valid only when no other MySQL products are installed.\n\n- `showsettings` Displays the available options for the selected product, by passing in the product name after `-showsettings`.\n\n- `silent` Disable confirmation prompts.\n\n- `[product]` Each product can be specified by a product keyword with or without a semicolon-separated version qualifier. Passing in a product keyword alone selects the latest version of the product. If multiple architectures are available for that version of the product, the command returns the first one in the manifest list for interactive confirmation. Alternatively, you can pass in the exact version and architecture (x86 or x64) after the product keyword using the `-silent` switch.\n\n- `[features]` All features associated with a MySQL product are installed by default. The feature block is a semicolon-separated list of features or an asterisk character (*) that selects all features. To remove a feature, use the modify command.\n\n- `[config block]` One or more configuration blocks can be specified. Each configuration block is a semicolon-separated list of key-value pairs. A block can include either a config or user type key; `config` is the default type if one is not defined.\n\n Configuration block values that contain a colon character (:) must be wrapped in quotation marks. For example, `installdir=\"C:\\MySQL\\MySQL Server 8.0\"`. Only one configuration type block can be defined for each product. A user block should be defined for each user to be created during the product installation.\n\n **Note**\n \n The user type key is not supported when a product is being reconfigured.\n\nC:\\> MySQLInstallerConsole install server;5.6.25:*:port=3307;serverid=2:type=user;username=foo;password=bar;role=DBManager\nAn example that passes in additional configuration blocks, separated by `^` to fit:\n\n```\nC:\\> MySQLInstallerConsole install server;5.6.25;x64:*:type=config;openfirewall=true; generallog=true;binlog=true;serverid=3306;enable_tcpip=true;port=3306;rootpasswd=pass; ^\n```\n\n- **list**\n Lists an interactive console where all of the available MySQL products can be searched. Execute `MySQLInstallerConsole list` to launch the console and enter a substring to search.\n\n```\nC:\\> MySQLInstallerConsole list\n```\n\n- **modify** `[product1:-removelist]+addlist] [product2:-removelist]+addlist] [...]\n Modifies or displays features of a previously installed MySQL product. To display the features of a product, append the product keyword to the command, for example:\n\n```\nC:\\> MySQLInstallerConsole modify server\n```\n\n The syntax option for this command:\n\n `-silent` Disable confirmation prompts.\n\n```\nC:\\> MySQLInstallerConsole modify server:+documentation\nC:\\> MySQLInstallerConsole modify server:-debug\n```\n\n- **remove** `[product1] [product2] [...]`\n Removes one ore more products from your system. Switches and syntax options include:\n\n - `*` Pass in `*` to remove all of the MySQL products.\n - `-continue` Continue the operation even if an error occurs.\n - `-silent` Disable confirmation prompts.\n\n```\nC:\\> MySQLInstallerConsole remove *\nC:\\> MySQLInstallerConsole remove server\n```\n\n- **status**\n Provides a quick overview of the MySQL products that are installed on the system. Information includes product name and version, architecture, date installed, and install location.\n\n```\nC:\\> MySQLInstallerConsole status\n```\n\n- **update**\n Downloads the latest MySQL product catalog to your system. On success, the catalog is applied the next time either `MySQLInstaller` or `MySQLInstallerConsole.exe` is executed.\n\n```\nC:\\> MySQLInstallerConsole update\n```\n\n**Note**\n\nThe **Automatic Catalog Update** GUI option executes this command from the Windows Task Scheduler.\n\n- **upgrade** `[product1:version] [product2:version] [...]`\n Upgrades one or more products on your system. Syntax options include:\n1.4 Installing MySQL on Microsoft Windows Using a noinstall ZIP Archive\n\nUsers who are installing from the noinstall package can use the instructions in this section to manually install MySQL. The process for installing MySQL from a ZIP Archive package is as follows:\n\n1. Extract the main archive to the desired install directory\n \n * Optional: also extract the debug-test archive if you plan to execute the MySQL benchmark and test suite\n\n2. Create an option file\n\n3. Choose a MySQL server type\n\n4. Initialize MySQL\n\n5. Start the MySQL server\n\n6. Secure the default user accounts\n\nThis process is described in the sections that follow.\n\n1.4.1 Extracting the Install Archive\n\nTo install MySQL manually, do the following:\n\n1. If you are upgrading from a previous version please refer to Chapter 2, Upgrading MySQL on Windows, before beginning the upgrade process.\n\n2. Make sure that you are logged in as a user with administrator privileges.\n\n3. Choose an installation location. Traditionally, the MySQL server is installed in C:\\mysql. If you do not install MySQL at C:\\mysql, you must specify the path to the install directory during startup or in an option file. See Section 1.4.2, “Creating an Option File”.\n\n \n **Note**\n\n The MySQL Installer installs MySQL under C:\\Program Files\\MySQL.\n\n4. Extract the install archive to the chosen installation location using your preferred file-compression tool. Some tools may extract the archive to a folder within your chosen installation location. If this occurs, you can move the contents of the subfolder into the chosen installation location.\n\n1.4.2 Creating an Option File\n\nIf you need to specify startup options when you run the server, you can indicate them on the command line or place them in an option file. For options that are used every time the server starts, you may find\nCreating an Option File\n\nit most convenient to use an option file to specify your MySQL configuration. This is particularly true under the following circumstances:\n\n- The installation or data directory locations are different from the default locations (C:\\Program Files\\MySQL\\MySQL Server 8.0 and C:\\Program Files\\MySQL\\MySQL Server 8.0\\data).\n\n- You need to tune the server settings, such as memory, cache, or InnoDB configuration information.\n\nWhen the MySQL server starts on Windows, it looks for option files in several locations, such as the Windows directory, C:\\, and the MySQL installation directory (for the full list of locations, see Using Option Files). The Windows directory typically is named something like C:\\WINDOWS. You can determine its exact location from the value of the WINDIR environment variable using the following command:\n\n```\nC:\\> echo %WINDIR%\n```\n\nMySQL looks for options in each location first in the my.ini file, and then in the my.cnf file. However, to avoid confusion, it is best if you use only one file. If your PC uses a boot loader where C:\\ is not the boot drive, your only option is to use the my.ini file. Whichever option file you use, it must be a plain text file.\n\n**Note**\n\nWhen using the MySQL Installer to install MySQL Server, it creates the my.ini at the default location, and the user executing MySQL Installer is granted full permissions to this new my.ini file.\n\nIn other words, be sure that the MySQL Server user has permission to read the my.ini file.\n\nYou can also make use of the example option files included with your MySQL distribution; see Server Configuration Defaults.\n\nAn option file can be created and modified with any text editor, such as Notepad. For example, if MySQL is installed in E:\\mysql and the data directory is in E:\\mydata\\data, you can create an option file containing a [mysqld] section to specify values for the basedir and datadir options:\n\n```\n[mysqld]\n# set basedir to your installation path\nbasedir=E:/mysql\n# set datadir to the location of your data directory\ndatadir=E:/mydata/data\n```\n\nMicrosoft Windows path names are specified in option files using (forward) slashes rather than backslashes. If you do use backslashes, double them:\n\n```\n[mysqld]\n# set basedir to your installation path\nbasedir=E:\\mysql\n# set datadir to the location of your data directory\ndatadir=E:\\mydata\\data\n```\n\nThe rules for use of backslash in option file values are given in Using Option Files.\n\nThe ZIP archive does not include a data directory. To initialize a MySQL installation by creating the data directory and populating the tables in the mysql system database, initialize MySQL using either --initialize or --initialize-insecure. For additional information, see Initializing the Data Directory.\n\nIf you would like to use a data directory in a different location, you should copy the entire contents of the data directory to the new location. For example, if you want to use E:\\mydata as the data directory instead, you must do two things:\n1. Move the entire `data` directory and all of its contents from the default location (for example `C:\\Program Files\\MySQL\\MySQL Server 8.0\\data`) to `E:\\mydata`.\n\n2. Use a `--datadir` option to specify the new data directory location each time you start the server.\n\n### 1.4.3 Selecting a MySQL Server Type\n\nThe following table shows the available servers for Windows in MySQL 8.0.\n\n<table>\n<thead>\n<tr>\n<th>Binary</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>mysqld</code></td>\n<td>Optimized binary with named-pipe support</td>\n</tr>\n<tr>\n<td><code>mysqld-debug</code></td>\n<td>Like <code>mysqld</code>, but compiled with full debugging and automatic memory allocation checking</td>\n</tr>\n</tbody>\n</table>\n\nAll of the preceding binaries are optimized for modern Intel processors, but should work on any Intel i386-class or higher processor.\n\nEach of the servers in a distribution support the same set of storage engines. The `SHOW ENGINES` statement displays which engines a given server supports.\n\nAll Windows MySQL 8.0 servers have support for symbolic linking of database directories.\n\nMySQL supports TCP/IP on all Windows platforms. MySQL servers on Windows also support named pipes, if you start the server with the `named_pipe` system variable enabled. It is necessary to enable this variable explicitly because some users have experienced problems with shutting down the MySQL server when named pipes were used. The default is to use TCP/IP regardless of platform because named pipes are slower than TCP/IP in many Windows configurations.\n\n### 1.4.4 Initializing the Data Directory\n\nIf you installed MySQL using the `noinstall` package, no data directory is included. To initialize the data directory, use the instructions at Initializing the Data Directory.\n\n### 1.4.5 Starting the Server for the First Time\n\nThis section gives a general overview of starting the MySQL server. The following sections provide more specific information for starting the MySQL server from the command line or as a Windows service.\n\nThe information here applies primarily if you installed MySQL using the `noinstall` version, or if you wish to configure and test MySQL manually rather than with the MySQL Installer.\n\nThe examples in these sections assume that MySQL is installed under the default location of `C:\\Program Files\\MySQL\\MySQL Server 8.0`. Adjust the path names shown in the examples if you have MySQL installed in a different location.\n\nClients have two options. They can use TCP/IP, or they can use a named pipe if the server supports named-pipe connections.\n\nMySQL for Windows also supports shared-memory connections if the server is started with the `shared_memory` system variable enabled. Clients can connect through shared memory by using the `--protocol=MEMORY` option.\n\nFor information about which server binary to run, see Section 1.4.3, “Selecting a MySQL Server Type”.\n\nTesting is best done from a command prompt in a console window (or “DOS window”). In this way you can have the server display status messages in the window where they are easy to see. If something is wrong with your configuration, these messages make it easier for you to identify and fix any problems.\nStarting MySQL from the Windows Command Line\n\nNote\nThe database must be initialized before MySQL can be started. For additional information about the initialization process, see Initializing the Data Directory.\n\nTo start the server, enter this command:\n\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqld\" --console\n\nFor a server that includes InnoDB support, you should see the messages similar to those following as it starts (the path names and sizes may differ):\n\nInnoDB: The first specified datafile c:\\ibdata\\ibdata1 did not exist:\nInnoDB: a new database to be created!\nInnoDB: Setting file c:\\ibdata\\ibdata1 size to 209715200\nInnoDB: Database physically writes the file full: wait...\nInnoDB: Log file c:\\iblogs\\ib_logfile0 did not exist: new to be created\nInnoDB: Setting log file c:\\iblogs\\ib_logfile0 size to 31457280\nInnoDB: Log file c:\\iblogs\\ib_logfile1 did not exist: new to be created\nInnoDB: Setting log file c:\\iblogs\\ib_logfile1 size to 31457280\nInnoDB: Log file c:\\iblogs\\ib_logfile2 did not exist: new to be created\nInnoDB: Setting log file c:\\iblogs\\ib_logfile2 size to 31457280\nInnoDB: Doublewrite buffer not found: creating new\nInnoDB: Doublewrite buffer created\nInnoDB: creating foreign key constraint system tables\nInnoDB: foreign key constraint system tables created\n011024 10:58:25 InnoDB: Started\n\nWhen the server finishes its startup sequence, you should see something like this, which indicates that the server is ready to service client connections:\n\nmysqld: ready for connections\nVersion: '8.0.29' socket: '' port: 3306\n\nThe server continues to write to the console any further diagnostic output it produces. You can open a new console window in which to run client programs.\n\nIf you omit the --console option, the server writes diagnostic output to the error log in the data directory (C:\\Program Files\\MySQL\\MySQL Server 8.0\\data by default). The error log is the file with the .err extension, and may be set using the --log-error option.\n\nNote\nThe initial root account in the MySQL grant tables has no password. After starting the server, you should set up a password for it using the instructions in Securing the Initial MySQL Account.\n\n1.4.6 Starting MySQL from the Windows Command Line\n\nThe MySQL server can be started manually from the command line. This can be done on any version of Windows.\n\nTo start the mysql server from the command line, you should start a console window (or “DOS window”) and enter this command:\n\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqld\"\n\nThe path to mysqld may vary depending on the install location of MySQL on your system.\n\nYou can stop the MySQL server by executing this command:\n\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqladmin\" -u root shutdown\n\nNote\nIf the MySQL root user account has a password, you need to invoke mysqladmin with the -p option and supply the password when prompted.\nThis command invokes the MySQL administrative utility `mysqladmin` to connect to the server and tell it to shut down. The command connects as the MySQL root user, which is the default administrative account in the MySQL grant system.\n\n**Note**\n\nUsers in the MySQL grant system are wholly independent from any operating system users under Microsoft Windows.\n\nIf `mysqld` doesn’t start, check the error log to see whether the server wrote any messages there to indicate the cause of the problem. By default, the error log is located in the `C:\\Program Files\\MySQL\\MySQL Server 8.0\\data` directory. It is the file with a suffix of `.err`, or may be specified by passing in the `--log-error` option. Alternatively, you can try to start the server with the `--console` option; in this case, the server may display some useful information on the screen to help solve the problem.\n\nThe last option is to start `mysqld` with the `--standalone` and `--debug` options. In this case, `mysqld` writes a log file `C:\\mysqld.trace` that should contain the reason why `mysqld` doesn’t start. See The DEBUG Package.\n\nUse `mysqld --verbose --help` to display all the options that `mysqld` supports.\n\n### 1.4.7 Customizing the PATH for MySQL Tools\n\n**Warning**\n\nYou must exercise great care when editing your system PATH by hand; accidental deletion or modification of any portion of the existing PATH value can leave you with a malfunctioning or even unusable system.\n\nTo make it easier to invoke MySQL programs, you can add the path name of the MySQL bin directory to your Windows system PATH environment variable:\n\n- On the Windows desktop, right-click the My Computer icon, and select Properties.\n\n- Next select the Advanced tab from the System Properties menu that appears, and click the Environment Variables button.\n\n- Under System Variables, select Path, and then click the Edit button. The Edit System Variable dialogue should appear.\n\n- Place your cursor at the end of the text appearing in the space marked Variable Value. (Use the End key to ensure that your cursor is positioned at the very end of the text in this space.) Then enter the complete path name of your MySQL bin directory (for example, `C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin`)\n\n**Note**\n\nThere must be a semicolon separating this path from any values present in this field.\n\nDismiss this dialogue, and each dialogue in turn, by clicking OK until all of the dialogues that were opened have been dismissed. The new PATH value should now be available to any new command shell you open, allowing you to invoke any MySQL executable program by typing its name at the DOS prompt from any directory on the system, without having to supply the path. This includes the servers, the mysql client, and all MySQL command-line utilities such as mysqladmin and mysqldump.\n\nYou should not add the MySQL bin directory to your Windows PATH if you are running multiple MySQL servers on the same machine.\n1.4.8 Starting MySQL as a Windows Service\n\nOn Windows, the recommended way to run MySQL is to install it as a Windows service, so that MySQL starts and stops automatically when Windows starts and stops. A MySQL server installed as a service can also be controlled from the command line using **NET** commands, or with the graphical **Services** utility. Generally, to install MySQL as a Windows service you should be logged in using an account that has administrator rights.\n\nThe **Services** utility (the Windows **Service Control Manager**) can be found in the Windows Control Panel. To avoid conflicts, it is advisable to close the **Services** utility while performing server installation or removal operations from the command line.\n\n**Installing the service**\n\nBefore installing MySQL as a Windows service, you should first stop the current server if it is running by using the following command:\n\n```\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqladmin\" -u root shutdown\n```\n\n**Note**\n\nIf the MySQL **root** user account has a password, you need to invoke **mysqladmin** with the **-p** option and supply the password when prompted.\n\nThis command invokes the MySQL administrative utility **mysqladmin** to connect to the server and tell it to shut down. The command connects as the MySQL **root** user, which is the default administrative account in the MySQL grant system.\n\n**Note**\n\nUsers in the MySQL grant system are wholly independent from any operating system users under Windows.\n\nInstall the server as a service using this command:\n\n```\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqld\" --install\n```\n\nThe service-installation command does not start the server. Instructions for that are given later in this section.\n\nTo make it easier to invoke MySQL programs, you can add the path name of the MySQL **bin** directory to your Windows system **PATH** environment variable:\n\n- On the Windows desktop, right-click the **My Computer** icon, and select **Properties**.\n\n- Next select the **Advanced** tab from the **System Properties** menu that appears, and click the **Environment Variables** button.\n\n- Under **System Variables**, select **Path**, and then click the **Edit** button. The **Edit System Variable** dialogue should appear.\n\n- Place your cursor at the end of the text appearing in the space marked **Variable Value**. (Use the **End** key to ensure that your cursor is positioned at the very end of the text in this space.) Then enter the complete path name of your MySQL **bin** directory (for example, **C:\\Program Files\\MySQL \\MySQL Server 8.0\\bin**), and there should be a semicolon separating this path from any values present in this field. Dismiss this dialogue, and each dialogue in turn, by clicking **OK** until all of the dialogues that were opened have been dismissed. You should now be able to invoke any MySQL executable program by typing its name at the DOS prompt from any directory on the system, without having to supply the path. This includes the servers, the **mysql** client, and all MySQL command-line utilities such as **mysqladmin** and **mysqldump**.\nYou should not add the MySQL bin directory to your Windows PATH if you are running multiple MySQL servers on the same machine.\n\n**Warning**\n\nYou must exercise great care when editing your system PATH by hand; accidental deletion or modification of any portion of the existing PATH value can leave you with a malfunctioning or even unusable system.\n\nThe following additional arguments can be used when installing the service:\n\n- You can specify a service name immediately following the `--install` option. The default service name is MySQL.\n\n- If a service name is given, it can be followed by a single option. By convention, this should be `--defaults-file=file_name` to specify the name of an option file from which the server should read options when it starts.\n\n The use of a single option other than `--defaults-file` is possible but discouraged. `--defaults-file` is more flexible because it enables you to specify multiple startup options for the server by placing them in the named option file.\n\n- You can also specify a `--local-service` option following the service name. This causes the server to run using the LocalService Windows account that has limited system privileges. If both `--defaults-file` and `--local-service` are given following the service name, they can be in any order.\n\nFor a MySQL server that is installed as a Windows service, the following rules determine the service name and option files that the server uses:\n\n- If the service-installation command specifies no service name or the default service name (MySQL) following the `--install` option, the server uses the service name of MySQL and reads options from the [mysqld] group in the standard option files.\n\n- If the service-installation command specifies a service name other than MySQL following the `--install` option, the server uses that service name. It reads options from the [mysqld] group and the group that has the same name as the service in the standard option files. This enables you to use the [mysqld] group for options that should be used by all MySQL services, and an option group with the service name for use by the server installed with that service name.\n\n- If the service-installation command specifies a `--defaults-file` option after the service name, the server reads options the same way as described in the previous item, except that it reads options only from the named file and ignores the standard option files.\n\nAs a more complex example, consider the following command:\n\n```bash\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqld\" --install MySQL --defaults-file=C:\\my-opts.cnf\n```\n\nHere, the default service name (MySQL) is given after the `--install` option. If no `--defaults-file` option had been given, this command would have the effect of causing the server to read the [mysqld] group from the standard option files. However, because the `--defaults-file` option is present, the server reads options from the [mysqld] option group, and only from the named file.\n\n**Note**\n\nOn Windows, if the server is started with the `--defaults-file` and `--install` options, `--install` must be first. Otherwise, mysqld.exe attempts to start the MySQL server.\n\nYou can also specify options as Start parameters in the Windows Services utility before you start the MySQL service.\nFinally, before trying to start the MySQL service, make sure the user variables %TEMP% and %TMP% (and also %TMPDIR%, if it has ever been set) for the operating system user who is to run the service are pointing to a folder to which the user has write access. The default user for running the MySQL service is LocalSystem, and the default value for its %TEMP% and %TMP% is C:\\Windows\\Temp, a directory LocalSystem has write access to by default. However, if there are any changes to that default setup (for example, changes to the user who runs the service or to the mentioned user variables, or the --tmpdir option has been used to put the temporary directory somewhere else), the MySQL service might fail to run because write access to the temporary directory has not been granted to the proper user.\n\nStarting the service\n\nAfter a MySQL server instance has been installed as a service, Windows starts the service automatically whenever Windows starts. The service also can be started immediately from the Services utility, or by using an `sc start mysql_service_name` or `NET START mysql_service_name` command. SC and NET commands are not case-sensitive.\n\nWhen run as a service, mysqld has no access to a console window, so no messages can be seen there. If mysqld does not start, check the error log to see whether the server wrote any messages there to indicate the cause of the problem. The error log is located in the MySQL data directory (for example, C:\\Program Files\\MySQL\\MySQL Server 8.0\\data). It is the file with a suffix of .err.\n\nWhen a MySQL server has been installed as a service, and the service is running, Windows stops the service automatically when Windows shuts down. The server also can be stopped manually using the Services utility, the `sc stop mysql_service_name` command, the `NET STOP mysql_service_name` command, or the `mysqladmin shutdown` command.\n\nYou also have the choice of installing the server as a manual service if you do not wish for the service to be started automatically during the boot process. To do this, use the `--install-manual` option rather than the `--install` option:\n\n```\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqld\" --install-manual\n```\n\nRemoving the service\n\nTo remove a server that is installed as a service, first stop it if it is running by executing `SC STOP mysql_service_name` or `NET STOP mysql_service_name`. Then use `SC DELETE mysql_service_name` to remove it:\n\n```\nC:\\> SC DELETE mysql\n```\n\nAlternatively, use the `mysqld --remove` option to remove the service.\n\n```\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqld\" --remove\n```\n\nIf mysqld is not running as a service, you can start it from the command line. For instructions, see Section 1.4.6, “Starting MySQL from the Windows Command Line”.\n\nIf you encounter difficulties during installation, see Section 1.5, “Troubleshooting a Microsoft Windows MySQL Server Installation”.\n\nFor more information about stopping or removing a Windows service, see Starting Multiple MySQL Instances as Windows Services.\n\n1.4.9 Testing The MySQL Installation\n\nYou can test whether the MySQL server is working by executing any of the following commands:\n\n```\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqlshow\"\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqlshow\" --u root mysql\n```\nIf mysqld is slow to respond to TCP/IP connections from client programs, there is probably a problem with your DNS. In this case, start mysqld with the `skip_name_resolve` system variable enabled and use only `localhost` and IP addresses in the `Host` column of the MySQL grant tables. (Be sure that an account exists that specifies an IP address or you may not be able to connect.)\n\nYou can force a MySQL client to use a named-pipe connection rather than TCP/IP by specifying the `--pipe` or `--protocol=PIPE` option, or by specifying . (period) as the host name. Use the `--socket` option to specify the name of the pipe if you do not want to use the default pipe name.\n\nIf you have set a password for the root account, deleted the anonymous account, or created a new user account, then to connect to the MySQL server you must use the appropriate `--u` and `--p` options with the commands shown previously. See Connecting to the MySQL Server Using Command Options.\n\nFor more information about mysqlshow, see mysqlshow — Display Database, Table, and Column Information.\n\n1.5 Troubleshooting a Microsoft Windows MySQL Server Installation\n\nWhen installing and running MySQL for the first time, you may encounter certain errors that prevent the MySQL server from starting. This section helps you diagnose and correct some of these errors.\n\nYour first resource when troubleshooting server issues is the error log. The MySQL server uses the error log to record information relevant to the error that prevents the server from starting. The error log is located in the data directory specified in your `my.ini` file. The default data directory location is `C:\\Program Files\\MySQL\\MySQL Server 8.0\\data`, or `C:\\ProgramData\\Mysql` on Windows 7 and Windows Server 2008. The `C:\\ProgramData` directory is hidden by default. You need to change your folder options to see the directory and contents. For more information on the error log and understanding the content, see The Error Log.\n\nFor information regarding possible errors, also consult the console messages displayed when the MySQL service is starting. Use the `SC START mysqld_service_name` or `NET START mysqld_service_name` command from the command line after installing mysqld as a service to see any error messages regarding the starting of the MySQL server as a service. See Section 1.4.8, “Starting MySQL as a Windows Service”.\n\nThe following examples show other common error messages you might encounter when installing MySQL and starting the server for the first time:\n\n- If the MySQL server cannot find the mysql privileges database or other critical files, it displays these messages:\n\n ```\n System error 1067 has occurred.\n Fatal error: Can't open and lock privilege tables:\n Table 'mysql.user' doesn't exist\n ```\n\n These messages often occur when the MySQL base or data directories are installed in different locations than the default locations (`C:\\Program Files\\MySQL\\MySQL Server 8.0` and `C:\\Program Files\\MySQL\\MySQL Server 8.0\\data`, respectively).\n\n This situation can occur when MySQL is upgraded and installed to a new location, but the configuration file is not updated to reflect the new location. In addition, old and new configuration files might conflict. Be sure to delete or rename any old configuration files when upgrading MySQL.\n\n If you have installed MySQL to a directory other than `C:\\Program Files\\MySQL\\MySQL Server 8.0`, ensure that the MySQL server is aware of this through the use of a configuration (`my.ini`) file. Put the `my.ini` file in your Windows directory, typically `C:\\WINDOWS`. To determine its exact\nlocation from the value of the \\texttt{WINDIR} environment variable, issue the following command from the\ncommand prompt:\n\n\\begin{verbatim}\nC:> echo \\%WINDIR\\%\n\\end{verbatim}\n\nYou can create or modify an option file with any text editor, such as Notepad. For example, if MySQL\nis installed in \\texttt{E:\\mysql} and the data directory is \\texttt{D:\\MySQLdata}, you can create the option file and\nset up a \\texttt{[mysqld]} section to specify values for the \\texttt{basedir} and \\texttt{datadir} options:\n\n\\begin{verbatim}\n[mysqld]\n# set basedir to your installation path\nbasedir=E:/mysql\n# set datadir to the location of your data directory\ndatadir=D:/MySQLdata\n\\end{verbatim}\n\nMicrosoft Windows path names are specified in option files using (forward) slashes rather than\nbackslashes. If you do use backslashes, double them:\n\n\\begin{verbatim}\n[mysqld]\n# set basedir to your installation path\nbasedir=C:\\Program Files\\MySQL\\MySQL Server 8.0\n# set datadir to the location of your data directory\ndatadir=D:\\MySQLdata\n\\end{verbatim}\n\nThe rules for use of backslash in option file values are given in \\textit{Using Option Files}.\n\nIf you change the \\texttt{datadir} value in your MySQL configuration file, you must move the contents of\nthe existing MySQL data directory before restarting the MySQL server.\n\nSee Section 1.4.2, “Creating an Option File”.\n\n- If you reinstall or upgrade MySQL without first stopping and removing the existing MySQL service\nand install MySQL using the MySQL Installer, you might see this error:\n\n\\begin{verbatim}\nError: Cannot create Windows service for MySql. Error: 0\n\\end{verbatim}\n\nThis occurs when the Configuration Wizard tries to install the service and finds an existing service\nwith the same name.\n\nOne solution to this problem is to choose a service name other than \\texttt{mysql} when using the\nconfiguration wizard. This enables the new service to be installed correctly, but leaves the outdated\nservice in place. Although this is harmless, it is best to remove old services that are no longer in use.\n\nTo permanently remove the old \\texttt{mysql} service, execute the following command as a user with\nadministrative privileges, on the command line:\n\n\\begin{verbatim}\nC:> SC DELETE mysql\n[SC] DeleteService SUCCESS\n\\end{verbatim}\n\nIf the \\texttt{SC} utility is not available for your version of Windows, download the \\texttt{delsrv} utility from \\url{http://www.microsoft.com/windows2000/techinfo/reskit/tools/existing/delsrv-o.asp} and use the \\texttt{delsrv mysql} syntax.\n\n\\section*{1.6 Windows Postinstallation Procedures}\n\nGUI tools exist that perform most of the tasks described in this section, including:\n\n- **MySQL Installer**: Used to install and upgrade MySQL products.\n\n- **MySQL Workbench**: Manages the MySQL server and edits SQL statements.\n\nIf necessary, initialize the data directory and create the MySQL grant tables. Windows installation\noperations performed by MySQL Installer initialize the data directory automatically. For installation from\na ZIP Archive package, initialize the data directory as described at \\textit{Initializing the Data Directory}.\nRegarding passwords, if you installed MySQL using the MySQL Installer, you may have already assigned a password to the initial root account. (See Section 1.3, “MySQL Installer for Windows”.) Otherwise, use the password-assignment procedure given in Securing the Initial MySQL Account.\n\nBefore assigning a password, you might want to try running some client programs to make sure that you can connect to the server and that it is operating properly. Make sure that the server is running (see Section 1.4.5, “Starting the Server for the First Time”). You can also set up a MySQL service that runs automatically when Windows starts (see Section 1.4.8, “Starting MySQL as a Windows Service”).\n\nThese instructions assume that your current location is the MySQL installation directory and that it has a bin subdirectory containing the MySQL programs used here. If that is not true, adjust the command path names accordingly.\n\nIf you installed MySQL using MySQL Installer (see Section 1.3, “MySQL Installer for Windows”), the default installation directory is C:\\Program Files\\MySQL\\MySQL Server 8.0:\n\nC:\\> cd \"C:\\Program Files\\MySQL\\MySQL Server 8.0\"\n\nA common installation location for installation from a ZIP archive is C:\\mysql:\n\nC:\\> cd C:\\mysql\n\nAlternatively, add the bin directory to your PATH environment variable setting. That enables your command interpreter to find MySQL programs properly, so that you can run a program by typing only its name, not its path name. See Section 1.4.7, “Customizing the PATH for MySQL Tools”.\n\nWith the server running, issue the following commands to verify that you can retrieve information from the server. The output should be similar to that shown here.\n\nUse mysqlshow to see what databases exist:\n\nC:\\> bin\\mysqlshow\n\n+--------------------+\n| Databases |\n+--------------------+\n| information_schema |\n| mysql |\n| performance_schema |\n| sys |\n+--------------------+\n\nThe list of installed databases may vary, but always includes at least mysql and information_schema.\n\nThe preceding command (and commands for other MySQL programs such as mysql) may not work if the correct MySQL account does not exist. For example, the program may fail with an error, or you may not be able to view all databases. If you install MySQL using MySQL Installer, the root user is created automatically with the password you supplied. In this case, you should use the -u root and -p options. (You must use those options if you have already secured the initial MySQL accounts.) With -p, the client program prompts for the root password. For example:\n\nC:\\> bin\\mysqlshow -u root -p\nEnter password: (enter root password here)\n\nIf you specify a database name, mysqlshow displays a list of the tables within the database:\nUse the `mysql` program to select information from a table in the `mysql` database:\n\n```bash\nC:\\> bin\\mysqlshow mysql\n```\n\n```\n+---------------------------+\n| Tables |\n+---------------------------+\n| columns_priv |\n| component |\n| db |\n| default_roles |\n| engine_cost |\n| func |\n| general_log |\n| global_grants |\n| gtid_executed |\n| help_category |\n| help_keyword |\n| help_relation |\n| help_topic |\n| innodb_index_stats |\n| innodb_table_stats |\n| ndb_binlog_index |\n| password_history |\n| plugin |\n| procs_priv |\n| proxies_priv |\n| role_edges |\n| server_cost |\n| servers |\n| slave_master_info |\n| slave_relay_log_info |\n| slave_worker_info |\n| slow_log |\n| tables_priv |\n| time_zone |\n| time_zone_leap_second |\n| time_zone_name |\n| time_zone_transition |\n| time_zone_transition_type |\n| user |\n```\n\nFor more information about `mysql` and `mysqlshow`, see `mysql — The MySQL Command-Line Client`, and `mysqlshow — Display Database, Table, and Column Information`.\n\n### 1.7 Windows Platform Restrictions\n\nThe following restrictions apply to use of MySQL on the Windows platform:\n\n- **Process memory**\n\n On Windows 32-bit platforms, it is not possible by default to use more than 2GB of RAM within a single process, including MySQL. This is because the physical address limit on Windows 32-bit is 4GB and the default setting within Windows is to split the virtual address space between kernel (2GB) and user/applications (2GB).\n\n Some versions of Windows have a boot time setting to enable larger applications by reducing the kernel application. Alternatively, to use more than 2GB, use a 64-bit version of Windows.\n\n- **File system aliases**\nWindows Platform Restrictions\n\nWhen using MyISAM tables, you cannot use aliases within Windows link to the data files on another volume and then link back to the main MySQL datadir location.\n\nThis facility is often used to move the data and index files to a RAID or other fast solution.\n\n• **Limited number of ports**\n\nWindows systems have about 4,000 ports available for client connections, and after a connection on a port closes, it takes two to four minutes before the port can be reused. In situations where clients connect to and disconnect from the server at a high rate, it is possible for all available ports to be used up before closed ports become available again. If this happens, the MySQL server appears to be unresponsive even though it is running. Ports may be used by other applications running on the machine as well, in which case the number of ports available to MySQL is lower.\n\nFor more information about this problem, see https://support.microsoft.com/kb/196271.\n\n• **DATA DIRECTORY and INDEX DIRECTORY**\n\nThe DATA DIRECTORY clause of the CREATE TABLE statement is supported on Windows for InnoDB tables only, as described in Creating Tables Externally. For MyISAM and other storage engines, the DATA DIRECTORY and INDEX DIRECTORY clauses for CREATE TABLE are ignored on Windows and any other platforms with a nonfunctional realpath() call.\n\n• **DROP DATABASE**\n\nYou cannot drop a database that is in use by another session.\n\n• **Case-insensitive names**\n\nFile names are not case-sensitive on Windows, so MySQL database and table names are also not case-sensitive on Windows. The only restriction is that database and table names must be specified using the same case throughout a given statement. See Identifier Case Sensitivity.\n\n• **Directory and file names**\n\nOn Windows, MySQL Server supports only directory and file names that are compatible with the current ANSI code pages. For example, the following Japanese directory name does not work in the Western locale (code page 1252):\n\n\\[datadir=\"C:/私たちのプロジェクトのデータ\"\\]\n\nThe same limitation applies to directory and file names referred to in SQL statements, such as the data file path name in LOAD DATA.\n\n• **The \\ path name separator character**\n\nPath name components in Windows are separated by the \\ character, which is also the escape character in MySQL. If you are using LOAD DATA or SELECT ... INTO OUTFILE, use Unix-style file names with / characters:\n\n\\[mysql> LOAD DATA INFILE 'C:/tmp/skr.txt' INTO TABLE skr;\\]\n\\[mysql> SELECT * INTO OUTFILE 'C:/tmp/skr.txt' FROM skr;\\]\n\nAlternatively, you must double the \\ character:\n\n\\[mysql> LOAD DATA INFILE 'C:\\\\tmp\\\\skr.txt' INTO TABLE skr;\\]\n\\[mysql> SELECT * INTO OUTFILE 'C:\\\\tmp\\\\skr.txt' FROM skr;\\]\n\n• **Problems with pipes**\n\nPipes do not work reliably from the Windows command-line prompt. If the pipe includes the character \\[^Z / CHAR(24)\\], Windows thinks that it has encountered end-of-file and aborts the program.\nWindows Platform Restrictions\n\nThis is mainly a problem when you try to apply a binary log as follows:\n\n```\nC:\\> mysqlbinlog binary_log_file | mysql --user=root\n```\n\nIf you have a problem applying the log and suspect that it is because of a `^Z / CHAR(24)` character, you can use the following workaround:\n\n```\nC:\\> mysqlbinlog binary_log_file --result-file=/tmp/bin.sql\nC:\\> mysql --user=root --execute \"source /tmp/bin.sql\"\n```\n\nThe latter command also can be used to reliably read any SQL file that may contain binary data.\nChapter 2 Upgrading MySQL on Windows\n\nThere are two approaches for upgrading MySQL on Windows:\n\n• Using MySQL Installer\n• Using the Windows ZIP archive distribution\n\nThe approach you select depends on how the existing installation was performed. Before proceeding, review Upgrading MySQL for additional information on upgrading MySQL that is not specific to Windows.\n\nNota\nWhichever approach you choose, always back up your current MySQL installation before performing an upgrade. See Database Backup Methods.\n\nUpgrades between non-GA releases (or from a non-GA release to a GA release) are not supported. Significant development changes take place in non-GA releases and you may encounter compatibility issues or problems starting the server.\n\nNota\nMySQL Installer does not support upgrades between Community releases and Commercial releases. If you require this type of upgrade, perform it using the ZIP archive approach.\n\nUpgrading MySQL with MySQL Installer\n\nPerforming an upgrade with MySQL Installer is the best approach when the current server installation was performed with it and the upgrade is within the current release series. MySQL Installer does not support upgrades between release series, such as from 5.7 to 8.0, and it does not provide an upgrade indicator to prompt you to upgrade. For instructions on upgrading between release series, see Upgrading MySQL Using the Windows ZIP Distribution.\n\nTo perform an upgrade using MySQL Installer:\n\n1. Start MySQL Installer.\n\n2. From the dashboard, click Catalog to download the latest changes to the catalog. The installed server can be upgraded only if the dashboard displays an arrow next to the version number of the server.\n\n3. Click Upgrade. All products that have a newer version now appear in a list.\n\nNota\nMySQL Installer deselects the server upgrade option for milestone releases (Pre-Release) in the same release series. In addition, it displays a warning to indicate that the upgrade is not supported, identifies the risks of continuing, and provides a summary of the steps to perform an upgrade manually. You can reselect server upgrade and proceed at your own risk.\n\n4. Deselect all but the MySQL server product, unless you intend to upgrade other products at this time, and click Next.\n\n5. Click Execute to start the download. When the download finishes, click Next to begin the upgrade operation.\n\nUpgrades to MySQL 8.0.16 and higher may show an option to skip the upgrade check and process for system tables. For more information about this option, see Important server upgrade conditions.\n6. Configure the server.\n\n**Upgrading MySQL Using the Windows ZIP Distribution**\n\nTo perform an upgrade using the Windows ZIP archive distribution:\n\n1. Download the latest Windows ZIP Archive distribution of MySQL from https://dev.mysql.com/downloads/.\n\n2. If the server is running, stop it. If the server is installed as a service, stop the service with the following command from the command prompt:\n\n```plaintext\nC:\\> SC STOP mysqld_service_name\n```\n\nAlternatively, use `NET STOP mysqld_service_name`.\n\nIf you are not running the MySQL server as a service, use `mysqladmin` to stop it. For example, before upgrading from MySQL 5.7 to 8.0, use `mysqladmin` from MySQL 5.7 as follows:\n\n```plaintext\nC:\\> \"C:\\Program Files\\MySQL\\MySQL Server 5.7\\bin\\mysqladmin\" -u root shutdown\n```\n\n**Note**\n\nIf the MySQL root user account has a password, invoke `mysqladmin` with the `-p` option and enter the password when prompted.\n\n3. Extract the ZIP archive. You may either overwrite your existing MySQL installation (usually located at `C:\\mysql`), or install it into a different directory, such as `C:\\mysql8`. Overwriting the existing installation is recommended.\n\n4. Restart the server. For example, use the `SC START mysqld_service_name` or `NET START mysqld_service_name` command if you run MySQL as a service, or invoke `mysqld` directly otherwise.\n\n5. Prior to MySQL 8.0.16, run `mysql_upgrade` as Administrator to check your tables, attempt to repair them if necessary, and update your grant tables if they have changed so that you can take advantage of any new capabilities. See `mysql_upgrade — Check and Upgrade MySQL Tables`. As of MySQL 8.0.16, this step is not required, as the server performs all tasks previously handled by `mysql_upgrade`.\n\n6. If you encounter errors, see Section 1.5, “Troubleshooting a Microsoft Windows MySQL Server Installation”.\nChapter 3 Connection to MySQL Server Failing on Windows\n\nWhen you're running a MySQL server on Windows with many TCP/IP connections to it, and you're experiencing that quite often your clients get a Can't connect to MySQL server error, the reason might be that Windows does not allow for enough ephemeral (short-lived) ports to serve those connections.\n\nThe purpose of TIME_WAIT is to keep a connection accepting packets even after the connection has been closed. This is because Internet routing can cause a packet to take a slow route to its destination and it may arrive after both sides have agreed to close. If the port is in use for a new connection, that packet from the old connection could break the protocol or compromise personal information from the original connection. The TIME_WAIT delay prevents this by ensuring that the port cannot be reused until after some time has been permitted for those delayed packets to arrive.\n\nIt is safe to reduce TIME_WAIT greatly on LAN connections because there is little chance of packets arriving at very long delays, as they could through the Internet with its comparatively large distances and latencies.\n\nWindows permits ephemeral (short-lived) TCP ports to the user. After any port is closed, it remains in a TIME_WAIT status for 120 seconds. The port is not available again until this time expires. The default range of port numbers depends on the version of Windows, with a more limited number of ports in older versions:\n\n- Windows through Server 2003: Ports in range 1025–5000\n\nWith a small stack of available TCP ports (5000) and a high number of TCP ports being open and closed over a short period of time along with the TIME_WAIT status you have a good chance for running out of ports. There are two ways to address this problem:\n\n- Reduce the number of TCP ports consumed quickly by investigating connection pooling or persistent connections where possible\n- Tune some settings in the Windows registry (see below)\n\n**Important**\n\nThe following procedure involves modifying the Windows registry. Before you modify the registry, make sure to back it up and make sure that you understand how to restore it if a problem occurs. For information about how to back up, restore, and edit the registry, view the following article in the Microsoft Knowledge Base: [http://support.microsoft.com/kb/256986/EN-US/](http://support.microsoft.com/kb/256986/EN-US/).\n\n1. Start Registry Editor (Regedt32.exe).\n2. Locate the following key in the registry:\n\n```\nHKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\n```\n3. On the **Edit** menu, click **Add Value**, and then add the following registry value:\n\n```\nValue Name: MaxUserPort\nData Type: REG_DWORD\nValue: 65534\n```\n\nThis sets the number of ephemeral ports available to any user. The valid range is between 5000 and 65534 (decimal). The default value is 0x1388 (5000 decimal).\n\n4. On the **Edit** menu, click **Add Value**, and then add the following registry value:\n\n```\nValue Name: TcpTimedWaitDelay\n```\n\n---\n\n45\nData Type: REG_DWORD\nValue: 30\n\nThis sets the number of seconds to hold a TCP port connection in TIME_WAIT state before closing. The valid range is between 30 and 300 decimal, although you may wish to check with Microsoft for the latest permitted values. The default value is 0x78 (120 decimal).\n\n5. Quit Registry Editor.\n\n6. Reboot the machine.\n\nNote: Undoing the above should be as simple as deleting the registry entries you’ve created.\nChapter 4 Resetting the Root Password: Windows Systems\n\nOn Windows, use the following procedure to reset the password for the MySQL 'root'@'localhost' account. To change the password for a root account with a different host name part, modify the instructions to use that host name.\n\n1. Log on to your system as Administrator.\n\n2. Stop the MySQL server if it is running. For a server that is running as a Windows service, go to the Services manager: From the Start menu, select Control Panel, then Administrative Tools, then Services. Find the MySQL service in the list and stop it.\n\n If your server is not running as a service, you may need to use the Task Manager to force it to stop.\n\n3. Create a text file containing the password-assignment statement on a single line. Replace the password with the password that you want to use.\n\n ```\n ALTER USER 'root'@'localhost' IDENTIFIED BY 'MyNewPass';\n ```\n\n4. Save the file. This example assumes that you name the file C:\\mysql-init.txt.\n\n5. Open a console window to get to the command prompt: From the Start menu, select Run, then enter cmd as the command to be run.\n\n6. Start the MySQL server with the init_file system variable set to name the file (notice that the backslash in the option value is doubled):\n\n ```\n C:\\> cd \"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\"\n C:\\> mysql --init-file=C:\\mysql-init.txt\n ```\n\n If you installed MySQL to a different location, adjust the cd command accordingly.\n\n The server executes the contents of the file named by the init_file system variable at startup, changing the 'root'@'localhost' account password.\n\n To have server output to appear in the console window rather than in a log file, add the --console option to the mysql command.\n\n If you installed MySQL using the MySQL Installation Wizard, you may need to specify a --defaults-file option. For example:\n\n ```\n C:\\> mysql\n --defaults-file=\"C:\\ProgramData\\MySQL\\MySQL Server 8.0\\my.ini\"\n --init-file=C:\\mysql-init.txt\n ```\n\n The appropriate --defaults-file setting can be found using the Services Manager: From the Start menu, select Control Panel, then Administrative Tools, then Services. Find the MySQL service in the list, right-click it, and choose the Properties option. The Path to executable field contains the --defaults-file setting.\n\n7. After the server has started successfully, delete C:\\mysql-init.txt.\n\n You should now be able to connect to the MySQL server as root using the new password. Stop the MySQL server and restart it normally. If you run the server as a service, start it from the Windows Services window. If you start the server manually, use whatever command you normally use.\nChapter 5 MySQL for Visual Studio\n\nTable of Contents\n\n5.1 General Information ................................................................. 49\n 5.1.1 New in Version 1.2 ....................................................... 50\n 5.1.2 New in Version 2.0 (Development Release) ......................... 51\n5.2 Installing MySQL for Visual Studio ........................................ 55\n5.3 Enabling the MySQL Toolbar .................................................. 57\n5.4 Making a Connection ............................................................. 58\n 5.4.1 Connect Using Server Explorer ....................................... 60\n 5.4.2 Connect Using MySQL Connections Manager ......................... 62\n5.5 Editing ....................................................................................... 63\n 5.5.1 MySQL SQL Editor ............................................................ 64\n 5.5.2 Code Editors ..................................................................... 65\n 5.5.3 Editing Tables .................................................................... 67\n 5.5.4 Editing Views ..................................................................... 72\n 5.5.5 Editing Indexes .................................................................. 74\n 5.5.6 Editing Foreign Keys .......................................................... 75\n 5.5.7 Editing Stored Procedures and Functions ............................... 76\n 5.5.8 Editing Triggers ................................................................. 78\n5.6 MySQL Project Items ................................................................. 79\n 5.6.1 MySQL ASP.NET MVC Items ............................................. 79\n 5.6.2 MySQL Windows Forms Items ............................................ 86\n5.7 MySQL Application Configuration Tool ...................................... 88\n 5.7.1 Entity Framework .............................................................. 89\n 5.7.2 Web Providers ................................................................. 91\n 5.7.3 Using the MySQL Connection String Editor ......................... 95\n5.8 MySQL Data Export Tool .......................................................... 96\n5.9 DDL T4 Template Macro ........................................................... 102\n5.10 Debugging Stored Procedures and Functions .............................. 103\n5.11 MySQL for Visual Studio Frequently Asked Questions .................. 113\n\n5.1 General Information\n\nMySQL for Visual Studio provides access to MySQL objects and data from Visual Studio. As a Visual Studio package, MySQL for Visual Studio integrates directly into Server Explorer providing the ability to create new connections and work with MySQL database objects.\n\nFunctionality concepts includes:\n\n- **SQL Development**: By integrating directly into Visual Studio, database objects (tables, views, stored routines, triggers, indexes, etc) can be created, altered, or dropped directly inside Server Explorer.\n\n Visual object editors include helpful information to guide you through the editing process. Standard data views are also available to help you view your data.\n\n- **Query Designer**: Visual Studio’s query design tool is also directly supported. With this tool, you can query and view data from tables or views while also combining filters, group conditions, and parameters. Stored routines (both with and without parameters) can also be queried.\n\n- **Stored Routine Debugging**: Use the full debugging support for stored routines. Using the standard Visual Studio environment and controls, you can set breakpoints, add watches, and step into, out of, and over routines and calls. Local variables can be added to the watch window and call stack navigation is also supported.\n\n- **Entity Framework**: The Entity Framework is supported, to allow template based code generation and full support of the model designers and wizards.\nNew in Version 1.2\n\nFor notes detailing the changes in each release, see the MySQL for Visual Studio Release Notes.\n\n5.1.1 New in Version 1.2\n\nThis section summarizes many of the new features added to 1.2.x in relation to earlier versions of MySQL for Visual Studio.\n\n• Support for MySQL 8.0 Features\n• New or Changed Tool Support\n• Version Support for Visual Studio\n• Item Templates versus Project Templates\n\nFor notes detailing the changes in each point release, see the MySQL for Visual Studio Release Notes.\n\nSupport for MySQL 8.0 Features\n\n• Starting with MySQL for Visual Studio 1.2.9, SSL PEM connections can be made using the classic MySQL protocol. Both PEM and PFX certificates are permitted with Connector/NET 8.0.16 or higher when the server supports SSL connections. For configuration instructions, see SSL Connections with Server Explorer.\n\n• MySQL for Visual Studio 1.2.8 supports the MySQL 8.0 release series (requires MySQL Connector/NET 6.9.12, 6.10.7, or 8.0.11) including:\n • MySQL data dictionary, which uses INFORMATION_SCHEMA tables rather than tables in the mysql database (see MySQL Data Dictionary).\n • The caching_sha2_password authentication plugin introduced in MySQL 8.0 (see Caching SHA-2 Pluggable Authentication).\n\nNew or Changed Tool Support\n\n• Starting with MySQL for Visual Studio 1.2.9, the plugin detects when the version of Connector/NET has been changed after MySQL for Visual Studio was installed and prompts to update the necessary configuration files using the Configuration Update Tool. Visual Studio must be restarted to activate the updated configuration files.\n\n• The MySQL Website Configuration tool was renamed to MySQL Application Configuration and extended to automate entry updates to the app.config file in the MySQL for Visual Studio 1.2.9 release.\n\nVersion Support for Visual Studio\n\n• MySQL for Visual Studio 1.2.10:\n • Support for Microsoft Visual Studio 2015 was removed.\n\n• MySQL for Visual Studio 1.2.9:\n • Support for Microsoft Visual Studio 2019 was added.\n • Support for Microsoft Visual Studio 2012 and 2013 was removed.\n\n• MySQL for Visual Studio 1.2.7:\n • Support for Microsoft Visual Studio 2017 was added.\n • Support for Microsoft Visual Studio 2010 was removed.\nItem Templates versus Project Templates\n\nBeginning with MySQL for Visual Studio 1.2.5, the project templates used to create MySQL Windows Forms and MySQL MVC projects are no longer be available, as they were replaced with MySQL Project Items:\n\n- **MySQL MVC Item** replaces *MySQL MVC Project*.\n- **MySQL Windows Forms Item** replaces *Windows Form Project*.\n\nThese item templates offer the benefit of adding items to existing projects new windows forms or MVC controllers/views connected to MySQL, based on MySQL Entity Framework models, without the need of create an entirely new MySQL project.\n\nIn addition, item templates better follow the Visual Studio template standards, which are oriented to create projects regardless of the database connectivity.\n\nFor information about using Item Templates, see Section 5.6, “MySQL Project Items”.\n\n5.1.2 New in Version 2.0 (Development Release)\n\nThis section summarizes many of the new features added to the 2.0 release series in relation to the MySQL for Visual Studio 1.2 release series. MySQL for Visual Studio 2.0.5 is a development release.\n\nNew features are described in the following sections:\n\n- Viewing MySQL Query Output\n- Version Support for Visual Studio\n- Switching Connections from Script and Code Editors\n- Making a Connection\n- MySQL Toolbar\n- MySQL JavaScript and Python Code Editors\n\nFor notes detailing the changes in each point release, see the MySQL for Visual Studio Release Notes.\n\nViewing MySQL Query Output\n\nAn output pane was added to the MySQL SQL, JavaScript, and Python editors to display information about each executed query. The output pane includes the information that previously appeared in the Messages tab.\n\n**Figure 5.1 MySQL SQL Editor Output**\n\nVersion Support for Visual Studio\n\nBeginning with MySQL for Visual Studio 2.0.5:\n\n- Support for Microsoft Visual Studio 2017 was added.\n- Support for Microsoft Visual Studio 2010 was removed.\nSwitching Connections from Script and Code Editors\n\nA drop-down list was added to the toolbar of the SQL, JavaScript, and Python editors from which you can select a valid connection. JavaScript and Python editors show only the connections that support the X Protocol.\n\nMaking a Connection\n\nA new MySQL Connections Manager tool was added, and it can create and manage MySQL connections. It is found under the Server Explorer.\n\nThis button opens the MySQL Connections Manager dialog that enables the sharing of stored MySQL connections with MySQL Workbench, if it is installed. MySQL connections are displayed in a simpler way and can be created and edited from within this dialog. These connections can be imported to the Visual Studio Server Explorer for use with Visual Studio.\n\nAfter opening the MySQL Connections Manager:\nNew in Version 2.0 (Development Release)\n\n**Figure 5.4 MySQL Connections Manager Dialog: Choosing a Connection**\n\nTo add a new MySQL connection with the MySQL Connections Manager:\n\n**Figure 5.5 MySQL Connections Manager Dialog: New Connection**\n\nMySQL Toolbar\n\nIn the Server Explorer, and with MySQL Server 5.7, the MySQL connection context-menu was changed to show the options to create JavaScript or Python scripts, along with the existing SQL script option.\nNew in Version 2.0 (Development Release)\n\nFigure 5.6 MySQL Toolbar: Create New Script\n\nSelect JavaScript or Python to launch the MySQL code editor for the selected language.\n\nMySQL JavaScript and Python Code Editors\n\nUse the code editor to write and execute JavaScript or Python queries with MySQL Server 5.7 and higher, or as before, use SQL queries.\n\nFigure 5.7 MySQL Editor: Script Template\n\nSelect MyJs Script or MyPy Script to launch the MySQL code editor for the selected language.\n5.2 Installing MySQL for Visual Studio\n\nMySQL for Visual Studio is an add-on for Microsoft Visual Studio that simplifies the development of applications using data stored by the MySQL RDBMS. Many MySQL for Visual Studio features also\nrequire that MySQL Connector/NET be installed on the same host where you perform Visual Studio development. Connector/NET is a separate product.\n\nThe options for installing MySQL for Visual Studio are:\n\n- **Using MySQL Installer (preferred):** Download and execute the MySQL Installer.\n\n With this option you can download and install MySQL Server, MySQL for Visual Studio, and Connector/NET together from the same software package, based on the server version. Initially, MySQL Installer assists you by evaluating the software prerequisites needed for the installation. Thereafter, MySQL Installer enables you to keep your installed products updated or to easily add and remove related MySQL products.\n\n For additional information about using MySQL Installer with MySQL products, see Section 1.3, “MySQL Installer for Windows”.\n\n- **Using the standalone Zip or MSI file:** This option is ideal if you have MySQL Server and Connector/NET installed already. Use the information in this section to determine which version of MySQL for Visual Studio to install.\n\n### MySQL for Visual Studio Configuration Update Tool\n\nThe MySQL for Visual Studio installation updates its configuration automatically when Connector/NET is installed on your computer. However, if you install Connector/NET after MySQL for Visual Studio, or upgrade Connector/NET after you have installed MySQL for Visual Studio, you are prompted to run the Configuration Update Tool.\n\nA configuration deviation, if present, is detected by MySQL for Visual Studio when you attempt to create an Entity Framework model or the first time you attempt to open, create, or edit a connection to MySQL. Optionally, you can have MySQL for Visual Studio update the configuration files for you when it detects configuration errors and provides a popup window prompting you to invoke the tool. Select **Yes** to run the tool. You must restart Visual Studio after the affected configuration files are updated.\n\n### Minimum Requirements\n\nMySQL for Visual Studio operates with multiple versions of Visual Studio, although the extent of support is based on your installed versions of Connector/NET and Visual Studio.\n\nMinimum requirements for the supported versions of Visual Studio are as follows:\n\n- **Visual Studio 2019** (Community, Professional, and Enterprise):\n\n MySQL for Visual Studio 1.2.9 with Connector/NET 8.0.14\n\n **Tip**\n \n Connector/NET 8.0.18 (or later) is recommended.\n\n- **Visual Studio 2017** (Community, Professional, and Enterprise):\n\n MySQL for Visual Studio 1.2.7 with Connector/NET 8.0.14 or MySQL for Visual Studio 2.0.5 with Connector/NET 6.9.8\n\nMySQL for Visual Studio does not support Express versions of Microsoft development products, including the Visual Studio and the Microsoft Visual Web Developer.\n\nThe following table shows the support information for MySQL for Visual Studio.\n### MySQL Connector/.NET Restrictions\n\nMySQL Connector/.NET is closely tied to MySQL for Visual Studio, but they are two separate products that can be used without one another. The following restrictions apply:\n\n- MySQL for Visual Studio cannot be installed alongside any version of Connector/.NET 6.6 and earlier, which must be removed before installing MySQL for Visual Studio.\n\n- The following MySQL for Visual Studio features require Connector/.NET:\n - The Entity Framework Designer\n - The Application Configuration tool\n - Debugging Stored Procedures and Functions\n - The DDL T4 Template Macro (to generate a database from an EF Model)\n\n### 5.3 Enabling the MySQL Toolbar\n\nThe optional MySQL toolbar includes MySQL specific functionality and links to external MySQL tools such as MySQL Workbench and MySQL Utilities. Additional actions are available from the context menu for each data connection.\n\nAfter installing MySQL for Visual Studio, the MySQL toolbar is available by selecting **View**, **Toolbars**, **MySQL** from the main menu. To position the MySQL toolbar within Visual Studio, do the following:\n\n1. From the main menu, click **Tools** and then **Customize**.\n\n2. In the **Toolbars** tab, select MySQL to highlight it. The check box should have a check mark to indicate that the toolbar is visible.\n\n3. Select a dock location from **Modify Selection**. For example, the following figure shows the MySQL toolbar in the **Dock location: Left** position. Other dock locations are Top, Right, and Bottom.\nMaking a Connection\n\nFigure 5.10 MySQL for Visual Studio Toolbar and Context Menu\n\nThe MySQL toolbar provides shortcuts to some of the main features of MySQL for Visual Studio:\n\n- **MySQL Script Window**: Opens a new MySQL script window using the selected connection. All available MySQL connections are listed in a submenu, which can be selected on the toolbar:\n\nFigure 5.11 The MySQL for Visual Studio Toolbar: Connections\n\nThe MySQL script window supports the IntelliSense feature for easing MySQL script creation inside Visual Studio.\n\n- **Debug MySQL Routine**: Starts a debugging session on a selected MySQL stored routine inside Visual Studio.\n\n- **MySQL Data Export Tool**: Opens a new tabbed-window of the Data Export tool.\n\n- **MySQL Workbench SQL Editor**: Opens a new Workbench with an SQL editor window using the current MySQL connection, if MySQL Workbench has been installed.\n\n- **MySQL Utilities Console**: Opens a new console window for the MySQL Utilities tool, if it is installed.\n\n5.4 Making a Connection\n\nMySQL for Visual Studio leverages and extends the connection capabilities of Visual Studio to create and store MySQL connections. To ensure access to the full set of connection options, install the most recent version of MySQL Connector.NET on the client computer (see Minimum Requirements).\nMySQL for Visual Studio provides the following two distinct release series:\n\n- **MySQL for Visual Studio 1.2 release series.** Provides General Availability (GA) releases for use with MySQL 5.6, 5.7, and 8.0 servers. Connections can be made using the classic MySQL protocol only. Both PEM and PFX certificates are permitted with Connector/NET 8.0.16 or higher when the server supports SSL connections. Unencrypted connections are supported by the latest versions of MySQL Connector/NET. To add or modify MySQL data connections, use the Server Explorer management console in Visual Studio (see Section 5.4.1, “Connect Using Server Explorer”).\n\n- **MySQL for Visual Studio 2.0 release series.** Provides a development release series for use with MySQL 5.6 and 5.7 servers (version 2.0.5 is the current milestone). Basic connections are supported for both the classic MySQL protocol and X Protocol (33060 default port number). When the server supports SSL connections, PEM and PFX certificates are permitted with X Protocol; PFX certificates are permitted with the classic MySQL protocol. Use either MySQL Connections Manager or Server Explorer in Visual Studio to add or modify classic MySQL protocol connections. To add or modify X Protocol connections, use MySQL Connections Manager only (see Section 5.4.2, “Connect Using MySQL Connections Manager”).\n\nMySQL Connections Manager was introduced in the MySQL for Visual Studio 2.0 release series to simplify the creation and management of MySQL server connections within Visual Studio. From MySQL Connections Manager, you have the option to migrate all stored connections to MySQL Workbench (if it is installed), making MySQL Workbench a central repository for MySQL connections.\n\n### Basic Connections in Visual Studio\n\nA basic connection is either unencrypted or encrypted (in MySQL 8.0, SSL is enabled by default) and the connection is made using standard TCP/IP, which is the default connection method in MySQL for Visual Studio to connect to the MySQL RDBMS. Basic connections are easy to configure, particularly if the client application and MySQL server are on the same host computer or operate within the same local area network. For instructions on how to create a basic connection to MySQL from within Visual Studio, see Basic Connections with Server Explorer or Basic Connections with MySQL Connections Manager.\n\n### SSL Connections in Visual Studio\n\nMySQL Server uses the PEM format for certificates and private keys. Connector/NET 8.0.17 enables the use of either PEM or PFX certificates with the classic MySQL protocol when Server Explorer in Visual Studio (with MySQL for Visual Studio 1.2.9 or higher) is used to add or modify the data connection.\n\nBoth the MySQL server and the client must be configured to enable SSL encryption (see Using Encrypted Connections). In addition to providing the paths to certificate files, the client can specify the SSL mode to use for connections. When using Server Explorer, the SSL mode value is set with an advanced property. MySQL Connections Manager provides the Use SSL Encryption drop-down list with similar values. The following table describes the optional SSL values to select (and the files to specify) with each tool.\n\n<table>\n<thead>\n<tr>\n<th>Server Explorer Mode</th>\n<th>Connections Manager Mode</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>None</td>\n<td>No</td>\n<td>Do not use SSL. No SSL files are required.</td>\n</tr>\n<tr>\n<td>Preferred</td>\n<td>If Available</td>\n<td>Use SSL if the server supports it, but allow connection in all cases. Preferred is the default value with Connector/NET 8.0.11 or higher. No SSL files are required; however, providing the SSL CA file (with either a .pem or .pfx file extension) is the best practice</td>\n</tr>\n</tbody>\n</table>\n5.4.1 Connect Using Server Explorer\n\nThis section describes how to create a new connection with or without encryption. After a connection is successfully established, all settings are saved for future use. When you start Visual Studio for the next time, open the connection node in Server Explorer to establish a connection to the MySQL server again. The instructions for setting up connections are provided in these sections.\n\n- Basic Connections with Server Explorer\n- SSL Connections with Server Explorer\n\nTo modify or delete a connection, use the Server Explorer context menu for the corresponding node. You can modify any of the settings by overwriting the existing values with new ones. The connection may be modified or deleted only if no active editor for its objects is opened; otherwise, you may lose your data.\n\n**Basic Connections with Server Explorer**\n\nTo create a connection to an existing MySQL database:\n\n1. Start Visual Studio and open the Server Explorer by clicking **Server Explorer** from the **View** menu.\n2. Right-click the Data Connections node and then select **Add Connection**.\n3. From the Add Connection window, click **Change** to open the Change Data Source dialog box, then do the following:\n a. Select **MySQL Database** from the list of data sources. Alternatively, you can select `<other>`, if **MySQL Database** is absent.\n b. Select **.NET Framework Data Provider for MySQL** as the data provider.\n c. Click **OK** to return to the Add Connections window.\n4. Type a value for each of the following connection settings:\n - **Server name:**\n\n---\n\n**Table: Required and Verify CA**\n\n<table>\n<thead>\n<tr>\n<th>Server Explorer</th>\n<th>Connections Manager</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Required</td>\n<td>Require</td>\n<td>Always use SSL and deny a connection if the server does not support SSL. Do not perform server certificate validation. No SSL files are required.</td>\n</tr>\n<tr>\n<td>VerifyCA</td>\n<td>Require and Verify CA</td>\n<td>Always use SSL. Validate the certificate authorities (CA), but tolerate a name mismatch. Requires the SSL CA file. Use either a <code>.pem</code> or <code>.pfx</code> file extension.</td>\n</tr>\n<tr>\n<td>VerifyFull</td>\n<td>Require and Verify Identity</td>\n<td>Always use SSL and fail if the host name is not correct. Requires valid SSL CA, SSL Cert, and SSL Key files for PEM (.pem file extension). Requires the SSL CA file for PFX certificates (.pfx file extension).</td>\n</tr>\n</tbody>\n</table>\nConnect Using Server Explorer\n\nThe name or IP address of the computer hosting the MySQL server. For example, localhost if the MySQL server is installed on the local computer.\n\n- **User name:**\n\n The name of a valid MySQL database user account.\n\n- **Password:**\n\n The password of the user account specified previously. Optionally, click **Save my password** to avoid having to enter the password in the Modify Connections window for each connection session.\n\n- **Database name:**\n\n The database to use as the default schema. You can leave the name blank and select a default schema later from the list of schema on the target server.\n\nYou can also set the port to connect with the MySQL server by clicking **Advanced**. To test connection with the MySQL server, set the server host name, the user name and the password, and then click **Test Connection**. If the test succeeds, the success confirmation dialog box opens.\n\n5. Click **OK** to create and store the new connection. The new connection with its tables, views, stored procedures, stored functions, and loadable functions now appears within the **Data Connections** node of Server Explorer.\n\nSSL Connections with Server Explorer\n\nYou can enable SSL encryption for a classic MySQL protocol connection from Server Explorer. Both SSL PEM and PFX certificate formats are permitted. In addition, MySQL Connector/NET version 8.0.17 must be installed on the client host.\n\nTo create a connection with SSL encryption enabled:\n\n1. Add and test a new basic connection (see **Basic Connections with Server Explorer**).\n\n To modify an existing connection, right-click the connection node within **Data Connections** and select **Modify Connection**.\n\n2. In the Add (or Modify) Connection window, click **Advanced** to open the Advanced Properties dialog box. Advanced properties are categorized and presented in a two-column list, showing the property name and value field (or value list). Default values are not shown.\n\n3. In the **Connection** property category, do the following:\n\n a. Select **Connection Protocol** and then select **Socket** from the value list (use the arrow in the value field to open the list). This property sets the connection protocol to use standard TCP/IP.\n\n b. Select **Port** and type **3306** in the value field.\n\n4. In the **Authentication** property category, select **Ssl Mode** and choose the type of mode that best represents your connection. For a description of each mode and the required files, see Table 5.2, “SSL Mode Values”.\n\n a. For SSL PEM, use the **Ssl CA**, **Ssl Cert**, and **Ssl Key** properties to add the required files (must have a .pem file extension).\n\n b. For SSL PFX (PKCS#12 format), use the **Certificate File**, **Certificate Password**, **Certificate Store Location**, and **Certificate Thumbprint** properties to add the required information or files (must have a .pfx file extension).\nClick **OK** to close the Advanced Properties dialog box.\n\n5. **Click Test Connection** and adjust the property values if needed.\n6. **Click OK** to create and store the new or modified connection.\n\n### 5.4.2 Connect Using MySQL Connections Manager\n\nThis section describes how to create a new connection with or without encryption. After a connection is successfully established, all settings are saved for future use. When you start Visual Studio for the next time, open the connection node in Server Explorer to establish a connection to the MySQL server again. The instructions for setting up connections are provided in these sections.\n\n- Basic Connections with MySQL Connections Manager\n- SSL Connections with Connections Manager\n\nTo modify or delete a connection, start MySQL Connections Manager and select an existing connection. You can modify any of the settings by overwriting the existing values with new ones. The connection may be modified or deleted only if no active editor for its objects is opened; otherwise, you may lose your data.\n\n### Basic Connections with MySQL Connections Manager\n\nTo create a connection to an existing MySQL database:\n\n1. Click **in the Server Explorer menu bar to open the MySQL Connections Manager window.**\n2. **Click Add New Connection** to create a new connection.\n3. **Provide a unique name for the new connection in the required Connection Name field.**\n4. **Confirm that TCP/IP (standard) is selected as the connection method.**\n5. In the **Parameters** tab, add or modify the following information:\n - **Hostname:** and **Port:**\n The name (or IP address) and port number of the computer hosting the MySQL server. For example, *localhost* if the MySQL server is installed on the local computer. The default port value is 3306.\n - **Username:**\n The name of a valid MySQL user account.\n - **Password:**\n The password of the user account specified previously.\n - **Default Schema:**\n A default schema name is required to open the connection. Select a name from the list.\n6. **Click Test Connection** to verify the connection information.\n7. **Click OK** to create and store the new connection. The new connection now appears in MySQL Connections Manager. Optionally, select the new connection from Connections Manager to add its tables, views, stored procedures, stored functions, and loadable functions to the Data Connections node in Server Explorer.\nSSL Connections with Connections Manager\n\nX Protocol connections can be configured to use SSL with PEM or PFX files. Connections must be\ncreated using the MySQL Connections Manager, which is supported by MySQL for Visual Studio\n2.0.5 (or higher). MySQL Workbench provides similar support to add PEM files, but it does not support\ncertificates in PFX format.\n\nNote\nX Plugin must be installed to support connections using X Protocol (see Setting\nUp MySQL as a Document Store).\n\nIn contrast, classic MySQL protocol connections support SSL PFX files only when you use MySQL\nConnections Manager to configure the connection.\n\nTo create a connection to a MySQL database using SSL encryption:\n\n1. Click in the Server Explorer menu bar to open the MySQL Connections Manager window.\n\n2. Add and test a new basic connection (see Basic Connections with MySQL Connections Manager)\nor double-click an existing connection to modify it.\n\n3. In the SSL tab, add a path to the SSL CA, SSL CERT, and SSL Key files within the SSL PEM area.\nClick Test Connection to verify the connection information. The next figure shows an example of\nSSL PEM values within this tab.\n\nFigure 5.12 MySQL Server Connection SSL Tab\n\nTo configure SSL PFX (PKCS#12 format), select either the file-based or store-based option. Use\nthe .pfx file extension to enable the correct certificate format.\n\n4. Click OK to save the connection and return to the MySQL Connections Manager window.\n\nNote\nYou must close and then reopen MySQL Connections Manager to apply\nthe default schema.\n\n5. Double-click the new SSL connection to add it to Server Explorer (or select the connection and click\nOK). To open the JavaScript or Python code editor, right-click the connection in Server Explorer\nand then select an editor.\n\n5.5 Editing\n\nMaking edits in MySQL for Visual Studio.\nAfter you have established a connection, for example, using the **Connect to MySQL** toolbar button, you can use auto-completion as you type or by pressing **Control + J**. Depending on the context, the auto-completion dialog can show the list of available tables, table columns, or stored procedures (with the signature of the routine as a tooltip). Typing some characters before pressing **Control + J** filters the choices to those items starting with that prefix.\n\n### 5.5.1 MySQL SQL Editor\n\nThe MySQL SQL Editor can be opened from the **MySQL toolbar** or by clicking **File**, **New**, and **File** from the Visual Studio main menu. This action displays the **New File** dialog.\n\n\n\nFrom the **New File** dialog, select the MySQL template, select the **MySQL Script** document, and then click **Open**.\n\nThe MySQL SQL Editor will be displayed. You can now enter SQL code as required, or connect to a MySQL server. Click the **Connect to MySQL** button in the MySQL SQL Editor toolbar. You can enter the connection details into the **Connect to MySQL** dialog that is displayed. You can enter the server name, user ID, password and database to connect to, or click the **Advanced** button to select other connection string options. Click the **Connect** button to connect to the MySQL server. To execute your SQL code against the server, click the **Run SQL** button on the toolbar.\nThe results from queries are displayed in the Results tab and relevant information appears in the MySQL Output pane. The previous example displays the query results within a Result Grid. You can also select the Field Types, Execution Plan, and Query Stats for an executed query.\n\n5.5.2 Code Editors\n\nThis section explains how to make use of the code editors in MySQL for Visual Studio.\n\nIntroduction\n\nMySQL for Visual Studio provides access to MySQL objects and data without forcing developers to leave Visual Studio. Designed and developed as a Visual Studio package, MySQL for Visual Studio integrates directly into Server Explorer providing a seamless experience for setting up new connections and working with database objects.\n\nThe following MySQL for Visual Studio features are available as of version 2.0.5:\n\n- JavaScript and Python code editors, where scripts in those languages can be executed to query data from a MySQL database.\n- Better integration with the Server Explorer to open MySQL, JavaScript, and Python editors directly from a connected MySQL instance.\n- A newer user interface for displaying query results, where different views are presented from result sets returned by a MySQL server like:\n - Multiple tabs for each result set returned by an executed query.\n - Results view, where the information can be seen in grid, tree, or text representation for JSON results.\n• Field types view, where information about the columns of a result set is shown, such as names, data types, character sets, and more.\n\n• Query statistics view, displaying information about the executed query such as execution times, processed rows, index and temporary tables usage, and more.\n\n• Execution plan view, displaying an explanation of the query execution done internally by the MySQL server.\n\nGetting Started\n\nThe minimum requirements are:\n\n• MySQL for Visual Studio 2.0.5\n\n• Visual Studio 2012\n\n• MySQL 5.7.12 with X Plugin enabled (Code editors are not supported for use with MySQL 8.0 servers.)\n\nTo enable X Plugin for MySQL 5.7:\n\n1. Open a command prompt and navigate to the folder with your MySQL binaries.\n\n2. Invoke the `mysql` command-line client:\n\n ```\n mysql -u user -p\n ```\n\n3. Execute the following statement:\n\n ```\n mysql> INSTALL PLUGIN mysqlx SONAME 'mysqlx.dll';\n ```\n\nImportant\n\nThe `mysql.session` user must exist before you can load X Plugin. `mysql.session` was added in MySQL 5.7.19. If your data dictionary was initialized using an earlier version you must run the `mysql_upgrade` procedure. If the upgrade is not run, X Plugin fails to start with the following error message:\n\n```\nThere was an error when trying to access the server with user: mysql.session@localhost. Make sure the user is present in the server and that mysql_upgrade was ran after a server update.\n```\n\nOpening a Code Editor\n\nBefore opening a code editor that can run scripts against a MySQL server, a connection needs to be established:\n\n1. Open the Server Explorer pane by clicking View.\n\n2. Right-click the Data Connections node and select Add Connection.\n\n3. In the Add Connection window, make sure the MySQL Data Provider is being used and fill in all the information.\n\nNote\n\nTo enter the port number, click Advanced and set the Port among the list of connection properties.\n4. Click **Test Connection** to ensure you have a valid connection, then click **OK**. The new connection with its tables, views, stored procedures, and functions now appears within the Data Connections list of Server Explorer.\n\n5. Right-click the connection, select **New MySQL Script**, and then select the language of the editor (JavaScript or Python) to open a new MySQL script tab in Visual Studio.\n\nTo create a new editor for existing MySQL connections, you need only to do the last step.\n\n### Using the Code Editor\n\nAn open editor includes a toolbar with the actions that can be executed. The first two buttons in the toolbar represent a way to connect or disconnect from a MySQL server. If the editor was opened from the Server Explorer, the connection will be already established for the new script tab.\n\nThe third button is the **Run** button, the script contained in the editor window is executed by clicking it and results from the script execution are displayed in the lower area of the script tab.\n\n### 5.5.3 Editing Tables\n\nMySQL for Visual Studio contains a table editor, which enables the visual creation and modification of tables.\n\nThe Table Designer can be accessed through a mouse action on table-type node of Server Explorer. To create a new table, right-click the **Tables** node (under the connection node) and choose **Create Table** from the context-menu.\n\nTo modify an existing table, double-click the node of the table to modify, or right-click this node and choose the **Design** item from the context menu. Either of the commands opens the Table Designer.\nTable Designer consists of the following parts:\n\n- **Columns Editor** - a data grid on top of the Table Designer. Use the Columns grid for column creation, modification, and deletion. For additional information, see Section 5.5.3.1, “Column Editor”.\n\n- **Indexes/Keys** window - a window opened from the **Table Designer** menu to manage indexes.\n\n- **Relationships** window - a window opened from the **Table Designer** menu to manage foreign keys.\n\n- **Column Properties** panel - a panel near the bottom of the Table Designer. Use the Column Properties panel to set advanced column options.\n\n- **Properties** window - a standard Visual Studio Properties window, where the properties of the edited table are displayed. Use the Properties window to set the table properties. To open, right-click on a table and select the **Properties** context-menu item.\n\nEach of these areas is discussed in more detail in subsequent sections.\nTo save changes you have made in the Table Designer, press either **Save** or **Save All** on the Visual Studio main toolbar, or press **Control + S**. If you have not already named the table, you will be prompted to do so.\n\n**Figure 5.16 Choose Table Name**\n\nAfter the table is created, you can view it in the **Server Explorer**.\n\n**Figure 5.17 Newly Created Table**\n\nThe Table Designer main menu lets you set a **primary key** column, edit relationships such as **foreign keys**, and create **indexes**.\n\n**Figure 5.18 Table Designer Main Menu**\n\n### 5.5.3.1 Column Editor\n\nYou can use the Column Editor to set or change the name, data type, default value, and other properties of a table column. To set the focus to a needed cell of a grid, use the mouse click. Also you can move through the grid using **Tab** and **Shift + Tab** keys.\n\nTo set or change the name, data type, default value and comment of a column, activate the appropriate cell and type the desired value.\n\nTo set or unset flag-type column properties (**NOT NULL**, auto incremented, flags), select or deselect the corresponding check boxes. The set of column flags depends on the data type of the column.\n\nTo reorder columns, index columns or foreign key columns in the Column Editor, select the whole column to reorder by clicking the selector column on the left of the column grid. Then move the column by using **Control+Up** (to move the column up) or **Control+Down** (to move the column down) keys.\nTo delete a column, select it by clicking the selector column on the left of the column grid, then press the **Delete** button on a keyboard.\n\n### 5.5.3.2 Column Properties\n\nThe **Column Properties** tab can be used to set column options. In addition to the general column properties presented in the Column Editor, in the **Column Properties** tab you can set additional properties such as Character Set, Collation and Precision.\n\n#### Figure 5.19 Column Properties Panel\n\n\n\n### 5.5.3.3 Table Properties\n\nTo bring up Table Properties select the table and right-click to activate the context menu. Select **Properties**. The **Table Properties** dockable window will be displayed.\nThe following table properties are listed under table properties, and many are fully described in the `SHOW TABLE STATUS` MySQL documentation.\n\n- **Auto Increment**: The next `AUTO_INCREMENT` value.\n- **Average Row Length**: The `AVG_ROW_LENGTH` value.\n- **Character Set**: The Charset value.\n- **Collation**: The Collation value.\n- **Comment**: Table comments.\n- **Data Directory**: The directory used to store data files for this table.\n- **Index Directory**: The directory used to store index files for this table.\n- **Maximum Rows**: Value of the `MAX_ROWS` property.\n- **Minimum Rows**: Value of the `MIN_ROWS` property.\n- **Name**: Name of the table.\n- **Row Format**: The `ROW_FORMAT` value.\n- **Schema**: The schema this table belongs to.\n- **Storage Engine**.\nIn MySQL 5.5 and higher, the default storage engine for new tables is InnoDB. See Introduction to InnoDB for more information about the choice of storage engine, and considerations when converting existing tables to InnoDB.\n\nThe property Schema is read-only.\n\n5.5.4 Editing Views\n\nTo create a new view, right-click the Views node under the connection node in Server Explorer. From the node's context menu, choose the Create View command. This command opens the SQL Editor.\nYou can then enter the SQL for your view, and then execute the statement.\n\nTo modify an existing view, double-click a node of the view to modify, or right-click this node and choose the **Alter View** command from a context menu. Either of the commands opens the SQL Editor.\n\nAll other view properties can be set in the **Properties** window. These properties are:\n\n- **Catalog**: The `TABLE_CATALOG`.\n- **Check Option**: Whether or not the `WITH CHECK OPTION` clause is present. For additional information, see *The View WITH CHECK OPTION Clause*.\n- **Definer**: Creator of the object.\n- **Definition**: Definition of the view.\n- **Is Updatable**: Whether or not the view is Updatable. For additional information, see *Updatable and Insertable Views*.\n- **Name**: The name of the view.\n- **Schema**: The schema which owns the view.\n- **Security Type**: The `SQL SECURITY` value. For additional information, see *Stored Object Access Control*.\n\nSome of these properties can have arbitrary text values, others accept values from a predefined set. In the latter case, set the desired value with an embedded combobox.\n\nThe properties **Is Updatable** and **Schema** are read-only.\n\nTo save changes you have made, use either Save or Save All buttons of the Visual Studio main toolbar, or press **Control + S**.\n5.5.5 Editing Indexes\n\nIndexes management is performed using the **Indexes/Keys** dialog.\n\nTo add an index, select **Table Designer, Indexes/Keys...** from the main menu, and click **Add** to add a new index. You can then set the index name, index kind, index type, and a set of index columns.\nTo remove an index, select it in the list box on the left, and click the Delete button.\n\nTo change index settings, select the needed index in the list box on the left. The detailed information about the index is displayed in the panel on the right hand side. Change the desired values.\n\n5.5.6 Editing Foreign Keys\n\nYou manage foreign keys for InnoDB tables using the Foreign Key Relationships dialog.\n\nTo add a foreign key, select Table Designer, Relationships... from the main menu. This displays the Foreign Key Relationship dialog. Click Add. You can then set the foreign key name, referenced table name, foreign key columns, and actions upon update and delete.\n\nTo remove a foreign key, select it in the list box on the left, and click the Delete button.\n\nTo change foreign key settings, select the required foreign key in the list box on the left. The detailed information about the foreign key is displayed in the right hand panel. Change the desired values.\n5.5.7 Editing Stored Procedures and Functions\n\nTo create a new stored procedure, right-click the Stored Procedures node under the connection node in Server Explorer. From the node's context menu, choose the Create Routine command. This command opens the SQL Editor.\n\nTo create a new stored function, right-click the Functions node under the connection node in Server Explorer. From the node's context menu, choose the Create Routine command.\n\nTo modify an existing stored routine (procedure or function), double-click the node of the routine to modify, or right-click this node and choose the Alter Routine command from the context menu. Either of the commands opens the SQL Editor.\nRoutine properties can be viewed in the **Properties** window. These properties are:\n\n- Body\n- Catalog\n- Comment\n- Creation Time\n- Data Access\n- Definer\n- Definition\n- External Name\n- External Language\n- Is Deterministic\n- Last Modified\n- Name\n- Parameter Style\n- Returns\n- Schema\n- Security Type\n- Specific Name\n- SQL Mode\n- SQL Path\n- Type\n\nSome of these properties can have arbitrary text values, others accept values from a predefined set. In both cases, these values cannot be set from the properties panel.\n\nYou can also set all the options directly in the SQL Editor, using the standard `CREATE PROCEDURE` or `CREATE FUNCTION` statement.\n\nTo save changes you have made, use either **Save** or **Save All** buttons of the Visual Studio main toolbar, or press **Control + S**.\n5.5.8 Editing Triggers\n\nTo create a new trigger, right-click the node of the table in which to add the trigger. From the node’s context menu, choose the **Create Trigger** command. This command opens the SQL Editor.\n\nTo modify an existing trigger, double-click the node of the trigger to modify, or right-click this node and choose the **Alter Trigger** command from the context menu. Either of the commands opens the SQL Editor.\n\nTo create or alter the trigger definition using SQL Editor, type the trigger statement in the SQL Editor using standard SQL.\n\n**Note**\n\nEnter only the trigger statement, that is, the part of the `CREATE TRIGGER` query that is placed after the `FOR EACH ROW` clause.\n\nAll other trigger properties are set in the Properties window. These properties are:\n\n- Definer\n- Event Manipulation\n- Name\n- Timing\nMySQL Project Items\n\nSome of these properties can have arbitrary text values, others accept values from a predefined set. In the latter case, set the desired value using the embedded combo box.\n\nThe properties Event Table, Schema, and Server in the Properties window are read-only.\n\nTo save changes you have made, use either Save or Save All buttons of the Visual Studio main toolbar, or press Control + S. Before changes are saved, you will be asked to confirm the execution of the corresponding SQL query in a confirmation dialog.\n\nTo observe the runtime behavior of a stored routine and debug any problems, use the Stored Procedure Debugger. For additional information, see Section 5.10, “Debugging Stored Procedures and Functions”.\n\n5.6 MySQL Project Items\n\nThis two-part tutorial uses MySQL MVC Item templates to set up a MVC web application. In the second part of the tutorial, a Windows Forms Item with MySQL connectivity is created.\n\nMinimum Requirements\n\n- MySQL 5.5 installed on a host that is accessible.\n- MySQL for Visual Studio 1.2.5.\n- Visual Studio 2012, the professional edition.\n- MySQL Connector/NET is required to use web providers in the generated web application.\n\n5.6.1 MySQL ASP.NET MVC Items\n\nTo add a MySQL MVC Item to an existing MVC project, first add a MySQL Entity Framework model. Skip this step if you have already done this.\n\nConfigure the project to use MySQL with an Entity Framework. There are two ways to do this:\n\n- Manually add the references needed (EntityFramework, MySql.Data & MySql.Data.Entity), and add the required configuration to the web.config configuration file\n- Or (preferred), take advantage of the MySQL Website Configuration tool, which allows either Entity Framework 5 or 6 with MySQL. For additional information about this tool, see Section 5.7, “MySQL Application Configuration Tool”.\n\nOnce you have configured the project to use MySQL with Entity Framework, proceed to create the model using the standard ADO.NET Entity Data Model wizard. For MySQL MVC Item Templates, you need to add the model under the \"Models\" folder, as illustrated below:\nFigure 5.28 ADO.NET Entity Data Model\nFigure 5.29 Choose or create a new MySQL connection\n\nFigure 5.30 Creating a new MySQL connection\nAfter selecting the MySQL connection, you need to select the database objects to include in the model.\n\n**Important**\n\nThe *Pluralize or singularize generated object names* option must remain unchecked, otherwise the MySQL MVC Item Template will not function properly.\n\n**Figure 5.31 Selecting the database object to include in the model**\n\nClick **Finish** to generate the model, as demonstrated below:\nFigure 5.32 Creating the MySQL Entity Framework model\n\nNow, generate a new MySQL MVC Item. Right-click on the project, and select **Add New Item** from the contextual menu.\n\nFigure 5.33 Add New Item\n\nThis launches the **Add New Item** wizard. The MySQL menu offers two options: **MySQL New MVC Item** and **MySQL New Windows Form**. Select **MySQL New MVC Item**, and then click **Add**.\nThis opens the **MVC Item Template** dialog. Now select the MySQL model and entity that you want to use to create the MVC item. The model dropdown list is populated based on all the MySQL Entity Framework models available in the project, entities dropdown list is populated with entities available for the selected model.\nAfter selecting the model and entity to create the item, click **Finish**, and a new controller and view matching the selected entity will be added to the project. These contain the necessary back end code to render the entity data.\nYou can now execute the application. In our example we used the Sakila database and generated an Actor controller:\n\n**Figure 5.38 The Actor View**\n\nYou can now execute the application. In our example we used the Sakila database and generated an Actor controller:\n\n**Figure 5.38 The Actor View**\n\n<table>\n<thead>\n<tr>\n<th>actor_id</th>\n<th>first_name</th>\n<th>last_name</th>\n<th>last_update</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>PENELLOPE</td>\n<td>GUINESS</td>\n<td>21/02/2004 13:24:33 AM</td>\n</tr>\n<tr>\n<td>2</td>\n<td>NICK</td>\n<td>WAHLBERG</td>\n<td>21/02/2004 13:24:33 AM</td>\n</tr>\n<tr>\n<td>3</td>\n<td>ED</td>\n<td>CHASE</td>\n<td>21/02/2004 13:24:33 AM</td>\n</tr>\n<tr>\n<td>4</td>\n<td>JENNIFER</td>\n<td>DAVIES</td>\n<td>21/02/2004 13:24:33 AM</td>\n</tr>\n<tr>\n<td>5</td>\n<td>JOHNNY</td>\n<td>LOLLOBRIDA</td>\n<td>21/02/2004 13:24:33 AM</td>\n</tr>\n<tr>\n<td>6</td>\n<td>BETTE</td>\n<td>NICHOLSON</td>\n<td>21/02/2004 13:24:33 AM</td>\n</tr>\n<tr>\n<td>7</td>\n<td>GRACE</td>\n<td>MOSTEL</td>\n<td>21/02/2004 13:24:33 AM</td>\n</tr>\n<tr>\n<td>8</td>\n<td>MATTHEW</td>\n<td>JOHANSSON</td>\n<td>21/02/2004 13:24:33 AM</td>\n</tr>\n<tr>\n<td>9</td>\n<td>JOE</td>\n<td>SWANK</td>\n<td>21/02/2004 13:24:33 AM</td>\n</tr>\n<tr>\n<td>10</td>\n<td>CHRISTIAN</td>\n<td>GABLE</td>\n<td>21/02/2004 13:24:33 AM</td>\n</tr>\n</tbody>\n</table>\n\n© 2015 - My ASP.NET Application\n\n### 5.6.2 MySQL Windows Forms Items\n\nThis portion of the tutorial describes how to create a Windows Form with MySQL connectivity. The item template to use for this operation is named **MySQL New Windows Form**. To open the Add New Item window, right-click your Windows Form application and select **MySQL** from the list of installed items.\n\nThe item template for adding a new MySQL Windows Form is similar to the MySQL MVC item template (see Section 5.6.1, \"MySQL ASP.NET MVC Items\"), but with three major differences:\n\n- You can create the MySQL Entity Framework model under the root path of the project.\n\n**Figure 5.39 A MySQL Entity Framework model created in a Windows Form Application**\n\n- When selecting the desired entity, you can also select the layout type in which the new form will display the entity data.\nFigure 5.40 The \"MySQL Windows Form\" Item Template dialog, with the layout options\n\nA Resources folder is added to the project that contains images used by the icons for the generated form.\n\nFigure 5.41 The Resources Folder and New Form\n\nThe new form will have all the necessary back-end code to display the entity data, with the user interface (UI) based on the previously selected layout.\n5.7 MySQL Application Configuration Tool\n\nThe MySQL Application Configuration tool (previously named MySQL Website Configuration) enables you to configure options for the following categories with MySQL as the database provider: entity\nframework, membership (advanced or simple), roles, profiles, session state, site map, and web personalization. With this MySQL for Visual Studio feature, you can configure multiple provider pages in sequence and the tool modifies your configuration files accordingly.\n\nEditing configuration files manually can be problematic. The MySQL Application Configuration tool simplifies the task by providing the relevant options for each web (or application) project in a graphical, wizard-like format that permits you to navigate among the provider categories. The tool then adds, modifies, or removes entries from the `App.config` file, which applies to settings for non-web projects only, and the `Web.config` file for your web-based projects.\n\nThe MySQL Application Configuration tool appears as a small icon on the Solution Explorer toolbar in Visual Studio, as shown in the following figure. The icon is visible only when a project is active (with a connection to MySQL), and Connector/.NET is installed. Clicking the MySQL Application Configuration icon launches the tool and displays the options for setting up Entity Framework support.\n\n**Figure 5.44 MySQL Application Configuration Tool**\n\nThe remainder of this chapter describes each item that you can configure using the MySQL Application Configuration tool.\n\n### 5.7.1 Entity Framework\n\nThe MySQL Application Configuration tool downloads the latest entity framework and MySQL Connector/.NET assemblies from the NuGet gallery to keep the assembly versions synchronized. After the configuration is applied, the tool adds the following references to your project:\n\n- EntityFramework\n- EntityFramework.SqlServer\n- MySql.Data\n- MySql.Data.EntityFramework\n\nUnlike the other web providers supported by this tool, the entity framework options can be applied to either non-web or web applications. The context of your project determines which configuration file the tool updates. The next sections describe the details for setting options with non-web and web projects.\n\n**Note**\n\nMySQL for Visual Studio does not support Entity Framework Core. For the current support profile, see Minimum Requirements.\nSetting Options for Non-Web Applications\n\nThe MySQL Application Configuration tool synchronizes the latest version of MySQL Connector/NET and Entity Framework 6 assemblies and then adds the required references to your application’s App.config file. When started in the context of a non-web application, the tool lists entity framework as the only item and MySQL for Visual Studio 1.2.9 (or higher) is a prerequisite. For an example of when you might use the tool, see Tutorial: Using an Entity Framework Entity as a Windows Forms Data Source.\n\nTo enable the tool, select Use MySQL with Entity Framework, ensure that Entity Framework 6.x is selected, and then click Finish (see the figure that follows).\n\n\n\nSetting Options for Web Applications\n\nIn the context of a web application, entity framework is the first page of options that you can enable. After enabling (or skipping) the entity framework option, the wizard-like tool steps through several additional web provider pages (see Section 5.7.2, “Web Providers”). You can enable entity framework alone and skip the other web providers, or selectively enable other providers in the same session.\n\nWith MySQL for Visual Studio 1.2.9 (or higher) installed, Entity Framework 6 is the only version to select, as the following figure shows. Previous versions of MySQL for Visual Studio permit you to configure your application to use Entity Framework 5 or 6. (Prior to version 1.2.9, this tool was named MySQL Website Configuration.) The current version of MySQL Connector/NET no longer supports Entity Framework 5.\n\nTo include entity framework options, select Use MySQL with Entity Framework, ensure that an Entity Framework version is selected, and then click Next to advance to the membership provider options. To skip configuring entity framework options, deselect the Use MySQL with Entity Framework check box.\nFor information about the options on the membership (or simple membership), roles, profiles, session state, site map, and web personalization pages, see Section 5.7.2, “Web Providers”.\n\n### 5.7.2 Web Providers\n\nThe MySQL Application Configuration tool establishes MySQL as the database provider for one or more web providers by making changes to your application's `Web.config` file. You can choose only one of the two membership providers: membership or simple membership. All of the other web providers may be enabled independently or together. The configuration entries for each web provider managed by the MySQL Application Configuration tool are included in the sections that follow.\n\n- **Membership Provider**\n- **Simple Membership Provider**\n- **Roles Provider**\n- **Profiles Provider**\n- **Session State Provider**\n- **Site Map Provider**\n- **Web Personalization Provider**\n\nWeb-provider pages share several common elements, as the membership provider page shows.\nWeb Providers\n\nFigure 5.47 MySQL Application Configuration Tool - Membership\n\nCheck box to enable the provider. Web providers are enabled when you select the check box on the page. When selected, the page enforces requirement-checking specific to the provider. For example, if you enable any provider, the configuration file for your application must include a connection string. If the connection string is missing, the tool returns a warning when you attempt to move to the next provider. To skip (or disable) an individual web provider, deselect the check box.\n\nName. Each enabled web provider requires a value to specify the application name. If you do not provide a value, then the default value creates an application name for you. The value is associated with the applicationName property in the Web.config file.\n\nConnection String. The Web.config file stores a single connection string for all of the MySQL web-providers. Each web-provider page includes an area for entering a connection string, however only the last entry is saved. For example, if you set it in the first web provider and also set it on the third web provider, the connection string from the third provider page is saved. You can enter a connection string directly in the text box provided or click Edit to use a visual editor to help you sort and select the various connection string options (see Section 5.7.3, “Using the MySQL Connection String Editor”).\n\nAutogenerate Schema. Select the Autogenerate Schema option check box to ensure that the necessary schemas are created automatically for the web provider being configured. These schemas are used to store MySQL web provider information. The database used for storage is the one specified in the connection string.\n\nWrite exceptions to event log. Select the Write exceptions to event log option check box to ensure that exceptions generated by the application are written to the Windows event log.\n\nMembership Provider\n\nIn addition to the standard membership provider, there is also a simple membership provider. You can only choose one of these two membership providers. To use the membership provider, select Use MySQL to manage my membership records to enable the page. You can now enter the name of the application that you are creating the configuration for. You can also enter a description for the application. The Autogenerate Schema and Write exceptions to event log options can be selected for this web provider.\n\nAfter setting up a membership provider, a new section is added to the web configuration file.\n\n```\n<membership defaultProvider=\"MySQLMembershipProvider\">\n<providers>\n <remove name=\"MySQLMembershipProvider\" />\n</providers>\n```\nWith one of the membership providers configured, click **Next** to advance to the roles provider page.\n\n**Simple Membership Provider**\n\nThe simple membership provider options are similar to those of the membership provider, but with fewer properties in the configuration file. To enable, check the **Use MySQL to manage my simple membership records**.\n\n---\n\n**Note**\n\nThe simple membership provider is not supported by MySQL Connector/NET 8.0 and cannot be enabled if you have the 8.0 version of the connector installed.\n\nThe MySQL simple membership provider handles the website membership tasks with ASP.NET. This provider is a simpler version of the ASP.NET Membership provider, and it can also work with OAuth Authentication. For additional information about using OAuth authentication, see Adding OAuth Authentication to a Project.\n\nThe required configuration options for the simple membership provider are: a name for the connection string and a connection string that contains a valid database with a local or remote MySQL server instance, a user table to store the credentials, and column names for the **User ID** and **User Name** columns.\n\nSelect the **Auto Create Tables** option to create the required tables when adding the first user to the table. After setting up a membership provider, a new section is added to the web configuration file.\n\n```xml\n<add name=\"MySQLSimpleMembershipProvider\" type=\"MySql.Web.Security.MySQLSimpleMembershipProvider, MySql.Web, Version=6.10.8.0, Culture=neutral, PublicKeyToken=c2222fc22222c44d\"\n applicationName=\"/\" description=\"MySQL default application\" connectionStringName=\"LocalMySqlServer\"\n writeExceptionsToEventLog=\"False\" autogenerateschema=\"False\" enableExpireCallback=\"False\"\n enablePasswordRetrieval=\"False\" enablePasswordReset=\"True\" requiresQuestionAndAnswer=\"True\"\n requiresUniqueEmail=\"False\" passwordFormat=\"Clear\" maxInvalidPasswordAttempts=\"5\"\n minRequiredPasswordLength=\"7\" minRequiredNonalphanumericCharacters=\"1\" passwordAttemptWindow=\"10\"\n passwordStrengthRegularExpression=\"\" />\n</providers>\n</membership>\n```\n\nAfter setting up one of the membership providers, click **Next** to advance to the roles provider page.\n\n**Roles Provider**\n\nClick **Use MySQL to manage my roles** to enable this provider page. The page includes the following options to edit: the connection string, the application name, and a description of the provider. The **Autogenerate Schema** and **Write exceptions to event log** options can be selected for this web provider.\n\nAfter setting up a roles provider, a new section is added to the web configuration file.\nProfiles Provider\n\nClick Use MySQL to manage my profiles to enable this provider page. The page includes the following options to edit: the connection string, the application name, and a description of the provider. The Autogenerate Schema, Write exceptions to event log, and Callback for session end event options can be selected for this web provider.\n\nAfter setting up a profiles provider, a new section is added to the web configuration file.\n\nSession State Provider\n\nClick Use MySQL to manage my ASP.Net session state to enable this provider page. The page includes the following options to edit: the connection string, the application name, and a description of the provider. The Autogenerate Schema and Write exceptions to event log options can be selected for this web provider.\n\nAfter setting up a session provider, a new section is added to the web configuration file.\n\nSite Map Provider\n\nThe site map provider builds a site map from a MySQL database, and builds a complete tree of the SitemapNode objects. It also provides methods so that the generated nodes can be read from the site map. Click Use MySQL to manage my ASP.NET site map to enable this provider page.\n\nThe required configuration options: A name for the application and a connection string that contains a valid database with a local or remote MySQL server instance. The Autogenerate Schema and Write exceptions to event log options can be selected for this web provider.\n\nAfter setting up the site map provider, a new section is added to the web configuration file.\nClick Next to proceed to the web personalization configuration page:\n\n**Web Personalization Provider**\n\nThe web personalization provider is used when a website application needs to store persistent information for the content and layout of the Web Parts pages that are generated by a Web Parts personalization service. This provider should be used along with the membership, roles, and profiles providers. Click Use MySQL to manage my ASP.NET personalization provider to enable this provider page.\n\nThe required configuration options: A name for the application and a connection string that contains a valid database with a local or remote MySQL server instance. The Autogenerate Schema and Write exceptions to event log options can be selected for this web provider.\n\nAfter setting up the web personalization provider, a new section is added to the web configuration file.\n\nWhen you have selected the web personalization options, click Finish to write the changes for all web providers to the Web.config file and close the tool.\n\n### 5.7.3 Using the MySQL Connection String Editor\n\nThe MySQL Connection String Editor lists and describes all supported connection-string options for the version of MySQL Connector/NET that you have installed. To open the editor from any web-provider page (see the Connection String entry box), click Edit.\n\nBy default, the editor lists connection-string options by category (see the figure that follows). Alternatively, you can sort the list alphabetically using the sorting buttons provided. The main list consists of options on the left and values on the right of a split area. To add a text value, such as the database name, select the option in the list (Database, in this example), and then type the name of the database (sakila) after the cursor. Some connection-string options have predefined values and show a down arrow when selected.\n\nWhen you select a connection-string option, a brief description is shown in an information box below the list. After you add an option value and then select another option, the editor appends the new option/value pair to the existing connection string. Click OK to return to the web-provider page, which now includes the modified connection string.\n5.8 MySQL Data Export Tool\n\nMySQL for Visual Studio has a data export tool that creates a dump file for a MySQL database.\n\nNote\n\nDefined connection strings are automatically loaded and available in editor, whether they were created manually in `web.config` for each application or previously using this tool.\nCreating a Dump of an existing MySQL Database\n\nTo open a new window for the MySQL Data Export tool, you must first create a new connection using the **Server Explorer** window inside Visual Studio. After the connection is established, a contextual menu can be opened by right clicking on the connection node. From the menu, choose the **MySQL Data Export** option. A new tab opens for the current connection. You can then select one or more databases to include in the dump.\nFollow these steps to create a dump for the MySQL Databases:\n\n1. Select all the databases and their objects to be included in the dump.\nCreating a Dump of an existing MySQL Database\n\n2. It is very important to select the desired settings for the dump: whether the dump will include the data, whether the insert operations will be logged in extended mode, and so on. In the main window of the MySQL Database Export tool are shown the basic options for the dump. Also, by clicking on the Advanced button, more specific options can also be selected.\n\nFigure 5.52 MySQL for Visual Studio Data Export Tool: Advanced Options\n\n3. When the selection of the options is done, give a name to the result file that will be created. If no path is given for the result file, the default path to be used is My Documents under the user's folder.\n\nFigure 5.53 MySQL for Visual Studio Data Export Tool: Generating the Dump File\n4. A filter can be applied on the list of schemas for the selected connection. With it, the user can easily locate the databases to be included in the dump.\n\n**Figure 5.54 MySQL for Visual Studio Data Export Tool: Filtering the Schemas**\n\n5. After selecting the options and the name for the dump file, the user can click the **Export** button, which generates the dump.\n\n**Figure 5.55 MySQL for Visual Studio Data Export Tool: Viewing the Generated Script**\nCreating a Dump of an existing MySQL Database\n\nEach dump can have different settings. After configuring the dump operation, the settings can be saved into a setting file for later use. This file includes: the connection selected, the name of the file for the dump, and the database or databases and the objects selected for dumping. The file extension for the setting file is `.dumps`.\n\nFigure 5.56 MySQL for Visual Studio Data Export Tool: Saving a Setting File\n\nA saved setting file can be loaded into the MySQL Data Export tool by clicking the Load Settings button.\n\nFigure 5.57 MySQL for Visual Studio Data Export Tool: Opening a Setting File\n5.9 DDL T4 Template Macro\n\nConvert an Entity Framework model to MySQL DDL code. Starting with a blank model, you can develop an entity model in Visual Studio’s designer. Once the model is created, you can select the model’s properties, and in the Database Script Generation category of the model’s properties, the property DDL Generation can be found. Select the value SSDLToMySQL.tt(VS) from the drop-down list.\n\nFigure 5.58 DDL T4 Template Macro - Model Properties\n\nRight-clicking the model design area displays a context-sensitive menu. Selecting Generate Database from Model from the menu displays the Generate Database Wizard. The wizard can then be used to generate MySQL DDL code.\n5.10 Debugging Stored Procedures and Functions\n\nThe stored procedure debugger provides facilities for setting breakpoints, stepping into individual statements (Step Into, Step Out, Step Over), evaluating and changing local variable values, evaluating breakpoints, and other debugging tasks.\n\nPrivileges\n\nThe debugger recreates at the start of each debug session a server-side debugger database in your server. This database helps to track the instrumented code and implement observability logic in the debugged routine. Your current connection needs to have privileges to create that database, and its associated stored routines, functions, and tables.\n\nThe debugger makes changes behind the scenes to temporarily add instrumentation code to the stored routines that you debug. You must have the ALTER ROUTINE privilege for each stored procedure, function, or trigger that you debug. (Including procedures and functions that are called, and triggers that are fired, by a procedure that you are debugging.)\n\nStarting the Debugger\n\nTo start the debugger, follow these steps:\n\n2. Expand the Stored Procedures folder. Only stored procedures can be debugged directly. To debug a user-defined function, create a stored procedure that calls the function.\n3. Click on a stored procedure node, then right-click and from the context menu choose Debug Routine.\nUsage\n\nAt this point, Visual Studio switches to debug mode, opening the source code of the routine being debugged in step mode, positioned on the first statement.\n\nIf the initial routine you debug has one or more arguments, a pop-up will show up with a grid (a row per each argument and three columns: one for the argument, one for the argument value (this is editable) and one for nullifying that argument value (a check box). After setting up all the argument values, you can press **OK** to start the debug session, or **Cancel** to cancel the debug session.\n\nFigure 5.61 Setting Arguments (1 of 2)\nHow the Debugger Functions\n\nTo have visibility into the internal workings of a stored routine, the debugger prepares a special version of the procedure, function, or trigger being debugged, instrumented with extra code to keep track of the current line being stepped into and the values of all the local variables. Any other stored procedures, functions, or triggers called from the routine being debugged are instrumented the same way. The debug versions of the routines are prepared for you automatically, and when the debug session ends (by either pressing F5 or Shift + F5), the original versions of the routines are automatically restored.\n\nA copy of the original version of each instrumented routine (the version without instrumentation) is stored in the `AppData\\Roaming\\MySqlDebuggerCache` folder for the current Windows user (the path returned by calling `System.Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)` in .NET, plus appending `MySqlDebuggerCache`). There is one file for each instrumented routine, named `routine_name.mysql`. For example, in Windows 7, for a user named `fergs`, the path is `C:\\Users\\fergs\\AppData\\Roaming\\MySqlDebuggerCache`.\n\nTwo threads are used, one for the debugger and one for the routine being debugged. The threads run in strict alternation, switching between the debugger and the routine as each statement is executed in the stored routine.\n\nBasic Debugging Operations\n\nThe debugger has the same look and feel as the standard Visual Studio debuggers for C#, VB.NET or C++. In particular, the following are true:\n\nLocals and Watches\n\n- To show the Locals tab, choose the menu item Debug, Windows, Locals.\nBasic Debugging Operations\n\nThe **Locals** tab lists all the variables available in the current scope: variables defined with `DECLARE` at any point in the routine, argument parameters, and session variables that are referenced.\n\n- If the last step operation changes the value of a local, its value will be highlighted in red (until another statement is executed or stepped).\n\n- You can change the value of any local.\n\n- To show the **Watch** tab, choose the menu item **Debug, Windows, Watch**.\n\n To define a watch, type any valid MySQL expression, optionally including function calls. If the watch evaluation makes sense in the current context (current stack frame), it will show its value, otherwise it will show an error message in the same row the watch was defined.\n\n- When debugging a trigger, in addition to any locals declared or session variables referenced, the new and old object (when applicable) will be listed. For example in a trigger for `INSERT`, for a table defined like:\n\n```sql\ncreate table t1( id int, myname varchar(50));\n```\n\nthe locals will list the extra variables `new.id` and `new.myname`. For an `UPDATE` trigger, you will also get the extra variables `old.id` and `old.myname`. These variables from the new and old objects can be manipulated the same way as any ordinary local variable.\n\n**Figure 5.63 Debugging a Trigger**\n\n---\n\n**Call Stack**\n\n- To show the **Call Stack** tab, choose the menu item **Debug, Windows, Call Stack**.\n\n- The stack trace (in the **Call Stack** tab) will list all the stack traces, one for each routine invocation. The one with a yellow mark is the current stepping point. Clicking in another will activate in the editor the tab for that routine source, highlighting in green the last statement stepped.\nStepping\n\n- Stepping of a new routine starts in the first executable instruction (excluding declares, handlers, cursor declarations, and so on).\nBasic Debugging Operations\n\nFigure 5.65 Debug Stepping\n\n```\nCREATE PROCEDURE `myTest`()\nbegin\n declare n int;\n set n = 1;\n while n < 5 do\n begin\n set n = n + 1;\n end\n end while;\nend\n```\n\nFigure 5.66 Function Stepping (1 of 2)\n\n```\nCREATE PROCEDURE `SimpleNonScalar`()\nbegin\n update CalcData set z = DoSum(x, y);\nend\n```\nBasic Debugging Operations\n\nFigure 5.67 Function Stepping (2 of 2)\n\n• To step into the code of a condition handler, the condition must be triggered in the rest of the MySQL routine.\n\n• The next statement to be executed is highlighted in yellow.\n\n• To continue stepping, you can choose between **Step Into** (by pressing F11), **Step Out** (by pressing F10) or **Step Over** (by pressing Shift + F11).\n\n• You can step out of any of functions, triggers or stored procedures. If you step from the main routine, it will run that routine to completion and finish the debug session.\n\n• You can step over stored procedure calls, stored functions, and triggers. (To step over a trigger, step over the statement that would cause the trigger to fire.)\n\n• When stepping into a single statement, the debugger will step into each individual function invoked by that statement and each trigger fired by that statement. The order in which they are debugged is the same order in which the MySQL server executes them.\n\n• You can step into triggers triggered from `INSERT`, `DELETE`, `UPDATE`, and `REPLACE` statements.\n\n• Also, the number of times you enter into a stored function or trigger depends on how many rows are evaluated by the function or affected by the trigger. For example, if you press F11 (**Step Into**) into an `UPDATE` statement that modifies three rows (calling a function for a column in the `SET` clause, thus invoking the function for each of the three rows), you will step into that function three times in succession, once for each of the rows. You can accelerate this debug session by disabling any breakpoints defined in the given stored function and pressing Shift + F11 to step out. In this example, the order in which the different instances of the stored function are debugged is server-specific: the same order used by the current MySQL server instance to evaluate the three function invocations.\n\n**Breakpoints**\n• To show the **Breakpoints** tab, choose the menu item **Debug, Windows, Breakpoints**.\n\n• The **Breakpoints** tab will show all the breakpoints defined. From here, you can enable and disable breakpoints one by one or all at once (using the toolbar on top of the **Breakpoints** tab).\n\n• You can define new breakpoints only in the middle of a debug session. Click in the left gray border of any MySQL editor, or click anywhere in a MySQL editor and press **F9**. In the familiar Visual Studio way, you press **F9** once to create a breakpoint in that line, and press it again to remove that breakpoint.\n\n• Once a breakpoint is defined, it will appear enabled (as filled red circle left to the current row if that line is a valid statement to put a breakpoint) or disabled (as a non-filled red circle left to the current row if that row is not valid to put a breakpoint).\n\n• To define conditional breakpoints, after creating the breakpoint, right click in the red dot and choose **Condition...**. There you can put any valid MySQL expression and state if the condition is **Is True** or **Has changed**. The former will trigger the breakpoint every time the condition is true, the latter every\ntime the condition value has changed. (If you define a conditional breakpoint, it is not enough to step into the line with the breakpoint defined to trigger such a breakpoint.)\n\nFigure 5.68 Conditional Breakpoints\nOther Features\n\nFigure 5.69 Expressions and Breakpoints\n\n- To define pass count breakpoints, after creating the breakpoint, right click in the red dot and choose Hit Count... In the pop-up dialog, define the specific condition to set. For example, break when the hit count is equal to and a value 3 will trigger the breakpoint the third time it is hit.\n\nOther Features\n\n- To abort the debug session (and the execution of the current call stack of routines), press **Shift + F5**.\n- To run the routine to completion (or until next breakpoint hit), press **F5**.\n- For all functionality you can use (in addition to the shortcuts documented), see the options in the **Debug** menu of Visual Studio.\n\nLimitations\n\n- Code being debugged must not use `get_lock` or `release_lock` MySQL functions, since they are used internally by the debugger infrastructure to synchronize the debugger and the debugged routine.\n- Code being debugged must avoid using any transaction code (**START TRANSACTION**, **COMMIT**, **ROLLBACK**) due to the possibility of wiping out the contents of the debugger tables. (This limitation may be removed in the future).\n- You cannot debug the routines in the **serversidedebugger** database.\n- The MySQL server running the routine being debugged can be any MySQL server version after 5.0, and running on any supported platform.\n- Always run debug sessions on test and development servers, rather than against a MySQL production server, because debugging can cause temporary performance issues or even deadlocks. The instrumented versions of the routines being debugged use locks that might not pertain to the rest of the production code.\nKeyboard Shortcuts\n\nThe following list summarizes the keyboard shortcuts for debugging:\n\n• F9 Toggles breakpoints\n• F11: Step into once\n• F10: Step over once\n• Shift + F11: Step out once\n• F5: Run\n• Shift + F5: Abort current debug session\n\n5.11 MySQL for Visual Studio Frequently Asked Questions\n\nQuestions\n\n• 5.11.1: How do I know if MySQL for Visual Studio is installed?\n\nQuestions and Answers\n\n5.11.1: How do I know if MySQL for Visual Studio is installed?\n\nOpen Visual Studio and go to View, Toolbars, and look for (and enable) the MySQL toolbar. Or, open MySQL Installer and look for the MySQL for Visual Studio product."}}},{"rowIdx":295,"cells":{"id":{"kind":"string","value":"aee77ba5ae4443abbfe3e5223e77a245dabc796c"},"text":{"kind":"string","value":"Armin Kösegi, Rainer Nerding\n\nSAP® Change and Transport Management\n\n- 3rd edition, completely revised and expanded with information on all releases from SAP R/3 4.6 to SAP EIM 6.0 SAP NetWeaver 7.0\n- Provides detailed information on Transport Organizer, Transport Management System, SAP Solution Manager, and NWDI\n- New chapters cover the enhanced Change and Transport System (CTS+), Java upgrades, Enhancement Packages, and more\n\nGalileo Press\nBonn • Boston\n# Contents at a Glance\n\n## PART I The Big Picture\n1. SAP ERP Architecture and Data Components .......................... 31\n2. Realizing Business Processes in SAP ERP ................................. 45\n3. The SAP ERP System Landscape ............................................ 67\n4. Managing Changes and Data in an SAP ERP System Landscape ................................................................. 109\n5. Setting Up a System Landscape .............................................. 139\n6. Maintaining a System Landscape ........................................... 167\n\n## PART II Technical Tasks\n7. Transport Setup Activities at Installation ................................. 213\n8. Setting Up the TMS ............................................................. 247\n9. Client Tools ........................................................................ 301\n\n## PART III Tools\n10. Managing Development Changes ............................................ 347\n11. Managing Customizing Changes ............................................ 409\n12. Releasing and Exporting Change Requests .............................. 455\n13. Importing Change Requests ................................................ 487\n14. Technical Insight into the Import Process ............................... 527\n15. SAP NetWeaver Development Infrastructure .......................... 573\n16. Enhanced Change and Transport System ................................ 617\n17. Maintaining SAP Software .................................................. 643\n18. SAP Software Release Upgrade ............................................ 719\n19. SAP Solution Manager ........................................................ 801\n\n## Appendices\nA. Transport Profile Parameters ............................................... 881\n## Contents\n\nForeword ........................................................................................................ 21\nIntroduction .................................................................................................... 23\n\n### PART I The Big Picture\n\n<table>\n<thead>\n<tr>\n<th>1 SAP ERP Architecture and Data Components</th>\n<th>..........</th>\n<th>31</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1.1 Client/Server Architecture in Brief</td>\n<td>........</td>\n<td>32</td>\n</tr>\n<tr>\n<td>1.2 The SAP ERP Database</td>\n<td>........................................</td>\n<td>35</td>\n</tr>\n<tr>\n<td>1.2.1 The Repository</td>\n<td>................................................</td>\n<td>35</td>\n</tr>\n<tr>\n<td>1.2.2 Customer Data</td>\n<td>................................................</td>\n<td>36</td>\n</tr>\n<tr>\n<td>1.2.3 Technical Implementation</td>\n<td>........................................</td>\n<td>37</td>\n</tr>\n<tr>\n<td>1.3 SAP ERP Clients</td>\n<td>..........................................................</td>\n<td>37</td>\n</tr>\n<tr>\n<td>1.3.1 Technical Implementation</td>\n<td>........................................</td>\n<td>38</td>\n</tr>\n<tr>\n<td>1.3.2 Data Components</td>\n<td>................................................</td>\n<td>39</td>\n</tr>\n<tr>\n<td>1.3.3 Standard SAP ERP Clients</td>\n<td>........................................</td>\n<td>42</td>\n</tr>\n<tr>\n<td>1.4 Questions</td>\n<td>..........................................................</td>\n<td>43</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>2 Realizing Business Processes in SAP ERP</th>\n<th>..........</th>\n<th>45</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>2.1 Customizing</td>\n<td>..........................................................</td>\n<td>46</td>\n</tr>\n<tr>\n<td>2.1.1 SAP ERP Reference Model</td>\n<td>........................................</td>\n<td>47</td>\n</tr>\n<tr>\n<td>2.1.2 Implementation Guide (IMG)</td>\n<td>........................................</td>\n<td>48</td>\n</tr>\n<tr>\n<td>2.2 Development</td>\n<td>..........................................................</td>\n<td>53</td>\n</tr>\n<tr>\n<td>2.2.1 ABAP Workbench</td>\n<td>................................................</td>\n<td>54</td>\n</tr>\n<tr>\n<td>2.2.2 Customer-Developed Repository Objects</td>\n<td>........................................</td>\n<td>55</td>\n</tr>\n<tr>\n<td>2.2.3 Enhancements</td>\n<td>................................................</td>\n<td>56</td>\n</tr>\n<tr>\n<td>2.2.4 Modifications</td>\n<td>................................................</td>\n<td>59</td>\n</tr>\n<tr>\n<td>2.3 Questions</td>\n<td>..........................................................</td>\n<td>63</td>\n</tr>\n</tbody>\n</table>\n\n<table>\n<thead>\n<tr>\n<th>3 The SAP ERP System Landscape</th>\n<th>.........................</th>\n<th>67</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>3.1 SAP ERP Client Roles</td>\n<td>..........................................................</td>\n<td>68</td>\n</tr>\n<tr>\n<td>3.1.1 Critical Client Roles</td>\n<td>........................................</td>\n<td>68</td>\n</tr>\n<tr>\n<td>3.1.2 Additional Client Roles</td>\n<td>........................................</td>\n<td>71</td>\n</tr>\n</tbody>\n</table>\nContents\n\n3.2 Defining an SAP Client .................................................. 74\n 3.2.1 Client-Dependent Change Option ............................. 75\n 3.2.2 Client-Independent Change Option ............................ 77\n3.3 Multiple Clients in an SAP ERP System ......................... 79\n 3.3.1 Functional Limitations ........................................ 79\n 3.3.2 Technical Limitations .......................................... 80\n 3.3.3 Protective Measures for Multiple-Client Operations .......... 81\n3.4 The SAP Three-System Landscape .................................. 82\n 3.4.1 Standard SAP Systems ........................................ 82\n 3.4.2 Distribution of Client Roles .................................. 83\n3.5 Alternative System Landscapes ................................... 86\n 3.5.1 One-System Landscape ....................................... 86\n 3.5.2 Two-System Landscape ....................................... 87\n 3.5.3 Four-System Landscape ...................................... 89\n3.6 Complex System Landscapes ...................................... 89\n 3.6.1 Multiple Production System Landscape .................... 90\n 3.6.2 Phased System Landscape ................................... 94\n 3.6.3 Global System Landscape ................................... 100\n3.7 Questions .................................................................. 105\n\n4 Managing Changes and Data in an SAP ERP System Landscape .................................................. 109\n\n 4.1 Transporting Customizing and Development Changes ... 109\n 4.1.1 Change Requests and Tasks ................................. 110\n 4.1.2 Preparing Changes .......................................... 114\n 4.1.3 Importing Changes .......................................... 117\n 4.1.4 Change and Transport System (CTS) .................... 122\n 4.2 Transferring Data .................................................... 124\n 4.2.1 Master Data ................................................... 125\n 4.2.2 Transaction Data ............................................. 128\n 4.2.3 User Master Data ............................................ 131\n 4.3 Copying SAP ERP Systems and Clients ....................... 134\n 4.3.1 System Copy .................................................. 134\n 4.3.2 Client Copy .................................................. 135\n 4.4 Questions .................................................................. 136\n## Contents\n\n### 5 Setting Up a System Landscape ................................. 139\n\n*5.1 Setting Up the Development System .................................. 139*\n *5.1.1 Post-Installation Processing ................................ 140*\n *5.1.2 Setting Up the Transport Management System (TMS) ........................................ 141*\n *5.1.3 Creating Clients .................................................. 142*\n\n*5.2 Setting Up the Quality Assurance and Production Systems ....................................................... 146*\n *5.2.1 After Installing the New SAP System .......................... 147*\n *5.2.2 Change Request Strategy ....................................... 148*\n *5.2.3 Quality Assurance Procedure of the TMS ................. 151*\n *5.2.4 Client Copy Strategy ........................................... 153*\n\n*5.3 System Copy Strategy .................................................... 158*\n *5.3.1 System Copy of Quality Assurance ........................... 159*\n *5.3.2 Cleaning Up after a System Copy ............................. 160*\n\n*5.4 Release Considerations ................................................ 162*\n\n*5.5 Questions .............................................................. 165*\n\n### 6 Maintaining a System Landscape ................................. 167\n\n*6.1 Implementation Plan .................................................... 168*\n\n*6.2 Managing Implementation Projects ................................. 170*\n *6.2.1 Implementation Phases ........................................ 170*\n *6.2.2 Managing Change Requests ................................... 172*\n *6.2.3 Unit Testing ...................................................... 175*\n *6.2.4 Releasing and Exporting Change Requests ................ 177*\n\n*6.3 Transport Management .................................................. 179*\n *6.3.1 Exporting Change Requests ................................... 180*\n *6.3.2 Importing Change Requests .................................. 181*\n *6.3.3 Post-Import Issues ............................................. 188*\n *6.3.4 Importing into the Production System .................... 190*\n\n*6.4 Business Validation ..................................................... 197*\n *6.4.1 Testing Procedures .............................................. 197*\n *6.4.2 SAP Testing Tools .............................................. 199*\n\n*6.5 Support for the SAP Standard ....................................... 202*\n *6.5.1 Support for an SAP Release .................................. 202*\n *6.5.2 Release Upgrades ............................................... 207*\n\n*6.6 Questions .............................................................. 208*\nPART II Technical Tasks\n\n7 Transport Setup Activities at Installation .......... 213\n\n7.1 Specifying the System ID (SID) .......... 213\n7.2 Setting Up the Transport Directory .......... 214\n 7.2.1 One or Many Transport Directories? .......... 216\n 7.2.2 Transport Directory Structure .......... 217\n 7.2.3 Procedure .......... 219\n7.3 Configuring a Transport Profile .......... 225\n 7.3.1 Transport Profile as of R/3 Release 4.5 .......... 225\n 7.3.2 Profile Syntax .......... 228\n 7.3.3 Required Parameters .......... 231\n7.4 Activities within SAP ERP .......... 238\n 7.4.1 Initializing the Change and Transport\n Organizer (CTO) .......... 239\n 7.4.2 Setting the Global System Change Option .......... 240\n 7.4.3 Verifying Required Background Jobs .......... 243\n 7.4.4 Verifying Background Work Processes .......... 244\n7.5 Questions .......... 244\n\n8 Setting Up the TMS .......... 247\n\n8.1 TMS Terminology and Concepts .......... 247\n 8.1.1 Transport Domain .......... 248\n 8.1.2 Transport Routes .......... 251\n8.2 Setting Up the Transport Domain .......... 254\n 8.2.1 Setting Up the Domain Controller .......... 255\n 8.2.2 Extending the Transport Domain .......... 257\n 8.2.3 Backup Domain Controller .......... 264\n 8.2.4 Verifying the Transport Domain .......... 266\n 8.2.5 Technical Aspects of the Configuration Process .......... 270\n8.3 Configuring Transport Routes .......... 276\n 8.3.1 Procedure .......... 276\n 8.3.2 Extending and Changing a Transport Route\n Configuration .......... 281\n 8.3.3 Extended Transport Control .......... 288\n8.4 Verifying the System Landscape Setup .......... 294\n 8.4.1 Verifying the TMS Setup .......... 295\n## Contents\n\n10.2.6 Recording Repository Objects to Change Requests .......................................................... 370\n10.2.7 Object List of Change Requests and Tasks .......................... 372\n10.3 Repairs and Modifications ............................................ 378\n 10.3.1 Setting the Repair Flag ..................................... 379\n 10.3.2 Modification Assistant ...................................... 379\n 10.3.3 Modification Browser ....................................... 381\n 10.3.4 Modifications ................................................... 381\n10.4 SAP Enhancement Concept ........................................... 384\n10.5 The Object Directory .................................................... 398\n 10.5.1 Object Attributes ............................................. 400\n 10.5.2 Displaying or Changing an Object Directory Entry ..................................................... 401\n 10.5.3 Transporting Objects Using the Transport Organizer (Extended View) ...................... 403\n10.6 Questions ..................................................................... 406\n\n11 Managing Customizing Changes ................................. 409\n 11.1 Customizing Prerequisites ........................................... 409\n 11.2 Customizing Change Requests ............................................. 413\n 11.2.1 Viewing Customizing Change Requests ............. 414\n 11.2.2 Creating Customizing Change Requests ............ 415\n 11.2.3 Customizing in Project IMGs ............................ 418\n 11.2.4 Recording Customizing Changes ....................... 421\n 11.2.5 Object Lists for Customizing Change Requests ... 424\n 11.2.6 Identifying Change Requests with the Same Object ................................................. 427\n 11.3 Nonstandard Customizing Activities .............................. 429\n 11.3.1 Client-Independent Customizing Activities ...... 429\n 11.3.2 Manual Transports and Other Transport Types .. 433\n 11.3.3 Customizing in a Production Client .................... 435\n 11.4 Support Tools for Customizing ...................................... 436\n 11.4.1 Comparing Customizing in Two Clients .......... 437\n 11.4.2 Single comparison with Transaction SCMP .......... 446\n 11.4.3 Business Configuration Sets .............................. 448\n 11.4.4 Customizing Transfer Assistant ......................... 449\n 11.5 Questions ..................................................................... 452\n12 Releasing and Exporting Change Requests .......... 455\n\n12.1 Documenting Change Requests and Tasks .......... 456\n 12.1.1 Creating and Changing Documentation ........ 456\n 12.1.2 Action Logs for Change Requests .............. 457\n12.2 Unit Testing .................................................... 458\n 12.2.1 Client-Dependent Customizing ................. 458\n 12.2.2 SAPscript Styles and Forms .................... 460\n 12.2.3 Report Variants ........................................ 461\n12.3 Releasing a Task .............................................. 462\n 12.3.1 Release Errors ....................................... 462\n 12.3.2 Impact on the Change Request ................... 463\n12.4 Releasing a Change Request .............................. 465\n 12.4.1 Merging Change Requests ......................... 466\n 12.4.2 Procedure for Releasing a Change Request ...... 467\n 12.4.3 The Export Process ................................ 472\n 12.4.4 Authorizations ....................................... 475\n12.5 Transport Logs ................................................ 476\n 12.5.1 Managing Transport Logs ......................... 478\n 12.5.2 Displaying Transport Errors at Logon ............ 478\n12.6 Versioning for Repository Objects .................. 480\n 12.6.1 Version Management ................................. 481\n 12.6.2 Versions in Nondevelopment Systems .......... 483\n12.7 Questions ..................................................... 484\n\n13 Importing Change Requests ................................. 487\n\n13.1 Understanding Import Queues ......................... 487\n 13.1.1 Import Overview ................................... 488\n 13.1.2 Import Queue ....................................... 490\n13.2 Performing Imports .......................................... 495\n 13.2.1 Before Performing Imports ...................... 495\n 13.2.2 Import All ........................................... 497\n 13.2.3 Preliminary Imports ................................. 499\n13.3 Managing Import Queues ................................. 502\n 13.3.1 Forwarding a Change Request .................... 502\n 13.3.2 Deleting a Change Request from an Import Queue ......................................................... 503\n14.5 Understanding Transport Tools ................................................ 560\n 14.5.1 The Transport Program R3trans ........................................ 560\n 14.5.2 ABAP Programs .............................................................. 563\n14.6 Questions ........................................................................... 569\n\n15 SAP NetWeaver Development Infrastructure ............... 573\n 15.1 The SAP NetWeaver Application Server Structure ........... 573\n 15.2 Overview of the Java Development Process ................... 575\n 15.3 Parts of the SAP NetWeaver Development\n Infrastructure ................................................................ 580\n 15.4 Configuration of the SAP NetWeaver Development\n Infrastructure ................................................................ 584\n 15.4.1 Local Development Environment ............................ 584\n 15.4.2 Overview of the Different Development\n Scenarios ................................................................ 585\n 15.5 Configuration of the SAP NetWeaver Development\n Infrastructure ................................................................ 592\n 15.5.1 Configuration of the System Landscape\n Directory .................................................................. 593\n 15.5.2 Setting Up Users and Authorizations ....................... 597\n 15.5.3 Setting Up SAP NetWeaver Developer Studio ............ 599\n 15.5.4 Creating Products and Software Components ........ 600\n 15.5.5 Creating a Domain and Track in the Change\n Management Service ................................................ 602\n 15.5.6 Creating a Development Component ...................... 605\n 15.6 Developing in the SAP NetWeaver Development\n Infrastructure ................................................................ 605\n 15.6.1 Creating a J2EE Application ..................................... 607\n 15.6.2 Creating a Local Build and Carrying Out the\n Local Tests .................................................................. 608\n 15.6.3 Check-in of Changes ............................................... 608\n 15.6.4 Activation in the CBS, Central Deployment,\n and Central Test ...................................................... 610\n 15.6.5 Release of Changes to the Consolidation\n System .................................................................... 611\n 15.7 Transporting Java Projects ................................................. 611\n 15.8 Summary ........................................................................... 614\n 15.9 Questions ........................................................................... 615\n# 16 Enhanced Change and Transport System\n\n- **16.1 Overview and Architecture** ........................................... 619\n- **16.2 Performing Transports for Non-ABAP Objects** ............... 621\n - **16.2.1 Export of a Portal Development from the Portal Content Studio** ................................................. 622\n - **16.2.2 Transport Organizer Web UI** ............................. 623\n - **16.2.3 Import Transport Requests with Non-ABAP Objects** ............................................................ 627\n- **16.3 Configuration of the Enhanced Change and Transport System** .......................................................................... 627\n - **16.3.1 Setting up the ABAP Stack** ............................... 628\n - **16.3.2 Setting up the Java Stack** .................................. 629\n - **16.3.3 Setting up the TMS System Landscape** .............. 629\n - **16.3.4 Configuration Parameters for Non-ABAP Source Systems** ........................................................ 632\n - **16.3.5 Configuration Parameters for Non-ABAP Target Systems** ........................................................... 632\n - **16.3.6 Connection of the Development Environment to the Transport System (Close Coupling)** ........ 633\n- **16.4 CTS+ Transport Landscapes** ........................................... 635\n - **16.4.1 Non-ABAP System** ............................................ 635\n - **16.4.2 Dual-Stack System** ............................................ 637\n - **16.4.3 Combined CTS+ Applications** ....................... 638\n- **16.5 Questions** ..................................................................... 640\n\n# 17 Maintaining SAP Software\n\n- **17.1 Making Manual Corrections on the Basis of SAP Notes** ... 644\n - **17.1.1 SAP HotNews** ................................................... 644\n - **17.1.2 SAP TopNotes** .................................................. 646\n- **17.2 Implementing Notes with the SAP Note Assistant** ......... 647\n - **17.2.1 Registering Manually-Implemented Notes** ........ 648\n - **17.2.2 Processing Notes** .............................................. 649\n - **17.2.3 Implementation Status and Processing Status of Notes** ........................................................... 667\n- **17.3 ABAP Support Packages** ............................................... 669\n - **17.3.1 Applying ABAP Support Packages** ............... 671\n - **17.3.2 Modification Adjustment** .................................. 696\n17.4 Java Corrections ............................................................ 697\n 17.4.1 Java Correction Types ............................................ 697\n 17.4.2 Version Information of a Java System .................. 700\n 17.4.3 Java Support Package Manager (JSPM) ............... 701\n 17.4.4 Importing Java Support Packages ...................... 705\n17.5 Support Package Stacks ................................................. 707\n 17.5.1 SP Stack Strategy with the Usual Import Procedure ........................................ 709\n 17.5.2 Cross-System Support Package Stacks ............... 712\n 17.5.3 Details of the Components in SAP Support Package Stacks ................................ 712\n 17.5.4 SP Stack Calendar ............................................. 714\n17.6 Side Effects .............................................................. 715\n17.7 Questions ................................................................... 717\n\n18 SAP Software Release Upgrade ................................... 719\n\n 18.1 Lifecycle of an SAP Production System ..................... 719\n 18.1.1 SAP Release and Maintenance Strategy .......... 720\n 18.1.2 Upgrade Motivation ....................................... 722\n 18.2 Release Change Process ............................................ 724\n 18.2.1 SAP System Switch Upgrade Procedure .......... 728\n 18.2.2 SAP System Switch Upgrade in Detail .......... 730\n 18.3 Modification Adjustment .......................................... 735\n 18.3.1 Modification Adjustment During Release Changes ........................................ 739\n 18.3.2 Modification Adjustment During the Import of Support Packages ....................... 742\n 18.3.3 Modification Assistant .................................. 745\n 18.4 Upgrade Strategies for a Transport Landscape .......... 747\n 18.4.1 Release Change in a Three-System Landscape .... 748\n 18.4.2 Release Change with an Additional Development System .................................. 749\n 18.4.3 Release Change with Five Systems .................. 750\n 18.5 SAP Enhancement Packages ....................................... 754\n 18.5.1 Implementation Activities for SAP Enhancement Packages .................................. 756\n 18.5.2 Technical Implementation ............................... 761\nContents\n\n18.6 Upgrades and Unicode .................................................. 768\n 18.6.1 CU&UC ............................................................ 775\n 18.6.2 TU&UC ............................................................. 776\n 18.6.3 Unicode Hardware Requirements ..................... 777\n 18.6.4 Unicode Transports ........................................... 779\n\n18.7 Java Upgrade ............................................................... 780\n\n18.8 Additional Recommendations for a Release Change ..... 786\n 18.8.1 Upgrade Tools and SAP Upgrade Service Offers ... 786\n 18.8.2 Other Recommendations ................................. 794\n\n18.9 Questions ..................................................................... 798\n\n19 SAP Solution Manager ..................................................... 801\n\n 19.1 Customizing Synchronization ........................................ 805\n 19.1.1 Customizing Distribution ................................ 806\n 19.1.2 The Customizing Scout .................................. 811\n 19.1.3 Creating and Loading Synchronization Objects ... 819\n\n 19.2 Change Request Management ...................................... 821\n 19.2.1 Change Request Management Workflow ........... 824\n 19.2.2 Architecture .................................................. 826\n 19.2.3 Project Cycles ............................................... 828\n 19.2.4 Task List ........................................................ 832\n 19.2.5 Change Management Work Center ................... 833\n 19.2.6 Change Request .............................................. 834\n 19.2.7 Change Types ............................................... 836\n 19.2.8 Change Tracking ............................................ 839\n\n 19.3 Change Analysis ........................................................ 842\n 19.3.1 Features ....................................................... 843\n 19.3.2 Performing an Analysis ............................... 843\n 19.3.3 Architecture ............................................... 848\n\n 19.4 SAP Maintenance Optimizer ......................................... 851\n 19.4.1 Features ....................................................... 851\n 19.4.2 Integration with other Tools ......................... 852\n 19.4.3 Setting up Maintenance Optimizer ............... 853\n 19.4.4 Import of Support Packages ..................... 854\n 19.4.5 Import of Enhancement Packages .............. 861\n 19.4.6 Reporting for Maintenance Procedures .......... 864\n\n 19.5 Upgrade Support .......................................................... 865\n\n 19.6 Questions ..................................................................... 875\nAppendices ........................................................................ 881\nA Transport Profile Parameters .................................................. 881\nB Selected Transaction Codes ...................................................... 899\nC Glossary ............................................................................... 905\nD Questions and Answers .......................................................... 933\n D.1 Chapter 1: SAP ERP Architecture and Data\n Components .......................................................................... 933\n D.2 Chapter 2: Realizing Business Processes in SAP ERP ...... 934\n D.3 Chapter 3: The SAP ERP System Landscape ................. 937\n D.4 Chapter 4: Managing Changes and Data in an SAP\n ERP System Landscape .......................................................... 940\n D.5 Chapter 5: Setting Up a System Landscape .................... 942\n D.6 Chapter 6: Maintaining a System Landscape ................ 944\n D.7 Chapter 7: Transport Setup Activities at Installation .... 946\n D.8 Chapter 8: Setting Up the TMS ..................................... 948\n D.9 Chapter 9: Client Tools .................................................. 950\n D.10 Chapter 10: Managing Development Changes ............. 952\n D.11 Chapter 11: Managing Customizing Changes ............... 953\n D.12 Chapter 12: Releasing and Exporting Change Requests ... 955\n D.13 Chapter 13: Importing Change Requests ..................... 957\n D.14 Chapter 14: Technical Insight—the Import Process ...... 959\n D.15 Chapter 15: SAP NetWeaver Development\n Infrastructure ......................................................................... 962\n D.16 Chapter 16: Enhanced Change and Transport System ... 964\n D.17 Chapter 17: Maintaining SAP Software ....................... 965\n D.18 Chapter 18: SAP Software Release Upgrade ............... 968\n D.19 Chapter 19: SAP Solution Manager ............................... 970\nE Literature ............................................................................... 973\n E.1 SAP Online Help ............................................................. 973\n E.2 SAP Training Courses ..................................................... 973\n E.3 SAP Developer Network (SDN) ..................................... 974\n E.4 SAP Service Marketplace ............................................... 974\n E.5 Bibliography ................................................................... 974\nF Authors .................................................................................. 977\nIndex ......................................................................................... 979\nSAP provides several methods to correct errors that have occurred in your SAP system. This chapter describes these methods, the contents of the changes involved, and recommendations for project implementation.\n\n17 Maintaining SAP Software\n\nIn this chapter, you will learn about the software maintenance strategies and tools provided by SAP and, in particular, about Support Packages and SAP Notes. Support Packages correct all errors that have been identified within a specific time period in a system, whereas SAP Notes correct individual errors as they occur. This chapter also explains the modification adjustment steps you need to take when importing Support Packages.\n\nThe tools discussed in this chapter are as follows.\n\n- The Note Assistant (Transaction SNOTE), used to import Notes with code corrections.\n- The SAP Patch Manager (Transaction SNOTE), used to import Support Packages.\n- The SAP Add-on Installation Manager (Transaction SAINT), used to import add-ons and delta upgrades.\n- The SAP Java Support Package Installation Manager, used to import Java Packages.\n\nThis chapter is intended primarily for system administrators and technical consultants who are responsible for maintaining and updating an SAP ERP system landscape. Nonetheless, project leads and strategic consultants will also benefit from this information because it is helpful for planning package upgrades and for estimating the time and staff costs involved. Experience shows that the main factors causing difficulties in\nSupport Package implementation projects are the required downtime, the time and effort necessary for testing, and the indispensable code freeze. Section 17.3 addresses these aspects, and also describes the benefits gained from importing Support Packages.\n\nSection 17.4 focuses on the maintenance of Java-based systems in particular, which in many respects is different from the maintenance of ABAP systems.\n\n### 17.1 Making Manual Corrections on the Basis of SAP Notes\n\nIf a specific problem occurs with the SAP ERP software and this problem is corrected, details of the correction are published in an SAP Note. The correction is also included in the next Support Package.\n\nIf the problem is particularly urgent, you may not be able to wait for the Support Package and will have to manually make the correction with the help of an SAP Note.\n\nSAP provides the SAP Note Assistant to enable customers to import SAP Notes. This tool considerably reduces the amount of manual work required to implement the Note and make modification adjustments later on.\n\nParticularly important Notes—such as those about faults with serious consequences including system downtime and data inconsistencies—are classified as HotNews and are published on the SAP Service Marketplace.\n\n#### 17.1.1 SAP HotNews\n\nSAP HotNews items are SAP customer Notes with Priority 1 (very high). These Notes contain the solutions to problems that could cause a system breakdown or data loss in the SAP system. Therefore, if one of\nthese Notes applies to your system, it is very important that you take it seriously.\n\nThe new SAP HotNews process enables you to display only HotNews items that are relevant to your areas. The shared personalization interface for SAP HotNews and SAP TopNotes (see the text that follows) allows you to create multiple filters for the applications you use (such as SAP ERP or SAP CRM). Using the filter maintenance functions, you can select your products (such as SAP ERP), product versions (such as SAP R/3 4.6C), software components (such as SAP Basis 4.6C), and Support Packages, and the system returns only the HotNews items that are relevant to your criteria.\n\nSAP HotNews items are located in the SAP Service Marketplace under the /notes Quick Link: http://service.sap.com/notes. (You need a Service Marketplace user to be able to view this content.)\n\nYou can also have the SAP HotNews that are of interest to you emailed to you in the SAP Service Marketplace newsletter. To subscribe to the relevant topic area—News for Administrators (incl. SAP HotNews)—of the SAP Service Marketplace newsletter, you need to configure the required settings in the SAP Service Marketplace under My Profile. You will then be informed automatically as soon as there is a new SAP HotNews item that is relevant to your settings.\n\nIf you receive an SAP HotNews item with information that is extremely important for the operation of your SAP system, you should confirm receipt of this item in the SAP Service Marketplace. When you do so, this HotNews item is no longer displayed to you. SAP is also notified that you have read the HotNews item and that you have taken the recommended measures.\n\nAs an SAP system administrator, you should regularly review all SAP HotNews items, or ensure that this is done and, if necessary, proactively implement applicable items in your system. Figure 17.1 shows the SAP HotNews Browser in the SAP Service Marketplace.\nSAP TopNotes are the most important SAP Notes in a component or sub-component (such as FI-AR). These are the Notes that are most frequently attached to customer problem messages. Every month, the system identifies the ten most common messages for the component in question. Then, the TopNotes are checked manually, and other important SAP Notes can be added to them or replace them. This concept is described in detail in Note 557703.\n\nSAP TopNotes are also located in the SAP Service Marketplace under the /notes Quick Link (http://service.sap.com/notes). As with SAP HotNews, you can also be notified of new SAP TopNotes by email.\n17.2 Implementing Notes with the SAP Note Assistant\n\nThe SAP Note Assistant (Transaction SNOTE, see Figure 17.2) can automatically implement Notes that contain corrections to source code. Other changes, such as Customizing changes or changes to a table cannot be automatically implemented. Always make sure to read the Note carefully before implementing it using the Note Assistant. It may contain information about prerequisites, interdependencies, and references to clean-up steps you’ll need to consider in the implementation process.\n\n\n\nThe Note Assistant provides the following functions:\n\n- **Reporting**\n Provides an overview of the existing Notes and their processing status, and of all the source-code corrections that have been implemented to date.\n**Project administration**\nAllows you to assign Notes to processors, which can then set the processing status. The system notifies you if a Note has an inconsistent status.\n\n**Retraceability**\nMeans that the system automatically logs the processing steps.\n\n**Error correction**\nEnables you to automatically implement source-code corrections (correction instructions) that are described in Notes.\n\n**Integration**\nWhen Support Packages or upgrades are imported, the system automatically identifies the Notes that the Support Package or upgrade resolves and which correction instructions have to be reimplemented.\n\n### 17.2.1 Registering Manually-Implemented Notes\n\nIf you implemented corrections from Notes in your SAP system before installing the Note Assistant, you can retroactively “notify” the Note Assistant of this fact. Because the Note Assistant cannot automatically determine whether a Note correction was implemented in your system manually (that is, without the use of the Note Assistant), this is important to do. Proceed as follows:\n\n1. In the ABAP Editor (Transaction SE38), call the program `SCWN_REGISTER_NOTES`.\n2. In the program’s input screen, enter the numbers of the Notes you want to register and that have been fully implemented.\n3. This can cause the following situations to occur:\n - If you created a Remote Function Call (RFC) connection to the SAP-Net-R/3 frontend, the program automatically loads the Notes to be registered into your system’s database.\n - If you did not create an RFC connection, first load the Notes to be registered from the SAP Service Marketplace. Then, upload the Notes in the Note Assistant.\n4. The program checks whether the Notes are valid for your release and Support Package level. It also verifies whether the Notes are already registered as having been implemented in the Note Assistant. The system then outputs the results of these checks to a list.\n\n5. To register the Note, select **Program • Execute**.\n\nTo be able to register the Note as implemented, the system has to enter the details of the Note and the objects it corrected in a change request. When you transport this request, you are registering the Note as implemented, even in your downstream systems. If it is not possible to include the Note and its objects in one request—because, for example, some objects have already been locked in other requests—the system will reject the registration.\n\n### 17.2.2 Processing Notes\n\nTo correct an error in a program using the Note Assistant, proceed as follows:\n\n1. Load the Note into your system. During the loading process, the Note Assistant checks whether the characteristics of the Note (software component, release level, and Support Package level) match those of your system. It then states whether the corrections can be implemented.\n\n Only Notes with source-code corrections (correction instructions) can be automatically implemented.\n\n2. Read the Note description carefully.\n\n The Note description may contain information about prerequisites and interdependencies, and references to post-processing steps (for example, changes that need to be made to a table), which the Note Assistant does not automatically recognize. If you do not read and, if required, act upon this information, serious problems can result. It is therefore absolutely imperative that you read the Note before you start the implementation.\n\n3. Determine whether the Note is relevant to you. Classify the Note in accordance with the processing status.\n4. Implement the correction.\n5. Carry out any post-processing steps that may be specified in the Note.\n6. Test whether the error has been successfully corrected.\n7. Set the processing status to COMPLETED.\n8. Release the transport request and import the corrections into the downstream systems in your system landscape.\n\n**Search Note**\n\nThe Note Browser enables you to search through all SAP Notes in your system. It also displays Notes that are assigned to another processor and Notes that have already been implemented. Proceed as follows:\n\n1. Select a search criterion for the Note:\n - Note number\n - Application component\n - Processing status\n - Implementation status\n - Processor\n\n2. Select which option you require:\n - Restrict the selection process to certain software components and their releases.\n - Sort the Notes according to their number or the application component to which they belong.\n\n3. Confirm your selection.\n\nThe Note Browser then displays a list of the Notes that match your criteria, including their Note number, short text, component, processing status, implementation status, and user (see Figure 17.3). You can also implement Notes directly from the Note Browser.\nImplementing Notes with the SAP Note Assistant\n\n17.2\n\nThe Note Browser\n\nFigure 17.3 The Note Browser Displays All Notes That Have Been Implemented Using the SAP Note Assistant\n\nLoad Note\n\nYou can load SAP Notes into your system from the SAP Service Marketplace or the SAPNet-R/3 frontend, using either a direct RFC connection (Note download) or by file transfer (Note upload). Note download has the following benefits:\n\n- You can transfer the Note in the Note Assistant from the SAPNet-R/3 frontend directly to your system.\n- If the Note in question specifies other Notes as prerequisites, the Note Assistant automatically downloads these in the implementation process.\n- You can download updated versions of the Notes with the touch of a button.\n\nTo download a Note, you must create an RFC connection to the SAPNet-R/3 frontend. To upload a Note, a permanent RFC connection to the\nSAPNet-R/3 frontend is not necessary. Instead, first load the required Note from the SAP Service Marketplace and save it locally on your PC. Then, upload the Note from inside the Note Assistant.\n\nTo download a Note, proceed as follows:\n\n1. Select **GoTo • Download SAP Note** in the Note Assistant.\n2. Enter the numbers of the Notes you want to download. You can use the selection function to select individual Notes or a list of Notes.\n3. Confirm your selection. The system then loads the matching Notes from the SAPNet-R/3 frontend into your database.\n\nFor Note Upload to be available, the SAP Download Manager must be installed on your computer. Notes can then be downloaded from the SAP Service Marketplace. For more information on the SAP Download Manager, see the SAP Service Marketplace at [service.sap.com/swcenter](http://service.sap.com/swcenter). Proceed as follows:\n\n1. Select the Note in question from the SAP Service Marketplace under [service.sap.com/notes](http://service.sap.com/notes).\n2. Select **Download**. The Note is added to your Download Basket. Repeat this process as many times as necessary.\n3. To save the selected Notes to your local PC, start the SAP Download Manager. Select **Download**. The Notes are saved as files to the local directory you specified.\n4. In the Note Assistant, load the Note files into your system using the Note Upload function (**GoTo • Upload SAP Note**).\n\nAfter you have successfully downloaded or uploaded a Note that was not previously in your system, it is listed with processing status **NEW**.\n\n**Classify Note**\n\nClassifying a Note allows you to specify the relevance or processing status of a Note. Read the Note carefully and decide whether its content is relevant to the situation in your system. Then proceed as follows:\n\n1. If the Note is relevant, set its status to **IN PROCESSING** (see Figure 17.4). This informs other users that you are already processing this Note.\n2. Closely follow the recommendations given in the Note. If the Note contains a correction instruction, implement it in your system.\n\n3. If you want to assign the Note to another processor, enter the user name of the processor.\n\nAll of your actions are recorded in the log file for the Note. You can also enter additional comments in the log file, for instance, information you may want to pass on to another user.\n\nIf the Note is not relevant to you, set the processing status to **Not Relevant**. This signals to you and all other users that this Note can be disregarded.\n\n**Implement Correction Instruction**\n\nA function exists that implements the correction instruction contained in a Note. If you have previously modified the object that is the subject of a correction instruction, you can also adapt the correction to your modifications.\n\nTo implement the correction instruction of a Note in your system, proceed as follows:\n\n1. Place the cursor on the title of the Note in the initial screen of the Note Assistant and select **SAP NOTE • IMPLEMENT SAP NOTE**. First, the system checks which correction instruction from the Note is appropriate for your release and Support Package level. It then checks whether any corrections from other Notes are a prerequisite to the implemen-\nuy the system displays these in a dialog box.\n\n- If you have an RFC connection to the SAPNet-R/3 frontend, you can automatically download these Notes by confirming the dialog box.\n\n- Otherwise, load them from the SAP Service Marketplace and then upload them using the Note Assistant.\n\nIf the prerequisite Notes are relevant to your system, they are then displayed in the order in which they need to be implemented (see Figure 17.5). If possible, the system implements all prerequisite Notes in one step.\n\nRead the prerequisite Notes as carefully as you would any other Notes. If any prerequisite Notes are not relevant (for example, because they have already been imported in a Support Package), the Note Assistant automatically assigns the correct status to them and does not display them in the list. To view these Notes, call the Notes Browser and select the Not Relevant processing status.\n\n2. Before the system corrects the objects, it opens a dialog box in which you can select the change request.\n\n - Either select a suitable change request, or create a new one.\n\n The Note (R3TR NOTE), including all correction instructions (R3TR CINS) and all changed objects, is entered into the request. The transport request then transports all corrections to the downstream systems.\nNote that all objects to be corrected, plus details of the Note, must be entered in a request. This is the only way to ensure that the corrections are transported in their entirety to the downstream systems.\n\nNo SSCR key is required for automatically implementing Note corrections.\n\n3. A dialog box opens that lists all of the objects to be changed. A traffic light icon shows whether the system can automatically implement the correction.\n\nClick on the object name to open an editor. The editor shows you the changes in detail.\n\nIf you previously modified the objects to be corrected, the Note will have a yellow traffic light. You can then adapt the corrections to suit your modifications (also see the section “Split-Screen Editor”).\n\nIf you make manual changes when implementing Notes, the system cannot judge whether the corrections have been implemented properly. Therefore, you must confirm in a separate dialog box that the corrections can be classified in the system as fully implemented (see figure 17.6).\n\nIf the system cannot automatically implement a correction, even though the objects in question were not previously modified, you should first attempt to import the Note using the split-screen editor. In many cases, minor differences in the source code cause the automatic implementation to fail. If the implementation still doesn’t\nwork, it is probably because the Note contains an error of some sort. If this happens, contact SAP Support by creating a problem message under the Note’s component (for example, FI-AR-CR).\n\n4. Check that the corrected objects do not contain any syntax errors. This is particularly important if they also contain customer-specific modifications. Note that currently the system can automatically implement only source-text changes. If any other changes are required (changes to Dictionary objects, for example), they are described in the Note text and must be manually implemented in your system.\n\n5. After implementing the corrections, test the function in question to ensure that it has been fully corrected by the Note.\n\nYou can display all objects that were corrected by the Note; simply select GoTo • CORRECTED OBJECTS to call the modification browser.\n\n6. Set the processing status to COMPLETED.\n\nIn exceptional cases, you can remove correction instructions that you have implemented. This undoes all implemented changes. The Note in question remains in your system and is reset to the status it had prior to it being implemented. To remove certain correction instructions, select SAP NOTE • RESET SAP NOTE IMPLEMENTATION.\n\n7. After you have solved your problem via the Note, release the change request that was created when you implemented the correction instruction. This transports the corrections and the Note data to the downstream systems in your system landscape.\n\nIf a particular Note has prerequisite Notes, the Note Assistant identifies these when the Note is being implemented and instructs you to load them into your system. As soon as the prerequisite Notes are available, the Note Assistant displays the Note you selected along with all additional Notes in a dialog box called the Note queue (see Figure 17.7). The Notes have to be implemented in the order shown in the Note queue. Before you start the implementation process, read the prerequisite Notes as carefully as you would any other Notes.\nImplementing Notes with the SAP Note Assistant\n\n17.2\n\nImplementing a Note Queue\n\nYou have the following options:\n\n- **Implement multiple Notes in one step**\n The system implements as many of the specified Notes as possible, in one step, in sequence. The Notes that can be implemented at the same time are highlighted in color.\n\n The system can implement multiple Notes in one step only if all corrections can be transferred in unmodified form from the Notes. If you have made your own modifications to the includes in question, the system may be unable to insert individual changes. The system always implements such Notes individually so that you can adapt your modifications.\n\n- **Implement all Notes individually**\n The system implements the specified Notes individually. This option allows you to review in detail what source code changes belong to which of the specified Notes, and to modify the changed source code, if necessary.\n\n- **Cancel SAP Note implementation**\n The system does not make any changes to the source code.\n\nThe **CONFIRM CHANGES** dialog box shown in Figure 17.8 displays which objects will be changed by the Note implementation, and whether the Note Assistant can copy in the changes. If you confirm this dialog box, the system implements the corrections into the specified objects. If you select Cancel, the system does not make any corrections.\nMaintaining SAP Software\n\nFigure 17.8 Display of Objects to Be Changed\n\nThe ‘traffic light’ icons show you whether the corrections in a Note can be implemented. The different colors have the following meanings:\n\n- **Green light**\n The corrections can be implemented without any changes.\n\n- **Yellow light**\n Some of the corrections can be implemented.\n Before you confirm the implementation, you should adapt the corrections so that the object changes can be imported correctly. To do this, click on the object name or on the traffic light icon. The split-screen editor opens, where you can edit the source code.\n\n- **Red light**\n The object changes cannot be implemented.\n This can occur for a variety of reasons; for example, the object has to be created from scratch, or is locked by another change request.\n A corresponding message text exists for every object (for example, Corrections that have not been included completely). If you click on the text, the system displays the appropriate long text with detailed information.\n\nTo implement the corrections, select all of the objects for which you want to implement corrections and select **Continue**.\n\nNote that only the objects you selected will be changed.\n\nThe split-screen editor shown in Figure 17.9 provides a detailed display of all corrections in an object. You can use this editor to adapt the corrections to your own modifications, if necessary.\nImplementing Notes with the SAP Note Assistant\n\n17.2\n\nSplit-Screen Editor\n\nFigure 17.9 Split-Screen Editor\n\nThe split-screen editor is divided into two areas:\n\n- On the left-hand side of the screen, you see the source code as it looks after the changes have been implemented. The changes are highlighted in color. You can edit the source code in this portion of the screen.\n\n- On the right-hand side of the screen, you see the parts of the program that have been deleted, and the corrections the Note Assistant cannot implement automatically. These deletions and corrections are displayed in the form of context blocks, delete blocks, and insert blocks.\n\nYou can do the following on the left-hand side of the screen:\n\n- Manually edit the program\n- Select, cut, copy, and paste blocks\n\nTo select a block that is highlighted in color, place your cursor on the header line and choose SELECT. You can also select multiple lines.\nTo do so, place your cursor on the first line of the block you want to select and choose Select. Then place your cursor on the last line and choose Select again.\n\n- Select Undo to undo all changes, step by step, that you made in the split-screen editor.\n- Select Redo to restore all changes you undid.\n- Use the arrow buttons to go to the next or last change.\n- Select Concatenate to attach two lines to each other.\n\nIf a block has been inserted or deleted, the Undo/Redo button appears between the left- and the right-hand side of the editor. You can use it to undo or redo individual changes. The technical function of the undo and redo buttons is to exchange individual delete and insert blocks.\n\n**Technical Details on Correction Instructions**\n\nTechnical details on correction instructions contains information on the following topics:\n\n- The format of correction instructions\n- The validity of correction instructions\n- Prerequisites for correction instructions\n\nCorrection instructions describe how the source code of ABAP programs has to be changed to resolve an error. These instructions are located at the end of each SAP Note. You use correction instructions to automatically correct the source code of ABAP programs, ABAP includes, function modules, method implementations, dynpro flow logic, and type groups.\n\nEvery change contains information about the object (for example, the include or the function module) and the modularization unit (such as the FORM routine) in which it will be made. The location of the change is identified by the unique number of the unchanged lines that directly precede the lines to be changed (context block). The lines to be deleted are then listed (delete block), followed by the lines to be inserted (insert block). A correction instruction can consist of multiple context blocks, delete blocks, and insert blocks.\nWhen automatically implementing a correction instruction, the system finds the context blocks in the include or function module to be corrected, checks whether the context blocks follow the lines to be deleted, and replaces these lines with the lines to be inserted.\n\nIf the include or function module to be corrected contains customer modifications, sometimes the system cannot find the context blocks specified in the correction instruction, or in the lines to be deleted. In other words, the system cannot fully implement the correction. In this case, you can use the split-screen editor to adapt the corrections in the Note to your modifications.\n\nSince 1998, correction instructions have been formalized to such a degree that they can be implemented automatically. However, older Notes may still be in non-standardized format, and the Note Assistant will be unable to automatically completely implement these Notes. However, as mentioned before, you can manually edit the source code, using the split-screen editor. It is recommended that you do this to ensure that the Note Assistant can register the Note in your system.\n\nEvery correction instruction specifies the release and Support Package levels in which you can implement the correction instruction. These levels are known as the validity range of the correction instruction. For example: if an error is detected in Release SAP_BASIS 7.00, and Support Package 5 corrects this error, the validity period of the correction instruction in question will be specified as “SAP_BASIS 7.00, Support Packages 1–4.”\n\nA Note can also specify that a correction instruction may not be implemented if the system contains a specific software component (such as an add-on). This may be the case if, for example, a correction makes changes to a part of a program that is required in its unmodified form by another software component.\n\nIf such a condition exists, this information displays in the header area of the correction instruction under Invalid for <software component, release, Support Package level>.\n\nThe Note Assistant automatically checks the validity and implements a correction instruction only if the status of the system is included in the specified validity area.\nIn certain cases, correction instructions can be implemented only if other correction instructions have already been implemented. This is due to interdependent changes made to the same points in the source code, or to semantic dependencies.\n\nThese dependencies are described in the header area of the correction instructions. If there are dependencies, you will have to implement not just one Note, but a series of Notes.\n\nLog File\n\nA log file is created when you download a Note (see Figure 17.10). A log file contains information about all of the main processing steps, including the date, time, system, and user in question, allowing you to trace the steps that have already been taken.\n\nYou can also save your own notes or remarks in the log file, provided that you are entered as a processor for this Note.\n\nThe information in the log file cannot be deleted.\n\n\n\nFigure 17.10 Log File\nUpdate Note\n\nUpdating a Note allows you to adjust the version of a Note in your system to the current version in the SAPNet-R/3 frontend. You can thus check at any time whether the Notes in your system are up to date. If necessary, the system downloads the latest version.\n\nYou have the following options:\n\n- Adjust an individual Note from within the Notes display\n- Adjust all Notes listed in your worklist\n- Adjust all Notes listed in the Notes browser\n\nNotes can be automatically updated only if you have set up an RFC connection to the SAPNet-R/3 frontend.\n\nTo update a Note, proceed as follows:\n\n - The system checks whether your system contains the latest versions of the Notes listed on the screen.\n - It also displays—in a dialog box—any Notes that SAP has changed since the last time you downloaded them.\n\n2. To download the latest versions of these Notes, click OK in the dialog box.\n\nIf the current Note was changed, and therefore has to be reimplemented, the Note Assistant displays this Note in your worklist under the Inconsistent heading. In this case, all you have to do is reimplement the Note.\n\nPost-Processing Support Packages\n\nA Support Package contains a collection of error corrections. Support Packages can be imported only in their entirety and only in the specified order. Every correction in a Support Package is documented in a Note.\nAfter you import a Support Package, you must execute the modification adjustment using Transaction SPAU as shown in Figures 17.11 and 17.12. The scenarios that can arise are as follows.\n\n1. When a Support Package is imported, the system automatically checks whether you have previously implemented individual corrections from this Support Package in the form of Notes. In the modification adjustment function (Transaction SPAU), these Notes are displayed with a traffic light icon with no colors and are therefore marked as obsolete.\n\nYou must reset the objects they contain to their original SAP status. You can do this in one of the following ways:\n\n- Click on the traffic light icon.\n- Position the cursor on the Note number. Choose **Reset to Original**.\n\nA dialog box opens. In this box, confirm that you want to reset the Note correction to the original status.\n\nIf you have selected multiple Notes corrections, you can choose **Reset All**, and the dialog box does not open.\n2. The system checks whether corrections that you have previously implemented via a Note have been overwritten by a Support Package that did not contain these corrections. If this is the case, you will have to reimplement these Note corrections. The system displays these Notes in the modification adjustment (Transaction SPAU) with a yellow traffic light.\n\nClick on the traffic light to start the reimplement process for the Note.\n\nThese Notes are also displayed in your worklist with the status **Inconsistent**, which mean they have to be reimplemented. To start the reimport, choose **Implement SAP Note**.\n3. The system checks whether you have previously implemented individual corrections from the Support Package into your system via Notes. If the Note version in the Support Package is more current than the Note that was implemented in your system using the Note Assistant, the modification adjustment function cannot reset the objects in the Note to their original status. The system displays this Note with a yellow traffic light.\n\nIn this case, proceed as follows:\n\n- Call the Note Assistant.\n- Download the latest version of all Notes.\n- Recalculate the adjustment modes in the modification adjustment. Then choose GoTo • DETERMINE ADJUSTMENT MODE.\n\nIf SAP has not changed the Note, its traffic light icon has no colors. You can reset it to its original status as described in step 1.\n\nIf SAP has changed the Note, its traffic light icon is yellow. In this case, proceed as described in step 2.\n\n4. An example of this scenario would be a Note that contains several correction instructions, each of which has a different validity period. This can have the following effect: When a Support Package is imported, one correction instruction may become obsolete, whereas another may still be valid. In such cases—which are, admittedly, rare—the Note has a green traffic light icon.\n\nIf you click on the icon, correction instructions that are no longer relevant are reset to their original status.\n\n5. The adjustment modes for Notes corrections are calculated in a background process after a Support Package is imported. However, if for some reason this process is not started, or if errors occur, a green question mark is displayed in front of the object in the hierarchy display. Click on the question mark to restart the process. This process can take a few minutes to complete.\n\nIf an object contains your own modifications and Note corrections, you must first process the Note corrections in the modification adjustment function (SPAU), and then adjust your own modifications.\nThe system does not support modification adjustments in the **WITH MODIFICATION ASSISTANT** subtree if the object is contained in Note corrections that have not yet been adjusted, or reset to their original status.\n\nIn all cases, in a modification adjustment—or when correction instructions are reset to their original status—the objects contained in the Note are placed into transport requests. This ensures that they are transported to the downstream systems.\n\n### 17.2.3 Implementation Status and Processing Status of Notes\n\nThe Note display in the Note Assistant contains two statuses: **IMPLEMENTATION STATUS** and **PROCESSING STATUS**. The implementation status of a Note is determined by the system, based on existing information. The processing status is specified by the user.\n\nYou should note that the system checks whether the processing status you specify is consistent with the implementation status of the correction instructions.\n\nFor example, you may set the processing status to **COMPLETED** only if all relevant corrections have been implemented (implementation status **COMPLETELY IMPLEMENTED** or **CANNOT BE IMPLEMENTED**).\n\nIf the implementation status changes afterwards and if it is no longer consistent with the processing status (for example, after a Support Package is imported), the system marks this Note as **INCONSISTENT** in the Note overview.\n\n**Implementation Status**\n\nIf a Note contains correction instructions, the implementation status indicates whether all relevant correction instructions of the Note have been implemented in the system.\n\nThe system automatically sets the implementation status. The possible values are as follows (see Figure 17.13):\n\n- **Incompletely implemented**\n - Not all relevant correction instructions have been implemented, or a particular correction instruction has not been implemented completely.\nThe objects in question are therefore considered to be in an inconsistent state, and you should reimplement the relevant Note.\n\n- **Obsolete version implemented**\n SAP has corrected a Note that contained errors. Reimplement the Note in your system.\n\n- **Can be implemented**\n The Note contains correction instructions you can implement in your system, if necessary.\n\n- **Completely implemented**\n The corrections in the Note have been fully implemented in your system. In this case, you don’t have to take any action.\n\n- **Cannot be implemented**\n The Note does not contain any correction instructions you can implement in your system. In this case, you do not have to take action.\n\n- **Obsolete**\n After you implemented the corrections in the Note, you imported a Support Package that also contains these corrections. The error has therefore been resolved completely.\n\n\n\n**Figure 17.13** Possible Implementation Statuses of a Note\n\n**Processing Status**\n\nThe processor of a Note sets its processing status. This status tells other users and the system whether this Note has already been processed and if so, to what extent. This status is set in the Note Assistant and can be one of the following:\nThe Note has been loaded into your system but has not yet been processed.\n\n**In processing**\nThe Note is being processed.\n\n**Completed**\nThe instructions in the Note have been executed and any corrections have been implemented in the system. Therefore, processing is completed.\n\n**Not relevant**\nThe Note has been read and classified as not relevant. A possible reason for this is that it pertains to a function that you do not use.\n\n### 17.3 ABAP Support Packages\n\nSAP regularly publishes Support Packages for different types of program correction and updates, both for ABAP and Java.\n\nSupport Packages can be downloaded from the SAP Service Marketplace under the Quick Link `/swdc`. SAP also provides collections of Support Packages on CD-ROM. You can order these Support Packages from the SAP Software Shop at [http://service.sap.com/softwarecat](http://service.sap.com/softwarecat).\n\nSAP provides a range of tools that make it easy and convenient for you to obtain Support Packages and import them automatically.\n\nThe new reporting tool for *side effects of SAP Notes* helps you avoid any undesirable side effects of Support Packages after you import them. This tool discovers whether the SAP Notes in a Support Package could have side effects on other areas of your SAP system, and outputs a list of additional SAP Notes you should implement to prevent these side effects from happening.\n\nSupport Packages provide the following benefits:\n\n1. **Proactive solution of known problems**\n Support Packages solve known problems that have occurred in other SAP customers’ systems, and thus proactively remove potential problems. This, in turn, leads to better system stability.\n2. **Prerequisite to problem-solving**\n In rare cases, a problem can be solved only if a certain Support Package has been imported. In such cases, it is not possible to solve the problem with a series of Notes. If the problem in question occurs, the required Support Package will have to be imported at short notice. The older the Support Package status, the higher the risk becomes.\n\n3. **Improved repair and maintenance**\n If a problem occurs, it is easier to find a solution if the latest Support Package has been imported. This is because you can exclude from the possible solutions all Notes that are contained in the Support Packages that have already been imported.\n\n4. **Reduced repair and maintenance**\n If you import the Support Packages for your system, there is no need to import all of the individual Notes. If the kind of error occurs that necessitates the implementation of a Note, this Note may have several prerequisite Notes that also have to be implemented. If you don’t have the latest Support Packages, the list of prerequisite Notes may be very long, thus increasing the amount of time and effort required for error correction.\n\n5. **Prerequisite for implementation projects**\n An up to date Support Package is often a prerequisite for the implementation of new functionality in a system. In such cases, if the Support Package level is not current, the implementation process will have to be put on hold until the appropriate Support Package is imported.\n\n6. **Prerequisite for interfaces to other SAP systems**\n In some cases, it is necessary to import the latest Support Packages so that other SAP systems with newer Support Packages can use interfaces to your system.\n\n7. **Statutory changes**\n Support Packages comply with the latest statutory requirements. This is especially relevant to the HR area, but also to statutory changes in the FI/CO area.\n\n8. **Prerequisite for importing Enhancement Packages**\n SAP ERP 6.0 as well as most applications based on SAP NetWeaver 7.0 provide new functions in Enhancement Packages. These enable the customer to import software innovations more frequently and with little additional effort. Enhancement Packages each require a current Support Package stack.\nSupport Packages contain quality improvements to the SAP system and make any adjustments that may be necessary (due to statutory changes, for example). They do this by replacing the affected objects in your system.\n\nEvery Support Package is valid for one specific release level (but for all databases and operating systems) and has a prerequisite number of predecessors. An upgrade of the next release level or correction level contains all Support Packages for the preceding levels that were available when the upgrade was delivered.\n\nThe Support Package Manager ensures that Support Packages are imported only in the predefined order.\n\nTo prevent problems from occurring, import Support Packages at regular intervals. This is the best way to keep your system landscape up to date.\n\nJava Support Packages contain corrections and updates to Java components. They are delivered in the form of software component archives (SCAs). Unlike ABAP Support Packages, Java Support Packages always contain the full version of the development component in question. It is therefore sufficient to import only the latest one. If dependencies exist between the current Java Support Package and other Java Support Packages, they are described in an SAP Note.\n\nJava Support Packages have been delivered since SAP Web Application Server (SAP Web AS) 6.20 and are imported using the Software Deployment Manager (SDM). The SDM is delivered with the SAP Web AS from Version 6.20 on. SAP Note 544244 contains more detailed information on this topic. As of SAP NetWeaver 7.00 you are also provided with the Java Support Package Manager (JSPM). This is a Java-based tool for implementing Java Support Packages, patches, and Support Package stacks. The use of JSPM is similar to the use of SPAM. Java Support Packages and patches are discussed in detail later in this chapter.\n\n17.3.1 Applying ABAP Support Packages\n\nSupport Package Manager\n\nThe Support Package Manager (SPAM) enables you to import SAP Support Packages into your system easily and efficiently.\nYou can open the SPAM in one of the following ways:\n\n- Choose SAP Menu • Tools • ABAP Workbench • Utilities • Maintenance • Support Package Manager.\n- Enter Transaction code SPAM.\n\nThe SAP Add-on Installation Tool (SAINT) provides functionality that is similar to Transaction SPAM. However, SAINT also lets you implement add-ons and delta upgrades of individual ABAP software components. If you need to upgrade software components with the Support Package stack, Transaction SAINT is frequently used instead of Transaction SPAM. However, using SAINT is similar to using SPAM; therefore, only Transaction SPAM (see Figure 17.14) is described in detail here.\n\n\n\n**Figure 17.14** The Initial Screen of Transaction SPAM\n\nThe Support Package Manager has the following features:\n\n- **Support Package loading**\n You can load Support Packages into your system from the SAP Service Marketplace, the SAPNet-R/3 frontend, or from collection CDs.\nRestartability\nWhen the Support Package Manager imports a Support Package into your system, it adheres to a fixed order of steps.\n\nIf the import process has to be canceled for any reason, you can resume processing at a later stage from the point that had been reached.\n\nDisplay import status\nYou can use the Support Package Manager to identify the current import status of your system.\n\nSpecial import procedure\nA special import procedure minimizes downtime.\n\nStart time control\nThe individual phases of the Support Package Manager are grouped into modules. This allows you to set the start time of the modules to any time you like.\n\nBackground processing\nYou can also schedule the modules to run in background processing, with predefined start times.\n\nYou need the following authorizations to be able to use all of the Support Package Manager functions:\n\n- S_TRANSPRT\n- S_CTS_ADMIN\n\nAuthorizations\nBoth authorizations are contained in the S_A.SYSTEM authorization profile.\n\nIf you log on to client 000 and your user master contains the relevant authorization profile, you can use all of the Support Package Manager functions. If you log on to another client, or if you don’t have the required user profile, you can use only the display functions.\n\nYou can only assign this authorization profile to the system administrator. Also, only the system administrator should have authorization for the following actions:\n- Download Support Packages\n- Import Support Packages\n- Confirm successfully imported Support Packages\n- Reset the status of a Support Package\n\nSettings\n\nChoose Extras • Settings to open a dialog box in which you can configure general settings for the Support Package Manager. These settings affect the behavior of the system when loading and importing all types of Support Packages. One exception is SPAM/SAINT updates, which have special predefined settings.\n\nYou only have to configure the settings once because they are saved and used every time the Support Package Manager is called. Note that these settings also apply to the SAP Add-On Installation Tool.\n\nAn exception to this is the settings for the Downtime-minimized import mode: This does not automatically apply to the Add-On Installation Tool.\n\n\n\n**Figure 17.15** Load Packages Tab\n\nOn the Load Packages tab, you can change or check the following properties (see Figure 17.15):\n- **Directory on Application Server**\n Shows the application server directory in which the Support Packages are stored.\n\n- **Load CAR/SAR Archives from Frontend**\n - **Display Content Before Decompressing**\n Allows you to specify whether you want to view a dialog box containing the archive content before the CAR/SAR archive is decompressed. This is selected by default.\n - **Delete Archive After Decompressing**\n Allows you to specify whether the CAR/SAR archive that was transferred to the application server should be deleted after it is successfully decompressed. This is selected by default.\n - **Save Last Upload Directory**\n Allows you to specify whether the most recently used upload directory on your frontend computer should be saved. If you select this option, this directory is automatically displayed as the start directory in the archive selection dialog box the next time you use this transaction. You can also enter an upload directory of your choice in the **Upload Directory** field. This directory is then displayed as the start directory in the archive selection dialog box.\n\n\nOn the **Define Queue** tab, you can change or check the following properties (see Figure 17.16):\n\n**Define Queue tab**\n\n- **Queue Calculation Initial Screen**\n You can specify the queue calculation method you want to be provided with by default when entering the queue definition screen:\n - **Queue calculation for a Vector of Software Comps (components)**\n The Support Package queue calculation takes place for multiple software components based on the target Support Package level that has been defined for each software component (see section “Define Queue,” marginal text: “Define queue on the basis of multiple software components”).\n - **Queue Calculation for a Single Software Component**\n The Support Package queue calculation is done by selecting one software component and the highest Support Package for this software component (see section “Define Queue,” marginal text: “Define queue on the basis of target Support Package”).\n\n- **Include Modification Adjustment Transports**\n You can specify whether you want to include SPDD and SPAU adjustment transports.\n\n\nOn the **IMPORT QUEUE** tab, you can change or check the following properties (see Figure 17.17):\n\n- **Scenario**\n By selecting the scenario, you determine which actions will be carried out during the import of the Support Package:\n - **Standard**\n Select the standard scenario if you want to import Support Packages completely and execute all of the steps involved.\n - **Import Mode: Downtime-minimized**\n If you select the standard scenario, you can also select the downtime-minimized import mode to reduce the downtime. This is not selected by default. If you do not select this option, Support Packages are imported using the conventional method. For more information on this import mode, see the relevant section that follows.\n - **Test**\n The test scenario lets you determine whether you need to carry out a modification adjustment, or whether conflicts exist that need to be resolved before the import—that is, before the Support Package is imported. No data or objects are imported into your system in the test scenario.\n There is no test scenario for SPAM/SAINT updates. Therefore, if you select this option when importing a SPAM/SAINT update, it is ignored.\n\n- **Create New Data File**\n This option allows you to specify whether the data files in the EPS packages should be decompressed with every attempted import. It is selected by default.\n\n If you have a multisystem landscape with a shared transport directory, it is best to select this option in only the first system into which you import Support Packages, and to deselect it in the downstream systems. This saves time in the import process because the data files do not need to be created again in the downstream systems.\n- **Delete Data File After Import**\n This option allows you to specify whether the data files should be deleted after a Support Package is imported. This helps to save disk space and is selected by default.\n\n If you have a multisystem landscape with a shared transport directory, it is best to deselect this option because the data files do not need to be created again in the other systems (see the list item “Create New Data File”).\n\n- **Create Object Versions during Import**\n This option does not apply to SPAM/SAINT updates.\n\n It allows you to specify whether versions should be created of the Support Packages’ objects during the import process. This option is deselected by default. This is because versioning makes sense only if it is activated for all imports, and also because it can take a long time and takes up a lot of space in the database.\n\n Note that if version creation is activated in the transport tools’ configuration in the Transport Management System (Transaction STMS), you must set the `VERS_AT_IMP` parameter to `ALWAYS`.\n\n- **ABAP/Screen Generation**\n These options allow you to specify whether the programs and screens that come with the Support Package should be generated during the import.\n\n They have no effect with SPAM/SAINT updates.\n\n - **Never**\n If you select this option, the programs and screens are generated only when they are called for the first time.\n\n - **Always**\n If you select this option, the programs and screens are always generated. Note that the generation process can take a very long time to complete, and may cause errors.\n\n - **According to SAP Instructions**\n If you select this option, the programs and screens are always generated if the generation option is activated during the import process for these Support Packages.\nImport Phases and Modules\n\nAll actions the import tools perform run in *phases*. These phases, in turn, are grouped into modules. The modules have the following properties:\n\n- You can run them individually.\n- You can start them in a background process.\n- You can set the start time of the modules to any time you like.\n\nThe import process is subdivided into the following modules:\n\n- **Preparation module**\n This module carries out all of the preparation and testing steps (such as a test import and add-on conflict checking). It can run during live operation.\n\n After you have run the Preparation module, you can reset the queue. If you proceed to the Import 1 module and do not reset the queue, the data is changed in the database and you will not be able to reset or delete the queue from this point on.\n\n- **Import 1 module**\n This module imports and activates Dictionary objects (and carries out a modification adjustment of Dictionary objects, if necessary). Any changes that are made in the process of importing and activating the Dictionary are still in an inactive state in the system. This means that the runtime system cannot “see” these changes yet. If you are sure that manual changes do not need to be made and that no transports will be imported into the system, this module can also run during live operation. This is usually the standard in production systems.\n\n- **Import 2 module**\n This module carries out the remaining import steps, including the activation of inactive Dictionary nametabs. To avoid inconsistencies, this module cannot run simultaneously with live operations, because it imports changes to various transport objects.\n\n- **Clean-Up module**\n This module handles all post-import (“clean-up”) steps, especially modification adjustment for Repository objects. Live operations can resume after all modifications have been adjusted.\nBecause the package import process can be stopped after every module, it is possible to run the Preparation and Import 1 modules during live operations. After the system has been transferred to non-live operations, the Import 2 module and, if necessary, the modification adjustment can be carried out, after which live operations can resume.\n\nMake sure that no company-specific transports, aside from modification adjustment transports, occur when the Import 1 module has been started, and that no manual changes are made to Repository objects (ABAP programs and Dictionary objects). Moreover, the search helps may be inconsistent during the time period between running modules Import 1 and Import 2. This time period should be kept as short as possible.\n\nThe Support Package Manager uses the status bar to indicate which phase is currently being executed. If you want to know which phases are executed for which scenario (test or standard scenario), run program RSSPAM10.\n\n**SAP Add-on Installation Tool**\n\nThe SAP Add-on Installation Tool (SAINT) provides functionality that is similar to Transaction SPAM. However, SAINT also lets you implement add-ons and delta upgrades of individual ABAP software components. If you need to upgrade software components with the Support Package stack, you need to use Transaction SAINT instead of Transaction SPAM. Moreover, Transaction SAINT enables you to use multiple parallel processes for the R3trans import and for background processing. However, this is only possible for specific packages that consist of multiple object bills of material, for instance, ERP Enhancement Packages.\n\n**Import SPAM/SAINT Update**\n\nSPAM/SAINT updates (known as SPAM updates for short) provide you with updates and improvements to the Support Package Manager and the SAP Add-On Installation Tool. Every release comes with a SPAM update, which is then updated as necessary over time. It is stored in the following locations in the system:\nIn the short description; for example, SPAM/SAINT update version <REL>/0001\n\nIn the package name; for example, SAPKD<REL>01\n\nWe recommend that you always import the latest version of a SPAM update before importing Support Packages or Installation Packages.\n\nA SPAM update can be successfully imported only if the system does not contain any canceled packages. If the system does contain such packages, a dialog box informs you of this fact and you can do one of two things:\n\n- Fully import the queue and then import the SPAM update.\n- Delete the queue, import the SPAM update, and then import the queue.\n\nNote that you can delete the queue only if the Import 1 module has not yet been started (up to phase SCHEDULE_RDDIMPDP).\n\nTo import a SPAM update, proceed as follows:\n\n1. Open the Support Package Manager (Transaction SPAM).\n2. Check that the SPAM update in question is more up to date than the version that is currently on your system. (The latest version is displayed in the title bar of the Support Package Manager.)\n3. To import the latest version, choose SUPPORT PACKAGE • IMPORT SPAM UPDATE. SPAM updates are automatically confirmed after they have been successfully imported.\n\n**Loading Support Packages**\n\nBefore you can import a Support Package, you must load it from the SAP Service Marketplace (see Figure 17.18).\nMaintaining SAP Software\n\nLoading Support Packages from the SAP Service Marketplace\n\nSupport Packages in the SAP Service Marketplace are in compressed format. You therefore have to decompress them before using them.\n\nIf the archives are located on your frontend computer, you can transfer them directly to the application server from within the Support Package Manager and decompress them there. However, if the archives are larger than 10MB, proceed as follows:\n\n1. Load the Support Packages from the SAP Service Marketplace or mount the relevant CD.\n\n2. Log on with the following operating system-dependent user:\n\n<table>\n<thead>\n<tr>\n<th>Operating System</th>\n<th>User</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Unix</td>\n<td><sid>adm</td>\n</tr>\n<tr>\n<td>IBM eServer iSeries</td>\n<td><SID>OFR</td>\n</tr>\n<tr>\n<td>Windows</td>\n<td><SID>adm</td>\n</tr>\n</tbody>\n</table>\n3. Switch to the following operating system-dependent subdirectory in your system:\n\n<table>\n<thead>\n<tr>\n<th>Operating System</th>\n<th>Subdirectory</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Unix and IBM eServer iSeries</td>\n<td>trans</td>\n</tr>\n<tr>\n<td>Windows</td>\n<td>TRANS</td>\n</tr>\n</tbody>\n</table>\n\n4. Use the following operating system-dependent command to decompress the archive that contains the Support Packages:\n\n<table>\n<thead>\n<tr>\n<th>Operating System</th>\n<th>Command</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Unix</td>\n<td>SAPCAR -xvf /<CD_DIR>/<PATH>/<ARCHIVE>.CAR</td>\n</tr>\n<tr>\n<td>IBM eServer iSeries</td>\n<td>SAPCAR `~xvf /QOPT/<VOLID>/<PATH>/<ARCHIVE>.CAR'</td>\n</tr>\n<tr>\n<td>Windows</td>\n<td>SAPCAR -xvf <CD_DRIVE>:<PATH><ARCHIVE>.CAR</td>\n</tr>\n</tbody>\n</table>\n\nThe decompressed Support Packages are then automatically placed in the EPS inbox of your transport directory (Unix and IBM eServer iSeries: /usr/sap/trans/EPS/in; Windows: <DRIVE>:\\usr\\sap\\trans\\EPS\\in).\n\n5. Load the Support Packages into your system using SUPPORT PACKAGE • LOAD PACKAGE • FROM APPLICATION SERVER.\n\nA list of the Support Packages you just uploaded displays. They are now known to the SAP system with all of their attributes and can be handled correctly by the Support Package Manager.\n\n6. Choose Back to return to the Support Package Manager's initial screen.\n\n7. Define the queue.\n\nIf you want to load the archives (*.CAR/*.SAR) from the frontend to the application server, and if the archives are smaller than 10MB, proceed as described in the list of steps that follows. If the archives are greater than 10MB, the procedure described here will not be efficient. In this case, first transfer the Support Packages to the application server—via FTP, for example—and then load them from there.\n1. Open the Support Package Manager (Transaction SPAM).\n\n2. Choose SUPPORT PACKAGE • LOAD PACKAGES • FROM FRONTEND. The dialog box for archive selection opens.\n\n3. Select the relevant archive. This archive is transferred to the application server. The archive's table of contents is read and then displayed in a dialog box.\n\n4. Select DECOMPRESS to transfer the archive to the application server and decompress it. If you select the NEW SUPPORT PACKAGES option and choose DISPLAY under DIRECTORY in the initial screen, the corresponding package is displayed in the Support Package Manager after the archive has been decompressed.\n\n**Define Queue**\n\nThe queue determines which Support Packages are imported into your system by the Support Package Manager, and in what order. If the queue has not yet been fully defined, you now have to define the queue, making your selection from the available Support Packages. If the queue has been fully defined, it is simply displayed, and you cannot change it. However, you can delete the queue entirely, if required, by choosing DELETE QUEUE.\n\nNote that you can delete the queue only if the Import 1 module has not yet been started (up to phase SCHEDULE_RDDIMPDP).\n\nThe Support Package Manager ensures that only Support Packages that are suitable for your system are displayed in the queue. Support Packages that are intended for another release, or for an add-on that you have not installed, don't appear in the queue, even if you loaded them into your SAP system.\n\nYou can define the queue on the basis of either the software components in your system or a target Support Package as shown in figure 17.19.\nTo define a queue on the basis of software components, proceed as follows:\n\n1. Click **Display/Define** in the initial screen of the Support Package Manager.\n The **Component Selection** dialog box appears, and the list of installed software components is displayed (such as SAP_BASIS, SAP_HR, SAP_BW).\n\n2. Select the component you want.\n Alternatively, you can calculate a common queue for all software components in the system by selecting **All Components**.\n\n3. The queue is then displayed. The queue contains the Support Packages available for the selected component(s) in your system, and possibly also any Support Packages required for other components, Conflict Resolution Transports (CRTs), and any associated add-on Support Packages.\n\nFigure 17.19 Defining the Import Queue\n\n<table>\n<thead>\n<tr>\n<th>Software Comp.</th>\n<th>Target Package</th>\n<th>Level</th>\n<th>Calculated Package</th>\n<th>Level</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>SAP_BASIS</td>\n<td>SAP_BASIS011</td>\n<td>0311</td>\n<td>SAP_BASIS034011</td>\n<td>0011</td>\n</tr>\n<tr>\n<td>SAP_HR</td>\n<td>SAP_HR034011</td>\n<td>0311</td>\n<td>SAP_HR034011</td>\n<td>0011</td>\n</tr>\n<tr>\n<td>ST-PI</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>PI_BASIS</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>SAP_BW</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>ST-API</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\n---\n\nThe calculated queue is consistent and matches the chosen target packages.\n- Check the queue on the tab **Calculated Queue**.\n- Confirm the queue with **[Confirm Queue]**.\nIf you want to define the queue for another software component, select New Component.\n\n4. You now have the following options:\n\n- If you are happy with the queue as displayed, choose Confirm Queue to confirm and close the dialog box.\n- You can also reduce the queue selection. To do this, select the Support Package you want to be the last in the queue. The queue is then recalculated. You can also explicitly recalculate the queue by selecting Recalculate Queue.\n\nTo define the queue on the basis of a target Support Package, proceed as follows:\n\n1. In the initial screen of the Support Package Manager, choose the New Support Packages option under Directory.\n2. Choose Display. The system displays a list of the Support Packages in the system.\n3. Place your cursor on the Support Package you need and click Calculate Queue. The queue is displayed. It contains the Support Packages available in your system for the target Support Package, and possibly also any Support Packages required for other components, Conflict Resolution Transport (CRT), and any associated add-on Support Packages.\n4. Proceed as described under Step 4 in the section “Define Queue,” marginal text: “Define queue on the basis of software components.”\n\nThe following rules apply when you create a queue:\n\n- Support Packages for a selected component are placed in the queue in sequence.\n- If Support Packages in the queue are linked to Support Packages of another component (such as another predecessor relationship or a required CRT), other Support Packages are added to the queue until all predecessor relationships are accounted for.\n\nNote that the Support Package Manager takes into account the configuration of your SAP system and places only the Support Packages your system can accept into the queue.\nImport Queue\n\nThe Support Package Manager provides the following two scenarios for importing Support Packages or the queue:\n\nThe test scenario is used to identify any conflicts or problems (for example, repairs that have not been released) before the actual import process. The test import creates the list of objects to be adjusted in Transactions SPDD and SPAU, and should therefore be run during the project preparation phase.\n\nThis scenario allows you to estimate—and, possibly, minimize—the time and effort required to import Support Packages. No data is imported into the system in this scenario, and if errors occur, you can continue the import without having to correct them. You must explicitly select the test scenario.\n\nNote that after the test scenario has run, the queue is empty again and you will have to redefine it. You will then also have to explicitly select the standard scenario.\n\nIn the standard scenario, the Support Packages contained in the queue are fully imported. If errors occur, you can continue and complete the import only after you have removed or resolved them.\n\nAfter you have selected the standard scenario, you can choose between the conventional import mode and the *downtime-minimized* import mode. The latter reduces the downtime.\n\nProceed as follows to import the queue in the standard scenario:\n\n1. To set the standard scenario, select Extras • Settings.\n2. On the Import Queue tab, select Standard and configure the other import settings.\n3. Select the import mode you need to use.\n4. Select Support Package • Import Queue. You can also use this function to resume an import procedure that was previously canceled.\n5. The dialog box for selecting the start options opens. Specify the required start options and confirm the dialog box.\nThe Support Package Manager then completes the import, in accordance with the import mode and start options you selected.\n\nIf you accept the standard start options without changing them, the Support Package Manager handles the entire import process in the dialog box. The status bar provides you with information about the progress of the import and the current phase of the Support Package Manager. Note that your system should no longer be live at this point.\n\nIf you selected a start time or **Continue Manually** for the Import 2 module, you can keep the system in productive mode until the Import 2 module starts.\n\nIf you accepted the standard start options without changing them, you can keep the system in live mode for the time being, because the Support Package Manager will explicitly ask you to stop live operations when the time comes.\n\nAs usual, the Support Package Manager carries out all of the preparatory and checking steps (Preparation module). It then imports the inactive objects (Import 1 module), during which process the system can stay live.\n\nThe development environment is locked when the Import 1 module starts, so that objects are not unintentionally modified. Therefore, the consistency of the system is not jeopardized when objects are accessed by this module.\n\nThe Support Package Manager then notifies you in a dialog box that you have to stop productive operations for the next import module (Import 2).\n\n- **Click on** **CANCEL** **to do this in an orderly manner.**\n\n Close any background jobs that are running. Request all users to close any transactions they are running and to log themselves off from the SAP system.\n\n- **Click on** **CONTINUE** **to continue the import.**\n\n The Import 2 module activates the objects that were previously imported in an inactive state and imports the remaining objects from the Support Packages in the queue.\nAfter this module has finished, the Support Package Manager informs you that you can resume live operations in the system, provided that no changes, or at most only small changes, were made to SAP objects.\n\n- If you made changes to SAP objects, the Support Package Manager instructs you to finish the modification adjustment process.\n\nIf you have to adjust Dictionary objects (Transaction SPDD), you must do this immediately, whereas with Repository objects (Transaction SPAU), you can adjust the objects immediately, at a later point, or in parallel with the clean-up steps after importing a Support Package. To do this, proceed as described in Chapter 18, Section 18.3.\n\n- To complete the import process, select IMPORT QUEUE again.\n\nThe clean-up steps are carried out on the next import module (Clean Up), and the import process is completed and closed.\n\nYou can define the start options for the individual modules according to your system requirements. If you confirm the dialog box without configuring any specific settings of your own, the import tool uses the standard settings of the selected import mode. You can store any settings you configure as a template for future import procedures.\n\nThe tabs in the START OPTIONS FOR THE QUEUE dialog box (see Figure 17.20) allow you to select the options you need for every module:\n\n- **Start in dialog immediately**\n Select this option if you want this module to start running immediately in the dialog box. If you select this option for multiple modules, they are executed immediately, one after the other. The mode remains blocked for the duration of the import.\n\n- **Start in background immediately**\n Select this option if you want this module to start running immediately in the background. If you select this option for multiple modules, they are executed immediately, one after the other.\n\n- **Start in background later**\n Select this option if you want this module to start running in the background at a later time. Specify the start date and start time in the input fields. The **NO START AFTER** option lets you specify that this\n\nDefines start options\nmodule should run only during the period between **planned start** and **no start after**. If no background process is available in this time period, this module is not started.\n\n- **Manual Start/Continue Manually**\n Select this option if you want to manually start processing of this module. The import tool stops the processing process after the previous module has finished.\n\n\n\n**Figure 17.20** Defining the Start Options\n\nIf you selected the conventional import procedure (**Downtime-minimized** is not activated), the following standard settings apply:\n\n<table>\n<thead>\n<tr>\n<th>Module</th>\n<th>Option</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Preparation</td>\n<td>Start in dialog immediately</td>\n</tr>\n<tr>\n<td>Import 1</td>\n<td>Continue in dialog immediately</td>\n</tr>\n<tr>\n<td>Import 2</td>\n<td>Continue in dialog immediately</td>\n</tr>\n<tr>\n<td>Clean Up</td>\n<td>Continue in dialog immediately</td>\n</tr>\n</tbody>\n</table>\nIf you have selected the downtime-minimized import mode, the following standard settings apply:\n\n<table>\n<thead>\n<tr>\n<th>Module</th>\n<th>Option</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Preparation</td>\n<td>Start in dialog immediately</td>\n</tr>\n<tr>\n<td>Import 1</td>\n<td>Continue in dialog immediately</td>\n</tr>\n<tr>\n<td>Import 2</td>\n<td>Continue manually</td>\n</tr>\n<tr>\n<td>Clean Up</td>\n<td>Continue manually</td>\n</tr>\n</tbody>\n</table>\n\n**Downtime-minimized Import Mode**\n\nAs a rule, the process of importing the latest OCS packages (Support Packages, Add-on Installation Packages, and add-on upgrades) requires a relatively long system downtime due to the size and scope of these packages. Although the system is not restarted in the import process, it should still not be used for live operations during this process. This restriction is a distinct disadvantage in many live systems.\n\nTherefore, the downtime-minimized import mode was developed to reduce the downtime required for package imports. This mode enables you to import the majority of import objects while keeping the system live. The objects in question are program code and program texts. Therefore, downtime can be reduced greatly if a package contains a high proportion of program code and texts. (This figure is approximately 70-80% for SAP Basis and SAP R/3 Support Packages.)\n\nIn downtime-minimized import mode, the objects are imported into the database in an inactive state and are mostly “invisible” to the system. The system can continue to stay live.\n\nThis procedure contains new actions (activation of inactive objects) and more organizational steps than the previous mode, which means that the import process takes longer. The efficiency and time-savings in the non-live phase of this mode, as compared to conventional mode, depend on two things: the proportion of inactively imported objects of the overall volume of imported data, and the amount of time consumed by additional actions that have to be carried out during the downtime (such as the handling of after-import methods and XPRAs).\nImport the packages in queues that are as large as possible. Ideally, put all packages in one queue.\n\nNote, however, that in some cases Support Packages cannot be imported in one queue using the Support Package Manager. Consult the relevant SAP Note in your release for more information.\n\nBecause the inactively imported objects are stored in the database at the same time as the active versions, more space is temporarily required in the database.\n\nThe objects are activated later by a predefined process that is provided by the import tool (Support Package Manager/SAP Add-On Installation Tool). Nevertheless, inactive objects are not fully isolated from the system, which means that parallel changes can cause unwanted activations and therefore system inconsistencies.\n\nDuring the import, you should ensure the following:\n\n- That there is enough free storage space in the database\n- That there are no simultaneous imports of transport requests\n- That the development environment is not in live use\n\nUse downtime-minimized import mode in the following situations:\n\n- In live systems\n- In test systems, if you want to test the expected downtime in the live system\n\nDuring the import process, you should treat the systems like live systems (no manual changes to program objects, and no parallel imports of other transport requests).\n\nDo not use downtime-minimized import mode in the following situations:\n\n- In development systems or in systems into which a lot of regular imports are made (such as QA or test systems)\n\n System consistency cannot be guaranteed during the import if manual changes are made to program objects, or if other transport requests are imported at the same time.\nTo import Support Packages to BBP/CRM systems\n\nThe additional preparation and clean-up steps required by the special Support Package Manager for BBP/CRM mean, in effect, that the entire import process takes place during downtime.\n\nTo import preconfigured systems (SAP Best Practices) using the Add-On Installation Tool\n\nImporting Support Packages into a System Landscape\n\nSupport Packages can be imported in groups or individually. If you have multiple SAP ERP systems, you must import Support Packages into each of these systems.\n\nYou can use the previously discussed procedure to import Support Packages into your landscape’s development system, but the procedure is different for the other SAP ERP systems in your landscape, especially if you have to carry out a modification adjustment. Figure 17.21 shows an example of how Support Packages can be distributed in a three-system landscape.\n\nFigure 17.21 Distribution of Support Packages in a Three-System Landscape\n\nIdeally, all SAP ERP systems have the same release level, as is the case after they are installed, after an SAP ERP release upgrade, or after the roll-\nout in the implementation phase. If this is the case, you can import one or more Support Packages the same way you import change requests:\n\n1. Import the Support Packages into the development system. The system adjusts all objects that were imported with the Support Package and that have been modified by the customer:\n\n - You may need to carry out a modification adjustment for the Dictionary objects using Transaction SPDD in the development system. The changes that result from the adjustment can then be included in a change request. This change request can be used to transport the modification adjustment of the ABAP Dictionary objects to other systems.\n\n - You may need to carry out a modification adjustment for the ERP Repository objects using Transaction SPAU. The changes that result from the adjustment can then be included in a change request. This request can be used to transport the modification adjustment of the Repository objects to other systems. If enhancements were used to make changes to the SAP ERP system (see Chapter 2), there is no need for an adjustment because enhancements don’t result in modifications.\n\n2. Import the Support Packages into the quality assurance system.\n\n3. Import the change requests with the changes from the modification adjustments (if any) into the QA system.\n\n4. Verify the Support Package using operational validation tests. If changes have to be made due to Support Package imports, make the changes in the development system and then test them in the QA system.\n\n5. After you have tested and verified the Support Packages, import them into the live system, along with all transport requests associated with the Support Packages.\n\nIt is a prerequisite of this process that no change requests for the import are waiting to be processed in the QA or in the live system. In other words, the SAP systems—especially the QA and live systems—must all have the same release level. The validation process in the QA system ensures that the Support Package and all of the change requests that result from the modification adjustment can be imported into the live system.\nSupport Packages and Development Projects\n\nIt is more difficult to schedule Support Package imports if large development projects are ongoing in your system landscape. This is because you are not supposed to make transports between systems with different Support Package levels. Therefore, development projects cannot be imported into the live system until the Support Packages have been imported into all systems in the landscape.\n\nDespite efforts to keep this “code freeze” period as short as possible, experience shows that one to two weeks have to be allotted for the SPAU adjustment in the development system, and approximately two to four weeks must be scheduled for the integration test in the QA system that follows. Of course, these time periods are average values and will vary from system to system.\n\nThe time and effort required for the SPAU adjustment increases as the number of modified and customer-specific objects increases. In addition to the objects listed in SPAU, any customer-specific objects that access standard SAP code also have to be checked. The SAP Code Inspector (Transaction SCI) is an automated tool for performing this task, and lets you carry out an extended syntax check for all customer-specific objects.\n\nThe time and effort required for this check depends on the number of business processes in use. The SAP system administrator has to decide whether to test only the most important business processes, or whether more minor processes should also be included in the test. Therefore, it is necessary to categorize the business processes according to their importance (ABC analysis) in advance. A well-organized test management process and the ready availability of automated test cases (eCATT) reduce the time and effort required for the test, and thus shorten the duration of the code freeze period.\n\nBefore Support Packages are imported into the development system, any open change requests should be released and imported to the downstream systems. After the Support Packages have been imported into the development system and the SPAU adjustment is complete, you may be able to resume development work in the development system. However,\nit’s still possible that errors detected in the Support Package tests may be difficult to solve in the development system because the development system may have a more up to date software release. The safer option is therefore to resume work in the development system only if the Support Packages have been tested and found to be error-free. In all cases, all transports in the QA system must be suspended for the duration of the integration test.\n\nBecause of these effects on development projects, the timing of Support Package imports must be carefully planned and coordinated with the development project teams.\n\nSome SAP customers first test Support Package imports and the SPAU adjustment in a sandbox environment, to minimize the code freeze period. Initial unit tests can also be carried out in the sandbox system.\n\nYou can also use the latest Support Package level for the relevant development projects, and then transport the changes along with the Support Packages through the maintenance landscape. This has the advantage that only one test is required for Support Packages and development projects. Note that this approach requires a phase-based system landscape, as described in Section 3.6.2.\n\n17.3.2 Modification Adjustment\n\nIf Support Packages include objects that have been modified in the customer system, you need to implement a modification adjustment. Here, you have the following options: keep the modified version, accept the new standard SAP version, or adjust the two versions manually. The new standard SAP version remains active unless an adjustment has been carried out. Ideally, the modification adjustment needs to be implemented only in the development system. The resulting SPDD and SPAU transports can be integrated in the Support Package queue for the downstream systems.\n\nChapter 18, Section 18.3 deals with the topic of modification adjustment in greater detail. Thus, we will not discuss it further at this point.\n17.4 Java Corrections\n\nABAP corrections are delivered via SAP Notes or Support Packages. SAP Notes contain correction instructions that can be used to insert selected code lines into existing code. This lets you correct errors individually and in an isolated manner. In Java systems, these isolated changes are not possible, and you need to at least update the entire development component.\n\nFigure 17.22 shows the SAP component model. Products consists of multiple software components, which comprise multiple packages (ABAP) or development components (Java). These, in turn, are containers for individual development objects that belong together logically and are interdependent.\n\n17.4.1 Java Correction Types\n\nSoftware maintenance is available for products, software components, and development components. Products are installed or upgrades to a higher release level are implemented. A release consists of multiple software components that contain new functions and improvements.\nSupport Packages\n\nIn contrast to ABAP, a Support Package does not just contain the changed objects, but all objects of a software component. Therefore, in Java, you only have to import the last Support Package; in ABAP, you have to import all predecessors in the correct sequence. This means that Java Support Packages are cumulative. The common file format is SCA, which is implemented using the Java Support Package Manager (JSPM).\n\nFixes\n\nFixes are full deliveries of a development component. In other words, they contain all objects of this particular development component. A fix is the smallest delivery unit of corrections and usually solves one specific problem. Fixes are provided only in emergency cases if an urgent preliminary correction is required before the next Support Package is available. They are not offered on the SAP Service Marketplace by default, but are instead delivered to individual customers on demand as a support message or in an SAP Note. If the error correction is of general interest, a patch is published on the SAP Service Marketplace (see the next section).\n\nThe import of fixes carries a certain risk because it may be possible that dependencies exist to other development components that will stop functioning after the fix has been imported. You should therefore implement fixes only in coordination with SAP Support. Fixes are delivered in SDA file format.\n\nPatches\n\nA patch is a modified Support Package. It contains the last regular Support Package and also all important and generally valid fixes that have been compiled since the release of the last Support Package. Just like a Support Package, a patch is a full delivery of a complete software component. The common file format is SCA. Patches are created by SAP on request and are published in the SAP Service Marketplace, for instance, if serious problems have emerged. Usually, patches are created only for the latest Support Packages.\n\nYou can download both Support Packages and patches from the SAP Service Marketplace under the Quick Link [http://service.sap.com/swdc](http://service.sap.com/swdc) (see...\nFigure 17.24. You must decide whether you want to import the last Support Package or also integrate the latest patch. Under the Info link of a patch you can find a list of Notes available for the patch. If these Notes are relevant for your system, you should integrate the patch. If you click on the Info link of a Support Package, you are provided with a summary that describes all corrections in a Support Package.\n\nFigure 17.23 shows the three different Java correction types: Support Packages, Fixes and Patches.\n\n\n\n**Figure 17.23** Java Support Packages, Fixes, and Patches\n\n\n\n**Figure 17.24** Java Support Packages and Patches in the SAP Service Marketplace\n17.4.2 Version Information of a Java System\n\nYou can view the version information of a Java-based system on the component information page. The URL is http://<hostname>:<port>/sap/monitoring/ComponentInfo (see Figure 17.25).\n\nFor each software component, the version information indicates the release level, the Support Package level, and the patch level.\n\n**SCA**\nJava Support Packages are delivered in *Software Component Archive* (SCA) format. A software component archive comprises the following attributes:\nJava Corrections\n\n- **Vendor**\nThe manufacturer of the software, for example, sap.com.\n\n- **Name**\nThe name of the software component, for example, SAP-JEE. Vendor and name form a unique key for the software component. Components with identical names and different manufacturers are considered to be different.\n\n- **Release**\n\n- **Support Package level**\n\n- **Patch level**\n\n- **Counter**\nThe counter includes the release, Support Package level, patch level, and time stamp, for example, 1000.7.00.2.0.20050524093600. In this example, 7.00 is the release, 2 the Support Package level, 0 the patch level, and 20050524093600 the time stamp.\n\n- **Provider**\nThe provider who created the software component, for example, SAP AG.\n\n### 17.4.3 Java Support Package Manager (JSPM)\nThe Java Support Package Manager (see Figure 17.26) was implemented in SAP NetWeaver 7.0 to facilitate the import of Java Support Packages. In previous releases, Java Support Packages had to be imported using the Software Deployment Manager (SDM). The JSPM can also be used to import new software components or business packages. In addition, the JSPM identifies software components that have been modified and provides a modification adjustment in connection with the SAP NetWeaver Development Infrastructure (NWDI).\n\nThe JSPM is a Java-based program whose user interface is called at the operating system level. The script is go.bat and it is stored in the directory, \\usr\\sap\\<SID>\\<Instance>\\j2ee\\JSPM\\. The structure of the JSPM is similar to Transaction SPAM in ABAP systems and provides similar functions.\nMaintaining SAP Software\n\nFigure 17.26 Java Support Package Manager\n\nThe JSPM establishes a connection with the Software Deployment Manager (SDM) to import Support Packages and new software components. The SDM implements additional validation steps for the packages and imports them into the Java application after the check has completed successfully.\n\nAdvantages of JSPM\n\nSAP continuously provides new technologies and applications based on SAP NetWeaver Applications Server Java (AS Java). It is therefore important that these innovations can be imported safely and easily. JSPM was developed to address this issue and has the following advantages:\nImproved user interface\nThe JSPM has a graphical user interface whose structure is similar to the installation and upgrade tools SAPinst and SAPJup. Its functions and operating elements are extensively adapted to the proven ABAP Support Package Manager (Transaction SPAM), and the status of the import can be monitored. The import process is logged comprehensively and can be restarted if an error occurs. The JSPM also informs you if a restart of the J2EE Engine is necessary during the import process.\n\nCheck for Support Package prerequisites\nPrior to the import, the JSPM checks whether all prerequisites are met for importing the Support Packages—in particular, whether dependencies to other software components and their Support Packages exist.\n\nUpdate of the SAP kernel and additional operating system files\nThe JSPM can update both the software component within the Java Application Server and the associated operating system files, for instance, the SAP kernel or the Internet Graphics Server (IGS). These files can also be distributed in a high-availability cluster environment.\n\nPrior to importing the actual update, the JSPM can update itself and the Software Deployment Manager (SDM).\n\nAs a result, the JSPM automates the import of updates extensively and carries out many steps that previously had to be implemented as additional manual steps.\n\nImport of a complete Support Package stack\nThe JSPM can import a complete Support Package stack, including the appropriate SAP kernel, into the system. During this process, the stack configuration file, which was created when the stack was downloaded from the SAP Service Marketplace, is evaluated. You can set restrictions to a specific system usage type. You can also integrate patches that are more up to date than the stack to be imported if these patches have previously been downloaded to the Support Package inbox.\n\nModification adaptation in connection with the NWDI\nIn some scenarios, SAP provides the Java source code which can then be modified by the customer—for example, in the SAP ERP scenarios.\nESS/MSS or Biller Direct. During the import of Support Packages, the modifications are supposed to remain unchanged and not be overwritten by the SAP standard. This is provided by the JSPM in connection with the SAP NetWeaver Development Infrastructure (NWDI). First, the new Support Package is imported in NWDI where the modification adjustment takes place. Then, the modified archive is imported into the runtime system.\n\nThe following shipment units can be imported using the JSPM:\n\n- **Support Package stacks**\n Support Package stacks are coordinated combinations of Support Packages for all components of an application. They were introduced to reduce the wide range of possible software versions in customer systems. Moreover, the Support Package stacks are already tested intensively at SAP. For more information about Support Package stacks refer to Section 17.5. A Support Package stack may contain the following packages:\n - Archives for different software components (SCA). These archives can be both Support Packages and patches, which means that you can integrate the latest patches with the Support Package stack. After the corresponding software components have been modified, you can implement an adjustment using the NWDI.\n - Update for the Software Deployment Manager (SDMkit.jar)\n - SAP kernel (SAPEXE.SAR and SAPEXEDB.SAR)\n - Archives for the Internet Graphics Server (IGS)\n - Configuration file of type XML that contains a description of the stack’s software components as well as the corresponding support package and patch level\n\n- **Individual Support Packages and patches**\n SAP provides Support Packages for every software component. If dependencies exist between the current Support Package of different software components, they are described in an SAP Note.\n\n In addition, you can import “patched” Support Packages or patches. For example, patch 2 of Support Package 3 contains fixes that were created after the Support Package had already been released.\nThe file format of Support Packages is SCA, JAR, or SAR. Using the NWDI, you can only modify Support Packages of type SCA.\n\nJava Support Packages always contain all objects of a software component. Therefore, you only have to import the latest Support Package and not all predecessors in the correct sequence, as is the case in ABAP. This is the major difference in the software logistics of ABAP and Java systems.\n\n- **New software components**\n New software components of SAP and SAP partners.\n\n- **Business packages for SAP Business Suite applications**\n Business packages for applications of SAP Business Suite are new Java-based applications that are integrated with the SAP Business Suite applications. For example, business packages exist for the ESS/MSS scenario. These contain applications and user interfaces in the Portal that are integrated with the new business processes in the SAP ERP backend. Usually, the version of the business packages must be coordinated with the version of the backend application.\n\n### 17.4.4 Importing Java Support Packages\n\nThis section provides guidelines and tips on how you should import Support Packages into the Java stack. The links provided are valid for Release SAP NetWeaver 7.0. Similar links exist for other releases.\n\n**Step 1 — Planning**\n\nFrom the SAP Service Marketplace, download the latest Support Package Stack Guide for your Support Package level, which can be found under [http://service.sap.com/maintenanceNW70](http://service.sap.com/maintenanceNW70). The latest information is provided in the Notes, which can be found under [http://service.sap.com/sapnotesNW70](http://service.sap.com/sapnotesNW70). The most important SAP Notes are as follows:\n\n- 724452: Central Note for SAP NetWeaver Java Server 04/2004s\n- 852008: Release Restrictions for SAP NetWeaver 7.0\n- 879289: Support Package Stack Guide — SAP NetWeaver 7.0\n- 891983: JSPM: Central SAP Note SAP NetWeaver 2004s AS Java\nMaintaining SAP Software\n\nConsult the SAP online help to get additional information about enhancements and changes that are imported with the new stack. The online help can be found under http://help.sap.com/NW70. Click on the Release Notes link and select your Support Package stack.\n\nCluster environments\n\nIn certain cases, the JSPM stops the system or individual instances and restarts them again after a specific period of time. This is necessary for replacing the SAP kernel, for example. If you use a high-availability cluster solution, you must switch it off during the import process so that the JSPM can exclusively stop and start the instances.\n\nJDK update\n\nIn some cases, it is necessary to renew the Java Development Kit (JDK) before you can import Support Packages. This is described in SAP Note 718901. Note that the JVM path may change. In this case, you must adapt the new path on all dialog instances.\n\nIntegrate patches\n\nCheck whether the SAP Service Marketplace provides you with patches for the Support Package stack to be imported. These can be found under http://service.sap.com/swdc • Download • Support Packages and Patches. Click the Info button of the respective patch to view the corrections contained in it. In general, SAP does not recommend integrating the latest patches because they may not be tested in the context of the Support Package stack and may cause new problems. However, if the corrections are relevant for your system, you should integrate the patches. SAP Note 1080821 describes how patches are imported with a single step using the Support Package stack option. This is possible as of JSPM 7.0 Support Package 14.\n\nStep 2 — Preparation\n\nFirst, create a backup of the Java system and the database.\n\nDownload the required Support Packages from the SAP Service Marketplace. The files can be found under http://service.sap.com/sp-stacks. For all systems based on NetWeaver 7.0, you must download the files using the Maintenance Optimizer of the SAP Solution Manager. During the download, a stack definition file of type XML is created. Copy the Support Package stack files and stack definition file to your JSPM inbox directory.\nEnsure that the JSPM inbox is configured correctly. Usually, the path is: /usr/sap/trans/EPS/in. This path must be set in the instance profile (Parameter DIR_EPS_ROOT) and in the JSPM configuration file (usr\\ sap\\<SID>\\SYS\\j2ee\\JSPM\\param\\jspm_config.txt). There, the parameter /jspm/inbox must indicate this path. The operating system user, <sid>adm, requires read access to the JSPM inbox.\n\nRefer to the SAP online help and the respective Support Package Stack Guide for more detailed instructions. These can be found under http://service.sap.com/maintenance NW70.\n\n**Step 3 — Perform Update**\n\nLog on to the central instance as <sid>adm. The J2EE Engine and the SDM server must be running. No application may be connected to the SDM server because only one connection may be established to this server. If, for example, a user is connected to the SDM server via the SDM GUI, the JSPM cannot establish a connection with the server at the same time. Start the JSPM and enter your SDM password. Proceed as described in the Support Package Stack Guide. After the import has been completed successfully, you can fill in the feedback form.\n\n### 17.5 Support Package Stacks\n\nIn 2003, SAP added *Support Package stacks* (SP stacks) to its Support Package strategy for some product versions. This new strategy supports the import procedure for most customers and Support Packages, improves quality and service, and thus reduces ongoing operating costs.\n\nThe increasing range and complexity of components within individual product versions makes it necessary to improve the transparency of Support Packages and patches, and to clearly specify the recommended or permitted combinations. Therefore, a new SP stack is compiled for every product version that is updated via the new strategy, usually on a quarterly basis. This stack contains the optimal combination of Support Package and patch levels for the individual components at the time of the stack release.\nTherefore, SP stacks are combinations defined by SAP for each product version. SAP recommends that you import these stacks on a regular basis. Although the underlying technology of the individual Support Packages and patches does not change with this stack approach, an SP stack should be regarded as a whole. In other words, although you should take into account any minimum requirements of or dependencies between the individual components, the Support Packages and patches contained in the stack must be imported together.\n\nBenefits By reducing the range of theoretically possible combinations to practical, real-world combinations, several benefits result for the customer:\n\n- The quality of the individual Support Packages is improved because other associated components are maintained to a known minimum level. As a result, corrections are less complex and of a higher quality.\n- Quality and compatibility within the set combinations are improved because SAP’s own tests can focus more on these combinations.\n- Download pages that are tailored to SP stacks make it easier to download required Support Packages and patches.\n- Import instructions can also be tailored to the combination to be imported, reducing the time and effort required for the import process.\n- The general level of knowledge about any restrictions, and transparency about side effects and their solutions, are better overall for SP stacks than for individual combinations. Potential problems can be prevented and, when they occur, solved more effectively. This, in turn, reduces operating costs.\n\nReducing TCO SP stacks support the requirements of customers with live applications for regular Support Package and patch recommendations, and their need for minimum total cost of ownership (TCO). For customers with upgrade or implementation projects, the minimum requirements may involve other (higher) recommendations than the most recent SP stacks.\n\nImplementing SP stacks leads to a reduction in complexity, increased quality, improved transparency, and simplified repair and maintenance. SP stacks further reduce the risks to live operations and help expedite\nthe resolution of problems. They are another step toward reducing total cost of ownership (TCO).\n\nAfter an SP stack is released, details of the relevant information and download site are available from the SAP Service Marketplace via the Quick Link /sp-stacks, as shown in Figure 17.27.\n\nAdditional information on specific SP stacks is available from the relevant Release and Information Note (RIN), which is available via a link on the previously mentioned page.\n\n**Figure 17.27** Downloading Support Package Stacks from the SAP Service Marketplace\n\n### 17.5.1 SP Stack Strategy with the Usual Import Procedure\n\nIt has been established that most customers carry out planned maintenance for each live application between one and four times a year, and that this maintenance process usually covers all of the components of each application.\n\nIn practice, the frequency of planned maintenance operations depends on many factors. These include the following:\n\n<table>\n<thead>\n<tr>\n<th>SAP NETWEAVER 7.0</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Step 1 of 3 - Choose your Source and Target Stack</strong></td>\n</tr>\n<tr>\n<td><strong>Please choose the Source Stack and then the Target Stack</strong></td>\n</tr>\n<tr>\n<td><strong>Remark:</strong> The Source Stack is not mandatory so if you do not know it, leave the field empty.</td>\n</tr>\n<tr>\n<td><strong>Target Stack:</strong> SAP NETWEAVER 7.0-16 (09/2008)</td>\n</tr>\n<tr>\n<td><strong>Source Stack:</strong> 14 (01/2000)</td>\n</tr>\n<tr>\n<td><strong>Restrict according to Usage</strong></td>\n</tr>\n<tr>\n<td>[ ] Development Infrastructure</td>\n</tr>\n<tr>\n<td>[ ] Application Server ABAP</td>\n</tr>\n<tr>\n<td>[ ] Process Integration (PI)</td>\n</tr>\n<tr>\n<td>[ ] Enterprise Portal</td>\n</tr>\n<tr>\n<td>[Next Step]</td>\n</tr>\n</tbody>\n</table>\n\n**Additional Information**\nThe customer's specific situation (projects, live status, etc.)\n- The product in question (technical factors, statutory changes, etc.)\n- The benefits of having the latest release when support is required\n- The customer's assessment of the risk of encountering known errors (and therefore, of incurring unnecessary costs and having to react at short notice)\n- The expected costs of a planned maintenance operation\n\nAs a result, a standard rule for calculating the optimal time and frequency of planned maintenance operations does not exist. Customers decide on the optimal conditions, taking into account their individual circumstances. However, SAP recommends that customers run a planned maintenance operation at least once a year, and preferably two to four times a year, regardless of whether problems have arisen. This keeps the risks previously outlined manageable. SAP assumes that the latest SP stack will be imported as part of a planned maintenance operation, and that the SP stacks in use in a system landscape are not retained beyond one year. As mentioned before, if problems occur, SAP can instruct customers to import the latest Support Packages or patches, independently of the SP stack cycle.\n\nUnexpected problems can occur at any time, regardless of planned maintenance operations. They have to be fixed as quickly and straightforward as possible. A range of different mechanisms is available for this purpose, and the decision which device to use depends on the affected component and the actual problem. These mechanisms include correction instructions for ABAP-based tracks (which can solve problems relatively localized, and in a targeted way) and Java Support Packages (which, for technical reasons, usually contain other problem solutions and whose effects are therefore not as restricted to the local environment as ABAP-based tracks are).\n\nThe SP Stacks strategy goes hand in hand with the general combination of planned maintenance and specific corrections that are provided in the meantime:\n- The frequency with which SAP provides Support Package stacks depends on the age and maturity of the product. For new releases, new Support Package stacks are delivered every two months. For older releases, SP stacks are provided only twice per year.\nThe frequency of SP stack deliveries is intended to complement the frequency of planned maintenance operations. This does not mean, however, that planned maintenance must be carried out at the SP stack interval. Based on your assessment of the previously discussed factors, you can temporarily postpone the import of an SP stack, provided that your system does not contain any errors that necessitate the import of up to date Support Packages or patches. You can catch up with any Support Packages you postpone when you import the next SP stack.\n\nSP stacks contain Support Package combinations that you should change only in exceptional cases; for example, if a problem has occurred that can be solved only by a change. In such cases, you should keep the modification as small and as local as possible. Of course, you can also import new Support Packages or patches as a preventative measure if circumstances in the system indicate that the error in question is likely to occur. However, in many cases, you will be able to make a local correction via the correction instruction in a Note, for example.\n\nComponents of an SP stack that are not in use, or not in live use, in a system landscape do not have to be patched when an SP stack is imported, provided they have no technical or logical dependencies with any components that are in active use. You should note, however, that the Support Package or patch levels of components that are in use cannot be lower than the levels of the combination set in the SP stack.\n\nIf unexpected problems are identified in an SP stack, they will usually affect only a few customers. Therefore, it is not necessary to change the general recommendation for the planned maintenance processes.\n\nInstead, a Release and Information Note (RIN) is used to inform all customers of the general release of an SP stack, possibly including information about potential problems. As discussed previously, notification of critical errors is communicated via HotNews Notes. A special reporting tool in the SAP Service Marketplace can be used to find out about known side effects of all types of Support Packages (Quick Link http://service.sap.com/side-effects).\nAny differences between Support Package levels or patch levels and the relevant SP stack should be documented in Notes. This approach is used only for problems or other special cases (such as statutory changes or for customers' project or implementation phases). This also applies to Support Packages or patches that have been created since the last SP stack, and that will be part of subsequent SP stacks.\n\nIt is also possible that Support Packages or patches may exist that are more up to date than those contained in the last SP stack. Nevertheless, as long as your system is not experiencing any problems, the general recommendation is that you use the combination contained in the latest SP stack. Any Support Packages or patches that are created in the interim are reserved for the special cases mentioned previously.\n\nThe full-stack approach applies to Java-based systems in particular. This means that you always have to import the complete stack. Deviating combinations have not been tested and frequently cause problems. Individual Support Packages should only be imported in coordination with the SAP support team.\n\n17.5.2 Cross-System Support Package Stacks\n\nIn some cases, it may be necessary to import the same Support Package stack across the system, for instance, if the ESS/MSS scenario runs on an ERP backend system and in an external Portal. In this case, the Support Package levels of the Web Dynpro sources that are imported into the portal must match with the Support Package levels in the SAP ERP backend. At the same time, they are also part of the Portal stack so that the entire Support Package stack in SAP NetWeaver Portal must correspond to the Support Package stack in the SAP ERP backend. A similar situation applies to Web Reporting in SAP NetWeaver BI 7.0.\n\n17.5.3 Details of the Components in SAP Support Package Stacks\n\nBased on one “leading” application component, SP stacks represent a combination of preset or recommended Support Package levels and patch levels of product version's other components. Dependencies are defined step-by-step in a “top-down” fashion (see the example that follows).\nFor some components such as the SAP GUI, stacks specify one level for each possible release. Other components may be optional; that is, the relevant Support Package or patch level must be fulfilled only if the component in question will be in use in a production system (for example, an SAP ERP Enterprise Extension).\n\nThe basic rule is that the other components must have at least the specified level for you to be able to import a Support Package for the leading component. Also, a higher level is recommended for most components only for problems where a local correction (such as a correction instruction) or a workaround does not exist.\n\nAn SP stack can consist of the following:\n\n- A Support Package level of a leading application component (such as SAP_APPL 4.6C), which serves as the name of the SP stack.\n- A Support Package level of the application basis (such as SAP ABA 4.6C) that is a prerequisite for the previously mentioned application Support Package and that would not usually be overwritten until the next SP stack.\n- A Support Package level of the basis layer (such as SAP Basis 4.6C) that is a prerequisite for the previously mentioned ABAP Support Package and that would not usually be overwritten until the next SP stack.\n- A recommended kernel patch level (such as SAP KERNEL 4.6D) that would not usually be overwritten until the next SP stack, provided that there are no problems. This kernel patch level is intended for use on the operational level and can be higher than the upgrade level for the release in question (in this case, follow the instructions in the upgrade documentation or the relevant Notes).\n- A minimum patch level for every possible SAP GUI release (such as 4.6D/6.20 for Windows, and 6.20/6.30 for Java). Note that the releases in this case should initially be regarded as alternatives and that each patch level is a minimum requirement that can be overwritten at any time. This minimum requirement within an SP stack will be increased only in exceptional cases. However, because the SAP GUI is a component of almost all SAP products, the requirements of the SP stacks of different products that are used in parallel must be coordinated with each other. In this case, it is the maximum required SAP\nGUI release with the maximum required patch level that is relevant. Other conditions may also arise in the context of product-specific GUI add-ons.\n\n- A minimum patch level for every possible SAP ITS release (such as 4.6D, 6.10, and 6.20) is recommended. The different releases should be regarded as alternatives, similarly to the SAP GUI.\n- Optional components might require the specified level only when the component in question is in production use.\n\n### 17.5.4 SP Stack Calendar\n\nEither the product versions listed in the SP stack calendar (see Figure 17.28) are already supported by SP stacks, or SP stacks will be introduced for them in the near future. Every SP stack is “led” by a particular component or Support Package track, and the relevant Support Package is a central component of this. After the first SP stack is released, this signals the start of the new strategy for that product version.\n\n\n17.6 Side Effects\n\nThe SAP Service Marketplace has a reporting tool that helps you avoid unwanted side effects. Side effects can occur in rare cases after a Support Package or an SAP Note has been imported. The tool enables SAP customers to reduce their internal support costs and increase the stability of their SAP solution.\n\nSAP Support Packages consist of several SAP Notes, each of which contains software corrections. Importing Support Packages and Notes increases system stability and protects the system from known problems. Nonetheless, it can still happen that a Note that is intended to solve one problem can actually cause another problem. To solve this new problem, a new Note is created that is linked to the first Note.\n\nThis tool is intended to make these dependencies easier to handle. If you’re importing a Support Package or an SAP Note, you can search for any known side effects and correct these, if necessary. The tool enables you to proactively prevent problems that could occur after an import.\n\nInformation about side effects is defined in the Note attributes. The reporting tool identifies all side effects that will be caused by the Notes contained in the Support Package. Therefore, to protect your system from unwanted side effects, import these Notes after you import the Support Package.\n\nThe Quick Link [http://service.sap.com/notes](http://service.sap.com/notes) in the SAP Service Marketplace provides information about known side effects of individual SAP Notes (see Figure 17.29).\n\nTo obtain a list of all of the side effects of a Support Package or an SP stack, use the reporting tool in the SAP Service Marketplace (Quick Link: [http://service.sap.com/side-effects](http://service.sap.com/side-effects)).\n\nUse this tool just before you import a Support Package to see the most up to date list of side effects.\n\nSide effects that have already been eliminated by other Support Packages in the same queue are automatically removed from the results list. This list is tailored to your Support Package queue. It is sorted by application component, so that you can easily skip Notes that belong to applications you do not use.\nNote that it can take several hours to create the results list. The system sends you an email when the list is complete. Figure 17.30 shows the beginning of a side-effect report.\n\nSAP began side-effect reporting in July 2003. Complete information on the side effects of earlier Notes is not available.\n17.7 Questions\n\n1. What are the benefits of importing SAP Support Packages?\n A. Proactive solution of known problems\n B. Functional extensions to SAP software\n C. Improved ease of maintenance and reduced time and effort for repairs and maintenance\n\n2. Which of the following statements are true with regard to the SAP Note Assistant?\n A. It simplifies the maintenance of programs in the customer namespace.\n B. It enables you to import Notes that contain code corrections.\n C. It simplifies the process of making changes to Data Dictionary objects.\n D. It identifies dependencies between SAP Notes.\n E. It can replace the process of importing Support Packages.\n\n3. Which of the following statements are true with regard to Support Packages?\n A. They change the SAP standard of your SAP system before the next release upgrade.\n B. You can import all types of Support Packages into all SAP systems, regardless of the components installed in the target system.\n C. Support Packages are available only to customers who are taking part in the ramp-up.\n D. Different types of Support Packages may be required for SAP systems with different components.\n\n4. Which of the following statements are true with regard to the SAP Patch Manager?\n A. The Patch Manager ensures that Support Packages are imported in the correct order.\n B. The SAP Patch Manager does not check whether the type of Support Package you want to import is suitable for your SAP ERP installation. You have to determine whether you need a particular Conflict Resolution Transport, for example.\nC. The SAP Patch Manager does not allow you to protect SAP objects you have modified. These objects are automatically overwritten.\n\nD. The SAP Patch Manager automatically opens Transactions SPDD and SPAU for the modification adjustment process, if required.\n\n5. **Which of the following statements are true with regard to Support Package stacks?**\n\nA. Support Package stacks are combinations of Support Packages that are recommended by SAP.\n\nB. Support Package stacks should be imported only if an urgent problem is preventing an import from being carried out.\n\nC. Support Package stacks are Support Package combinations that have been particularly well tested by SAP.\n\nD. The SAPGUI version also must be upgraded to the latest level with every Support Package stack upgrade.\n\n6. **Which of the following statements are true with regard to ABAP and Java corrections?**\n\nA. An ABAP Support Package always overwrites all objects of a software component.\n\nB. A Java Support Package always overwrites all objects of a software component.\n\nC. An individual ABAP program can be changed using an SAP Note that contains a correction instruction.\n\nD. An individual Java program can be changed using the Software Deployment Archive (SDA).\n\n7. **Where can you find version information about a Java system?**\n\nA. Under \\http://<hostname>:\\<port>/sap/monitoring/ComponentInfo\n\nB. In the SAP System Landscape Directory (SLD)\n\nC. In the system status information of the ABAP stack (only for dual-stack systems)\n\nC. In Transaction SPAM of the ABAP stack (only for dual-stack systems)\nIndex\n\n5-1-2 maintenance strategy, 720\n/TMWFLOW/CMSCONF, 840\n\nA\n\nABAP, 905\nABAP Dictionary, 35, 905\nABAP Editor, 905\nABAP programs, 563\nABAP software components, 765\nABAP Workbench, 36, 54, 905\n ABAP Dictionary Maintenance, 54\n ABAP Editor, 54\n Function Builder, 54\n Menu Painter, 54\n Screen Painter, 54\n Tools, 347\nABC analysis, 695\nAction log file, 515\nActivation, 906\nActivation of the enqueue definitions, 545\nActivity, 605, 608\nActivity group, 906\nAdd-on patch, 905\nAdjustment transport, 742\nAdministrative change, 838\nADO, 905\nADO import, 545\nALE, 906\n Customizing distribution, 906\nAlert Monitor, 906\nAPI, 907\nAppends, 57\nApplication data, 41, 312, 907\n Eliminate, 160\n Master data, 41\n Transaction data, 41\nApplication Link Enabling (ALE), 127, 906\n Customizing Distribution, 128\n Scenario, 128\nApplication server, 907\nApplication Specific Upgrade (ASU), 725, 907\n Toolbox, 725\nArchiveLink, 907\nArchiving object, 907\nAssembly, 577, 578\nAssembly line, 70\nAssign S-User, 853\nAuthorizations\n NWDI, 597\nAutomatic recording of changes, 907\nAutomatic transport, 433\n\nB\n\nBackground\n Jobs, 243\n Work processes, 244\nBackground processing, 915\nBackup domain controller, 249, 264, 908\n Activation, 266\n Definition, 265\nBAPI, 908\nBatch input, 908\nBuild\n Incremental, 610\n Process, 578\n Space, 610\nBusiness Configuration Sets (BC Sets), 104, 448, 908\nBusiness functions, 861\nBusiness partner, 836\nBusiness process, 915\nBusiness Server Pages, 573\nBusiness validation, 197\n Test cycle, 198\n Testing procedures, 197\n Test plan, 198\nBusiness validation period\n Tests, 169\nIndex\n\nButton, 912\nByte code, 576\n\nC\n\nCATT, 201, 909\nCBS, 910\nCCMS, 909\nCentral User Administration, 132\nChange Advisory Board, 825\nChange Analysis, 802, 842, 906\nChange and Transport Organizer (CTO),\n 123, 239, 909\n Initialization, 239\nChange and Transport System, 122, 909\nChange groups, 845\nChange list, 605\nChange Management Service, 581, 909\n Create domain, 602\n Create track, 602\nChange Management Work Center, 833\nChange manager, 825, 909\nChange of release, 719\n Process, 724\n With additional development system,\n 749\nChange option\n Client-dependent, 75\n Client-independent, 77\nChange request, 110, 834, 906\n Action log, 457\n Additional users, 417\n Add users, 369\n Change owner, 369, 418\n Create, 367\n Default settings, 368\n Document, 456\n Documentation, 174\n Export, 177, 180, 455\n Forward, 502\n Identify, 427\n IMG setup, 174\n Import, 154, 181, 487, 534\n Import all, 182\n Into multiple clients, 511\n Local, 363\n Manage, 172\n Merge, 466\n Multiple object lists, 375\n Object list, 372\n Owner, 178\n Preliminary import, 183\n Protect, 370\n Repository object checks, 178\n Strategy, 148\n Target client, 496\n Task, 363\n Technical representation, 112\n Transport, 179\n Transportable, 362\n Transport all objects, 375\n Types, 110\n Unit testing, 175\n View, 364\nChange Request Management (ChaRM),\n 201, 821, 909\nChange Request Management Workflow,\n 824\nChanges, 110\n Automatic, 421\n Automatic recording, 145\n Client-independent, 112\n Copy with Transaction SCC1, 459\n Export, 116\n Import, 117\n Manual, 422\n Promote, 114\n Release, 116\nChange tracking, 839\nChange types, 836, 845\nClient, 918\n Change option, 308\n Compare, 305, 919\n Copy, 134\n Create, 142\n Customizing differences, 444\n Customizing settings, 437\n Export, 155, 317\n ID, 305\n Import, 319\n\n980\nLogical system name, 305 \nName, 305 \nProtection, 305, 308 \nRestrictions, 309 \nRole, 305, 307 \nSettings, 919 \nSystem resources, 329 \nTransport, 919 \nClient change option, 144 \nSettings, 144 \nClient comparison \n Display results, 440 \nClient copy, 43, 135, 305, 919 \n According to a transport request, 919 \n Background scheduling, 329 \n Local, 315 \n Monitor, 323 \n Profile, 919 \n Remote, 315 \n Restart in case of termination, 326 \n Table delivery classes, 331 \n Tool, 135 \n Tools, 310, 327 \n Verify, 323 \nClient copy strategy \n Import sequence, 156 \nClient-dependent, 918 \nClient-dependent change option, 305 \nClient-dependent customizing data, 312 \nClient entry, 302 \n Create, 302 \n Delete, 304 \n Maintain, 304 \nClient-independent, 919 \nClient-independent change option, 305 \nClient-independent customizing data, 312 \nClient role, 71 \n critical, 68 \n distribution, 83 \nClient/server architecture, 32 \n application service, 32 \n data base service, 32 \n presentation service, 32 \nClient/server technology, 31 \n example, 33 \nClient setting, 305 \nCity, 305 \nRestrictions, 305 \nStandard currency, 305 \nClient-specific transport route, 918 \nClient tool, 301 \n authorization profile, 341 \n Client transport, 317 \n Advantages, 310 \n Special transaction, 326 \nClose coupling, 621, 633, 913 \nCluster environment, 706 \nCMS, 909 \nCMS domain, 602 \nCMS user, 597 \nCode freeze, 695, 741, 747 \nCode Inspector, 695 \nCode page, 769 \nCombined Unicode & Upgrade Conversion (CU&UC), 774, 775, 910 \nCommon Information Model, 593 \nCompare transport requests, 840 \nComparison runs, 813 \nComponent Build Service, 581, 910 \nComponent model, 697 \nComputer Aided Test Tool (CATT), 129, 201, 909 \nConfigStore, 848 \nConfiguration and File Reporting, 848 \nConfiguration process \n Technical aspects, 270 \nConflict Resolution Transport (CRT), 910 \nConsolidation \n Route, 917 \n System, 917 \nConsolidation route, 252 \nContainer (J2EE), 577 \nControl file, 926 \nCopy from client, 461 \nCorrection, 917 \nCorrection instruction, 653 \n Validity, 661 \nCorrection task, 364 \nCPI-C, 910 \nCreate a J2EE application, 607 \nCreate customer development class, 351, 386, 387 \nCreate domain in the CMS, 602\nCreate track in the CMS, 602\nCritical object, 507\nCRMD_ORDER, 831\nCross-system tool, 104\nCTO, 123\nCTS, 122\nCTS+, 910\nCTS project, 827, 910\nCurrent settings, 435, 917\n Customizing activities, 436\nCUST, 69\nCustomer development, 913\nCustomizing, 46, 48, 69, 98, 910\n Change request, 172\n Client-dependent, 77, 458\n Client-independent, 77\n Implementation Guide (IMG), 45, 48\n Prerequisites, 409\n SAP ERP Reference Model, 47\n User authorizations, 410\nCustomizing activity\n Client-independent, 429\n Logging, 338, 921\n Nonstandard, 429\nCustomizing-and-development client (CUST), 69\nCustomizing change request, 111, 413, 910\n Create, 415\n Default settings, 416\n Display, 414\n Object list, 424\nCustomizing changes\n Manage, 409\n Record, 421\n Transport, 109\nCustomizing Cross-System Viewer, 104, 436, 439, 910\nCustomizing data, 40\nCustomizing Distribution, 805, 806, 911\n Procedure, 809\n Requirements, 807\nCustomizing management\n Project IMG, 410\nCustomizing objects, 420\n Client-dependent, 427\n\nLock in target system, 807\n Predefined, 807\nCustomizing Organizer (CO), 123, 911\nCustomizing requests, 427\nCustomizing Scout, 806, 811, 911\nCustomizing Synchronization, 805\nCustomizing tools, 436\n Business Configuration Sets (BC Sets), 436\n Customizing Transfer Assistant, 437\n Table comparison, 436\n View comparison, 436\nCustomizing Transfer Assistant, 449, 911\n\nD\n\nData\n Application data, 36\n Client-dependent, 31\n Client-independent, 32\n Customizing data, 36\n User master data, 36\nData archiving, 911\nDatabase, 911\n Copy, 911\n Instance, 911\n Server, 911\nDatabase copy, 158\nDatabase management system\n Relational, 37\nDatabase parameter\n dbhost, 232\n dbname, 232\nData changes\n Log, 336\nData components, 39\nData file, 911\nData selection\n Profiles, 312\nData transfer, 124\nData Transfer Workbench, 126\nDBA, 912\nDbhost, 232\nDbname, 232\nDefault change request\n Set, 423\nDelivery class, 907\nDelivery route, 253, 908\nDelta Customizing, 912\nDeployment descriptor, 578\nDesign Time Repository, 581, 912\n Check-in, 608\n Structure, 610\nDetail Viewer, 847\nDevelopment, 43\n ABAP Workbench, 45\n Class, 400\n In multiple systems, 359\n Prerequisites, 347\n SSCR key, 348\n system enhancements, 53\n Task, 364\nDevelopment changes, 347\n Development prerequisites, 347\n Manage, 347\n Transport, 109\nDevelopment class, 914\nDevelopment component, 601\nDevelopment configuration, 600, 604, 605\nDevelopment configuration pool, 600\nDevelopment database, 480\nDevelopment object, 601\nDevelopment system, 62, 141, 914\n Additional clients, 185\n Setting up, 139\nDevelopment track, 602\nDevelopment without Release, 830\nDevelopment with Release, 830\nDialog box, 912\nDialog work process, 912\nDictionary activation, 545\nDictionary import, 545\nDIR_TRANS, 234\n Windows, 235\nDISCOVERY, 786\nDispatcher, 912\nDisplay profiles, 314\nDisplay transport errors at logon, 478\nDistribution, 545\nDistribution status, 269\nDocumentation\n Change, 456\n Create, 456\nDocumentation requirements, 383\nDomain controller, 620\n Setup, 255\nDomain links, 522\nDownload basket, 851\nDowntime-minimized, 691, 796\nDowntime-minimized import mode, 691\nDTR, 912\nDual-stack system, 618, 628, 637, 781, 912\n\nE\n\nEarlyWatch, 42\neCATT, 791, 912\nEclipse, 580, 913\nEDI, 913\neLearning, 792\nEmergency Correction, 830\nEmergency production fixes, 193\nEnd mark, 497, 531, 913\n Move, 504\nEnd of Import queue, 531\nEnd user training, 792\nEnd-user training client, 74, 83\nEnhanced Change and Transport System (CTS+), 617, 619\n Combined applications, 638\n Configuration, 627\n Deploy Web Service, 620\n Export Client, 620\n Transport landscape, 635\nEnhancement, 56, 927\nEnhancement Framework, 384\nEnhancement Package (EhP), 754, 852, 861, 913\n Import, 670\nEnhancement Package Installer (EhPI), 766, 767\nEnqueue, 914\nEnqueue conversion, 545\nImport buffer, 530\n Import change requests, 533\nIndicator, 536\n tp command, 532\nImport process, 117\nImport Project All, 823\nImport queue, 118, 487\n Add change request, 504\n Changes, 191\n Check, 505\n Close, 497\n Consistency check, 506\n Delete change request, 503\n Display, 490\n Import, 512\n Inconsistencies, 122\n Manage, 502\n Manipulate, 121\n Refresh, 494\n Sequence, 120\n Significance, 120\n Status information, 490\n Transport tool check, 506\nImport service, 621\nImport SPAM/SAINT update, 680\nIndustry Solution (IS), 908\nInstallation\n System ID, 213\n Transport directory, 214\nInstance, 916\nIntegrate patches, 706\nIntegration system, 916\nIntegration testing, 146, 917\nInterface technology, 127\nInternet Transaction Server (ITS), 917\nIT Infrastructure Library (ITIL), 824, 917\n\nJ\nJ2EE Engine, 917\nJ2EE Engine components, 574\nJ2EE Explorer, 607\nJava\n Applets, 577\n Archive, 578\n Development process, 575\n Development scenarios, 585\n Servlets, 577\nJava corrections, 697\nJava correction types, 697\nJava Development Kit (JDK), 706\nJava Enterprise Beans, 574\nJava Enterprise Runtime, 574\nJava Server Pages, 573, 574, 577, 607\nJava software components, 763\nJava Software Development Kit (J2SDK), 578\nJava Support Package, 671, 698\n Import, 705\nJava Support Package Manager (JSPM), 671, 698, 701, 860, 917\nJava upgrade, 780\nJava Virtual Machine (JVM), 576\n\nK\nKernel, 35\n\nL\nLAN, 917\nLayered development, 592\nLegacy system, 906\nLegacy System Migration Workbench, 126\nLocal change request, 918\nLocal objects, 918\nLocks, 926\nLog files\n Evaluate, 543\n Generic, 543\n Single step, 543\nLogical component, 826\nLogical system, 918\nLogical system names\n Application Link Enabling (ALE), 305\n SAP Business Workflow, 306\nLoose coupling, 621, 633, 918\n\n985\nIndex\n\nM\n\nMain import, 545\nMaintenance cycle, 831, 931\nMaintenance Optimizer, 803, 918\nMaintenance Optimizer BC Set, 853\nMaintenance procedure, 855\nMaintenance process\n Implementation phases, 168\nMaintenance strategy, 720\nManual transports, 433, 919\nMaster data, 125, 926\n Import, 126\n Template, 128\n Transfer, 126\nMDMP, 919\nMode, 920\nModification, 59, 378, 381, 919\n Make, 382\n Recommended, 61\n SSCR, 62\n SSCR key, 382\nModification adjustment, 60, 735, 736, 920\n Data dictionary objects, 737\n During release changes, 739\n During the import of Support Packages, 742\n Programs, 738\n Tables, 738\nModification Assistant, 61, 379, 745, 920\nModification Browser, 381, 919\nModification-free enhancement, 384\nMove nametabs, 545\nMultiple-client concept, 79\nMultiple-client operations\n limitations, 79\n protective measures, 81\nMultiple Display Multiple Processing (MDMP), 769, 919\n\nN\n\nName range, 242, 920\nNamespace, 103, 242, 920\n\nNametab, 920\nNaming convention\n Actlog, 557\n Buffer, 558\n Cofiles, 558\n Data, 558\n Define, 359\n Log, 558\n Sapnames, 557\nNew BAdIs, 384, 388\nNon-ABAP system, 619, 627, 635, 920\nNotification of imports, 189\nNo transport, 434\nNumber ranges, 332\n\nO\n\nObject\n Checks, 921\n List, 920\nObject attributes, 400\nObject checks, 468\nObject Directory, 398, 920\nObject directory entry\n Change, 401\n Display, 401\nObject list, 424\n Add, 374\n Change, 376\n Display, 372\n Lock objects, 377\n Unlock objects, 377\nObject locking, 371\nOCS, 921\nOne-system landscape, 86\nOriginal language, 400\nOriginal object, 921\nOriginal system, 378, 400\nOS/DB migrations, 770\n\nP\n\nParameter type\n Database-specific, 229\n Global, 229\nOperating system-specific, 229\nSAP ERP system-specific, 229\nPatch, 698\nPerformance, 921\nPerson responsible for object, 400\nPhased system landscape, 94\n Customizing, 98\n Development, 98\n Final quality assurance system, 95\n Production support system, 95\n Realization, 96\n Requirements, 95\n Standard client role, 96\nPortal content, 763\nPortal Content Studio, 622\nPost-import issues, 188\nPost-import processing, 509\nPost-installation processing, 140\n Industry solution, 140\n Language, 140\n Support Packages, 140\nPreliminary import, 499, 931\n Expert mode, 500\n Multiple change requests, 500\nPreliminary import option u0, 536\nPREPARE, 724, 775, 921\n Phase, 730\nPresentation server, 35, 921\nProcessing status, 442\nPROD, 70\nProduct, 601\n Create, 600\nProduction client, 69, 70\n Customizing, 435\nProduction environment\n Validation, 161\nProduction system, 82, 921\n Import, 190\n Lifecycle, 719\n Setup, 146\nProduction systems, multiple, 90\n Customizing, 94\n Development, 94\nProfile Generator, 921\nProject Cycles, 828\nProject IMG, 51, 921\n Customizing, 418\n Tree structure, 418\nQA Approval Process, 193\nQTST, 70\nQuality assurance, 193\n System copy, 159\nQuality assurance client, 69, 70, 115\nQuality assurance procedure, 151, 922\nQuality assurance system, 82, 114, 134, 921\n Setup, 146\nQuality assurance test client, 148\nQuick Sizer, 789\nR/3, 922\n System, 922\n System service, 922\nR3load, 773\nR3trans, 122, 123, 560, 922\nr3transpath, 236\nRamp-up, 922\nRamp-up procedure, 721\nRDBMS, 922\nRDDIMPDP, 922\nRecipient system, 908\nRegression testing, 129\nRegular correction, 822, 836\nRelease, 601, 915\n Error, 462, 467\n Process, 455\nRelease and Information Note, 711\nRelease change\n With five systems, 750\nRelease Customizing, 922\nRelease Management, 828\nRelease strategy, 720\nRelease upgrade, 852\nRelocation transports, 930\nRemote client copy\nAdvantages, 311\nRemove change documents, 340\nRepair, 364, 378, 923, 924, 925\nRepair flag, 379, 400, 923\nReport, 461\nVariants, 461\nRepository, 922\nObject, 923\nSwitch, 923\nRepository Browser, 923\nRepository object, 35, 102\ncreate, 53\nVersion management, 480\nRepository object, customer-developed\ncustomer development class, 56\ncustomer name range, 56\nnamespace, 56\nRepository switch, 729\nResource constraints, 334\nRestricting customer object names, 358\nReturn code, 546, 923\nRFC, 923\nRFC connections, 271\nRFC system check, 317\nRoadmap, 923\nRoles\nNWDI, 597\nRoot cause analysis, 802, 843\nRuntime environment, 917\n\nS\n\nSAINT, 643, 672, 680, 765, 860, 923\nSample transaction data, 129\nCreate, 129\nSandbox client, 74, 83, 115\nSAP Add-on Installation Manager, 643\nSAP Add-on Installation Tool, 672, 680\nSAP client, 301\nCreate, 302\nData, 309\nDelete, 333\nSet up, 301\nTest run, 334\nSAP component model, 600, 697\nSAP ERP buffer synchronization, 554\nSAP ERP change request\nTransport, 213\nSAP ERP client, 31, 37\ndefinition, 74\nSAP ERP client roles, 68\nSAP ERP database, 31, 35\ncustomer data, 36\nSAP ERP data components, 31\nSAP ERP Repository, 35\nSAP ERP Repository, 31\nABAP Dictionary, 35\ncontainer, 31\nSAP ERP Repository object\nChanges, 347\nSAP ERP Repository object, customer-developed, 55\nSAP ERP Solution Browser, 788\nSAP ERP system\nCopy, 134\nCustomizing, 32\nimplementation, 32\nSAP ERP system administration\noptimization, 31\nperformance, 31\nSAP ERP system landscape, 67\nManage, 109\nSapevt, 560\nSAP Going Live Functional Upgrade\nCheck, 790\nSAP GUI, 924\nSAP HotNews, 644\nSAP J2EE Engine, 574\nSAP Java Support Package Installation\nManager, 643\nSAPjup, 780, 925\nSAP Maintenance Optimizer, 205, 758, 851, 861\nSAP NetWeaver Developer Studio\n(NWDS), 580, 924\nSetup, 599\nSAP NetWeaver Development\nInfrastructure (NWDI), 573, 580, 618, 924\nConfiguration, 584, 592\nHardware requirement, 585\nIndex\n\nSOLAR01, 870\nSOLAR02, 870\nSOLAR_EVAL, 870, 871\nSOLAR_LEARNING_MAP, 874\nSOLAR_PROJECT_ADMIN, 865, 870, 872\nSOLMAN_WORK_CENTER, 865\nSolution, 805, 918\nSOLUTION_MANAGER, 843\nSolution Manager Key, 875\nSolution Manager project, 804, 826, 925\nSolution Manager work center, 865\nSort and compress, 471\nSources of errors, detect, 553\nSPAM, 643, 860\nSPAM Update, 926\nSPAU, 664, 735, 736, 739, 743, 773\nSPAU_ENH, 397\nSPDD, 731, 736, 739, 742, 773\n Adjustment, 731\nSpecialized development client, 73\nSplit-Screen Editor, 658\nSPUM4, 773, 775\nSPUMG, 773, 774, 775\nSQL, 926\nSSCR, 55\nStabilize production period, 169\nStack configuration file, 852\nStandard client, 69, 142\nStandard configuration\n Activate, 280\n Distribute, 280\nStandard currency, 306\nStandard maintenance, 720\nStandard request, 634, 926\nStandard SAP ERP Clients, 42\nStandard SAP object, modification, 54\nStandard SAP systems, 82\nStandard transport layer, 252, 926\nStopmark, 531, 537, 926\nStructure conversion, 545\nSUMG, 774\nSupport, 202\nSupport Package, 205, 669, 851, 926\n Authorizations, 673\n Benefits, 669\n Collection, 926\nDefine queue, 684\nDowntime-minimized import mode, 691\nImplementation cycle, 695\nImport, 671, 854\nImport into a system landscape, 693\nImport queue, 687\nJava, 671, 698, 705\nLoad, 681\nPost-process, 663\nSide effects, 715\nStack, 927\nTypes, 671\nSupport Package Manager, 671, 737\n Import phases, 680\nSupport Package stack (SP stack), 205, 707\n Calendar, 714\n Components, 712\n Cross-system, 712\nSwitch, 727\nSwitch and Enhancement Framework, 927\nSynchronization objects, 807, 811, 927\n Create, 819\n Load, 821\nSynchronized upgrade, 781\nSystem\n Change option, 927\n Copy, 927\n Landscape, 928\nSystem change option, 103, 112\nSystem copy, 134, 158\n Strategy, 158\nSystem identification, 37\nSystem ID (SID), 112, 213\nSystem landscape, 139\n alternatives, 86\n complex, 89\n global, 100\n Maintenance, 167\n multiple production, 90\n Release change, 747\nSystem Landscape Directory (SLD), 582, 924\n Configuration, 593\nSystem landscape setup\n Methods, 162\n Verify, 294\nSystem name, 528\nSystem status, 266\nSystem switch, 728, 730\nSystem switch upgrade, 927\n\nT\n\nTABIM_UPG, 734\nTable log analysis, 337\nTable logging, 145, 335, 928\nTarget client\n Set, 495\nTarget group, 931\nTask, 907\n Release, 462\n Types, 363\nTask list, 832\nTCP/IP, 928\nTechnical upgrade, 724, 793\nTechnical usage, 861\nTechnical usage, 757\nTest imports, 474\nTest messages, 838\nTest Workbench, 200, 791\nThree-system landscape, 82\nTMS, 123\nTMS authorization, 523\nTMS communication system, 620\nTMS setup\n Issues, 548\n Verify, 295\nTMS Trusted Services, 274\ntp, 122, 528, 560\n And ABAP programs, 564\n Authorization, 529\n Commands, 530\n Command syntax, 529\n Performing imports, 533\n Prerequisites, 528\n Processing sequence, 538\n Return codes, 547\ntp system log, 514\nTrace analysis, 802\nTransaction code, 928\nTransaction data, 128, 908\n Interfaces, 130\n transdir, 233\nTransfer Assistant, 104\nTransport, 928\n Adjust, 517\n Between transport domains, 517\n Between transport groups, 515\n Control information, 530\n Control program, 929\n Directory, 929\n Domain, 928\n Domain controller, 928\n Group, 928\n Java, 611\n Java projects, 611\n Layer, 929\n Log, 188, 929\n Management, 179\n Process, 179\n Profile, 929\n Request, 928\n Route, 930\nTransportable change request, 929\nTransport capability\n Configuration, 238\nTransport control\n Extended, 185\nTransport control program, 122, 528\nTransport directory, 214, 620\n Bin, 218\n Buffer, 218\n Clean up, 558\n Cofiles, 218\n Common, 223\n Ctopl, 219\n Data, 218\n Eps, 219\n In heterogeneous operating systems, 224\n Log, 219\n Naming conventions, 556\n Olddata, 219\n On AS/400, 223\n Prerequisites, 220\n Sapnames, 219\nIndex\n\nSetup, 219\nStructure, 217\nTmp, 219\nUnix, 221\nWindows, 221\nWith Windows and Unix, 224\nTransport domain, 248\nChanges, 264\nComplement external system, 262\nConfiguration, 519\nController, 249\nExtension, 257\nSetup, 254\nVerify, 266\nTransport group, 215, 217, 250, 257\nTransport layer\nClient-specific, 292\nTransport log, 476\nManage, 478\nTransport Management System (TMS), 123, 929\nAlert monitor, 297\nConcepts, 247\nInitialize, 255\nSetup, 141, 147, 247\nTerminology, 247\nTransport non-ABAP objects, 617\nTransport object, 403\nTransport of copies, 837\nTransport Organizer (TO), 123, 403, 929\nTransport Organizer Web UI, 620, 623, 929\nTransport parameter\nabapntfmode, 881\nalllog, 882\nallow_rc4, 882\nbuffreset, 882\nbufreftime, 882\nc_import, 883\ncfilelifefime, 883\ncommunication_system, 883\necc, 884\ndatalifefime, 884\ndbcodepage, 884\ndbconfpath, 885\ndbhost, 885\ndblibpath, 885\ndbllogicalname, 886\ndbname, 886\ndbswpath, 886\ndbtype, 887\ndummy, 887\nexporttoascii, 888\nimpmon_mode, 888\ninformixdir, 889\ninformix_server, 888\ninformix_serveralias, 888\ninformixsqlhost, 889\nk_import, 889\nlanguage, 889\nloglifefime, 890\nmssql_passwd, 890\nmssql_user, 890\nnbufform, 891\nnew_sapnames, 891\nnon_abap_system, 891\nolddatalifefime, 892\nopticonnect, 892\nr3transpath, 892\nrecclient, 893\nrepeatonerror, 893\nsetunicodeflag, 893\nsourcesystems, 894\nstopimmediately, 894\nstoponerror, 894\nsyslog, 895\ntargetsystems, 895\ntestimport, 896\ntestsystems, 896\nt_import, 895\ntp_version, 897\ntransdir, 897\nvers_at_imp, 897\nw_import, 898\nTransport process\nTechnical aspects, 122\nTransport profile, 225\nConfiguration, 225\nDatabase parameter, 231\nParameter, 225\nParameter type, 229, 230\nPath-specific parameter, 232\nPredefined variables, 230\nProfile syntax, 228\nR/3 Release 4.5, 225\nTransport profile parameter, 881\nTransport request\n CTS+, 634\n Non-ABAP, 623\nTransport route, 251\n Client-specific, 115, 289\n Configuration, 276\n Create, 277\n Define, 114\n Standard configuration, 277\nTransport route configuration\n Change, 281\n Extend, 281\n Extended transport control, 288\n Verify, 296\n Version control, 288\nTransport tools, 560\n Interactions, 561\nTU&UC, 774, 776\nTwin Unicode & Upgrade Conversion (TU&UC), 930\nTwo-system landscape, 87\n\nU\n\nUCHECK, 772, 776\nUnconditional mode, 534\nUnicode, 768, 930\n Hardware requirements, 777\nUnit test client, 71, 83, 143\nUnit testing, 71, 116, 458, 915\nUpgrade, 781\n Method, 796\n Project, 794\n Tests, 796\nUpgrade Assistant, 930\nUpgrade Customizing, 930\nUpgrade Roadmap, 866\nUpgrade Support, 865\nUpgrade Weekend Support, 793\nUrgent correction, 822, 838, 912\nUser data, 312\nUser Management Engine (UME), 574\nUser master data, 41, 131, 908\nUsers\n NWDI, 597\n\nV\n\nVariants, 312\nVBAP, 39\nVersion\n Database, 480\n Management, 481\nVersion database, 930\nVersion information\n Java, 700\nVersion management, 545\nView, 930\n Customizing, 420\nView table logs, 337\nVirtual system, 261, 930\n Create, 261\n Replace, 262\nVocabulary, 773\n\nW\n\nWAN, 931\nWeb Service Deploy Proxy, 629\nWeb Service Navigator, 629\nWorkbench change requests, 111, 361, 931\nWorkbench Organizer (WBO), 112, 123, 931\nWork center, 833, 865, 931\nWorkload analysis, 802\nWrite accesses, 272\n\nX\n\nXI/PI content, 762\nXPRA, 734\nXPRA execution, 545\nXSS, 763"}}},{"rowIdx":296,"cells":{"id":{"kind":"string","value":"a74e2941cdd6f2a837522442bbed75449b30c427"},"text":{"kind":"string","value":"TESTING AND MOBILITY ISSUES IN DISTRIBUTED SYSTEMS\n\nAPPROVED BY SUPERVISORY COMMITTEE:\n\nSupervisor: ________________________________\nTESTING AND MOBILITY ISSUES IN DISTRIBUTED SYSTEMS\n\nby\n\nSridhar Alagar, B.Sc., B.E., M.S.\n\nDISSERTATION\nPresented to the Faculty of the Graduate School of\nThe University of Texas at Dallas\nin Partial Fulfillment\nof the Requirements\nfor the Degree of\n\nDOCTOR OF PHILOSOPHY IN COMPUTER SCIENCE\n\nTHE UNIVERSITY OF TEXAS AT DALLAS\nJanuary 1996\nAcknowledgements\n\nWords are not sufficiently powerful to convey my gratitude to my advisor, Dr. Venkatesan. His motivation, involvement, and commitment fueled my drive to publish papers and complete my dissertation. Under his tutelage, I solved problems, improved my skills for technical writing, and matured as a researcher. Initially he was my guru, but later became like a father to me on the technical side. It is needless to say that without him I would not have completed this work, but it is important to say that knowing him was one of the best things that have happened to me.\n\nI thank Dr. Lawrence Chung, Dr. Joseph Cleveland, Dr. Simeon Ntafos, and Dr. Ivor Page for agreeing to be on the supervisory committee and for their valuable comments which improved the presentation of this dissertation.\n\nI would like to thank the faculty of the computer science department whose teachings helped me broaden my knowledge in computer science.\n\nI also thank the graduate secretaries, Sandra Bowen, Lynda Gary, and Susan Marsh, for their help during my graduate study.\n\nI would like to thank the National Science Foundation and the Texas Advanced Technology Program for their financial support in the form of research grants.\n\nSpecial thanks go to my friend and co-researcher Ramki for discussing with me often, criticizing my ideas, and constantly encouraging me. Without him, completing my graduate study would have been more difficult. I also thank\nseveral other friends for expressing their confidence in me which helped me to complete this work.\n\nFinally, and most importantly, I would like to thank my father, Alagar, my mother, Visalakshi, and my wife, Srimathi, for their unconditional support in all of my endeavors.\n\nNovember, 1995\nTesting distributed programs and coping with host mobility are among the important topics in distributed computing. Issues in testing distributed programs are considered first, and then problems posed by host mobility in distributed systems are considered.\n\nFor testing distributed systems, a hierarchy consisting of three levels is proposed. Level 1 involves selecting input data for the distributed program. Level 2 exists due to the asynchrony of the communication medium, and it consists of many runs for each input data selected at level 1. The difficulty at this level is that the number of runs for an input can be enormous. Distributed algorithms are presented to find and generate different runs.\n\nAt Level 3, a run selected from level 2 is tested. Testing at level 3 is difficult due to the combinatorial explosion of the state space. Several techniques are provided to tackle the state explosion problem while testing a run for errors that are expressed using arbitrary predicates. The techniques include space efficient algorithms, a parallel algorithm, and a method to increase the granularity of an execution step. Next, assuming that errors can be expressed using predicates in conjunctive normal form, an efficient on-line distributed algorithm is presented for detecting them.\nRecording global states is useful in setting distributed breakpoints. A message optimal algorithm for recording a global state of a system with causal message ordering is presented.\n\nNext, several distributed algorithms for communication support and fault tolerance in mobile systems are provided.\n\nConventional algorithms for causal message ordering cannot be used directly for mobile systems due to their energy constraints. Three algorithms are devised for causally ordered message delivery in mobile systems. The first algorithm handles the resource constraints of the mobile hosts. However, the algorithm is not easily scalable and does not handle hosts disconnections. The second algorithm eliminates the above disadvantages at the cost of inhibiting some messages. The third algorithm is a trade-off between the two algorithms. In all three algorithms, mobile support stations perform considerable amount of work on behalf of mobile hosts.\n\nAs mobile hosts are highly dependent on mobile support stations, coping with support station failures is important. Two schemes are presented to design mobile computing systems that can tolerate support station failures, and several related issues are discussed. Finally, a protocol to reliably broadcast messages in mobile wireless networks is provided.\nTable of Contents\nList of Figures\nList of Tables\nChapter 1\n\nIntroduction\n\nDistributed systems have gained their popularity in recent years because of declining hardware and communication costs. On-line banking, airline reservation systems, and telecommunication networks are some examples of the pervasiveness of distributed systems in everyday life. Inherent fault-tolerance through the redundancy of resources, increased performance by concurrently executing a single task on several computing modules, resource sharing, the mobility of hosts, and the ability to adapt to a changing environment are some of the advantages. In this dissertation, we consider problems in two important topics in distributed systems, namely, testing distributed programs and mobile computing.\n\n1.1 Challenges in Testing Distributed programs\n\nAlthough distributed systems have several advantages over centralized systems, they are harder to program and test than the sequential systems [?] for the following reasons. First, they consist of a number of concurrent processes. Second, a process may update its variables independently or in response to the actions of another process. Third, problems specific to the development of distributed applications are not suitably reflected by known programming languages and software engineering environments [?].\n\nThe problem of testing sequential programs has been considered by many,\nand several techniques and tools are available. These techniques cannot be applied directly to testing distributed programs due to the presence of several interacting processes. Also, the communication medium introduces non-determinism, which is absent in sequential programs. The message arrival sequence at a process in one execution for a fixed \"input data\" may be different from another execution with the same input data yielding a different result. For completeness in testing a distributed program, all possible executions for a fixed input data may have to be tested (implicitly or explicitly). Then we can vary the input data. Also, given a single execution of a distributed program, checking if it exhibits an erroneous behavior is non-trivial. For high software reliability, the processes cannot be tested independently; the processes must be tested \"together.\" But testing processes together leads to the combinatorial state space explosion problem. Clearly, testing distributed programs is hard and challenging.\n\n1.1.1 Summary of Results\n\nIn this dissertation, we present a hierarchical approach for testing distributed programs. We also present several distributed algorithms for testing at various levels of the hierarchy. Figure 1.1 shows the three levels of the hierarchy.\n\nLevel 1 of the hierarchy deals with the selection of input data from the input space. The set of all input data for the distributed program constitutes the input space. This level is common to both sequential and distributed programs. Several existing techniques for sequential programs may be extended to distributed programs.\n\nLevel 2 of the hierarchy addresses the question of non-determinism due to the communication medium. The sequence of messages received by a process may be different from one execution to another (for the same input) due to the non-determinism. Thus the execution of a distributed program for a fixed input data is not unique. One execution may not reveal an error, and we may need to test\nseveral executions. At this level, for a single input data selected from the input space in level 1, different executions are produced. We present a distributed algorithm for producing different executions for a fixed input data. Also, we show that the role of non-determinism due to the communication medium is drastically reduced in (1) distributed programs that run on unidirectional rings with FIFO channels and (2) distributed programs whose fundamental steps involve associative function computation.\n\nLevel 3 of the hierarchy involves testing a particular execution selected from the execution space in level 2. To achieve a comprehensive testing strategy, the states of the processes cannot be tested independently; “global states” have\nto be tested. We propose three criteria, namely, testing all global computations, testing by global predicate detection, and restricted predicate based testing.\n\nA single execution chosen from the execution space in level 2 may correspond to several *global computations*. A global computation is a sequence of global states starting from the initial global state and ending at the final global state of an execution. Testing all global computations is effective, but it is infeasible since the number of global computations can be exponential in the number of global states.\n\nGlobal predicate detection is checking whether the given predicate is true in a global state of the system in a given execution. Since many properties about programs such as safety and liveness can be expressed in terms of predicates, a technique to detect whether a predicate is true at a global state is useful for testing distributed programs. Global predicate detection may involve exhaustive testing of all the global states. Testing all global states is adequate in several cases, but it may be difficult to perform due to the state explosion problem. We present several algorithms to tackle the state explosion problem in global predicate detection. First, we present an algorithm that uses $O(mn)$ space where $m$ is the total number of events in the computation and $n$ is the number of processes in the system. We further reduce the space complexity of the algorithm for detecting global predicates to $O(m)$ by not using vector clocks. We then parallelize our space efficient algorithm for detecting global predicates. Considering the explosive nature of global state space, a parallel algorithm can significantly reduce the time taken to detect a global predicate. A salient feature of our parallel algorithm is that the processors that test global states do not communicate (through messages or shared memory) to determine who has to test a particular global state. Our experimental results show that the speedup of our algorithm is close to the optimal value. We further improve the performance, both in time and space, of our algorithms by increasing the granularity of an execution step from an event to a sequence of events (*interval*). Instead of checking every global\nstate, we check every *global interval*. When the values of the variables related to\nthe global predicates are not changed “frequently,” the number of global intervals\ncan be substantially less than the number of global states, thereby reducing the\nspace and time requirements of our algorithms.\n\nRestricted predicate based testing is to test for errors that can be ex-\npressed in a restricted form of predicates, e.g., predicates in CNF or DNF with\neach clause consisting of variables from a single process. Predicate based testing\nis feasible, but may be less effective. We present a distributed algorithm for de-\ntecting predicates in CNF. The message complexity of the algorithm is \\(O(kn^2)\\)\nwhere \\(k\\) is the total number of marked intervals at which a clause is true.\n\nAnother important problem in testing and debugging distributed pro-\ngrams is recording a snapshot (global state) of a distributed system. Recording\na snapshot is useful in setting “global breakpoints.” We present an optimal dis-\ntributed algorithm to record a global state of a distributed system with causally\nordered message delivery. The message complexity of our algorithm is \\(O(n)\\) bits\nwhere \\(n\\) is the number of processes in the system.\n\n### 1.1.2 Related Work\n\nThere have been several papers on debugging distributed programs, but there are\nvery few papers that address the issues in testing distributed programs. Taylor\nand Kelly [?] propose a method to test concurrent programs by extending the\ntraditional program based testing technique. They define several criteria based on\nthe control flow graph and establish a hierarchy among these criteria. (Note that\nthe hierarchy proposed by Taylor and Kelly is based on the flow graph model of\nthe program and is different from the hierarchy proposed by us which is inherent\nin dynamic testing of distributed programs.) The technique at the top of the\nhierarchy, testing all the paths, is the most effective but it is not practical. Even\nthe restricted statement testing criterion is impractical for concurrent programs.\nThe added difficulty is due to the multiple number of processes. To bypass this difficulty, they restrict the criterion further, by choosing nodes that require closer examination. This criterion is less effective, but feasible. Carver and Tai [?] propose a static analysis technique to detect synchronization errors in concurrent programs. The proposed techniques of Taylor and Kelly [?] and Carver and Tai [?] are program based static analysis methods for testing concurrent programs (ADA and CSP). Our method is based on events and global states, and is dynamic in nature.\n\nThe concept of evaluating global predicates, which is useful in the third level of the hierarchy, evolved out of the event occurrence condition introduced by Spezialetti [?], and by Spezialetti and Kearns [?]. Cooper and Marzullo first proposed an algorithm for detecting whether an arbitrary predicate is true in a global state [?]. The time and space complexities of their algorithm, in the worst case, can be exponential in the number of processes. In this dissertation, we present an algorithm whose space complexity is linear in the number of processes. We also provide several techniques to reduce the time taken to detect arbitrary global predicates.\n\nSeveral researchers have presented efficient algorithms for evaluating global predicates by applying some restrictions on the form of predicates. Manabe and Imase [?], Venkatesan and Dathan [?], and Garg and Waldecker [?] consider predicates in conjunctive normal form. We present an efficient on-line algorithm for detecting predicates in conjunctive normal form. Our technique uses vector clocks of Fidge and Mattern [?, ?] for global predicate detection, and is more efficient and decentralized than the techniques of [?, ?]. Venkatesan and Dathan’s [?] method for detecting global predicates requires $O(n^3)$ messages and is an off-line algorithm. Our algorithm uses $O(n^2)$ messages and is on-line in nature. But their algorithm does not use vector clocks while our algorithm uses vector clocks. Li and Dash [?] give an algorithm to detect predicate of the form $P$ unless $Q$. Miller and Choi [?], and Haban and Weigel [?] consider the problem of detecting\nunstable linked predicates. A work by Hurfin, Plouzeau and Raynal [?] deals with a class of global predicates, called atomic sequence of predicates. These sequences are defined by a pair of sequences of local predicates: expected predicates and forbidden predicates [?].\n\nChandy and Lamport [?] define the notion of global states and present an algorithm to record a global state in distributed systems with FIFO communication channels. The message complexity of their algorithm is $O(m)$ bits where $m$ is the number of channels. Several algorithms exist in the literature for recording global states both in FIFO and NON-FIFO networks [?, ?, ?]. Acharya and Badrinath [?] first considered the problem of recording a global state in a distributed system that maintains “causal order” in message delivery. Since the causal order property is stronger than the FIFO property, global states might be recorded more efficiently in these systems than in systems with FIFO channels. The algorithm of Acharya and Badrinath [?] uses $O(n)$ control messages, but the messages are long (each message is $n$ integers in length where $n$ is the number of processes). In this chapter, we present a message-optimal algorithm to record global states. The message complexity is $O(n)$ and each message is of size $O(1)$ bits.\n\n1.2 Mobility Issues in Distributed Systems\n\nThe advent of cellular communication, PCNs, and wireless LANs has made mobile computing realizable in practice. A mobile computing environment consists of a set of mobile hosts (MH) and mobile support stations (MSSs). A mobile host is a host that can move while retaining its connection with the network [?]. Typically mobile hosts are laptops or palmtops with severe energy and storage constraints. Many of them operate with AA batteries and a small amount of disk space [?]. A mobile host communicates with other hosts through a mobile support station.\nA mobile support station is a static host and has the necessary infrastructure to communicate with mobile hosts. The geographical area within which an MSS supports mobile hosts is called a cell. Communication between a mobile support station and a mobile host located in its cell is through a wireless medium. All mobile support stations are connected through a wired network. The set of all mobile support stations and the links connecting them constitute the conventional (static) distributed computing environment.\n\nWith the introduction of host mobility several new issues arise in distributed computing [?]. At any time a mobile host can move from the cell of one MSS to the cell of another MSS. This leads to the problem of tracking the location of mobile hosts. Tracking a mobile host is essential in establishing a connection with the mobile host and in delivering messages to the mobile host [?, ?, ?, ?, ?].\n\nAnother issue in mobile computing is assigning wireless channels to mobile hosts to communicate with their MSSs. Two MSSs with a common cell boundary cannot use the same wireless communication channel to communicate with a mobile host in their respective cells [?]. Since the bandwidth of a wireless communication medium is limited, efficient channel allocation strategies are required.\n\nVarious other challenges arise because the existing communication protocols and distributed algorithms cannot be directly used in mobile systems due to the frequent changes in physical connectivity, resource constraints of mobile hosts, and limited bandwidth of the wireless links. Some of the main objectives in extending and designing new distributed algorithms for a mobile computing environment are as follows.\n\n1. Handle host mobility efficiently.\n\n2. Reduce the power consumption of a mobile host.\n\n3. Cope with mobile host’s limited disk space.\n\n4. Reduce the overall communication cost.\n1.2.1 Summary of Results\n\nIn this dissertation, we design communication protocols and provide fault-tolerant features for mobile computing.\n\nFirst, we present three algorithms for causally ordered message delivery in mobile systems. The first algorithm appends $O(n_h^2)$ integers to each message where $n_h$ is the number of mobile hosts. The algorithm copes with the resource constraints of the mobile hosts as the mobile support stations execute the algorithm on behalf of mobile hosts. But the algorithm is not easily scalable and does not handle hosts disconnections and connections well. Our second algorithm eliminates the above disadvantages at the cost of inhibiting some messages. The algorithm requires $O(n_s^2)$ integers to be appended to each message where $n_s$ is the number of mobile support stations. The performance of our second algorithm will be significantly better than the first algorithm since $n_h \\gg n_s$. Our simulation results confirm this. The third algorithm is a trade-off between the first two algorithms.\n\nWe then consider the problem of designing mobile computing systems that tolerate mobile support station failures so that mobile hosts can continue to operate in spite of support station failures. We present two schemes to tolerate support station failures and discuss some important related issues. In both schemes, the information stored at a mobile support station is replicated at several “secondary” support stations. The two schemes differ in the way in which replication is achieved. When a mobile support station fails, the mobile hosts under its coverage can switch to one of their secondary support stations and continue their operation. The two schemes are compared by an experimental study. We also present several methods for selecting the set of secondary support stations for a mobile host and discuss various methods to cope with the failure of mobile hosts.\n\nFinally, we present a protocol to reliably broadcast messages in mobile\nwireless networks. A mobile wireless network consists of a set of mobile hosts distributed over a wide geographical area without any support stations. Reliable broadcast is achieved by selective flooding and handshaking.\n\n1.2.2 Related Work\n\nDesigning communication protocols for mobile computing is a widely studied field in distributed computing systems. Ioannidis et al. [?] present an infrastructure that enables mobile hosts to keep their network connections even while they move. They present two IP-based protocols to provide continuous network connectivity without affecting higher-level protocols and software. Teraoka et al. [?] present a network architecture for providing host migration transparency at the network layer level. They achieve transparency by dividing the conventional network sublayer into two sublayers: virtual network sublayer and physical network sublayer. The physical address of a mobile host is cached at the physical network sublayer and propagating cache technique is used to update the change in physical address. Badrinath et al. [?] provide a general framework for designing distributed algorithms for mobile computing environments. They handle mobility by creating a proxy for each mobile host. The proxies for mobile hosts will be located at the MSSs. Causally ordered message delivery can be achieved using frameworks discussed above, but the solutions will be inefficient. We provide efficient algorithms for causal ordering by handling mobility explicitly in our algorithms.\n\nSeveral researchers have worked on the fault-tolerant aspects of mobile computing [?, ?]. Acharya et al. present an efficient technique to checkpoint the states of mobile hosts [?]. Krishna et al. provide checkpointing and rollback techniques to recover from mobile hosts failure [?]. While these results consider the failures of mobile hosts, we consider the failures of MSSs and present techniques for providing continuous support to mobile hosts in spite of MSS failures.\nIssues in mobile wireless networks have attracted the attention of several researchers. Perkins and Bhagwat present a routing scheme based on destination-sequenced distance-vector for hosts in mobile wireless networks [?]. Krishna et al. provide a cluster based approach for routing in mobile wireless networks [?]. Several other researchers [?, ?] have considered the problem of routing in mobile wireless networks. We consider the problem of reliably broadcasting messages to host which has not been considered by any other researcher.\n\nThe dissertation is organized as follows. System model and related definitions are discussed in Chapter 2. We identify a three level hierarchy inherent in testing distributed programs in Chapter 3. In Chapter 4, several techniques are presented to tackle the global state space explosion encountered in testing distributed programs. A distributed algorithm to record a global state in distributed systems with causal message ordering is presented in Chapter 5. Next we provide three algorithms to preserve causal ordering in mobile system in Chapter 6. In Chapter 7, various schemes are provided to tolerate base station failures in mobile computing. In Chapter ??, a protocol for reliable message broadcast in mobile wireless network is presented. Finally, Chapter ?? concludes the dissertation.\n\nParts of the results discussed in this dissertation appear in preliminary form in [?, ?, ?, ?, ?, ?]\nChapter 2\n\nModel and Definitions\n\nA distributed system is a collection of processes connected by a set of communication channels. The channels are bidirectional. Communication channels take an arbitrary but finite amount of time to deliver the messages (i.e., the channels are asynchronous). Execution speed of the processes is also asynchronous. Communication among the processes is by message passing only. Let $P = \\{P_1, \\ldots, P_n\\}$ be the set of processes and $C_{ij}$ represent the channel between $P_i$ and $P_j$.\n\nA process is a collection of events that form a total order. An event in a process is an action that changes the state of the process. An event may be a send event resulting in sending of a message to one or multiple processes, a receive event resulting in the receipt of a message from a process, or an internal event in which no sending or receiving of a message is involved. The $k^{th}$ event of process $P_i$ is denoted by $e_i^k$.\n\nLet $E$ be the set of all events in a particular execution. Events in $E$ are ordered based on the causal relation happened before, $\\to$, introduced by Lamport [?]. For any two events $e$ and $e'$, $e \\to e'$ is true if any of the following holds.\n\n1. $e$ and $e'$ are two events in the same process and $e$ occurs before $e'$.\n2. \\( \\varepsilon \\) corresponds to sending a message \\( m \\) and \\( \\varepsilon' \\) corresponds to the receipt of \\( m \\).\n\n3. There exists an event \\( \\varepsilon'' \\) such that \\( \\varepsilon \\rightarrow \\varepsilon'' \\) and \\( \\varepsilon'' \\rightarrow \\varepsilon' \\).\n\nThe set \\( E \\) and the binary relation \\( \\rightarrow \\) on \\( E \\) defines an execution. \\( (E, \\rightarrow) \\) is a partially ordered set. An execution of a distributed program can be represented by a space-time diagram. The space-time diagram for a sample execution is shown in Figure 2.1.\n\nTo determine the causality between any two events, we use the vector clock introduced by Fidge [?] and Mattern [?]. Let \\( V_i \\) be the vector clock maintained by \\( P_i \\). The value of \\( V_i \\) varies as \\( P_i \\) executes events. Let the timestamp of an event \\( e_i \\), denoted as \\( TS(e_i) \\), be the value of \\( V_i \\) after executing \\( e_i \\). Whenever a process sends a message, it \\emph{timestamps} the message by appending the current (updated) clock value to it. The following operations are performed on the clock \\( V_i \\) by \\( P_i \\) when it executes an event \\( e \\).\n\n1. For each event \\( e \\), \\( P_i \\) first increments the \\( i^{th} \\) component of its clock, i.e.,\n\\[\nV_i[i] = V_i[i] + 1.\n\\]\n\n2. If \\( e \\) is a send event, \\( TS(e) \\) is appended to the message.\n\n3. If \\( e \\) is a receive event and \\( T \\) is the time stamp of the message, \\( V_i[j] = max(V_i[j], T[j]) \\) for all \\( j \\).\n\nConsider the example shown in Figure 2.1. The initial clock value of all three processes is \\([0, 0, 0]\\). When \\( P_1 \\) sends its first message to \\( P_3 \\), \\( P_1 \\) changes its clock value to \\([1, 0, 0]\\) (by operation 1) and timestamps it with \\([1, 0, 0]\\). On receiving this message, \\( P_3 \\) changes its clock value to \\([1, 0, 2]\\) (by operations 1 and 2).\n\nWe say that \\( TS(e_i^x) < TS(e_j^y) \\) if \\( TS(e_i^x)[x] \\leq TS(e_j^y)[x] \\) for all \\( x \\) and there exists a \\( y \\) such that \\( TS(e_i^x)[y] < TS(e_j^y)[y] \\). It is easy to show that \\( e_i^x \\rightarrow e_j^y \\) iff\nThe frontier for a cut is unique, and hence we sometimes represent a cut by its frontier. In Figure 2.1, cut $C$ ($< e_1^1, e_2^2, e_3^3 >$) is a consistent cut; whereas cut $C'$ is inconsistent since $e_1^2$ is included in $C'$ and $e_2^2$ is not included in $C'$ and $e_2^2 \\rightarrow e_1^2$.\n\nA process state is represented as a sequence consisting of the initial state followed by a sequence of events occurred in that process and the process state is the state after executing the sequence of events from the initial state.\n\nA channel state is a sequence of messages sent along the channel that are consistent. The frontier for a cut is unique, and hence we sometimes represent a cut by its frontier. In Figure 2.1, cut $C$ ($< e_1^1, e_2^2, e_3^3 >$) is a consistent cut; whereas cut $C'$ is inconsistent since $e_1^2$ is included in $C'$ and $e_2^2$ is not included in $C'$ and $e_2^2 \\rightarrow e_1^2$.\n\nA process state is represented as a sequence consisting of the initial state followed by a sequence of events occurred in that process and the process state is the state after executing the sequence of events from the initial state.\n\nA channel state is a sequence of messages sent along the channel that are\nnot yet received. A global state of a distributed system is a collection of process states and channel states. We say that an event e is in a global state G if e is in a process state of the global state G. Similarly, a message m is in a global state G if m is in a channel state of the global state G. For a message m, let send(m) be the event that corresponds to the sending of m and recv(m) be the event that corresponds to the receipt of m. A global state G is consistent if, for a message m sent by P_i to P_j,\n\n\\[ m \\text{ is in } G \\text{ or } \\text{recv}(m) \\text{ is in } G \\implies \\text{send}(m) \\text{ is in } G. \\]\n\nA global state G is complete if, for a message m sent by P_i to P_j,\n\n\\[ \\text{send}(m) \\text{ is in } G \\implies m \\text{ is in } G \\text{ or } \\text{recv}(m) \\text{ is in } G. \\]\n\nFor every cut \\(<e^1_{k_1}, \\ldots, e^n_{k_n}>\\), there is a unique global state \\(<s^1_{k_1}, \\ldots, s^n_{k_n}>\\) where \\(s^i_{k_i}\\) is the state of \\(P_i\\) after executing \\(e^i_{k_i}\\). (The global state is unique because the state after every event in the cut is unique.) Also, for every global state, there is a unique cut. In Figure 2.1, the global state corresponding to cut \\(C\\) is \\(<s^1_{k_1}, s^2_{k_2}, s^3_{k_3}>\\). A global state \\(<s^1_{k_1}, \\ldots, s^m_{k_m}>\\) is a consistent global state if its corresponding cut is a consistent cut. Hereafter, the term “global state” refers to “consistent global state.”\n\nMattern [?] has shown that the set of all global states of a given execution (run) forms a lattice. The lattice for the execution shown in Figure 2.1 is shown in Figure 2.2. A point in a lattice represents a global state. Two global states \\(G\\) and \\(G'\\) are connected by a directed edge if \\(G'\\) can be reached from \\(G\\) by executing one event in any of the processes. There is a path from a global state \\(G\\) to \\(G'\\) in the lattice if \\(G'\\) is reachable from \\(G\\) by executing several events. Finally, a path from the initial global state to the final global state represents one global computation and is a possible computation of the system. Note that there may be several paths from the initial global state to the final global state depending on the relative order in which the events take place within the processes.\nSeveral other definitions used in this dissertation are not discussed here for the sake of brevity. They will be defined as and when they are required.\nChapter 3\n\nHierarchy in Testing Distributed Programs\n\nIn this chapter, we identify a three level hierarchy that is inherent in testing distributed programs. Level 1 involves the selection of an input data set for the given distributed program. Level 2 deals with selecting an execution for a given input, and level 3 is concerned with testing an execution selected in level 2. Level 1 is common to both sequential and distributed programs. Level 2 is non-existent in testing sequential programs, and is present in testing distributed programs due to the non-determinism of the communication medium. Level 3 testing is more involved in distributed programs than sequential programs due to the presence of multiple number of processes. We merely identify the existent of Level 1; the major contribution of this chapter is to Level 2 and Level 3.\n\nThe organization of this chapter is as follows. Certain issues related to selecting input data (level 1) are discussed in Section 3.1. In Section 3.2, we consider the problem of generating different executions for a given input data (level 2). Issues related to level 3 of the testing hierarchy are considered in Section 3.3. Section 3.4 concludes the chapter.\n3.1 Selecting Input Data (Level 1)\n\nIn this level, input data is selected from the input space of a distributed program. In a distributed program, for each read statement executed by a process, a value must be chosen and given. Thus, an input data for a distributed program is a set of sequences of input values, one sequence per process, such that when a process needs data, the next value from the sequence associated with that process is given.\n\nThis level is common to both sequential program testing and distributed program testing, and it is more involved in the case of distributed programs. Several existing techniques for sequential programs can be extended to distributed programs. One such possible technique is random testing. Input data from the input space are selected by random sampling. As stated earlier, this dissertation concentrates more on issues in level 2 and level 3 than in level 1. Some issues in level 1 are extending techniques available for sequential program testing and studying their feasibility and effectiveness in testing distributed programs.\n\n3.2 Coping with the Communication Medium (Level 2)\n\nIn a sequential program, the input determines the output. In a distributed program, the output of a process not only depends on the input data but also on the sequence of the messages received by it. A different message arrival sequence may produce a different result for the same input data. Thus, for a given input data, an error in a distributed program may not be revealed in a particular execution while the error may be revealed in a different execution. We illustrate this point with an example.\n\nConsider a voting-based distributed mutual exclusion program. Every process has one vote. A process trying to enter its critical section must get a majority of votes from the other processes. (For simplicity, we do not consider\ndeadlocks and livelocks [?].) Assume that in an implementation, a process trying to enter its critical section waits for exactly half the number of votes instead of waiting for more than half the number of votes (due to a typing error). We consider two executions; one reveals this error and the other does not reveal it.\n\nFigure 3.1 represents one execution of the mutual exclusion program outlined above. Initially, processes $P_2$ and $P_3$ try to enter the critical section. $P_2$ broadcasts a request vote message (message $r'$ in Figure 3.1), $P_3$ broadcasts a request vote message (message $r$), and both of them wait for the votes. $P_1$ and $P_4$ receive the request from $P_3$ first, hence they send their votes to $P_3$ (messages $g$). Since $P_3$ gets half the number of votes, it enters its critical section (denoted as CS in the Figure). $P_2$ has only one vote (its own vote), so it does not enter its critical section. After leaving its critical section, $P_3$ returns the votes (messages $t$). Now, $P_1$ and $P_4$ grant their votes to $P_2$, and $P_2$ enters its critical section.\n\nConsider another execution of the same program as shown in Figure 3.2. In this execution, $P_1$ gets the request from $P_2$ first (message $r'$ in Figure 3.2), so it sends its vote to $P_2$. $P_4$ grants its vote to $P_3$ as in the earlier execution. Now, $P_2$ and $P_3$ have half the number of votes, hence both may enter the critical section “at the same time” (as shown by the consistent cut GS). Thus, for a given input data, there may be several runs (some may exhibit errors) with different outputs depending on the several possible message arrival sequences.\n\nA test case for a sequential program is the input data alone. A **distributed test case** is a collection of input values (for each process) and the sequence of messages received by each process such that the behavior of the distributed system is identical for each run of the distributed test case [?]. Thus, generating test cases for distributed programs involves generating input data, as in sequential programs, and considering different message patterns. Note that by generating a different run for a fixed input data, we generate a different distributed test case.\n\nWe next present an algorithm to generate different runs (distributed test cases)\nfor a fixed input data.\n\n3.2.1 Producing Different Runs\n\nLet the distributed program be executed once, and \\( E_i = < e'_1, e'_2, \\ldots > \\) be the sequence of consecutive events of \\( P_i \\). \\( E_i \\) is a process run for process \\( P_i \\). \\( E = \\{ E_1, \\ldots, E_n \\} \\) is a run of the distributed system.\n\nFor a process \\( P_i \\), a process run \\( E'_i \\) is different from a process run \\( E_i \\) if the sequences of messages received by \\( P_i \\) in the two process runs \\( E'_i \\) and \\( E_i \\) are different (even if the input data is the same for \\( E_i \\) and \\( E'_i \\)). Unless mentioned otherwise, the term “different run” means a different run for the same input data. A run \\( E' = \\{ E'_1, \\ldots, E'_n \\} \\) of a distributed system is different from a run \\( E = \\{ E_1, \\ldots, E_n \\} \\) if and only if there exists at least one process \\( P_i \\) such that \\( E'_i \\)\nis different from \\( E_i \\). Let \\( \\text{recv}(m) \\) denote the receive event initiated by the receipt of message \\( m \\), and let \\( \\text{send}(m) \\) be the event that involves the sending of \\( m \\).\n\n**Lemma 1** Let \\( E = \\{E_1, \\ldots, E_n\\} \\) be a run of the distributed system for a given input data, and let \\( M_i = < m_1, m_2, \\ldots> \\) be the sequence of messages received by \\( P_i \\) during process run \\( E_i \\in E \\). There is a process run \\( E'_i \\) different from \\( E_i \\), for the same input data, if and only if there are two consecutive messages \\( m_{i-1} \\) and \\( m_i \\) received by \\( P_i \\) in \\( E_i \\) such that \\( \\text{recv}(m_{i-1}) \\not\\rightarrow \\text{send}(m_i) \\) in \\( E \\).\n\n**Proof** (\\( \\Rightarrow \\)) Let \\( E \\) and \\( E' \\) are two different runs of the distributed system. Let \\( S = \\{e'_1, \\ldots, e'_n\\} \\) be a set of events such that \\( e'_j \\) is an event in \\( E'_j \\) (of process \\( P_j \\)) and \\( e'_j \\) is the earliest event of \\( E'_j \\) that differs from its corresponding event \\( e_k \\) in \\( E_j \\). Note that the first event in \\( E'_j \\), for all \\( j \\), is the first event in \\( E_j \\) since the input data is the same for both the runs.\n\n**Fact 1:** There exists an event \\( e'_{k_y} \\in S \\) such that \\( e'_{k_z} \\not\\rightarrow e'_{k_y} \\) for all \\( z \\neq y \\). (That is, no event of \\( e'_{k_z} \\in S \\) happens before/precedes \\( e'_{k_y} \\).)\n\nSince our model is event driven (where an event \\( e \\) is determined solely on its previous event and, if \\( e \\) is a receive event, on the contents of the message received), \\( e'_{k_y} \\) is a receive event. Now, choose \\( i = y \\) (\\( P_i = P_y \\)). Let \\( \\text{recv}(m') = e'_{k_y} \\) and \\( \\text{recv}(m_q) = e_{k_i} \\) where \\( m_q \\) is a message received by \\( P_i \\) in \\( E_i \\) (See Figure 3.3).\n\nSince \\( e'_{k_i} \\neq e_{k_i} \\), \\( m' \\neq m_q \\). Now, there exists a message \\( m_t \\in M_i \\) such that \\( m_t = m_q \\) and \\( t > q \\). (Recall that \\( e'_{k_i} \\) is the earliest event in \\( E'_i \\) that differs from \\( e_{k_i} \\) in \\( E_i \\) and, from Fact 1, \\( e'_{k_i} \\) is not preceded by any other event of \\( S \\).) Clearly, \\( m_t \\) is received before \\( m_q \\) in \\( E'_i \\). Therefore, \\( \\text{recv}(m_q) \\not\\rightarrow \\text{send}(m_t) \\) in \\( E \\). (Call this Claim 1.) Now, for any \\( r \\) (\\( q \\leq r < t \\)), \\( \\text{recv}(m_q) \\rightarrow \\text{recv}(m_r) \\) in \\( E_i \\). This implies that \\( \\text{recv}(m_{t-1}) \\not\\rightarrow \\text{send}(m_t) \\) in \\( E_i \\). (Otherwise \\( \\text{recv}(m_q) \\rightarrow \\text{send}(m_t) \\), contradicting Claim 1 that was proved before.)\n\n\\( \\lesssim \\) Clearly, during \\( E'_i \\) message \\( m_q \\) can be received before \\( m_{t-1} \\) by \\( P_i \\) yielding a different process run.\nLemma 1 holds when the links are not FIFO. If the links are FIFO, the FIFO condition must be included.\n\n**FIFO condition:** If two messages, $m_1$ and $m_2$, received by process $P_i$ are sent by the same process $P_j$ connected to $P_i$ by a bidirectional FIFO communication link, then $send(m_1) \\rightarrow send(m_2) \\Leftrightarrow recv(m_1) \\rightarrow recv(m_2)$.\n\n**Lemma 2** Let $E$ be a run (of the distributed system) for a given input data. Assume that the links are FIFO. Let $M_i = < m_1, m_2, \\ldots >$ be the sequence of messages received by $P_i$ during process run $E_i \\in E$. There is a process run $E'_i$ different from $E_i$, for the same input data, if and only if there are two consecutive messages $m_{t-1}$ and $m_t$ received by $P_i$ in $E_i$ such that (i) $recv(m_{t-1}) \\not\\rightarrow send(m_t)$ in $E$, and (ii) $send(m_{t-1})$ and $send(m_t)$ are events on two different processes in $E$.\n\n**Proof:** It follows from Lemma 1 and the FIFO condition. \n\nLemmas 1 and 2 are very significant. To produce a different run, we need to check only consecutive receive events to see if they can be swapped instead.\n\n---\n\nFigure 3.3: Different Runs\nof checking every pair of receive events. Thus, the number of pairs checked for swapping is linear in the number of receive events.\n\nWe now explain the algorithms to produce different runs. Formal descriptions are in Figure 3.4 and Figure 3.5. We say that two messages $m_k$ and $m_l$ received by $P_i$ in $E_i$ can be permuted if $recv(m_k) \\neq send(m_l)$ in $E$. We assume that the distributed program to be tested is reproducible – i.e., the behavior of each process during the first execution is identical to the behavior during subsequent executions of the same program under the same environment. (Several algorithms exist for reproducible execution and the reader is referred to [? , ?, ?, ?] for details.) During the first run, in addition to the data required for reproducible execution, each process stores the timestamp value $TS(recv(m))$ and $TS(m)$ for every message $m$ received. Algorithm output_pairs() shown in Figure 3.4 outputs all pairs of consecutive messages that can be permuted in a process. (Note that this algorithm can be executed on-line.) The user can then choose the pair of messages to be permuted in a process, and invoke algorithm produce_different_run($k$, $pid$). The parameters indicate that messages $m_k$ and $m_{k+1}$ have to be permuted in the process indicated by $pid$. If the id of the process is equal to $pid$, then the algorithm reproduces execution till $m_k$ and $m_{k+1}$ are received. It then processes $m_{k+1}$ before processing $m_k$ and broadcasts REPRODUCE_OVER to other processes indicating to them that a different run begins. All processes whose id is not equal to $pid$ reproduce execution till they receive the REPRODUCE_OVER message. Each process, after receiving the REPRODUCE_OVER message, continues its normal execution.\n\nThe number of possible test cases for a fixed input data may be large, and we do not have an upper bound. But, there are certain classes of programs for which the test case is unique.\noutput_pairs(); { executed by $P_i$ }\nbegin\n $k \\leftarrow 0$;\n $\\text{permute} \\leftarrow \\text{false}$;\n repeat\n $k \\leftarrow k + 1$;\n $e \\leftarrow \\text{recv}(m_k)$;\n if $TS(e)[i] > TS(m_{k+1})[i]$ then (** $\\text{recv}(m_k) \\not\\rightarrow \\text{send}(m_{k+1})$ **) \n output \"k and $k + 1$th messages can be permuted\"\n $\\text{permute} \\leftarrow \\text{true}$;\n until process terminates\n if $\\text{permute} = \\text{false}$ then\n output \"No different run exists.\"\n end.\n\nFigure 3.4: Algorithm output_pairs for $P_i$\n\n3.2.2 Restricted Cases\n\nUnidirectional ring\n\nTheorem 1 For fixed input data, the run in a unidirectional network with FIFO links is unique.\n\nProof: A process can receive a message from only one process and since the links are FIFO, it follows from Lemma 2 that the run is unique.\n\nIt is clear from Theorem 1 that testing distributed programs in unidirectional rings is simpler than in other networks since the input data alone determines the behavior of the processes. (A distributed test case consists of only the input data).\nproduce\\_different\\_run( k, pid); \\{ executed by \\( P_i \\) \\}\n\nbegin\n\nif \\( (P_i = \\text{pid}) \\) then\n\nReproduce execution \\( E_i \\) till messages \\( m_k \\) and \\( m_{k+1} \\) are received;\n\nProcess \\( m_{k+1} \\) before processing \\( m_k \\) and broadcast\n\nREPRODUCE\\_OVER message;\n\nelse\n\nReproduce execution until REPRODUCE\\_OVER message is received;\n\nContinue normal execution;\n\nend.\n\nFigure 3.5: Algorithm \\text{produce\\_different\\_run} for \\( P_i \\)\n\n---\n\n**Associative distributed programs**\n\nMany of the distributed algorithms such as algorithms for breadth first search, shortest paths, maximum flow, maximum matching, sorting, median finding, and constructing snapshots use the following simple paradigm [?] for reducing the message complexity: (a) preprocess the network, and (b) decompose the algorithm into several phases such that the following computation takes place in each phase: the value of an associative function \\( F \\) of the private values (which may change from phase to phase) of each process in the network is distributively computed. The coordinator then advances the computation. We call these algorithms \\textit{af-based} (associative function based) algorithms [?]. The computation of the associative function is carried out using a spanning tree \\( T \\).\n\nThe root of \\( T \\) (the coordinator) initiates the computation. A leaf node computes the function using its private value only and sends the value to its parent. A non-leaf node (including the root) waits for a value from each child, computes the function using its private value and the values received from all of\nits children, and sends the computed value to its parent (if any).\n\n\n\n**Figure 3.6: Computation of MIN function**\n\nFor example, consider a six processes system computing the MIN function where $T$ is as shown in Figure 3.6(a). The private value of a process is shown in italics, the arrows denote messages, and the number on each arrow denotes the value sent. Figure 3.6(b) shows an execution. Consider process $P_2$. In the beginning, $P_2$ has its local value 8 and it receives three messages with values 5, 3 and 6. Clearly, the order in which $P_2$ receives these messages is immaterial as far as computing the MIN function is concerned. Thus, even if the three messages had arrived at a different order, the behavior of $P_2$ after receiving all of them is the same. A similar reasoning applies to $P_1$ when it receives the values sent by $P_2$ and $P_6$. Clearly, in this example, the random communication delays cannot alter a process’s behavior that is visible to the other processes. This idea is generalized as follows.\n\nLet $S$ be a state of $P_i$ and $X = [m_1, \\ldots, m_x]$ be a sequence of messages. Let $RS_i(S, X)$ be the resulting state of $P_i$ and $out_{P_i}(S, X)$ be the sequence of\nmessages sent by $P_i$ to other processes when $P_i$ starts from state $S$ and processes the sequence of messages $X$. Note that $RS_i(S, X')$ and $outm_i(S, X')$ are undefined if (a) $RS_i(S, X''')$ is undefined or (b) $P_i$ cannot receive $m''$ while in state $RS_i(S, X''')$ where $X' = X''m''$, and $X'$ and $X''$ are prefixes of $X$.\n\nLet $\\{m_1, \\ldots, m_x\\}$ be a set of messages sent (but not yet delivered) to process $P_i$ such that $\\forall s, t$ and $1 \\leq s, t \\leq x$, $m_s$ and $m_t$ are concurrent*. Let $perm(X)$ be the set of all permutations of $X$. A process $P_i$ is said to execute an associative distributed program with respect to its process state $S$ and a message sequence $X$ if $RS_i(S, X) = RS_i(S, Y)$ and $outm_i(S, X) = outm_i(S, Y)$ for each $Y \\in perm(X)$. A distributed application program is said to be an associative distributed program if each process $P_i$ executes an associative distributed program with respect to $S$ and $M$, where $S$ is any legal state of $P_i$ and $M$ is any sequence of messages.\n\nIt is easy to see that all af-based distributed programs are associative distributed programs. For these programs, level 2 is considerably less involved than the general case. Clearly, for all $i$, the global state at the end of the $i^{th}$ phase of the associative function does not depend on the random communication delays. Thus, the variation of the “behavior” of the process with random message transmission delays is localized and is not visible outside.\n\n3.3 Testing a run (Level 3)\n\nSequential programs are tested by running the test cases and by comparing the (intermediate and) final states or the output values with the expected values. Testing a distributed program is complicated because of the presence of multiple processes. Testing the local states of all of the processes in isolation is insufficient;\n\n*Two messages $m_s$ and $m_t$ are concurrent if $m_s$ does not “affect” $m_t$ and $m_t$ does not “affect” $m_s$. \nwe need to test the global states. The necessity of testing global states is illustrated with an example. Consider again the execution of the mutual exclusion program shown in Figure 3.2. In the consistent global state $GS$ (denoted by the dotted line in the Figure) both $P_2$ and $P_3$ are in their critical section which is clearly an error. We cannot detect errors of this nature by testing the local states of the processes alone. Also, it is not sufficient to test the final global state alone since the transient errors occurring in the intermediate global states may not be detected.\n\n### 3.3.1 Testing all Global Computations\n\nRecall from Chapter 2 that an execution forms a lattice. Each path from an initial global state to the final global state (of a lattice) represents a global computation that could have been observed by an external observer. One way to test a distributed program is to test all possible paths from the initial global state to the final global state in the lattice. This corresponds to testing all the global computations of an execution. Clearly, this technique can ensure correctness, but, in the worst case, the number of paths may be exponential in the number of global states. Hence, this criterion is not feasible in all cases.\n\n### 3.3.2 Testing Global Predicates\n\nGiven a run and a predicate $\\Phi$, we test the run by asking the question “Does there exist a global state (consistent cut) where the predicate $\\Phi$ holds?” This question is posed as POSSIBLY($\\Phi$) in [?, ?] and as weak predicates in [?]. If $\\Phi$ represents an error condition, then POSSIBLY($\\Phi$) represents a possible occurrence of an error. Since many properties about programs can be expressed in terms of predicates, a technique to detect POSSIBLY($\\Phi$) is useful in detecting whether any (safety) property of the program is violated. The predicates may be constructed using the specification of the distributed program with some input\nfrom the implementation group. To thoroughly test the program, sufficient number of predicates covering all aspects of specification and implementation must be constructed. We do not discuss methods for constructing predicates since they are specific to the application program.\n\nTo detect $\\text{POSSIBLY}(\\Phi)$, for any arbitrary $(\\Phi)$, we can test every global state. (It appears that detecting an arbitrary global predicate involves exhaustive checking of every global state.) Thus in this technique, we test all consistent global states instead of testing all possible paths. Unfortunately, the worst-case number of global states may be exponential in the number of processes. For a given number of events (on all processes), the number of global states may not be high when a large number of messages are sent since messages create dependencies. The number of global states is very high when the number of messages transmitted is low. In Chapter 4 we provide several algorithms to tackle the state explosion problem while detecting $\\text{POSSIBLY}(\\Phi)$.\n\n### 3.3.3 Restricted Predicate based testing\n\nIf the number of global states is high, we may have to restrict the testing methodologies to properties that can be expressed by predicates in a restricted form. For example, if the distributed program implements a solution to the mutual exclusion problem, then the property to be detected is “multiple processes are in the critical section in a global state.” This can be expressed as “$\\Phi = (P_1 \\text{ is in critical section}) \\land (P_2 \\text{ is in critical section})$” in a system consisting of two processes.\n\nIn this section, we consider only CNF predicates where each conjunct is any boolean expression using constants and variables of a single process. Thus, a conjunctive predicate may be represented as $C_1 \\land C_2 \\land \\ldots \\land C_n$, where conjunct $C_i$ is any boolean expression involving constants and variables local to process $P_i$ only. We next present a distributed algorithm for evaluating $\\text{POSSIBLY}(\\Phi)$. \nTesting POSSIBLY(\\(\\Phi\\))\n\nAn event may be the result of the execution of several statements or subprograms, and several variables may be updated in an event. Note that no messages are sent or received during any part of an event except in the beginning, and each action that results in sending a message or receiving a message marks the beginning of a new event. If the conjunct \\(C_i\\) becomes true at any time \\(t\\) of execution of the program at process \\(P_i\\), then \\(P_i\\) marks the event that occurs during time \\(t\\). Clearly, the marked events of \\(P_i\\) represent those events during which \\(C_i\\) becomes true at least once. Since \\(C_i\\) refers to variables of \\(P_i\\) only, no messages are needed in marking events.\n\nThe events are marked on-line by all of the processes and the marked events along with their timestamps are stored in memory. For every process there will be a corresponding monitor process which will execute the algorithm for detecting POSSIBLY(\\(\\Phi\\)). All the monitor processes communicate among themselves and can execute the distributed algorithm on-line. For ease of exposition, hereafter we use the term process instead of monitor process whenever there is no confusion. Each process merges consecutive marked events into a maximal sequence of marked events. Let \\(S_i\\) be a maximal sequence of consecutive marked events of \\(P_i\\). Let the indices of the first and last events of \\(S_i\\) be \\(f_i\\) and \\(l_i\\) respectively. The event immediately before the first event of \\(S_i\\) and the event immediately after the last event of \\(S_i\\) are unmarked events. If \\(C_i = \\emptyset\\), then \\(S_i\\) contains all events of \\(P_i\\).\n\nTesting POSSIBLY(\\(\\Phi\\)) is equivalent to checking if there exists a consistent cut (global state) such that each component of the cut occurs within a marked sequence of events. If no event of \\(P_i\\) is marked, then POSSIBLY(\\(\\Phi\\)) is false. An algorithm for detecting POSSIBLY(\\(\\Phi\\)) is presented in Figure 3.7. Initially, a process \\(P_i\\) sets its \\(S_i\\) to the first sequence of marked events. All the processes distributively find whether there exist a consistent cut, \\(< e_k^1, \\ldots, e_k^n >\\), such\n1. For each process $P_i$, $S_i$ is set to the first sequence of marked events of $P_i$.\n\n2. Run the procedure $detect$ of Figure 3.8.\n\n3. If $flag_i = true$, $status_i \\leftarrow true$, else remove the current $S_i$ from consideration and set $S_i$ to the sequence of marked events of $P_i$ that occurs just before the currently removed $S_i$ and $status_i \\leftarrow false$. If no such sequence exists, $status_i \\leftarrow over$.\n\n4. Broadcast $status_i$, and receive $status_j$ from all $P_j$.\n\n5. If $status_j = true$ for all $P_j$, POSSIBLY($\\Phi$) is true; halt. If $status_j = false$ for any $P_j$, goto step (2). If $status_j = over$ for any $P_j$, POSSIBLY($\\Phi$) is false, halt.\n\nFigure 3.7: Algorithm POSSIBLY($\\Phi$) for Process $P_i$\n\nthat each event $e^i_k$ is in $S_i$ by invoking the procedure $detect$ in Figure 3.8. If so, POSSIBLY($\\Phi$) is true, and the algorithm terminates. Otherwise there exist an $S_j$ in $P_j$ and an $S_i$ in $P_i$ such that the first event of $S_j$ depends on an event that occurred later than the final event of $S_i$. Every such process $P_i$ sets $S_i$ to a sequence of marked events that occurs just after the current $S_i$, and the algorithm continues. If there exist no such sequence, then POSSIBLY($\\Phi$) is false and the algorithm terminates.\n\nConsider a sample run consisting of two processes shown in Figure 3.9. A sequence of marked events is shown by an ellipse in the Figure. The timestamp for each event is also shown in the Figure. Initially, $P_1$ sets $S_1$ to the first sequence of marked events and invokes procedure $detect$. (Process $P_2$ also executes the same steps.) Process $P_1$ then sends $TS(e^1_{f_1})[2] (= 0)$ to $P_2$ and waits for a message from\n1. Let $f_i$ be the index of the first event of $S_i$ and $l_i$ be the index of the last event of $S_i$. Process $P_i$ sends $TS(e_{j_i}^i)[j]$ to each $P_j$.\n\n2. Wait till $TS(e_{j_j}^j)[i]$ values sent by each $P_j$ is received and locally stored in $P_i$.\n\n3. If $TS(e_{j_j}^j)[i] \\leq l_i$ for each $j$, then set $flag_i$ to true else set $flag_i$ to false.\n\nFigure 3.8: Procedure detect\n\n\n\nFigure 3.9: A sample run\n\n$P_2$ (step 2 of procedure detect). Similarly, process $P_2$ sends $TS(e_{j_2}^2)[1]$ (= 4) to $P_1$. Since the value sent by $P_2$ is greater than $l_1$ (= 3), $flag_1$ is set to false. After returning from the procedure, $P_1$ advances $S_1$ to the next sequence of marked events since $flag_1$ is false. $P_2$ will not change $S_2$ since, at the end of procedure detect, $flag_2$ is true. After executing step 5 of the algorithm, $P_1$ and $P_2$ will go to step 2 and invoke procedure detect again. This time at the end of the procedure both $flag_1$ and $flag_2$ will be true and the algorithm will terminate. We next prove the correctness of our algorithm.\nLemma 3 For all i, let $S_i$ be a sequence of marked events in process $P_i$. Let $CC = \\langle e_{k_1}^i, \\ldots, e_{k_n}^i \\rangle$ be a consistent cut such that $e_{k_i}^i$ is in $S_i$ for all i. Then $TS(e_{j_f}^i)[i] \\leq l_i$ for any $i, j$.\n\nProof: Recall, that $e_{f_i}^i$ and $e_{i_0}^i$ are the first and last events of $S_i$. Since $CC$ is a consistent cut, by definition, $TS(e_{f_i}^i)[i] \\leq TS(e_{i_0}^i)[i]$ for any $i, j$. As $e_{k_i}^i$ is in $S_j$, $TS(e_{k_i}^j)[i] \\leq TS(e_{k_j}^j)[i]$ ($e_{j_f}^i \\to e_{i_0}^i$). Similarly, $TS(e_{k_i}^i)[i] \\leq l_i$ ($e_{k_i}^i \\to e_{i_0}^i$). Hence, $TS(e_{j_f}^i)[i] \\leq l_i$.\n\nLemma 4 For all i, flag$_i$ is set to true by the procedure detect if and only if there is a consistent cut $\\langle e_{k_1}^i, \\ldots, e_{k_n}^i \\rangle$ such that $e_{k_i}^i$ is in $S_i$ for all i.\n\nProof: ($\\Rightarrow$) Procedure detect sets flag$_i$ = true only if $TS(e_{j_f}^i)[i] \\leq l_i$ for each $j$. Since flag$_i$ = true, $k_i = \\max(TS(e_{j_1}^i)[i], \\ldots, TS(e_{j_n}^i)[i]) \\leq l_i$. Also, $k_i \\geq f_i$, since $TS(e_{f_i}^i)[i] = f_i$. Hence event $e_{k_i}^i$ is in $S_i$ for each $i$. Now construct a cut $CC = \\langle e_{k_1}, \\ldots, e_{k_n} \\rangle$ such that each $k_i = \\max(TS(e_{j_1}^i)[i], \\ldots, TS(e_{j_n}^i)[i])$ for all $i : 1, \\ldots, n$. The supremum of any set of consistent cuts is a consistent cut (see [?]). Clearly, $CC$ is a supremum of $n$ consistent cuts denoted by the timestamps of $e_{j_f}^i$’s. Therefore, $CC, \\langle e_{k_1}, \\ldots, e_{k_n} \\rangle$, is a consistent cut such that $e_{k_i}^i$ is in $S_i$ for all i.\n\n($\\Leftarrow$) Since there exists a consistent cut $\\langle e_{k_1}, \\ldots, e_{k_n} \\rangle$ such that $e_{k_i}^i$ is in $S_i$ for all i, from Lemma 3, $TS(e_{j_f}^i)[i] \\leq l_i$ for any $j$. Hence from step 3 of the procedure detect, flag$_i$ is set to true for each i.\n\nIn fact, Lemma 4 gives a method to determine a consistent cut at which POSSIBLY($\\Phi$) holds.\n\nTheorem 2 Algorithm POSSIBLY($\\Phi$) of Figure 3.7 is correct.\n\nProof: We first show that if POSSIBLY($\\Phi$) holds, our algorithm detects it. Since POSSIBLY($\\Phi$) is true, by definition, there exists a consistent cut $CC =$\n< e_{k_1}^i, \\ldots, e_{k_n}^i > such that C_i is true at e_{k_i}^i for all i. Therefore, e_{k_i}^i must be in a marked sequence, say S_i'. From Lemma 3,\n\\[ TS(e_{j'}^i)[i] \\leq l_i' \\quad \\forall i, j \\] (3.1)\nwhere \\( j_i' \\) and \\( l_i' \\) are indices of the first and last events of \\( S_i' \\) respectively. To prove that our algorithm detects POSSIBLY(\\( \\Phi \\)), it is enough if we show that \\( C_i \\) is true at \\( e_{k_i}^i \\) for all \\( i \\) and step 2 of the algorithm is executed. The rest of the proof follows from Lemma 4. Assume to the contrary that some of the \\( S_i' \\) were eliminated. Let \\( S' = \\{ S_1', \\ldots, S_n' \\} \\). Let \\( S'' \\subseteq S' \\) be removed when step 3 of the algorithm is executed for the \\( t^{th} \\) time and for any \\( t' < t \\) no subset of \\( S' \\) were removed. Consider an \\( S_i = S_i' \\in S'' \\). (\\( S_i \\) was removed when step 3 was executed for the \\( t^{th} \\) time.) \\( S_i \\) was removed because \\( flag_i = false \\). This implies that for some \\( j \\),\n\\[ TS(e_{j'}^i)[i] > l_i = l_i' \\] (3.2)\nNow, either \\( S_j \\in S'' \\) or \\( S_j \\notin S'' \\). If \\( S_j \\in S'' \\), then \\( S_j = S_j' \\). If \\( S_j \\notin S'' \\), then either \\( S_j = S_j' \\) or a sequence of marked events that occur before than \\( S_j' \\). Now there are only two cases to consider. Either \\( S_j = S_j' \\) or \\( S_j \\) occurs before \\( S_j' \\). \\( S_j = S_j' \\) implies \\( f_j = f_j' \\). Therefore from equation 3.1 \\( TS(e_{j'}^i)[i] \\leq l_i \\) which is a contradiction to equation 3.2. Now if \\( S_j \\) is a sequence that occurs before \\( S_j' \\), then \\( e_{j'}^i \\rightarrow e_{j'}^i \\) which implies \\( TS(e_{j'}^i)[i] < TS(e_{j'}^i)[i] \\). Therefore again from equation 3.1 \\( TS(e_{j'}^i)[i] < l_i \\) which is a contradiction to equation 3.2. Hence, if POSSIBLY(\\( \\Phi \\)) is true our algorithm detects it.\n\nIf the algorithm detects that POSSIBLY(\\( \\Phi \\)) is true, then \\( flag_i = true \\) for all \\( i \\). Hence it follows from Lemma 4 that POSSIBLY(\\( \\Phi \\)) holds.\n\nMessage complexity: Each process broadcasts \\( l_i \\) and \\( status_i \\) and \\( O(n) \\) messages are used in broadcasting them. Thus, \\( O(n^2) \\) messages are sufficient for determining POSSIBLY(\\( \\Phi \\)) if each process has one marked sequence. Otherwise, the message complexity is \\( O(kn^2) \\) where \\( k \\) is the total number of marked sequences in all of the processes.\n3.4 Concluding Remarks\n\nThis chapter develops a hierarchical approach, which consists of three levels, to dynamic testing of distributed programs. At the first level, input data is selected. The second level deals with selecting different runs for an input data. An execution of the distributed program is tested for correctness at the third level.\n\nThere is no known way to generate a finite number of distributed test cases which will “expose” all errors, since the equivalent problem in the sequential case is known to be undecidable. Further research is needed to find reasonable criteria for selecting distributed test cases. Testing all paths in a lattice is infeasible, and enumerating and testing all global states may be difficult if the number of global states is enormous. Thus, one can settle for a lesser criterion like restricted predicate based testing. More study is required in this direction. Different approaches such as (1) placing restrictions on the type of distributed programs, and (2) using probabilistic methods are future directions for research.\nChapter 4\n\nTechniques to Tackle State Space Explosion in Global Predicate Detection\n\nIn this chapter, we present several algorithms that are useful for testing in Level 3 of the hierarchy. We particularly consider the problem of detecting Possibly(Φ) where Φ is any arbitrary predicate. Cooper and Marzullo [?] present a centralized algorithm for detecting Possibly(Φ). In this chapter, we refer to this algorithm as the CM algorithm. The space and time complexities of the CM algorithm are exponential in the number of processes. Several researchers have presented polynomial time algorithms for detecting a global predicate by placing restrictions on the type of predicate [?, ?, ?, ?, ?]. However, the CM algorithm is important because (1) existing polynomial time algorithms are for restricted forms of predicates, and (2) the polynomial time algorithms are different for different kinds of predicates. In contrast, the CM algorithm may be used for any arbitrary predicate. It appears that detecting an arbitrary global predicate involves exhaustive checking of every global state. In this chapter, we present several techniques to tackle global state explosion while detecting an arbitrary predicate.\n\nThe organization of the chapter follows. We present some definitions in Section 4.1. Section 4.2 presents an algorithm for Possibly(Φ) that uses $O(mn)$\nspace where \\( m \\) is the total number of events in the computation and \\( n \\) is the number of processes in the system. This algorithm uses vector clocks. In Section 4.3, the space complexity of the algorithm for Possibly(\\( \\Phi \\)) is further reduced to \\( O(m) \\) by not using vector clocks. We parallelize the first space efficient algorithm for detecting Possibly(\\( \\Phi \\)) in Section 4.4. Section 4.5 improves the performance of the algorithms, both in time and space, by increasing the granularity of an execution step from an event to a sequence of events (\\( interval \\)). The chapter is concluded in Section 4.6.\n\n### 4.1 Preliminaries\n\nA global state \\( S \\) is represented as \\( < k_1, \\ldots, k_n > \\) such that, for process \\( P_i \\), its state after executing \\( k_i \\) events is included in \\( S \\).\n\nFor a global state \\( S = < k_1, \\ldots, k_n > \\),\n\n\\[\n\\text{value}(S) = (k_1, k_2, \\ldots, k_n)\n\\]\n\nFor a set of global states \\( GS \\),\n\n\\[\n\\text{value}(GS) = \\{ \\text{value}(S) \\mid S \\in GS \\}\n\\]\n\nFor any two global states \\( S = < k_1, \\ldots, k_n > \\) and \\( S' = < k'_1, \\ldots, k'_n > \\), \\( \\text{value}(S) > \\text{value}(S') \\) if there exists a \\( j \\) such that \\( k_j > k'_j \\) and \\( k_i = k'_i \\) for all \\( i : 1 \\leq i < j \\).\n\nFunction \\( \\text{succ} \\), the successor function, for a global state \\( S \\) is defined below.\n\n\\[\n\\text{succ}(S) = \\{ S' \\mid \\text{system may change from global state } S \\text{ to } S' \\text{ by executing one event} \\}\n\\]\n\n\\( \\text{succ}(S) \\) can contain at most \\( n \\) global states, since the number of possible events that can be executed at \\( S \\) is at most \\( n \\) (one event per process). Function \\( \\text{pred} \\), the predecessor function, for a global state \\( S \\) is defined below.\n\\[\npred(S) = \\{ S' \\mid \\text{system may change from global state } S' \\text{ to } S \\text{ by executing one event} \\}\n\\]\n\n\\( \\text{pred}(S) \\) also contains at most \\( n \\) global states. For a global state \\( S \\), its \\( \\text{pred} \\) and \\( \\text{succ} \\) can be computed easily by using vector clocks [?, ?].\n\nThroughout this chapter we assume that the computation terminates eventually.\n\n### 4.2 Algorithm for Possibly(\\( \\Phi \\))\n\nWe first discuss briefly why the CM algorithm for Possibly(\\( \\Phi \\)) requires space exponential in the number of processes. The CM algorithm constructs the lattice of the execution to detect Possibly(\\( \\Phi \\)). The number of nodes (global states) in the lattice can be exponential in the number of processes. The depth of the lattice is the total number of events in the run. Thus the average breadth of the lattice can be exponential in the number of processes, even when the total number of events in an execution is polynomial in the number of processes. The \\textit{level} of a global state \\( < k_1, \\ldots, k_n > \\) in a lattice is the sum \\( k_1 + k_2 + \\ldots + k_n \\). The CM algorithm for Possibly(\\( \\Phi \\)) traverses the lattice in a breadth first fashion. It computes all the global states in one level, stores and checks them and then proceeds to the next level. Hence the space required (to store nodes that are in one level) in the worst case can be exponential in \\( n \\).\n\nIn contrast, our algorithm traverses the lattice in a depth first fashion. We do not explicitly store the nodes that are already visited, as this will require exponential amount of space. Also, we do not visit a node more than once. We perform some computation to decide whether a node has already been visited or not.\n\n**Main idea**\n\nAssume that we are in global state \\( S \\) in the lattice. Let \\( S' \\) be a successor of \\( S \\).\nin the lattice. Now we have to decide whether $S'$ can be visited (tested) from $S$. Global state $S'$ has at most $n$ predecessors in the lattice. All predecessors $S'$ can be ordered according to their values. If the value of $S$ is the maximum among all the predecessors of $S'$, then we visit $S'$ from $S$. The key rule for testing a global state exactly once is to visit the global state only from its predecessor that has the maximum value among all of its predecessors.\n\nOur algorithm for Possibly($\\Phi$) is executed by a monitor process. During the computation, all the processes, after executing an event, send the timestamp of the event and the value of the local variables related to $\\Phi$ to the monitor. A formal description of the algorithm for Possibly($\\Phi$) appears in Figure 4.1.\n\nAlgorithm POSSIBLY is invoked with a global state $S$. First, $\\Phi$ is tested at $S$. If $\\Phi$ holds, then the algorithm returns true. Otherwise $\\text{succ}(S)$ is computed. For every successor $S'$ of $S$ such that $S$ is the predecessor of $S'$ with the maximum value, algorithm POSSIBLY($S'$) is invoked. Initially, the monitor invokes the algorithm with the initial global state $<0,\\ldots,0>$. Before invoking the algorithm POSSIBLY with a global state $S$, if the monitor has not received the values of the variables corresponding to the state $S$, it waits for them and then invokes POSSIBLY with $S$. If the algorithm returns true, then Possibly($\\Phi$) is true.\n\n**An example**\n\nWe illustrate the working of the algorithm with a sample lattice shown in Figure 4.2(b). The execution corresponding to this lattice is shown in Figure 4.2(a). The numbers in bold show the order in which the lattice is traversed. The algorithm is invoked with the initial global state $<0,0>$. The value of $i$ is 1. After step 6, $S' = <1,0>$. Since, $<1,0>$ is a consistent global state and $\\text{max}(\\text{value}(\\text{pred}(<1,0>)))$ is $<0,0>$, POSSIBLY($<1,0>$) is invoked.\n\nTo understand the algorithm further, assume that algorithm POSSIBLY is invoked with state $<0,1>$. After executing step 6 once, $S' = <1,1>$. The set $\\text{pred}(<1,1>)$ is $\\{<1,0>,<0,1>\\}$, and $\\text{max}(\\text{value}(\\text{pred}(<1,1>)))$ is\nAlgorithm POSSIBLY($S$)\nbegin\n(1) if $\\Phi$ is true at $S$ then\n(2) \\hspace{5mm} \\text{return(true);}$\n(3) \\hspace{5mm} $i := 1;$\n(4) \\hspace{5mm} Let $S = <k_1, \\ldots, k_i, \\ldots, k_n>$$\n(5) \\hspace{5mm} \\text{while (} i \\leq n \\text{) do}$\n\\hspace{10mm} begin\n(6) \\hspace{10mm} $S' = <k_1, \\ldots, k_i + 1, \\ldots, k_n>$$\n(7) \\hspace{10mm} \\text{if } S' \\text{ is a consistent global state then}$\n(8) \\hspace{10mm} \\hspace{10mm} \\text{if } value(S) = \\max(value(pred(S')))$\n(9) \\hspace{10mm} \\hspace{10mm} \\hspace{10mm} \\text{if } (\\text{POSSIBLY}(S') = \\text{true})$ then\n(10) \\hspace{10mm} \\hspace{10mm} \\hspace{10mm} \\hspace{10mm} \\text{return(true);}$$\n(11) \\hspace{10mm} i = i + 1;$\n\\hspace{10mm} end;\n(12) \\hspace{10mm} \\text{return(false);}$$\nend.$\n\nFigure 4.1: Algorithm for detecting POSSIBLY($\\Phi$)\nFigure 4.2: A sample execution and its lattice.\n<1, 0> and not <0, 1> (step 8). So, POSSIBLY(<1, 1>) is not invoked from <0, 1>. When step 6 is executed for the second time, S' becomes <1, 2>. But <1, 2> is not a consistent global state, and since there are no more successors of <0, 1>, the current invocation of the algorithm returns.\n\n4.2.1 Correctness and Analysis\n\nTheorem 3 Possibly(Φ) is true if and only if algorithm POSSIBLY returns true when invoked with the initial global state.\n\nProof(⇒) We prove by taking the contrapositive, i.e., if the algorithm returns false, then Possibly(Φ) is false. To prove this, it is sufficient to prove that all global states of the lattice are checked by the algorithm. The proof is by induction on the level of the lattice. The algorithm is initially invoked with the initial global state at level 0, so all global states at level 0 are checked. Assume that all the global states at level k are checked, for some k ≥ 0. Consider a global state S' at level k + 1. The global state S' has at least one predecessor at level k. Let S be a predecessor of S' such that S has the maximum value among all the predecessor of S' at level k. From step (8) of the algorithm it is clear that whenever S is checked, S' will also be checked. The global state S is at level k, and by induction hypothesis S is checked. Hence, if Possibly(Φ) is true, algorithm POSSIBLY returns true.\n\n(⇐) Algorithm POSSIBLY returns true only if Φ is true at a global state. Hence Possibly(Φ) is true.\n\nTheorem 4 The space complexity of Algorithm POSSIBLY is O(mn) where m is the total number of events in the given run and n is the number of processes.\nProof Observe that the depth of the recursion for the algorithm is at most $m$, the depth of the lattice. The size of data stored at each level of recursion is $O(n)$. (The number of components of the timestamp of an event is $n$). So, it is easy to see that $O(nm)$ is the space complexity for the algorithm.\n\nWe performed some experimental studies and their results are shown in Table 4.1. Some sample executions were generated for different number of processes. With 12 processes and 1200 events (depth) the maximum size of breadth is 875201. So a depth first approach can give significant savings in storage over the breadth first approach. Also when using the breadth first approach, the global states at the next level have to be computed and stored in a linked list. Before inserting a global state in the list, the list has to be searched to determine whether the global state is already present in the list. (A global state at the next level may be computed more than once because the global state can have more than one predecessor at the current level.) Maintaining and searching the list requires significant amount of time when the breadth of the lattice is large.\n\nOne advantage of breadth first approach is that Possibly($\\Phi$) can be detected early if $\\Phi$ is true at a global state at the top of the lattice. However if $\\Phi$ is true at a global state that occurs near the bottom of the lattice, depth first approach detects $\\Phi$ early as breadth first approach will be spending significant time in levels at the top of the lattice.\n\n<table>\n<thead>\n<tr>\n<th>Processes</th>\n<th>Total No. of Events</th>\n<th>No. of Global States</th>\n<th>Max. Breadth</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>5</td>\n<td>500</td>\n<td>203801</td>\n<td>1430</td>\n</tr>\n<tr>\n<td>8</td>\n<td>800</td>\n<td>3238799</td>\n<td>62609</td>\n</tr>\n<tr>\n<td>10</td>\n<td>1000</td>\n<td>18052003</td>\n<td>270353</td>\n</tr>\n<tr>\n<td>12</td>\n<td>1200</td>\n<td>22084953</td>\n<td>875201</td>\n</tr>\n</tbody>\n</table>\n\nTable 4.1: Experimental Results\nThe space complexity of the algorithm can further be reduced to $O(m)$ without using vector clocks. The linear space algorithm is presented in the next section.\n\n4.3 A Linear Space Algorithm\n\nThis algorithm does not use vector clocks. For every event $e$, the algorithm needs those events that immediately “happened before” $e$. Let the set of events that immediately happened before $e$ be denoted by $\\text{dep}(e)$. If $e$ is an internal event or send event, $\\text{dep}(e)$ is just the event that occurred immediately before $e$ in the same process. If $e$ is a receive event, $\\text{dep}(e)$ has two events – the corresponding send event and the event that occurred immediately before $e$ in the same process. During the computation, we append, to every message, the event number of the corresponding send event and the process in which the send event occurred. Thus, $\\text{dep}(e)$ can be easily computed on the fly.\n\nEvent $e \\in C$ is incomparable if $e \\not\\rightarrow e'$ for any event $e' \\in C$ ($C \\subseteq E$). Let $\\text{incomp}(S)$ denote the set of incomparable events in the cut corresponding to the global state $S$. The set $\\text{incomp}(S)$ can have at most one event per process. We order the events in $\\text{incomp}(S)$ according to the id of the process in which they occur. Let $\\text{max(}\\text{incomp}(S)\\text{)}$ denote the event in $\\text{incomp}(S)$ that occurred in the process with the largest id among all the events in $\\text{incomp}(S)$.\n\n**Lemma 5** Let $S$ be a global state in execution $E$. Global state $S'$ is a predecessor of $S$ in the lattice of $E$ if and only if $S$ is reachable from $S'$ by executing an event $e \\in \\text{incomp}(S)$.\n\n**Proof:** ($\\Rightarrow$) Let $C'$ and $C$ be the cuts corresponding to $S'$ and $S$ respectively. Since $S'$ is a predecessor of $S$, global state $S$ is reachable from $S'$ by executing an event $e$. Assume that $e \\not\\in \\text{incomp}(S)$. This implies that there exists an event\n\\( e' \\in C \\) such that \\( e \\rightarrow e' \\), \\( e' \\in C' \\), because \\( C' \\subset C \\) and \\( C - C' = \\{ e \\} \\). Now, \\( e' \\in C' \\) and \\( e \\notin C' \\) implies that \\( C' \\) is not a consistent cut and \\( S' \\) is not a consistent global state, a contradiction.\n\n(\\( \\Leftarrow \\)): Follows from the definition of predecessor.\n\nThe above lemma and the ordering of events in \\( \\text{incomp}(S) \\) suggest a way to test the global state \\( S \\) exactly once. If we are in \\( S' \\), we will test \\( S \\) only if we execute event \\( e \\) at \\( S' \\) to reach \\( S \\) where \\( e = \\max(\\text{incomp}(S)) \\). For this, the knowledge of \\( \\text{incomp}(S) \\) is needed. Assuming that we know \\( \\text{incomp}(S') \\), the following lemma shows a way to compute \\( \\text{incomp}(S) \\).\n\n**Lemma 6** Let global state \\( S \\) be reachable from global state \\( S' \\) in the lattice of \\( E \\) by executing event \\( e \\). Then \\( \\text{incomp}(S) = \\text{incomp}(S') - \\text{dep}(e) + \\{ e \\} \\).\n\n**Proof:** First we show that for any event \\( e' \\), \\( e' \\in \\text{incomp}(S) \\Rightarrow e' \\in \\text{incomp}(S') - \\text{dep}(e) + \\{ e \\} \\). Assume that \\( e' \\in \\text{incomp}(S) \\) but \\( e' \\notin \\text{incomp}(S') - \\text{dep}(e) + \\{ e \\} \\). Clearly, \\( e' \\neq e \\). Also \\( e' \\neq e \\) since \\( e' (\\in \\text{incomp}(S)) \\) is an incomparable event in \\( C \\) and \\( e \\in C \\). Thus \\( e' \\notin \\text{dep}(e) \\). Therefore \\( e' \\notin \\text{incomp}(S') \\). As \\( e' \\) is not an incomparable event in \\( C' \\) there exists an event \\( e'' \\) in \\( C' \\) such that \\( e' \\rightarrow e'' \\). Since \\( C' \\subset C \\) and \\( C - C' = \\{ e \\} \\), \\( e'' \\in C \\) also. Therefore, \\( e' \\) is not an incomparable event in \\( C \\). Hence \\( e' \\notin \\text{incomp}(S) \\), a contradiction.\n\nNext, we show that \\( e' \\in \\text{incomp}(S') - \\text{dep}(e) + \\{ e \\} \\Rightarrow e' \\in \\text{incomp}(S) \\). If \\( e' = e \\), the claim follows from Lemma 5. Now, assume \\( e' \\neq e \\). Clearly, \\( e' \\notin \\text{dep}(e) \\).\n\nOtherwise \\( e' \\in \\text{incomp}(S') - \\text{dep}(e) + \\{ e \\} \\) is not true, since \\( \\text{dep}(e) \\) is subtracted from \\( \\text{incomp}(S') \\). So, \\( e' \\in \\text{incomp}(S') \\). Now we claim that \\( e' \\neq e \\). If \\( e' \\rightarrow e \\), then either \\( e' \\) immediately happened before \\( e \\) or \\( e' \\rightarrow e'' \\rightarrow e \\) where \\( e'' \\in \\text{dep}(e) \\).\n\nBut \\( e' \\notin \\text{dep}(e) \\). Therefore, \\( e' \\rightarrow e'' \\rightarrow e \\) where \\( e'' \\in \\text{dep}(e) \\). Now \\( \\text{dep}(e) \\subset C' \\), since \\( \\text{dep}(e) \\subset C \\) and \\( C = C' \\cup \\{ e \\} \\). \\( \\text{dep}(e) \\subset C' \\) and \\( e' \\in \\text{incomp}(S') \\) implies that \\( e \\neq e'' \\). So, \\( e' \\neq e \\). Therefore there does not exist any event \\( e'' \\) such that \\( e'' \\in C' \\cup \\{ e \\} = C \\) and \\( e' \\rightarrow e'' \\). Hence \\( e' \\in \\text{incomp}(S) \\). \n\n\\[ \\square \\]\nWe use the above lemma to reduce the space complexity. The algorithm is similar to the algorithm in Figure 4.1. The only difference is in the way the key rule to visit a global state is implemented. A formal presentation of the algorithm is shown in Figure 4.3. GS and INC are global variables. GS is initialized to the initial global state, and INC is initially empty. The set of incomparable events in GS is stored in INC. At any instant, GS contains the current global state being tested or considered for testing. At step 5, we execute the next event, say $e$, in process $i$ by incrementing the $i^{th}$ component of GS. Now to check whether the new value of GS is a consistent global state, it is enough if we check whether $\\text{dep}(e)$ is included in GS since the previous value of GS is a consistent global state.\n\n### 4.3.1 Correctness and Analysis\n\n**Theorem 5** $\\text{Possibly}(\\Phi)$ is true if and only if algorithm POSSIBLY in Figure 4.3 returns true when invoked with the initial global state.\n\n**Proof ($\\Rightarrow$)** We prove by taking the contrapositive, i.e., if the algorithm returns false, then $\\text{Possibly}(\\Phi)$ is false. To prove this, it is sufficient if we prove that all global states of the lattice are checked by the algorithm. The proof is by induction on the level of the lattice. The algorithm is initially invoked with GS set to the initial global state. Assume that all the global states at level $k$ are checked, for some $k \\geq 0$. Consider a global state $S$ at level $k + 1$. Let $e = \\text{max}(\\text{incomp}(S))$ and $e$ be an event in $P$. From Lemma 5, there exists a predecessor, say $S'$, from which $S$ can be reached by executing $e$. The global state $S'$ is at level $k$, and by induction hypothesis function possibly is invoked with $GS$ set to $S'$. Steps 5 through 9 of the algorithm ensures $S$ will also be checked. (From Lemma 6, it follows that the set $INC$ will be equal to $\\text{incomp}(S)$ after step 8.) Hence, if $\\text{Possibly}(\\Phi)$ is true, algorithm POSSIBLY returns true.\nGlobal variables:\n\n$GS$ : array $[1, \\ldots, n]$ of integers; \\textit{contains the current global state}\n\n$INC$ : set of events; \\textit{contains the incomparable events in GS}\n\nFunction POSSIBLY()\nbegin\n(1) if $\\Phi$ is true at $GS$ then\n(2) return(true);\n(3) $i := 1$;\n(4) while ($i < n$) do\n\\hspace{1em} begin\n(5) $GS[i] = GS[i] + 1$; \\textit{let} $\\epsilon$ \\textit{be the event executed in} $P_i$\\end\n(6) if $GS$ is a consistent global state then\n\\hspace{1em} $temp = INC \\cap \\text{dep}(\\epsilon)$;\n(7) $INC = INC - temp + \\{\\epsilon\\}$;\n(8) if $\\max(INC) = \\epsilon$\n\\hspace{1em} if (POSSIBLY() = true) then\n\\hspace{2em} return(true);\n\\hspace{1em} $INC = INC + temp - \\{\\epsilon\\}$;\n(10) $GS[i] = GS[i] - 1$;\n(11) $i = i + 1$;\n\\hspace{1em} end;\n(12) return(false);\nend.\n\nFigure 4.3: Linear Space Algorithm for detecting POSSIBLY($\\Phi$)\nAlgorithm POSSIBLY returns true only if $\\Phi$ is true at a global state. Hence $\\text{Possibly}(\\Phi)$ is true.\n\n**Theorem 6** The space complexity of Algorithm POSSIBLY in Figure 4.3 is $O(m)$ where $m$ is the total number of events in the given run.\n\n**Proof** Observe that the algorithm does not use vector clocks to check if a global state is consistent. We store only $\\text{dep}(e)$ for every event which uses a constant space. The local variable $\\text{temp}$ inside the function POSSIBLY() can contain at most two events. So every time the function is invoked, only a constant amount of additional storage is used. Since the depth of recursion is equal to the total number of events $m$, the space complexity of the algorithm is $O(m)$.\n\n### 4.4 A Parallel Algorithm\n\nIn this section, we parallelize the algorithm presented in the Section 4.2 to reduce the time taken to detect $\\text{Possibly}(\\Phi)$. (The linear space algorithm presented in Section 4.3 can also be parallelized similarly.) We assume that a parallel machine consisting of $t$ processors is available. Our algorithm is independent of the architecture of the parallel machine. In fact the distributed system on which the computation was performed can also be used.\n\nTo ease the description of the algorithm, we assume that the input (timestamps of all the events, and the value of variables related to $\\Phi$ after every event) is available at all the processors. Later, we discuss various ways of providing the input to all the processors.\n\nIn our parallel algorithm, every global state is tested exactly by one processor. A salient feature of our algorithm is that processors do not exchange messages to decide whether they can test a particular global state or not. We\nachieve this by using the same idea used in Section 4.2 to reduce the space complexity of algorithm POSSIBLY.\n\nA global state will be tested only by a processor that tested the largest predecessor (which is unique) of the global state. If a processor, say $\\mathcal{P}_r_i$, finds some idle processor, $\\mathcal{P}_r_i$ will delegate one of the global states that it has to test to the idle processor.\n\nOne of the processors will also act as a processor allocator. A processor that becomes idle will register itself with the allocator. When a processor has more than one global state to test, it will request the allocator for idle processor(s). The allocator will serve the requests in the first come first serve basis. Initially, processor $\\mathcal{P}_r_0$ is assigned the initial global state, and all other processors are idle.\n\nNow we illustrate our algorithm with the example shown in Figure 4.4. The number of processors used is 3. Processor $\\mathcal{P}_r_0$ is assigned the global state $< 0, 0 >$ initially. Since the global state $< 0, 0 >$ is the largest predecessor of $< 1, 0 >$ and $< 0, 1 >$ processor $\\mathcal{P}_r_0$ has to test them. However, processors $\\mathcal{P}_r_1$ and $\\mathcal{P}_r_2$ are idle. So, $\\mathcal{P}_r_0$ assigns state $< 0, 1 >$ to $\\mathcal{P}_r_1$ and tests state $< 1, 0 >$. $\\mathcal{P}_r_0$, after testing $< 1, 0 >$, considers the states $< 2, 0 >$ and $< 1, 1 >$. Since $< 1, 0 >$ is the largest predecessor of the states $< 2, 0 >$ and $< 1, 1 >$, it is processor $\\mathcal{P}_r_0$’s responsibility to test them. At this stage, $\\mathcal{P}_r_2$ is idle, so state $< 1, 1 >$ is assigned to $\\mathcal{P}_r_2$. $\\mathcal{P}_r_2$ tests $< 2, 0 >$.\n\n$\\mathcal{P}_r_1$ after testing $< 0, 1 >$ examines $< 1, 1 >$ and finds that $< 0, 1 >$ is not the largest predecessor of $< 1, 1 >$, so it does not test $< 1, 1 >$. $\\mathcal{P}_r_2$ informs the allocator that it is idle as it does not have any other global state to test. Proceeding in a similar fashion, $\\mathcal{P}_r_0$ tests states $< 2, 1 >$, $< 2, 2 >$, $< 2, 3 >$, and $< 3, 3 >$ and $\\mathcal{P}_r_2$ tests $< 1, 2 >$, and $< 1, 3 >$.\n\nA formal description of the algorithm is shown in Figure 4.5. An idle processor, say $\\mathcal{P}_r_i$, begins testing when it receives a start($S$) message ($S$ is a\nglobal state). \\( P_r_i \\) first tests \\( \\Phi \\) at \\( S \\). If \\( \\Phi \\) is true at \\( S \\), it notifies all the processors and exits. Otherwise \\( P_r_i \\) finds the list of all the successors of \\( S \\) for which \\( S \\) is the largest predecessor and stores them in queue \\( Q_i \\). Processor \\( P_r_i \\) then requests the allocator for any idle processor by sending \\( \\text{request}(x) \\) message to the allocator where \\( x \\) is the number of processors that \\( P_r_i \\) needs. \\( P_r_i \\) then takes the first element in \\( Q_i \\) and repeats the steps in the loop.\n\nIn the meanwhile, if \\( P_r_i \\) receives \\( \\text{allocated}(P_r_i) \\) message, \\( P_r_i \\) sends \\( \\text{start}(S') \\) to \\( P_r_j \\) where \\( S' \\) is the last element in \\( Q_i \\). When \\( Q_i \\) becomes empty, \\( P_r_i \\) informs the allocator that is idle and waits for a \\( \\text{start} \\) message.\n\n4.4.1 Correctness and Analysis\n\nThe correctness of the parallel algorithm is similar to the proof in Theorem 3. We analyze the space complexity of the algorithm assuming that only one processor\nOn receiving \\textit{start}(GS), execute the following steps.\n\n\\begin{verbatim}\nS = GS;\ndone = false;\nrepeat\n count = 0;\n if \\Phi is true at S, notify all the processors and exit;\n for each \\( S' \\) such that \\( S' \\) is a successor of \\( S \\)\n if \\( \\text{value}(S) = \\max(\\text{value}(\\text{pred}(S')) \\) then\n add \\( S' \\) to the head of \\( Q_i \\);\n count = count + 1;\n if \\( Q_i \\) is empty then\n done = true\n else\n S = head of \\( Q_i \\);\n send \\textit{request}(count - 1) message to the allocator;\n delete the first element of \\( Q_i \\);\n until(done)\ninform the allocator that \\( P_{ri} \\) is idle.\n\\end{verbatim}\n\nOn receiving \\textit{allocated}(\\( P_{rj} \\)) from the allocator, execute the following steps.\n\n\\begin{verbatim}\nS' = tail of \\( Q_i \\);\ndelete tail of \\( Q_i \\);\nSend \\textit{start}(S') to processor \\( P_{rj} \\);\n\\end{verbatim}\n\nFigure 4.5: Algorithm executed by processor \\( P_{ri} \\)\nexecutes the parallel algorithm.\n\n**Theorem 7** The space complexity of the parallel algorithm is $O(mn^2)$ where $m$ is the total number of events in the given run and $n$ is the number of processes.\n\n**Proof:** Note that $\\mathcal{P}_i$ adds a global state to the head of queue and removes a global state from the head of the queue. (The queue is used as a stack.) Thus the global states at a higher level of the lattice are tested first before testing the next global state in the same level. This ensures that at most $n$ global states are stored per level. (There can be at most $n$ immediate successors for a global state.) The space required to store a global state is $O(n)$. Since there are $m$ levels in the lattice, the total space required is $O(mn^2)$.\n\nThe following situation of the algorithm merits observation: Whenever $\\mathcal{P}_i$ receives an allocated($\\mathcal{P}_j$) message, $\\mathcal{P}_i$ sends start($S'$) to $\\mathcal{P}_j$ where $S'$ is the last element in $Q_i$. The last global state in $Q_i$ is at a level earlier than the level of the global state that is at the head of the queue $Q_i$. The reasoning behind this is that $\\mathcal{P}_j$ may get to test more number of global states if it starts from an earlier level than if it starts from a latter level. One can visualize the working of the parallel algorithm as though the parallel machine is proceeding in a breadth first fashion and each processor within the machine is proceeding in a depth first fashion.\n\nWe have evaluated the performance of our parallel algorithm by a simulation. Figure 4.6 shows the relationship between total time taken for the parallel machine to test all the global states and the number of processors. As the number of processors increases the time taken to test all the global states reduces. Figure 4.7 shows the speedup achieved as the number of processors is varied. The speedup achieved is close to the optimal value, for the experiments we have performed, since the number of global states is very large.\nFigure 4.6: Time taken vs. No. of Processors.\n\nFigure 4.7: Speedup vs. No. of Processors.\nProviding Input\n\nIf a parallel machine is dedicated for testing Possibly($\\Phi$), one way to distribute the input is to send the input to all the processors. Another approach is to store the input in a shared memory, and the processors can get the input from the shared memory as and when they require it. If the existing distributed system itself is used for testing, the input can be provided separately to all the processors or the input can be stored in a common place, e.g., in a mounted network file system or a distributed shared memory.\n\n4.5 Increasing the granularity of the execution step\n\nThe performance of algorithms for detecting arbitrary global predicates can be improved by considering a sequence of consecutive events instead of a single event when detecting $\\Phi$. The value of a local variable related to $\\Phi$ may not change during every event. A consecutive sequence of states in a process in which the values of the local variables related to $\\Phi$ remain unchanged can be considered as identical states with respect to the detection of $\\Phi$. An interval is a maximal sequence of events such that the values of the local variables related to $\\Phi$ are the same after the occurrence of every event in the sequence. A process begins a new interval if an event changes the value of its local variable related to $\\Phi$.\n\nProcess $P_i$ maintains an interval clock $V_i$ consisting of $n$ components. Process $P_i$ increments the $i^{th}$ component of $V_i$ whenever it begins a new interval. When a process sends a message, it timestamps the message with the current value of its interval clock. When $P_i$ receives a message with timestamp $T$, $V_i[j]$ is set to $\\max(V_i[j], T[j])$ for all $j$. The timestamp of interval $I_i$ is denoted by $TS(I_i)$. For an interval $I_i$ in $P_i$, $TS(I_i)$ is the value of the updated interval clock $V_i$ when the first event of the interval $I_i$ occurred.\n\nWe say that two intervals $I_i$ and $I_j$ are consistent if $TS(I_i)[j] \\leq TS(I_j)[j]$ and $TS(I_j)[i] \\leq TS(I_i)[i]$. A global interval is a collection of intervals with one\ninterval from every process such that the intervals are pairwise consistent. A\nglobal interval \\( GI = < I_1, \\ldots, I_n > \\) is consistent if \\( I_i \\) and \\( I_j \\) are consistent for all \\( i, j \\). The set of all global intervals forms a lattice. A node in a lattice is a global interval, and there is an edge between global intervals \\( GI_i \\) to \\( GI_j \\) if the computation can proceed from one global interval to another by executing a sequence of events (interval) in a process. Our claim is that it is sufficient if we check all the global intervals instead of all the global states to detect Possibly(\\( \\Phi \\)) for any arbitrary predicate. We first present some definitions that are useful in proving this claim.\n\nFor an event \\( e \\), \\( \\text{mincut}(e) \\) is a consistent cut \\( C \\) such that \\( e \\in C \\) and for any consistent cut \\( C' \\) if \\( e \\in C' \\), then \\( C \\subseteq C' \\). The \\text{wavefront} of a cut \\( C \\) is \\( < e_1, \\ldots, e_n > \\) such that \\( e_i \\) is in \\( P_i \\) and for any \\( e_i' \\) in \\( P_i \\), if \\( e_i \\rightarrow e_i' \\) then \\( e_i' \\not\\in C \\) [?]. Let \\( I.first \\) and \\( I.last \\) denote the first event and the last event of the interval \\( I \\), respectively.\n\n**Theorem 8** There exists a consistent global interval at which \\( \\Phi \\) is true if and only if there exists a consistent cut (global state) at which \\( \\Phi \\) is true.\n\n**Proof** (\\( \\Rightarrow \\)) Let \\( GI = < I_1, \\ldots, I_n > \\) be a consistent global interval at which \\( \\Phi \\) is true. From the definition of consistent global interval, it is clear that \\( I_i \\) and \\( I_j \\) are consistent, for any \\( i \\) and \\( j \\). Consider any event \\( e \\) in \\( P_i \\) such that \\( I_i.last \\rightarrow e \\). Then, \\( e \\not\\in I_j.first \\), since \\( I_i \\) and \\( I_j \\) are consistent. Therefore, \\( e \\not\\in \\text{mincut}(I_j.first) \\).\n\nThus, for any \\( e \\) in \\( P_i \\)\n\n\\[\nI_i.last \\rightarrow e \\Rightarrow e \\not\\in \\text{mincut}(I_j.first)\n\\] \\hfill (4.1)\n\nLet \\( C = \\bigcup_{i=1}^{n} \\text{mincut}(I_i.first) \\). \\( C \\) is the supremum of \\( n \\) consistent cuts, hence \\( C \\) is also a consistent cut [?]. Let the wavefront of \\( C \\) be \\( < e_1, \\ldots, e_n > \\). To prove that \\( \\Phi \\) is true at \\( C \\), it is sufficient if we show that \\( e_i \\) is in \\( I_i \\) for all \\( i \\). Now for any \\( i \\), either \\( e_i = I_i.first \\), or \\( I_i.first \\rightarrow e_i \\). If \\( e_i = I_i.first \\), then \\( e_i \\) is in \\( I_i \\).\nNow consider the case in which $I_i.first \\rightarrow e_i$. Since $e_i \\in C$, there exists a $j$ such that $e_i \\in mincut(I_j.first)$. From (4.1) (by taking contrapositive) it is clear that $I_j.last \\not\\rightarrow e_i$. This implies that $e_i \\rightarrow I_i.last$, or $e_i = I_i.last$. Therefore, $e_i$ is in $I_i$. Hence $\\Phi$ is true at the consistent cut $C$.\n\n$(\\Leftarrow)$ Let $<e_1, \\ldots, e_n>$ be the wavefront of the cut at which $\\Phi$ is true. Let $e_i$ be in an interval $I_i$ for all $i$. Consider any $i$, $j$. Since $e_i$ and $e_j$ are consistent, for any $e$ in $P_j$ such that $e_j \\rightarrow e$, $e \\neq e_i$. Observe that $I_i.first = e_i$, or $I_i.first \\rightarrow e_i$ and $e_j = I_j.last$, or $e_j \\rightarrow I_j.last$. Therefore, $e \\neq e_i$ (where $e$ is an event such that $I_j.last \\rightarrow e$ and $e$ is in $P_j$). Therefore, $e \\neq I_i.first$. Hence, $TS(I_i)[j] \\leq TS(I_j)[j]$.\n\nSimilarly, it can shown that $TS(I_j)[i] \\leq TS(I_i)[i]$. Thus, $<I_1, \\ldots, I_n>$ is a consistent global interval and $\\Phi$ is true at this global interval.\n\nTheorem 8 implies that it is sufficient to consider global intervals instead of global states to detect Possibly($\\Phi$). When a process begins a new interval, it sends the timestamp of the interval and the value of the local variable related to $\\Phi$ to the monitor process. Algorithm POSSIBLY described in Figure 4.1 and the parallel algorithm described in Figure 4.5 can use global intervals to detect Possibly($\\Phi$). The successor and predecessor functions can be computed using the timestamps of the intervals. In a process, the number of intervals can be considerably less than the number of events if every event does not change the value of the local variable. Therefore, the total number of global intervals can be substantially less than the total number of global states, improving the performance of our algorithms to detect Possibly($\\Phi$) both in space and time.\n\nThe linear space algorithm presented in Section 4.3 cannot use global intervals without increasing the space complexity for the following reasons. The number of intervals that directly depends on an interval can be $n$ in the worst case and hence the size of $dep(e)$ can be $n$. Also, to find whether a global interval is consistent we need an interval clock (whose size is $n$ integers).\n\nOur concept of interval clock is an extension of weak vector clock used by\nMarzullo and Neiger [2]. A process $P_i$ increments its $i^{th}$ component (terminates an interval) either when it executes an event that potentially changes $\\Phi$, or when it executes a receive event through which it perceives that another process has potentially changed $\\Phi$ [2]. But in our technique, a process terminates an interval only when it executes an event that changes a value of a variable related to $\\Phi$. A process $P_i$ may not change the variable related to $\\Phi$ but it may receive messages from a process $P_j$ that frequently changes its variable related to $\\Phi$. If we use our method, process $P_i$ will contain only one interval; whereas if we use the weak vector clock, the number of intervals in $P_i$ can be more depending on the number of messages it receives from $P_j$. Hence, the number of global intervals in our case can be considerably less than the number of global states obtained by using weak vector clocks.\n\nFigure 4.8: An example to compare interval clocks and weak vector clocks\n\nTo compare interval clocks and weak vector clocks, consider the example shown in Figure 4.8. The local variable of $P_1$ is $a$, and its value is changed by five events. The local variable of $P_2$ is $b$, and its value is changed once. If we use weak vector clocks, the number of global states that must be tested is 26; whereas the number of global intervals is 9 if we use interval clocks. The difference can be substantial if the number of processes is large.\n4.6 Concluding Remarks\n\nIn this chapter, we presented space efficient algorithms to detect Possibly(Φ) for any arbitrary predicate Φ. Reduction in space is achieved by traversing the lattice in a depth first fashion and by not storing the nodes that are already visited. We have then presented a parallel algorithm to detect Possibly(Φ). Our experimental study shows that the speedup achieved is close to the optimal value. Also, we have improved the performance of our algorithm, both in space and time, by increasing the granularity of an execution step from an event to a sequence of events. If every event does not change the values of the variables that are related to the predicate Φ, the number global intervals will be considerably less than the number of global states thereby improving the performance of our algorithm.\nChapter 5\n\nDistributed Snapshots with Causal Message Ordering\n\nRecording a global state (taking a snapshot) is a fundamental problem in distributed systems. Since the information is distributed among the processes and there is no common clock, the processes have to coordinate to record a global state. Due to the inherent asynchrony in distributed systems, the recorded global state may not have occurred during the execution. However, the recorded global state can be useful in many applications – in detecting stable properties like “program has terminated,” “processes are deadlocked,” etc. [?], and in setting distributed breakpoints. A distributed breakpoint is a natural extension of the conventional notion of a breakpoint in a sequential program to a distributed program [?]. A distributed breakpoint is initiated by one process of a distributed system, and is used to stop the execution of all the processes such that the resulting global state is consistent.\n\nIn this chapter, we present an optimal distributed algorithm to record a global state of a distributed system with causally ordered message delivery. The message complexity of our algorithm is $O(n)$ bits where $n$ is the number of processes in the system. The algorithm is message optimal. The time complexity of our algorithm is also $O(n)$. Optimality is achieved by using some “information” already available for implementing causally ordered message delivery. We\nassume that the underlying causal ordering protocol can be modified to make this information available to the snapshot algorithm. Our algorithm improves the algorithm presented by Acharya and Badrinath [?] that uses $O(n)$ control messages where each message contains $n$ integers. Several algorithms have been proposed for recording global states both in FIFO and NON-FIFO networks [?, ?, ?, ?].\n\nIn Section 5.1, we present some definitions. The snapshot algorithm is presented in Section 5.2 and the correctness of the algorithm in Section 5.3. We compare our algorithm with the algorithm of Acharya and Badrinath in Section 5.4. Section 5.5 concludes the chapter.\n\n5.1 Preliminaries\n\nThe ordering of events in a distributed system is based on the “happened before” relation, denoted by $\\rightarrow$, introduced by Lamport [?]. Causal ordering of message delivery is preserved if, for any two messages $m$ and $m'$ that have the same destination and $\\text{send}(m) \\rightarrow \\text{send}(m')$, $\\text{recv}(m) \\rightarrow \\text{recv}(m')$. An example of causal ordering is shown in Figure 5.1(a). Process $P_1$ first sends message $m$ to $P_3$ and then sends message $m''$ to $P_2$. Process $P_2$ sends a message $m'$ to $P_3$ after receiving message $m''$. Since $\\text{send}(m) \\rightarrow \\text{send}(m')$, causal ordering requires $P_3$ to receive $m$ before $m'$. Note that causal ordering implies FIFO, but FIFO need not imply causal ordering. In Figure 5.1(b) the FIFO property is satisfied but causal ordering is violated. For any two messages $m$ and $m'$ sent to the same process such that $\\text{send}(m) \\rightarrow \\text{send}(m')$, causal ordering requires that $\\text{recv}(m) \\rightarrow \\text{recv}(m')$, whereas FIFO requires this only if $m$ and $m'$ were sent by the same process. Thus causal ordering is a stronger property than FIFO. In our model, all messages are delivered in causal order. The reader is referred to [?, ?, ?] for implementation details of causally ordered message delivery.\n\nFor definitions of consistent and complete global states, please refer to Chapter 2.\nThe performance of the snapshot algorithm is measured by the communication complexity. The communication complexity (worst case) is the maximum number of bits transmitted by the snapshot algorithm.\n\n5.2 Snapshot Algorithm\n\nOur snapshot algorithm makes use of the information already available for maintaining causal order of message delivery. For ease of exposition, we refer to the protocol that ensures causal order message delivery as the causal order protocol. The snapshot algorithm is initiated by a process by multicasting a marker message to all the processes. The causal ordering protocol at the initiator will append some information to the marker to maintain causally ordered message delivery. When the causal order protocol at a process receives a marker it saves this information appended to the marker. Subsequently, on receiving an application message, the causal order protocol checks (using the information saved) whether the sending of the marker happened before the sending of the application message. If so, it marks the application message new and delivers the message.\nto the process. Otherwise it marks the application message old and delivers the message to the process. We assume that this modification can be incorporated into the protocol that maintains causal ordering.\n\nThe above mentioned modification can be done if the implementation of causal order protocol is based on vector clocks [?] or on message counting [?]. Consider the implementation based on message counting. Each process $P_i$ maintains two arrays $\\text{DELIV}_i[1, \\ldots, n]$ and $\\text{SENT}_i[1, \\ldots, n, 1, \\ldots, n]$. $\\text{DELIV}_i[j]$ denotes the number of messages from $P_j$ delivered to $P_i$. $\\text{SENT}_i[j, k]$ is the number of messages sent by $P_j$ to $P_k$ that $P_i$ knows of. Whenever a message $m$ is sent by $P_i$, $\\text{SENT}_i$ is sent with $m$. Now when the causal order protocol at $P_j$ receives the marker message, $<\\text{marker}, \\text{ST}>$, the causal order protocol saves the value $\\text{ST}[i, j]$. On receiving a subsequent message $<m, \\text{ST}_m>$, if $\\text{ST}_m[i, j] \\geq \\text{ST}[i, j]$, then $m$ is marked new. Otherwise $m$ is marked old.\n\nWe next present the snapshot algorithm. A process that initiates the algorithm is called an initiator. The initiator may be the process in which the user wants to set a distributed breakpoint. For simplicity, we assume that only one process initiates the algorithm. (Our algorithm can be extended for multiple initiators.)\n\n**Steps executed by the initiator**\n- The initiator multicasts a marker message to all the processes and waits for a done message from each process.\n- After receiving a done message from each process, the initiator multicasts a terminate message to all the processes.\n\n**Steps executed by a process $P_i$ (including the initiator)**\n- On receiving a marker message, process $P_i$ records its local state, initializes the state of all incoming channels to null, and sends a done message to the initiator.\n- On receiving an application message from $P_j$, process $P_i$ checks whether the message is marked old. If so, process $P_i$ records the message as a part of the channel $C_{ji}$’s state.\n• On receiving a terminate message from the initiator, process \\( P_i \\) terminates the snapshot algorithm.\n\n5.3 Correctness and Complexity\n\nLet \\( \\text{marker}_i \\) and \\( \\text{terminate}_i \\) denote, respectively, the copies of the marker and the terminate messages received by \\( P_i \\). Let \\( \\text{done}_i \\) denote the done message sent by \\( P_i \\).\n\n**Lemma 7** A message \\( m \\) sent by \\( P_i \\) to \\( P_j \\) after \\( P_i \\) records its local state is not in the global state recorded by the snapshot algorithm.\n\n**Proof:** Recall that the marker message is multicast by the initiator to all the processes. Let \\( P_i \\) send a message \\( m \\) to \\( P_j \\) after \\( P_i \\) records its state. Clearly, \\( \\text{recv}(\\text{marker}_i) \\rightarrow \\text{send}(m) \\). Since \\( \\text{send}(\\text{marker}) \\rightarrow \\text{recv}(\\text{marker}_i) \\), by transitivity, \\( \\text{send}(\\text{marker}) \\rightarrow \\text{send}(m) \\). Causal order message delivery ensures that \\( \\text{recv}(\\text{marker}_j) \\rightarrow \\text{recv}(m) \\). Therefore, \\( P_j \\) has recorded its state before receiving \\( m \\). Also, the causal order protocol marks \\( m \\) new. Thus, \\( m \\) will not be in the channel \\( C_{ij} \\)'s recorded state.\n\n**Lemma 8** If a message \\( m \\) is sent by \\( P_i \\) to \\( P_j \\) before \\( P_i \\) records its local state, then \\( \\text{recv}(m) \\) is in the recorded state of \\( P_j \\) or \\( m \\) is in the recorded state of channel \\( C_{ij} \\).\n\n**Proof:** Consider a message \\( m \\) sent by \\( P_i \\) to \\( P_j \\) before \\( P_i \\) records its local state. If \\( P_j \\) has received \\( m \\) (sent by \\( P_i \\)) before recording the local state, then \\( \\text{recv}(m) \\) is in the local state of \\( P_j \\). Assume that \\( P_j \\) receives \\( m \\) after recording its local state. We know that \\( \\text{send}(m) \\rightarrow \\text{recv}(\\text{marker}_i) \\). Since \\( P_i \\) sends a done message to the initiator after recording its state, \\( \\text{send}(m) \\rightarrow \\text{send}(\\text{done}_i) \\). Only after receiving done messages from all the processes the initiator multicasts terminate message.\nto all the processes. Therefore, $send(m) \\rightarrow send(terminate)$. Causal order message delivery ensures that $recv(m) \\rightarrow recv(terminate_j)$. Message $m$ will be marked $old$ by the causal order protocol, because $send(marker) \\not\\rightarrow send(m)$. The snapshot algorithm at a process records an application message marked $old$ as part of the state of the channel through which it received the message. Therefore, $m$ is recorded in the state of $C_{ij}$.\n\nThe algorithm terminates since each process eventually receives the $terminate$ message from the initiator. When a process receives the $terminate$ message it has recorded its local state and the state of all its incoming channels. The causal ordering protocol can stop marking the messages as $new$ or $old$ when the snapshot algorithm terminates.\n\n**Theorem 9** The global state recorded is consistent and complete.\n\n**Proof:** From Lemma 7, the recorded global state is consistent, and from Lemma 8 it is complete.\n\n**Theorem 10** The message complexity of the snapshot algorithm is $O(n)$ bits, and the algorithm is optimal with respect to message complexity.\n\n**Proof:** The initiator sends $2n$ messages ($n$ marker and $n$ terminate messages), and all other processes send one $done$ message each. Thus the message complexity is $O(n)$ bits, since each message is of size $O(1)$ bits. For the lower bound, note that the initiator has to inform all the processes to record their respective local states. This requires at least one message bit per process. Thus the lower bound for the message complexity is $\\Omega(n)$ bits. Hence the algorithm is message optimal.\n5.4 Comparison\n\nWe briefly review Acharya–Badrinath algorithm before comparing it with our algorithm. Their algorithm requires that the underlying causal ordering protocol at each process \\( P_i \\) maintain two arrays, \\( SENT_i[1, \\ldots, n] \\) and \\( RECD_i[1, \\ldots, n] \\). At any instant, \\( SENT_i[j] \\) denotes the number of messages \\( P_i \\) has sent to \\( P_j \\) till that instant, and \\( RECD_i[j] \\) denotes the number of messages \\( P_i \\) has received from \\( P_j \\) till that instant. An initiator process initiates the snapshot algorithm by multicasting a token message to all the processes. After receiving the token message, process \\( P_i \\) records its state and replies by sending its local state and the two arrays \\( SENT_i \\) and \\( RECD_i \\) to the initiator. The initiator, after receiving replies from all the processes, computes the channels states as sequence of message-ids. A channel \\( C_{ij} \\)'s state is given by \\( \\{RECD_j[i] + 1, \\ldots, SENT_i[j]\\} \\).\n\nThe Acharya–Badrinath algorithm is two-phased, one for sending token, and the other for sending reply. Our algorithm is three-phased, one for sending marker, second for sending done, and the third for sending terminate. However, in the Acharya–Badrinath algorithm, the global state is assembled at the initiator and the state of a channel is recorded as the sequence of message-ids of the in-transit messages. Since the initiator does not know the contents of those messages, their algorithm relies on either the senders keeping a log of the messages sent, or the receivers storing the messages as they arrive [?]. The initiator has to send another \\( O(n) \\) control messages to inform the processes about the states of their incoming channels. Thus, their algorithm is also three-phased if the contents of the channels’ states have to be known. In our algorithm, a process records the states of all of its incoming channels similar to Chandy–Lamport algorithm [?]. A process need not store a message that does not belong to a recorded channel state. Also, the computation performed by the initiator in our algorithm is much less compared to their algorithm where the initiator computes \\( O(n^2) \\) comparisons) the states of all the channels.\nThe Acharya–Badrinath algorithm uses $O(n)$ messages, but the reply messages are long. (The size of a message can be $O(n \\log n)$ bits assuming that the number of messages sent by a process is polynomial in $n$. The message complexity of our algorithm is $O(n)$ bits. The size of messages we use is always $O(1)$ bits. We achieve low message complexity and reduce the computation overhead performed at the initiator by relying on the ability of causal ordering protocol to mark the application messages as new or old. This may require some modification to the “code” of the causal ordering protocol. Acharya–Badrinath algorithm does not require this modification, but it requires that the underlying causal ordering protocol maintain SENT and RECD arrays. These are the only differences between our assumptions and their assumptions.\n\n5.5 Concluding Remarks\n\nWe have presented an algorithm to record a global state of a distributed system. The algorithm makes use of the information already available for maintaining causally ordered message delivery. Every process locally records its state and the states of all of its incoming channels. The message complexity of the algorithm is $O(n)$ bits. The algorithm can be extended to situations where there are multiple initiators. When a process initiates the process of recording a snapshot, the initiator stamps the marker with its id. The additional steps performed by the causal order protocol are more involved. Now an application message may be marked new with respect to one initiator, but it need not be marked new with respect to another initiator. So the messages that are marked new are also stamped with initiators’ ids. When a process receives a new message stamped with initiators ids, the message is not recorded as part of the channel state in the recordings that correspond to the stamped ids. All other steps of the algorithm are similar to that of the single initiator.\nChapter 6\n\nCausally Ordered Message Delivery in Mobile Systems\n\nThere is a growing trend in using mobile computing environment for several applications, and it is important that the mobile systems are provided adequate support both at the system level and at the communication level. In this chapter, we consider the problem of providing a particular kind of communication support, namely, causally ordered message delivery to mobile hosts. Causal ordering is useful in several applications like management of replicated data, resource allocation, monitoring a distributed system, USENET etc., [?, ?]. Causal ordering is best suited for applications that involve human interactions from several locations [?] – such applications are typical in mobile systems. Some of the major applications of distributed mobile systems include providing information, stock trading, teleconferencing, etc. It is undesirable for a user to receive messages out of causal order. In this chapter, we present three algorithms for causal ordering in mobile systems.\n\n6.1 Motivation\n\nAny of the existing algorithms for causal ordering in static hosts can be executed by every mobile host, and all the relevant data structures can be stored in the\nmobile hosts. This solution will work. But while designing algorithms for mobile systems, the following factors must be taken into account.\n\nF1. The capability of mobile hosts may be very limited in terms of the disk space and processing power [?, ?]. The amount of computation performed by a mobile host should be low.\n\nF2. The available bandwidth is low and the cost of message transmission is high in the wireless medium compared to the wired medium [?]. So the communication overhead in the wireless medium should be minimal.\n\nF3. The number of mobile hosts (MHs) may not be known in advance and it may be substantially larger than the number of mobile support stations (MSSs). Hence it is desirable to design algorithms such that the overhead (communication and computation) does not increase with the number of mobile hosts.\n\nF4. A mobile host may often disconnect itself from the network and reconnect at a later time. Algorithms designed for mobile systems should be able to easily handle the effect of host disconnections and connections.\n\nIf mobile hosts are made to execute the traditional causal ordering algorithms (by storing the relevant data structures in the mobile hosts), none of the above factors (F1–F4) can be satisfied. Keeping these factors in mind, we design three algorithms for causal ordering in mobile systems.\n\nThe first algorithm stores the data structures of MHs relevant to causal ordering in the MSSs, and the algorithm is executed by the MSSs on behalf of the MHs. However, the message overhead (length of the header*) is proportional to\n\n*header of a message is the extra information sent with the message to maintain causal ordering.\nthe square of the number of mobile hosts. Thus, factor F3 is not satisfied. Also, the algorithm does not handle hosts disconnections very well and is not easily scalable.\n\nAlgorithm 2 eliminates the problems of Algorithm 1. The size of the message header is proportional to the square of the number of MSSs. Since the size of the header does not vary with the number of mobile hosts, the algorithm is scalable (with respect to the number of the mobile hosts) and host disconnections/connections do not pose any problem. But there may be some “inhibition” in delivering the messages to the mobile hosts. Our experimental results suggest that delay due to inhibition is less than the delay involved in transmitting and processing the long header (of each message) used in Algorithm 1. Also, the load placed on the MSSs is very small compared to Algorithm 1.\n\nAlgorithm 3 is a hybrid algorithm and is a trade-off between Algorithm 1 and Algorithm 2. Every MSS is partitioned into $k$ logical MSSs to reduce the delay due to “inhibition” in delivering the messages to MHs. However, $k$ cannot be large as this will increase the size of the header and hence the message overhead. A summary of our results is shown in Table 6.1 where $n_h$ is the number of MHs, $n_s$ is the number of MSSs, and $k$ is the number of logical MSSs per MSS. Note that in general $n_h \\gg n_s$.\n\n<table>\n<thead>\n<tr>\n<th>Algorithm</th>\n<th>Size of message header</th>\n<th>“handoff” Complexity</th>\n<th>“inhibition”</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Algorithm 1</td>\n<td>$O(n_h^2)$ integers</td>\n<td>$O(1)$ messages</td>\n<td>No</td>\n</tr>\n<tr>\n<td>Algorithm 2</td>\n<td>$O(n_s^2)$ integers</td>\n<td>$O(n_s)$ messages</td>\n<td>Yes</td>\n</tr>\n<tr>\n<td>Algorithm 3</td>\n<td>$O(k \\times n_s^2)$ integers</td>\n<td>$O(k \\times n_s)$ messages</td>\n<td>decreases with $k$</td>\n</tr>\n</tbody>\n</table>\n\nTable 6.1: Comparison of the three causal ordering algorithms.\n6.2 Mobility Model\n\nA distributed mobile system consists of a set of mobile hosts and static hosts. A mobile host (MH) is a host whose geographical location can change with time while retaining its connectivity to the network. A static host is a host whose location does not change during the computation. A static host can also be a mobile support station (MSS). An MSS has the necessary infrastructures to support the mobile hosts. For simplicity, we assume that the system consists of only MSSs and MHs. A static host can be considered as an MH that does not move.\n\nThe geographical area within which an MSS supports MHs is called a cell. Communication between MHs and MSSs is through a wireless channel. An MH can communicate directly with an MSS only if the MH is located in the cell of the MSS. A mobile host may belong to at most one cell at any time. Mobile hosts communicate with other hosts through their MSSs.\n\nMSSs are connected among themselves using wired channels. We assume that a logical channel exists between every pair of MSSs. These logical channels need not be FIFO channels; whereas the wireless channels are FIFO. Both wired and wireless channels are reliable and take an arbitrary, but finite amount of time to deliver messages. The MSSs and the wired channels constitute the static network which is similar to the model described in Chapter 2.\n\nAn example of a distributed mobile system is shown in Figure 6.1. Hosts $s_1$, $s_2$ and $s_3$ are three MSSs connected by wired channels. Hosts $h_1$, $h_2$ and $h_3$ are three mobile hosts. Initially, $h_1$ and $h_3$ are in the cell of $s_1$, and $h_2$ is in the cell of $s_3$.\n\nA mobile host communicates with other mobile hosts through its MSS. Consider Figure 6.1. To send a message to MH $h_2$, MH $h_1$ first sends the message\n\n---\n\n$\\dagger$ The MSS of an MH is the MSS in whose cell the MH is located.\nto its MSS $s_1$. MSS $s_1$ then sends the message to MSS $s_3$, in whose cell $h_2$ is located, and requests $s_3$ to deliver the message to $h_2$. Similarly, a message for $h_1$ is first sent to MSS $s_1$, and then $s_1$ delivers the message to $h_1$. Even if $h_1$ and $h_2$ are in the same cell, they communicate through their common MSS.\n\nA mobile host can migrate from one cell to another cell at any time. Every MSS periodically broadcasts a beacon [?]. Let MH $h_1$ move from the cell of MSS $s_1$ to the cell of $s_2$ as shown in Figure 6.1. $h_1$ discovers that it is in the cell of $s_2$ after receiving the beacon broadcast by $s_2$. MH $h_1$ informs MSS $s_2$ of $h_1$’s id and the id of its previous MSS $s_1$. A handoff procedure is then executed between $s_2$ and $s_1$. $s_2$ informs $s_1$ about $h_1$’s migration and gets the relevant information associated with $h_1$ from MSS $s_1$.\n\n\\footnote{Due to the mobility of $h_2$, MSS $s_1$ may not always know the location of $h_2$. However, there are several protocols [? , ? , ?] that ensure message delivery to mobile hosts.}\nA mobile host can disconnect itself from the network by sending a \\textit{disconnect} message to its current MSS and can reconnect at a later time by sending a \\textit{connect} message. If an MSS receives a message for any of the disconnected mobile hosts, the message can be stored and delivered to mobile host after it reconnects or the message can be dropped, depending on the application.\n\n\\section{Simulation Model}\n\nWe have evaluate the performance our algorithms for mobile system by simulation. The model used for our simulations is described below.\n\nOur simulation model is similar to that of [?]. The simulation is event driven and it is run on a Sparc 10 station. The events are send events, receive events, and handoff events. The bandwidth of a wired channel is assumed to be 100 Mbits/sec, and the propagation delay in a wired channel is 7 ms. For a wireless channel, the bandwidth and propagation delay are assumed to be 1 Mbits/sec and 500 \\(\\mu\\)s, respectively.\n\nInitially, the cells of the mobile hosts are assigned randomly. The time interval between two send events in a mobile host is an exponentially distributed random variable with a mean of \\(t_s\\) seconds. The amount of time a mobile host spends in a cell is also an exponentially distributed random variable with a mean of \\(t_h\\) seconds. The values of \\(t_s\\) and \\(t_h\\) are varied \\((0.1, 1.0, 10 \\text{ secs})\\) to consider different scenario of communication and mobility. The destination of a message and the cell to which an MH switches are determined randomly. The size of each message is varied (exponential distribution) between 2 Kbytes and 4 Kbytes. The value of every point in the graph is an average of 1000 experiments performed.\n6.3 Preliminaries\n\nCausal ordering was first proposed for the Isis system [?]. There are several algorithms that implement causal ordering for distributed systems with static hosts [?, ?, ?]. The algorithm by Birman and Joseph appends, to every message, the history of the communications that happened before the sending of the message [?]. The size of the message header can become unbounded. However, the channels need not be reliable. The algorithm by Raynal, Schiper and Toueg, referred henceforth as the RST algorithm, is based on message counting and assumes the channels to be reliable [?]. The RST algorithm, which we will discuss subsequently, appends $N^2$ integers to every message, where $N$ is the number of hosts in the system. The algorithm by Schiper et al. [?] uses vector clocks and is somewhat similar to the RST algorithm. In this chapter we extend the RST algorithm to mobile systems.\n\n6.3.1 RST Algorithm\n\nThe RST algorithm for causal ordering maintains two arrays, $\\text{DELIV}_i[N]$ and $\\text{SENT}_i[N, N]$, for each host $P_i$. $\\text{DELIV}_i[j]$ denotes the total number of messages received by $P_i$ from $P_j$. $\\text{SENT}_i[k, j]$ indicates $P_i$'s knowledge about the number of messages $P_k$ has sent to $P_j$. The following steps are executed at $P_i$ to ensure causal ordering.\n\nWhenever $P_i$ sends message $M$ to $P_j$, $P_i$ appends its current value of $\\text{SENT}_i$ to $M$. ($P_i$ sends $(M, \\text{SENT}_i)$ to $P_j$.) Observe that $\\text{SENT}_i$ contains information about the message that were sent before $M$ was sent. $P_i$ then increments $\\text{SENT}_i[i, j]$ by 1.\n\nOn receiving a message containing $(M, ST)$ from $P_j$, the causal ordering algorithm at $P_i$ first checks if $\\text{DELIV}_i[k] \\geq ST[k, i]$ for all $k$. ($P_i$ checks whether all the messages, sent to $P_i$, that are causally dependent on $M$ have been delivered.) If so, the message $M$ is delivered to the application, $\\text{DELIV}_i[j]$ is\nincremented by 1, \\( \\text{SENT}_i[j, i] \\) is set to \\( ST[j, i] + 1 \\), and finally \\( \\text{SENT}_i[i, j] \\) is set to \\( \\max(ST[i, j], \\text{SENT}_i[i, j]) \\) for all \\( i, j \\). If not, \\( M \\) is buffered till \\( \\text{DELIV}_i[k] \\geq ST[k, i] \\) for all \\( k \\).\n\nConsider the sample execution consisting of three hosts shown in Figure 6.2. Host \\( P_1 \\) sends message \\( (m_1, \\text{SENT}_1) \\) to \\( P_3 \\) and increments \\( \\text{SENT}_1[1, 3] \\) by\n\n\\[\n\\begin{align*}\nP_3 & \\quad \\text{[0 0 0]} \\\\\n\\text{[0 0 1]} & \\quad \\text{(m3, c)} \\\\\n0 0 0 & \\quad \\text{a= 0 0 0} \\\\\n0 1 0 & \\quad \\text{b= 0 0 0} \\\\\n\\text{[0 1 0]} & \\quad \\text{(m1, a)} \\\\\n\\text{[0 0 1]} & \\quad \\text{(m2, b)} \\\\\n\\text{[0 0 0]} & \\\\\n\\end{align*}\n\\]\n\nFigure 6.2: A sample execution\n\n1. \\( P_1 \\) then sends message \\( (m_2, \\text{SENT}_1) \\) to \\( P_2 \\). On receiving \\( (m_2, ST_{m2}) \\), \\( P_2 \\) updates \\( \\text{SENT}_2 \\) based on \\( ST_{m2} \\). After updating \\( \\text{SENT}_2 \\), \\( P_2 \\) gains the knowledge that \\( P_1 \\) has sent one message to \\( P_3 \\) before sending \\( m_2 \\) to \\( P_2 \\) (the value of \\( ST_{m2}[1, 3] \\) is 1). \\( P_2 \\) transfers this knowledge to \\( P_3 \\) when it sends \\( (m_3, \\text{SENT}_3) \\) to \\( P_3 \\). Assume that \\( m_3 \\) arrives at \\( P_3 \\) before \\( m_1 \\). Now \\( m_3 \\) will not be delivered to the application, because \\( \\text{DELIV}_3[1] \\nless ST_{m3}[1, 3] \\). Message \\( m_3 \\) will be delivered only after \\( m_1 \\) is delivered.\n\n6.3.2 Reliable Message Delivery\n\nBefore we explain our algorithms, we describe a simple protocol executed by an MH and its MSS to ensure reliable message delivery (without duplication) when the MH moves from one cell to another cell.\nLet an MH $h_i$ be in the cell of MSS $s_j$. Every message sent by $h_i$ is first sent to $s_j$ and then $s_j$ sends the message to the destination. Similarly every message received by $h_i$ is received through MSS $s_j$. Let $\\text{MH}_i\\text{RSEQNO}_i$ denote the number of messages received by MH $h_i$ from MSS $s_j$. Let $\\text{MH}_i\\text{SEQNO}_i$ denote the number of messages sent by $h_i$ that have been received by $s_j$. $\\text{MH}_i\\text{RSEQNO}_i$ is maintained at MH $h_i$ and $\\text{MH}_i\\text{SEQNO}_i$ is maintained at the MSS of MH $h_i$. Messages sent by $s_j$ to $h_i$ are numbered sequentially in increasing order and are stored in a FIFO queue, $\\text{PEND}_i\\text{ACK}_i$, within $s_j$. MH $h_i$ sends an ack after receiving a message from $s_j$ and increments $\\text{MH}_i\\text{RSEQNO}_i$. After receiving an ack for a message it sent to $h_i$, MSS $s_j$ deletes that message from $\\text{PEND}_i\\text{ACK}_i$. Messages sent by $h_i$ to $s_j$ are also numbered by $h_i$ sequentially in the increasing order and are stored locally in MH $h_i$ till the messages are acknowledged. After receiving a message from $h_i$, MSS $s_i$ sends an ack to $h_i$ and increments $\\text{MH}_i\\text{SEQNO}_i$. Next the algorithms for causal ordering are described.\n\n### 6.4 Algorithm 1\n\nIn this section, the RST algorithm is extended to mobile systems. Algorithm 1 consists of two modules: static module and handoff module. The static module is executed when an MH is in a particular cell. The handoff module is executed when an MH moves from one cell to another.\n\n#### 6.4.1 Static Module\n\nFor each MH $h_i$, we maintain two arrays $\\text{MH}_i\\text{DELIV}_i[n_h]$ and $\\text{MH}_i\\text{SENT}_i[n_h, n_h]$, where $n_h$ is the number of mobile hosts in the mobile computing environment. $\\text{MH}_i\\text{DELIV}_i[j]$ denotes the total number of messages received by $h_i$ from $h_j$. $\\text{MH}_i\\text{SENT}_i[k, j]$ indicates $h_i$’s knowledge about the number of messages $h_k$ has sent to $h_j$. Assume that MH $h_i$ is in the cell of MSS $s_j$. To reduce the communication and computation overhead of MH $h_i$, these arrays are stored in MSS $s_j$. \nSince the messages from (to) \\( h_i \\) go through MSS \\( s_j \\), the causal ordering algorithm is executed by MSS \\( s_j \\). A message \\( M \\) sent to MH \\( h_i \\) becomes deliverable to \\( h_i \\) if the reception of \\( M \\) by \\( h_i \\) does not violate causal ordering. All messages for \\( h_i \\), received by \\( s_j \\), which are not yet deliverable are stored in the queue MH\\_PENDING at MSS \\( s_j \\).\n\nInitially, all the entries in the arrays MH\\_DELIV and MH\\_SENT are set to 0 and MH\\_PENDING is empty. To send a message \\( m \\) to another MH \\( h_j \\), \\( h_i \\) first sends the message \\( m \\) to its MSS \\( s_j \\). \\( s_j \\) tags MH\\_SENT with \\( m \\), and sends \\((m, MH\\_SENT_i)\\) to the MSS of \\( h_j \\). There are several protocols [?, ?, ?] that ensure message delivery to mobile hosts. Any of these protocols can be used.\n\nMSS \\( s_j \\), on receiving a message \\((m, ST_m)\\) meant for \\( h_i \\) from MH \\( h_j \\), first checks whether \\( m \\) is deliverable. Message \\( m \\) is deliverable if \\( MH\\_DELIV[k] \\geq ST_m[i, k] \\) for all \\( k \\). If so, \\( s_j \\) transmits \\( m \\) to \\( h_i \\); increments MH\\_DELIV\\( j \\) and updates MH\\_SENT\\( i \\). Message \\( m \\) is also queued by \\( s_j \\) in PEND\\_ACK\\( i \\). Message \\( m \\) will be deleted from PEND\\_ACK\\( i \\) after receiving an ack for \\( m \\) from MH \\( h_i \\). If \\( m \\) is not deliverable, \\( m \\) is stored in MH\\_PENDING till \\( m \\) becomes deliverable. Whenever a message \\( m \\) is delivered to \\( h_i \\), \\( s_j \\) checks MH\\_PENDING for any message that may be deliverable after \\( m \\) was delivered. A formal description of the module is given in Figure 6.3.\n\n### 6.4.2 Handoff Module\n\nLet \\( h_i \\) move from the cell of MSS \\( s_j \\) to the cell of MSS \\( s_k \\). The handoff module is then executed by \\( s_j \\) and \\( s_k \\). After entering the cell of \\( s_k \\), MH \\( h_i \\) sends the message \\texttt{hello}(\\( h_i, s_j, MH\\_RSEQNO_i \\)) to \\( s_k \\). Also, \\( h_i \\) retransmits the messages (to \\( s_k \\)) for which it did not receive ack from its previous MSS \\( s_j \\). MSS \\( s_k \\) then informs \\( s_j \\) that \\( h_i \\) has switched from MSS \\( s_j \\) to MSS \\( s_k \\) by sending a \\texttt{handoff\\_begin}(\\( h_i \\)) message to \\( s_j \\). After receiving \\texttt{handoff\\_begin}(\\( h_i \\)), \\( s_j \\) transfers MH\\_DELIV\\( i \\), MH\\_SENT\\( i \\), MH\\_PENDING\\( i \\), and PEND\\_ACK\\( i \\) to MSS \\( s_k \\) and fi-\nLet MH \\( h_i \\) be in the cell of MSS \\( s_j \\).\n\n1. On receiving message \\( m \\) from \\( h_i \\) to be sent to MH \\( h_j \\), MSS \\( s_j \\) executes the following steps.\n\n (a) Send \\((m, \\text{MH\\_SENT}_i)\\) to \\( h_j \\).\n\n (b) \\( \\text{MH\\_SENT}_i[i, j] = \\text{MH\\_SENT}_i[i, j] + 1. \\)\n\n (c) \\( \\text{MH\\_SEQNO}_i = \\text{MH\\_SEQNO}_i + 1. \\)\n\n (d) Send an ack to \\( h_i \\).\n\n2. MSS \\( s_j \\), on receiving a message \\( m \\) for \\( h_i \\) from \\( h_j \\), executes the following steps.\n\n (a) If \\( m \\) is not deliverable to \\( h_i \\), queue \\((m, ST_m)\\) in \\( \\text{MH\\_PENDING}_i \\).\n\n (b) If \\( m \\) is deliverable, then\n\n i. Transmit \\( m \\) to \\( h_i \\) and queue \\( m \\) in \\( \\text{PEND\\_ACK}_i \\).\n\n ii. \\( \\text{MH\\_DELIV}_i[j] = \\text{MH\\_DELIV}_i[j] + 1. \\)\n\n iii. \\( \\text{MH\\_SENT}_i[j, i] = ST_m[j, i] + 1. \\)\n\n iv. \\( \\text{MH\\_SENT}_i[k, l] = max(\\text{MH\\_SENT}_i[k, l], ST_m[k, l]), \\) for all \\( k, l \\)\n\n v. If any message \\((m, ST_m)\\) in \\( \\text{MH\\_PENDING}_i \\) becomes deliverable, goto step 2(b)i.\n\nFigure 6.3: Static Module of Algorithm 1\nnally sends message \\textit{handoff\\_over}(h_i; \\textit{MH\\_SEQNO}_i) to \\(s_k\\). After sending the \\textit{handoff\\_over} message, if \\(s_j\\) receives any messages sent by \\(h_i\\) (when \\(h_i\\) was in \\(s_j\\)'s cell), MSS \\(s_j\\) drops them. (This scenario is possible because the wireless channels take an arbitrary amount of time to deliver messages.)\n\nOn receiving these data structures, \\(s_k\\) first transmits all messages in \\textit{PEND\\_ACK}_i with sequence number greater than \\textit{MH\\_RSEQNO}_i in FIFO order. Also, \\(s_k\\) forwards the messages (to their destinations) retransmitted by \\(h_i\\) with sequence number greater than \\textit{MH\\_SEQNO}_i. The handoff procedure is then terminated at \\(s_k\\). A description of the handoff module appears in Figure 6.4. If MH \\(h_i\\) switches to some other cell before the handoff is completed, the current handoff is completed before a new handoff begins.\n\n\\textbf{Theorem 11} Algorithm 1 ensures causally ordered message delivery.\n\n\\textbf{Proof:} Note that in Algorithm 1 the MSSs executes the RST algorithm for causal ordering on behalf of MHs. If the mobile hosts do not move, the correctness of the algorithm follows from the correctness of the RST algorithm and from the fact that the wireless channel between an MH and an MSS is FIFO. If an MH \\(h_i\\) switches its cell, then, during the handoff, all the messages in \\textit{PEND\\_ACK}_i are first sent to \\(h_i\\) in the FIFO order. Also, \\(h_i\\) retransmits the messages for which it has not got acks from its previous MSS before switching. The data structures \\textit{MH\\_DELIV}_i, \\textit{MH\\_SENT}_i and \\textit{MH\\_PENDING}_i are transferred to the new MSS of \\(h_i\\) during the handoff. The new MSS starts executing the causal ordering algorithm only after the handoff terminates (i.e., only after receiving the data structures required to maintain causal ordering).\n\n\\section*{6.4.3 Analysis}\n\nFor every message sent by MH \\(h_i\\), the MSS (in whose cell \\(h_i\\) resides) sends \\textit{MH\\_SENT}_i with the message. Hence, the size of the header for every message\nLet MH $h_i$ switch from the cell of MSS $s_j$ to the cell of MSS $s_k$.\n\n1. Steps executed by MSS $s_k$.\n\n (a) On receiving message $\\text{hello}(h_i, s_j, \\text{MH}\\_\\text{RSEQNO}_i)$ from $h_i$, send message $\\text{handoff\\_begin}(h_i)$ to MSS $s_j$.\n\n (b) Receive $\\text{MH\\_SENT}_i$, $\\text{MH\\_PENDING}_i$, $\\text{PEND\\_ACK}_i$ from $s_j$.\n\n (c) After receiving $\\text{handoff\\_over}(h_i, \\text{MH\\_SSEQNO}_i)$, transmit all the messages in $\\text{PEND\\_ACK}_i$ with number greater than $\\text{MH\\_RSEQNO}_i$ in FIFO order to $h_i$.\n\n (d) Send messages sent by $h_i$ with number greater than $\\text{MH\\_SSEQNO}_i$ to their destinations.\n\n2. Steps executed by MSS $s_j$.\n\n (a) On receiving $\\text{handoff\\_begin}(h_i)$ from $s_k$, transfer $\\text{MH\\_DELIV}_i$, $\\text{MH\\_SENT}_i$, $\\text{MH\\_PENDING}_i$, $\\text{PEND\\_ACK}_i$ to $s_k$, and then send message $\\text{handoff\\_over}(h_i, \\text{MH\\_SSEQNO}_i)$ to $s_k$.\n\nFigure 6.4: Handoff Module of Algorithm 1\nsent over the static network is $O(n_h^2)$ integers. The handoff module uses $O(1)$ messages of size $O(n_h^2)$ numbers when MH $h_i$ switches its cell.\n\nNow, consider the factors F1–F4 discussed in Section 6.1. Since Algorithm 1 is executed at MSSs, factors F1 and F2 are satisfied. The overhead in the wireless medium is kept minimal. But factors F3–F4 are not satisfied. An overhead of $O(n_h^2)$ integers over the static network is costly if $n_h$ is very large. Also, due to disconnections and connections, $n_h$ varies. So during disconnections, some of the entries in the arrays \\texttt{MH\\_DELIV}, and \\texttt{MH\\_SENT} may be useless. The arrays need not be static, but maintaining dynamic arrays can become complicated if the MH disconnections and connections are frequent. In addition, the processing time for updating the matrix \\texttt{MH\\_SENT} will be substantial for large $n_h$, and the nontrivial processing time increases the delay in delivering a message. These are reflected well in our experimental study shown in Figure 6.5. If the processing delay in updating \\texttt{MH\\_SENT} is ignored, the average delay experienced by a message is less than the average delay when processing time is taken into account. Algorithm 2, which is presented next, eliminates these disadvantages.\n\n### 6.5 Algorithm 2\n\nIn Algorithm 1, messages are tagged with complete information to explicitly maintain causal ordering among the mobile hosts. In Algorithm 2, messages are tagged with sufficient information just to maintain causal ordering among the MSSs. Since the wireless channel between an MSS and an MH in its cell is FIFO, maintaining causal ordering at the static network level is sufficient if the MHs do not move. To ensure that causal ordering is not violated after an MH moves, we incorporate some steps into the handoff procedure.\nFigure 6.5: Average Message delay using Algorithm 1 with and without processing delay\n6.5.1 Static Module\n\nThe static module is similar to the static module of Algorithm 1, but for some of the data structures. For each MSS $s_i$, we maintain arrays $\\text{MSS\\_DELIV}_i[n_s]$, $\\text{MSS\\_SENT}_i[n_s, n_s]$, and a buffer $\\text{MSS\\_PENDING}_i$. (This is unlike in Algorithm 1 where we maintain these data structures for every mobile host.) Observe that the sizes of the arrays $\\text{MSS\\_DELIV}_i[n_s]$ and $\\text{MSS\\_SENT}_i[n_s, n_s]$ vary with $n_s$, the number of MSSs. The value of $\\text{MSS\\_DELIV}_i[j]$ indicates the number of messages (whose destination can be different MHs) received from MSS $s_j$ by MSS $s_i$. $\\text{MSS\\_SENT}_i[k, j]$ denotes the number of messages sent by MSS $s_k$ (not necessarily delivered) to MSS $s_j$ that $s_i$ knows of. Every MSS knows (need not be exact) about the location of the MHs. Initially, we assume that the initial locations of MHs are known to all MSSs. We show how this knowledge gets updated in the next section. In other aspects, the static module is similar to the static module of Algorithm 1 and is described in Figure 6.6.\n\n6.5.2 Handoff Module\n\nThe handoff module is more involved when compared to the handoff module of Algorithm 1. Since causal ordering is explicitly maintained only at the MSSs level, some measures have to be taken during handoff to maintain causal ordering after an MH moves.\n\nBefore we describe the handoff module, we illustrate the problem at hand with an example. Consider mobile hosts $h_1$, $h_2$, and $h_3$. Assume that $h_1$, $h_2$ and $h_3$ are in the cells of MSSs $s_1$, $s_2$ and $s_3$ respectively. Let $h_3$ send a message $m_1$ to $h_1$ ($m_1$ will be sent to MSS $s_1$) and then send a message $m_2$ to $h_2$. Before receiving $m_1$, let $h_1$ switch to the cell of $s_2$. Now, MH $h_2$, after receiving $m_2$ from $h_3$, sends a message $m_3$ for $h_1$ to $s_2$. If $s_2$ delivers $m_3$ to $h_1$, causal ordering will be violated because $h_1$ has not yet received $m_1$. Also, $s_2$ cannot infer with the knowledge it has gained so far whether there are any in-transit messages for $h_1$. \nLet MHs $h_k$ and $h_l$ be in the cells of MSSs $s_i$ and $s_j$ respectively.\n\n1. On receiving message $m$ from $h_k$ to be sent to the MSS of $h_l$, MSS $s_i$ executes the following step.\n \n (a) Send $(m, \\text{MSS}_{i;i})$ to the MSS of $s_j$.\n \n (b) $\\text{MSS}_{i;i}[i, j] = \\text{MSS}_{i;i}[i, j] + 1$.\n \n (c) $\\text{MH}_{i;i.\\text{SEQNO}} = \\text{MH}_{i;i.\\text{SEQNO}} + 1$.\n \n (d) Send an ack to $h_k$.\n\n2. MSS $s_i$, on receiving a message for $h_k$ from $s_j$ executes the following steps.\n \n (a) If $m$ is not deliverable to $h_k$, queue $(m, ST_m)$ in $\\text{MH}_{i;i.\\text{PENDING}}$.\n \n (b) If $m$ is deliverable, then\n \n i. Transmit $m$ to $h_k$ and queue $m$ in $\\text{PEND}_{i;i.\\text{ACK}}$.\n \n ii. $\\text{MSS}_{i,j;i}[j] = \\text{MSS}_{i,j;i}[j] + 1$.\n \n iii. $\\text{MSS}_{i,j;i}[i, i] = ST_m[i, i] + 1$.\n \n iv. $\\text{MSS}_{i,j;i}[k, l] = max(\\text{MH}_{i,j;i}[k, l], ST_m[k, l])$, for all $k, l$\n \n v. If any message $(m, ST_m)$ in $\\text{MH}_{i;i.\\text{PENDING}}$ becomes deliverable, goto step 2(b)i.\n\nFigure 6.6: Static Module of Algorithm 2\nsent to $s_1$. However, if $s_2$ delivers $m_3$ after ascertaining that all the messages for $h_1$ sent to $s_1$ have been delivered, causal ordering will not be violated. Now, we describe the handoff module.\n\nAssume that a mobile host $h_k$ switches from the cell of MSS $s_i$ to the cell of MSS $s_j$. After switching, MH $h_k$ sends $\\text{hello}(h_k, s_i, \\text{MH}_\\text{RSEQNO}_i)$ message to $s_j$. The message $\\text{hello}(h_k, s_i, \\text{MH}_\\text{RSEQNO}_i)$ to $s_j$ indicates that $h_k$ has switched from the cell of $s_i$ to $s_j$. On receiving this message, $s_j$ sends the message $\\text{handoff}_\\text{begin}(h_k)$ to $s_j$, and then broadcasts the message $\\text{notify}(h_k, s_i, s_j)$ to all the MSSs. The message $\\text{notify}(h_k, s_i, s_j)$ signifies that MH $h_k$ has switched from MSS $s_i$ to MSS $s_j$. An MSS $s$, on receiving $\\text{notify}(h_k, s_i, s_j)$ message, updates its local knowledge about the location of MH $h_k$ and sends a $\\text{last}(h_k)$ message to $s_i$. After receiving $\\text{notify}(h_k, s_i, s_j)$, MSS $s$ will send messages meant for MH $h_k$ only to $s_j$ (the new MSS of $h_k$) and not to $s_i$ (the previous MSS of $h_k$).\n\nMSS $s_i$, after receiving the message $\\text{handoff}_\\text{begin}(h_k)$ from $s_j$ sends message $\\text{enable}(h_k, \\text{PEND}\\_\\text{ACK}_k, \\text{MH}_\\text{SEQNO}_i)$ to $s_j$ and waits for $\\text{last}(h_k)$ messages from all the MSSs. Meanwhile, if any message received by $s_i$ for $h_k$ becomes deliverable to $h_k$, $s_i$ marks it as old and forwards it to $s_j$.\n\nOnce $s_j$ receives the message $\\text{enable}(h_k, \\text{PEND}\\_\\text{ACK}_k, \\text{MH}_\\text{SEQNO}_i)$ message, it starts sending the application messages sent by $h_k$ with sequence number greater than $\\text{MH}_\\text{SEQNO}_i$ to their destinations. Also, $s_j$ delivers all the messages in $\\text{PEND}\\_\\text{ACK}_k$ in the FIFO order to MH $h_k$. Duplication is avoided by delivering only those messages with sequence number greater than $\\text{MH}_\\text{RSEQNO}_i$. $s_j$ also delivers all the messages for MH $h_k$ that are marked old to $h_k$ in the order in which the messages arrived. Any messages for $h_k$ that are not marked old will be queued in $\\text{MSS}_\\text{PENDING}_j$.\n\nMSS $s_i$ (the previous MSS of $h_k$), after receiving $\\text{last}(h_k)$ from all the MSSs sends the message $\\text{handoff}_\\text{over}(h_k)$ to MSS $s_j$. Observe that, no messages for $h_k$ sent to $s_i$ will be in transit after $s_i$ receives $\\text{last}(h_k)$ from all the MSSs. The\nhandoff terminates at \\( s_j \\) after \\( \\text{handoff\\_over}(h_k) \\) is received by \\( s_j \\). If \\( s_j \\) receives the message \\( \\text{handoff\\_begin}(h_k) \\) from some other MSS before the current handoff terminates (this can happen if \\( h_k \\) switches it cell), \\( s_j \\) will respond to the message only after the handoff terminates. A description of the handoff module is shown in Figure 6.7.\n\nWe next prove the correctness of Algorithm 2.\n\n**Correctness Argument**\n\nLet \\( mh\\_send(m) \\) be the event corresponding to sending of message \\( m \\) by a mobile host. Let \\( mh\\_recv(m) \\) be the event corresponding to receiving of message \\( m \\) by a mobile host. Let \\( mss\\_send(m) \\) denote the event in an MSS corresponding to the sending of message \\( m \\) (sent by an MH) to another MSS, and \\( mss\\_recv(m) \\) denote the event in an MSS corresponding to the receipt of \\( m \\) sent by another MSS (in which event \\( mss\\_send(m) \\) happened) to be delivered to an MH.\n\n**Lemma 9** Let \\( m_1 \\) and \\( m_2 \\) be two messages sent to MH \\( h_k \\). If \\( mh\\_send(m_1) \\rightarrow mh\\_send(m_2) \\), then \\( mss\\_send(m_1) \\rightarrow mss\\_send(m_2) \\).\n\n**Proof:** First assume that messages \\( m_1 \\) and \\( m_2 \\) are sent by two different MHs. Since \\( mh\\_send(m_1) \\rightarrow mh\\_send(m_2) \\), there exists a sequence of events such that \\( mh\\_send(m_1) \\rightarrow mss\\_send(m_1) \\ldots \\rightarrow mh\\_recv(m) \\ldots \\rightarrow mh\\_send(m_2) \\). Since \\( mh\\_send(m_2) \\rightarrow mss\\_send(m_2) \\), it follows that \\( mss\\_send(m_1) \\rightarrow mss\\_send(m_2) \\). Now consider the case in which \\( m_1 \\) and \\( m_2 \\) are sent by the same mobile host. Assume that the send events \\( mss\\_send(m_1) \\) and \\( mss\\_send(m_2) \\) happened in two different MSSs. (The mobile host may have switched cells in between \\( mh\\_send(m_1) \\) and \\( mh\\_send(m_2) \\).) Otherwise, the result is obvious. Let the mobile host switch from MSS \\( s_1 \\) to MSS \\( s_2 \\). MSS \\( s_2 \\) will send \\( m_2 \\) only after it receives an \\( \\text{enable} \\) message from MSS \\( s_1 \\) as part of handoff. MSS \\( s_1 \\) would have sent \\( m_1 \\) before sending the \\( \\text{enable} \\) message. Hence, \\( mss\\_send(m_1) \\rightarrow mss\\_send(m_2) \\).\nAssume that MH $h_k$ switched from the cell of $s_i$ to $s_j$.\n\n1. Steps executed by $s_j$.\n\n (a) After receiving $\\text{hello}(h_k, s_i, \\text{MH}_{-}\\text{RSEQNO}_k)$ from MH $h_k$, send $\\text{handoff}_\\text{begin}(h_k)$ to MSS $s_i$, and then send $\\text{notify}(h_k, s_i, s_j)$ to all the MSSs.\n\n (b) On receiving $\\text{enable}(h_k, \\text{PEND\\_ACK}_k, \\text{MH\\_SEQNO}_k)$, deliver messages in $\\text{PEND\\_ACK}_k$ in FIFO order, and start sending messages sent by MH $h_k$ to their destinations. Use $\\text{MH\\_SEQNO}_k$ and $\\text{MH\\_RSEQNO}_k$ to avoid duplication of messages.\n\n (c) Deliver any messages for $h_k$ from $s_i$ that are marked $\\text{old}$ to $h_k$. Queue all other messages for $h_k$ in $\\text{MH\\_PENDING}_j$.\n\n (d) Terminate on receiving $\\text{handoff\\_over}(h_k)$ from $s_i$.\n\n2. Steps executed by MSS $s_i$\n\n (a) Send $\\text{enable}(h_k, \\text{PEND\\_ACK}_k, \\text{MH\\_SEQNO}_k)$ message after receiving $\\text{handoff}_\\text{begin}(h_k)$ message from $s_j$. After sending $\\text{enable}$ message drop any message received from $h_k$.\n\n (b) If any message for $h_k$ becomes deliverable, mark it as $\\text{old}$ and forward it to $s_j$.\n\n (c) After receiving $\\text{last}(h_k)$ from all MSSs, send $\\text{handoff\\_over}(h_k)$ to $s_j$.\n\n3. Steps executed by all the MSSs.\n\n (a) On receiving $\\text{notify}(h_k, s_i, s_j)$, update the local knowledge about $h_k$’s location to $s_j$ and send $\\text{last}(h_k)$ to $s_i$.\n\nFigure 6.7: Handoff Module of Algorithm 2\nTheorem 12 Let $m_1$ and $m_2$ be two messages sent to $MH_h$. If $mh_{send}(m_1) \\rightarrow mh_{send}(m_2)$, then $mh_{recv}(m_1) \\rightarrow mh_{recv}(m_2)$.\n\nProof: From Lemma 9, $mss_{send}(m_1) \\rightarrow mss_{send}(m_2)$. If $m_1$ and $m_2$ are sent to the same MSS, then from the correctness of the RST algorithm it follows that $mss_{recv}(m_1) \\rightarrow mss_{recv}(m_2)$. Now, $m_1$ and $m_2$ are delivered to $MH_h$ directly or through handoff (if $h_k$ switches cells). In either case $mh_{recv}(m_1) \\rightarrow mh_{recv}(m_2)$. Now consider the case in which $m_1$ and $m_2$ are sent to two different MSSs. Let $m_1$ was sent to MSS $s_i$ and $m_2$ was sent to MSS $s_j$. This can happen only if $MH_h$ switched from the cell of MSS $s_i$ to the cell of $s_j$. Now assume that $m_1$ was not received by $MH_h$ when it was in the cell of $s_i$. (Otherwise, the result is fairly obvious.) Observe that MSS $s_j$ will not deliver $m_2$ to $h_k$ till the handoff procedure is completed. MSS $s_i$ sends $handoff_{over}(h_k)$ message to $s_j$ only after it receives $last(h_k)$ from each MSS. By the time MSS $s_i$ receives $last(h_k)$ from all the MSSs, $s_i$ would have forwarded $m_1$ to $s_j$ or it would have transferred $m_1$ as part of $PEND_ACK_k$. In either case, $s_j$ will deliver $m_1$ before the handoff is terminated. Message $m_2$ will be delivered after the handoff is terminated. Hence, $mh_{recv}(m_1) \\rightarrow mh_{recv}(m_2)$.\n\n6.5.3 Analysis\n\nSince the size of $mss_{SENT}$ is $n_h^2$, the size of each message header over the wired network is $O(n_h^2)$ integers. The overhead does not depend on $n_h$, the number of MHs. Clearly, factors F3–F4 are satisfied. MH connections/disconnections do not affect the size of the arrays $mss_{DELIV}$ and $mss_{SENT}$. During handoff, a notify message has to be sent to all the MSSs, and all the MSSs send $last$ messages. Hence, the handoff module uses $O(n_s)$ messages. The storage requirement of Algorithm 2 and the load placed on the MSSs are less than that of Algorithm 1.\n\nThough the handoff module is involved, it does not affect the performance compared to Algorithm 1 due to the following reasons. (i) $MH_h$ does not wait\nFigure 6.8: Comparison of Algorithm 1 and Algorithm 2 with respect to message delay with \\( n_x = 10 \\)\n\nfor the handoff module to terminate to receive messages. It continues to receive old messages. (ii) Messages sent by \\( h_k \\) for other MHs are sent by \\( s_j \\) (the new MSS of \\( h_k \\)) immediately after \\( s_j \\) receives an enable message.\n\nThe drawback of Algorithm 2 is the possibility of a message being temporarily “inhibited” during delivery to an MH. There is an inhibition in delivering a message to an MH if it is queued in \\texttt{MSS\\_PENDING} even though the delivery of the message does not violate causal ordering. Messages may be inhibited because causal ordering is explicitly implemented among the MSSs. Reception of a message may violate causal ordering from an MSS’s point of view; whereas its delivery to an MH may not violate causal ordering from the MH’s point of view. However, this delay is less than the delay introduced by Algorithm 1 in transmitting and processing the header of each message. The average delay in delivering a message in Algorithm 2 is considerably less than the delay in Algo-\nrithm 1 when \\( n_h \\) increases, as shown in Figure 6.8. When \\( n_h \\) is less than 30 the message header in both the algorithms are comparable in size. The message delay in Algorithm 2 is more than that of Algorithm 1 due to the inhibition inherent in Algorithm 2. However, as \\( n_h \\) increase the delay due to processing the message header in Algorithm 1 dominates.\n\n6.6 Algorithm 3\n\nThis Algorithm reduces the delay in delivering the messages to MH due to inhibition, the drawback of Algorithm 2, without much increase in the message overhead. The algorithm achieves this by partitioning every physical MSS into \\( k \\) logical MSSs.\n\nIf an MH enters the cell of an MSS, the MH will be allocated to one of the logical MSS depending on the load in each logical MSS of the MSS. The MHs will communicate with the other MHs through their logical MSSs. Every logical MSS maintains two arrays \\( \\text{MSS\\_DELIV}[k \\times n_s] \\) and \\( \\text{MSS\\_SENT}[k \\times n_s, k \\times n_s] \\) and a queue \\( \\text{MSS\\_PENDING} \\). The algorithm is same as Algorithm 2 except for the fact that causal ordering is explicitly maintained among the logical MSSs. The size of the message header is \\( O(k^2 \\times n_s^2) \\).\n\nMessages to MHs that belong to different logical MSSs will not inhibit each other though they may be in the same cell. Thus, as \\( k \\) increases, the unnecessary delay in delivering the message to MH decreases. However, \\( k \\) cannot be large, since the size of the message header will increase and, as a result, the time to process the message header will become a dominating factor. In Figure 6.9, the average message delay initially decreases when \\( k \\) increases. But when \\( k \\) becomes large the average message delay increases.\nFigure 6.9: Message delays for various values of $k$ with $n_s = 10$. \n\n6.7 Concluding Remarks\n\nIn this chapter, we have considered the problem of causally ordered message delivery to mobile hosts. A direct implementation of an existing algorithm can incur a large message overhead. Algorithm 2 reduces the overhead and it is scalable since the overhead of a message does not vary with the number of mobile hosts. The message overhead can be further reduced by sending the SENT arrays incrementally, in a manner similar to the scheme proposed by Singhal and Kshemakalyani for efficient implementation of vector clocks [7]. Algorithm 3 reduces the delay due to inhibition, inherent in Algorithm 2, in delivering the messages to MHs by partitioning every MSS into $k$ logical MSSs. The value of $k$ should not be large as a large value of $k$ increases the message overhead.\n\nOur algorithms for causal ordering in mobile systems are based on the RST algorithm for static hosts. Other algorithms can also be modified to work\nin mobile systems. Only the static modules of our algorithms are based on the RST algorithm. The handoff modules are fairly independent of the RST algorithm. If one wants to handle host mobility in an existing distributed system that supports causal ordering, handoff module of Algorithm 2 can be used with some modification to the existing algorithm that provides causal ordering at the static network level.\nChapter 7\n\nTolerating Mobile Support Station Failures\n\nWhen a mobile support station fails, vital state information of the live mobile hosts stored in the support station is lost. The mobile hosts are forced to wait till the support station recovers. This leads to new problems in providing a highly fault-tolerant mobile computing environment. As mobile computing environments become widely popular, it is important to design mobile computing environments where “uninterrupted” service is available in spite of support station failures.\n\nConventional recovery schemes [?, ?, ?, ?, ?, ?] can be used to recover a failed mobile support station. However, the (actual) down time for support stations may be long and hence the time for recovery can be long. It is undesirable to make the live mobile hosts (whose partial states are stored in the failed support stations) wait for a long period of time. In many critical applications, we need a fault-tolerant scheme that does not block mobile hosts while their support stations recover from failures.\n\nIn this chapter, we propose two schemes to tolerate the simultaneous failures of up to \\( k \\) mobile support stations. In both schemes, the information stored at a mobile support station is replicated at several “secondary” support stations. The two schemes differ in the way in which replication is achieved. When a mobile support station fails, the mobile hosts under its coverage can switch to one of their secondary support stations and continue their operations. To switch to one of its secondary support station, a mobile host may move. If movement of\na mobile host is impossible or undesirable, then the network may be designed to\ncover each mobile host by at most $k + 1$ support stations. Thus the “affected”\nmobile hosts need not wait for the failed support stations to recover. We also\npresent several methods for selecting the set of secondary support stations for a\nmobile host and discuss methods to cope with mobile host failures.\n\nThe organization of the chapter is as follows. Two schemes to tolerate\nmobile support station failures are presented in Section 7.1. In Section 7.2, the\nperformance of both the schemes are analyzed through simulation. Various re-\nlated issues are discussed in Section ??, and Section ?? concludes the chapter.\n\n7.1 Schemes for tolerating MSS failures\n\n7.1.1 Preliminaries\n\nDue to the energy and resource limitations, a part (or all) of the data structures\nand state information of a mobile host is stored in its MSS [?, ?]. Let $st_{\\text{info}}(h)$\ndenote the state information of mobile host $h$ stored in $h$’s MSS. The information\nstored in $st_{\\text{info}}(h)$ depends on the application, and the actual details are not re-\nquired to explain our schemes. For example, $st_{\\text{info}}(h)$ for Algorithm 1 described\nin chapter 6 will be the arrays $\\text{MH\\_SENT}$, $\\text{MH\\_DELIV}$ and $\\text{MH\\_PENDING}$.\n\nUpdating $st_{\\text{info}}(h)$ is easy for an MSS (in whose cell $h$ resides), since each\nmessage sent by/to a mobile host $h$ is sent through the MSS.\n\nWhen an MSS $s$ fails, the state information (of the mobile hosts in $s$’s\ncell) maintained by $s$ is lost. The mobile hosts in $s$’s cell cannot continue to\noperate until the state information is available. Thus they are forced to wait till\n$s$ recovers. We overcome this problem by maintaining $st_{\\text{info}}(h)$ at several MSSs.\n\nWith every mobile host $h$, we associate a set of secondary MSSs denoted\nby $\\text{sec\\_mss}(h)$. Methods to select secondary MSSs are described in Section 7.1.4.\nIn this section, we assume that $\\text{sec\\_mss}(h)$ is available for each mobile host $h$. \nThe cardinality of $sec\\_mss(h)$ must be at least $k$ to tolerate $k$ MSSs failures. The primary MSS of a mobile host $h$, denoted as $pri\\_mss(h)$, is the MSS in whose cell $h$ resides. For each $h$, $sec\\_mss(h)$ represents the MSSs where $st\\_info(h)$ is replicated. Let $sender(m)$ and $dest(m)$ denote, respectively, the sender and the destination of message $m$. We also assume that mobile support stations obey the fail-stop failure model [?] and there is a mechanism by which the failure of an MSS can be detected by its neighboring MSSs and the mobile hosts in its cell.\n\nIn the following subsections, we present two schemes to tolerate MSS failures.\n\nThe first scheme takes a pessimistic approach. Before updating $st\\_info(h)$, $pri\\_mss(h)$ ensures that copies of $st\\_info(h)$ at all the secondary MSSs of $h$ are updated. The copies of $st\\_info(h)$ at $pri\\_mss(h)$ and at all MSSs in $sec\\_mss(h)$ are consistent. However, there is a delay in delivering messages to MSS/mobile hosts. But when $pri\\_mss(h)$ fails, $h$ can switch to any one of the MSSs in $sec\\_mss(h)$ and continue its computation with no delay.\n\nThe second scheme takes an optimistic approach, and $st\\_info(h)$ is updated asynchronously at $sec\\_mss(h)$. There is no delay in delivering the messages to MSS/mobile hosts. However, a recovery protocol must be run when $h$ switches to one of the MSSs in $sec\\_mss(h)$ after $pri\\_mss(h)$ fails.\n\n7.1.2 Pessimistic Replication\n\nNormal operation\nDuring the normal operation, when MSS $s_1$ sends a message (whose destination is mobile host $h$) to $pri\\_mss(h)$, MSS $s_1$ stores the message in a buffer. After receiving an acknowledgement from $pri\\_mss(h)$, MSS $s_1$ deletes the message from its buffer. If $s_1$ receives a message notifying the failure of $pri\\_mss(h)$, $s_1$ will find the new primary MSS of $h$ and retransmit the message to that MSS. Similarly, when a mobile host sends a message to its primary MSS (to be delivered to another\nmobile host), it will wait for an acknowledgement from its primary MSS. Before receiving an acknowledgement, if the mobile host receives a message notifying the failure of its primary MSS, it establishes connection with another MSS, and retransmits the message. This ensures that messages are not lost when an MSS fails.\n\nAs stated earlier, every message sent by mobile host $h$ is first sent to $pri_{mss}(h)$. Similarly, every message sent to mobile host $h$ is first received by $pri_{mss}(h)$. Let $m$ be a message such that either $sender(m) = h$ or $dest(m) = h^*$. $st_{info}(h)$ may be updated when $pri_{mss}(h)$ receives $m$. $pri_{mss}(h)$ sends the message $copy(h, m)$ to all the MSSs in $sec_{mss}(h)$ if $st_{info}(h)$ must be updated. If $pri_{mss}(h)$ does not need to update $st_{info}(h)$ on receiving $m$, then no $copy(h, m)$ message is sent. We assume that MSSs are able to identify messages that require an update to $st_{info}(h)$. On receipt of the $copy(h, m)$ message, every MSS in $sec_{mss}(h)$ updates $st_{info}(h)$ stored locally and sends an acknowledgement to $pri_{mss}(h)$. Each MSS of $sec_{mss}(h)$ updates its copy of $st_{info}(h)$ as though mobile host $h$ is in its cell. After receiving acknowledgements from all the MSSs in $sec_{mss}(h)$, $pri_{mss}(h)$ updates $st_{info}(h)$, delivers the message to $dest(m)$, and sends an acknowledgement to $sender(m)$. A description of the scheme is shown in Figure 7.1.\n\n**Handoff procedure**\n\nA mobile host may move from the cell of its primary MSS to the cell of another MSS at any time. Let mobile host $h$ initially be in the cell of MSS $s_1$. Assume that $h$ moves to the cell of another MSS, say $s_2$. Mobile host $h$ establishes communication with $s_2$ by using the *beacon* protocol [?], and then $h$ sends the *id* of its “old” MSS ($s_1$) to $s_2$. A handoff procedure is executed between $s_1$ and $s_2$.\n\n---\n\n*Our replication schemes do not distinguish between the cases when $sender(m) = h$ and when $dest(m) = h$, since we are not concerned with what is updated in $st_{info}(h)$; what is updated in $st_{info}(h)$ may be different in both the cases and it depends on the application.*\nSteps executed by $\\textit{pri}_{\\text{mss}}(h)$\n\n1. Let $m$ be a message such that either $\\textit{sender}(m) = h$ or $\\textit{dest}(m) = h$. On receiving message $m$, $\\textit{pri}_{\\text{mss}}(h)$ checks whether an update to $\\textit{st}_{\\text{info}}(h)$ is required.\n\n2. If so, $\\textit{pri}_{\\text{mss}}(h)$ multicasts the message $\\textit{copy}(h, m)$ to all the MSSs in $\\textit{sec}_{\\text{mss}}(h)$, and stores $m$ in a buffer.\n\n3. Wait for acknowledgements from all the MSSs in $\\textit{sec}_{\\text{mss}}(h)$. If a failure notification of an MSS in $\\textit{sec}_{\\text{mss}}(h)$ arrives before the acknowledgement, then $\\textit{pri}_{\\text{mss}}(h)$ will not wait for an acknowledgement from that failed MSS.\n\n4. Update $\\textit{st}_{\\text{info}}(h)$. Send $m$ to $\\textit{dest}(m)$ and delete $m$ from the buffer. After receiving an acknowledgement from $\\textit{dest}(m)$ for the receipt of $m$, $\\textit{pri}_{\\text{mss}}(h)$ sends an acknowledgement to $\\textit{sender}(m)$.\n\nSteps executed by MSS $s$ in $\\textit{sec}_{\\text{mss}}(h)$\n\ni. On receiving a message $\\textit{copy}(h, m)$ from MSS $s_1$, update $\\textit{st}_{\\text{info}}(h)$ stored locally and send an acknowledgement to $s_1$.\n\nii. If mobile host $h$ establishes connection with $s$ after $\\textit{pri}_{\\text{mss}}(h)$ fails, set $\\textit{pri}_{\\text{mss}}(h)$ to $s$. Send $\\textit{st}_{\\text{info}}(h)$ to the new MSS in $\\textit{sec}_{\\text{mss}}(h)$. Request MSSs that are no longer in $\\textit{sec}_{\\text{mss}}(h)$ to delete $\\textit{st}_{\\text{info}}(h)$.\n\nFigure 7.1: Pessimistic Replication\nMSS $s_2$ notifies $s_1$ that $h$ has switched cells by sending $\\text{handoff\\_begin}(h)$ message to $s_1$. MSS $s_1$ waits for all the pending acknowledgements from $\\text{sec\\_mss}(h)$, updates $\\text{st\\_info}(h)$, and then sends $\\text{st\\_info}(h)$ to $s_2$. MSS $s_1$ also sends any pending messages (to be delivered to mobile host $h$) to $s_2$. MSS $s_1$ then sends $\\text{handoff\\_completed}(h)$ message to $s_2$. However, if $s_2$ belongs to $\\text{sec\\_mss}(h)$, then $\\text{st\\_info}(h)$ need not be sent to $s_2$, so $s_1$ just sends $\\text{handoff\\_completed}(h)$ to $s_2$. This is an added advantage of our fault tolerant scheme. If the set $\\text{sec\\_mss}(h)$ changes, MSS $s_2$ sends $\\text{st\\_info}(h)$ to all the new MSSs in $\\text{sec\\_mss}(h)$ and notifies MSS $s_1$ and the old MSSs in $\\text{sec\\_mss}(h)$ to delete $\\text{st\\_info}(h)$ from their storage.\n\n**Operation after failure**\n\nWhen $\\text{pri\\_mss}(h)$ fails, $h$ switches to another MSS, say $s$, and notifies MSS $s$ about the failure of $\\text{pri\\_mss}(h)$. MH $h$ also sends the set $\\text{sec\\_mss}(h)$ to MSS $s$. If $s \\in \\text{sec\\_mss}(h)$, then $h$ can continue its operation since a copy of $\\text{st\\_info}(h)$ is stored in MSS $s$. If $s \\notin \\text{sec\\_mss}(h)$, then $s$ acquires a copy of $\\text{st\\_info}(h)$ from one of the MSSs in $\\text{sec\\_mss}(h)$. MSS $s$ then becomes the primary MSS of $h$.\n\nThe set $\\text{sec\\_mss}(h)$ may change as a result of mobile host $h$ switching to $s$. All the “new” MSSs in $\\text{sec\\_mss}(h)$ get a copy of $\\text{st\\_info}(h)$ from $s$, and all the “old” MSSs in $\\text{sec\\_mss}(h)$, which no longer belong to $\\text{sec\\_mss}(h)$, delete $\\text{st\\_info}(h)$. MSS $s$, the new primary MSS of $h$, may receive $\\text{copy}(h, m)$ sent by the old primary MSS of $h$ before failure of old primary MSS. In this case, MSS $s$ will send $m$ to all the MSSs in $\\text{sec\\_mss}(h)$ and wait for acknowledgements. On receiving acknowledgements from all the secondary MSSs of $h$, $s$ will process $m$ and deliver it to $\\text{sender}(m)$.\n\nNow consider the failure of an MSS during handoff. Let MH $h$ switch from the cell of $s_1$ to $s_2$, and let $s_2$ fail during handoff. Then MH $h$ will switch to another MSS in $\\text{sec\\_mss}(h)$ and initiate a new handoff procedure as though the handoff was not initiated with $s_2$. The previous MSS of MH $h$ will still be $s_1$ and not $s_2$. If MSS $s_1$ has also failed, then the new MSS of $h$ will acquire $\\text{st\\_info}(h)$\nfrom one of the secondary MSSs of $h$.\n\n**Theorem 13** If pessimistic replication strategy is used, MH $h$ can switch to one of the MSSs in sec.mss($h$) and continue its computation when pri.mss($h$) fails.\n\n**Proof:** Consider the effects of the failure of pri.mss($h$) at various stages of the scheme shown in Figure 7.1. Let $s$ be an MSS to which $h$ has switched after pri.mss($h$) fails. Assume that $s \\in$ sec.mss($h$). (If $s \\notin$ sec.mss($h$), then $s$ acquires a copy of $st_{\\text{info}}(h)$ from one of the secondary MSSs of MH $h$.)\n\nIf a failure occurs during step 1, then message $m$ has not been sent to sec.mss($h$) and $st_{\\text{info}}(h)$ has not been updated. Mobile host $h$ will switch to $s$, and since an acknowledgement for $m$ is not yet sent to the sender of $m$, sender($m$) will retransmit the message.\n\nIf pri.mss($h$) fails during step 2 or step 3, sec.mss($h$) may or may not have received the message $\\text{copy}(h, m)$. If MSS $s$ has not received the message $\\text{copy}(h, m)$, the scenario is the same as the previous one. If MSS $s$ has received the message $\\text{copy}(h, m)$, then, when the sender of $m$ retransmits $m$, $s$ will send $m$ to dest($m$) without updating $st_{\\text{info}}(h)$.\n\nIf MSS $s$ fails during step 4, the effects are similar to the effects of failure during step 2, but for the difference where dest($m$) may receive duplicate copies of $m$ when sender of $m$ retransmits $m$. If dest($m$) has already received $m$, then $m$ will be discarded.\n\nIf an MSS fails while executing a handoff procedure for MH $h$, then MH $h$ will switch to another MSS and initiate a new handoff.\n\nThus, when an MSS failure occurs, mobile hosts in its cell can switch to one of their secondary MSSs and continue their computation without any blocking.\n7.1.3 Optimistic Replication\n\nNormal operation\nThe primary MSS of $h$ updates $st_{\\text{info}}(h)$ on receiving message $m$ sent to $h$, or on receiving message $m$ from $h$. In this scheme, $pri_{\\text{mss}}(h)$ sends message $copy(h, m)$ to all the MSSs in $sec_{\\text{mss}}(h)$ similar to pessimistic scheme, but does not wait for acknowledgements from $sec_{\\text{mss}}(h)$. Message $m$ is immediately processed and $st_{\\text{info}}(h)$ is updated locally by $pri_{\\text{mss}}(h)$, and then $m$ is delivered to $dest(m)$. Hence, the delay in delivering $m$ is less in this scheme than the delay in the pessimistic scheme.\n\nA secondary MSS stores the $copy(h, m)$ message it receives in a log (volatile or stable) without processing the copy message immediately. The secondary MSS processes the messages in the log for MH $h$ and updates $st_{\\text{info}}(h)$ occasionally (whenever the secondary MSS is idle or after a predetermined time interval). A secondary MSS does not send acknowledgements to the $pri_{\\text{mss}}(h)$ for $copy$ messages, unlike in pessimistic scheme.\n\nHandoff Procedure\nThe handoff procedure for this scheme is similar to the handoff procedure for pessimistic scheme except for one difference. When MH $h$ switches to MSS $s$ in $sec_{\\text{mss}}(h)$, the MSS $s$ may not have the recent value of $st_{\\text{info}}(h)$. MSS $s$ can get $st_{\\text{info}}(h)$ from the previous MSS of $h$, or it can process the messages stored (locally) in the log and update $st_{\\text{info}}(h)$, depending on the load of MSS $s$. All other operations are the same as in the handoff procedure described in the pessimistic scheme.\n\nOperation after failure\n$pri_{\\text{mss}}(h)$ processes a message for mobile host $h$ and updates $st_{\\text{info}}(h)$ immediately after sending the message $copy(h, m)$ to all the MSSs in $sec_{\\text{mss}}(h)$. Hence $st_{\\text{info}}(h)$ at $pri_{\\text{mss}}(h)$ may get updated while the message $copy(h, m)$ are in transit to the MSSs in $sec_{\\text{mss}}(h)$. This may lead to $st_{\\text{info}}(h)$ being inconsistent\namong pri_mss(h) and the MSSs in sec_mss(h). In case of an MSS failure, this inconsistency must be resolved.\n\nLet us consider the failure of an MSS, say s1. Let mobile host h be in the cell of s1 and let h switch to the cell of MSS s2 ∈ sec_mss(h). s2 is the new primary MSS of h. Let m be the last message that was processed by s1 for h. Consider the case where s1 sends message copy(h, m) to sec_mss(h), processes m, updates st_info(h), delivers m to dest(m), and then fails. Now assume that MH h switches to the cell of MSS s2. In this scenario, h has the most recent state; it is possible that s2 has not yet received the message m, or even some messages prior to m. Hence, s2 has an outdated copy of st_info(h), i.e. s2 has a chronologically earlier state for h.\n\nTo make the copy of st_info(h) in MSS s2 consistent with the MH h, a recovery procedure is executed by s2. The recovery procedure executed by s2 consists of two steps:\n\n1. Processing all the messages stored in the log for h, and\n2. Processing all the in-transit messages from s1.\n\nWhile executing step 1 is simple, for step 2, s2 has to ensure that it has received all the in-transit messages of the asynchronous channels. We ensure that s2 has received all the in-transit messages from s1 by using a communication primitive return flush [?].\n\nThe definition of return flush from [?] is as follows. If host p sends a return flush message to host q that is known to have failed, the communication network will return the message to p after delivering all other messages from q to p.\n\nMSS s2 sends a return flush to s1 and starts processing the messages stored in the log for h. After processing the stored messages, it processes the in-transit\nmessages received and updates $st_{\\text{info}}(h)$. Once MSS $s_2$ receives the return flush from the network, $st_{\\text{info}}(h)$ is consistent with the state of MH $h$. The recovery procedure is complete, and MH $h$ can continue with the computation.\n\nAll the other MSSs in $sec_{\\text{mss}}(h)$ may not have the updated version of $st_{\\text{info}}(h)$. MSS $s_2$ sends $st_{\\text{info}}(h)$ to them. The other MSSs in $sec_{\\text{mss}}(h)$ receive the latest version of $st_{\\text{info}}(h)$ and clear the messages stored in log for MH $h$. If the set $sec_{\\text{mss}}(h)$ changes, MSS $s_2$ sends a copy of $st_{\\text{info}}(h)$ to the new MSSs in $sec_{\\text{mss}}(h)$ and requests the old MSSs in $sec_{\\text{mss}}(h)$ to delete their copy of $st_{\\text{info}}(h)$ and the messages stored in their log for MH $h$.\n\nIf MSS $s_1$ fails while executing a handoff procedure for MH $h$ (with the previous MSS of $h$), then MH $h$ will switch to another MSS as though it never switched to $s_1$.\n\n**Theorem 14** If optimistic replication strategy is used, MH $h$ can switch to another MSSs and proceed with its computation whenever pri_{\\text{mss}}(h) fails.\n\n**Proof:** Let MH $h$ switch to MSS $s_2$ from MSS $s_1$ as a result of $s_1$’s failure. Without loss of generality, assume that $s_2 \\in sec_{\\text{mss}}(h)$. (Otherwise $s_2$ requests one of the secondary MSSs of $h$ to execute the recovery procedure and gets the $st_{\\text{info}}(h)$ from that MSS.) Before $h$ continues its operation (after switching to MSS $s_2$), MSS $s_2$ processes all the messages in its log for MH $h$ in the received order and updates its copy of $st_{\\text{info}}(h)$. $s_2$ also sends a return flush message to $s_1$. When MSS $s_2$ receives the return flush message from the network, it would have received (processed) a copy of all the messages that caused an update on $st_{\\text{info}}(h)$ at $s_1$. Thus the copy of $st_{\\text{info}}(h)$ at MSS $s_2$ becomes consistent with $st_{\\text{info}}(h)$ at $s_1$ (prior to $s_1$’s failure), and hence $h$ can continue its computation from the cell of $s_2$.\n\nSo far, we have assumed that $sec_{\\text{mss}}(h)$ is available for each MSS $h$. Next, two strategies are presented for selecting secondary MSSs for a mobile host.\n7.1.4 Selection Strategies for Secondary MSSs\n\nDifferent strategies for selecting secondary MSSs may be designed based on various factors such as the mobility pattern of mobile hosts, topology of the network, frequency of mobile hosts’ migration, etc. Since our schemes for fault tolerance do not depend on how secondary MSSs are selected for a mobile host, different strategies for selecting secondary MSSs can be used for different mobile hosts. Also, either the pessimistic or the optimistic replication scheme can be used with any of the strategies for selecting secondary MSSs.\n\nStrategy 1\n\nIf the movement of the mobile host \\( h \\) is within a certain locality, then it is sufficient to consider those MSSs within that locality as candidates for the secondary MSSs of \\( h \\). The MSS within which the mobile host \\( h \\) resides is \\( \\text{pri}_\\text{mss}(h) \\) and all the other MSSs from the locality constitute the secondary MSSs. When \\( \\text{pri}_\\text{mss}(h) \\) fails, mobile host \\( h \\) switches to MSS \\( s \\) in \\( \\text{sec}_\\text{mss}(h) \\), marks \\( s \\) as \\( \\text{pri}_\\text{mss}(h) \\), and proceeds with the computation. An advantage of this strategy is that if \\( h \\) migrates to another cell during the normal operation, additional handoff steps need not be executed. Additional handoff steps are not needed since there is a copy of \\( \\text{st}_\\text{info}(h) \\) in its new MSS. Instead, the previous \\( \\text{pri}_\\text{mss}(h) \\) is marked as a secondary MSS, and its new MSS is marked as \\( \\text{pri}_\\text{mss}(h) \\). This strategy is effective and efficient if the movement of \\( h \\) is constrained to a subset of cells, e.g., some mobile hosts may move more frequently within one area, and occasionally move to other areas.\n\nStrategy 2\n\nLet \\( \\text{neighbors} \\) of an MSS \\( s \\) be a set of MSSs whose cells are adjacent to the cell of \\( s \\) or overlapping with the cell of \\( s \\). For example, in Figure 7.2, the (geographical) neighbors of MSS \\( s_2 \\) are \\( s_1 \\), \\( s_3 \\), and \\( s_4 \\). For a mobile host \\( h \\) in the cell of \\( s \\), the neighbors of \\( s \\) constitute \\( \\text{sec}_\\text{mss}(h) \\). This way of maintaining \\( \\text{sec}_\\text{mss}(h) \\) is based on the expectation that when a mobile host leaves MSS \\( s \\), it must move to one\nof the neighbors of $s$. If $\\text{pri}_\\text{mss}(h)$ fails, the mobile host $h$ switches to one of the neighbors of $\\text{pri}_\\text{mss}(h)$ and continue its operation. When $h$ moves from an MSS, say $s_1$, to another MSS, say $s_2$, during the normal operation, $\\text{sec}_\\text{mss}(h)$ may change since the neighbors of $s_1$ and $s_2$ may not be the same. A copy of $\\text{st}_\\text{info}(h)$ has to be sent to all the new secondary MSSs of $h$. If $s_2$ belongs to $\\text{sec}_\\text{mss}(h)$, then additional handoff steps need not be executed.\n\nIf the cell of a secondary MSS of $h$ overlaps with $\\text{pri}_\\text{mss}(h)$, then physical movement of $h$ is not necessary to switch to the secondary MSS. If physical movement (to switch when an MSS fails) is undesirable, then the network has to built in such a way that every cell overlaps with $k$ other cells. But, this may increase the cost of building the network for large values of $k$.\n\nThe advantage of this strategy over strategy 1 is that the mobility pattern of a mobile host need not be known. However, $\\text{sec}_\\text{mss}(h)$ may change when $\\text{pri}_\\text{mss}(h)$ changes making the handoff procedure costly. In this strategy, the set\n\nFigure 7.2: Neighbors of $s_2 = \\{s_1, s_3, s_4\\}$\nof secondary MSSs for a mobile host entirely depends on its primary MSS and\nthe network topology. In Strategy 1, the set of secondary MSSs entirely depends\non the mobility pattern of a mobile host and not on the MSS.\n\n7.2 Analysis\n\nIn this section, we evaluate the performance of the replication schemes. In both\nthe schemes, for every message, \\( k \\) additional messages are sent to replicate the\nstate of an MH. In the pessimistic scheme, the application messages are delayed\nby a primary MSS as it waits for acknowledgements from secondary MSSs. In\nthe optimistic scheme, there is a delay in recovering from an MSS failure. (A\nsecondary MSS has to send and receive return flush and process the messages in\nits log.) We performed a detailed simulation study to measure these delays and\nthe storage required to buffer the messages.\n\n7.2.1 Simulation Results\n\nThroughout the simulation, the number of MSSs was fixed at 10. The number\nof MHs was varied from 25 to 250. The values of \\( k \\) varies from 2 to 5. The\nvalue of every point in the graphs is an average of the results of 1000 experiments\nperformed.\n\nFigure ?? shows the delay incurred in waiting for the acknowledgements\nfrom the secondary MSSs (pessimistic scheme). The delay increases as the num-\nber of MHs increases, because the load per MSS increases. Also, when \\( k \\) increases,\nthe delay increases due to the increase in the number of acknowledgements for\nwhich a primary MSS has to wait.\n\nIn the pessimistic scheme, a primary MSS has to buffer each message till\nit receives acknowledgements from the secondary MSSs. Figure ?? shows the\namount of storage required per MSS (on an average) to buffer the messages as"}}},{"rowIdx":297,"cells":{"id":{"kind":"string","value":"8d70444db35c37c988d0cfc5f1f78e1746b49cc4"},"text":{"kind":"string","value":"A Categorical Approach to Networks of Aligned Ontologies\n\nMihai Codescu1 · Till Mossakowski2 · Oliver Kutz1\n\nReceived: 8 June 2016 / Revised: 15 March 2017 / Accepted: 5 September 2017\n© Springer-Verlag GmbH Germany 2017\n\nAbstract Ontology matching and alignment are key mechanisms for linking the diverse datasets and ontologies arising in the Semantic Web and other application areas for formalised ontologies. We show that category theory provides the powerful abstractions needed for a uniform treatment of ontology alignment at various levels: semantics, language design, reasoning and tools. The general representation and reasoning framework that we propose includes: (1) an abstract notion of logical system, consisting of a logic syntax and a model theory, based on an extension of institutions with additional features specific to alignments, (2) a declarative language to specify networks of ontologies and alignments, with independent control over specifying local ontologies and complex alignment relations, based on and improving the Distributed Ontology, Model and Specification Language DOL, (3) the possibility to align logically heterogeneous ontologies, and (4) the provision of generic proof support for global reasoning over networks of aligned ontologies, employing different semantics. In particular, we show how the three semantics of Zimmermann and Euzenat can be uniformly and faithfully represented using DOL language constructs, by refining them into four different kinds of semantics: simple, integrated (general and inclusive), and contextualised. Finally, we discuss the implementation of the DOL alignment features in the Ontohub/Hets tool system.\n\nKeywords Ontology alignment · Networks of ontologies · Category theory · DOL · Semantics · Reasoning\n\nContents\n\n1 Introduction .............................................\n2 Formal Preliminaries ...................................\n 2.1 Logics ..............................................\n 2.2 Logic Translations ...................................\n 2.3 Relativisation of Ontologies ........................\n 2.4 Heterogeneity ......................................\n3 Networks of Aligned Ontologies ....................\n 3.1 Syntax of DOL Alignments ........................\n 3.2 Syntax of DOL Networks ...........................\n4 Four Semantics of Relational Networks of Ontologies ...\n 4.1 Simple Semantics ...................................\n 4.2 Integrated Semantics: General and Inclusive ........\n 4.3 Contextualised Semantics ...........................\n5 Normalisation of Alignments ...........................\n 5.1 Structure of the Normalisation Process ............\n 5.2 Simple Semantics ...................................\n 5.3 Inclusive Integrated Semantics ....................\n 5.4 General Integrated Semantics ....................\n 5.5 Contextualised Semantics ..........................\n6 Heterogeneous Alignments ..............................\n7 Representation Theorems for Networks of Ontologies ...\n 7.1 Representation Theorems for Specific Semantics ....\n 7.2 General Representation Theorems ..................\n 7.3 Structuring and Non-monotonic Constructs in DOL ...\n8 Reasoning with Networks of Ontologies ................\n 8.1 Logical Consequence in Networks of ontologies ....\n 8.2 Satisfiability ......................................\n 8.3 Reasoning About Correspondences .................\n 8.4 Complexity of Reasoning ..........................\n 8.5 Modules of Networks ..............................\n 8.6 Tool Support .....................................\n9 Extending the Framework ..............................\n1 Introduction\n\nMatching, and subsequently aligning and linking the diverse terminologies found in heterogeneous datasets, taxonomies and ontologies, arising in the Semantic Web and related application areas for semantic technologies, are seen as key mechanisms towards enabling deeper interoperability between systems and software. Various methods for ontology matching exist, among them linguistic, structural, semantic and statistical methods. The field is quite well developed, with yearly competitions since 2004 comparing the various strengths and weaknesses of existing algorithms [75].\n\nOntology alignments, produced by ontology matching, express correspondences at the semantic level between the symbols of different ontologies. The correspondences of an alignment can involve various relations, between the entities of the ontologies, like equivalence, subsumption, disjointness or membership. The aligned entities can be named symbols, like classes, object properties, individuals, function symbols and sorts or even complex concepts or terms.\n\nThe problem of giving an interpretation to alignments in terms of the semantics of the ontologies is complicated by the fact that the domains of interpretation of the two ontologies are unrelated. Different ways of dealing with this problem exist in the literature. The first solution, called simple semantics in [80], is to assume that the domain of interpretation of the ontologies is uniform [9, 10]. The second solution, called integrated semantics in [80], is to assume the existence of a universal domain together with functions relating the domains of individual ontologies to the universal domain. This approach has been introduced in [78], under the name of integrated distributed description logics (IDDL). Finally, the domains of the individual ontologies can be related among themselves directly instead via a unique universal domain. This approach gives rise to the third semantics, called contextualised semantics in [80]. It was introduced in [80] as an attempt to generalise a number of existing semantic formalisms (distributed first-order logics (DFOL) [25], distributed description logics (DDL) [5] and contextualised ontologies (C-OWL) [7]) and later corrected to a relational semantics in [79]. Package-based description logics (PDL) [3] also fall into this semantic category, as do E-connections [48]. Moreover, [80] discusses the implications of these possible interpretations of alignments with respect to reasoning and composition of alignments.\n\nA major problem with these approaches is their diversity. There exist some attempts for unification, which however remain unsatisfactory: there is no common syntax, no common semantic framework, and no common tool support.\n\nIn this work, we show how category theory can provide such a unifying framework at various levels. Our categorical framework provides a precise syntax, semantics and proof mechanisms for alignments and for networks of alignments that follow closely those developed for OWL (see [20, 80]) while simultaneously abstracting from the dependency on OWL and generalising the approach to an arbitrary logic.\n\nWe also improve previous related work at the abstract categorical level [34, 49, 79, 81] which did not spell out all details, and did not make the step from abstract description and case studies to language design and implementation. In particular, the intuitive definition of satisfaction of a correspondence in a pair of aligned ontologies from [20, 80] is not covered by these works, while we cover it and generalise it to an arbitrary logic.1\n\nOur results have greatly influenced the syntax and semantics of alignments, networks of alignments and their combination in the Distributed Ontology, Model and Specification Language DOL [59, 62, 68]. While DOL has been developed independently, its treatment of alignments is essentially based on the contributions provided in the present paper.\n\nBefore giving a detailed outline of the structure of the paper, we describe the general approach followed and the solutions provided in a high-level fashion.\n\nGeneral Approach and Results Summary The general framework for representation of and reasoning with alignments that we propose has the following three main features.\n\n1. It provides a declarative language to specify networks of ontologies and alignments, with independent control over specifying the local ontologies and complex alignment relations.\n2. It supports the alignment of logically heterogeneous ontologies.\n3. It allows to independently choose the semantical paradigm to interpret the alignment relations (simple/integrated/contextualised).\n\nThrough category theory, we obtain a unifying framework at various levels:\n\n**semantic level:** We give a uniform semantics for distributed networks of aligned ontologies while at the same time reflecting properly the semantic variation points indicated above.\n\n---\n\n1 This paper is an extended version of [14]. While in [14] we present the semantics of alignments for the particular case of OWL, in the present paper we introduce a general construction, independent of the underlying logical formalism. This means that the results of [14] can be obtained as an instantiation of the results of this paper. Note however that we needed to enhance the formalisation of the notion of logical system in order to achieve this goal.\nA Categorical Approach to Networks of Aligned Ontologies\n\n(meta) language level: Based on the Distributed Ontology, Model and Specification Language DOL, we provide (and equip DOL with) a uniform notation for distributed networks of aligned ontologies, spanning the different possible semantic choices.\n\nreasoning level: Using the powerful notion of colimit, we provide reasoning methods for distributed networks of aligned ontologies, again across all semantic choices.\\(^2\\)\n\ntool level: HETS (https://hets.eu) and Ontohub (https://ontohub.org) provide an implementation of analysis and reasoning for distributed networks of aligned ontologies, again using the powerful abstractions provided by category theory.\n\nlogic level: Our semantics is defined in a logic-independent way and formulated under rather mild technical assumptions. Moreover, these assumptions are verified by most logical formalisms used in practice. In this paper, we use as running examples the logic SROIQ underlying the Web ontology language OWL 2 DL, as well as unsorted first-order logic.\n\nThis shows that category theory is not only a powerful abstraction at the semantic level, but can properly guide language design and tool implementations. It thus provides in particular useful abstraction barriers from a software engineering point of view.\n\nOur use of category theory is modest, oriented towards the generalisation of results that can, with similar efforts, also be developed for particular logics. Moreover, if one wants to use our general results and instantiate them for a particular logic, there is no free lunch: one still has to provide a number of specific notions for the logic at hand. Still, our approach has benefits over solutions that are hand-crafted for each individual logic. Firstly, we gain insights, at a general level, in the nature of systems of aligned ontologies and their properties. Secondly, the individual hand-crafted solutions are often similar in their details, for example, the reduction of packaged-based DLs to SROIQ in [3], which the authors claim to have adapted from that for DDLs [5]. This calls for abstraction. Indeed, for this kind of reduction, we prove some general theorems that need not to be reproved in each individual case. Thirdly, each approach to alignment and/or to distributed ontologies has its own language and formalism. With DOL, we provide general language constructs for alignments that do not need to be reinvented for each logic separately. And last but not least, HETS and Ontohub provide logic-independent tool support. While the tool support also does not come for free, it is much less effort to instantiate the general tool framework with additionally needed logic-specific tools than it is to newly create an alignment analysis and reasoning tool from scratch.\\(^3\\) A typical user of our framework will mostly benefit from the uniform language design and tool implementation. Both are available and can be used at an intuitive level without a deeper understanding of our framework.\n\nThe Distributed Ontology, Model and Specification Language DOL\\(^4\\) is a metalanguage in the sense that it enables the reuse of existing ontologies as building blocks for new ontologies using a variety of structuring techniques, as well as the specification of relationships between ontologies. One important feature of DOL is the ability to combine ontologies that are written in different languages without changing their semantics. A sketch of the formal specification of the language can be found in [62], with a more extensive description found in [59,68]. The general theoretical background for DOL was given in [51]. This paper gives the first detailed treatment of the syntax and semantics of DOL alignments independently of the logics of the aligned ontologies.\n\nThe general picture of networks of ontologies in DOL is then as follows: existing formalisms for ontologies can be integrated as-is into the DOL framework. With our new extended DOL syntax, we can specify different kinds of alignments. Based on this, we construct networks of ontologies and alignments between them. These networks are called relational. Functional networks of ontologies are possible as well; the links between the ontologies of a functional network are given by ontology morphisms. The latter are similar to alignments that behave like functions (i.e. that relate each symbol in the source ontology with exactly one symbol in the target ontology). Functional networks of ontologies can be combined into an integrated ontology via a colimit. Note that colimits, which can intuitively be considered as quotients of disjoint unions, provide a powerful and flexible way of combining a network of alignments into a single combined ontology. Reasoning in a functional network is then the same as reasoning in the combined ontology. This con-\n\n---\n\n\\(^2\\) We do not claim here that the reasoning methods we provide outperform more specialised alignment reasoning methods, say for DDL, or alignment debugging: our main contribution is the provision of a unifying framework that works simultaneously at the various levels.\n\n\\(^3\\) Note that this paper does not cover search for alignments.\n\n\\(^4\\) DOL has been adopted as a standard by the Object Management Group (OMG), see http://www.omg.org/spec/DOL/ and http://dol-omg.org.\nstruction generalises the above mentioned reduction from package-based DLs and DDLs to \\textit{SROIQ}.\n\nIn order to do the same for relational networks, we first must normalise relational networks into functional ones. This step depends on the particular choice of an alignment framework, specifically on (a) the logics of the ontologies involved, and (b) the assumptions made on the domains, i.e. the type of semantics involved. It may involve transformations on the ontologies, such as relativisation of the domain of interpretation using predicates. During this construction, the correspondences become \\textit{bridge axioms} in a bridge ontology relating the aligned ontologies. Bridge axioms internalise the semantics of correspondences. This transformation is specific to the logics of the aligned ontologies and may require a translation to a more expressive formalism.\n\nOur approach is generic in the following sense: in order to include a new ontology language into the framework, it is sufficient to define the satisfaction of correspondences, the relativisation for local logics, and the transformation of correspondences to sentences for each of the four\\textsuperscript{5} kinds of semantics. Also, the construction of colimits must be defined. As a consequence of this construction, the general framework will provide both a treatment of all four semantics for alignments for the newly included ontology language, as well as a way to reason about such alignments via a reduction to reasoning about (unstructured) ontologies.\n\n**Outline of the Paper** \nThe rest of the paper is structured as follows: in Sect. 2, we present the core technical ingredients for our abstract framework in four parts (i) in Sect. 2.1, we introduce an abstract notion of logical system, based on an extension of institutions with additional infrastructure required to capture aspects specific to alignments, (ii) in Sect. 2.2, we complement this with a notion of logic translation, (iii) in Sect. 2.3, we formalise the notion of relativisation of a logic as a logic translation with certain properties, (iv) and in Sect. 2.4, we introduce a Grothendieck construction over a graph of logics and their translations, meant to provide a foundation for syntactic heterogeneity. In Sect. 3, we formally introduce correspondences, alignments and networks of aligned ontologies over an arbitrary logic. We also present the syntax of alignments and networks in DOL. In Sect. 4, we recall the different approaches to semantics of networks of aligned ontologies, based on the assumptions made on the domain of interpretation of the involved ontologies. We illustrate the interpretation of correspondence relations, in each case, for \\textit{SROIQ} and FOL. In Sect. 5, we describe the construction of the diagram of an alignment, using a general method that is further instantiated to each of the four semantics of networks of ontologies. The general idea is to build a bridge ontology, internalising the semantics of the correspondences of the alignment, and to relate it with transformations of the aligned ontologies in a W-shaped diagram. In Sect. 6, we address the issue that the logic of the aligned ontologies may not be the same, or that a correspondence cannot be internalised in the logics of the aligned ontologies. Thus, we build a W-diagram for alignments, similar to the construction of the previous section, for the heterogeneous case. In Sect. 7, we show that the construction of the W-diagram for alignments captures its intended semantics, for all four cases. Moreover, we discuss when the colimit of the resulting diagram represents exactly the models of the network of aligned ontologies. In Sect. 8, we build on the results of the previous section and study various aspects regarding reasoning with networks of aligned ontologies via reasoning in the derived colimit ontology. We also introduce a notion of satisfiability for \\textit{NeO}s and define modules of networks. Employing modularity is proposed as a pathway to optimise the performance of reasoning in the colimit-based approach. We here also discuss tool support for reasoning with networks of alignments and colimit computation in HETS and Ontohub. In Sect. 9, we outline a road-map towards a full integration of formalisms like E-connections, DDL and DFOL into our general framework, sketching the main challenges ahead. Finally, in Sect. 10, we provide a brief summary and outlook to future work.\n\n2 Formal Preliminaries\n\nWe will use the Distributed Ontology, Model and Specification Language DOL mainly as a means for the specification of ontologies and their relations, networks of ontologies and alignment relations. In this section, we will develop the formal preliminaries for the semantics of DOL. We will here only introduce the abstract semantics necessary to understand DOL’s treatment of various types of alignments, networks and combinations of networks.\n\nWe will use basic concepts of category theory. Readers unfamiliar with category theory may view a category as a graph with a monoid-like composition operation on the arrows. The notion of category is mainly needed to abstract away from the specific details of the notion of signature. Signatures specify the non-logical vocabulary of an ontology. They form the nodes (called objects in category theory terminology) of the graph. Edges are maps between signatures (called morphisms in category theory terminology). Intuitively, they capture change in notation, e.g. renaming a symbol or extending a signature with new symbols. The monoid-like composition of arrows (morphisms) can be thought of as the usual composition of maps.\n\nWe will follow the standard notations of [55], with the exception of composition of morphisms, where we prefer the diagrammatic order and the notation \\(\\circ\\). That is, if \\(f:\\)\nA \\rightarrow B \\text{ and } g : B \\rightarrow C, \\text{ while their composition often is written } g \\circ f : A \\rightarrow C, \\text{ we will write } f ; g : A \\rightarrow C. \\text{ If } C \\text{ is a category, then } |C| \\text{ are the objects of } C, \\text{ and } C^{op} \\text{ is its opposite category (i.e. } C \\text{ with the direction of all morphisms reversed).}\n\n2.1 Logics\n\nWe introduce below a unifying notion of logic, covering the large variety of formalisms in use at an abstract level, following the spirit of Goguen’s and Burstall’s institutions [29]. This allows us to develop results independently of the particularities of a logical system. The definitions presented here are new: while the terminology is inspired by [69], our notions make more assumptions about the features present both in the syntax and the semantics of a logic. That is, we consider institutions with extra infrastructure (like carrier sets and predicated) that is specifically tailored towards alignments, while still staying at a general level. Indeed, our framework of logic (=institution with extra infrastructure) should cover roughly the same set of logics that are covered by institutions—even though the formalisation of some logics will require some adoptions, see e.g. the formalisation of many-sorted logic in Example 9.\n\nWe start by introducing the notion of logic syntax. The main idea is that signatures collect the non-logical symbols of the language. Each signature gets assigned the set of sentences that can be formed with its symbols. Also, for each signature, we provide means for extracting the symbols it consists of, together with their kind. Signature morphisms are mappings between signatures. We do not assume any details except that signature morphisms can be composed and there are identity morphisms; this amounts to a category of signatures.\n\nDefinition 1 A logic syntax is a tuple \\( L = (\\text{Sign, Sen, Symbols, Kinds, Sym, kind, arity}) \\) consisting of\n\n- a category \\( \\text{Sign} \\) of signatures and signature morphisms;\n- a sentence functor\\(^6\\) \\( \\text{Sen} : \\text{Sign} \\rightarrow \\text{Set} \\) assigning to each signature the set of its sentences and to each signature morphism \\( \\sigma : \\Sigma \\rightarrow \\Sigma' \\) a sentence translation function \\( \\text{Sen}(\\sigma) : \\text{Sen}(\\Sigma) \\rightarrow \\text{Sen}(\\Sigma') \\);\n- a set \\( \\text{Symbols} \\) of symbols and a set \\( \\text{Kinds} \\) of symbol kinds together with a function \\( \\text{kind} : \\text{Symbols} \\rightarrow \\text{Kinds} \\) giving the kind of each symbol;\n- a faithful functor\\(^7\\) \\( \\text{Sym} : \\text{Sign} \\rightarrow \\text{Set} \\) assigning to each signature \\( \\Sigma \\) a set of symbols \\( \\text{Sym}(\\Sigma) \\subseteq \\text{Symbols} \\) and to each signature morphism \\( \\sigma : \\Sigma \\rightarrow \\Sigma' \\) a function \\( \\text{Sym}(\\sigma) : \\text{Sym}(\\Sigma) \\rightarrow \\text{Sym}(\\Sigma') \\) such that for each \\( s \\in \\text{Sym}(\\Sigma) \\), \\( \\text{kind}(\\sigma(s)) = \\text{kind}(s) \\);\n\n- a function \\( \\text{arity} : \\text{Symbols} \\rightarrow \\mathbb{N} \\) giving the arity of each symbol.\n\nBefore giving examples of logic syntaxes, we introduce the concept of logical theory.\n\nDefinition 2 Let \\( L \\) be a logic syntax. A theory of \\( L \\) consists of a signature \\( \\Sigma \\) and a set \\( E \\) of \\( \\Sigma \\)-sentences.\n\nFor the purposes of this paper, it suffices to regard an ontology as a theory. In DOL, ontologies can be written using more complex structuring mechanisms.\n\nExample 1 In \\( ALC \\), the signatures are tuples \\((A, \\mathcal{R}, I)\\) with \\( A, \\mathcal{R}, I \\) subsets of a set of names.\\(^8\\) For two signatures \\( \\Sigma = (A, \\mathcal{R}, I) \\) and \\( \\Sigma' = (A', \\mathcal{R}', I') \\), a signature morphism \\( \\varphi : \\Sigma \\rightarrow \\Sigma' \\) consists of a function \\( \\varphi^A : A \\rightarrow A' \\), a function \\( \\varphi^\\mathcal{R} : \\mathcal{R} \\rightarrow \\mathcal{R}' \\) and a function \\( \\varphi^I : I \\rightarrow I' \\). Kinds is the set \\{concept, role, individual\\}. Symbols is the set of all pairs \\((k, s)\\) where \\( k \\) is an element of Kinds and \\( s \\) is a name. For each \\((k, s) \\in \\text{Symbols}, \\text{kind}(k, s) = k\\). For each signature \\( \\Sigma = (A, \\mathcal{R}, I) \\), \\text{Sym}(\\Sigma) is the union of the set \\{(concept, a) | a \\in A\\} with \\{(role, r) | r \\in \\mathcal{R}\\} and \\{(individual, i) | i \\in I\\}. The arity of a symbol is 0 for symbols of kind individual, 1 for symbols of kind concept and 2 for symbols of kind role. For an \\( ALC \\) signature \\((A, \\mathcal{R}, I)\\), complex concepts follow the grammar\n\n\\[ C ::= A \\mid \\top \\mid \\bot \\mid \\neg C \\mid C \\cup C' \\mid C \\cap C' \\mid \\forall R.C \\mid \\exists R.C \\]\n\nwhere \\( R \\) is a role. Sentences are subsumptions between (complex) concepts \\( C_1 \\subseteq C_2 \\), membership assertions of individuals in concepts, written \\( a \\in C \\) for \\( a \\in I \\), and of pairs of individuals in roles, written \\( R(a, b) \\) for \\( a, b \\in I \\) and \\( R \\in \\mathcal{R} \\). Sentence translation along a morphism is just translation of the non-logical symbols in a sentence along the corresponding component of the morphism.\n\nExample 2 The logic SROIQ [39], which is the logical core of the Web Ontology Language OWL 2 DL,\\(^9\\) inherits its signatures and symbols from \\( ALC \\). Sentences are that of \\( ALC \\), extended with the following constructs: (i) complex role inclusions such as \\( R \\circ S \\subseteq S \\) as well as simple role hierarchies such as \\( R \\subseteq S \\), assertions for symmetric, transitive, reflexive, asymmetric and disjoint roles (called RBox\n\n---\n\n\\(^6\\) Referring to the intuition of categories of graphs, a functor is just a graph homomorphism. However note that also the monoidal composition of arrows must be preserved.\n\n\\(^7\\) A functor is faithful if it is injective when restricted to each set of morphisms that have a given source and target.\n\n\\(^8\\) According to the OWL 2 specification, names of OWL symbols should be IRIs; see https://www.w3.org/TR/owl2-syntax/.\n\n\\(^9\\) See http://www.w3.org/TR/owl2-overview/. Note, however, that OWL also includes datatypes, which further enrich the logic. We omit these because they are inessential for the presentation of the logical framework presented in this paper and would unnecessarily complicate exposition.\nsentences, denoted by \\( s \\in \\mathcal{R} \\) in the name of the logic), as well as the construct \\( \\exists X \\text{Self} \\) (collecting the set of ‘-reflexive points’); (ii) nominals, i.e. concepts of the form \\([a]_i\\), where \\( a \\in I \\) (denoted by \\( O \\)); (iii) inverse roles (denoted by \\( I \\)); qualified and unqualified number restrictions (\\( Q \\)). For details on the rather complex grammatical restrictions for \\( \\mathcal{SROIQ} \\) (e.g. regular role inclusions, simple roles) compare [39].\n\nStrictly speaking, we have defined \\( \\mathcal{SROIQ} \\) resp. OWL 2 DL without restrictions in the sense of [72]. The reason is that in a logic, sentences can be used for arbitrary formation of theories. By contrast, \\( \\mathcal{SROIQ} \\) imposes specific constraints on theory formation: e.g. a role can only be declared to be either irreflexive or transitive, but not both [39].\n\nSince colimits, similar to unions of theories, can lead to such irrec-\n\n2 DL, like Pellet or Fact, cannot be used for reasoning. In such cases, a logic translation to FOL (Sect. 2.2) and a FOL reasoner must be used instead. Note that this limitation is not a specificity of our approach, but applies to all computable sound and complete approaches to reasoning in networks of OWL ontologies.\\(^{10}\\)\n\nWe now come to first-order logic (FOL), which has been used in the formalisation of many upper ontologies such as DOLCE, BFO, GFO, SUMO and others.\n\nExample 3 In the logic syntax of many-sorted first-order logic FOL\\(_s\\), signatures are pairs of the form \\((F, P)\\) where \\( F = (F^i)_{i \\in \\mathbb{N}} \\) is a set of function symbols such that for each \\( i, F^i \\) is the set of function symbols of arity \\( i \\), \\( P = (P^i)_{i \\in \\mathbb{N}} \\) is a set of predicate symbols such that for each \\( i, P^i \\) is the set of function symbols of arity \\( i \\), and the elements of \\( F^i \\) and \\( P^i \\) are from a set of names. Given two signatures \\( \\Sigma_1 = (F_1, P_1) \\) and \\( \\Sigma_2 = (F_2, P_2) \\), a signature morphism \\( \\varphi : \\Sigma_1 \\to \\Sigma_2 \\) has two components, \\( \\varphi_{op} : F_1 \\to F_2 \\) such that \\( \\varphi_{op}(f) \\in F^i_2 \\) for each \\( f \\in F^i_1 \\) and \\( \\varphi_{pred} : P_1 \\to P_2 \\) such that \\( \\varphi_{pred}(p) \\in P^i_2 \\) for each \\( p \\in P^i_1 \\). \\( \\text{Kinds} \\) is the set \\((\\text{fun}, \\text{pred})\\). \\( \\text{Symbols} \\) is the set of all tuples \\((s, i)\\) where \\( k \\) is an element of \\( \\text{Kinds} \\), \\( s \\) is a name and \\( i \\) is a natural number. For each \\((k, s, i) \\in \\text{Symbols} \\), \\( \\text{kind}(k, s, i) = k \\). For each signature \\( \\Sigma = (F, P) \\), \\( \\text{Sym}(\\Sigma) = \\{(\\text{fun}, f, i) \\mid f \\in F^i \\} \\cup \\{(\\text{pred}, p, i) \\mid p \\in P^i \\} \\). Given a signature \\( \\Sigma = (F, P) \\) and a countable infinite set of variables \\( X \\), the set \\( T^\\Sigma(X) \\) of terms is the least set that contains \\( X \\) and for each operation symbol \\( f \\in F_n \\), for some \\( n \\in \\mathbb{N} \\), and each terms \\( t_1, \\ldots, t_n \\in T^\\Sigma(X) \\), it also contains \\( f(t_1, \\ldots, t_n) \\). Formulas are formed starting from atomic sentences, which are predications \\( p(t_1, \\ldots, t_n) \\) and equations \\( t_1 = t_2 \\), where \\( t_1, \\ldots, t_n \\) are terms and \\( p \\in P_n \\) for some \\( n \\in \\mathbb{N} \\), and applying to them the usual Boolean connectives (defined, e.g. in terms of negation and conjunction) and quantification over a subset of \\( X \\). Sentences are closed formulas. Sentence translation is done by just replacing symbols according to the signature morphism.\n\nExample 4 The logic syntax of many-sorted first-order logic MSFOL is similar to that of unordered FOL. Signatures are triples \\((S, F, P)\\) where \\( S \\) is a set of sorts, \\( F = (F_{w,s})_{w \\in S^*, s \\in S} \\) is a family of function symbols and \\( P = (P_w)_{w \\in S^*} \\) a family of predicate symbols, both consisting of sets of names. Signature morphisms map sorts, function symbols and predicate symbols in a compatible way. \\( \\text{Kinds} \\) is the set \\([\\text{sort}, \\text{fun}, \\text{pred}]\\). \\( \\text{Symbols} \\) is the set of all tuples of form \\((\\text{sort}, s), (\\text{fun}, f, w \\to s)\\) or \\((\\text{pred}, p, w)\\), where \\( s, f \\) and \\( p \\) are names and \\( w \\) is a string of names. \\( \\text{kind}((\\text{sort}, s)) = \\text{sort}, \\text{kind}((\\text{fun}, f, w \\to s)) = f \\) and \\( \\text{kind}((\\text{pred}, p, w)) = \\text{pred} \\). For each signature \\( \\Sigma = (S, F, P), \\text{Sym}(\\Sigma) = \\{(\\text{sort}, s) \\mid s \\in S \\} \\cup \\{(\\text{fun}, f, w \\to s) \\mid f \\in F_{w,s} \\} \\cup \\{(\\text{pred}, p, w) \\mid p \\in P_w \\} \\). Sentences are defined like in FOL, except that they need to respect typing.\\(^{\\square}\\)\n\nExample 5 The logic syntax of relational database schemes is defined over some fixed set \\( D \\) of datatpe sorts with fixed interpretation \\( I : D \\to \\text{Set} \\). For instance, we may have \\( D = \\{\\text{integer}, \\text{string}, \\text{text}, \\text{boolean}, \\text{blob}\\} \\).\n\nA signature is a set \\( T \\) of database table declarations of form\n\n\\[\nT(f_1 : d_1, \\ldots, f_n : d_n)\n\\]\n\nwhere \\( t \\) is a name (of the table) the \\( f_i : d_i \\) are field (column) declarations, with \\( f_i \\) a name and \\( d_i \\in D \\). A field declaration can be marked as primary key. Signature morphisms map table declarations to those with same datatypes, such that primary keys are preserved. \\( \\text{Kinds} \\) is the set of all tables \\((table, t)\\) where \\( t \\) is a table name. \\( \\text{kind}(table, t) = table \\). For each signature \\( T \\), \\( \\text{Sym}(\\Sigma) = \\bigcup_{(table, t) \\in T} \\{(table, t)\\} \\).\n\nA sentence is a link (integrity constraint)\n\n\\[\nt_1[f_1] \\rightarrow t_2[f_2] \\ \\text{mult}\n\\]\n\nbetween two field names \\( f_i \\) of tables \\( t_i \\) \\((i = 1, 2)\\), attributed by a multiplicity \\( \\text{mult} \\) that is taken from the set \\( \\{\\text{one_to_many}, \\text{one_to_one}\\} \\). Sentence translation is done by just replacing names according to the signature morphism.\\(^{\\square}\\)\n\nAlso, higher-order logic (HOL) has been used for ontology design, e.g. in the modelling of universals and roles [4], and\n\n\\(^{10}\\) An approach overcoming this limitation could easily be used to reason about OWL ontologies featuring, e.g. irreflexive transitive roles, which is however undecidable.\nis particularly important for foundational ontologies such as UFO [32]. In [54], the authors argue that the focus on OWL or FOL ontologies does not allow for a sufficiently general analysis and resolution of ontological faults. They advocate HOL for the study of ontology evolution in physics.\n\nExample 6 [6] The logic syntax of Church-style simple higher-order logic HOL has as signatures pairs $(S, F)$ where $S$ is a set of sorts (or base types), and $F = (F_t)_t \\in S^+\\rightarrow$ is a family of constants, where $S^+$ is the set of higher types, i.e. the closure of $S \\cup \\{\\text{Bool}\\}$ under function arrows $\\rightarrow$. Signature morphisms map sorts and constants in a compatible way.\n\n**Kinds** is the set \\{sort, const\\}. **Symbols** is the set of all tuples of form \\((\\text{sort}, s)\\) or \\((\\text{const}, f, t)\\), where $s$ and $f$ are names and $t \\in S^+$ is a type. kind\\((\\text{sort}, s)\\) = sort and kind\\((\\text{const}, f, t)\\) = const. For each $\\Sigma = (S, F)$, $\\text{Sym}(\\Sigma) = \\{\\text{sort}, s\\mid s \\in S\\} \\cup \\{(\\text{const}, f, t)\\mid f \\in F_1\\}$.\n\nTerms are inductively defined as follows:\n\n$$u ::= x \\mid c \\mid \\bar{F} u u \\mid \\lambda x : t. u$$\n\nwhere $\\bar{F}$ extends $F$ with the (logical) predefined constants $\\land : t \\rightarrow t \\rightarrow \\text{Bool}$. $\\land : (t \\rightarrow \\text{Bool}) \\rightarrow \\text{Bool}$, $\\lor : \\text{Bool} \\rightarrow \\text{Bool}$ and $\\wedge : \\text{Bool} \\rightarrow \\text{Bool} \\rightarrow \\text{Bool}$. Terms must be well-typed. Sentences are terms of type $\\text{Bool}$. Sentence translation is defined by replacement of non-logical symbols (from the signature) along the signature morphism. The arity of sorts is 0. If $t = s_1 \\rightarrow \\cdots s_n \\rightarrow s$, where $s_1, \\ldots, s_n, s$ are sorts, the arity of a symbol in $F_1$ is $n$, for each $n \\in \\mathbb{N}$.\n\nA logic syntax can be complemented with a model theory, which introduces semantics for the language and gives a satisfaction relation between the models and the sentences of a signature. In the context of ontology alignment, we add the assumption that models are interpreted over a universe, and symbols of each kind are interpreted as elements of the same certain set that is formed over the universe.\n\n**Definition 3** Let $L = (\\text{Sign}, \\text{Sen}, \\text{Symbols}, \\text{Kinds}, \\text{Sym}, \\text{kind, arity})$ be a logic syntax. A model theory for $L$ is a tuple $(\\text{Mod}, \\models, \\text{universe}, \\text{dom}, \\text{sym})$ where\n\n$- \\text{Mod} : \\text{Sign} \\rightarrow \\text{Cat}$\n\nis a functor giving for each signature $\\Sigma$ the category of $\\Sigma$-models $\\text{Mod}(\\Sigma)$ and for each signature morphism $\\varphi : \\Sigma_1 \\rightarrow \\Sigma_2$, a functor $\\text{Mod}(\\varphi) : \\text{Mod}(\\Sigma_2) \\rightarrow \\text{Mod}(\\Sigma_1)$ (often called reduct functor), where often $\\text{Mod}(\\varphi)(M^2)$ is written $M^2|_{\\varphi}$.\n\n$- \\models = \\{\\Sigma \\subseteq \\{\\text{Mod}(\\Sigma)\\} \\times \\text{Sen}(\\Sigma)\\}_{\\Sigma \\in \\text{Sign}}$ is a family of satisfaction relations enjoying the following satisfaction condition:\n\n$$M' \\models_{\\Sigma'} \\varphi(e) \\iff M'_{\\varphi} \\models_{\\Sigma} e$$\n\nfor each $\\varphi : \\Sigma \\rightarrow \\Sigma' \\in \\text{Sign}$, each $M' \\in |\\text{Mod}(\\Sigma')|$ and each $e \\in \\text{Sen}(\\Sigma)$.\n\n$- \\text{universe} = \\{\\text{universe}_\\Sigma : \\text{Mod}(\\Sigma) \\rightarrow \\text{Set}\\}_{\\Sigma \\in \\text{Sign}}$ is a family of functors that give the universe of each $\\Sigma$-model, such that for each signature morphism $\\sigma : \\Sigma \\rightarrow \\Sigma'$ and each $M' \\in |\\text{Mod}(\\Sigma')|,$\n\n$$\\text{universe}_\\Sigma(M') = \\text{universe}_{\\Sigma'}(M'_{\\sigma})$$\n\n$- \\text{domain} : \\text{Kinds} \\times |\\text{Set}| \\rightarrow |\\text{Set}|$ is a function giving the domain of each kind, needed for interpreting symbols of that kind. The domain is given relative to the universe (which of course is a set).\n\n$- \\text{sym} : (\\Sigma \\in |\\text{Sign}|) \\times (M \\in \\text{Mod}(\\Sigma)) \\times (s \\in \\text{Sym}(\\Sigma)) \\rightarrow \\text{domain}(\\text{kind}(s), \\text{universe}(M))$ gives the interpretation of symbols in the corresponding domain. That is, if $\\Sigma$ is a signature, $M$ is a $\\Sigma$-model and $s \\in \\text{Sym}(\\Sigma)$, the interpretation $\\text{sym}(\\Sigma, M, s)$ of $s$ in $M$ is an element of the set $\\text{domain}(\\text{kind}(s), \\text{universe}(M))$. If $\\Sigma$ is clear from the context, we may shortly denote by $M_s$ the interpretation of $s$ in $M$ (completely written $\\text{sym}(\\Sigma, M, s)$). Moreover, it is required that for each $\\sigma : \\Sigma \\rightarrow \\Sigma'$, each $M' \\in |\\text{Mod}(\\Sigma')|$ and each $s \\in \\text{Sym}(\\Sigma)$,\n\n$$\\text{sym}(\\Sigma', M', \\text{Sym}(\\sigma)(s)) = \\text{sym}(\\Sigma, M|_{\\sigma}, s)$$\n\nsuch that if two models have the same universe and interpret symbols in the same way, they are equal, i.e. for each $\\Sigma \\in |\\text{Sign}|$ and each $M', M'' \\in |\\text{Mod}(\\Sigma)|$, if $\\text{universe}(M') = \\text{universe}(M'')$ and $M'_s = M''_s$ for each $s \\in \\text{Sym}(\\Sigma)$, then $M' = M''$.\n\nThe last conditions allows us to define a model by giving its universe and the interpretation of all symbols in the model.\n\nExample 7 Models of an $\\text{ALC}$ (or $\\text{SROIQ}$) signature $(\\mathcal{A}, \\mathcal{R}, I)$ are pairs $M = (\\Delta, I)$ where $\\Delta$ is a set giving the universe (i.e. $\\text{universe}(M) = \\Delta$) of the structure and $I$ is an interpretation function assigning to each symbol an element of the domain corresponding to its kind:\n\n$\\otimes$ Springer\nto each atomic concept \\( A \\in A \\) a subset \\( A^I \\) of \\( \\Delta \\), since domain(concept, \\( X \\)) = \\( P(X) \\),\n\n- to each role \\( R \\in R \\) a binary relation \\( R^I : \\Delta \\times \\Delta \\), since domain(role, \\( X \\)) = \\( P(X \\times X) \\), and\n\n- to each individual \\( i \\in I \\) an element \\( i^I \\) of \\( \\Delta \\), since domain(individual, \\( X \\)) = \\( X \\).\n\nHomomorphisms between models are functions between the universes that preserve individuals, concepts and roles. The functor universe maps a model homomorphism to its underlying function. Given a signature morphism \\( \\varphi : \\Sigma = (A, R, I) \\rightarrow \\Sigma' = (A', R', I') \\) and a \\( \\Sigma' \\)-model \\( \\langle \\Delta', . \\rangle \\), its \\( \\Sigma \\)-reduct has the same universe \\( \\Delta \\) and interprets an atomic concept, role or individual \\( x \\) as \\( \\varphi(x)^I \\). Interpretation of atomic concepts in a model \\( \\langle \\Delta, . \\rangle \\) extends to interpretations of concepts, denoted also \\( C^I \\) where \\( C \\) is a concept, inductively as follows: \\( \\top \\) is interpreted as \\( \\Delta \\), \\( \\bot \\) is interpreted as the empty set, the negation of a concept is interpreted as the \\( \\Delta \\)-complement of the interpretation of the negated concept, the union and intersection of two concepts are interpreted as the set-theoretic union and, respectively, intersection of the interpretations of the concepts, the concept \\( \\forall R.C \\), where \\( R \\) is a role and \\( C \\) is a concept, is interpreted as \\( \\{ x \\in \\Delta \\mid \\forall y \\in \\Delta \\text{ such that } x R^I y, y \\in C^I \\} \\) and \\( \\exists R.C \\), where \\( R \\) is a role and \\( C \\) is a concept, is interpreted as \\( \\{ x \\in \\Delta \\mid \\exists y \\in \\Delta \\text{ such that } x R^I y \\} \\). Satisfaction is the standard satisfaction in description logics: a model \\( \\langle \\Delta, . \\rangle \\) satisfies a subsumption \\( X \\sqsubseteq Y \\) if for each element \\( x \\in X \\) there is some \\( y \\in Y \\) such that \\( x R^I y \\).\n\nExample 8 Models \\( M \\) of FOL are first-order structures, consisting of a carrier set \\( M_U \\) and an interpretation of n-ary function symbols \\( f \\) as functions \\( M_f \\) with arguments on \\( M_U \\) and result in \\( M_U \\), for each natural number \\( n \\), and of n-ary predicate symbols \\( p \\) as n-ary relations \\( M_p \\) on \\( M_U \\). The universe universe(\\( M \\)) is \\( M_U \\). The symbols are interpreted as elements in their corresponding domains:\n\n\\[\n\\text{domain(fun, } X) = \\{ f : X^n \\rightarrow X \\mid n \\in \\mathbb{N} \\} \\\\\n\\text{domain(pred, } X) = \\{ p \\subseteq X^n \\mid n \\in \\mathbb{N} \\}\n\\]\n\nHomomorphisms between models are functions between the universes that preserve functions and predicates. The functor universe maps a model homomorphism to its underlying function. The reduct of a model along a signature morphism \\( \\varphi \\) has the same carrier set as the original model and interprets a function or predicate symbol \\( x \\) in the same way as \\( \\varphi(x) \\) is interpreted in the original model. We denote Fun(\\( X \\)) = \\{ \\( f : X^n \\rightarrow X \\mid n \\in \\mathbb{N} \\) \\} and Pred(\\( X \\)) = \\{ \\( p \\subseteq X^n \\mid n \\in \\mathbb{N} \\) \\}.\n\n\\[\\text{Example 9} \\] Models \\( M \\) of MSFOL are first-order structures, consisting of a universe \\( M_U \\), a carrier set \\( M_\\Sigma \\subseteq M_U \\) for each sort \\( s \\), an interpretation of function symbols \\( f \\in F_{w,s} \\) as functions \\( M_{f,w,s} : M_s \\rightarrow M_t \\) (where \\( M_{s_1 \\cdots s_n} = M_{s_1} \\times \\cdots \\times M_{s_n} \\)), and of predicate symbols \\( p \\in P_w \\) as relations \\( M_{p,w} \\subseteq M_s \\). The universe universe(\\( M \\)) is \\( M_U \\). The symbols are interpreted as elements in their corresponding domains:\n\n\\[\n\\text{domain(sort, } Y) = \\{ X \\mid X \\subseteq Y \\} \\\\\n\\text{domain(fun, } Y) = \\{ f : Y^n \\rightarrow Y \\mid n \\in \\mathbb{N} \\} \\\\\n\\text{domain(pred, } Y) = \\{ p \\subseteq Y^n \\mid n \\in \\mathbb{N} \\}\n\\]\n\nThe remaining components are defined similarly as for FOL.\n\n\\[\\text{Example 10} \\] Models \\( M \\) of HOL are higher-order structures, consisting of a universe \\( M_U \\), a carrier set \\( M_t \\subseteq M_U \\) for each sort type \\( t \\in S^\\rightarrow \\) with \\( M_{B_{\\text{bool}}} = \\{ \\top, \\bot \\} \\) and \\( M_{n_1 \\rightarrow n_2} \\subseteq M_{n_1} \\rightarrow M_{n_2} \\), an interpretation of constants \\( f \\in F_t \\) as elements \\( M_f \\in M_t \\). The universe universe(\\( M \\)) is \\( M_U \\). The symbols are interpreted as elements in their corresponding domains:\n\n\\[\n\\text{domain(sort, } Y) = \\{ X \\mid X \\subseteq Y \\} \\\\\n\\text{domain(const, } Y) = Y\n\\]\n\nThe remaining components are defined similarly as for FOL.\n\n\\[\\text{Example 11} \\] A model \\( M \\) of a relational database scheme signature \\( T \\) interprets each table declaration of the form \\( t(f_1 : d_1, \\ldots, f_n : d_n) \\) as a relation \\( M(t) \\subseteq I(d_1) \\times \\cdots \\times I(d_n) \\)\n\nThe universe consists of the (fixed) interpretation of all datatypes:\n\n\\[\nM_U = \\bigcup_{d \\in D} I(d)\n\\]\n\nA link \\( t_1[f] \\rightarrow t_2[g] \\) many_to_one (resp. one_to_one) is satisfied in a model \\( M \\) if for each element \\( (a_1, \\ldots, a_n) \\in \\)\n\n\\[\\text{15} \\] Normally, MSFOL models do not feature such a universe. However, for our technical results, having a universe is needed, and it does not change the logic essentially: given a standard many-sorted model, it is always possible to let \\( M_U \\) be the union of all carrier sets.\n\n\\[\\text{16} \\] Normally, HOL models do not feature such a universe, but the same remark as for MSFOL applies.\ndomain(table, X) = \\{R \\subseteq X^n \\mid n \\in \\mathbb{N}\\}\n\nModels are ordered by inclusion of all table interpretations; such a partial order gives a category of models.\n\nThe reduct of a model along a signature morphism \\(\\varphi\\) has the same carrier set as the original model and interprets a table \\(x\\) in the same way as \\(\\varphi(x)\\) is interpreted in the original model. For a signature \\(T\\) and a \\(T\\)-model \\(M\\), the interpretation \\(\\text{sym}(\\Sigma, M, s)\\) of a symbol \\(s = (\\text{table}, t)\\) where \\(t\\) is a name, is defined to be \\(M(t)\\).\n\nA logic combines then a logic syntax with a model theory for it:\n\n**Definition 4** A logic consists of a logic syntax \\(L\\) and a model theory for \\(L\\).\n\nNotice that we follow a model-theoretic approach to logics, where the central role is played by the satisfaction relation between models and sentences. It is possible to further extend the concept of logic with a provability relation, but this is not needed for our purposes. Moreover, our concept of logic extends the well-known concept of institution [29], defined below, with additional elements that allow one to speak about the symbols of a signature and with the condition that models are interpreted over a set.\n\n**Definition 5** \\(\\mathcal{I} = (\\text{Sign}^T, \\text{Sen}^T, \\text{Mod}^T, \\models^T)\\) is called an institution if it consists of\n\n- a category \\(\\text{Sign}^T\\) of signatures,\n- a functor \\(\\text{Sen}^T\\) : \\(\\text{Sign}^T \\rightarrow \\text{Set}\\) giving, for each signature \\(\\Sigma\\), the set of sentences \\(\\text{Sen}^T(\\Sigma)\\), and for each signature morphism \\(\\sigma : \\Sigma \\rightarrow \\Sigma'\\), the sentence translation map \\(\\text{Sen}^T(\\sigma) : \\text{Sen}^T(\\Sigma) \\rightarrow \\text{Sen}^T(\\Sigma')\\), where often \\(\\text{Sen}^T(\\sigma)(e)\\) is written as \\(\\sigma(e)\\),\n- a functor \\(\\text{Mod}^T\\) : \\((\\text{Sign}^T)^{ob} \\rightarrow \\text{Cat}\\) giving, for each signature \\(\\Sigma\\), the category of its models \\(\\text{Mod}^T(\\Sigma)\\), and for each morphism \\(\\sigma : \\Sigma \\rightarrow \\Sigma'\\), the reduct functor \\(\\text{Mod}^T(\\sigma) : \\text{Mod}^T(\\Sigma') \\rightarrow \\text{Mod}^T(\\Sigma)\\), where often \\(\\text{Mod}^T(\\sigma)(M')\\) is written as \\(M'|\\sigma\\),\n- for each \\(\\Sigma \\in \\text{Sign}^I\\), a satisfaction relation\n\n\\[ \\models^T : \\Sigma \\subseteq |\\text{Mod}^T(\\Sigma)| \\times \\text{Sen}^T(\\Sigma) \\]\n\nsuch that for each \\(\\sigma : \\Sigma \\rightarrow \\Sigma'\\) in \\(\\text{Sign}^T\\) the satisfaction condition holds:\n\n\\[ M' \\models^T \\sigma(e) \\iff M'|\\sigma \\models^T e \\]\n\nfor each \\(M' \\in |\\text{Mod}^T(\\Sigma')|\\) and \\(e \\in \\text{Sen}^T(\\Sigma)\\).\n\nWe can easily obtain an institution underlying a logic.\n\n**Definition 6** Given a logic \\(L\\), we obtain the institution of \\(L\\), \\(\\text{Inst}(L) = (\\text{Sign}, \\text{Sen}, \\text{Mod}, \\models)\\), by extracting the corresponding components from the logic syntax and the model theory of \\(L\\).\n\nThis allows us, in the rest of this section, to recall a number of concepts defined over an arbitrary institution and regard them as concepts over an arbitrary logic, in the sense of Definition 4.\n\nIn the following, if \\(L_i\\) is a logic, we will use the subscript \\(i\\), for its constituents.\n\nWe want to speak of subsignatures, make use of unions of signatures, etc. Note that such set-theoretic terms are not available in an arbitrary (signature) category: there, we just have objects (aka signatures) and morphisms. To define subsignatures and signature unions formally, we must extend the notion of institution by requiring the signature category to be inclusive. Informally, this means that we mark some of the morphisms of the signature category to be inclusions. These inclusions then form a partial order, which can be construed as a subcategory having the same objects as the whole signature category, but just fewer morphisms. The effect is that in an inclusive signature category, we can use the usual set-theoretic terms like: subsignature or union. This is formalised as follows:\n\n**Definition 7** An inclusive category [31] is a category having a broad subcategory whose arrows are called inclusions, which is a partially ordered class with a least element (denoted \\(\\emptyset\\)), finite infima (categorically: products) and suprema (categorically: coproducts), called intersection (denoted \\(\\cap\\)) and union (denoted \\(\\cup\\)) such that for each pair of objects \\(A, B\\), \\(A \\cup B\\) is a pushout of \\(A \\cap B\\) in the category.\n\nFor any objects \\(A\\) and \\(B\\) of an inclusive category, we write \\(A \\subseteq B\\) if there is an inclusion from \\(A\\) to \\(B\\); the unique such inclusion will then be denoted by \\(\\iota_{A \\subseteq B} : A \\hookrightarrow B\\), or simply \\(A \\hookrightarrow B\\). A functor between two inclusive categories is inclusive if it takes inclusions in the source category to inclusions in the target category. An inclusive category has pushouts which preserve inclusions iff there exists a pushout.\n\n\\[\\text{Sign}^T\\]\n\n\\[\\Sigma\\]\n\n\\[\\text{Sen}^T\\]\n\n\\[\\text{Mod}^T\\]\n\n\\[\\models^T\\]\n\n\\[M' \\models^T \\sigma(e) \\iff M'|\\sigma \\models^T e\\]\n\n\\[\\text{Inst}(L) = (\\text{Sign}, \\text{Sen}, \\text{Mod}, \\models)\\]\n\n\\[\\text{Incl}\\]\n\n\\[\\subseteq\\]\n\n\\[\\cup\\]\n\n\\[\\cap\\]\n\n\\[\\iota_{A \\subseteq B}\n\n\\[A \\hookrightarrow B\\]\n\n\\[A \\hookrightarrow B\\]\n\n\\[\\text{Sign}^T\\]\n\n\\[\\Sigma\\]\n\n\\[\\text{Sen}^T\\]\n\n\\[\\text{Mod}^T\\]\n\n\\[\\models^T\\]\n\n\\[M' \\models^T \\sigma(e) \\iff M'|\\sigma \\models^T e\\]\n\n\\[\\text{Inst}(L) = (\\text{Sign}, \\text{Sen}, \\text{Mod}, \\models)\\]\n\n\\[\\text{Incl}\\]\n\n\\[\\subseteq\\]\n\n\\[\\cup\\]\n\n\\[\\cap\\]\n\n\\[\\iota_{A \\subseteq B}\n\n\\[A \\hookrightarrow B\\]\n\n\\[A \\hookrightarrow B\\]\nA \\xleftarrow{c} A' \\xrightarrow{c} B' \\xleftarrow{c} B'' \n\nfor each span where one arrow is an inclusion.\n\n**Definition 8** An institution is **inclusive** if\n\n- \\( \\text{Sign} \\) is inclusive and has pushouts which preserve inclusions,\n- \\( \\text{Sen} \\) is inclusive and preserves intersections,\\(^{18} \\) and\n- each model category is inclusive, and reduct functors are inclusive. \\( \\square \\)\n\nIf \\( \\mathcal{I} \\) is an inclusive institution and \\( \\Sigma \\subseteq \\Sigma' \\) is an inclusion of signatures, we write \\( M'|\\Sigma \\) for the reduct of a \\( \\Sigma' \\)-model \\( M' \\) along the inclusion \\( \\iota: \\Sigma \\subseteq \\Sigma' \\). Also since in such a case \\( \\text{Sen}(\\iota: \\Sigma \\subseteq \\Sigma') \\) is just the set-theoretic inclusion, we omit its application.\n\nIn the following, let \\( \\mathcal{I} \\) be an inclusive institution. A theory morphism (also called an ontology morphism) \\( \\sigma: (\\Sigma_1, E_1) \\to (\\Sigma_2, E_2) \\) is a signature morphism \\( \\sigma: \\Sigma_1 \\to \\Sigma_2 \\) such that \\( \\sigma(E_1) \\) is a logical consequence of \\( E_2 \\). If \\( O = (\\Sigma, \\Delta) \\) is a theory (ontology), we will use the notation \\( \\text{Sig}(O) \\) for \\( \\Sigma \\). A model of a theory \\( (\\Sigma, E) \\) is a \\( \\Sigma \\)-model that satisfies all sentences in \\( E \\). The class of all models of an theory will be denoted \\( \\text{Mod}(O) \\).\n\n**Definition 9** (**Institution of theories**) Given an institution \\( \\mathcal{I} \\), we define the **institution of \\( I \\)-theories**, denoted \\( \\mathcal{I}^h = (\\text{Sign}^h, \\text{Sen}^h, \\text{Mod}^h, \\models^h) \\) as follows:\n\n- \\( \\text{Sign}^h \\) has as objects all \\( \\mathcal{I} \\)-theories and as arrows \\( \\mathcal{I} \\)-theory morphisms;\n- for a theory \\( (\\Sigma, E) \\), \\( \\text{Mod}^h(\\Sigma, E) \\) consists of all \\( \\Sigma \\)-models that satisfy \\( E \\);\n- for each theory \\( (\\Sigma, E) \\), each \\( (\\Sigma, E) \\)-model \\( M \\) and each \\( \\Sigma \\)-sentence \\( e \\), \\( \\text{Sen}^h(\\Sigma, E) = \\text{Sen}^\\mathcal{I}(\\Sigma) \\) and \\( M \\models^h(\\Sigma, E) e \\leftrightarrow M \\models^\\mathcal{I} e \\). \\( \\square \\)\n\nThe construction of the institution of \\( \\mathcal{I} \\)-theories can be generalised to obtain the logic of \\( L \\)-theories for a logic \\( L \\), denoted \\( L^h \\).\n\n“Given a species of structure, say widgets, then the result of interconnecting a system of widgets to form a super-widget corresponds to taking the colimit of the diagram of widgets in which the morphisms show how they are interconnected.” J. Goguen \\([28]\\)\n\n\\[^{18}\\text{That is, for each family of signatures } \\Sigma \\subseteq [\\text{Sign}], \\text{we have that } \\text{Sen}(\\Sigma) = \\bigcap_{\\Sigma \\subseteq \\Sigma'} \\text{Sen}(\\Sigma).\\]\n\n\\[^{19}\\text{Actually, here we only need the existence of an initial (“empty”) signature.}\\]\n**Definition 13** Let $I_1$ and $I_2$ be two institutions. An institution comorphism $(\\phi, \\alpha, \\beta) : I_1 \\to I_2$ consists of a functor $\\phi : \\text{Sign}_1 \\to \\text{Sign}_2$, a natural transformation $\\beta : \\phi; \\text{Mod}_2 \\Rightarrow \\text{Mod}_1$ and a natural transformation $\\alpha : \\text{Sen}_1 \\Rightarrow \\phi; \\text{Sen}_2$ such that the following satisfaction condition holds for each $\\Sigma \\in |\\text{Sign}_1|$, $M' \\in |\\text{Mod}_2(\\phi(\\Sigma))|$ and $e \\in \\text{Sen}_1(\\Sigma)$:\n\n\\[\n\\beta_\\Sigma(M') \\models_\\Sigma e \\iff M' \\models_\\phi(\\Sigma) \\alpha_\\Sigma(e)\n\\]\n\n\\[\\Box\\]\n\nNaturality of $\\alpha$ and $\\beta$ means that for each signature morphism $\\sigma : \\Sigma_1 \\to \\Sigma_2$ in $I_1$, the following diagrams commute:\n\n\\[\n\\begin{array}{c}\n\\text{Sen}^{T_1}(\\Sigma_1) \\\\\n\\downarrow \\alpha_{\\Sigma_1} \\\\\n\\text{Sen}^{T_2}(\\Phi(\\Sigma_1)) \\\\\n\\text{Sen}^{T_2}(\\Phi(\\sigma)) \\\\\n\\end{array}\n\\begin{array}{c}\n\\text{Sen}^{T_2}(\\Sigma_2) \\\\\n\\downarrow \\alpha_{\\Sigma_2} \\\\\n\\text{Sen}^{T_2}(\\Phi(\\Sigma_2)) \\\\\n\\text{Sen}^{T_2}(\\Phi(\\sigma)) \\\\\n\\end{array}\n\\]\n\n\\[\n\\begin{array}{c}\n\\text{Mod}^{T_2}(\\Phi(\\Sigma_2)) \\\\\n\\downarrow \\beta_{\\Sigma_2} \\\\\n\\text{Mod}^{T_1}(\\Sigma_2) \\\\\n\\text{Mod}^{T_2}(\\Phi(\\sigma)) \\\\\n\\end{array}\n\\begin{array}{c}\n\\text{Mod}^{T_2}(\\Phi(\\Sigma_1)) \\\\\n\\downarrow \\beta_{\\Sigma_1} \\\\\n\\text{Mod}^{T_1}(\\Sigma_1) \\\\\n\\text{Mod}^{T_2}(\\Phi(\\sigma)) \\\\\n\\end{array}\n\\]\n\n**Example 12** The standard translation of $\\text{ALC}$ to $\\text{FOL}$ defined in [1] is an institution comorphism. Each $\\text{ALC}$ signature $(\\Delta, \\mathcal{R}, \\mathcal{I})$ is translated to the first-order signature $\\Phi(\\Delta, \\mathcal{R}, \\mathcal{I}) = (F, P)$ where $F$ contains all elements of $\\mathcal{I}$ as function symbols of arity 0 and $P$ contains all elements of $\\Delta$ as predicate symbols of arity 1 and all elements of $\\mathcal{R}$ as predicate symbols of arity 2. Given an $\\text{ALC}$ signature $(\\Delta, \\mathcal{R}, \\mathcal{I})$, we define the translation $\\alpha_\\Sigma$ of $(\\Delta, \\mathcal{R}, \\mathcal{I})$-concepts to $\\Phi(\\Delta, \\mathcal{R}, \\mathcal{I})$-formulas with a free variable $x$ as follows:\n\n- each atomic concept $A \\in \\Delta$ is translated to $A(x)$\n- $\\top$ is translated to $\\text{True}$, and $\\bot$ is translated to $\\text{False}$,\n- $\\neg C$ is translated to $\\neg\\alpha_\\Sigma(C)$,\n- $C_1 \\cap C_2$ to $\\alpha_\\Sigma(C_1) \\land \\alpha_\\Sigma(C_2)$,\n- $\\exists R.C$ is translated to $\\exists y.\\alpha_\\Sigma(C) \\land R(x, y)$\n- $\\forall R.C$ is translated to $\\forall y.\\alpha_\\Sigma(C) \\land R(x, y)$\n\nFor an $\\text{ALC}$ signature $(\\Delta, \\mathcal{R}, \\mathcal{I})$, its sentences are translated as follows:\n\n- $C_1 \\subseteq C_2$ becomes $\\forall x.\\alpha_\\Sigma(C_1) \\implies \\alpha_\\Sigma(C_2)$,\n- $a \\in C$ becomes $\\alpha_\\Sigma(C)[a/x]$,\n- $R(a, b)$ becomes $\\alpha_\\Sigma(C)$\n\nGiven an $\\text{ALC}$ signature $(\\Delta, \\mathcal{R}, \\mathcal{I})$ and a $\\Phi(\\Delta, \\mathcal{R}, \\mathcal{I})$-model $N$, we define its reduct to an $(\\Delta, \\mathcal{R}, \\mathcal{I})$-model $M = (\\Delta^I, \\mathcal{R}^I, \\mathcal{I}^I)$ by taking $\\Delta^I$ to be the carrier $\\mathcal{N}^I$ and $\\Delta^I = \\mathcal{N}^I$ for each $A \\in \\Delta$, which is a unary predicate on $\\Delta$, $\\Delta^I = \\mathcal{N}^I$ for each $R \\in \\mathcal{R}$, which is a binary predicate on $\\Delta$ and $i^I = \\mathcal{I}^I$ for each $i \\in I$, which is an element of $\\Delta$. It is easy to see that the satisfaction condition holds.\n\n**Example 13** The comorphism from $\\text{ALC}$ to $\\text{FOL}$ defined in the previous example generalises to a comorphism from $\\text{SROIQ}$ to $\\text{FOL}$. Details can be found in [1].\n\n**Example 14** [6] We can define a comorphism from $\\text{MSFOL}$ to $\\text{HOL}$. Each $\\text{MSFOL}$ signature $(F, P)$ is mapped to the HOL signature $(S, \\mathcal{F}, \\mathcal{P})$ where $\\mathcal{F}_i = \\mathcal{F}_{i}$ if $i$ is of the form $s_1 \\rightarrow \\cdots \\rightarrow s_n \\rightarrow s$ and $\\mathcal{F}_i = \\mathcal{F}_n$ if $i$ is of the form $s_1 \\rightarrow \\cdots \\rightarrow s_n \\rightarrow \\text{Bool}$, where $s, s_1, \\ldots, s_n \\in S$. The sentence translation $\\alpha_{\\Sigma(F, P)}$ takes\n\n- a predication $p(t_1, \\ldots, t_n)$ to the atomic sentence $p(t_1, \\ldots, t_n) = \\text{Bool True}$\n- an equation $t_1 = t_2$ to $t_1 = t_2$, where $s$ is the sort of the terms $t_1$ and $t_2$,\n- the negation $\\neg \\Phi$ of a formula $\\Phi$ to $\\neg \\alpha_{\\Sigma(F, P)}(\\Phi)$,\n- a conjunction $\\Phi_1 \\land \\Phi_2$ of two formulas $\\Phi_1$ and $\\Phi_2$ to $\\alpha_{\\Sigma(F, P)}(\\Phi_1) \\land \\alpha_{\\Sigma(F, P)}(\\Phi_2)$,\n- a quantification $\\forall x_1 : s_1, \\ldots, x_n : s_n. \\Phi$ to $\\Pi_x(\\lambda x_1 : s_1, \\ldots, \\lambda x_n : s_n. \\alpha_{\\Sigma(F, P)(\\Phi)}(x_1, \\ldots, x_n))$\nDefinition 14 (Logic translation) Let \\( L_1 \\) and \\( L_2 \\) be two logics. A logic translation from \\( L_1 \\) to \\( L_2 \\) consists of\n\n- an institution comorphism \\((\\Phi, \\alpha, \\beta) : \\text{Inst}(L_1) \\rightarrow \\text{Inst}(L_2)\\),\n- a function \\( \\kappa : \\text{Kinds}_1 \\rightarrow \\text{Kinds}_2 \\)\n- a function \\( \\gamma : \\text{Symbols}_1 \\rightarrow \\text{Symbols}_2 \\), that for each signature \\( \\Sigma \\in [\\text{Sign}_1] \\) restricts to\n \\[ \\gamma_\\Sigma : \\text{Sym}_1(\\Sigma) \\rightarrow \\text{Sym}_2(\\Sigma) \\]\n\nsuch that the following compatibility conditions hold:\n\n- for each \\( s \\in \\text{Symbols}_1 \\),\n \\[ \\text{kind}_2(\\gamma(s)) = \\kappa(\\text{kind}_1(s)) \\]\n- for each \\( \\sigma : \\Sigma \\rightarrow \\Sigma' \\) and each \\( s \\in \\text{Sym}_1(\\Sigma) \\),\n \\[ \\gamma(\\text{Sym}_1(\\sigma)(s)) = \\text{Sym}_2(\\Phi(\\sigma))(\\gamma(s)) \\]\n- for each \\( k \\in \\text{Kinds}_1 \\) and each \\( \\Sigma \\in [\\text{Set}] \\),\n \\[ \\text{domain}_2(\\kappa(k), \\Sigma) = \\text{domain}_1(k, \\Sigma) \\]\n\nExample 16 The institution comorphism from MSFOL to HOL (see Example 14) can be extended to a logic translation as follows:\n\n- \\( \\kappa(sort) = sort, \\kappa(fun) = const, \\kappa(pred) = const \\)\n- for each name \\( n \\),\n - \\( \\gamma(sort, s) = (sort, s) \\),\n - \\( \\gamma(fun, f, s_1 \\times \\cdots \\times s_n \\rightarrow s) = (const, f, s_1 \\rightarrow \\cdots \\rightarrow s_n \\rightarrow s) \\),\n - \\( \\gamma(pred, p, s_1 \\times \\cdots \\times s_n) = (const, p, s_1 \\rightarrow \\cdots \\rightarrow s_n \\rightarrow \\text{Bool}) \\).\n\nWith obvious identities and composition, logics and logic translations form a category named Logic.\n\n2.3 Relativisation of Ontologies\n\nThe general idea of relativisation of ontologies is that we can encode the universe of a model as a predicate that is interpreted as a subset of a larger set, which is the global universe. Relativisations have previously been used in defining Common Logic modules [67], in the reencoding of DDL into OWL [15], or to translate between possibilist and actualist quantification in modal logic [23,46] or in free logic [52]. They are generally a well-known tool in mathematical logic used in a variety of contexts [11,73].\n\nWe introduce some notation needed for relativisation. Let \\( L \\) be a logic. With \\( L^{\\text{discrete}} \\), we denote the discrete sublogic of \\( L \\). It differs from \\( L \\) only by that it has just identities as signature morphisms. For a logic translation \\( \\rho = (\\Phi, \\alpha, \\beta) : L_1 \\rightarrow L_2^{\\text{th}} \\) and a \\( L_1 \\) ontology \\( O = (\\Sigma, \\Delta) \\), if \\( \\Phi(\\Sigma) = (\\Sigma', \\Delta') \\) we let\n\n\\[\n\\rho(O) = (\\Sigma', \\Delta' \\cup [\\alpha_\\Sigma(\\delta) \\mid \\delta \\in \\Delta]).\n\\]\n\nWe will also need to introduce a unary predicate for the top concept of an ontology already when doing its relativisation. To do that, we must assume existence of predicates as symbols.\n\nDefinition 17 Let \\( L \\) be a logic. We say that \\( L \\) admits unary and binary predicates if it has two designated kinds \\( \\text{unaryPred} \\) and \\( \\text{binaryPred} \\). The unary predicates of \\( L \\), denoted \\( \\text{unary}_L \\), are all symbols \\( s \\in \\text{Symbols} \\) of kind \\( \\text{unaryPred} \\) and arity 1. The binary predicates of \\( L \\), denoted\n\n\\[ \\text{SROIQ} \\]\n\n\\[ \\text{FOL} \\]\n\n\\[ \\Lth \\]\n\n\\[ \\text{Mod}_2(\\Phi(\\Sigma)) \\]\n\n\\[ \\text{universe}^{\\Phi(\\Sigma)}_2(M') = \\text{universe}^{\\Phi(\\Sigma)}_2(\\beta(\\Sigma')(M')) \\]\n\nExample 15 The institution comorphisms from ALC to FOL (see Example 12) and from SROIQ to FOL (see Example 13) can be extended to logic translations as follows:\n\n- \\( \\kappa(\\text{concept}) = \\text{pred}, \\kappa(\\text{role}) = \\text{pred}, \\kappa(\\text{individual}) = \\text{fun} \\)\n- for each name \\( n \\),\n - \\( \\gamma(\\text{concept}, n) = (\\text{pred}, n, 1) \\),\n - \\( \\gamma(\\text{role}, n) = (\\text{pred}, n, 2) \\), and\n - \\( \\gamma(\\text{individual}, n) = (\\text{fun}, n, 0) \\).\n\n\\[ \\kappa(\\text{sort}) = \\text{sort}, \\kappa(\\text{fun}) = \\text{const}, \\kappa(\\text{pred}) = \\text{const} \\]\n\n\\[ \\gamma(\\text{sort}, s) = (\\text{sort}, s), \\]\n\n\\[ \\gamma(\\text{fun}, f, s_1 \\times \\cdots \\times s_n \\rightarrow s) = (\\text{const}, f, s_1 \\rightarrow \\cdots \\rightarrow s_n \\rightarrow s) \\],\n\n\\[ \\gamma(\\text{pred}, p, s_1 \\times \\cdots \\times s_n) = (\\text{const}, p, s_1 \\rightarrow \\cdots \\rightarrow s_n \\rightarrow \\text{Bool}) \\).\n\n\\[ \\rho(O) = (\\Sigma', \\Delta' \\cup [\\alpha_\\Sigma(\\delta) \\mid \\delta \\in \\Delta]). \\]\n\n\\[ \\text{SROIQ} \\]\n\n\\[ \\text{unaryPred} \\]\n\n\\[ \\text{pred} \\]\n\n\\[ \\text{unary}_L \\]\n\n\\[ \\text{unaryPred} \\]\n\n\\[ \\text{binaryPred} \\]\n\n\\[ \\text{FOL} \\]\n\n\\[ \\Lth \\]\n\n\\[ \\text{universe}^{\\Phi(\\Sigma)}_2(M') = \\text{universe}^{\\Phi(\\Sigma)}_2(\\beta(\\Sigma')(M')) \\]\n\n\\[ \\kappa(\\text{sort}) = \\text{sort}, \\kappa(\\text{fun}) = \\text{const}, \\kappa(\\text{pred}) = \\text{const} \\]\n\n\\[ \\gamma(\\text{sort}, s) = (\\text{sort}, s), \\]\n\n\\[ \\gamma(\\text{fun}, f, s_1 \\times \\cdots \\times s_n \\rightarrow s) = (\\text{const}, f, s_1 \\rightarrow \\cdots \\rightarrow s_n \\rightarrow s), \\]\n\n\\[ \\gamma(\\text{pred}, p, s_1 \\times \\cdots \\times s_n) = (\\text{const}, p, s_1 \\rightarrow \\cdots \\rightarrow s_n \\rightarrow \\text{Bool}). \\]\n\n\\[ \\rho(O) = (\\Sigma', \\Delta' \\cup [\\alpha_\\Sigma(\\delta) \\mid \\delta \\in \\Delta]). \\]\n\n\\[ \\text{SROIQ} \\]\n\n\\[ \\text{unaryPred} \\]\n\n\\[ \\text{pred} \\]\n\n\\[ \\text{unary}_L \\]\n\n\\[ \\text{unaryPred} \\]\n\n\\[ \\text{binaryPred} \\]\n\n\\[ \\text{FOL} \\]\n\n\\[ \\Lth \\]\n\n\\[ \\text{universe}^{\\Phi(\\Sigma)}_2(M') = \\text{universe}^{\\Phi(\\Sigma)}_2(\\beta(\\Sigma')(M')) \\]\nbinary_{L}, are all symbols \\( s \\in \\text{Symbols} \\) of kind binary_{Pred} and arity 2.\n\n\\[ \\text{Example 17} \\quad \\text{ALC admits predicates: unary_{Pred} is concept and binary_{Pred} is role.} \\]\n\n\\[ \\text{Example 18} \\quad \\text{In FOL both unary_{Pred} and binary_{Pred} are of the kind \\text{pred}.} \\]\n\nIn the following we will assume that all logics admit predicates.\n\n**Definition 18 (Relativisation)** A logic translation that preserves interpretation of symbols\n\n\\[ \\text{rel} = (\\Phi, \\alpha, \\beta, \\kappa, \\gamma) : L_{\\text{discrete}} \\rightarrow L_{\\text{th}} \\]\n\nis a relativisation of ontologies in \\( L \\) if (1) for each signature \\( \\Sigma \\) in \\( \\text{Inst}(L) \\),\n\n\\[ \\text{Symbols}(\\text{Sig}(\\Phi(\\Sigma))) = \\text{Symbols}(\\Sigma) \\cup \\{ \\text{top} \\} \\]\n\nwhere \\( \\text{top} \\in \\text{unary}_{L} \\), (2) for each signature \\( \\Sigma \\) and each \\( \\Phi(\\Sigma) \\)-model \\( M, M_{up} = \\text{universe}(\\beta_{\\Sigma}(M)) \\), and (3) the following amalgamation property holds: For any two \\( L \\)-ontologies \\( O_{1} = (\\Sigma_{1}, \\Delta_{1}) \\) and \\( O_{2} = (\\Sigma_{2}, \\Delta_{2}) \\),\n\n\\[ L_{\\text{discrete}} \\quad L_{\\text{th}} \\]\n\n\\[ O_{1} \\xrightarrow{\\text{rel}} \\text{rel}(O_{1}) \\xrightarrow{\\sigma_{1}} O_{1}' \\subseteq O_{1}' \\cup O_{2}' \\]\n\n\\[ O_{2} \\xrightarrow{\\text{rel}} \\text{rel}(O_{2}) \\xrightarrow{\\sigma_{2}} O_{2}' \\subseteq O_{1}' \\cup O_{2}' \\]\n\nif \\( O_{i}' \\) is the theory obtained by renaming \\( \\text{top} \\) along \\( \\sigma_{i} \\) to \\( O_{i} : \\text{top} \\), for \\( i = 1, 2 \\), then for any two models \\( M_{1} \\) of \\( O_{1} \\) and \\( M_{2} \\) of \\( O_{2} \\) and any set \\( U \\) that includes universe(\\( M_{1} \\)) and universe(\\( M_{2} \\)), there exists a unique model \\( M \\) of \\( O_{1}' \\cup O_{2}' \\) with universe(\\( M \\)) = \\( U \\) and such that, if \\( N^{i} = (M|_{\\text{Sig}(\\text{rel}(O_{i}))})_{\\sigma_{i}} \\), for \\( i = 1, 2 \\), then \\( \\beta_{\\Sigma_{1}}(N^{i}) = M^{i} \\).\n\nThe first condition ensures that a correspondence between two ontologies \\( O_{1} \\) and \\( O_{2} \\) in \\( L \\) is also a correspondence between their relativisations \\( \\text{rel}(O_{1}) \\) and \\( \\text{rel}(O_{2}) \\). The relativisation translation does not preserve universes of models. Note that it is possible to define more than one relativisation for a logic.\\(^{23}\\)\n\n\\[ \\text{Example 19} \\quad \\text{(Relativisation in SROIQ)} \\]\n\n\\[ \\text{rel}_{\\text{SROIQ}} : \\text{SROIQ}_{\\text{discrete}} \\rightarrow \\text{SROIQ}_{\\text{th}} \\]\n\nLet \\( \\Sigma = (A, R, I) \\) be a SROIQ signature. We define \\( \\Phi(\\Sigma) = ((A \\cup \\{ \\text{top} \\}, R, I), E) \\) where \\( E \\) contains the following axioms:\n\n- each occurrence of \\( \\top \\) is replaced by \\( \\text{top} \\), and\n- each concept \\( \\neg C \\) replaced by \\( \\text{top} \\cap \\neg C \\)\n- each concept \\( \\forall R.C \\) is replaced by \\( \\text{top} \\cap \\forall R.C \\).\n- each role has its domain and range, if present, intersected with \\( \\text{top} \\).\n\nSince the empty concept \\( \\bot \\) is interpreted, independently of the universe of the model, as the empty set, no replacement must be done in its case. For existential restrictions, no relativisation is needed, because the domain and the range have already been restricted accordingly when making their intersection with \\( \\text{top} \\).\n\nThe model reduct \\( \\beta_{\\Sigma} : \\text{Mod}(\\Phi(\\Sigma)) \\rightarrow \\text{Mod}(\\Sigma) \\) takes each model \\( M' = (U', I') \\) of \\( \\Phi(\\Sigma) \\) to the model \\( (U, I) \\) of \\( \\Sigma \\), where \\( U = \\text{top} \\) (the universe of the reduct is given by the interpretation of \\( \\text{top} \\) in \\( M' \\)) and each concept of \\( \\Sigma \\) is interpreted as in \\( M' \\). The axioms of \\( \\Phi(\\Sigma) \\) ensure that the definition is correct.\n\nIt is easy to show that the satisfaction condition holds.\n\nMoreover, if \\( O_{i} = (\\Sigma_{i}, E_{i}) \\) and \\( M^{i} \\) is a model of \\( O_{i} \\), for \\( i = 1, 2 \\), and \\( U \\) is a set that includes the universes of \\( M_{1} \\) and \\( M_{2} \\), we obtain a model \\( M \\) of the union of the relativisations of \\( O_{1} \\) and \\( O_{2} \\) by defining its universe to be the set \\( U, O_{i} : \\top \\) is interpreted as the universe of \\( M_{i} \\) for \\( i = 1, 2 \\) and each concept is interpreted as in \\( M_{1} \\) if it comes from \\( \\Sigma_{1} \\) or as in \\( M_{2} \\) if it comes from \\( \\Sigma_{2} \\).\n\n\\( \\kappa \\) and \\( \\gamma \\) are both identities.\n\n\\[ \\text{Example 20} \\quad \\text{(Relativisation in FOL)} \\]\n\n\\[ \\text{rel}_{\\text{FOL}} : \\text{FOL}_{\\text{discrete}} \\rightarrow \\text{FOL}_{\\text{th}} \\]\n\nLet \\( (F, P) \\) be a FOL signature. We define \\( \\Phi(F, P) = ((F, P'), E) \\) where \\( P_{1}' = P_{1} \\cup \\{ \\text{top} \\} \\) and \\( P_{n}' = P_{n} \\) for \\( n = 0 \\) or \\( n > 1 \\), and \\( E \\) contains the following axioms:\nfor each \\( c \\in F_0, \\top(c) \\),\n- for each \\( f \\in F_n, \\forall x_1, \\ldots, x_n. \\top(x_1) \\land \\ldots \\land \\top(x_n) \\implies \\top(f(x_1, \\ldots, x_n)) \\),\n- for each \\( p \\in F_n, \\forall x_1, \\ldots, x_n. P(x_1, \\ldots, x_n) \\implies \\top(x_1) \\land \\ldots \\land \\top(x_n) \\).\n\nSentences are translated by relativising quantifiers [73] and for a \\( (F, P) \\)-model \\( M \\) we define \\( N = \\beta_{\\emptyset, F_P}(M) \\) by taking \\( N^f = M_{\\top f} \\), \\( N_f = M_f \\) for each \\( f \\in F \\) and \\( N_p = M_p \\) for each \\( p \\in P \\) and the axioms in \\( \\Phi(F, P) \\) ensure that the definition is well-formed.\n\n\\( \\kappa \\) and \\( \\gamma \\) are both identities. \\( \\square \\)\n\n### 2.4 Heterogeneity\n\nTo deal with the problem of syntactic heterogeneity, i.e. the situation when ontologies expressed in different logical formalisms are aligned, we need a framework that provides principled support for heterogeneous ontologies. Such a framework is given by Grothendieck logics, a concept that adapts Grothendieck institutions [17] to our notion of logic. The idea is to begin with a graph of logics and logic translations, and then to flatten this graph, such that no interaction between logics is made other than those specified via the translations.\n\n**Definition 19** Given an index category \\( \\text{Ind} \\), an indexed logic is a functor \\( \\mathcal{L} : \\text{Ind}^{\\text{op}} \\to \\text{Logic} \\).\n\nIn an indexed logic \\( \\mathcal{L} \\), we use the notations \\( \\mathcal{L}^i \\) for the logic \\( \\mathcal{L}(i) \\) and \\( \\mu_d \\) for the logic translation \\( \\mathcal{L}(d) \\). Their components are marked with the superscript \\( ^i \\) or, respectively, \\( ^d \\). Moreover, the constituents of the logic \\( \\mathcal{L}^\\# \\) will also marked \\( (_\\#)^\\# \\).\n\n**Definition 20** Given an indexed logic \\( \\mathcal{L} : \\text{Ind}^{\\text{op}} \\to \\text{Logic} \\), we define its associated Grothendieck logic \\( \\mathcal{L}^\\# \\) as follows:\n\n\\( \\Phi^\\#(\\Sigma) = \\{ (i, \\Sigma) | i \\in \\text{Ind}, \\Sigma \\text{ a signature in } \\mathcal{L}^i \\}, \\)\n- symbols \\( \\#^\\# = \\{ (i, s) | i \\in \\text{Ind}, s \\in \\text{Symbols}^i \\} \\) and\n- kinds \\( \\#^\\# = \\{ (i, k) | i \\in \\text{Ind}, k \\in \\text{Kinds}^i \\} \\),\n- \\( \\text{sym}^\\#(i, \\Sigma) = \\{ (i, s) | s \\in \\text{sym}^i(\\Sigma) \\} \\),\n- \\( \\text{arity}^\\#(i, s) = \\text{arity}^i(s) \\),\n- \\( \\text{kind}^\\#(i, s) = \\text{kind}^d(s) \\),\n- signature morphisms \\( (d, \\sigma) : (i, \\Sigma_1) \\to (j, \\Sigma_2) \\) consist of a morphism \\( d : j \\to i \\) in \\( \\text{Ind} \\) and a signature morphism \\( \\sigma : \\Phi^d(\\Sigma_1) \\to \\Sigma_2 \\) in \\( \\mathcal{L}^i \\),\n- if \\( (d_1, \\sigma_1) : (i, \\Sigma) \\to (j, \\Sigma') \\) and \\( (d_2, \\sigma_2) : (j, \\Sigma') \\to (k, \\Sigma'') \\), the composition \\( (e, \\sigma) := (d_1, \\sigma_1); (d_2, \\sigma_2) : (i, \\Sigma) \\to (k, \\Sigma'') \\) is obtained by defining \\( e \\) as the composition of \\( d_2 \\) and \\( d_1 \\):\n\n\\[\n\\begin{array}{ccc}\n k & d_2 & j \\\\\n d_1 & i \\\\\n e\n\\end{array}\n\\]\n\nand \\( \\sigma \\) as the composition of \\( \\Phi^{d_2}(\\sigma_1) \\) and \\( \\sigma_2 \\):\n\n\\[\n\\Phi^{d_2}(\\Phi^{d_1}(\\Sigma)) \\xrightarrow{\\Phi^{d_2}(\\sigma_1)} \\Phi^{d_2}(\\Sigma') \\xrightarrow{\\sigma} \\Sigma''\n\\]\n\n- \\( \\text{sym}^\\#(d, \\sigma)(i, s) = (j, \\text{sym}^j(\\sigma)(\\gamma^d(s))) \\)\n- for each signature \\( (i, \\Sigma) \\),\n\n\\[\n\\text{Sen}^\\#(i, \\Sigma) = \\text{Sen}^i(\\Sigma)\n\\]\n\nand\n\n\\[\n\\text{Mod}^\\#(i, \\Sigma) = \\text{Mod}^i(\\Sigma)\n\\]\n\nMoreover, \\( M \\models \\# e \\) iff \\( M \\models^i e \\) for any \\((i, \\Sigma)\\)-model \\( M \\) and any \\((i, \\Sigma)\\)-sentence \\( e \\). For each signature morphism \\( (d, \\sigma) : (i, \\Sigma_1) \\to (j, \\Sigma_2) \\), the sentence translation \\( \\text{Sen}^\\#(d, \\sigma) : \\text{Sen}^i(\\Sigma_1) \\to \\text{Sen}^j(\\Sigma_2) \\) is defined by first translating the sentence along \\( \\mathcal{L}(d) \\) and then along the morphism \\( \\sigma \\):\n\n\\[\n\\begin{array}{ccc}\n \\text{Sen}^i(\\Sigma_1) & \\xrightarrow{\\alpha_{\\Sigma_1}^d} & \\text{Sen}^j(\\Phi^d(\\Sigma_1)) \\\\\n \\xrightarrow{\\text{Sen}^j(\\sigma)} & \\text{Sen}^j(\\Sigma_2)\n\\end{array}\n\\]\n\nThe reduct \\( \\text{Mod}^\\#(d, \\sigma) : \\text{Mod}^i(\\Sigma_2) \\to \\text{Mod}^i(\\Sigma_1) \\) is defined by first reducing along the signature morphism and then along \\( \\mathcal{L}(d) \\):\n\n\\[\n\\begin{array}{ccc}\n \\text{Mod}^i(\\Sigma_2) & \\xrightarrow{\\text{Mod}^i(\\sigma)} & \\text{Mod}^i(\\Phi^d(\\Sigma_1)) \\\\\n \\xrightarrow{\\beta_{\\Sigma_1}^d} & \\text{Mod}^i(\\Sigma_1)\n\\end{array}\n\\]\n\nThat is, sentences, models and satisfaction for a Grothendieck signature \\((i, \\Sigma)\\) are defined component wise, while the sentence and model translations for a Grothendieck signature morphism are obtained by composing the translation given by the inter-institution comorphism with the one given by the intra-institution signature morphism.\n3 Networks of Aligned Ontologies\n\nIn this section we recall networks of aligned ontologies and introduce syntax for them in DOL. Networks of aligned ontologies (here denoted NeO) [20], called distributed systems in [80], consist of a family \\((O_i)_{i \\in Ind}\\) of ontologies over a set of indexes \\(Ind\\) interconnected by a set of alignments \\((A_{ij})_{i,j \\in Ind}\\) between them.\n\n**Definition 21** Let \\(L\\) be a logic syntax. A family of correspondence relations, denoted \\(\\mathcal{R}\\), is a set of relation names, written \\(R\\). Each relation name has assigned a set of its kinds, which are pairs \\((k_1, k_2) \\in \\textbf{Kinds}\\).\n\n**Definition 22** Let \\(L\\) be a logic syntax and let \\(\\mathcal{R}\\) be a family of correspondence relations for \\(L\\). A correspondence is a triple \\((s_1, s_2, R)\\) where \\(s_1, s_2 \\in \\textbf{Symbols}\\) and \\(R \\in \\mathcal{R}\\) such that \\((\\text{kind}(s_1), \\text{kind}(s_2))\\) is in the set of kinds of \\(R\\).\n\n**Definition 23** For two ontologies \\(S, T\\), an alignment between \\(S\\) and \\(T\\) is a set of correspondences\n\\[\n\\{(s^i_1, s^i_2, R^i)\\}_{i=1,...,n}\n\\]\nfor \\(n \\in \\mathbb{N}\\), such that for each \\(i = 1, \\ldots, n\\) we have that \\(s^i_1 \\in \\text{Sym}(\\text{Sig}(S)), s^i_2 \\in \\text{Sym}(\\text{Sig}(T))\\) and \\(R^i \\in \\mathcal{R}\\).\n\n**Example 21** Below are the types of relations that can appear in correspondences between \\(\\textit{ALC}\\) symbols, together with their kinds:\n\n\\[\n\\begin{align*}\n= & \\quad \\{(\\text{concept}, \\text{concept}), (\\text{role}, \\text{role}), (\\text{individual}, \\text{individual})\\} \\\\\n\\perp & \\quad \\{(\\text{concept}, \\text{concept}), (\\text{role}, \\text{role}), (\\text{individual}, \\text{individual})\\} \\\\\n< & \\quad \\{(\\text{concept}, \\text{concept}), (\\text{role}, \\text{role})\\} \\\\\n\\in & \\quad \\{(\\text{individual}, \\text{concept})\\} \\\\\n\\exists & \\quad \\{(\\text{concept}, \\text{individual})\\}\n\\end{align*}\n\\]\n\n**Example 22** Similarly, in \\(\\textit{FOL}\\) we have the following correspondences:\n\n\\[\n\\begin{align*}\n= & \\quad \\{(\\text{fun}, \\text{fun}), (\\text{pred}, \\text{pred})\\} \\\\\n\\perp & \\quad \\{(\\text{fun}, \\text{fun}), (\\text{pred}, \\text{pred})\\} \\\\\n< & \\quad \\{(\\text{fun}, \\text{fun}), (\\text{pred}, \\text{pred})\\} \\\\\n> & \\quad \\{(\\text{pred}, \\text{pred})\\}\n\\end{align*}\n\\]\n\nNote that in the literature, correspondences are also equipped with a confidence value between 0 and 1 [20]. We omit these values here (and implicitly assume that they are 1), because our semantics maps correspondences to theories in a two-valued logic. Alternatively, one might set a threshold and keep only those correspondences with confidence above this threshold into our framework. More sophisticated reasoning with confidence values other than 1 would need reasoning about uncertainty, which is beyond the scope of the paper. However, to mention just one way to address this problem within our framework, it is possible to extend the notion of bridge rule in the case of contextualised semantics, as has been proposed in [35,36]. Here, confidence values are internalised into appropriate bridge rule axioms, and the semantics includes ‘fuzzyfied’ connecting relations interpreting these new bridge rule operators. Explicitly studying this version of contextualised semantics for alignments is part of our future work.\n\n3.1 Syntax of DOL Alignments\n\nDOL represents the general alignment format in a similar way to the Alignment API [16] as follows:\n\nalignment \\(A : S \\to T = \\]\n\\[\n\\begin{align*}\n&\\quad s^1_1 \\text{REL}^1 s^1_2, \\ldots, s^n_1 \\text{REL}^n s^n_2 \\\\\n&[\\text{assuming}\\ \\textit{DOMAIN}]\n\\end{align*}\n\\]\n\nwhere\\(^{24}\\)\n\n- \\(S\\) and \\(T\\) are the ontologies to be aligned,\n- \\(s^i_1\\) is the name of an \\(S\\)-symbol, and \\(s^i_2\\) is the name of a \\(T\\)-symbol, for \\(i = 1, \\ldots, n\\),\n- \\(s^i_1 \\text{REL}^i s^i_2\\) is a correspondence which identifies a relation between the ontology symbols, and\n- \\(\\textit{DOMAIN}\\) records the type of semantics used for the alignment, using one of SingleDomain, GlobalDomain, GeneralGlobalDomain and Contextualised Domain. If no assumption about the universe is specified, the default is that simple semantics is used. The terminating \\texttt{end} is also optional.\n\nNote that we only write names of symbols in correspondences instead of symbols. This works only if the names of symbols of different kinds are different, and thus we can uniquely identify a symbol by its name. This holds for some logics. For \\textit{OWL} and its sublogics, it does not hold. Here, symbols must be disambiguated by their kind (individual, class, property) if they are overloaded. Neither does it hold in logics like \\textit{Casl} [65] that allow type overloading, i.e. different symbols with same names, e.g.\\(+\\) for both concatenation of strings and addition on natural numbers. Here, one must use fully typed symbols to avoid ambiguities.\n\n**Example 23** The foundational ontology repository Repository of Ontologies for MULtiple USes (ROMULUS) [45] contains alignments between a number of foundational\n\n\\(^{24}\\) DOL, in accordance with the Alignment API, has further syntax for cardinality of alignments, which however is not relevant here.\nontologies. We present here the alignment of the ontologies DOLCE⁵⁵ and BFO⁵⁶ using DOL syntax.\n\nalignment DOLCELite2BFO:\n<http://www.loa.cnr.it/ontologies/DOLCE-Lite.owl> to <http://www.ifomis.org/bfo/1.1> =\nendurant = IndependentContinuant,\nphysical-endurant = MaterialEntity,\nphysical-object = Object,\nperdurant = Occurrent,\nprocess = Process,\nquality = Quality,\nspatio-temporal-region = SpatiotemporalRegion,\ntemporal-region = TemporalRegion,\nspace-region = SpatialRegion\n\n3.2 Syntax of DOL Networks\n\nThe syntax for specifying networks of alignments (or relational networks of ontologies) in DOL is\n\nnetwork N =\nN₁, ..., Nₘ,\nO₁, ..., Oₙ,\nA₁, ..., Aₖ,\nwhere Nᵢ are (sub-)networks, Oᵢ are ontologies and Aᵢ are alignments (with source and target among the Oᵢ or in the sub-networks Nᵢ). We will generally assume that all alignments used in a DOL network have been specified with the same semantics keyword. (The consideration of DOL networks involving heterogeneous alignment semantics is left for future work.)\n\nThus we can use a DOL network for specifying a NeO, by listing all the ontologies and all the alignments of the NeO as elements of a DOL network. Conversely, any such (i.e. relational) DOL network can be transformed to a NeO by, for each pair of ontologies, uniting multiple alignments or adding the empty alignment if there was none.\n\nDOL provides also a notation for functional networks of ontologies. Here, the ontologies are related by ontology morphisms. The syntax for specifying a functional network of ontologies in DOL is\n\nnetwork N =\nN₁, ..., Nₘ,\nO₁, ..., Oₙ,\nV₁, ..., Vₚ,\nwhere Nᵢ are (sub-)networks, Oᵢ are ontologies, and Vᵢ are ontology morphisms (with source and target among the Oᵢ or in Nᵢ).\n\nFrom a functional network, it is straightforward to obtain a diagram in the sense of Definition 10: one has to assemble all ontologies and ontology morphisms of all included sub-networks into one diagram. The semantics of a functional network is then given by the class of compatible families of models for this diagram. The semantics of relational networks is studied in Sect. 4.\n\nDOL also provides means for combining a functional network into a new ontology, such that the symbols related in the diagram of the DOL network are identified. The syntax of combinations is ontology O = combine D, where D is a functional DOL network, named or specified as above.\n\nThe semantics of a combination O is the class of models of the colimit ontology of the diagram obtained from the functional network. When the underlying institution has the amalgamation property, this model class is in bijection with the class of models of the diagram.\n\nThere is an obvious integration of the concepts of relational and functional network of ontologies into a concept of (general) network of ontologies, which may involve both alignments and ontology morphisms. Actually, DOL provides this most general notion of networks. The semantics of these networks follows easily from those of the relational and functional networks. Note however that it is not clear how to give a semantics to combinations of general networks. This question will be addressed in Sect. 5.\n\nIn the remainder of this paper, if speaking just of a NeO, we will always mean a relational NeO. Functional or general NeOs will be explicitly qualified as such.\n\n4 Four Semantics of Relational Networks of Ontologies\n\nWe will now generalise the three semantics for networks of aligned ontologies introduced in [80] to an arbitrary logic.\n\nA semantics of relational NeOs is given in terms of local interpretation of the ontologies and alignments it consists of. To be able to give such a semantics, one needs to give an interpretation of the relations between symbols that are expressed in the correspondences.\n\nIn the following four subsections let S = {(Oᵢ)ᵢ∈Ind, (Aᵢⱼ)ᵢ,j∈Ind} be a NeO (in any logic) over a set of indexes Ind.\n\n4.1 Simple Semantics\n\nO₁ \\rightarrow O₂ \\rightarrow \\cdots \\rightarrow Oₙ\n\nM₁ \\rightarrow M₂ \\rightarrow \\cdots \\rightarrow Mⁿ\n\nSee http://www.ifomis.org/bfo/.\n\nSee http://www.loa.cnr.it/ontologies/DOLCE.html.\n\nSee http://www.ifomis.org/bfo/.\n\nSpringer\nIn the simple semantics, the assumption is that all ontologies are interpreted over the same universe. This means that a model of \\( S \\) consists of a family of models \\( M^i \\) of \\( O_i \\) for \\( i \\in \\text{Ind} \\), such that \\( \\text{universe}(M^i) = \\text{universe}(M^j) = D \\) for each \\( i, j \\in \\text{Ind} \\) and a certain set \\( D \\). The interpretation of the correspondence relations is given by the following definition.\n\n**Definition 24** Given a model theory for a logic \\( L \\), the interpretation of correspondence relations relative to a set \\( R \\) is an interpretation function \\( J \\) taking as arguments a relation \\( R \\in \\mathcal{R} \\), a kind \\((k_1, k_2)\\) of \\( R \\) and a set \\( X \\) and giving as result a relation \\( R^I_X \\) from domain\\((k_1, X)\\) to domain\\((k_2, X)\\). □\n\nIf \\( O_1, O_2 \\) are two ontologies and \\( c = (s_1, s_2, R) \\) is a correspondence between \\( O_1 \\) and \\( O_2 \\), we say that \\( c \\) is satisfied by the models \\( M^1, M^2 \\) of \\( O_1, O_2 \\), written \\( M^1, M^2 \\models_c \\), if and only if \\( R^1_{D M^2} \\). A model of an alignment \\( A \\) between ontologies \\( O_1 \\) and \\( O_2 \\) is then a pair \\( M^1, M^2 \\) of interpretations of \\( O_1, O_2 \\) such that for all \\( c \\in A \\), \\( M^1, M^2 \\models_c \\). We denote this by \\( M^1, M^2 \\models_A \\). An interpretation of \\( S \\) is a family \\((M^i)_{i \\in \\text{Ind}} \\) of models \\( M^i \\) of \\( O_i \\). A simple interpretation of \\( S \\) is an interpretation \\((M^i)_{i \\in \\text{Ind}} \\) of \\( S \\) over the same universe \\( D \\).\n\n**Definition 25** [80] A simple model of a NeO \\( S \\) is a simple interpretation \\((M^i)_{i \\in \\text{Ind}} \\) of \\( S \\) such that for each \\( i, j \\in I \\), \\( M^i, M^j \\models_{A_{ij}} \\). This is written \\((M^i)_{i \\in \\text{Ind}} \\models S \\). We denote by \\( \\text{Mod}^{\\text{sim}}(S) \\) the class of all simple models of \\( S \\). □\n\n**Example 24** (Interpretation of correspondence relations in SROIQ) The interpretation of correspondence relations in SROIQ relative to a global universe \\( D \\) is given in the table, where on the first column we have the correspondence, on the second the relation that interprets it and on the third its domain of interpretation.\n\n\\[\n\\begin{array}{ll}\n(c_1, c_2, =) & = \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(r_1, r_2, =) & = \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(i_1, i_2, =) & = \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(c_1, c_2, \\subseteq) & \\subseteq \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(r_1, r_2, \\subseteq) & \\subseteq \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(i_1, i_2, \\subseteq) & \\subseteq \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(c_1, c_2, \\supseteq) & \\supseteq \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(r_1, r_2, \\supseteq) & \\supseteq \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(i_1, i_2, \\supseteq) & \\supseteq \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(c_1, c_2, \\not\\subseteq) & \\not\\subseteq \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(r_1, r_2, \\not\\subseteq) & \\not\\subseteq \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n(i_1, i_2, \\not\\subseteq) & \\not\\subseteq \\mathcal{P}(D) \\times \\mathcal{P}(D) \\\\\n\\end{array}\n\\]\n\nAnother possibility is to consider that the universes of interpretation of the ontologies of a NeO may be different, but are mapped into a global universe of interpretation \\( U \\). This mapping is done via a family of equalising functions \\( \\gamma_i : D_i \\rightarrow U \\), where \\( D_i = \\text{universe}(M^i) \\) for ontology \\( O_i \\), for each \\( i \\in \\text{Ind} \\). A relation \\( R \\in \\mathcal{R} \\) is interpreted as a relation \\( R_U \\) on the global universe. The function giving the interpretation of correspondence relations relative to a set is defined as in the case of simple semantics. A correspondence \\( c = (s_1, s_2, R) \\) is satisfied by two models \\( M^1 \\) of \\( O_1 \\) and \\( M^2 \\) of \\( O_2 \\) when \\( \\gamma_1(M^1_i) R^I_U \\gamma_2(M^2_i) \\), denoted by \\( M^1, M^2 \\models_{\\gamma_1, \\gamma_2} c \\). Moreover, \\( M^1, M^2 \\models_{\\gamma_1, \\gamma_2} c \\) for each \\( c \\in A \\).\n\nAn integrated interpretation of a NeO \\( S \\) is then a pair \\( \\{(M^i)_{i \\in \\text{Ind}}, (\\gamma_i)_{i \\in \\text{Ind}}\\} \\) where \\( (M^i)_{i \\in \\text{Ind}} \\) is an interpretation of \\( S \\) and \\( \\gamma_i : \\text{universe}(M^i) \\rightarrow U \\) is a function to a common global universe \\( U \\) for each \\( i \\in \\text{Ind} \\).\n\n**Definition 26** [80] An integrated interpretation of a NeO \\( S \\), \\( \\{(M^i)_{i \\in \\text{Ind}}, (\\gamma_i)_{i \\in \\text{Ind}}\\} \\), is an integrated model of \\( S \\) iff for each \\( i, j \\in \\text{Ind} \\), \\( M^i, M^j \\models_{\\gamma_i, \\gamma_j} A_{ij} \\). □\n\n**Example 26** In SROIQ the correspondence relations are interpreted like in the case of simple semantics, presented in Example 24, but now relative to the global universe \\( U \\). □\n\nIn the sequel, we will distinguish the special case that the \\( \\gamma_i \\) are inclusions as inclusive integrated semantics. Actually, this case will turn out to be technically simpler than general integrated semantics that drops this restriction. General integrated semantics can be useful if different ontologies work...\nwith different assumptions about the identity of individuals. For example in $O_1$, Superman and Clark Kent might be different, while in $O_2$ they are the same person. The universe $U$ of an integrated model would feature only one element representing both Superman and Clark Kent. Hence, the mapping $y_1$ from the local $O_1$-model to $U$ will typically be non-injective.\n\nWe denote by $\\text{Mod}^{int}(S)$ the class of all general integrated models of a NeO $S$ and by $\\text{Mod}^{uni}(S)$ the class of all inclusive integrated models of a NeO $S$.\n\n### 4.3 Contextualised Semantics\n\nContextualised semantics gives up the notion of a global universe, and instead lets each ontology in a network be interpreted with its own local universe. However, in order to give a semantics to alignments, these universes need to be related somehow. The approach of [80] to use mappings between local universes has a number of limitations and has been replaced by a more flexible approach subsequently [20], which uses relations between local universes. This is closely related to the semantics of DDLs [5] and $\\mathcal{E}$-connections [48].\n\nThe idea is to relate the universes of the models of the ontologies by a family of relations $r = (r_{ij})_{i,j \\in \\text{Ind}}$. The relations $R$ in $\\mathcal{R}$ are interpreted in each universe $D_i$ of the models $M^i$ of the ontologies in the NeO.\n\nSatisfaction of a correspondence $c = (s_1, s_2, R)$ by two models $M^1$ of $O_1$ and $M^2$ of $O_2$ means\n\n$$M^1_{s_1} R_1 r_{21}(M^2_{s_2})$$\n\nwhere $R_1$ is the interpretation of $R$ in $\\text{universe}(M^1)$, $r_{21}(y) = \\{x \\in \\text{universe}(M^1) \\mid (y, x) \\in r_{21}\\}$, $r(y) = \\cup_{y \\in Y} r(y)$ and $x R Y$ if $x R y$ for each $y \\in Y$. Because the domain relations are involved, the definition of the interpretation function for the correspondence relations relative to a set must take them into account. We denote it by $M^1, M^2 \\models^c R$, and extend this to alignments, denoted $M^1, M^2 \\models^c c$, if all correspondences of the alignment are satisfied by $M^1, M^2$ w.r.t. $r$.\n\nA contextualised interpretation of $S$ is then a pair \\{$(M^i)_{i \\in \\text{Ind}}, (r_{ij})_{i,j \\in \\text{Ind}}$\\} where $(M^i)_{i \\in \\text{Ind}}$ is an interpretation of $S$ and $(r_{ij})_{i,j \\in \\text{Ind}}$ is a family of relations such that $r_{ij}$ relates the universe of $M^i$ to the universe of $M^j$ and $r_{ij}$ is the identity (diagonal) relation. Further assumptions about these relations can be added, thus restricting more the class of interpretations of a NeO.\n\n### Definition 27\n\nA contextualised model of the NeO $S$ is a contextualised interpretation \\{(M^i)_{i \\in \\text{Ind}}, (r_{ij})_{i,j \\in \\text{Ind}}\\} of $S$ such that for each $i, j \\in \\text{Ind}$, $M^i$, $M^j \\models \\rho C$ $A_{ij}$. We denote by $\\text{Mod}^{con}(S)$ the class of all contextualised models of a NeO $S$.\n\n### Example 27\n\n(Interpretation of correspondence relations in SROIQ) The interpretation of correspondences in SROIQ relative to a set $D$ in the contextualised semantics is\n\n\\[\n\\begin{align*}\n(c_1, c_2, =) & \\quad M^1_{c_1} = r_{21}(M^2_{c_2}) \\\\\n(r_1, r_2, =) & \\quad M^1_{r_1} = r_{21}(M^2_{r_2}) \\\\\n(i_1, i_2, =) & \\quad M^1_{i_1} \\cap r_{21}(M^2_{i_2}) = \\emptyset \\\\\n(r_1, r_2, \\perp) & \\quad M^1_{r_1} \\cap r_{21}(M^2_{r_2}) = \\emptyset \\\\\n(i_1, i_2, \\perp) & \\quad (M^1_{i_1}, M^1_{i_2}) \\notin r_{21} \\\\\n(c_1, c_2, <) & \\quad M^1_{c_1} \\subseteq r_{21}(M^2_{c_2}) \\\\\n(r_1, r_2, <) & \\quad M^1_{r_1} \\subseteq r_{21}(M^2_{r_2}) \\\\\n(c_1, c_2, >) & \\quad M^1_{c_1} \\supseteq r_{21}(M^2_{c_2}) \\\\\n(r_1, r_2, >) & \\quad M^1_{r_1} \\supseteq r_{21}(M^2_{r_2}) \\\\\n(c_1, i_2, \\equiv) & \\quad r_{21}(M^2_{i_2}) \\subseteq M^1_{c_1} \\\\\n(i_1, i_2, \\in) & \\quad M^1_{i_1} \\in r_{21}(M^2_{i_2})\n\\end{align*}\n\\]\n\nwhere $c_1$, $r_1$, $i_1$ are class, role and individual symbols from an ontology $O_1$, $c_2$, $r_2$, $i_2$ are class, role and individual symbols from an ontology $O_2$, $M^1$ and $M^2$ are models of $O_1$ and $O_2$ with domains $D_1$ and $D_2$ and $r_{21}$ is the domain relation between $D_2$ and $D_1$.\n\n### 5 Normalisation of Alignments\n\nIn this section we describe how relational (and therefore also general) networks can be normalised into functional ones. Part of this normalisation process generalises to an arbitrary institution, while certain parts (namely relativisation of ontologies and the construction of bridges) are institution-specific and have to be provided separately for each institution.\n\nA central motivation behind this construction is the following: We will prove representation theorems showing that the semantics of a relational network coincides with that of its normalisation, see Sect. 7. This implies that reasoning in the normalised network coincides with that of the original network.\ncolimit of the normalised network is complete and (in case of logics admitting amalgamation) also sound for reasoning about the network (Corollary 3).\n\n5.1 Structure of the Normalisation Process\n\nRelational DOL networks (i.e. networks involving alignments) can be normalised to purely functional networks. In this section, we lay out the structure of this normalisation process, while in the next four sections, we will provide details for each of the four possible assumptions about the semantics.\n\n**Example 28** We illustrate the four approaches to semantics with the help of a simple example. Let us consider the following two ontologies:\n\n**ontology** \\( S = \\text{Class: Person} \\)\n\n- **Individual:** alex\n- **Types:** Person\n- **Class:** Child\n\n**ontology** \\( T = \\text{Class: HumanBeing} \\)\n\n- **Class:** Male\n- **SubClassOf:** HumanBeing\n- **Class:** Employee\n\nTogether with the following correspondences:\n\n\\[ S : Person = T : HumanBeing \\]\n\\[ S : \\text{alex} \\in T : \\text{Male} \\]\n\\[ S : \\text{Child} \\sqcap T : \\text{Employee} \\]\n\nwhere we prefix with \\( S : \\) the symbols coming from \\( S \\) and with \\( T : \\) the symbols coming from \\( T \\).\n\nUsing the DOL syntax, we can write this alignment as\n\n**alignment** \\( A : S \\rightarrow T = \\text{Person} = \\text{HumanBeing}, \\text{alex} \\in T = \\text{Male}, \\text{Child} \\sqcap \\text{Employee} \\)\n\nNote that so far we have not specified which kind of semantics is assumed for \\( A \\). Depending on the choice for the semantics assumed, the normalisation of \\( A \\) will be constructed in a different way. \\( \\square \\)\n\nThe idea is to introduce for each correspondence a theory that captures its semantics. This is done differently for four possible semantics of the alignment. Using these theories, we then construct a diagram that gives the semantics of the alignment. In all four semantics, the diagram is a \\( W \\)-alignment in the sense of [81]:\n\n**Definition 28** Let \\( S \\) and \\( T \\) be two ontologies in a logic \\( L \\)\n\nand \\( A = \\{ c_i = (s_{i1}, s_{i2}, R_i) \\mid i \\in \\text{Ind} \\} \\) an alignment between \\( S \\) and \\( T \\). The **diagram of the alignment** \\( A \\) is\n\n\\[\n\\begin{array}{ccc}\nS & \\xleftarrow{\\sigma_1} & B \\\\\n\\downarrow t_1 & & \\downarrow t_2 \\\\\n\\tilde{S}' & & \\tilde{T}'\n\\end{array}\n\\]\n\nwhere the ontologies \\( B, \\tilde{S}, \\tilde{S}', \\tilde{T}, \\tilde{T}' \\) and the morphisms \\( t_1, t_2, \\sigma_1, \\sigma_2 \\) depend on the choice of semantics for the alignment \\( A \\), in a way to be made precise for each possible option.\n\nIntuitively, \\( \\tilde{S} \\) and \\( \\tilde{T} \\) are either the ontologies \\( S \\) and \\( T \\) being aligned, or a transformation of them, involving their translation along a comorphism. \\( B \\) is a bridge ontology that formalises the intended meaning of the correspondences of \\( A \\). It will be constructed as a union of smaller theories, each internalising the semantics of a correspondence of \\( A \\). This means, intuitively, that the models \\( M \\) of a theory that internalises the semantics of \\((s_1, s_2, R)\\), are precisely those for which the relation \\( M_R \\) holds for \\( M_{s_1} \\) and \\( M_{s_2} \\), in a way that takes into account the possible semantics of the alignment. We will define this formally for each choice of semantics. It is possible that some correspondence cannot be internalised in the logic of the ontologies being aligned. In this case, we will have to look for a more expressive logic, where such a theory internalising the semantics of that correspondence can be constructed. We will discuss the implications of this change of logic in Sect. 6. \\( \\tilde{S}' \\) and \\( \\tilde{T}' \\) interface \\( \\tilde{S} \\) and \\( \\tilde{T} \\), respectively, with \\( B \\), meaning that they connect the symbols from the aligned ontologies with their correspondents in the bridge ontology along \\( t_i \\) and \\( \\sigma_i \\).\n\nThese diagrams will be used in the construction of the normalisation of a network:\n\n**Definition 29** Given a relational NeO, its **normalisation** is defined as the functional network obtained by uniting all diagrams for the alignments in the NeO. Given a general NeO, its normalisation is defined as the union of its functional part with the normalisation of its relational part. \\( \\square \\)\n\nFor each ontology \\( O_i \\) in a network of aligned ontologies let \\( \\tilde{O}_i \\) be its corresponding ontology in the diagram of the network. Let \\( \\Sigma_i = \\text{Sig}(O_i) \\) and \\( \\Sigma'_i = \\text{Sig}(\\tilde{O}_i) \\). In each of the four cases that correspond to the different choices of semantics we can define: (i) a sentence translation functor \\( \\alpha^* : \\text{Sen}(\\Sigma_i) \\rightarrow \\text{Sen}(\\Sigma'_i) \\) (ii) a model reduction functor \\( \\beta^* : \\text{Mod}(\\Sigma'_i) \\rightarrow \\text{Mod}(\\Sigma_i) \\) such that the condition \\( \\beta^*(M') \\models e \\iff M' \\models \\alpha^*(e) \\) holds for each \\( M \\in \\text{Mod}(\\tilde{O}_i) \\) and each \\( e \\in \\text{Sen}(\\Sigma_i) \\). Using these functors allows us to formulate the results about reasoning in a NeO in a uniform way. In all four cases, we can define a signature morphism in a Grothendieck logic from \\( \\Sigma_i \\) to \\( \\Sigma'_i \\) such that \\( \\alpha^* \\) and \\( \\beta^* \\) are the sentence translation and model reduction functors corresponding to it. Thus, the expected condition follows from the satisfaction condition of the Grothendieck logic.\n\nWe now proceed with discussing how these diagrams are obtained for each of the four possible semantics.\n5.2 Simple Semantics\n\nWe start with defining what it means for a theory to capture the semantics of a correspondence. In this section, let $A = \\{c_i = (s^i_1, s^i_2, R_i) \\mid i \\in Ind\\}$ be an alignment between two ontologies $S$ and $T$ in a logic $L$, where $Ind$ is a set of indices. First we define the signature of the theory.\n\n**Definition 30** The bridge signature $\\Sigma_B$ of $A$ is defined as the union of $\\text{Sig}_1(A)$ and $\\text{Sig}_2(A)$, where\n\n- $\\Sigma_1$ is the smallest subsignature of $\\text{Sig}(S)$ such that $\\text{Symbols}(\\Sigma_1)$ includes $s^1_i$ for each $i \\in Ind$, and $\\text{Sig}_1(A)$ is the signature obtained by renaming every symbol $s \\in \\text{Symbols}(\\Sigma_1)$ to $S : s$ and\n- $\\Sigma_2$ is the smallest subsignature of $\\text{Sig}(T)$ such that $\\text{Symbols}(\\Sigma_2)$ includes $s^2_i$ for each $i \\in Ind$, and $\\text{Sig}_2(A)$ is the signature obtained by renaming every symbol $s \\in \\text{Symbols}(\\Sigma_2)$ to $T : s$.\n\nWe must prefix the symbols occurring in correspondences with the names of the ontology where they come from to avoid unintended identifications when making the union of the involved signatures.\n\n**Definition 31** Let $\\Sigma_B$ be the bridge signature of $A$ and $\\Delta$ be a set of $\\Sigma_B$ sentences. We say that $(\\Sigma_B, \\Delta)$ internalises the semantics of $c_i = (s^1_i, s^2_i, R_i)$ for some $i \\in Ind$, denoted $(\\Sigma_B, \\Delta) \\equiv \\text{sim} c_i$, if\n\n$$M \\models_{\\Sigma_B} \\Delta \\iff (M_{s^1_i}, M_{T:s^2_i}) \\in (R_i)_{\\text{universe}(M)}$$\n\nfor each $\\Sigma_B$-model $M$.\n\n**Definition 32** Let $\\Sigma_B$ be the bridge signature of $A$. Assume that $(\\Sigma_B, \\Delta_i) \\equiv \\text{sim} c_i$ for each $c_i \\in A$. The diagram of $A$ is obtained by setting the parameters of Definition 28 as follows:\n\n- $\\tilde{S} = S$ and $\\tilde{T} = T$,\n- $\\tilde{S}' = (\\text{Sig}_1(A), \\emptyset)$,\n- $\\iota_1$ maps each $S : s \\in \\text{Symbols}(\\text{Sig}_1(A))$ to $s$,\n- $\\tilde{T}' = (\\text{Sig}_2(A), \\emptyset)$,\n- $\\iota_2$ maps each $T : s \\in \\text{Symbols}(\\text{Sig}_2(A))$ to $s$,\n- $B = (\\Sigma_B, \\cup_{i \\in Ind} \\Delta_i)$,\n- $\\sigma_1$ and $\\sigma_2$ are inclusions.\n\n**Example 29** (Simple semantics in $\\mathcal{SROIQ}$)\n\nFor each type of correspondence, we give below the theory that internalises its semantics. We have chosen to use Manchester syntax for $\\mathcal{SROIQ}$ [38], as it makes more obvious the kinds of symbols involved. We also assume that the correspondences are between symbols from the ontologies $S$ and $T$.\n\n(c1, c2, =) Class: $S:c1$\nEquivalentTo: $T:c2$\n\n(r1, r2, =) ObjectProperty: $S:r1$\nEquivalentTo: $T:r2$\n\n(i1, i2, =) Individual: $S:i1$\nSameAs: $T:i2$\n\n(c1, c2, ⊥) Class: $S:c1$\nDisjointWith: $T:c2$\n\n(r1, r2, ⊥) ObjectProperty: $S:r1$\nDisjointWith: $T:r2$\n\n(i1, i2, ⊥) Individual: $S:i1$\nDifferentFrom: $T:i2$\n\n(c1, c2, <) Class: $S:c1$\nSubClassOf: $T:c2$\n\n(r1, r2, <) ObjectProperty: $S:r1$\nSubPropertyOf: $T:r2$\n\n(c1, c2, >) Class: $T:c2$\nSubClassOf: $S:c1$\n\n(r1, r2, >) ObjectProperty: $T:r2$\nSubPropertyOf: $S:r1$\n\n(c1, i2, ☐) Individual: $T:i2$\nTypes: $S:c1$\n\n(i1, c2, ⊓⊔) Individual: $S:i1$\nTypes: $T:c2$\n\n**Example 30** (Simple semantics in FOL) Similarly, in FOL we have the following theories that internalise the semantics of correspondences:\n(f_1, f_2, =) \\forall x_1, \\ldots, x_n.\nS : f_1(x_1, \\ldots, x_n) = T : f_2(x_1, \\ldots, x_n)\n\n(f_1, f_2, \\bot) \\forall x_1, \\ldots, x_n.\n\\neg S : f_1(x_1, \\ldots, x_n) = T : f_2(x_1, \\ldots, x_n)\n\n(p_1, p_2, =) \\forall x_1, \\ldots, x_n.\nS : p_1(x_1, \\ldots, x_n) \\iff T : p_2(x_1, \\ldots, x_n)\n\n(p_1, p_2, \\bot) \\forall x_1, \\ldots, x_n.\n\\neg(S : p_1(x_1, \\ldots, x_n) \\land T : p_2(x_1, \\ldots, x_n))\n\n(p_1, p_2, <) \\forall x_1, \\ldots, x_n.\nS : p_1(x_1, \\ldots, x_n) \\implies T : p_2(x_1, \\ldots, x_n)\n\n(p_1, p_2, >) \\forall x_1, \\ldots, x_n.\nT : p_2(x_1, \\ldots, x_n) \\implies S : p_1(x_1, \\ldots, x_n)\n\n\\Box\n\nExample 31 For the alignment of Example 28, we start by adding the assumption that we have a shared universe for the ontologies:\n\nalignment A : S to T = \\ldots\nassuming SingleDomain\n\nThe network of A is then\n\n\\[ \\begin{array}{ccc}\nS & \\xrightarrow{t_1} & \\sigma_1 & \\xrightarrow{t_2} & B & \\xrightarrow{\\sigma_2} & T \\\\\n\\tilde{S}' & & & & \\tilde{T}'\n\\end{array} \\]\n\nwhere \\( \\tilde{S}' \\) consists of the concepts \\( S : \\text{Person} \\) and \\( S : \\text{Child} \\) and the individual \\( \\text{Sales} \\) and \\( \\tilde{T}' \\) consists of the concepts \\( T : \\text{HumanBeing} \\), \\( T : \\text{Employee} \\) and \\( T : \\text{Male} \\). Then the bridge ontology \\( B \\) is:\n\nontology B =\nClass: S:Person EquivalentTo: T:HumanBeing\nClass: T:Employee\nClass: T:Male\nClass: S:Child DisjointWith: T:Employee\nIndividual: S:alex Types: T:Male\n\nWe can combine the resulting functional network into a single ontology. In DOL, this is written as:\n\nontology C = combine N\n\nThe colimit ontology of the network of A is:\n\nontology C =\nClass: S:Person EquivalentTo: T:HumanBeing\nClass: T:Employee\nClass: T:Male SubClassOf: T:HumanBeing\nClass: S:Child DisjointWith: T:Employee\nIndividual: S:alex Types: T:Male, S:Person\n\n\\Box\n\n5.3 Inclusive Integrated Semantics\n\nNormalisation of relational networks with integrated semantics is more difficult than for simple semantics, as compatible families of models of connected functional networks always have a unique universe (this follows from model reducts preserving the universe). To remedy this, we use the relativisation of ontologies. Thus the universes of the ontologies appear explicitly as concepts, and they can be interpreted as subsets of the global universe, that subsumes them.\n\nHere internalisation is the same as in the case of simple semantics. For uniformity we use the notation \\((\\Sigma_B, \\Delta) \\approx^{int} c\\), which means that \\((\\Sigma_B, \\Delta) \\approx^{sim} c\\).\n\nDefinition 33 Assume that \\((\\Sigma_B, \\Delta_i) \\approx^{int} c_i\\) for each \\(c_i \\in A\\). The diagram of \\(A\\) is obtained by setting the parameters of Definition 28 as follows:\n\n- \\( \\tilde{S} = rel_L(S) \\) and \\( \\tilde{T} = rel_L(T) \\), where \\( rel_L \\) is the relativisation of the logic \\( L \\) of the ontologies being aligned,\n- \\( \\tilde{S}' = (\\Sigma_{\\text{Sig}}(A) \\cup \\{ S : T \\in \\text{binary}_L \\}, \\emptyset) \\),\n- \\( t_1 \\) maps each \\( S : s \\in \\text{Symbols}(\\Sigma_{\\text{Sig}}(A)) \\) to \\( s \\) and \\( S : \\top \\) to itself,\n- \\( \\tilde{T}' = (\\Sigma_{\\text{Sig}}(A) \\cup \\{ T : T \\in \\text{binary}_L \\}, \\emptyset) \\),\n- \\( t_2 \\) maps each \\( T : s \\in \\text{Symbols}(\\Sigma_{\\text{Sig}}(A)) \\) to \\( s \\) and \\( T : \\top \\) to itself,\n- \\( B = (\\Sigma_B, \\bigcup_{i \\in \\text{Ind}} \\Delta_i) \\),\n- \\( \\sigma_1 \\) and \\( \\sigma_2 \\) are inclusions.\n\n\\Box\n\nWe can instantiate Definition 33 for SROIQ using the internalisation of alignments from Example 29 and the relativisation from Example 19. Similarly, we get an instantiation for FOL using the internalisation of alignments from Example 30 and the relativisation from Example 20. We expect that in a similar way, also for other logics, internalisation of alignments for simple semantics can be reused for inclusive integrated semantics when a relativisation is added.\n\nExample 32 Continuing Example 28, we add the assumption of a global universe:\n\nalignment A : S to T = \\ldots\nassuming GlobalDomain\n\nThe diagram of A is then\n\n\\[ \\begin{array}{ccc}\n\\tilde{S} & \\xrightarrow{t_1} & \\sigma_1 & \\xrightarrow{t_2} & B & \\xrightarrow{\\sigma_2} & \\tilde{T} \\\\\n\\tilde{S}' & & & & \\tilde{T}'\n\\end{array} \\]\n\nwhere \\( \\tilde{S}' \\) consists of the concepts \\( S : \\top, S : \\text{Person} \\) and \\( S : \\text{Child} \\) and the individual \\( \\text{Sales} \\) and \\( \\tilde{T}' \\) consists of the concepts \\( T : \\top, T : \\text{HumanBeing} \\), \\( T : \\text{Employee} \\) and \\( T : \\text{Male} \\).\n\nThe relativisations of the ontologies \\( S \\) and \\( T \\) are\nontology \\( \\hat{S} = \\)\n\n- Class: S:Thing\n- Class: Person SubClassOf: S:Thing\n- Individual: Alex Types: Person, S:Thing\n- Class: Child SubClassOf: S:Thing\n\nontology \\( \\hat{T} = \\)\n\n- Class: T:Thing\n- Class: HumanBeing SubClassOf: T:Thing\n- Class: Male SubClassOf: HumanBeing, T:Thing\n- Class: Employee SubClassOf: T:Thing\n- Class: Child DisjointWith: T:Employee\n- Individual: S: Alex Types: T: Male, S: Person, S: Thing\n\nThe bridge ontology of \\( A \\) is the same as for the simple semantics.\n\nThe colimit of the relativised diagram of the alignment in Example 28 is:\n\nontology \\( C = \\)\n\n- Class: S:Thing\n- Class: T:Thing\n- Class: T: HumanBeing SubClassOf: T: Thing\n- Class: S: Person EquivalentTo: T: HumanBeing\n- Class: S: Person SubClassOf: S: Thing\n- Class: T: Male SubClassOf: T: HumanBeing, T: Thing\n- Class: S: Child SubClassOf: S: Thing\n- Class: S: Child DisjointWith: T: Employee\n- Individual: S: Alex Types: T: Male, S: Person, S: Thing\n\n\\( \\square \\)\n\nIf \\( S \\) is a network of aligned ontologies and \\( O_i \\) an ontology of \\( S \\) for \\( i \\in I \\), we define the heterogeneous signature morphism from \\( \\text{Sig}(O_i) \\) to \\( \\text{Sig}(\\text{rel}_L(O_i)) \\) as \\( (\\text{rel}_L, i \\circ (\\text{rel}_L(O_i))) \\). Thus \\( \\alpha^* \\) and \\( \\beta^* \\) are the components \\( \\alpha \\) and \\( \\beta \\) of the relativisation comorphism \\( \\text{rel}_L \\).\n\n5.4 General Integrated Semantics\n\nSince general integrated semantics allow the use of arbitrary equalising functions in the model, the approach of Sect. 5.3 does not work. We have to modify the bridge ontology and the internalisation of alignments: the ontologies of the network can be interpreted using different universes, and these are mapped to a global universe using (functional) binary relations. Moreover, we need to make sure that if an ontology is aligned more than once in a network of aligned ontologies, the global universe and the equalising functions are interpreted in the same way in the entire diagram of the network.\n\n**Definition 34** Let \\( A = (s_i = (s_i^1, s_i^2, R_i) \\mid i \\in \\text{Ind}) \\) be an alignment between two ontologies \\( S \\) and \\( T \\) in a logic \\( L \\), where \\( \\text{Ind} \\) is a set of indices. The basic bridge ontology \\((\\Sigma_B, \\Delta_B)\\) of \\( A \\) in the general integrated semantics consists of\n\n- the signature \\( \\Sigma_B \\) that takes the union of \\( \\text{Sig}_1(A) \\) and \\( \\text{Sig}_2(A) \\), where\n- \\( \\Sigma_1 \\) is the smallest subsignature of \\( \\text{Sig}(S) \\) such that \\( \\text{Symbols}(\\Sigma_1) \\) includes \\( s_i^j \\) for each \\( i \\in \\text{Ind} \\), and \\( \\text{Sig}_1(A) \\) takes the signature obtained by renaming every \\( s \\in \\text{Symbols}(\\Sigma_1) \\) to \\( S: s \\) and extends it with \\( S: \\top, G \\in \\text{unary}_L \\) and with \\( r_S \\) and \\( r_T \\) in \\( \\text{binary}_L \\).\n- \\( \\Sigma_2 \\) is the smallest subsignature of \\( \\text{Sig}(T) \\) such that \\( \\text{Symbols}(\\Sigma_2) \\) includes \\( s_i^j \\) for each \\( i \\in \\text{Ind} \\), and \\( \\text{Sig}_2(A) \\) takes the signature obtained by renaming every \\( s \\in \\text{Symbols}(\\Sigma_2) \\) to \\( T: s \\) and extends it with a with \\( T: \\top, G \\in \\text{unary}_L \\) and with \\( r_S \\) and \\( r_T \\) in \\( \\text{binary}_L \\).\n- logic-dependent sentences \\( \\Delta_B \\) that axiomatise \\( r_S \\) and \\( r_T \\) to be inverse-functional and right total and having their domains \\( G \\) and their ranges \\( S: \\top \\) and \\( T: \\top \\), respectively.\n\n\\( \\square \\)\n\nBesides the symbols involved in the correspondences of \\( A \\), the bridge ontology contains explicit representation of the involved domains: the universes of the aligned ontologies \\( S: \\top \\) and \\( T: \\top \\) as well as the global domain \\( G \\). The equalising functions are represented by the relations \\( r_S \\) and \\( r_T \\). Note that we work with their inverses to be able to internalise the semantics of correspondences in OWL.\n\n**Definition 35** Let \\( c = (s_1, s_2, R) \\) be a correspondence of a generalised integrated alignment. Let \\( (\\Sigma_B, \\Delta_B) \\) be the basic bridge ontology of the alignment and let \\( \\Delta \\) be a set of \\( \\Sigma_B \\)-sentences that includes \\( \\Delta_B \\). We say that \\( (\\Sigma_B, \\Delta) \\) internalises the semantics of \\( c \\), denoted \\( (\\Sigma_B, \\Delta) \\upharpoonright \\text{gint } c \\), if for each \\( \\Sigma_B \\)-model \\( M, M \\models \\Sigma_B \\upharpoonright \\text{gint } c \\) if we have in \\( M \\) that \\( (x, MS_{s_1}) \\in Mr_S \\) and \\( (y, MT_{s_2}) \\in Mr_T \\) implies \\( (x, y) \\in R^i_G \\) for \\( x, y \\in MG \\).\n\n\\( \\square \\)\n\n**Definition 36** Assume that \\( (\\Sigma_B, \\Delta_i) \\upharpoonright \\text{gint } c_i \\) for each \\( c_i \\in A \\). The parameters of Definition 28 are set as follows:\n\n- \\( \\hat{\\Sigma} \\) extends \\( \\text{rel}_L(S) \\), where \\( \\text{rel}_L \\) is the relativisation of the logic \\( L \\) of the ontologies being aligned, with a new symbol \\( G \\) in \\( \\text{unary}_L \\) and with a new symbol \\( r_S \\) in \\( \\text{binary}_L \\) and similarly \\( \\hat{T} \\) extends \\( \\text{rel}_L(T) \\), with a new symbol \\( G \\) in \\( \\text{unary}_L \\) and with a new symbol \\( r_T \\) in \\( \\text{binary}_L \\),\n- \\( \\hat{\\Sigma} = (\\text{Sig}_1(A), \\emptyset) \\),\n- \\( \\iota_1 \\) maps each \\( S: s \\in \\text{Symbols}(\\text{Sig}_1(A)) \\) to \\( s, S: \\top \\) to \\( \\text{top} \\) and \\( G, r_S \\) identically,\n- \\( \\hat{T} = (\\text{Sig}_2(A), \\emptyset) \\),\n- \\( \\iota_2 \\) maps each \\( T: s \\in \\text{Symbols}(\\text{Sig}_2(A)) \\) to \\( s, T: \\top \\) to \\( \\text{top} \\) and \\( G, r_T \\) identically,\n- \\( B = (\\Sigma_B, \\cup_{i\\in \\text{Ind}} \\Delta_i) \\),\n- \\( \\sigma_1 \\) and \\( \\sigma_2 \\) are inclusions.\n\n\\( \\square \\)\nExample 33 (General integrated semantics in FOL) In FOL we have the following basic bridge ontology:\n\n\\[\n\\forall x_1, x_2, z. \\exists S, x. S : \\top (x) \\land \\exists z. z \\in S (x) \\\\\n\\forall x. S : \\top (x) \\Rightarrow \\exists z. z \\in S (x) \\\\\n\\forall x_1, x_2, z. \\exists T. x_1 \\land z \\in T x_2 \\Rightarrow x_1 = x_2 \\\\\n\\forall x. T : \\top (x) \\Rightarrow \\exists z. z \\in T x \\\\\n\\forall x, z. z \\in T x \\Rightarrow T : \\top (x) \\land \\exists z. z \\in T x\n\\]\n\nwhere for each of \\( r_S \\) and \\( r_T \\), the first axiom is inverse functionality, the second one is right-totality and the third one gives the domain and the range, and the following theories that internalise the semantics of correspondences:\n\n\\[\n(f_1, f_2, =) \\forall x_1, \\ldots, x_n, y_1, \\ldots, y_n, z_1, \\ldots, z_n. \\\\\nS : \\top (x_1) \\land \\ldots \\land S : \\top (x_n) \\\\\n\\land T : \\top (y_1) \\land \\ldots \\land T : \\top (y_n) \\\\\n\\land z_1 r_S x_1 \\land \\ldots \\land z_n r_S x_n \\\\\n\\land z_1 r_T y_1 \\land \\ldots \\land z_n r_T y_n \\\\\n\\Rightarrow \\\\\n\\exists z. z \\in S (x_1, \\ldots, x_n) \\land \\\\\nz \\in T T : f_2 (y_1, \\ldots, y_n)\n\\]\n\n\\[\n(f_1, f_2, \\perp) \\neg \\exists x_1, \\ldots, x_n, y_1, \\ldots, y_n, z_1, \\ldots, z_n. \\\\\nS : \\top (x_1) \\land \\ldots \\land S : \\top (x_n) \\\\\n\\land T : \\top (y_1) \\land \\ldots \\land T : \\top (y_n) \\\\\n\\land z_1 r_S x_1 \\land \\ldots \\land z_n r_S x_n \\\\\n\\land z_1 r_T y_1 \\land \\ldots \\land z_n r_T y_n \\\\\n\\Rightarrow \\\\\n\\exists z. z \\in S (x_1, \\ldots, x_n) \\land \\\\\nz \\in T T : f_2 (y_1, \\ldots, y_n)\n\\]\n\n\\[\n(p_1, p_2, =) \\forall x_1, \\ldots, x_n, y_1, \\ldots, y_n, z_1, \\ldots, z_n. \\\\\nS : \\top (x_1) \\land \\ldots \\land S : \\top (x_n) \\\\\n\\land T : \\top (y_1) \\land \\ldots \\land T : \\top (y_n) \\\\\n\\land z_1 r_S x_1 \\land \\ldots \\land z_n r_S x_n \\\\\n\\land z_1 r_T y_1 \\land \\ldots \\land z_n r_T y_n \\\\\n\\Rightarrow \\\\\nS : p_1 (x_1, \\ldots, x_n) \\iff T : p_2 (y_1, \\ldots, y_n)\n\\]\n\n\\[\n(p_1, p_2, \\perp) \\neg \\exists x_1, \\ldots, x_n, y_1, \\ldots, y_n, z_1, \\ldots, z_n. \\\\\nS : \\top (x_1) \\land \\ldots \\land S : \\top (x_n) \\\\\n\\land T : \\top (y_1) \\land \\ldots \\land T : \\top (y_n) \\\\\n\\land z_1 r_S x_1 \\land \\ldots \\land z_n r_S x_n \\\\\n\\land z_1 r_T y_1 \\land \\ldots \\land z_n r_T y_n \\\\\n\\Rightarrow \\\\\nS : p_1 (x_1, \\ldots, x_n) \\iff T : p_2 (y_1, \\ldots, y_n)\n\\]\n\n\\[\n(p_1, p_2, >) \\forall x_1, \\ldots, x_n, y_1, \\ldots, y_n, z_1, \\ldots, z_n. \\\\\nS : \\top (x_1) \\land \\ldots \\land S : \\top (x_n) \\\\\n\\land T : \\top (y_1) \\land \\ldots \\land T : \\top (y_n) \\\\\n\\land z_1 r_S x_1 \\land \\ldots \\land z_n r_S x_n \\\\\n\\land z_1 r_T y_1 \\land \\ldots \\land z_n r_T y_n \\\\\n\\Rightarrow \\\\\nT : p_2 (y_1, \\ldots, y_n) \\Rightarrow S : p_1 (x_1, \\ldots, x_n)\n\\]\n\n\\[\n(p_1, p_2, <) \\forall x_1, \\ldots, x_n, y_1, \\ldots, y_n, z_1, \\ldots, z_n. \\\\\nS : \\top (x_1) \\land \\ldots \\land S : \\top (x_n) \\\\\n\\land T : \\top (y_1) \\land \\ldots \\land T : \\top (y_n) \\\\\n\\land z_1 r_S x_1 \\land \\ldots \\land z_n r_S x_n \\\\\n\\land z_1 r_T y_1 \\land \\ldots \\land z_n r_T y_n \\\\\n\\Rightarrow \\\\\nS : p_1 (x_1, \\ldots, x_n) \\Rightarrow T : p_2 (y_1, \\ldots, y_n)\n\\]\n\nExample 34 (General integrated semantics in SROIQ) The basic bridge ontology for general integrated semantics in SROIQ is\n\n- **ObjectProperty:** \\( r_S \\)\n- **Characteristics:** InverseFunctional\n- **Domain:** \\( G \\)\n- **Range:** \\( S : T \\)\n- **Class:** \\( S : T \\)\n- **SubClassOf:** inverse \\( r_S \\) some \\( G \\)\n- **ObjectProperty:** \\( r_T \\)\n- **Characteristics:** InverseFunctional\n- **Domain:** \\( G \\)\n- **Range:** \\( T : T \\)\n- **Class:** \\( T : T \\)\n- **SubClassOf:** inverse \\( r_T \\) some \\( G \\)\n- **Class:** \\( G \\)\n\nThe theories that internalise the semantics of correspondences are:\n\n\\[\n(c_1, c_2, =) \\text{ EquivalentClasses:} \\\\\nr_S \\text{ some } S : c_1, \\\\\nr_T \\text{ some } T : c_2\n\\]\n\n\\[\n(i_1, i_2, =) \\text{ EquivalentClasses:} \\\\\nr_S \\text{ some } (S : i_1) \\\\\nr_T \\text{ some } (T : i_2)\n\\]\n\n\\[\n(c_1, c_2, \\perp) \\text{ Class: } r_S \\text{ some } S : c_1 \\\\\n\\text{ DisjointWith: } r_T \\text{ some } (T : i_2)\n\\]\n\n\\[\n(i_1, i_2, \\perp) \\text{ Class: } r_T \\text{ some } (S : i_1) \\\\\n\\text{ DisjointWith: } r_T \\text{ some } (T : i_2)\n\\]\n\n\\[\n(c_1, c_2, <) \\text{ Class: } r_S \\text{ some } S : c_1 \\\\\n\\text{ SubClassOf: } r_T \\text{ some } T : c_2\n\\]\n\n\\[\n(c_1, c_2, >) \\text{ Class: } r_T \\text{ some } T : c_2 \\\\\n\\text{ SubClassOf: } r_S \\text{ some } S : c_1\n\\]\n\n\\[\n(c_1, i_2, \\exists) \\text{ Class: } r_T \\text{ some } (T : i_2) \\\\\n\\text{ SubClassOf: } r_S \\text{ some } S : c_1\n\\]\n\n\\[\n\\text{ Springer}\n\\]\n\n\\[\n\\text{ Springer}\n\\]\n\n\\[\n\\text{ Springer}\n\\]\n\n\\[\n\\text{ Springer}\n\\]\nFor correspondences involving roles, we would need to be able to express equivalences or disjointness axioms involving complex roles, which are beyond the expressivity of SROIQ. Therefore, the correspondences \\((r_1, r_2, =), (r_1, r_2, \\lessdot), (r_1, r_2, <)\\) and \\((r_1, r_2, >)\\) cannot be internalised in SROIQ. We will give their internalisations in FOL in Example 42.\n\n**Example 35** Continuing Example 28, we add the assumption of a global universe with general integrated semantics:\n\nalignment \\(A : S \\text{ to } T = \\ldots\\)\n\nassuming GeneralGlobalDomain\n\nThe diagram of \\(A\\) is then\n\n\\[\n\\begin{array}{ccc}\nS & \\xrightarrow{\\sigma_1} & B \\\\\n\\downarrow t_1 & & \\downarrow \\sigma_2 \\\\\n\\tilde{S}' & \\xleftarrow{\\sigma'} & \\tilde{T}'\n\\end{array}\n\\]\n\nwhere \\(\\tilde{S}'\\) consists of the concepts \\(G, S:Thing, S:Person\\) and \\(S:Child\\), the object property \\(r_S\\) and the individual \\(S:alex\\) and \\(\\tilde{T}'\\) consists of the concepts \\(G, T:Thing, T:HumanBeing, T:Employee\\) and \\(T:Male\\) and the object property \\(r_T\\). The ontologies \\(\\tilde{S}\\) and \\(\\tilde{T}\\) are\n\n**ontology** \\(\\tilde{S} =\\)\n\n\\[\n\\begin{array}{l}\n\\text{Class: } S:Thing \\\\\n\\text{Class: } G \\\\\n\\text{ObjectProperty: } r_S \\\\\n\\text{SubClassOf: } S:Thing \\\\\n\\text{SubClassOf: } S:Person \\\\\n\\text{SubClassOf: } S:Child \\\\\n\\text{Individual: } \\text{alex} \\\\\n\\text{Types: } \\text{Person, } S:Thing \\\\\n\\text{Class: } \\text{Child} \\\\\n\\text{SubClassOf: } S:Thing\n\\end{array}\n\\]\n\n**ontology** \\(\\tilde{T} =\\)\n\n\\[\n\\begin{array}{l}\n\\text{Class: } T:Thing \\\\\n\\text{Class: } G \\\\\n\\text{ObjectProperty: } r_T \\\\\n\\text{SubClassOf: } T:HumanBeing \\\\\n\\text{SubClassOf: } T:Employee \\\\\n\\text{SubClassOf: } T:Male\n\\end{array}\n\\]\n\nThe bridge ontology \\(B\\) of Example 28 is:\n\n**ontology** \\(B =\\)\n\n\\[\n\\begin{array}{l}\n\\text{Class: } G \\\\\n\\text{SubClassOf: } S:Thing \\\\\n\\text{ObjectProperty: } r_S \\\\\n\\text{Characteristics: } \\text{InverseFunctional} \\\\\n\\text{Domain: } G \\\\\n\\text{Range: } T:Thing \\\\\n\\text{SubClassOf: } S:Person \\\\\n\\text{SubClassOf: } r_T \\\\\n\\text{Characteristics: } \\text{InverseFunctional}\n\\end{array}\n\\]\n\nIf \\(S\\) is a network of aligned ontologies and \\(O_i\\) an ontology of \\(S\\) for \\(i \\in \\text{Ind}\\), there is an inclusion morphism from \\(\\text{Sig}(rel_{L_i}(O_i))\\) to \\(\\text{Sig}(\\tilde{O}_i)\\) (recall that this is the ontology corresponding to \\(O_i\\) in the diagram of \\(S\\), that we denote \\(t_i\\). We define the heterogeneous signature morphism from \\(\\text{Sig}(O_i)\\) to \\(\\text{Sig}(\\tilde{O}_i)\\) as \\((rel_{L_i}, \\tilde{t}_i)\\). Thus \\(\\alpha^*(e) = \\text{Sen}(t_i)(\\alpha(e))\\) and \\(\\beta^*(M') = \\beta(M'|_{\\tilde{t}_i})\\), where \\(rel_{L_i} = (\\Phi, \\alpha, \\beta)\\).\n\n### 5.5 Contextualised Semantics\n\nRecall from Sect. 4.3 that in contextualised semantics, the ontologies of the network can be interpreted using different universes, which however are related using binary relations.\n\n**Definition 37** Let \\(A = \\{c_i = (s_{i1}^1, s_{i2}^1, R_i) \\mid i \\in \\text{Ind}\\}\\) be an alignment between two ontologies \\(S\\) and \\(T\\) in a logic \\(L\\), where \\(\\text{Ind}\\) is a set of indices. The basic bridge ontology \\((\\Sigma_B, \\Delta_B)\\) of \\(A\\) in the contextualised semantics consists of\nhave the following theories that internalise the semantics of\n\nExample 36\n\nA Categorical Approach to Networks of Aligned Ontologies\n\nDefinition 38\n\nLet \\( c = (s_1, s_2, R) \\) be a correspondence of a contextualised alignment \\( A \\). Let \\( (\\Sigma_B, \\Delta_B) \\) be the basic bridge ontology of \\( A \\) and let \\( \\Delta \\) be a set of \\( \\Sigma_B \\)-sentences that includes \\( \\Delta_B \\). We say that \\( (\\Sigma_B, \\Delta) \\) internalises the semantics of \\( c \\), denoted \\( (\\Sigma_B, \\Delta) \\cong_{\\text{con}} c \\), if\n\n\\[\nM \\models_{\\Sigma_A} \\Delta \\text{ iff } M_{S:x_1} R_{M:S:T}^I M_{T:s_1}(M_{T:s_2})\n\\]\n\nDefinition 39\n\nAssume that \\( (\\Sigma_B, \\Delta_i) \\cong_{\\text{con}} c_i \\) for each \\( c_i \\in A \\). The parameters of Definition 28 are set as follows:\n\n- \\( \\tilde{S} = \\text{rel}_L(S) \\) and \\( \\tilde{T} = \\text{rel}_L(T) \\), where \\( \\text{rel}_L \\) is the relativisation of the logic \\( L \\) of the ontologies being aligned,\n- \\( \\tilde{S} = (\\text{Sig}_1(A), \\emptyset) \\),\n- \\( t_1 \\) maps each \\( S : s \\in \\text{Symbols}(\\text{Sig}_1(A)) \\) to \\( s \\) and \\( S : T \\) to itself,\n- \\( \\tilde{T} = (\\text{Sig}_2(A), \\emptyset) \\),\n- \\( t_2 \\) maps each \\( T : s \\in \\text{Symbols}(\\text{Sig}_2(A)) \\) to \\( s \\) and \\( T : T \\) to itself,\n- \\( B = (\\Sigma_B, \\cup_{i \\in \\text{Ind} \\Delta_i}) \\),\n- \\( \\sigma_1 \\) and \\( \\sigma_2 \\) are inclusions.\n\nExample 36 (Contextualised semantics in FOL) In FOL we have the following theories that internalise the semantics of correspondences:\n\n\\[\n(f_1, f_2, =) \\forall x_1, \\ldots, x_n, y_1, \\ldots, y_n.\nS : T(x_1) \\land \\ldots \\land S : T(x_n)\n\\land T : T(y_1) \\land \\ldots \\land T : T(y_n)\n\\land y_1 rTS x_1 \\land \\ldots \\land y_n rTS x_n\n\\implies S : f_1(y_1, \\ldots, y_n) rTS T : f_2(x_1, \\ldots, x_n)\n\\]\n\n\\[\n(f_1, f_2, \\bot) \\neg \\exists x_1, \\ldots, x_n, y_1, \\ldots, y_n.\nS : T(x_1) \\land \\ldots \\land S : T(x_n)\n\\land T : T(y_1) \\land \\ldots \\land T : T(y_n)\n\\land y_1 rTS x_1 \\land \\ldots \\land y_n rTS x_n\n\\implies S : f_1(y_1, \\ldots, y_n) rTS T : f_2(x_1, \\ldots, x_n)\n\\]\n\n\\[\n(p_1, p_2, =) \\forall x_1, \\ldots, x_n, y_1, \\ldots, y_n.\nS : T(x_1) \\land \\ldots \\land S : T(x_n)\n\\land T : T(y_1) \\land \\ldots \\land T : T(y_n)\n\\land y_1 rTS x_1 \\land \\ldots \\land y_n rTS x_n\n\\implies S : p_1(x_1, \\ldots, x_n) \\iff T : p_2(y_1, \\ldots, y_n)\n\\]\n\n\\[\n(p_1, p_2, \\bot) \\neg \\exists x_1, \\ldots, x_n, y_1, \\ldots, y_n.\nS : T(x_1) \\land \\ldots \\land S : T(x_n)\n\\land T : T(y_1) \\land \\ldots \\land T : T(y_n)\n\\land y_1 rTS x_1 \\land \\ldots \\land y_n rTS x_n\n\\implies S : p_1(x_1, \\ldots, x_n) \\iff T : p_2(y_1, \\ldots, y_n)\n\\]\n\n\\[\n(p_1, p_2, >) \\forall x_1, \\ldots, x_n, y_1, \\ldots, y_n.\nS : T(x_1) \\land \\ldots \\land S : T(x_n)\n\\land T : T(y_1) \\land \\ldots \\land T : T(y_n)\n\\land y_1 rTS x_1 \\land \\ldots \\land y_n rTS x_n\n\\implies T : p_2(y_1, \\ldots, y_n) \\iff S : p_1(x_1, \\ldots, x_n)\n\\]\n\n\\[\n(p_1, p_2, <) \\forall x_1, \\ldots, x_n, y_1, \\ldots, y_n.\nS : T(x_1) \\land \\ldots \\land S : T(x_n)\n\\land T : T(y_1) \\land \\ldots \\land T : T(y_n)\n\\land y_1 rTS x_1 \\land \\ldots \\land y_n rTS x_n\n\\implies S : p_1(x_1, \\ldots, x_n) \\iff T : p_2(y_1, \\ldots, y_n)\n\\]\n\nHowever, the following example shows that it is not always possible to express the semantics of a correspondence in the contextualised semantics in the same logic as the one used in the aligned ontologies.\n\nExample 37 (Contextualised semantics in SROIQ)\n\nThe diagram of an alignment between two SROIQ ontologies \\( S \\) and \\( T \\) is obtained by applying the construction in Definition 42 to the relativisation of the aligned ontologies and to the correspondences of the alignment. The basic bridge ontology is\n\n\\[\n\\text{ObjectProperty :} rTS\n\\text{Domain: } T: \\text{Thing}\n\\text{Range: } S: \\text{Thing}\n\\]\n\nThe theories internalising the semantics of the correspondences extend it as follows:\n\n\\[\n(c_1, c_2, =) \\text{ Class: } S:c1\n\\text{ EquivalentTo: inverse(rTS) some } T:c2\n\\]\n(i₁, i₂, =) Individual: T:i2\nFacts: \\( r_{TS} S:i1 \\)\n(c₁, c₂, \\perp) EquivalentClasses:\n\\[ S: c1 \\text{ and inverse}(r_{TS}) \\text{ some } T: c2, \\]\nNoting\n(i₁, i₂, \\perp) EquivalentClasses:\n\\[ \\{T:i2\\} \\text{ and } r_{TS} \\text{ some } \\{S:i1\\}, \\]\nNoting\n(c₁, c₂, >) Class: inverse(r_{TS}) some T: c2\nSubClassOf: S: c1\\(^{29}\\)\n(r₁, r₂, >) ObjectProperty: S:r₁\nSubPropertyChain:\n\\[ \\text{inverse}(r_{TS}) \\circ T:r₂ \\circ r_{TS} \\]\n(c₁, c₂, <) Class: S: c1\nSubClassOf: inverse(r_{TS}) some T: c2\n(r₁, r₂, <) ObjectProperty: S:r₂\nSubPropertyChain:\n\\[ r_{TS} \\circ T:r₁ \\circ \\text{inverse}(r_{TS}) \\]\n(c₁, i₂, \\exists) Individual: T:i2\nFacts: \\( r_{TS} \\text{ some } S: c1 \\)\n(i₁, c₂, \\epsilon) Individual: S:i1\nFacts: inverse(r_{TS}) some T: c2\n\nFor the correspondence \\((r₁, r₂, =)\\) where \\(r₁\\) and \\(r₂\\) are roles, it is not possible to express in \\(SROIQ\\) that \\(r₁\\) and \\(r_{TS}^{-1}\\) are equivalent roles, where \\(r_{TS}\\) is the domain relation. A similar problem appears for the correspondence \\((r₁, r₂, \\perp)\\). □\n\nTo obtain a theory that internalises the semantics of this correspondence, we must use a more expressive logic, like first-order logic. This will be done in the next section.\n\n**Example 38** For the alignment in Example 23, we add the assumption that we have different universes for the ontologies, which are related by relations:\n\nalignment \\(A: S \\rightarrow T = \\ldots \\)\n\nassuming ContextualisedDomain\n\nThe network of \\(A\\) is then\n\n\\[\n\\begin{array}{c}\n\\tilde{S} \\\\\n\\sigma_1 \\\\\n\\tilde{S}'\n\\end{array}\n\\begin{array}{c}\n\\tilde{T} \\\\\n\\sigma_2 \\\\\n\\tilde{T}'\n\\end{array}\n\\]\n\nwhere the constituents of the diagram, except \\(B\\), are as defined in Example 32. The bridge ontology of \\(A\\) now becomes:\n\nontology \\(B = \\)\n\nClass: \\(S: \\text{Thing}\\)\nClass: \\(T: \\text{Thing}\\)\nObjectProperty: \\(r_{TS} \\text{ Domain: } T: \\text{Thing Range: } S: \\text{Thing}\\)\nClass: \\(S: \\text{Person}\\)\nEquivalentTo: inverse \\(r_{TS}\\) some \\(T: \\text{HumanBeing}\\)\n\n\\(^{29}\\) Again, this is not valid Manchester syntax, but expressible in \\(SROIQ\\) (general concept inclusion).\n\nThe colimit ontology of this network is:\n\nontology \\(C = \\)\n\nClass: \\(T: \\text{Thing}\\)\nObjectProperty: \\(r_{TS} \\text{ Domain: } T: \\text{Thing Range: } S: \\text{Thing}\\)\nClass: \\(S: \\text{Person}\\)\nEquivalentTo: inverse \\(r_{TS}\\) some \\(T: \\text{HumanBeing}\\)\nClass: \\(T: \\text{Employee}\\)\nClass: \\(T: \\text{Male SubClassOf: } T: \\text{HumanBeing}\\)\nEquivalentClasses:\n\\(S: \\text{Child and inverse } r_{TS} \\text{ some } T: \\text{Employee} , \\text{Nothing}\\)\nIndividual: \\(S: \\text{alex} \\)\n\nTypes: inverse \\(r_{TS}\\) some \\(T: \\text{Male} , S: \\text{Person}\\)\n\nNote that the correspondences of \\(A\\) do not include an equivalence between roles, and thus we can build a bridge ontology in \\(SROIQ\\).\n\nThe functors \\(\\alpha^*\\) and \\(\\beta^*\\) are defined as in the case of inclusive integrated semantics.\n\n### 6 Heterogeneous Alignments\n\nWe now discuss how to generalise the semantics of functional networks to the heterogeneous case, where by heterogeneity we mean the syntactic heterogeneity in the sense of \\(^{20}\\), where the ontologies being aligned are not expressed in the same ontology language.\\(^{30}\\) Arrows occurring in functional networks are theory morphisms in the Grothendieck logic, see Definition 20. The semantics using compatible families of models just carries over.\n\nFor heterogeneous relational networks, we need to equip the Grothendieck logic (which is induced by an indexed logic) with a family of correspondence relations in the sense of Definition 21. Now typically many or even all of the logics in the indexed logic will come with a family of correspondence relations. Each such relation name \\(R\\) of kind \\((k₁, k₂)\\) for logic \\(i\\) carries over to a relation name \\((ι, R)\\) of kind \\((ι(i), (ι, k₂))\\) for the Grothendieck logic. The interpretation of such relation names in the four different semantics also carries over to the Grothendieck logic.\n\nNaturally, these relation names (and their interpretations) inherited from the individual logics of the indexed logic can be used for homogeneous correspondences and alignments only. In order to be able to write truly heterogeneous alignments, one needs to introduce more relation names to the...\nGrothendieck logic. This leads to a syntax and semantics of heterogeneous relational (and also general) networks of ontologies.\n\nThis framework also allows us to align ontologies written in different formalisms, e.g., an OWL or RDF ontology with a first-order ontology. A typical example where this scenario is relevant is the alignment of a domain ontology (expressed in OWL) with a foundational ontology (expressed in FOL) with the general goal of improving the design of the domain ontology (see e.g., [24]).\n\n**Example 39** Below are the type of correspondences that can occur in alignments between an SROIQ and a FOL ontology (in this order):\n\n| ≈ | {⟨concept, pred⟩, ⟨role, pred⟩, ⟨individual, fun⟩} |\n| ⊥ | {⟨concept, pred⟩, ⟨role, pred⟩, ⟨individual, fun⟩} |\n| < | {⟨concept, pred⟩, ⟨role, pred⟩} |\n| > | {⟨concept, pred⟩, ⟨role, pred⟩} |\n| ∈ | {⟨individual, pred⟩} |\n| ∋ | {⟨concept, fun⟩} |\n\n**Definition 40** Let $S$ be an ontology in a logic $L_1$ and $T$ an ontology in a logic $L_2$, and let $c = (s_1, s_2, R)$ be a correspondence between the symbols $s_1$ of $S$ and $s_2$ of $T$ in an alignment $A$. Let $(\\Sigma_B, \\Delta_B)$ be the basic bridge ontology of $A$ along $\\rho_1 = (\\Phi_1, \\alpha_1, \\beta_1, \\gamma_1, \\kappa_1) : L_1 \\rightarrow L$ and $\\rho_2 = (\\Phi_2, \\alpha_2, \\beta_2, \\gamma_2, \\kappa_2) : L_2 \\rightarrow L$, introduced in the previous definition, and let $\\rho = (\\Phi', \\alpha', \\beta', \\gamma', \\kappa') : L \\rightarrow L'$. Let $\\Delta$ be a set of sentences including $\\alpha' (\\Delta_B)$. Then the theory $(\\Phi' (\\Sigma_B), \\Delta)$ internalises the semantics of $c$ along $\\rho_1$; $\\rho$ and $\\rho_2$; $\\rho$ if $M \\models^L_{\\Phi' (\\Sigma_B)} \\Delta$ iff (i) for the simple and inclusive integrated semantics, $(M_{\\rho_1; y'} (S; s_1), M_{\\rho_2; y'} (T; s_2)) \\in R^I_{\\text{universe}(M)}$; (ii) for the general integrated semantics, for each $x$, $y$ with $(x, M_{\\rho_1; y'} (S; s_1)) \\in M_R$ and $(y, M_{\\rho_2; y'} (T; s_2)) \\in M_R$, we have that $(x, y) \\in R^I_{M^R}$ and (iii) for the contextualised semantics, we have that $(M_{\\rho_1; y'} (S; s_1), M_{\\rho_2; y'} (T; s_2)) \\in R^I_{M^R}$. □\n\n**Example 41** If $O_1$ is an OWL ontology and $O_2$ is a FOL ontology, and $c = (s_1, s_2, R)$ is a correspondence in an alignment between $O_1$ and $O_2$, a theory internalising the semantics of $c$ along the translation from OWL to FOL defined in Example 13 and the identity translation on FOL is obtained according to the previous definition by internalising the semantics of $(y (s_1), s_2, R)$ in FOL, where $y$ is the symbol translation component of the logic translation from OWL to FOL. Similarly, correspondences between a MSFOL and a HOL ontology can be internalised in HOL by translating the MSFOL symbols to HOL.\n\nThe theory that internalises the semantics of a correspondence in an alignment $A$ will then have as signature the translation of the bridge signature of $A$ along a logic translation.\n\n**Definition 41** Let $S$ be an ontology in a logic $L_1$ and $T$ an ontology in a logic $L_2$, and let $c = (s_1, s_2, R)$ be a correspondence between the symbols $s_1$ of $S$ and $s_2$ of $T$ in an alignment $A$. Let $(\\Sigma_B, \\Delta_B)$ be the basic bridge ontology of $A$ along $\\rho_1 = (\\Phi_1, \\alpha_1, \\beta_1, \\gamma_1, \\kappa_1) : L_1 \\rightarrow L$ and $\\rho_2 = (\\Phi_2, \\alpha_2, \\beta_2, \\gamma_2, \\kappa_2) : L_2 \\rightarrow L$, introduced in the previous definition, and let $\\rho = (\\Phi', \\alpha', \\beta', \\gamma', \\kappa') : L \\rightarrow L'$. Let $\\Delta$ be a set of sentences including $\\alpha' (\\Delta_B)$. Then the theory $(\\Phi' (\\Sigma_B), \\Delta)$ internalises the semantics of $c$ along $\\rho_1$; $\\rho$ and $\\rho_2$; $\\rho$ if $M \\models^L_{\\Phi' (\\Sigma_B)} \\Delta$ iff (i) for the simple and inclusive integrated semantics, $(M_{\\rho_1; y'} (S; s_1), M_{\\rho_2; y'} (T; s_2)) \\in R^I_{\\text{universe}(M)}$; (ii) for the general integrated semantics, for each $x$, $y$ with $(x, M_{\\rho_1; y'} (S; s_1)) \\in M_R$ and $(y, M_{\\rho_2; y'} (T; s_2)) \\in M_R$, we have that $(x, y) \\in R^I_{M^R}$ and (iii) for the contextualised semantics, we have that $(M_{\\rho_1; y'} (S; s_1), M_{\\rho_2; y'} (T; s_2)) \\in R^I_{M^R}$. □\n\n**Example 41** If $O_1$ is an OWL ontology and $O_2$ is a FOL ontology, and $c = (s_1, s_2, R)$ is a correspondence in an alignment between $O_1$ and $O_2$, a theory internalising the semantics of $c$ along the translation from OWL to FOL defined in Example 13 and the identity translation on FOL is obtained according to the previous definition by internalising the semantics of $(y (s_1), s_2, R)$ in FOL, where $y$ is the symbol translation component of the logic translation from OWL to FOL. Similarly, correspondences between a MSFOL and a HOL ontology can be internalised in HOL by translating the MSFOL symbols to HOL.\n\nThe theory that internalises the semantics of a correspondence in an alignment $A$ will then have as signature the translation of the bridge signature of $A$ along a logic translation.\nlogic, though typically a less expressive logic suffices). This allows us to compute the bridge ontology \\( B \\) in the logic \\( L \\).\n\n**Definition 42 (Construction of the bridge ontology)** Let \\( S \\) be an ontology in a logic \\( L_1 \\) and \\( T \\) an ontology in a logic \\( L_2 \\), and let \\( A = \\{ c_i = (s'_i, s''_i, R_i) \\mid i \\in \\text{Ind} \\} \\) be an alignment between \\( S \\) and \\( T \\). For each \\( c_i \\), let \\( (\\Phi'(\\Sigma_B), \\Delta_i) \\) be a theory that internalises the semantics of \\( (s'_i, s''_i, R_i) \\) along \\( \\rho_1 = (\\Phi_1, \\alpha_1, \\beta_1, \\gamma_1, \\kappa_1) : L_1 \\rightarrow L \\) and \\( \\rho_2 = (\\Phi_2, \\alpha_2, \\beta_2, \\gamma_2, \\kappa_2) : L_2 \\rightarrow L \\). Then the diagram of \\( A \\) along \\( \\rho_1 \\) and \\( \\rho_2 \\) has the following shape:\n\n\\[\n\\begin{align*}\n(L_1, \\tilde{S}) & \\xrightarrow{\\rho_1, \\sigma_1} (L, B) & (L, B) & \\xrightarrow{\\rho_2, \\sigma_2} (L_2, \\tilde{T}) \\\\\n(L_1, \\tilde{S}) & \\xrightarrow{\\rho_1, \\sigma_1} (L, \\tilde{T}) & (L_2, \\tilde{T}) & \\xrightarrow{\\rho_2, \\sigma_2} (L, B)\n\\end{align*}\n\\]\n\nwhere \\( \\tilde{S}, \\tilde{T}, \\tilde{S}', \\tilde{T}' \\) and \\( t_1, t_2 \\) are constructed as in the previous section, depending on the choice of semantics for \\( A, B = (\\Phi'(\\Sigma_B), \\cup_{i \\in \\text{Ind}} \\Delta_i) \\), and \\( \\sigma_i \\) is an inclusion for \\( i = 1, 2 \\).\n\nIn [13], we discussed how the (approximation of a) colimit of such a heterogeneous diagram can be computed in general.\n\n**Example 42 (General integrated semantics in SROIQ)** We can now give the theories internalising the general integrated semantics of SROIQ correspondences involving roles. Note that both here and in the next example, while we prefer to use a syntax similar to Manchester syntax for OWL to improve readability, the theories are in FOL.\\(^{32}\\)\n\n\\[\n(r_1, r_2, =) \\text{ObjectProperty: } r_1 \\circ r_2 \\circ \\text{inverse}(r_5) \\\\\n\\text{EquivalentTo: } r_1 \\circ r_2 \\circ \\text{inverse}(r_7)\n\\]\n\n\\[\n(r_1, r_2, \\perp) \\text{ObjectProperty: } r_1 \\circ r_2 \\circ \\text{inverse}(r_5) \\\\\n\\text{DisjointWith: } r_1 \\circ r_2 \\circ \\text{inverse}(r_7)\n\\]\n\n\\[\n(r_1, r_2, <) \\text{ObjectProperty: } r_1 \\circ r_2 \\circ \\text{inverse}(r_5) \\\\\n\\text{SubPropertyOf: } r_1 \\circ r_2 \\circ \\text{inverse}(r_7)\n\\]\n\n\\[\n(r_1, r_2, >) \\text{ObjectProperty: } r_1 \\circ r_2 \\circ \\text{inverse}(r_7) \\\\\n\\text{SubPropertyOf: } r_5 \\circ r_1 \\circ \\text{inverse}(r_5)\n\\]\n\n\\(^{31}\\) We make the simplifying assumption that the logics \\( J_i \\) of the theories that internalise the semantics of all correspondences are the same. In practice, when this is not the case, there exists a logic \\( J \\) and logic translations \\( \\gamma_i : J \\rightarrow J \\), for each \\( i \\), and the theory obtained by translating \\((\\Sigma_i, \\Delta_i)\\) along \\( \\gamma_i \\) also internalises the semantics of \\( c_i \\).\n\n\\(^{32}\\) For example, the first theory is the abbreviation of \\( \\forall x, y . \\ (\\exists z_1, z_2 . \\ r_4(x, z_1) \\land r_1(z_1, z_2) \\land r_2(y, z_2)) \\iff (\\exists w_1, w_2 . \\ r_7(x, w_1) \\land r_5(w_1, w_2) \\land r_7(y, w_2)) \\).\n\n**Example 43 (Contextualised semantics in SROIQ)**\n\nWe can now give the theories internalising the contextualised semantics of the correspondences \\((r_1, r_2, =)\\) and \\((r_1, r_2, \\perp)\\), that are not expressible in SROIQ:\n\n\\[\n(r_1, r_2, =) \\text{ObjectProperty: } S : r_1 \\\\\n\\text{EquivalentTo: } \\text{inverse}(r_7) \\circ T \\circ r_5 \\circ T \\\\\n(r_1, r_2, \\perp) \\text{ObjectProperty: } S : r_1 \\\\\n\\text{DisjointWith: } \\text{inverse}(r_7) \\circ T \\circ r_5 \\circ T\n\\]\n\n**Example 44** [57] describes a tool for modelling mereotopological relations, based on a OWL formalisation, called MereoPtoD\\(^{33}\\) of the KGEMT mereotopological theory. This has been realised by extending an extremely simplified version of DOLCE (just a taxonomy of categories) with a hierarchy of roles. In order to integrate the information present in the resulting ontology and in the rich first-order axiomatisation of DOLCE,\\(^{34}\\) we will write a heterogeneous alignment:\n\n**alignment A : MEROPOD to DOLCE**\n\n- Particular = PT\n- Perdurant = PD\n- Endurant = ED\n- ...\n\nNote that we are making use of the correspondences between OWL and FOL introduced in Example 39. We assume that the translation from OWL to FOL introduced in Example 15 is included in the logic graph and denote it by \\( \\text{OWL} \\rightarrow \\text{FOL} \\). The diagram of the alignment will be\n\n\\[\n\\begin{align*}\n\\text{OWL} & \\xrightarrow{id_{\\text{owl}}} \\text{FOL} \\\\\n\\text{FT} & \\xrightarrow{id_{\\text{fol}}} \\text{FOL}\n\\end{align*}\n\\]\n\nwhere \\( id_{\\text{owl}} \\) and \\( id_{\\text{fol}} \\) are the identity translations on OWL and FOL. Thus, the OWL concepts on the left are identified with the first-order counterparts, and in the resulting colimit of the alignment, which will also be a FOL theory, they will inherit their full first-order axiomatisation.\n\n**Example 45** In [54], the authors develop a HOL ontology about physical facts, in particular heat. In a similar way as in Example 44, we construct a heterogeneous alignment between the multi-sorted version of DOLCE\\(^{35}\\) and the heat ontology of [54]:\n\n**alignment A : DOLCE to HEAT**\n\n\\[\nT = \\text{Time}, \\\\\nEV = \\text{Evt}, \\\\\n...\n\\]\n\n\\(^{33}\\) http://www.meteck.org/files/ontopartissup/MereoTopoD.owl.\n\n\\(^{34}\\) As described in http://www.loa.istc.cnr.it/old/Papers/D18.pdf.\n\nHere, we use the correspondences between MSFOL and HOL introduced in Example 40 and the translation from MSFOL to HOL introduced in Example 16.\n\nExample 46 Using the obvious generalisation of the institution comorphism from MSFOL to FOL [18, section 4.1] to a logic translation, we can define an alignment between the unsorted and the multi-sorted version of DOLCE.\n\n7 Representation Theorems for Networks of Ontologies\n\nIn the previous two sections, we have given a generalisation of relational (and general) networks to functional networks. The normalisation constructs a diagram of ontologies linked via ontology morphisms, in a way that depends on the choice of semantics for the alignments in a NeO. Since we assumed that for any two ontologies in a NeO there is an alignment between them, the resulting diagram will always be connected. In this section, we show that this normalisation process faithfully reflects the semantics, that is, the model class of a normalised network is isomorphic to that of the original network. Moreover, we show that in the case of logics admitting amalgamation, the model class of the normalised network is in turn isomorphic to that of its colimit.\n\nThis means that functional networks (and via normalisation also relational and general networks) can be represented by their colimit, and especially that reasoning about the network is equivalent to reasoning about the colimit. Since the colimit is a single ontology, this means that we have established a method for taking standard reasoning tools (designed for single ontologies) and reusing them for reasoning about networks. These reasoning aspects will be discussed in greater detail in the subsequent Sect. 8.\n\n7.1 Representation Theorems for Specific Semantics\n\nIn this section let $S = (\\langle O_i \\rangle_{i \\in \\text{Ind}}, \\langle A_{ij} \\rangle_{i,j \\in \\text{Ind}})$ be a network of aligned ontologies over a logic $L$. Let $D^{\\text{sim}}(S)$ be the union of all diagrams obtained by taking for each alignment $A_{ij}$ its diagram using simple semantics.\n\nTheorem 1 (Representation theorem for simple semantics) The following model classes are isomorphic:\n\n1. $\\text{Mod}^{\\text{sim}}(S)$\n2. the class of all families of models compatible with $D^{\\text{sim}}(S)$.\n\nProof We prove that an isomorphism between 1. and 2. exists.\n\nLet $M = (M^i)_{i \\in |D^{\\text{sim}}(S)|}$ be a family of models compatible with $D^{\\text{sim}}(S)$. By construction, $D^{\\text{sim}}(S)$ includes all ontologies $O_i$ and thus we get a family of models $(M^i)_{i \\in \\text{Ind}}$ by restricting $M$ to the indices in $\\text{Ind}$. We need to show that for each alignment $A_{ij} \\in S$, $M^i, M^j \\models S A_{ij}$, that is, $M^i, M^j \\models S c$ for each $c = (s_1, s_2, R)$ in $A_{ij}$. By definition this means that $M^i_t R^j U M^j_{t'}$, where $U$ is the shared universe of the ontologies in $S$. $U$ is shared because model reducts preserve the universe and $D^{\\text{sim}}(S)$ is connected. We know that if $b \\in |D^{\\text{sim}}(S)|$ is the node of the bridge ontology for $A_{ij}$, then $M^b_{O_i ; s_1} U M^b_{O_j ; s_2}$. By compatibility with the diagram we have\n\n$M^b_{O_i ; s_1} = M^i_t = M^i_s$ and $M^b_{O_j ; s_2} = M^j_{t'} = M^j_{s_2}$, where we denoted $i'$ and $j'$ the nodes of $S^t$ and $T^t$ (as in the construction of the diagram of $A_{ij}$ with the Definition 28) in $D$. Thus $(M^i)_{i \\in \\text{mod}}^{\\text{sim}}(S)$.\n\nNow let us assume that $M = (M^i)_{i \\in \\text{Ind}}$ is a model in $\\text{Mod}^{\\text{sim}}(S)$. For each alignment $A_{ij}$ we must give interpretations for the ontologies $S^t$, $T^t$ and $B$ in its diagram, since models for $S$ and $T$ are already provided by $M^i$ and $M^j$. We can interpret $S^t$ as $M^i_{|s_1}$ and $T^t$ as $M^j_{|s_2}$. The symbols from $B$ that come either from $O_i'$ or from $O_j'$ are interpreted in $M^b$ like in $M^i$ or, respectively, like in $M^j$. Since $M$ is in $\\text{Mod}^{\\text{sim}}(S)$, we know that $M^i_t R^j U M^j_{t'}$ for each $c_k = (s^k_1, s^k_2, R) \\in A_{ij}$. But by definition $M^b_{O_i ; s_1} = M^i_{s_1}$ and $M^b_{O_j ; s_2} = M^j_{s_2}$, which means that $M^b_{O_i ; s_1} U M^b_{O_j ; s_2}$. Since $(\\Sigma_B, \\Delta_k) \\Leftrightarrow c_k$ we get that $M^b \\models \\Delta_k$ and since $k$ is arbitrary, we get that $M^b \\in \\text{Mod}(B)$.\n\nWe need to show that the two constructions are inverse to each other. Let $M = (M^i)_{i \\in |D^{\\text{sim}}(S)|}$ be a family of models compatible with $D^{\\text{sim}}(S)$. With the first construction, we showed that by restricting to the indices in $\\text{Ind}$ we get a family of models $(M^i)_{i \\in \\text{Ind}}$ that is in $\\text{Mod}^{\\text{sim}}(S)$. By applying the second construction to this family of models, for each alignment $A_{ij}$ we obtain models $M^S$, $M^T$ and $M^B$ for the ontologies $S^t$, $T^t$ and $B$ of the diagram of $A_{ij}$. Let $i'$, $j'$, $b$ be the indices of these nodes in $D^{\\text{sim}}(S)$. We have that $M^S = M^i_{|s_1}$ and $M^T = M^j_{|s_2}$, where in both cases the second equality is ensured by the compatibility with the diagram. By compatibility with the diagram and the definition of $M^B$, $M^B$ and $M^b$ have the same universe and interpret each symbol of $\\Sigma_B$ in the same way, and thus must be equal.\n\nIn the other direction, let $M = (M^i)_{i \\in \\text{Ind}}$ be in $\\text{Mod}^{\\text{sim}}(S)$. With the second construction we extend this family of models to one compatible with $D^{\\text{sim}}(S)$. With the first construction we restrict the family obtained to the indices in $\\text{Ind}$. Since these models are not modified by the second\nconstruction, we get back \\( M \\). Thus, we have shown that the two constructions are isomorphic. \\( \\square \\)\n\n**Theorem 2 (Representation theorem for inclusive integrated semantics)** Let \\( D^{int}(S) \\) be the diagram of \\( S \\) obtained by taking the union of all diagrams of the alignments in \\( S \\) using inclusive integrated semantics. The following model classes are isomorphic:\n\n1. \\( \\text{Mod}^{int}(S) \\) and\n2. the class of all families of models compatible with \\( D^{int}(S) \\).\n\n**Proof** We prove that an isomorphism between 1. and 2. exists.\n\nLet \\( M = (M^{i})_{i \\in \\text{Ind}(S)} \\) be a family of models compatible with \\( D^{int}(S) \\). For each index \\( i \\in \\text{Ind} \\), \\( M^{i} \\) is a model of \\( rel_{L}(O_{i}) \\). Let \\( N = (\\beta_{\\text{Sig}(O_{i})}(M^{i}))_{i \\in \\text{Ind}} \\), where \\( \\beta \\) is the model reduct component of \\( rel_{L} \\) and the \\( i \\)-th component of \\( N \\) is denoted \\( N^{i} \\). We need to show that for each alignment \\( A_{ij} \\in S, N^{i} \\) is \\( \\models \\) \\( 1 \\) for \\( A_{ij}, \\) that is, \\( N^{i} \\) is a model of \\( \\text{rel}_{L}(A_{ij}) \\) for each \\( c \\). By definition this means that \\( N^{i}_{s_{1}}R^{i}_{1}N^{i}_{s_{2}} \\) for \\( U \\), \\( U \\) the global universe (which we know is shared as \\( D^{int}(S) \\) is connected and reduces preserve the universe). We know that, if \\( b \\in D^{int}(S) \\), is the node of the bridge ontology for \\( A_{ij} \\), \\( M^{b}_{O_{i};s_{1}}R^{i}_{1}M^{b}_{O_{j};s_{2}} \\). By compatibility with the diagram we have that \\( M^{b}_{s_{1}} = M^{b}_{O_{i};s_{1}} \\) and \\( M^{b}_{s_{2}} = M^{b}_{O_{j};s_{2}} \\). Using the compatibility conditions for the logic translation \\( \\text{rel}_{L} \\) we get that \\( N^{i}_{s_{1}} = M^{b}_{O_{i};s_{1}} \\) and \\( N^{i}_{s_{2}} = M^{b}_{O_{j};s_{2}} \\), and thus \\( N \\in \\text{Mod}^{int}(S) \\).\n\nNow let us assume that \\( M = (M^{i})_{i \\in \\text{Ind}} \\) is a model in \\( \\text{Mod}^{int}(S) \\) and the global diagram is the set \\( G \\). For each alignment \\( A_{ij} \\) we must give interpretations for the ontologies \\( \\tilde{S}, \\tilde{T}, \\tilde{T}' \\), \\( B \\) in its universe. Using the amalgamation property of \\( \\text{rel}_{L} \\), we know that there exists a unique model \\( N \\) of \\( \\text{rel}_{L}(O_{i}) \\) with universe \\( N = G \\) such that, if \\( N^{i} = N|_{\\text{Sig}(\\text{rel}_{L}(O_{i}))} \\), we have that \\( \\beta_{\\text{Sig}(O_{i})}(N^{i}) = M^{i} \\). We take thus \\( N^{i} \\) as the model of \\( \\tilde{S} \\) and \\( N^{j} \\) as the model of \\( \\tilde{T} \\). We can interpret \\( \\tilde{S} \\) as \\( N^{i}_{l} \\) and \\( \\tilde{T} \\) as \\( N^{j}_{l} \\). The symbols from \\( B \\) that come either from \\( \\tilde{S} \\) or from \\( \\tilde{T} \\) are interpreted in \\( M^{b} \\) like in \\( N^{i}_{l} \\) or, respectively, like in \\( N^{j}_{l} \\).\n\nSince \\( M \\) is in \\( \\text{Mod}^{int}(S) \\), we know that \\( M^{b}_{O_{i};s_{1}}R^{i}_{1}M^{b}_{O_{j};s_{2}} \\) for each \\( c_{k} = (s_{k}^{i}, s_{k}^{j}, R) \\in A_{ij} \\). By the compatibility conditions of \\( \\text{rel}_{L} \\), we get that \\( N^{i}_{s_{1}}R^{i}_{1}N^{j}_{s_{2}} \\) for each \\( c_{k} \\). But by definition \\( M^{b}_{O_{i};s_{1}} = N^{i}_{s_{1}} \\) and \\( M^{b}_{O_{j};s_{2}} = N^{j}_{s_{2}} \\), which means that \\( M^{b}_{O_{i};s_{1}}R^{i}_{1}M^{b}_{O_{j};s_{2}} \\). Since \\( (\\Sigma_{B}, \\Delta_{k}) \\equiv^{int} c_{k} \\) we get that \\( M^{b} \\models \\Delta_{k} \\) and since \\( k \\) is arbitrary, we get that \\( M^{b} \\in \\text{Mod}(B) \\).\n\nWe need to show that the two constructions are inverse to each other. Let \\( M = (M^{i})_{i \\in \\text{Ind}(S)} \\) be a family of models compatible with \\( D^{int}(S) \\). With the first construction, we showed that by restricting the indices in \\( \\text{Ind} \\) and taking the reduct along \\( \\text{rel}_{L} \\) we get a family of models \\( (N^{i})_{i \\in \\text{Ind}} \\) that is in \\( \\text{Mod}^{int}(S) \\). By applying the second construction to this family of models where the global domain \\( G \\) is set to the universe \\( U \\) of the models in \\( M \\), for each alignment \\( A_{ij} \\) we obtain models \\( M^{S}, M^{T}, M^{T'}, M^{B} \\) for the ontologies \\( S, T, T', B \\) of the diagram of \\( A_{ij} \\). Let \\( i, j, i', j' \\) be the indices of these nodes in \\( D^{int}(S) \\). First, notice that by construction the universes of \\( M^{S}, M^{T}, M^{T'}, M^{B} \\) are all equal with \\( U \\). For each symbol \\( s \\in \\text{Symbols}(\\text{Sig}(O_{i})) \\), we know that \\( (M^{S})_{s} = N^{i} = M^{i} \\). We know that \\( (M^{S})_{\\top} = \\text{universe}(N^{i}) = M^{i}_{\\top} \\). Thus \\( M^{S} = M^{i} \\). Then \\( M^{T} = M^{S}_{l} \\) and \\( M^{T'} = M^{i}_{l} \\) (because \\( M^{S} = M^{T} = M^{i} \\), the first and third equality follow from compatibility with \\( D^{int}(S) \\). In the same way we obtain that \\( M^{T} = M^{i} \\) and \\( M^{T'} = M^{i} \\). To prove that \\( M^{B} = M^{i} \\), let \\( s \\) be a symbol in \\( \\Sigma_{B} \\). If \\( s = O_{i} : s_{1}, \\) we know that \\( (M^{B})_{O_{i};s_{1}} = (M^{S})_{O_{i};s_{1}} = (M^{T})_{O_{i};s_{1}} = (M^{B})_{O_{i};s_{1}} \\). If \\( s = O_{i} : \\top, \\) by compatibility with \\( D^{int}(S) \\) we have that \\( (M^{B})_{O_{i};\\top} = (M^{S})_{O_{i};\\top} = (M^{T})_{O_{i};\\top} = (M^{B})_{O_{i};\\top} \\). Similarly we can show that \\( (M^{B})_{O_{i};\\top} = (M^{B})_{O_{i};\\top} \\). Thus \\( M^{B} = M^{i} \\) and \\( M^{B} \\) interpret all symbols of \\( \\Sigma_{B} \\) in the same way, and since they also have the same universe they are equal.\n\nIn the other direction, let \\( M = (M^{i})_{i \\in \\text{Ind}} \\) be a model in \\( \\text{Mod}^{int}(S) \\) and \\( G \\) be the global domain (that includes all universes of the models \\( M^{i} \\)). With the second construction we obtain a family of models \\( N = (N^{i})_{i \\in \\text{Ind}(S)} \\) compatible with \\( D^{int}(S) \\), such that for each \\( i \\in \\text{Ind} \\), the reduct of \\( N^{i} \\) along \\( \\text{rel}_{L} \\) is \\( M^{i} \\). By applying the first construction to \\( N \\), we build a model \\( M' = (M'(i))_{i \\in \\text{Ind}} \\) in \\( \\text{Mod}^{int}(S) \\) by taking \\( (M'(i))_{s} = (\\beta_{\\text{Sig}(O_{i})}(N^{i})) = M^{i} \\), so \\( M' = M \\). \\( \\square \\)\n\n**Theorem 3 (Representation theorem for general integrated semantics)** Let \\( D^{int}(S) \\) be the diagram obtained by taking the union of all diagrams of the alignment in \\( S \\) assuming general integrated semantics. The following model classes are isomorphic:\n\n1. \\( \\text{Mod}^{int}(S) \\) and\n2. the class of all families of models compatible with \\( D^{int}(S) \\).\n\n**Proof** Let \\( M = (M^{i})_{i \\in \\text{Ind}(S)} \\) be a family of models compatible with \\( D^{int}(S) \\). For each index \\( i \\in \\text{Ind}, M^{i} \\) is an expansion of a model \\( (M^{i})' \\) of \\( \\text{rel}_{L}(O_{i}) \\) with interpretation of \\( G \\) and \\( r_{O_{i}} \\). Let \\( N^{i} = \\beta_{\\text{Sig}(O_{i})}(M'(i)) \\) for \\( i \\in \\text{Ind} \\) and let \\( N = (N^{i})_{i \\in \\text{Ind}} \\). Using the properties of \\( \\text{rel}_{L} \\) we know that\n\n\\( \\copyright \\) Springer\nLet $M = ((M^i)_{i \\in Ind})$ be a model in $\\Mod^{\\text{int}}(S)$ with equalising functions $(\\gamma_i : \\text{universe}(M^i) \\to U)_{i \\in Ind}$ and $X$ is a set that includes the global domain $U$ and the universes of all models $M^i$ in $M$. For each alignment $A_{ij}$ in $S$, we must give interpretations for the ontologies $\\hat{S}, \\hat{T}, \\hat{S}', \\hat{T}'$ and $B$ in the diagram of $A_{ij}$. Let $i, j, i', j'$ be the indices of these nodes in $\\mathcal{D}^{\\text{int}}(S)$ and we look for models $M^i_1, M^i_2, M'^i_1, M'^i_2$ and $M^i_{\\text{ref}}$. Using the amalgamation property of $rel_L$, we know that there exists a unique model $N$ of $rel_L(O_i) \\cup rel_L(O_j)$ with $\\text{universe}(N) = X$ such that, if we denote $N^i = N|\\text{Sig}(rel_L(O_i))$ and $N^j = N|\\text{Sig}(rel_L(O_j))$, we have that $\\beta_{\\text{Sig}(rel_L(O_i))}(N^i) = M^i_1$ and $\\beta_{\\text{Sig}(rel_L(O_j))}(N^j) = M^j_1$ (since $X$ includes the universes of $M^i_1$ and $M^j_1$). We can take thus $M^i_1$ as the model of $\\hat{S}$ that interprets all symbols of $rel_L(O_i)$ as in $N^i$, the symbol $G$ as $U$ and the symbol $r_{O_i}$ as the inverse of $\\gamma_i$. Similarly, $M^i_2$ is the model of $\\hat{T}$ that interprets all symbols of $rel_L(O_j)$ as in $N^j$, the symbol $G$ as $U$ and the symbol $r_{O_j}$ as the inverse of $\\gamma_j$. The models $M^i_1$ and $M^j_1$ are $M^i_{\\text{ref}}$ and, respectively, $M^j_{\\text{ref}}$. We have left to define the model $M^i_{\\text{ref}}$. Its universe is $X$. The symbols from $B$ that come from $\\hat{S}$ or $\\hat{T}$ are interpreted in $M^i_{\\text{ref}}$ like in $M^i_1$ or, respectively, like in $M^j_1$. Since $\\gamma_i$ and $\\gamma_j$ are functions, their inverses are inverse-functional and right total. For each correspondence $c_k = (s, t, R) \\in A_{ij}$, we must show that $M^b_{\\text{ref}} \\models \\Delta_k$, where $(\\Sigma_{\\mathcal{B}}, \\Delta_k) \\equiv^{\\text{int}} c_k$. By definition, it suffices to show that if $x, y \\in (M^b_{\\text{ref}})$ such that $(x, (M^i_{\\text{ref}})_{O_{ij}:3}) \\in (M^i_{\\text{ref}})_{rs}$ and $(y, (M^j_{\\text{ref}})_{O_{ij}:3}) \\in (M^j_{\\text{ref}})_{rt}$, we have that $(x, y) \\in R^i_{\\text{Sig}(rel_L(O_i))}$. But using the definitions of the interpretations of the symbols and of the relations $rs$ and $rt$ in $M^b$, this amounts to showing that $(\\gamma_i(M^i_1), \\gamma_j(M^j_1)) \\in R^i_{\\text{Sig}(rel_L(O_i))}$ and this holds because $M$ is a model for $S$.\n\nWe need to show that the two constructions are inverse to each other. Let $M = ((M^i)_{i \\in \\mathcal{D}^{\\text{int}}(S)})$ be a family of models compatible with $\\mathcal{D}^{\\text{int}}(S)$. With the first construction we restrict to indices in $\\text{Ind}$ and take for each such index $i$ the reduct of $M^i|\\text{Sig}(rel_L(O_i))$ along $rel_L$ to obtain a family of models $N = (N^i)_{i \\in \\text{Ind}}$ that is in $\\Mod^{\\text{int}}(S)$ with the equalising functions $\\gamma_i : M^i_{O_{ij}:T} \\to M^b_i$ defined by $\\gamma_i(x) = y$ iff $(y, x) \\in M^i_{\\text{ref}}$. The compatibility of $M$ with $\\mathcal{D}^{\\text{int}}(S)$ ensures that $G$ is interpreted in the same way in all models and that $\\gamma_i$ are indeed functions. With the first construction for $N$ and the universe of $M^i$, which we know is the same for each $i \\in \\mathcal{D}^{\\text{int}}(S)$ because $\\mathcal{D}^{\\text{int}}(S)$ is connected, we obtain a family of models $M_1$ compatible with $\\mathcal{D}^{\\text{int}}(S)$. We must show that $M = M_1$. Let $i, j, i', j', b$ be the nodes in $\\mathcal{D}^{\\text{int}}(S)$ of the diagram of the alignment $A_{ij}$. First notice that by construction the universes of the models in $M_1$ are equal with the universes of models in $M$. Moreover, $(M^i)_{G} = M^b_i$ and $(M^i)_{r_{O_i}} = M^i_{\\text{ref}}$. For each $s \\in \\text{Symbols}(\\text{Sig}(O_i)), (M^i)^s = N^i_{s}$ and moreover $(M^i)_{\\text{top}} = \\text{universe}(N^i)$. Thus $(M^i)^{i'} = M^i_{\\text{top}}$. Similarly $(M^i)^{j'} = M^j_{\\text{top}}$. Thus using the compatibility with $\\mathcal{D}^{\\text{int}}(S)$ we get $(M^i)^{j'} = (M^i)^{i'} = (M^j)^{i'} = M^i_{\\text{top}}$ and the same for $j'$. Finally, $M^b_{\\text{top}}$ and $(M^j)^{i'}$ are equal because by construction they interpret symbols in the same way as in equal models.\n\nIn the other direction, let $M = ((M^i)_{i \\in \\text{Ind}})$ be a model in $\\Mod^{\\text{int}}(S)$ with equalising functions $(\\gamma_i : \\text{universe}(M^i) \\to U)_{i \\in \\text{Ind}}$. The set $X$ that we use as a parameter for the universe is $U \\cup \\bigcup_{i \\in \\text{Ind}} \\text{universe}(M^i)$. With the second construction for $M$ and $X$ we obtain a family of models $N = (N^i)_{i \\in \\mathcal{D}^{\\text{con}}(S)}$ compatible with $\\mathcal{D}^{\\text{int}}(S)$ such that for each $i \\in \\text{Ind}$ the reduct of $N^i|\\text{Sig}(rel_L(O_i))$ along $rel_L$ is $M^i_{\\text{ref}}$. Thus, by applying the first construction to $N$, we get back $M$. \n\n\\end{proof}\n\nTheorem 4 (Representation theorem for contextualised semantics) Let $\\mathcal{D}^{\\text{con}}(S)$ be the diagram obtained by taking the union of all diagrams of the alignments in $S$ assuming contextualised semantics. The following model classes are isomorphic:\n\n1. $\\Mod^{\\text{con}}(S)$ and\n2. the class of all families of models compatible with $\\mathcal{D}^{\\text{con}}(S)$.\n\nProof Let $M = ((M^i)_{i \\in \\mathcal{D}^{\\text{con}}(S)})$ be a family of models compatible with $\\mathcal{D}^{\\text{con}}(S)$. For each index $i \\in \\text{Ind}$, $M^i$ is a model of $rel_L(O_i)$. If $\\beta$ be the model reduct component of $rel_L$, let $N = (\\beta_{\\text{Sig}(O_i)}(M^i))_{i \\in \\text{Ind}}$ and let $N^i$ be the $i$-th component of $N$. Using the property of $rel_L$ for each alignment $A_{ij}$ in $S$, we have that $M^i_{\\text{top}} = M^b_{O_{ij}:T} = \\text{universe}(N^i)$ and similarly $M^i_{\\text{top}} = M^b_{O_{ij}:T} = \\text{universe}(N^i), b$ is the node of the bridge of $A_{ij}$. This allows us to define $r_{ij} = M^b_{rs,ij}$. We need to show that for each alignment $A_{ij}$ in $S$, $N^i, N^j \\models c$ for each $c = (s_1, s_2, R) \\in A_{ij}$. By definition this means $N^i_{s_1} \\cap r_{ij}(N^j_{s_2})$, where $U$ is the universe of $N^i$. But $N^i_{s_1} = \\dots$\n(by compatibility properties of \\( rel_L \\)) \\( M^i_{s_1} = (M^i_{s_1}) \\) (by compatibility with the diagram) \\( M^b_{O_{j,s_1}} \\). Similarly, \\( N_{s_2} = M^b_{O_{j,s_2}} \\).\n\nThus, taking into account also the definition of \\( r_{ji} \\), we need to show that \\( M^b_{O_{j,s_1}} R^i_{U_{O_{i,T}}} M^b_{O_{j,s_2}} \\). This follows from \\( M^b \\models \\Delta \\), which in particular means that \\( M^b \\models \\Delta_i \\), where \\((\\Sigma_B, \\Delta_i) \\equiv^S \\).\n\nNow, let \\( M = \\{(M^i_{s_1})_{i \\in I}, (r_{ij})_{i,j \\in I} \\} \\) be a contextualised model in \\( \\text{Mod}^{con}(S) \\) and let \\( U \\) be a set that includes \\( \\cup_{i \\in I} \\text{universe}(M^i) \\). We must define a family of models compatible with \\( D^{con}(S) \\). For each alignment \\( A_{ij} \\) we must give models for the ontologies \\( S, T, S^\\prime, T^\\prime \\) and \\( B \\) in its diagram. Using the amalgamation property of \\( rel_L \\), there is a unique model \\( N \\) of \\( rel_L(O_i) \\cup rel_L(O_j) \\) with \\( \\text{universe}(N) = U \\) and such that, if we denote \\( \\hat{N}^i = N|_{\\text{Sig}(rel_L(O_i))} \\) and \\( \\check{N}^j = N|_{\\text{Sig}(rel_L(O_j))} \\), we have that \\( \\hat{\\beta}_{\\Sigma_O}^{rel_L}(\\hat{N}^i) = M^i \\) and \\( \\check{\\beta}_{\\Sigma_O}^{rel_L}(\\check{N}^j) = M^j \\). This gives us the needed models \\( N^i \\) for \\( S \\) and \\( N^j \\) for \\( T \\). The models for \\( S^\\prime \\) and \\( T^\\prime \\) are \\( N^i_{|_S} \\) and, respectively, \\( N^j_{|_S} \\). The model of \\( B \\) is obtained by interpreting each symbol coming from \\( S^\\prime \\) like in \\( N^i_{|_S} \\) and, similarly from \\( T^\\prime \\) like in \\( N^j_{|_S} \\), the relativised top concepts \\( O_t : T \\) as \\( \\text{universe}(N^i) \\) and \\( O_j : T \\) as \\( \\text{universe}(N^j) \\), and the relation \\( r_{TS} \\) as \\( r_{ji} \\).\n\nThus, we get that the resulting model \\( N^b \\) is indeed a \\( \\Delta \\)-model: we need to show that \\( \\hat{N}^b_{O_{j,s_2}} R^b_{\\langle O_{j,s_1} \\rangle} \\check{N}^b_{O_{j,s_2}} \\), which, with a similar argument as for the previous implication, amounts to \\( M_{s_1}^i R^i_{\\langle O_{i,T_s} \\rangle} M_{s_2}^j \\), and this holds because \\( \\{(M^i_{s_1})_{i \\in I}, (r_{ij})_{i,j \\in I} \\} \\in \\text{Mod}^{con}(S) \\).\n\nWe need to show that the two constructions are inverse to each other. Let \\( M = (M^i_{s_1})_{i \\in D^{con}(S)} \\) be a family of models compatible with \\( D^{con}(S) \\). With the first construction, we showed that by restricting to the indices in \\( I \\) and taking the reduce along \\( rel_L \\) we get a family of models \\( (N^i)_{i \\in I} \\) and relations \\( r_{ji} = M^b_{r_{TS}} \\) for each \\( A_{ij} \\) where \\( b \\) is the node of the bridge ontology of \\( A_{ij} \\) such that \\( \\{(M^i_{s_1})_{i \\in I}, (r_{ij})_{i,j \\in I} \\} \\in \\text{Mod}^{con}(S) \\). By applying the second construction to this family of models and to the universe \\( U \\) of \\( M^i \\), which we know is unique by compatibility with the diagram, for each alignment \\( A_{ij} \\) we obtain models \\( M^{S^\\prime}, M^T, M^{S^\\prime}, M^T \\) and \\( M^b \\) for the ontologies \\( S, T, S^\\prime, T^\\prime \\) and \\( B \\) of the diagram of \\( A_{ij} \\). Let \\( i, i', j, j' \\), \\( b \\) be the indices of these nodes in \\( D^{con}(S) \\). First, notice that the universes of \\( M^{S^\\prime}, M^T, M^{S^\\prime}, M^T \\) and \\( M^b \\) are all equal with \\( U \\). For each symbol \\( s \\in \\text{Symbols}(\\text{Sig}(O_i)) \\), we know that \\( (M^{S^\\prime})_s = N^i_{s} = M^i_{s} \\).\n\nWe know that \\( (M^{S^\\prime})_{top} = \\text{universe}(N^i) = M^b_{top} \\). Thus \\( M^{S^\\prime} = M^i \\). Then \\( M^{S^\\prime} = M^{S^\\prime}_{i_1} = M_{i_1}^i \\) (because \\( M^i = M^{S^\\prime} = M^{T} \\), where the first and third equality follow from compatibility with \\( D^{con}(S) \\). In the same way we obtain that \\( M^T = M^i \\) and \\( M^T = M^i \\). To prove that \\( M^b = M^b \\), let \\( s \\) be a symbol in \\( \\Sigma_B \\). If \\( s = O_i : s_1 \\), we know that \\( (M^b)_{O_{j,s_1}} = (M^S)_{O_{j,s_1}} = (M^i)_{O_{j,s_1}} = (M^b)_{O_{j,s_1}} \\). If \\( s = O_j : s_2 \\), we know that \\( (M^b)_{O_{j,s_2}} = (M^T)_{O_{j,s_2}} = (M^b)_{O_{j,s_2}} \\). If \\( \\beta^b \\) is the isomorphism between the class \\( \\text{Mod}^{sem}(S) \\) of models of a \\( \\text{NeO} S = ((O_i)_{i \\in I}, (A_{ij})_{i,j \\in I}) \\) and the class \\( \\text{Mod}(D^{sem}(S)) \\) of models of compatible with \\( D^{sem}(S) \\). The isomorphism is given by \\( (M^i)_{i \\in (D^{sem}(S))} \\in \\text{Mod}(D^{sem}(S)) \\mapsto (\\beta^b(M^i))_{i \\in I} \\in \\text{Mod}^{sem}(S) \\).\n\nThe colimit ontology \\( C^{sem}(S) \\) of \\( D^{sem}(S) \\) exactly represents models of networks in the following sense:\n\n**Corollary 1** In all four semantics, if the underlying logic is amalgamable, there is an isomorphism between the class \\( \\text{Mod}^{sem}(S) \\) of models of a \\( \\text{NeO} S \\) and the class \\( \\text{Mod}(C^{sem}(S)) \\) of models of the colimit ontology \\( C^{sem}(S) \\) of the diagram \\( D^{sem}(S) \\). The isomorphism is given by \\( C \\in \\text{Mod}(C^{sem}(S)) \\mapsto (\\beta^c(C_{\\mid_{I_0}}))_{i \\in I_0} \\in \\text{Mod}^{sem}(S) \\).\n\nIf we only have weak amalgamation, the construction still works, but it is not necessarily an isomorphism:\n\n**Corollary 2** Let \\( S \\) be a \\( \\text{NeO}, D^{sem}(S) \\) its diagram and \\( C^{sem}(S) \\) the colimit. In all four semantics, for each model\nC of $C^\\text{sem}(S)$, $(\\beta^*(C_i)_{i \\in \\text{Ind}})$ in $\\text{Mod}^\\text{sem}(S)$. Moreover, if the underlying logic is weakly amalgamable (or at least has weak amalgamation of pushouts), for each model $(M^i)_{i \\in \\text{Ind}}$ in $\\text{Mod}^\\text{sem}(S)$, there is a model $C$ of $C^\\text{sem}(S)$ such that $\\beta^*(C_i) = M^i$, where $\\mu_i$ is the structural morphism of the colimit of $D^\\text{sem}(S)$, for each $i \\in \\text{Ind}$.\n\n**Proof** By Theorem 5, Proposition 1 and the definition of weak amalgamation. □\n\nIn the heterogeneous case, to be able to state representation theorems we must adapt the definitions in Sect. 4 to a heterogeneous setting. With this modification, the proofs of the representation theorem follow using similar arguments as for their homogeneous counterparts, and therefore we do not spell them in detail here. Moreover, since in general we can obtain just a weakly amalgamable cocone for a heterogeneous diagram, Corollary 1 does not hold in all cases, while Corollary 2 still holds in the heterogeneous case, where $C^\\text{sem}(S)$ is now a weakly amalgamable cocone for $D^\\text{sem}(S)$.\n\n### 7.3 Structuring and Non-monotonic Constructs in DOL\n\nSo far, we have assumed that all ontologies used in networks of alignments are flat, i.e. consist of a signature and a flat set of axioms. In reality, large ontologies are formulated in a more structured way. For example, both OWL and DOL provide an import construct, such that existing ontologies can be reused, avoiding repetition. DOL also provides more complex structuring constructs for ontologies such as union, forgetting or module extraction, as well as combination (=colimit) of networks. However, these constructs can be flattened out, which means that any structured ontology can be transformed into an equivalent flat, i.e. unstructured ontology. Hence, one can perform the flattening before applying the above representation theorems (and the reasoning mechanisms of Sect. 8).\n\nDOL also provides non-flattenable constructs such as hiding (restriction to an export interface) or minimisation. The latter imposes a non-monotonic closed-world assumption and is equivalent to McCarthy’s circumscription. Details can be found in [59,62,68]. These constructs cannot be flattened. Still, we can make them interact with our diagram and colimit constructions as follows: each non-flattenable ontology in a NeO is replaced by its signature. Moreover, the colimit of the diagram for the NeO is united (using a DOL union) with each thus replaced ontology, renamed (using DOL renaming) along the injection of its signature into the colimit. Of course, the resulting ontology is a non-flattenable ontology again. This means that the reasoning mechanisms of Sect. 8 are generally not directly applicable. Instead, more specialised reasoning has to be invoked, depending on the nature of the involved DOL constructs. Note that our approach still allows the elimination of (networks of) alignments for such reasoning tasks. That is, the remaining problem is that of general reasoning for non-flattenable DOL constructs (which is beyond the scope of this paper).\n\nIn a similar way, other non-monotonic logics such as F-logic, RIF or answer set programming can be combined with our framework. However, the non-monotonic aspects of these logics can possibly not be expressed in DOL, but rather require more specialised non-monotonic constructs.\n\n### 8 Reasoning with Networks of Ontologies\n\nIn the previous section we have established a number of representation results showing that under mild conditions (logics admitting amalgamation), the model class of a normalised network is isomorphic to the model class of its colimit.\n\nAs a result, functional networks as well as relational and general networks (via normalisation) can be represented by their colimit. This implies in particular, as we will see below, that determining the logical consequences of a network can be reduced to reasoning in the colimit ontology of the network, a single ontology. This reduction will give an important handle on tool reuse, as we will discuss in greater detail in Sect. 8.6.\n\n#### 8.1 Logical Consequence in Networks of ontologies\n\nWe define logical consequence in a NeO as follows:\n\n**Definition 43 (Logical consequence of networks)** Given a NeO $S = ((O_i)_{i \\in \\text{Ind}}, (A_{ij})_{i,j \\in \\text{Ind}})$, an index $i \\in \\text{Ind}$ and a sentence $\\varphi$ over the signature of $O_i$, we say that $\\varphi$ is a logical consequence of $S$ w.r.t. the semantic assumption $\\text{sem}$ for $S$, where $\\text{sem} \\in \\{\\text{sim}, \\text{iint}, \\text{gint}, \\text{con}\\}$, in symbols:\n\n$$S \\models^\\text{sem} (i, \\varphi)$$\n\nif for all $(M^i)_{i \\in \\text{Ind}}$ in $\\text{Mod}^\\text{sem}(S)$, we have $M^i \\models \\varphi$. □\n\nThe four theorems above imply that we can use the colimit to reason about the consequences of a NeO.\n\n**Corollary 3** Let $S = ((O_i)_{i \\in \\text{Ind}}, (A_{ij})_{i,j \\in \\text{Ind}})$ be a NeO. Reasoning in the colimit $C^\\text{sem}(S)$ of its normalisation is complete for reasoning about $S$, in either of the four semantics. More precisely, let $\\mu_i : \\text{Sig}(O_i) \\rightarrow \\text{Sig}(C^\\text{sem}(S))$ be the colimit injection for the node corresponding to $O_i$ in $D^\\text{sem}(S)$. Then\n\n$$S \\models^\\text{sem} (i, \\varphi) \\implies C^\\text{sem}(S) \\models \\mu_i(\\alpha^*(\\varphi))$$\n\n37 See [61] for the formalisation of the monotonic part of F-logic as an institution.\n\n38 The DOL syntax is: \\texttt{entailment} $c = i \\text{ in } S \\text{ entails } \\{ \\varphi \\}$, where $c$ is some name for the entailment.\nWe have completeness and soundness, that is\n\\[ S \\models^\\text{sem} (i, \\varphi) \\text{ iff } C^\\text{sem}(S) \\models \\mu_i(\\alpha^*(\\varphi)) \\]\nunder the condition that the logic admits weak amalgamation (at least of pushouts).\n\n**Proof** Assume \\( S \\models^\\text{sem} (i, \\varphi) \\).\n\nLet \\( C \\) be a model of \\( C^\\text{sem}(S) \\) and let \\( M^i = \\beta^*(C|\\mu_i) \\). Then by Corollary 2, \\( (M^i)_{i \\in \\text{Ind}} \\) is in \\( \\text{Mod}^\\text{sem}(S) \\). Hence by the assumption \\( S \\models^\\text{sem} (i, \\varphi) \\), we obtain \\( \\beta^*(C|\\mu_i) = M^i \\models \\varphi \\).\n\nBy the satisfaction condition for \\( \\alpha^* \\) and \\( \\beta^* \\), we get \\( C|\\mu_i \\models \\alpha^*(\\varphi) \\), and by that for \\( \\mu_i \\), we finally obtain \\( C \\models \\mu_i(\\alpha^*(\\varphi)) \\). Since \\( C \\) is arbitrarily chosen, we get \\( C^\\text{sem}(S) \\models \\mu_i(\\alpha^*(\\varphi)) \\).\n\nConversely, assume \\( C^\\text{sem}(S) \\models \\mu_i(\\alpha^*(\\varphi)) \\). We want to show \\( S \\models^\\text{sem} (i, \\varphi) \\). Let \\( (M^i)_{i \\in \\text{Ind}} \\) be a model of \\( S \\) according to the chosen semantics \\( \\text{sem} \\). By weak amalgamation (or by Proposition 1 in case we have only weak amalgamation of pushouts), we can apply Corollary 2 and obtain a model \\( C \\) of the colimit \\( C^\\text{sem}(S) \\) such that \\( \\beta^*(C|\\mu_i) = M^i \\) for each \\( i \\in |D^\\text{sem}(S)| \\). By the assumption, we obtain \\( C \\models \\mu_i(\\alpha^*(\\varphi)) \\).\n\nBy the satisfaction condition for \\( \\mu_i \\) and that for \\( \\alpha^* \\) and \\( \\beta^* \\), we get that \\( M^i = \\beta^*(C|\\mu_i) \\models \\varphi \\). But this is just \\( (M^i)_{i \\in \\text{Ind}} \\models (i, \\varphi) \\).\n\nOne drawback of reasoning in the colimit ontology is that it includes all symbols and all sentences of the ontologies in the network, and this may lead to inefficient proof search. On the other hand, we can take advantage of the fact that the structure of the NeO has been explicitly specified as a DOL network to reason locally, in just one ontology of the network, instead of globally, in the colimit, whenever the goal involves only symbols of the respective ontology.\n\n**Proposition 3** Local reasoning is sound for global reasoning, that is,\n\\[ O_i \\models \\varphi \\implies S \\models^\\text{sem} (i, \\varphi) \\]\n\n**Proof** Let \\( (M^i)_{i \\in \\text{Ind}} \\) be a model in \\( \\text{Mod}^\\text{sem}(S) \\). Then \\( M^i \\) is a model of \\( O_i \\). By the assumption, \\( M^i \\models \\varphi \\).\n\nThe converse of Proposition 3 does not hold in general:\n\n**Example 47** Consider the following two simple ontologies formalised in SROIQ.\n\\[ O_1 = \\{C \\subseteq D; a : B\\} \\text{ and } O_2 = \\{a : E; b : D\\} \\]\n\nAssume that the concepts \\( C, D \\in O_1 \\) and \\( E \\in O_2 \\), and individuals \\( a \\in O_1 \\) and \\( a \\in O_2 \\) are aligned in DOL, assuming simple semantics, as follows:\n\nalignment A: \\( O_1 \\) to \\( O_2 = \\)\n\\[\n\\begin{align*}\nC &> E, \\\\\nD &< D, \\\\\na &= a\n\\end{align*}\n\\]\nend\n\nThat is, \\( a \\in O_1 \\) and \\( a \\in O_2 \\) are asserted to be the same individual, \\( C \\) a superclass of \\( E \\), and \\( D \\) in \\( O_1 \\) a subclass of \\( D \\) in \\( O_2 \\). Then it is easy to verify that we have \\( S \\models^\\text{sem} (i, a : D) \\) for \\( i = 1, 2 \\), although it holds that \\( O_1 \\not\\models a : D \\).\n\nThe converse of Proposition 3 does hold in case of conservativity:\n\n**Definition 44** A NeO \\( S \\) is conservative for some ontology \\( O_i \\) in \\( S \\), if each model \\( M^i \\) of \\( O_i \\) can be expanded to a model \\( (M^i)_{i \\in \\text{Ind}} \\) of \\( S \\).\n\n**Proposition 4** If \\( S \\) is conservative for \\( O_i \\), local reasoning in \\( O_i \\) is complete for global reasoning for \\( O_i \\)-sentences, that is,\n\\[ S \\models^\\text{sem} (i, \\varphi) \\implies O_i \\models \\varphi \\]\n\n**Proof** Assume \\( S \\models^\\text{sem} (i, \\varphi) \\). Let \\( M^i \\) be a model of \\( O_i \\). By conservativity, \\( M^i \\) can be expanded to a model \\( (M^i)_{i \\in \\text{Ind}} \\) in \\( \\text{Mod}^\\text{sem}(S) \\). By assumption, \\( (M^i)_{i \\in \\text{Ind}} \\models (i, \\varphi) \\), that is, \\( M^i \\models \\varphi \\).\n\nIn a sense, this shows that the network \\( S \\) does not propagate any new information into ontology \\( O_i \\), and hence from the perspective of \\( O_i \\), the network is not needed. (Note however that still \\( O_i \\) could propagate information into other ontologies.)\n\nFor the next result, we need conservativity of theory morphisms.\n\n**Definition 45** A theory morphism \\( \\sigma: O_1 \\rightarrow O_2 \\) is (model-theoretically) conservative if each \\( O_1 \\) model \\( M^1 \\) has a \\( \\sigma \\)-expansion to an \\( O_2 \\)-model.\n\nWe can reduce conservativity of functional networks to ordinary conservativity of ontology extensions, which are special theory morphisms:\n\n**Proposition 5** In institutions with amalgamation (amalgamation of pushouts), conservativity of a functional (connected functional) network \\( S \\) for \\( O_i \\) is equivalent to conservativity of the inclusion ontology morphism \\( \\mu_i: O_i \\rightarrow C^\\text{sem}(S) \\), for each of the four semantics \\( \\text{sem} \\).\n\n**Proof** By Corollary 1.\n8.2 Satisfiability\n\nAn important property of NeOs is their satisfiability, i.e. existence of a distributed model. Unsatisfiability of a NeO indicates contradictory knowledge in the associated ontologies, or alignments that do not match with the intended meaning of the aligned symbols.\n\nSatisfiability can be shown using the colimit:\n\n**Proposition 6** Let S be a NeO. Satisfiability of the colimit $C^{sem}(S)$ is sufficient for satisfiability of S. In case of (weak) amalgamation (of at least pushouts), it is also necessary.\n\n**Proof** Immediate from Corollary 2. □\n\nLet S be a NeO.\n\n**Definition 46** We say that S is\n\n- simple-satisfiable if there is a simple model of S.\n- inclusive-integrated-satisfiable if there is an inclusive integrated model of S.\n- general-integrated-satisfiable if there is a general integrated model of S\n- contextualised-satisfiable if there is a contextualised model of S. □\n\nFirst, notice that if S is inclusive-integrated-satisfiable, it is also general-integrated-satisfiable, as the first notion is more restrictive.\n\nThe following proposition allows us to reduce the problem of checking satisfiability of a NeO using any of the four semantics to checking its satisfiability using simple semantics. This has the advantage of generating a less complex colimit ontology, as the relativisations are not involved.\n\n**Proposition 7** If S is simple-satisfiable, it is also inclusive-integrated-satisfiable (and therefore also general-integrated-satisfiable) as well as contextualised-satisfiable.\n\n**Proof** Let us assume that S is simple-satisfiable. Then there exists a model $(M^i)^i \\in Ind$ in $Mod^{sem}(S)$ and we know that universe($M^i$) = universe($M^j$) = $U$ for any $i, j \\in Ind$. Then $((M^i)^i \\in Ind, (\\mu_i)^i \\in Ind)$, where $\\mu_i = i|_U$ for each $i \\in Ind$, is an inclusive integrated model of S, since for any $i, j \\in Ind$ and any $(s_1, s_2, R) \\in A_{ij}$, we have that $\\mu_i(M^i_{s_1})R^j_{s_2}\\mu_j(M^j_{s_2})$, because $M^i_{s_1}R^j_{s_2}M^j_{s_2}$. $(M^i)^i \\in Ind, (\\mu_i)^i \\in Ind)$ is a contextualised model for S, where for each $i, j \\in Ind$ $r_{ij} = \\{(x, x) \\mid x \\in U\\}$, since for any $i, j \\in Ind$ and any $(s_1, s_2, R) \\in A_{ij}$, we have that $M^i_{s_1}R^j_{s_2}M^j_{s_2}$. □\n\nFor OWL we can also prove that if S is inclusive-integrated-satisfiable, then it is also simple-satisfiable. The result does not hold in general, e.g. not in FOL, where quantifiers now range over a larger universe, possibly changing the satisfaction of formulas.\n\n8.3 Reasoning About Correspondences\n\nIn Sect. 8.1, we have considered the question whether an individual sentence is a logical consequence of a network of ontologies. Now we extend this to correspondences:\n\n**Definition 47** (Correspondence following from a network) For each of the four semantics, given a NeO $S = ((O_i)^i \\in Ind, (A_{ij})_{i, j \\in Ind})$ and indices $i, j \\in Ind$, a correspondence $c = (s_i, s_j, R)$ between $O_i$ and $O_j$ is said to be a logical consequence of $S$, in symbols:$^{39}$\n\n$S \\models^{sem} (i, j, c),$\n\nif for all models $(M^i)^i \\in Ind$ in $Mod^{sem}(S)$, we have $M^i, M^j \\models c$. □\n\nFor reasoning about correspondences, we can use the representation theorems of Sect. 7.1 as well. Recall that for a NeO $S$, in Sect. 7.1 we have constructed the diagram $D^{sem}(S)$ by collecting all W-diagrams corresponding to the alignments in S. Recall from Definition 28 that the bridge ontology of such a W-diagram contains, for each correspondence in the alignment, an internalisation ($\\Sigma_B, \\Delta$) according to Definition 31.\n\n**Proposition 8** Let $S = ((O_i)^i \\in Ind, (A_{ij})_{i, j \\in Ind})$ be a NeO and let $c = (s_i, s_j, R)$ be a correspondence between $O_i$ and $O_j$. Let $(\\Sigma^b, \\Delta) \\models^{sem} c$, where sem in $\\{sim, int, gint, con\\}$ and $\\Sigma^b$ is the signature of the node b of the bridge ontology of $A_{ij}$. Let $C^{sem}(S)$ be the colimit of $D^{sem}(S)$, and $\\mu_b : \\Sigma^b \\rightarrow \\text{Sig}(C^{sem}(S))$ be the colimit injection for $\\Sigma^b$. Then\n\n$S \\models^{sem} (i, j, c)$ implies $C^{sem}(S) \\models \\mu_b(\\Delta)$\n\nand equivalence holds for logics admitting weak amalgamation (at least of pushouts).\n\n**Proof** Assume that $S \\models^{sem} (i, j, c)$. Let C be a model of the colimit $C^{sem}(S)$. Let $M^k = \\beta^k(C|_{\\mu_k})$ for $k \\in |D(S)|$. Then by Corollary 2, $(M^k)^k \\in Ind \\in Mod^{sem}(S)$. Hence by the assumption $S \\models^{sem} (i, j, c)$, we get that $M^i, M^j \\models^{sem} c$. By compatibility with the diagram and $(\\Sigma^b, \\Delta) \\models^{sem} c$, this means that $C|_{\\mu_b} \\models \\Delta$. By the satisfaction condition, we finally obtain $C \\models \\mu_b(\\Delta)$.\n\nConversely, assume $C^{sem}(S) \\models \\mu_b(\\Delta)$. We want to show $S \\models^{sem} (i, j, c)$. Let $(M^k)^k \\in Ind$ be a model of S according to the chosen semantics sem. By weak amalgamation (or by Proposition 1 in case we have only weak amalgamation\n\n$^{39}$ The proposed DOL syntax is: entailment $e = i,j$ in $S$ entails $c$, where e is some name for the entailment.\n\n$^{40}$ Note that $\\Sigma^b$ is $\\Sigma_B$, whose definition depends on the choice of sem and was introduced in the corresponding subsection of Sect. 5.\nof pushouts), we can apply Corollary 2 and obtain a model $C$ of the colimit $C^{sem}(S)$ such that $\\beta^k(C|_{\\mu_k}) = M^k$ for each $k \\in |D^{sem}(S)|$. By the assumption, we obtain $C \\models \\mu_k(\\Delta)$. By the satisfaction condition, we get $C|_{\\mu_b} \\models \\Delta$. By $(\\Sigma^b, \\Delta) \\equiv^{sem} c$ and compatibility with the diagram, we get $M^j \\models^{sem} c$, that is, $(M^i)_{i \\in \\text{Ind}} \\models^{sem} (i, j, c)$. \n\nAll this easily generalises from single correspondences to sets of these, i.e. alignments. The proof carries over as such for the case of heterogeneous alignments, except that now the morphisms $(\\mu_k)_{k \\in \\text{Ind}}$ are heterogeneous signature morphisms and the satisfaction condition is the one in the Grothendieck logic.\n\n### 8.4 Complexity of Reasoning\n\nIn the previous subsections, we have reduced reasoning about a $\\text{NeO}$ $S$ to reasoning in the colimit ontology $C^{sem}(S)$, see especially Corollary 3 and Proposition 8. Since reasoning in the colimit ontology can be done using standard tools, this reduction provides us with a reasoning mechanism for $\\text{NeOs}$. In the following, we will analyse the computational cost associated with computing the colimit and the resulting complexity of reasoning in the colimit.\n\nIn [64], we have examined how colimits in typical signature categories are constructed. Here, “typical” means set-like, that is, signatures consists of several components that are sets of symbols, possibly kinded. This is indeed the case for the vast majority of logical formalisms. A closer inspection of the colimit selection methods in [64] reveals the following:\n\n**Proposition 9** Let $A$ be an alphabet of letters, and $A^*$ the set of words over $A$. Let the class of set-like categories over $A^*$ be the smallest class containing $\\text{Set}(A^*)$ (the category of subsets of $A^*$ and functions between them), and being closed under products and Grothendieck constructions. Then the number of symbols in a colimit ontology is linear in the number of symbols of the ontologies in the network (diagram). Moreover, colimit computation in such categories requires at most quadratic time.\n\n**Proof** The number of symbols is linear because a colimit is a quotient of a disjoint union. Since the equivalence classes in the quotient have at most linear size, the overall computation time is at most quadratic.\n\n**Proposition 9** in particular applies to $\\text{OWL}$, unssorted FOL and sorted FOL. Let us add that for practical example ontologies, the size of equivalence classes is usually less than a small constant (also for large ontologies), and hence complexity is even linear. Since Proposition 9 only concerns the colimit computation, we additionally need to take the complexity of computing the W-diagrams (including the bridge ontology) into account. However, an inspection shows that this is also linear.\n\nThe complexity of reasoning even in weak logics can be very high. For example, logical consequence in propositional logic is coNP-complete. For propositional Horn logic, it is in polynomial time. The standard reasoning problems in the DL $\\text{SROIQ}$ are known to be NExpTime-complete and in the DL $\\text{SHIQ}$ they are NExpTime-complete [43]. First-order logic is known to be undecidable. In all these cases, the computation of the colimit is dominated by the complexity of reasoning. Moreover, the size of the colimit is linear in the size of the input ontologies. This means that reasoning in, e.g. a $\\text{SROIQ}$-based $\\text{NeO}$ is (like that in $\\text{SROIQ}$ itself) NExpTime-complete. Of course, in the case when a correspondence is not internalisable in the logic of the aligned ontologies, complexity will typically increase when internalising the semantics of that correspondence in a more expressive logic (for $\\text{SROIQ}$, this will not happen for simple semantics). Moreover, when the merging of different $\\text{SROIQ}$ ontologies is no longer expressible in $\\text{SROIQ}$, complexity can increase as well (even become undecidable). This is not a limitation of our approach, but a problem of reasoning in $\\text{NeOs}$ in general.\n\nIn order to test the running time of our approach in practice, we have tried our reasoning method with the examples from the biomedical domain available at the Bioportal repository. Biportal provides about 400,000 correspondences (called “mappings”). We have organised these into DOL (called “mappings”). We have organised these into DOL alignments, organised the alignments into networks, and then tried to show satisfiability of these networks. By Proposition 6, it suffices to compute the colimit ontology and then use a standard $\\text{OWL}$ reasoner to show its satisfiability (w.r.t. simple semantics). However, one major problem was the immense size of many colimits, resulting from the immense size of some input ontologies (some of them 200–500 MB large). Therefore, we decided to use modules of networks, as developed in the next subsection (see especially Corollary 4). This was more successful. Detailed results will be reported in a separate paper.\n\n### 8.5 Modules of Networks\n\nWe have shown that reasoning in a network amounts to reasoning in a colimit ontology. However, the colimit ontology can become very large. A smaller colimit can be obtained by\n\n---\n\n41 With these, typed symbols (like in many-sorted FOL) can easily be realised.\n\n42 That is, a quotient of a disjoint union, as done by the colimit. However note that the problem already arises with simple unions.\n\n43 http://bioportal.bioontology.org/mappings.\n\n44 https://ontohub.org/repositories/bioportal_mappings.\nworking with modules. A module of an ontology captures all the knowledge that the ontology has about a certain signature \\( \\Sigma \\). Technically, this is ensured by requiring that the whole ontology is a \\( \\Sigma \\)-conservative extension of the module. This will be explored now. We restrict ourselves to modules in the model-theoretic sense, that is, modules using the model-theoretic notion of conservative extension.\n\n**Definition 48** Let \\( O \\) be an ontology and \\( \\Sigma \\subseteq \\text{Sig}(O) \\). A sub-ontology \\( O' \\subseteq O \\) is called a \\( \\Sigma \\)-module for \\( O \\), if for each \\( O' \\)-model \\( M' \\), there is an \\( O \\)-model \\( M \\) with \\( M|_\\Sigma = M'|_\\Sigma \\).\n\n**Definition 49** Let \\( S = ((O_i)_{i \\in \\text{Ind}}, (A_{ij})_{i, j \\in \\text{Ind}}) \\) be a NeO. A NeO \\( S' = ((O'_i)_{i \\in \\text{Ind}}, (A'_{ij})_{i, j \\in \\text{Ind}}) \\) is called a module of \\( S \\) if for each \\( i \\in \\text{Ind}, O'_i \\) is a \\( \\Sigma_i \\)-module of \\( O_i \\), where \\( \\Sigma_i \\) is the union of all interface signatures related to \\( O_i \\) stemming from those W-diagrams occurring in the normalisation of \\( S \\).\n\nNote that due to the choice of the interface signatures \\( \\Sigma_i \\), each \\( A_{ij} \\) is still an alignment between \\( O'_{i} \\) and \\( O'_j \\).\n\nThe colimit of such a module of a network is generally much smaller than that of the network itself. This smaller colimit can be used for reasoning about inconsistency or about logical consequences, as far as they are formulated in the signature of the smaller colimit:\n\n**Proposition 10** Let \\( S = ((O_i)_{i \\in \\text{Ind}}, (A_{ij})_{i, j \\in \\text{Ind}}) \\) be a NeO and \\( S' = ((O'_i)_{i \\in \\text{Ind}}, (A'_{ij})_{i, j \\in \\text{Ind}}) \\) be a module of \\( S \\). Then \\( S \\) is a model-theoretic conservative extension of \\( S' \\), which means that any \\( S' \\)-model \\( ((M'_i)'_{i \\in \\text{Ind}}) \\) can be expanded to an \\( S \\)-model \\( (M'_i)_{i \\in \\text{Ind}} \\) such that \\( M'_i|_{\\text{Sig}(O'_j)} = (M'_i)' \\) for all \\( i \\in \\text{Ind} \\).\n\n**Proof** Given an \\( S' \\)-model \\( ((M'_i)'_{i \\in \\text{Ind}}) \\), for each \\( i \\in \\text{Ind}, O'_i \\) is a \\( \\Sigma_i \\)-module of \\( O_i \\), where \\( \\Sigma_i \\) is defined as in Definition 49. Hence, \\( (M'_i)' \\) can be expanded to a model of \\( O_i \\). Then \\( (M'_i)' \\) is a module of \\( S \\).\n\n**Corollary 4** Let \\( S' \\) be a module of a NeO \\( S \\). Then satisfiability of \\( S \\) is equivalent to that of \\( S' \\).\n\nWe now show that reasoning over a relational network is equivalent to reasoning over any module.\n\n**Proposition 11** Let \\( S = ((O_i)_{i \\in \\text{Ind}}, (A_{ij})_{i, j \\in \\text{Ind}}) \\) be a relational NeO, \\( S' = ((O'_i)_{i \\in \\text{Ind}}, (A'_{ij})_{i, j \\in \\text{Ind}}) \\) a module of \\( S \\), and \\( e \\in \\text{Sen}(\\text{Sig}(O'_i)) \\) (with \\( i_0 \\in \\text{Ind} \\)) a sentence. Let \\( \\iota: \\text{Sig}(O_{i_0}) \\to \\text{Sig}(O'_{i_0}) \\) be the inclusion. Then\n\n\\[\nS \\models \\text{sem} (i, \\iota(e)) \\iff S' \\models \\text{sem} (i, e)\n\\]\n\n**Proof** “\\( \\Rightarrow \\)”: Assume \\( S \\models \\text{sem} (i, \\iota(e)) \\) and let \\( ((M'_i)'_{i \\in \\text{Ind}}) \\in \\text{Mod}^{\\text{sem}}(S') \\). Let \\( (M'_i)_{i \\in \\text{Ind}} \\) be an expansion to a model in \\( \\text{Mod}^{\\text{sem}}(S) \\). By assumption, \\( M'_i|_{\\text{Sig}(O'_j)} = (M'_i)' \\). By the satisfaction condition, \\( M'_i \\models \\iota(e) \\).\n\n**“\\( \\Leftarrow \\)”:** Assume \\( S' \\models \\text{sem} (i, e) \\) and let \\( (M'_i)' \\) be a module of \\( S' \\). Then \\( M'_i|_{\\text{Sig}(O'_j)} \\models (M'_i)' \\). By the satisfaction condition, \\( M'_i \\models \\iota(e) \\).\n\n8.6 Tool Support\n\nDOL is supported by Ontohub (https://ontohub.org,[12,47]), a Web-based repository engine for managing distributed heterogeneous ontologies. The back-end of Ontohub is the Heterogeneous Tool Set HETS [63] which is used for parsing, static analysis and proof management of ontologies. HETS supports alignments and combinations: according to the theory in Sects. 5 and 6, it generates the normalised network of an alignment according to the assumption made on the domain, and can automatically compute colimits of ontologies in different logics, including OWL, first-order logic and multi-sorted first-order logic.\n\n**Example 48** Figure 1 shows the network of the alignment in Example 28 displayed in Ontohub after analysing the specifications in DOL.\n\n---\n\n45 The proposed DOL syntax for a module of a network \\( S \\) is extract \\( S \\).\n\n46 Full support for all four semantics is currently in progress, the implementation of simple semantics for alignments in Hets is stable.\nculation of the alignment. The outer nodes form the W-shaped alignment while the central node, labelled with C, is the colimit ontology of the NeO. The node C is automatically computed by Ontohub via HETS.\n\nExample 49 Figure 2 shows the network of the alignment in Example 32 in Hets. Note that the two ontologies were relativised and they are linked to their relativisation via a double arrow, which in Hets denotes a heterogeneous signature morphism (here, the relativisation translation is applied). The W-shaped diagram of the alignment is visible in the lower part of the figure. The colimit is in the upper part of the figure and was computed automatically by Hets.47\n\nNote that both HETS and Ontohub support reasoning in ontologies via interfacing with standard reasoners, such as Pellet and Hermit (for OWL) and SPASS and Vampire (for first-order logic). In particular, this means that reasoning in the colimit ontology is possible. By the results of the previous subsections, this means that reasoning for networks is available, too. Implementation of computation of modules is under way; for the initial experiments mentioned above, we have done this computation in an ad hoc way.\n\n9 Extending the Framework\n\nA number of related combination techniques are in principle covered by our approach, in particular those often referred to as modular or distributed ontology languages (see [15,77] for overviews of some of these languages).48 We here discuss only how to deal with the most well-known cases, namely DDL [5], $E$-connections [48], DFOL [25], and multi-context systems (MCS) in general [26]. Note that for all of them, future work is required to incorporate their more expressive alignment or bridging constructs into our abstract framework.\n\nIf $O_i$ and $O_j$ are two ontologies, DDL admits so-called bridge rules of the following form:\n\n- $i : C \\xrightarrow{\\xi} j : D$ (‘into’ bridge rule)\n- $i : C \\xrightarrow{\\eta} j : D$ (‘onto’ bridge rule)\n- $i : a \\mapsto j : b$ (individual correspondence)\n- $i : a \\xrightarrow{\\varphi} \\{ j : b_1, \\ldots, j : b_n \\}$ (complete correspond.)\n\nwhere $C, D$ are concepts and $a, b, b_1, \\ldots, b_n$ are individuals and we prefix the symbols from $O_i$ with ‘$i$’ and those coming from $O_j$ with ‘$j$’.\n\nThe intended interpretation is that given two models $M^i$ and $M^j$ of $O_i$ and $O_j$, respectively, such that $r_{ij}$ is a relation between $\\text{universe}(M^i)$ and $\\text{universe}(M^j)$, we have that:\n\n- $M^i, M^j \\models i : C \\xrightarrow{\\xi} j : D$ iff $r_{ij}(M^i_C) \\subseteq M^j_D$\n- $M^i, M^j \\models i : C \\xrightarrow{\\eta} j : D$ iff $r_{ij}(M^i_C) \\supseteq M^j_D$\n- $M^i, M^j \\models i : a \\mapsto j : b$ iff $r_{ij}(M^i_a, M^j_b)$\n- $M^i, M^j \\models i : a \\xrightarrow{\\varphi} \\{ j : b_1, \\ldots, j : b_n \\}$ iff $r_{ij}(M^i_a) = \\{M^j_{b_1}, \\ldots, M^j_{b_n}\\}$.\n\nFirst, notice that in the logic-independent framework introduced in this paper, we do not support the last type of bridge rule directly since this would require to allow non-symbols in correspondences, but terms, e.g. complex concepts in OWL (like in the case of the nominal in the last bridge rule above), or complex terms in FOL. Terms would have to be defined in a logic-independent way, leading to a number of technical complications in the framework that we refrain from introducing here for simplicity.49 However, this does not limit the coverage of our framework when assuming sufficiently expressive logics participating in a network. As shown already in [5], the last kind of bridge rule can be simulated via translation into sufficiently expressive DLs, e.g. by assuming that either counting quantifiers are present, as in $\\mathcal{SHIQ}$ [40], or by using nominals, as available in $\\mathcal{SROIQ}$ underlying OWL 2 DL [39].\n\nMoreover, notice that the contextualised semantics for alignments, introduced in Sect. 4.3, is defined relative to the universe of the source ontology of the alignment, while\n\n47 The names $A\\_source, A\\_target, A\\_bridge$ of the nodes in the diagram of the alignment, as well as the names $O1\\_relativisation$ and $O2\\_relativisation$ for the relativisation of ontologies are generated during the analysis of the alignment $A$.\n\n48 These are extensively studied in the Workshops on Modular Ontologies (WoMO), see http://iaoa.org/womo.\n\n49 See [60] for an institution independent treatment of terms.\nin the case of DDL, the correspondence relation is defined over the domain of the target ontology. This requires a syntactic modification of DDL alignments in order to capture correctly their semantics within our framework. Namely, we must reverse the source and the target ontology and the direction of the arrows in the bridge rules. For the first three kinds of bridge rules directly supported in our current setting, this transformation then trivially generates valid bridge rules. Alternatively, we could modify the definition in Sect. 4.3 to work from the perspective of the target ontology. We have decided not to do so, in order to stay consistent with the generic definitions in [80].\n\nSimilarly, the methodology of $E$-connections fits perfectly well into the contextualised semantics paradigm ($E$-connections introduce symbols interpreted as relations between the universes of the combined ontologies), however their significantly more expressive alignment constructs and syntactic heterogeneity pose problems.\n\n$E$-connections are introduced over abstract description systems, term-based languages that abstract from the specific syntaxes of many typical modal and description logics, and are interpreted over a uniform semantics based on set-valued terms and set-valued functions. Moreover, $E$-connections allow for a variety of bridge logics, essentially variants of typical description logics, including universal and existential restrictions (essentially equivalent to the ‘into’ and ‘onto’ bridge rules introduced for DDL in the case of connecting DL-based ontologies), counting quantifiers, and Boolean operations on links. Grothendieck institutions allow us to manage this kind of heterogeneity. The difficulty is that the expressivity of the language of links (in our terminology, the logic of the bridge ontology in the W-shaped network of the alignment) should be allowed to vary by making a flexible selection of DL-like operators that can be applied to the domain relations. Correspondingly, the computation of heterogeneous colimits will depend on these choices. Moreover, $E$-connections generalise the DDL-based paradigm in two other important aspects. First, they allow any number of linking relations between two given domains, which implies that our framework for specifying domain relations needs, for instance, to be extended with means to specify sets of such relations. Secondly, in an network of ontologies based on the $E$-connections paradigm, it is also possible to have $n$-ary relations between $n$ participating ontologies, with the corresponding obvious generalisations of the alignment operations (see [48] for details). Such an extension requires more significant efforts regarding for instance internalisation of the now $n$-ary bridge logic.\n\nRegarding DDL, we have shown that the basic case of standard bridge rules for description logics (into/onto rules and individual correspondences) is directly covered by our approach. As shown in [15, 48], such basic DDLs can be also simulated by basic $E$-connections. More precisely, a suitable specialisation of $E$-connections to DL-based ontologies, binary relations, and a more basic bridge language, is essentially equivalent to basic DDL. ‘Basic’ is here meant in the technical sense of not involving non-standard bridge rules, i.e. those beyond the standard ‘into’ and ‘onto’ bridge rules (see [5]). Indeed, the case of such non-standard bridge rules is the more interesting one. This includes heterogeneous bridge rules relating for instance symbols of different arity (e.g. reifying a relation into a concept by a projection operation) [27], handling default rules [8], or rules for controlling inconsistency propagation [37].\n\nSimilarly, distributed first-order logic (DFOL) [25] can also be incorporated into our general framework with the following qualifications. First, DFOL has a semantics very similar to contextualised semantics for alignments. We can therefore fix the parameters of how the network of the alignment is constructed, namely relativisation of ontologies. Second, we can then obtain the bridge axioms from the correspondences stated in a DFOL-alignment. Unlike in the case of $E$-connections, in DFOL the bridge language remains in the first-order logic paradigm.\n\n10 Conclusions\n\nOur theoretical contributions to the foundations of ontology alignment and combination of alignments in networks are intended to provide an abstract, unified view of the most prominent approaches to giving semantics to alignments.\n\nRegardless of the semantic paradigm employed, ‘reasoning’ with alignments involves at least three levels:\n\n1. the finding/discovery of alignments (based either on human manual effort, or on (semi)-automatic structural, linguistic, statistical or logical methods),\n2. the construction of the aligned ontology (a global, colimit-based approach, or a localised, distributed approach), and\n3. reasoning over the aligned network of ontologies, respectively, debugging, repair and revision of the ontologies or the alignment relations (see e.g. [41, 42, 56]), closing the loop to (1).\n\nOur contributions in this paper address levels (2) and (3).\n\nRegarding (2), platforms such as Bioportal (with about 400,000 correspondences in 2016) illustrate that mappings between ontologies, ontology modules, and the concepts and definitions living in them, are of great importance to support reuse. They are regarded of particular importance in areas such as clinical and medical terminology, where terminolo-\ngies are vast, not uniform across user groups, but essential in practice [70]. The importance of heterogeneity in data formats and formal languages used, resulting not in small part from the diversity of user groups and stakeholders involved in the biomedical domains, has been stressed in [50,76]. In the case of Bioportal, the DOL language allows to declaratively manage sets of alignments, and to give them precise semantics. We have started to apply the approach of this paper to Bioportal, see https://ontohub.org/bioportal_mappings for DOL formalisations of the Bioportal “mappings” (which are correspondences) as networks of alignments.\n\nThe importance of alignments has also been well demonstrated for foundational ontologies in the repository ROMULUS [44]. In the case of ROMULUS, it allows to align ontologies such as Dolce or BFO expressed in first-order logic with OWL versions of the same ontology. This is a feature that no other alignment framework currently covers and is already supported by the Ontohub platform.\n\nOntologies developed in the area of applied ontology, in particular foundational and upper ontologies, often need expressiveness beyond OWL; here, the multi-logic nature of Ontohub is essential to allow to host and align these ontologies. A good example for these novel capabilities is given by the recent FOUST initiative (‘The FOUnational STance’), an effort to build a curated, digital library hosted on Ontohub to provide authoritative formalised versions of the leading foundational ontologies (including BFO, DOLCE, GFO, GUM, UFO and YAMATO). This will include variants of these ontologies given, e.g. in OWL, FOL and HOL, as well as formally establishing their relationships based on theory interpretation and alignment. That is, a standard task is the heterogeneous reasoning problem to establish that the translation of an ontology written in a ‘weaker dialect’ is logically entailed by the version written in the ‘stronger dialect’. Moreover, standard alignment techniques are not sufficient in terms of expressivity to cover the more substantial meaning shifts that occur across terms used in various foundational ontologies. The extensions of our framework discussed in Sect. 9 are therefore essential for the long-term success of a project such as FOUST.\n\nRegarding (3), alignment tools such as LogMap [41], ALCOMO [56] or AgreementMakerLight [22], employ reasoning over aligned ontologies and repair either parts of the input ontologies or revise the mappings (one technique to enable this is to re-encode the mappings into a global OWL ontology) to restore global consistency. Using DOL and the reasoning capabilities of the HETS/Ontohub ecosystem [47,63], such tools could be used to directly operate on a NeO, and to update the network structure accordingly.\n\nNote that our approach to reasoning is a global one: the colimit of a NeO integrates all ontologies and all alignments that are part of the NeO. This is in contrast to distributed approaches (like, e.g. DRAGO [74] for DDL or DRAOn [53,82] for IDDL), where local reasoning is combined with propagation rules along bridge rules. Distributed approaches can be more efficient than ours in specific cases, although having typically the same worst-case complexity as our global approach (see Sect. 8.4). However, we believe that the global approach in combination with the use of modules of networks (Sect. 8.5) can scale down reasoning times significantly, and thus provide a generic and competitive approach to reasoning in networks of ontologies. Moreover, our approach has the advantage of being very general: it is applicable to the four different semantics of networks of alignments and also to heterogeneous ontologies. The distributed approaches do not provide reasoning methods for all these cases, and they would need ad hoc extensions to cover them. By contrast, we provide a systematic approach that can easily be instantiated to new logics. The approach presented here provides an integration of the major paradigms of ontology alignment into one coherent framework. This currently covers standard alignment relations and basic DDL bridge rules, and, with suitable generalisations as outlined in Sect. 9, also $\\mathcal{E}$-connections, PD-L, IDDL, and DFOL.\n\nWe provide a generic framework for alignments, orthogonal to the local logics used in the ontologies participating in a network. To instantiate our framework for a particular logic, it suffices to provide constructions of the bridge ontologies and relativisation translations for that logic. Moreover, DOL’s support for heterogeneity allows us not only to handle heterogeneous alignment, but also to move to a more expressive logic when a bridge axiom cannot be expressed in the local logic of the ontologies. Thus, we have seen that contextualised semantics for OWL, without restrictions on correspondences, can be given in our framework.\n\nFuture work includes the combination of different alignment paradigms within one network (as principally enabled by our unifying framework) and an integration of techniques for the revision of NeOs [19] into DOL. In our setting, the propagation of detected repairs into a network could be done by updating the alignment mappings and recomputing the\n\n---\n\n51. See https://foust.inf.unibz.it.\n\n52. To give some more detail, DOLCE is available in various DL versions, in FOL, and in an extension using quantified modal logic (see http://www.loa.istc.cnr.it/old/DOLCE.html); GFO is currently in FOL, BFO versions exist in OWL DL, OBO, Isabelle, and CLIF (a syntax for Common Logic [58]) (see https://github.com/BFO-ontology/BFO), GUM exists in OWL DL and CASL (see http://www.ontospace.uni-bremen.de/ontology/gum.html), UFO is written in higher-order logic (Coq/Gallina), and YAMATO in FOL and OWL.\n\n53. Note that the distributed nature is limited: DRAGO “can answer consistency and satisfiability queries at one peer” [20]. And for DRAOn, “cross-ontology correspondences are limited to concept subsumption or disjointness, and role subsumption (so, role disjointness is not supported)” [82].\nalignment networks. Further work is also needed for the problem of reasoning about the consequences of a Neo; here we expect module extraction to provide an increase in performance of proof search.\n\nWe currently pursue to add support for the full \\( E \\)-connections bridge logic and other major combination paradigms to DOL as discussed in the previous section. Proof support for such combinations can either be realised via logic translations to already supported logics, or by adding dedicated reasoning procedures such as [66, 74] to the HETS system. At the tool level, the integration of the four semantics for alignments in Ontohub is currently in progress. Ontohub is already compatible with the OWL API, and its potential for interoperability is increased further by the integration of the Alignment API. Also, scalability to alignments among large ontologies (such as those in Bioportal) is a challenge that should be addressed by future work. While some initial experiments using modules of networks have been promising, we still have to solve more down-to-earth problems, e.g., regarding the organisation of prefix maps in the colimit.\n\nAcknowledgements We would like to thank Jérôme Euzenat and Fabian Neuhauß for extensive discussions of ideas found in this paper. We also thank the anonymous reviewers for their substantial feedback and for suggesting a number of improvements, both on a technical level and regarding the presentation of results.\n\nReferences\n\n\nA Categorical Approach to Networks of Aligned Ontologies"}}},{"rowIdx":298,"cells":{"id":{"kind":"string","value":"a776b47736cb42919a0658d0fa2650dedc70777a"},"text":{"kind":"string","value":"Custom Shape Tutorial\nHow to Create Your Own Custom Shapes\nby Regina Henschel\nPreface\n\nCopyright\n\nThis document is Copyright © 2022 by Regina Henschel. This document maybe distributed and/or modified under the terms of either the GNU General Public License (https://www.gnu.org/licenses/gpl.html), version 3 or later, or the Creative Commons Attribution License (https://creativecommons.org/licenses/by/4.0/), version 4.0 or later.\n\nAll trademarks within this guide belong to their legitimate owners.\n\nContributors\n\nTo this edition.\n\nRegina Henschel\n\nRevisions\n\nMarch 2022: Olivier Hallot has corrected numerous linguistic errors.\n\nFeedback\n\nPlease direct comments or suggestions about this document to Regina Henschel [rb.henschel@t-online.de] or use the discussion page of https://wiki.documentfoundation.org/User:Regina/Custom_Shape_Tutorial or write a mail to documentation@global.libreoffice.org.\n\nSoftware\n\nThe shapes have been tested in LibreOffice version 7.1.5, only extruded custom shapes (chapter 10) need version 7.4 and for custom shapes in text path mode (chapter 9) you should use at least version 7.3.\n\nThis tutorial contains images of the shapes. The shapes themselves are collected in a separate file “Shapes from Custom Shape Tutorial.odg” https://wiki.documentfoundation.org/images/e/ed/Shapes_from_Custom_Shape_Tutorial.odg\n# Table of Contents\n\nPreface.........................................................................................................................3 \n1 Introduction...................................................................................................................8 \n2 Basic Parts of a Custom Shape.....................................................................................9 \n 2.1 Examine Markup of Predefined Shape ‘Right Triangle’.............................................9 \n 2.1.1 Common Parts..................................................................................................9 \n 2.1.2 First Look at Element `<draw:enhanced-geometry>`.......................................10 \n 2.1.3 First Look at Attribute `<draw:enhanced-path>`.............................................11 \n 2.2 Your first Custom Shape.........................................................................................13 \n 2.3 Attribute `<draw:text-areas>`.............................................................................15 \n 2.4 Attribute `<draw:glue-points>`............................................................................17 \n 2.5 Attribute `<svg:viewBox>`.................................................................................18 \n 2.5.1 Preparation.....................................................................................................18 \n 2.5.2 Explanation – Snap-Rectangle.......................................................................19 \n 2.5.3 Explanation – Attribute `<svg:viewBox>`.....................................................20 \n 2.5.4 Further Remarks.........................................................................................21 \n 2.6 Exercise Solutions...............................................................................................22 \n 2.6.1 Exercise 2.1..................................................................................................22 \n 2.6.2 Exercise 2.2..................................................................................................22 \n 2.6.3 Exercise 2.3..................................................................................................22 \n 2.6.4 Exercise 2.4..................................................................................................22 \n 2.6.5 Exercise 2.5..................................................................................................22 \n 2.6.6 Exercise 2.6..................................................................................................22 \n3 Introduction to Handles and Equations....................................................................24 \n 3.1 Linear Handle and Modifiers.................................................................................24 \n 3.2 Equations............................................................................................................26 \n 3.3 Restriction of Handle Movement.........................................................................27 \n 3.4 Overflow............................................................................................................28 \n 3.5 Functions............................................................................................................30 \n 3.6 Polar Handles.....................................................................................................31 \n 3.7 Further Handle Attributes....................................................................................33 \n 3.8 Exercise Solutions..............................................................................................33 \n 3.8.1 Exercise 3.1..................................................................................................33 \n 3.8.2 Exercise 3.2..................................................................................................33 \n 3.8.3 Exercise 3.3..................................................................................................33 \n 3.8.4 Exercise 3.4..................................................................................................34 \n 3.8.5 Exercise 3.5..................................................................................................34 \n 3.8.6 Exercise 3.6..................................................................................................34 \n4 Quadrants..................................................................................................................36 \n 4.1 Introduction..........................................................................................................36 \n 4.2 Single Quadrant....................................................................................................37 \n 4.3 Sequence of Quadrants.......................................................................................38 \n 4.4 Exercise Solutions...............................................................................................40 \n 4.4.1 Exercise 4.1..................................................................................................40 \n 4.4.2 Exercise 4.2..................................................................................................40 \n 4.4.3 Exercise 4.3..................................................................................................41\n9.3.3 Text with Multiple Text Lines................................................................. 91\n9.4 Two Sub-Paths.......................................................................................... 92\n9.5 More Than Two Sub-Paths.......................................................................... 94\n9.6 Controlling Text Position......................................................................... 96\n9.7 Exercise solutions..................................................................................... 96\n 9.7.1 Exercise 9.1........................................................................................ 96\n 9.7.2 Exercise 9.2........................................................................................ 96\n 9.7.3 Exercise 9.3........................................................................................ 97\n\n10 Custom Shapes in 3D................................................................................ 98\n 10.1 Enable 3D-mode.................................................................................... 98\n 10.1.1 Attribute draw:extrusion.............................................................. 98\n 10.1.2 Attribute draw:extrusion-allowed............................................. 98\n 10.2 Coordinate System............................................................................... 99\n 10.3 Text....................................................................................................... 99\n 10.4 Object Geometry................................................................................... 99\n 10.4.1 Attribute draw:extrusion-depth................................................ 99\n 10.4.2 Attribute draw:extrusion-rotation-angle................................. 100\n 10.4.3 Attribute draw:extrusion-rotation-center................................. 100\n 10.5 Projection............................................................................................. 101\n 10.5.1 Attribute dr3d:projection............................................................. 101\n 10.5.2 Central Projection........................................................................ 101\n 10.5.3 Attributes draw:extrusion-viewpoint and draw:extrusion-origin 102\n 10.5.4 Parallel Projection........................................................................ 104\n 10.5.5 Attribute draw:extrusion-skew.................................................. 104\n 10.5.6 Examples of oblique parallel projection................................. 105\n 10.5.7 Examples for orthographic projection..................................... 106\n 10.6 Object Surface..................................................................................... 107\n 10.6.1 Attribute draw:extrusion-color................................................ 107\n 10.6.2 Attribute draw:extrusion-light-face........................................ 107\n 10.6.3 Attribute draw:extrusion-diffusion........................................... 107\n 10.6.4 Attribute draw:extrusion-shininess........................................... 108\n 10.6.5 Attribute draw:extrusion-specularity....................................... 108\n 10.6.6 Attributes draw:extrusion-metal and loext:extrusion-metal-type 109\n 10.7 Rendering Quality............................................................................... 110\n 10.7.1 Attribute dr3d:shade-mode....................................................... 110\n 10.7.2 Attribute draw:extrusion-number-of-line-segments................ 111\n 10.8 Scene Lights......................................................................................... 111\n 10.8.1 Attributes draw:extrusion-first-light-direction and draw:extrusion-second-light-direction.............................. 111\n 10.8.2 Attribute draw:extrusion-brightness....................................... 112\n 10.8.3 Attributes draw:extrusion-first-light-level and draw:extrusion-second-light-level........................................... 112\n 10.8.4 Attributes draw:extrusion-first-light-harsh and draw:extrusion-second-light-harsh........................................ 113\n\n11 Mathematics............................................................................................ 114\n 11.1 Approximate Sine Curve by Cubic Bézier Curve................................. 114\n 11.2 Mathematics for Tangents of Ellipses............................................... 115\n 11.2.1 Tangents to the Circle in General......................................... 115\n 11.2.2 Coordinates for Points of Contact......................................... 116\n 11.2.3 Angles for Points of Contact................................................. 117\n 11.2.4 Tangents to Ellipse............................................................... 117\n11.3 Skew Values for Oblique Parallel Projection..........................................................119\n 11.3.1 Calculate Skew Values..................................................................................119\n 11.3.2 Construct Skew Values................................................................................120\n 11.3.3 Construct the Projection of an Object..........................................................120\n11.4 Angles in Orthographic Projection..................................................................121\n 11.4.1 From Rotation Angles to Projection.............................................................121\n 11.4.2 From Projection to Rotation Angles.............................................................123\n12 Indexes..................................................................................................................125\n 12.1 Figures..............................................................................................................125\n 12.2 Tables...............................................................................................................128\n 12.3 Index of Elements, Attributes and Path Commands........................................129\n1 Introduction\n\nThe term custom shape is used as umbrella term in this tutorial for those shapes, which are written as element `<draw:custom-shape>` in the document source file. LibreOffice provides a lot of predefined custom shapes. They are grouped to the sets ‘Basic Shapes’, ‘Block Arrows’, ‘Symbol Shapes’, ‘Stars and Banners’, ‘Callouts’, and ‘Flowchart’. And all shapes from the ‘Fontwork Gallery’ are custom shapes too.\n\nTo distinguish a custom shape from other kind of shapes select the shape and look at the tool ‘Toggle Extrusion’. It is only enabled, if the shape is a custom shape.\n\nLibreOffice provides no tools to create own custom shapes. This tutorial shows you how to create own custom shapes by defining them directly in the source file. Once they are defined, they can be used in other documents without manipulating the source file again.\n\nWarning: Self-made custom shapes are mainly useful, if you stick to LibreOffice and OpenDocument Format. Converting self-made custom shapes into OOXML format does not work in all cases. Microsoft Office currently cannot read all kind of self-made custom shapes in OpenDocument format.\n\nAs you will work directly in the source file with XML markup, you need some tools. Find more about editing the source file on page ODF_Markup in the Wiki. In case you need help with the tools, you can ask on the associated “Discussion” page, so that the page can be improved, or you write a mail to documentation@global.libreoffice.org.\n\nThe tutorial assumes that you know general handling of shapes as described in the Draw Guide. The tutorial contains some exercises. The solutions can be found at the end of each chapter. The exercise has a link to its solution. The exercise number in the solution is a link back to the text of the exercise.\n\nThe tutorial contains images of the shapes. The discussed shapes themselves are provided in a separate document “Shapes from Custom Shape Tutorial”. That way they are available even if you use a printed or a PDF version of the tutorial.\n\n---\n\n1 https://wiki.documentfoundation.org/Documentation/ODF Markup, [last called 2021-08-28]\n2 https://documentation.libreoffice.org/en/english-documentation/ [last called 2021-08-29]\n3 https://wiki.documentfoundation.org/images/e/ed/Shapes_from_Custom_Shape_Tutorial.odg\n2 Basic Parts of a Custom Shape\n\n2.1 Examine Markup of Predefined Shape ‘Right Triangle’\n\nStart a new Draw document and insert the shape ‘Right Triangle’ at position \\( x = 50 \\text{ mm}, y = 20 \\text{ mm} \\) with size width \\( = 40 \\text{ mm} \\) and height \\( = 60 \\text{ mm} \\). The shape belongs to the set ‘Basic Shapes’. In case you work with the packed file format ‘.odg’, enter the package and open the file content.xml in an editor. In case you work with the flat file format ‘.fodg’, open it directly in an editor. Search for the element \\(<\\text{draw:custom-shape}>\\). You should see something similar to the following markup\n\n\\[\n<\\text{draw:custom-shape} \\\\\n\\hspace{1cm} \\text{draw:style-name}=\"gr1\" \\\\\n\\hspace{1cm} \\text{draw:text-style-name}=\"P1\" \\\\\n\\hspace{1cm} \\text{draw:layer}=\"layout\" \\\\\n\\hspace{1cm} \\text{svg:width}=\"4cm\" \\\\\n\\hspace{1cm} \\text{svg:height}=\"6cm\" \\\\\n\\hspace{1cm} \\text{svg:x}=\"6cm\" \\\\\n\\hspace{1cm} \\text{svg:y}=\"3cm\">\n\\hspace{1cm} <\\text{p}>\n\\hspace{1cm} </draw:enhanced-geometry ... />\n</draw:custom-shape>\n\\]\n\n2.1.1 Common Parts\n\nThe attributes of a \\(<\\text{draw:custom-shape}>\\) element are similar to other shape types.\n\n- **draw:style-name=\"gr1\"**\n The shape uses the graphic properties which are contained in a style with name ‘gr1’. Those determine the fill style and line width, for example.\n\n- **draw:text-style-name=\"P1\"**\n The text in the shape uses a paragraph style with name ‘P1’. Here, our shape has no text. That can be seen by the empty element \\(<\\text{p}>/\\).\n\n- **draw:layer=\"layout\"**\n The shape is placed on the layer ‘layout’. Layers exist only in Draw and Impress. It is irrelevant for this tutorial.\n\n- **svg:width=\"4cm\" svg:height=\"6cm\"**\n The attributes \\( \\text{svg:width} \\) and \\( \\text{svg:height} \\) determine the size of the shape. LibreOffice has an internal precision of 1/100 mm. Because of rounding errors between non-metric system (inch, point) and metric system (mm, cm) the values are sometimes by 1 or 2 hundredth millimeter too small or too large. Don’t worry about it.\n\n- **svg:x=\"6cm\" svg:y=\"3cm\"**\n The attributes \\( \\text{svg:x} \\) and \\( \\text{svg:y} \\) determine the position of the shape. For details see section 2.5.\n\nIn case the shape is rotated or sheared, there will be a **draw:transform** attribute instead of **svg:width, svg:height and svg:x, svg:y.**\nThe part which is specific for a custom shape is the element `<draw:enhanced-geometry ... />`\n\n### 2.1.2 First Look at Element `<draw:enhanced-geometry>`\n\n```xml\n<draw:enhanced-geometry\nglue-points=\"0 0 10800 0 21600 10800 21600 10800 10800\"\ntext-areas=\"1900 12700 12700 19700\"\ntype=\"right-triangle\"\nenhanced-path=\"M 0 0 L 21600 21600 0 21600 0 0 Z N\"\n/>\n\n`draw:enhanced-path=\"...\"`\n\nLibreOffice uses this attribute to decide, how to treat the shape in import from, and export to Microsoft file formats. The ODF standard allows you to omit this attribute, but LibreOffice needs it to decide how to handle the shape.\n\nFor your own shapes you must use `draw:type=\"non-primitive\"`.\n\n`draw:enhanced-path=\"...\"`\n\nThe drawing of the shape consists of geometric elements like lines, curves or circles. The `draw:enhanced-path` attribute contains the definition of the drawing. It is a sequence of commands and coordinates of points. This attribute is mandatory.\n\n`svg:viewBox=\"0 0 21600 21600\"\n\ndeфини́ция геометри́ческих эле́ментов использу́ет локальную, безедини́чную дека́дную систе́му коорди́нат для точки́. Как и обычно́ в 2D компьютерной графи́ке ось х направлена́ вправо и ось y направлена́ вниз. Этот атрибут является обязательным.\n\n`draw:glue-points=\"...\"\n\nEach shape has four default glue points and you can add your own glue points. Custom shapes may have additional shape specific glue points. They are listed in this optional attribute.\n\n`draw:text-areas=\"...\"\n\nSet explicitly the rectangular area into which text writing is possible. The values determine the left, top, right and bottom edges of this area. This attribute is optional. If omitted, the entire custom shape is used.\n\nIn case the shape is mirrored, attributes `draw:mirror-horizontal` and `draw:mirror-vertical` will be added.\n2.1.2 First Look at Element `<draw:enhanced-geometry>`\n\nExercise 2.1\nDetermine the coordinates of points A, B and C in Figure 1.\n\n→ solution\n\n2.1.3 First Look at Attribute `draw:enhanced-path`\n\nThe enhanced-path is the essential part of the enhanced-geometry of a custom shape. It describes how to draw the geometric elements. It uses commands like\n\n- **M x y**\n - Lift off the pen, move to point (x|y), put down the pen. That starts a new sub-path. Point (x|y) is then the ‘current point’ and it is the ‘initial point’ of the sub-path.\n\n- **L x y**\n - Draw a line from the current point to point (x|y). Point (x|y) is then the new ‘current point’.\n\n- **Z**\n - Close the sub-path by drawing a line from the ‘current point’ to the ‘initial point’ of the sub-path.\n\n- **N**\n - End the sub-path set and lift off the pen. The ‘current point’ is then undefined.\n\nMore details about the above commands are in chapter 5.1\n\nIf several identical commands follow each other directly, only the first one needs to be written down.\n\nSo the attribute `draw:enhanced-path=\"M 0 0 L 21600 21600 0 21600 0 0 Z N\"` has the following meaning:\n\n- **M 0 0**\n - Put down the pen at point (0|0). This is the initial point of the sub-path.\n\n- **L 21600 21600**\n - Draw a line to point (21600|21600).\n2 Basic Parts of a Custom Shape\n\n2.1.3 First Look at Attribute draw:enhanced-path\n\n0 21600 \nDraw a line to point (0|21600). Command L is repeated,\n0 0 \nDraw a line to point (0|0). Command L is repeated.\nZ \nDraw a line to the initial point of the sub-path.\nN \nLift off the pen. This ends the sub-path set.\n\nExercise 2.2\n\nWhat shape do you get with the following path?\n\ndraw:enhanced-path=\"M 10800 0 L 21600 10800 10800 21600 0 10800 Z N\"\n\n→ solution\n\nExercise 2.3\n\nWrite a <draw:enhanced-path> element for the shape in Figure 2.\n\n→ solution\n\nExercise 2.4\n\nDo the following paths give the same shape?\n\n(a) draw:enhanced-path=\"M 0 0 L 21600 21600 0 21600 0 0 Z N\"\n\n(b) draw:enhanced-path=\"M 0 0 L 21600 21600 0 21600 Z N\"\n\n→ solution\n\nExercise 2.5\n\nWhy is the following path invalid in regard to the ODF standard although applications might be fault tolerant and show something?\n\ndraw:enhanced-path=\"L 21600 21600 0 10800 10800 0 Z N\"\n\n→ solution\n2.2 Your first Custom Shape\n\nLet’s create the shape shown in Figure 3. In general, this process has the following steps.\n\n1. Put the desired shape into a coordinate system and determine the coordinates of its corners.\n\n \n\n You get the corners \\((0|0), (21600|10800), (0|21600)\\) and \\((10800|10800)\\).\n\n2. Write the necessary enhanced-path down. For example, you can use\n\n \"M 0 0 L 21600 10800 0 21600 10800 10800 Z N\"\n\n3. Prepare the document\n\n Start with a new Draw document. Then insert an existing custom shape – here use the ‘Right Triangle’ shape. Starting with an existing custom shape has the advantage, that you need not manipulate the surrounding document code – the styles for the graphic and text properties are already defined – and you don’t need to locate where to put the shape markup in the document.\n\n Start with a square size. Set area fill and line style as you like. Close the document.\n4. Edit the document\n\nEnter the package and open sub-file content.xml in an editor or open the flat format file in an editor. Search for the element `<draw:custom-shape>`.\n\nChange the value of attribute `draw:type` to \"non-primitive\".\n\nExchange the value of attribute `draw:enhanced-path` with your path from step 2.\n\nSave the changes and close the document.\n\n5. Test your shape\n\nOpen the file in LibreOffice. Does the shape look as desired? If not, look for errors in steps 1, 2 or 4. Look for Typos too.\n\nThe editor should have you already warned about structural errors in the markup. To detect errors regarding to the ODF standard, you can use the validator.4\n\n6. Document your shape\n\nCreate a text document that contains\n\n– (useful for this tutorial) Write down to which section of the tutorial this shape belongs.\n\n– The new created shape. Copy and paste from the Draw-document. If you put the shape at the beginning of the document, then it is shown in the thumbnail of the document. That makes it easier to find it in your library.\n\n– The figure and coordinates from steps 1 and 2.\n\n– Write down mathematical equations which you have made to find the coordinates. (You likely need no equation for this example.)\n\n– Write down the meaning of the equations used in the custom shape. (We have no equations in this custom shape.)\n\n– The markup of the final `draw:enhanced-geometry` element from step 4.\n\nSave this documentation into a library. You will need the document if you will change the shape or extend its features.\n\n7. Drag the shape into your Gallery for use in other documents (do it later, because some changes are still missing).\n\n4 https://odfvalidator.org/ [last called 2021-08-31]\n\nItem auto-detect of ODF Version is not reliable, choose OASIS ODF 1.3 (extended conforming).\n2.3 Attribute \\texttt{draw:text-areas}\n\nMake a document with your shape created in section 2.2. Enter some text.\n\nThe text added to the shape in Figure 5 consists of a sequence of ‘single character followed by space’ and has a small font size. Word wrap is enabled and text anchor is set to left/middle by the ‘Text attributes’ dialog. That makes the text area more visible.\n\nNotice the text position and size. The text area from the ‘Right Triangle’ shape is used. We need to adapt it to the new enhanced path. Figure 6 shows the desired area as hatched rectangle.\n\nThe area shall have 1/6 of the shape height and shall be vertically centered. The area shall not cover the shape. You need the left, top, right, and bottom coordinates of the area edges.\n\n\\begin{align*}\n\\text{left} &= 0, \\quad \\text{top} = \\frac{1}{2} \\cdot \\frac{5}{6} \\cdot 21600 = 9000 \\\\\n\\text{right} &= \\text{top} = 9000 \\quad \\text{and} \\quad \\text{bottom} = 21600 - 9000 = 12600.\n\\end{align*}\n\nSo, to get this rectangle you need \\texttt{draw:text-areas=\"0 9000 9000 12600\"} in the source file. Edit it accordingly and update your documentation.\n\nThe actual text is not restricted to the text-area rectangle and can overflow. The overflow directions can be controlled in the ‘Text Attributes’ dialog. You can find some hints on using the dialog in the wiki page ‘Text in Custom Shapes’.\\footnote{\\url{https://wiki.documentfoundation.org/Documentation/Text_in_Custom_Shapes} [last called 2021-08-29]}\n\nCoordinates can be negative. You can define a text-area, which is extended to the left, for example. Figure 7 shows the same shape – now with the attribute \\texttt{draw:text-areas=\"-6000 6000 6000 15600\"}\nWhy the attribute name has a plural ‘s’? Because the attribute can specify one or two text areas. If a second text area exists it is used in case the text style sets a writing mode “top-bottom”. Such writing mode is used for some East Asian languages.\n\nRotate the shape. Notice that the text area rotates together with the path.\n\nThe enhanced geometry of a custom shape provides the attribute `draw:text-rotate-angle` to add a rotation to the text area. The text area is rotated around its center and the rotation is clockwise. If the angle value has no unit, it defaults to degrees. You can determine the angle unit as `deg`, `grad` or `rad`. This attribute can be used to get an upright text in a rotated shape, for example.\n\nChange the markup for the right shape in figure 8 as this:\n\n```xml\n<draw:enhanced-geometry draw:type=\"non-primitive\" svg:viewBox=\"0 0 21600 21600\"\n draw:text-areas=\"0 9000 9000 126000\" draw:text-rotate-angle=\"90deg\"\n draw:glue-points=\"0 0 21600 10800 0 21600\"\n draw:enhanced-path=\"M 0 0 L 21600 10800 0 21600 10800 10800 Z N\" />\n```\n\nand you will get the results in the shape of figure 9.\nThere is no way to make the additional text area rotation to depend on the shape rotation. You need to adapt the text area rotation manually, when changing the shape rotation. Unfortunately, LibreOffice has yet no user interface for this attribute\\(^6\\). You have to edit the markup in the document source or use a macro.\n\nYou can add a ‘Text Box’ to the shape in Writer. This is generated with the position and size defined in the attribute `draw:text-areas`. But in fact, this ‘Text Box’ is a frame, and the shape will act as a frame. That means, the shape can no longer rotate and the text in this ‘Text Box’ cannot overflow but you get a red triangle that indicates that there is more text not shown.\n\n2.4 Attribute `draw:glue-points`\n\nThe shape ‘Right Triangle’ has glue points in the middle of its edges and in its corners. These positions are not always suitable for the new shape. It should get only glue points in its three outer corners. A glue point is given by x-coordinate and y-coordinate, separated by space. Multiple glue points are listed with a space between them.\n\n---\n\n**Exercise 2.6:**\n\nDetermine the needed attribute value.\n\n→ solution\n\nYou have surely found that you need `draw:glue-points=\"0 0 21600 10800 0 21600\"`. Change it in the new shape and update your documentation. Your shape is ready now.\n\n---\n\n\\(^6\\) [https://bugs.documentfoundation.org/show_bug.cgi?id=144942](https://bugs.documentfoundation.org/show_bug.cgi?id=144942)\nThe ODF standard defines the attribute `draw:glue-point-leaving-directions` to restrict the glue point so that a connector can leave it only in one direction. That is not implemented in LibreOffice. And the ODF standard defines the attribute `draw:glue-point-type`. That allows to auto-generate glue points or to forbid glue points. That is only partly implemented in LibreOffice. We therefore skip these attributes.\n\n### 2.5 Attribute `svg:viewBox`\n\nThe attribute `svg:viewBox` in ODF is derived from the similar attribute in the ‘Scalable Vector Graphics’ (SVG) language. The meaning of the parameters are `svg:viewBox=\"left top width height\"`. We examine it in this section.\n\n#### 2.5.1 Preparation\n\nStart with a new document in Draw. Set Draw (temporarily) to use measurement unit ‘Centimeter’. That is in menu Tools > Options > LibreOffice Draw > General > Settings. Set the grid to ‘Resolution’ 0.5 cm and ‘Subdivision’ 5. That is in Tools > Options > LibreOffice Draw > Grid.\n\nSet the page to 12 cm width and 8 cm height in menu Page > Page Properties > tab ‘Page’\n\n---\n\n\n\n*Figure 11: User defined page size*\n\n---\n\n… and left margin to 2 cm and top margin to 1 cm.\n\n---\n\nInsert the shape ‘Right Triangle’. Save the file. Open it in an editor to manipulate element `<draw:custom-shape>`.\n\nChange the element to the given values below. Keep the brown parts unchanged. Delete the attributes `draw:glue-point` and `draw:text-areas`, they are not relevant here.\n\n```\n<draw:custom-shape draw:style-name=\"gr1\"\n draw:text-style-name=\"P1\"\n draw:layer=\"layout\"\n svg:width=\"6cm\"\n svg:height=\"4cm\"\n svg:x=\"4cm\"\n svg:y=\"2cm\">\n <text:p/>\n```\n\n---\n\n7 [https://www.w3.org/TR/SVG11/coords.html#ViewBoxAttribute](https://www.w3.org/TR/SVG11/coords.html#ViewBoxAttribute)\n2.5.1 Preparation\n\nSave the changed file, but do not open it in LibreOffice now.\n\nThe markup above will generate a straight-line segment. Determine the coordinates of its start and end point in the document. Please only read further, after you have tried to calculate them.\n\n2.5.2 Explanation – Snap-Rectangle\n\nSo let see, how the calculation must be done.\n\nThe attributes `svg:width=\"6cm\"`, `svg:height=\"4cm\"`, `svg:x=\"4cm\"` and `svg:y=\"2cm\"` determine position and size of the rectangle of the resize-handles, which you get, when you click on the shape. This rectangle is called the ‘snap-rectangle’.\n\nLook at the status bar…\n\n… or open the ‘Position and Size’ dialog. The snap-rectangle has its left-top corner at \\((\\text{left} | \\text{top}) = (2.00 \\text{ cm} | 1.00 \\text{ cm})\\), and its size is \\(w \\times h = 6 \\text{ cm} \\times 4 \\text{ cm}\\).\n2 Basic Parts of a Custom Shape\n\n2.5.2 Explanation – Snap-Rectangle\n\nThe position values `svg:x=\"4cm\"` and `svg:y=\"2cm\"` refer to the page including margins, but the values in the UI refer to the content area excluding margins.\n\n- `snap-rectangle left = svg:x=\"4cm\" - left page margin 2 cm = 2 cm` in UI\n- `snap-rectangle top = svg:y=\"2cm\" - top page margin 1 cm = 1 cm` in UI\n\n2.5.3 Explanation – Attribute `svg:viewBox`\n\nThe attribute `svg:viewBox=\"10 40 180 80\"` maps the local coordinate system of the shape to position (2 cm | 1 cm) and size 6 cm × 4 cm of the snap-rectangle.\n\n**Table 1: Example of manual mapping of snap-rectangle to locale coordinate system**\n\n<table>\n<thead>\n<tr>\n<th>snap-rectangle in UI</th>\n<th>local coordinate system</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>left 2 cm</td>\n<td>10</td>\n</tr>\n<tr>\n<td>width 6 cm</td>\n<td>180</td>\n</tr>\n<tr>\n<td>1 cm distance in x-direction</td>\n<td>180 / 6 = 30 distance in x-direction</td>\n</tr>\n<tr>\n<td>top 1 cm</td>\n<td>40</td>\n</tr>\n<tr>\n<td>height 4 cm</td>\n<td>80</td>\n</tr>\n<tr>\n<td>1 cm distance in y-direction</td>\n<td>80 / 4 = 20 distance in y-direction</td>\n</tr>\n<tr>\n<td>left point (40</td>\n<td>80)</td>\n</tr>\n<tr>\n<td></td>\n<td>40 = 10 + 1 · 30</td>\n</tr>\n<tr>\n<td>left point y = top 1 cm + 2 · 1 cm = 3 cm</td>\n<td>80 = 40 + 2 · 20</td>\n</tr>\n<tr>\n<td>left point (3 cm</td>\n<td>3 cm)</td>\n</tr>\n</tbody>\n</table>\n2.5.3 Explanation – Attribute svg:viewBox\n\n<p>| | |</p>\n<table>\n<thead>\n<tr>\n<th></th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>right point x = left 2 cm + 5 \\cdot 1 cm = 7 cm</td>\n<td>160 = 10 + 5 \\cdot 30</td>\n</tr>\n<tr>\n<td>right point y = top 1 cm + 1 \\cdot 1 cm = 2 cm</td>\n<td>60 = 40 + 1 \\cdot 20</td>\n</tr>\n<tr>\n<td>right point (7 cm \\mid 2 cm)</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nFigure 16 shows the position of the axes of the local coordinate system of the shape related to the UI rendering.\n\n\n\n2.5.4 Further Remarks\n\nValues for left and top in the `svg:viewBox` attribute may be negative in the ODF standard and LibreOffice can use it. However, foreign applications might not be able to handle it and will show nothing or fall back to zero.\n\nValues for width and height cannot be strictly negative but may be zero. The attribute `svg:viewBox=\"0 0 0 0\"` would disable display of the shape, if the attribute was used in SVG. But it has a special meaning in LibreOffice as it is used for import and export filter with MS Office file formats. So, do not use it for own shapes.\n\nThe attribute `svg:viewBox=\"0 0 21600 21600\"` is used in most of the predefined custom shapes of LibreOffice. The reason is, that these shapes are designed for compatibility with the old, binary file format of MS Office, which uses these values. An advantage of value 21600 is, that it allows a lot of fractions with integer result. But you don't need to stick to it.\n\nOther places in LibreOffice – shapes of type Polygon for example – use values in 1/100 mm directly derived from the contained points.\n2.6 Exercise Solutions\n\n2.6.1 Exercise 2.1\nA(10800|0), B(21600|14400), C(7200|18000)\n\n2.6.2 Exercise 2.2\nIt is a rhombus.\n\n2.6.3 Exercise 2.3\nThe coordinates of the corner of the triangle have the coordinates \\((0|14400), (21600|0)\\) and \\((7200|21600)\\). There are multiple solutions depending on where you start the sub-path and whether you visit the corners clockwise or counter-clockwise. For example:\ndraw:enhanced-path=\"M 0 14400 L 21600 0 7200 21600 Z N\"\ndraw:enhanced-path=\"M 7200 21600 L 21600 0 0 14400 Z N\"\n\n2.6.4 Exercise 2.4\nAt first glance the shapes look the same, but shape (a) – that is the predefined 'Right Triangle' – consists of four points, and shape (b) consists of three points.\n(a) It has the points \\((0|0), (21600|21600), (0|21600)\\) and \\((0|0)\\).\n(b) It has the points \\((0|0), (21600|21600), (0|21600)\\).\nYou will notice that shape (a) has indeed four points, if you convert the shape to a polygon and then look into the status bar or drag the points of the polygon.\n\n2.6.5 Exercise 2.5\nThe command L requires existence of a ‘current point’. The pen needs to be already down. That is not the case when starting the drawing of the enhanced path.\n\n2.6.6 Exercise 2.6\nThe shape ‘Right Triangle’ has the glue point attribute\ndraw:glue-points=\"0 0 10800 0 21600 10800 21600 21600 21600 21600\"\nFor the new shape we need points left-top (0|0), right-middle (21600|10800), and left-bottom (0|21600),\n\ndraw:glue-points=\"0 0 21600 10800 0 21600\"\n3 Introduction to Handles and Equations\n\n3.1 Linear Handle and Modifiers\n\nStart making a new document in Draw, insert a shape ‘Right Triangle’ and save the file. Open the file in an editor and locate the element `<draw:custom-shape>`. Change the markup to that shown below, thereby keep the brown parts. Save the modified file and open it in LibreOffice.\n\n```xml\n<draw:custom-shape draw:name=\"Introductory example\"\n draw:style-name=\"gri\"\n draw:text-style-name=\"P1\"\n draw:layer=\"layout\"\n svg:width=\"4cm\"\n svg:height=\"3cm\"\n svg:x=\"5cm\"\n svg:y=\"6cm\">\n <text:p/>\n <draw:enhanced-geometry svg:viewBox=\"0 0 100 100\"\n draw:type=\"non-primitive\"\n draw:modifiers=\"50\"\n draw:enhanced-path=\"M $0 0 L 1 00 1 00 0 Z N\">\n <draw:handle draw:handle-position=\"$0 top\" />\n </draw:enhanced-geometry>\n</draw:custom-shape>\n```\n\nThe blue, bold parts are new. What do they mean?\n\nYou should get a shape like shown in Figure 18. Click on it and then drag the handle. You can move it horizontally and the triangle changes the position of its top vertex.\n\nThe handle is generated by the element `<draw:handle draw:handle-position=\"$0 top\" />`\n\nThe element `<draw:handle>` is a sub-element of the `<draw:enhanced-geometry>` element. Therefore there is no longer the markup `/` for an empty element, but there is the closing tag `</draw:enhanced-geometry>`.\n\nThe attribute `draw:handle-position` of the handle has two parameters. The first one is the x-coordinate, the second one the y-coordinate.\n\nThe value `top` for the second parameter is a constant and means the value `top` of the `svg:viewBox` attribute. So instead of `top` you could use the value `0` here as well. Of course, there are constants `left`, `right` and `bottom` for the other edges of the viewBox rectangle too. All possible constants are listed in ‘Table 13 - Handle position constants’ in section 19.179 `draw:handle-position` in the ODF standard.\n\n---\n\nThe value $0$ for the first parameter is a reference to the first value in the `draw:modifiers` attribute. The value 50 in the source file is the value at time of saving. If you move the handle, this value changes. The same value is then used in the attribute `draw:enhanced-path`. As result, the start point in the ‘moveto’ command changes when you drag the handle. The values in the attribute `draw:modifiers` are counted from left to right starting with zero.\n\nThe value in the `draw:modifiers` attribute is not an absolute length, but it is a coordinate in the local coordinate system of the shape. Hence the value 50 generates an isosceles triangle here.\n\n**Exercise 3.1**\n\nWhich value in the `draw:modifiers` attribute is needed to get a right triangle? Will it remain to be a right angle, when you change the size of the shape?\n\n→ **solution**\n\nThe position of the handle can be set numerically in the UI. Select the shape, open the ‘Position and Size’ dialog and go to tab ‘Slant & Corner Radius’. The setting is neither a ‘slant’ nor a ‘corner radius’. But when the fields for the handle position have been implemented, this tab had enough room for the new controls.\n\n‘Control Point 1’ is the handle of the shape. ‘Control Point 2’ is for the case, that the shape has a second handle. (The fact, that the fields of ‘Control Point2’ are not grayed out here, is an error in that dialog.)\n\nYou see that the value in the field is not a value of the local coordinate system of the shape, but the coordinate of the handle in the UI. Thereby, the value is measured from the left edge of the snap-rectangle of the shape.\n\n**Exercise 3.2**\n\nWhich value do you need to enter to get a right triangle?\n\n→ **solution**\n\n**Exercise 3.3**\n\nThere are two more values beside ‘2cm’, which make the triangle an isosceles triangle. Calculate them. Tip: use Pythagoras’ theorem.\n\nDoes the triangle remain a right triangle when you change height or change width of this shape?\n\n→ **solution**\nA reference to a value in the `draw:modifiers` attribute may be used in attributes `draw:glue-points` and `draw:text-areas` too. To get a glue point that remains at the tip of the rectangle you can use `draw:glue-points=\"0 0\"`, for example.\n\nShapes with handles exist in the OOXML standard too. There the modifiers are called ‘adjustment values’. This term is used in the code of LibreOffice as well.\n\n### 3.2 Equations\n\nNow we will change the triangle of section 3.1 so that the text-area is bound to the top vertex of the triangle and moves along with it, when the top is moved. The width of the text-area shall be 50% of the width of the triangle and the height 25% of the height of the triangle. It shall be placed so, that the tip of the triangle is in the middle of the bottom edge of the text-area.\n\nFigure 20 shows a sketch including local coordinate system and viewBox.\n\n\n\nTop edge coordinate = −25, bottom edge coordinate = 0.\n\nLeft edge coordinate = $0 − 25$, right edge coordinate = $0 + 25$.\n\nThe left and right edge coordinate require a mathematical term. But the attribute `draw:text-areas` and attributes `draw:enhanced-path` and `draw:glue-point` neither – allow mathematical terms in the point coordinates.\n\nThe solution is the element `<draw:equation>`. It is a sub-element of the `<draw:enhanced-geometry>`.\n\n```\n<draw:equation draw:name=\"f0\" draw:formula=\"$0-25\"/>\n<draw:equation draw:name=\"f1\" draw:formula=\"$0+25\"/>\n```\n\nSo a `<draw:equation>` element has the parameter `draw:name`, which provides an identifier for the formula, and parameter `draw:formula`, which contains the mathematical expression to be evaluated.\nThe result of the evaluation can be used in point coordinates and in other expressions by writing a reference to the formula. A reference is constructed by the character `?` immediately followed by the identifier of the equation.\n\nThe desired text-area is then defined by `draw:text-areas=\"?f0 -25 ?f1 0\"` (left top right bottom).\n\nThe complete `<draw:enhanced-geometry>` element for the triangle is then\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 100 100\"\n draw:text-areas=\"?f0 -25 ?f1 0\"\n draw:type=\"non-primitive\"\n draw:modifiers=\"128\"\n draw:enhanced-path=\"M $0 0 L 100 100 0 100 Z N\">\n <draw:equation draw:name=\"f0\" draw:formula=\"$0-25\"/>\n <draw:equation draw:name=\"f1\" draw:formula=\"$0+25\"/>\n <draw:handle draw:handle-position=\"$0 top\"/>\n</draw:enhanced-geometry>\n```\n\nYou can place as many of the `<draw:equation>` elements as you need before the `<draw:handle>` elements. The `<draw:equation>` elements are evaluated in the order they are written in the source file.\n\nThe ODF standard allows to use arbitrary identifiers, and using meaningful identifiers helps to understand the purpose of a formula. Isn’t the following easier to understand?\n\n```xml\ndraw:text-areas=\"?left -25 ?right 0\"\n<draw:equation draw:name=\"left\" draw:formula=\"$0-25\"/>\n<draw:equation draw:name=\"right\" draw:formula=\"$0+25\"/>\n```\n\nSadly, when LibreOffice opens the file, it throws away the existing identifiers and enumerates the equation as f0, f1, f2, ..., when it saves the file. Therefore it is very important to document your own shape as described in section 2.2.\n\nThe OOXML standard uses equations in its shapes too. In this case, the element is called `guide`.\n\n### 3.3 Restriction of Handle Movement\n\nStart a new document. Insert the shape created in section 3.2 and insert the predefined shape ‘Isosceles Triangle’ from the ‘Basic Shapes’ set. Drag the handle far away from the base of the triangle. Notice that this is possible with your own shape but not with the predefined one. The handle can only be dragged to the left or right edge of the snap-rectangle in the shape ‘Isosceles Triangle’.\n\nSuch restrictions are done by the attributes `draw:handle-range-x-maximum` and `draw:handle-range-x-minimum` for the horizontal direction and `draw:handle-range-y-maximum` and `draw:handle-range-y-minimum` for the vertical direction. These are attributes of the `<draw:handle>` element.\nPossible values of these attributes are the same as in a parameter of the draw:handle-position attribute. That is, you can use a number, one of the above-mentioned constants, a reference to a modifier or a reference to a formula.\n\nWith the restriction of the handle movement to the range of the snap-rectangle, the complete <draw:enhanced-geometry> element would be\n<draw:enhanced-geometry svg:viewBox=\"0 0 100 100\"\n draw:text-areas=\"?f0 -25 ?f1 0\"\n draw:type=\"non-primitive\"\n draw:modifiers=\"128\"\n draw:enhanced-path=\"M $0 0 L 100 100 0 100 Z N\">\n <draw:equation draw:name=\"f0\"\n draw:formula=\"$0-25\"/>\n <draw:equation draw:name=\"f1\"\n draw:formula=\"$0+25\"/>\n <draw:handle draw:handle-position=\"$0 top\"\n draw:handle-range-x-minimum=\"left\"\n draw:handle-range-x-maximum=\"right\" />\n</draw:enhanced-geometry>\n\n**Exercise 3.4**\n\nWith the predefined parallelogram in the ‘Basic Shapes’ set, you can move the top edge horizontally. We want a similar parallelogram but for vertical shearing.\n\nCreate an <draw:enhanced-geometry> element, so that the right edge can be moved up and down. The parallelogram shall become a rectangle at the topmost position of the handle and a line segment at the lowest position.\n\n→ solution\n\n### 3.4 Overflow\n\nIn the shear taught in mathematics class, neither the base nor the opposite edge of the parallelogram change their length, but the opposite edge is only shifted. To get this kind of shear, you could make the design as shown in Figure 22.\nand use the following markup\n\n```xml\n<draw:enhanced-geometry\ndraw:modifiers=\"40\"\ndraw:enhanced-path=\"M 0 0 L 100 $0 100 ?f0 0 100 Z N\">\n <draw:equation draw:name=\"f0\" draw:formula=\"100+$0\"/>\n <draw:handle draw:handle-position=\"right $0\"/>\n</draw:enhanced-geometry>\n```\n\nAs you can see in Figure 22, the drawn parallelogram overflows the snap-rectangle. That is no problem in Draw/Impress but might be in text documents or spreadsheets.\n\nCreate this shape and insert it in a text document with lot of dummy text. Set the shape anchor type to ‘as character’. Notice that the automatic recalculation of the line height is based on the snap-rectangle. The parallelogram overflows the text above or below. You can tweak the wrap behavior by adding a top or bottom spacing in the wrap properties.\n\nA similar problem exists in spreadsheets. Insert the shape into a cell and anchor it ‘to cell’. Then use tool ‘Fit to Cell Size’ from the context menu of the shape. The size is adapted so that the snap-rectangle fits into the cell. The overflowing drawing is not considered.\n3.5 Functions\n\nWe will create a right triangle with horizontal base by using a Thales' circle.\n\nIn the first version we use only the upper half circle. We set the viewBox rectangle twice as wide as high. Of course the snap-rectangle needs the same ratio for to get really a right triangle.\n\nThe sketch in Figure 27 indicates the needed calculations. For the coordinates of point $P(x_p | y_p)$ in respect to the center of the circle as origin we get $y_p = \\sqrt{50^2 - (x_p)^2}$.\n\nThe Table 2 lists the functions, which are available for use in formulas. It is cited from the ODF standard.\n\nTable 2: Available functions for attribute draw:formula\n\n<table>\n<thead>\n<tr>\n<th>Markup</th>\n<th>Meaning</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>abs(n)</td>\n<td>returns the absolute value of n</td>\n</tr>\n<tr>\n<td>sqrt(n)</td>\n<td>returns the positive square root of n</td>\n</tr>\n<tr>\n<td>sin(n)</td>\n<td>returns the trigonometric sine of n, where n is an angle specified in radians</td>\n</tr>\n<tr>\n<td>cos(n)</td>\n<td>returns the trigonometric cosine of n, where n is an angle specified in radians</td>\n</tr>\n<tr>\n<td>tan(n)</td>\n<td>returns the trigonometric tangent of n, where n is an angle specified in radians</td>\n</tr>\n<tr>\n<td>atan(n)</td>\n<td>returns the arc tangent of n in radians</td>\n</tr>\n<tr>\n<td>min(x,y)</td>\n<td>returns the smaller of two values</td>\n</tr>\n<tr>\n<td>max(x,y)</td>\n<td>returns the greater of two values</td>\n</tr>\n<tr>\n<td>atan2(y,x)</td>\n<td>returns the angle in radians of the vector (x,y) with the x-axis</td>\n</tr>\n<tr>\n<td>if(c,x,y)</td>\n<td>conditional testing: if c is greater than zero then the result of evaluating x is returned, otherwise the result of evaluating y is returned.</td>\n</tr>\n</tbody>\n</table>\n\nFor our triangle with point P as handle the idea is now:\n\nmodifier $0$ \\hspace{1cm} x-coordinate of handle\n\n$f0=0-50$ \\hspace{1cm} value $x_p = \\text{modifier} - 50$\n\n---\n\nIt is from Table 12 in section ‘19.171 draw:formula’ in part 2.\n3 Introduction to Handles and Equations\n\n3.5 Functions\n\n\\[ f_1 = \\sqrt{50 \\times 50 - y_0 \\times y_0} \\]\n\nvalue \\( y_p \\). There exists no power-function, we need to multiply\n\n\\[ f_2 = 50 - f_1 \\]\n\ny-coordinate of handle = \\( 50 - y_p \\)\n\nThe x-coordinate of the handle needs to be restricted to the range \\([0;100]\\). Otherwise the value \\( x_p \\) will be outside the range \\([-50;50]\\) and the radicand of the square root would be negative.\n\n---\n\n**Exercise 3.5**\n\nCreate the markup of a suitable `<draw:enhanced-geometry>` element.\n\n→ **solution**\n\nIn the second version we use a full circle. This cannot be solved with a horizontal modifier because you would not be able to differentiate, whether the vertex of the triangle is in the upper or lower half circle.\n\nThe sketch in Figure 28 shows a suitable idea. The handle is now freely movable, which implies, that there need to be two modifiers. The vertex of the triangle is then the intersection point of the ray from the center through the handle position.\n\nCalculation is firstly straight forward. Get an angle \\( \\alpha \\) from the handle position using the `atan2` function. Then calculate the position of the vertex using \\( \\cos(\\alpha) \\) and \\( \\sin(\\alpha) \\).\n\nBut `atan2(0,0)` is not defined. The ODF standard does not specify a replacement value for this case. We could set the tip of the triangle same as for \\( \\alpha=0 \\) in this case. The challenge is to detect this case. There exist no comparison operators and no logic operators. The only possibility is to use the `if` function with its ‘is positive’ condition.\n\nI have added the idea here, because we will see the same idea later, when we discuss commands to draw circles and arcs, and because it introduces you to the formula language of custom shapes.\n\n---\n\n**Exercise 3.6**\n\nCreate the markup of a suitable `<draw:enhanced-geometry>` element. You should at least be able to do so, if you do not consider the special case of `atan2(0,0)`. You can afterwards find an idea for the special case in the exercise solution.\n\n→ **solution**\n\n---\n\n3.6 Polar Handles\n\nA polar handle does not move horizontally or vertically but on a circular path around a center. Its position is not specified by Cartesian coordinates \\((x|y)\\) but by polar coordinates \\((radius, angle)\\). A handle is a ‘polar handle’ if it has the attribute `draw:handle-polar`.\n\n---\n Markup example for a polar handle\n\n```xml\n<draw:handle\n draw:handle-polar=\"20 40\"\n draw:handle-position=\"30 120\" />\n```\n\nThe `draw:handle-polar` attribute specifies the center of the circle. In the example the center has the coordinates (20|40).\n\nThe `draw:handle-position` attribute specifies the radius of the circle in its first parameter and the angle in degree in its second parameter. The angle is measured from the positive x-axis towards the positive y-axis. Because the y-axis points down, this is clockwise on screen.\n\nCaution, the order radius/angle is different form the current contents in section ‘19.179 draw:handle-position’ in ODF 1.3, part 3. But this order is actually used not only by LibreOffice but also by other applications.\n\nThe radius can be restricted by the attributes `draw:handle-radius-range-minimum` and `draw:handle-radius-range-maximum`. The angle is used modulo 360. An angle of 230° results in the same handle position as the angle −130°, for example.\n\nWe use the Thales’ circle problem again. If you tried the solution from Exercise 3.6, you noticed that the handle movement is not intuitive in that solution. You will see that a polar handle moves much better along the Thales’ circle.\n\nThe markup of the `<draw:enhanced-geometry>` could be\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 100 100\" draw:type=\"non-primitive\"\n draw:modifiers=\"120\"\n draw:enhanced-path=\"M 0 50 L ?f 0 ?f 100 50 Z N\">\n <draw:equation draw:name=\"f0\"\n draw:formula=\"50+50*cos($0*pi/180)\" />\n <draw:equation draw:name=\"f1\"\n draw:formula=\"50+50*sin($0*pi/180)\" />\n <draw:handle draw:handle-polar=\"50 50\"\n draw:handle-position=\"50 $0\"/>\n</draw:enhanced-geometry>\n```\n\nTo draw the line segment of the triangle, we need Cartesian coordinates. We get them the same way as in Exercise 3.6 only that the result of function `atan2` is an angle in radians and here we have an angle in degrees. To fit the trigonometric functions `sin` and `cos`, the values in degree needs to be converted. This is done by the factor pi/180. The identifier `pi` is a ready to use constant.\n\nThe above markup has no glue points defined. Consider adding glue points for the center of the circle and for the vertex of the triangle. That would allow to add a connector to indicate the radius line segment.\nYou have seen that the ‘Position and Size’ dialog shows positions of linear handles. Does it show the Cartesian coordinates of a polar handle? Can you enter coordinates, so that a desired angle is stored? Create a shape with the above markup, set its size to 4 cm width and 4 cm height and test it. You will find that the ‘Position and Size’ dialog is not yet usable with polar handles.\n\n### 3.7 Further Handle Attributes\n\nThe ODF standard specifies the attributes `draw:handle-mirror-horizontal`\\(^{10}\\) and `draw:handle-mirror-vertical`\\(^{11}\\). These attributes are preserved by LibreOffice, but not evaluated.\n\nThe ODF standard specifies the attribute `draw:handle-switched`\\(^{12}\\). If `true`, then the handle directions are swapped if shape height exceeds shape width. I do not have a meaningful example yet.\n\n### 3.8 Exercise Solutions\n\n#### 3.8.1 Exercise 3.1\n\nYou get a right triangle for modifier values 0 and 100. Because resizing is a transformation in vertical or horizontal direction and the arms of the right angle are vertical and horizontal too, it remains a right angle.\n\n#### 3.8.2 Exercise 3.2\n\nThe triangle becomes a right triangle if the handle is at the left or at the right edge of the snap-rectangle. So you need to enter 0 cm or 4 cm to get a right triangle.\n\n#### 3.8.3 Exercise 3.3\n\n\\[ x = \\sqrt{4^2 - 3^2} = \\sqrt{7} \\approx 2.646 \\]\n\nThe needed value for the left solution is \\(-2.646\\) cm. You can enter the negative value in the dialog, but on reopening the dialog, it will show zero. The dialog needs obviously some improvements.\n\nFor the right solution you get 6.646 cm. Remember that the values in the field are relative to the left edge of the snap-rectangle.\n\nIf you change either width or height, the hypotenuse will change with a different factor than width or height. Therefore the triangle will not stay isosceles. It becomes obvious when you drag the shape to a huge width or height. You would need to calculate a new value for the handle position.\n\n---\n\n\n3.8.4 Exercise 3.4\n\nThe length of the vertical edges are reduced when shearing becomes larger.\n\n<draw:enhanced-geometry svg:viewBox=\"0 0 100 100\" draw:type=\"non-primitive\"\n draw:modifiers=\"40\"\n draw:enhanced-path=\"M 0 0 L 100 0 100 100 0 ?f0 Z N\">\n <draw:equation draw:name=\"f0\" draw:formula=\"100-$0\"\n draw:handle draw:handle-position=\"right $0\"\n draw:handle-range-x-minimum=\"top\"\n draw:handle-range-x-maximum=\"bottom\"/>\n</draw:enhanced-geometry>\n\n3.8.5 Exercise 3.5\n\n<draw:enhanced-geometry svg:viewBox=\"0 0 100 50\" draw:type=\"non-primitive\"\n draw:modifiers=\"70\"\n draw:enhanced-path=\"M 0 50 L $0 ?f2 100 50 Z N\">\n <draw:equation draw:name=\"f0\" draw:formula=\"$0-50\"\n draw:equation draw:name=\"f1\" draw:formula=\"sqrt(50*50-?f0*?f0)\"\n draw:equation draw:name=\"f2\" draw:formula=\"50-?f1\"\n draw:handle draw:handle-position=\"$0 ?f2\"\n draw:handle-range-x-minimum=\"left\"\n draw:handle-range-x-maximum=\"right\"/>\n</draw:enhanced-geometry>\n\n3.8.6 Exercise 3.6\n\nModifier values are given in the local coordinate system. Hence you need to change them to a coordinate system, where the center of the circle is the origin. And after doing the trigonometric calculations, you need to bring the values back to the local coordinate system of the shape.\n\nTo convert the condition (x≠0 ∨ y≠0) into the formula language is a challenge. Table 3 below gives some general hints how to translate conditions to the possibilities of the formula language of custom shapes.\n\n<draw:enhanced-geometry svg:viewBox=\"0 0 100 100\" draw:type=\"non-primitive\"\n draw:modifiers=\"60 80\"\n draw:enhanced-path=\"M 0 50 L ?f3 ?f4 100 50 Z N\">\n <draw:equation draw:name=\"f0\" draw:formula=\"?$0 - 50\" />\n <draw:equation draw:name=\"f1\" draw:formula=\"?$1 - 50\" />\n <draw:equation draw:name=\"f2\"\n### 3.8.6 Exercise 3.6\n\n```\n<draw:formula=\"if(abs(?f0)+abs(?f1),atan2(?f0,?f1),0) />\n<draw:equation draw:name=\"f3\" draw:formula=\"50+50*cos(?f2)\"/>\n<draw:equation draw:name=\"f4\" draw:formula=\"50+50*sin(?f2)\"/>\n<draw:handle draw:handle-position=\"$0 $1\"/>\n</draw:enhanced-geometry>\n```\n\nTable 3: Translate conditions to formula language\n\n<table>\n<thead>\n<tr>\n<th>Condition</th>\n<th>Translation</th>\n</tr>\n</thead>\n</table>\n| if (a > b) then A else B | $a > b \\iff a - b > 0$ \nif(a-b,A,B) |\n| if (a ≥ b) then A else B | $a \\geq b \\iff \\neg(a < b) \\iff \\neg(b > a) \\iff \\neg(b - a > 0)$ \nFor negation exchange the branches. \nif (Cond.) then A else B ⇔ if (¬Cond.) then B else A \nif(b-a,B,A) |\n| if (a ≠ b) then A else B | $a \\neq b \\iff a - b \\neq 0 \\iff |a - b| > 0$ \nif(abs(a-b),A,B) |\n| if (a = b) then A else B | Negation of (a ≠ b) \nif(abs(a-b),B,A) |\n| if (a ≠ b ∨ c ≠ d) then A else B | Sum of non-negative values is only positive if at least one value is positive \nif(abs(a-b)+abs(c-d),A,B) |\n| if (a = b ∧ c = d) then A else B | Negation of (a ≠ b ∨ c ≠ d) \nif(abs(a-b)+abs(c-d),B,A) |\n| if (a ≠ b ∧ c ≠ d) then A else B | Product of non-negative values is only positive of both factors are positive \nif(abs(a-b)*abs(c-d),A,B) |\n| if (a = b ∨ c = d) then A else B | Negation of (a ≠ b ∧ c ≠ d) \nif(abs(a-b)*abs(c-d),B,A) |\n4 Quadrants\n\n4.1 Introduction\n\nAfter a lot of mathematics in chapter 3 the examples in this chapter are artistic. Let’s create tiles like this, for example.\n\nYou can mirror and rotate tiles and combine them to borders and wallpapers. The tool Edit > Duplicate in Draw can help you in that.\n\nExamples:\n\nThe quadrants will be used in addition to the already known lines in chapter 5 “Fill and Stroke”.\n\n36\n4 Quadrants\n\n4.2 Single Quadrant\n\nThe ODF standard provides the commands X and Y for drawing quadrants. Their definition is in “Table 10 - Enhanced path commands”\\textsuperscript{13}\n\nTable 4: Description of commands X and Y\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Name</th>\n<th>Parameters</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>X</td>\n<td>elliptical-quadrantx</td>\n<td>(x y) +</td>\n<td>Draws a quarter ellipse, whose initial segment is tangential to the x-axis from the current point to (x, y). For each additional quarter ellipse command, the axis to which the segment is tangential to switches from x to y and from y to x.</td>\n</tr>\n<tr>\n<td>Y</td>\n<td>elliptical-quadranty</td>\n<td>(x y) +</td>\n<td>Draws a quarter ellipse, whose initial segment is tangential to the y-axis from the current point to (x, y). For each additional quarter ellipse command, the axis to which the segment is tangential to switches from y to x and from x to y</td>\n</tr>\n</tbody>\n</table>\n\nSome examples will show how they are used. Start with a custom shape ‘Rectangle’, set its area fill to ‘None’ and line width to 0.5 mm. Use a square size, edge length 4 cm will work well.\n\nOpen the file for editing the element <draw:enhanced-geometry>. Use the markup\n\n```xml\n<draw:enhanced-geometry\n svg:viewBox=\"0 0 100 100\"\n draw:type=\"non-primitive\"\n draw:enhanced-path=\" ... \">\n\nThe commands X and Y expect a ‘current point’. Hence our path starts with a ‘moveto’-command. Set the pen to the center of the viewBox rectangle. Our first target point is (0|25). With command X the markup is then\n\n```xml\ndraw:enhanced-path=\"M 50 50 X 0 25\"\n```\n\nWhat is drawn? The wording “tangential to the x-axis“ might not be clear. It means, that the segment leaves the current point horizontally, namely to the side where the target point is placed.\n\n\n\nThe current point and the target point determine the center of an ellipse. The ellipse meets current point and target point. The drawn segment is the short elliptic arc from current point to target point.\n\n\\textsuperscript{13} in section 19.145 draw:enhanced-path in part3, ODF 1.3.\n\n\n37\nExercise 4.1\n\nNote down the complete value for the `draw:enhanced-path` attribute to get the segment in Figure 33. Which point is center of the circle? Which point needs to become ‘current point’ and which is target point, if you use the X command?\n→ solution\n\nThe Y command works similar, only that the segment leaves the current point vertically. So you can get the quadrant of Figure 33 using the Y command as well. Start in point (100|100), go vertically up towards point (0|0). The according markup would be\n\n```\ndraw:enhanced-path=\"M 100 100 Y 0 0\"\n```\n\nThe difference between the two solutions become visible, if you apply a line style with arrowhead.\n\n4.3 Sequence of Quadrants\n\nYou have learned that it is allowed to omit the character of a command, if several identical commands follow each other immediately. The path \"L 10 30 50 20 10 90\" means the same as the path \"L 10 30 L 50 20 L 10 90\".\n\nThe same rule applies to command X and Y in principle. The path \"M 50 0 X 100 50 50 100 0 50 50 0\" means the same as path \"M 50 0 X 100 50 X 50 100 X 0 50 X 50 0\".\n\nBut the resulting shape is Figure 35 and not Figure 34. Why?\nThat is the sentence “For each additional quarter ellipse command, the axis to which the segment is tangential to switches from x to y and from y to x.” in the ODF standard\\textsuperscript{13}. So in fact the commands X and Y do the same. They draw a sequence of elliptic quadrants with alternating between horizontal and vertical start direction for the segments. Only that command X starts with horizontal direction and command Y starts with vertical direction.\n\nTo get the drawing of Figure 34, you need a different command than X or Y in between. You can use command M for example. That lifts off the pen and you start newly. In fact Figure 34 was created by the path \"M 50 0 X 100 50 M 100 50 X 50 100 M 50 100 X 0 50 M 0 50 X 50 0 N\".\n\n**Exercise 4.2**\n\nWrite down a complete `<draw:enhanced geometry>` element for a custom shape to show a heart like in Figure 36. Restrict the text area to the hatched square as discussed in chapter 2.3\n1. Tip: Use a suitable size of the viewBox\n2. Tip: Start with the intersection point of the two half circles.\n\n→ solution\n\n**Exercise 4.3**\n\nWrite down a complete `<draw:enhanced geometry>` element for a custom shape to show the blue drawing of Figure 37. The inner circle shall touch the outer quadrants. For to accomplish this, the distances as in Figure 37 has to be used. Do not calculate \\( \\sqrt{2} \\) by yourself but use a `<draw:equation>` element as discussed in chapter 3.\n\n→ solution\n4.4 Exercise Solutions\n\n4.4.1 Exercise 4.1\n\nPoint (0|100) is center of the circle.\n\n4.4.2 Exercise 4.2\n\nThe value for the enhanced-path might be very long. You can insert line breaks and additional spaces. And you can write a comma between parameters – not between command and parameter. These things are not permanent but help you to not lose track while editing.\n\nThe needed points are at ⅓ and ⅔ of the width. Therefore, a viewBox width is suitable, which is divisible by 3.\n\nRemember, the values for the text area have the meaning ‘left top right bottom’.\n\n```xml\n<draw:enhanced-geometry\n draw:type=\"non-primitive\"\n svg:viewBox=\"0 0 60 60\"\n draw:text-areas=\"20 20 60 60\"\n draw:enhanced-path=\"M 20,20 Y 40,0 60,20\n L 60,60 20,60\n X 0,40 20,20\" />\n```\n\nThis `<draw:enhanced-geometry>` element has no child elements. Therefore it ends with `/>`.\n\nOther solutions are possible.\n### 4.4.3 Exercise 4.3\n\nThis solution draws first the outer quadrants and second the inner circle.\n\n```xml\n<draw:enhanced-geometry\ndraw:type=\"non-primitive\"\nsvg:viewBox=\"0 0 60 60\"\ndraw:enhanced-path=\"M 0,30 X 30,0 60,30 30,60 0,30\nM ?f0,30 Y 30,?f0 ?f1,30 30,?f1 ?f0,30\" >\n<draw:equation draw:name=\"f0\" draw:formula=\"60/sqrt(2)\" />\n<draw:equation draw:name=\"f1\" draw:formula=\"60?-f0\" />\n</draw:enhanced-geometry>\n```\n\nThis `<draw:enhanced-geometry>` element has child elements. Hence it needs an end tag.\n5 Fill and Stroke\n\n5.1 Set of Sub-paths\n\nTo get a path with two quadrants with same start direction, you cannot use two commands X following directly each other, but you need a command in-between. You can use a command M or a command L. Does that work the same way? Use a graphic style with no area fill and no line arrowheads and then try it out.\n\nNow change the line style of the object so, that it has a ‘Circle’ at start and an ‘Arrow’ at end and set the area fill to some color. You will get this\n\n<table>\n<thead>\n<tr>\n<th>Command 1</th>\n<th>Command 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>"M 0 0 X 30 30 L 30 30 X 60 0"</td>\n<td>"M 0 0 X 30 30 M 30 30 X 60 0"</td>\n</tr>\n<tr>\n<td>not filled</td>\n<td>not filled</td>\n</tr>\n<tr>\n<td>filled</td>\n<td>filled</td>\n</tr>\n</tbody>\n</table>\n\nIn the solution with command L the entire path is treated as one sub-path. In the solution with command M it is treated as two sub-paths.\n\nRule: The command M always starts a new sub-path.\n\nNow look at the fill. In a custom shape you don't need a closed path to fill it. It is different from curve and polygon objects. The start point and the end point of a sub-path are connected by an imaginary straight-line segment and the area of this thus ‘closed’ sub-path is filled.\n\nRule: Each sub-path determines an own fill area. Thereby the area is bounded by the sub-path itself and a fictive straight-line segment from start point to end point.\n\nNext we will generate the shape in Figure 39.\n\nA trial with path value \"M 30 30 Y 0 0 L 30 0 Z\" will not work. The sector gets lines and the arc has no longer arrowheads because the path is closed. The values \"M 30 30 Y 0 0 L 30 0\" and \"M 30 0 L 30 30 Y 0 0\" will work neither. We need something to suppress fill of the arc and lines of the sector. Look at “Table 10 - Enhanced path commands“ in the ODF standard\\(^\\text{14}\\). You will find (in parts cited from there):\n\n\\(^\\text{14}\\) \\url{https://docs.oasis-open.org/office/OpenDocument/v1.3/os/part3-schema/OpenDocument-v1.3-os-part3-schema.html#refTable9}\nTable 5: Description of commands F and S\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Name</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>F</td>\n<td>nofill</td>\n<td>Specifies that the current set of sub-paths will not be filled.</td>\n</tr>\n<tr>\n<td>S</td>\n<td>nostroke</td>\n<td>Specifies that the current set of sub-paths will not be stroked.</td>\n</tr>\n</tbody>\n</table>\n\n\"stroke\" is the technical term for what is called a \"line\" in the user interface.\n\nWe now use value \"M 30 30 Y 0 0 L 30 0 Z\" for the sector and value \"M 30 30 Y 0 0\" for the arc and add the F and S commands.\n\nTry value \"M 30 30 Y 0 0 F M 30 30 Y 0 0 L 30 0 Z S\". You get – nothing. The F and S commands are applied to both arc and sector so that actually nothing is drawn. The description contains “current set of sub-paths”. Arc and sector need to be in different sets. To start a new set, use the command N (again partly cited from ODF standard).\n\nTable 6: Description of command N\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Name</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>N</td>\n<td>endpath</td>\n<td>Ends the current set of sub-paths. The sub-paths will be filled by using the “even-odd” filling rule. Other following subpaths will be filled independently.</td>\n</tr>\n</tbody>\n</table>\n\n(\"even-odd\" filling rule will be discussed in section 5.2)\n\nNext try is value \"M 30 30 Y 0 0 F N M 30 30 Y 0 0 L 30 0 Z S\". You get a shape like Figure 40. The sector is in front of the arc and partly hides the line ends. A set of sub-paths is always drawn in front of the sub-paths from previous sets. We need it swapped, first draw sector then arc.\n\nValue \"M 30 30 Y 0 0 L 30 0 Z S N M 30 30 Y 0 0 F\" gives the desired shape.\n\n5.2 Overlapping Areas\n\nIf the enhance-path value has several sub-paths areas overlap can happen. If the sub-paths belong to the same set, the “even-odd” filling rule is used for the areas. The lines of the paths are always drawn on top of the area fill for sub-paths in the same set.\n\nIf sub-paths belong to different sets, that is a command N is in-between, then first the painting of each set is determined, and these paintings are then drawn on top of each other. Thereby the sets are drawn in the order they appear in the attribute value.\n\n5.2.1 Example for ‘even-odd’ Filling Rule\n\nThe shape in Figure 41 was generated by the markup\n\ndraw:enhanced-path=\n \"M 30 0 L 0 20 30 40 Z\n M 40 0 10 20 40 40 Z\n M 0 0 40 20 0 40 Z\"\n5 Fill and Stroke\n\n5.2.1 Example for ‘even-odd’ Filling Rule\n\nThe shape has three large triangles. Figure 42 shows them as hatched triangles to highlight how many areas overlap. If an odd number of areas overlap – including case of one area – then the points in the overlapping part are drawn. If an even number of areas overlap – including case of no area –, then the points in the overlapping part are not drawn, this overlapping part becomes transparent.\n\nIf you search internet for “even-odd filling rule”, you will get formal definitions using a ray\\textsuperscript{15}. For the purpose of making your own custom-shapes it is easier to count the number of areas involved in the overlap.\n\nFigures 43 and 44 show counting the areas involved in an overlap.\n\nExercise 5.1\n\nCreate a shape with Yin-Yang symbol\\textsuperscript{16}.\n\nThe Yin-Yang symbol has two colors – Black and White. That is not possible with one custom-shape. Create the shape so the white areas are transparent instead. Then you get the desired Yin-Yang symbol, if you show the shape in front of a white background. That might be the document background, or you use a white circle, which you place behind the Yin-Yang symbol.\n\n→ solution\n\n\\textsuperscript{15} See https://www.w3.org/TR/SVG11/painting.html#FillProperties, for example.\n\n\\textsuperscript{16} For Yin-Yang symbol see e.g. https://en.wikipedia.org/wiki/Yin_and_yang\n5.2.2 Example for Stacked Filled Areas\n\nChange the markup of previous example so, that it has three sets of sub-paths, in fact each set has one sub-path.\n\n\\[\n\\text{draw:enhanced-path} = \"M 30 0 L 0 20 30 40 Z N M 40 0 10 20 40 40 Z N M 0 0 40 20 0 40 Z\"\n\\]\n\nThe shape looks as in Figure 45.\n\nThe areas behind still exist and are visible, if you set some transparency for the fill, here 75%. The color will then accumulate.\n\nExercise 5.2\n\nHow looks the shape, if we make only two sets? Try to sketch the result. Then test whether you are right by creating the shape.\n\na) \\text{draw:enhanced-path}\n\n= \"M 30 0 L 0 20 30 40 Z M 40 0 10 20 40 40 Z N M 0 0 40 20 0 40 Z\"\n\nb) \\text{draw:enhanced-path}\n\n= \"M 30 0 L 0 20 30 40 Z N M 40 0 10 20 40 40 Z M 0 0 40 20 0 40 Z\"\n\n→ solution\n\n5.3 Reference for Filling\n\nLibreOffice always uses the bounding box of the shape as reference area for positioning and scaling the filling, regardless of whether the shape has even-odd filling or stacked areas or both. If the shape has structured filling like a gradient or bitmap, it becomes obvious.\nTake for example the triangle, which was created in chapter 3. Here it is filled with a gradient with 10 steps. The dashed rectangle indicates the bounding box of the shape.\n\n\n\nIf the rectangle has the same area filling as the triangle, you can see that the fill indeed uses the bounding rectangle as reference for scaling and position.\n\n\n\nThe shapes of this chapter look with the same gradient as this:\n\n\n\nThe `<draw:enhanced-geometry>` element has an attribute `draw:concentric-gradient-fill-allowed` in the ODF standard. That would allow filling to start at the shape path instead of the bounding box, resulting in rendering like what is known from OOXML, for example\n\n\n\nBut that attribute is not yet implemented in LibreOffice.\n\n### 5.4 Lighten and Darken\n\nIn Figure 46 you saw you can get more of less light sub-paths, if the filling has transparency. However, transparency is not part of the shape geometry but a property of the graphic style.\n\n---\n\nTo improve compatibility with OOOXML standard, LibreOffice has introduced commands J and K to lighten (blend with White) and commands H and I to darken (blend with Black) the shape color. These commands do not belong to the ODF 1.3 standard and thus must be used in its own namespace – in this case drawooo. If using these commands, you must save in format “1.3 Extended”. To allow other applications to show at least the shape, you must add the ordinary draw:enhanced-path attribute. An example shows how to use it.\n\nExample:\n\nThe light part in the shape is a square, which covers the entire shape in the back. Then half circles are drawn, becoming darker and smaller from back to front. Note that the shape has no line at the edges. It is done with the S command at the square.\n\nThe solution uses svg:viewBox=\"0 0 80 80\". Half circles with same color belong to the same sub-paths set.\n\n```\nM 0,0 L 80,0 80,80 0,80 Z S N\nM 0,0 x 40,40 0,80 M 80,0 x 40,40 80,80 N\nM 0,0 x 30,30 0,60 M 80,20 x 50,50 80,80 N\nM 0,0 x 20,20 0,40 M 80,40 x 60,60 80,80 N\nM 0,0 x 10,10 0,20 M 80,60 x 70,70 80,80 N\"\n```\n\nAttribute in normal namespace draw. Its value has no extended commands.\n\nBackground rectangle. Command S disables lines (technical term ‘stroke’) for the rectangle.\n\ncircle radius 40\nhalf circles on left and right side\ncircle radius 30\ncircle radius 20\ncircle radius 10\n\n```\nM 0,0 L 80,0 80,80 0,80 Z S N\nM 0,0 x 40,40 0,80 M 80,0 x 40,40 80,80 K N\nM 0,0 x 30,30 0,60 M 80,20 x 50,50 80,80 N\nM 0,0 x 20,20 0,40 M 80,40 x 60,60 80,80 I N\nM 0,0 x 10,10 0,20 M 80,60 x 70,70 80,80 H N\"\n```\n\nAttribute is in proprietary namespace drawooo, only used by LibreOffice.\n\ncommand J: lighten\ncommand K: lightenless\nhalf circles in original color\ncommand I: darkenless\ncommand H: darken\n\nWithout the extension, that is, as other applications would render it, the shape looks as in Figure 52.\n\n---\n\n47\n5.5 Exercise Solutions\n\n5.5.1 Exercise 5.1\n\nThe symbol contains only the black parts. The lower small circle belongs to the same sub-paths set with the same fill. It becomes transparent because of even-odd fill rule. These parts are drawn without lines. Note the command S in the markup.\n\nAdd a circle with perimeter line but no fill to separate the symbol from the background. Note the command F in the markup. Since the black parts are drawn without lines, you can use another color for the perimeter instead of black, light gray for example.\n\nValue for the draw:enhanced-path attribute:\n\"M 50,0 X 100,50 50,100\n25,75 50,50 75,25 50,0\nM 50,67 X 58,75 50,83 42,75 50,67\nM 50,17 X 58,25 50,33 42,25 50,17 S N\nM 50,0 X 100,50 50,100 0,50 50,0 F N\"\n\nright large half circle\ninner half circles left and right\nsmall circle in Yin part\nsmall circle in Yang part\nadditional circle for boundary\n\n5.5.2 Exercise 5.2\n\na) Figure 54: First set with even-odd filling\n\nb) Figure 55: Last set with even-odd filling\n6 Bézier Curves\n\n6.1 General\n\nThis chapter introduces you to commands Q and C which produce a quadratic Bézier curve and cubic Bézier curve, respectively. In literature often all points of a Bézier curve are named ‘control point’. However, we keep the wording of the Draw Guide\\textsuperscript{18} to use the term ‘control point’ only for those points which are used to determine the shape of the curve.\n\n6.2 Quadratic Bézier Curve\n\nAgain, partly cited from ODF standard\\textsuperscript{14}\n\nTable 7: Description of Command Q\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Name</th>\n<th>Parameters</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Q</td>\n<td>quadratic-</td>\n<td>(x1 y1 x y)+</td>\n<td>Draws a quadratic Bézier curve from the current point to (x,y) using (x1,y1) as the control point. (x,y) becomes the new current point at the end of the command.</td>\n</tr>\n</tbody>\n</table>\n\nThe ‘+’ in the parameters syntax description (x1 y1 x y)+ means, that a sequence of several Q commands is possible.\n\nA quadratic Bézier curve is always a parabola segment. Start- and end point of the curve belong to the parabola. The control point is the intersection of the tangents through start- and end point.\n\nSo the simple markup \\texttt{draw:enhanced-path=\"M 0,0 Q 20,80 40,0\"} already creates a parabola. It can be transformed to any needed focal parameter value by changing width or height of the custom shape. For more custom shapes for parabolas see the two documents mentioned in Material for schools\\#Parabolas\\textsuperscript{19}\n\nExercise 6.1\n\nThe purpose of this exercise is to brush up your knowledge about handles and equations, see chapter 3. Therefore, the needed mathematics to calculate the control point is given.\n\nCreate a custom shape with parabola segment so that (in local coordinate system of the shape) the left most point is (0|0) and the right most point is (40|40). Which part of the parabola is shown is determined by an xy-handle. With the handle in position \\(H\\left(x_H|y_H\\right)\\) the value for a parameter \\(b\\) is then\n\n\\[\nb = \\frac{x_H^2 - 40 y_H}{x_H^2 - 40 x_H}\n\\]\n\n\\textsuperscript{18} https://books.libreoffice.org/en/DG71/DG7111-AdvancedDrawTechniques.html#toc94\n\n\\textsuperscript{19} https://wiki.documentfoundation.org/Documentation/Material_for_schools#Parabolas\nAnd with this parameter $b$ the control point $Z$ of the quadratic Bézier curve has the coordinates $Z(20|20 b)$. Because of potential division by zero in the calculation of $b$, the range for $x_H$ shall be restricted to the range $x_H \\in [0.001; 39.999]$.\n\n--- solution\n\n### 6.3 Cubic Bézier curve\n\nYou already know cubic Bézier curves from the tools ‘Curve’ and ‘Curve, filled’ in the toolbar ‘Curves and Polygons’ and you have used the ‘Edit Points’ toolbar to edit them. The cubic Bézier curve as part of the `draw:enhanced-path` is a little bit restricted as it has no command for ‘Symmetric Transition’.\n\nAgain, partly cited from ODF standard\\(^{14}\\)\n\n#### Table 8: Description of command C\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Name</th>\n<th>Parameters</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>C</td>\n<td>curveto</td>\n<td>(x1 y1 x2 y2 x y) +</td>\n<td>Draws a cubic Bézier curve from the current point to (x,y) using (x1,y1) as the control point at the beginning of the curve and (x2,y2) as the control point at the end of the curve.</td>\n</tr>\n</tbody>\n</table>\n\nThe notation in the tutorial follows the book “A Primer on Bézier Curves”\\(^{20}\\), which is a good start into learning more about Bézier curves.\n\nA cubic Bézier curve is determined by a parametric function\n\n$$B(t) = \\begin{bmatrix} B_x(t) \\\\ B_y(t) \\end{bmatrix} = (1-t)^3P_0 + 3(1-t)^2t\\cdot P_1 + 3(1-t)t^2P_2 + t^3P_3, \\quad t \\in [0;1]$$\n\nwith start anchor point $P_0$, control point $P_1$ (related to start point), control point $P_2$ (related to end point) and end anchor point $P_3$\\(^ {21}\\).\n\nIf you have got points $P_0(x_0|y_0)$, $P_1(x_1|y_1)$, $P_2(x_2|y_2)$, $P_3(x_3|y_3)$ then the markup is\n\ndraw:enhanced-path=\"M x_0,y_0 C x_1,y_1 x_2,y_2 x_3,y_3\"\n\nHere again a sequence of commands is possible and in such sequence the character C is only needed at the beginning.\n\nSo if you have got points $P_0(x_0|y_0)$, $P_1(x_1|y_1)$, $P_2(x_2|y_2)$, $P_3(x_3|y_3)$ for a Bézier curve and $P_4(x_4|y_4)$, $P_5(x_4|y_4)$, $P_6(x_6|y_6)$, $P_7(x_7|y_7)$ for a second Bézier curve continuing the first one, then the markup is\n\ndraw:enhanced-path=\"M x_0,y_0 C x_1,y_1 x_2,y_2 x_3,y_3 x_4,y_4 x_5,y_5 x_6,y_6\"\n\nFigure 56: Points of a Bézier curve\n\n\\(^{20}\\) [https://pomax.github.io/bezierinfo/](https://pomax.github.io/bezierinfo/) [called 2021-09-13]\n\n\\(^{21}\\) Most articles name all four points ‘control’ points, but I follow the naming of the LibreOffice ‘Draw Guide’ which emphasizes the type of the points.\n6 Bézier Curves\n\nThat results in long sequences of point coordinates, and you need to be very careful to list them correctly.\n\n6.3 Cubic Bézier curve\n\nAs first example we make a shape for an ‘Easter egg’. The screenshot Figure 57 shows the shape in ‘Edit points’ mode. It was created as path object using the tool “Curve, filled”.\n\nIf your custom shape is static, that is, it has no handles, then you can write the values directly into the draw:enhanced-path attribute.\n\nHow do you calculate the values?\n\nA first idea would be to create the desired object as path object in the UI and then use its points from the source file. But that does not work. A path object uses the attribute svg:d. That follows in its syntax the attribute d of the path element of SVG²². Unfortunately LibreOffice writes the control points as relative values and the language for the draw:enhanced-path attribute has no commands for relative values.\n\nHence you need to define the points manually. For the “Easter egg” I have measured the distances in the UI.\n\n<table>\n<thead>\n<tr>\n<th>A</th>\n<th>B</th>\n<th>C</th>\n<th>D</th>\n<th>E</th>\n<th>F</th>\n<th>G</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td></td>\n<td>This spreadsheet belongs to section “Cubic Bézier Curve”</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>3</td>\n<td>All values are designed for below viewBox</td>\n<td>0</td>\n<td>2000</td>\n<td>3000</td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>4</td>\n<td>svg:viewBox="0 0 2000 3000"</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>5</td>\n<td>Parameters of Easter egg</td>\n<td>comment</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>7</td>\n<td>1000</td>\n<td>0</td>\n<td>anchor point A, top of egg</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>8</td>\n<td>790</td>\n<td>3000</td>\n<td>horizontal distance of top control points from anchor point A</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>9</td>\n<td>1000</td>\n<td>3000</td>\n<td>anchor point B, bottom of egg</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>10</td>\n<td>1820</td>\n<td>3000</td>\n<td>horizontal distance of bottom control points from anchor point B</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>11</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>12</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>13</td>\n<td>draw:enhanced-path="</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>14</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>15</td>\n<td>1000</td>\n<td>0</td>\n<td>P0 of 1. Bézier curve = point A</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>16</td>\n<td>210</td>\n<td>0</td>\n<td>P1 of 1. Bézier curve</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>17</td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>18</td>\n<td>-820</td>\n<td>3000</td>\n<td>P2 of 1. Bézier curve</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>19</td>\n<td>1000</td>\n<td>3000</td>\n<td>P3 of 1. Bézier curve = P0 of 2. Bézier curve</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>20</td>\n<td>2820</td>\n<td>3000</td>\n<td>P1 of 2. Bézier curve</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>21</td>\n<td>1790</td>\n<td>0</td>\n<td>P2 of 2. Bézier curve</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n<tr>\n<td>22</td>\n<td>1000</td>\n<td>0</td>\n<td>P3 of 2. Bézier curve = point A, explicit close not needed for filling</td>\n<td></td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nFigure 58: Spreadsheet to calculate coordinates for the enhanced-path and document it\n\nI suggest using a spreadsheet as documentation of your work. The screenshot Figure 58 shows such spreadsheet. If you organize the spreadsheet in a smart way, you can copy and paste the values into\n\nBézier Curves\n\n6.3.1 Example ‘Easter egg’\n\nthe editor you use to create the custom shape. The marked area was copied directly to Notepad++ to create the custom shape below, for example.\n\n![Easter Egg Shape]\n\nFigure 59: Finished Easter egg as custom shape\n\nThe markup in the custom shape is then\n<draw:enhanced-geometry\n svg:viewBox=\"0 0 2000 3000\" draw:type=\"non-primitive\"\n draw:enhanced-path=\"M 1000 0 C 210 0 -820 3000 1000 3000 2820 3000 1790 0 1000 0\"/>\n\n6.3.2 Sine Curve as Custom Shape\n\nSine curves can be very well approximated by cubic Bézier curves. This section describes how to do it.\n\nIf you approximate a function graph on interval \\([a_0; a_3]\\) these three relationships are important:\n\n1. The anchor points of the Bézier curve coincide with the points of the function graph at the edge of the interval.\n\n2. The straight line through control point and anchor point is a tangent to the function graph.\n\n3. In the sequence of Bézier curves, one curve segment will connect to the next. The transition should be smooth. Therefore, the Bézier curves here are so created, that not only the tangent but also its curvature in \\(P_0\\) and \\(P_3\\) is the same as for the function. In other contexts, instead of curvature other requirements might be useful, average or maximal deviation, for example.\n\nIt is helpful to use a computer algebra system for the calculation. Section 11.1 contains more about the mathematics.\n\nCurve A: For to get the red curve in Figure 60 the points are\n\\[ P_0(0|0), P_1\\left(\\frac{3π}{2} - \\frac{3π^2}{8} - \\frac{1}{2}, \\frac{3π}{2} - \\frac{3π^2}{8} - \\frac{1}{2}\\right), P_2(1|1) \\text{ and } P_3\\left(\\frac{π}{2}|1\\right). \\]\n\nThe maximal deviation of Bézier curve to sine curve is less than 0.0006.\n\n![Sine Curve on Interval 0;π/2]\n\nFigure 60: Sine curve on interval \\([0; π/2]\\)\n\nCurve B: For to get the red curve in Figure 61 the points are\n\\[ P_0\\left(-\\frac{π}{2}, -1\\right), P_1\\left(-\\frac{π}{2} + \\frac{2}{\\sqrt{3}}, 1\\right), P_2\\left(\\frac{π}{2} - \\frac{2}{\\sqrt{3}}, 1\\right) \\text{ and } P_3\\left(\\frac{π}{2}|1\\right). \\]\n\nThe maximal deviation of Bézier curve to sine curve is less than 0.0024.\n6 Bézier Curves\n\n6.3.2 Sine Curve as Custom Shape\n\nNow we discuss the steps needed to create the shape for curve A.\n\nThe custom shape uses a local coordinate system with y-axis pointing down and origin in the left top corner of the shape.\n\nYou need to transform the mathematical 'world' coordinates to coordinates in the local coordinate system. That is done with a homogeneous matrix $M$, so that \"point in shape local coordinates\" = $M \\cdot \\text{\"point in world coordinates\"}$\n\n$$\nM = \\begin{pmatrix}\n\\frac{\\text{viewBox width}}{\\text{world width}} & 0 & \\frac{\\text{viewBox width}}{\\text{world width}} & \\text{left} \\\\\n0 & -\\frac{\\text{viewBox height}}{\\text{world height}} & 0 & \\text{top} \\\\\n0 & 0 & \\frac{\\text{viewBox height}}{\\text{world height}} & \\text{viewBox height} \\\\\n0 & 0 & 1 & 1\n\\end{pmatrix}\n$$\n\nThe homogeneous matrix is used for to include translations into the matrix. If you apply the matrix to point coordinates you need to add value 1 as third point coordinate.\n\nCurve A uses the “world” rectangle with (left | top) = (0 | 1) and width × height = $\\pi/2 \\times 1$. The shape will use the viewBox value \"0 0 1500 1000\". The needed transformation matrix is then\n\n$$\nM = \\begin{pmatrix}\n3000 & 0 & 0 & 0 \\\\\n0 & -1000 & 1000 & 0 \\\\\n0 & 0 & 1 & 1\n\\end{pmatrix}\n$$\n\nNext you apply the matrix to the points coordinates and get the following results.\n\nFigure 61: Sine curve on interval $[-\\pi/2;\\pi/2]$\n\nFigure 62: Transformation of 'world' coordinates to shape local coordinates\n### Sine Curve as Custom Shape\n\n<table>\n<thead>\n<tr>\n<th>Point</th>\n<th>“world” coordinates $P_w$</th>\n<th>Coordinates in shape $P_s = M \\cdot P_w$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$P_0$</td>\n<td>$(0</td>\n<td>0)$</td>\n</tr>\n<tr>\n<td>$P_1$</td>\n<td>$(\\frac{3}{2} \\pi - \\frac{3}{8} \\pi^2 - \\frac{1}{2} \\frac{3}{2} \\pi - \\frac{3}{8} \\pi^2 - \\frac{1}{2})$</td>\n<td>$(\\frac{3000}{\\pi} \\left(\\frac{3}{2} \\pi - \\frac{3}{8} \\pi^2 - \\frac{1}{2}\\right) - 1000(\\frac{3}{2} \\pi - \\frac{3}{8} \\pi^2 - \\frac{1}{2})+1000)$</td>\n</tr>\n<tr>\n<td>$P_2$</td>\n<td>$(1</td>\n<td>1)$</td>\n</tr>\n<tr>\n<td>$P_3$</td>\n<td>$(\\frac{\\pi}{2}</td>\n<td>1)$</td>\n</tr>\n</tbody>\n</table>\n\nThese coordinates can result in the following markup. Other solutions are possible.\n\n```xml\n<draw:enhanced-geometry\n draw:enhanced-path=\"M 0 1500 C ?f ?f 0 0 0 0 0\" >\n <draw:equation draw:name=\"f0\" draw:formula=\"3000/pi\" />\n <draw:equation draw:name=\"f1\" draw:formula=\"3/2*pi-3/8*pi*pi-1/2\" />\n <draw:equation draw:name=\"f2\" draw:formula=\"?f0*?f1\" />\n <draw:equation draw:name=\"f3\" draw:formula=\"1000*(-?f1+1)\" />\n</draw:enhanced-geometry>\n```\n\nYou could also calculate the values outside in a spreadsheet and use them directly (copy&paste!) in the `draw:enhance-path` attribute. The syntax allows floating point values with decimal dot. In that case let the spreadsheet also calculate the transformations.\n\n#### Exercise 6.2\n\nCreate a shape as in Figure 63. For that you put a Bézier curve with the points given in the text to Figure 61 and a mirrored and shifted version of it together in one `draw:enhance-path`. Extending the curve that way makes it possible for the user to create a long sine curve by using the tool ‘Edit > Duplicate’.\n\nUse \"0 0 6000 2000\" as viewBox value and use formulas.\n\n→ solution\n\n### Exercise Solutions\n\n#### 6.4.1 Exercise 6.1\n\n```xml\n<draw:enhanced-geometry\ndraw:enhanced-path=\"M 0 1500 C ?f1 ?f0 0 0 0 0 0\" >\n <draw:equation draw:name=\"f0\" draw:formula=\"3000/pi\" />\n <draw:equation draw:name=\"f1\" draw:formula=\"3/2*pi-3/8*pi*pi-1/2\" />\n</draw:enhanced-geometry>\n```\n\nDo not forget to change it, if you start with a predefined shape\n\nOther values are possible, but using the shape is easier if the shown lines end at the shape snap rectangle.\nWithout a `draw:modifiers` attribute a handle would not be movable. The default values are arbitrary, but should be valid in regard to the range given in the `draw:handle` element.\n\nThe y-coordinate of the control point depends on the way you have built the expressions. In case you have only one expression used, it would be \"M 0 0 Q 20 ?f0 40 40\"\n\nYou could have written the complete formula into one equation. ODF allows such long expressions.\n\nThis handle should be freely movable. Therefore, both coordinates need a reference to a modifier.\n\nDirect translation of the given range.\n\nThe element has child elements and therefore needs a structure with start and end tag.\n\n### 6.4.2 Exercise 6.2\n\nThe sinus curve segment has the “world” rectangle with \\((\\text{left} | \\text{top}) = (-\\pi/2 | 1)\\) and \\(\\text{width} \\times \\text{height} = 2\\pi \\times 2\\). Together with the given viewBox value \"0 0 6000 2000\" you get the transformation matrix\n\n\\[\nM = \\begin{pmatrix}\n3000 & 0 & 1500 \\\\\n0 & -1000 & 1000 \\\\\n0 & 0 & 1\n\\end{pmatrix}\n\\]\nThe point coordinates are given in following table:\n\n<table>\n<thead>\n<tr>\n<th>Point</th>\n<th>“world” coordinates $P_w$</th>\n<th>coordinates in shape $P_s = M \\cdot P_w$</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>$P_0$</td>\n<td>$(-\\pi/2, -1)$</td>\n<td>$(0, 2000)$</td>\n</tr>\n<tr>\n<td>$P_1$</td>\n<td>$\\left(-\\frac{\\pi}{2} + \\frac{2}{\\sqrt{3}}, -1\\right)$</td>\n<td>$\\left(\\frac{3000}{\\pi} \\cdot \\frac{2}{\\sqrt{3}}, 2000\\right)$</td>\n</tr>\n<tr>\n<td>$P_2$</td>\n<td>$\\left(\\frac{\\pi}{2} - \\frac{2}{\\sqrt{3}}, 1\\right)$</td>\n<td>$\\left(3000 - \\frac{3000}{\\pi} \\cdot \\frac{2}{\\sqrt{3}}, 0\\right)$</td>\n</tr>\n<tr>\n<td>$P_3 = Q_0$</td>\n<td>$(\\pi/2, 1)$</td>\n<td>$(3000, 0)$</td>\n</tr>\n<tr>\n<td>$Q_1$</td>\n<td>$\\left(\\frac{\\pi}{2} + \\frac{2}{\\sqrt{3}}, 1\\right)$</td>\n<td>$\\left(3000 + \\frac{3000}{\\pi} \\cdot \\frac{2}{\\sqrt{3}}, 0\\right)$</td>\n</tr>\n<tr>\n<td>$Q_2$</td>\n<td>$\\left(\\frac{3\\pi}{2} - \\frac{2}{\\sqrt{3}}, -1\\right)$</td>\n<td>$\\left(6000 - \\frac{3000}{\\pi} \\cdot \\frac{2}{\\sqrt{3}}, 2000\\right)$</td>\n</tr>\n<tr>\n<td>$Q_3$</td>\n<td>$(3\\pi/2, -1)$</td>\n<td>$(6000, 2000)$</td>\n</tr>\n</tbody>\n</table>\n\nThe expression $\\frac{3000}{\\pi} \\cdot \\frac{2}{\\sqrt{3}}$ (or simplified $\\frac{2000 \\cdot \\sqrt{3}}{\\pi}$) appears several times in the coordinates. So you should put it into a formula for its own.\n\n<draw:enhanced-geometry\n svg:viewBox=\"0 0 6000 2000\"\n draw:type=\"non-primitive\"\n draw:enhanced-path=\"M 0 2000 C ?f0 0 2000 ?f1 0 3000 0\n ?f2 0 ?f3 2000 6000 2000\" >\n <draw:equation draw:name=\"f0\" draw:formula=\"3000/pi*2/sqrt(3)\" />\n <draw:equation draw:name=\"f1\" draw:formula=\"3000-?f0\" />\n <draw:equation draw:name=\"f2\" draw:formula=\"3000+?f0\" />\n <draw:equation draw:name=\"f3\" draw:formula=\"6000-?f0\" />\n</draw:enhanced-geometry>\n\nFigure 64: Exercise solution long sine curve by duplicating the shape\n7 Shapes with Fixed Distances\n\n7.1 Fixed Height for Sub-path\n\nThe first example is inspired by a question on Ask:\n\nTwo rectangles are combined in a group. One rectangle holds a heading, the other takes the text body. Requirement: The heading does not change its height, when the group size is changed.\n\nThe property “Protect Size” does only disable size related settings in the user interface of the shape itself, but it does not protect a shape from being resized, when the containing group is resized.\n\nFirst approach: We cannot have fixed total height, but we can try to draw a rectangle inside the shape, which has a fixed height and the rest of the shape is transparent.\n\nWe assume shape H is currently 4 cm high and the rectangle for the heading has a fixed height of 1 cm. We assume further, that shape H has the viewBox value \"0 0 2500 6000\". (The actual\n\nFigure 65: Desired and actual result for making a group higher\n\nFigure 66: First idea: rectangle with fixed height inside a larger shape\n\nThe commands and formulas discussed so far all refer to the viewBox and the values of the viewBox do not change when the shape is resized. Something else is needed, that refers to the actual size of the shape. Such is given in the identifiers logwidth and logheight.\n\nQuoted from “Table 11 - Enhanced geometry equation identifiers” in the ODF 1.3 standard:\n\nTable 9: Description of identifiers logheight and logwidth\n\n| logheight | The height in 1/100th mm as specified by the svg:height attribute is used. |\n| logwidth | The width in 1/100th mm as specified by the svg:width attribute is used. |\n\nWe assume shape H is currently 4 cm high and the rectangle for the heading has a fixed height of 1 cm. We assume further, that shape H has the viewBox value \"0 0 2500 6000\". (The actual\n\n23 https://ask.libreoffice.org/t/protect-size-of-individual-items-in-a-group/67682/4 [called 2021-09-17]\nvalues of attribute viewBox are not essential to the problem, but concrete values make the solutions more understandable.) The desired height of 1 cm is 1/4 of the total height of the shape. So in local coordinate system we need to use 1/4 of the viewBox height, that is 1500. If the shape is then dragged to a height of 8 cm, the desired 1 cm is 1/8 of the total height of the shape. So, in local coordinate system we need to use 1/8 of the viewBox height, that is 750.\n\nIn general we get\n\n\\[\n\\text{needed value in local coordinate system} = \\frac{\\text{desired fixed height in world coordinates}}{\\text{shape height in world coordinates}} \\cdot \\text{viewBox height}\n\\]\n\nThis is where the identifier \\( \\text{logheight} \\) comes into play. We switch to values in 1/100th mm and get\n\n\\[\n\\text{needed value in local coordinate system} = \\frac{\\text{desired fixed height in 1/100th mm}}{\\text{logheight (which is in 1/100th mm)}} \\cdot \\text{viewBox height}\n\\]\n\nYou can read the rule also as: Scale the desired height with the ratio of viewBox height to logheight.\n\n\\[\n\\text{needed value in local coordinate system} = \\frac{\\text{desired fixed height in 1/100th mm}}{\\text{logheight (which is in 1/100th mm)}} \\cdot \\frac{\\text{viewBox height}}{\\text{logheight (which is in 1/100th mm)}}\n\\]\n\nThe shape H could have this markup:\n\n```xml\n<draw:enhanced-geometry\n svg:viewBox=\"0 0 2500 6000\"\n draw:text-areas=\"0 0 2500 ?f0\"\n draw:type=\"non-primitive\"\n draw:enhanced-path=\"M 0 0 L 0 ?f0 2500 ?f0 2500 0 Z\">\n <draw:equation draw:name=\"f0\" draw:formula=\"1000/logheight * height\"/>\n</draw:enhanced-geometry>\n```\n\nNote that the text area has the same rectangle as given by the path. Only the attribute text-area has parameters “left, top, right, bottom”, whereas attribute viewBox has the parameters “left, top, width, height”. You need to use the same rectangle to place the text really into the fixed rectangle.\n\nIf you look at the drag handles, you see that the actual shape height is larger as the colored rectangle for the heading.\n\n\n\nNow combine shape H in 2.5 width with a shape B for the body text into a group. Use for shape B a rectangle with 2.5 cm width and 3 cm height so that both shapes together result in 2.5 cm width and 4 cm height.\n\nTry out what happens, if you change the height of the group to 6cm, for example.\n\nShape H for the heading behaves as expected and keeps 1 cm height of its colored rectangle. But shape B for the body text behaves the same as before, so that there is now a gap between the shapes.\nWe need to design shape B so the area above the text rectangle is always 1 cm high. That is only possible, if this area belongs to the shape.\n\nConclusion: Shape B needs a similar solution as shape H. It needs the same total height as shape H. However, now the upper part with the fixed height is transparent, and the colored rectangle and the text area are placed in the lower part.\n\n**Exercise 7.1**\n\nCreate the markup for such shape B.\n\n→ solution\n\nIn general, to calculate a value \\( Local \\) in the local coordinate system from a value \\( World \\) in the world coordinate system use the formula \\( Local = \\frac{World\\cdot width}{logwidth} \\) for horizontal direction or \\( Local = \\frac{World\\cdot height}{logheight} \\) for vertical direction.\n\nLibreOffice uses internally the unit “Twip” in Writer and “1/100th mm” in all other modules. 1 Twip = 127/7200 mm. Currently [as of 2021-09-18] LibreOffice has the bug\\(^25\\), that the identifiers \\( logheight \\) and \\( logwidth \\) give the value in regard to Twip in Writer.\n\nIf your formula has a constant number as length which is used in comparison to identifier \\( logwidth \\) or \\( logheight \\), you need to use the length in Twip too. In such case you need a special version of your shape for use in Writer, and you cannot exchange such shapes between Writer and the other modules. That means, to get a rectangle with 1 cm height in Writer in the above example, you have to use 72000/127 for the desired fixed height in the formula instead of 1000.\n\n### 7.2 Ratio of Shape Width to Height\n\nIn this section we will create a shape like the shape “Card” of the category “Flowchart”, but with a handle to determine the size of the cut corner.\n\nAs a quick shot we get the following markup\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 600 600\"\n draw:type=\"non-primitive\" draw:modifiers=\"150\"\n draw:enhanced-path=\"M $0 0 L 0 0 600 600 600 600 0 Z\">\n```\n\n\\(^{25}\\) The fact, that identifiers \\( logwidth \\) and \\( logheight \\) are not conform to ODF 1.3 in Writer is tracked as bug in [https://bugs.documentfoundation.org/show_bug.cgi?id=144591](https://bugs.documentfoundation.org/show_bug.cgi?id=144591)\nHowever, when you change the width or height of the shape the cut has no longer 45° (yellow). But we want a solution where the cut has always 45° regardless shape width or height (green).\n\nLet us have a second view on identifiers \\( \\text{logwidth} \\) and \\( \\text{logheight} \\).\n\nMapping between world and local coordinate systems, can be illustrated with a grid on the shape.\n\nIf the width or height is changed, the units on x-axis and y-axis become different. To get the same angle, one of x- or y-coordinate has to be adapted.\n\nIf the shape is now half of the height of the square size, then \\( \\text{logwidth/}\\text{logheight}=2 \\) and the y-coordinate must be doubled. If the shape has a height three times the height of the square size, then \\( \\text{logwidth/}\\text{logheight}=1/3 \\) and you need 1/3 of the y-coordinate. Only the ratio of shape width and height is relevant.\nThe scaling factor for the y-coordinate is \\( \\frac{\\log width}{\\log height} \\).\n\nAnd the solution is now:\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 600 600\"\n draw:type=\"non-primitive\" draw:modifiers=\"150\"\n draw:enhanced-path=\"M 0 0 L 0 ?f0 0 600 600 600 600 0 Z\">\n <draw:equation draw:name=\"f0\" draw:formula=\"0*\\log width/\\log height\"/>\n <draw:handle draw:handle-position=\"0 top\"\n draw:handle-range-x-minimum=\"0\"\n draw:handle-range-x-maximum=\"600\"/>\n</draw:enhanced-geometry>\n```\n\nThis solution uses implicitly the fact, that the viewBox is a square, that is, \\( \\text{width}=\\text{height} \\). If that is not the case, you need to consider ratio in the viewBox size as well. For example\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 600 300\"\n draw:type=\"non-primitive\" draw:modifiers=\"150\"\n draw:enhanced-path=\"M 0 0 L 0 ?f0 0 300 300 300 600 600 0 Z\">\n <draw:equation draw:name=\"f0\"\n draw:formula=\"0*height/width*\\log width/\\log height\"/>\n <draw:handle draw:handle-position=\"0 top\"\n draw:handle-range-x-minimum=\"0\"\n draw:handle-range-x-maximum=\"600\"/>\n</draw:enhanced-geometry>\n```\n\n**Exercise 7.2**\n\nIf you drag the handle in the shape having \\( \\frac{\\log width}{\\log height}=2 \\), then you will get for example\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 600 600\"\n draw:type=\"non-primitive\" draw:modifiers=\"150\"\n draw:enhanced-path=\"M 0 0 L 0 2 0 600 600 600 0 Z\">\n <draw:equation draw:name=\"f0\"\n draw:formula=\"0*height/width*\\log width/\\log height\"/>\n <draw:handle draw:handle-position=\"0 top\"\n draw:handle-range-x-minimum=\"0\"\n draw:handle-range-x-maximum=\"600\"/>\n</draw:enhanced-geometry>\n```\n\n**Figure 73: Needed adaption for changed width or height**\n\n**Figure 74: Need for restricting the range for handle movement**\n\nObviously, we need to restrict the range for handle movement to get “nice” results.\n\nSet the value of attribute `draw:handle-range-x-maximum` so, that the cut it not lower then half of the height and not more right than half of the width of the shape. Use the viewBox value \"0 0 600 600\".\nYou can use a formula reference instead of a constant value or identifier in the value of attribute draw:handle-range-x-maximum.\n\nTest your solution with very wide and with very tall shapes.\n\n\\[ \\text{solution} \\]\n\nRemark: The OOXML standard has a similar shape “snap1Rect”.\n\n### 7.3 Equilateral Triangle\n\nWe want a shape with these properties:\n\n- The shape shows an equilateral triangle.\n- The width of the triangle is equal to the width of the shape.\n- The base of the triangle aligns with the bottom edge of the shape.\n- The height of the triangle is computed so the triangle is equilateral, regardless of the height of the shape.\n\nFigure 76 shows the triangle-shape in a world coordinate system with y-axis pointing down. Left, top corner of the shape is aligned with the origin. The local coordinate system looks similar, only it has height instead of logheight and width instead of logwidth.\n\nThe mathematical formula for the length \\( h \\) is \\( h = g \\cdot \\frac{1}{2} \\sqrt{3} = g \\cdot \\frac{\\sqrt{3}}{4} \\).\n\n\\[ h = g \\cdot \\sin \\left( \\frac{1}{3} \\pi \\right) \\]\n\n\\( h = g \\cdot \\sin \\left( \\frac{1}{3} \\pi \\right) \\) can be used as well.\n\nA solution is possible with the ideas from section 7.1 as well as with those from section 7.2.\n\nThe following solution uses ideas from section 7.1. However now the length, which should be independent from the shape height, is not given anymore by a constant number in the world coordinate system but is calculated from the shape width, and the fixed length is measured from the bottom edge of the shape.\n\nWe can use these equations\n\n\\[ f_0 = \\text{logwidth} \\times \\sqrt{0.75} \\quad \\text{Length } h \\text{ in world coordinate system} \\]\n\n\\[ f_1 = f_0 \\times \\text{height} / \\text{logheight} \\quad \\text{Value that represents length } h \\text{ in local coordinate system.} \\]\n7 Shapes with Fixed Distances\n\n7.3 Equilateral Triangle\n\nf₂=height−f₁\n\nThe y-coordinate of tip of the triangle in the local coordinate system.\n\nAnd this solution uses ideas from section 7.2. It calculates first a distance in local coordinate system and then corrects it for cases with ratio ≠ 1.\n\nf₀=width*sqrt(0.75)\n\nDistance of triangle tip to triangle base in local coordinate system, if viewBox would be square\n\nf₁=?f₀*height/width\n\nCorrection for the case viewBox is not square\n\nf₂=?f₁*logwidth/logheight\n\nCorrection for the case the shape is not square\n\nf₃=height−f₂\n\nThe y-coordinate of tip of the triangle in the local coordinate system.\n\nPut for both solutions the expressions into a single formula and simplify it, then you see that the result is the same.\n\nWith svg:viewBox=\"0 0 6000 4000\" for example, the path would be in first solution\n\ndraw:enhanced-path=\"M 0 4000 L 3000 ?f₂ 6000 4000\"\n\nand in second solution\n\ndraw:enhanced-path=\"M 0 4000 L 3000 ?f₃ 6000 4000\"\n\nExercise 7.3\n\nCreate two shapes with these properties:\n\nOne shape shows a square, the other a cross as diagonals of the square.\n\nThe base length of the square is the minimum of width and height of the shape. So the square is never larger than the snap rectangle of the shape.\n\nThe square is centered in the shape, that is the place besides the square is the same on opposite sides.\n\n→ solution\n\n7.4 Height Independent Length with Modifier\n\nWe pick the example “right triangle by Thales’ circle with xy-handle” from section “3.5 Functions”.\n\nFigure 77: Square centered in snap rectangle of the shape\n\nFigure 78: Thales' half circle\nThe solution there has been\n\n```\n<draw:enhanced-geometry svg:viewBox=\"0 0 100 50\" draw:type=\"non-primitive\"\n draw:modifiers=\"70\"\n draw:enhanced-path=\"M 0 50 L $0 ?f2 100 50 Z N\">\n <draw:equation draw:name=\"f0\" draw:formula=\"$0-50\"/>\n <draw:equation draw:name=\"f1\" draw:formula=\"sqrt(50*50-?f0*?f0)\"/>\n <draw:equation draw:name=\"f2\" draw:formula=\"50-?f1\"/>\n <draw:handle draw:handle-position=\"$0 ?f2\"\n draw:handle-range-x-minimum=\"left\"\n draw:handle-range-x-maximum=\"right\"/>\n</draw:enhanced-geometry>\n```\n\nBut that creates only a right triangle if the shape is twice as wide as high. To get a right triangle in all cases, the height of the triangle needs to be independent from the shape height.\n\nIn addition, as the triangle no longer stretches to the height of the shape, we need to decide where to position the triangle. Here the triangle is aligned with the bottom edge of the shape.\n\nWe try a solution with ideas from section 7.1. The difference is that here the height needs to be calculated not from a value in the world coordinate system but from a modifier value, which is as such a value in the local coordinate system. The solution is to first calculate backwards a length value in the world coordinate system, which is represented by the modifier.\n\nIn detail we make these steps\n\n1. Calculate the value $m$ in the world coordinate system, which is represented by the modifier value $S0$.\n\n You know from section 7.1, how to calculate a value $Local$ in the local coordinate system from a value $World$ in the world coordinate system. Use the formula $Local = \\frac{World \\cdot \\text{width}}{\\text{logwidth}}$ for horizontal direction or $Local = \\frac{World \\cdot \\text{height}}{\\text{logheight}}$ for vertical direction.\n\n Now we know value $Local$ and look for value $World$. We rearrange the formula and get $World = \\frac{Local \\cdot \\text{logwidth}}{\\text{width}}$ or $World = \\frac{Local \\cdot \\text{logheight}}{\\text{height}}$ respectively.\n\n Because the modifier value $S0$ is related to horizontal handle movement we use $m = \\frac{S0 \\cdot \\text{logwidth}}{\\text{width}}$.\n\n2. Calculate the height $dy$ of the triangle in world coordinate system.\n\n $radius = \\frac{\\text{logwidth}}{2}$, $dx = m - radius$ and $dy = \\sqrt{radius^2 - dx^2}$\n3. Calculate the height $h$ in the local coordinate system that represents the value $dy$. This is a length in vertical direction\n\n$$h = \\frac{dy \\cdot \\text{height}}{\\logheight}$$\n\n4. Calculate the $y$-coordinate of the top of the triangle in the local coordinate system. The $x$-coordinate is given by the modifier.\n\n$$y\\text{-coordinate of top of the triangle} = \\text{height} - h$$\n\nThis solution transferred to an `<draw:enhanced-geometry>` element is then\n\n```xml\n<draw:enhanced-geometry\n svg:viewBox=\"0 0 100 50\"\n draw:type=\"non-primitive\"\n draw:modifiers=\"70\"\n draw:enhanced-path=\"M 0 50 L $0 ?f5 100 50 Z\">\n <draw:equation draw:name=\"f0\" draw:formula=\"$0*\\logwidth/\\text{width}\"/>\n <draw:equation draw:name=\"f1\" draw:formula=\"\\logwidth/2\"/>\n <draw:equation draw:name=\"f2\" draw:formula=\"?f0-?f1\"/>\n <draw:equation draw:name=\"f3\" draw:formula=\"\\sqrt{?f1*?f1-?f2*?f2}\"/>\n <draw:equation draw:name=\"f4\" draw:formula=\"?f3*\\text{height}/\\logheight\"/>\n <draw:equation draw:name=\"f5\" draw:formula=\"\\text{height}-?f4\"/>\n <draw:handle draw:handle-position=\"$0 ?f5\"\n draw:handle-range-x-minimum=\"left\"\n draw:handle-range-x-maximum=\"right\"/>\n</draw:enhanced-geometry>\n```\n\nIf you use other values than 100 and 50 for width and height in the attribute `svg:viewBox`, you need to adapt the values in `draw:enhanced-path` according to the meaning – not literal – \"M 0 bottom L $0 ?f5 right bottom Z\". Remember you cannot use `bottom` and `right` directly in a value of attribute `draw:enhanced-path`, because these identifiers are not allowed.\n\n### Exercise 7.4\n\nCreate a solution based on the ideas of section 7.2.\n\n→ solution\n\n### 7.5 Further Path Attributes\n\nThe ODF standard provides the attributes `draw:path-stretchpoint-x`\\(^{26}\\) and `draw:path-stretchpoint-y`\\(^{27}\\). It seems to me, that the implementation in LibreOffice does not follow the description in the ODF standard. Therefore, I do not discuss the attributes here.\n\n---\n\n\n7.6 Exercise Solutions\n\n7.6.1 Exercise 7.1\n\nFor shape B you need\n\n```\n<draw:enhanced-geometry\n svg:viewBox=\"0 0 2500 6000\"\n draw:text-areas=\"0 ?f0 2500 6000\"\n draw:type=\"non-primitive\"\n draw:enhanced-path=\"M 0 ?f0 L 0 6000 2500 6000 2500 ?f0 Z\">\n <draw:equation draw:name=\"f0\" draw:formula=\"1000/logheight * height\"/>\n</draw:enhanced-geometry>\n```\n\nNote the formula is not changed in comparison to the solution for shape H. Only path and text area are set to the area below point (0|?f0), whereas shape H has them above that point.\n\n7.6.2 Exercise 7.2\n\nThe solution in section 7.2 was\n\n```\n<draw:enhanced-geometry svg:viewBox=\"0 0 600 600\"\n draw:type=\"non-primitive\" draw:modifiers=\"150\"\n draw:enhanced-path=\"M $0 0 L 0 ?f0 0 600 600 600 600 0 Z\">\n <draw:equation draw:name=\"f0\" draw:formula=\"$0*logwidth/logheight\" />\n <draw:equation draw:name=\"f1\" draw:formula=\"height/2*logheight/logwidth\" />\n <draw:equation draw:name=\"f2\" draw:formula=\"min(width/2,?f1)\" />\n <draw:handle draw:handle-position=\"$0 top\"\n draw:handle-range-x-minimum=\"0\"\n draw:handle-range-x-maximum=\"600\"/>\n</draw:enhanced-geometry>\n```\n\nThe modifier value $0 marks the horizontal position of the cut and formula value ?f0 the vertical position.\n\nThe condition ?f0 < height/2 needs to be converted to use $0. Some formula rearrangements:\n\n\\[ ?f0 < \\text{height/2} \\Leftrightarrow ?f0 = $0*\\text{logwidth/logheight} \\]\n\\[ \\Leftrightarrow $0 < \\text{height/2*logheight/logwidth} \\]\n\nThe condition $0<width/2 can be used directly. To fulfill both conditions use the minimum of the values.\n\n```\n<draw:enhanced-geometry svg:viewBox=\"0 0 600 600\"\n draw:type=\"non-primitive\" draw:modifiers=\"150\"\n draw:enhanced-path=\"M $0 0 L 0 ?f0 0 600 600 600 600 0 Z\">\n <draw:equation draw:name=\"f0\" draw:formula=\"$0*logwidth/logheight\" />\n <draw:equation draw:name=\"f1\" draw:formula=\"height/2*logheight/logwidth\" />\n <draw:equation draw:name=\"f2\" draw:formula=\"min(width/2,?f1)\" />\n <draw:handle draw:handle-position=\"$0 top\"\n draw:handle-range-x-minimum=\"0\"\n draw:handle-range-x-maximum=\"?f2\"/>\n</draw:enhanced-geometry>\n```\nFigure 80 shows the square-shape in a world coordinate system with y-axis pointing down. Left, top corner of the shape is aligned with the origin. The local coordinate system is similar, only it has height instead of \\( \\log \\)height and width instead of \\( \\log \\)width.\n\nThe size of the shape (not of the square) in world coordinate system is \\( \\log \\)width \\( \\times \\) \\( \\log \\)height, the size of the shape in local coordinate system is width \\( \\times \\) height.\n\nThere is no unique solution. Two solutions as example:\n\n**Example A**\n\nThe length of the edge of the square as minimum of \\( \\log \\)width and \\( \\log \\)height can be calculated with\n\n\\[\nf_0 = \\min(\\log \\text{width}, \\log \\text{height})\n\\]\n\nDepending on whether \\( \\log \\text{width} > \\log \\text{height} \\) (\\( \\equiv \\log \\text{width} - \\log \\text{height} \\) is positive) or not, the formulas use the representation of the world square width or height. The way is the same as in the previous examples.\n\n\\[\nf_1 = \\text{if}(\\log \\text{width} - \\log \\text{height}, ?f_0/\\log \\text{width} \\times \\text{width}, \\text{width})\n\\]\n\n\\[\nf_2 = \\text{if}(\\log \\text{width} - \\log \\text{height}, \\text{width}, ?f_0/\\log \\text{height} \\times \\text{height})\n\\]\n\nTo center the square, we calculate the space outside the square and halve it. That gives the coordinates of left, top point \\( P \\) in local coordinate system. Depending on whether \\( \\log \\text{width} > \\log \\text{height} \\) or not, this shift has to be done either with width or height.\n\n\\[\nf_3 = \\text{if}(\\log \\text{width} - \\log \\text{height}, (\\text{width}-?f_1)/2,0)\n\\]\n\n\\[\nf_4 = \\text{if}(\\log \\text{width} - \\log \\text{height}, 0, (\\text{height}-?f_2)/2)\n\\]\n\nTo get coordinates of point \\( R \\) in local coordinate system we add width and height of the square to the coordinates of point \\( P \\).\n\n\\[\nf_5 = ?f_3+?f_1\n\\]\n\n\\[\nf_6 = ?f_4+?f_2\n\\]\n\nThe coordinates of points \\( Q \\) and \\( S \\) are taken from points \\( P \\) and \\( R \\) and need no formulas:\n\n\\( \\text{Qx} = \\text{Rx}, \\text{Qy} = \\text{Py}, \\text{Sx} = \\text{Px}, \\text{Sy} = \\text{Ry} \\)\n\n**Example B**\n\nHere some steps are combined, and case distinctions are omitted.\n\nIf \\( \\log \\text{width} > \\log \\text{height} \\), then \\( \\log \\text{height} \\) is the minimum and length of edges of the square. If \\( \\log \\text{width} \\leq \\log \\text{height} \\), then \\( \\log \\text{width} \\) is length of edges. We omit above formula \\( f_0 \\) and use these values directly.\n\n\\[\nf_0 = \\text{if}(\\log \\text{width} - \\log \\text{height}, \\log \\text{height}/\\log \\text{width} \\times \\text{width}, \\text{width})\n\\]\n\nwidths of the square in locale coordinate system\nf1=if(logwidth-logheight, height, logwidth/logheight*height)\n height of the square in locale coordinate system\n\nf2=(width-?f0)/2\n x-coordinate of point P. \n width-?0 gives 0 in case logwidth \\leq \\text{logheight}\n\nf3=(height-?f1)/2\n y-coordinate of point P\n height-?f1 gives 0 in case logwidth > \\text{logheight}\n\nf4=?f0+?f2\n x-coordinate of point R\n\nf5=?f1+?f3\n y-coordinate of point R\n\nFor example B, the path for the square is:\n\\text{draw:enhanced-path=}'M \\ ?f2 \\ ?f3 \\ L \\ ?f4 \\ ?f3 \\ ?f4 \\ ?f5 \\ ?f3 \\ ?f5''\n\nand for the cross:\n\\text{draw:enhanced-path=}'M \\ ?f2 \\ ?f3 \\ L \\ ?f4 \\ ?f5 \\ M \\ ?f4 \\ ?f3 \\ L \\ ?f3 \\ ?f5''\n\nNote both examples A and B work for any width and height value in attribute svg:viewBox.\n\n**7.6.4 Exercise 7.4**\n\nf0=width/2\n Radius of Thales’ circle in local coordinate system\n Hypotenuse for Pythagorean theorem\n\nf1=0-?f0\n Horizontal leg for Pythagorean theorem\n\nf2=sqrt(?f0*?f0-?f1*?f1)\n Vertical leg by Pythagorean theorem\n\nf3=?f2*height/width\n Correction for non-square viewBox\n\nf4=?f3*logwidth/logheight\n Correction for non-square shape\n\nf5=height-?f4\n Distance from top\n\n\\text{<draw:enhanced-geometry}\n \\text{svg:viewBox=}'0 0 100 50''\n \\text{draw:type=}'non-primitive''\n \\text{draw:modifiers=}'70''\n \\text{draw:enhanced-path=}'M 0 50 L 0 \\ ?f5 100 50 Z''}\n\\text{<draw:equation draw:name=}'f0'' draw:formula=}'width/2''/\n\\text{<draw:equation draw:name=}'f1'' draw:formula=}'0-?f0''/\n\\text{<draw:equation draw:name=}'f2'' draw:formula=}'sqrt(?f0*?f0-?f1*?f1)''/\n\\text{<draw:equation draw:name=}'f3'' draw:formula=}'?f2*height/width''/\n\\text{<draw:equation draw:name=}'f4'' draw:formula=}'?f3*logwidth/logheight''/\n\\text{<draw:equation draw:name=}'f5'' draw:formula=}'height-?f4''/\n\\text{<draw:handle draw:handle-position=}'$0 \\ ?f5''\n \\text{draw:handle-range-x-minimum=}'left''\n \\text{draw:handle-range-x-maximum=}'right''/\n\\text{</draw:enhanced-geometry>\n8 Arcs\n\n8.1 Defining an Arc by Bounding Box and Radial Rays\n\nTable 10: Description for Commands A, B, V and W.\n\n*From “Table 10 - Enhanced path commands” in the ODF standard.*\n\n<table>\n<thead>\n<tr>\n<th>Command Name</th>\n<th>Parameters</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>A arcto</td>\n<td>(x1 y1 x2 y2 x3 y3 x4 y4) +</td>\n<td>(x1, y1) and (x2, y2) define the bounding box of an ellipse. A line is then drawn from the current point to the start angle of the arc that is specified by the radial vector of point (x3, y3) and then counter-clockwise to the end-angle that is specified by point (x4, y4).</td>\n</tr>\n<tr>\n<td>B arc</td>\n<td>(x1 y1 x2 y2 x3 y3 x4 y4) +</td>\n<td>The same as the “A” command, except that an implied moveto to the starting point is done.</td>\n</tr>\n<tr>\n<td>V clockwisearc</td>\n<td>(x1 y1 x2 y2 x3 y3 x4 y4)+</td>\n<td>The same as the “A” command, except that an implied moveto to the starting point is done and the arc is drawn clockwise.</td>\n</tr>\n<tr>\n<td>W clockwisearcto</td>\n<td>(x1 y1 x2 y2 x3 y3 x4 y4) +</td>\n<td>The same as the “A” command except, that the arc is drawn clockwise.</td>\n</tr>\n</tbody>\n</table>\n\nThe following drawings only differ in the command used. In all cases the shape has size $w \\times h = 15 \\text{ cm} \\times 6 \\text{ cm}$ and attribute `svg:viewBox=\"0 0 1500 600\"`\n\nFigure 81: Command A\n\ndraw:enhanced-path=\"M 1260 100 A 200 100 1000 500 1120 387 513 195\"\n\n---\n\n8.1 Defining an Arc by Bounding Box and Radial Rays\n\nFigure 82: Command \\texttt{B}\n\n\\begin{verbatim}\ndraw:enhanced-path=\"B 200 100 1000 500 1120 387 513 195\"\n\\end{verbatim}\n\nThe command \\texttt{B} has an implied `moveto' at the beginning. Therefore, the command \\texttt{M 1260 100} was omitted here.\n\nFigure 83: Command \\texttt{V}\n\n\\begin{verbatim}\ndraw:enhanced-path=\"V 200 100 1000 500 1120 387 513 195\"\n\\end{verbatim}\n\nThe command \\texttt{V} has an implied `moveto' at the beginning. Therefore, the command \\texttt{M 1260 100} was omitted here.\n8.1 Defining an Arc by Bounding Box and Radial Rays\n\nThe arcs have a fill in the examples. Remember, to determine the area to fill, a straight line is drawn from start- to end-point of the sub-path.\n\nThe arcs have an arrowhead at the end-point to make the direction of the arcs visible.\n\nNote these arc definitions do not use angles.\n\nExercise 8.1\n\nCreate a circular arc on a square shape so that the underlying circle fills the entire shape. The start point of the arc should be fixed in the middle of the right edge of the shape and the end point should be variable by means of a handle. The arc should be drawn clockwise and should be never filled.\n\na) Determine the end-point of the arc by an xy-handle.\n\nb) Determine the end-point of the arc by a polar-handle.\n\n→ solution\n\nAs you noticed, there is no way to bind the xy-handle to the circle line. The visual feedback while dragging the handle is not very good. But in LibreOffice 7.3 you can only set the exact positions in the ‘Position and Size’ dialog for xy-handles, and not for polar handles. Therefore, such a shape is still useful.\n\nExercise 8.2\n\nCreate an arc similar to previous exercise. But now the circle sector which belongs to the arc shall be shown as filled area (if the user has enabled filling). Tip: There has been something similar in chapter ‘Fill and Stroke’.\n8.1 Defining an Arc by Bounding Box and Radial Rays\n\nExercise 8.3\nCreate a full circle on a square shape.\n\n8.2 Defining an Arc by Center, Radii, Start- and End-Angle\n\nTable 11: Description of Commands T and U.\n\nFrom ‘Table 10 - Enhanced path commands’ in the ODF standard.\n\n<table>\n<thead>\n<tr>\n<th>Command Name</th>\n<th>Parameters</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>T angle-ellipseto</td>\n<td>(x, y, wR, hR, t0, t1) +</td>\n<td>Draws a segment of an ellipse. The ellipse is specified by the center(x, y), the width 2<em>wR, the height 2</em>hR, and the start-angle t0 in degrees and end-angle t1 in degrees. The segment is drawn clockwise.</td>\n</tr>\n<tr>\n<td>U angleellipse</td>\n<td>(x, y, wR, hR, t0, t1) +</td>\n<td>The same as the “T” command, except that an implied moveto to the starting point is done.</td>\n</tr>\n</tbody>\n</table>\n\nThe angle is measured clockwise. The first leg is on the positive part of the x-axis. The determined point on the ellipse is the intersection of the second leg with the ellipse line.\n\nSo in fact, the angles are used modulo 360°. An angle of −45° is treated the same as an angle of 315°, for example. There is one exception: If t1 = t0 + 360°, a full ellipse is drawn.\n\nIf a user touches a handle, then a value in the range [−180°;180] is generated.\n\nNote that this angle orientation is different from the use of start- and end-angle in the shapes `<draw:circle>` and `<draw:ellipse>`, which are available in the ‘Legacy Circles and Ovals’ toolbar in the UI. For those shapes angles are measured counter-clockwise on screen and in markup.\n\nThe angles refer to the local coordinate system. If the shape has a different ratio for width to height than the viewBox of the enhanced-geometry, then the rendered angle will be different from the value in the associated modifier.\n\nExercise 8.4\n\nThe Fibonacci spiral can be approximated by quarter circles. An illustration\\(^{30}\\) for that is in Wikipedia, and more information on Fibonacci spiral can be found in Wikipedia under topic “Golden spiral”\\(^{31}\\).\n\nCreate a shape in width to height ratio of 34 to 21 and viewBox value “0 0 34 21”, that shows such approximation of the Fibonacci spiral similar to the above-mentioned illustration. Do this by using\n\na) command T \nb) command U \nc) command X or Y (see chapter ‘Quadrants’)\n\n→ solution\n\nNow we set a line style with arrowhead to the shapes generated in the exercise and compare them.\n\nCommand T or Y\n\nCommand U\n\n\n\n\n\nFigure 86: compare commands T or Y with command U in regard to arrowhead\n\nThe essential difference between commands T and U is, that a sequence of commands U generates a sequence of several sub-paths because of the implied ‘moveto’ of command U, whereas commands T and Y generate one sub-paths. And because each sub-path gets its own arrowhead in LibreOffice\\(^{32}\\), there are arrow heads inside the spiral if using a sequence of commands U.\n\nSome use cases can be easier solved with commands T and U than with commands A, B, V or W. Compare the following solutions with those from exercise 8.1.\n\nExample full circle:\n\nCommands U and T have a special case for full circle\n\n```\n<draw:enhanced-geometry svg:viewBox=\"0 0 4000 4000\"\n draw:type=\"non-primitive\"\n```\n\n---\n\n\\(^{30}\\) [https://commons.wikimedia.org/wiki/File:FibonacciSpiral.svg](https://commons.wikimedia.org/wiki/File:FibonacciSpiral.svg)\n\n\n\\(^{32}\\) There is ongoing discussion about arrow heads in the ODF TC. But any standardization of the behavior is earliest available in ODF 1.4. \n[https://issues.oasis-open.org/browse/OFFICE-4111](https://issues.oasis-open.org/browse/OFFICE-4111)\n8 Arcs\n\n8.2 Defining an Arc by Center, Radii, Start- and End-Angle\n\nExample: Shape with handles for start and end point.\n\n\n\n*Figure 87: Arc with handle for start and for end point*\n\nThe modifiers can be used directly, no calculation of circle points is needed.\n\n**Arc with sector fill**\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 4000 4000\"\n draw:type=\"non-primitive\" draw:modifiers=\"-45 -105\"\n U 2000 2000 2000 2000 $0 $1 F\">\n <draw:handle draw:handle-position=\"2000 $0\" draw:handle-polar=\"2000 2000\"/>\n</draw:enhanced-geometry>\n```\n\n**Arc with only line**\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 4000 4000\"\n draw:type=\"non-primitive\" draw:modifiers=\"115 50\"\n <draw:handle draw:handle-position=\"2000 $0\" draw:handle-polar=\"2000 2000\"/>\n</draw:enhanced-geometry>\n```\n\n8.3 Defining an Arc by Start-Angle and Swing-Angle\n\nThis command is an extension to the ODF 1.3 standard and is only usable in a\n`draw:enhanced-path` attribute. This command will be available in the ordinary\n`draw:enhance-path` attribute in version 1.4 of the ODF standard.\n\n**Table 12: Description of the command G.**\n\n*From issue OFFICE-4026 in the ODF TC bug tracker*\\(^{33}\\).\n\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Parameters</th>\n<th>Description</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>G arcangleto</td>\n<td>(wR hR st sw) +</td>\n<td>Draws an arc of an ellipse. The ellipse is given by the width 2<em>wR, and the height 2</em>hR. The arc is specified by the start angle st in degrees and the swing angle sw in degrees. The ellipse is positioned so that the current point is the start point of the arc. The arc is drawn so that sw is the central angle of the arc. If sw is positive, the arc is drawn clockwise; if sw is negative, the arc is</td>\n</tr>\n</tbody>\n</table>\n\n\\(^{33}\\) [https://issues.oasis-open.org/browse/OFFICE-4026](https://issues.oasis-open.org/browse/OFFICE-4026)\n8 Arcs\n\n8.3 Defining an Arc by Start-Angle and Swing-Angle\n\ndrawn counter-clockwise. The endpoint of the arc becomes the new current point.\n\nIn case the path is filled, the filling is drawn as an ellipse segment.\n\nThe swing angle may be greater than 360° and may be smaller than −360°. In such cases the fill will overlap.\n\nCommand G has essential differences to the commands T and U:\n\n- The arc is attached to the current point and continues the current sub-path. Command T continues the current sub-path but draws an additional straight line segment. Command U starts a new sub-path.\n\n- By using negative swing angles, it is possible to draw arcs counter-clockwise. Commands T and U draw arcs always clockwise. The directions become visible if arrowheads are shown.\n\nAs example we will develop the markup for a “wave” shape as in figure 89.\n\n*Figure 88: Parameters of command G*\n\n*Figure 89: \"wave\" shape*\n\nThis shape is combined from two circle arcs. The illustration in figure 90 shows details of the construction.\n\nWe use the viewBox value \"0 0 120 20\". In this coordinate system the start point of the “wave” has coordinates (0|10) and the end point (120|10). The center points of the circles are $M_1(30|50)$ and $M_2(90|−30)$. Notice, that the center points are outside the viewBox. That is allowed.\nTo use command G we need the radii of the circles, the angle, which corresponds to the start point of the arc, and the “swing” angle, that is the center angle of the arc.\n\nThe radius \\( r \\) of the circle is determined by a center and a point on the circle circumference. With Pythagoras’ theorem we get\n\n\\[\nr = \\sqrt{(30-0)^2 + (50-10)^2} = 50\n\\]\n\nSame for the other circle\n\n\\[\nr = \\sqrt{(120-90)^2 + (10-(-30))^2} = 50\n\\]\n\nAn overview of the involved angles is given in figure 91.\n\nTo calculate angle \\( \\alpha \\) we use the same right triangle as for the radius.\n\n\\[\nf_0 = \\text{atan2}(40,30) \\times 180/\\pi\n\\]\n\nThe other angles can be derived from angle \\( \\alpha \\).\n\nStart angle for first arc (clockwise) \\( f_1 = 180 + f_0 \\)\n\nSwing angle for first arc \\( f_2 = 180 - 2 \\times f_0 \\)\n\nStart angle of second arc (counter-clockwise) \\( f_3 = 180 - f_0 \\)\n\nSwing angle for second arc \\( f_4 = -f_2 \\), same angle as for first arc but opposite direction\n\nThe enhanced-path is then\n\n```\ndrawoo:enhanced-path=\"M 0 10\nG 50 50 ?f1 ?f2\n50 50 ?f3 ?f4\"\n```\n\ncommand G needs special namespace\nmove to start point\nfirst arc\ncurrent point is correct for second arc\nsecond arc\n8.4 Tangent to Circular Arc\n\nWe are going to create a shape with a very simple ‘heart’. The heart should have the same size as the shape. A first idea is shown in figure 92. But that solution is not nice, because the transition between the arc and the straight line is not smooth.\n\nWe need to find a point of contact on the circle, so that a straight line through the middle of the bottom edge becomes a tangent to the circle, see figure 94.\n\nThe final shape should look like these\n\n\n\nTo compute a point of contact for a tangent and calculate the associated angles look at some formulas in chapter ‘11 Mathematics’. In the ‘heart’ shape case, it is $x_B = x_M + r$, which makes some formulas simpler.\n\nUse the viewBox value \"0 0 4000 4000\", which fits to the grid in the illustrations.\n\n$M_{\\text{left}}(1000|1000), M_{\\text{right}}(3000|1000), \\text{radius}=1000, B(2000|4000), P(2000|1000)$\n\n$k = |PB| = |RB| = 3000$\n\n$|MB| = \\sqrt{1000^2 + 3000^2} = 1000 \\cdot \\sqrt{10}$\n\nWe calculate the angles as shown in section 11.2.3.\n\n$\\beta = \\text{atan2}(3000, 1000)$\n\n$\\gamma = 2 \\cdot \\beta = 2 \\cdot \\text{atan2}(3000, 1000)$\n\nThe angle corresponding to point R is $\\gamma$.\n\nWe then calculate the coordinates of point R as shown in section 11.2.2.\n\n$x_R = \\frac{1000}{1000^2 + 3000^2} \\cdot (1000^2 - 3000^2) + 1000 = 200$\nThe angle of point P with respect to left circle is 360°, in regard to right circle it is 180°.\n\nThe angle and coordinates for the right point of contact can be calculated from symmetry. It is angle = 180°−γ and coordinates \\( (4000 − x_R \\mid y_R) = (3800 \\mid 1600) \\).\n\n**Exercise 8.5**\n\nNow develop the markup for this ‘heart’ shape. The heart shall be drawn as one sub-path. Find a solution for each of the three ways to draw arcs. You need to be careful to use correct parameters. All these commands draw an arc, but the parameters are quite different.\n\n--- solution\n\n### 8.5 Binding a Handle to an Ellipse Line\n\nIn case of a circular arc it is possible to bind a polar handle to the circle line by putting the circle radius as constant into the `draw:handle-position` attribute. That is not possible in case of an elliptical arc, because an ellipse has no unique radius.\n\n\n\nThe problem is shown on an example with a cone. The shape here is 5 cm wide and 7 cm high. The ellipse for the base area is 2 cm high. The shape uses `viewBox` value \"0 0 5000 7000\", so the ellipse has semi-major axis 2500 and semi-minor axis 1000, center of the ellipse is (2500|6000) and top of the lines is (2500|0) in local coordinate system.\n\nThe lines are tangent to the ellipse. You can create the shape with the help of section 11.2.4. But that is not topic here and therefore the formulas so far are given immediately. Comments on them are in the exercise solutions.\n\n\\[\n\\begin{align*}\nf_0 &= 2500/100 \\\\\nf_1 &= \\sqrt{f_0^2} \\\\\nf_2 &= \\sqrt{(f_1 + 2500)^2} \\\\\nf_3 &= 2500 - 2500/f_1 \\\\\n\\end{align*}\n\\]\nThe enhanced path is then so far\n\n```\ndraw:enhanced-path=\"\n U 2500 6000 2500 1000 0 360 N\n M ?f3 ?f6 L 2500 0 ?f4 ?f6 F\"\n```\n\nCommand U can draw a full ellipse. End of set, otherwise the comment F, needed for the lines, would affect the ellipse too.\n\nCommand F disables area fill for the lines. It is needed because in custom shapes open paths can be filled too.\n\nThe cone is now extended by a triangle. This illustration is common in mathematics teaching to calculate the length of a surface line of a cone. The special feature here is that the position of the triangle can be varied by a handle on the ellipse line.\n\nFigure 97: cone with surface line in various positions\n\nA polar handle is determined by the distance \\( r \\) to the center and the angle \\( \\gamma \\). The angle will be connected to a modifier. We will calculate the distance \\( r \\) so, that the handle is on the ellipse line.\n\nTo compute the distance \\( r \\) we can treat the ellipse as if it were centered to origin. Then all points with angle \\( y \\) have coordinates \\( (r \\cdot \\cos(y) \\mid r \\cdot \\sin(y)) \\). On the other hand, the position of the handle is a point on the ellipse line and as such needs to fulfill the ellipse equation in addition. For the ellipse in the example with radii 2500 and 1000 this is\n\n\\[\n\\left( \\frac{r \\cdot \\cos(y)}{2500} \\right)^2 + \\left( \\frac{r \\cdot \\sin(y)}{1000} \\right)^2 = 1\n\\]\n\nWe resolve this to\n\n\\[\n| \\frac{1000 \\cdot 2500}{\\sqrt{(1000 \\cdot \\cos(y))^2 + (2500 \\cdot \\sin(y))^2}} |\n\\]\n\nWe not only need the distance \\( r \\) but also the Cartesian coordinates of the handle to be able to draw the triangle.\n8 Arcs\n\n8.5 Binding a Handle to an Ellipse Line\n\n\\[ x = 2500 + r \\cdot \\cos(\\gamma) \\] and \\[ y = 6000 + r \\cdot \\sin(\\gamma) \\]\n\nThe complete markup is given in the exercise solution.\n\n**Exercise 8.6**\n\nCreate the complete `<draw:enhanced-geometry>` element for this shape. This is a repetition exercise for creating polar handles (section 3.6) and for area fill (section 5).\n\nAs repetition exercise for section 5.4 you might make the triangle fill lighter than the base area fill.\n\n--- solution\n\n### 8.6 Exercise Solutions\n\n#### 8.6.1 Exercise 8.1\n\n**Exercise 8.1 a)**\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 4000 4000\"\n draw:type=\"non-primitive\" draw:modifiers=\"1000 1000\"\n draw:enhanced-path=\"V 0 0 4000 4000 4000 2000 $0 $1 F N\">\n <draw:handle draw:handle-position=\"$0 $1\"\n draw:handle-range-x-maximum=\"4000\"\n draw:handle-range-x-minimum=\"0\"\n draw:handle-range-y-maximum=\"4000\"\n draw:handle-range-y-minimum=\"0\"/>\n</draw:enhanced-geometry>\n```\n\nNote the command **F** which disables filling.\n\nThe advantage of using an xy-handle is that the user can set the exact position in the dialog ‘Position and Size’. The disadvantage is that the handle cannot be bound to the circle line. The handle has no obvious connection to the arc. We discussed this problem already in chapter ‘3.5 Functions’ when a right triangle via Thales’ circle was created.\n\n**Exercise 8.1 b)**\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 4000 4000\"\n draw:type=\"non-primitive\" draw:modifiers=\"-145\"\n draw:enhanced-path=\"V 0 0 4000 4000 4000 2000 ?f0 ?f1 F N\">\n <draw:equation draw:name=\"f0\" draw:formula=\"2000+2000*cos($0*(pi/180))\"/>\n <draw:equation draw:name=\"f1\" draw:formula=\"2000+2000*sin($0*(pi/180))\"/>\n <draw:handle draw:handle-position=\"2000 $0\" draw:handle-polar=\"2000 2000\"/>\n</draw:enhanced-geometry>\n```\n\nSetting a fixed radius of **2000** forces the polar handle to move on the circle line.\n\nBecause the handle returns an angle, and the command A requires point coordinates, these have to be calculated. Therefore the unit degree has to be converted to radians to be usable with functions sin and cos.\n\n#### 8.6.2 Exercise 8.2\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 4000 4000\"\n```\nThe filled sector needs a separate set, done by command \\( \\text{n} \\), otherwise the commands \\( \\text{F} \\) and \\( \\text{S} \\) will be applied to both – arc and sector – and nothing is rendered.\n\n8.6.3 Exercise 8.3\n\nIf the start and end points are the same point of the ellipse, then the center angle of the arc is 0° and nothing is drawn. To circumvent this, draw the circle in two parts.\n\nCurrently the path is set to “closed” because start- and endpoint of the arc are the same\\(^{34}\\). Since the arc is “closed” there is no arrowhead. If you need an arrowhead, set the end point a little offset, for example 4000 1999 instead of 4000 2000.\n\n8.6.4 Exercise 8.4\n\nTo use commands \\( \\text{U} \\) and \\( \\text{T} \\) you need to start at the outer end of the spiral, because commands \\( \\text{U} \\) and \\( \\text{T} \\) draw arcs always clockwise. Using commands \\( \\text{X} \\) or \\( \\text{Y} \\) the orientation is automatically correct.\n\nYou can compute the point coordinates and radii needed directly from the grid in the illustration.\n\na) Command \\( \\text{U} \\)\n\nCommand \\( \\text{T} \\) needs a current point; therefore, requires a command \\( \\text{M} \\) to start.\n\n\\(^{34}\\) I consider this a bug, see case B in bug https://bugs.documentfoundation.org/show_bug.cgi?id=144390\nc) Command Y\n\nCommand Y needs a current point; therefore, requires a command M to start.\n\nDrawing with start inside:\n<draw:enhanced-geometry svg:viewBox=\"0 0 34 21\" draw:type=\"non-primitive\"\ndraw:enhanced-path=\"M 24 15 Y 25 16 26 15 24 13 21 16 26 21 34 13 21 0 0 21\"/>\n\nDrawing with start outside:\n<draw:enhanced-geometry svg:viewBox=\"0 0 34 21\" draw:type=\"non-primitive\"\ndraw:enhanced-path=\"M 0 21 Y 21 0 34 13 26 21 21 16 24 13 21 16 24 13 21 0 0 21\"/>\n\nWhen comparing with the other solutions, you see here a shorter version. Each quarter circle needs only one coordinate pair.\n\n8.6.5 Exercise 8.5\n\nUsing start- and endpoint\n\nWe start at the bottom corner of the heart and draw the arcs clockwise. Then command W is suitable. It provides the starting straight line. The ending straight line is drawn by a ‘close’ command.\n\nCommand A would be suitable too, but you would need to start with the right arc. Commands B and V are not suitable because they start a new sub-path.\n\nCommand W has the parameters:\nleft, top and right, bottom of bounding box of ellipse, start-point of arc, end-point of arc\n\nUsing start-angle and end-angle\n\nWe start again at the bottom corner of the heart and draw the arcs clockwise. Command T is suitable. It provides a starting straight line from current point to start of arc. The ending straight line is drawn by a ‘close’ command.\n\nCommand U is not suitable, because it starts a new sub-path.\n\nCommand T has the parameters: center, horizontal radius, vertical radius (of ellipse), start-angle for arc, end-angle for arc.\n\nTo get the angles, use the trigonometric functions, therefore we need some formulas.\n\n\\[ f_0 = 2 \\cdot \\arctan \\left( \\frac{3000}{1000} \\right) \\]\n\nangle \\( \\gamma \\) in radians\n\n\\[ f_1 = \\frac{f_0 \\cdot 180}{\\pi} \\]\n\nangle \\( \\gamma \\) in degrees\n\n\\[ f_2 = 180 - f_1 \\]\n\nend-angle in degrees for right arc\n\nAnd now here is the complete markup, commented\n\n\\[\n\\text{bottom corner of the heart}\n\\]\n\n\\[\n\\text{center left, horizontal and vertical radius}\n\\]\n\n\\[\n\\text{start-angle and end-angle for left arc}\n\\]\n\n\\[\n\\text{command T again, we omit the character}\n\\]\n\n\\[\n\\text{center right, horizontal and vertical radius}\n\\]\n\n\\[\n\\text{start-angle and end-angle for right arc}\n\\]\n\n\\[\n\\text{closing straight line to (2000|4000), which is initial point of the sub-path}\n\\]\n\n\\[\n\\text{angle \\( \\gamma \\) in radians}\n\\]\n\n83\n8.6.5 Exercise 8.5\n\nFormulas needed for the tangent lines\n\n\\[ f_0 = 2500/100 \\]\n\nscale factor in y-direction to transform the ellipse to a circle\n\n\\[ f_1 = ?f_0 \\times 6000 \\]\n\ndistance from pole to center in regard to the circle\n\n\\[ f_2 = \\sqrt{(?f_1 \\times (2500-2500 \\times ?f_1)^2)} \\]\n\ndistance \\( k \\) as in section 11 in regard to the circle, that is the distance between pole and point of contact\n\n\\[ f_3 = 2500 - 2500/\\?f_1 \\times ?f_2 \\]\n\n\\( x \\)-coordinate of left point of contact. The \\( x \\)-coordinate is not affected by vertical scaling and mirroring.\n\n\\[ f_4 = 2500 + 2500 \\times (\\?f_1 \\times ?f_2) \\]\n\n\\( x \\)-coordinate of right point of contact.\n8 Arcs\n\nExercise 8.6\n\n\\[ f_5 = \\frac{2500}{f_1} \\times \\frac{2500}{f_0} \\]\n\ny-coordinate, still mirrored and translated (see section 11.2.4). Reverse scaling is applied.\n\n\\[ f_6 = 6000 - f_5 \\]\n\nfinal y-coordinate for left and right point of contact. Now revers mirror and translate is applied.\n\n**Formulas needed for the handle**\n\nThe value \\( r \\) is rather complex. Therefore the calculation is divided in smaller parts. You may write it into one formula.\n\n\\[ \\$0 \\]\n\nmodifier, bound to the angle of the handle, value in degrees\n\n\\[ f_7 = 1000 \\times \\cos(\\$0 \\pi / 180) \\]\n\nfirst summand in radicand. Notice the angle conversion from degrees to radians. You might use a separate formula for that. Or you use separate formula for the complete \\( \\cos \\) expression and the complete \\( \\sin \\) expression. They are used again in calculating the coordinates.\n\n\\[ f_8 = 2500 \\times \\sin(\\$0 \\pi / 180) \\]\n\nsecond summand in radicand\n\n\\[ f_9 = \\frac{1000 \\times 2500}{\\sqrt{f_7^2 + f_8^2}} \\]\n\ncomplete value of radius \\( r \\)\n\n**Formulas for the position of the handle, needed for the triangle.**\n\n\\[ f_{10} = 2500 + f_9 \\times \\cos(\\$0 \\pi / 180) \\]\n\nx-coordinate of handle point, corner of the triangle\n\n\\[ f_{11} = 6000 + f_9 \\times \\sin(\\$0 \\pi / 180) \\]\n\ny-coordinate of handle point, corner of the triangle\n\n**Complete enhanced-geometry element**\n\n```xml\n<draw:enhanced-geometry\n svg:viewBox=\"0 0 5000 7000\" draw:type=\"non-primitive\"\n draw:modifiers=\"140\"\n draw:enhanced-path=\"U 2500 6000 2500 1000 0 360 N\"\n M \\( f_3 \\) \\( f_6 \\) L 2500 0 \\( f_4 \\) \\( f_6 \\) F\n N\n M 2500 0 L \\( f_{10} \\) \\( f_{11} \\) 2500 6000 Z\"\n>\n<draw:equation draw:name=\"f_0\" draw:formula=\"2500/1000\"/>\n```\n\n85\nEach handle is defined by an own element. Be careful to put the handle elements after the equation elements.\n\nUsing this attribute make the handle to a polar handle. The values determine the center of the handle movement.\n\nThe first value determines the distance from center to handle position. Here it is the calculated value \\( r \\). The second value is the angle. Here it is a reference to a modifier. At least one value must be a reference to a modifier, otherwise the handle will not move.\n9 Text Path\n\n9.1 Attribute Overview\n\nThis chapter is about artistic-shaped text in our custom shapes. LibreOffice provides some predefined shapes in the Fontwork-dialog and allows your own geometries too.\n\n\n\nFigure 98: Predefined Fontwork shapes in LibreOffice\n\nSimilar shapes exist as “WordArt” in old, binary Microsoft Office. The OOXXML standard has a fixed set of “TextWarpDefinitions” for such shapes, which are available as “abc Transform” in modern versions of Microsoft Office. VML has the element “TextPath”.\n\nThe ODF standard provides some attributes of the enhanced geometry to describe such shapes:\n\n**draw:text-path**\n\n- Its value is `true` or `false`, default to `false`. If `true`, text and path of the custom shape are used in a special way, as explained below.\n\nLibreOffice interprets the `draw:text-path` attribute for all custom-shapes. It has no user interface to let you change its value.\n\n**draw:text-path-allowed**\n\n- Values are `true` or `false`, with `false` as default. The definition in ODF 1.3 is, “The draw:text-path-allowed attribute specifies whether the user interface of a consumer that supports the draw:text-path attribute should allow modification of the value of the draw:text-path attribute.”\n\nThe definition in ODF 1.1 is, “The `draw:text-path-allowed` attribute specifies if the shape is capable of being rendered as Fontwork object.”\n\nThe meaning is unclear to me. LibreOffice does not interpret this attribute.\n\n---\n\n\n37 Section “Text Path Allowed” on page 339 in OpenDocument-v1.1-os.odt, 1 February 2007\n9 Text Path\n\n9.1 Attribute Overview\n\ndraw:text-path-mode\n\nAccepted values are shape, normal or path, with normal as default. The ODF standard defines the meaning as:\n\n“normal: text is drawn along the path without scaling;\npath: text is fitted to a path;\nshape: text is fitted to the bounding box of a shape.”\n\nLibreOffice does not interpret this attribute. The attribute value path better corresponds to the way LibreOffice renders Fontwork shapes. Because the default value is normal, your shapes should not omit the attribute but have it with value path.\n\ndraw:text-path-scale\n\nValues are shape or path, with path as default value. The ODF standard defines the meaning as:\n\n“path: text scaling is determined by the length of the path from the draw:enhanced-path 19.145 attribute.\nshape: text scaling is determined by the width of a shape.”\n\nMore details how LibreOffice interprets this property are given below.\n\ndraw:text-path-same-letter-heights\n\nValues are true or false, with false as default value. If set to true, all letters are scaled in height-direction to have the same height. LibreOffice has a user interface for it in the Fontwork toolbar, so you do not need to care about it in your shapes.\n\nFigure 99: Fontwork Same Letter Heights\n\n---\n\n\n9.2 Common Properties\n\nThe normal shape (left) has the markup\n<draw:enhanced-geometry svg:viewBox=\"0 0 21600 21600\" draw:type=\"non-primitive\"\n draw:enhanced-path=\"M 0 21600 Y 10800 0 21600 21600 Z N\"/>\n\nThe “Fontwork” shape (right) has the markup\n<draw:enhanced-geometry svg:viewBox=\"0 0 21600 21600\" draw:type=\"non-primitive\"\n draw:text-path=\"true\"\n draw:enhanced-path=\"M 0 21600 Y 10800 0 21600 21600 Z N\"/>\n\nThe markup is the same, only that the ‘Fontwork’ shape has\nthe additional attributes to enable text path. We see\n\n- Settings from tab ‘Font Effects’ are ignored, here the\n property ‘outline’ and the brown character color.\n\n- The area fill of the shape is used to fill the letters. In\n LibreOffice, the entire text gets one common fill.\n OpenOffice.org versions fill each letter individually.\n\n- The stroke settings of the shape are used in the outline of the letters.\n\n- Word wrap is ignored.\n\n- Paragraph alignment is ignored.\n\n- The path defined in the enhanced-path attribute is no longer rendered as path. It still exists and\n can be seen, if option ‘Modify Objects with Attributes’ in the ‘Options’ toolbar is disabled and\n you start rotation, for example, see screenshot in figure 101.\n\nBTW, you get a ‘nicer’ Fontwork shape, if you omit the command Z in the enhanced path and set\nthe alignment to ‘Center’.\n\nFigure 100: Compare normal shape with same shape with text path enabled\n\nFigure 101: Underlying path in 'Fontwork' shape\n9.3 One Path Line\n\n9.3.1 Value shape of Attribute text-path-scale\n\nThe examples here are based on following shape\n\n\n\n*Figure 102: Shape consisting of two circle arcs*\n\nThe markup is\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 120 20\" draw:type=\"non-primitive\"\n draw:enhanced-path=\"V -20 0 80 100 0 10 60 10 A 40 -80 140 20 60 10 120 10\"/>\n```\n\nThen add text-path attributes\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 120 20\" draw:type=\"non-primitive\"\n draw:text-path=\"true\" draw:text-path-mode=\"path\" draw:text-path-scale=\"shape\"\n draw:enhanced-path=\"V -20 0 80 100 0 10 60 10 A 40 -80 140 20 60 10 120 10\"/>\n```\n\nThe text is displayed in its original size. Mixing text parts with different sizes is not possible.\n\nOnly when the text width exceeds the path length, then the font size is reduced to fit the length. The font resizing affects only the rendering. The nominal font size in the style of the shape is not changed.\n\nThe text is then attached to the path. Each letter is rotated to be perpendicular to the path.\n\n*Table 13: Different font sizes rendered by text-path-scale attribute value 'shape'*\n\n*A dashed black line indicates the shape size, a pink dashed line indicates the path.*\n\n<table>\n<thead>\n<tr>\n<th>Font Size</th>\n<th>Shape</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>15 pt</td>\n<td><img src=\"image\" alt=\"15 pt example\" /></td>\n</tr>\n<tr>\n<td>24 pt</td>\n<td><img src=\"image\" alt=\"24 pt example\" /></td>\n</tr>\n<tr>\n<td>40 pt</td>\n<td><img src=\"image\" alt=\"40 pt example\" /></td>\n</tr>\n</tbody>\n</table>\n\nThe comparison with the 40 pt large text in the rectangle shows, that the font size in the Fontwork shape is reduced for rendering.\nPrior to LO 7.3 the rendering has a bug\\textsuperscript{40}, in which an additional padding of about 10% is introduced in the path length. As result, the text could not fill the whole path.\n\n**Exercise 9.1**\n\nUse a Fibonacci spiral from exercise 8.4 to create a Fontwork shape for a spiral text.\n\n→ **solution**\n\n### 9.3.2 Value path of Attribute text-path-scale\n\nIf the value of the attribute text-path-scale is path, then the font size for rendering adjusted, so that the text attached to the path covers the entire path.\n\n\n\n**Figure 103: text-path-scale value 'path'**\n\n**Exercise 9.2**\n\nThe predefined Fontwork shapes ‘Arch Up (Curve)’, ‘Arch Down (Curve)’, ‘Arch Left (Left)’, ‘Arch Right (Curve)’ and ‘Circle (Curve)’ are shapes of this kind. But all of them have only one handle for the arc and the shapes are symmetric to horizontal or vertical axis.\n\nCreate a Fontwork shape, which puts the text on an arc. The start- and end-angle of the arc shall be adjustable by handles.\n\n→ **solution**\n\n### 9.3.3 Text with Multiple Text Lines\n\nThe behavior is similar if the text has multiple lines. The text is then treated as a single block. The middle of the text block is aligned with the path as default, but the anchor can be changed, see section 9.6. The longest line determines the font size to render.\n\nTo create multiple lines you must make different paragraphs using the Enter-key. Automatic or manual line break using shortcut Shift-Enter is ignored.\n\n\n\n**Figure 104: text-path-scale value 'shape' with two paragraphs**\n\nThe rendering has bugs\\textsuperscript{41} currently if the text block is wider than the path length. If you get unexpected results, check whether the nominal font size is too large.\n\n\\textsuperscript{40} https://bugs.documentfoundation.org/show_bug.cgi?id=145004\n\\textsuperscript{41} https://bugs.documentfoundation.org/show_bug.cgi?id=145004\nIn the current implementation the distance from the start is calculated for each letter, assuming a straight text line. This distance is measured along the possible curved path and determines a point on the path. Then an imaginary perpendicular line (the normal) is drawn through this point and the character is placed and aligned on it. Thus, characters on the outer side of a curve are more spaced than characters on the inner side. Characters can even overlap in sharp curves.\n\nFigure 105: Rendering of multi-line text on a curve\n\n9.4 Two Sub-Paths\n\nIf the shape has two sub-paths, the text block is transformed to fit between the two lines. The top of the text block is bound to the first line, the bottom of the text block is bound to the second line. Most of the preset Fontwork shapes have a geometry with two sub-paths.\n\nIn contrast to shapes with one sub-path, the characters are not perpendicular to the sub-path, but each character is then transformed to fit between corresponding relative path-portions on the two sub-paths. For text with multiple paragraphs the relative vertical position in the bounding box of the text block is relevant too.\n\nFontwork shapes with two sub-paths still react on attribute draw:text-path-scale as described above. The length of the mean of the two sub-path lengths is used as reference. The preset Fontwork shapes with two sub-paths have the value ‘path’ for this attribute.\n\nTable 14: Examples for text rendering with two sub-paths\n\nA dashed black line indicates the shape size, pink dashed lines indicate the sub-paths.\n\n<table>\n<thead>\n<tr>\n<th>Markup</th>\n<th>Rendered Shape</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><draw:enhanced-geometry svg:viewBox="0 0 60 60" draw:text-path="true"</td>\n<td></td>\n</tr>\n<tr>\n<td>draw:text-path-mode="path"</td>\n<td></td>\n</tr>\n<tr>\n<td>draw:text-path-scale="path"</td>\n<td></td>\n</tr>\n<tr>\n<td>draw:type="non-primitive"</td>\n<td></td>\n</tr>\n<tr>\n<td>draw:enhanced-path="M 0 45 L 60 0</td>\n<td></td>\n</tr>\n<tr>\n<td>M 0 60 L 60 15"/></td>\n<td>LibraOffice</td>\n</tr>\n</tbody>\n</table>\nThe common part of the markup of the following examples is:\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 60 60\"\n draw:text-path=\"true\" draw:text-path-mode=\"path\"\n draw:text-path-scale=\"shape\"\n draw:type=\"non-primitive\"\n draw:enhanced-path=\"M 0 45 L 60 0\n M 0 60 L 60 15\"/>\n```\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 60 60\"\n draw:text-path=\"true\" draw:text-path-mode=\"path\"\n draw:text-path-scale=\"path\"\n draw:type=\"non-primitive\"\n draw:enhanced-path=\"M 30 60 X 0 30 30 0\n M 60 45 X 30 15\"/>\n```\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 60 60\"\n draw:text-path=\"true\" draw:text-path-mode=\"path\"\n draw:text-path-scale=\"shape\"\n draw:type=\"non-primitive\"\n draw:enhanced-path=\"M 30 60 X 0 30 30 0\n M 60 45 X 30 15\"/>\n```\nTable 15: Examples for text rendering depending on path direction and order\n\n<table>\n<thead>\n<tr>\n<th>value of draw:enhanced-path</th>\n<th>rendering</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>M 0 0 L 8 0 M 0 6 L 8 6</td>\n<td>LibreOffice Community</td>\n</tr>\n<tr>\n<td>top and bottom line left to right</td>\n<td></td>\n</tr>\n<tr>\n<td>M 0 6 L 8 6 M 0 0 L 8 0</td>\n<td>Communio</td>\n</tr>\n<tr>\n<td>top and bottom line left to right, but first line at bottom, second at top</td>\n<td></td>\n</tr>\n<tr>\n<td>The text block is vertically mirrored.</td>\n<td></td>\n</tr>\n<tr>\n<td>M 8 0 L 0 0 M 8 6 L 0 6</td>\n<td>LibreOffice Community</td>\n</tr>\n<tr>\n<td>top and bottom line right to left</td>\n<td></td>\n</tr>\n<tr>\n<td>The text block is horizontally mirrored.</td>\n<td></td>\n</tr>\n</tbody>\n</table>\n\nObviously, direction and order of the two paths have to be considered.\n\nNote that the filling is applied independent from rendering the characters.\n\nThe predefined Fontwork shapes provide already a lot of different forms. You likely need your own Fontwork shapes only to use draw:text-path-scale=\"shape\" or if you want to use a sub-path, which creates some mirroring.\n\n**Exercise 9.3**\n\nCreate an ODF conform version of a ‘Ring’. Such shapes are provided by OOXML. Figure 106 shows a ‘Ring’ shape made in PowerPoint.\n\nYou need two ellipses of same size, where one is shifted vertically. The solution will show a very simple version without handles. Of course you could apply all your knowledge from the previous chapters and create a shape with handle for the start of the text and for the height of the ellipses.\n\n→solution\n\n**9.5 More Than Two Sub-Paths**\n\nIf the number of sub-paths is odd, the rendering is similar to the case of one sub-path. If the number of sub-paths is even, each two consecutive sub-paths form a pair and rendering is similar to the case of two sub-paths. The black dashed lines indicate the shape size and the red dashed lines indicate the sub-paths in the examples.\nThe paragraphs of the text are evenly distributed over the sub-paths. In figure 107 the five paragraphs are distributed over the three sub-paths as 12-34-5. A distribution 123-4-5 or 12-3-45 is not possible. In figure 108 the 4 sub-paths are combined to 2 pairs and the 5 paragraphs are then distributed as 123-45. Note that there is no text between the second and third sub-path.\n\nIt is not possible to mix stretchy rendering between a pair of sub-paths with rendering of text on sub-paths.\n\nThe ‘Fontwork Shape’ tool provides shapes with odd number of sub-paths in the last but one row. Their names contain the suffix “(Curve)”. The last row has the same shape names, now with suffix “(Pour)”. These shapes have an even number of sub-paths.\n\nTable 16: 'Arch Up' shape in variants 'Curve' and 'Pour'\n\n<table>\n<thead>\n<tr>\n<th>‘Arch Up’ shape with one sub-path</th>\n<th>‘Arch Up’ shape with two sub-paths</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><img src=\"image1\" alt=\"Arch Up (Curve)\" /></td>\n<td><img src=\"image2\" alt=\"Arch Up (Pour)\" /></td>\n</tr>\n<tr>\n<td><img src=\"image3\" alt=\"LibreOffice\" /></td>\n<td><img src=\"image4\" alt=\"LibreOffice\" /></td>\n</tr>\n</tbody>\n</table>\n9.6 Controlling Text Position\n\nThe position of the text can be influenced by the style attributes `draw:textarea-horizontal-align` and `draw:textarea-vertical-align`. They are available as ‘Anchor’ in the dialog ‘Text Attributes’ in the user interface. Thereby the value justify – ‘Full Width’ in the UI – is not evaluated at all. The horizontal anchor positions are mirrored to the toolbar ‘Fontwork Alignment’ in the ‘Fontwork’ toolbar. Changing the horizontal alignment there has no influence on the vertical alignment.\n\nIf the attribute `text-path-scale` has the value path, then you will see anchor differences for the horizontal anchor only if the text in a sub-paths pair has at least two paragraphs with different length. The vertical anchor position is ignored because the text is fit between pairs of two sub-paths.\n\nIf the attribute `text-path-scale` has the value shape, the vertical anchor positions top, middle and bottom are evaluated.\n\nRemember that these settings belong to the style of the shape. There are no attributes in the enhanced geometry to determine the position of Fontwork text. In addition, the attributes `draw:text-areas` and `draw:text-rotate-angle` are not evaluated for Fontwork shapes, and you cannot tweak the position by adding leading or trailing spaces or by setting an indent at a paragraph.\n\nYou can only act on the position by specifying the enhanced path itself as needed.\n\n9.7 Exercise solutions\n\n9.7.1 Exercise 9.1\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 34 21\" draw:type=\"non-primitive\"\n draw:text-path=\"true\" draw:text-path-mode=\"path\" draw:text-path-scale=\"shape\"\n draw:enhanced-path=\"M 0 21 Y 21 0 34 13 26 21 21 16 24 13 26 15 25 16 24 15\"/>\n```\n\nThe path of the Fibonacci spiral is drawn from the outside in.\n\n9.7.2 Exercise 9.2\n\n```xml\n<draw:enhanced-geometry svg:viewBox=\"0 0 4000 4000\"\n draw:type=\"non-primitive\"\n draw:text-path=\"true\" draw:text-path-mode=\"path\"\n draw:text-path-scale=\"path\"\n```\n9.7.2 Exercise 9.2\n\nThe size of the characters is adapted such that the text fills the entire path. Drag the handle in the shape to see this feature.\n\n9.7.3 Exercise 9.3\n\nTo get a full ellipse, draw two arcs. To get the lower part of the text left-to-right and the higher part of the text mirrored, right to left, the arcs are drawn counter-clockwise. Therefore, the commands A and B are used.\n\nBoth examples have nominal font size 18pt. In case of the letters are enlarged so that the text fills the whole ellipse. In both cases the letters are stretched vertically to fit between the two ellipses.\n\n---\n\n42 Shapes a contained in the separate file “Shapes from Custom Shape Tutorial.odg”.\n\n97\n10 Custom Shapes in 3D\n\nThe command ‘Toggle Extrusion’\\[\\text{\\textvisiblespace}\\] brings a custom shape into 3D-mode or back. The shape is extruded perpendicular to the shape to generate a solid. The same engine is used internally for rendering such extruded shapes as for ‘real’ 3D-scenes. However, the ‘3D Effects’ dialog is not usable with an extruded custom shape. Instead, the ‘3D-Settings’ toolbar is used to manipulate 3D properties via the user interface. The toolbar provides a simplified way to specify properties, but does not provide all possible settings of the document format.\n\nODF specifies 24 attributes in the <draw:enhanced-geometry> element for custom-shapes, that are related to the 3D-mode. Besides the attributes dr3d:projection and dr3d:shade-mode all of them have a naming structure draw:extrusion-*. The ODF specification was inspired by similar shape modes in the binary file format of MS Office\\textsuperscript{43}, by the attributes of the extrusion element in VML\\textsuperscript{44} and 3D-shapes in Rich Text Format\\textsuperscript{45}.\n\nThe properties are usable in macros, with service EnhancedCustomShapeExtrusion.\\textsuperscript{46} To examine the current, non default properties applied, the ‘Developer Tools’ are helpful. The extrusion properties are located in item ‘Extrusion’ in property ‘CustomShapeGeometry’.\n\nThis chapter will discuss these attributes. You already know how to edit the document source, therefore this chapter has no further exercises, but explains these attributes.\n\n10.1 Enable 3D-mode\n\n10.1.1 Attribute draw:extrusion\n\nThe attribute value ”true” switches 3D-mode on and value ”false” switches it off. The attribute is available as command ‘Toggle Extrusion’\\[\\text{\\textvisiblespace}\\] in the user interface, so there is no need to edit it in file format.\n\n10.1.2 Attribute draw:extrusion-allowed\n\nWith the attribute draw:extrusion-allowed a document producer can specify, that the application shall or shall not provide tools for extruding a shape. This attribute is not implemented in LibreOffice. All custom shapes – which includes Fontwork shapes – can be extruded in LibreOffice.\n\n\\textsuperscript{43} see chapters ‘2.3.15 3D Object’ and ‘2.3.16 3D Style’ in [MS-ODRAW] ‘Office Drawing Binary File Format’, available from https://docs.microsoft.com/en-us/openspecs/office_file_formats\n\\textsuperscript{44} See https://www.w3.org/TR/NOTE-VML and chapter ‘VML Extrusion Element’ in https://docs.microsoft.com/en-us/windows/win32/vml/msdn-online-vml-extrusion-element\n\\textsuperscript{46} https://api.libreoffice.org/docs/idl/ref/servicecom_1_1sun_1_1star_1_1drawing_1_1EnhancedCustomShapeExtrusion.html\n10.2 Coordinate System\n\nThe x-axis points right and the y-axis points down in the internal 2D coordinate-system of custom shapes. That is the same for the 3D coordinate-system of an extruded custom shape. The z-axis is perpendicular to the xy-plane and points towards the observer. So extruded custom shapes use a left-handed coordinate-system. That is different from “true” 3D objects, which use a right-handed coordinate-system.\n\nThe origin of the 3D coordinate-system is the center of the snap rectangle of the shape. But for x- or y-coordinates you will not use absolute values. The attributes are defined to use values, which are somehow relative to the shape.\n\n10.3 Text\n\nCustom shapes can have text. Those text is currently not included in the 3D-scene of the extruded shape but is drawn on top of the projection of the shape.\n\nIf the shape has set the attribute `draw:text-path=\"true\"` (see chapter 9, Text Path) you get a ‘Fontwork’ shape. In that case the text itself is the outline of the shape and reacts on extrusion.\n\n10.4 Object Geometry\n\n10.4.1 Attribute `draw:extrusion-depth`\n\nThe attribute value has two components. The first component specifies the extrusion depth. It is a number with unit. This component is available as drop-down list ‘Depth’ in the ‘3D-settings’ toolbar. The second component is a number in the range [0;1], which is interpreted as fraction of the depth. It specifies the amount of the extrusion that lies before a shape. This second component has no user interface. The default value is \"36pt 0\".\n\nValue 0 for the second component means that the shape is the front face of the solid, with value 1 it is the back face of the solid. The impact of the second component becomes visible, when the object is rotated. Figure 113 shows objects with second component value 0, 0.5 and 1 respectively. The objects have same rotation angles and same rotation center. Note the location of the solid relative to the snap rectangle of the shape.\n10 Custom Shapes in 3D\n\n10.4.1 Attribute draw:extrusion-depth\n\nThe attribute draw:extrusion-depth is used to specify the depth of the extrusion. The value is given as a position along the z-axis, ranging from 0 (fully extruded) to 1 (fully retracted).\n\n\n\n10.4.2 Attribute draw:extrusion-rotation-angle\n\nThe attribute value has two components. The first component specifies the angle for the rotation around the x-axis, the second component the angle for the rotation around the y-axis. The angles may have the unit deg, grad, or rad. If no unit is used, the value is interpreted as angle in degrees. The default value is \"0 0\".\n\nThe user interface provides four buttons to rotate the solid in 5 deg steps.\n\n- \"Tilt Down\" Rotation around a horizontal axis. Parts of the solid above the axis come nearer to you. The rotation angle decreases.\n- \"Tilt Up\" Rotation around a horizontal axis. Parts of the solid below the axis come nearer to you. The rotation angle increases.\n- \"Tilt Left\" Rotation around a vertical axis. Parts of the solid right from the axis come nearer to you. The rotation angle increases.\n- \"Tilt Right\" Rotation around a vertical axis. Parts of the solid left from the axis come nearer to you. The rotation angle decreases.\n\nThe user interface has no limit for rotation. You can end up with rotation angles larger than 360 deg or smaller than −360 deg. Editing the document source might be useful to correct such angles.\n\nThe rotation on the z-axis is not specified as extrusion property but by the draw:transform attribute of the <draw:custom-shape> element. The corresponding user interface is the ‘Rotation’ section in the ‘Position and Size’ dialog.\n\nThe rotations are applied in the order first z-axis, then vertical axis (y-axis), last horizontal axis (x-axis).\n\n10.4.3 Attribute draw:extrusion-rotation-center\n\nThe attribute draw:extrusion-rotation-center specifies the center of rotation, the intersection point of the rotation axes. The user interface has no tool for changing its values. The default\nposition of the rotation center is the center of the shape. That need not be the front face of the solid, see attribute \\texttt{draw:extrusion-depth}.\n\nThe attribute value is written in the form \" (dx dy dz) \", for example \" (0.5 -0.5 1000) \". The first and second component are fractions of the shape size. The third component is interpreted as hundredth millimeter. The shape center as default rotation center would be written as value \" (0 0 0) \".\n\nThese values are relative to the default rotation center. A positive value for \\texttt{dx} moves the center to the right, a positive value for \\texttt{dy} moves it down, and a positive value for \\texttt{dz} moves it towards the observer. The value \" (0.5 -0.5 1000) \" will set the rotation center to the right-top of the shape, 1 cm towards the observer, for example. The position of the rotation center effects the position of the actual rendered drawing.\n\nOld versions of LibreOffice have this wrongly implemented. You need at least version 7.3 to use other than the default value of this attribute.\n\n10.5 Projection\n\nTo render the three-dimensional solid to the two-dimensional paper or screen either parallel projection or central projection is used. For extruded custom shapes the projection plane (image plane, film plane) is always the xy-plane.\n\nA custom shape has a defined two-dimensional size, which is indicated by the resize handles. The result of the projection is not fit into this rectangle but might exceed it. That is different to “true” 3D-objects.\n\n10.5.1 Attribute \\texttt{dr3d:projection}\n\nThe attribute \\texttt{dr3d:projection} specifies which projection kind to use. It has the value \\texttt{parallel} for parallel projection and the value \\texttt{perspective} for central projection. The value \\texttt{parallel} is the default value.\n\nYou find this setting in the user interface in the lower part of the drop-down ‘Direction’ in the ‘3D-Settings’ toolbar.\n\nWhen you change the projection type, LibreOffice remembers related values you have set and will also write them to file. This allows you to easily switch between projection types.\n\n10.5.2 Central Projection\n\nA central projection is determined by a viewpoint (eye-point), that is the position of the observer. A straight line is drawn through viewpoint and object point. The intersection of this line with the xy-plane is the result of the projection.\n\nThe illustration shows an extruded square in a view from top to bottom. The square is extruded so that \\(\\frac{1}{4}\\) of the depth lies before the shape.\nLooking at the same extruded shape from front to back, you see the known effect, that nearer parts are larger than parts far away. And you see that the viewpoint becomes the so called ‘vanishing point’.\n\n**10.5.3 Attributes draw:extrusion-viewpoint and draw:extrusion-origin**\n\nThe viewpoint is specified by the attributes `draw:extrusion-viewpoint` and `draw:extrusion-origin` in the document source. These attributes are always used together. They are specific to central projection and ignored if the projection type is set to value “parallel”.\n\nThe value of attribute `draw:extrusion-viewpoint` has the form \"(vx vy vz)\" where each of vx, vy and vz is a length consisting of a number immediately followed by a length unit. The default value is \"(3.5cm -3.5cm 25cm)\". But LibreOffice uses \"(-3.472cm 3.472cm 25cm)\" as default, which is the default value in MS Office file formats. The attribute is not available in the user interface.\n\nThe component vz determines the z-coordinate of the viewpoint directly. The components vx and vy are not coordinates in the coordinate system, but they describe a shift from the viewpoint origin. The viewpoint origin is specified by the attribute `draw:extrusion-origin`. Its value has the form \"dx dy\". The components dx and dy are fractions of width and height of the bounding rectangle of the 2D shape with applied 2D transformations. Values are in the range \\([-0.5, 0.5]\\). The center of the bounding rectangle is given by the value \"0 0\". The default value is \"0.5 -0.5\", the right-top corner of the bounding rectangle.\n10 Custom Shapes in 3D\n\n10.5.3 Attributes draw:extrusion-viewpoint and draw:extrusion-origin\n\nExample: Take a shape ‘rectangle’ with width 10 cm and height 5 cm, without any transformations. With attributes\ndraw:extrusion-origin=\"-0.2 0.5\" and\ndraw:extrusion-viewpoint=\"(4cm, 3cm, 10cm)\"\nyou get the absolute coordinates of the viewpoint as\nx-coordinate = −0.2 ∙ 10 cm + 4 cm = 2 cm and y-coordinate = 0.5 ∙ 5 cm + 3 cm = 5.5 cm\n\nLibreOffice has no tool in the user interface to set arbitrary values. It only offers nine presets in the upper part of the drop-down ‘Direction’ in the ‘3D-Settings’ toolbar.\n\nNorth-East: draw:extrusion-viewpoint=\"(-3.472cm 3.472cm 25cm)\"\n draw:extrusion-origin=\"-0.5 0.5\"\nEast: draw:extrusion-viewpoint=\"(-3.472cm 0cm 25cm)\"\n draw:extrusion-origin=\"-0.5 0\"\nSouth-East: draw:extrusion-viewpoint=\"(-3.472cm -3.472cm 25cm)\"\n draw:extrusion-origin=\"-0.5 -0.5\"\nSouth: draw:extrusion-viewpoint=\"(0cm -3.472cm 25cm)\"\n draw:extrusion-origin=\"0 -0.5\"\nSouth-West: draw:extrusion-viewpoint=\"(3.472cm -3.472cm 25cm)\"\n draw:extrusion-origin=\"0.5 -0.5\"\nWest: draw:extrusion-viewpoint=\"(3.472cm 0cm 25cm)\"\n draw:extrusion-origin=\"0.5 0\"\nNorth-West: draw:extrusion-viewpoint=\"(3.472cm 3.472cm 25cm)\"\n draw:extrusion-origin=\"0.5 0.5\"\nNorth: draw:extrusion-viewpoint=\"(0cm 3.472cm 25cm)\"\n draw:extrusion-origin=\"0 0.5\"\n10.5.3 Attributes draw:extrusion-viewpoint and draw:extrusion-origin\n\nBackwards: draw:extrusion-viewpoint=\"(0cm 0cm 25cm)\"\ndraw:extrusion-origin=\"0 0\"\n\nNote that the bounding rectangle might be different from the snap rectangle. Both shapes in the\nfollowing illustration have set draw:extrusion-viewpoint=\"(0cm 0cm 10cm)\"\ndraw:extrusion-origin=\"0 0\" and svg:width=\"12cm\", svg:height=\"8cm\" and\ndraw:extrusion-depth=\"25mm 0\". But the bounding boxes are different and therefore the\npositions of the viewpoint origin are different.\n\nOld versions of LibreOffice have not used the bounding rectangle but the snap rectangle. To get the\ncorrect rendering as specified in ODF and as used by MS Office, you need to use at least version\n7.3.\n\n10.5.4 Parallel Projection\n\nIn general, a parallel projection can be determined by a projection direction. To calculate the image\nof a point, we need to know the image point U of the unit point (0|0|1) of the z-axis. ODF uses the\npolar coordinates (r, φ) of this point. Section 11.3 contains how to create them from known\nprojection direction.\n\nThe angle φ is positive in the shown direction.\n\n10.5.5 Attribute draw:extrusion-skew\n\nThe attribute draw:extrusion-skew specifies the skew amount (redaction factor) and the skew\nangle. Its value has the form \"amount angle\". The amount is given as percentage without % sign\nof the z-coordinate of a point. With above notations it is 100 r. The number of component angle is\nthe above notated angle $\\varphi$ converted to unit degree. The value of the angle is used modulo 360°, so value $-30$ has the same result as value $330$. The default value is \"50 45\" in ODF.\n\nThe `draw:extrusion-skew` attribute is only used for parallel projection and is ignored in case of central projection.\n\nThe buttons in the upper part of the drop-down ‘Direction’ of the ‘3D-Settings’ toolbar work too for parallel projection. The value for the `angle` component is set as indicated in following table:\n\n<table>\n<thead>\n<tr>\n<th>North-West 135</th>\n<th>North 90</th>\n<th>North-East 45</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>West 180</td>\n<td>Backwards 0</td>\n<td>East $-360$</td>\n</tr>\n<tr>\n<td>South-West $-135$</td>\n<td>South $-90$</td>\n<td>South-East $-45$</td>\n</tr>\n</tbody>\n</table>\n\nAll buttons but ‘Backwards’ set the `amount` component to 50.\n\nThe button ‘Backwards’ is special because it produces an orthogonal projection, whereas the other buttons produce oblique projections. The ‘Backwards’ button sets the `amount` component to 0.\n\nLibreOffice writes the value $-360$ for the direction ‘East’, which is basically the same as value 0. But it indicates that the user has set ‘East’ and not ‘Backwards’.\n\nLibreOffice uses internal $-135$ (‘South-West’) as default skew angle, because MS Office formats use that value as default. So you need to make sure, that the value of `draw:extrusion-skew` is not omitted in document source but always written. To force this when using the ‘3D-Settings’ toolbar switch from the default direction ‘South-West’ to a different direction and then back, in case ‘South-West’ is intended.\n\n### 10.5.6 Examples of oblique parallel projection\n\nOblique parallel projections are often called “cavalier projection” or “cabinet projection”. However, these terms are not standardized and depend on country. Surely you have used such projections in school mathematics to sketch a cuboid on squared paper.\n\nTo use a coordinate system as shown in the illustration, you need to set `draw:skew=\"70.71 -135\"`. Using a skew angle $-135$ results in a projection, where those lines, which go from the observer perpendicular to the xy-plane are drawn with a 45° angle to the x-axis. The reduction factor of 70.71 ≈ $\\sqrt{0.5} \\approx 0.7071$ corresponds to the length of the diagonals in a grid square.\n\nThe illustrations show a cube with edge length 3 cm and extrusion behind the front face.\n10.5.6 Examples of oblique parallel projection\n\ndraw:skew=\"70.71 -135\" draw:skew=\"50 -135\" draw:skew=\"50 -120\"\n\n10.5.7 Examples for orthographic projection\n\nIn an “orthographic”, also called “orthogonal”, parallel projection, the projection direction is perpendicular to the xy-plane. Two of such projections are standardized in ISO 5456-3, “isometric projection” and “dimetric” projection.\n\nBecause the direction is perpendicular to the xy-plane, you must set draw:skew=\"0 0\" (‘Backwards’). But to get “isometric” or “dimetric”, you need to rotate the solid in addition.\n\nTo get a nearly “dimetric” projection, rotate the solid by 20° about the y-axis and by 20° about the x-axis. You can do that in the ‘3D-Settings’ toolbar by 4 times ‘Tilt Left’ and 4 times ‘Tilt Down’. That produces about 7° and 42° angles of receding lines against a horizontal line. Some “Geodreieck”\\footnote{https://en.wikipedia.org/wiki/Set_square#Geodreieck} tools have marks for 7° and 42°. The illustration shows again a cube. The markup for this cube is\n\ndraw:extrusion-skew=\"0 0\"\ndraw:extrusion-rotation-angle=\"-20 20\"\n\nThe “isometric” projection needs a rotation of 45° about the y-axis and a rotation about the x-axis of about 35°. The cube in the illustration has the markup\n\ndraw:extrusion-skew=\"0 0\"\ndraw:extrusion-rotation-angle=\"-35 45\"\n\nIf you want the angles more precise, you need to edit the document source. You can use for “dimetric” projection\n\ndraw:extrusion-skew=\"0 0\"\ndraw:extrusion-rotation-angle=\"-19.4205368891 20.2680671953\"\n\nand for “isometric” projection\n\ndraw:extrusion-skew=\"0 0\"\ndraw:extrusion-rotation-angle=\"-35.2643896828 45\"\n\n\\footnote{https://en.wikipedia.org/wiki/Set_square#Geodreieck} [last called 2022-03-03]\n10 Custom Shapes in 3D\n\nThe calculations for these angles are shown in section 11.4.\n\n10.6 Object Surface\n\nRendering object surface and lighting of extruded shapes have changed significantly in LibreOffice 7.4. The descriptions here are of limited use for earlier versions.\n\nThe surface of an object is determined by the fill of front face and back face and by the color of the extruded facets. The fill of front and back face is specified as the fill of the two-dimensional shape. The color of the extruded facets can be specified explicitly or is determined automatically by LibreOffice.\n\nAnother aspect is how the surface of an object reacts on the lights of the 3D-scene.\n\n10.6.1 Attribute draw:extrusion-color\n\nThis attribute is available in the ‘3D Color’ part of the ‘3D-Settings’ toolbar. No need to edit the document source for that.\n\nThe attribute value false means, that no explicit extrusion color is used. That is setting ‘Automatic’ in the ‘3D Color’ tool. In case the shape has a color fill, LibreOffice uses this color for the extrusion facets too. In other cases, LibreOffice sets a color following some internal rules. Other applications will have own rules. For interoperability you should set the color explicitly in these cases.\n\nThe attribute value true means, that the color is used, that is defined in the style attribute draw:secondary-fill-color. That color can be set by the common tool for color choosing in the lower part of the ‘3D Color’ tool. When you chose a color there, then attribute draw:extrusion-color=\"true\" is automatically set in the <draw:enhanced-geometry> element and the attribute draw:secondary-fill-color is generated in the associated <style:style> element. So there is no need to edit the document source for this attribute.\n\n10.6.2 Attribute draw:extrusion-light-face\n\nThis attribute toggles whether the front face of the extruded shape reacts on lights. This attribute is not implemented in LibreOffice. In LibreOffice a front face always reacts on lights.\n\n10.6.3 Attribute draw:extrusion-diffusion\n\nThis attribute specifies how much of diffuse light is reflected by the shape. To use this attribute, you need at least version 7.4. ODF allows values from 0% to 100% with default value 0%. The value 0% is not interpreted by LibreOffice, because existing shapes in documents created with older versions of LibreOffice have not set the attribute, but act like having 100% set. A value smaller than 100% reduces the brightness of the rendered object. To force writing the attribute to document source switch extrusion off and then back to on.\n\nThis attribute acts only on solid colors. Filling with gradient, bitmap, hatch or pattern is not affected.\n10 Custom Shapes in 3D\n\n10.6.3 Attribute draw:extrusion-diffusion\n\nDiffusion 100% Diffusion 50%\n\n*Figure 114: Diffusion*\n\nThe ‘Metal MS compatible’ surface preset uses about 67% for the diffusion attribute. Switching to ‘Matte’, ‘Plastic’ or ‘Metal ODF’ surface preset then sets the diffusion attribute to 100%.\n\n10.6.4 Attribute draw:extrusion-shininess\n\nThis attribute specifies how much the shape material behaves like a mirror with respect to lights. To use this attribute, you need at least version 7.4. Older versions interpret the attribute incorrectly.\n\nThis attribute is similar to the setting ‘Specular Intensity’ in the ‘Material’ tab of the ‘3D Effects’ dialog of “true” 3D-scenes. ODF allows values from 0% to 100%, but values below 3% result in strange rendering and values larger than 66% will not increase the effect. In most cases there is no need to change the default value of 50%.\n\nShininess 15% Shininess 50% Shininess 66%\n\n*Figure 115: Shininess*\n\n10.6.5 Attribute draw:extrusion-specularity\n\nTo use this attribute, you need at least version 7.4. Older versions interpret this attribute incorrectly.\n\nThe description of the attribute is very vague in the standard. LibreOffice uses it similar to the attribute ‘Specular Color’ in the ‘Material’ tab of the ‘3D Effects’ dialog of a “true” 3D-scenes.\n\nThe value is a percent value. With value 0% the first light source is no longer treated as specular light, but as a directional, but diffuse light. That results in a matte surface of the rendered shape. In LibreOffice, specularity is evaluated only for the first light.\nODF 1.3 allows only values in range [0%, 100%]. But when importing a document from MS binary formats often a value of about 122% is used. Saving in ‘ODF 1.3 extended’ will keep this value, saving in ‘ODF 1.3’ will clamp it to 100%.\n\nNote that only the extruded facets of the solid are glossy, front face and back face are always matte.\n\nThere is no general user interface for this attribute. The ‘Surface’ drop-down list in the ‘3D Settings’ toolbar set a value of 122% when switching from ‘Matte’ surface to ‘Plastic’, ‘Metal ODF’ or ‘Metal MS compatible’, and it sets a value of 0% when switching to ‘Matte’ surface. In other cases, an existing value is kept. So if you set an own value in the document source, it might be overwritten when you use the ‘Surface’ drop-down list, and you will need to set the value again.\n\n10.6.6 Attributes `draw:extrusion-metal` and `loext:extrusion-metal-type`\n\nThe ODF standard specifies for values of the `draw:extrusion-metal` attribute:\n\n- `false`: the specular color for the shading of an extruded shape is white.\n- `true`: the specular color for the shading of an extruded shape is gray (red green and blue values of 200) instead of white and 15% is added to the specularity.”\n\nTo achieve better compatibility with Microsoft Office formats, LibreOffice introduces an additional `loext:extrusion-metal-type` attribute. Its possible values are `MetalODF` and `MetalMSCompatible`. With value `MetalODF`, rendering uses the way specified in ODF. With value `MetalMSCompatible`, rendering uses the shape fill or extrusion color respectively instead of Gray. That is similar to rendering in MS Office. This attribute cannot be saved in ‘ODF 1.3’ file format, you must use ‘ODF 1.3 extended’. A document saved in ‘ODF 1.3’ will always display a shape with `draw:extrusion-metal=\"true\"` as if `loext:extrusion-metal-type=\"MetalODF\"` was set.\n\nYou can set surface ‘Metal ODF’ and ‘Metal MS compatible’ in the ‘Surface’ drop-down list in the ‘3D-_settings’ toolbar. These two entries replace the ‘Metal’ entry in versions prior to 7.4.\n\nThe ‘Metal MS compatible’ surface preset additionally sets the value for `draw:diffusion` to about 67%. This darkens the shape similar to rendering in MS Office.\n\n10 Custom Shapes in 3D\n\n10.6.6 Attributes draw:extrusion-metal and loext:extrusion-metal-type\n\nThe ‘Matt’ and ‘Plastic’ surface presets have no corresponding attribute in file format. The ‘Wire Frame’ preset is part of the \\texttt{dr3d:shade-mode} attribute.\n\n10.7 Rendering Quality\n\n10.7.1 Attribute \\texttt{dr3d:shade-mode}\n\nThe \\texttt{dr3d:shade-mode} attribute has the possible values \\texttt{draft}, \\texttt{flat}, \\texttt{gouraud} and \\texttt{phong}.\n\nThe \\texttt{draft} value is set, when you select the ‘Wire Frame’ surface preset. In this case, no surface is drawn, but the otherwise invisible lines are drawn as solid lines in the thickness and color set as shape properties. For curves, lines are drawn between the ends of the line segments created to interpolate the curve.\n\nThe \\texttt{flat} value is the default value. It is set, when you switch from ‘Wire Frame’ surface preset to any of the other surface presets or when a shape is newly created and extruded.\n\nThere is no user interface to set the values \\texttt{gouraud} and \\texttt{phong}. They require to calculate of interpolations for each point of an extruded face and therefore rendering is more expensive. If MS Office exports an extruded shape to ODF, it uses the \\texttt{gouraud} value. The \\texttt{gouraud} value is known as \\texttt{SMOOTH} in the API. In \\texttt{gouraud} mode, the faces are not rendered in a single color, but with gradients so that the color transitions between faces are smoother.\n\nFigure 118 shows how the shape at the right side is rendered if it is extruded.\n10 Custom Shapes in 3D\n\n10.7.1 Attribute dr3d:shade-mode\n\nIf an extrusion color is set, then LibreOffice treats the extruded facets internally as a separate drawing object. The rendering is more symmetrical in this case.\n\n10.7.2 Attribute draw:extrusion-number-of-line-segments\n\nThis attribute specifies the number of line segments, which have to be used to interpolate a curve. This attribute is not implemented in LibreOffice.\n\n10.8 Scene Lights\n\nRendering object surface and lighting of extruded shapes have changed significantly in LibreOffice 7.4. The descriptions here are of limited use for earlier versions.\n\nA 3D-scene of an extruded custom shape has three lights: one ambient light with no direction and two directional lights. Ambient light is reflected by every part of the surface of an object in the same extent, directional lights are only reflected with an amount that depends on the direction of the facets of the extruded shape in relation to the direction of the light. That is, the angle between the normal of the facet surface and direction of the light is taken into account. The most light is received when the reflected light is directed towards the observer.\n\n10.8.1 Attributes draw:extrusion-first-light-direction and draw:extrusion-second-light-direction\n\nNormally, the light rays of a directional light can be parallel or they start in a common point. The ODF format does not use the latter but has only parallel light rays.\n\nThe value of a direction attribute has the form \"(dx dy dz)\". Note that the separator is a space, not a comma. The components are not absolute values, only the ratio between them is relevant.\nValue \"(5 0 1)\" has the same meaning as value \"(50000 0 10000)\". The default direction for the first light source is \"(5 0 1)\", for the second light source \"(-5 0 1)\".\n\nThe upper part of the ‘Lighting’ tool in the ‘3D-Settings’ toolbar has nine buttons for setting a preset. The images show the direction of the first light, but the direction of the second light is automatically set as well. The directions used are listed in the table below. The values are the same values as used by MS Office in RTF or binary format. If you have set own values in the document source, you will have to set them again when you change the lighting direction using the toolbar.\n\n<table>\n<thead>\n<tr>\n<th>From</th>\n<th>First Light</th>\n<th>Second Light</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>top-left</td>\n<td>(-50000 -50000 10000)</td>\n<td>(50000 0 10000)</td>\n</tr>\n<tr>\n<td>top</td>\n<td>(0 -50000 10000)</td>\n<td>(0 50000 10000)</td>\n</tr>\n<tr>\n<td>top-right</td>\n<td>(50000 -50000 10000)</td>\n<td>(-50000 0 10000)</td>\n</tr>\n<tr>\n<td>left</td>\n<td>(-50000 0 10000)</td>\n<td>(50000 0 10000)</td>\n</tr>\n<tr>\n<td>center</td>\n<td>(0 0 10000)</td>\n<td>(0 0 10000)</td>\n</tr>\n<tr>\n<td>right</td>\n<td>(50000 0 10000)</td>\n<td>(-50000 0 10000)</td>\n</tr>\n<tr>\n<td>bottom-left</td>\n<td>(-50000 50000 10000)</td>\n<td>(50000 0 10000)</td>\n</tr>\n<tr>\n<td>bottom</td>\n<td>(0 50000 10000)</td>\n<td>(0 -50000 10000)</td>\n</tr>\n<tr>\n<td>bottom-right</td>\n<td>(50000 50000 10000)</td>\n<td>(-50000 0 10000)</td>\n</tr>\n</tbody>\n</table>\n\nThe implementation in LibreOffice versions prior to 7.4 used the wrong, opposite sign for the z-coordinate. This causes the light to fall on the shape from behind. To get around the fact that the shapes are much too dark as a result, an additional light with rays parallel to the z-axis coming from the observer was introduced. Since the lighting was corrected in version 7.4, the lighting of the old shapes looks different in version 7.4.\n\n10.8.2 Attribute `draw:extrusion-brightness`\n\nThe `draw:extrusion-brightness` attribute determines the amount of non-directional, ambient light. The values range from 0% to 100% with a default value of 33%. The ambient light is not colored light. LibreOffice multiplies the percent value with 255 and sets the result to all three channels of an RGB color, effectively setting a degree of Gray. Example: For percent value 33%, LibreOffice calculates the value \\(0.33 \\cdot 255 = 84.15\\), rounds it to 84 and sets the color RGB(84,84,84).\n\n10.8.3 Attributes `draw:extrusion-first-light-level` and `draw:extrusion-second-light-level`\n\nThese attributes determine the amount of directional light. The values range from 0% to 100%. It is converted to a RGB color as described above. The default value is 66% for both light sources.\n\nThe ‘Bright’, ‘Normal’ and ‘Dim’ intensity presets in the ‘Lighting’ tool in the ‘3D-Settings’ toolbar set these values:\n10 Custom Shapes in 3D\n\n10.8.3 Attributes draw:extrusion-first-light-level and draw:extrusion-second-light-level\n\n- **‘Bright’**:\n \n - draw:extrusion-brightness=\"33%\"\n - draw:extrusion-first-light-level=\"66%\"\n - draw:extrusion-second-light-level=\"66%\"\n\n- **‘Normal’**:\n \n - draw:extrusion-brightness=\"15%\"\n - draw:extrusion-first-light-level=\"67%\"\n - draw:extrusion-second-light-level=\"37%\"\n\n- **‘Dim’**:\n \n - draw:extrusion-brightness=\"6%\"\n - draw:extrusion-first-light-level=\"79%\"\n - draw:extrusion-second-light-level=\"21%\"\n\nIf you have set own values in the document source, you will have to set them again when you change the light intensity using the toolbar.\n\n10.8.4 Attributes draw:extrusion-first-light-harsh and draw:extrusion-second-light-harsh\n\nThese attributes determine for the first and second light, respectively, whether it is a harsh or a soft light. The ODF specification leaves it up to implementations to determine how the light is softened. LibreOffice adds four light directions at a 60° angle to the original light direction and distributes some of the light amount to these additional lights. This satisfactorily emulates how MS Office uses a “soft” light. These additional lights are not included in the document source or shape properties, but are only used when rendering the shape. In default settings, the first light is always harsh. The second light is soft in ‘Bright’ and ‘Normal’ presets and harsh in ‘Dim’ preset.\n\nAll following examples use draw:extrusion-brightness=\"0%\", draw:extrusion-second-light-level=\"0%\" and draw:extrusion-first-light-level=\"100%\".\n\n\n\n*Figure 120: harsh vs. soft combined with specular vs. matte*\n\nAlthough a “soft” light is more diffuse than a “harsh” light, it still has a direction. That is different from ambient light, which has no direction.\n11 Mathematics\n\n11.1 Approximate Sine Curve by Cubic Bézier Curve.\n\nIn almost all cases it will not be possible to use a single Bézier curve for an entire function graph, but it will be a sequence of Bézier curves, each approximating a section of the function graph. So the more precise task is: Approximate a function graph over interval \\([a; b]\\) by a Bézier curve.\n\n1st requirement: The anchor points of the Bézier curve coincide with the points of the function graph at the edge of the interval.\n\n<table>\n<thead>\n<tr>\n<th>(\\text{general } f(x))</th>\n<th>([\\sin(x) \\text{ on } [-\\pi/2; \\pi/2]})</th>\n<th>([\\sin(x) \\text{ on } [0; \\pi/2]})</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>(P_0(a_0, f(a_0)))</td>\n<td>(P_0\\left(-\\frac{\\pi}{2}, 1\\right))</td>\n<td>(P_0(0, 0))</td>\n</tr>\n<tr>\n<td>(P_3(a_3, f(a_3)))</td>\n<td>(P_3\\left(\\frac{\\pi}{2}, 1\\right))</td>\n<td>(P_3\\left(\\frac{\\pi}{2}, 1\\right))</td>\n</tr>\n</tbody>\n</table>\n\n2nd requirement: The straight line through the control point and the anchor point is a tangent to the function graph.\n\nThe tangent line at the point \\(P(x_0, f(x_0))\\) generally has in the expression \\(t(x) = f'(x_0) \\cdot (x - x_0) + f(x_0)\\).\n\n<table>\n<thead>\n<tr>\n<th>(\\text{general } f(x))</th>\n<th>([\\sin(x) \\text{ on } [-\\pi/2; \\pi/2]})</th>\n<th>([\\sin(x) \\text{ on } [0; \\pi/2]})</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>(P_1(a_1, f'(a_0) \\cdot (a_1 - a_0) + f(a_0)))</td>\n<td>(P_1(c_1, -1))</td>\n<td>(P_1(d_1, d_1))</td>\n</tr>\n<tr>\n<td>(P_2(a_2, f'(a_3) \\cdot (a_2 - a_3) + f(a_3)))</td>\n<td>(P_2(c_2, 1))</td>\n<td>(P_2(d_2, 1))</td>\n</tr>\n</tbody>\n</table>\n\n3rd requirement: In the sequence of Bézier curves, one curve will touch the next. The transition should be smooth. Therefore, the Bézier curves are created so that their curvature at points \\(P_0\\) and \\(P_3\\) is the same as for the function.\n\nFor a function, the curvature (“kappa”) is calculated as \\(\\kappa_f = \\frac{f''(x)}{(1 + f'(x)^2)^{3/2}}\\)\n\nFor a Bézier curve it is \\(\\kappa_B(t) = \\frac{B_x'(t) \\cdot B_y''(t) - B_x''(t) \\cdot B_y'(t)}{((B_x'(t))^2 + (B_y'(t))^2)^{3/2}}\\)\n\nTherefore you have to solve \\(\\kappa_B(0) = \\kappa_f(a_0) \\land \\kappa_B(1) = \\kappa_f(a_3)\\). It is highly recommended to use a computer algebra system (CAS) for this.\n\nIn case “\\(\\sin(x) \\text{ on } [-\\pi/2; \\pi/2]\\)” we get the solutions \\(c_1 = -\\frac{\\pi}{2} + \\frac{2}{\\sqrt{3}}\\) and \\(c_2 = \\frac{\\pi}{2} - \\frac{2}{\\sqrt{3}} = -c_1\\).\n\nA table of values shows that the maximum deviation of the y-values between Bézier curve and sine curve is less than 0.00234623573828.\n\nIn case “\\(\\sin(x) \\text{ on } [0; \\pi/2]\\)” we get the solutions \\(d_1 = \\frac{3}{2} \\pi - \\frac{3}{8} \\pi^2 - \\frac{1}{2} \\approx 0.511287329976\\) and \\(d_2 = 1\\).\n\nThis results in a maximal deviation of less than 0.000580425227085. Even using the rounded values \\(P_1(0.5|0.5)\\) only results a maximal deviation of less than 0.000748891084773.\nIn other context, other third requirements may be useful instead of curvature, such as considering average or maximal deviation.\n\nThere is a lot of literature on Bézier curves. For starters, “A Primer on Bézier Curves” might be useful.\n\n### 11.2 Mathematics for Tangents of Ellipses\n\nThe tangents through a point B outside the circle touch the circle at points S and R. The straight line through points R and S is the ‘polar’ to ‘pole’ B.\n\nThis chapter contains a method to calculate the points of contact S and R and angles associated with these points. Section 11.2.4 discusses how to solve a similar problem for an ellipse. If you search for the terms ‘pole’ and ‘polar’ you will find some more methods.\n\nThe following calculations and figures show the case where point B lies below the center of the circle. Formulas for positions above the center can be derived by mirroring.\n\nThe formulas already take into account the coordinates of the center of the circle. Instead, you can translate the drawing so that the center is at the origin, and first determine the solution for it. Afterwards you move it back.\n\n#### 11.2.1 Tangents to the Circle in General\n\n\n\nThe points S and R belong to the circle with center M, which gives the equation\n\n\\[\n(x - x_M)^2 + (y - y_M)^2 = r^2\n\\]\n\nThe triangles MSB and MBR are right triangles and so we get the equation\n\n49 [https://pomax.github.io/bezierinfo/](https://pomax.github.io/bezierinfo/) [called 2021-09-13]\n\\[ |MB|^2 = (x_B-x_M)^2 + (y_B-y_M)^2 \\] and then \\[ k = |SB| = |RB| = \\sqrt{|MB|^2 - r^2} = \\sqrt{(x_B-x_M)^2 + (y_B-y_M)^2 - r^2}. \\]\n\nSince the point B is outside the circle, the radicand is never negative.\n\nDepending on the task, you may need the Cartesian coordinates \\((x_R, y_R)\\) of a point of contact or the associated angle \\(\\gamma\\) or both. Calculating one from the other is the well-known problem of converting between Cartesian and polar coordinates. If the angle \\(\\gamma\\) is known, the Cartesian coordinates are \\((r \\cdot \\cos(\\gamma), x_M)\\) \\(\\frac{r}{2} \\cdot \\sin(\\gamma) + y_M\\) and from known coordinates \\((x_R, y_R)\\) the angle can be calculated by \\(\\gamma = \\text{atan2}(y_R - y_M, x_R - x_M)\\).\n\n### 11.2.2 Coordinates for Points of Contact\n\nThe coordinates of points S and R are (using a CAS)\n\n\\[\n\\begin{align*}\n x_S &= \\frac{r}{|MB|^2} \\cdot \\left( r \\cdot (x_B - x_M) + (y_B - y_M) \\cdot k \\right) \\cdot x_M \\\\\n y_S &= \\frac{r}{|MB|^2} \\cdot \\left( r \\cdot (y_B - y_M) - (x_B - x_M) \\cdot k \\right) \\cdot y_M \\\\\n x_R &= \\frac{r}{|MB|^2} \\cdot \\left( r \\cdot (x_B - x_M) - (y_B - y_M) \\cdot k \\right) \\cdot x_M \\\\\n y_R &= \\frac{r}{|MB|^2} \\cdot \\left( r \\cdot (y_B - y_M) + (x_B - x_M) \\cdot k \\right) \\cdot y_M\n\\end{align*}\n\\]\n\nThe formulas are unwieldy in the general case. But they can be simplified in some special cases.\n\nFor the special case \\(x_B = x_M\\) the formulas can be reduced and you get \\(|MB|^2 = (y_B - y_M)^2\\) and \\(k = \\sqrt{(y_B - y_M)^2 - r^2}\\).\n\n\\[\n\\begin{align*}\n x_S &= \\frac{r}{y_B - y_M} \\cdot \\sqrt{(y_B - y_M)^2 - r^2} \\cdot x_M \\quad \\text{and} \\quad y_S = \\frac{r}{y_B - y_M} \\cdot r + y_M \\\\\n x_R &= \\frac{r}{y_B - y_M} \\cdot \\left( -\\sqrt{(y_B - y_M)^2 - r^2} \\right) \\cdot x_M \\quad \\text{and} \\quad y_R = \\frac{r}{y_B - y_M} \\cdot r + y_M\n\\end{align*}\n\\]\n\nIn special case \\(x_B = x_M + r\\), that is, when the tangent is parallel to the y-axis, the point S has coordinates \\((x_M + r \\mid y_M)\\) and the point R has coordinates\n\n\\[\n\\begin{align*}\n x_R &= \\frac{r}{r^2 + (y_B - y_M)^2} \\cdot \\left( r^2 - (y_B - y_M)^2 \\right) \\cdot x_M \\quad \\text{and} \\quad y_R = \\frac{r}{r^2 + (y_B - y_M)^2} \\cdot 2r \\cdot (y_B - y_M) + y_M\n\\end{align*}\n\\]\n\nAnalogous, in special case \\(x_B = x_M - r\\), point R has coordinates \\((x_M - r \\mid y_M)\\) and S has coordinates\n\n\\[\n\\begin{align*}\n x_S &= \\frac{r}{r^2 + (y_B - y_M)^2} \\cdot \\left( -r^2 + (y_B - y_M)^2 \\right) \\cdot x_M \\quad \\text{and} \\quad y_S = \\frac{r}{r^2 + (y_B - y_M)^2} \\cdot 2r \\cdot (y_B - y_M) + y_M\n\\end{align*}\n\\]\n11.2.3 Angles for Points of Contact\n\nPoint R is determined by $\\gamma = \\alpha + \\beta$, point S is determined by $\\omega = \\alpha - \\beta$\n\nWe need to calculate the angles $\\alpha$ and $\\beta$. The formula language in custom shapes has only atan2 as inverse trigonometric function.\n\nAngle $\\alpha$ is determined by point B, $\\alpha = \\text{atan2}(y_B - y_M, x_B - x_M)$.\n\nAngle $\\beta$ is determined by right triangle SBM or MBR, $\\beta = \\text{atan2}(k, r)$.\n\nIn special case $x_B = x_M + r$ you get $\\alpha = \\beta$ and so $\\gamma = 2 \\cdot \\beta$ and $\\omega = 360^\\circ$.\n\nIn special case $x_B = x_M - r$ you get $\\alpha + \\beta = 180^\\circ$ and so $\\gamma = 180^\\circ$ and $\\omega = 180^\\circ - 2 \\cdot \\beta$.\n\nIn special case $x_B = x_M$ you get $\\alpha = 90^\\circ$ and so $\\gamma = 90^\\circ + \\beta$ and $\\omega = 90^\\circ - \\beta$.\n\n11.2.4 Tangents to Ellipse\n\nTranslate the drawing so that the center of the ellipse is at the origin. Mirror on the x-axis if the pole is above the center of the ellipse.\n\nStretch the drawing so that the ellipse becomes a circle with semi-major axis of the ellipse as radius, keeping the center of the ellipse fixed. Note that the pole point C of the ellipse also moves and becomes a new point B to be a pole of the circle.\n\nIn most use cases, the direction in which to stretch is known. Case distinctions are then not necessary.\nYou can calculate the coordinates of point R and S first:\n\n1. Calculate the points of contact R and S of the tangents of the pole B with respect to the circle, as shown in the previous sections.\n\n2. Stretch back the drawing. This will move points R and S on the circle to points D and E on the ellipse. Mirror back if you mirrored in the beginning.\n\n3. Calculate the angles $\\delta$ and $\\epsilon$ from the point coordinates of points D and E using the function atan2 if you need angles in addition.\n\n4. Translate the drawing back to the original position.\n\nOr you calculate the angles $\\alpha$ and $\\omega$ first:\n\n1. Calculate the angles $\\alpha$ and $\\omega$ for pole B with respect to the circle, as shown in the previous sections.\n\n2. Mirror back if you have mirrored in the beginning.\n\n3. Calculate the angles $\\delta$ and $\\epsilon$ using “de La Hire's point construction”\\(^{50}\\) for an ellipse.\n\n\\(^{50}\\) [https://en.wikipedia.org/wiki/Ellipse#Drawing_ellipses](https://en.wikipedia.org/wiki/Ellipse#Drawing_ellipses)\nThe angle \\( \\delta \\) is then obtained from the Cartesian coordinates of point \\( D \\):\n\n\\[\n\\delta = \\text{atan2}\\left( hR \\cdot \\sin(\\gamma), wR \\cdot \\cos(\\gamma) \\right)\n\\]\n\nThe calculation for angle \\( \\varepsilon \\) is then analogous.\n\n\\[\n\\varepsilon = \\text{atan2}\\left( hR \\cdot \\sin(\\omega), wR \\cdot \\cos(\\omega) \\right)\n\\]\n\n4. If you need the Cartesian coordinates of the points of contact, translate the drawing back to the original position.\n\n### 11.3 Skew Values for Oblique Parallel Projection\n\nLet us assume that the projection direction is determined by “4 right, 2 down, 3 towards observer”.\n\n#### 11.3.1 Calculate Skew Values\n\nTo calculate the values for the draw:extrusion-skew attribute, we describe the direction by a vector in a right-handed coordinate system with y-axis up.\n\n\\[\n\\vec{b} = \\begin{pmatrix} b_x \\\\ b_y \\\\ b_z \\end{pmatrix}, \\text{ in the example } \\vec{b} = \\begin{pmatrix} 4 \\\\ -2 \\\\ 3 \\end{pmatrix}\n\\]\n\nWe now calculate the point \\( U(u_x|u_y|0) \\) on the xy-plane that is the image of the unit point \\( (0|0|1) \\) of the z-axis.\n\nFor this point we get the equation\n\n\\[\n\\begin{pmatrix} u_x \\\\ u_y \\\\ 0 \\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 1 \\end{pmatrix} + \\lambda \\cdot \\begin{pmatrix} b_x \\\\ b_y \\\\ b_z \\end{pmatrix}, \\text{ in the example } \\begin{pmatrix} u_x \\\\ u_y \\\\ 0 \\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 1 \\end{pmatrix} + \\lambda \\cdot \\begin{pmatrix} 4 \\\\ -2 \\\\ 3 \\end{pmatrix}.\n\\]\n\nIt has the solution\n\n\\[\n\\lambda = -\\frac{1}{b_z}, \\quad u_x = -\\frac{b_x}{b_z}, \\quad u_y = -\\frac{b_y}{b_z}, \\text{ in the example } \\lambda = -\\frac{1}{3}, \\quad u_x = -\\frac{4}{3}, \\quad u_y = \\frac{2}{3}.\n\\]\n\nWe exclude case \\( b_z = 0 \\), because the projection direction would be parallel to the xy-plane.\n\n\\[\nr = \\frac{1}{|b_z|} \\sqrt{b_x^2 + b_y^2} \\quad \\text{and} \\quad \\varphi = \\text{atan2}\\left( -\\frac{b_y}{b_z}; -\\frac{b_x}{b_z} \\right)\n\\]\nIn the example \\( r \\approx 1.4907 \\) and \\( \\varphi \\approx 2.677945 \\text{rad} \\approx 153.43495 \\text{deg} \\)\n\nIn case \\( b_x = 0 \\land b_y = 0 \\) atan2 is not defined. The projection direction would not be oblique, but orthogonal to the xy-plane. In this case we use \\( r = 0 \\) and \\( \\varphi = 0 \\).\n\n11.3.2 Construct Skew Values\n\nFirst, we look at the 3D-scene from top to bottom. The grid has 0.5 line spacing. For this view we need only the x-coordinate and the z-coordinate. The yellow arrow is the projection direction. The yellow straight line is parallel to the projection direction. This line meets the xy-plane in the x-coordinate \\( U_x \\).\n\nNow we look at the 3D-scene from right to left. For this view we only need the y-coordinate and the z-coordinate. The yellow arrow is again the projection direction. Again we construct a parallel straight line through the unit point of the z-axis. It intersects the xy-plane in y-coordinate \\( U_y \\).\n\nAs last step, we look on the 3D-scene from front to back and identify the point \\( U(U_x | U_y) \\). In fact, we get not only the point \\( U \\). We get the whole image of the z-axis and a scale on this image.\n\nNow you can measure the distance \\( r \\) and the angle \\( \\varphi \\).\n\n11.3.3 Construct the Projection of an Object\n\nLet’s take as an example an extruded rectangle with 6 cm width, 2 cm height and 2 cm depth. The front face lies in the xy-plane. The center of the rectangle is at the origin of the coordinate system. So the vertices of the front face are \\( A(-3|-1|0) \\), \\( B(3|-1|0) \\), \\( C(3|1|0) \\) and \\( D(-3|1|0) \\).\nThe back face lies behind the front face. So the back face has the vertices E(−3|−1|−2), F(3|−1|−2), G(3|1|−2) and H(−3|1|−2).\n\nThe solid purple rectangle is the front face, the dotted one is the back face. To get the point E, take a copy of the segment from 0 to −2 of the image of the z-axis and move it to the point A. Do the same for all points of the front face.\n\n### 11.4 Angles in Orthographic Projection\n\n#### 11.4.1 From Rotation Angles to Projection\n\nFirst, consider the example with attribute `draw:extrusion-rotation-angle=\"25 15\"`.\n\nA rotation of $25^\\circ$ around the x-axis corresponds to using 5 times “Tilt up”. The illustration shows this rotation in a view from right to left. This rotation is described by the matrix\n\n$$\nM_x = \\begin{pmatrix}\n1 & 0 & 0 \\\\\n0 & \\cos(25^\\circ) & -\\sin(25^\\circ) \\\\\n0 & \\sin(25^\\circ) & \\cos(25^\\circ)\n\\end{pmatrix}.\n$$\n\nA rotation of $15^\\circ$ around the y-axis corresponds to using 3 times “Tilt Left”. The illustration shows this rotation in a view from top to bottom. This rotation is described by the matrix\n\n$$\nM_y = \\begin{pmatrix}\n\\cos(15^\\circ) & 0 & -\\sin(15^\\circ) \\\\\n0 & 1 & 0 \\\\\n\\sin(15^\\circ) & 0 & \\cos(15^\\circ)\n\\end{pmatrix}.\n$$\n\nWe apply both rotations, first the rotation around the y-axis, then the rotation around the x-axis. So we get the total matrix\n\n$$\nM = M_x \\cdot M_y = \\begin{pmatrix}\n\\cos(15^\\circ) & 0 & -\\sin(15^\\circ) \\\\\n-\\sin(25^\\circ) \\cdot \\sin(15^\\circ) & \\cos(25^\\circ) & -\\sin(25^\\circ) \\cdot \\cos(15^\\circ) \\\\\n\\cos(25^\\circ) \\cdot \\sin(15^\\circ) & \\sin(25^\\circ) & \\cos(25^\\circ) \\cdot \\cos(15^\\circ)\n\\end{pmatrix}.\n$$\nMore generally, the rotation given by the \\texttt{draw:extrusion-rotation-angle=\"α β\"} attribute is described by the matrix\n\\[ M = M_x \\cdot M_y = \\begin{pmatrix} \\cos(β) & 0 & -\\sin(β) \\\\ -\\sin(α) \\cdot \\sin(β) & \\cos(α) & -\\sin(α) \\cdot \\cos(β) \\\\ \\cos(α) \\cdot \\sin(β) & \\sin(α) & \\cos(α) \\cdot \\cos(β) \\end{pmatrix}. \\]\n\nWe now look at the object in an orthogonal parallel projection in a front-to-back view. We determine the images of the three coordinate axis in this view. Differences in the \\( z \\)-coordinate are not visible, so we ignore the last row in the matrix. We find the coordinates of the images of the unit points of the axes as columns in the matrix\n\\[ \\begin{pmatrix} \\cos(β) & 0 & -\\sin(β) \\\\ -\\sin(α) \\cdot \\sin(β) & \\cos(α) & -\\sin(α) \\cdot \\cos(β) \\end{pmatrix}. \\]\n\nFor the above example, this is the matrix \\( \\begin{pmatrix} 0.97 & 0 & -0.26 \\\\ -0.11 & 0.91 & -0.41 \\end{pmatrix} \\) in rounded values.\n\nImage of point \\( (1|0|0) \\) of x-axis is \\( (0.97|-0.11) \\).\nImage of point \\( (0|1|0) \\) of y-axis is \\( (0|0.91) \\).\nImage of point \\( (0|0|1) \\) of z-axis is \\( (-0.26|-0.41) \\).\n\nThe illustration shows a cube with an edge length of 5 cm. The extrusion is behind the shape and the center of rotation is the center of the shape. The axis arrows are drawn so long that they would be 5 cm long in the 3D-scene. Note that the edges of the cube in the view are parallel to the images of the axes and the projected lengths of the cube correspond to the projected lengths of the axis arrows. Remember that in the two-dimensional view of the shape, the y-axis points downward.\n11.4.2 From Projection to Rotation Angles\n\nOrthographic projections are usually described in terms of the two-dimensional drawing by the angles to the horizontal x-axis and the reduction factors for axis units.\n\nRotation angle \\( \\alpha \\) and \\( \\beta \\) produce the images:\n\n\\[\n\\begin{align*}\n(1|0|0) & \\rightarrow U \\left( \\cos(\\beta) \\left| -\\sin(\\alpha) \\cdot \\sin(\\beta) \\right| \\right) \\\\\n(0|1|0) & \\rightarrow V \\left( \\left| 0 \\right| \\cos(\\alpha) \\right) \\\\\n(0|0|1) & \\rightarrow W \\left( -\\sin(\\beta) \\left| -\\sin(\\alpha) \\cdot \\cos(\\beta) \\right| \\right)\n\\end{align*}\n\\]\n\nThe “dimetric” projection requires angles of 7° and 42° according to ISO 5456-3. Using the approximated angels \\( \\alpha = -20^\\circ \\) and \\( \\beta = 20^\\circ \\) gives about \\( U(0.94|0.12) \\), \\( V(0|0.94) \\) and \\( W(-0.34|0.32) \\).\n\n\\[\n\\begin{align*}\n\\arctan \\left( \\frac{0.32}{0.34} \\right) & \\approx 43.219^\\circ \\\\\n\\arctan \\left( \\frac{0.12}{0.94} \\right) & \\approx 7.095^\\circ\n\\end{align*}\n\\]\n\nThis results in angles \\( \\arctan \\left( \\frac{0.32}{0.34} \\right) \\approx 43.219^\\circ \\) and \\( \\arctan \\left( \\frac{0.12}{0.94} \\right) \\approx 7.095^\\circ \\).\n\nSo to get 7° and 42° we need:\n\n\\[\n\\frac{-\\sin(\\alpha) \\cdot \\cos(\\beta)}{-(-\\sin(\\beta))} = \\tan(42^\\circ) \\quad \\text{and} \\quad \\frac{-\\sin(\\alpha) \\cdot \\sin(\\beta)}{\\cos(\\beta)} = \\tan(7^\\circ)\n\\]\n\nSimplify these equations and you get:\n\n\\[\n\\frac{-\\sin(\\alpha)}{\\tan(\\beta)} = \\tan(42^\\circ) \\quad \\text{and} \\quad -\\sin(\\alpha) \\cdot \\tan(\\beta) = \\tan(7^\\circ)\n\\]\n\nand then \\( \\sin(\\alpha) = -\\tan(42^\\circ) \\cdot \\tan(\\beta) \\) and \\( \\left| \\tan(\\beta) \\right|^2 = \\frac{\\tan(7^\\circ)}{\\tan(42^\\circ)} \\).\n\nFinally, since we already know that \\( \\beta > 0 \\) and \\( \\alpha < 0 \\), we get.\n\\( \\beta = \\arctan \\left( \\frac{\\tan(7^\\circ)}{\\tan(42^\\circ)} \\right) \\approx 20.2680671953^\\circ \\) and\n\n\\( \\alpha = \\arcsin \\left( -\\tan(42^\\circ) \\cdot \\sqrt{\\frac{\\tan(7^\\circ)}{\\tan(42^\\circ)}} \\right) = -19.4205368891^\\circ. \\)\n\nThe \"isometric\" projection requires angles of 30° and 30° in the 2D drawing. We obtain the necessary 3D rotation angles in a similar way as for the \"dimetric\" projection.\n\n\\( \\beta = \\arctan \\left( \\frac{\\tan(30^\\circ)}{\\tan(30^\\circ)} \\right) = 45^\\circ \\) and \\( \\alpha = \\arcsin \\left( -\\tan(30^\\circ) \\cdot 1 \\right) \\approx -35.2643896828^\\circ \\)\n12 Indexes\n\n12.1 Figures\n\n2.1.2 Figure 1: Locale coordinate system ................................................................. 11\n2.1.3 Figure 2: Triangle in local coordinate system .................................................. 12\n2.2 Figure 3: Desired shape ..................................................................................... 13\n2.2 Figure 4: Desires shape in coordinate system .................................................... 13\n2.3 Figure 5: Wrong text area ................................................................................. 15\n2.3 Figure 6: Desired text area ................................................................................ 15\n2.3 Figure 7: Negative position of left edge of text area ......................................... 16\n2.3 Figure 8: Text in rotated shape ......................................................................... 16\n2.3 Figure 9: Rotated shape with additional rotation of text area .......................... 17\n2.4 Figure 10: Wrong glue points .......................................................................... 17\n2.5.1 Figure 11: User defined page size ................................................................. 18\n2.5.1 Figure 12: Page margins ................................................................................ 18\n2.5.2 Figure 13: Snap-rectangle ........................................................................... 19\n2.5.2 Figure 14: Status bar ..................................................................................... 19\n2.5.2 Figure 15: 'Position and Size' dialog .............................................................. 20\n2.5.4 Figure 16: Local coordinate system of the shape .......................................... 21\n2.6.2 Figure 17: Rhombus ....................................................................................... 22\n3.1 Figure 18: Custom shape with handle ............................................................... 24\n3.1 Figure 19: Fields for position of handles ........................................................... 25\n3.2 Figure 20: Desired text-area is hatched ............................................................... 26\n3.3 Figure 21: Parallelogram with vertical edge-movement ..................................... 28\n3.4 Figure 22: Parallelogram with fix base length .................................................. 28\n3.4 Figure 23: Spacing in wrap properties ............................................................... 29\n3.4 Figure 24: Wrap spacing top 2 cm .................................................................. 29\n3.4 Figure 25: no wrap spacing ............................................................................... 29\n3.4 Figure 26: Fit to Cell Size ................................................................................ 29\n3.5 Figure 27: Thales' half circle ............................................................................ 30\n3.5 Figure 28: Full Thales' circle .......................................................................... 31\n3.8.3 Figure 29: Triangle for Pythagoras' theorem ................................................ 33\n3.8.4 Figure 30: height of parallelogram = height of snap-rectangle ..................... 34\n4.2 Figure 31: Start of command X ....................................................................... 37\n4.2 Figure 32: Elliptic arc with 90deg center angle ................................................ 38\n4.2 Figure 33: Quadrant of a circle ....................................................................... 38\n4.3 Figure 34: Forced X direction .......................................................................... 39\n4.3 Figure 35: Automatic X Y toggle ................................................................... 39\n4.3 Figure 36: Heart ............................................................................................... 39\n4.3 Figure 37: Diamond with circle ...................................................................... 39\n5.1 Figure 38: Path with two commands X ............................................................ 42\n5.1 Figure 39: Orientated arc with associated sector ............................................. 42\n5.1 Figure 40: Sector in front of arc ....................................................................... 43\n5.2.1 Figure 41: Example even-odd filling rule ..................................................... 44\n5.2.1 Figure 42: Triangles hatched for counting involved areas .......................... 44\n5.2.1 Figure 43: Odd number of involved areas ..................................................... 44\n5.2.2 Figure 44: Even number of involved areas ................................................... 44\n5.2.2 Figure 45: Stacked filled areas .................................................................... 45\n5.2.2 Figure 46: Stacked filled areas with transparency ..............................................................45\n5.3 Figure 47: Bounding box for triangle ..................................................................................46\n5.3 Figure 48: Rectangle equal to bounding box with same filling as shape ..........................46\n5.3 Figure 49: Gradient with even-odd filling and with stacked areas .................................46\n5.3 Figure 50: expected rendering if draw:concentric-gradient-fill-allowed=\"true\" ..........46\n5.4 Figure 51: Light and Darken ............................................................................................47\n5.4 Figure 52: Without darken or lighten ................................................................................47\n5.5.1 Figure 53: Yin-Yang exercise solution .........................................................................48\n5.5.2 Figure 54: First set with even-odd filling ......................................................................48\n5.5.2 Figure 55: Last set with even-odd filling ......................................................................48\n6.3 Figure 56: Points of a Bézier curve ..................................................................................50\n6.3.1 Figure 57: Easter egg created as path object .................................................................51\n6.3.1 Figure 58: Spreadsheet to calculate coordinates for the enhanced-path and document it 51\n6.3.1 Figure 59: Finished Easter egg as custom shape .............................................................52\n6.3.2 Figure 60: Sine curve on interval \\([0;\\pi/2]\\) ....................................................................52\n6.3.2 Figure 61: Sine curve on interval \\([-\\pi/2;\\pi/2]\\) .................................................................53\n6.3.2 Figure 62: Transformation of 'world' coordinates to shape local coordinates ............53\n6.3.2 Figure 63: Sine curve segment ......................................................................................54\n6.4.2 Figure 64: Exercise solution long sine curve by duplicating the shape .........................56\n7.1 Figure 65: Desired and actual result for making a group higher ....................................57\n7.1 Figure 66: First idea: rectangle with fixed height inside a larger shape ..........................57\n7.1 Figure 67: Drag handles of shape H ................................................................................58\n7.1 Figure 68: Resized group with fixed heading rectangle ....................................................59\n7.2 Figure 69: Rectangle with cut corner ...............................................................................60\n7.2 Figure 70: Angle changes if width or height changes .......................................................60\n7.2 Figure 71: Grid on square shape with same unit on both axes ........................................60\n7.2 Figure 72: Different units on axes ....................................................................................60\n7.2 Figure 73: Needed adaption for changed width or height ...............................................61\n7.2 Figure 74: Need for restricting the range for handle movement .......................................61\n7.3 Figure 75: Equilateral triangle inside the snap rectangle of the shape ............................62\n7.3 Figure 76: ‘world’ coordinate system for equilateral triangle .........................................62\n7.3 Figure 77: Square centered in snap rectangle of the shape ............................................63\n7.4 Figure 78: Thales’ half circle .............................................................................................63\n7.4 Figure 79: Right triangle aligned with bottom of the shape ............................................64\n7.6.3 Figure 80: Square in “world” coordinate system ..........................................................67\n8.1 Figure 81: Command A ....................................................................................................69\n8.1 Figure 82: Command B ....................................................................................................70\n8.1 Figure 83: Command V ....................................................................................................70\n8.1 Figure 84: Command W ....................................................................................................71\n8.2 Figure 85: Parameters of commands T and U .................................................................72\n8.2 Figure 86: compare commands T or Y with command U in regard to arrowhead ..........73\n8.2 Figure 87: Arc with handle for start and for end point .....................................................74\n8.3 Figure 88: Parameters of command G .............................................................................75\n8.3 Figure 89: \"wave\" shape .................................................................................................75\n8.3 Figure 90: Circles used for \"wave\" shape ........................................................................76\n8.3 Figure 91: \"wave\" shape, overview of involved angles .......................................................76\n8.4 Figure 92: Heart – first, not appealing version .................................................................77\n8.4 Figure 93: Heart with smooth transition, filled and unfilled ..........................................77\n8.4 Figure 94: Heart – tangent ...............................................................................................77\nIndexes\n\n8.4 Figure 95: Design a heart with smooth transition ................................................. 77\n8.5 Figure 96: Cone ................................................................................................. 78\n8.5 Figure 97: cone with surface line in various positions ....................................... 79\n9.1 Figure 98: Predefined Fontwork shapes in LibreOffice ..................................... 87\n9.1 Figure 99: Fontwork Same Letter Heights .......................................................... 88\n9.2 Figure 100: Compare normal shape with same shape with text path enabled .... 89\n9.2 Figure 101: Underlying path in 'Fontwork' shape ............................................. 89\n9.3.1 Figure 102: Shape consisting of two circle arcs ........................................... 90\n9.3.2 Figure 103: text-path-scale value 'path' ......................................................... 91\n9.3.3 Figure 104: text-path-scale value 'shape' with two paragraphs ..................... 91\n9.3.3 Figure 105: Rendering of multi-line text on a curve ..................................... 92\n9.4 Figure 106: 'Ring' shape made in PowerPoint ..................................................... 94\n9.5 Figure 107: Odd number of sub-paths ............................................................... 95\n9.5 Figure 108: Even number of sub-paths ............................................................. 95\n9.7.1 Figure 109: Text on Fibonacci spiral ............................................................. 96\n9.7.2 Figure 110: Text on arc with handle and scale 'path' ..................................... 97\n9.7.3 Figure 111: font size increased to fit the ellipse .......................................... 97\n9.7.3 Figure 112: only increased height ................................................................. 97\n10.4.1 Figure 113: Rotated shape with different extrusion positions ....................... 100\n10.6.3 Figure 114: Diffusion ..................................................................................... 108\n10.6.4 Figure 115: Shininess .................................................................................... 108\n10.6.6 Figure 116: Several values of attribute draw:extrusion-specularity ............... 109\n10.6.6 Figure 117: Rendering with and without surface Metal ............................... 110\n10.7.1 Figure 118: shade mode variants with no extrusion color ......................... 111\n10.7.1 Figure 119: shade mode variants with blue extrusion color ....................... 111\n10.8.4 Figure 120: harsh vs. soft combined with specular vs. matte ..................... 113\n11.2.1 Figure 121: Tangents to the Circle ............................................................... 115\n11.2.3 Figure 122: Illustration of tangents to circle including angles ..................... 117\n11.2.4 Figure 123: Relationship between tangents to circle and to ellipse ............. 118\n11.2.4 Figure 124: De La Hire’s point construction for an ellipse ......................... 119\n12.2 Tables\n\n2.5.3 Table 1: Example of manual mapping of snap-rectangle to locale coordinate system........20\n3.5 Table 2: Available functions for attribute draw:formula..................................................30\n3.8.6 Table 3: Translate conditions to formula language.....................................................35\n4.2 Table 4: Description of commands X and Y.................................................................37\n5.1 Table 5: Description of commands F and S.................................................................43\n5.1 Table 6: Description of command N...........................................................................43\n6.2 Table 7: Description of Command Q...........................................................................49\n6.3 Table 8: Description of command C............................................................................50\n7.1 Table 9: Description of identifiers logheight and logwidth............................................57\n8.1 Table 10: Description for Commands A, B, V and W...................................................69\n8.2 Table 11: Description of Commands T and U...............................................................72\n8.3 Table 12: Description of the command G.....................................................................75\n9.3.1 Table 13: Different font sizes rendered by text-path-scale attribute value 'shape'.........90\n9.4 Table 14: Examples for text rendering with two sub-paths..........................................92\n9.4 Table 15: Examples for text rendering depending on path direction and order..............94\n9.5 Table 16: 'Arch Up' shape in variants 'Curve' and 'Pour'.............................................95\n12.3 Index of Elements, Attributes and Path Commands\n\nA........................................................................................................................................................................... 69\nB........................................................................................................................................................................... 69\nC........................................................................................................................................................................... 49\ndr3d:projection................................................................. 101\ndr3d:shade-mode........................................................................ 110\ndraw:concentric-gradient-fill-allowed................................................................. 46\ndraw:enhanced-geometry........................................................................... 10\ndraw:enhanced-path............................................................................... 10\ndraw:equation...................................................................................... 26\ndraw:extrusion..................................................................................... 98\ndraw:extrusion-allowed........................................................................ 98\ndraw:extrusion-brightness.................................................................... 112\ndraw:extrusion-color........................................................................... 107\ndraw:extrusion-depth........................................................................... 99\ndraw:extrusion-diffusion....................................................................... 107\ndraw:extrusion-first-light-direction............................................................. 111\ndraw:extrusion-first-light-harsh................................................................. 113\ndraw:extrusion-first-light-level................................................................ 112\ndraw:extrusion-light-face........................................................................ 107\ndraw:extrusion-metal........................................................................... 109\ndraw:extrusion-number-of-line-segments.............................................. 111\ndraw:extrusion-origin........................................................................... 102\ndraw:extrusion-rotation-angle................................................................. 100\ndraw:extrusion-rotation-center................................................................. 100\ndraw:extrusion-second-light-direction..................................................... 111\ndraw:extrusion-second-light-harsh............................................................. 113\ndraw:extrusion-second-light-level............................................................ 112\ndraw:extrusion-shininess....................................................................... 108\ndraw:extrusion-skew............................................................................ 104\ndraw:extrusion-specularity.................................................................... 108\ndraw:extrusion-viewpoint...................................................................... 102\ndraw:formula...................................................................................... 26\ndraw:glue-point-leaving-directions............................................................. 18\ndraw:glue-point-type............................................................................. 18\ndraw:glue-points.................................................................................... 10, 17\ndraw:handle......................................................................................... 24\ndraw:handle-mirror-horizontal............................................................... 33\ndraw:handle-mirror-vertical................................................................... 33\ndraw:handle-polar.................................................................................. 31\ndraw:handle-position............................................................................ 24, 32\ndraw:handle-radius-range-maximum...................................................... 32\ndraw:handle-radius-range-minimum....................................................... 32\ndraw:handle-range-x-maximum............................................................... 27\ndraw:handle-range-x-minimum............................................................... 27\ndraw:handle-range-y-maximum............................................................... 27\ndraw:handle-range-y-minimum............................................................... 27\ndraw:handle-switched............................................................................ 33\n<table>\n<thead>\n<tr>\n<th>draw:layer</th>\n<th>..........................................................</th>\n<th>.9</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>draw:mirror-horizontal</td>\n<td>..................................................................</td>\n<td>10</td>\n</tr>\n<tr>\n<td>draw:mirror-vertical</td>\n<td>..................................................................</td>\n<td>10</td>\n</tr>\n<tr>\n<td>draw:modifiers</td>\n<td>..................................................................</td>\n<td>25</td>\n</tr>\n<tr>\n<td>draw:name</td>\n<td>..................................................................</td>\n<td>26</td>\n</tr>\n<tr>\n<td>draw:path-stretchpoint-x</td>\n<td>..................................................................</td>\n<td>65</td>\n</tr>\n<tr>\n<td>draw:path-stretchpoint-y</td>\n<td>..................................................................</td>\n<td>65</td>\n</tr>\n<tr>\n<td>draw:secondary-fill-color</td>\n<td>..................................................................</td>\n<td>107</td>\n</tr>\n<tr>\n<td>draw:style-name</td>\n<td>..................................................................</td>\n<td>.9</td>\n</tr>\n<tr>\n<td>draw:text-areas</td>\n<td>..................................................................</td>\n<td>10, 15</td>\n</tr>\n<tr>\n<td>draw:text-path</td>\n<td>..................................................................</td>\n<td>87</td>\n</tr>\n<tr>\n<td>draw:text-path-allowed</td>\n<td>..................................................................</td>\n<td>87</td>\n</tr>\n<tr>\n<td>draw:text-path-mode</td>\n<td>..................................................................</td>\n<td>88</td>\n</tr>\n<tr>\n<td>draw:text-path-same-letter-heights</td>\n<td>..................................................................</td>\n<td>88</td>\n</tr>\n<tr>\n<td>draw:text-path-scale</td>\n<td>..................................................................</td>\n<td>88</td>\n</tr>\n<tr>\n<td>draw:text-rotate-angle</td>\n<td>..................................................................</td>\n<td>16</td>\n</tr>\n<tr>\n<td>draw:text-style-name</td>\n<td>..................................................................</td>\n<td>.9</td>\n</tr>\n<tr>\n<td>draw:textarea-horizontal-align</td>\n<td>..................................................................</td>\n<td>96</td>\n</tr>\n<tr>\n<td>draw:transform</td>\n<td>..................................................................</td>\n<td>.9</td>\n</tr>\n<tr>\n<td>draw:type</td>\n<td>..................................................................</td>\n<td>10</td>\n</tr>\n<tr>\n<td>draw:wooo:enhanced-path</td>\n<td>..................................................................</td>\n<td>47</td>\n</tr>\n<tr>\n<td>even-odd</td>\n<td>..................................................................</td>\n<td>43</td>\n</tr>\n<tr>\n<td>F.</td>\n<td>..................................................................</td>\n<td>43</td>\n</tr>\n<tr>\n<td>G.</td>\n<td>..................................................................</td>\n<td>75</td>\n</tr>\n<tr>\n<td>H.</td>\n<td>..................................................................</td>\n<td>47</td>\n</tr>\n<tr>\n<td>height</td>\n<td>..................................................................</td>\n<td>62</td>\n</tr>\n<tr>\n<td>I.</td>\n<td>..................................................................</td>\n<td>47</td>\n</tr>\n<tr>\n<td>J.</td>\n<td>..................................................................</td>\n<td>47</td>\n</tr>\n<tr>\n<td>K.</td>\n<td>..................................................................</td>\n<td>47</td>\n</tr>\n<tr>\n<td>L.</td>\n<td>..................................................................</td>\n<td>11</td>\n</tr>\n<tr>\n<td>loext:extrusion-metal-type</td>\n<td>..................................................................</td>\n<td>109</td>\n</tr>\n<tr>\n<td>logwidth</td>\n<td>..................................................................</td>\n<td>57</td>\n</tr>\n<tr>\n<td>M.</td>\n<td>..................................................................</td>\n<td>11</td>\n</tr>\n<tr>\n<td>N.</td>\n<td>..................................................................</td>\n<td>11</td>\n</tr>\n<tr>\n<td>Q.</td>\n<td>..................................................................</td>\n<td>49</td>\n</tr>\n<tr>\n<td>S.</td>\n<td>..................................................................</td>\n<td>43</td>\n</tr>\n<tr>\n<td>svg:height</td>\n<td>..................................................................</td>\n<td>.9</td>\n</tr>\n<tr>\n<td>svg:viewBox</td>\n<td>..................................................................</td>\n<td>10, 18</td>\n</tr>\n<tr>\n<td>svg:width</td>\n<td>..................................................................</td>\n<td>.9</td>\n</tr>\n<tr>\n<td>svg:x</td>\n<td>..................................................................</td>\n<td>.9</td>\n</tr>\n<tr>\n<td>svg:y</td>\n<td>..................................................................</td>\n<td>.9</td>\n</tr>\n<tr>\n<td>T.</td>\n<td>..................................................................</td>\n<td>72</td>\n</tr>\n<tr>\n<td>U.</td>\n<td>..................................................................</td>\n<td>72</td>\n</tr>\n<tr>\n<td>V.</td>\n<td>..................................................................</td>\n<td>69</td>\n</tr>\n<tr>\n<td>W.</td>\n<td>..................................................................</td>\n<td>69</td>\n</tr>\n<tr>\n<td>width</td>\n<td>..................................................................</td>\n<td>62</td>\n</tr>\n<tr>\n<td>X.</td>\n<td>..................................................................</td>\n<td>37</td>\n</tr>\n<tr>\n<td>Y.</td>\n<td>..................................................................</td>\n<td>37</td>\n</tr>\n<tr>\n<td>Z.</td>\n<td>..................................................................</td>\n<td>11</td>\n</tr>\n</tbody>\n</table>\nTip: An alphabetic index as above, does not allow hyperlinks. You can use the tool ‘Go to page’ instead. It is available in the Navigator in the side bar or via short-cut Ctrl+G."}}},{"rowIdx":299,"cells":{"id":{"kind":"string","value":"9db939507b5add1c3efb79a74cc9a4889236d1c9"},"text":{"kind":"string","value":"7-2016\n\nOn Abstract Modular Inference Systems and Solvers\n\nYuliya Lierler \n*University of Nebraska at Omaha, ylierler@unomaha.edu*\n\nMiroslaw Truszczynski \n*University of Kentucky*\n\nFollow this and additional works at: https://digitalcommons.unomaha.edu/compscifacpub\n\nRecommended Citation\n\nLierler, Yuliya and Truszczynski, Miroslaw, \"On Abstract Modular Inference Systems and Solvers\" (2016). Computer Science Faculty Publications. 22. \nhttps://digitalcommons.unomaha.edu/compscifacpub/22\nOn abstract modular inference systems and solvers ✩\n\nYuliya Lierler a,⁎, Miroslaw Truszczynski b,⁎\n\na Department of Computer Science, University of Nebraska at Omaha, Omaha, NE 68182, USA\nb Department of Computer Science, University of Kentucky, Lexington, KY 40506-0633, USA\n\nABSTRACT\n\nIntegrating diverse formalisms into modular knowledge representation systems offers increased expressivity, modeling convenience, and computational benefits. We introduce the concepts of abstract inference modules and abstract modular inference systems to study general principles behind the design and analysis of model generating programs, or solvers, for integrated multi-logic systems. We show how modules and modular systems give rise to transition graphs, which are a natural and convenient representation of solvers, an idea pioneered by the SAT community. These graphs lend themselves well to extensions that capture such important solver design features as learning. In the paper, we consider two flavors of learning for modular formalisms, local and global. We illustrate our approach by showing how it applies to answer set programming, propositional logic, multi-logic systems based on these two formalisms and, more generally, to satisfiability modulo theories.\n\n© 2016 The Authors. Published by Elsevier B.V. This is an open access article under the CC BY license (http://creativecommons.org/licenses/by/4.0/).\n\n1. Introduction\n\nKnowledge representation and reasoning (KR&R) is concerned with developing formal languages and logics to model knowledge, and with designing and implementing corresponding automated reasoning tools. The choice of specific logics and tools depends on the type of knowledge to be represented and reasoned about. Different logics are suitable for common-sense reasoning, reasoning under incomplete information and uncertainty, for temporal and spatial reasoning, and for modeling and solving Boolean constraints, or constraints over larger, even continuous domains. In applications in areas such as distributed databases, semantic web, hybrid constraint modeling and solving, to name just a few, several of these aspects come into play. Accordingly, often diverse logics have to be accommodated together.\n\nModeling convenience is not the only reason why diverse logics are combined into modular hybrid KR&R systems. Another motivation is to exploit in reasoning the transparent structure that comes from modularity, computational strengths of individual logics, and synergies that arise when they are put together. An early example of a successful integration of different types of reasoning is constraint logic programming (CLP) [28,29], which exploited computational properties of different theories of constraints in a formalism centered around logic programming. About two decades later a similar idea appeared in the area of propositional satisfiability. The resulting approach, known as satisfiability modulo theories (SMT) [49,4], consists of integrating diverse constraint theories around the “core” provided by propositional satisfiability. SMT solvers are currently among the most efficient automated reasoning tools and are widely used for computer-aided software verification [10]. Another, more recent example is constraint answer set programming (CASP) [45,20,2,31,35] that integrates answer set...\nprogramming (ASP) [42,47] with constraint modeling and solving [51]. These approaches do not impose any strong \\textit{a priori} restrictions on the constraint theories they allow. However, some types of theories are particularly heavily studied (for instance, equality with uninterpreted functions, forms of arithmetic, arrays). Finally, more focused hybrid systems that combine modules expressed in classical logic with modules given as answer set programs have also received substantial attention lately. Examples include the “multi-logics” PC(ID) [43], SM(ASP) [36] and ASP-FO [11].\n\nThese multi-logic modular integrations facilitate modeling but also often lead to enormous performance gains. A good example is the problem of existence of Hamiltonian cycles in graphs. Known propositional logic encodings require that counter variables be used to represent reachability. That leads to representations of large sizes. Using propositional logic to represent non-recursive constraints and logic programs to represent reachability (which is much more direct than a counter-based propositional encoding) leads to concise encodings. East and Truszczynski [13] demonstrated that the performance of SAT solvers on propositional encodings of the problem lags dramatically behind that of the solver asps, designed for handling together propositional and logic program modules on hybrid representations of the problem.\n\nThe “computational” motivation behind modular KR&R underlies our paper.\n\nThe key computational task arising in KR&R is that of \\textit{model generation}. Model Generating programs, or solvers, developed in satisfiability (SAT) and ASP proved to be effective in a broad range of KR&R applications. Accordingly, model generation is of critical importance in modular multi-logic systems. Research on formalisms listed above resulted in fast solvers that demonstrate substantial gains that one can obtain from their heterogeneous nature. However, the diversity of logics considered and low-level technical details of their syntax and semantics obscure general principles that are important in the design and analysis of solvers for multi-logic systems.\n\nIn this paper, we address this problem by proposing a language for representing modular multi-logic systems that aims to provide a general abstract view on solvers, to bring up key principles behind solver design, and to facilitate studies of their properties. As we are not concerned with the modeling aspect of a KR&R system but with solving, we design our language so that it (i) abstracts away the syntactic details, (ii) can capture diverse concepts of inference, and (iii) is based only on the weakest assumptions concerning the semantics of underlying logics, in particular, this language can capture any formalism whose semantics is determined by a set of models. The basic elements of this language are \\textit{abstract inference modules} (or just \\textit{modules}) that are defined to consist of \\textit{inferences}. Collections of abstract inference modules constitute \\textit{abstract modular inference systems} (or just \\textit{modular systems}). We define the semantics of abstract inference modules and show that they provide a uniform language to capture inference mechanisms from different logics, and their modular combinations. Importantly, abstract inference modules and abstract modular inference systems give rise to \\textit{transition graphs} of the type introduced by Nieuwenhuis, Oliveras, and Tinelli [49] in their study of SAT and SMT solvers. As in that earlier work, our transition graphs provide a natural and convenient representation of solvers for modular and modular systems. They lend themselves well to extensions that capture such important solver design techniques as learning (which here comes in two flavors: \\textit{local} that is limited to single modules, and \\textit{global} that is applied across modules). In this way, abstract modular inference systems and the corresponding framework of transition graphs are useful conceptualizations clarifying computational principles behind solvers for multi-logic knowledge representation systems and facilitating systematic development of new ones. The design of transition systems based on \\textit{syntax-free} modules is what separates this work from earlier uses of graphs for describing model generation algorithms behind SAT, SMT, PC(ID), or ASP solvers [49,43,34,36]. These earlier transition graphs are language specific and based on the syntactic constructs typical of the respective formalisms. Adding a new level of abstraction allows one a bird’s eye view on the landscape of solving techniques and their usage in hybrid settings.\n\nTo demonstrate the power of our approach, we show that it applies to answer set programming, propositional logic, multi-logic systems based on these two formalisms, and generally to satisfiability modulo theories. As SMT is a general framework for integrating diverse logics, the same expressivity claims hold true for our approach. However, in at least one aspect, our approach goes beyond the basic tenants of SMT. Namely, our modular systems have no central core, the role played by SAT in the case of SMT. Rather, all modules are viewed in exactly the same way and can pass on results of inferences directly to each other. In addition, all modules are presented in a uniform way as sets of inferences. In this way, we can ignore syntactical aspects of logics. Of course, that makes our formalism poorly tailored for modeling, as it is the syntax of logics that is typically used to provide concise representations of knowledge. Yet, our syntax-free modules make explicit the reasoning the logics of the modules support, and that is of central importance to our objective to support the design and analysis of solvers.\n\nThe paper is organized as follows. We start by introducing abstract inference modules. We then adapt the transition graphs of Nieuwenhuis et al. [49] to the formalism of abstract inference modules and use them to describe algorithms for finding and enumerating models of modules. In Section 4, we introduce abstract modular inference systems, extend the concept of a transition graph to modular systems, and show that transition graphs can be used to formalize search\n\n---\n\n1 Logic PC(ID) is a propositional fragment of classical first-order logic with inductive definitions; SM(ASP) is a propositional language that merges classical logic expressions and logic programs under stable model semantics; ASP(FO) is a first-order language, which encapsulates modules stemming from classical logic and modules stemming from logic programming.\n\n2 We stress that in this discussion we simply aim at showing that combining modules coming from different logics may be beneficial. Here, limitations of propositional logic in modeling recursive constraints are overcome with modules designed specifically for this task. However, it is possible (in fact, straightforward) to design a single ASP program that efficiently handles the Hamiltonian cycle application.\nfor models in this setting, too. We also show in that section that abstract modular systems can be used to represent SMT. In Section 5, we discuss extensions to our framework that support representing model-finding algorithms exploiting “inference” learning, an abstract version of clause learning developed and studied in SAT. Throughout the paper, we illustrate our approach by showing how it applies to propositional logic, answer set programming, to multi-logic systems based on these two formalisms, and to SMT. We conclude by discussing related work, and recapping our contributions. All proofs are gathered in the appendix.\n\n2. Abstract inference modules\n\nWe start with some notation. Let \\( \\sigma \\) be a vocabulary (a set of propositional atoms). Elements of \\( \\sigma \\) and their negations are literals. We write \\( \\text{Lit}(\\sigma) \\) for the set of all literals over \\( \\sigma \\). For a literal \\( l \\) we define its dual literal \\( \\bar{l} \\) as \\( \\neg a \\), if \\( l = a \\), and \\( a \\), if \\( l = \\neg a \\). For a set \\( M \\subseteq \\text{Lit}(\\sigma) \\), we define \\( M^+ = \\sigma \\cap M \\) and \\( M^- = \\{ a \\in \\sigma : \\neg a \\in M \\} \\). A literal \\( l \\in \\text{Lit}(\\sigma) \\) is unassigned by a set of literals \\( M \\subseteq \\text{Lit}(\\sigma) \\) if \\( M \\) contains neither \\( l \\) nor its dual literal \\( \\bar{l} \\). A set \\( M \\) of literals over \\( \\sigma \\) is consistent if for every literal \\( l \\in \\text{Lit}(\\sigma) \\), \\( l \\notin M \\) or \\( \\bar{l} \\notin M \\). We denote the set of all consistent subsets of \\( \\text{Lit}(\\sigma) \\) by \\( \\text{C}(\\sigma) \\). A set \\( M \\) of literals is complete over \\( \\sigma \\) if for every atom \\( a \\in \\sigma \\), either \\( a \\in M \\) or \\( \\neg a \\in M \\).\n\n**Definition 1.** An abstract inference module over a vocabulary \\( \\sigma \\) (or just a module, for short) is a finite set of pairs of the form \\((M, l)\\), where \\( M \\subseteq \\text{C}(\\sigma) \\), \\( l \\in \\text{Lit}(\\sigma) \\) and \\( l \\notin M \\). These pairs are called inferences of the module. For a module \\( S \\), \\( \\sigma_S \\) denotes the set of all atoms that appear (possibly negated) in inferences of \\( S \\).\n\nIntuitively, an inference \\((M, l)\\) in a module indicates support for inferring \\( l \\) whenever all literals in \\( M \\) are given. We note that if \\((M, l)\\) is an inference and \\( l \\in M \\), the inference is an explicit indication of a contradiction. Fig. 1(a) shows all inferences over the vocabulary \\( \\{a\\} \\). Figs. 1(b) and 1(c) give examples of modules over the vocabulary \\( \\{a\\} \\). Here and throughout the paper, we present inferences as directed edges and modules as bipartite graphs.\n\nA set \\( M \\subseteq \\text{Lit}(\\sigma) \\) is consistent with a set \\( X \\) (not necessarily included in \\( \\sigma \\)) if \\( M^+ \\subseteq X \\) and \\( M^- \\cap X = \\emptyset \\). A literal \\( l \\in \\text{Lit}(\\sigma) \\) is consistent with a set \\( X \\) if \\( \\{l\\} \\subseteq X \\) is consistent with \\( X \\). Let \\( S \\) be an abstract inference module over a vocabulary \\( \\sigma \\). A set \\( X \\) is a model of \\( S \\) if for every inference \\((M, l)\\in S \\) such that \\( M \\) is consistent with \\( X \\), \\( l \\) is consistent with \\( X \\), too. A module is satisfiable if it has models, and is unsatisfiable otherwise. For example, any set that contains \\( a \\) is a model of the module in Fig. 1(b), whereas no set that does not contain \\( a \\) is such. The module in Fig. 1(c) has no models due to inferences \\((\\emptyset, a)\\) and \\((\\emptyset, \\neg a)\\) (as well as \\((\\{a\\}, \\neg a)\\) and \\((\\{\\neg a\\}, a)\\)). The module in Fig. 1(b) is satisfiable, the one in Fig. 1(c) is unsatisfiable.\n\nLet \\( S \\) be an abstract module over some vocabulary \\( \\sigma \\). Clearly, \\( S \\) can also be viewed as a module over the vocabulary \\( \\sigma_S \\), as any inference of \\( S \\) is an inference constructed of literals in \\( \\text{Lit}(\\sigma_S) \\). Moreover, it is clear from the definitions that for a module \\( S \\) viewed as a module over \\( \\sigma_S \\), a set \\( X \\) is a model of \\( S \\) if and only if \\( X \\cap \\sigma_S \\) is a model of \\( S \\). Thus, the semantics of a module \\( S \\) is fully determined by its models contained in \\( \\sigma_S \\). Following the same argument, we can view a module \\( S \\) over a vocabulary \\( \\sigma \\) as a module over any vocabulary \\( \\sigma' \\supseteq \\sigma \\). In this respect, modules behave exactly as formulas and theories in classical logic.\n\nTwo modules (not necessarily over the same vocabulary) that have the same models are equivalent. Similarly to the observation made above, the following proposition shows that to test equivalence of modules one may restrict attention only to models consisting of atoms that occur in the modules in question.\n\n**Proposition 1.** Abstract inference modules \\( S_1 \\) and \\( S_2 \\) are equivalent if and only if they have the same models contained in the set \\( \\sigma_{S_1} \\cup \\sigma_{S_2} \\).\n\nThe semantics of modules is given by their models. Let \\( S \\) be a module over a vocabulary \\( \\sigma \\) and \\( l \\) a literal in \\( \\text{Lit}(\\sigma) \\). We say that \\( S \\) entails \\( l \\), written \\( S \\models l \\), if for every model \\( X \\) of \\( S \\), \\( l \\) is consistent with \\( X \\). Furthermore, \\( S \\) entails \\( l \\) with respect to a set \\( M \\subseteq \\text{Lit}(\\sigma) \\) of literals, written \\( S \\models_M l \\), if whenever \\( M \\) is consistent with a model \\( X \\) of \\( S \\), \\( l \\) is consistent with \\( X \\), too. Modules are sound with respect to their semantics, which we formally state below.\n\n**Proposition 2.** Let \\( S \\) be a module and \\((M, l)\\) an inference in \\( S \\). Then \\( S \\models_M l \\).\n\nIn the paper, we often consider unions of (finitely many) modules. The union of modules is a well-defined operation as modules are sets (of inferences). Thus, the union of modules \\( M_1, \\ldots, M_n \\) is simply the module that consists precisely of all the inferences of \\( M_1, \\ldots, M_n \\). We use the symbol \\( \\cup \\) to denote the union of modules. The resulting module can be viewed as a module over any vocabulary \\( \\sigma \\) that contains the vocabularies of all modules in the union.\nProposition 3. Let $S_1$ and $S_2$ be abstract inference modules. A set $X$ is a model of $S_1 \\cup S_2$ if and only if $X$ is a model of $S_1$ and $S_2$.\n\nModules are not meant for modeling knowledge. Representations by means of logic theories are usually more concise. Furthermore, logic languages align closely with the natural language, which facilitates modeling and makes the correspondence between logic theories and knowledge they represent direct. Modules lack this connection. The power of modules comes from the fact that they provide a uniform, syntax-independent way to describe theories and inference methods for different logics. We illustrate this property of modules by showing that they can capture theories and inferences in classical propositional logic and in answer set programming [23,42,47] (where logic programs are used as theories).\n\n2.1. Propositional logic via abstract inference modules\n\nLet $T$ be a finite propositional theory (formula) over $\\sigma$, and let $\\sigma_T$ be the set of atoms that appear in $T$. We first consider the inference method given by the classical entailment. By $\\text{Ent}(T)$ we denote the module consisting of pairs $(M, l)$ that satisfy the following conditions: $M \\in C(\\sigma_T)$, $l \\in \\text{Lit}(\\sigma_T) \\setminus M$, and $T \\cup M \\models l$. Fig. 1(b) shows the module $\\text{Ent}(\\{a\\})$. Fig. 1(c) shows the module $\\text{Ent}((a \\land \\neg a))$. Similarly, Fig. 2 presents the module $\\text{Ent}(T)$, where $T$ is the theory in conjunctive normal form (CNF theory)\\footnote{We follow a common convention and represent CNF theories as sets of clauses.}:\n\n$$\\{a \\lor b, \\neg a \\lor \\neg b\\}. \\tag{1}$$\n\nWe note that $\\text{Ent}(T)$ has two models contained in $\\{a, b\\}$: $\\{a\\}$ and $\\{b\\}$.\\footnote{We identify a model, an interpretation, of a propositional theory with the set of atoms that are assigned True in the model.} More generally, every model $X$ of $\\text{Ent}(T)$ contains exactly one of $a$ and $b$.\n\nFocusing on specific inference rules of propositional logic also gives rise to abstract modules. $\\text{Unit Propagate}$ is a standard inference rule commonly used when reasoning with CNF theories. This inference rule is essential to all satisfiability (SAT) solvers, programs that compute models of CNF theories or determine that no models exist. Let $T$ be a finite propositional CNF theory over $\\sigma$. The $\\text{Unit Propagate}$ rule gives rise to the module $\\text{UP}(T)$ that consists of all pairs $(M, l)$ that satisfy the following conditions: $M \\in C(\\sigma_T)$, $l \\in \\text{Lit}(\\sigma_T) \\setminus M$, and $T$ has a clause $C \\lor l$ (modulo reordering of literals) such that for every literal $u$ of $C$, $\\exists \\in M$.\n\nLet $T$ be the CNF theory $\\text{(1)}$. The module $\\text{Ent}(T)$ in Fig. 2 coincides with $\\text{UP}(T)$. Thus, for the theory $\\text{(1)}$ the $\\text{Unit Propagate}$ rule captures entailment.\n\nWe say that a module $S$ is equivalent to a propositional theory $T$ if they have the same models. Clearly, the module in Fig. 2 is equivalent to the propositional theory $\\text{(1)}$. This is an instance of a general property.\n\nProposition 4. For every propositional theory $T$ (respectively, CNF formula $T$ containing no empty clause), $\\text{Ent}(T)$ (respectively, $\\text{UP}(T)$) is equivalent to $T$.\n\n2.2. Answer set programming via abstract inference modules\n\n$\\text{Unit Propagate}$ is the primary inference rule of most SAT solvers. In the case of answer set programming, most solvers rely on several inference rules associated with reasoning under the answer set semantics. For instance, the classical answer set solver SMODELS [48] exploits four inference rules called the $\\text{Unit Propagate}$ rule, the $\\text{Unfounded}$ rule, the $\\text{All Rules Cancelled}$ rule, and the $\\text{Backchain True}$ rule. To state these rules we introduce some definitions and notations commonly used in logic programming.\n\nA logic program, or simply a program, over $\\sigma$ is a finite set of rules of the form\n\n$$a_0 \\leftarrow a_1, \\ldots, a_\\ell, \\text{ not } a_{\\ell+1}, \\ldots, \\text{ not } a_m, \\tag{2}$$\n\nwhere each $a_i$, $0 \\leq i \\leq m$, is an atom from $\\sigma$. The expression $a_0$ is the head of the rule. The expression on the right hand side of the arrow is the body. For a program $\\Pi$ and an atom $a$, Bodies($\\Pi, a$) denotes the set of the bodies of all rules in $\\Pi$ with the head $a$. We write $\\sigma_{\\Pi a}$ for the set of atoms that occur in a program $\\Pi$. \\[ \n\nFig. 2. Abstract module $\\text{Ent}(T)$ for the theory $T$ given by (1).\n\n\\[ \n\nFor the body $B$ of a rule (2), we define $s(B) = \\{a_1, \\ldots, a_\\ell, \\neg a_{\\ell+1}, \\ldots, \\neg a_m\\}$. In some cases, we identify $B$ with the conjunction of the elements in $s(B)$, and we often interpret a rule (2) as the propositional clause\n\n$$a_0 \\lor \\neg a_1 \\lor \\ldots \\lor \\neg a_\\ell \\lor a_{\\ell+1} \\lor \\ldots \\lor a_m.$$ (3)\n\nFor a program $\\Pi$, we write $\\Pi^{cl}$ for the set of clauses (3) corresponding to all rules in $\\Pi$.\n\nThe concept of an answer set (stable model) was introduced in [22], Saccà and Zaniolo [52] showed that answer sets can be characterized in terms of unfounded sets [56]. This characterization is the one we present here as it is especially useful in understanding inference rules of modern answer set solvers discussed here. A set $U$ of atoms occurring in a program $\\Pi$ is unfounded on a consistent set $M$ of literals with respect to $\\Pi$ if for every atom $a \\in U$ and every $B \\in \\text{Bodies}(\\Pi, a)$, there is $u \\in s(B)$ such that $\\bar{u} \\in M$ or $U \\cap s(B) \\neq \\emptyset$. For a program $\\Pi$ over $\\sigma$, a set $X$ of atoms over $\\sigma$ is an answer set of $\\Pi$ if and only if $X$ is a model of $\\Pi^{cl}$ and $X$ contains no element of a set that is unfounded on $X \\cup \\{-\\sigma: a \\in \\sigma \\setminus X\\}$ with respect to $\\Pi$. For a set $M$ of literals and a program $\\Pi$, we write $\\text{Unf}(M, \\Pi)$ to denote the family of all sets unfounded on $M$ w.r.t. $\\Pi$.\n\nWe are now ready to define the sMODELS inference rules. For a program $\\Pi$, a set $M \\subset C(\\sigma_{\\Pi_1})$ of literals, and a literal $l \\in \\text{Lit}(\\sigma_{\\Pi_1}) \\setminus M$:\n\n**Unit Propagate**: derive $l$ if $\\Pi^{cl}$ contains clause $C \\lor l$ such that for every $u \\in C$, $\\bar{u} \\in M$;\n\n**Unfounded**: derive $l$ if $l = \\neg a$ and $a \\in U$, for some $U \\in \\text{Unf}(M, \\Pi)$;\n\n**All Rules Cancelled**: derive $l$ if $l = \\neg a$ and for every $B \\in \\text{Bodies}(\\Pi, a)$, there is $u \\in s(B)$ such that $\\bar{u} \\in M$;\n\n**Backchain True**: derive $l$, if for some rule $a \\leftarrow B \\in \\Pi$, $a \\in M$, $l \\in s(B)$, and for every $B' \\in \\text{Bodies}(\\Pi, a)$ such that $s(B') \\neq s(B)$, there is $u \\in s(B')$ such that $\\bar{u} \\in M$.\n\nThe four rules above give rise to abstract inference modules $\\text{UP}(\\Pi)$, $\\text{UF}(\\Pi)$, $\\text{ARC}(\\Pi)$ and $\\text{BC}(\\Pi)$, respectively, each obtained by taking the definition of the corresponding rule as the condition for $(M, l)$, where $M \\subset C(\\sigma_{\\Pi_1})$ and $l \\notin \\text{Lit}(\\sigma_{\\Pi_1}) \\setminus M$, to be an inference of the module. For instance, the module $\\text{UF}(\\Pi)$ consists of all inferences $(M, l)$ such that $M \\subset C(\\sigma_{\\Pi_1})$, $l \\notin \\text{Lit}(\\sigma_{\\Pi_1}) \\setminus M$, and $l = \\neg a$, where $a$ is any atom such that $a \\in U$, for some $U \\in \\text{Unf}(M, \\Pi)$.\n\nWe note that the inference rule **All Rules Cancelled** is subsumed by the inference rule **Unfounded**. That is, $\\text{ARC}(\\Pi) \\subset \\text{UF}(\\Pi)$. This is the only inclusion relation between distinct modules in that set that holds for every program. We also note that $\\text{UP}(\\Pi)$ and $\\text{UP}(\\Pi^{cl})$ are identical (and so, equivalent) even though they concern different logics.\n\nWe say that a module $S$ is equivalent to a program $\\Pi$ if for every $X \\subset \\sigma_{\\Pi_1}$, $X$ is a model of $S$ if and only if $X$ is an answer set of $\\Pi$. None of the four modules $\\text{UP}(\\Pi)$, $\\text{UF}(\\Pi)$, $\\text{ARC}(\\Pi)$ and $\\text{BC}(\\Pi)$ alone is equivalent to the underlying program $\\Pi$.\n\nHowever, some combinations of these modules are. Let us define\n\n$$\\text{UPUF}(\\Pi) = \\text{UP}(\\Pi) \\cup \\text{UF}(\\Pi)$$\n\nand\n\n$$\\text{smodels}(\\Pi) = \\text{UP}(\\Pi) \\cup \\text{UF}(\\Pi) \\cup \\text{ARC}(\\Pi) \\cup \\text{BC}(\\Pi).$$\n\nSince $\\text{ARC}(\\Pi) \\subset \\text{UF}(\\Pi)$, it is not necessary to list the module $\\text{ARC}(\\Pi)$ explicitly in the union above. We do so, as the rule **All Rules Cancelled** is computationally cheaper than the rule **Unfounded** and in practical implementations the two are distinguished.\n\nThe following result restates well-known properties of these inference rules in terms of equivalence of modules and programs.\n\n**Proposition 5.** Every logic program $\\Pi$ is equivalent to the modules $\\text{UPUF}(\\Pi)$ and $\\text{smodels}(\\Pi)$.\n\nLet $\\Pi$ be the program\n\n$$a \\leftarrow \\text{not } b$$\n\n$$b \\leftarrow \\text{not } a.$$ (4)\n\nThis program has two answer sets $\\{a\\}$ and $\\{b\\}$. Since these are also the only two models over the vocabulary $\\{a, b\\}$ of the module in Fig. 2, the program and the module are equivalent. This module represents the program (4) and the reasoning mechanism captured by the module $\\text{smodels}(\\Pi)$. Two other modules associated with program (4) are given in Fig. 3. Fig. 3(a) shows the module $\\text{UP}(\\Pi)$, and the reasoning mechanism based on **Unit Propagate**. This module is not equivalent to program (4). Indeed, $\\{a, b\\}$ is its model, but not an answer set of (4). Fig. 3(b) shows the module $\\text{ARC}(\\Pi)$ (which in this case happens to coincide with both $\\text{UF}(\\Pi)$ and $\\text{BC}(\\Pi)$). Also this module is not equivalent to program (4) as $\\emptyset$ is its model but not an answer set of $\\Pi$. The union of the two modules in Fig. 3 captures all four inference rules and is indeed equal to the module in Fig. 2.\n\n---\n\n5 This is not the standard concept of equivalence as it is restricted to models over the vocabulary of the program. It is sufficient, however, for our purpose of studying algorithms to compute answer sets.\nWe conclude this section with two more examples. In the first example, let \\( \\Pi \\) be the program consisting of the rule\n\n\\[\na \\leftarrow \\lnot a.\n\\]\n\nThis program has no answer sets. The module \\( \\text{UP}(\\Pi) \\) consists of a single inference \\( \\{\\lnot a, a\\} \\), whereas the modules \\( \\text{UF}(\\Pi), \\text{ARC}(\\Pi) \\), and \\( \\text{BC}(\\Pi) \\) coincide and consist of a single inference \\( \\{a, \\lnot a\\} \\). The module resulting from the union of two last mentioned inferences is unsatisfiable.\n\nIn the second example, we assume that \\( \\Pi \\) is given by the rules\n\n\\[\n\\begin{align*}\na & \\leftarrow b \\\\\nb & \\leftarrow a.\n\\end{align*}\n\\]\n\nThe empty set is the only answer set of this program. The inferences in Fig. 4(a) form the module \\( \\text{BC}(\\Pi) \\) and those in Fig. 4(b) define the module \\( \\text{ARC}(\\Pi) \\). The union of these two modules yields the module \\( \\text{UP}(\\Pi) \\). The union of the inferences in Fig. 4(b) and in Fig. 5 gives the module \\( \\text{UF}(\\Pi) \\).\n\n### 3. Transition graphs — an abstraction of model finding algorithms\n\nFinding models of logic theories and programs is a key computational task in declarative programming. Nieuwenhuis et al. [49] proposed to use transition graphs to describe search procedures involved in model-finding algorithms commonly called solvers, and developed that approach for the case of SAT. Their transition graph framework can express \\text{dplL}, the basic search procedure employed by SAT solvers, and its enhancements with techniques such as conflict-driven clause learning. Lierler and Truszczynski [34,36] proposed a similar framework to describe and analyze the answer set solvers \\text{smodels}, \\text{cmodels} [25] and \\text{clasp} [17,19], as well as a PC(ID) solver \\text{minisat(id)} [43]. In the previous section, we argued that theories and programs can be represented by equivalent abstract inference modules (Propositions 4 and 5). We now show that the idea of a transition graph can be generalized to the setting of modules, leading to an abstract perspective on the problem of search for models of modules, and unifying the approaches to the model-finding task.\n\nLet \\( \\sigma \\) be a finite vocabulary. A state over \\( \\sigma \\) is either a special state \\( \\bot \\) (the fail state) or a sequence \\( M \\) of distinct literals over \\( \\sigma \\), some possibly annotated by \\( \\Delta \\), which marks them as decision literals, such that:\n\n1. the set of literals in \\( M \\) is consistent or \\( M = M' \\downarrow \\), where the set of literals in \\( M' \\) is consistent and contains \\( \\overline{l} \\), and\n2. if \\( M = M' \\uparrow \\Delta \\downarrow M'' \\), then \\( l \\) is unassigned in the set of the literals in \\( M'' \\).\n\nFor instance, if \\( \\sigma = \\{a, b\\} \\), then \\( \\overline{\\emptyset}, a, \\lnot a \\wedge b, \\lnot a b \\wedge a \\) and \\( \\bot \\) are examples of states over \\( \\sigma \\).\n\nIf \\( M \\) is a state, by \\( [M] \\) we denote the set of the literals in \\( M \\) (that is, we drop annotations and ignore the order). Our definition of a state allows for inconsistent states. However, inconsistent states are of a very specific form — the inconsistency arises because of the last literal in the state. There is also a restriction on annotated (decision) literals. A decision literal must not appear in a state following another occurrence of that literal or its dual (annotated or not). Intuitively, a literal\nInference Propagate\\(_S\\) : \\( M \\rightarrow Ml \\) if \\( \\begin{cases} [M] \\text{ is consistent, } l \\notin [M], \\text{ and} \\\\ \\text{ for some } M' \\subseteq [M], (M', l) \\text{ is an inference of } S \\end{cases} \\)\n\nFail: \\( M \\rightarrow \\bot \\) if \\([M]\\) is inconsistent and \\(M\\) contains no decision literals\n\nBacktrack: \\( P \\vdash Q \\rightarrow P \\widetilde{I} \\) if \\( \\begin{cases} [P \\vdash Q] \\text{ is inconsistent, and} \\\\ Q \\text{ contains no decision literals} \\end{cases} \\)\n\nDecide: \\( M \\rightarrow M \\vdash l \\) if \\([M]\\) is consistent and \\(l\\) is unassigned by \\( [M] \\)\n\nFig. 6. The transition rules of the graph \\( AM_S \\).\n\nannotated by \\( \\Delta \\) denotes a current assumption: thus once a literal is assigned in a state, there is no point in later making an assumption concerning whether it holds or not.\n\nEach module \\( S \\) determines its transition graph \\( AM_S \\). The set of nodes of \\( AM_S \\) consists of all possible states relative to \\( \\sigma_S \\). The edges of the graph \\( AM_S \\) are specified by the transition rules listed in Fig. 6. The first rule depends on the module, the last three do not. They have the same form no matter what module we consider. Hence, we omit the reference to the module from their notation. Moreover, even for the rule Inference Propagate, we often omit the reference to the module if it is implied by the context, or if the specific reference is immaterial. Finally, we call a node in a transition graph terminal if no edge originates in it (equivalently, no rule applies to it).\n\nThe graph \\( AM_S \\) can be used to decide whether a module \\( S \\) has a model. The following properties are essential.\n\n**Theorem 6.** For every abstract inference module \\( S \\),\n\n(a) graph \\( AM_S \\) is finite and acyclic,\n\n(b) for any terminal state \\( M \\) of \\( AM_S \\) other than \\( \\bot, [M]^+ \\) is a model of \\( S \\),\n\n(c) state \\( \\bot \\) is reachable from \\( \\emptyset \\) in \\( AM_S \\) if and only if \\( S \\) is unsatisfiable (has no models).\n\nThus, to decide whether a module \\( S \\) has a model it is enough to find in the graph \\( AM_S \\) a path leading from node \\( \\emptyset \\) to a terminal node \\( M \\). If \\( M = \\bot \\), \\( S \\) is unsatisfiable. Otherwise, \\( [M]^+ \\) is a model of \\( S \\). For instance, let \\( S \\) be the module in Fig. 2. Below we show a path in the transition graph \\( AM_S \\) with every edge annotated by the corresponding transition rule:\n\n\\[\n\\emptyset \\xrightarrow{\\text{Decide}} b^\\Delta \\xrightarrow{\\text{Inference Propagate}_S} b^{\\Delta \\neg a}.\n\\]\n\nThe state \\( b^{\\Delta \\neg a} \\) is terminal. Thus, Theorem 6(b) asserts that \\( \\{b\\} \\) is a model of \\( S \\). There may be several paths determining the same model. For instance, the path\n\n\\[\n\\emptyset \\xrightarrow{\\text{Decide}} \\neg a^{\\Delta} \\xrightarrow{\\text{Decide}} \\neg a^{\\Delta} b^\\Delta\n\\]\n\nleads to the terminal node \\( \\neg a^{\\Delta} b^\\Delta \\), which is different from \\( b^{\\Delta \\neg a} \\) but corresponds to the same model.\n\nWe can view a path in the graph \\( AM_S \\), starting in \\( \\emptyset \\) and ending in a terminal node as a description of a specific way to search for a model of module \\( S \\). Each such path is determined by a function (strategy) selecting for each non-terminal state exactly one of its outgoing edges (exactly one applicable transition). Therefore, solvers based on the transition graph \\( AM_S \\) are determined by the “select-edge-to-follow” function. Such a function can be based, in particular, on assigning strict priorities to inferences in \\( S \\). Below we describe an algorithm that captures the “classical” DPLL strategy. Assuming \\( M \\) is the current state and it is not terminal, the algorithm proceeds as follows:\n\nIf \\( M \\) is inconsistent and has no decision literals, follow the Fail edge (this is the only applicable transition);\n\nif \\( M \\) is inconsistent and has decision literals, follow the Backtrack edge (this is the only applicable transition);\n\nif \\( M \\) is consistent and Inference Propagate\\(_S\\) applies, follow the edge implied by the highest priority inference of the form \\((M', l)\\) in \\( S \\) such that \\( M' \\subseteq [M] \\);\n\notherwise, follow a Decide edge.\n\nThis is still not a complete specification of a solver, as it offers no directions on how to select a decision literal (of which many possible Decide transitions to apply). Much of research on SAT solvers design has focused on this particular aspect and several heuristics were proposed over the years. Each such heuristics for selecting a decision literal when the Decide transition applies yields an algorithm. Additional algorithms can be obtained by switching the preference between Inference Propagate and Decide rules. Earlier, we selected an Inference Propagate edge and only if impossible, we selected a Decide edge. But that order can be reversed resulting in another class of algorithms. Finally, we could even consider more complicated selection functions that, when both Decide and Inference Propagate edges are available, in some cases select an Inference Propagate edge and in others a Decide one.\nBefore we proceed, we state several observations about the graph $AM_S$. First, for every model $X$ of an abstract module $S$, there is a terminal state $M$ in $AM_S$ such that $X \\cap \\sigma_S = [M]^+$ and $M$ is reachable from $\\emptyset$ in the graph $AM_S$ (in other words, every model of $S$ is represented by some terminal state reachable from $\\emptyset$ in $AM_S$). Indeed, we can take for $M$ any state that contains annotated atoms $x^\\Delta$, for all $x \\in X \\cap \\sigma_S$, and annotated negated atoms $\\neg y^\\Delta$, for all $y \\in \\sigma_S \\setminus X$. Each such state $M$ is reachable by a path whose edges are determined by the Decide rule. Moreover, if $X$ is a model of $S$, then $M$ is clearly a terminal state.\n\nSecond, generally each model of a module $S$ is represented by many terminal states in the graph $AM_S$. Some are reachable from $\\emptyset$ and some are not. However, as we just argued, the terminal states reachable from $\\emptyset$ represent all models of the module. Thus, to decide satisfiability of a module (or, for satisfiable modules, to find a model) it is sufficient to consider only the states reachable from $\\emptyset$. In this sense, the states reachable from $\\emptyset$ determine the “essential” fragment of the transition graph. To illustrate these observations, let us consider the module $UP((a \\lor b))$ (which simulates Unit Propagate inferences based on $a \\lor b$). Then, $ab$, $a^\\Delta b$, $a^\\Delta b^\\Delta$, and $a^\\Delta b^\\Delta$ all represent the same family of models — those that contain atoms $a$ and $b$.\n\nHowever, only one of these four states, $a^\\Delta b^\\Delta$, is reachable from $\\emptyset$. The other three are not.\n\nThird, one can generalize part (c) of Theorem 6 as follows. Let $M$ be any state other than $\\bot$. If a terminal state other than $\\bot$ is reachable from $M$, then $S$ has models that are consistent with $[M]$. Otherwise, $\\bot$ is the only terminal state reachable from $M$ and $S$ has no models consistent with $[M]$ (but it may have other models). Thus, while only the fragment of the graph $AM_S$ consisting of the states reachable from $\\emptyset$ is needed to determine satisfiability and find models of the module, other parts of the graph are of interest too. Incidentally, similar generalizations are possible for parts (c) in Theorems 11, 16 and 17 that we state later.\n\nFinally, we observe that the fragment of the graph $AM_S$ reachable from $\\emptyset$ contains inconsistent states also. Such states are, however, not terminal. For instance, the state $\\neg a^\\Delta \\neg b^\\Delta a$ is reachable from $\\emptyset$ in the transition graph of the module $UP((a \\lor b))$ (the path is given by the edges determined by two applications of the Decide rule, followed by an application of the Unit Propagate rule). This state is not terminal as the Backtrack rule applies. Similarly, the fragment consisting of states that are not reachable may contain states that are consistent (as we mentioned above, the state $ab$ is not reachable from $\\emptyset$ yet, it is consistent).\n\n### 3.1. Abstract SAT solvers\n\nWe now show how the approaches proposed by Nieuwenhuis et al. [49] and Lierler [34] to describe and analyze SAT and ASP solvers, respectively, fit in our abstract framework. Let $F$ be a CNF formula that contains no empty clause. Nieuwenhuis et al. [49], defined the transition graph $DP_F$ to capture the computation of the DPLL algorithm. We now review this graph in the form convenient for our purposes. All states over the vocabulary of $F$ form the vertexes of $DP_F$. The edges of $DP_F$ are specified by the three “generic” transition rules $Fail$, $Backtrack$ and $Decide$ of the graph $AM_S$, and the $Unit Propagate$ rule below:\n\n$$Unit Propagate_F : \\quad M \\rightarrow MI \\text{ if } \\left\\{ \\begin{array}{l} [M] \\text{ is consistent, } l \\notin [M], \\text{ and } \\forall u \\in C, \\Pi \\in [M], \\text{ such that } \\Pi \\cap l \\in F, \\text{ such that } \\forall u \\in C, \\Pi \\in [M] \\end{array} \\right.$$\n\nFor example, let $F$ be the theory consisting of a single clause $a$. Fig. 7 presents $DP_F$. It turns out that we can see the graph $DP_F$ as the transition graph of the abstract module $UP(F)$.\n\n** Proposition 7.** For every CNF formula $F$ with no empty clause, $DP_F = AM_{UP(F)}$.\n\nTheorem 6, Proposition 7, and the fact that a CNF formula $F$ and the module $UP(F)$ are equivalent (Proposition 4) imply the following result.\n\n---\n\n\\[ \\text{Footnote 6: Four more states, with } b \\text{ preceding } a, \\text{ also represent this family of models.} \\]\nUnfounded\n: \\( M \\rightarrow M \\rightarrow \\neg a \\) if \\[\n\\begin{cases}\n[M] \\text{ is consistent, } \\neg a \\notin [M], \\\\\na \\in U, \\text{ for some } U \\in \\text{Unf}(M, \\Pi)\n\\end{cases}\n\\]\n\nAll Rules Cancelled\n: \\( M \\rightarrow M \\rightarrow a \\) if \\[\n\\begin{cases}\n[M] \\text{ is consistent, } a \\notin [M], \\\\\n\\text{for every } B \\in \\text{Bodies}(\\Pi, a), \\\\\n\\text{there is } u \\in s(B) \\text{ such that } \\Pi \\in [M]\n\\end{cases}\n\\]\n\nBackchain True\n: \\( M \\rightarrow M \\) if \\[\n\\begin{cases}\n[M] \\text{ is consistent, } \\Pi \\notin [M], \\\\\n\\text{for some } a \\leftrightarrow B \\in \\Pi, a \\in [M], \\text{ and } u \\in s(B), \\\\\n\\text{for every } B' \\in \\text{Bodies}(\\Pi, a) \\text{ so that } s(B') \\neq s(B), \\\\\n\\text{there is } u \\in s'(B') \\text{ such that } \\Pi \\in [M]\n\\end{cases}\n\\]\n\n**Corollary 8.** For any CNF formula \\( F \\),\n\n(a) graph \\( \\mathcal{DF} \\) is finite and acyclic,\n(b) for any terminal state \\( M \\) of \\( \\mathcal{DF} \\), other than \\( \\perp \\), \\( [M]^{+} \\) is a model of \\( F \\),\n(c) state \\( \\perp \\) is reachable from \\( \\emptyset \\) in \\( \\mathcal{DF} \\) if and only if \\( F \\) is unsatisfiable (has no models).\n\nThis is precisely the result stated by Nieuwenhuis et al. [49] and used to argue that the graph \\( \\mathcal{DF} \\) is an abstraction of the \\( \\text{DPLL} \\) method. To decide the satisfiability of \\( F \\) (and to find a model, if one exists), it is enough to find a path leading from the state \\( \\emptyset \\) to a terminal state \\( M \\): If \\( M = \\perp \\) then \\( F \\) is unsatisfiable; otherwise, \\( [M]^{+} \\) is a model of \\( F \\). In our example, the only terminal states reachable from the state \\( \\emptyset \\) in \\( \\mathcal{DF} \\) are \\( a \\) and \\( a^\\perp \\). This translates into the fact that \\( \\{ a \\} \\) is a model of \\( F \\). Specific algorithms encapsulated by the graph \\( \\mathcal{DF} \\) (equivalently, \\( \\text{AM}_{\\mathcal{UPU}F}(\\Pi) \\)) can be obtained by deciding on a way to select an edge while in a consistent state. Typical implementations of basic backtracking SAT solvers follow a Unit Propagate\\( F \\) edge whenever possible, choosing Decide edges only if nothing else applies. These algorithms differ from each other in the heuristics they use for the selection of a decision literal.\n\n3.2. Abstract answer set solvers\n\nOur abstract approach to model generation in logics also applies to answer set programming [23,42,47]. Lierler [34] introduced a transition system \\( \\text{SM}_{\\Pi} \\) to describe and study the \\( \\text{Smodels} \\) solver. We first review the graph \\( \\text{SM}_{\\Pi} \\) and then show that Lierler’s approach can be viewed as an instantiation of our general theory.\n\nThe set of nodes of the graph \\( \\text{SM}_{\\Pi} \\) consists of all states relative to the vocabulary of program \\( \\Pi \\). The edges of \\( \\text{SM}_{\\Pi} \\) are specified by the transition rules of the graph \\( \\mathcal{DF}_{\\Pi} \\) and the rules presented in Fig. 8.\n\nThe following result shows that Lierler’s approach can be viewed as an instantiation of our general theory.\n\n**Proposition 9.** For every logic program \\( \\Pi \\), \\( \\text{SM}_{\\Pi} = \\text{AM}_{\\text{Smodels}(\\Pi)} \\).\n\nIndeed, this proposition, Theorem 6 and the fact that \\( \\Pi \\) is equivalent to the module \\( \\text{Smodels}(\\Pi) \\) (Proposition 5) imply the result stemming from that of Lierler [34].\n\n**Corollary 10.** For every logic program \\( \\Pi \\),\n\n(a) graph \\( \\text{SM}_{\\Pi} \\) is finite and acyclic,\n(b) for any terminal state \\( M \\) of \\( \\text{SM}_{\\Pi} \\), other than \\( \\perp \\), \\( M^{+} \\) is an answer set of \\( \\Pi \\),\n(c) state \\( \\perp \\) is reachable from \\( \\emptyset \\) in \\( \\text{SM}_{\\Pi} \\) if and only if \\( \\Pi \\) has no answer sets.\n\nSince \\( \\text{UPUF}(\\Pi) \\) is also equivalent to \\( \\Pi \\), we obtain a similar corollary for the transition graph \\( \\text{AM}_{\\text{UPU}F}(\\Pi) \\). Intuitively, this graph is characterized by the transition rules of the graph \\( \\mathcal{DF}_{\\Pi} \\) as well as the rule Unfounded presented in Fig. 8. Thus, \\( \\text{AM}_{\\text{UPU}F}(\\Pi) \\) is an abstraction of another class of correct algorithms for finding answer sets of programs. In fact, it is so for any module \\( S \\) such that \\( \\text{UPUF}(\\Pi) \\subseteq S \\subseteq \\text{Smodels}(\\Pi) \\).\n\nAlso the graph \\( \\text{SM}_{\\Pi} \\) describes a whole family of backtracking search algorithms for finding answer sets of programs. They differ from each other by the way an edge is selected while in a consistent state.\n\nOur discussion of SAT and ASP solvers shows that the framework of modules uniformly encompasses different logics. Furthermore, it uniformly models diverse reasoning mechanisms (the logical entailment, reasoning under specific inference rules). Our results also show that transition graphs proposed earlier to represent and analyze SAT and ASP solvers are special cases of transition graphs for abstract inference modules.\n3.3. Model enumeration\n\nWe showed above how the transition graph $AMS_S$ can be used to conceptualize algorithms for deciding whether a module $S$ has a model. Model enumeration is a related task of generating all models of a module $S$. Paper by Gebser et al. [18] is a good reference for the problem. We now show that the transition graph approach can be adapted for the task of enumeration.\n\nTo account for model enumeration for a module $S$, we extend the graph $AMS_S$ to a graph $AME_S$. To this end, we introduce the transition rule\n\n$$\n\\text{Enumerate} : \\quad M \\rightarrow \\begin{cases} \nP \\overset{1}{\\rightarrow} & \\text{if no other rule applies to } M, \nM = P \\overset{1}{\\rightarrow} Q, \\text{ and } Q \\text{ contains no decision literals} \n\\bot & \\text{if no other rule applies to } M, \\text{ and} \nM \\text{ contains no decision literals,}\n\\end{cases}\n$$\n\nand define the transition graph $AME_S$ for an AM $S$ as the graph $AMS_S$ extended with the transition rule $Enumerate$. The following theorem captures the main properties of this graph.\n\n**Theorem 11.** For every abstract inference module $S$,\n\n(a) the graph $AME_S$ is finite and acyclic,\n(b) the $\\bot$ state is reachable from $\\emptyset$,\n(c) for every path from $\\emptyset$ to $\\bot$ in $AME_S$, the set of states in which the rule $Enumerate$ applies is precisely the set of models of $S$ over $\\sigma_S$, and for each model $X$ of $S$ over $\\sigma_S$ there is exactly one state $M$ on the path such that $X = [M]$.\n\nThis theorem assures us that if we follow a path from $\\emptyset$ to $\\bot$ we will encounter all models of $S$ over $\\sigma_S$.\n\nAnother related task is model counting where one wants to find the number of models of $S$, rather than what they are. Gomes at al. [27] provides a good account for the task. Since methods used for model counting aim to avoid explicit enumeration, it is not clear whether transition graphs can be useful for this task.\n\n4. Abstract modular system and solver $AMS_A$\n\nBy capturing diverse logics in a single framework, abstract modules are well suited for studying modularity in declarative formalisms and for analyzing solvers for such modular formalisms. As illustrated by our examples, abstract inference modules can capture reasoning of various logics including classical reasoning with propositional theories and reasoning with programs under the answer set semantics. Putting modules together provides an abstract, uniform way to represent hybrid modular systems, in which modules represent theories from different logics.\n\nWe now define an abstract modular declarative framework that uses the concept of a module as its basic element. We then show how abstract transition graphs for modules generalize to the new formalism.\n\n**Definition 2.** An abstract modular inference system (AMS) over a vocabulary $\\sigma$ is a finite set $A$ of abstract inference modules over vocabularies contained in $\\sigma$. A set $X$, is a model of $A$ if $X$ is a model of every module $S \\in A$.\n\nFor an abstract modular inference system $A$, by $\\sigma_A$ we denote the vocabulary $\\bigcup_{S \\in A} \\sigma_S$. Recalling our comments from Section 2, we note that an AMS $A$ can be viewed as a modular system over any vocabulary extending $\\sigma_A$.\n\nLet $S_1$ be the module presented in Fig. 1(b) and $S_2$ be the module in Fig. 2. The vocabulary $\\sigma_A$ of an AMS $A = \\{S_1, S_2\\}$ consists of the atoms $a$ and $b$. It is easy to see that the set $\\{a\\}$ is the only model of $A$ over $\\sigma_A$ (more generally, a set $X$ is a model of $A$ if and only if $X$ contains $a$ and does not contain $b$). In Section 2, we observed that (i) $S_1 = \\text{Ent}(T)$ (and also $\\cup \\text{Ent}(T)$) for a propositional theory $T = \\{a\\}$, and (ii) $S_2 = \\text{smodels}(\\Pi)$ for a program $\\Pi$ given by (4). Thus, the AMS $A = \\{S_1, S_2\\}$ illustrates how abstract modular systems can serve as an abstraction for heterogeneous multi-logic systems.\n\n4.1. Modular logic programs via abstract modular inference systems\n\nFor a general example of a modular declarative formalism that can be seen as an abstract modular system we now discuss modular logic programs [37]. Modular logic programs generalize the formalism of lp-modules, an early approach to modular answer set programming proposed by Oikarinen and Janhunen [50].\n\nThe semantics of modular logic programs relies on the notion of an input answer set of a program [36]. A set $X$ of atoms is an input answer set of a logic program $\\Pi$ if $X$ is an answer set of the program $\\Pi \\cup (X \\setminus \\text{Head}(\\Pi))$, where $\\text{Head}(\\Pi)$ denotes the set of all head atoms of $\\Pi$. Informally, input answer sets treat all atoms not occurring in the heads of program rules as open so that they can assume any logical value. These atoms are viewed as the “input.” For instance, program $a \\leftarrow b$ has two input answer sets that are subsets of set $\\{a, b\\}$: namely, $\\emptyset$ and set $\\{a, b\\}$. \nTo capture the semantics of input answer sets in terms of inferences, we introduce a modified version of the propagation rule Unfounded:\n\n**Unfounded**: derive \\( l \\) if \\( l \\equiv \\neg a \\) and, for some \\( U \\in \\text{Unf}(M, \\Pi) \\), \\( a \\in U \\) and for every \\( b \\in U \\), \\( b \\in \\text{Head}(\\Pi) \\) or \\( \\neg b \\in M \\).\n\nThe only difference from the Unfounded rule we discussed earlier is a restriction on unfounded sets that the new rule imposes.\n\nThe Unfounded' rule gives rise to an inference module \\( UF'(\\Pi) \\) defined by taking the condition of the rule as a specification of when \\((M, l)\\) is to be an inference of the module. With the module \\( UF'(\\Pi) \\) at hand, we define \\( UPUF'(\\Pi) = UP(\\Pi) \\cup UF'(\\Pi) \\).\n\nAn inference module \\( S \\) is input-equivalent to a logic program \\( \\Pi \\) if the input answer sets of \\( \\Pi \\) coincide with the models of \\( S \\). We now restate Proposition 5 for the case of input-equivalence.\n\n**Proposition 12.** Every program \\( \\Pi \\) is input-equivalent to the module \\( UPUF'(\\Pi) \\).\n\nA modular (logic) program is a set of logic programs [37]. For a modular program \\( \\mathcal{P} \\), a set \\( X \\) of atoms is a model of \\( \\mathcal{P} \\) if \\( X \\) is an input answer set of every program \\( \\Pi \\) in \\( \\mathcal{P} \\). An AMS \\( \\mathcal{A} \\) is equivalent to a modular program \\( \\mathcal{P} \\) if models of \\( \\mathcal{P} \\) coincide with models of \\( \\mathcal{A} \\).\n\n**Proposition 13.** Every modular program \\( \\{\\Pi_1, \\ldots, \\Pi_n\\} \\) is equivalent to the abstract modular system \\( \\{UPUF'(\\Pi_1), \\ldots, UPUF'(\\Pi_n)\\} \\).\n\nTheories in the logics SM(ASP) [37] and PC(ID) [43] can be viewed as abstract modular systems in the same manner.\n\n**Remarks on modularity in ASP.** We use modular logic programs in this paper only to illustrate the key aspects of our general framework. Thus, it is not the place for an extended discussion of the relationship between modular logic programs and more standard work on modularity in ASP. Nevertheless, a few comments might be in order. First, in ASP the thrust is on identifying a decomposition of a program into subprograms (“modules”) so that there is a direct correspondence between the answer sets of the subprograms and the answer sets of the program. Finding such decompositions (either explicitly by preprocessing, or implicitly during search) may have a big impact on the performance of solvers. Because of the nature of the answer set semantics, such decompositions are only possible for programs with some hierarchical structure given by stratification [1] or, more generally, splitting [41]. In this work, we use the generic term “model” of a modular system to stress that our semantics of modular logic programs is not directly related to the semantics of answer sets of the union of modules.\n\nIn fact, our motivation is quite different. We assume an “inverse” scenario where the modular structure is given right from the beginning. The objective is to define a semantics of a collection of programs based on the semantics of the individual programs. The semantics of answer sets does not lend itself naturally to this purpose. For instance, consider a modular program\n\n\\[\n\\{a \\leftarrow \\}, \\{b \\leftarrow \\}\n\\] \n\n(8)\n\nThere is no set of atoms that yields an answer set to both logic programs \\( \\{a \\leftarrow \\} \\) and \\( \\{b \\leftarrow \\} \\) simultaneously. Therefore, in our earlier work we proposed the input answer set semantics as the semantics for individual logic programs, that lends a way to defining a meaningful semantics of modular logic programs. In this example, the set \\( \\{a, b\\} \\) of atoms is a model of modular logic program (8), as it is an input answer set of each of the component programs. For another example, let us consider a modular program\n\n\\[\n\\{a \\leftarrow b\\}, \\{b \\leftarrow a\\}.\n\\] \n\n(9)\n\nClearly, the union of the rules in the modules of (9) is exactly the program given by (5). Each of the programs \\( \\{a \\leftarrow b\\} \\) and \\( \\{b \\leftarrow a\\} \\) has only one answer set, \\( \\emptyset \\). However, the modular program has two models \\( \\emptyset \\) and \\( \\{a, b\\} \\). It is so because both sets are input answer sets of each module, even though only the first one is an answer set. To summarize, an important point behind input answer set semantics is that it allows us to avoid difficulties that arise in ASP in the context of substitutability of one subprogram by another [40] or when attempting to determine the answer sets of the union of programs [32].\n\n### 4.2. Satisfiability modulo theories via abstract modular inference systems\n\nSatisfiability modulo theories (SMT) [49,4] is a general, broadly used framework for integrating diverse logics. In this section we review the concept of SMT programs and illustrate how these programs can be seen as abstract modular systems presented in this paper.\n\nWe start by introducing the notion of a theory in SMT. A signature \\( \\Sigma \\) is a set of predicate and function symbols, each with an associated nonnegative integer called arity. We call predicate symbols of arity 0 propositional. We call a signature\n\n---\n\n5 We used the term “answer set” in our earlier work.\npropositional if it only contains propositional symbols. (We note that elsewhere in the paper we refer to propositional signatures as vocabularies.) A term over $\\Sigma$ is either\n\n- a function symbol of arity $0$ from $\\Sigma$, or\n- an expression $f(t_1, \\ldots, t_n)$, where $f$ is a function symbol from $\\Sigma$ of arity $n > 0$ and $t_1, \\ldots, t_n$ are terms over $\\Sigma$.\n\nAn atomic formula is either\n\n- a propositional symbol from $\\Sigma$, or\n- an expression $p(t_1, \\ldots, t_n)$, where $p$ is a predicate symbol from $\\Sigma$ of arity $n > 0$ and $t_1, \\ldots, t_n$ are terms over $\\Sigma$.\n\nA theory literal, or $t$-literal, is either an atomic formula $A$ or its negation $\\neg A$. A theory formula (or a $t$-formula, for short) is a set of $t$-literals. An interpretation for a signature $\\Sigma$ (or a $\\Sigma$-interpretation for short) is a pair $I$ consisting of a non-empty set $|I|$, the universe of the interpretation, and a mapping $(\\cdot)^I$ assigning\n\n- to each function symbol $f$ in $\\Sigma$ of arity $0$, an element $f^I \\in |I|$, \n- to each function symbol $f$ in $\\Sigma$ of arity $n > 0$, a total function $f^I : |I|^n \\to |I|$, \n- to each propositional symbol $p$ in $\\Sigma$, an element in $\\{\\text{True}, \\text{False}\\}$, \n- to each predicate symbol $p$ in $\\Sigma$ of arity $n > 0$, a total function $p^I : |I|^n \\to \\{\\text{True}, \\text{False}\\}$.\n\nLet $I$ be a $\\Sigma$-interpretation. We extend the mapping $(\\cdot)^I$ to all terms over $\\Sigma$ by induction by setting for every function symbol $f$ of arity $n > 0$ and every sequence $t_1, \\ldots, t_n$ of terms\n\n$$(f(t_1, \\ldots, t_n))^I = f^I(t_1^I, \\ldots, t_n^I),$$\n\nwhere $f^I$ is the function assigned to $f$ by the interpretation $I$. Similarly, we extend the mapping $(\\cdot)^I$ to all $t$-formulas over $\\Sigma$. Namely, if $\\phi$ is a $t$-literal $p(t_1, \\ldots, t_n)$, we set\n\n$$(p^I)^I = p^I(t_1^I, \\ldots, t_n^I),$$\n\nwhere $p^I$ is the truth value function for $p$ given by the interpretation $I$. Next, if $\\phi$ is a $t$-literal $\\neg A$, we set\n\n$$((\\neg A)^I) = \\begin{cases} \\text{True} & \\text{if } A^I = \\text{False}, \\\\ \\text{False} & \\text{if } A^I = \\text{True} \\end{cases}$$\n\nFinally, for a $t$-formula $\\phi$,\n\n$$\\phi^I = \\begin{cases} \\text{True} & \\text{if for every } t\\text{-literal } L \\in \\phi, L^I = \\text{True}, \\\\ \\text{False} & \\text{otherwise} \\end{cases}$$\n\nWhen $\\phi^I = \\text{True}$ we say that the interpretation $I$ satisfies $\\phi$.\n\nFor a signature $\\Sigma$, a $\\Sigma$-theory is a set of $\\Sigma$-interpretations. We say that a $t$-formula $\\phi$ over $\\Sigma$ is satisfiable in a $\\Sigma$-theory $\\Gamma$ (or is $\\Gamma$-satisfiable, for short) if there is an element of the set $\\Gamma$ that satisfies $\\phi$.\n\nClearly, $t$-formulas can be regarded simply as classical ground formulas with negation and conjunction as the only connectives allowed. Further, the semantics we introduced above is just the classical first-order logic semantics of such formulas. In the literature on SMT, a more sophisticated syntax of formulas is considered. Yet, SMT solvers often use so-called propositional abstractions of first-order formulas which, in their most commonly used case, are t-formulas of the kind discussed here [49, Section 3.1].\n\nFor a signature $\\Sigma$, a disjoint propositional signature $\\sigma$, and a $\\Sigma$-theory $\\Gamma$, a $[\\Sigma, \\sigma, \\Gamma]$-abstraction is a mapping from atomic formulas over $\\Sigma$ to $\\sigma$. For a $[\\Sigma, \\sigma, \\Gamma]$-abstraction $\\lambda$, a set $M$ of propositional literals over the signature $\\sigma$ is a model of $\\lambda$ (or a $\\lambda$-model) if a $t$-formula\n\n$$\\{A \\mid \\lambda(A) \\in M\\} \\cup \\{\\neg A \\mid \\neg\\lambda(A) \\in M\\}$$\n\nis satisfiable in $\\Sigma$-theory $\\Gamma$. Clearly, $\\lambda$-models are consistent sets of literals over $\\sigma$.\n\nAn SMT program is a tuple $\\langle T, \\lambda_1, \\ldots, \\lambda_n \\rangle$, where $T$ is a propositional CNF formula that contains no empty clauses, and every $\\lambda_i$, $1 \\leq i \\leq n$, is a $[\\Sigma_i, \\sigma_T, \\Gamma_T]$-abstraction. Recall that by $\\sigma_T$ we denote the set of atoms that appear in $T$. A consistent and complete set $M$ of literals over $\\sigma_T$ is a model of an SMT program $\\langle T, \\lambda_1, \\ldots, \\lambda_n \\rangle$ if $M^+$ is a model of $T$ and $M$ is a $\\lambda_i$-model, for every $i$, $1 \\leq i \\leq n$.\n\nWe will now construct several abstract module systems that are equivalent to an SMT program $\\langle T, \\lambda_1, \\ldots, \\lambda_n \\rangle$. The propositional formula $T$ can be equivalently represented by modules $\\text{Ent}(T)$ and $\\text{UP}(T)$ introduced in Section 2.1. What remains is to construct modules to represent $[\\Sigma_i, \\sigma_T, \\Gamma_T]$-abstractions $\\lambda_i$.\n\nWe first define the notion of entailment for $[\\Sigma, \\sigma, \\Gamma]$-abstractions. Let $\\lambda$ be a $[\\Sigma, \\sigma, \\Gamma]$-abstraction, $l \\in \\sigma$ a literal, and $M$ a consistent set of literals over $\\sigma$. We say that $\\lambda$ entails $l$ w.r.t. $M$ when for every consistent set $M'$ of literals over $\\sigma$ that is\na superset of $M$ it holds that if $M'$ is a $\\lambda$-model then $l \\in M'$. We denote the fact that $\\lambda$ entails $l$ w.r.t. $M$ by $\\lambda[M] \\models l$. Note that if there is no single consistent set $M'$ of literals over $\\sigma$ such that $M \\subseteq M'$ and $M'$ is a $\\lambda$-model then, every literal $l \\in \\sigma$ is entailed by $\\lambda$ w.r.t. $M$.\n\nFor a $[\\Sigma, \\sigma, T]$-abstraction $\\lambda$, by $\\text{Ent}(\\lambda)$ we denote the module consisting of pairs $(M, l)$ that satisfy the following conditions: $M$ is a consistent set of literals over $\\sigma$ (in other words, $M \\in C(\\sigma)$), $l \\in \\text{Lit}(\\sigma) \\setminus M$, and $\\lambda[M] \\models l$.\n\nFor a $[\\Sigma, \\sigma, T]$-abstraction $\\lambda$, by $\\text{Min}(\\lambda)$ we denote the module consisting of pairs $(M, l)$ that satisfy the following conditions: $M$ is a consistent and complete set of literals over $\\sigma$, $l \\in \\text{Lit}(\\sigma) \\setminus M$, and $\\lambda[M] \\models l$. The $\\text{Min}$ module differs from the $\\text{Ent}$ module by only including inferences $(M, l)$, where $M$ is complete in addition to being consistent. Thus, it serves the purpose of spotting that set $M^+$ is not a $\\lambda$-model.\n\nAn AMS $\\mathcal{A}$ and an SMT program $P = \\langle T, \\lambda_1, \\ldots, \\lambda_n \\rangle$, are equivalent if for any consistent and complete set $M$ of literals over $\\sigma_T$, $M$ is a model of $P$ if and only if $M^+$ is a model of $\\mathcal{A}$. We are now ready to state a formal result relating SMT programs and abstract modular inference systems composed of introduced modules.\n\n**Proposition 14.** Every SMT program $P = \\langle T, \\lambda_1, \\ldots, \\lambda_n \\rangle$ is equivalent to any of the following abstract modular systems (over the vocabulary $\\sigma_T$)\n\n1. $\\{\\text{Ent}(T), \\text{Ent}(\\lambda_1), \\ldots, \\text{Ent}(\\lambda_n)\\}$,\n2. $\\{\\text{UP}(T), \\text{Ent}(\\lambda_1), \\ldots, \\text{Ent}(\\lambda_n)\\}$,\n3. $\\{\\text{Ent}(T), \\text{Min}(\\lambda_1), \\ldots, \\text{Min}(\\lambda_n)\\}$,\n4. $\\{\\text{UP}(T), \\text{Min}(\\lambda_1), \\ldots, \\text{Min}(\\lambda_n)\\}$.\n\nIt is interesting to note that replacing $\\text{Ent}(\\lambda_i)$ with $\\text{Min}(\\lambda_i)$ makes no difference for the semantics. However, the modular systems that result from such replacements capture different evaluation strategies of SMT solvers. In particular, the lazy evaluation strategy of SMT solvers [49] relies on the fact that the SMT program $P = \\langle T, \\lambda_1, \\ldots, \\lambda_n \\rangle$ is equivalent to the fourth abstract modular system in the proposition above.\n\nConstraint answer set programming [45,20,2,31,35] is another prominent multi-logic formalism. In SMT, theories are integrated with a propositional formula. In constraint answer set programming, theories (called constraints) are integrated with logic programs. A similar argument can be used to show that AMSs capture constraint answer set programs.\n\n### 4.3. Abstract AMS Solver\n\nWe now resume our study of general properties of abstract modular systems. For an AMS $\\mathcal{A} = \\{S_1, \\ldots, S_n\\}$, we define $\\mathcal{A}^\\cup = S_1 \\cup \\ldots \\cup S_n$. We can now state the result showing that modular systems can be expressed in terms of a single abstract inference module. We say that an AMS $\\mathcal{A}$ is equivalent to an abstract inference module $S$ if $\\mathcal{A}$ and $S$ have the same models.\n\n**Theorem 15.** Every abstract modular inference system $\\mathcal{A}$ is equivalent to the abstract inference module $\\mathcal{A}^\\cup$.\n\nThis theorem shows the value of our abstraction. Concrete modular systems composed from theories of different logics cannot be easily combined into single theory. In particular, the operation of union cannot be applied since the result might not belong to any well-defined formal system. However, once all modules of the system are expressed as abstract modules, the problem disappears. The corresponding abstract modules can be combined and the union operator is the right one for the task.\n\nWe use Theorem 15 to define for each AMS $\\mathcal{A}$ its transition graph $\\text{ams}_\\mathcal{A}$. Namely, we set $\\text{ams}_\\mathcal{A} = \\text{am}_{\\mathcal{A}^\\cup}$. Theorem 6 implies the following result.\n\n**Theorem 16.** For every AMS $\\mathcal{A}$,\n\n(a) the graph $\\text{ams}_\\mathcal{A}$ is finite and acyclic,\n(b) for any terminal state $M$ of $\\text{ams}_\\mathcal{A}$ other than $\\bot$, $[M]^+$ is a model of $\\mathcal{A}$,\n(c) the state $\\bot$ is reachable from $\\emptyset$ in $\\text{ams}_\\mathcal{A}$ if and only if $\\mathcal{A}$ is unsatisfiable.\n\nAs in several other similar results before, Theorem 16 shows that the graph $\\text{ams}_\\mathcal{A}$ is an abstract representation of a class of algorithms to decide satisfiability of a modular system $\\mathcal{A}$. An algorithm from the class searches for a path in $\\text{ams}_\\mathcal{A}$ that leads from node $\\emptyset$ to a terminal node. In each step, it extends the path with a node reachable from the currently last node by some edge originating in it. Theorem 16(a) guarantees that the method terminates, the other two parts of that result ensure correctness.\n\nFor instance, let $\\mathcal{A}$ be the AMS $\\{S_1, S_2\\}$, where $S_1$ is a module in Fig. 1(b) and $S_2$ is a module in Fig. 2. Below is a valid path in the transition graph $\\text{ams}_\\mathcal{A}$ with every edge annotated by the corresponding transition rule:\n\n\\[\n\\emptyset \\xrightarrow{\\text{Decide}} \\neg a \\xrightarrow{\\text{Inference Propagate}_{S_2}} \\neg a \\neg b \\xrightarrow{\\text{Inference Propagate}_{S_1}} \\neg a \\neg b \\neg a \\xrightarrow{\\text{Backtrack}} \\neg a \\xrightarrow{\\text{Decide}} a \\neg b. \n\\]\nThe state \\( a \\rightarrow b \\) is terminal. Thus, \\textbf{Theorem 16(b)} asserts that \\( \\{a\\} \\) is a model of \\( \\mathcal{A} \\). Let us interpret this example. Earlier we demonstrated that module \\( S_1 \\) can be regarded as a representation of a propositional theory consisting of a single clause \\( a \\) whereas \\( S_2 \\) corresponds to the logic program \\( (4) \\) under the semantics of answer sets. We then illustrated how modules \\( S_1 \\) and \\( S_2 \\) give rise to particular algorithms for implementing search procedures. The graph \\( \\text{AMS}_\\mathcal{A} \\) represents all algorithms obtained by integrating algorithms represented by the modules \\( S_1 \\) and \\( S_2 \\), respectively.\n\nWe will now discuss some classes of algorithms captured by the graph \\( \\text{AMS}_\\mathcal{A} \\). As before, they are more specifically determined by a strategy of selecting an outgoing edge from the current state. Let us assume that such a strategy is available for each module \\( S \\in \\mathcal{A} \\). Let us also assume that modules in \\( \\mathcal{A} \\) are prioritized. Since modular systems do not assume any inherent priorities among modules, we assume the priorities are provided by the user as input (or control parameter) to the algorithm. This leads to an algorithm that proceeds as follows (assuming \\( M \\) is the current state and it is not terminal):\n\n- If \\( M \\) is inconsistent, we always select the \\textit{Fail or Backtrack} edge (whichever is applicable);\n- If \\( M \\) is consistent then we select an edge determined by the edge-selection strategy for the highest priority module.\n\nAssuming that modules in \\( \\mathcal{A} \\) are enumerated \\( S_1, \\ldots, S_k \\) according to the descending priorities, the described algorithm works as follows. It starts by moving along edges implied by inferences of the module \\( S_1 \\) (according to the selection strategy for that module). If we reach \\( \\bot \\), the entire search is over with failure. Otherwise, we reach a consistent state, in which no further inference from module \\( S_1 \\) is applicable (that state represents a model of \\( S_1 \\)). The phase of search involving module \\( S_1 \\) gets suspended and we continue in the same way but now following edges determined by inferences in module \\( S_2 \\). In other words, we start the phase of the search involving module \\( S_2 \\). If we reach \\( \\bot \\), the search is over with failure. If we reach an inconsistent state that contains decision literals, we apply the \\textit{Backtrack} rule. If that rule backtracks to a literal introduced after we moved to module \\( S_2 \\), we remain in the module \\( S_2 \\) phase and continue. If the backtrack takes us back to a literal introduced while a higher priority module was considered (in this case, that must be module \\( S_1 \\)), we resume the module \\( S_1 \\) phase of the search suspended earlier. If \\textit{Inference Propagate} or \\textit{Decide} edges in module \\( S_2 \\) are available, we select one of them following the strategy for module \\( S_2 \\). If we reach a consistent state with no outgoing edges implied by inferences of \\( S_2 \\) (that state represents a model of both \\( S_1 \\) and \\( S_2 \\)) we suspend the module \\( S_2 \\) phase and start the module \\( S_3 \\) phase, and continue in that way until a terminal state is reached.\n\nThe main advantage of such an algorithm is that each phase is concerned only with inferences coming from a single module and state changes involve only literals from the vocabulary of that module. The literals established during phases involving higher priority modules remain fixed. Thus, the search space in each phase is effectively limited to that of the module involved in that phase.\n\nOur goal in this discussion is not to present a complete landscape of possible algorithmic instantiation of the graph \\( \\text{AMS}_\\mathcal{A} \\) but simply to show an example of such an instantiation. Clearly, other possibilities exist. For instance, the preference order may be dynamic. That is, once a model \\( M \\) of modules \\( S_1, \\ldots, S_i \\) is found, the next module to drive the search might be selected based on \\( M \\). We may also alternate between modules in a more arbitrary way, possibly switching from the current module to another even in situations when the current state has outgoing edges implied by the inferences of the current module. However, such algorithms may have to work with search spaces that are larger than the search space for a single module.\n\n**System DLVHEX** Our results apply to a version of the \\textsc{dlvhex} solver \\cite{15} restricted to logic programs. \\textsc{dlvhex} computes models of \\textit{HEX-programs} by exploiting their modularity, that is, representing programs as an equivalent modular program. Answer set programs consisting of rules of the form \\( (2) \\) form a special class of \\textit{HEX-programs}. Therefore, \\textsc{dlvhex} restricted to such programs can be seen as an answer set solver that exploits their modularity. Given a program \\( \\Pi \\), \\textsc{dlvhex} starts its operation by constructing a modular program \\( \\mathcal{P} = \\{\\Pi_1, \\ldots, \\Pi_n\\} \\) so that (i) \\( \\Pi = \\Pi_1 \\cup \\cdots \\cup \\Pi_n \\) and (ii) answer sets of \\( \\mathcal{P} \\) coincide with answer sets of \\( \\Pi \\). It then processes modules one after another according to an order determined by the structure of a program. That process can be modeled in abstract terms described above. In particular, the graph \\( \\text{AMS}_{\\text{UPUF}(\\Pi_1), \\ldots, \\text{UPUF}(\\Pi_n)} \\) can be seen as an abstraction capturing the family of \\textsc{dlvhex}-like algorithms based on \\textit{Unit Propagate} and \\textit{Unfounded} inferences.\\footnote{http://www.kr.tuwien.ac.at/research/systems/dlvhex/}\n\n**Model enumeration** By \\textbf{Theorem 15}, the problem of model enumeration for abstract modular systems can be reduced to the problem of model enumeration for a single module. Therefore, we do not discuss it here.\n\n5. Learning in solvers for AMSs\n\nNieuwenhuis et al. \\cite[Section 2.4]{49} defined the \\textit{DPLL-System-with-Learning} graph to describe SAT solvers’ learning, one of the crucial features of current SAT solvers responsible for rapid success in this area of automated reasoning. Their approach\n\n\\footnote{A modular structure of a program was exploited by other solvers, too \\cite{8, 19, 53}. However, in those efforts modularity (represented by strongly connected components of the positive dependency graph) was used to improve the performance of a specific propagator, namely, the one based on unfounded sets. Our approach is not meant to model that level of granularity in solver’s design.}\nextends to our abstract setting. Specifically, the graph $\\text{AMS}_A$ can be extended with “learning transitions” to represent solvers for AMSs that incorporate learning.\n\nThe intuition behind learning in SAT is to allow new propagations by extending the original set of clauses as computation proceeds. These additional “learned” clauses give rise to new inferences to a SAT solver by enabling additional applications of Unit Propagate. In abstract modules, a similar effect can be obtained by extending them with new inferences (pairs $(M, l)$). These inferences give rise to new edges in the transition graph via the rule Inference Propagate. Thus, they can be seen as “shortcuts” in the original graph leading to shorter paths to a terminal state. We now state these intuitions formally for the case of abstract modular systems.\n\nLet $S$ be a module and $E$ a set of inferences over $\\sigma_S$. By $S^E$ we denote the module constructed by adding to $S$ the inferences in $E$. A set $E$ of inferences over $\\sigma_S$ is $S$-safe if the module $S^E$ is equivalent to $S$.\n\nLet $A$ be an AMS and $E$ a set of inferences over $\\sigma_A$. For a module $S \\in A$, we define $E_{\\mid S}$ to be the set of all inferences in $E$ over the vocabulary $\\sigma_S$, and set $A^E_{\\mid S} = \\{S^E_{\\mid S} \\mid S \\in A\\}$. We say that $E$ is $A$-safe if $E = \\bigcup_{S \\in A} E_{\\mid S}$ (that is, if every inference in $E$ is an inference over $\\sigma_S$, for some $S \\in A$), and if the module $A^E_{\\mid S}$ is equivalent to $A$.\n\nAn (augmented) state relative to an $\\text{AMS}_A = \\{S_1, \\ldots, S_n\\}$ is either a distinguished state $\\bot$ or a pair of the form $M \\parallel \\Gamma_1, \\ldots, \\Gamma_n$, where $M$ is a state over the vocabulary $\\sigma_A$ and $\\Gamma_1, \\ldots, \\Gamma_n$ is a sequence of sets of inferences over the vocabularies of the modules $S_1, \\ldots, S_n$, respectively. Sometimes we denote the sequence $\\Gamma_1, \\ldots, \\Gamma_n$ by $G$. If $E$ is a set of inferences over the vocabulary $\\sigma_A$ and $G = \\Gamma_1, \\ldots, \\Gamma_n$, we define $G^E = \\Gamma_1 \\cup E_{\\mid S_1} \\cup \\cdots \\cup \\Gamma_n \\cup E_{\\mid S_n}$.\n\nEach $\\text{AMS}_A = \\{S_1, \\ldots, S_n\\}$ determines a graph $\\text{AMS}_{\\text{AMS}_A}$. Its nodes are the augmented states relative to $A$ and its transitions are specified in Figs. 9 and 10. The transitions in the first group are determined by individual modules, the transitions in the second group are “global.”\n\nTo illustrate the rule Learn Global, consider an AMS consisting of two modules:\n\n1. $F$ is a module over the vocabulary $\\{a_1, a_2\\}$ with no inferences. (Every consistent and complete set of literals over $\\{a_1, a_2\\}$ is its model.)\n2. $S$ is a module over the vocabulary $\\{a_1\\}$ of the form:\n\n $$\n \\begin{align*}\n &a_1 \\\\\n \\uparrow \\quad \\uparrow\n &\\neg a_1\n \\end{align*}\n $$\n\nThe inferences $(\\emptyset, a_1), (\\emptyset, \\neg a_1), ((a_1), \\neg a_1)$ and ($\\neg a_1, a_1$) are $(F, S)$-safe. Thus, we can apply the rule Learn Global with any subset of these inferences. This allows the future applications of Inference Propagate$_F$ to have access to these new inferences. Note that originally, Inference Propagate$_F$ has empty set of inferences to work with. Also, no $(F)$-safe inferences exist so that Learn Local$_F$ is inapplicable.\n\nWe refer to the transition rules Inference Propagate, Backtrack, Decide, and Fail of the graph $\\text{AMS}_{\\text{AMS}_A}$ as basic. We say that a node in the graph is semi-terminal if no basic rule is applicable to it. The graph $\\text{AMS}_{\\text{AMS}_A}$ can be used for deciding whether an AMS $A$ has a model by constructing a path from $\\emptyset \\parallel \\emptyset, \\ldots, \\emptyset$ to a semi-terminal node. We make this claim precise by stating the following theorem.\nTheorem 17. For every AMS \\( \\mathcal{A} \\),\n\n(a) the graph \\( \\text{amsL}_\\mathcal{A} \\) is finite and acyclic,\n(b) for any semi-terminal state \\( M \\| G \\) of \\( \\text{amsL}_\\mathcal{A} \\) reachable from \\( \\emptyset \\| \\emptyset, \\ldots, \\emptyset \\), \\( [M]^+ \\) is a model of \\( \\mathcal{A} \\),\n(c) state \\( \\perp \\) is reachable from \\( \\emptyset \\| \\emptyset, \\ldots, \\emptyset \\) in \\( \\text{amsL}_\\mathcal{A} \\) if and only if \\( \\mathcal{A} \\) has no models.\n\nIt follows that if we are constructing a path starting in \\( \\emptyset \\| \\emptyset, \\ldots, \\emptyset \\) then we will reach some semi-terminal state and at that point the task of finding a model of \\( \\mathcal{A} \\) is completed.\n\nWe stress that our discussion of learning does not aim at any specific algorithmic ways in which one could perform learning. Instead, we formulate conditions that learned inferences are to satisfy (S-safety for learning local to a module \\( S \\), and \\( \\mathcal{A} \\)-safety for the global learning rule), which ensure the correctness of solvers that implement learning. In this way, we provide a uniform framework for correctness proofs of multi-logic solvers incorporating learning.\n\nThere is an important difference between Learn Local and Learn Global. The first one allows new propagations within a module but does not change its semantics as the models of the module stay the same. Moreover, it is local, that is, other modules are unaffected by it. The application of Learn Global, while preserving the overall semantics of the system, may change the semantics of individual modules by eliminating some of their models. Moreover, being global, it affects in principle all modules of the system.\n\nSAT researchers have demonstrated that Learn Local is crucial for the success of SAT technology both in practice and theoretically [46,44]. In fact, local (conflict-driven) learning has become standard not only in SAT solvers [26], but also in ASP solvers [19]. Nieuwenhuis et al. [49] described a transition rule \\( T \\)-Learn for SMT that can be seen as a precursor of the Learn Global rule. It is a standard practice in SMT solving to implement \\( T \\)-Learn [49]. Eiter et al. [14] implement Learn Global in the system \\( \\text{dlvhex} \\) and report that this significantly decreases the runtime of the system. We now present theoretical analysis showing that in some cases, Learn Global has a potential to yield substantial performance benefits for modular systems.\n\nLet us consider a solver modeled within our abstract solving framework by imposing two restrictions. First, the transitions determined by the rule Learn Global are not allowed. We write \\( \\text{amsL}^- \\) for the graph obtained from the corresponding graph \\( \\text{amsL} \\) by removing the edges corresponding to the application of the rule Learn Global. Second, we assume that the solver proceeds (applies the rules) according to the ranking given by an enumeration of modules in the input AMS \\( \\mathcal{A} \\), say \\( \\mathcal{A} = \\{S_1, \\ldots, S_k\\} \\) (vide our discussion of solvers, and in particular of \\( \\text{dlvhex} \\), in an earlier section). We will now show that a solver of this type can reap significant performance benefits by incorporating the rule Learn Global. To show that let us consider a family \\( \\mathcal{A}_n = \\{F_n, S\\} \\ (n = 1, 2, \\ldots) \\) of AMSs, where:\n\n1. \\( F_n \\) is a module over the vocabulary \\( \\{a_1, \\ldots, a_n\\} \\) with no inferences. In particular, every consistent and complete set of literals over \\( \\{a_1, \\ldots, a_n\\} \\) is its model.\n2. \\( S \\) is a module as defined in the example prior to Theorem 17.\n\nAssuming that the module \\( F_n \\) is higher ranked than the module \\( S \\), solvers modeled by the graph \\( \\text{amsL}^- \\) and the ranking-based rule application will start with the module \\( F_n \\) and by applying Decide to all its atoms, arrive at one of the models of \\( F_n \\). Next, they will move the search to module \\( S \\) and in constant time discover a contradiction. Once the contradiction has been reached by means of rules in \\( S \\), the algorithm backtracks to module \\( F_n \\) and generates another model of \\( F_n \\). Then it moves on to \\( S \\) again, and again discovers a contradiction. The search terminates with failure only after all \\( 2^n \\) models of \\( F_n \\) have been inspected. Consequently, the search runs in time exponential in \\( n \\).\n\nThere are two inferences that could be learned and added to \\( S \\) by means of the rule Learn Local: \\((\\{a_1\\}, \\lnot a_1)\\) and \\((\\lnot a_1, a_1)\\). Indeed, both are \\( S \\)-safe. However, incorporating these two inferences in the module \\( S \\) does not improve the performance of the solver. It will still try all models of \\( F_n \\) and fail only after all of them were considered. Thus, local learning does not help reduce the running time.\n\nHowever, the inferences \\((\\emptyset, a_1)\\), \\((\\emptyset, \\lnot a_1)\\), \\((\\lnot a_1, a_1)\\) and \\((\\lnot a_1, a_1)\\) are \\( \\{F_n, S\\} \\)-safe. Applying the rule Learn Global with, say, \\((\\emptyset, a_1)\\) and \\((\\lnot a_1, a_1)\\), and incorporating these two inferences into \\( F_n \\), allows the solver to immediately terminate the search (it will apply the inference \\((\\emptyset, a_1)\\) followed by \\((\\lnot a_1, a_1)\\), and finally reach \\( \\perp \\) by applying the rule Fail). That search will run in time linear in \\( n \\) (essentially, the amount of time needed to reach the first conflict as all other steps take constant time). Thus, global learning results in an exponential speed up.\n\n6. Related work and future research\n\nIn an important development, Brewka and Eiter [6] introduced an abstract notion of a heterogeneous nonmonotonic multi-context system (MCS). One of the key aspects of that proposal is its abstract representation of a logic that allows one to study MCSs without regard to syntactic details. The independence of contexts from syntax has allowed researchers to focus on semantic aspects of multi-context systems. Since their inception, multi-context systems have received substantial attention and inspired implementations of hybrid reasoning systems including \\( \\text{dlvhex} \\) [15] and DMCS [16]. There are some similarities between AMSs and MCSs. However, there are also differences. First, MCSs provide an abstract framework to define seman-\ntics of hybrid systems. In contrast, AMSs explicitly represent inferences of a logic and provide an abstract framework for studying model generation algorithms.\n\nSecond, the two formalisms differ in how they share information among modules. MCSs use this to end the so-called “bridge rules.” In AMSs information sharing is implemented by a simple notion of sharing parts of the vocabulary between the modules. Rather non-surprisingly, bridge rules can simulate it. More interestingly, as our recent research on model-based abstract modular systems shows, despite its simplicity, information sharing through vocabulary sharing is expressive enough to capture the effects of bridge rules [39].\n\nModularity is one of the key techniques in principled software development. The importance of modularity has also been recognized in declarative programming languages rooted in KR&R such as answer set programming. In particular, Oikarinen and Janhunen [50] proposed a modular version of answer set programs called lp-modules. In that work, the authors were primarily concerned with the decomposition of lp-modules into sets of simpler ones. They proved that under some assumptions such decompositions are possible. Dao-Tran et al. [9] extend modularity to programs under the answer set semantics, whose models may have contextually dependent input provided by other modules. Janhunen [30] proposed the composition of hybrid reasoning systems using a general modular architecture that allows to combine propositional formulas as well as logic programs. Järvisalo, Oikarinen, Janhunen, and Niemelä [33], and Tasharrofi and Ternovska [54] studied different collections of operators to combine elementary abstract modules into more complex ones. We focused on building simple (flat-structured) modular systems that can be obtained from abstract modules by means of only one composition operator, the union (which implements the standard notion of the logical conjunction connective). In contrast to the work by Järvisalo et al. [33] and Tasharrofi and Ternovska [54], the conjunction (union) can be applied to any modules, no matter their internal structure and interdependencies between them. Whether our “union-based” modular systems can represent modular systems arising when other operators to combine modules are allowed is an interesting open question.\n\nTasharrofi, Wu, and Ternovska [55] proposed an algorithm for modular model expansion tasks, in particular, for the task of model generation, in the abstract multi-logic system setting developed by Tasharrofi and Ternovska [54]. They describe their algorithm by standard pseudocode and do not propose any abstract representations. Giunchiglia et al. [24] analyzed pseudocode descriptions of algorithms to study and relate several backtrack search procedures behind answer set solvers. In this work, we adapt an abstract graph-based framework for designing backtrack search algorithms for abstract modular systems. The benefits of that approach for modeling families of backtrack search procedures employed in SAT, ASP, and PC(ID) solvers were demonstrated by Nieuwenhuis et al. [49], Lierler [34], and Lierler and Truszczynski [36]. Our work provides additional support for the generality and flexibility of the graph-based framework as a finer abstraction of backtrack search algorithms than direct pseudocode representations, allowing for convenient means to prove correctness and study relationships between the families of the algorithms.\n\nGebser and Schaub [21] describe a form of a tableaux system to capture inferences involved in computing answer sets. Several rules used in their approach are closely related to those we discussed in the context of modules designed to represent reasoning on logic programs. However, the two approaches are formally different. Most notably, the concepts of states in a tableaux and in an abstract module are different. Still, there seems to be a connection between them, which we plan to investigate in our future work.\n\nBrain [5] introduces the concept of I-spaces meant to uniformly capture states of computation of search algorithms stemming from different logical formalisms. This way search algorithms can be uniformly described and compared. Similarly, D’Silva, Haller and Kroening [12] introduce a lattice-theoretic generalization of several logic-based formalisms including propositional satisfiability. They show that a conflict-driven-clause-learning algorithm of modern satisfiability solvers can be considered and analyzed in lattice-theoretic terms. It is an interesting question whether I-spaces of Brain or the lattice-theoretic approach of D’Silva et al. could be used to study modularity of multi-logic systems.\n\nBrochenin et al. [7] illustrated how the graph-based framework in spirit of Nieuwenhuis et al. can be lifted from capturing DPLL-like procedures to decision procedures at the second level of polynomial hierarchy. In the future we intend to investigate the applicability of the ideas by Brochenin et al. in the context of abstract modular inference systems and solvers.\n\nBarrett et al. [3] proposed the transition system DPLL(T₁,..., Tₙ) that captures the following architecture of an SMT solver: DPLL-based SAT solver plays the role of the master system coordinating the search process of distinct specialized solvers for theories T₁,..., Tₙ. The AMSL₄ transition system can be seen as a generalization of the DPLL(T₁,..., Tₙ) framework that (a) removes SAT solving as the distinguished component of an SMT solver, and (b) is agnostic about which theory solver plays the role of the master system.\n\n7. Conclusions\n\nIn this paper, we introduced abstract modules and abstract modular systems and showed that they provide a framework capable of capturing diverse logics and inference mechanisms integrated into modular knowledge representation systems. In particular, we showed that propositional theories and logic programs can be expressed as abstract inference modules, and that collections of propositional theories and logic programs can be represented as abstract modular systems. Even more importantly, we showed that satisfiability modulo theories can be translated to and studied in the language of abstract modular systems, too, thus demonstrating a broad scope of applicability of our formal framework.\nNext, we showed that transition graphs determined by modules and modular systems provide an elegant and effective unifying representation of model generating algorithms, or solvers, and simplify reasoning about such issues as correctness or termination. Our discussion of inference learning identified two types of learning relevant to computing models of modular systems — local and global. The former corresponds to learning studied before in SAT and SMT and shown both theoretically and practically to be essential for good performance. The latter, the global learning, is a new concept that arises in the context of modular systems. It concerns learning across modules and, as local learning, promises to lead to performance gains. In the future, we will conduct a systematic study of global learning and its impact on solvers for practical multi-logic formalisms.\n\nThe paper provides evidence that abstract inference modules, abstract modular systems and their transition graphs can be useful in theoretical studies of solver properties, and in the development of solvers for modular systems that combine theories from different logic formalisms.\n\nAcknowledgements\n\nWe are grateful to the reviewers for numerous comments that helped us to significantly improve the paper.\n\nAppendix A. Proofs\n\nProposition 1. Abstract inference modules $S_1$ and $S_2$ are equivalent if and only if they have the same models contained in the set $\\sigma_{S_1} \\cup \\sigma_{S_2}$. \n\nProof. ($\\Rightarrow$) Evident. ($\\Leftarrow$) Assume that $S_1$ and $S_2$ have the same models contained in the set $\\sigma_{S_1} \\cup \\sigma_{S_2}$. To prove the implication, it suffices to show that if $X$ is a model of $S_1$ then $X$ is a model of $S_2$. To simplify the notation, we define $\\delta = \\sigma_{S_1} \\cup \\sigma_{S_2}$ and $X_0 = X \\cap \\delta$.\n\nLet $(M, I)$ be an inference of $S_1$ such that $M$ is consistent with $X_0$. Since $M \\subseteq \\text{Lit}(\\delta)$, $M$ is consistent with $X$. It follows that $I$ is consistent with $X$. Since $I \\in \\text{Lit}(\\delta)$, $I$ is consistent with $X_0$. Thus, $X_0$ is a model of $S_1$. By the assumption, $X_0$ is a model of $S_2$.\n\nLet $(M', I')$ be an inference of $S_2$ such that $M'$ is consistent with $X$. Since $M' \\subseteq \\text{Lit}(\\delta)$, $M'$ is consistent with $X_0$. We recall that $X_0$ is a model of $S_2$. Thus, $I'$ is consistent with $X_0$ and, since $I' \\in \\text{Lit}(\\delta)$, also with $X$. It follows that $X$ is a model of $S_2$.\n\nProposition 2. Let $S$ be a module and $(M, I)$ an inference in $S$. Then $S \\models_M I$.\n\nProof. Let $X$ be a model of $S$ such that $M$ is consistent with $X$. By the definition of a model of a module, $I$ is consistent with $X$ and the result follows.\n\nProposition 3. Let $S_1$ and $S_2$ be abstract inference modules. A set $X$ is a model of $S_1 \\cup S_2$ if and only if $X$ is a model of $S_1$ and $S_2$.\n\nProof. The assertion is an immediate consequence of definitions. Let $X$ be a model of $S_1 \\cup S_2$ and $(M, I)$ be an inference of $S_1$ such that $M$ is consistent with $X$. Since $(M, I)$ is an inference of $S_1 \\cup S_2$, $I$ is consistent with $X$ and, so, $X$ is a model of $S_1$. The case of $(M, I)$ being an inference of $S_2$ and the converse implication can be proved in a similar way.\n\nProposition 4. For every propositional theory $T$ (respectively, CNF formula $T$ containing no empty clause), $\\text{Ent}(T)$ (respectively, $\\text{UP}(T)$) is equivalent to $T$.\n\nProof. We denote by $\\sigma_T$ the vocabulary that consists of atoms occurring in $T$ (and $\\text{Ent}(T)$).\n\n**Statement 1:** For every propositional theory $T$, $\\text{Ent}(T)$ is equivalent to $T$. Let $X$ be a model of $T$ and $(M, I)$ an inference of $\\text{Ent}(T)$ such that $M$ is consistent with $X$. Clearly, $X$ is a model of $M$. Since $T \\cup M \\models_I I$ and $X$ is a model of $T \\cup M$, $X$ is model of $I$, that is, $I$ is consistent with $X$. We derive that $X$ is a model of $\\text{Ent}(T)$.\n\nConversely, let $X$ be a model of $\\text{Ent}(T)$ and let us define $M = (X \\cap \\sigma_T) \\cup \\{\\neg a : a \\in \\sigma_T \\setminus X\\}$. Clearly, $M$ is consistent with $X$. We now proceed by contradiction. Assume that $X$ is not a model of $T$. Then, $T \\cup M$ is inconsistent. Let $I$ be any literal in $M$ and $M' = M \\setminus \\{I\\}$. It follows that $T \\cup M' \\models_I I$ (indeed, since $T \\cup M$ is inconsistent, every model of $T \\cup M'$, must be consistent with $I$). By definition, $(M', I) \\in \\text{Ent}(T)$. From the fact that $M$ is consistent with $X$ and $M' \\subset M$, we derive that $M'$ is consistent with $X$. Since $X$ is a model of $\\text{Ent}(T)$, $I$ is consistent with $X$. On the other hand, $I \\in M$ and $M$ is consistent with $X$. Thus, $I$ is consistent with $X$, a contradiction.\n\n**Statement 2:** For every CNF formula $T$ containing no empty clause, $\\text{UP}(T)$ is equivalent to $T$. Let $X$ be a model of $T$ and $(M, I)$ an inference of $\\text{UP}(T)$ such that $M$ is consistent with $X$. It follows that $T$ has a clause $C \\lor l$ such that for every literal $u$ of $C$, $u \\in M$. Thus, all literals $u$, $u \\in C$, are consistent with $X$, that is, $X$ is a model of $\\neg C$. Since $X$ is a model of $T$, $X$ is a model of $l$, that is, $I$ is consistent with $X$. We derive that $X$ is a model of $\\text{UP}(T)$.\nConversely, let X be a model of UP(T). We proceed by contradiction. Assume that X is not a model of T. Then there is a clause C in T such that X is a model of \\( \\neg C \\). Let us assume that \\( C = u_1 \\lor \\ldots \\lor u_k \\). It follows that the set \\( \\{ \\Pi_1, \\ldots, \\Pi_k \\} \\) is consistent with X. Since C is a clause of T and T contains no empty clause, \\( k \\geq 1 \\). Moreover, since C is not a tautology (we recall that X is a model of \\( \\neg C \\)), \\( u_k \\notin \\{ \\Pi_1, \\ldots, \\Pi_{k-1} \\} \\). By the definition of UP(T), \\( \\{ \\Pi_1, \\ldots, \\Pi_{k-1} \\}, u_k \\in UP(T) \\). Since \\( \\{ \\Pi_1, \\ldots, \\Pi_{k-1} \\} \\) is consistent with X and X is a model of UP(T), \\( u_k \\) is consistent with X, a contradiction. □\n\nWe recall that if \\( \\Pi \\) is a program, \\( \\sigma_\\Pi \\) denotes the vocabulary that consists of atoms occurring in \\( \\Pi \\). It is obvious that \\( \\sigma_\\Pi \\) also coincides with the set of atoms occurring in the modules \\( UP(\\Pi), UF(\\Pi), UPUF(\\Pi) \\) and \\( smodels(\\Pi) \\).\n\n**Proposition 5.** Every logic program \\( \\Pi \\) is equivalent to the modules UPUF(\\( \\Pi \\)) and smodels(\\( \\Pi \\)).\n\n**Proof.** Statement 1: Every logic program \\( \\Pi \\) is equivalent to the module UPUF(\\( \\Pi \\)). Let X be an answer set of \\( \\Pi \\). By definition, X is a model of \\( \\Pi^{cl} \\) and X does not have any non-empty subset that is unfounded on X with respect to \\( \\Pi \\). We start by showing that X is a model of UPUF(\\( \\Pi \\)). We then demonstrate that X is a model of UF(\\( \\Pi \\)). By Proposition 3, it will immediately follow that X is a model of UPUF(\\( \\Pi \\)).\n\nLet \\( (M, l) \\) be any inference in UPUF(\\( \\Pi \\)) such that M is consistent with X. Since \\( (M, l) \\in UPUF(\\Pi) \\), \\( \\Pi^{cl} \\) has a clause C \\( \\lor l \\) (modulo a reordering of literals) such that for every literal \\( u \\in C \\), \\( \\Pi \\in M \\). Thus, all literals \\( \\Pi \\), \\( u \\in C \\), are consistent with X, that is, X is a model of \\( \\Pi^{cl} \\). Since X is a model of \\( \\Pi^{cl} \\), X is a model of l, that is, l is consistent with X. Thus, X is a model of UPUF(\\( \\Pi \\)).\n\nLet \\( (M, l) \\) be any inference in X such that M is consistent with X. By the definition of UF(\\( \\Pi \\)), there is an atom \\( a \\in \\sigma_{\\Pi} \\) such that \\( l = a \\) and \\( a \\in U \\), for some set \\( U \\in Unf(M, \\Pi) \\). Since M is consistent with X, \\( \\Pi \\) and \\( U \\) is also unfounded on \\( X \\cup \\{ \\neg a : a \\in \\sigma_{\\Pi} \\setminus X \\} \\) with respect to \\( \\Pi \\). By the definition of an answer set, \\( a \\notin X \\). Consequently, \\( l = a \\) is consistent with X. It follows that X is a model of UF(\\( \\Pi \\)) and, by the comment above, a model of UPUF(\\( \\Pi \\)).\n\nConversely, let \\( X \\subseteq \\sigma_{\\Pi} \\) be a model of UPUF(\\( \\Pi \\)). By Proposition 3, X is a model of UPUF(\\( \\Pi \\)) and a model of UF(\\( \\Pi \\)). Let us assume that X is not an answer set of \\( \\Pi \\).\n\nCase 1: X is not a model of \\( \\Pi^{cl} \\). Then there is a clause C in \\( \\Pi^{cl} \\) such that X is a model of \\( \\neg C \\). Let us assume that \\( C = u_1 \\lor \\ldots \\lor u_k \\). It follows that the set \\( \\{ \\Pi_1, \\ldots, \\Pi_k \\} \\) is consistent with X. Since C is a clause of \\( \\Pi^{cl} \\), \\( k \\geq 1 \\). Moreover, since C is not a tautology, \\( u_k \\notin \\{ \\Pi_1, \\ldots, \\Pi_{k-1} \\} \\). By the definition of UPUF(\\( \\Pi \\)), \\( \\{ \\Pi_1, \\ldots, \\Pi_{k-1} \\}, u_k \\in UPUF(\\Pi) \\). Since \\( \\{ \\Pi_1, \\ldots, \\Pi_{k-1} \\} \\) is consistent with X and X is a model of UPUF(\\( \\Pi \\)), \\( u_k \\) is consistent with X, a contradiction.\n\nCase 2: X contains an element, say a, that belongs to a set that is unfounded on \\( X \\cup \\{ \\neg a : a \\in \\sigma_{\\Pi} \\setminus X \\} \\) with respect to \\( \\Pi \\). By the definition of the rule Unfounded, we conclude that \\( X \\cup \\{ \\neg a : a \\in \\sigma_{\\Pi} \\setminus X \\}, \\neg a \\in UF(\\Pi) \\). Since X is a model of UF(\\( \\Pi \\)) and is consistent with \\( X \\cup \\{ \\neg a : a \\in \\sigma_{\\Pi} \\setminus X \\} \\), \\( \\neg a \\) is consistent with X, a contradiction.\n\n**Statement 2:** Every logic program \\( \\Pi \\) is equivalent to the module smodels(\\( \\Pi \\)). Let X be an answer set of \\( \\Pi \\). By Statement 1, X is a model of UPUF(\\( \\Pi \\)) and UF(\\( \\Pi \\)). Since ARC(\\( \\Pi \\)) \\( \\subseteq UF(\\Pi) \\), X is a model of ARC(\\( \\Pi \\)). The proof that X is also a model of BC(\\( \\Pi \\)) uses the well-known fact that if X is an answer set of \\( \\Pi \\), X is also a supported model of \\( \\Pi \\) that is, for every \\( a \\in X \\), there is \\( B \\in Bodies(\\Pi) \\) such that X is a model of s(\\( B \\)). Let us consider an inference \\( (M,l) \\in BC(\\Pi) \\) such that M is consistent with X. By the definition of BC(\\( \\Pi \\)), there is a rule \\( a \\leftarrow B \\) in \\( \\Pi \\) such that \\( a \\in M \\), \\( l \\in s(B) \\), and for every \\( B' \\in Bodies(\\Pi, a) \\) such that s(\\( B' \\)) \\( \\neq \\) s(\\( B \\)), there is \\( u \\in s(B') \\) such that \\( u \\in M \\). Let \\( a \\leftarrow B' \\) be a rule in \\( \\Pi \\) such that s(\\( B' \\)) \\( \\neq \\) s(\\( B \\)) and let \\( u \\in s(B') \\) be such that \\( u \\in M \\). Since M is consistent with X, X is not a model of u (if \\( u = b \\), for some atom b, \\( \\neg b \\in M \\) and so, \\( b \\notin X \\); if \\( u = \\neg b \\), for some atom b, \\( b \\in M \\) and so, \\( b \\in X \\)). It follows that X is not a model of s(\\( B' \\)) for any rule \\( a \\leftarrow B' \\) in \\( \\Pi \\), where s(\\( B' \\)) \\( \\neq \\) s(\\( B \\)). Since X is a supported model of \\( \\Pi \\) and \\( a \\in X \\), X must be a model of s(B). In particular, X is a model of l, that is, l is consistent with X. Thus, X is a model of the inference \\( (M,l) \\) and so, a model of BC(\\( \\Pi \\)). By Proposition 3, X is a model of smodels(\\( \\Pi \\)).\n\nConversely, let \\( X \\subseteq \\sigma_{\\Pi} \\) be a model of smodels(\\( \\Pi \\)). By the definitions of UPUF(\\( \\Pi \\)) and smodels(\\( \\Pi \\)), UPUF(\\( \\Pi \\)) \\( \\subseteq \\) smodels(\\( \\Pi \\)). Thus, X is a model of UPUF(\\( \\Pi \\)). By Statement 1, X is an answer set of \\( \\Pi \\). □\n\nSince states are sequences of literals, we will often refer to prefixes of states. Formally, given a state \\( l_1 l_2 \\ldots l_n \\), every sequence \\( l_1 l_2 \\ldots l_k \\), where \\( 0 \\leq k \\leq n \\), is its prefix. In particular, each state is its own prefix.\n\n**Lemma 18.** Let S be an abstract inference module and N a non-fail state in the transition system AM_S reachable in AM_S from \\( \\emptyset \\). For every prefix M’ of N and for every model X of S, if every decision literal of M’ is consistent with X, then \\( [M'] \\) is consistent with X.\n\n**Proof.** We proceed by induction on the length of a path from \\( \\emptyset \\) to N in AM_S. If that length is 0, \\( N = \\emptyset \\) and the claimed property trivially holds. Let us consider a non-fail state N reachable from \\( \\emptyset \\) by a path \\( p \\) of length \\( k > 0 \\) and let us assume that every non-fail state reachable in AM_S from \\( \\emptyset \\) by a path of length at most \\( k - 1 \\) has the claimed property. Let M’ be the state preceding N on \\( p \\). Since M’ is reachable from \\( \\emptyset \\) by a path of length \\( k - 1 \\), it follows by the induction hypothesis that M’ has the claimed property. That is, for every prefix M” of M’ (including M” = M’) and for every model X of S, if every decision literal in M” is consistent with X then \\( [M’] \\) is consistent with X.\nLet $N$ be of the form $l_1 \\ldots l_n$.\\footnote{As we move from a state to a non-fail state in the transition, the state can grow or shrink, the latter when the rule Backtrack is used. Thus, we have that $n \\leq k$ and, in general, the inequality is strict.} Since $N$ is reached from $M'$ by an edge resulting from Inference Propagate, Backtrack or Decide (applying the rule Fail results in the state $\\bot$), $l_1 \\ldots l_{n-1}$ is a prefix of $M'$.\n\nLet $X$ be a model of $S$ and $M''$ a prefix of $N$ such that all decision literals in $M''$ are consistent with $X$. If $M''$ is a prefix of $l_1 \\ldots l_{n-1}$, then $M''$ is a prefix of $M'$. By the observation above, $[M'']$ is consistent with $X$. In particular, if all decision literals in $l_1 \\ldots l_{n-1}$ are consistent with $X$, $[l_1 \\ldots l_{n-1}]$ is consistent with $X$.\n\nThe only other case is $M'' = N$. Since all decision literals in $N$ are consistent with $X$, all decision literals of $l_1 \\ldots l_{n-1}$ are consistent with $X$. Thus, by the observation above, $[l_1 \\ldots l_{n-1}]$ is consistent with $X$. To complete the proof, we have to show that $l_n$ is consistent with $X$. The edge connecting $M'$ to $N = l_1 \\ldots l_n$ in $\\mathsf{AMP}_S$ is not generated by the rule Fail. This leaves us with three cases to consider.\n\n**Inference Propagate:** In this case, $M' = l_1 \\ldots l_{n-1}$, $[M']$ is consistent, $l_n \\notin [M']$ and for some $M'' \\subseteq [M']$, $(M'', l_n)$ is an inference of $S$. By Proposition 2, $S \\models M'' l_n$. Since $[M']$ is consistent with $X$, $M''$ is consistent with $X$ and so, $l_n$ is consistent with $X$.\n\n**Backtrack:** In this case, $M'$ has the form $l_1 \\ldots l_{n-1} l_n^\\perp Q$, where $Q$ contains no decision literals, and $[M'] = [l_1 \\ldots l_{n-1}] Q$ is inconsistent. Let us assume that $l_n$ is not consistent with $X$. It follows that $l_n$ is consistent with $X$. Consequently, all decision literals of $M'$ are consistent with $X$. By the induction hypothesis, $[M']$ is consistent with $X$, a contradiction. Thus, $l_n$ is consistent with $X$.\n\n**Decide:** In this case, $M' = l_1 \\ldots l_{n-1}$ and $l_n$ is a decision literal. Since all decision literals of $M$ are consistent with $X$ then, trivially, $[l_n]$ is consistent with $X$. \\hfill $\\Box$\n\n**Theorem 6.** For every module $S$,\n\n(a) graph $\\mathsf{AM}_S$ is finite and acyclic,\n\n(b) for any terminal state $M$ of $\\mathsf{AM}_S$ other than $\\bot$, $\\lceil M \\rceil^+$ is a model of $S$,\n\n(c) state $\\bot$ is reachable from $\\emptyset$ in $\\mathsf{AM}_S$ if and only if $S$ is unsatisfiable (has no models).\n\n**Proof.** Part (a) can be proved following the argument for Proposition 1 in the paper by Lierler [34]. It also follows as a corollary from Theorem 11(a), to which we provide an explicit proof later on.\n\n(b) Let $M$ be a terminal state of $\\mathsf{AM}_S$ other than $\\bot$. Since neither Fail nor Backtrack is applicable, $[M]$ is consistent. Since Decide is not applicable, $[M]$ assigns all literals, that is, $[M]$ is complete. Let $(M', l)$ be an inference of $S$ such that $M'$ is consistent with $[M]^+$. It follows that $M' \\subseteq [M]$. Since Inference Propagate is not applicable, $l \\in M$. Thus, $l$ is consistent with $[M]^+$. It follows that $[M]^+$ is a model of $S$.\n\n(c) Left-to-right: Since $\\bot$ is reachable from $\\emptyset$, there is a state $M$ without decision literals such that there is a path in $\\mathsf{AM}_S$ from $\\emptyset$ to $M$, and there is an edge from $M$ to $\\bot$ in $\\mathsf{AM}_S$ due to the application of Fail. It follows that $[M]$ is consistent. By Lemma 18, $[M]$ is consistent with every model of $S$ (indeed, $M$ has no decision literals). Since $[M]$ is inconsistent, $S$ has no models.\n\nRight-to-left: From (a) it follows that there is a path in $\\mathsf{AM}_S$ from $\\emptyset$ to some terminal state. Since $S$ has no models, (b) implies that this state must be $\\bot$. \\hfill $\\Box$\n\n**Proposition 7.** For every CNF formula $F$ with no empty clause, $\\mathsf{DPI} = \\mathsf{AM}_{\\mathsf{UP}(F)}$.\n\n**Proof.** It is clear that the two graphs have the same sets of nodes ($\\bot$ and all states over the vocabulary $\\sigma_F$). It is also clear that both graphs have the same edges arising from the generic rules Fail, Backtrack and Decide. Thus, let us consider an edge in $\\mathsf{DPI}$ implied by the rule Unit Propagate. By definition, this edge has the form $(M, Ml)$, where $[M] \\subseteq \\mathsf{Lit}(\\sigma_F)$ is consistent, $l \\in \\mathsf{Lit}(\\sigma_F) \\setminus M$, and there is a clause $C \\lor l \\in F$ such that for every literal $u \\in C, \\overline{u} \\in [M]$. It follows that $([M], l) \\in \\mathsf{UP}(F)$ and, by the definition of Inference Propagate, $(M, Ml)$ is an edge of $\\mathsf{AM}_{\\mathsf{UP}(F)}$.\n\nConversely, let us consider an edge of $\\mathsf{AM}_{\\mathsf{UP}(F)}$ implied by Inference Propagate. This edge is of the form $(M, Ml)$, where $[M] \\subseteq \\mathsf{Lit}(\\sigma_F)$ is consistent, $l \\in \\mathsf{Lit}(\\sigma_F) \\setminus M$, and for some $M' \\subseteq [M]$, $(M', l)$ is an inference of $\\mathsf{UP}(F)$. It follows that there is a clause $C \\lor l \\in F$, such that for every literal $u \\in C, \\overline{u} \\in [M']$. Consequently, for every literal $u \\in C, \\overline{u} \\in [M]$ and so, $(M, Ml)$ is an edge of $\\mathsf{DPI}$. \\hfill $\\Box$\n\n**Proposition 9.** For every logic program $\\Pi$, $\\mathsf{SM}_\\Pi = \\mathsf{AM}_{\\mathsf{models}(\\Pi)}$.\n\n**Proof.** The proof follows the same line of argument as the previous one and is an immediate consequence of the definitions. \\hfill $\\Box$\n\nWe say that a sequence $M'$ extends a sequence $M$ if $M$ is a prefix of $M'$; moreover, $M'$ properly extends $M$ if $M'$ extends $M$ and $M \\neq M'$. We recall that states other than the fail state $\\bot$ are sequences and note that the following lemma follows directly from the definitions of the transition rules.\nLemma 19. If $M \\neq \\bot$ is a state in $\\text{AM}_S$ and $M'$ is a successor of $M$ such that $M' \\neq \\bot$, then $M'$ is a proper extension of $M$ or $M' = P \\overline{l}$, where $l$ is the last decision literal in $M = P \\overline{l} Q$.\n\nLemma 20. Let $S$ be an abstract module. For every path $p$ in $\\text{AM}_S$ starting in a state $M$, every state that follows $M$ on $p$ is equal to $\\bot$, or is a proper extension of $M$, or contains a literal $l$, for some decision literal $l \\overline{l}$ in $M$.\n\nProof. We prove the statement by induction on the number of decision literals $k$ in $M$. Let $k = 0$. Then, $M = \\bot$ or $M$ is a sequence of non-decision literals. In the first case, path $p$ consists of $M$ only and the assertion is trivially true (there are no nodes on $p$ that follow $M$). In the second case, Lemma 19 and a simple inductive argument imply that every state on $p$ that follows $M$, other than $\\bot$, has $M$ as its proper prefix.\n\nThus, let $k \\geq 1$ and let us assume that the assertion holds for every path originating in a state with at most $k - 1$ decision literals. For the induction step, let us consider a state $M = P_1 \\overline{l}_1 P_2 \\overline{l}_2 \\ldots P_k \\overline{l}_k$, where $P_1, \\ldots, P_k$ contain no decision literals. If all states on $p$ contain $l_i \\overline{l}_i$ then, by Lemma 19 and a simple induction, all states that follow $M$ on $p$ are of the form $M Q$, for some non-empty sequence $Q$ of literals (possibly annotated) that are unassigned in $M$. Thus, the assertion follows. Otherwise, let $M'$ be the first state on $p$ not containing $\\overline{l}_i$. By Lemma 19 and a simple inductive argument, all states on $p$ strictly between $M$ and $M'$ properly extend $M$ and $M' = P_1 \\overline{l}_i P_2 \\overline{l}_2 \\ldots P_k \\overline{l}_k$. In particular, $\\overline{l}_i \\in M'$. Moreover, by the induction hypothesis, every state that follows $M'$ on $p$ is equal to $\\bot$, is an extension of $M'$ and, consequently, contains $\\overline{l}_i$, or contains $\\overline{l}_i$, for some $i$, $1 \\leq i \\leq k - 1$. Thus, the assertion follows in this case, too. □\n\nTheorem 11. For every abstract inference module $S$,\n\n(a) the graph $\\text{AM}_S$ is finite and acyclic,\n(b) the $\\bot$ state is reachable from $\\emptyset$,\n(c) for every path from $\\emptyset$ to $\\bot$ in $\\text{AM}_S$, the set of states in which the rule Enumerate applies is precisely the set of models of $S$ over $\\sigma_S$, and for each model $X$ of $S$ over $\\sigma_S$ there is exactly one state $M$ on the path such that $X = \\{M\\}$.\n\nProof. (a) Finiteness of $\\text{AM}_S$ is evident. Let us assume that there is a cycle in $\\text{AM}_S$. Then, there is a path in $\\text{AM}_S$ that starts in a state $M$ and returns to $M$ after traversing a positive number of edges. That contradicts Lemma 20. (b) It is easy to see that every path ending in a state other than $\\bot$ can be extended. Since $\\text{AM}_S$ is acyclic, following outgoing edges of nodes in $\\text{AM}_S$ (breaking ties in an arbitrary way, if more than one rule applies) eventually takes us to $\\bot$. (c) We note that (i) the states of graphs $\\text{AM}_S$ and $\\text{AM}_S$ coincide, and (ii) each edge of the graph $\\text{AM}_S$ is also an edge of the graph $\\text{AM}_S$. Also, for every terminal state $M$ of $\\text{AM}_S$ other than $\\bot$, the rule Enumerate is the only transition rule applicable to $M$ in $\\text{AM}_S$. By Theorem 6(b), it follows that $\\{M\\}$ is a model of $S$. Thus, if $M$ is a state on a path $p$ from $\\emptyset$ to $\\bot$ in $\\text{AM}_S$, and the edge on $p$ leading from $M$ to the next state on the path is determined by Enumerate, then $\\{M\\}$ is a model of $S$.\n\nTo conclude the proof, we show that every model of $S$ over $\\sigma_S$ will eventually be reached by any path from $\\emptyset$ to $\\bot$. Let $X$ be a model of $S$ over $\\sigma_S$. Consider any path $p$ from $\\emptyset$ to $\\bot$ in $\\text{AM}_S$. Let $P$ denote the longest prefix of a state on $p$ such that $\\{P\\} \\subseteq X$. Let $M$ denote the first state on $p$ such that $P$ is a prefix of $M$. We will show that $M = P$ and $\\{P\\} = X = \\{M\\}$.\n\nCase 1. $M = P Q$, where $Q$ is a nonempty sequence of literals. It follows that $M \\neq \\emptyset$ and that $M$ was obtained from its predecessor on $p$, say $M'$, by means of one of the rules of $\\text{AM}_S$ other than the Fail rule. It follows that $P$ is the prefix of $M'$. This contradicts the fact that $M$ is the first state on $p$ such that $P$ is a prefix of $M$.\n\nCase 2. $M = P$. It remains to show that $\\{P\\} = X$. We recall that $\\{P\\} \\subseteq X$. Towards a contradiction, let us assume that $\\{P\\} \\subset X$. It follows that (i) $P$ is consistent and (ii) $X \\setminus \\{P\\}$ is nonempty and contains literals that are unassigned by $\\{P\\}$. By (i), rules Fail and Backtrack are not applicable. By (ii), rule Decide is applicable and hence rule Enumerate is not applicable. By $P'$ we denote the successor state for $P$ on $p$. Let us assume that $P'$ is generated by the Unit Propagate rule. Then, $P' = PI$ and since $P$ is consistent with $X$ and $X$ is a model of $S$, $l$ is consistent with $X$ and so, $l \\in X$. This contradicts the fact that $P$ is the longest prefix of any state on $p$ such that $\\{P\\} \\subseteq X$. Thus, $P'$ is obtained from $P$ by the Decide rule and so, $P' = PI^\\Delta$. Since $P$ is the longest prefix of any state on $p$ such that $\\{P\\} \\subseteq X$, $l \\notin X$. The path $p$ can only terminate by entering $\\bot$ from a state with no decision literals by an application of either Enumerate or Fail rule. Let $M'$ be the first state on $p$ after $M$ that does not contain $I^\\Delta$. By Lemma 19 and a simple inductive argument, $M' = PI$. We recall that $l \\notin X$. Thus, $l \\in X$ and $\\{P\\} \\subseteq X$, a contradiction.\n\nFrom Lemma 20 it immediately follows that we will not encounter two states encoding the same model on any path in $\\text{AM}_S$. □\n\nProposition 12. Every program $\\Pi$ is input-equivalent to the module $\\text{UPUF}'(\\Pi)$.\n\nProof. By definition, $X$ is an input answer set of $\\Pi$ if and only if $X$ is an answer set of $\\Pi \\cup (X \\setminus \\text{Head}(\\Pi))$. By Proposition 5, $X$ is an answer set of $\\Pi \\cup (X \\setminus \\text{Head}(\\Pi))$ if and only if $X$ is a model of $\\text{UPUF}(\\Pi \\cup (X \\setminus \\text{Head}(\\Pi)))$. Thus, to complete the proof it suffices to show that $X$ is a model of $\\text{UPUF}'(\\Pi)$ if and only if $X$ is a model of $\\text{UPUF}(\\Pi \\cup (X \\setminus \\text{Head}(\\Pi)))$. □\nLet us assume that $X$ is a model of $\\text{UPUF}(\\Pi \\cup (X \\setminus \\text{Head}(\\Pi)))$. Let $(M, l)$ be an inference of $\\text{UPUF}'(\\Pi)$ such that $M$ is consistent with $X$. To prove that $X$ is a model of $\\text{UPUF}'(\\Pi)$ we need to show that $l$ is consistent with $X$. If $(M, l)$ is implied by the rule $\\text{Unit Propagate}$ then, clearly, $(M, l)$ is also an inference of $\\text{UPUF}(\\Pi \\cup (X \\setminus \\text{Head}(\\Pi)))$. Since $X$ is a model of that module and $M$ is consistent with $X$, $l$ is consistent with $X$.\n\nThus, let us assume that $(M, l)$ is implied by the rule $\\text{Unfounded}'$. It follows that $l = \\neg a$ and that for some set $U$, $U$ is unfounded on $M$ w.r.t. $\\Pi$, $a \\in U$, and for every $b \\in U$, $b \\in \\text{Head}(\\Pi)$ or $\\neg b \\in M$. Let us assume that $a \\in X$. Since $M$ is consistent with $X$ and $X$ is a model of $\\text{UPUF}(\\Pi \\cup (X \\setminus \\text{Head}(\\Pi)))$, $(M, \\neg a)$ is not an inference of $\\text{UPUF}(\\Pi \\cup (X \\setminus \\text{Head}(\\Pi)))$. In particular, it follows that $U$ is not unfounded on $M$ w.r.t. $\\Pi \\cup (X \\setminus \\text{Head}(\\Pi))$. Since $U$ is unfounded on $M$ w.r.t. $\\Pi$, we obtain that $U \\cap (X \\setminus \\text{Head}(\\Pi)) \\neq \\emptyset$. Let $b \\in U \\cap (X \\setminus \\text{Head}(\\Pi))$. Then $b \\in U$, $b \\in X$ and $b \\notin \\text{Head}(\\Pi)$. By the properties of $U$, $\\neg b \\in M$. Since $M$ is consistent with $X$, $b \\notin X$, a contradiction. Thus, $a \\notin X$ and so, $\\neg a$ (that is, $l$) is consistent with $X$.\n\nConversely, let us assume that $X$ is a model of $\\text{UPUF}'(\\Pi)$ and let $(M, l)$ be an inference of $\\text{UPUF}(\\Pi \\cup (X \\setminus \\text{Head}(\\Pi)))$ such that $M$ is consistent with $X$. We will show that $l$ is consistent with $X$. This property will imply that $X$ is a model of $\\text{UPUF}'(\\Pi)$, thus completing the argument.\n\nCase 1. The inference $(M, l)$ is determined by the rule $\\text{Unit Propagate}$ applied to a clause from $\\Pi^{\\Pi}$. It follows that $(M, l)$ is also an inference of the module $\\text{UPUF}(\\Pi)$. Since $X$ is a model of $\\text{UPUF}(\\Pi)$ and $M$ is consistent with $X$, $l$ is consistent with $M$.\n\nCase 2. The inference $(M, l)$ is determined by the rule $\\text{Unit Propagate}$ applied to a single-atom clause $a$, where $a \\in X \\setminus \\text{Head}(\\Pi)$. It follows that $l = a$. Since $a \\in X \\setminus \\text{Head}(\\Pi)$, then $a$ (that is, $l$) is consistent with $X$.\n\nCase 3. The inference $(M, l)$ is determined by the rule $\\text{Unfounded}$, that is, it is of the form $(M, \\neg a)$, where $a \\in \\sigma_\\Pi$. $a$ is unassigned by $M$, and $a$ belongs to some set $U$ of atoms that is unfounded on $M$ w.r.t. $\\Pi \\cup (X \\setminus \\text{Head}(\\Pi))$. It is clear that $U \\cap (X \\setminus \\text{Head}(\\Pi)) = \\emptyset$. In particular, $U$ is unfounded on $M$ w.r.t. $\\Pi$.\n\nLet us define $M' = M \\cup \\{b : b \\in \\sigma_\\Pi \\setminus X, b \\neq a\\}$. First, it is evident that $a$ is unassigned by $M'$. Second, $M'$ is consistent with $X$ and so, $M'$ is consistent. Finally, $U$ is unfounded on $M'$ w.r.t. $\\Pi$ (since $M \\subseteq M'$). Let $b \\in U$. If $b \\notin \\text{Head}(\\Pi)$, then $b \\notin X$ (otherwise, we would have $b \\in U \\cap (X \\setminus \\text{Head}(\\Pi))$. Thus, $\\neg b \\in M'$. Since $a$ is unassigned in $M'$ ($M'$, $\\neg a$) is an inference of $\\text{UPUF}'(\\Pi)$ implied by the rule $\\text{Unfounded}'$ (with $U$ as an unfounded set underlying it). Since $X$ is a model of $\\text{UPUF}'(\\Pi)$ and $M'$ is consistent with $X$, $\\neg a$ (that is, $l$) is consistent with $X$.\n\n**Proposition 13.** Every modular program $\\{\\Pi_1, \\ldots, \\Pi_n\\}$ is equivalent to the abstract modular system $\\{\\text{UPUF}'(\\Pi_1), \\ldots, \\text{UPUF}'(\\Pi_n)\\}$.\n\n**Proof.** A set $X$ of atoms is a model of a modular program $\\{\\Pi_1, \\ldots, \\Pi_n\\}$ if and only if $X$ is an input answer set of every $\\Pi_i$, $1 \\leq i \\leq n$. Similarly, $X$ is a model of the abstract modular system $\\{\\text{UPUF}'(\\Pi_1), \\ldots, \\text{UPUF}'(\\Pi_n)\\}$ if and only if $X$ is a model of every abstract module $\\text{UPUF}'(\\Pi_i)$, $1 \\leq i \\leq n$. Thus, the result follows from **Proposition 12**.\n\n**Proposition 14.** Every SMT program $P = (T, \\lambda_1, \\ldots, \\lambda_n)$ is equivalent to any of the following abstract modular systems (over the vocabulary $\\sigma_T$):\n\n1. $\\{\\text{Ent}(T), \\text{Ent}(\\lambda_1), \\ldots, \\text{Ent}(\\lambda_n)\\}$.\n2. $\\{\\text{UP}(T), \\text{Ent}(\\lambda_1), \\ldots, \\text{Ent}(\\lambda_n)\\}$.\n3. $\\{\\text{Ent}(T), \\text{Min}(\\lambda_1), \\ldots, \\text{Min}(\\lambda_n)\\}$.\n4. $\\{\\text{UP}(T), \\text{Min}(\\lambda_1), \\ldots, \\text{Min}(\\lambda_n)\\}$.\n\n**Proof.** **Statement 1.** Let $M$ be a consistent and complete set of literals over $\\sigma_T$ such that $M$ is a model of $P$. By the definition of a model of an SMT program, $M^+$ is a model of $T$ and, for every $i$, $1 \\leq i \\leq n$, $M$ is a $\\lambda_i$-model. By **Proposition 4**, the former implies that $M^+$ is a model of $\\text{Ent}(T)$. We will now use the latter to show that for every $i$, $1 \\leq i \\leq n$, $M^+$ is a model of $\\text{Ent}(\\lambda_i)$. To this end, let us consider an inference $(l, l) \\in \\text{Ent}(\\lambda_i)$ such that $l$ is consistent with $M^+$. We need to show that $l$ is consistent with $M^+$. Since $L$ is consistent with $M^+$, $L^+ \\subseteq M^+$ and $L^- \\cap M^+ = \\emptyset$. By the assumption that both $M$ and $L$ are sets of literals over $\\sigma_T$, we obtain $L \\subseteq M$. From the construction of $\\text{Ent}(\\lambda_i)$ it follows that $\\lambda_i[L] \\models l$. Since $M$ is consistent and complete, and also a $\\lambda_i$-model such that $L \\subseteq M$, $l \\in M$. Consequently, $l$ is consistent with $M^+$.\n\nConversely, let $M$ be a consistent and complete set of literals over $\\sigma_T$ such that $M^+$ is a model of $\\{\\text{Ent}(T), \\text{Ent}(\\lambda_1), \\ldots, \\text{Ent}(\\lambda_n)\\}$. By the definition of a model of an AMS, $M^+$ is a model of $\\text{Ent}(T)$ and, for every $i$, $1 \\leq i \\leq n$, a model of $\\text{Ent}(\\lambda_i)$. By **Proposition 4**, $M^+$ is a model of $T$. It remains to show that for every $i$, $1 \\leq i \\leq n$, $M$ is a $\\lambda_i$-model. Let us fix an arbitrary $i$, $1 \\leq i \\leq n$, and proceed by contradiction. That is, let us assume that $M$ is not a $\\lambda_i$-model. Since $M$ is a consistent and complete set of literals over $\\sigma_T$, for every literal $l \\in \\sigma_T$, $\\lambda_i[M] \\models l$. We let us consider any literal $l$ over $\\sigma_T$ such that $l \\notin M$ (since $M$ is consistent, such literals exist). From the definition of $\\text{Ent}(\\lambda_i)$ it follows that $(M, l) \\in \\text{Ent}(\\lambda_i)$. Since $M$ is consistent with $M^+$ and $M^+$ is a model of $\\text{Ent}(\\lambda_i)$ it follows that $l$ is consistent with $M^+$. By the completeness of $M$, $l \\in M$, a contradiction.\n\n**Statement 2.** The proof follows that of **Statement 1.** The only difference is that we now use the module $\\text{UP}(T)$ as an equivalent abstract inference module representation of $T$ (cf. **Proposition 4**).\nStatement 3. Let $M$ be a consistent and complete set of literals over $\\sigma_T$ such that $M$ is a model of $P$. We reason as before and obtain that $M^+$ is a model of $T$. In the proof of Statement 1, we showed that $M^+$ is a model of $\\text{Ent}(\\lambda_i)$. Since $\\text{Min}(\\lambda_i) \\subseteq \\text{Ent}(\\lambda_i)$, $M^+$ is a model of $\\text{Min}(\\lambda_i)$.\n\nThe converse implication can be proved exactly as in Statement 1, as the only elements of $\\text{Ent}(\\lambda_i)$ we used in the reasoning also belong to $\\text{Min}(\\lambda_i)$.\n\nStatement 4. The proof follows the lines of the argument of Statement 3 with the same proviso that we used in Statement 2. □\n\n**Theorem 15.** Every abstract modular inference system $A$ is equivalent to the abstract inference module $A^\\perp$.\n\n**Proof.** By definition, $X$ is a model of $A = \\{S_1, \\ldots, S_n\\}$ if and only if $X$ is a model of every module $S_i$, $1 \\leq i \\leq n$. By Proposition 3, that latter holds if and only if $X$ is a model of the module $A^\\perp$. □\n\n**Theorem 16.** For every AMS $A$,\n\n(a) the graph $\\text{AMS}_A$ is finite and acyclic,\n\n(b) for any terminal state $M$ of $\\text{AMS}_A$ other than $\\perp, [M]^+$ is a model of $A$,\n\n(c) the state $\\perp$ is reachable from $\\emptyset$ in $\\text{AMS}_A$ if and only if $A$ is unsatisfiable.\n\n**Proof.** By definition, $\\text{AMS}_A = \\text{AM}_A^\\perp$. By Theorem 6(a), $\\text{AM}_A^\\perp$ is finite and acyclic. Thus, the graph $\\text{AMS}_A$ is finite and acyclic, too. Next, by Theorem 6(b), any terminal state of $\\text{AM}_A^\\perp$ other than $\\perp$ is a model of $A^\\perp$. Thus, by Theorem 15, each such state is a model of $\\text{AMS}_A$. Part (c) follows by a similar argument. □\n\n**Theorem 17.** For every AMS $A$,\n\n(a) the graph $\\text{AMSL}_A$ is finite and acyclic,\n\n(b) for any semi-terminal state $M \\parallel G$ of $\\text{AMSL}_A$ reachable from $\\emptyset \\parallel \\emptyset, \\ldots, \\emptyset$, $[M]^+$ is a model of $A$,\n\n(c) state $\\perp$ is reachable from $\\emptyset \\parallel \\emptyset, \\ldots, \\emptyset$ in $\\text{AMSL}_A$ if and only if $A$ has no models.\n\n**Proof (Sketch).** (a) The set of augmented states is obviously finite as augmented states are defined over a finite vocabulary. Thus, the graph $\\text{AMSL}_A$ is finite. Let us assume that $\\text{AMSL}_A$ contains a cycle, say $C$. Since transition rules either keep the second component of a state the same or extend it, $C$ is of the form $M_0 \\parallel G, M_1 \\parallel G, \\ldots, M_p \\parallel G$, where $G$ is a sequence of sets of inferences, and each $M_i$ is a state over $\\sigma_A$. Let $G = \\bigcup G$. One can show that $M_0, M_1, \\ldots, M_p$ is a cycle in $\\text{AMSL}_A$, a contradiction with Theorem 16(a).\n\n(b) Let us assume that $M \\parallel G$ is reachable from $\\emptyset \\parallel \\emptyset, \\ldots, \\emptyset$. It follows that $G = \\bigcup G$ is $A$-safe. Using this observation, one can show that $M$ is reachable from $\\emptyset$ in $\\text{AMSL}_A$. Moreover, since $M \\parallel G$ is a semi-terminal state in $\\text{AMSL}_A$, $M$ is a terminal state in $\\text{AMSL}_A$. By Theorem 16(b), $[M]^+$ is a model of $A^\\perp$. Since $G$ is $A$-safe, $A^\\perp$ and $A$ are equivalent and so, $[M]^+$ is a model of $A$.\n\n(c) Let us first assume that $\\perp$ is reachable from $\\emptyset \\parallel \\emptyset, \\ldots, \\emptyset$ in $\\text{AMSL}_A$. Let $M \\parallel G$ be the direct predecessor of $\\perp$ on one of those reachability paths. It follows that $M$ is inconsistent and contains no decision literals. Reasoning as before, we can show that $M$ is reachable from $\\emptyset$ in $\\text{AMSL}_A$ (where $G = \\bigcup G$). Since $M$ is inconsistent and contains no decision literals, $\\perp$ is reachable from $\\emptyset$ in $\\text{AMSL}_A$. By Theorem 16(c), $A^\\perp$ is not satisfiable. Since $G$ is $A$-safe, $A^\\perp$ and $A$ are equivalent. Consequently, $A$ is unsatisfiable (has no models).\n\nNext, let us assume that $\\perp$ is not reachable from $\\emptyset \\parallel \\emptyset, \\ldots, \\emptyset$ in $\\text{AMSL}_A$. Then $\\perp$ is not reachable from $\\emptyset$ in $\\text{AMSL}_A$. By Theorem 16(c), $A$ has models. □\n\nReferences\n\n\n"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":2,"numItemsPerPage":100,"numTotalItems":22671,"offset":200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NDMzMjM1MiwianRpIjoiMTg4MzY0YjYtZDFhZS00OTUxLTljZTAtZTRjNjg0MjYwYWQyIiwic3ViIjoiL2RhdGFzZXRzL21saW5tZy9kb2xtYTNfbG9uZ21pbm9fbWl4LTEwMEItMTEyNS1zYWZlLXRvLWxvYWQiLCJleHAiOjE3ODQzMzU5NTIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.aybN0EdKu9J7XZJGtpU53uEhEZJmuqe0A3xV_eCtf8I4vYHCHUf7cIzaplq6ioCOCiAShlqlsCofLpGisNqDDg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":22671,"numBytesParquet":1201011708}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
id stringlengths 40 40 | text stringlengths 19.6k 351k |
|---|---|
9733bdb9ff1096684d21cc5506c71cf17be098d0 | Package ‘extracat’
November 21, 2015
Type Package
Title Categorical Data Analysis and Visualization
Version 1.7-4
Date 2015-11-21
Author Alexander Pilhoefer <alexander.pilhoefer@gmail.com>
Maintainer Alexander Pilhoefer <alexander.pilhoefer@gmail.com>
Description Categorical Data Analysis and Visualization.
Depends R... |
7674227d29755d182435bc1d2e3fffa9476c5985 | COLLABORATORS
<table>
<thead>
<tr>
<th>ACTION</th>
<th>NAME</th>
<th>DATE</th>
<th>SIGNATURE</th>
</tr>
</thead>
<tbody>
<tr>
<td>WRITTEN BY</td>
<td>Adam Dickmeiss, Marc Cromme, and Mike Taylor</td>
<td>April 28, 2021</td>
<td></td>
</tr>
</tbody>
</table>
REVISION HISTORY
<table>
<thead>
<tr>
<th>NUMBER</th>
<th>D... |
92557630ed8f2a78b82bc18f98b273428c05950d | Model Transformation at Runtime for Dynamic Adaptation in Distributed Groupware
by
Christopher Wolfe
A thesis submitted to the School of Computing in conformity with the requirements for the degree of Doctor of Philosophy
Queen’s University
Kingston, Ontario, Canada
February, 2011
Copyright © Christopher Wolfe, 20... |
56107de3e0cb8a234c0cee742b156b948a5a7d55 | The RISC Algorithm Language (RISCAL)
Tutorial and Reference Manual
(Version 1.0.5)
Wolfgang Schreiner
Research Institute for Symbolic Computation (RISC)
Johannes Kepler University, Linz, Austria
Wolfgang.Schreiner@risc.jku.at
August 1, 2017
Abstract
This report documents the RISC Algorithm Language (RI... |
2a318df7a3e5ac3ef8a6024937065840201fab07 | NFD Developer’s Guide
Alexander Afanasyev\textsuperscript{1}, Junxiao Shi\textsuperscript{2}, Beichuan Zhang\textsuperscript{2}, Lixia Zhang\textsuperscript{1}, Ilya Moiseenko\textsuperscript{1}, Yingdi Yu\textsuperscript{1}, Wentao Shang\textsuperscript{1}, Yanbiao Li\textsuperscript{1}, Spyridon Mastorakis\textsuper... |
2813a3528a1775fc22001097037cfb91c860f3ff | Record concatenation with intersection types
Citation for published version (APA):
Document status and date:
Published: 01/01/1995
Publisher Version:
Publisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers)
Please check the document version of this publication:
• A submitted ... |
9e8dfe84f7fbfbc194d82b37d0c2da9ab6e2c9c1 | # Table of Contents
1. Introduction ............................................................................................................. 2
1.1. Identity Technologies ......................................................................................... 2
1.1.1. Identity Stores ................... |
ebc9011671f1d11870fd0c0a4c369828b5662362 | Detecting Semantic Method Clones In Java Code Using Method Ioe-behavior
2013
Rochelle Elva
University of Central Florida
Find similar works at: http://stars.library.ucf.edu/etd
University of Central Florida Libraries http://library.ucf.edu
Part of the Computer Sciences Commons, and the Engineering Commons
STARS C... |
25bc16d9a5ed28f5abee58b21e8a25b867867754 | LPVAX - A THREE-DIMENSIONAL LINEAR PROGRAMMING GRAPHICS PACKAGE ON THE INTERGRAPH-VAX SYSTEM
A Thesis Presented to
The Faculty of the College of Engineering and Technology
Ohio University
In Partial Fulfillment
of the Requirements for the Degree
Master of Science
by
Linda A. Humphreys
November, 1986
# TABLE OF CONTE... |
4ac5329ea7c1f3e1bdb18b36699dab74fe9e32d2 | Scalable Distributed Time-Travel Text Search
Masterarbeit im Fach Informatik
Master’s Thesis in Computer Science
von / by
Thaer Samar
angefertigt unter der Leitung von / supervised by
Dr. Klaus Berberich
begutachtet von / reviewers
Dr. Klaus Berberich
Prof. Dr. Gerhard Weikum
December 2011
Statement
I, Thaer Sa... |
fc35b92974736b4fe1d36d992fb651f246cedd05 | SIMATIC HMI
WinCC V7.2
SIMATIC HMI WinCC V7.2 System description
System Manual
<table>
<thead>
<tr>
<th>Topic</th>
<th>Page</th>
</tr>
</thead>
<tbody>
<tr>
<td>SIMATIC WinCC System Overview</td>
<td>1</td>
</tr>
<tr>
<td>Process visualization with SIMATIC WinCC</td>
<td>2</td>
</tr>
<tr>
<td>Options</td>
<td>3</td>... |
672e886f5a14acab70816ba8a49e5be486d9084f | Pushdown flow analysis with abstract garbage collection
J. IAN JOHNSON
Northeastern University, Boston, MA, USA
(e-mail: ianj@ccs.neu.edu)
ILYA SERGEY
IMDEA Software Institute, Madrid, Spain
(e-mail: ilya.sergey@imdea.org)
CHRISTOPHER EARL
University of Utah, Salt Lake City, UT, USA
(e-mail: cwearl@cs.ut... |
04c153703f6f4324b93f8793cf97c12beb497c56 | COMPILE-TIME MEMORY DISAMBIGUATION FOR C PROGRAMS
BY
BEN-CHUNG CHENG
B.S., National Taiwan University, 1992
M.S., University of Illinois, 1997
THESIS
Submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy in Computer Science in the Graduate College of the University of Illinois a... |
50f422e7cd87fccae93b179c34889f6bb9038aaf |
retained in the candidate set, and all the other are rejected. By Corollary 5, the rejected orderings are blockwise-equivalent to the retained candidate. Consequently, $\text{CandSet}(N)$ is strongly valid.
2. $N$ is an OR-node. Again, we start with showing that $\text{ConsSet}(N)$ is strongly valid. Let $\tilde{O}... |
f2ab62bbc02ae085a781c10f368515882fe07118 | NOTE TO USERS
This reproduction is the best copy available.
UMI®
Custom and Model Based Detection of Deficiencies Related to Java Multithreading
Jagmit Singh
A Thesis in The Department of Electrical and Computer Engineering
Presented in Partial Fulfillment of the Requirements for the Degree of Master of Applied Sc... |
858f2cdd980149f43d9b15c4d68f981cef638d8b | Capturing Types
ALEKSANDER BORUCH-GRUSZECKI∗, EPFL,
MARTIN ODERSKY∗, EPFL,
EDWARD LEE, University of Waterloo,
ONDŘEJ LHOTÁK, University of Waterloo,
JONATHAN BRACHTHÄUSER, Eberhard Karls University of Tübingen,
Type systems usually characterize the shape of values but not their free variables. However, many desirabl... |
ca2a57f366f3ac48f25253c1dcdba2c70f6783ee | A Foundation for Fault Tolerant Components
DISSERTATION
Presented in Partial Fulfillment of the Requirements for
the Degree Doctor of Philosophy in the
Graduate School of The Ohio State University
By
William Leal, B.A., M.S., M.S.
* * * * *
The Ohio State University
2001
Dissertation Committee:
Anish Arora, Adv... |
6e7e2ce15a76619acd8d287bd1d04b0775c8356d | ### Revision History
<table>
<thead>
<tr>
<th>Version</th>
<th>Date</th>
<th>Remarks</th>
</tr>
</thead>
<tbody>
<tr>
<td>ISTQB 2018</td>
<td>27-April-2018</td>
<td>Candidate general release version</td>
</tr>
<tr>
<td>ISTQB 2018</td>
<td>12-February-2018</td>
<td>Candidate beta version</td>
</tr>
<tr>
<td>ISTQB 2018<... |
e216875be11d29a80ae48f54f51b6394d50eb0b4 | Developing an e-business Application for the IBM WebSphere Application Server
John Akerley, Murtuza Hashim, Alexander Koutsoumbos, Angelo Maffione
Developing an e-business Application for the IBM WebSphere Application Server
September 1999
Take Note!
Before using this information and the product it supports, be sure... |
940c02b8afc690d3a9c8eb3b4d782cd431946959 | Well-founded recursion with copatterns and sized types
ANDREAS ABEL
Department of Computer Science and Engineering
Gothenburg University, Sweden
(e-mail: andreas.abel@gu.se)
BRIGITTE PIENTKA
School of Computer Science, McGill University, Montreal, Canada
(e-mail: bpientka@cs.mcgill.ca)
Abstract
In this paper, we st... |
2e942f24d3a49dc67e5b6f07fee009437a4d5fe5 | CALL-BY-VALUE TERMINATION IN THE UNTYPED \(\lambda\)-CALCULUS
NEIL D. JONES\(^a\) AND NINA BOHR\(^b\)
\(^a\) DIKU, University of Copenhagen, Denmark
e-mail address: neil@diku.dk
\(^b\) IT-University of Copenhagen, Denmark
e-mail address: nina@itu.dk
Abstract. A fully-automated algorithm is developed able to show th... |
d3cd9d85818f1bc61fed48a247c734ad6a8d60c9 | The copyright of this thesis vests in the author. No quotation from it or information derived from it is to be published without full acknowledgement of the source. The thesis is to be used for private study or non-commercial research purposes only.
Published by the University of Cape Town (UCT) in terms of the non-ex... |
c05a3fe74e2b5fc5aac40bb869c34367ef6a3190 | Abstract
The Hypertext Transfer Protocol (HTTP) is a stateless application-level protocol for distributed, collaborative, hypertext information systems. This document defines the semantics of HTTP/1.1 messages, as expressed by request methods, request header fields, response status codes, and response header fields, a... |
13001dd0fe78c54602067fe276435b47c36faa99 | Abstract
This guide consists of information to install and configure Red Hat Single Sign-On 7.4
Table of Contents
MAKING OPEN SOURCE MORE INCLUSIVE ................................................................. 5
CHAPTER 1. GUIDE OVERVIEW ................................................................. 6
1.1. ... |
8d9a472c92513fbba5c10e0d5393524c30713505 | Content
CONTENT ...........................................................................................................................................i
ABSTRACT ...........................................................................................................................................ii
1. INTRODUC... |
ed57fd68ba8d52ce06fba0319e0ef1a8c51e6860 | Compatibility Definition
Android 7.1
Last updated: February 24th, 2017
Copyright © 2016, Google Inc. All rights reserved.
compatibility@android.com
Table of Contents
1. Introduction
2. Device Types
2.1 Device Configurations
3. Software
3.1 Managed API Compatibility
3.1.1 Android Extensions
3.2 Soft AP... |
4d1788f8c9024fc0e7e412452c8535906fab3740 | Explicit substitutions
M. ABADI, L. CARDELLI
Digital Equipment Corp., Systems Research Center, 130 Lytton Avenue, Palo Alto, California, USA 94301
P.-L. CURIEN*
Laboratoire d'Informatique, Ecole Normale Superieure, 45 Rue d'Ulm 75005, Paris, France
AND J.-J. LEVY†
INRIA, Domaine de Voluceau, Rocquencourt, B.P. 105, ... |
4443120de94f1a4882849432d7e3ab59599bf45c | Dynamic Partial Order Reduction for Checking Correctness Against Transaction Isolation Levels
AHMED BOUAJJANI, Université Paris Cité, CNRS, IRIF, France
CONSTANTIN ENEA, LIX, Ecole Polytechnique, CNRS and Institut Polytechnique de Paris, France
ENRIQUE ROMÁN-CALVO, Université Paris Cité, CNRS, IRIF, France
Modern app... |
0e37cd615f314fba89e145d75f0505ccc0d8b006 | Event-based run-time adaptation in communication-centric systems
Cinzia Di Giusto, Jorge A. Pérez
To cite this version:
Cinzia Di Giusto, Jorge A. Pérez. Event-based run-time adaptation in communication-centric systems. Formal Aspects of Computing, 2016, 10.1007/s00165-016-0377-z. hal-01320789
HAL Id: hal-01320789
ht... |
fe46e67cd03a1a89ab2464efd5451bb955cd9bb0 | Programming the Greedy CAM Machine
Erik Ruf
January 26, 2007
MSR-TR-2007-04
Microsoft Research
Microsoft Corporation
One Microsoft Way
Redmond, WA 98052
Programming the Greedy CAM Machine
Erik Ruf
January 26, 2007
Abstract
The Greedy CAM architecture describes a class of experimental processors that aim to cope... |
2108f3ec0910956989b79bd4de6bbacf6a68cd0a | Hash Proof Based Encryption Schemes in EasyCrypt
Morten Rotvold Solberg
Acknowledgements
Before you lies the work concluding my time as a student at NTNU. The project I have been working on this semester have been both interesting, fun, educational, difficult and from time to time seemed to be rather overwhelming. I ... |
aa23e65c3adb509ab8929471a164cfed2485a8fc | Towards a compiler toolchain for quantum programs
THÈSE
présentée et soutenue publiquement le 13 Janvier 2023
pour l’obtention du
Doctorat de l’Université de Lorraine
(mention informatique)
par
Agustín Pablo Borgna
Composition du jury
Rapporteurs : Bob Coecke Quantinuum
Michael Mislove Tulane University
Exami... |
63175a51acd3b35357c88eb6327ba6023d97f260 | Requirements Specification and Analysis
of
Command and Control Systems
Jaco van de Pol (CWI, Amsterdam)
Jozef Hooman (KUN, Nijmegen)
Edwin de Jong (Hollandse Signaalapparaten BV, Hengelo)
August 25, 1999
Abstract
This report presents a method for formally specifying and analyzing requirements specifications of comma... |
c8e63653e131a0c1274e3453799ef94da164e7de | A Hybrid Approach to Formal Verification of Higher-Order Masked Arithmetic Programs
PENGFEI GAO∗†, ShanghaiTech University, China
HONGYI XIE, ShanghaiTech University, China
FU SONG‡, ShanghaiTech University, China
TAOLUE CHEN, University of Surrey, UK
Side-channel attacks, which are capable of breaking secrecy via si... |
05987b82e8f0dd3b5d1a412d2ea9214f1cb1602e | Prevent users and processes from performing unauthorized interactions with files and devices by using Security-Enhanced Linux (SELinux)
Prevent users and processes from performing unauthorized interactions with files and devices by using Security-Enhanced Linux (SELinux)
Abstract
By configuring SELinux, you can enhanc... |
3b0f48d28bd9015717e924841b62416c4e2f0832 | High-level Structures for Quantum Computing
Jarosław Adam Miszczak
This book is concerned with the models of quantum computation.
Information processing based on the rules of quantum mechanics provides us with new opportunities for developing more efficient algorithms and protocols. However, to harness the power off... |
246915b6226f9f0fe76b7dc30839cece53016710 | A Low-Effort Animated Data Structure Visualization Creation System
by
Larry A Barowski
A dissertation submitted to the Graduate Faculty of
Auburn University
in partial fulfillment of the
requirements for the Degree of
Doctor of Philosophy
Auburn, Alabama
August 2, 2014
Keywords: visualization, data structure, jGRA... |
b8f01dc29dff4ecdb73d2b17a072963d1936be4d | Adaptive Simulated Annealing (ASA) is a C-language code developed to statistically find the best global fit of a nonlinear constrained non-convex cost-function over a $D$-dimensional space. This algorithm permits an annealing schedule for “temperature” $T$ decreasing exponentially in annealing-time $k$, $T = T_0 \exp(-... |
25bc813f6a1651479d5bc03e4176f7ce279aa40f | Table of Contents
1 Quickstart Installation Guide ................................. 1
1.1 Installing The Head Node .............................. 1
1.2 First Boot ............................................. 4
1.3 Booting Regular Nodes .................................. 5
1.4 Optional: Upgrading Python ..... |
efa8d2d1f65af47c5d2a30c2520a9d03f4821718 | UNIX SYSTEM PROGRAMMING
NOTES FOR 6TH SEMESTER COMPUTER SCIENCE
SUBJECT CODE: 10CS62
SUBMITTED BY
Pradeep Surasura
Assistant Professor
Department of Computer Science
Notes have been circulated on self risk nobody can be held responsible if anything is wrong or is improper information or insufficient information pro... |
6dc665b448f80f62dc6fbabe76214d1b88edb122 | Abstract
*fizz* is an experimental language and runtime environment for the exploration of cognitive architectures and combined Machine Learning (ML) and Machine Reasoning (MR) solutions. It is based primarily on symbolic programming and fuzzy formal logic, and it features a distributed, concurrent, asynchronous and r... |
f1be915280ce3fe5f18197082faf3b56dbf6aebd | 1 PyMacLab - Python Macroeconomics Laboratory 1
1.1 Introduction ................................................. 1
1.1.1 Description ............................................. 1
1.1.2 First things first ...................................... 1
1.1.3 Features at a Glance ................................. |
ba53d02b2f248df2579135e1ebc9a60bb2a6118d | Graph algorithms have been shown to possess enough parallelism to keep several computing resources busy – even hundreds of cores on a GPU. Unfortunately, tuning their implementation for efficient execution on a particular hardware configuration of heterogeneous systems consisting of multi-core CPUs and GPUs is challeng... |
57942a4d3c30041982e231725606aed7d4837199 | Dynamic logics of polyhedra and their application in 3D modeling
MSc Thesis (Afstudeerscriptie)
written by
Kirill Kopnev
(born 23.11.1999 in Moscow, Russia)
under the supervision of Nick Bezhanishvili and Vincenzo Ciancia, and submitted to the Examinations Board in partial fulfillment of the requirements for the de... |
cba1dc8d123547304219a04d83cf8615567cf9d0 |
Author: Kai-Cheung Leung
Department of Computer Science, University of Otago, New Zealand
Status:
A thesis submitted for the degree of Doctor of Philosophy at the University of Otago, Dunedin, New Zealand. 17th August, 2013
Department of Computer Science, University of Otago, PO Box 56, Dunedin, Otago, New Zealand
... |
194672b483524921253f896f496f479c5aeee499 | Porting the UNIX Implementation of Icon*
William H. Mitchell
TR 83-10d
ABSTRACT
This document explains how to port the UNIX implementation of the Icon programming language. The Icon system is composed of a translator, a linker, and an interpreter. Procedures for porting each system component are described in detail... |
56828f65f4db616643554a9352f33e690cfdefb4 | Universiteit Leiden
ICT in Business
Requirements prioritization in Agile environments:
a model for effective prioritization
Name: Eleni Stavrou
Student-no: s1277030
Date: 25/02/2016
1st supervisor: Christoph Johan Stettina
2nd supervisor: Hans le Fever
# Table of contents
1. Problem definition ...................... |
5934a7b0e7562b3582df0883683c8e4b2b56ef5c | Abstract
The Resource Description Framework (RDF) is a language for representing information about resources in the World Wide Web. This Primer is designed to provide the reader with the basic knowledge required to effectively use RDF. It introduces the basic concepts of RDF and describes its XML syntax. It describes ... |
b20d282c012cccb9d506dc92de75a6198ea8abdf | Revised Report on the Algorithmic Language Scheme
Richard Kelsey, William Clinger, and Jonathan Rees (Editors)
D. H. Bartley R. Halstead D. Oxley G. J. Sussman
G. Brooks C. Hanson K. M. Pitman M. Wand
Dedicated to the Memory of Robert Hieb
20 February 1998
SUMMARY
The report gives a defining description of the pr... |
57962a0ee08ab1a6925581d672be28a979d8f699 | Randomized Distributed Computing on Rings
By
LISA HIGHAM
B.Sc. Honours, The University of Alberta, 1972
M.Sc., The University of Alberta, 1982
A THESIS SUBMITTED IN PARTIAL FULFILLMENT OF
THE REQUIREMENTS FOR THE DEGREE OF
DOCTOR OF PHILOSOPHY
in
THE FACULTY OF GRADUATE STUDIES
(Department of Computer Science)
W... |
fe27e7dac0b33a8667d6a8334db90949c9d75775 | Towards an industrial ALM (Application Lifecycle) Tool Integration
Georgi A. Markov
Olga R. Druzhinina
Thesis submitted for completion of Master of Science (120 credits)
Main field of study: Computer Science
Specialization: Informatics
June 2011
This thesis is submitted to the School of Computing at Blekinge Institu... |
6e3691a8886e268b815c01c039379eabb62b9737 | Requirements Specification Language (RSL) and Supporting Tools
Deborah Frincke
Dave Wolber
Gene Fisher
California Polytechnic State University
San Luis Obispo, California
G. C. Cohen
Boeing Defense & Space Group
Seattle, Washington
NASA Contract NAS1-18586
November 1992
NASA Contractor Report 189700
P... |
65692714b711302c529267b5a2f96ce1544a0df9 | Design of the Certifying Programming Language
— Vero
Xinyu Feng
Email:xinyu.feng@yale.edu
June 3, 2004
Contents
1 Introduction ............................................. 5
1.1 The Certifying Programming Language ................. 5
1.2 Related Work ....................................... 7
1.3 Design of Ver... |
64fe2838829698046657fb1cbcbd6ea95c74555c | # Table of Contents
Eclipse GlassFish Server ......................................................... 1
Preface ....................................................................................... 2
Oracle GlassFish Server Documentation Set .............................. 2
Typographic Conventions .................. |
3640bab7cf8301bb4e4d1aaad3e9baa05ebadb72 | The sustainable development of a software product depends on a number of groups working together to achieve a common goal. However, each of the groups interacts with the product in different ways, and can have conflicting aims and objectives. For example, developers trying to correct issues in the software architecture... |
1f0185fcfa7286fac3cc1dcc8d013ccb49304078 | IBM 1130/1800 Macro Assembler Programming
This manual describes how to use the Macro Assembler of the 1130 Disk Monitor System, Version 2, and the 1800 Multiprogramming Executive Operating System, Versions 2 and 3. It should be used by programmers who have a basic knowledge of the assembler language and use this langu... |
71510a2d8b010376751ed911ab83bdf7e0318f28 | Contextual Governance for Service Oriented Architecture Composition
Thesis by P. de Leusse
In partial fulfilment of the requirements for the degree of doctor of philosophy
Newcastle University
Newcastle upon Tyne, UK
2010
Acknowledgements
I am fortunate to have worked in the School of Computing Science at Newcastle... |
08430f00ff3a1f4e5bf66805c36c9dc6f851dfa3 | A LOGIC-BASED METHODOLOGY FOR BUSINESS PROCESS ANALYSIS AND DESIGN: LINKING BUSINESS POLICIES TO WORKFLOW MODELS
by
Harry Jiannan Wang
Copyright © Harry Jiannan Wang 2006
A Dissertation Submitted to the Faculty of the
COMMITTEE ON BUSINESS ADMINISTRATION
In Partial Fulfillment of the Requirements
For the Degree o... |
dd86e28cccbac7d078520a8eba9ba47e18b8d291 | USING Microsoft Expression Web 2
The Only Expression Web 2 Book You Need
Jim Cheshire
Who Should Read This Book?
Expression Web 2 is a powerful Web development product, and there are plenty of books about it. That puts readers in a tight spot when trying to figure out which book to purchase to learn how to use Expre... |
221d2d1fd106cc7ef63ab83096a4ecd15c9c2e36 | ### GETTING STARTED
1 **Installation**
1.1 System Requirements
1.2 Binary Packages
1.3 Updating
1.4 Installing Specific Versions
2 **Building From Source**
2.1 Dependencies
2.2 Building and Updating
2.3 Statically Linked Routinator
2.4 Platform Specific Instructions
3 **Configuration**
3.1 Setu... |
7b99268fbf164bf33de62a6bbf4008d80c0934a9 | Software development processes and software quality assurance
Zsolt Dr. Ulbert
Copyright © 2014 University of Pannonia
Manuscript completed: February 2014
Language reviewed by: Bódis László, Kismödi Péter
Published by: University of Pannonia
Editor by: University of Pannonia
2014
Software development process an... |
eff8dc043fed1df2f6a40f884d81cba1ba19f625 | This CMMI Implementation Guide is a reference book for anyone interested in implementing CMMI in their organization. The purpose of this book is to provide insight into CMMI Implementation phases and best practices to be followed in this journey. Most of us agree that CMMI is more a De facto model that IT Industry foll... |
1b799c8c42f47ed5dc2f350c41a16e8b5b08b965 | Dietrich Boles, Daniel Jasper
Hamster-Simulator
Version 2.9.6
Benutzungshandbuch
22.12.2017
4 Bedienung des Hamster-Simulators ................................................................. 31
4.1 Grundfunktionen ....................................................................................... 32
4.1... |
c923870b098acffd4525370a7110f51fabba6876 | On the execution of high level formal specifications
Timothy Allen Wahls
Iowa State University
Follow this and additional works at: http://lib.dr.iastate.edu/rtd
Part of the Computer Sciences Commons
Recommended Citation
http://lib.dr.iastate.edu/rtd/10732
This Dissertation is brought to you for free and open acces... |
99ef5ae11705c0406c4165c01e9a609f4b281fe5 | Citation for published version
DOI
https://doi.org/10.1145/2429069.2429099
Link to record in KAR
http://kar.kent.ac.uk/50270/
Document Version
UNSPECIFIED
Copyright & reuse
Content in the Kent Academic Repository is made available for research purposes. Unless otherwise stated all content is protected by copyr... |
da09c77a2e52eef6e6f9a15142fb2ae47eca3555 | A model of cooperative threads
Citation for published version:
Digital Object Identifier (DOI):
10.1145/1480881.1480887
Link:
Link to publication record in Edinburgh Research Explorer
Document Version:
Peer reviewed version
Published In:
General rights
Copyright for the publications made accessible via the Edinbu... |
4d45e1ac5f808bc97e6fe6d057dbb2dd6e6fec7e | # TABLE OF CONTENTS
1 Introduction 3
1.1 What is Proxmox Backup Server? 3
1.2 Architecture 3
1.3 Main Features 3
1.4 Reasons for Data Backup? 4
1.5 Software Stack 4
1.6 Getting Help 5
1.6.1 Enterprise Support 5
1.6.2 Community Support Forum 5
1.6.3 Mailing Lists 5
1.6.4 Bug Tracker 5
1.7 License ... |
65f757a1c763ea1fbe97ba9c6656bd65f6fc2541 | Abstract
Understanding the behavior of software is important for the existing software to be improved. In this paper, we present a trace slicing technique that is suitable for analyzing complex, textually-large computations in rewriting logic, which is a general framework efficiently implemented in the Maude language ... |
fe1b692762cb8faa7174b26dcd11c1479ab0a083 | Semi-Automatic Conceptual Data Modeling Using Entity and Relationship Instance Repositories
A Thesis
Submitted to the Faculty
of
Drexel University
by
Ornsiri Thonggoom
in partial fulfillment of the requirements for the degree of
Doctor of Philosophy
May 2011
ACKNOWLEDGEMENT
I am indebted to my supervising professor, ... |
cbf37dfc6010a258a6b5a33c5aed205e77cd9ddc |
Downloaded from:
Usage Guidelines:
Please refer to usage guidelines at contact lib-eprints@bbk.ac.uk. or alternatively
Automatically Proving Termination and Memory Safety for Programs with Pointer Arithmetic
Thomas Ströder · Jürgen Giesl · Marc Brockschmidt · Florian Frohn · Carsten Fuhs · Jera Hensel · Peter Schnei... |
9dc9cd841645fca8670c0d68f88aeb8c1da03fe7 | # CONTENTS
1 Introduction
1.1 Contributing .......................................................... 1
1.2 How to run the client .............................................. 2
1.3 Understanding the client in more depth ....................... 2
2 What is a Certificate?
2.1 Certificates and Lineages ...... |
1a6b5938d0cccfe9e139311fa2b459f565d8d828 | Automated Test Case Generation as a Many-Objective Optimisation Problem with Dynamic Selection of the Targets
Annibale Panichella∗, Fitsum Meshesha Kifetew†, Paolo Tonella†
∗SnT - University of Luxembourg, Luxembourg
†Fondazione Bruno Kessler, Trento, Italy
annibale.panichella@uni.lu, kifetew@fbk.eu, tonella@fbk.eu
A... |
4b34d5cfefb6c737a31c47b32a7e14c249e3850f | Thesis
ALGOL-M
An Implementation of a High-level Block Structured Language for a Microprocessor-based Computer System
by
John P. Flynn
and
Mark S. Moranville
September 1977
Thesis Advisor:
G. A. Kildall
Approved for public release; distribution unlimited.
ALGOL-M
An Implementation of a High-level Block Structured ... |
c8f51bdab4117540b799e1d34b68f9612fbdcb10 | Welcome to the Course
Hi! Welcome to CSC280. I’m glad you’re taking it, and (although I realize it is a B.S. requirement and—worse still!—it covers what certainly is the most abstract material in our undergraduate core), I hope that you’ll be glad you took it!
After all, most of you are computer science majors, and t... |
dc5ad8d77d83da113d18083b6d36dea39c33c2d2 | Described herein are techniques to perform reassembly of a Transmission Control Protocol (TCP) data stream from payloads of TCP segments of a bidirectional TCP connection between a first TCP end-point operating at a first network device and a second TCP end-point operating at a second network device.
OTHER PUBLICATIONS... |
636a13f41c5748f97c831a7b303089e633d29fbd | Web-based visualization of guidelines and drug use in epilepsy: a project contributing to smart drug prescriptions
Citation for published version (APA):
Document status and date:
Published: 25/09/2015
Document Version:
Publisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers)
... |
9e1bc2078e0d46d65f272e2ee11e4cfe5f2b578b | Package ‘dtwclust’
July 7, 2019
Type Package
Title Time Series Clustering Along with Optimizations for the Dynamic Time Warping Distance
Description Time series clustering along with optimized techniques related to the Dynamic Time Warping distance and its corresponding lower bounds. Implementations of partitional,... |
477a90cb7026d833e6a96756be4dd8dfc4e3a129 | A SYNTACTIC APPROACH TO TYPE SOUNDNESS
Andrew K. Wright* Matthias Felleisen*
Department of Computer Science
Rice University
Houston, TX 77251-1892
June 18, 1992
Rice Technical Report TR91-160
To appear in: Information and Computation
Abstract
We present a new approach to proving type soundness for Hindley/Milne... |
91f4473b27e2870b49b768117a0c7555c7e3a503 | ## Contents
1 Introduction ................................. 1
1.1 Related Documentation ................................. 1
1.2 Prerequisites ................................. 2
1.2.1 Red Hat Subscription ................................. 2
1.2.2 Access to Repositories ............................... |
7776db014e65621e6dc1d5afa69041d9053d1b1b | Notice of Disclaimer
The information disclosed to you hereunder (the “Materials”) is provided solely for the selection and use of Xilinx products. To the maximum extent permitted by applicable law: (1) Materials are made available “AS IS” and with all faults, Xilinx hereby DISCLAIMS ALL WARRANTIES AND CONDITIONS, EXPR... |
93cf3e9e6679e6c13860fc003dbd7389c9b8dc93 | 1 Diameter Users Guide
The diameter application is a framework for building applications on top of the Diameter protocol.
1.1 Introduction
The diameter application is an implementation of the Diameter protocol as defined by RFC 6733. It supports arbitrary Diameter applications by way of a dictionary interface that a... |
c2bf0abce56bd4b008532845147a091cc58be040 | Preface .............................................................................................................................................. v
I. Introduction .................................................................................................................................. 1
1. Why Spring ... |
e545a96ff5809928ca2abeb20ac8dbbd4ff86553 | On the analysis of random replacement caches using static probabilistic timing methods for multi-path programs
Lesage, B.; Griffin, D.; Altmeyer, S.J.; Cucu-Grosjean, L.; Davis, R.I.
Published in:
Real-Time Systems
DOI:
10.1007/s11241-017-9295-2
Citation for published version (APA):
On the analysis of random replace... |
8d0719082df8fb9075b338e02eb64bbd9f91bae4 | Master Thesis
Translating Spec# Programs to C# with CodeContracts
Author(s):
Egli, Florian
Publication Date:
2012
Permanent Link:
https://doi.org/10.3929/ethz-a-007305132
Rights / License:
In Copyright - Non-Commercial Use Permitted
Translating Spec# Programs to C# with CodeContracts
Florian Egli
Master's Thesis... |
861aa64694a72a7d707d874cf7b5f74fedfa0b50 | The Oracle Rules Language Reference Guide contains a detailed and complete reference to the Oracle Business Rules RL Language syntax, semantics, and built-in functions. You can create and edit the Oracle Rules language directly but the language is normally generated by high-level tools.
Contents
Preface ................. |
afc195f347eaaf785d28ac884c5b49662fac667f | Customer profiles
Citation for published version (APA):
Document status and date:
Published: 01/10/2014
Document Version:
Publisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers)
Please check the document version of this publication:
• A submitted manuscript is the version of... |
63ad02864b9f66a43e224ba6f2169ea81f41a8a2 | RADIC: A POWERFUL
FAULT-TOLERANT
ARCHITECTURE
Thesis submitted by Angelo Amancio Duarte in fulfillment of the requirements for the degree of Doctor per the Universitat Autònoma de Barcelona.
Bellaterra, May 2007
RADIC: A POWERFUL FAULT-TOLERANT ARCHITECTURE
Thesis submitted by Angelo Amancio Duarte in fulfillment of... |
7f8e71531c2b11199ed549f1b8756bcf7a6a6e28 | MySQL Connector/ODBC Release Notes
Abstract
This document contains release notes for the changes in each release of MySQL Connector/ODBC.
For additional Connector/ODBC documentation, see MySQL Connector/ODBC Developer Guide.
Updates to these notes occur as new product features are added, so that everybody can follo... |
f049c36329d83b2b188c0a07695a9cc834939cf0 | ### Revision History
<table>
<thead>
<tr>
<th>Date</th>
<th>Status</th>
<th>Notes</th>
</tr>
</thead>
<tbody>
<tr>
<td>September 2005</td>
<td>First printing</td>
<td>New for Version 3.0.2 (Release 14SP3)</td>
</tr>
<tr>
<td>March 2006</td>
<td>Online only</td>
<td>Revised for Version 3.1 (Release 2006a)</td>
</tr>
<t... |
443d983401b7d2dcb30928bcd491881e6b00672d | Leveraging software product lines engineering in the construction of domain specific languages
David Fernando Méndez Acuña
To cite this version:
HAL Id: tel-01427187
https://tel.archives-ouvertes.fr/tel-01427187v2
Submitted on 23 Aug 2017
HAL is a multi-disciplinary open access archive for the deposit and dissemin... |
557e42af36b9ff10e767a7ac5aba1be4d6d7531f | Definitional Functoriality for Dependent (Sub)Types
Théo Laurent, Meven Lennon-Bertrand, Kenji Maillard
To cite this version:
Théo Laurent, Meven Lennon-Bertrand, Kenji Maillard. Definitional Functoriality for Dependent (Sub)Types. 2023. hal-04160858v1
HAL Id: hal-04160858
https://hal.science/hal-04160858v1
Preprint ... |
342e89f464ce5eaf8b7a63945a0cfae19bdfb2e2 | Software Fault Tolerance in Distributed Systems
Using Controlled Re-execution
by
Ashis Tarafdar, B.Tech., M.S.
Dissertation
Presented to the Faculty of the Graduate School of
The University of Texas at Austin
in Partial Fulfillment
of the Requirements
for the Degree of
Doctor of Philosophy
The University of Texas ... |
515a597b4ce9e3c43ecf4fa41400b20f395561ac | UNISTORE: A fault-tolerant marriage of causal and strong consistency
Manuel Bravo Alexey Gotsman Borja de Régil Hengfeng Wei ∗
IMDEA Software Institute Nanjing University
Abstract
Modern online services rely on data stores that replicate their data across geographically distributed data centers. Providing strong cons... |
bfca7d2f138c6246deac19a70e907e215b9e7410 | Copyright Notice
Copyright © 2020 Imperas Software Limited. All rights reserved. This software and
documentation contain information that is the property of Imperas Software Limited. The
software and documentation are furnished under a license agreement and may be used or
copied only in accordance with the terms of the... |
312ee83764227adf59d7cef7bfc6b2d40a123da7 | MySQL and Windows
Abstract
This is the MySQL extract for Microsoft Windows from the MySQL 8.0 Reference Manual.
For legal information, see the Legal Notices.
For help with using MySQL, please visit the MySQL Forums, where you can discuss your issues with other MySQL users.
Document generated on: 2022-06-26 (revisio... |
aee77ba5ae4443abbfe3e5223e77a245dabc796c | Armin Kösegi, Rainer Nerding
SAP® Change and Transport Management
- 3rd edition, completely revised and expanded with information on all releases from SAP R/3 4.6 to SAP EIM 6.0 SAP NetWeaver 7.0
- Provides detailed information on Transport Organizer, Transport Management System, SAP Solution Manager, and NWDI
- New ... |
a74e2941cdd6f2a837522442bbed75449b30c427 | TESTING AND MOBILITY ISSUES IN DISTRIBUTED SYSTEMS
APPROVED BY SUPERVISORY COMMITTEE:
Supervisor: ________________________________
TESTING AND MOBILITY ISSUES IN DISTRIBUTED SYSTEMS
by
Sridhar Alagar, B.Sc., B.E., M.S.
DISSERTATION
Presented to the Faculty of the Graduate School of
The University of Texas at Dalla... |
8d70444db35c37c988d0cfc5f1f78e1746b49cc4 | A Categorical Approach to Networks of Aligned Ontologies
Mihai Codescu1 · Till Mossakowski2 · Oliver Kutz1
Received: 8 June 2016 / Revised: 15 March 2017 / Accepted: 5 September 2017
© Springer-Verlag GmbH Germany 2017
Abstract Ontology matching and alignment are key mechanisms for linking the diverse datasets and o... |
a776b47736cb42919a0658d0fa2650dedc70777a | Custom Shape Tutorial
How to Create Your Own Custom Shapes
by Regina Henschel
Preface
Copyright
This document is Copyright © 2022 by Regina Henschel. This document maybe distributed and/or modified under the terms of either the GNU General Public License (https://www.gnu.org/licenses/gpl.html), version 3 or later, or... |
9db939507b5add1c3efb79a74cc9a4889236d1c9 | 7-2016
On Abstract Modular Inference Systems and Solvers
Yuliya Lierler
*University of Nebraska at Omaha, ylierler@unomaha.edu*
Miroslaw Truszczynski
*University of Kentucky*
Follow this and additional works at: https://digitalcommons.unomaha.edu/compscifacpub
Recommended Citation
Lierler, Yuliya and Truszczy... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.